Home | History | Annotate | Download | only in compiler 
      1 //
      2 // Copyright (c) 2002-2010 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 //
      6 
      7 #include "compiler/OutputHLSL.h"
      8 
      9 #include "compiler/debug.h"
     10 #include "compiler/InfoSink.h"
     11 #include "compiler/UnfoldSelect.h"
     12 #include "compiler/SearchSymbol.h"
     13 
     14 #include <stdio.h>
     15 #include <algorithm>
     16 
     17 namespace sh
     18 {
     19 // Integer to TString conversion
     20 TString str(int i)
     21 {
     22     char buffer[20];
     23     sprintf(buffer, "%d", i);
     24     return buffer;
     25 }
     26 
     27 OutputHLSL::OutputHLSL(TParseContext &context) : TIntermTraverser(true, true, true), mContext(context)
     28 {
     29     mUnfoldSelect = new UnfoldSelect(context, this);
     30     mInsideFunction = false;
     31 
     32     mUsesTexture2D = false;
     33     mUsesTexture2D_bias = false;
     34     mUsesTexture2DProj = false;
     35     mUsesTexture2DProj_bias = false;
     36     mUsesTextureCube = false;
     37     mUsesTextureCube_bias = false;
     38     mUsesDepthRange = false;
     39     mUsesFragCoord = false;
     40     mUsesPointCoord = false;
     41     mUsesFrontFacing = false;
     42     mUsesPointSize = false;
     43     mUsesXor = false;
     44     mUsesMod1 = false;
     45     mUsesMod2 = false;
     46     mUsesMod3 = false;
     47     mUsesMod4 = false;
     48     mUsesFaceforward1 = false;
     49     mUsesFaceforward2 = false;
     50     mUsesFaceforward3 = false;
     51     mUsesFaceforward4 = false;
     52     mUsesEqualMat2 = false;
     53     mUsesEqualMat3 = false;
     54     mUsesEqualMat4 = false;
     55     mUsesEqualVec2 = false;
     56     mUsesEqualVec3 = false;
     57     mUsesEqualVec4 = false;
     58     mUsesEqualIVec2 = false;
     59     mUsesEqualIVec3 = false;
     60     mUsesEqualIVec4 = false;
     61     mUsesEqualBVec2 = false;
     62     mUsesEqualBVec3 = false;
     63     mUsesEqualBVec4 = false;
     64     mUsesAtan2 = false;
     65 
     66     mScopeDepth = 0;
     67 
     68     mUniqueIndex = 0;
     69 }
     70 
     71 OutputHLSL::~OutputHLSL()
     72 {
     73     delete mUnfoldSelect;
     74 }
     75 
     76 void OutputHLSL::output()
     77 {
     78     mContext.treeRoot->traverse(this);   // Output the body first to determine what has to go in the header
     79     header();
     80 
     81     mContext.infoSink.obj << mHeader.c_str();
     82     mContext.infoSink.obj << mBody.c_str();
     83 }
     84 
     85 TInfoSinkBase &OutputHLSL::getBodyStream()
     86 {
     87     return mBody;
     88 }
     89 
     90 int OutputHLSL::vectorSize(const TType &type) const
     91 {
     92     int elementSize = type.isMatrix() ? type.getNominalSize() : 1;
     93     int arraySize = type.isArray() ? type.getArraySize() : 1;
     94 
     95     return elementSize * arraySize;
     96 }
     97 
     98 void OutputHLSL::header()
     99 {
    100     ShShaderType shaderType = mContext.shaderType;
    101     TInfoSinkBase &out = mHeader;
    102 
    103     for (StructDeclarations::iterator structDeclaration = mStructDeclarations.begin(); structDeclaration != mStructDeclarations.end(); structDeclaration++)
    104     {
    105         out << *structDeclaration;
    106     }
    107 
    108     for (Constructors::iterator constructor = mConstructors.begin(); constructor != mConstructors.end(); constructor++)
    109     {
    110         out << *constructor;
    111     }
    112 
    113     if (shaderType == SH_FRAGMENT_SHADER)
    114     {
    115         TString uniforms;
    116         TString varyings;
    117 
    118         TSymbolTableLevel *symbols = mContext.symbolTable.getGlobalLevel();
    119         int semanticIndex = 0;
    120 
    121         for (TSymbolTableLevel::const_iterator namedSymbol = symbols->begin(); namedSymbol != symbols->end(); namedSymbol++)
    122         {
    123             const TSymbol *symbol = (*namedSymbol).second;
    124             const TString &name = symbol->getName();
    125 
    126             if (symbol->isVariable())
    127             {
    128                 const TVariable *variable = static_cast<const TVariable*>(symbol);
    129                 const TType &type = variable->getType();
    130                 TQualifier qualifier = type.getQualifier();
    131 
    132                 if (qualifier == EvqUniform)
    133                 {
    134                     if (mReferencedUniforms.find(name.c_str()) != mReferencedUniforms.end())
    135                     {
    136                         uniforms += "uniform " + typeString(type) + " " + decorate(name) + arrayString(type) + ";\n";
    137                     }
    138                 }
    139                 else if (qualifier == EvqVaryingIn || qualifier == EvqInvariantVaryingIn)
    140                 {
    141                     if (mReferencedVaryings.find(name.c_str()) != mReferencedVaryings.end())
    142                     {
    143                         // Program linking depends on this exact format
    144                         varyings += "static " + typeString(type) + " " + decorate(name) + arrayString(type) + " = " + initializer(type) + ";\n";
    145 
    146                         semanticIndex += type.isArray() ? type.getArraySize() : 1;
    147                     }
    148                 }
    149                 else if (qualifier == EvqGlobal || qualifier == EvqTemporary)
    150                 {
    151                     // Globals are declared and intialized as an aggregate node
    152                 }
    153                 else if (qualifier == EvqConst)
    154                 {
    155                     // Constants are repeated as literals where used
    156                 }
    157                 else UNREACHABLE();
    158             }
    159         }
    160 
    161         out << "// Varyings\n";
    162         out <<  varyings;
    163         out << "\n"
    164                "static float4 gl_Color[1] = {float4(0, 0, 0, 0)};\n";
    165 
    166         if (mUsesFragCoord)
    167         {
    168             out << "static float4 gl_FragCoord = float4(0, 0, 0, 0);\n";
    169         }
    170 
    171         if (mUsesPointCoord)
    172         {
    173             out << "static float2 gl_PointCoord = float2(0.5, 0.5);\n";
    174         }
    175 
    176         if (mUsesFrontFacing)
    177         {
    178             out << "static bool gl_FrontFacing = false;\n";
    179         }
    180 
    181         out << "\n";
    182 
    183         if (mUsesFragCoord)
    184         {
    185             out << "uniform float4 dx_Viewport;\n"
    186                    "uniform float2 dx_Depth;\n";
    187         }
    188 
    189         if (mUsesFrontFacing)
    190         {
    191             out << "uniform bool dx_PointsOrLines;\n"
    192                    "uniform bool dx_FrontCCW;\n";
    193         }
    194 
    195         out << "\n";
    196         out <<  uniforms;
    197         out << "\n";
    198 
    199         if (mUsesTexture2D)
    200         {
    201             out << "float4 gl_texture2D(sampler2D s, float2 t)\n"
    202                    "{\n"
    203                    "    return tex2D(s, t);\n"
    204                    "}\n"
    205                    "\n";
    206         }
    207 
    208         if (mUsesTexture2D_bias)
    209         {
    210             out << "float4 gl_texture2D(sampler2D s, float2 t, float bias)\n"
    211                    "{\n"
    212                    "    return tex2Dbias(s, float4(t.x, t.y, 0, bias));\n"
    213                    "}\n"
    214                    "\n";
    215         }
    216 
    217         if (mUsesTexture2DProj)
    218         {
    219             out << "float4 gl_texture2DProj(sampler2D s, float3 t)\n"
    220                    "{\n"
    221                    "    return tex2Dproj(s, float4(t.x, t.y, 0, t.z));\n"
    222                    "}\n"
    223                    "\n"
    224                    "float4 gl_texture2DProj(sampler2D s, float4 t)\n"
    225                    "{\n"
    226                    "    return tex2Dproj(s, t);\n"
    227                    "}\n"
    228                    "\n";
    229         }
    230 
    231         if (mUsesTexture2DProj_bias)
    232         {
    233             out << "float4 gl_texture2DProj(sampler2D s, float3 t, float bias)\n"
    234                    "{\n"
    235                    "    return tex2Dbias(s, float4(t.x / t.z, t.y / t.z, 0, bias));\n"
    236                    "}\n"
    237                    "\n"
    238                    "float4 gl_texture2DProj(sampler2D s, float4 t, float bias)\n"
    239                    "{\n"
    240                    "    return tex2Dbias(s, float4(t.x / t.w, t.y / t.w, 0, bias));\n"
    241                    "}\n"
    242                    "\n";
    243         }
    244 
    245         if (mUsesTextureCube)
    246         {
    247             out << "float4 gl_textureCube(samplerCUBE s, float3 t)\n"
    248                    "{\n"
    249                    "    return texCUBE(s, t);\n"
    250                    "}\n"
    251                    "\n";
    252         }
    253 
    254         if (mUsesTextureCube_bias)
    255         {
    256             out << "float4 gl_textureCube(samplerCUBE s, float3 t, float bias)\n"
    257                    "{\n"
    258                    "    return texCUBEbias(s, float4(t.x, t.y, t.z, bias));\n"
    259                    "}\n"
    260                    "\n";
    261         }
    262     }
    263     else   // Vertex shader
    264     {
    265         TString uniforms;
    266         TString attributes;
    267         TString varyings;
    268 
    269         TSymbolTableLevel *symbols = mContext.symbolTable.getGlobalLevel();
    270 
    271         for (TSymbolTableLevel::const_iterator namedSymbol = symbols->begin(); namedSymbol != symbols->end(); namedSymbol++)
    272         {
    273             const TSymbol *symbol = (*namedSymbol).second;
    274             const TString &name = symbol->getName();
    275 
    276             if (symbol->isVariable())
    277             {
    278                 const TVariable *variable = static_cast<const TVariable*>(symbol);
    279                 const TType &type = variable->getType();
    280                 TQualifier qualifier = type.getQualifier();
    281 
    282                 if (qualifier == EvqUniform)
    283                 {
    284                     if (mReferencedUniforms.find(name.c_str()) != mReferencedUniforms.end())
    285                     {
    286                         uniforms += "uniform " + typeString(type) + " " + decorate(name) + arrayString(type) + ";\n";
    287                     }
    288                 }
    289                 else if (qualifier == EvqAttribute)
    290                 {
    291                     if (mReferencedAttributes.find(name.c_str()) != mReferencedAttributes.end())
    292                     {
    293                         attributes += "static " + typeString(type) + " " + decorate(name) + arrayString(type) + " = " + initializer(type) + ";\n";
    294                     }
    295                 }
    296                 else if (qualifier == EvqVaryingOut || qualifier == EvqInvariantVaryingOut)
    297                 {
    298                     if (mReferencedVaryings.find(name.c_str()) != mReferencedVaryings.end())
    299                     {
    300                         // Program linking depends on this exact format
    301                         varyings += "static " + typeString(type) + " " + decorate(name) + arrayString(type) + " = " + initializer(type) + ";\n";
    302                     }
    303                 }
    304                 else if (qualifier == EvqGlobal || qualifier == EvqTemporary)
    305                 {
    306                     // Globals are declared and intialized as an aggregate node
    307                 }
    308                 else if (qualifier == EvqConst)
    309                 {
    310                     // Constants are repeated as literals where used
    311                 }
    312                 else UNREACHABLE();
    313             }
    314         }
    315 
    316         out << "// Attributes\n";
    317         out <<  attributes;
    318         out << "\n"
    319                "static float4 gl_Position = float4(0, 0, 0, 0);\n";
    320 
    321         if (mUsesPointSize)
    322         {
    323             out << "static float gl_PointSize = float(1);\n";
    324         }
    325 
    326         out << "\n"
    327                "// Varyings\n";
    328         out <<  varyings;
    329         out << "\n"
    330                "uniform float2 dx_HalfPixelSize;\n"
    331                "\n";
    332         out <<  uniforms;
    333         out << "\n";
    334     }
    335 
    336     if (mUsesFragCoord)
    337     {
    338         out << "#define GL_USES_FRAG_COORD\n";
    339     }
    340 
    341     if (mUsesPointCoord)
    342     {
    343         out << "#define GL_USES_POINT_COORD\n";
    344     }
    345 
    346     if (mUsesFrontFacing)
    347     {
    348         out << "#define GL_USES_FRONT_FACING\n";
    349     }
    350 
    351     if (mUsesPointSize)
    352     {
    353         out << "#define GL_USES_POINT_SIZE\n";
    354     }
    355 
    356     if (mUsesDepthRange)
    357     {
    358         out << "struct gl_DepthRangeParameters\n"
    359                "{\n"
    360                "    float near;\n"
    361                "    float far;\n"
    362                "    float diff;\n"
    363                "};\n"
    364                "\n"
    365                "uniform float3 dx_DepthRange;"
    366                "static gl_DepthRangeParameters gl_DepthRange = {dx_DepthRange.x, dx_DepthRange.y, dx_DepthRange.z};\n"
    367                "\n";
    368     }
    369 
    370     if (mUsesXor)
    371     {
    372         out << "bool xor(bool p, bool q)\n"
    373                "{\n"
    374                "    return (p || q) && !(p && q);\n"
    375                "}\n"
    376                "\n";
    377     }
    378 
    379     if (mUsesMod1)
    380     {
    381         out << "float mod(float x, float y)\n"
    382                "{\n"
    383                "    return x - y * floor(x / y);\n"
    384                "}\n"
    385                "\n";
    386     }
    387 
    388     if (mUsesMod2)
    389     {
    390         out << "float2 mod(float2 x, float y)\n"
    391                "{\n"
    392                "    return x - y * floor(x / y);\n"
    393                "}\n"
    394                "\n";
    395     }
    396 
    397     if (mUsesMod3)
    398     {
    399         out << "float3 mod(float3 x, float y)\n"
    400                "{\n"
    401                "    return x - y * floor(x / y);\n"
    402                "}\n"
    403                "\n";
    404     }
    405 
    406     if (mUsesMod4)
    407     {
    408         out << "float4 mod(float4 x, float y)\n"
    409                "{\n"
    410                "    return x - y * floor(x / y);\n"
    411                "}\n"
    412                "\n";
    413     }
    414 
    415     if (mUsesFaceforward1)
    416     {
    417         out << "float faceforward(float N, float I, float Nref)\n"
    418                "{\n"
    419                "    if(dot(Nref, I) >= 0)\n"
    420                "    {\n"
    421                "        return -N;\n"
    422                "    }\n"
    423                "    else\n"
    424                "    {\n"
    425                "        return N;\n"
    426                "    }\n"
    427                "}\n"
    428                "\n";
    429     }
    430 
    431     if (mUsesFaceforward2)
    432     {
    433         out << "float2 faceforward(float2 N, float2 I, float2 Nref)\n"
    434                "{\n"
    435                "    if(dot(Nref, I) >= 0)\n"
    436                "    {\n"
    437                "        return -N;\n"
    438                "    }\n"
    439                "    else\n"
    440                "    {\n"
    441                "        return N;\n"
    442                "    }\n"
    443                "}\n"
    444                "\n";
    445     }
    446 
    447     if (mUsesFaceforward3)
    448     {
    449         out << "float3 faceforward(float3 N, float3 I, float3 Nref)\n"
    450                "{\n"
    451                "    if(dot(Nref, I) >= 0)\n"
    452                "    {\n"
    453                "        return -N;\n"
    454                "    }\n"
    455                "    else\n"
    456                "    {\n"
    457                "        return N;\n"
    458                "    }\n"
    459                "}\n"
    460                "\n";
    461     }
    462 
    463     if (mUsesFaceforward4)
    464     {
    465         out << "float4 faceforward(float4 N, float4 I, float4 Nref)\n"
    466                "{\n"
    467                "    if(dot(Nref, I) >= 0)\n"
    468                "    {\n"
    469                "        return -N;\n"
    470                "    }\n"
    471                "    else\n"
    472                "    {\n"
    473                "        return N;\n"
    474                "    }\n"
    475                "}\n"
    476                "\n";
    477     }
    478 
    479     if (mUsesEqualMat2)
    480     {
    481         out << "bool equal(float2x2 m, float2x2 n)\n"
    482                "{\n"
    483                "    return m[0][0] == n[0][0] && m[0][1] == n[0][1] &&\n"
    484                "           m[1][0] == n[1][0] && m[1][1] == n[1][1];\n"
    485                "}\n";
    486     }
    487 
    488     if (mUsesEqualMat3)
    489     {
    490         out << "bool equal(float3x3 m, float3x3 n)\n"
    491                "{\n"
    492                "    return m[0][0] == n[0][0] && m[0][1] == n[0][1] && m[0][2] == n[0][2] &&\n"
    493                "           m[1][0] == n[1][0] && m[1][1] == n[1][1] && m[1][2] == n[1][2] &&\n"
    494                "           m[2][0] == n[2][0] && m[2][1] == n[2][1] && m[2][2] == n[2][2];\n"
    495                "}\n";
    496     }
    497 
    498     if (mUsesEqualMat4)
    499     {
    500         out << "bool equal(float4x4 m, float4x4 n)\n"
    501                "{\n"
    502                "    return m[0][0] == n[0][0] && m[0][1] == n[0][1] && m[0][2] == n[0][2] && m[0][3] == n[0][3] &&\n"
    503                "           m[1][0] == n[1][0] && m[1][1] == n[1][1] && m[1][2] == n[1][2] && m[1][3] == n[1][3] &&\n"
    504                "           m[2][0] == n[2][0] && m[2][1] == n[2][1] && m[2][2] == n[2][2] && m[2][3] == n[2][3] &&\n"
    505                "           m[3][0] == n[3][0] && m[3][1] == n[3][1] && m[3][2] == n[3][2] && m[3][3] == n[3][3];\n"
    506                "}\n";
    507     }
    508 
    509     if (mUsesEqualVec2)
    510     {
    511         out << "bool equal(float2 v, float2 u)\n"
    512                "{\n"
    513                "    return v.x == u.x && v.y == u.y;\n"
    514                "}\n";
    515     }
    516 
    517     if (mUsesEqualVec3)
    518     {
    519         out << "bool equal(float3 v, float3 u)\n"
    520                "{\n"
    521                "    return v.x == u.x && v.y == u.y && v.z == u.z;\n"
    522                "}\n";
    523     }
    524 
    525     if (mUsesEqualVec4)
    526     {
    527         out << "bool equal(float4 v, float4 u)\n"
    528                "{\n"
    529                "    return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;\n"
    530                "}\n";
    531     }
    532 
    533     if (mUsesEqualIVec2)
    534     {
    535         out << "bool equal(int2 v, int2 u)\n"
    536                "{\n"
    537                "    return v.x == u.x && v.y == u.y;\n"
    538                "}\n";
    539     }
    540 
    541     if (mUsesEqualIVec3)
    542     {
    543         out << "bool equal(int3 v, int3 u)\n"
    544                "{\n"
    545                "    return v.x == u.x && v.y == u.y && v.z == u.z;\n"
    546                "}\n";
    547     }
    548 
    549     if (mUsesEqualIVec4)
    550     {
    551         out << "bool equal(int4 v, int4 u)\n"
    552                "{\n"
    553                "    return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;\n"
    554                "}\n";
    555     }
    556 
    557     if (mUsesEqualBVec2)
    558     {
    559         out << "bool equal(bool2 v, bool2 u)\n"
    560                "{\n"
    561                "    return v.x == u.x && v.y == u.y;\n"
    562                "}\n";
    563     }
    564 
    565     if (mUsesEqualBVec3)
    566     {
    567         out << "bool equal(bool3 v, bool3 u)\n"
    568                "{\n"
    569                "    return v.x == u.x && v.y == u.y && v.z == u.z;\n"
    570                "}\n";
    571     }
    572 
    573     if (mUsesEqualBVec4)
    574     {
    575         out << "bool equal(bool4 v, bool4 u)\n"
    576                "{\n"
    577                "    return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;\n"
    578                "}\n";
    579     }
    580 
    581     if (mUsesAtan2)
    582     {
    583         out << "float atanyx(float y, float x)\n"
    584                "{\n"
    585                "    if(x == 0 && y == 0) x = 1;\n"   // Avoid producing a NaN
    586                "    return atan2(y, x);\n"
    587                "}\n";
    588     }
    589 }
    590 
    591 void OutputHLSL::visitSymbol(TIntermSymbol *node)
    592 {
    593     TInfoSinkBase &out = mBody;
    594 
    595     TString name = node->getSymbol();
    596 
    597     if (name == "gl_FragColor")
    598     {
    599         out << "gl_Color[0]";
    600     }
    601     else if (name == "gl_FragData")
    602     {
    603         out << "gl_Color";
    604     }
    605     else if (name == "gl_DepthRange")
    606     {
    607         mUsesDepthRange = true;
    608         out << name;
    609     }
    610     else if (name == "gl_FragCoord")
    611     {
    612         mUsesFragCoord = true;
    613         out << name;
    614     }
    615     else if (name == "gl_PointCoord")
    616     {
    617         mUsesPointCoord = true;
    618         out << name;
    619     }
    620     else if (name == "gl_FrontFacing")
    621     {
    622         mUsesFrontFacing = true;
    623         out << name;
    624     }
    625     else if (name == "gl_PointSize")
    626     {
    627         mUsesPointSize = true;
    628         out << name;
    629     }
    630     else
    631     {
    632         TQualifier qualifier = node->getQualifier();
    633 
    634         if (qualifier == EvqUniform)
    635         {
    636             mReferencedUniforms.insert(name.c_str());
    637         }
    638         else if (qualifier == EvqAttribute)
    639         {
    640             mReferencedAttributes.insert(name.c_str());
    641         }
    642         else if (qualifier == EvqVaryingOut || qualifier == EvqInvariantVaryingOut || qualifier == EvqVaryingIn || qualifier == EvqInvariantVaryingIn)
    643         {
    644             mReferencedVaryings.insert(name.c_str());
    645         }
    646 
    647         out << decorate(name);
    648     }
    649 }
    650 
    651 bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
    652 {
    653     TInfoSinkBase &out = mBody;
    654 
    655     switch (node->getOp())
    656     {
    657       case EOpAssign:                  outputTriplet(visit, "(", " = ", ")");           break;
    658       case EOpInitialize:
    659         if (visit == PreVisit)
    660         {
    661             // GLSL allows to write things like "float x = x;" where a new variable x is defined
    662             // and the value of an existing variable x is assigned. HLSL uses C semantics (the
    663             // new variable is created before the assignment is evaluated), so we need to convert
    664             // this to "float t = x, x = t;".
    665 
    666             TIntermSymbol *symbolNode = node->getLeft()->getAsSymbolNode();
    667             TIntermTyped *expression = node->getRight();
    668 
    669             sh::SearchSymbol searchSymbol(symbolNode->getSymbol());
    670             expression->traverse(&searchSymbol);
    671             bool sameSymbol = searchSymbol.foundMatch();
    672 
    673             if (sameSymbol)
    674             {
    675                 // Type already printed
    676                 out << "t" + str(mUniqueIndex) + " = ";
    677                 expression->traverse(this);
    678                 out << ", ";
    679                 symbolNode->traverse(this);
    680                 out << " = t" + str(mUniqueIndex);
    681 
    682                 mUniqueIndex++;
    683                 return false;
    684             }
    685         }
    686         else if (visit == InVisit)
    687         {
    688             out << " = ";
    689         }
    690         break;
    691       case EOpAddAssign:               outputTriplet(visit, "(", " += ", ")");          break;
    692       case EOpSubAssign:               outputTriplet(visit, "(", " -= ", ")");          break;
    693       case EOpMulAssign:               outputTriplet(visit, "(", " *= ", ")");          break;
    694       case EOpVectorTimesScalarAssign: outputTriplet(visit, "(", " *= ", ")");          break;
    695       case EOpMatrixTimesScalarAssign: outputTriplet(visit, "(", " *= ", ")");          break;
    696       case EOpVectorTimesMatrixAssign:
    697         if (visit == PreVisit)
    698         {
    699             out << "(";
    700         }
    701         else if (visit == InVisit)
    702         {
    703             out << " = mul(";
    704             node->getLeft()->traverse(this);
    705             out << ", transpose(";
    706         }
    707         else
    708         {
    709             out << ")))";
    710         }
    711         break;
    712       case EOpMatrixTimesMatrixAssign:
    713         if (visit == PreVisit)
    714         {
    715             out << "(";
    716         }
    717         else if (visit == InVisit)
    718         {
    719             out << " = mul(";
    720             node->getLeft()->traverse(this);
    721             out << ", ";
    722         }
    723         else
    724         {
    725             out << "))";
    726         }
    727         break;
    728       case EOpDivAssign:               outputTriplet(visit, "(", " /= ", ")");          break;
    729       case EOpIndexDirect:             outputTriplet(visit, "", "[", "]");              break;
    730       case EOpIndexIndirect:           outputTriplet(visit, "", "[", "]");              break;
    731       case EOpIndexDirectStruct:
    732         if (visit == InVisit)
    733         {
    734             out << "." + node->getType().getFieldName();
    735 
    736             return false;
    737         }
    738         break;
    739       case EOpVectorSwizzle:
    740         if (visit == InVisit)
    741         {
    742             out << ".";
    743 
    744             TIntermAggregate *swizzle = node->getRight()->getAsAggregate();
    745 
    746             if (swizzle)
    747             {
    748                 TIntermSequence &sequence = swizzle->getSequence();
    749 
    750                 for (TIntermSequence::iterator sit = sequence.begin(); sit != sequence.end(); sit++)
    751                 {
    752                     TIntermConstantUnion *element = (*sit)->getAsConstantUnion();
    753 
    754                     if (element)
    755                     {
    756                         int i = element->getUnionArrayPointer()[0].getIConst();
    757 
    758                         switch (i)
    759                         {
    760                         case 0: out << "x"; break;
    761                         case 1: out << "y"; break;
    762                         case 2: out << "z"; break;
    763                         case 3: out << "w"; break;
    764                         default: UNREACHABLE();
    765                         }
    766                     }
    767                     else UNREACHABLE();
    768                 }
    769             }
    770             else UNREACHABLE();
    771 
    772             return false;   // Fully processed
    773         }
    774         break;
    775       case EOpAdd:               outputTriplet(visit, "(", " + ", ")"); break;
    776       case EOpSub:               outputTriplet(visit, "(", " - ", ")"); break;
    777       case EOpMul:               outputTriplet(visit, "(", " * ", ")"); break;
    778       case EOpDiv:               outputTriplet(visit, "(", " / ", ")"); break;
    779       case EOpEqual:
    780       case EOpNotEqual:
    781         if (node->getLeft()->isScalar())
    782         {
    783             if (node->getOp() == EOpEqual)
    784             {
    785                 outputTriplet(visit, "(", " == ", ")");
    786             }
    787             else
    788             {
    789                 outputTriplet(visit, "(", " != ", ")");
    790             }
    791         }
    792         else if (node->getLeft()->getBasicType() == EbtStruct)
    793         {
    794             if (node->getOp() == EOpEqual)
    795             {
    796                 out << "(";
    797             }
    798             else
    799             {
    800                 out << "!(";
    801             }
    802 
    803             const TTypeList *fields = node->getLeft()->getType().getStruct();
    804 
    805             for (size_t i = 0; i < fields->size(); i++)
    806             {
    807                 const TType *fieldType = (*fields)[i].type;
    808 
    809                 node->getLeft()->traverse(this);
    810                 out << "." + fieldType->getFieldName() + " == ";
    811                 node->getRight()->traverse(this);
    812                 out << "." + fieldType->getFieldName();
    813 
    814                 if (i < fields->size() - 1)
    815                 {
    816                     out << " && ";
    817                 }
    818             }
    819 
    820             out << ")";
    821 
    822             return false;
    823         }
    824         else
    825         {
    826             if (node->getLeft()->isMatrix())
    827             {
    828                 switch (node->getLeft()->getNominalSize())
    829                 {
    830                   case 2: mUsesEqualMat2 = true; break;
    831                   case 3: mUsesEqualMat3 = true; break;
    832                   case 4: mUsesEqualMat4 = true; break;
    833                   default: UNREACHABLE();
    834                 }
    835             }
    836             else if (node->getLeft()->isVector())
    837             {
    838                 switch (node->getLeft()->getBasicType())
    839                 {
    840                   case EbtFloat:
    841                     switch (node->getLeft()->getNominalSize())
    842                     {
    843                       case 2: mUsesEqualVec2 = true; break;
    844                       case 3: mUsesEqualVec3 = true; break;
    845                       case 4: mUsesEqualVec4 = true; break;
    846                       default: UNREACHABLE();
    847                     }
    848                     break;
    849                   case EbtInt:
    850                     switch (node->getLeft()->getNominalSize())
    851                     {
    852                       case 2: mUsesEqualIVec2 = true; break;
    853                       case 3: mUsesEqualIVec3 = true; break;
    854                       case 4: mUsesEqualIVec4 = true; break;
    855                       default: UNREACHABLE();
    856                     }
    857                     break;
    858                   case EbtBool:
    859                     switch (node->getLeft()->getNominalSize())
    860                     {
    861                       case 2: mUsesEqualBVec2 = true; break;
    862                       case 3: mUsesEqualBVec3 = true; break;
    863                       case 4: mUsesEqualBVec4 = true; break;
    864                       default: UNREACHABLE();
    865                     }
    866                     break;
    867                   default: UNREACHABLE();
    868                 }
    869             }
    870             else UNREACHABLE();
    871 
    872             if (node->getOp() == EOpEqual)
    873             {
    874                 outputTriplet(visit, "equal(", ", ", ")");
    875             }
    876             else
    877             {
    878                 outputTriplet(visit, "!equal(", ", ", ")");
    879             }
    880         }
    881         break;
    882       case EOpLessThan:          outputTriplet(visit, "(", " < ", ")");   break;
    883       case EOpGreaterThan:       outputTriplet(visit, "(", " > ", ")");   break;
    884       case EOpLessThanEqual:     outputTriplet(visit, "(", " <= ", ")");  break;
    885       case EOpGreaterThanEqual:  outputTriplet(visit, "(", " >= ", ")");  break;
    886       case EOpVectorTimesScalar: outputTriplet(visit, "(", " * ", ")");   break;
    887       case EOpMatrixTimesScalar: outputTriplet(visit, "(", " * ", ")");   break;
    888       case EOpVectorTimesMatrix: outputTriplet(visit, "mul(", ", transpose(", "))"); break;
    889       case EOpMatrixTimesVector: outputTriplet(visit, "mul(transpose(", "), ", ")"); break;
    890       case EOpMatrixTimesMatrix: outputTriplet(visit, "transpose(mul(transpose(", "), transpose(", ")))"); break;
    891       case EOpLogicalOr:         outputTriplet(visit, "(", " || ", ")");  break;
    892       case EOpLogicalXor:
    893         mUsesXor = true;
    894         outputTriplet(visit, "xor(", ", ", ")");
    895         break;
    896       case EOpLogicalAnd:        outputTriplet(visit, "(", " && ", ")");  break;
    897       default: UNREACHABLE();
    898     }
    899 
    900     return true;
    901 }
    902 
    903 bool OutputHLSL::visitUnary(Visit visit, TIntermUnary *node)
    904 {
    905     TInfoSinkBase &out = mBody;
    906 
    907     switch (node->getOp())
    908     {
    909       case EOpNegative:         outputTriplet(visit, "(-", "", ")");  break;
    910       case EOpVectorLogicalNot: outputTriplet(visit, "(!", "", ")");  break;
    911       case EOpLogicalNot:       outputTriplet(visit, "(!", "", ")");  break;
    912       case EOpPostIncrement:    outputTriplet(visit, "(", "", "++)"); break;
    913       case EOpPostDecrement:    outputTriplet(visit, "(", "", "--)"); break;
    914       case EOpPreIncrement:     outputTriplet(visit, "(++", "", ")"); break;
    915       case EOpPreDecrement:     outputTriplet(visit, "(--", "", ")"); break;
    916       case EOpConvIntToBool:
    917       case EOpConvFloatToBool:
    918         switch (node->getOperand()->getType().getNominalSize())
    919         {
    920           case 1:    outputTriplet(visit, "bool(", "", ")");  break;
    921           case 2:    outputTriplet(visit, "bool2(", "", ")"); break;
    922           case 3:    outputTriplet(visit, "bool3(", "", ")"); break;
    923           case 4:    outputTriplet(visit, "bool4(", "", ")"); break;
    924           default: UNREACHABLE();
    925         }
    926         break;
    927       case EOpConvBoolToFloat:
    928       case EOpConvIntToFloat:
    929         switch (node->getOperand()->getType().getNominalSize())
    930         {
    931           case 1:    outputTriplet(visit, "float(", "", ")");  break;
    932           case 2:    outputTriplet(visit, "float2(", "", ")"); break;
    933           case 3:    outputTriplet(visit, "float3(", "", ")"); break;
    934           case 4:    outputTriplet(visit, "float4(", "", ")"); break;
    935           default: UNREACHABLE();
    936         }
    937         break;
    938       case EOpConvFloatToInt:
    939       case EOpConvBoolToInt:
    940         switch (node->getOperand()->getType().getNominalSize())
    941         {
    942           case 1:    outputTriplet(visit, "int(", "", ")");  break;
    943           case 2:    outputTriplet(visit, "int2(", "", ")"); break;
    944           case 3:    outputTriplet(visit, "int3(", "", ")"); break;
    945           case 4:    outputTriplet(visit, "int4(", "", ")"); break;
    946           default: UNREACHABLE();
    947         }
    948         break;
    949       case EOpRadians:          outputTriplet(visit, "radians(", "", ")");   break;
    950       case EOpDegrees:          outputTriplet(visit, "degrees(", "", ")");   break;
    951       case EOpSin:              outputTriplet(visit, "sin(", "", ")");       break;
    952       case EOpCos:              outputTriplet(visit, "cos(", "", ")");       break;
    953       case EOpTan:              outputTriplet(visit, "tan(", "", ")");       break;
    954       case EOpAsin:             outputTriplet(visit, "asin(", "", ")");      break;
    955       case EOpAcos:             outputTriplet(visit, "acos(", "", ")");      break;
    956       case EOpAtan:             outputTriplet(visit, "atan(", "", ")");      break;
    957       case EOpExp:              outputTriplet(visit, "exp(", "", ")");       break;
    958       case EOpLog:              outputTriplet(visit, "log(", "", ")");       break;
    959       case EOpExp2:             outputTriplet(visit, "exp2(", "", ")");      break;
    960       case EOpLog2:             outputTriplet(visit, "log2(", "", ")");      break;
    961       case EOpSqrt:             outputTriplet(visit, "sqrt(", "", ")");      break;
    962       case EOpInverseSqrt:      outputTriplet(visit, "rsqrt(", "", ")");     break;
    963       case EOpAbs:              outputTriplet(visit, "abs(", "", ")");       break;
    964       case EOpSign:             outputTriplet(visit, "sign(", "", ")");      break;
    965       case EOpFloor:            outputTriplet(visit, "floor(", "", ")");     break;
    966       case EOpCeil:             outputTriplet(visit, "ceil(", "", ")");      break;
    967       case EOpFract:            outputTriplet(visit, "frac(", "", ")");      break;
    968       case EOpLength:           outputTriplet(visit, "length(", "", ")");    break;
    969       case EOpNormalize:        outputTriplet(visit, "normalize(", "", ")"); break;
    970       case EOpDFdx:             outputTriplet(visit, "ddx(", "", ")");       break;
    971       case EOpDFdy:             outputTriplet(visit, "ddy(", "", ")");       break;
    972       case EOpFwidth:           outputTriplet(visit, "fwidth(", "", ")");    break;
    973       case EOpAny:              outputTriplet(visit, "any(", "", ")");       break;
    974       case EOpAll:              outputTriplet(visit, "all(", "", ")");       break;
    975       default: UNREACHABLE();
    976     }
    977 
    978     return true;
    979 }
    980 
    981 bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
    982 {
    983     ShShaderType shaderType = mContext.shaderType;
    984     TInfoSinkBase &out = mBody;
    985 
    986     switch (node->getOp())
    987     {
    988       case EOpSequence:
    989         {
    990             if (mInsideFunction)
    991             {
    992                 out << "{\n";
    993 
    994                 mScopeDepth++;
    995 
    996                 if (mScopeBracket.size() < mScopeDepth)
    997                 {
    998                     mScopeBracket.push_back(0);   // New scope level
    999                 }
   1000                 else
   1001                 {
   1002                     mScopeBracket[mScopeDepth - 1]++;   // New scope at existing level
   1003                 }
   1004             }
   1005 
   1006             for (TIntermSequence::iterator sit = node->getSequence().begin(); sit != node->getSequence().end(); sit++)
   1007             {
   1008                 if (isSingleStatement(*sit))
   1009                 {
   1010                     mUnfoldSelect->traverse(*sit);
   1011                 }
   1012 
   1013                 (*sit)->traverse(this);
   1014 
   1015                 out << ";\n";
   1016             }
   1017 
   1018             if (mInsideFunction)
   1019             {
   1020                 out << "}\n";
   1021 
   1022                 mScopeDepth--;
   1023             }
   1024 
   1025             return false;
   1026         }
   1027       case EOpDeclaration:
   1028         if (visit == PreVisit)
   1029         {
   1030             TIntermSequence &sequence = node->getSequence();
   1031             TIntermTyped *variable = sequence[0]->getAsTyped();
   1032             bool visit = true;
   1033 
   1034             if (variable && (variable->getQualifier() == EvqTemporary || variable->getQualifier() == EvqGlobal))
   1035             {
   1036                 if (variable->getType().getStruct())
   1037                 {
   1038                     addConstructor(variable->getType(), scopedStruct(variable->getType().getTypeName()), NULL);
   1039                 }
   1040 
   1041                 if (!variable->getAsSymbolNode() || variable->getAsSymbolNode()->getSymbol() != "")   // Variable declaration
   1042                 {
   1043                     if (!mInsideFunction)
   1044                     {
   1045                         out << "static ";
   1046                     }
   1047 
   1048                     out << typeString(variable->getType()) + " ";
   1049 
   1050                     for (TIntermSequence::iterator sit = sequence.begin(); sit != sequence.end(); sit++)
   1051                     {
   1052                         TIntermSymbol *symbol = (*sit)->getAsSymbolNode();
   1053 
   1054                         if (symbol)
   1055                         {
   1056                             symbol->traverse(this);
   1057                             out << arrayString(symbol->getType());
   1058                             out << " = " + initializer(variable->getType());
   1059                         }
   1060                         else
   1061                         {
   1062                             (*sit)->traverse(this);
   1063                         }
   1064 
   1065                         if (visit && this->inVisit)
   1066                         {
   1067                             if (*sit != sequence.back())
   1068                             {
   1069                                 visit = this->visitAggregate(InVisit, node);
   1070                             }
   1071                         }
   1072                     }
   1073 
   1074                     if (visit && this->postVisit)
   1075                     {
   1076                         this->visitAggregate(PostVisit, node);
   1077                     }
   1078                 }
   1079                 else if (variable->getAsSymbolNode() && variable->getAsSymbolNode()->getSymbol() == "")   // Type (struct) declaration
   1080                 {
   1081                     // Already added to constructor map
   1082                 }
   1083                 else UNREACHABLE();
   1084             }
   1085 
   1086             return false;
   1087         }
   1088         else if (visit == InVisit)
   1089         {
   1090             out << ", ";
   1091         }
   1092         break;
   1093       case EOpPrototype:
   1094         if (visit == PreVisit)
   1095         {
   1096             out << typeString(node->getType()) << " " << decorate(node->getName()) << "(";
   1097 
   1098             TIntermSequence &arguments = node->getSequence();
   1099 
   1100             for (unsigned int i = 0; i < arguments.size(); i++)
   1101             {
   1102                 TIntermSymbol *symbol = arguments[i]->getAsSymbolNode();
   1103 
   1104                 if (symbol)
   1105                 {
   1106                     out << argumentString(symbol);
   1107 
   1108                     if (i < arguments.size() - 1)
   1109                     {
   1110                         out << ", ";
   1111                     }
   1112                 }
   1113                 else UNREACHABLE();
   1114             }
   1115 
   1116             out << ");\n";
   1117 
   1118             return false;
   1119         }
   1120         break;
   1121       case EOpComma:            outputTriplet(visit, "", ", ", "");                break;
   1122       case EOpFunction:
   1123         {
   1124             TString name = TFunction::unmangleName(node->getName());
   1125 
   1126             if (visit == PreVisit)
   1127             {
   1128                 out << typeString(node->getType()) << " ";
   1129 
   1130                 if (name == "main")
   1131                 {
   1132                     out << "gl_main(";
   1133                 }
   1134                 else
   1135                 {
   1136                     out << decorate(name) << "(";
   1137                 }
   1138 
   1139                 TIntermSequence &sequence = node->getSequence();
   1140                 TIntermSequence &arguments = sequence[0]->getAsAggregate()->getSequence();
   1141 
   1142                 for (unsigned int i = 0; i < arguments.size(); i++)
   1143                 {
   1144                     TIntermSymbol *symbol = arguments[i]->getAsSymbolNode();
   1145 
   1146                     if (symbol)
   1147                     {
   1148                         out << argumentString(symbol);
   1149 
   1150                         if (i < arguments.size() - 1)
   1151                         {
   1152                             out << ", ";
   1153                         }
   1154                     }
   1155                     else UNREACHABLE();
   1156                 }
   1157 
   1158                 sequence.erase(sequence.begin());
   1159 
   1160                 out << ")\n"
   1161                        "{\n";
   1162 
   1163                 mInsideFunction = true;
   1164             }
   1165             else if (visit == PostVisit)
   1166             {
   1167                 out << "}\n";
   1168 
   1169                 mInsideFunction = false;
   1170             }
   1171         }
   1172         break;
   1173       case EOpFunctionCall:
   1174         {
   1175             if (visit == PreVisit)
   1176             {
   1177                 TString name = TFunction::unmangleName(node->getName());
   1178 
   1179                 if (node->isUserDefined())
   1180                 {
   1181                     out << decorate(name) << "(";
   1182                 }
   1183                 else
   1184                 {
   1185                     if (name == "texture2D")
   1186                     {
   1187                         if (node->getSequence().size() == 2)
   1188                         {
   1189                             mUsesTexture2D = true;
   1190                         }
   1191                         else if (node->getSequence().size() == 3)
   1192                         {
   1193                             mUsesTexture2D_bias = true;
   1194                         }
   1195                         else UNREACHABLE();
   1196 
   1197                         out << "gl_texture2D(";
   1198                     }
   1199                     else if (name == "texture2DProj")
   1200                     {
   1201                         if (node->getSequence().size() == 2)
   1202                         {
   1203                             mUsesTexture2DProj = true;
   1204                         }
   1205                         else if (node->getSequence().size() == 3)
   1206                         {
   1207                             mUsesTexture2DProj_bias = true;
   1208                         }
   1209                         else UNREACHABLE();
   1210 
   1211                         out << "gl_texture2DProj(";
   1212                     }
   1213                     else if (name == "textureCube")
   1214                     {
   1215                         if (node->getSequence().size() == 2)
   1216                         {
   1217                             mUsesTextureCube = true;
   1218                         }
   1219                         else if (node->getSequence().size() == 3)
   1220                         {
   1221                             mUsesTextureCube_bias = true;
   1222                         }
   1223                         else UNREACHABLE();
   1224 
   1225                         out << "gl_textureCube(";
   1226                     }
   1227                     else if (name == "texture2DLod")
   1228                     {
   1229                         UNIMPLEMENTED();   // Requires the vertex shader texture sampling extension
   1230                     }
   1231                     else if (name == "texture2DProjLod")
   1232                     {
   1233                         UNIMPLEMENTED();   // Requires the vertex shader texture sampling extension
   1234                     }
   1235                     else if (name == "textureCubeLod")
   1236                     {
   1237                         UNIMPLEMENTED();   // Requires the vertex shader texture sampling extension
   1238                     }
   1239                     else UNREACHABLE();
   1240                 }
   1241             }
   1242             else if (visit == InVisit)
   1243             {
   1244                 out << ", ";
   1245             }
   1246             else
   1247             {
   1248                 out << ")";
   1249             }
   1250         }
   1251         break;
   1252       case EOpParameters:       outputTriplet(visit, "(", ", ", ")\n{\n");             break;
   1253       case EOpConstructFloat:
   1254         addConstructor(node->getType(), "vec1", &node->getSequence());
   1255         outputTriplet(visit, "vec1(", "", ")");
   1256         break;
   1257       case EOpConstructVec2:
   1258         addConstructor(node->getType(), "vec2", &node->getSequence());
   1259         outputTriplet(visit, "vec2(", ", ", ")");
   1260         break;
   1261       case EOpConstructVec3:
   1262         addConstructor(node->getType(), "vec3", &node->getSequence());
   1263         outputTriplet(visit, "vec3(", ", ", ")");
   1264         break;
   1265       case EOpConstructVec4:
   1266         addConstructor(node->getType(), "vec4", &node->getSequence());
   1267         outputTriplet(visit, "vec4(", ", ", ")");
   1268         break;
   1269       case EOpConstructBool:
   1270         addConstructor(node->getType(), "bvec1", &node->getSequence());
   1271         outputTriplet(visit, "bvec1(", "", ")");
   1272         break;
   1273       case EOpConstructBVec2:
   1274         addConstructor(node->getType(), "bvec2", &node->getSequence());
   1275         outputTriplet(visit, "bvec2(", ", ", ")");
   1276         break;
   1277       case EOpConstructBVec3:
   1278         addConstructor(node->getType(), "bvec3", &node->getSequence());
   1279         outputTriplet(visit, "bvec3(", ", ", ")");
   1280         break;
   1281       case EOpConstructBVec4:
   1282         addConstructor(node->getType(), "bvec4", &node->getSequence());
   1283         outputTriplet(visit, "bvec4(", ", ", ")");
   1284         break;
   1285       case EOpConstructInt:
   1286         addConstructor(node->getType(), "ivec1", &node->getSequence());
   1287         outputTriplet(visit, "ivec1(", "", ")");
   1288         break;
   1289       case EOpConstructIVec2:
   1290         addConstructor(node->getType(), "ivec2", &node->getSequence());
   1291         outputTriplet(visit, "ivec2(", ", ", ")");
   1292         break;
   1293       case EOpConstructIVec3:
   1294         addConstructor(node->getType(), "ivec3", &node->getSequence());
   1295         outputTriplet(visit, "ivec3(", ", ", ")");
   1296         break;
   1297       case EOpConstructIVec4:
   1298         addConstructor(node->getType(), "ivec4", &node->getSequence());
   1299         outputTriplet(visit, "ivec4(", ", ", ")");
   1300         break;
   1301       case EOpConstructMat2:
   1302         addConstructor(node->getType(), "mat2", &node->getSequence());
   1303         outputTriplet(visit, "mat2(", ", ", ")");
   1304         break;
   1305       case EOpConstructMat3:
   1306         addConstructor(node->getType(), "mat3", &node->getSequence());
   1307         outputTriplet(visit, "mat3(", ", ", ")");
   1308         break;
   1309       case EOpConstructMat4:
   1310         addConstructor(node->getType(), "mat4", &node->getSequence());
   1311         outputTriplet(visit, "mat4(", ", ", ")");
   1312         break;
   1313       case EOpConstructStruct:
   1314         addConstructor(node->getType(), scopedStruct(node->getType().getTypeName()), &node->getSequence());
   1315         outputTriplet(visit, structLookup(node->getType().getTypeName()) + "_ctor(", ", ", ")");
   1316         break;
   1317       case EOpLessThan:         outputTriplet(visit, "(", " < ", ")");                 break;
   1318       case EOpGreaterThan:      outputTriplet(visit, "(", " > ", ")");                 break;
   1319       case EOpLessThanEqual:    outputTriplet(visit, "(", " <= ", ")");                break;
   1320       case EOpGreaterThanEqual: outputTriplet(visit, "(", " >= ", ")");                break;
   1321       case EOpVectorEqual:      outputTriplet(visit, "(", " == ", ")");                break;
   1322       case EOpVectorNotEqual:   outputTriplet(visit, "(", " != ", ")");                break;
   1323       case EOpMod:
   1324         {
   1325             switch (node->getSequence()[0]->getAsTyped()->getNominalSize())   // Number of components in the first argument
   1326             {
   1327               case 1: mUsesMod1 = true; break;
   1328               case 2: mUsesMod2 = true; break;
   1329               case 3: mUsesMod3 = true; break;
   1330               case 4: mUsesMod4 = true; break;
   1331               default: UNREACHABLE();
   1332             }
   1333 
   1334             outputTriplet(visit, "mod(", ", ", ")");
   1335         }
   1336         break;
   1337       case EOpPow:              outputTriplet(visit, "pow(", ", ", ")");               break;
   1338       case EOpAtan:
   1339         ASSERT(node->getSequence().size() == 2);   // atan(x) is a unary operator
   1340         mUsesAtan2 = true;
   1341         outputTriplet(visit, "atanyx(", ", ", ")");
   1342         break;
   1343       case EOpMin:           outputTriplet(visit, "min(", ", ", ")");           break;
   1344       case EOpMax:           outputTriplet(visit, "max(", ", ", ")");           break;
   1345       case EOpClamp:         outputTriplet(visit, "clamp(", ", ", ")");         break;
   1346       case EOpMix:           outputTriplet(visit, "lerp(", ", ", ")");          break;
   1347       case EOpStep:          outputTriplet(visit, "step(", ", ", ")");          break;
   1348       case EOpSmoothStep:    outputTriplet(visit, "smoothstep(", ", ", ")");    break;
   1349       case EOpDistance:      outputTriplet(visit, "distance(", ", ", ")");      break;
   1350       case EOpDot:           outputTriplet(visit, "dot(", ", ", ")");           break;
   1351       case EOpCross:         outputTriplet(visit, "cross(", ", ", ")");         break;
   1352       case EOpFaceForward:
   1353         {
   1354             switch (node->getSequence()[0]->getAsTyped()->getNominalSize())   // Number of components in the first argument
   1355             {
   1356             case 1: mUsesFaceforward1 = true; break;
   1357             case 2: mUsesFaceforward2 = true; break;
   1358             case 3: mUsesFaceforward3 = true; break;
   1359             case 4: mUsesFaceforward4 = true; break;
   1360             default: UNREACHABLE();
   1361             }
   1362 
   1363             outputTriplet(visit, "faceforward(", ", ", ")");
   1364         }
   1365         break;
   1366       case EOpReflect:       outputTriplet(visit, "reflect(", ", ", ")");       break;
   1367       case EOpRefract:       outputTriplet(visit, "refract(", ", ", ")");       break;
   1368       case EOpMul:           outputTriplet(visit, "(", " * ", ")");             break;
   1369       default: UNREACHABLE();
   1370     }
   1371 
   1372     return true;
   1373 }
   1374 
   1375 bool OutputHLSL::visitSelection(Visit visit, TIntermSelection *node)
   1376 {
   1377     TInfoSinkBase &out = mBody;
   1378 
   1379     if (node->usesTernaryOperator())
   1380     {
   1381         out << "t" << mUnfoldSelect->getTemporaryIndex();
   1382     }
   1383     else  // if/else statement
   1384     {
   1385         mUnfoldSelect->traverse(node->getCondition());
   1386 
   1387         out << "if(";
   1388 
   1389         node->getCondition()->traverse(this);
   1390 
   1391         out << ")\n"
   1392                "{\n";
   1393 
   1394         if (node->getTrueBlock())
   1395         {
   1396             node->getTrueBlock()->traverse(this);
   1397         }
   1398 
   1399         out << ";}\n";
   1400 
   1401         if (node->getFalseBlock())
   1402         {
   1403             out << "else\n"
   1404                    "{\n";
   1405 
   1406             node->getFalseBlock()->traverse(this);
   1407 
   1408             out << ";}\n";
   1409         }
   1410     }
   1411 
   1412     return false;
   1413 }
   1414 
   1415 void OutputHLSL::visitConstantUnion(TIntermConstantUnion *node)
   1416 {
   1417     writeConstantUnion(node->getType(), node->getUnionArrayPointer());
   1418 }
   1419 
   1420 bool OutputHLSL::visitLoop(Visit visit, TIntermLoop *node)
   1421 {
   1422     if (handleExcessiveLoop(node))
   1423     {
   1424         return false;
   1425     }
   1426 
   1427     TInfoSinkBase &out = mBody;
   1428 
   1429     if (node->getType() == ELoopDoWhile)
   1430     {
   1431         out << "do\n"
   1432                "{\n";
   1433     }
   1434     else
   1435     {
   1436         if (node->getInit())
   1437         {
   1438             mUnfoldSelect->traverse(node->getInit());
   1439         }
   1440 
   1441         if (node->getCondition())
   1442         {
   1443             mUnfoldSelect->traverse(node->getCondition());
   1444         }
   1445 
   1446         if (node->getExpression())
   1447         {
   1448             mUnfoldSelect->traverse(node->getExpression());
   1449         }
   1450 
   1451         out << "for(";
   1452 
   1453         if (node->getInit())
   1454         {
   1455             node->getInit()->traverse(this);
   1456         }
   1457 
   1458         out << "; ";
   1459 
   1460         if (node->getCondition())
   1461         {
   1462             node->getCondition()->traverse(this);
   1463         }
   1464 
   1465         out << "; ";
   1466 
   1467         if (node->getExpression())
   1468         {
   1469             node->getExpression()->traverse(this);
   1470         }
   1471 
   1472         out << ")\n"
   1473                "{\n";
   1474     }
   1475 
   1476     if (node->getBody())
   1477     {
   1478         node->getBody()->traverse(this);
   1479     }
   1480 
   1481     out << "}\n";
   1482 
   1483     if (node->getType() == ELoopDoWhile)
   1484     {
   1485         out << "while(\n";
   1486 
   1487         node->getCondition()->traverse(this);
   1488 
   1489         out << ")";
   1490     }
   1491 
   1492     out << ";\n";
   1493 
   1494     return false;
   1495 }
   1496 
   1497 bool OutputHLSL::visitBranch(Visit visit, TIntermBranch *node)
   1498 {
   1499     TInfoSinkBase &out = mBody;
   1500 
   1501     switch (node->getFlowOp())
   1502     {
   1503       case EOpKill:     outputTriplet(visit, "discard", "", "");  break;
   1504       case EOpBreak:    outputTriplet(visit, "break", "", "");    break;
   1505       case EOpContinue: outputTriplet(visit, "continue", "", ""); break;
   1506       case EOpReturn:
   1507         if (visit == PreVisit)
   1508         {
   1509             if (node->getExpression())
   1510             {
   1511                 out << "return ";
   1512             }
   1513             else
   1514             {
   1515                 out << "return;\n";
   1516             }
   1517         }
   1518         else if (visit == PostVisit)
   1519         {
   1520             out << ";\n";
   1521         }
   1522         break;
   1523       default: UNREACHABLE();
   1524     }
   1525 
   1526     return true;
   1527 }
   1528 
   1529 bool OutputHLSL::isSingleStatement(TIntermNode *node)
   1530 {
   1531     TIntermAggregate *aggregate = node->getAsAggregate();
   1532 
   1533     if (aggregate)
   1534     {
   1535         if (aggregate->getOp() == EOpSequence)
   1536         {
   1537             return false;
   1538         }
   1539         else
   1540         {
   1541             for (TIntermSequence::iterator sit = aggregate->getSequence().begin(); sit != aggregate->getSequence().end(); sit++)
   1542             {
   1543                 if (!isSingleStatement(*sit))
   1544                 {
   1545                     return false;
   1546                 }
   1547             }
   1548 
   1549             return true;
   1550         }
   1551     }
   1552 
   1553     return true;
   1554 }
   1555 
   1556 // Handle loops with more than 255 iterations (unsupported by D3D9) by splitting them
   1557 bool OutputHLSL::handleExcessiveLoop(TIntermLoop *node)
   1558 {
   1559     TInfoSinkBase &out = mBody;
   1560 
   1561     // Parse loops of the form:
   1562     // for(int index = initial; index [comparator] limit; index += increment)
   1563     TIntermSymbol *index = NULL;
   1564     TOperator comparator = EOpNull;
   1565     int initial = 0;
   1566     int limit = 0;
   1567     int increment = 0;
   1568 
   1569     // Parse index name and intial value
   1570     if (node->getInit())
   1571     {
   1572         TIntermAggregate *init = node->getInit()->getAsAggregate();
   1573 
   1574         if (init)
   1575         {
   1576             TIntermSequence &sequence = init->getSequence();
   1577             TIntermTyped *variable = sequence[0]->getAsTyped();
   1578 
   1579             if (variable && variable->getQualifier() == EvqTemporary)
   1580             {
   1581                 TIntermBinary *assign = variable->getAsBinaryNode();
   1582 
   1583                 if (assign->getOp() == EOpInitialize)
   1584                 {
   1585                     TIntermSymbol *symbol = assign->getLeft()->getAsSymbolNode();
   1586                     TIntermConstantUnion *constant = assign->getRight()->getAsConstantUnion();
   1587 
   1588                     if (symbol && constant)
   1589                     {
   1590                         if (constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)
   1591                         {
   1592                             index = symbol;
   1593                             initial = constant->getUnionArrayPointer()[0].getIConst();
   1594                         }
   1595                     }
   1596                 }
   1597             }
   1598         }
   1599     }
   1600 
   1601     // Parse comparator and limit value
   1602     if (index != NULL && node->getCondition())
   1603     {
   1604         TIntermBinary *test = node->getCondition()->getAsBinaryNode();
   1605 
   1606         if (test && test->getLeft()->getAsSymbolNode()->getId() == index->getId())
   1607         {
   1608             TIntermConstantUnion *constant = test->getRight()->getAsConstantUnion();
   1609 
   1610             if (constant)
   1611             {
   1612                 if (constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)
   1613                 {
   1614                     comparator = test->getOp();
   1615                     limit = constant->getUnionArrayPointer()[0].getIConst();
   1616                 }
   1617             }
   1618         }
   1619     }
   1620 
   1621     // Parse increment
   1622     if (index != NULL && comparator != EOpNull && node->getExpression())
   1623     {
   1624         TIntermBinary *binaryTerminal = node->getExpression()->getAsBinaryNode();
   1625         TIntermUnary *unaryTerminal = node->getExpression()->getAsUnaryNode();
   1626 
   1627         if (binaryTerminal)
   1628         {
   1629             TOperator op = binaryTerminal->getOp();
   1630             TIntermConstantUnion *constant = binaryTerminal->getRight()->getAsConstantUnion();
   1631 
   1632             if (constant)
   1633             {
   1634                 if (constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)
   1635                 {
   1636                     int value = constant->getUnionArrayPointer()[0].getIConst();
   1637 
   1638                     switch (op)
   1639                     {
   1640                       case EOpAddAssign: increment = value;  break;
   1641                       case EOpSubAssign: increment = -value; break;
   1642                       default: UNIMPLEMENTED();
   1643                     }
   1644                 }
   1645             }
   1646         }
   1647         else if (unaryTerminal)
   1648         {
   1649             TOperator op = unaryTerminal->getOp();
   1650 
   1651             switch (op)
   1652             {
   1653               case EOpPostIncrement: increment = 1;  break;
   1654               case EOpPostDecrement: increment = -1; break;
   1655               case EOpPreIncrement:  increment = 1;  break;
   1656               case EOpPreDecrement:  increment = -1; break;
   1657               default: UNIMPLEMENTED();
   1658             }
   1659         }
   1660     }
   1661 
   1662     if (index != NULL && comparator != EOpNull && increment != 0)
   1663     {
   1664         if (comparator == EOpLessThanEqual)
   1665         {
   1666             comparator = EOpLessThan;
   1667             limit += 1;
   1668         }
   1669 
   1670         if (comparator == EOpLessThan)
   1671         {
   1672             int iterations = (limit - initial + 1) / increment;
   1673 
   1674             if (iterations <= 255)
   1675             {
   1676                 return false;   // Not an excessive loop
   1677             }
   1678 
   1679             while (iterations > 0)
   1680             {
   1681                 int remainder = (limit - initial + 1) % increment;
   1682                 int clampedLimit = initial + increment * std::min(255, iterations) - 1 - remainder;
   1683 
   1684                 // for(int index = initial; index < clampedLimit; index += increment)
   1685 
   1686                 out << "for(int ";
   1687                 index->traverse(this);
   1688                 out << " = ";
   1689                 out << initial;
   1690 
   1691                 out << "; ";
   1692                 index->traverse(this);
   1693                 out << " < ";
   1694                 out << clampedLimit;
   1695 
   1696                 out << "; ";
   1697                 index->traverse(this);
   1698                 out << " += ";
   1699                 out << increment;
   1700                 out << ")\n"
   1701                        "{\n";
   1702 
   1703                 if (node->getBody())
   1704                 {
   1705                     node->getBody()->traverse(this);
   1706                 }
   1707 
   1708                 out << "}\n";
   1709 
   1710                 initial += 255 * increment;
   1711                 iterations -= 255;
   1712             }
   1713 
   1714             return true;
   1715         }
   1716         else UNIMPLEMENTED();
   1717     }
   1718 
   1719     return false;   // Not handled as an excessive loop
   1720 }
   1721 
   1722 void OutputHLSL::outputTriplet(Visit visit, const TString &preString, const TString &inString, const TString &postString)
   1723 {
   1724     TInfoSinkBase &out = mBody;
   1725 
   1726     if (visit == PreVisit)
   1727     {
   1728         out << preString;
   1729     }
   1730     else if (visit == InVisit)
   1731     {
   1732         out << inString;
   1733     }
   1734     else if (visit == PostVisit)
   1735     {
   1736         out << postString;
   1737     }
   1738 }
   1739 
   1740 TString OutputHLSL::argumentString(const TIntermSymbol *symbol)
   1741 {
   1742     TQualifier qualifier = symbol->getQualifier();
   1743     const TType &type = symbol->getType();
   1744     TString name = symbol->getSymbol();
   1745 
   1746     if (name.empty())   // HLSL demands named arguments, also for prototypes
   1747     {
   1748         name = "x" + str(mUniqueIndex++);
   1749     }
   1750     else
   1751     {
   1752         name = decorate(name);
   1753     }
   1754 
   1755     return qualifierString(qualifier) + " " + typeString(type) + " " + name + arrayString(type);
   1756 }
   1757 
   1758 TString OutputHLSL::qualifierString(TQualifier qualifier)
   1759 {
   1760     switch(qualifier)
   1761     {
   1762       case EvqIn:            return "in";
   1763       case EvqOut:           return "out";
   1764       case EvqInOut:         return "inout";
   1765       case EvqConstReadOnly: return "const";
   1766       default: UNREACHABLE();
   1767     }
   1768 
   1769     return "";
   1770 }
   1771 
   1772 TString OutputHLSL::typeString(const TType &type)
   1773 {
   1774     if (type.getBasicType() == EbtStruct)
   1775     {
   1776         if (type.getTypeName() != "")
   1777         {
   1778             return structLookup(type.getTypeName());
   1779         }
   1780         else   // Nameless structure, define in place
   1781         {
   1782             const TTypeList &fields = *type.getStruct();
   1783 
   1784             TString string = "struct\n"
   1785                              "{\n";
   1786 
   1787             for (unsigned int i = 0; i < fields.size(); i++)
   1788             {
   1789                 const TType &field = *fields[i].type;
   1790 
   1791                 string += "    " + typeString(field) + " " + field.getFieldName() + arrayString(field) + ";\n";
   1792             }
   1793 
   1794             string += "} ";
   1795 
   1796             return string;
   1797         }
   1798     }
   1799     else if (type.isMatrix())
   1800     {
   1801         switch (type.getNominalSize())
   1802         {
   1803           case 2: return "float2x2";
   1804           case 3: return "float3x3";
   1805           case 4: return "float4x4";
   1806         }
   1807     }
   1808     else
   1809     {
   1810         switch (type.getBasicType())
   1811         {
   1812           case EbtFloat:
   1813             switch (type.getNominalSize())
   1814             {
   1815               case 1: return "float";
   1816               case 2: return "float2";
   1817               case 3: return "float3";
   1818               case 4: return "float4";
   1819             }
   1820           case EbtInt:
   1821             switch (type.getNominalSize())
   1822             {
   1823               case 1: return "int";
   1824               case 2: return "int2";
   1825               case 3: return "int3";
   1826               case 4: return "int4";
   1827             }
   1828           case EbtBool:
   1829             switch (type.getNominalSize())
   1830             {
   1831               case 1: return "bool";
   1832               case 2: return "bool2";
   1833               case 3: return "bool3";
   1834               case 4: return "bool4";
   1835             }
   1836           case EbtVoid:
   1837             return "void";
   1838           case EbtSampler2D:
   1839             return "sampler2D";
   1840           case EbtSamplerCube:
   1841             return "samplerCUBE";
   1842         }
   1843     }
   1844 
   1845     UNIMPLEMENTED();   // FIXME
   1846     return "<unknown type>";
   1847 }
   1848 
   1849 TString OutputHLSL::arrayString(const TType &type)
   1850 {
   1851     if (!type.isArray())
   1852     {
   1853         return "";
   1854     }
   1855 
   1856     return "[" + str(type.getArraySize()) + "]";
   1857 }
   1858 
   1859 TString OutputHLSL::initializer(const TType &type)
   1860 {
   1861     TString string;
   1862 
   1863     for (int component = 0; component < type.getObjectSize(); component++)
   1864     {
   1865         string += "0";
   1866 
   1867         if (component < type.getObjectSize() - 1)
   1868         {
   1869             string += ", ";
   1870         }
   1871     }
   1872 
   1873     return "{" + string + "}";
   1874 }
   1875 
   1876 void OutputHLSL::addConstructor(const TType &type, const TString &name, const TIntermSequence *parameters)
   1877 {
   1878     if (name == "")
   1879     {
   1880         return;   // Nameless structures don't have constructors
   1881     }
   1882 
   1883     TType ctorType = type;
   1884     ctorType.clearArrayness();
   1885     ctorType.setPrecision(EbpHigh);
   1886     ctorType.setQualifier(EvqTemporary);
   1887 
   1888     TString ctorName = type.getStruct() ? decorate(name) : name;
   1889 
   1890     typedef std::vector<TType> ParameterArray;
   1891     ParameterArray ctorParameters;
   1892 
   1893     if (parameters)
   1894     {
   1895         for (TIntermSequence::const_iterator parameter = parameters->begin(); parameter != parameters->end(); parameter++)
   1896         {
   1897             ctorParameters.push_back((*parameter)->getAsTyped()->getType());
   1898         }
   1899     }
   1900     else if (type.getStruct())
   1901     {
   1902         mStructNames.insert(decorate(name));
   1903 
   1904         TString structure;
   1905         structure += "struct " + decorate(name) + "\n"
   1906                      "{\n";
   1907 
   1908         const TTypeList &fields = *type.getStruct();
   1909 
   1910         for (unsigned int i = 0; i < fields.size(); i++)
   1911         {
   1912             const TType &field = *fields[i].type;
   1913 
   1914             structure += "    " + typeString(field) + " " + field.getFieldName() + arrayString(field) + ";\n";
   1915         }
   1916 
   1917         structure += "};\n";
   1918 
   1919         if (std::find(mStructDeclarations.begin(), mStructDeclarations.end(), structure) == mStructDeclarations.end())
   1920         {
   1921             mStructDeclarations.push_back(structure);
   1922         }
   1923 
   1924         for (unsigned int i = 0; i < fields.size(); i++)
   1925         {
   1926             ctorParameters.push_back(*fields[i].type);
   1927         }
   1928     }
   1929     else UNREACHABLE();
   1930 
   1931     TString constructor;
   1932 
   1933     if (ctorType.getStruct())
   1934     {
   1935         constructor += ctorName + " " + ctorName + "_ctor(";
   1936     }
   1937     else   // Built-in type
   1938     {
   1939         constructor += typeString(ctorType) + " " + ctorName + "(";
   1940     }
   1941 
   1942     for (unsigned int parameter = 0; parameter < ctorParameters.size(); parameter++)
   1943     {
   1944         const TType &type = ctorParameters[parameter];
   1945 
   1946         constructor += typeString(type) + " x" + str(parameter) + arrayString(type);
   1947 
   1948         if (parameter < ctorParameters.size() - 1)
   1949         {
   1950             constructor += ", ";
   1951         }
   1952     }
   1953 
   1954     constructor += ")\n"
   1955                    "{\n";
   1956 
   1957     if (ctorType.getStruct())
   1958     {
   1959         constructor += "    " + ctorName + " structure = {";
   1960     }
   1961     else
   1962     {
   1963         constructor += "    return " + typeString(ctorType) + "(";
   1964     }
   1965 
   1966     if (ctorType.isMatrix() && ctorParameters.size() == 1)
   1967     {
   1968         int dim = ctorType.getNominalSize();
   1969         const TType &parameter = ctorParameters[0];
   1970 
   1971         if (parameter.isScalar())
   1972         {
   1973             for (int row = 0; row < dim; row++)
   1974             {
   1975                 for (int col = 0; col < dim; col++)
   1976                 {
   1977                     constructor += TString((row == col) ? "x0" : "0.0");
   1978 
   1979                     if (row < dim - 1 || col < dim - 1)
   1980                     {
   1981                         constructor += ", ";
   1982                     }
   1983                 }
   1984             }
   1985         }
   1986         else if (parameter.isMatrix())
   1987         {
   1988             for (int row = 0; row < dim; row++)
   1989             {
   1990                 for (int col = 0; col < dim; col++)
   1991                 {
   1992                     if (row < parameter.getNominalSize() && col < parameter.getNominalSize())
   1993                     {
   1994                         constructor += TString("x0") + "[" + str(row) + "]" + "[" + str(col) + "]";
   1995                     }
   1996                     else
   1997                     {
   1998                         constructor += TString((row == col) ? "1.0" : "0.0");
   1999                     }
   2000 
   2001                     if (row < dim - 1 || col < dim - 1)
   2002                     {
   2003                         constructor += ", ";
   2004                     }
   2005                 }
   2006             }
   2007         }
   2008         else UNREACHABLE();
   2009     }
   2010     else
   2011     {
   2012         int remainingComponents = ctorType.getObjectSize();
   2013         int parameterIndex = 0;
   2014 
   2015         while (remainingComponents > 0)
   2016         {
   2017             const TType &parameter = ctorParameters[parameterIndex];
   2018             bool moreParameters = parameterIndex < (int)ctorParameters.size() - 1;
   2019 
   2020             constructor += "x" + str(parameterIndex);
   2021 
   2022             if (parameter.isScalar())
   2023             {
   2024                 remainingComponents -= parameter.getObjectSize();
   2025             }
   2026             else if (parameter.isVector())
   2027             {
   2028                 if (remainingComponents == parameter.getObjectSize() || moreParameters)
   2029                 {
   2030                     remainingComponents -= parameter.getObjectSize();
   2031                 }
   2032                 else if (remainingComponents < parameter.getNominalSize())
   2033                 {
   2034                     switch (remainingComponents)
   2035                     {
   2036                       case 1: constructor += ".x";    break;
   2037                       case 2: constructor += ".xy";   break;
   2038                       case 3: constructor += ".xyz";  break;
   2039                       case 4: constructor += ".xyzw"; break;
   2040                       default: UNREACHABLE();
   2041                     }
   2042 
   2043                     remainingComponents = 0;
   2044                 }
   2045                 else UNREACHABLE();
   2046             }
   2047             else if (parameter.isMatrix() || parameter.getStruct())
   2048             {
   2049                 ASSERT(remainingComponents == parameter.getObjectSize() || moreParameters);
   2050 
   2051                 remainingComponents -= parameter.getObjectSize();
   2052             }
   2053             else UNREACHABLE();
   2054 
   2055             if (moreParameters)
   2056             {
   2057                 parameterIndex++;
   2058             }
   2059 
   2060             if (remainingComponents)
   2061             {
   2062                 constructor += ", ";
   2063             }
   2064         }
   2065     }
   2066 
   2067     if (ctorType.getStruct())
   2068     {
   2069         constructor += "};\n"
   2070                        "    return structure;\n"
   2071                        "}\n";
   2072     }
   2073     else
   2074     {
   2075         constructor += ");\n"
   2076                        "}\n";
   2077     }
   2078 
   2079     mConstructors.insert(constructor);
   2080 }
   2081 
   2082 const ConstantUnion *OutputHLSL::writeConstantUnion(const TType &type, const ConstantUnion *constUnion)
   2083 {
   2084     TInfoSinkBase &out = mBody;
   2085 
   2086     if (type.getBasicType() == EbtStruct)
   2087     {
   2088         out << structLookup(type.getTypeName()) + "_ctor(";
   2089 
   2090         const TTypeList *structure = type.getStruct();
   2091 
   2092         for (size_t i = 0; i < structure->size(); i++)
   2093         {
   2094             const TType *fieldType = (*structure)[i].type;
   2095 
   2096             constUnion = writeConstantUnion(*fieldType, constUnion);
   2097 
   2098             if (i != structure->size() - 1)
   2099             {
   2100                 out << ", ";
   2101             }
   2102         }
   2103 
   2104         out << ")";
   2105     }
   2106     else
   2107     {
   2108         int size = type.getObjectSize();
   2109         bool writeType = size > 1;
   2110 
   2111         if (writeType)
   2112         {
   2113             out << typeString(type) << "(";
   2114         }
   2115 
   2116         for (int i = 0; i < size; i++, constUnion++)
   2117         {
   2118             switch (constUnion->getType())
   2119             {
   2120               case EbtFloat: out << constUnion->getFConst(); break;
   2121               case EbtInt:   out << constUnion->getIConst(); break;
   2122               case EbtBool:  out << constUnion->getBConst(); break;
   2123               default: UNREACHABLE();
   2124             }
   2125 
   2126             if (i != size - 1)
   2127             {
   2128                 out << ", ";
   2129             }
   2130         }
   2131 
   2132         if (writeType)
   2133         {
   2134             out << ")";
   2135         }
   2136     }
   2137 
   2138     return constUnion;
   2139 }
   2140 
   2141 TString OutputHLSL::scopeString(unsigned int depthLimit)
   2142 {
   2143     TString string;
   2144 
   2145     for (unsigned int i = 0; i < mScopeBracket.size() && i < depthLimit; i++)
   2146     {
   2147         string += "_" + str(i);
   2148     }
   2149 
   2150     return string;
   2151 }
   2152 
   2153 TString OutputHLSL::scopedStruct(const TString &typeName)
   2154 {
   2155     if (typeName == "")
   2156     {
   2157         return typeName;
   2158     }
   2159 
   2160     return typeName + scopeString(mScopeDepth);
   2161 }
   2162 
   2163 TString OutputHLSL::structLookup(const TString &typeName)
   2164 {
   2165     for (int depth = mScopeDepth; depth >= 0; depth--)
   2166     {
   2167         TString scopedName = decorate(typeName + scopeString(depth));
   2168 
   2169         for (StructNames::iterator structName = mStructNames.begin(); structName != mStructNames.end(); structName++)
   2170         {
   2171             if (*structName == scopedName)
   2172             {
   2173                 return scopedName;
   2174             }
   2175         }
   2176     }
   2177 
   2178     UNREACHABLE();   // Should have found a matching constructor
   2179 
   2180     return typeName;
   2181 }
   2182 
   2183 TString OutputHLSL::decorate(const TString &string)
   2184 {
   2185     if (string.substr(0, 3) != "gl_" && string.substr(0, 3) != "dx_")
   2186     {
   2187         return "_" + string;
   2188     }
   2189     else
   2190     {
   2191         return string;
   2192     }
   2193 }
   2194 }
   2195