1 #ifndef _TCURASTERIZATIONVERIFIER_HPP 2 #define _TCURASTERIZATIONVERIFIER_HPP 3 /*------------------------------------------------------------------------- 4 * drawElements Quality Program Tester Core 5 * ---------------------------------------- 6 * 7 * Copyright 2014 The Android Open Source Project 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief Rasterization verifier utils. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "tcuDefs.hpp" 27 #include "tcuTestLog.hpp" 28 #include "tcuSurface.hpp" 29 #include "deMath.h" 30 31 #include <vector> 32 33 namespace tcu 34 { 35 36 enum CoverageType 37 { 38 COVERAGE_FULL = 0, // !< primitive fully covers the queried area 39 COVERAGE_PARTIAL, // !< primitive coverage is either partial, or could be full, partial or none depending on rounding and/or fill rules 40 COVERAGE_NONE, // !< primitive does not cover area at all 41 42 COVERAGE_LAST 43 }; 44 45 enum VerificationMode 46 { 47 VERIFICATIONMODE_STRICT = 0, // !< do not allow even a single bad pixel 48 VERIFICATIONMODE_WEAK, // !< allow some bad pixels 49 VERIFICATIONMODE_WEAKER, // !< allow more bad pixels 50 VERIFICATIONMODE_SMOOTH, // !< allow no missing pixels 51 52 VERIFICATIONMODE_LAST 53 }; 54 55 enum LineInterpolationMethod 56 { 57 LINEINTERPOLATION_STRICTLY_CORRECT = 0, // !< line interpolation matches the specification 58 LINEINTERPOLATION_PROJECTED, // !< line interpolation weights are otherwise correct, but they are projected onto major axis 59 LINEINTERPOLATION_INCORRECT // !< line interpolation is incorrect 60 }; 61 62 struct TriangleSceneSpec 63 { 64 struct SceneTriangle 65 { 66 tcu::Vec4 positions[3]; 67 tcu::Vec4 colors[3]; 68 bool sharedEdge[3]; // !< is the edge i -> i+1 shared with another scene triangle SceneTriangletcu::TriangleSceneSpec::SceneTriangle69 SceneTriangle() 70 { 71 // Other members are initialized in Vector constructor 72 for (int i = 0; i < 3; i++) 73 sharedEdge[i] = false; 74 } 75 }; 76 77 std::vector<SceneTriangle> triangles; 78 }; 79 80 struct LineSceneSpec 81 { LineSceneSpectcu::LineSceneSpec82 LineSceneSpec() 83 : isStrip(false) 84 , isSmooth(false) 85 , isRectangular(false) 86 , stippleEnable(false) 87 , verificationMode(VERIFICATIONMODE_STRICT) 88 {} 89 90 struct SceneLine 91 { 92 tcu::Vec4 positions[2]; 93 tcu::Vec4 colors[2]; 94 }; 95 96 std::vector<SceneLine> lines; 97 float lineWidth; 98 bool isStrip; 99 bool isSmooth; 100 bool isRectangular; 101 bool allowNonProjectedInterpolation; 102 bool stippleEnable; 103 deUint32 stippleFactor; 104 deUint16 stipplePattern; 105 VerificationMode verificationMode; 106 }; 107 108 struct PointSceneSpec 109 { 110 struct ScenePoint 111 { 112 tcu::Vec4 position; 113 tcu::Vec4 color; 114 float pointSize; 115 }; 116 117 std::vector<ScenePoint> points; 118 }; 119 120 struct RasterizationArguments 121 { 122 int numSamples; 123 int subpixelBits; 124 int redBits; 125 int greenBits; 126 int blueBits; 127 }; 128 129 struct VerifyTriangleGroupRasterizationLogStash 130 { 131 std::vector<std::string> messages; 132 int missingPixels; 133 int unexpectedPixels; 134 tcu::Surface errorMask; 135 bool result; 136 }; 137 138 struct VerifyTriangleGroupInterpolationLogStash 139 { 140 std::vector<std::string> messages; 141 int invalidPixels; 142 tcu::Surface errorMask; 143 bool success; 144 }; 145 146 /*--------------------------------------------------------------------*//*! 147 * \brief Calculates triangle coverage at given pixel 148 * Calculates the coverage of a triangle given by three vertices. The 149 * triangle should not be z-clipped. If multisample is false, the pixel 150 * center is compared against the triangle. If multisample is true, the 151 * whole pixel area is compared. 152 *//*--------------------------------------------------------------------*/ 153 CoverageType calculateTriangleCoverage (const tcu::Vec4& p0, const tcu::Vec4& p1, const tcu::Vec4& p2, const tcu::IVec2& pixel, const tcu::IVec2& viewportSize, int subpixelBits, bool multisample); 154 155 /*--------------------------------------------------------------------*//*! 156 * \brief Calculates line coverage at given pixel 157 * Calculates the coverage of a reactangle given by line coordinates and width. 158 *//*--------------------------------------------------------------------*/ 159 CoverageType calculateUnderestimateLineCoverage (const tcu::Vec4& p0, const tcu::Vec4& p1, const float lineWidth, const tcu::IVec2& pixel, const tcu::IVec2& viewportSize); 160 161 /*--------------------------------------------------------------------*//*! 162 * \brief Calculates triangle coverage at given pixel 163 * Calculates the coverage of a triangle given by by three vertices. 164 *//*--------------------------------------------------------------------*/ 165 CoverageType calculateUnderestimateTriangleCoverage (const tcu::Vec4& p0, const tcu::Vec4& p1, const tcu::Vec4& p2, const tcu::IVec2& pixel, int subpixelBits, const tcu::IVec2& viewportSize); 166 167 /*--------------------------------------------------------------------*//*! 168 * \brief Verify triangle rasterization result 169 * Verifies pixels in the surface are rasterized within the bounds given 170 * by RasterizationArguments. Triangles should not be z-clipped. 171 * 172 * Triangle colors are not used. The triangle is expected to be white. 173 * If logStash is not NULL the results are not logged, but copied to stash. 174 * 175 * Returns false if invalid rasterization is found. 176 *//*--------------------------------------------------------------------*/ 177 bool verifyTriangleGroupRasterization (const tcu::Surface& surface, const TriangleSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, VerificationMode mode = VERIFICATIONMODE_STRICT, VerifyTriangleGroupRasterizationLogStash* logStash = DE_NULL, const bool vulkanLinesTest = false); 178 179 /*--------------------------------------------------------------------*//*! 180 * \brief Verify line rasterization result 181 * Verifies pixels in the surface are rasterized within the bounds given 182 * by RasterizationArguments. Lines should not be z-clipped. 183 * 184 * Line colors are not used. The line is expected to be white. 185 * 186 * Returns false if invalid rasterization is found. 187 *//*--------------------------------------------------------------------*/ 188 bool verifyLineGroupRasterization (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log); 189 190 /*--------------------------------------------------------------------*//*! 191 * \brief Verify clipped line rasterization result 192 * Verifies pixels in the surface are rasterized within the bounds given 193 * by RasterizationArguments and by clipping the lines with a (-1, -1), (1, 1) 194 * square. Lines should not be z-clipped. 195 * 196 * Line colors are not used. The line is expected to be white. Lines are 197 * rasterized as two triangles. 198 * 199 * Returns false if invalid rasterization is found. 200 *//*--------------------------------------------------------------------*/ 201 bool verifyClippedTriangulatedLineGroupRasterization (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log); 202 203 /*--------------------------------------------------------------------*//*! 204 * \brief Verify line rasterization result both clipped and non-clipped 205 * 206 * For details please see verifyLineGroupRasterization and 207 * verifyClippedTriangulatedLineGroupRasterization 208 * 209 * Returns false if both rasterizations are invalid. 210 *//*--------------------------------------------------------------------*/ 211 bool verifyRelaxedLineGroupRasterization (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, const bool vulkanLinesTest = false, const bool strict = true); 212 213 /*--------------------------------------------------------------------*//*! 214 * \brief Verify point rasterization result 215 * Verifies points in the surface are rasterized within the bounds given 216 * by RasterizationArguments. Points should not be z-clipped. 217 * 218 * Point colors are not used. The point is expected to be white. 219 * 220 * Returns false if invalid rasterization is found. 221 *//*--------------------------------------------------------------------*/ 222 bool verifyPointGroupRasterization (const tcu::Surface& surface, const PointSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log); 223 224 /*--------------------------------------------------------------------*//*! 225 * \brief Verify triangle color interpolation is valid 226 * Verifies the color of a fragments of a colored triangle is in the 227 * valid range. Triangles should not be z-clipped. 228 * 229 * The background is expected to be black. 230 * 231 * Returns false if invalid rasterization interpolation is found. 232 *//*--------------------------------------------------------------------*/ 233 bool verifyTriangleGroupInterpolation (const tcu::Surface& surface, const TriangleSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log); 234 235 /*--------------------------------------------------------------------*//*! 236 * \brief Verify line color interpolation is valid 237 * Verifies the color of a fragments of a colored line is in the 238 * valid range. Lines should not be z-clipped. 239 * 240 * The background is expected to be black. 241 * 242 * Returns the detected interpolation method of the input image. 243 *//*--------------------------------------------------------------------*/ 244 LineInterpolationMethod verifyLineGroupInterpolation (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log); 245 246 /*--------------------------------------------------------------------*//*! 247 * \brief Verify line color interpolation is valid 248 * Verifies the color of a fragments of a colored line is in the 249 * valid range. Lines should not be z-clipped. 250 * 251 * The background is expected to be black. The lines are rasterized 252 * as two triangles. 253 * 254 * Returns false if invalid rasterization interpolation is found. 255 *//*--------------------------------------------------------------------*/ 256 bool verifyTriangulatedLineGroupInterpolation (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, const bool strictMode = true, const bool allowBresenhamForNonStrictLines = false); 257 258 } // tcu 259 260 #endif // _TCURASTERIZATIONVERIFIER_HPP 261