1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 2.0 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Varying interpolation accuracy tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es2aVaryingInterpolationTests.hpp" 25 #include "gluPixelTransfer.hpp" 26 #include "gluShaderProgram.hpp" 27 #include "gluShaderUtil.hpp" 28 #include "tcuStringTemplate.hpp" 29 #include "gluContextInfo.hpp" 30 #include "glsTextureTestUtil.hpp" 31 #include "tcuVector.hpp" 32 #include "tcuVectorUtil.hpp" 33 #include "tcuTestLog.hpp" 34 #include "tcuFloat.hpp" 35 #include "tcuImageCompare.hpp" 36 #include "tcuRenderTarget.hpp" 37 #include "tcuSurfaceAccess.hpp" 38 #include "deRandom.hpp" 39 #include "deStringUtil.hpp" 40 #include "deString.h" 41 42 #include "glw.h" 43 44 using tcu::TestLog; 45 using tcu::Vec3; 46 using tcu::Vec4; 47 using std::string; 48 using std::vector; 49 using std::map; 50 using tcu::SurfaceAccess; 51 52 namespace deqp 53 { 54 namespace gles2 55 { 56 namespace Accuracy 57 { 58 59 static inline float projectedTriInterpolate (const tcu::Vec3& s, const tcu::Vec3& w, float nx, float ny) 60 { 61 return (s[0]*(1.0f-nx-ny)/w[0] + s[1]*ny/w[1] + s[2]*nx/w[2]) / ((1.0f-nx-ny)/w[0] + ny/w[1] + nx/w[2]); 62 } 63 64 static void renderReference (const SurfaceAccess& dst, const float coords[4*3], const Vec4& wCoord, const Vec3& scale, const Vec3& bias) 65 { 66 float dstW = (float)dst.getWidth(); 67 float dstH = (float)dst.getHeight(); 68 69 Vec3 triR[2] = { Vec3(coords[0*3+0], coords[1*3+0], coords[2*3+0]), Vec3(coords[3*3+0], coords[2*3+0], coords[1*3+0]) }; 70 Vec3 triG[2] = { Vec3(coords[0*3+1], coords[1*3+1], coords[2*3+1]), Vec3(coords[3*3+1], coords[2*3+1], coords[1*3+1]) }; 71 Vec3 triB[2] = { Vec3(coords[0*3+2], coords[1*3+2], coords[2*3+2]), Vec3(coords[3*3+2], coords[2*3+2], coords[1*3+2]) }; 72 tcu::Vec3 triW[2] = { wCoord.swizzle(0, 1, 2), wCoord.swizzle(3, 2, 1) }; 73 74 for (int py = 0; py < dst.getHeight(); py++) 75 { 76 for (int px = 0; px < dst.getWidth(); px++) 77 { 78 float wx = (float)px + 0.5f; 79 float wy = (float)py + 0.5f; 80 float nx = wx / dstW; 81 float ny = wy / dstH; 82 83 int triNdx = nx + ny >= 1.0f ? 1 : 0; 84 float triNx = triNdx ? 1.0f - nx : nx; 85 float triNy = triNdx ? 1.0f - ny : ny; 86 87 float r = projectedTriInterpolate(triR[triNdx], triW[triNdx], triNx, triNy) * scale[0] + bias[0]; 88 float g = projectedTriInterpolate(triG[triNdx], triW[triNdx], triNx, triNy) * scale[1] + bias[1]; 89 float b = projectedTriInterpolate(triB[triNdx], triW[triNdx], triNx, triNy) * scale[2] + bias[2]; 90 91 Vec4 color = Vec4(r, g, b, 1.0f); 92 93 dst.setPixel(color, px, py); 94 } 95 } 96 } 97 98 class InterpolationCase : public TestCase 99 { 100 public: 101 InterpolationCase (Context& context, const char* name, const char* desc, glu::Precision precision, const tcu::Vec3& minVal, const tcu::Vec3& maxVal, bool projective); 102 ~InterpolationCase (void); 103 104 IterateResult iterate (void); 105 106 private: 107 glu::Precision m_precision; 108 tcu::Vec3 m_min; 109 tcu::Vec3 m_max; 110 bool m_projective; 111 }; 112 113 InterpolationCase::InterpolationCase (Context& context, const char* name, const char* desc, glu::Precision precision, const tcu::Vec3& minVal, const tcu::Vec3& maxVal, bool projective) 114 : TestCase (context, tcu::NODETYPE_ACCURACY, name, desc) 115 , m_precision (precision) 116 , m_min (minVal) 117 , m_max (maxVal) 118 , m_projective (projective) 119 { 120 } 121 122 InterpolationCase::~InterpolationCase (void) 123 { 124 } 125 126 static bool isValidFloat (glu::Precision precision, float val) 127 { 128 if (precision == glu::PRECISION_MEDIUMP) 129 { 130 tcu::Float16 fp16(val); 131 return !fp16.isDenorm() && !fp16.isInf() && !fp16.isNaN(); 132 } 133 else 134 { 135 tcu::Float32 fp32(val); 136 return !fp32.isDenorm() && !fp32.isInf() && !fp32.isNaN(); 137 } 138 } 139 140 template <int Size> 141 static bool isValidFloatVec (glu::Precision precision, const tcu::Vector<float, Size>& vec) 142 { 143 for (int ndx = 0; ndx < Size; ndx++) 144 { 145 if (!isValidFloat(precision, vec[ndx])) 146 return false; 147 } 148 return true; 149 } 150 151 InterpolationCase::IterateResult InterpolationCase::iterate (void) 152 { 153 TestLog& log = m_testCtx.getLog(); 154 de::Random rnd (deStringHash(getName())); 155 int viewportWidth = 128; 156 int viewportHeight = 128; 157 158 if (m_context.getRenderTarget().getWidth() < viewportWidth || 159 m_context.getRenderTarget().getHeight() < viewportHeight) 160 throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__); 161 162 int viewportX = rnd.getInt(0, m_context.getRenderTarget().getWidth() - viewportWidth); 163 int viewportY = rnd.getInt(0, m_context.getRenderTarget().getHeight() - viewportHeight); 164 165 static const char* s_vertShaderTemplate = 166 "attribute highp vec4 a_position;\n" 167 "attribute ${PRECISION} vec3 a_coords;\n" 168 "varying ${PRECISION} vec3 v_coords;\n" 169 "\n" 170 "void main (void)\n" 171 "{\n" 172 " gl_Position = a_position;\n" 173 " v_coords = a_coords;\n" 174 "}\n"; 175 static const char* s_fragShaderTemplate = 176 "varying ${PRECISION} vec3 v_coords;\n" 177 "uniform ${PRECISION} vec3 u_scale;\n" 178 "uniform ${PRECISION} vec3 u_bias;\n" 179 "\n" 180 "void main (void)\n" 181 "{\n" 182 " gl_FragColor = vec4(v_coords * u_scale + u_bias, 1.0);\n" 183 "}\n"; 184 185 map<string, string> templateParams; 186 templateParams["PRECISION"] = glu::getPrecisionName(m_precision); 187 188 glu::ShaderProgram program(m_context.getRenderContext(), 189 glu::makeVtxFragSources(tcu::StringTemplate(s_vertShaderTemplate).specialize(templateParams), 190 tcu::StringTemplate(s_fragShaderTemplate).specialize(templateParams))); 191 log << program; 192 if (!program.isOk()) 193 { 194 if (m_precision == glu::PRECISION_HIGHP && !m_context.getContextInfo().isFragmentHighPrecisionSupported()) 195 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Fragment highp not supported"); 196 else 197 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compile failed"); 198 return STOP; 199 } 200 201 // Position coordinates. 202 Vec4 wCoord = m_projective ? Vec4(1.3f, 0.8f, 0.6f, 2.0f) : Vec4(1.0f, 1.0f, 1.0f, 1.0f); 203 float positions[] = 204 { 205 -1.0f*wCoord.x(), -1.0f*wCoord.x(), 0.0f, wCoord.x(), 206 -1.0f*wCoord.y(), +1.0f*wCoord.y(), 0.0f, wCoord.y(), 207 +1.0f*wCoord.z(), -1.0f*wCoord.z(), 0.0f, wCoord.z(), 208 +1.0f*wCoord.w(), +1.0f*wCoord.w(), 0.0f, wCoord.w() 209 }; 210 211 // Coordinates for interpolation. 212 tcu::Vec3 scale = 1.0f / (m_max - m_min); 213 tcu::Vec3 bias = -1.0f*m_min*scale; 214 float coords[] = 215 { 216 (0.0f - bias[0])/scale[0], (0.5f - bias[1])/scale[1], (1.0f - bias[2])/scale[2], 217 (0.5f - bias[0])/scale[0], (1.0f - bias[1])/scale[1], (0.5f - bias[2])/scale[2], 218 (0.5f - bias[0])/scale[0], (0.0f - bias[1])/scale[1], (0.5f - bias[2])/scale[2], 219 (1.0f - bias[0])/scale[0], (0.5f - bias[1])/scale[1], (0.0f - bias[2])/scale[2] 220 }; 221 222 log << TestLog::Message << "a_coords = " << ((tcu::Vec3(0.0f) - bias)/scale) << " -> " << ((tcu::Vec3(1.0f) - bias)/scale) << TestLog::EndMessage; 223 log << TestLog::Message << "u_scale = " << scale << TestLog::EndMessage; 224 log << TestLog::Message << "u_bias = " << bias << TestLog::EndMessage; 225 226 // Verify that none of the inputs are denormalized / inf / nan. 227 TCU_CHECK(isValidFloatVec(m_precision, scale)); 228 TCU_CHECK(isValidFloatVec(m_precision, bias)); 229 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(coords); ndx++) 230 { 231 TCU_CHECK(isValidFloat(m_precision, coords[ndx])); 232 TCU_CHECK(isValidFloat(m_precision, coords[ndx] * scale[ndx % 3] + bias[ndx % 3])); 233 } 234 235 // Indices. 236 static const deUint16 indices[] = { 0, 1, 2, 2, 1, 3 }; 237 238 { 239 const int posLoc = glGetAttribLocation(program.getProgram(), "a_position"); 240 const int coordLoc = glGetAttribLocation(program.getProgram(), "a_coords"); 241 242 glEnableVertexAttribArray(posLoc); 243 glVertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, &positions[0]); 244 245 glEnableVertexAttribArray(coordLoc); 246 glVertexAttribPointer(coordLoc, 3, GL_FLOAT, GL_FALSE, 0, &coords[0]); 247 } 248 249 glUseProgram(program.getProgram()); 250 glUniform3f(glGetUniformLocation(program.getProgram(), "u_scale"), scale.x(), scale.y(), scale.z()); 251 glUniform3f(glGetUniformLocation(program.getProgram(), "u_bias"), bias.x(), bias.y(), bias.z()); 252 253 GLU_CHECK_MSG("After program setup"); 254 255 // Frames. 256 tcu::Surface rendered (viewportWidth, viewportHeight); 257 tcu::Surface reference (viewportWidth, viewportHeight); 258 259 // Render with GL. 260 glViewport(viewportX, viewportY, viewportWidth, viewportHeight); 261 glDrawElements(GL_TRIANGLES, DE_LENGTH_OF_ARRAY(indices), GL_UNSIGNED_SHORT, &indices[0]); 262 263 // Render reference \note While GPU is hopefully doing our draw call. 264 renderReference(SurfaceAccess(reference, m_context.getRenderTarget().getPixelFormat()), coords, wCoord, scale, bias); 265 266 glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, rendered.getAccess()); 267 268 // Compute difference. 269 const int bestScoreDiff = 16; 270 const int worstScoreDiff = 300; 271 int score = tcu::measurePixelDiffAccuracy(log, "Result", "Image comparison result", reference, rendered, bestScoreDiff, worstScoreDiff, tcu::COMPARE_LOG_EVERYTHING); 272 273 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::toString(score).c_str()); 274 return STOP; 275 } 276 277 VaryingInterpolationTests::VaryingInterpolationTests (Context& context) 278 : TestCaseGroup(context, "interpolation", "Varying Interpolation Accuracy Tests") 279 { 280 } 281 282 VaryingInterpolationTests::~VaryingInterpolationTests (void) 283 { 284 } 285 286 void VaryingInterpolationTests::init (void) 287 { 288 DE_STATIC_ASSERT(glu::PRECISION_LOWP+1 == glu::PRECISION_MEDIUMP); 289 DE_STATIC_ASSERT(glu::PRECISION_MEDIUMP+1 == glu::PRECISION_HIGHP); 290 291 // Exp = Emax-3, Mantissa = 0 292 float minF32 = tcu::Float32((0u<<31) | (0xfcu<<23) | 0x0u).asFloat(); 293 float maxF32 = tcu::Float32((1u<<31) | (0xfcu<<23) | 0x0u).asFloat(); 294 float minF16 = tcu::Float16((deUint16)((0u<<15) | (0x1cu<<10) | 0x0u)).asFloat(); 295 float maxF16 = tcu::Float16((deUint16)((1u<<15) | (0x1cu<<10) | 0x0u)).asFloat(); 296 297 static const struct 298 { 299 const char* name; 300 Vec3 minVal; 301 Vec3 maxVal; 302 glu::Precision minPrecision; 303 } coordRanges[] = 304 { 305 { "zero_to_one", Vec3( 0.0f, 0.0f, 0.0f), Vec3( 1.0f, 1.0f, 1.0f), glu::PRECISION_LOWP }, 306 { "zero_to_minus_one", Vec3( 0.0f, 0.0f, 0.0f), Vec3( -1.0f, -1.0f, -1.0f), glu::PRECISION_LOWP }, 307 { "minus_one_to_one", Vec3( -1.0f, -1.0f, -1.0f), Vec3( 1.0f, 1.0f, 1.0f), glu::PRECISION_LOWP }, 308 { "minus_ten_to_ten", Vec3(-10.0f, -10.0f, -10.0f), Vec3( 10.0f, 10.0f, 10.0f), glu::PRECISION_MEDIUMP }, 309 { "thousands", Vec3( -5e3f, 1e3f, 1e3f), Vec3( 3e3f, -1e3f, 7e3f), glu::PRECISION_MEDIUMP }, 310 { "full_mediump", Vec3(minF16, minF16, minF16), Vec3(maxF16, maxF16, maxF16), glu::PRECISION_MEDIUMP }, 311 { "full_highp", Vec3(minF32, minF32, minF32), Vec3(maxF32, maxF32, maxF32), glu::PRECISION_HIGHP }, 312 }; 313 314 for (int precision = glu::PRECISION_LOWP; precision <= glu::PRECISION_HIGHP; precision++) 315 { 316 for (int coordNdx = 0; coordNdx < DE_LENGTH_OF_ARRAY(coordRanges); coordNdx++) 317 { 318 if (precision < (int)coordRanges[coordNdx].minPrecision) 319 continue; 320 321 string baseName = string(glu::getPrecisionName((glu::Precision)precision)) + "_" + coordRanges[coordNdx].name; 322 323 addChild(new InterpolationCase(m_context, baseName.c_str(), "", (glu::Precision)precision, coordRanges[coordNdx].minVal, coordRanges[coordNdx].maxVal, false)); 324 addChild(new InterpolationCase(m_context, (baseName + "_proj").c_str(), "", (glu::Precision)precision, coordRanges[coordNdx].minVal, coordRanges[coordNdx].maxVal, true)); 325 } 326 } 327 } 328 329 } // Accuracy 330 } // gles2 331 } // deqp 332
