Add ES 300 matrix operations: outerProduct, determinant, inverse, and transpose, and missing ES 300 limit gl_MaxFragmentInputVectors.

git-svn-id: https://cvs.khronos.org/svn/repos/ogl/trunk/ecosystem/public/sdk/tools/glslang@20643 e7fa87d3-cd2b-0410-9028-fcbf551c1848

StandAlone/StandAlone.cpp

@@ -105,6 +105,7 @@ void GenerateResources(TBuiltInResource& resources)
     resources.maxVaryingVectors = 8;
     resources.maxFragmentUniformVectors = 16;
     resources.maxVertexOutputVectors = 16;
+    resources.maxFragmentInputVectors = 15;
     resources.minProgramTexelOffset = -8;
     resources.maxProgramTexelOffset = 7;
 }

Test/300.vert

@@ -0,0 +1,31 @@
+#version 300 es
+
+uniform mat4x3 m43;
+uniform mat3x3 m33;
+uniform mat4x4 m44;
+
+in vec3 v3;
+in vec2 v2;
+
+void main()
+{
+    int id = gl_VertexID + gl_InstanceID;
+
+    int c0 = gl_MaxVertexAttribs;
+    int c1 = gl_MaxVertexUniformVectors;
+    int c2 = gl_MaxVertexOutputVectors;
+    int c3 = gl_MaxFragmentInputVectors;
+    int c4 = gl_MaxVertexTextureImageUnits;
+    int c5 = gl_MaxCombinedTextureImageUnits;
+    int c6 = gl_MaxTextureImageUnits;
+    int c7 = gl_MaxFragmentUniformVectors;
+    int c8 = gl_MaxDrawBuffers;
+    int c9 = gl_MinProgramTexelOffset;
+    int c10 = gl_MaxProgramTexelOffset;
+
+    mat3x4 tm = transpose(m43);
+    highp float dm = determinant(m44);
+    mat3x3 im = inverse(m33);
+
+    mat3x2 op = outerProduct(v2, v3);
+}

Test/testlist

@@ -20,3 +20,4 @@ pointCoord.frag
 array.frag
 array100.frag
 comment.frag
+300.vert

glslang/Include/ResourceLimits.h

@@ -54,6 +54,7 @@ struct TBuiltInResource {
     int maxVaryingVectors;
     int maxFragmentUniformVectors;
     int maxVertexOutputVectors;
+    int maxFragmentInputVectors;
     int minProgramTexelOffset;
     int maxProgramTexelOffset;
 };

glslang/Include/intermediate.h

