| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES 3.0 Module |
| * ------------------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Shader indexing (arrays, vector, matrices) tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es3fShaderIndexingTests.hpp" |
| #include "glsShaderLibrary.hpp" |
| #include "glsShaderRenderCase.hpp" |
| #include "gluShaderUtil.hpp" |
| #include "tcuStringTemplate.hpp" |
| |
| #include "deInt32.h" |
| #include "deMemory.h" |
| |
| #include <map> |
| |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| |
| using namespace std; |
| using namespace tcu; |
| using namespace glu; |
| using namespace deqp::gls; |
| |
| namespace deqp |
| { |
| namespace gles3 |
| { |
| namespace Functional |
| { |
| |
| enum IndexAccessType |
| { |
| INDEXACCESS_STATIC = 0, |
| INDEXACCESS_DYNAMIC, |
| INDEXACCESS_STATIC_LOOP, |
| INDEXACCESS_DYNAMIC_LOOP, |
| |
| INDEXACCESS_LAST |
| }; |
| |
| static const char *getIndexAccessTypeName(IndexAccessType accessType) |
| { |
| static const char *s_names[INDEXACCESS_LAST] = {"static", "dynamic", "static_loop", "dynamic_loop"}; |
| |
| DE_ASSERT(deInBounds32((int)accessType, 0, INDEXACCESS_LAST)); |
| return s_names[(int)accessType]; |
| } |
| |
| enum VectorAccessType |
| { |
| DIRECT = 0, |
| COMPONENT, |
| SUBSCRIPT_STATIC, |
| SUBSCRIPT_DYNAMIC, |
| SUBSCRIPT_STATIC_LOOP, |
| SUBSCRIPT_DYNAMIC_LOOP, |
| |
| VECTORACCESS_LAST |
| }; |
| |
| static const char *getVectorAccessTypeName(VectorAccessType accessType) |
| { |
| static const char *s_names[VECTORACCESS_LAST] = {"direct", |
| "component", |
| "static_subscript", |
| "dynamic_subscript", |
| "static_loop_subscript", |
| "dynamic_loop_subscript"}; |
| |
| DE_ASSERT(deInBounds32((int)accessType, 0, VECTORACCESS_LAST)); |
| return s_names[(int)accessType]; |
| } |
| |
| void evalArrayCoordsFloat(ShaderEvalContext &c) |
| { |
| c.color.x() = 1.875f * c.coords.x(); |
| } |
| void evalArrayCoordsVec2(ShaderEvalContext &c) |
| { |
| c.color.xy() = 1.875f * c.coords.swizzle(0, 1); |
| } |
| void evalArrayCoordsVec3(ShaderEvalContext &c) |
| { |
| c.color.xyz() = 1.875f * c.coords.swizzle(0, 1, 2); |
| } |
| void evalArrayCoordsVec4(ShaderEvalContext &c) |
| { |
| c.color = 1.875f * c.coords; |
| } |
| |
| static ShaderEvalFunc getArrayCoordsEvalFunc(DataType dataType) |
| { |
| if (dataType == TYPE_FLOAT) |
| return evalArrayCoordsFloat; |
| else if (dataType == TYPE_FLOAT_VEC2) |
| return evalArrayCoordsVec2; |
| else if (dataType == TYPE_FLOAT_VEC3) |
| return evalArrayCoordsVec3; |
| else if (dataType == TYPE_FLOAT_VEC4) |
| return evalArrayCoordsVec4; |
| |
| DE_FATAL("Invalid data type."); |
| return NULL; |
| } |
| |
| void evalArrayUniformFloat(ShaderEvalContext &c) |
| { |
| c.color.x() = 1.875f * c.constCoords.x(); |
| } |
| void evalArrayUniformVec2(ShaderEvalContext &c) |
| { |
| c.color.xy() = 1.875f * c.constCoords.swizzle(0, 1); |
| } |
| void evalArrayUniformVec3(ShaderEvalContext &c) |
| { |
| c.color.xyz() = 1.875f * c.constCoords.swizzle(0, 1, 2); |
| } |
| void evalArrayUniformVec4(ShaderEvalContext &c) |
| { |
| c.color = 1.875f * c.constCoords; |
| } |
| |
| static ShaderEvalFunc getArrayUniformEvalFunc(DataType dataType) |
| { |
| if (dataType == TYPE_FLOAT) |
| return evalArrayUniformFloat; |
| else if (dataType == TYPE_FLOAT_VEC2) |
| return evalArrayUniformVec2; |
| else if (dataType == TYPE_FLOAT_VEC3) |
| return evalArrayUniformVec3; |
| else if (dataType == TYPE_FLOAT_VEC4) |
| return evalArrayUniformVec4; |
| |
| DE_FATAL("Invalid data type."); |
| return NULL; |
| } |
| |
| // ShaderIndexingCase |
| |
| class ShaderIndexingCase : public ShaderRenderCase |
| { |
| public: |
| ShaderIndexingCase(Context &context, const char *name, const char *description, bool isVertexCase, DataType varType, |
| ShaderEvalFunc evalFunc, const char *vertShaderSource, const char *fragShaderSource); |
| virtual ~ShaderIndexingCase(void); |
| |
| private: |
| ShaderIndexingCase(const ShaderIndexingCase &); // not allowed! |
| ShaderIndexingCase &operator=(const ShaderIndexingCase &); // not allowed! |
| |
| virtual void setup(int programID); |
| virtual void setupUniforms(int programID, const Vec4 &constCoords); |
| |
| DataType m_varType; |
| }; |
| |
| ShaderIndexingCase::ShaderIndexingCase(Context &context, const char *name, const char *description, bool isVertexCase, |
| DataType varType, ShaderEvalFunc evalFunc, const char *vertShaderSource, |
| const char *fragShaderSource) |
| : ShaderRenderCase(context.getTestContext(), context.getRenderContext(), context.getContextInfo(), name, |
| description, isVertexCase, evalFunc) |
| { |
| m_varType = varType; |
| m_vertShaderSource = vertShaderSource; |
| m_fragShaderSource = fragShaderSource; |
| } |
| |
| ShaderIndexingCase::~ShaderIndexingCase(void) |
| { |
| } |
| |
| void ShaderIndexingCase::setup(int programID) |
| { |
| DE_UNREF(programID); |
| } |
| |
| void ShaderIndexingCase::setupUniforms(int programID, const Vec4 &constCoords) |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| |
| DE_UNREF(constCoords); |
| |
| int arrLoc = gl.getUniformLocation(programID, "u_arr"); |
| if (arrLoc != -1) |
| { |
| //int scalarSize = getDataTypeScalarSize(m_varType); |
| if (m_varType == TYPE_FLOAT) |
| { |
| float arr[4]; |
| arr[0] = constCoords.x(); |
| arr[1] = constCoords.x() * 0.5f; |
| arr[2] = constCoords.x() * 0.25f; |
| arr[3] = constCoords.x() * 0.125f; |
| gl.uniform1fv(arrLoc, 4, &arr[0]); |
| } |
| else if (m_varType == TYPE_FLOAT_VEC2) |
| { |
| Vec2 arr[4]; |
| arr[0] = constCoords.swizzle(0, 1); |
| arr[1] = constCoords.swizzle(0, 1) * 0.5f; |
| arr[2] = constCoords.swizzle(0, 1) * 0.25f; |
| arr[3] = constCoords.swizzle(0, 1) * 0.125f; |
| gl.uniform2fv(arrLoc, 4, arr[0].getPtr()); |
| } |
| else if (m_varType == TYPE_FLOAT_VEC3) |
| { |
| Vec3 arr[4]; |
| arr[0] = constCoords.swizzle(0, 1, 2); |
| arr[1] = constCoords.swizzle(0, 1, 2) * 0.5f; |
| arr[2] = constCoords.swizzle(0, 1, 2) * 0.25f; |
| arr[3] = constCoords.swizzle(0, 1, 2) * 0.125f; |
| gl.uniform3fv(arrLoc, 4, arr[0].getPtr()); |
| } |
| else if (m_varType == TYPE_FLOAT_VEC4) |
| { |
| Vec4 arr[4]; |
| arr[0] = constCoords.swizzle(0, 1, 2, 3); |
| arr[1] = constCoords.swizzle(0, 1, 2, 3) * 0.5f; |
| arr[2] = constCoords.swizzle(0, 1, 2, 3) * 0.25f; |
| arr[3] = constCoords.swizzle(0, 1, 2, 3) * 0.125f; |
| gl.uniform4fv(arrLoc, 4, arr[0].getPtr()); |
| } |
| else |
| throw tcu::TestError("u_arr should not have location assigned in this test case"); |
| } |
| } |
| |
| // Helpers. |
| |
| static ShaderIndexingCase *createVaryingArrayCase(Context &context, const char *caseName, const char *description, |
| DataType varType, IndexAccessType vertAccess, |
| IndexAccessType fragAccess) |
| { |
| std::ostringstream vtx; |
| vtx << "#version 300 es\n"; |
| vtx << "in highp vec4 a_position;\n"; |
| vtx << "in highp vec4 a_coords;\n"; |
| if (vertAccess == INDEXACCESS_DYNAMIC) |
| vtx << "uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n"; |
| else if (vertAccess == INDEXACCESS_DYNAMIC_LOOP) |
| vtx << "uniform mediump int ui_four;\n"; |
| vtx << "out ${PRECISION} ${VAR_TYPE} var[${ARRAY_LEN}];\n"; |
| vtx << "\n"; |
| vtx << "void main()\n"; |
| vtx << "{\n"; |
| vtx << " gl_Position = a_position;\n"; |
| if (vertAccess == INDEXACCESS_STATIC) |
| { |
| vtx << " var[0] = ${VAR_TYPE}(a_coords);\n"; |
| vtx << " var[1] = ${VAR_TYPE}(a_coords) * 0.5;\n"; |
| vtx << " var[2] = ${VAR_TYPE}(a_coords) * 0.25;\n"; |
| vtx << " var[3] = ${VAR_TYPE}(a_coords) * 0.125;\n"; |
| } |
| else if (vertAccess == INDEXACCESS_DYNAMIC) |
| { |
| vtx << " var[ui_zero] = ${VAR_TYPE}(a_coords);\n"; |
| vtx << " var[ui_one] = ${VAR_TYPE}(a_coords) * 0.5;\n"; |
| vtx << " var[ui_two] = ${VAR_TYPE}(a_coords) * 0.25;\n"; |
| vtx << " var[ui_three] = ${VAR_TYPE}(a_coords) * 0.125;\n"; |
| } |
| else if (vertAccess == INDEXACCESS_STATIC_LOOP) |
| { |
| vtx << " ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n"; |
| vtx << " for (int i = 0; i < 4; i++)\n"; |
| vtx << " {\n"; |
| vtx << " var[i] = ${VAR_TYPE}(coords);\n"; |
| vtx << " coords = coords * 0.5;\n"; |
| vtx << " }\n"; |
| } |
| else |
| { |
| DE_ASSERT(vertAccess == INDEXACCESS_DYNAMIC_LOOP); |
| vtx << " ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n"; |
| vtx << " for (int i = 0; i < ui_four; i++)\n"; |
| vtx << " {\n"; |
| vtx << " var[i] = ${VAR_TYPE}(coords);\n"; |
| vtx << " coords = coords * 0.5;\n"; |
| vtx << " }\n"; |
| } |
| vtx << "}\n"; |
| |
| std::ostringstream frag; |
| frag << "#version 300 es\n"; |
| frag << "precision mediump int;\n"; |
| frag << "layout(location = 0) out mediump vec4 o_color;\n"; |
| if (fragAccess == INDEXACCESS_DYNAMIC) |
| frag << "uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n"; |
| else if (fragAccess == INDEXACCESS_DYNAMIC_LOOP) |
| frag << "uniform int ui_four;\n"; |
| frag << "in ${PRECISION} ${VAR_TYPE} var[${ARRAY_LEN}];\n"; |
| frag << "\n"; |
| frag << "void main()\n"; |
| frag << "{\n"; |
| frag << " ${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n"; |
| if (fragAccess == INDEXACCESS_STATIC) |
| { |
| frag << " res += var[0];\n"; |
| frag << " res += var[1];\n"; |
| frag << " res += var[2];\n"; |
| frag << " res += var[3];\n"; |
| } |
| else if (fragAccess == INDEXACCESS_DYNAMIC) |
| { |
| frag << " res += var[ui_zero];\n"; |
| frag << " res += var[ui_one];\n"; |
| frag << " res += var[ui_two];\n"; |
| frag << " res += var[ui_three];\n"; |
| } |
| else if (fragAccess == INDEXACCESS_STATIC_LOOP) |
| { |
| frag << " for (int i = 0; i < 4; i++)\n"; |
| frag << " res += var[i];\n"; |
| } |
| else |
| { |
| DE_ASSERT(fragAccess == INDEXACCESS_DYNAMIC_LOOP); |
| frag << " for (int i = 0; i < ui_four; i++)\n"; |
| frag << " res += var[i];\n"; |
| } |
| frag << " o_color = vec4(res${PADDING});\n"; |
| frag << "}\n"; |
| |
| // Fill in shader templates. |
| map<string, string> params; |
| params.insert(pair<string, string>("VAR_TYPE", getDataTypeName(varType))); |
| params.insert(pair<string, string>("ARRAY_LEN", "4")); |
| params.insert(pair<string, string>("PRECISION", "mediump")); |
| |
| if (varType == TYPE_FLOAT) |
| params.insert(pair<string, string>("PADDING", ", 0.0, 0.0, 1.0")); |
| else if (varType == TYPE_FLOAT_VEC2) |
| params.insert(pair<string, string>("PADDING", ", 0.0, 1.0")); |
| else if (varType == TYPE_FLOAT_VEC3) |
| params.insert(pair<string, string>("PADDING", ", 1.0")); |
| else |
| params.insert(pair<string, string>("PADDING", "")); |
| |
| StringTemplate vertTemplate(vtx.str().c_str()); |
| StringTemplate fragTemplate(frag.str().c_str()); |
| string vertexShaderSource = vertTemplate.specialize(params); |
| string fragmentShaderSource = fragTemplate.specialize(params); |
| |
| ShaderEvalFunc evalFunc = getArrayCoordsEvalFunc(varType); |
| return new ShaderIndexingCase(context, caseName, description, true, varType, evalFunc, vertexShaderSource.c_str(), |
| fragmentShaderSource.c_str()); |
| } |
| |
| static ShaderIndexingCase *createUniformArrayCase(Context &context, const char *caseName, const char *description, |
| bool isVertexCase, DataType varType, IndexAccessType readAccess) |
| { |
| std::ostringstream vtx; |
| std::ostringstream frag; |
| std::ostringstream &op = isVertexCase ? vtx : frag; |
| |
| vtx << "#version 300 es\n"; |
| frag << "#version 300 es\n"; |
| |
| vtx << "in highp vec4 a_position;\n"; |
| vtx << "in highp vec4 a_coords;\n"; |
| frag << "layout(location = 0) out mediump vec4 o_color;\n"; |
| |
| if (isVertexCase) |
| { |
| vtx << "out mediump vec4 v_color;\n"; |
| frag << "in mediump vec4 v_color;\n"; |
| } |
| else |
| { |
| vtx << "out mediump vec4 v_coords;\n"; |
| frag << "in mediump vec4 v_coords;\n"; |
| } |
| |
| if (readAccess == INDEXACCESS_DYNAMIC) |
| op << "uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n"; |
| else if (readAccess == INDEXACCESS_DYNAMIC_LOOP) |
| op << "uniform mediump int ui_four;\n"; |
| |
| op << "uniform ${PRECISION} ${VAR_TYPE} u_arr[${ARRAY_LEN}];\n"; |
| |
| vtx << "\n"; |
| vtx << "void main()\n"; |
| vtx << "{\n"; |
| vtx << " gl_Position = a_position;\n"; |
| |
| frag << "\n"; |
| frag << "void main()\n"; |
| frag << "{\n"; |
| |
| // Read array. |
| op << " ${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n"; |
| if (readAccess == INDEXACCESS_STATIC) |
| { |
| op << " res += u_arr[0];\n"; |
| op << " res += u_arr[1];\n"; |
| op << " res += u_arr[2];\n"; |
| op << " res += u_arr[3];\n"; |
| } |
| else if (readAccess == INDEXACCESS_DYNAMIC) |
| { |
| op << " res += u_arr[ui_zero];\n"; |
| op << " res += u_arr[ui_one];\n"; |
| op << " res += u_arr[ui_two];\n"; |
| op << " res += u_arr[ui_three];\n"; |
| } |
| else if (readAccess == INDEXACCESS_STATIC_LOOP) |
| { |
| op << " for (int i = 0; i < 4; i++)\n"; |
| op << " res += u_arr[i];\n"; |
| } |
| else |
| { |
| DE_ASSERT(readAccess == INDEXACCESS_DYNAMIC_LOOP); |
| op << " for (int i = 0; i < ui_four; i++)\n"; |
| op << " res += u_arr[i];\n"; |
| } |
| |
| if (isVertexCase) |
| { |
| vtx << " v_color = vec4(res${PADDING});\n"; |
| frag << " o_color = v_color;\n"; |
| } |
| else |
| { |
| vtx << " v_coords = a_coords;\n"; |
| frag << " o_color = vec4(res${PADDING});\n"; |
| } |
| |
| vtx << "}\n"; |
| frag << "}\n"; |
| |
| // Fill in shader templates. |
| map<string, string> params; |
| params.insert(pair<string, string>("VAR_TYPE", getDataTypeName(varType))); |
| params.insert(pair<string, string>("ARRAY_LEN", "4")); |
| params.insert(pair<string, string>("PRECISION", "mediump")); |
| |
| if (varType == TYPE_FLOAT) |
| params.insert(pair<string, string>("PADDING", ", 0.0, 0.0, 1.0")); |
| else if (varType == TYPE_FLOAT_VEC2) |
| params.insert(pair<string, string>("PADDING", ", 0.0, 1.0")); |
| else if (varType == TYPE_FLOAT_VEC3) |
| params.insert(pair<string, string>("PADDING", ", 1.0")); |
| else |
| params.insert(pair<string, string>("PADDING", "")); |
| |
| StringTemplate vertTemplate(vtx.str().c_str()); |
| StringTemplate fragTemplate(frag.str().c_str()); |
| string vertexShaderSource = vertTemplate.specialize(params); |
| string fragmentShaderSource = fragTemplate.specialize(params); |
| |
| ShaderEvalFunc evalFunc = getArrayUniformEvalFunc(varType); |
| return new ShaderIndexingCase(context, caseName, description, isVertexCase, varType, evalFunc, |
| vertexShaderSource.c_str(), fragmentShaderSource.c_str()); |
| } |
| |
| static ShaderIndexingCase *createTmpArrayCase(Context &context, const char *caseName, const char *description, |
| bool isVertexCase, DataType varType, IndexAccessType writeAccess, |
| IndexAccessType readAccess) |
| { |
| std::ostringstream vtx; |
| std::ostringstream frag; |
| std::ostringstream &op = isVertexCase ? vtx : frag; |
| |
| vtx << "#version 300 es\n"; |
| frag << "#version 300 es\n"; |
| |
| vtx << "in highp vec4 a_position;\n"; |
| vtx << "in highp vec4 a_coords;\n"; |
| frag << "layout(location = 0) out mediump vec4 o_color;\n"; |
| |
| if (isVertexCase) |
| { |
| vtx << "out mediump vec4 v_color;\n"; |
| frag << "in mediump vec4 v_color;\n"; |
| } |
| else |
| { |
| vtx << "out mediump vec4 v_coords;\n"; |
| frag << "in mediump vec4 v_coords;\n"; |
| } |
| |
| if (writeAccess == INDEXACCESS_DYNAMIC || readAccess == INDEXACCESS_DYNAMIC) |
| op << "uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n"; |
| |
| if (writeAccess == INDEXACCESS_DYNAMIC_LOOP || readAccess == INDEXACCESS_DYNAMIC_LOOP) |
| op << "uniform mediump int ui_four;\n"; |
| |
| vtx << "\n"; |
| vtx << "void main()\n"; |
| vtx << "{\n"; |
| vtx << " gl_Position = a_position;\n"; |
| |
| frag << "\n"; |
| frag << "void main()\n"; |
| frag << "{\n"; |
| |
| // Write array. |
| if (isVertexCase) |
| op << " ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n"; |
| else |
| op << " ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(v_coords);\n"; |
| |
| op << " ${PRECISION} ${VAR_TYPE} arr[${ARRAY_LEN}];\n"; |
| if (writeAccess == INDEXACCESS_STATIC) |
| { |
| op << " arr[0] = ${VAR_TYPE}(coords);\n"; |
| op << " arr[1] = ${VAR_TYPE}(coords) * 0.5;\n"; |
| op << " arr[2] = ${VAR_TYPE}(coords) * 0.25;\n"; |
| op << " arr[3] = ${VAR_TYPE}(coords) * 0.125;\n"; |
| } |
| else if (writeAccess == INDEXACCESS_DYNAMIC) |
| { |
| op << " arr[ui_zero] = ${VAR_TYPE}(coords);\n"; |
| op << " arr[ui_one] = ${VAR_TYPE}(coords) * 0.5;\n"; |
| op << " arr[ui_two] = ${VAR_TYPE}(coords) * 0.25;\n"; |
| op << " arr[ui_three] = ${VAR_TYPE}(coords) * 0.125;\n"; |
| } |
| else if (writeAccess == INDEXACCESS_STATIC_LOOP) |
| { |
| op << " for (int i = 0; i < 4; i++)\n"; |
| op << " {\n"; |
| op << " arr[i] = ${VAR_TYPE}(coords);\n"; |
| op << " coords = coords * 0.5;\n"; |
| op << " }\n"; |
| } |
| else |
| { |
| DE_ASSERT(writeAccess == INDEXACCESS_DYNAMIC_LOOP); |
| op << " for (int i = 0; i < ui_four; i++)\n"; |
| op << " {\n"; |
| op << " arr[i] = ${VAR_TYPE}(coords);\n"; |
| op << " coords = coords * 0.5;\n"; |
| op << " }\n"; |
| } |
| |
| // Read array. |
| op << " ${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n"; |
| if (readAccess == INDEXACCESS_STATIC) |
| { |
| op << " res += arr[0];\n"; |
| op << " res += arr[1];\n"; |
| op << " res += arr[2];\n"; |
| op << " res += arr[3];\n"; |
| } |
| else if (readAccess == INDEXACCESS_DYNAMIC) |
| { |
| op << " res += arr[ui_zero];\n"; |
| op << " res += arr[ui_one];\n"; |
| op << " res += arr[ui_two];\n"; |
| op << " res += arr[ui_three];\n"; |
| } |
| else if (readAccess == INDEXACCESS_STATIC_LOOP) |
| { |
| op << " for (int i = 0; i < 4; i++)\n"; |
| op << " res += arr[i];\n"; |
| } |
| else |
| { |
| DE_ASSERT(readAccess == INDEXACCESS_DYNAMIC_LOOP); |
| op << " for (int i = 0; i < ui_four; i++)\n"; |
| op << " res += arr[i];\n"; |
| } |
| |
| if (isVertexCase) |
| { |
| vtx << " v_color = vec4(res${PADDING});\n"; |
| frag << " o_color = v_color;\n"; |
| } |
| else |
| { |
| vtx << " v_coords = a_coords;\n"; |
| frag << " o_color = vec4(res${PADDING});\n"; |
| } |
| |
| vtx << "}\n"; |
| frag << "}\n"; |
| |
| // Fill in shader templates. |
| map<string, string> params; |
| params.insert(pair<string, string>("VAR_TYPE", getDataTypeName(varType))); |
| params.insert(pair<string, string>("ARRAY_LEN", "4")); |
| params.insert(pair<string, string>("PRECISION", "mediump")); |
| |
| if (varType == TYPE_FLOAT) |
| params.insert(pair<string, string>("PADDING", ", 0.0, 0.0, 1.0")); |
| else if (varType == TYPE_FLOAT_VEC2) |
| params.insert(pair<string, string>("PADDING", ", 0.0, 1.0")); |
| else if (varType == TYPE_FLOAT_VEC3) |
| params.insert(pair<string, string>("PADDING", ", 1.0")); |
| else |
| params.insert(pair<string, string>("PADDING", "")); |
| |
| StringTemplate vertTemplate(vtx.str().c_str()); |
| StringTemplate fragTemplate(frag.str().c_str()); |
| string vertexShaderSource = vertTemplate.specialize(params); |
| string fragmentShaderSource = fragTemplate.specialize(params); |
| |
| ShaderEvalFunc evalFunc = getArrayCoordsEvalFunc(varType); |
| return new ShaderIndexingCase(context, caseName, description, isVertexCase, varType, evalFunc, |
| vertexShaderSource.c_str(), fragmentShaderSource.c_str()); |
| } |
| |
| // VECTOR SUBSCRIPT. |
| |
| void evalSubscriptVec2(ShaderEvalContext &c) |
| { |
| c.color.xyz() = Vec3(c.coords.x() + 0.5f * c.coords.y()); |
| } |
| void evalSubscriptVec3(ShaderEvalContext &c) |
| { |
| c.color.xyz() = Vec3(c.coords.x() + 0.5f * c.coords.y() + 0.25f * c.coords.z()); |
| } |
| void evalSubscriptVec4(ShaderEvalContext &c) |
| { |
| c.color.xyz() = Vec3(c.coords.x() + 0.5f * c.coords.y() + 0.25f * c.coords.z() + 0.125f * c.coords.w()); |
| } |
| |
| static ShaderEvalFunc getVectorSubscriptEvalFunc(DataType dataType) |
| { |
| if (dataType == TYPE_FLOAT_VEC2) |
| return evalSubscriptVec2; |
| else if (dataType == TYPE_FLOAT_VEC3) |
| return evalSubscriptVec3; |
| else if (dataType == TYPE_FLOAT_VEC4) |
| return evalSubscriptVec4; |
| |
| DE_FATAL("Invalid data type."); |
| return NULL; |
| } |
| |
| static ShaderIndexingCase *createVectorSubscriptCase(Context &context, const char *caseName, const char *description, |
| bool isVertexCase, DataType varType, VectorAccessType writeAccess, |
| VectorAccessType readAccess) |
| { |
| std::ostringstream vtx; |
| std::ostringstream frag; |
| std::ostringstream &op = isVertexCase ? vtx : frag; |
| |
| int vecLen = getDataTypeScalarSize(varType); |
| const char *vecLenName = getIntUniformName(vecLen); |
| |
| vtx << "#version 300 es\n"; |
| frag << "#version 300 es\n"; |
| |
| vtx << "in highp vec4 a_position;\n"; |
| vtx << "in highp vec4 a_coords;\n"; |
| frag << "layout(location = 0) out mediump vec4 o_color;\n"; |
| |
| if (isVertexCase) |
| { |
| vtx << "out mediump vec3 v_color;\n"; |
| frag << "in mediump vec3 v_color;\n"; |
| } |
| else |
| { |
| vtx << "out mediump vec4 v_coords;\n"; |
| frag << "in mediump vec4 v_coords;\n"; |
| } |
| |
| if (writeAccess == SUBSCRIPT_DYNAMIC || readAccess == SUBSCRIPT_DYNAMIC) |
| { |
| op << "uniform mediump int ui_zero"; |
| if (vecLen >= 2) |
| op << ", ui_one"; |
| if (vecLen >= 3) |
| op << ", ui_two"; |
| if (vecLen >= 4) |
| op << ", ui_three"; |
| op << ";\n"; |
| } |
| |
| if (writeAccess == SUBSCRIPT_DYNAMIC_LOOP || readAccess == SUBSCRIPT_DYNAMIC_LOOP) |
| op << "uniform mediump int " << vecLenName << ";\n"; |
| |
| vtx << "\n"; |
| vtx << "void main()\n"; |
| vtx << "{\n"; |
| vtx << " gl_Position = a_position;\n"; |
| |
| frag << "\n"; |
| frag << "void main()\n"; |
| frag << "{\n"; |
| |
| // Write vector. |
| if (isVertexCase) |
| op << " ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n"; |
| else |
| op << " ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(v_coords);\n"; |
| |
| op << " ${PRECISION} ${VAR_TYPE} tmp;\n"; |
| if (writeAccess == DIRECT) |
| op << " tmp = coords.${SWIZZLE} * vec4(1.0, 0.5, 0.25, 0.125).${SWIZZLE};\n"; |
| else if (writeAccess == COMPONENT) |
| { |
| op << " tmp.x = coords.x;\n"; |
| if (vecLen >= 2) |
| op << " tmp.y = coords.y * 0.5;\n"; |
| if (vecLen >= 3) |
| op << " tmp.z = coords.z * 0.25;\n"; |
| if (vecLen >= 4) |
| op << " tmp.w = coords.w * 0.125;\n"; |
| } |
| else if (writeAccess == SUBSCRIPT_STATIC) |
| { |
| op << " tmp[0] = coords.x;\n"; |
| if (vecLen >= 2) |
| op << " tmp[1] = coords.y * 0.5;\n"; |
| if (vecLen >= 3) |
| op << " tmp[2] = coords.z * 0.25;\n"; |
| if (vecLen >= 4) |
| op << " tmp[3] = coords.w * 0.125;\n"; |
| } |
| else if (writeAccess == SUBSCRIPT_DYNAMIC) |
| { |
| op << " tmp[ui_zero] = coords.x;\n"; |
| if (vecLen >= 2) |
| op << " tmp[ui_one] = coords.y * 0.5;\n"; |
| if (vecLen >= 3) |
| op << " tmp[ui_two] = coords.z * 0.25;\n"; |
| if (vecLen >= 4) |
| op << " tmp[ui_three] = coords.w * 0.125;\n"; |
| } |
| else if (writeAccess == SUBSCRIPT_STATIC_LOOP) |
| { |
| op << " for (int i = 0; i < " << vecLen << "; i++)\n"; |
| op << " {\n"; |
| op << " tmp[i] = coords.x;\n"; |
| op << " coords = coords.${ROT_SWIZZLE} * 0.5;\n"; |
| op << " }\n"; |
| } |
| else |
| { |
| DE_ASSERT(writeAccess == SUBSCRIPT_DYNAMIC_LOOP); |
| op << " for (int i = 0; i < " << vecLenName << "; i++)\n"; |
| op << " {\n"; |
| op << " tmp[i] = coords.x;\n"; |
| op << " coords = coords.${ROT_SWIZZLE} * 0.5;\n"; |
| op << " }\n"; |
| } |
| |
| // Read vector. |
| op << " ${PRECISION} float res = 0.0;\n"; |
| if (readAccess == DIRECT) |
| op << " res = dot(tmp, ${VAR_TYPE}(1.0));\n"; |
| else if (readAccess == COMPONENT) |
| { |
| op << " res += tmp.x;\n"; |
| if (vecLen >= 2) |
| op << " res += tmp.y;\n"; |
| if (vecLen >= 3) |
| op << " res += tmp.z;\n"; |
| if (vecLen >= 4) |
| op << " res += tmp.w;\n"; |
| } |
| else if (readAccess == SUBSCRIPT_STATIC) |
| { |
| op << " res += tmp[0];\n"; |
| if (vecLen >= 2) |
| op << " res += tmp[1];\n"; |
| if (vecLen >= 3) |
| op << " res += tmp[2];\n"; |
| if (vecLen >= 4) |
| op << " res += tmp[3];\n"; |
| } |
| else if (readAccess == SUBSCRIPT_DYNAMIC) |
| { |
| op << " res += tmp[ui_zero];\n"; |
| if (vecLen >= 2) |
| op << " res += tmp[ui_one];\n"; |
| if (vecLen >= 3) |
| op << " res += tmp[ui_two];\n"; |
| if (vecLen >= 4) |
| op << " res += tmp[ui_three];\n"; |
| } |
| else if (readAccess == SUBSCRIPT_STATIC_LOOP) |
| { |
| op << " for (int i = 0; i < " << vecLen << "; i++)\n"; |
| op << " res += tmp[i];\n"; |
| } |
| else |
| { |
| DE_ASSERT(readAccess == SUBSCRIPT_DYNAMIC_LOOP); |
| op << " for (int i = 0; i < " << vecLenName << "; i++)\n"; |
| op << " res += tmp[i];\n"; |
| } |
| |
| if (isVertexCase) |
| { |
| vtx << " v_color = vec3(res);\n"; |
| frag << " o_color = vec4(v_color.rgb, 1.0);\n"; |
| } |
| else |
| { |
| vtx << " v_coords = a_coords;\n"; |
| frag << " o_color = vec4(vec3(res), 1.0);\n"; |
| } |
| |
| vtx << "}\n"; |
| frag << "}\n"; |
| |
| // Fill in shader templates. |
| static const char *s_swizzles[5] = {"", "x", "xy", "xyz", "xyzw"}; |
| static const char *s_rotSwizzles[5] = {"", "x", "yx", "yzx", "yzwx"}; |
| |
| map<string, string> params; |
| params.insert(pair<string, string>("VAR_TYPE", getDataTypeName(varType))); |
| params.insert(pair<string, string>("PRECISION", "mediump")); |
| params.insert(pair<string, string>("SWIZZLE", s_swizzles[vecLen])); |
| params.insert(pair<string, string>("ROT_SWIZZLE", s_rotSwizzles[vecLen])); |
| |
| StringTemplate vertTemplate(vtx.str().c_str()); |
| StringTemplate fragTemplate(frag.str().c_str()); |
| string vertexShaderSource = vertTemplate.specialize(params); |
| string fragmentShaderSource = fragTemplate.specialize(params); |
| |
| ShaderEvalFunc evalFunc = getVectorSubscriptEvalFunc(varType); |
| return new ShaderIndexingCase(context, caseName, description, isVertexCase, varType, evalFunc, |
| vertexShaderSource.c_str(), fragmentShaderSource.c_str()); |
| } |
| |
| // MATRIX SUBSCRIPT. |
| |
| void evalSubscriptMat2(ShaderEvalContext &c) |
| { |
| c.color.xy() = c.coords.swizzle(0, 1) + 0.5f * c.coords.swizzle(1, 2); |
| } |
| void evalSubscriptMat2x3(ShaderEvalContext &c) |
| { |
| c.color.xyz() = c.coords.swizzle(0, 1, 2) + 0.5f * c.coords.swizzle(1, 2, 3); |
| } |
| void evalSubscriptMat2x4(ShaderEvalContext &c) |
| { |
| c.color = c.coords.swizzle(0, 1, 2, 3) + 0.5f * c.coords.swizzle(1, 2, 3, 0); |
| } |
| |
| void evalSubscriptMat3x2(ShaderEvalContext &c) |
| { |
| c.color.xy() = c.coords.swizzle(0, 1) + 0.5f * c.coords.swizzle(1, 2) + 0.25f * c.coords.swizzle(2, 3); |
| } |
| void evalSubscriptMat3(ShaderEvalContext &c) |
| { |
| c.color.xyz() = c.coords.swizzle(0, 1, 2) + 0.5f * c.coords.swizzle(1, 2, 3) + 0.25f * c.coords.swizzle(2, 3, 0); |
| } |
| void evalSubscriptMat3x4(ShaderEvalContext &c) |
| { |
| c.color = c.coords.swizzle(0, 1, 2, 3) + 0.5f * c.coords.swizzle(1, 2, 3, 0) + 0.25f * c.coords.swizzle(2, 3, 0, 1); |
| } |
| |
| void evalSubscriptMat4x2(ShaderEvalContext &c) |
| { |
| c.color.xy() = c.coords.swizzle(0, 1) + 0.5f * c.coords.swizzle(1, 2) + 0.25f * c.coords.swizzle(2, 3) + |
| 0.125f * c.coords.swizzle(3, 0); |
| } |
| void evalSubscriptMat4x3(ShaderEvalContext &c) |
| { |
| c.color.xyz() = c.coords.swizzle(0, 1, 2) + 0.5f * c.coords.swizzle(1, 2, 3) + 0.25f * c.coords.swizzle(2, 3, 0) + |
| 0.125f * c.coords.swizzle(3, 0, 1); |
| } |
| void evalSubscriptMat4(ShaderEvalContext &c) |
| { |
| c.color = c.coords + 0.5f * c.coords.swizzle(1, 2, 3, 0) + 0.25f * c.coords.swizzle(2, 3, 0, 1) + |
| 0.125f * c.coords.swizzle(3, 0, 1, 2); |
| } |
| |
| static ShaderEvalFunc getMatrixSubscriptEvalFunc(DataType dataType) |
| { |
| switch (dataType) |
| { |
| case TYPE_FLOAT_MAT2: |
| return evalSubscriptMat2; |
| case TYPE_FLOAT_MAT2X3: |
| return evalSubscriptMat2x3; |
| case TYPE_FLOAT_MAT2X4: |
| return evalSubscriptMat2x4; |
| case TYPE_FLOAT_MAT3X2: |
| return evalSubscriptMat3x2; |
| case TYPE_FLOAT_MAT3: |
| return evalSubscriptMat3; |
| case TYPE_FLOAT_MAT3X4: |
| return evalSubscriptMat3x4; |
| case TYPE_FLOAT_MAT4X2: |
| return evalSubscriptMat4x2; |
| case TYPE_FLOAT_MAT4X3: |
| return evalSubscriptMat4x3; |
| case TYPE_FLOAT_MAT4: |
| return evalSubscriptMat4; |
| |
| default: |
| DE_FATAL("Invalid data type."); |
| return DE_NULL; |
| } |
| } |
| |
| static ShaderIndexingCase *createMatrixSubscriptCase(Context &context, const char *caseName, const char *description, |
| bool isVertexCase, DataType varType, IndexAccessType writeAccess, |
| IndexAccessType readAccess) |
| { |
| std::ostringstream vtx; |
| std::ostringstream frag; |
| std::ostringstream &op = isVertexCase ? vtx : frag; |
| |
| int numCols = getDataTypeMatrixNumColumns(varType); |
| int numRows = getDataTypeMatrixNumRows(varType); |
| const char *matSizeName = getIntUniformName(numCols); |
| DataType vecType = getDataTypeFloatVec(numRows); |
| |
| vtx << "#version 300 es\n"; |
| frag << "#version 300 es\n"; |
| |
| vtx << "in highp vec4 a_position;\n"; |
| vtx << "in highp vec4 a_coords;\n"; |
| frag << "layout(location = 0) out mediump vec4 o_color;\n"; |
| |
| if (isVertexCase) |
| { |
| vtx << "out mediump vec4 v_color;\n"; |
| frag << "in mediump vec4 v_color;\n"; |
| } |
| else |
| { |
| vtx << "out mediump vec4 v_coords;\n"; |
| frag << "in mediump vec4 v_coords;\n"; |
| } |
| |
| if (writeAccess == INDEXACCESS_DYNAMIC || readAccess == INDEXACCESS_DYNAMIC) |
| { |
| op << "uniform mediump int ui_zero"; |
| if (numCols >= 2) |
| op << ", ui_one"; |
| if (numCols >= 3) |
| op << ", ui_two"; |
| if (numCols >= 4) |
| op << ", ui_three"; |
| op << ";\n"; |
| } |
| |
| if (writeAccess == INDEXACCESS_DYNAMIC_LOOP || readAccess == INDEXACCESS_DYNAMIC_LOOP) |
| op << "uniform mediump int " << matSizeName << ";\n"; |
| |
| vtx << "\n"; |
| vtx << "void main()\n"; |
| vtx << "{\n"; |
| vtx << " gl_Position = a_position;\n"; |
| |
| frag << "\n"; |
| frag << "void main()\n"; |
| frag << "{\n"; |
| |
| // Write matrix. |
| if (isVertexCase) |
| op << " ${PRECISION} vec4 coords = a_coords;\n"; |
| else |
| op << " ${PRECISION} vec4 coords = v_coords;\n"; |
| |
| op << " ${PRECISION} ${MAT_TYPE} tmp;\n"; |
| if (writeAccess == INDEXACCESS_STATIC) |
| { |
| op << " tmp[0] = ${VEC_TYPE}(coords);\n"; |
| if (numCols >= 2) |
| op << " tmp[1] = ${VEC_TYPE}(coords.yzwx) * 0.5;\n"; |
| if (numCols >= 3) |
| op << " tmp[2] = ${VEC_TYPE}(coords.zwxy) * 0.25;\n"; |
| if (numCols >= 4) |
| op << " tmp[3] = ${VEC_TYPE}(coords.wxyz) * 0.125;\n"; |
| } |
| else if (writeAccess == INDEXACCESS_DYNAMIC) |
| { |
| op << " tmp[ui_zero] = ${VEC_TYPE}(coords);\n"; |
| if (numCols >= 2) |
| op << " tmp[ui_one] = ${VEC_TYPE}(coords.yzwx) * 0.5;\n"; |
| if (numCols >= 3) |
| op << " tmp[ui_two] = ${VEC_TYPE}(coords.zwxy) * 0.25;\n"; |
| if (numCols >= 4) |
| op << " tmp[ui_three] = ${VEC_TYPE}(coords.wxyz) * 0.125;\n"; |
| } |
| else if (writeAccess == INDEXACCESS_STATIC_LOOP) |
| { |
| op << " for (int i = 0; i < " << numCols << "; i++)\n"; |
| op << " {\n"; |
| op << " tmp[i] = ${VEC_TYPE}(coords);\n"; |
| op << " coords = coords.yzwx * 0.5;\n"; |
| op << " }\n"; |
| } |
| else |
| { |
| DE_ASSERT(writeAccess == INDEXACCESS_DYNAMIC_LOOP); |
| op << " for (int i = 0; i < " << matSizeName << "; i++)\n"; |
| op << " {\n"; |
| op << " tmp[i] = ${VEC_TYPE}(coords);\n"; |
| op << " coords = coords.yzwx * 0.5;\n"; |
| op << " }\n"; |
| } |
| |
| // Read matrix. |
| op << " ${PRECISION} ${VEC_TYPE} res = ${VEC_TYPE}(0.0);\n"; |
| if (readAccess == INDEXACCESS_STATIC) |
| { |
| op << " res += tmp[0];\n"; |
| if (numCols >= 2) |
| op << " res += tmp[1];\n"; |
| if (numCols >= 3) |
| op << " res += tmp[2];\n"; |
| if (numCols >= 4) |
| op << " res += tmp[3];\n"; |
| } |
| else if (readAccess == INDEXACCESS_DYNAMIC) |
| { |
| op << " res += tmp[ui_zero];\n"; |
| if (numCols >= 2) |
| op << " res += tmp[ui_one];\n"; |
| if (numCols >= 3) |
| op << " res += tmp[ui_two];\n"; |
| if (numCols >= 4) |
| op << " res += tmp[ui_three];\n"; |
| } |
| else if (readAccess == INDEXACCESS_STATIC_LOOP) |
| { |
| op << " for (int i = 0; i < " << numCols << "; i++)\n"; |
| op << " res += tmp[i];\n"; |
| } |
| else |
| { |
| DE_ASSERT(readAccess == INDEXACCESS_DYNAMIC_LOOP); |
| op << " for (int i = 0; i < " << matSizeName << "; i++)\n"; |
| op << " res += tmp[i];\n"; |
| } |
| |
| if (isVertexCase) |
| { |
| vtx << " v_color = vec4(res${PADDING});\n"; |
| frag << " o_color = v_color;\n"; |
| } |
| else |
| { |
| vtx << " v_coords = a_coords;\n"; |
| frag << " o_color = vec4(res${PADDING});\n"; |
| } |
| |
| vtx << "}\n"; |
| frag << "}\n"; |
| |
| // Fill in shader templates. |
| map<string, string> params; |
| params.insert(pair<string, string>("MAT_TYPE", getDataTypeName(varType))); |
| params.insert(pair<string, string>("VEC_TYPE", getDataTypeName(vecType))); |
| params.insert(pair<string, string>("PRECISION", "mediump")); |
| |
| if (numRows == 2) |
| params.insert(pair<string, string>("PADDING", ", 0.0, 1.0")); |
| else if (numRows == 3) |
| params.insert(pair<string, string>("PADDING", ", 1.0")); |
| else |
| params.insert(pair<string, string>("PADDING", "")); |
| |
| StringTemplate vertTemplate(vtx.str().c_str()); |
| StringTemplate fragTemplate(frag.str().c_str()); |
| string vertexShaderSource = vertTemplate.specialize(params); |
| string fragmentShaderSource = fragTemplate.specialize(params); |
| |
| ShaderEvalFunc evalFunc = getMatrixSubscriptEvalFunc(varType); |
| return new ShaderIndexingCase(context, caseName, description, isVertexCase, varType, evalFunc, |
| vertexShaderSource.c_str(), fragmentShaderSource.c_str()); |
| } |
| |
| // ShaderIndexingTests. |
| |
| ShaderIndexingTests::ShaderIndexingTests(Context &context) : TestCaseGroup(context, "indexing", "Indexing Tests") |
| { |
| } |
| |
| ShaderIndexingTests::~ShaderIndexingTests(void) |
| { |
| } |
| |
| void ShaderIndexingTests::init(void) |
| { |
| static const ShaderType s_shaderTypes[] = {SHADERTYPE_VERTEX, SHADERTYPE_FRAGMENT}; |
| |
| static const DataType s_floatAndVecTypes[] = {TYPE_FLOAT, TYPE_FLOAT_VEC2, TYPE_FLOAT_VEC3, TYPE_FLOAT_VEC4}; |
| |
| // Varying array access cases. |
| { |
| TestCaseGroup *varyingGroup = new TestCaseGroup(m_context, "varying_array", "Varying array access tests."); |
| addChild(varyingGroup); |
| |
| for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_floatAndVecTypes); typeNdx++) |
| { |
| DataType varType = s_floatAndVecTypes[typeNdx]; |
| for (int vertAccess = 0; vertAccess < INDEXACCESS_LAST; vertAccess++) |
| { |
| for (int fragAccess = 0; fragAccess < INDEXACCESS_LAST; fragAccess++) |
| { |
| const char *vertAccessName = getIndexAccessTypeName((IndexAccessType)vertAccess); |
| const char *fragAccessName = getIndexAccessTypeName((IndexAccessType)fragAccess); |
| string name = |
| string(getDataTypeName(varType)) + "_" + vertAccessName + "_write_" + fragAccessName + "_read"; |
| string desc = string("Varying array with ") + vertAccessName + " write in vertex shader and " + |
| fragAccessName + " read in fragment shader."; |
| varyingGroup->addChild(createVaryingArrayCase(m_context, name.c_str(), desc.c_str(), varType, |
| (IndexAccessType)vertAccess, |
| (IndexAccessType)fragAccess)); |
| } |
| } |
| } |
| } |
| |
| // Uniform array access cases. |
| { |
| TestCaseGroup *uniformGroup = new TestCaseGroup(m_context, "uniform_array", "Uniform array access tests."); |
| addChild(uniformGroup); |
| |
| for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_floatAndVecTypes); typeNdx++) |
| { |
| DataType varType = s_floatAndVecTypes[typeNdx]; |
| for (int readAccess = 0; readAccess < INDEXACCESS_LAST; readAccess++) |
| { |
| const char *readAccessName = getIndexAccessTypeName((IndexAccessType)readAccess); |
| for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) |
| { |
| ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; |
| const char *shaderTypeName = getShaderTypeName(shaderType); |
| string name = string(getDataTypeName(varType)) + "_" + readAccessName + "_read_" + shaderTypeName; |
| string desc = |
| string("Uniform array with ") + readAccessName + " read in " + shaderTypeName + " shader."; |
| bool isVertexCase = ((ShaderType)shaderType == SHADERTYPE_VERTEX); |
| uniformGroup->addChild(createUniformArrayCase(m_context, name.c_str(), desc.c_str(), isVertexCase, |
| varType, (IndexAccessType)readAccess)); |
| } |
| } |
| } |
| } |
| |
| // Temporary array access cases. |
| { |
| TestCaseGroup *tmpGroup = new TestCaseGroup(m_context, "tmp_array", "Temporary array access tests."); |
| addChild(tmpGroup); |
| |
| for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_floatAndVecTypes); typeNdx++) |
| { |
| DataType varType = s_floatAndVecTypes[typeNdx]; |
| for (int writeAccess = 0; writeAccess < INDEXACCESS_LAST; writeAccess++) |
| { |
| for (int readAccess = 0; readAccess < INDEXACCESS_LAST; readAccess++) |
| { |
| const char *writeAccessName = getIndexAccessTypeName((IndexAccessType)writeAccess); |
| const char *readAccessName = getIndexAccessTypeName((IndexAccessType)readAccess); |
| |
| for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) |
| { |
| ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; |
| const char *shaderTypeName = getShaderTypeName(shaderType); |
| string name = string(getDataTypeName(varType)) + "_" + writeAccessName + "_write_" + |
| readAccessName + "_read_" + shaderTypeName; |
| string desc = string("Temporary array with ") + writeAccessName + " write and " + |
| readAccessName + " read in " + shaderTypeName + " shader."; |
| bool isVertexCase = ((ShaderType)shaderType == SHADERTYPE_VERTEX); |
| tmpGroup->addChild(createTmpArrayCase(m_context, name.c_str(), desc.c_str(), isVertexCase, |
| varType, (IndexAccessType)writeAccess, |
| (IndexAccessType)readAccess)); |
| } |
| } |
| } |
| } |
| } |
| |
| // Vector indexing with subscripts. |
| { |
| TestCaseGroup *vecGroup = new TestCaseGroup(m_context, "vector_subscript", "Vector subscript indexing."); |
| addChild(vecGroup); |
| |
| static const DataType s_vectorTypes[] = {TYPE_FLOAT_VEC2, TYPE_FLOAT_VEC3, TYPE_FLOAT_VEC4}; |
| |
| for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_vectorTypes); typeNdx++) |
| { |
| DataType varType = s_vectorTypes[typeNdx]; |
| for (int writeAccess = 0; writeAccess < VECTORACCESS_LAST; writeAccess++) |
| { |
| for (int readAccess = 0; readAccess < VECTORACCESS_LAST; readAccess++) |
| { |
| const char *writeAccessName = getVectorAccessTypeName((VectorAccessType)writeAccess); |
| const char *readAccessName = getVectorAccessTypeName((VectorAccessType)readAccess); |
| |
| for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) |
| { |
| ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; |
| const char *shaderTypeName = getShaderTypeName(shaderType); |
| string name = string(getDataTypeName(varType)) + "_" + writeAccessName + "_write_" + |
| readAccessName + "_read_" + shaderTypeName; |
| string desc = string("Vector subscript access with ") + writeAccessName + " write and " + |
| readAccessName + " read in " + shaderTypeName + " shader."; |
| bool isVertexCase = ((ShaderType)shaderType == SHADERTYPE_VERTEX); |
| vecGroup->addChild( |
| createVectorSubscriptCase(m_context, name.c_str(), desc.c_str(), isVertexCase, varType, |
| (VectorAccessType)writeAccess, (VectorAccessType)readAccess)); |
| } |
| } |
| } |
| } |
| } |
| |
| // Matrix indexing with subscripts. |
| { |
| TestCaseGroup *matGroup = new TestCaseGroup(m_context, "matrix_subscript", "Matrix subscript indexing."); |
| addChild(matGroup); |
| |
| static const DataType s_matrixTypes[] = {TYPE_FLOAT_MAT2, TYPE_FLOAT_MAT2X3, TYPE_FLOAT_MAT2X4, |
| TYPE_FLOAT_MAT3X2, TYPE_FLOAT_MAT3, TYPE_FLOAT_MAT3X4, |
| TYPE_FLOAT_MAT4X2, TYPE_FLOAT_MAT4X3, TYPE_FLOAT_MAT4}; |
| |
| for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_matrixTypes); typeNdx++) |
| { |
| DataType varType = s_matrixTypes[typeNdx]; |
| for (int writeAccess = 0; writeAccess < INDEXACCESS_LAST; writeAccess++) |
| { |
| for (int readAccess = 0; readAccess < INDEXACCESS_LAST; readAccess++) |
| { |
| const char *writeAccessName = getIndexAccessTypeName((IndexAccessType)writeAccess); |
| const char *readAccessName = getIndexAccessTypeName((IndexAccessType)readAccess); |
| |
| for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) |
| { |
| ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; |
| const char *shaderTypeName = getShaderTypeName(shaderType); |
| string name = string(getDataTypeName(varType)) + "_" + writeAccessName + "_write_" + |
| readAccessName + "_read_" + shaderTypeName; |
| string desc = string("Vector subscript access with ") + writeAccessName + " write and " + |
| readAccessName + " read in " + shaderTypeName + " shader."; |
| bool isVertexCase = ((ShaderType)shaderType == SHADERTYPE_VERTEX); |
| matGroup->addChild( |
| createMatrixSubscriptCase(m_context, name.c_str(), desc.c_str(), isVertexCase, varType, |
| (IndexAccessType)writeAccess, (IndexAccessType)readAccess)); |
| } |
| } |
| } |
| } |
| } |
| |
| { |
| const std::vector<tcu::TestNode *> children = |
| gls::ShaderLibrary(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo()) |
| .loadShaderFile("shaders/indexing.test"); |
| |
| for (int i = 0; i < (int)children.size(); i++) |
| addChild(children[i]); |
| } |
| } |
| |
| } // namespace Functional |
| } // namespace gles3 |
| } // namespace deqp |
