modules/glshared/glsShaderConstExprTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL Shared 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 Shared shader constant expression test components
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "glsShaderConstExprTests.hpp"
  25 #include "glsShaderLibrary.hpp"
  26 #include "glsShaderLibraryCase.hpp"
  27
  28 #include "tcuStringTemplate.hpp"
  29
  30 #include "deStringUtil.hpp"
  31 #include "deMath.h"
  32
  33 namespace deqp
  34 {
  35 namespace gls
  36 {
  37 namespace ShaderConstExpr
  38 {
  39
  40 static void addOutputVar (glu::sl::ValueBlock* dst, glu::DataType type, float output)
  41 {
  42         dst->outputs.push_back(glu::sl::Value());
  43
  44         {
  45                 glu::sl::Value& value   = dst->outputs.back();
  46
  47                 value.name      = "out0";
  48                 value.type      = glu::VarType(type, glu::PRECISION_LAST);
  49                 value.elements.resize(1);
  50
  51                 switch (type)
  52                 {
  53                         case glu::TYPE_INT:
  54                                 value.elements[0].int32 = (int)output;
  55                                 break;
  56
  57                         case glu::TYPE_UINT:
  58                                 value.elements[0].int32 = (unsigned int)output;
  59                                 break;
  60
  61                         case glu::TYPE_BOOL:
  62                                 value.elements[0].bool32 = output!=0.0f;
  63                                 break;
  64
  65                         case glu::TYPE_FLOAT:
  66                                 value.elements[0].float32 = output;
  67                                 break;
  68
  69                         default:
  70                                 DE_ASSERT(false);
  71                 }
  72         }
  73 }
  74
  75 std::vector<tcu::TestNode*> createTests (tcu::TestContext&                      testContext,
  76                                                                                  glu::RenderContext&            renderContext,
  77                                                                                  const glu::ContextInfo&        contextInfo,
  78                                                                                  const TestParams*                      cases,
  79                                                                                  int                                            numCases,
  80                                                                                  glu::GLSLVersion                       version,
  81                                                                                  TestShaderStage                        testStage)
  82 {
  83         using std::string;
  84         using std::vector;
  85         using gls::ShaderLibraryCase;
  86
  87         // Needed for autogenerating shader code for increased component counts
  88         DE_STATIC_ASSERT(glu::TYPE_FLOAT+1 == glu::TYPE_FLOAT_VEC2);
  89         DE_STATIC_ASSERT(glu::TYPE_FLOAT+2 == glu::TYPE_FLOAT_VEC3);
  90         DE_STATIC_ASSERT(glu::TYPE_FLOAT+3 == glu::TYPE_FLOAT_VEC4);
  91
  92         DE_STATIC_ASSERT(glu::TYPE_INT+1 == glu::TYPE_INT_VEC2);
  93         DE_STATIC_ASSERT(glu::TYPE_INT+2 == glu::TYPE_INT_VEC3);
  94         DE_STATIC_ASSERT(glu::TYPE_INT+3 == glu::TYPE_INT_VEC4);
  95
  96         DE_STATIC_ASSERT(glu::TYPE_UINT+1 == glu::TYPE_UINT_VEC2);
  97         DE_STATIC_ASSERT(glu::TYPE_UINT+2 == glu::TYPE_UINT_VEC3);
  98         DE_STATIC_ASSERT(glu::TYPE_UINT+3 == glu::TYPE_UINT_VEC4);
  99
 100         DE_STATIC_ASSERT(glu::TYPE_BOOL+1 == glu::TYPE_BOOL_VEC2);
 101         DE_STATIC_ASSERT(glu::TYPE_BOOL+2 == glu::TYPE_BOOL_VEC3);
 102         DE_STATIC_ASSERT(glu::TYPE_BOOL+3 == glu::TYPE_BOOL_VEC4);
 103
 104         DE_ASSERT(testStage);
 105
 106         const char* shaderTemplateSrc =
 107                 "#version ${GLES_VERSION}\n"
 108                 "precision highp float;\n"
 109                 "precision highp int;\n"
 110                 "${DECLARATIONS}\n"
 111                 "void main()\n"
 112                 "{\n"
 113                 "       const ${CASE_BASE_TYPE} cval = ${CASE_EXPRESSION};\n"
 114                 "       out0 = cval;\n"
 115                 "       ${OUTPUT}\n"
 116                 "}\n";
 117
 118         const tcu::StringTemplate       shaderTemplate  (shaderTemplateSrc);
 119         vector<tcu::TestNode*>          ret;
 120
 121         for (int caseNdx = 0; caseNdx < numCases; caseNdx++)
 122         {
 123                 std::map<string, string>        shaderTemplateParams;
 124                 const int                                       minComponents   = cases[caseNdx].minComponents;
 125                 const int                                       maxComponents   = cases[caseNdx].maxComponents;
 126                 const DataType                          inType                  = cases[caseNdx].inType;
 127                 const DataType                          outType                 = cases[caseNdx].outType;
 128                 const string                            expression              = cases[caseNdx].expression;
 129                 // Check for presence of func(vec, scalar) style specialization, use as gatekeeper for applying said specialization
 130                 const bool                                      alwaysScalar    = expression.find("${MT}")!=string::npos;
 131
 132                 shaderTemplateParams["GLES_VERSION"]    = version == glu::GLSL_VERSION_300_ES ? "300 es" : "100";
 133                 shaderTemplateParams["CASE_BASE_TYPE"]  = glu::getDataTypeName(outType);
 134                 shaderTemplateParams["DECLARATIONS"]    = "${DECLARATIONS}";
 135                 shaderTemplateParams["OUTPUT"]                  = "${OUTPUT}";
 136
 137                 for (int compCount = minComponents-1; compCount < maxComponents; compCount++)
 138                 {
 139                         vector<tcu::TestNode*>          children;
 140                         std::map<string, string>        expressionTemplateParams;
 141                         string                                          typeName                        = glu::getDataTypeName((glu::DataType)(inType + compCount)); // results in float, vec2, vec3, vec4 progression (same for other primitive types)
 142                         const char*                                     componentAccess[]       = {"", ".y", ".z", ".w"};
 143                         const tcu::StringTemplate       expressionTemplate      (expression);
 144                         // Add type to case name if we are generating multiple versions
 145                         const string                            caseName                        = string(cases[caseNdx].name) + (minComponents==maxComponents ? "" : ("_" + typeName));
 146
 147                         // ${T} => final type, ${MT} => final type but with scalar version usable even when T is a vector
 148                         expressionTemplateParams["T"]                   = typeName;
 149                         expressionTemplateParams["MT"]                  = typeName;
 150
 151                         shaderTemplateParams["CASE_EXPRESSION"] = expressionTemplate.specialize(expressionTemplateParams) + componentAccess[compCount]; // Add vector access to expression as needed
 152
 153                         {
 154                                 const string mapped = shaderTemplate.specialize(shaderTemplateParams);
 155
 156                                 if (testStage & SHADER_VERTEX)
 157                                 {
 158                                         glu::sl::ShaderCaseSpecification        spec;
 159
 160                                         spec.targetVersion      = version;
 161                                         spec.expectResult       = glu::sl::EXPECT_PASS;
 162                                         spec.caseType           = glu::sl::CASETYPE_VERTEX_ONLY;
 163                                         spec.programs.resize(1);
 164
 165                                         spec.programs[0].sources << glu::VertexSource(mapped);
 166
 167                                         addOutputVar(&spec.values, outType, cases[caseNdx].output);
 168
 169                                         ret.push_back(new ShaderLibraryCase(testContext,
 170                                                                                                                 renderContext,
 171                                                                                                                 contextInfo,
 172                                                                                                                 (caseName + "_vertex").c_str(),
 173                                                                                                                 "",
 174                                                                                                                 spec));
 175                                 }
 176
 177                                 if (testStage & SHADER_FRAGMENT)
 178                                 {
 179                                         glu::sl::ShaderCaseSpecification        spec;
 180
 181                                         spec.targetVersion      = version;
 182                                         spec.expectResult       = glu::sl::EXPECT_PASS;
 183                                         spec.caseType           = glu::sl::CASETYPE_FRAGMENT_ONLY;
 184                                         spec.programs.resize(1);
 185
 186                                         spec.programs[0].sources << glu::FragmentSource(mapped);
 187
 188                                         addOutputVar(&spec.values, outType, cases[caseNdx].output);
 189
 190                                         ret.push_back(new ShaderLibraryCase(testContext,
 191                                                                                                                 renderContext,
 192                                                                                                                 contextInfo,
 193                                                                                                                 (caseName + "_fragment").c_str(),
 194                                                                                                                 "",
 195                                                                                                                 spec));
 196                                 }
 197                         }
 198
 199                         // Deal with functions that allways accept one ore more scalar parameters even when others are vectors
 200                         if (alwaysScalar && compCount > 0)
 201                         {
 202                                 const string    scalarCaseName  = string(cases[caseNdx].name) + "_" + typeName + "_" + glu::getDataTypeName(inType);
 203
 204                                 expressionTemplateParams["MT"] = glu::getDataTypeName(inType);
 205                                 shaderTemplateParams["CASE_EXPRESSION"] = expressionTemplate.specialize(expressionTemplateParams) + componentAccess[compCount];
 206
 207                                 {
 208                                         const string mapped = shaderTemplate.specialize(shaderTemplateParams);
 209
 210                                         if (testStage & SHADER_VERTEX)
 211                                         {
 212                                                 glu::sl::ShaderCaseSpecification        spec;
 213
 214                                                 spec.targetVersion      = version;
 215                                                 spec.expectResult       = glu::sl::EXPECT_PASS;
 216                                                 spec.caseType           = glu::sl::CASETYPE_VERTEX_ONLY;
 217                                                 spec.programs.resize(1);
 218
 219                                                 spec.programs[0].sources << glu::VertexSource(mapped);
 220
 221                                                 addOutputVar(&spec.values, outType, cases[caseNdx].output);
 222
 223                                                 ret.push_back(new ShaderLibraryCase(testContext,
 224                                                                                                                         renderContext,
 225                                                                                                                         contextInfo,
 226                                                                                                                         (scalarCaseName + "_vertex").c_str(),
 227                                                                                                                         "",
 228                                                                                                                         spec));
 229                                         }
 230
 231                                         if (testStage & SHADER_FRAGMENT)
 232                                         {
 233                                                 glu::sl::ShaderCaseSpecification        spec;
 234
 235                                                 spec.targetVersion      = version;
 236                                                 spec.expectResult       = glu::sl::EXPECT_PASS;
 237                                                 spec.caseType           = glu::sl::CASETYPE_FRAGMENT_ONLY;
 238                                                 spec.programs.resize(1);
 239
 240                                                 spec.programs[0].sources << glu::FragmentSource(mapped);
 241
 242                                                 addOutputVar(&spec.values, outType, cases[caseNdx].output);
 243
 244                                                 ret.push_back(new ShaderLibraryCase(testContext,
 245                                                                                                                         renderContext,
 246                                                                                                                         contextInfo,
 247                                                                                                                         (scalarCaseName + "_fragment").c_str(),
 248                                                                                                                         "",
 249                                                                                                                         spec));
 250                                         }
 251                                 }
 252                         }
 253                 }
 254         }
 255
 256         return ret;
 257 }
 258
 259 } // ShaderConstExpr
 260 } // gls
 261 } // deqp