Add support for NV_shader_noperspective_interpolation

include/GLSLANG/ShaderLang.h

@@ -26,7 +26,7 @@
 
 // Version number for shader translation API.
 // It is incremented every time the API changes.
-#define ANGLE_SH_VERSION 226
+#define ANGLE_SH_VERSION 227
 
 enum ShShaderSpec
 {
@@ -380,6 +380,7 @@ struct ShBuiltInResources
     int WEBGL_debug_shader_precision;
     int EXT_shader_framebuffer_fetch;
     int NV_shader_framebuffer_fetch;
+    int NV_shader_noperspective_interpolation;
     int ARM_shader_framebuffer_fetch;
     int OVR_multiview;
     int OVR_multiview2;

include/GLSLANG/ShaderVars.h

@@ -28,7 +28,8 @@ enum InterpolationType
 {
     INTERPOLATION_SMOOTH,
     INTERPOLATION_CENTROID,
-    INTERPOLATION_FLAT
+    INTERPOLATION_FLAT,
+    INTERPOLATION_NOPERSPECTIVE
 };
 
 // Validate link & SSO consistency of interpolation qualifiers

scripts/code_generation_hashes/ANGLE_shader_translator.json

@@ -4,15 +4,15 @@
   "src/compiler/translator/generate_parser.py":
     "566178ecdfae3a29803b3687fc518ebb",
   "src/compiler/translator/glslang.l":
-    "2f602a853e4c4d669edc3cc36a1a8c4a",
+    "76676b64d51f4312e8060f4a00bc8f1b",
   "src/compiler/translator/glslang.y":
-    "928cfcdd99877b5a289694a4057d5d76",
+    "609c38a1997b77a9affec84541daf9c9",
   "src/compiler/translator/glslang_lex_autogen.cpp":
-    "809307250ccc9a6c6d026da45b57dcec",
+    "edc229f6d1b48f8588301219df80760e",
   "src/compiler/translator/glslang_tab_autogen.cpp":
-    "f693228f495aac4629ee8e30c12dc62f",
+    "8872811534b4e8aeef0df354bbd05044",
   "src/compiler/translator/glslang_tab_autogen.h":
-    "286139e7a8f2dd3458fbf39bff09d2ad",
+    "1bb42872dd5fd0a6f647201b142b67b6",
   "tools/flex-bison/linux/bison.sha1":
     "efa86001f00e7bcfdbe899dd15fc88e0",
   "tools/flex-bison/linux/flex.sha1":

src/compiler/translator/BaseTypes.h

@@ -970,14 +970,17 @@ enum TQualifier
     EvqLastFragData,
 
     // GLSL ES 3.0 vertex output and fragment input
-    EvqSmooth,    // Incomplete qualifier, smooth is the default
-    EvqFlat,      // Incomplete qualifier
-    EvqCentroid,  // Incomplete qualifier
+    EvqSmooth,         // Incomplete qualifier, smooth is the default
+    EvqFlat,           // Incomplete qualifier
+    EvqNoPerspective,  // Incomplete qualifier
+    EvqCentroid,       // Incomplete qualifier
     EvqSmoothOut,
     EvqFlatOut,
+    EvqNoPerspectiveOut,
     EvqCentroidOut,  // Implies smooth
     EvqSmoothIn,
     EvqFlatIn,
+    EvqNoPerspectiveIn,
     EvqCentroidIn,  // Implies smooth
 
     // GLSL ES 3.1 compute shader special variables
@@ -1034,6 +1037,7 @@ inline bool IsShaderIn(TQualifier qualifier)
         case EvqVaryingIn:
         case EvqSmoothIn:
         case EvqFlatIn:
+        case EvqNoPerspectiveIn:
         case EvqCentroidIn:
             return true;
         default:
@@ -1051,6 +1055,7 @@ inline bool IsShaderOut(TQualifier qualifier)
         case EvqVaryingOut:
         case EvqSmoothOut:
         case EvqFlatOut:
+        case EvqNoPerspectiveOut:
         case EvqCentroidOut:
             return true;
         default:
@@ -1301,11 +1306,14 @@ inline const char *getQualifierString(TQualifier q)
     case EvqSmoothOut:              return "smooth out";
     case EvqCentroidOut:            return "smooth centroid out";
     case EvqFlatOut:                return "flat out";
+    case EvqNoPerspectiveOut:       return "noperspective out";
     case EvqSmoothIn:               return "smooth in";
     case EvqFlatIn:                 return "flat in";
+    case EvqNoPerspectiveIn:        return "noperspective in";
     case EvqCentroidIn:             return "smooth centroid in";
     case EvqCentroid:               return "centroid";
     case EvqFlat:                   return "flat";
+    case EvqNoPerspective:          return "noperspective";
     case EvqSmooth:                 return "smooth";
     case EvqShared:                 return "shared";
     case EvqComputeIn:              return "in";

src/compiler/translator/CollectVariables.cpp

@@ -724,6 +724,7 @@ ShaderVariable CollectVariablesTraverser::recordVarying(const TIntermSymbol &var
         case EvqVertexOut:
         case EvqSmoothOut:
         case EvqFlatOut:
+        case EvqNoPerspectiveOut:
         case EvqCentroidOut:
         case EvqGeometryOut:
             if (mSymbolTable->isVaryingInvariant(variable.variable()) || type.isInvariant())

src/compiler/translator/ExtensionBehavior.cpp

@@ -25,6 +25,7 @@
     OP(EXT_shader_texture_lod)                      \
     OP(EXT_YUV_target)                              \
     OP(EXT_shader_non_constant_global_initializers) \
+    OP(NV_shader_noperspective_interpolation)       \
     OP(NV_EGL_stream_consumer_external)             \
     OP(NV_shader_framebuffer_fetch)                 \
     OP(OES_EGL_image_external)                      \

src/compiler/translator/ExtensionBehavior.h

@@ -32,6 +32,7 @@ enum class TExtension
     EXT_shader_non_constant_global_initializers,
     NV_EGL_stream_consumer_external,
     NV_shader_framebuffer_fetch,
+    NV_shader_noperspective_interpolation,
     OES_EGL_image_external,
     OES_EGL_image_external_essl3,
     OES_standard_derivatives,

src/compiler/translator/Initialize.cpp

@@ -57,6 +57,10 @@ void InitExtensionBehavior(const ShBuiltInResources &resources, TExtensionBehavi
     {
         extBehavior[TExtension::NV_shader_framebuffer_fetch] = EBhUndefined;
     }
+    if (resources.NV_shader_noperspective_interpolation)
+    {
+        extBehavior[TExtension::NV_shader_noperspective_interpolation] = EBhUndefined;
+    }
     if (resources.ARM_shader_framebuffer_fetch)
     {
         extBehavior[TExtension::ARM_shader_framebuffer_fetch] = EBhUndefined;

src/compiler/translator/ParseContext.cpp

@@ -530,6 +530,7 @@ bool TParseContext::checkCanBeLValue(const TSourceLoc &line, const char *op, TIn
         case EvqVertexIn:
         case EvqGeometryIn:
         case EvqFlatIn:
+        case EvqNoPerspectiveIn:
         case EvqSmoothIn:
         case EvqCentroidIn:
             message = "can't modify an input";

src/compiler/translator/QualifierTypes.cpp

@@ -403,6 +403,26 @@ bool JoinVariableStorageQualifier(TQualifier *joinedQualifier, TQualifier storag
             }
             break;
         }
+        case EvqNoPerspective:
+        {
+            switch (storageQualifier)
+            {
+                case EvqCentroid:
+                    *joinedQualifier = EvqNoPerspective;
+                    break;
+                case EvqVertexOut:
+                case EvqGeometryOut:
+                    *joinedQualifier = EvqNoPerspectiveOut;
+                    break;
+                case EvqFragmentIn:
+                case EvqGeometryIn:
+                    *joinedQualifier = EvqNoPerspectiveIn;
+                    break;
+                default:
+                    return false;
+            }
+            break;
+        }
         case EvqCentroid:
         {
             switch (storageQualifier)

src/compiler/translator/ShaderLang.cpp

@@ -168,6 +168,7 @@ void InitBuiltInResources(ShBuiltInResources *resources)
     resources->EXT_geometry_shader                         = 0;
     resources->EXT_gpu_shader5                             = 0;
     resources->EXT_shader_non_constant_global_initializers = 0;
+    resources->NV_shader_noperspective_interpolation       = 0;
     resources->OES_texture_storage_multisample_2d_array    = 0;
     resources->OES_texture_3D                              = 0;
     resources->ANGLE_texture_multisample                   = 0;

src/compiler/translator/glslang.l

@@ -105,6 +105,7 @@ static int ES3_1_keyword(TParseContext *context, int token);
 static int ES2_reserved_ES2_extension_ES3_keyword(TParseContext *context, TExtension extension, int token);
 static int ES3_extension(TParseContext *context, TExtension extension, int token);
 static int ES3_reserved_ES3_1_extension_ES3_2_keyword(TParseContext *context, TExtension extension, int token);
+static int ES3_reserved_ES3_extension(TParseContext *context, TExtension extension, int token);
 static int ES3_reserved_ES3_extension_ES3_1_keyword(TParseContext *context, TExtension extension, int token);
 static int ES3_1_reserved_ES3_1_extension_ES3_2_keyword(TParseContext *context, TExtension extension, int token);
 static int WEBGL_video_texture_extension(TParseContext *context, int token);
@@ -156,9 +157,10 @@ O           [0-7]
 "case"         { return ES3_keyword(context, CASE); }
 "default"      { return ES2_reserved_ES3_keyword(context, DEFAULT); }
 
-"centroid"     { return ES3_keyword(context, CENTROID); }
-"flat"         { return ES2_reserved_ES3_keyword(context, FLAT); }
-"smooth"       { return ES3_keyword(context, SMOOTH); }
+"centroid"      { return ES3_keyword(context, CENTROID); }
+"flat"          { return ES2_reserved_ES3_keyword(context, FLAT); }
+"smooth"        { return ES3_keyword(context, SMOOTH); }
+"noperspective" { return ES3_reserved_ES3_extension(context, TExtension::NV_shader_noperspective_interpolation, NOPERSPECTIVE); }
 
 "in"           { return IN_QUAL; }
 "out"          { return OUT_QUAL; }
@@ -262,7 +264,6 @@ O           [0-7]
 
     /* Reserved keywords for GLSL ES 3.00 that are not reserved for GLSL ES 1.00 */
 "resource"          |
-"noperspective"     |
 "patch"             |
 "sample"            |
 "subroutine"        |
@@ -651,6 +652,24 @@ int ES3_reserved_ES3_1_extension_ES3_2_keyword(TParseContext *context, TExtensio
     return check_type(yyscanner);
 }
 
+int ES3_reserved_ES3_extension(TParseContext *context, TExtension extension, int token)
+{
+    struct yyguts_t* yyg = (struct yyguts_t*) context->getScanner();
+    yyscan_t yyscanner = (yyscan_t) context->getScanner();
+
+    if(context->getShaderVersion() >= 300)
+    {
+        if (context->isExtensionEnabled(extension)) {
+            return token;
+        } else {
+            return reserved_word(yyscanner);
+        }
+    }
+
+    yylval->lex.string = AllocatePoolCharArray(yytext, yyleng);
+    return check_type(yyscanner);
+}
+
 int ES3_reserved_ES3_extension_ES3_1_keyword(TParseContext *context, TExtension extension, int token)
 {
     struct yyguts_t* yyg = (struct yyguts_t*) context->getScanner();

src/compiler/translator/glslang.y

@@ -164,7 +164,7 @@ extern void yyerror(YYLTYPE* yylloc, TParseContext* context, void *scanner, cons
 %token <lex> BVEC2 BVEC3 BVEC4 IVEC2 IVEC3 IVEC4 VEC2 VEC3 VEC4 UVEC2 UVEC3 UVEC4
 %token <lex> MATRIX2 MATRIX3 MATRIX4 IN_QUAL OUT_QUAL INOUT_QUAL UNIFORM BUFFER VARYING
 %token <lex> MATRIX2x3 MATRIX3x2 MATRIX2x4 MATRIX4x2 MATRIX3x4 MATRIX4x3
-%token <lex> CENTROID FLAT SMOOTH
+%token <lex> CENTROID FLAT SMOOTH NOPERSPECTIVE
 %token <lex> READONLY WRITEONLY COHERENT RESTRICT VOLATILE SHARED
 %token <lex> STRUCT VOID_TYPE WHILE
 %token <lex> SAMPLER2D SAMPLERCUBE SAMPLER_EXTERNAL_OES SAMPLER2DRECT SAMPLER2DARRAY
@@ -777,6 +777,13 @@ interpolation_qualifier
     | FLAT {
         $$ = EvqFlat;
     }
+    | NOPERSPECTIVE {
+        if (!context->checkCanUseExtension(@1, TExtension::NV_shader_noperspective_interpolation))
+        {
+            context->error(@1, "unsupported interpolation qualifier", "noperspective");
+        }
+        $$ = EvqNoPerspective;
+    }
     ;
 
 type_qualifier

src/compiler/translator/glslang_tab_autogen.h

@@ -107,109 +107,110 @@ enum yytokentype
     CENTROID                  = 308,
     FLAT                      = 309,
     SMOOTH                    = 310,
-    READONLY                  = 311,
-    WRITEONLY                 = 312,
-    COHERENT                  = 313,
-    RESTRICT                  = 314,
-    VOLATILE                  = 315,
-    SHARED                    = 316,
-    STRUCT                    = 317,
-    VOID_TYPE                 = 318,
-    WHILE                     = 319,
-    SAMPLER2D                 = 320,
-    SAMPLERCUBE               = 321,
-    SAMPLER_EXTERNAL_OES      = 322,
-    SAMPLER2DRECT             = 323,
-    SAMPLER2DARRAY            = 324,
-    ISAMPLER2D                = 325,
-    ISAMPLER3D                = 326,
-    ISAMPLERCUBE              = 327,
-    ISAMPLER2DARRAY           = 328,
-    USAMPLER2D                = 329,
-    USAMPLER3D                = 330,
-    USAMPLERCUBE              = 331,
-    USAMPLER2DARRAY           = 332,
-    SAMPLER2DMS               = 333,
-    ISAMPLER2DMS              = 334,
-    USAMPLER2DMS              = 335,
-    SAMPLER2DMSARRAY          = 336,
-    ISAMPLER2DMSARRAY         = 337,
-    USAMPLER2DMSARRAY         = 338,
-    SAMPLER3D                 = 339,
-    SAMPLER3DRECT             = 340,
-    SAMPLER2DSHADOW           = 341,
-    SAMPLERCUBESHADOW         = 342,
-    SAMPLER2DARRAYSHADOW      = 343,
-    SAMPLERVIDEOWEBGL         = 344,
-    SAMPLEREXTERNAL2DY2YEXT   = 345,
-    IMAGE2D                   = 346,
-    IIMAGE2D                  = 347,
-    UIMAGE2D                  = 348,
-    IMAGE3D                   = 349,
-    IIMAGE3D                  = 350,
-    UIMAGE3D                  = 351,
-    IMAGE2DARRAY              = 352,
-    IIMAGE2DARRAY             = 353,
-    UIMAGE2DARRAY             = 354,
-    IMAGECUBE                 = 355,
-    IIMAGECUBE                = 356,
-    UIMAGECUBE                = 357,
-    ATOMICUINT                = 358,
-    LAYOUT                    = 359,
-    YUVCSCSTANDARDEXT         = 360,
-    YUVCSCSTANDARDEXTCONSTANT = 361,
-    IDENTIFIER                = 362,
-    TYPE_NAME                 = 363,
-    FLOATCONSTANT             = 364,
-    INTCONSTANT               = 365,
-    UINTCONSTANT              = 366,
-    BOOLCONSTANT              = 367,
-    FIELD_SELECTION           = 368,
-    LEFT_OP                   = 369,
-    RIGHT_OP                  = 370,
-    INC_OP                    = 371,
-    DEC_OP                    = 372,
-    LE_OP                     = 373,
-    GE_OP                     = 374,
-    EQ_OP                     = 375,
-    NE_OP                     = 376,
-    AND_OP                    = 377,
-    OR_OP                     = 378,
-    XOR_OP                    = 379,
-    MUL_ASSIGN                = 380,
-    DIV_ASSIGN                = 381,
-    ADD_ASSIGN                = 382,
-    MOD_ASSIGN                = 383,
-    LEFT_ASSIGN               = 384,
-    RIGHT_ASSIGN              = 385,
-    AND_ASSIGN                = 386,
-    XOR_ASSIGN                = 387,
-    OR_ASSIGN                 = 388,
-    SUB_ASSIGN                = 389,
-    LEFT_PAREN                = 390,
-    RIGHT_PAREN               = 391,
-    LEFT_BRACKET              = 392,
-    RIGHT_BRACKET             = 393,
-    LEFT_BRACE                = 394,
-    RIGHT_BRACE               = 395,
-    DOT                       = 396,
-    COMMA                     = 397,
-    COLON                     = 398,
-    EQUAL                     = 399,
-    SEMICOLON                 = 400,
-    BANG                      = 401,
-    DASH                      = 402,
-    TILDE                     = 403,
-    PLUS                      = 404,
-    STAR                      = 405,
-    SLASH                     = 406,
-    PERCENT                   = 407,
-    LEFT_ANGLE                = 408,
-    RIGHT_ANGLE               = 409,
-    VERTICAL_BAR              = 410,
-    CARET                     = 411,
-    AMPERSAND                 = 412,
-    QUESTION                  = 413
+    NOPERSPECTIVE             = 311,
+    READONLY                  = 312,
+    WRITEONLY                 = 313,
+    COHERENT                  = 314,
+    RESTRICT                  = 315,
+    VOLATILE                  = 316,
+    SHARED                    = 317,
+    STRUCT                    = 318,
+    VOID_TYPE                 = 319,
+    WHILE                     = 320,
+    SAMPLER2D                 = 321,
+    SAMPLERCUBE               = 322,
+    SAMPLER_EXTERNAL_OES      = 323,
+    SAMPLER2DRECT             = 324,
+    SAMPLER2DARRAY            = 325,
+    ISAMPLER2D                = 326,
+    ISAMPLER3D                = 327,
+    ISAMPLERCUBE              = 328,
+    ISAMPLER2DARRAY           = 329,
+    USAMPLER2D                = 330,
+    USAMPLER3D                = 331,
+    USAMPLERCUBE              = 332,
+    USAMPLER2DARRAY           = 333,
+    SAMPLER2DMS               = 334,
+    ISAMPLER2DMS              = 335,
+    USAMPLER2DMS              = 336,
+    SAMPLER2DMSARRAY          = 337,
+    ISAMPLER2DMSARRAY         = 338,
+    USAMPLER2DMSARRAY         = 339,
+    SAMPLER3D                 = 340,
+    SAMPLER3DRECT             = 341,
+    SAMPLER2DSHADOW           = 342,
+    SAMPLERCUBESHADOW         = 343,
+    SAMPLER2DARRAYSHADOW      = 344,
+    SAMPLERVIDEOWEBGL         = 345,
+    SAMPLEREXTERNAL2DY2YEXT   = 346,
+    IMAGE2D                   = 347,
+    IIMAGE2D                  = 348,
+    UIMAGE2D                  = 349,
+    IMAGE3D                   = 350,
+    IIMAGE3D                  = 351,
+    UIMAGE3D                  = 352,
+    IMAGE2DARRAY              = 353,
+    IIMAGE2DARRAY             = 354,
+    UIMAGE2DARRAY             = 355,
+    IMAGECUBE                 = 356,
+    IIMAGECUBE                = 357,
+    UIMAGECUBE                = 358,
+    ATOMICUINT                = 359,
+    LAYOUT                    = 360,
+    YUVCSCSTANDARDEXT         = 361,
+    YUVCSCSTANDARDEXTCONSTANT = 362,
+    IDENTIFIER                = 363,
+    TYPE_NAME                 = 364,
+    FLOATCONSTANT             = 365,
+    INTCONSTANT               = 366,
+    UINTCONSTANT              = 367,
+    BOOLCONSTANT              = 368,
+    FIELD_SELECTION           = 369,
+    LEFT_OP                   = 370,
+    RIGHT_OP                  = 371,
+    INC_OP                    = 372,
+    DEC_OP                    = 373,
+    LE_OP                     = 374,
+    GE_OP                     = 375,
+    EQ_OP                     = 376,
+    NE_OP                     = 377,
+    AND_OP                    = 378,
+    OR_OP                     = 379,
+    XOR_OP                    = 380,
+    MUL_ASSIGN                = 381,
+    DIV_ASSIGN                = 382,
+    ADD_ASSIGN                = 383,
+    MOD_ASSIGN                = 384,
+    LEFT_ASSIGN               = 385,
+    RIGHT_ASSIGN              = 386,
+    AND_ASSIGN                = 387,
+    XOR_ASSIGN                = 388,
+    OR_ASSIGN                 = 389,
+    SUB_ASSIGN                = 390,
+    LEFT_PAREN                = 391,
+    RIGHT_PAREN               = 392,
+    LEFT_BRACKET              = 393,
+    RIGHT_BRACKET             = 394,
+    LEFT_BRACE                = 395,
+    RIGHT_BRACE               = 396,
+    DOT                       = 397,
+    COMMA                     = 398,
+    COLON                     = 399,
+    EQUAL                     = 400,
+    SEMICOLON                 = 401,
+    BANG                      = 402,
+    DASH                      = 403,
+    TILDE                     = 404,
+    PLUS                      = 405,
+    STAR                      = 406,
+    SLASH                     = 407,
+    PERCENT                   = 408,
+    LEFT_ANGLE                = 409,
+    RIGHT_ANGLE               = 410,
+    VERTICAL_BAR              = 411,
+    CARET                     = 412,
+    AMPERSAND                 = 413,
+    QUESTION                  = 414
 };
 #endif
 

src/compiler/translator/util.cpp

@@ -33,6 +33,7 @@ bool IsInterpolationIn(TQualifier qualifier)
     {
         case EvqSmoothIn:
         case EvqFlatIn:
+        case EvqNoPerspectiveIn:
         case EvqCentroidIn:
             return true;
         default:
@@ -519,6 +520,7 @@ bool IsVaryingOut(TQualifier qualifier)
         case EvqVaryingOut:
         case EvqSmoothOut:
         case EvqFlatOut:
+        case EvqNoPerspectiveOut:
         case EvqCentroidOut:
         case EvqVertexOut:
         case EvqGeometryOut:
@@ -538,6 +540,7 @@ bool IsVaryingIn(TQualifier qualifier)
         case EvqVaryingIn:
         case EvqSmoothIn:
         case EvqFlatIn:
+        case EvqNoPerspectiveIn:
         case EvqCentroidIn:
         case EvqFragmentIn:
         case EvqGeometryIn:
@@ -569,6 +572,10 @@ InterpolationType GetInterpolationType(TQualifier qualifier)
         case EvqFlatOut:
             return INTERPOLATION_FLAT;
 
+        case EvqNoPerspectiveIn:
+        case EvqNoPerspectiveOut:
+            return INTERPOLATION_NOPERSPECTIVE;
+
         case EvqSmoothIn:
         case EvqSmoothOut:
         case EvqVertexOut:

src/libANGLE/Caps.cpp

@@ -950,6 +950,7 @@ const ExtensionInfoMap &GetExtensionInfoMap()
         map["GL_EXT_semaphore"] = enableableExtension(&Extensions::semaphore);
         map["GL_EXT_semaphore_fd"] = enableableExtension(&Extensions::semaphoreFd);
         map["GL_NV_EGL_stream_consumer_external"] = enableableExtension(&Extensions::eglStreamConsumerExternalNV);
+        map["GL_NV_shader_noperspective_interpolation"] = enableableExtension(&Extensions::noperspectiveInterpolationNV);
         map["GL_ANGLE_semaphore_fuchsia"] = enableableExtension(&Extensions::semaphoreFuchsiaANGLE);
         map["GL_EXT_unpack_subimage"] = enableableExtension(&Extensions::unpackSubimage);
         map["GL_NV_pack_subimage"] = enableableExtension(&Extensions::packSubimage);

src/libANGLE/Caps.h

@@ -431,6 +431,9 @@ struct Extensions
     // NV_pack_subimage
     bool packSubimage = false;
 
+    // GL_NV_shader_noperspective_interpolation
+    bool noperspectiveInterpolationNV = false;
+
     // GL_OES_vertex_half_float
     bool vertexHalfFloatOES = false;
 

src/libANGLE/Compiler.cpp

@@ -92,11 +92,12 @@ Compiler::Compiler(rx::GLImplFactory *implFactory, const State &state)
     mResources.EXT_shader_texture_lod       = extensions.shaderTextureLOD;
     mResources.EXT_shader_non_constant_global_initializers =
         extensions.shaderNonConstGlobalInitializersEXT;
-    mResources.OES_EGL_image_external          = extensions.eglImageExternalOES;
-    mResources.OES_EGL_image_external_essl3    = extensions.eglImageExternalEssl3OES;
-    mResources.NV_EGL_stream_consumer_external = extensions.eglStreamConsumerExternalNV;
-    mResources.ARB_texture_rectangle           = extensions.textureRectangle;
-    mResources.EXT_gpu_shader5                 = extensions.gpuShader5EXT;
+    mResources.OES_EGL_image_external                = extensions.eglImageExternalOES;
+    mResources.OES_EGL_image_external_essl3          = extensions.eglImageExternalEssl3OES;
+    mResources.NV_EGL_stream_consumer_external       = extensions.eglStreamConsumerExternalNV;
+    mResources.NV_shader_noperspective_interpolation = extensions.noperspectiveInterpolationNV;
+    mResources.ARB_texture_rectangle                 = extensions.textureRectangle;
+    mResources.EXT_gpu_shader5                       = extensions.gpuShader5EXT;
     mResources.OES_texture_storage_multisample_2d_array =
         extensions.textureStorageMultisample2DArrayOES;
     mResources.OES_texture_3D                  = extensions.texture3DOES;

src/libANGLE/renderer/gl/renderergl_utils.cpp

@@ -1226,7 +1226,8 @@ void GenerateCaps(const FunctionsGL *functions,
     extensions->unpackSubimage     = functions->standard == STANDARD_GL_DESKTOP ||
                                  functions->isAtLeastGLES(gl::Version(3, 0)) ||
                                  functions->hasGLESExtension("GL_EXT_unpack_subimage");
-    extensions->packSubimage = functions->standard == STANDARD_GL_DESKTOP ||
+    extensions->noperspectiveInterpolationNV = functions->isAtLeastGL(gl::Version(3, 0));
+    extensions->packSubimage                 = functions->standard == STANDARD_GL_DESKTOP ||
                                functions->isAtLeastGLES(gl::Version(3, 0)) ||
                                functions->hasGLESExtension("GL_NV_pack_subimage");
     extensions->vertexArrayObjectOES = functions->isAtLeastGL(gl::Version(3, 0)) ||

src/libANGLE/renderer/vulkan/vk_caps_utils.cpp

@@ -157,6 +157,9 @@ void RendererVk::ensureCapsInitialized() const
     // Vulkan natively supports standard derivatives
     mNativeExtensions.standardDerivativesOES = true;
 
+    // Vulkan natively supports noperspective interpolation
+    mNativeExtensions.noperspectiveInterpolationNV = true;
+
     // Vulkan natively supports 32-bit indices, entry in kIndexTypeMap
     mNativeExtensions.elementIndexUintOES = true;
 

src/tests/angle_end2end_tests.gni

@@ -106,6 +106,7 @@ angle_end2end_tests_sources = [
   "gl_tests/SRGBTextureTest.cpp",
   "gl_tests/SamplersTest.cpp",
   "gl_tests/SemaphoreTest.cpp",
+  "gl_tests/ShaderInterpTest.cpp",
   "gl_tests/ShaderNonConstGlobalInitializerTest.cpp",
   "gl_tests/ShaderStorageBufferTest.cpp",
   "gl_tests/SimpleOperationTest.cpp",

src/tests/gl_tests/ShaderInterpTest.cpp

+//
+// Copyright 2020 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Tests for shader interpolation qualifiers
+//
+
+#include "common/mathutil.h"
+#include "test_utils/ANGLETest.h"
+#include "test_utils/gl_raii.h"
+
+using namespace angle;
+
+constexpr int kPixelColorThreshhold = 8;
+
+class ShaderInterpTest : public ANGLETest
+{
+  protected:
+    ShaderInterpTest() : ANGLETest()
+    {
+        setWindowWidth(128);
+        setWindowHeight(128);
+    }
+
+    void draw(GLuint program, float skew)
+    {
+        glUseProgram(program);
+
+        std::array<Vector4, 3> vertices;
+        vertices[0] = {-1.0, -1.0, 0.0, 1.0};
+        vertices[1] = {1.0, -1.0, 0.0, 1.0};
+        vertices[2] = {0.0, 1.0 * skew, 0.0, skew};
+
+        std::array<Vector4, 3> colors;
+        colors[0] = {1.0, 0.0, 0.0, 1.0};
+        colors[1] = {0.0, 1.0, 0.0, 1.0};
+        colors[2] = {0.0, 0.0, 1.0, 1.0};
+
+        GLint positionLocation = glGetAttribLocation(program, "position");
+        GLint colorLocation    = glGetAttribLocation(program, "vertex_color");
+
+        glVertexAttribPointer(positionLocation, 4, GL_FLOAT, GL_FALSE, 0, vertices.data());
+        glVertexAttribPointer(colorLocation, 4, GL_FLOAT, GL_FALSE, 0, colors.data());
+
+        glEnableVertexAttribArray(positionLocation);
+        glEnableVertexAttribArray(colorLocation);
+
+        glDrawArrays(GL_TRIANGLES, 0, 3);
+    }
+};
+
+// Test that regular "smooth" interpolation works correctly
+TEST_P(ShaderInterpTest, Smooth)
+{
+    const char *vertSrc = R"(#version 300 es
+precision highp float;
+in vec4 position;
+in vec4 vertex_color;
+smooth out vec4 interp_color;
+
+void main()
+{
+    gl_Position = position;
+    interp_color = vertex_color;
+}
+)";
+    const char *fragSrc = R"(#version 300 es
+precision highp float;
+smooth in vec4 interp_color;
+out vec4 fragColor;
+
+void main()
+{
+    fragColor = interp_color;
+}
+)";
+
+    ANGLE_GL_PROGRAM(program, vertSrc, fragSrc);
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+
+    glClear(GL_COLOR_BUFFER_BIT);
+    draw(program, 1.0);
+    EXPECT_PIXEL_COLOR_NEAR(64, 64, GLColor(62, 64, 128, 255), kPixelColorThreshhold);
+
+    glClear(GL_COLOR_BUFFER_BIT);
+    draw(program, 2.0);
+    EXPECT_PIXEL_COLOR_NEAR(64, 64, GLColor(83, 86, 86, 255), kPixelColorThreshhold);
+}
+
+// Test that uninterpolated "Flat" interpolation works correctly
+TEST_P(ShaderInterpTest, Flat)
+{
+    // TODO: anglebug.com/4085
+    // No vendors currently support VK_EXT_provoking_vertex, which is necessary for conformant flat
+    // shading. SwiftShader does technically support this extension, but as it has not yet been
+    // ratified by Khronos, the vulkan validation layers do not recognize the create info struct,
+    // causing it to be stripped and thus causing the extension to behave as if it is disabled.
+    ANGLE_SKIP_TEST_IF(IsVulkan());
+
+    const char *vertSrc = R"(#version 300 es
+precision highp float;
+in vec4 position;
+in vec4 vertex_color;
+flat out vec4 interp_color;
+
+void main()
+{
+    gl_Position = position;
+    interp_color = vertex_color;
+}
+)";
+    const char *fragSrc = R"(#version 300 es
+precision highp float;
+flat in vec4 interp_color;
+out vec4 fragColor;
+
+void main()
+{
+    fragColor = interp_color;
+}
+)";
+
+    ANGLE_GL_PROGRAM(program, vertSrc, fragSrc);
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+
+    glClear(GL_COLOR_BUFFER_BIT);
+    draw(program, 1.0);
+    GLColor smooth_reference;
+    glReadPixels(64, 64, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &smooth_reference);
+    EXPECT_PIXEL_COLOR_EQ(64, 64, GLColor(0, 0, 255, 255));
+}
+
+// Test that "noperspective" interpolation correctly interpolates in screenspace
+TEST_P(ShaderInterpTest, NoPerspective)
+{
+    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_NV_shader_noperspective_interpolation"));
+
+    const char *vertSrcSmooth = R"(#version 300 es
+precision highp float;
+in vec4 position;
+in vec4 vertex_color;
+smooth out vec4 interp_color;
+
+void main()
+{
+    gl_Position = position;
+    interp_color = vertex_color;
+}
+)";
+    const char *fragSrcSmooth = R"(#version 300 es
+precision highp float;
+smooth in vec4 interp_color;
+out vec4 fragColor;
+
+void main()
+{
+    fragColor = interp_color;
+}
+)";
+    ANGLE_GL_PROGRAM(programSmooth, vertSrcSmooth, fragSrcSmooth);
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    draw(programSmooth, 1.0);
+    GLColor smooth_reference;
+    glReadPixels(64, 64, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &smooth_reference);
+
+    const char *vertSrcNoPerspective = R"(#version 300 es
+#extension GL_NV_shader_noperspective_interpolation : require
+
+#ifndef GL_NV_shader_noperspective_interpolation
+#error GL_NV_shader_noperspective_interpolation is not defined
+#endif
+
+precision highp float;
+in vec4 position;
+in vec4 vertex_color;
+noperspective out vec4 interp_color;
+
+void main()
+{
+    gl_Position = position;
+    interp_color = vertex_color;
+}
+)";
+    const char *fragSrcNoPerspective = R"(#version 300 es
+#extension GL_NV_shader_noperspective_interpolation : require
+
+#ifndef GL_NV_shader_noperspective_interpolation
+#error GL_NV_shader_noperspective_interpolation is not defined
+#endif
+
+precision highp float;
+noperspective in vec4 interp_color;
+out vec4 fragColor;
+
+void main()
+{
+    fragColor = interp_color;
+}
+)";
+    ANGLE_GL_PROGRAM(programNoPerspective, vertSrcNoPerspective, fragSrcNoPerspective);
+    glClear(GL_COLOR_BUFFER_BIT);
+    draw(programNoPerspective, 1.0);
+    EXPECT_PIXEL_COLOR_EQ(64, 64, smooth_reference);
+
+    glClear(GL_COLOR_BUFFER_BIT);
+    draw(programNoPerspective, 2.0);
+    EXPECT_PIXEL_COLOR_EQ(64, 64, smooth_reference);
+}
+
+ANGLE_INSTANTIATE_TEST_ES3(ShaderInterpTest);
\ No newline at end of file