Invariant keyword support

src/OpenGL/compiler/OutputASM.cpp

@@ -1866,6 +1866,12 @@ namespace glsl
 		case EvqFragmentIn:          return sw::Shader::PARAMETER_INPUT;
 		case EvqInvariantVaryingIn:  return sw::Shader::PARAMETER_INPUT;    // FIXME: Guarantee invariance at the backend
 		case EvqInvariantVaryingOut: return sw::Shader::PARAMETER_OUTPUT;   // FIXME: Guarantee invariance at the backend 
+		case EvqSmooth:              return sw::Shader::PARAMETER_OUTPUT;
+		case EvqFlat:                return sw::Shader::PARAMETER_OUTPUT;
+		case EvqCentroidOut:         return sw::Shader::PARAMETER_OUTPUT;
+		case EvqSmoothIn:            return sw::Shader::PARAMETER_INPUT;
+		case EvqFlatIn:              return sw::Shader::PARAMETER_INPUT;
+		case EvqCentroidIn:          return sw::Shader::PARAMETER_INPUT;
 		case EvqUniform:             return sw::Shader::PARAMETER_CONST;
 		case EvqIn:                  return sw::Shader::PARAMETER_TEMP;
 		case EvqOut:                 return sw::Shader::PARAMETER_TEMP;
@@ -1906,6 +1912,12 @@ namespace glsl
 		case EvqFragmentIn:          return varyingRegister(operand);
 		case EvqInvariantVaryingIn:  return varyingRegister(operand);
 		case EvqInvariantVaryingOut: return varyingRegister(operand);
+		case EvqSmooth:              return varyingRegister(operand);
+		case EvqFlat:                return varyingRegister(operand);
+		case EvqCentroidOut:         return varyingRegister(operand);
+		case EvqSmoothIn:            return varyingRegister(operand);
+		case EvqFlatIn:              return varyingRegister(operand);
+		case EvqCentroidIn:          return varyingRegister(operand);
 		case EvqUniform:             return uniformRegister(operand);
 		case EvqIn:                  return temporaryRegister(operand);
 		case EvqOut:                 return temporaryRegister(operand);

src/OpenGL/compiler/ParseHelper.cpp

@@ -1053,6 +1053,24 @@ bool TParseContext::functionCallLValueErrorCheck(const TFunction *fnCandidate, T
 	return false;
 }
 
+void TParseContext::es3InvariantErrorCheck(const TQualifier qualifier, const TSourceLoc &invariantLocation)
+{
+	switch(qualifier)
+	{
+	case EvqVaryingOut:
+	case EvqSmoothOut:
+	case EvqFlatOut:
+	case EvqCentroidOut:
+	case EvqVertexOut:
+	case EvqFragmentOut:
+		break;
+	default:
+		error(invariantLocation, "Only out variables can be invariant.", "invariant");
+		recover();
+		break;
+	}
+}
+
 bool TParseContext::supportsExtension(const char* extension)
 {
     const TExtensionBehavior& extbehavior = extensionBehavior();

src/OpenGL/compiler/ParseHelper.h

@@ -133,6 +133,7 @@ public:
 	bool singleDeclarationErrorCheck(const TPublicType &publicType, const TSourceLoc &identifierLocation);
     bool layoutLocationErrorCheck(const TSourceLoc& location, const TLayoutQualifier &layoutQualifier);
     bool functionCallLValueErrorCheck(const TFunction *fnCandidate, TIntermAggregate *);
+	void es3InvariantErrorCheck(const TQualifier qualifier, const TSourceLoc &invariantLocation);
 
     const TExtensionBehavior& extensionBehavior() const { return mDirectiveHandler.extensionBehavior(); }
     bool supportsExtension(const char* extension);

src/OpenGL/compiler/glslang.y

@@ -997,6 +997,16 @@ type_qualifier
         $$.setBasic(EbtVoid, $2.qualifier, @2);
         $$.layoutQualifier = $1;
     }
+    | INVARIANT storage_qualifier {
+        context->es3InvariantErrorCheck($2.qualifier, @1);
+        $$.setBasic(EbtVoid, $2.qualifier, @2);
+        $$.invariant = true;
+    }
+    | INVARIANT interpolation_qualifier storage_qualifier {
+        context->es3InvariantErrorCheck($3.qualifier, @1);
+        $$ = context->joinInterpolationQualifiers(@2, $2.qualifier, @3, $3.qualifier);
+        $$.invariant = true;
+    }
     ;
 
 storage_qualifier