Source/ThirdParty/ANGLE/src/compiler/OutputHLSL.cpp

   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 }