@@ -169,6 +169,10 @@ enum TOperator {
     EOpFwidth,          // Fragment only
 
     EOpMatrixTimesMatrix,
+    EOpOuterProduct,
+    EOpDeterminant,
+    EOpMatrixInverse,
+    EOpTranspose,
 
     EOpAny,
     EOpAll,

glslang/MachineIndependent/Initialize.cpp

@@ -283,6 +283,38 @@ void TBuiltIns::initialize(int version, EProfile profile)
         s.append(TString("mat3 matrixCompMult(mat3 x, mat3 y);"));
         s.append(TString("mat4 matrixCompMult(mat4 x, mat4 y);"));
 
+        if (version >= 120) {
+            s.append(TString("mat2   outerProduct(vec2 c, vec2 r);"));
+            s.append(TString("mat3   outerProduct(vec3 c, vec3 r);"));
+            s.append(TString("mat4   outerProduct(vec4 c, vec4 r);"));
+            s.append(TString("mat2x3 outerProduct(vec3 c, vec2 r);"));
+            s.append(TString("mat3x2 outerProduct(vec2 c, vec3 r);"));
+            s.append(TString("mat2x4 outerProduct(vec4 c, vec2 r);"));
+            s.append(TString("mat4x2 outerProduct(vec2 c, vec4 r);"));
+            s.append(TString("mat3x4 outerProduct(vec4 c, vec3 r);"));
+            s.append(TString("mat4x3 outerProduct(vec3 c, vec4 r);"));
+
+            s.append(TString("mat2   transpose(mat2   m);"));
+            s.append(TString("mat3   transpose(mat3   m);"));
+            s.append(TString("mat4   transpose(mat4   m);"));
+            s.append(TString("mat2x3 transpose(mat3x2 m);"));
+            s.append(TString("mat3x2 transpose(mat2x3 m);"));
+            s.append(TString("mat2x4 transpose(mat4x2 m);"));
+            s.append(TString("mat4x2 transpose(mat2x4 m);"));
+            s.append(TString("mat3x4 transpose(mat4x3 m);"));
+            s.append(TString("mat4x3 transpose(mat3x4 m);"));
+
+            if (version >= 150) {
+                s.append(TString("float determinant(mat2 m);"));
+                s.append(TString("float determinant(mat3 m);"));
+                s.append(TString("float determinant(mat4 m);"));
+                
+                s.append(TString("mat2 inverse(mat2 m);"));
+                s.append(TString("mat3 inverse(mat3 m);"));
+                s.append(TString("mat4 inverse(mat4 m);"));
+            }
+        }
+
         //
         // Vector relational functions.
         //
@@ -795,6 +827,9 @@ void TBuiltIns::initialize(const TBuiltInResource &resources, int version, EProf
                 snprintf(builtInConstant, maxSize, "const mediump int  gl_MaxVertexOutputVectors = %d;", resources.maxVertexOutputVectors);
                 s.append(TString(builtInConstant));
 
+                snprintf(builtInConstant, maxSize, "const mediump int  gl_MaxFragmentInputVectors = %d;", resources.maxFragmentInputVectors);
+                s.append(TString(builtInConstant));
+
                 snprintf(builtInConstant, maxSize, "const mediump int  gl_MinProgramTexelOffset = %d;", resources.minProgramTexelOffset);
                 s.append(TString(builtInConstant));
                 
@@ -964,6 +999,15 @@ void IdentifyBuiltIns(int version, EProfile profile, EShLanguage language, TSymb
     symbolTable.relateToOperator("not",              EOpVectorLogicalNot);
 
     symbolTable.relateToOperator("matrixCompMult",   EOpMul);
+    if (version >= 120) {
+        symbolTable.relateToOperator("outerProduct", EOpOuterProduct);
+        symbolTable.relateToOperator("transpose", EOpTranspose);
+        if (version >= 150) {
+            symbolTable.relateToOperator("determinant", EOpDeterminant);                
+            symbolTable.relateToOperator("inverse", EOpMatrixInverse);
+        }
+    }
+
     symbolTable.relateToOperator("mod",              EOpMod);
 
     symbolTable.relateToOperator("equal",            EOpVectorEqual);

glslang/MachineIndependent/Intermediate.cpp

@@ -1202,6 +1202,18 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
             }
             returnType = TType(getType().getBasicType(), EvqConst, 0, getMatrixRows(), node->getMatrixCols());
             break;
+        case EOpOuterProduct:
+            // TODO: functionality >= 120
+            break;
+        case EOpDeterminant:
+            // TODO: functionality >= 150
+            break;
+        case EOpMatrixInverse:
+            // TODO: functionality >= 150
+            break;
+        case EOpTranspose:
+            // TODO: functionality >= 120
+            break;
         case EOpDiv: 
             tempConstArray = new constUnion[objectSize];
             for (int i = 0; i < objectSize; i++) {

glslang/MachineIndependent/intermOut.cpp

@@ -237,6 +237,9 @@ bool OutputUnary(bool /* preVisit */, TIntermUnary* node, TIntermTraverser* it)
     case EOpDPdx:           out.debug << "dPdx";                 break;
     case EOpDPdy:           out.debug << "dPdy";                 break;
     case EOpFwidth:         out.debug << "fwidth";               break;
+    case EOpDeterminant:    out.debug << "determinant";          break;
+    case EOpMatrixInverse:  out.debug << "inverse";              break;
+    case EOpTranspose:      out.debug << "transpose";            break;
 
     case EOpAny:            out.debug << "any";                  break;
     case EOpAll:            out.debug << "all";                  break;
@@ -328,6 +331,7 @@ bool OutputAggregate(bool /* preVisit */, TIntermAggregate* node, TIntermTravers
     case EOpReflect:       out.debug << "reflect";                 break;
     case EOpRefract:       out.debug << "refract";                 break;
     case EOpMul:           out.debug << "component-wise multiply"; break;
+    case EOpOuterProduct:  out.debug << "outer product";           break;
 
     default: out.debug.message(EPrefixError, "Bad aggregation op");
     }