The Tor Browser: gfx/angle/src/compiler/VersionGLSL.cpp@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 //

     2 // Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.

     3 // Use of this source code is governed by a BSD-style license that can be

     4 // found in the LICENSE file.

     5 //

     7 #include "compiler/VersionGLSL.h"

     9 static const int GLSL_VERSION_110 = 110;

    10 static const int GLSL_VERSION_120 = 120;

    12 // We need to scan for the following:

    13 // 1. "invariant" keyword: This can occur in both - vertex and fragment shaders

    14 //    but only at the global scope.

    15 // 2. "gl_PointCoord" built-in variable: This can only occur in fragment shader

    16 //    but inside any scope.

    17 // 3. Call to a matrix constructor with another matrix as argument.

    18 //    (These constructors were reserved in GLSL version 1.10.)

    19 // 4. Arrays as "out" function parameters.

    20 //    GLSL spec section 6.1.1: "When calling a function, expressions that do

    21 //    not evaluate to l-values cannot be passed to parameters declared as

    22 //    out or inout."

    23 //    GLSL 1.1 section 5.8: "Other binary or unary expressions,

    24 //    non-dereferenced arrays, function names, swizzles with repeated fields,

    25 //    and constants cannot be l-values."

    26 //    GLSL 1.2 relaxed the restriction on arrays, section 5.8: "Variables that

    27 //    are built-in types, entire structures or arrays... are all l-values."

    28 //

    29 // TODO(alokp): The following two cases of invariant decalaration get lost

    30 // during parsing - they do not get carried over to the intermediate tree.

    31 // Handle these cases:

    32 // 1. When a pragma is used to force all output variables to be invariant:

    33 //    - #pragma STDGL invariant(all)

    34 // 2. When a previously decalared or built-in variable is marked invariant:

    35 //    - invariant gl_Position;

    36 //    - varying vec3 color; invariant color;

    37 //

    38 TVersionGLSL::TVersionGLSL(ShShaderType type)

    39     : mShaderType(type),

    40       mVersion(GLSL_VERSION_110)

    41 {

    42 }

    44 void TVersionGLSL::visitSymbol(TIntermSymbol* node)

    45 {

    46     if (node->getSymbol() == "gl_PointCoord")

    47         updateVersion(GLSL_VERSION_120);

    48 }

    50 void TVersionGLSL::visitConstantUnion(TIntermConstantUnion*)

    51 {

    52 }

    54 bool TVersionGLSL::visitBinary(Visit, TIntermBinary*)

    55 {

    56     return true;

    57 }

    59 bool TVersionGLSL::visitUnary(Visit, TIntermUnary*)

    60 {

    61     return true;

    62 }

    64 bool TVersionGLSL::visitSelection(Visit, TIntermSelection*)

    65 {

    66     return true;

    67 }

    69 bool TVersionGLSL::visitAggregate(Visit, TIntermAggregate* node)

    70 {

    71     bool visitChildren = true;

    73     switch (node->getOp()) {

    74       case EOpSequence:

    75         // We need to visit sequence children to get to global or inner scope.

    76         visitChildren = true;

    77         break;

    78       case EOpDeclaration: {

    79         const TIntermSequence& sequence = node->getSequence();

    80         TQualifier qualifier = sequence.front()->getAsTyped()->getQualifier();

    81         if ((qualifier == EvqInvariantVaryingIn) ||

    82             (qualifier == EvqInvariantVaryingOut)) {

    83             updateVersion(GLSL_VERSION_120);

    84         }

    85         break;

    86       }

    87       case EOpParameters: {

    88         const TIntermSequence& params = node->getSequence();

    89         for (TIntermSequence::const_iterator iter = params.begin();

    90              iter != params.end(); ++iter)

    91         {

    92             const TIntermTyped* param = (*iter)->getAsTyped();

    93             if (param->isArray())

    94             {

    95                 TQualifier qualifier = param->getQualifier();

    96                 if ((qualifier == EvqOut) || (qualifier ==  EvqInOut))

    97                 {

    98                     updateVersion(GLSL_VERSION_120);

    99                     break;

   100                 }

   101             }

   102         }

   103         // Fully processed. No need to visit children.

   104         visitChildren = false;

   105         break;

   106       }

   107       case EOpConstructMat2:

   108       case EOpConstructMat3:

   109       case EOpConstructMat4: {

   110         const TIntermSequence& sequence = node->getSequence();

   111         if (sequence.size() == 1) {

   112           TIntermTyped* typed = sequence.front()->getAsTyped();

   113           if (typed && typed->isMatrix()) {

   114             updateVersion(GLSL_VERSION_120);

   115           }

   116         }

   117         break;

   118       }

   120       default: break;

   121     }

   123     return visitChildren;

   124 }

   126 bool TVersionGLSL::visitLoop(Visit, TIntermLoop*)

   127 {

   128     return true;

   129 }

   131 bool TVersionGLSL::visitBranch(Visit, TIntermBranch*)

   132 {

   133     return true;

   134 }

   136 void TVersionGLSL::updateVersion(int version)

   137 {

   138     mVersion = std::max(version, mVersion);

   139 }

The Tor Browser / file revision