1 // 2 // Copyright (c) 2002-2014 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/translator/OutputHLSL.h" 8 9 #include "common/angleutils.h" 10 #include "common/utilities.h" 11 #include "common/blocklayout.h" 12 #include "compiler/translator/compilerdebug.h" 13 #include "compiler/translator/InfoSink.h" 14 #include "compiler/translator/DetectDiscontinuity.h" 15 #include "compiler/translator/SearchSymbol.h" 16 #include "compiler/translator/UnfoldShortCircuit.h" 17 #include "compiler/translator/FlagStd140Structs.h" 18 #include "compiler/translator/NodeSearch.h" 19 #include "compiler/translator/RewriteElseBlocks.h" 20 #include "compiler/translator/UtilsHLSL.h" 21 #include "compiler/translator/util.h" 22 #include "compiler/translator/UniformHLSL.h" 23 #include "compiler/translator/StructureHLSL.h" 24 #include "compiler/translator/TranslatorHLSL.h" 25 26 #include <algorithm> 27 #include <cfloat> 28 #include <stdio.h> 29 30 namespace sh 31 { 32 33 TString OutputHLSL::TextureFunction::name() const 34 { 35 TString name = "gl_texture"; 36 37 if (IsSampler2D(sampler)) 38 { 39 name += "2D"; 40 } 41 else if (IsSampler3D(sampler)) 42 { 43 name += "3D"; 44 } 45 else if (IsSamplerCube(sampler)) 46 { 47 name += "Cube"; 48 } 49 else UNREACHABLE(); 50 51 if (proj) 52 { 53 name += "Proj"; 54 } 55 56 if (offset) 57 { 58 name += "Offset"; 59 } 60 61 switch(method) 62 { 63 case IMPLICIT: break; 64 case BIAS: break; // Extra parameter makes the signature unique 65 case LOD: name += "Lod"; break; 66 case LOD0: name += "Lod0"; break; 67 case LOD0BIAS: name += "Lod0"; break; // Extra parameter makes the signature unique 68 case SIZE: name += "Size"; break; 69 case FETCH: name += "Fetch"; break; 70 case GRAD: name += "Grad"; break; 71 default: UNREACHABLE(); 72 } 73 74 return name + "("; 75 } 76 77 bool OutputHLSL::TextureFunction::operator<(const TextureFunction &rhs) const 78 { 79 if (sampler < rhs.sampler) return true; 80 if (sampler > rhs.sampler) return false; 81 82 if (coords < rhs.coords) return true; 83 if (coords > rhs.coords) return false; 84 85 if (!proj && rhs.proj) return true; 86 if (proj && !rhs.proj) return false; 87 88 if (!offset && rhs.offset) return true; 89 if (offset && !rhs.offset) return false; 90 91 if (method < rhs.method) return true; 92 if (method > rhs.method) return false; 93 94 return false; 95 } 96 97 OutputHLSL::OutputHLSL(TParseContext &context, TranslatorHLSL *parentTranslator) 98 : TIntermTraverser(true, true, true), 99 mContext(context), 100 mOutputType(parentTranslator->getOutputType()) 101 { 102 mUnfoldShortCircuit = new UnfoldShortCircuit(context, this); 103 mInsideFunction = false; 104 105 mUsesFragColor = false; 106 mUsesFragData = false; 107 mUsesDepthRange = false; 108 mUsesFragCoord = false; 109 mUsesPointCoord = false; 110 mUsesFrontFacing = false; 111 mUsesPointSize = false; 112 mUsesFragDepth = false; 113 mUsesXor = false; 114 mUsesMod1 = false; 115 mUsesMod2v = false; 116 mUsesMod2f = false; 117 mUsesMod3v = false; 118 mUsesMod3f = false; 119 mUsesMod4v = false; 120 mUsesMod4f = false; 121 mUsesFaceforward1 = false; 122 mUsesFaceforward2 = false; 123 mUsesFaceforward3 = false; 124 mUsesFaceforward4 = false; 125 mUsesAtan2_1 = false; 126 mUsesAtan2_2 = false; 127 mUsesAtan2_3 = false; 128 mUsesAtan2_4 = false; 129 mUsesDiscardRewriting = false; 130 mUsesNestedBreak = false; 131 132 const ShBuiltInResources &resources = parentTranslator->getResources(); 133 mNumRenderTargets = resources.EXT_draw_buffers ? resources.MaxDrawBuffers : 1; 134 135 mUniqueIndex = 0; 136 137 mContainsLoopDiscontinuity = false; 138 mOutputLod0Function = false; 139 mInsideDiscontinuousLoop = false; 140 mNestedLoopDepth = 0; 141 142 mExcessiveLoopIndex = NULL; 143 144 mStructureHLSL = new StructureHLSL; 145 mUniformHLSL = new UniformHLSL(mStructureHLSL, parentTranslator); 146 147 if (mOutputType == SH_HLSL9_OUTPUT) 148 { 149 if (mContext.shaderType == GL_FRAGMENT_SHADER) 150 { 151 // Reserve registers for dx_DepthRange, dx_ViewCoords and dx_DepthFront 152 mUniformHLSL->reserveUniformRegisters(3); 153 } 154 else 155 { 156 // Reserve registers for dx_DepthRange and dx_ViewAdjust 157 mUniformHLSL->reserveUniformRegisters(2); 158 } 159 } 160 161 // Reserve registers for the default uniform block and driver constants 162 mUniformHLSL->reserveInterfaceBlockRegisters(2); 163 } 164 165 OutputHLSL::~OutputHLSL() 166 { 167 SafeDelete(mUnfoldShortCircuit); 168 SafeDelete(mStructureHLSL); 169 SafeDelete(mUniformHLSL); 170 } 171 172 void OutputHLSL::output() 173 { 174 mContainsLoopDiscontinuity = mContext.shaderType == GL_FRAGMENT_SHADER && containsLoopDiscontinuity(mContext.treeRoot); 175 const std::vector<TIntermTyped*> &flaggedStructs = FlagStd140ValueStructs(mContext.treeRoot); 176 makeFlaggedStructMaps(flaggedStructs); 177 178 // Work around D3D9 bug that would manifest in vertex shaders with selection blocks which 179 // use a vertex attribute as a condition, and some related computation in the else block. 180 if (mOutputType == SH_HLSL9_OUTPUT && mContext.shaderType == GL_VERTEX_SHADER) 181 { 182 RewriteElseBlocks(mContext.treeRoot); 183 } 184 185 mContext.treeRoot->traverse(this); // Output the body first to determine what has to go in the header 186 header(); 187 188 mContext.infoSink().obj << mHeader.c_str(); 189 mContext.infoSink().obj << mBody.c_str(); 190 } 191 192 void OutputHLSL::makeFlaggedStructMaps(const std::vector<TIntermTyped *> &flaggedStructs) 193 { 194 for (unsigned int structIndex = 0; structIndex < flaggedStructs.size(); structIndex++) 195 { 196 TIntermTyped *flaggedNode = flaggedStructs[structIndex]; 197 198 // This will mark the necessary block elements as referenced 199 flaggedNode->traverse(this); 200 TString structName(mBody.c_str()); 201 mBody.erase(); 202 203 mFlaggedStructOriginalNames[flaggedNode] = structName; 204 205 for (size_t pos = structName.find('.'); pos != std::string::npos; pos = structName.find('.')) 206 { 207 structName.erase(pos, 1); 208 } 209 210 mFlaggedStructMappedNames[flaggedNode] = "map" + structName; 211 } 212 } 213 214 TInfoSinkBase &OutputHLSL::getBodyStream() 215 { 216 return mBody; 217 } 218 219 const std::map<std::string, unsigned int> &OutputHLSL::getInterfaceBlockRegisterMap() const 220 { 221 return mUniformHLSL->getInterfaceBlockRegisterMap(); 222 } 223 224 const std::map<std::string, unsigned int> &OutputHLSL::getUniformRegisterMap() const 225 { 226 return mUniformHLSL->getUniformRegisterMap(); 227 } 228 229 int OutputHLSL::vectorSize(const TType &type) const 230 { 231 int elementSize = type.isMatrix() ? type.getCols() : 1; 232 int arraySize = type.isArray() ? type.getArraySize() : 1; 233 234 return elementSize * arraySize; 235 } 236 237 TString OutputHLSL::structInitializerString(int indent, const TStructure &structure, const TString &rhsStructName) 238 { 239 TString init; 240 241 TString preIndentString; 242 TString fullIndentString; 243 244 for (int spaces = 0; spaces < (indent * 4); spaces++) 245 { 246 preIndentString += ' '; 247 } 248 249 for (int spaces = 0; spaces < ((indent+1) * 4); spaces++) 250 { 251 fullIndentString += ' '; 252 } 253 254 init += preIndentString + "{\n"; 255 256 const TFieldList &fields = structure.fields(); 257 for (unsigned int fieldIndex = 0; fieldIndex < fields.size(); fieldIndex++) 258 { 259 const TField &field = *fields[fieldIndex]; 260 const TString &fieldName = rhsStructName + "." + Decorate(field.name()); 261 const TType &fieldType = *field.type(); 262 263 if (fieldType.getStruct()) 264 { 265 init += structInitializerString(indent + 1, *fieldType.getStruct(), fieldName); 266 } 267 else 268 { 269 init += fullIndentString + fieldName + ",\n"; 270 } 271 } 272 273 init += preIndentString + "}" + (indent == 0 ? ";" : ",") + "\n"; 274 275 return init; 276 } 277 278 void OutputHLSL::header() 279 { 280 TInfoSinkBase &out = mHeader; 281 282 TString varyings; 283 TString attributes; 284 TString flaggedStructs; 285 286 for (std::map<TIntermTyped*, TString>::const_iterator flaggedStructIt = mFlaggedStructMappedNames.begin(); flaggedStructIt != mFlaggedStructMappedNames.end(); flaggedStructIt++) 287 { 288 TIntermTyped *structNode = flaggedStructIt->first; 289 const TString &mappedName = flaggedStructIt->second; 290 const TStructure &structure = *structNode->getType().getStruct(); 291 const TString &originalName = mFlaggedStructOriginalNames[structNode]; 292 293 flaggedStructs += "static " + Decorate(structure.name()) + " " + mappedName + " =\n"; 294 flaggedStructs += structInitializerString(0, structure, originalName); 295 flaggedStructs += "\n"; 296 } 297 298 for (ReferencedSymbols::const_iterator varying = mReferencedVaryings.begin(); varying != mReferencedVaryings.end(); varying++) 299 { 300 const TType &type = varying->second->getType(); 301 const TString &name = varying->second->getSymbol(); 302 303 // Program linking depends on this exact format 304 varyings += "static " + InterpolationString(type.getQualifier()) + " " + TypeString(type) + " " + 305 Decorate(name) + ArrayString(type) + " = " + initializer(type) + ";\n"; 306 } 307 308 for (ReferencedSymbols::const_iterator attribute = mReferencedAttributes.begin(); attribute != mReferencedAttributes.end(); attribute++) 309 { 310 const TType &type = attribute->second->getType(); 311 const TString &name = attribute->second->getSymbol(); 312 313 attributes += "static " + TypeString(type) + " " + Decorate(name) + ArrayString(type) + " = " + initializer(type) + ";\n"; 314 } 315 316 out << mStructureHLSL->structsHeader(); 317 318 out << mUniformHLSL->uniformsHeader(mOutputType, mReferencedUniforms); 319 out << mUniformHLSL->interfaceBlocksHeader(mReferencedInterfaceBlocks); 320 321 if (mUsesDiscardRewriting) 322 { 323 out << "#define ANGLE_USES_DISCARD_REWRITING" << "\n"; 324 } 325 326 if (mUsesNestedBreak) 327 { 328 out << "#define ANGLE_USES_NESTED_BREAK" << "\n"; 329 } 330 331 if (mContext.shaderType == GL_FRAGMENT_SHADER) 332 { 333 TExtensionBehavior::const_iterator iter = mContext.extensionBehavior().find("GL_EXT_draw_buffers"); 334 const bool usingMRTExtension = (iter != mContext.extensionBehavior().end() && (iter->second == EBhEnable || iter->second == EBhRequire)); 335 336 out << "// Varyings\n"; 337 out << varyings; 338 out << "\n"; 339 340 if (mContext.getShaderVersion() >= 300) 341 { 342 for (ReferencedSymbols::const_iterator outputVariableIt = mReferencedOutputVariables.begin(); outputVariableIt != mReferencedOutputVariables.end(); outputVariableIt++) 343 { 344 const TString &variableName = outputVariableIt->first; 345 const TType &variableType = outputVariableIt->second->getType(); 346 347 out << "static " + TypeString(variableType) + " out_" + variableName + ArrayString(variableType) + 348 " = " + initializer(variableType) + ";\n"; 349 } 350 } 351 else 352 { 353 const unsigned int numColorValues = usingMRTExtension ? mNumRenderTargets : 1; 354 355 out << "static float4 gl_Color[" << numColorValues << "] =\n" 356 "{\n"; 357 for (unsigned int i = 0; i < numColorValues; i++) 358 { 359 out << " float4(0, 0, 0, 0)"; 360 if (i + 1 != numColorValues) 361 { 362 out << ","; 363 } 364 out << "\n"; 365 } 366 367 out << "};\n"; 368 } 369 370 if (mUsesFragDepth) 371 { 372 out << "static float gl_Depth = 0.0;\n"; 373 } 374 375 if (mUsesFragCoord) 376 { 377 out << "static float4 gl_FragCoord = float4(0, 0, 0, 0);\n"; 378 } 379 380 if (mUsesPointCoord) 381 { 382 out << "static float2 gl_PointCoord = float2(0.5, 0.5);\n"; 383 } 384 385 if (mUsesFrontFacing) 386 { 387 out << "static bool gl_FrontFacing = false;\n"; 388 } 389 390 out << "\n"; 391 392 if (mUsesDepthRange) 393 { 394 out << "struct gl_DepthRangeParameters\n" 395 "{\n" 396 " float near;\n" 397 " float far;\n" 398 " float diff;\n" 399 "};\n" 400 "\n"; 401 } 402 403 if (mOutputType == SH_HLSL11_OUTPUT) 404 { 405 out << "cbuffer DriverConstants : register(b1)\n" 406 "{\n"; 407 408 if (mUsesDepthRange) 409 { 410 out << " float3 dx_DepthRange : packoffset(c0);\n"; 411 } 412 413 if (mUsesFragCoord) 414 { 415 out << " float4 dx_ViewCoords : packoffset(c1);\n"; 416 } 417 418 if (mUsesFragCoord || mUsesFrontFacing) 419 { 420 out << " float3 dx_DepthFront : packoffset(c2);\n"; 421 } 422 423 out << "};\n"; 424 } 425 else 426 { 427 if (mUsesDepthRange) 428 { 429 out << "uniform float3 dx_DepthRange : register(c0);"; 430 } 431 432 if (mUsesFragCoord) 433 { 434 out << "uniform float4 dx_ViewCoords : register(c1);\n"; 435 } 436 437 if (mUsesFragCoord || mUsesFrontFacing) 438 { 439 out << "uniform float3 dx_DepthFront : register(c2);\n"; 440 } 441 } 442 443 out << "\n"; 444 445 if (mUsesDepthRange) 446 { 447 out << "static gl_DepthRangeParameters gl_DepthRange = {dx_DepthRange.x, dx_DepthRange.y, dx_DepthRange.z};\n" 448 "\n"; 449 } 450 451 if (!flaggedStructs.empty()) 452 { 453 out << "// Std140 Structures accessed by value\n"; 454 out << "\n"; 455 out << flaggedStructs; 456 out << "\n"; 457 } 458 459 if (usingMRTExtension && mNumRenderTargets > 1) 460 { 461 out << "#define GL_USES_MRT\n"; 462 } 463 464 if (mUsesFragColor) 465 { 466 out << "#define GL_USES_FRAG_COLOR\n"; 467 } 468 469 if (mUsesFragData) 470 { 471 out << "#define GL_USES_FRAG_DATA\n"; 472 } 473 } 474 else // Vertex shader 475 { 476 out << "// Attributes\n"; 477 out << attributes; 478 out << "\n" 479 "static float4 gl_Position = float4(0, 0, 0, 0);\n"; 480 481 if (mUsesPointSize) 482 { 483 out << "static float gl_PointSize = float(1);\n"; 484 } 485 486 out << "\n" 487 "// Varyings\n"; 488 out << varyings; 489 out << "\n"; 490 491 if (mUsesDepthRange) 492 { 493 out << "struct gl_DepthRangeParameters\n" 494 "{\n" 495 " float near;\n" 496 " float far;\n" 497 " float diff;\n" 498 "};\n" 499 "\n"; 500 } 501 502 if (mOutputType == SH_HLSL11_OUTPUT) 503 { 504 if (mUsesDepthRange) 505 { 506 out << "cbuffer DriverConstants : register(b1)\n" 507 "{\n" 508 " float3 dx_DepthRange : packoffset(c0);\n" 509 "};\n" 510 "\n"; 511 } 512 } 513 else 514 { 515 if (mUsesDepthRange) 516 { 517 out << "uniform float3 dx_DepthRange : register(c0);\n"; 518 } 519 520 out << "uniform float4 dx_ViewAdjust : register(c1);\n" 521 "\n"; 522 } 523 524 if (mUsesDepthRange) 525 { 526 out << "static gl_DepthRangeParameters gl_DepthRange = {dx_DepthRange.x, dx_DepthRange.y, dx_DepthRange.z};\n" 527 "\n"; 528 } 529 530 if (!flaggedStructs.empty()) 531 { 532 out << "// Std140 Structures accessed by value\n"; 533 out << "\n"; 534 out << flaggedStructs; 535 out << "\n"; 536 } 537 } 538 539 for (TextureFunctionSet::const_iterator textureFunction = mUsesTexture.begin(); textureFunction != mUsesTexture.end(); textureFunction++) 540 { 541 // Return type 542 if (textureFunction->method == TextureFunction::SIZE) 543 { 544 switch(textureFunction->sampler) 545 { 546 case EbtSampler2D: out << "int2 "; break; 547 case EbtSampler3D: out << "int3 "; break; 548 case EbtSamplerCube: out << "int2 "; break; 549 case EbtSampler2DArray: out << "int3 "; break; 550 case EbtISampler2D: out << "int2 "; break; 551 case EbtISampler3D: out << "int3 "; break; 552 case EbtISamplerCube: out << "int2 "; break; 553 case EbtISampler2DArray: out << "int3 "; break; 554 case EbtUSampler2D: out << "int2 "; break; 555 case EbtUSampler3D: out << "int3 "; break; 556 case EbtUSamplerCube: out << "int2 "; break; 557 case EbtUSampler2DArray: out << "int3 "; break; 558 case EbtSampler2DShadow: out << "int2 "; break; 559 case EbtSamplerCubeShadow: out << "int2 "; break; 560 case EbtSampler2DArrayShadow: out << "int3 "; break; 561 default: UNREACHABLE(); 562 } 563 } 564 else // Sampling function 565 { 566 switch(textureFunction->sampler) 567 { 568 case EbtSampler2D: out << "float4 "; break; 569 case EbtSampler3D: out << "float4 "; break; 570 case EbtSamplerCube: out << "float4 "; break; 571 case EbtSampler2DArray: out << "float4 "; break; 572 case EbtISampler2D: out << "int4 "; break; 573 case EbtISampler3D: out << "int4 "; break; 574 case EbtISamplerCube: out << "int4 "; break; 575 case EbtISampler2DArray: out << "int4 "; break; 576 case EbtUSampler2D: out << "uint4 "; break; 577 case EbtUSampler3D: out << "uint4 "; break; 578 case EbtUSamplerCube: out << "uint4 "; break; 579 case EbtUSampler2DArray: out << "uint4 "; break; 580 case EbtSampler2DShadow: out << "float "; break; 581 case EbtSamplerCubeShadow: out << "float "; break; 582 case EbtSampler2DArrayShadow: out << "float "; break; 583 default: UNREACHABLE(); 584 } 585 } 586 587 // Function name 588 out << textureFunction->name(); 589 590 // Argument list 591 int hlslCoords = 4; 592 593 if (mOutputType == SH_HLSL9_OUTPUT) 594 { 595 switch(textureFunction->sampler) 596 { 597 case EbtSampler2D: out << "sampler2D s"; hlslCoords = 2; break; 598 case EbtSamplerCube: out << "samplerCUBE s"; hlslCoords = 3; break; 599 default: UNREACHABLE(); 600 } 601 602 switch(textureFunction->method) 603 { 604 case TextureFunction::IMPLICIT: break; 605 case TextureFunction::BIAS: hlslCoords = 4; break; 606 case TextureFunction::LOD: hlslCoords = 4; break; 607 case TextureFunction::LOD0: hlslCoords = 4; break; 608 case TextureFunction::LOD0BIAS: hlslCoords = 4; break; 609 default: UNREACHABLE(); 610 } 611 } 612 else if (mOutputType == SH_HLSL11_OUTPUT) 613 { 614 switch(textureFunction->sampler) 615 { 616 case EbtSampler2D: out << "Texture2D x, SamplerState s"; hlslCoords = 2; break; 617 case EbtSampler3D: out << "Texture3D x, SamplerState s"; hlslCoords = 3; break; 618 case EbtSamplerCube: out << "TextureCube x, SamplerState s"; hlslCoords = 3; break; 619 case EbtSampler2DArray: out << "Texture2DArray x, SamplerState s"; hlslCoords = 3; break; 620 case EbtISampler2D: out << "Texture2D<int4> x, SamplerState s"; hlslCoords = 2; break; 621 case EbtISampler3D: out << "Texture3D<int4> x, SamplerState s"; hlslCoords = 3; break; 622 case EbtISamplerCube: out << "Texture2DArray<int4> x, SamplerState s"; hlslCoords = 3; break; 623 case EbtISampler2DArray: out << "Texture2DArray<int4> x, SamplerState s"; hlslCoords = 3; break; 624 case EbtUSampler2D: out << "Texture2D<uint4> x, SamplerState s"; hlslCoords = 2; break; 625 case EbtUSampler3D: out << "Texture3D<uint4> x, SamplerState s"; hlslCoords = 3; break; 626 case EbtUSamplerCube: out << "Texture2DArray<uint4> x, SamplerState s"; hlslCoords = 3; break; 627 case EbtUSampler2DArray: out << "Texture2DArray<uint4> x, SamplerState s"; hlslCoords = 3; break; 628 case EbtSampler2DShadow: out << "Texture2D x, SamplerComparisonState s"; hlslCoords = 2; break; 629 case EbtSamplerCubeShadow: out << "TextureCube x, SamplerComparisonState s"; hlslCoords = 3; break; 630 case EbtSampler2DArrayShadow: out << "Texture2DArray x, SamplerComparisonState s"; hlslCoords = 3; break; 631 default: UNREACHABLE(); 632 } 633 } 634 else UNREACHABLE(); 635 636 if (textureFunction->method == TextureFunction::FETCH) // Integer coordinates 637 { 638 switch(textureFunction->coords) 639 { 640 case 2: out << ", int2 t"; break; 641 case 3: out << ", int3 t"; break; 642 default: UNREACHABLE(); 643 } 644 } 645 else // Floating-point coordinates (except textureSize) 646 { 647 switch(textureFunction->coords) 648 { 649 case 1: out << ", int lod"; break; // textureSize() 650 case 2: out << ", float2 t"; break; 651 case 3: out << ", float3 t"; break; 652 case 4: out << ", float4 t"; break; 653 default: UNREACHABLE(); 654 } 655 } 656 657 if (textureFunction->method == TextureFunction::GRAD) 658 { 659 switch(textureFunction->sampler) 660 { 661 case EbtSampler2D: 662 case EbtISampler2D: 663 case EbtUSampler2D: 664 case EbtSampler2DArray: 665 case EbtISampler2DArray: 666 case EbtUSampler2DArray: 667 case EbtSampler2DShadow: 668 case EbtSampler2DArrayShadow: 669 out << ", float2 ddx, float2 ddy"; 670 break; 671 case EbtSampler3D: 672 case EbtISampler3D: 673 case EbtUSampler3D: 674 case EbtSamplerCube: 675 case EbtISamplerCube: 676 case EbtUSamplerCube: 677 case EbtSamplerCubeShadow: 678 out << ", float3 ddx, float3 ddy"; 679 break; 680 default: UNREACHABLE(); 681 } 682 } 683 684 switch(textureFunction->method) 685 { 686 case TextureFunction::IMPLICIT: break; 687 case TextureFunction::BIAS: break; // Comes after the offset parameter 688 case TextureFunction::LOD: out << ", float lod"; break; 689 case TextureFunction::LOD0: break; 690 case TextureFunction::LOD0BIAS: break; // Comes after the offset parameter 691 case TextureFunction::SIZE: break; 692 case TextureFunction::FETCH: out << ", int mip"; break; 693 case TextureFunction::GRAD: break; 694 default: UNREACHABLE(); 695 } 696 697 if (textureFunction->offset) 698 { 699 switch(textureFunction->sampler) 700 { 701 case EbtSampler2D: out << ", int2 offset"; break; 702 case EbtSampler3D: out << ", int3 offset"; break; 703 case EbtSampler2DArray: out << ", int2 offset"; break; 704 case EbtISampler2D: out << ", int2 offset"; break; 705 case EbtISampler3D: out << ", int3 offset"; break; 706 case EbtISampler2DArray: out << ", int2 offset"; break; 707 case EbtUSampler2D: out << ", int2 offset"; break; 708 case EbtUSampler3D: out << ", int3 offset"; break; 709 case EbtUSampler2DArray: out << ", int2 offset"; break; 710 case EbtSampler2DShadow: out << ", int2 offset"; break; 711 case EbtSampler2DArrayShadow: out << ", int2 offset"; break; 712 default: UNREACHABLE(); 713 } 714 } 715 716 if (textureFunction->method == TextureFunction::BIAS || 717 textureFunction->method == TextureFunction::LOD0BIAS) 718 { 719 out << ", float bias"; 720 } 721 722 out << ")\n" 723 "{\n"; 724 725 if (textureFunction->method == TextureFunction::SIZE) 726 { 727 if (IsSampler2D(textureFunction->sampler) || IsSamplerCube(textureFunction->sampler)) 728 { 729 if (IsSamplerArray(textureFunction->sampler)) 730 { 731 out << " uint width; uint height; uint layers; uint numberOfLevels;\n" 732 " x.GetDimensions(lod, width, height, layers, numberOfLevels);\n"; 733 } 734 else 735 { 736 out << " uint width; uint height; uint numberOfLevels;\n" 737 " x.GetDimensions(lod, width, height, numberOfLevels);\n"; 738 } 739 } 740 else if (IsSampler3D(textureFunction->sampler)) 741 { 742 out << " uint width; uint height; uint depth; uint numberOfLevels;\n" 743 " x.GetDimensions(lod, width, height, depth, numberOfLevels);\n"; 744 } 745 else UNREACHABLE(); 746 747 switch(textureFunction->sampler) 748 { 749 case EbtSampler2D: out << " return int2(width, height);"; break; 750 case EbtSampler3D: out << " return int3(width, height, depth);"; break; 751 case EbtSamplerCube: out << " return int2(width, height);"; break; 752 case EbtSampler2DArray: out << " return int3(width, height, layers);"; break; 753 case EbtISampler2D: out << " return int2(width, height);"; break; 754 case EbtISampler3D: out << " return int3(width, height, depth);"; break; 755 case EbtISamplerCube: out << " return int2(width, height);"; break; 756 case EbtISampler2DArray: out << " return int3(width, height, layers);"; break; 757 case EbtUSampler2D: out << " return int2(width, height);"; break; 758 case EbtUSampler3D: out << " return int3(width, height, depth);"; break; 759 case EbtUSamplerCube: out << " return int2(width, height);"; break; 760 case EbtUSampler2DArray: out << " return int3(width, height, layers);"; break; 761 case EbtSampler2DShadow: out << " return int2(width, height);"; break; 762 case EbtSamplerCubeShadow: out << " return int2(width, height);"; break; 763 case EbtSampler2DArrayShadow: out << " return int3(width, height, layers);"; break; 764 default: UNREACHABLE(); 765 } 766 } 767 else 768 { 769 if (IsIntegerSampler(textureFunction->sampler) && IsSamplerCube(textureFunction->sampler)) 770 { 771 out << " float width; float height; float layers; float levels;\n"; 772 773 out << " uint mip = 0;\n"; 774 775 out << " x.GetDimensions(mip, width, height, layers, levels);\n"; 776 777 out << " bool xMajor = abs(t.x) > abs(t.y) && abs(t.x) > abs(t.z);\n"; 778 out << " bool yMajor = abs(t.y) > abs(t.z) && abs(t.y) > abs(t.x);\n"; 779 out << " bool zMajor = abs(t.z) > abs(t.x) && abs(t.z) > abs(t.y);\n"; 780 out << " bool negative = (xMajor && t.x < 0.0f) || (yMajor && t.y < 0.0f) || (zMajor && t.z < 0.0f);\n"; 781 782 // FACE_POSITIVE_X = 000b 783 // FACE_NEGATIVE_X = 001b 784 // FACE_POSITIVE_Y = 010b 785 // FACE_NEGATIVE_Y = 011b 786 // FACE_POSITIVE_Z = 100b 787 // FACE_NEGATIVE_Z = 101b 788 out << " int face = (int)negative + (int)yMajor * 2 + (int)zMajor * 4;\n"; 789 790 out << " float u = xMajor ? -t.z : (yMajor && t.y < 0.0f ? -t.x : t.x);\n"; 791 out << " float v = yMajor ? t.z : (negative ? t.y : -t.y);\n"; 792 out << " float m = xMajor ? t.x : (yMajor ? t.y : t.z);\n"; 793 794 out << " t.x = (u * 0.5f / m) + 0.5f;\n"; 795 out << " t.y = (v * 0.5f / m) + 0.5f;\n"; 796 } 797 else if (IsIntegerSampler(textureFunction->sampler) && 798 textureFunction->method != TextureFunction::FETCH) 799 { 800 if (IsSampler2D(textureFunction->sampler)) 801 { 802 if (IsSamplerArray(textureFunction->sampler)) 803 { 804 out << " float width; float height; float layers; float levels;\n"; 805 806 if (textureFunction->method == TextureFunction::LOD0) 807 { 808 out << " uint mip = 0;\n"; 809 } 810 else if (textureFunction->method == TextureFunction::LOD0BIAS) 811 { 812 out << " uint mip = bias;\n"; 813 } 814 else 815 { 816 if (textureFunction->method == TextureFunction::IMPLICIT || 817 textureFunction->method == TextureFunction::BIAS) 818 { 819 out << " x.GetDimensions(0, width, height, layers, levels);\n" 820 " float2 tSized = float2(t.x * width, t.y * height);\n" 821 " float dx = length(ddx(tSized));\n" 822 " float dy = length(ddy(tSized));\n" 823 " float lod = log2(max(dx, dy));\n"; 824 825 if (textureFunction->method == TextureFunction::BIAS) 826 { 827 out << " lod += bias;\n"; 828 } 829 } 830 else if (textureFunction->method == TextureFunction::GRAD) 831 { 832 out << " x.GetDimensions(0, width, height, layers, levels);\n" 833 " float lod = log2(max(length(ddx), length(ddy)));\n"; 834 } 835 836 out << " uint mip = uint(min(max(round(lod), 0), levels - 1));\n"; 837 } 838 839 out << " x.GetDimensions(mip, width, height, layers, levels);\n"; 840 } 841 else 842 { 843 out << " float width; float height; float levels;\n"; 844 845 if (textureFunction->method == TextureFunction::LOD0) 846 { 847 out << " uint mip = 0;\n"; 848 } 849 else if (textureFunction->method == TextureFunction::LOD0BIAS) 850 { 851 out << " uint mip = bias;\n"; 852 } 853 else 854 { 855 if (textureFunction->method == TextureFunction::IMPLICIT || 856 textureFunction->method == TextureFunction::BIAS) 857 { 858 out << " x.GetDimensions(0, width, height, levels);\n" 859 " float2 tSized = float2(t.x * width, t.y * height);\n" 860 " float dx = length(ddx(tSized));\n" 861 " float dy = length(ddy(tSized));\n" 862 " float lod = log2(max(dx, dy));\n"; 863 864 if (textureFunction->method == TextureFunction::BIAS) 865 { 866 out << " lod += bias;\n"; 867 } 868 } 869 else if (textureFunction->method == TextureFunction::LOD) 870 { 871 out << " x.GetDimensions(0, width, height, levels);\n"; 872 } 873 else if (textureFunction->method == TextureFunction::GRAD) 874 { 875 out << " x.GetDimensions(0, width, height, levels);\n" 876 " float lod = log2(max(length(ddx), length(ddy)));\n"; 877 } 878 879 out << " uint mip = uint(min(max(round(lod), 0), levels - 1));\n"; 880 } 881 882 out << " x.GetDimensions(mip, width, height, levels);\n"; 883 } 884 } 885 else if (IsSampler3D(textureFunction->sampler)) 886 { 887 out << " float width; float height; float depth; float levels;\n"; 888 889 if (textureFunction->method == TextureFunction::LOD0) 890 { 891 out << " uint mip = 0;\n"; 892 } 893 else if (textureFunction->method == TextureFunction::LOD0BIAS) 894 { 895 out << " uint mip = bias;\n"; 896 } 897 else 898 { 899 if (textureFunction->method == TextureFunction::IMPLICIT || 900 textureFunction->method == TextureFunction::BIAS) 901 { 902 out << " x.GetDimensions(0, width, height, depth, levels);\n" 903 " float3 tSized = float3(t.x * width, t.y * height, t.z * depth);\n" 904 " float dx = length(ddx(tSized));\n" 905 " float dy = length(ddy(tSized));\n" 906 " float lod = log2(max(dx, dy));\n"; 907 908 if (textureFunction->method == TextureFunction::BIAS) 909 { 910 out << " lod += bias;\n"; 911 } 912 } 913 else if (textureFunction->method == TextureFunction::GRAD) 914 { 915 out << " x.GetDimensions(0, width, height, depth, levels);\n" 916 " float lod = log2(max(length(ddx), length(ddy)));\n"; 917 } 918 919 out << " uint mip = uint(min(max(round(lod), 0), levels - 1));\n"; 920 } 921 922 out << " x.GetDimensions(mip, width, height, depth, levels);\n"; 923 } 924 else UNREACHABLE(); 925 } 926 927 out << " return "; 928 929 // HLSL intrinsic 930 if (mOutputType == SH_HLSL9_OUTPUT) 931 { 932 switch(textureFunction->sampler) 933 { 934 case EbtSampler2D: out << "tex2D"; break; 935 case EbtSamplerCube: out << "texCUBE"; break; 936 default: UNREACHABLE(); 937 } 938 939 switch(textureFunction->method) 940 { 941 case TextureFunction::IMPLICIT: out << "(s, "; break; 942 case TextureFunction::BIAS: out << "bias(s, "; break; 943 case TextureFunction::LOD: out << "lod(s, "; break; 944 case TextureFunction::LOD0: out << "lod(s, "; break; 945 case TextureFunction::LOD0BIAS: out << "lod(s, "; break; 946 default: UNREACHABLE(); 947 } 948 } 949 else if (mOutputType == SH_HLSL11_OUTPUT) 950 { 951 if (textureFunction->method == TextureFunction::GRAD) 952 { 953 if (IsIntegerSampler(textureFunction->sampler)) 954 { 955 out << "x.Load("; 956 } 957 else if (IsShadowSampler(textureFunction->sampler)) 958 { 959 out << "x.SampleCmpLevelZero(s, "; 960 } 961 else 962 { 963 out << "x.SampleGrad(s, "; 964 } 965 } 966 else if (IsIntegerSampler(textureFunction->sampler) || 967 textureFunction->method == TextureFunction::FETCH) 968 { 969 out << "x.Load("; 970 } 971 else if (IsShadowSampler(textureFunction->sampler)) 972 { 973 out << "x.SampleCmp(s, "; 974 } 975 else 976 { 977 switch(textureFunction->method) 978 { 979 case TextureFunction::IMPLICIT: out << "x.Sample(s, "; break; 980 case TextureFunction::BIAS: out << "x.SampleBias(s, "; break; 981 case TextureFunction::LOD: out << "x.SampleLevel(s, "; break; 982 case TextureFunction::LOD0: out << "x.SampleLevel(s, "; break; 983 case TextureFunction::LOD0BIAS: out << "x.SampleLevel(s, "; break; 984 default: UNREACHABLE(); 985 } 986 } 987 } 988 else UNREACHABLE(); 989 990 // Integer sampling requires integer addresses 991 TString addressx = ""; 992 TString addressy = ""; 993 TString addressz = ""; 994 TString close = ""; 995 996 if (IsIntegerSampler(textureFunction->sampler) || 997 textureFunction->method == TextureFunction::FETCH) 998 { 999 switch(hlslCoords) 1000 { 1001 case 2: out << "int3("; break; 1002 case 3: out << "int4("; break; 1003 default: UNREACHABLE(); 1004 } 1005 1006 // Convert from normalized floating-point to integer 1007 if (textureFunction->method != TextureFunction::FETCH) 1008 { 1009 addressx = "int(floor(width * frac(("; 1010 addressy = "int(floor(height * frac(("; 1011 1012 if (IsSamplerArray(textureFunction->sampler)) 1013 { 1014 addressz = "int(max(0, min(layers - 1, floor(0.5 + "; 1015 } 1016 else if (IsSamplerCube(textureFunction->sampler)) 1017 { 1018 addressz = "(((("; 1019 } 1020 else 1021 { 1022 addressz = "int(floor(depth * frac(("; 1023 } 1024 1025 close = "))))"; 1026 } 1027 } 1028 else 1029 { 1030 switch(hlslCoords) 1031 { 1032 case 2: out << "float2("; break; 1033 case 3: out << "float3("; break; 1034 case 4: out << "float4("; break; 1035 default: UNREACHABLE(); 1036 } 1037 } 1038 1039 TString proj = ""; // Only used for projected textures 1040 1041 if (textureFunction->proj) 1042 { 1043 switch(textureFunction->coords) 1044 { 1045 case 3: proj = " / t.z"; break; 1046 case 4: proj = " / t.w"; break; 1047 default: UNREACHABLE(); 1048 } 1049 } 1050 1051 out << addressx + ("t.x" + proj) + close + ", " + addressy + ("t.y" + proj) + close; 1052 1053 if (mOutputType == SH_HLSL9_OUTPUT) 1054 { 1055 if (hlslCoords >= 3) 1056 { 1057 if (textureFunction->coords < 3) 1058 { 1059 out << ", 0"; 1060 } 1061 else 1062 { 1063 out << ", t.z" + proj; 1064 } 1065 } 1066 1067 if (hlslCoords == 4) 1068 { 1069 switch(textureFunction->method) 1070 { 1071 case TextureFunction::BIAS: out << ", bias"; break; 1072 case TextureFunction::LOD: out << ", lod"; break; 1073 case TextureFunction::LOD0: out << ", 0"; break; 1074 case TextureFunction::LOD0BIAS: out << ", bias"; break; 1075 default: UNREACHABLE(); 1076 } 1077 } 1078 1079 out << "));\n"; 1080 } 1081 else if (mOutputType == SH_HLSL11_OUTPUT) 1082 { 1083 if (hlslCoords >= 3) 1084 { 1085 if (IsIntegerSampler(textureFunction->sampler) && IsSamplerCube(textureFunction->sampler)) 1086 { 1087 out << ", face"; 1088 } 1089 else 1090 { 1091 out << ", " + addressz + ("t.z" + proj) + close; 1092 } 1093 } 1094 1095 if (textureFunction->method == TextureFunction::GRAD) 1096 { 1097 if (IsIntegerSampler(textureFunction->sampler)) 1098 { 1099 out << ", mip)"; 1100 } 1101 else if (IsShadowSampler(textureFunction->sampler)) 1102 { 1103 // Compare value 1104 switch(textureFunction->coords) 1105 { 1106 case 3: out << "), t.z"; break; 1107 case 4: out << "), t.w"; break; 1108 default: UNREACHABLE(); 1109 } 1110 } 1111 else 1112 { 1113 out << "), ddx, ddy"; 1114 } 1115 } 1116 else if (IsIntegerSampler(textureFunction->sampler) || 1117 textureFunction->method == TextureFunction::FETCH) 1118 { 1119 out << ", mip)"; 1120 } 1121 else if (IsShadowSampler(textureFunction->sampler)) 1122 { 1123 // Compare value 1124 switch(textureFunction->coords) 1125 { 1126 case 3: out << "), t.z"; break; 1127 case 4: out << "), t.w"; break; 1128 default: UNREACHABLE(); 1129 } 1130 } 1131 else 1132 { 1133 switch(textureFunction->method) 1134 { 1135 case TextureFunction::IMPLICIT: out << ")"; break; 1136 case TextureFunction::BIAS: out << "), bias"; break; 1137 case TextureFunction::LOD: out << "), lod"; break; 1138 case TextureFunction::LOD0: out << "), 0"; break; 1139 case TextureFunction::LOD0BIAS: out << "), bias"; break; 1140 default: UNREACHABLE(); 1141 } 1142 } 1143 1144 if (textureFunction->offset) 1145 { 1146 out << ", offset"; 1147 } 1148 1149 out << ");"; 1150 } 1151 else UNREACHABLE(); 1152 } 1153 1154 out << "\n" 1155 "}\n" 1156 "\n"; 1157 } 1158 1159 if (mUsesFragCoord) 1160 { 1161 out << "#define GL_USES_FRAG_COORD\n"; 1162 } 1163 1164 if (mUsesPointCoord) 1165 { 1166 out << "#define GL_USES_POINT_COORD\n"; 1167 } 1168 1169 if (mUsesFrontFacing) 1170 { 1171 out << "#define GL_USES_FRONT_FACING\n"; 1172 } 1173 1174 if (mUsesPointSize) 1175 { 1176 out << "#define GL_USES_POINT_SIZE\n"; 1177 } 1178 1179 if (mUsesFragDepth) 1180 { 1181 out << "#define GL_USES_FRAG_DEPTH\n"; 1182 } 1183 1184 if (mUsesDepthRange) 1185 { 1186 out << "#define GL_USES_DEPTH_RANGE\n"; 1187 } 1188 1189 if (mUsesXor) 1190 { 1191 out << "bool xor(bool p, bool q)\n" 1192 "{\n" 1193 " return (p || q) && !(p && q);\n" 1194 "}\n" 1195 "\n"; 1196 } 1197 1198 if (mUsesMod1) 1199 { 1200 out << "float mod(float x, float y)\n" 1201 "{\n" 1202 " return x - y * floor(x / y);\n" 1203 "}\n" 1204 "\n"; 1205 } 1206 1207 if (mUsesMod2v) 1208 { 1209 out << "float2 mod(float2 x, float2 y)\n" 1210 "{\n" 1211 " return x - y * floor(x / y);\n" 1212 "}\n" 1213 "\n"; 1214 } 1215 1216 if (mUsesMod2f) 1217 { 1218 out << "float2 mod(float2 x, float y)\n" 1219 "{\n" 1220 " return x - y * floor(x / y);\n" 1221 "}\n" 1222 "\n"; 1223 } 1224 1225 if (mUsesMod3v) 1226 { 1227 out << "float3 mod(float3 x, float3 y)\n" 1228 "{\n" 1229 " return x - y * floor(x / y);\n" 1230 "}\n" 1231 "\n"; 1232 } 1233 1234 if (mUsesMod3f) 1235 { 1236 out << "float3 mod(float3 x, float y)\n" 1237 "{\n" 1238 " return x - y * floor(x / y);\n" 1239 "}\n" 1240 "\n"; 1241 } 1242 1243 if (mUsesMod4v) 1244 { 1245 out << "float4 mod(float4 x, float4 y)\n" 1246 "{\n" 1247 " return x - y * floor(x / y);\n" 1248 "}\n" 1249 "\n"; 1250 } 1251 1252 if (mUsesMod4f) 1253 { 1254 out << "float4 mod(float4 x, float y)\n" 1255 "{\n" 1256 " return x - y * floor(x / y);\n" 1257 "}\n" 1258 "\n"; 1259 } 1260 1261 if (mUsesFaceforward1) 1262 { 1263 out << "float faceforward(float N, float I, float Nref)\n" 1264 "{\n" 1265 " if(dot(Nref, I) >= 0)\n" 1266 " {\n" 1267 " return -N;\n" 1268 " }\n" 1269 " else\n" 1270 " {\n" 1271 " return N;\n" 1272 " }\n" 1273 "}\n" 1274 "\n"; 1275 } 1276 1277 if (mUsesFaceforward2) 1278 { 1279 out << "float2 faceforward(float2 N, float2 I, float2 Nref)\n" 1280 "{\n" 1281 " if(dot(Nref, I) >= 0)\n" 1282 " {\n" 1283 " return -N;\n" 1284 " }\n" 1285 " else\n" 1286 " {\n" 1287 " return N;\n" 1288 " }\n" 1289 "}\n" 1290 "\n"; 1291 } 1292 1293 if (mUsesFaceforward3) 1294 { 1295 out << "float3 faceforward(float3 N, float3 I, float3 Nref)\n" 1296 "{\n" 1297 " if(dot(Nref, I) >= 0)\n" 1298 " {\n" 1299 " return -N;\n" 1300 " }\n" 1301 " else\n" 1302 " {\n" 1303 " return N;\n" 1304 " }\n" 1305 "}\n" 1306 "\n"; 1307 } 1308 1309 if (mUsesFaceforward4) 1310 { 1311 out << "float4 faceforward(float4 N, float4 I, float4 Nref)\n" 1312 "{\n" 1313 " if(dot(Nref, I) >= 0)\n" 1314 " {\n" 1315 " return -N;\n" 1316 " }\n" 1317 " else\n" 1318 " {\n" 1319 " return N;\n" 1320 " }\n" 1321 "}\n" 1322 "\n"; 1323 } 1324 1325 if (mUsesAtan2_1) 1326 { 1327 out << "float atanyx(float y, float x)\n" 1328 "{\n" 1329 " if(x == 0 && y == 0) x = 1;\n" // Avoid producing a NaN 1330 " return atan2(y, x);\n" 1331 "}\n"; 1332 } 1333 1334 if (mUsesAtan2_2) 1335 { 1336 out << "float2 atanyx(float2 y, float2 x)\n" 1337 "{\n" 1338 " if(x[0] == 0 && y[0] == 0) x[0] = 1;\n" 1339 " if(x[1] == 0 && y[1] == 0) x[1] = 1;\n" 1340 " return float2(atan2(y[0], x[0]), atan2(y[1], x[1]));\n" 1341 "}\n"; 1342 } 1343 1344 if (mUsesAtan2_3) 1345 { 1346 out << "float3 atanyx(float3 y, float3 x)\n" 1347 "{\n" 1348 " if(x[0] == 0 && y[0] == 0) x[0] = 1;\n" 1349 " if(x[1] == 0 && y[1] == 0) x[1] = 1;\n" 1350 " if(x[2] == 0 && y[2] == 0) x[2] = 1;\n" 1351 " return float3(atan2(y[0], x[0]), atan2(y[1], x[1]), atan2(y[2], x[2]));\n" 1352 "}\n"; 1353 } 1354 1355 if (mUsesAtan2_4) 1356 { 1357 out << "float4 atanyx(float4 y, float4 x)\n" 1358 "{\n" 1359 " if(x[0] == 0 && y[0] == 0) x[0] = 1;\n" 1360 " if(x[1] == 0 && y[1] == 0) x[1] = 1;\n" 1361 " if(x[2] == 0 && y[2] == 0) x[2] = 1;\n" 1362 " if(x[3] == 0 && y[3] == 0) x[3] = 1;\n" 1363 " return float4(atan2(y[0], x[0]), atan2(y[1], x[1]), atan2(y[2], x[2]), atan2(y[3], x[3]));\n" 1364 "}\n"; 1365 } 1366 } 1367 1368 void OutputHLSL::visitSymbol(TIntermSymbol *node) 1369 { 1370 TInfoSinkBase &out = mBody; 1371 1372 // Handle accessing std140 structs by value 1373 if (mFlaggedStructMappedNames.count(node) > 0) 1374 { 1375 out << mFlaggedStructMappedNames[node]; 1376 return; 1377 } 1378 1379 TString name = node->getSymbol(); 1380 1381 if (name == "gl_DepthRange") 1382 { 1383 mUsesDepthRange = true; 1384 out << name; 1385 } 1386 else 1387 { 1388 TQualifier qualifier = node->getQualifier(); 1389 1390 if (qualifier == EvqUniform) 1391 { 1392 const TType& nodeType = node->getType(); 1393 const TInterfaceBlock* interfaceBlock = nodeType.getInterfaceBlock(); 1394 1395 if (interfaceBlock) 1396 { 1397 mReferencedInterfaceBlocks[interfaceBlock->name()] = node; 1398 } 1399 else 1400 { 1401 mReferencedUniforms[name] = node; 1402 } 1403 1404 out << DecorateUniform(name, nodeType); 1405 } 1406 else if (qualifier == EvqAttribute || qualifier == EvqVertexIn) 1407 { 1408 mReferencedAttributes[name] = node; 1409 out << Decorate(name); 1410 } 1411 else if (IsVarying(qualifier)) 1412 { 1413 mReferencedVaryings[name] = node; 1414 out << Decorate(name); 1415 } 1416 else if (qualifier == EvqFragmentOut) 1417 { 1418 mReferencedOutputVariables[name] = node; 1419 out << "out_" << name; 1420 } 1421 else if (qualifier == EvqFragColor) 1422 { 1423 out << "gl_Color[0]"; 1424 mUsesFragColor = true; 1425 } 1426 else if (qualifier == EvqFragData) 1427 { 1428 out << "gl_Color"; 1429 mUsesFragData = true; 1430 } 1431 else if (qualifier == EvqFragCoord) 1432 { 1433 mUsesFragCoord = true; 1434 out << name; 1435 } 1436 else if (qualifier == EvqPointCoord) 1437 { 1438 mUsesPointCoord = true; 1439 out << name; 1440 } 1441 else if (qualifier == EvqFrontFacing) 1442 { 1443 mUsesFrontFacing = true; 1444 out << name; 1445 } 1446 else if (qualifier == EvqPointSize) 1447 { 1448 mUsesPointSize = true; 1449 out << name; 1450 } 1451 else if (name == "gl_FragDepthEXT") 1452 { 1453 mUsesFragDepth = true; 1454 out << "gl_Depth"; 1455 } 1456 else if (qualifier == EvqInternal) 1457 { 1458 out << name; 1459 } 1460 else 1461 { 1462 out << Decorate(name); 1463 } 1464 } 1465 } 1466 1467 void OutputHLSL::visitRaw(TIntermRaw *node) 1468 { 1469 mBody << node->getRawText(); 1470 } 1471 1472 bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node) 1473 { 1474 TInfoSinkBase &out = mBody; 1475 1476 // Handle accessing std140 structs by value 1477 if (mFlaggedStructMappedNames.count(node) > 0) 1478 { 1479 out << mFlaggedStructMappedNames[node]; 1480 return false; 1481 } 1482 1483 switch (node->getOp()) 1484 { 1485 case EOpAssign: outputTriplet(visit, "(", " = ", ")"); break; 1486 case EOpInitialize: 1487 if (visit == PreVisit) 1488 { 1489 // GLSL allows to write things like "float x = x;" where a new variable x is defined 1490 // and the value of an existing variable x is assigned. HLSL uses C semantics (the 1491 // new variable is created before the assignment is evaluated), so we need to convert 1492 // this to "float t = x, x = t;". 1493 1494 TIntermSymbol *symbolNode = node->getLeft()->getAsSymbolNode(); 1495 TIntermTyped *expression = node->getRight(); 1496 1497 sh::SearchSymbol searchSymbol(symbolNode->getSymbol()); 1498 expression->traverse(&searchSymbol); 1499 bool sameSymbol = searchSymbol.foundMatch(); 1500 1501 if (sameSymbol) 1502 { 1503 // Type already printed 1504 out << "t" + str(mUniqueIndex) + " = "; 1505 expression->traverse(this); 1506 out << ", "; 1507 symbolNode->traverse(this); 1508 out << " = t" + str(mUniqueIndex); 1509 1510 mUniqueIndex++; 1511 return false; 1512 } 1513 } 1514 else if (visit == InVisit) 1515 { 1516 out << " = "; 1517 } 1518 break; 1519 case EOpAddAssign: outputTriplet(visit, "(", " += ", ")"); break; 1520 case EOpSubAssign: outputTriplet(visit, "(", " -= ", ")"); break; 1521 case EOpMulAssign: outputTriplet(visit, "(", " *= ", ")"); break; 1522 case EOpVectorTimesScalarAssign: outputTriplet(visit, "(", " *= ", ")"); break; 1523 case EOpMatrixTimesScalarAssign: outputTriplet(visit, "(", " *= ", ")"); break; 1524 case EOpVectorTimesMatrixAssign: 1525 if (visit == PreVisit) 1526 { 1527 out << "("; 1528 } 1529 else if (visit == InVisit) 1530 { 1531 out << " = mul("; 1532 node->getLeft()->traverse(this); 1533 out << ", transpose("; 1534 } 1535 else 1536 { 1537 out << ")))"; 1538 } 1539 break; 1540 case EOpMatrixTimesMatrixAssign: 1541 if (visit == PreVisit) 1542 { 1543 out << "("; 1544 } 1545 else if (visit == InVisit) 1546 { 1547 out << " = mul("; 1548 node->getLeft()->traverse(this); 1549 out << ", "; 1550 } 1551 else 1552 { 1553 out << "))"; 1554 } 1555 break; 1556 case EOpDivAssign: outputTriplet(visit, "(", " /= ", ")"); break; 1557 case EOpIndexDirect: 1558 { 1559 const TType& leftType = node->getLeft()->getType(); 1560 if (leftType.isInterfaceBlock()) 1561 { 1562 if (visit == PreVisit) 1563 { 1564 TInterfaceBlock* interfaceBlock = leftType.getInterfaceBlock(); 1565 const int arrayIndex = node->getRight()->getAsConstantUnion()->getIConst(0); 1566 mReferencedInterfaceBlocks[interfaceBlock->instanceName()] = node->getLeft()->getAsSymbolNode(); 1567 out << mUniformHLSL->interfaceBlockInstanceString(*interfaceBlock, arrayIndex); 1568 return false; 1569 } 1570 } 1571 else 1572 { 1573 outputTriplet(visit, "", "[", "]"); 1574 } 1575 } 1576 break; 1577 case EOpIndexIndirect: 1578 // We do not currently support indirect references to interface blocks 1579 ASSERT(node->getLeft()->getBasicType() != EbtInterfaceBlock); 1580 outputTriplet(visit, "", "[", "]"); 1581 break; 1582 case EOpIndexDirectStruct: 1583 if (visit == InVisit) 1584 { 1585 const TStructure* structure = node->getLeft()->getType().getStruct(); 1586 const TIntermConstantUnion* index = node->getRight()->getAsConstantUnion(); 1587 const TField* field = structure->fields()[index->getIConst(0)]; 1588 out << "." + DecorateField(field->name(), *structure); 1589 1590 return false; 1591 } 1592 break; 1593 case EOpIndexDirectInterfaceBlock: 1594 if (visit == InVisit) 1595 { 1596 const TInterfaceBlock* interfaceBlock = node->getLeft()->getType().getInterfaceBlock(); 1597 const TIntermConstantUnion* index = node->getRight()->getAsConstantUnion(); 1598 const TField* field = interfaceBlock->fields()[index->getIConst(0)]; 1599 out << "." + Decorate(field->name()); 1600 1601 return false; 1602 } 1603 break; 1604 case EOpVectorSwizzle: 1605 if (visit == InVisit) 1606 { 1607 out << "."; 1608 1609 TIntermAggregate *swizzle = node->getRight()->getAsAggregate(); 1610 1611 if (swizzle) 1612 { 1613 TIntermSequence *sequence = swizzle->getSequence(); 1614 1615 for (TIntermSequence::iterator sit = sequence->begin(); sit != sequence->end(); sit++) 1616 { 1617 TIntermConstantUnion *element = (*sit)->getAsConstantUnion(); 1618 1619 if (element) 1620 { 1621 int i = element->getIConst(0); 1622 1623 switch (i) 1624 { 1625 case 0: out << "x"; break; 1626 case 1: out << "y"; break; 1627 case 2: out << "z"; break; 1628 case 3: out << "w"; break; 1629 default: UNREACHABLE(); 1630 } 1631 } 1632 else UNREACHABLE(); 1633 } 1634 } 1635 else UNREACHABLE(); 1636 1637 return false; // Fully processed 1638 } 1639 break; 1640 case EOpAdd: outputTriplet(visit, "(", " + ", ")"); break; 1641 case EOpSub: outputTriplet(visit, "(", " - ", ")"); break; 1642 case EOpMul: outputTriplet(visit, "(", " * ", ")"); break; 1643 case EOpDiv: outputTriplet(visit, "(", " / ", ")"); break; 1644 case EOpEqual: 1645 case EOpNotEqual: 1646 if (node->getLeft()->isScalar()) 1647 { 1648 if (node->getOp() == EOpEqual) 1649 { 1650 outputTriplet(visit, "(", " == ", ")"); 1651 } 1652 else 1653 { 1654 outputTriplet(visit, "(", " != ", ")"); 1655 } 1656 } 1657 else if (node->getLeft()->getBasicType() == EbtStruct) 1658 { 1659 if (node->getOp() == EOpEqual) 1660 { 1661 out << "("; 1662 } 1663 else 1664 { 1665 out << "!("; 1666 } 1667 1668 const TStructure &structure = *node->getLeft()->getType().getStruct(); 1669 const TFieldList &fields = structure.fields(); 1670 1671 for (size_t i = 0; i < fields.size(); i++) 1672 { 1673 const TField *field = fields[i]; 1674 1675 node->getLeft()->traverse(this); 1676 out << "." + DecorateField(field->name(), structure) + " == "; 1677 node->getRight()->traverse(this); 1678 out << "." + DecorateField(field->name(), structure); 1679 1680 if (i < fields.size() - 1) 1681 { 1682 out << " && "; 1683 } 1684 } 1685 1686 out << ")"; 1687 1688 return false; 1689 } 1690 else 1691 { 1692 ASSERT(node->getLeft()->isMatrix() || node->getLeft()->isVector()); 1693 1694 if (node->getOp() == EOpEqual) 1695 { 1696 outputTriplet(visit, "all(", " == ", ")"); 1697 } 1698 else 1699 { 1700 outputTriplet(visit, "!all(", " == ", ")"); 1701 } 1702 } 1703 break; 1704 case EOpLessThan: outputTriplet(visit, "(", " < ", ")"); break; 1705 case EOpGreaterThan: outputTriplet(visit, "(", " > ", ")"); break; 1706 case EOpLessThanEqual: outputTriplet(visit, "(", " <= ", ")"); break; 1707 case EOpGreaterThanEqual: outputTriplet(visit, "(", " >= ", ")"); break; 1708 case EOpVectorTimesScalar: outputTriplet(visit, "(", " * ", ")"); break; 1709 case EOpMatrixTimesScalar: outputTriplet(visit, "(", " * ", ")"); break; 1710 case EOpVectorTimesMatrix: outputTriplet(visit, "mul(", ", transpose(", "))"); break; 1711 case EOpMatrixTimesVector: outputTriplet(visit, "mul(transpose(", "), ", ")"); break; 1712 case EOpMatrixTimesMatrix: outputTriplet(visit, "transpose(mul(transpose(", "), transpose(", ")))"); break; 1713 case EOpLogicalOr: 1714 if (node->getRight()->hasSideEffects()) 1715 { 1716 out << "s" << mUnfoldShortCircuit->getNextTemporaryIndex(); 1717 return false; 1718 } 1719 else 1720 { 1721 outputTriplet(visit, "(", " || ", ")"); 1722 return true; 1723 } 1724 case EOpLogicalXor: 1725 mUsesXor = true; 1726 outputTriplet(visit, "xor(", ", ", ")"); 1727 break; 1728 case EOpLogicalAnd: 1729 if (node->getRight()->hasSideEffects()) 1730 { 1731 out << "s" << mUnfoldShortCircuit->getNextTemporaryIndex(); 1732 return false; 1733 } 1734 else 1735 { 1736 outputTriplet(visit, "(", " && ", ")"); 1737 return true; 1738 } 1739 default: UNREACHABLE(); 1740 } 1741 1742 return true; 1743 } 1744 1745 bool OutputHLSL::visitUnary(Visit visit, TIntermUnary *node) 1746 { 1747 switch (node->getOp()) 1748 { 1749 case EOpNegative: outputTriplet(visit, "(-", "", ")"); break; 1750 case EOpVectorLogicalNot: outputTriplet(visit, "(!", "", ")"); break; 1751 case EOpLogicalNot: outputTriplet(visit, "(!", "", ")"); break; 1752 case EOpPostIncrement: outputTriplet(visit, "(", "", "++)"); break; 1753 case EOpPostDecrement: outputTriplet(visit, "(", "", "--)"); break; 1754 case EOpPreIncrement: outputTriplet(visit, "(++", "", ")"); break; 1755 case EOpPreDecrement: outputTriplet(visit, "(--", "", ")"); break; 1756 case EOpRadians: outputTriplet(visit, "radians(", "", ")"); break; 1757 case EOpDegrees: outputTriplet(visit, "degrees(", "", ")"); break; 1758 case EOpSin: outputTriplet(visit, "sin(", "", ")"); break; 1759 case EOpCos: outputTriplet(visit, "cos(", "", ")"); break; 1760 case EOpTan: outputTriplet(visit, "tan(", "", ")"); break; 1761 case EOpAsin: outputTriplet(visit, "asin(", "", ")"); break; 1762 case EOpAcos: outputTriplet(visit, "acos(", "", ")"); break; 1763 case EOpAtan: outputTriplet(visit, "atan(", "", ")"); break; 1764 case EOpExp: outputTriplet(visit, "exp(", "", ")"); break; 1765 case EOpLog: outputTriplet(visit, "log(", "", ")"); break; 1766 case EOpExp2: outputTriplet(visit, "exp2(", "", ")"); break; 1767 case EOpLog2: outputTriplet(visit, "log2(", "", ")"); break; 1768 case EOpSqrt: outputTriplet(visit, "sqrt(", "", ")"); break; 1769 case EOpInverseSqrt: outputTriplet(visit, "rsqrt(", "", ")"); break; 1770 case EOpAbs: outputTriplet(visit, "abs(", "", ")"); break; 1771 case EOpSign: outputTriplet(visit, "sign(", "", ")"); break; 1772 case EOpFloor: outputTriplet(visit, "floor(", "", ")"); break; 1773 case EOpCeil: outputTriplet(visit, "ceil(", "", ")"); break; 1774 case EOpFract: outputTriplet(visit, "frac(", "", ")"); break; 1775 case EOpLength: outputTriplet(visit, "length(", "", ")"); break; 1776 case EOpNormalize: outputTriplet(visit, "normalize(", "", ")"); break; 1777 case EOpDFdx: 1778 if(mInsideDiscontinuousLoop || mOutputLod0Function) 1779 { 1780 outputTriplet(visit, "(", "", ", 0.0)"); 1781 } 1782 else 1783 { 1784 outputTriplet(visit, "ddx(", "", ")"); 1785 } 1786 break; 1787 case EOpDFdy: 1788 if(mInsideDiscontinuousLoop || mOutputLod0Function) 1789 { 1790 outputTriplet(visit, "(", "", ", 0.0)"); 1791 } 1792 else 1793 { 1794 outputTriplet(visit, "ddy(", "", ")"); 1795 } 1796 break; 1797 case EOpFwidth: 1798 if(mInsideDiscontinuousLoop || mOutputLod0Function) 1799 { 1800 outputTriplet(visit, "(", "", ", 0.0)"); 1801 } 1802 else 1803 { 1804 outputTriplet(visit, "fwidth(", "", ")"); 1805 } 1806 break; 1807 case EOpAny: outputTriplet(visit, "any(", "", ")"); break; 1808 case EOpAll: outputTriplet(visit, "all(", "", ")"); break; 1809 default: UNREACHABLE(); 1810 } 1811 1812 return true; 1813 } 1814 1815 bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node) 1816 { 1817 TInfoSinkBase &out = mBody; 1818 1819 switch (node->getOp()) 1820 { 1821 case EOpSequence: 1822 { 1823 if (mInsideFunction) 1824 { 1825 outputLineDirective(node->getLine().first_line); 1826 out << "{\n"; 1827 } 1828 1829 for (TIntermSequence::iterator sit = node->getSequence()->begin(); sit != node->getSequence()->end(); sit++) 1830 { 1831 outputLineDirective((*sit)->getLine().first_line); 1832 1833 traverseStatements(*sit); 1834 1835 out << ";\n"; 1836 } 1837 1838 if (mInsideFunction) 1839 { 1840 outputLineDirective(node->getLine().last_line); 1841 out << "}\n"; 1842 } 1843 1844 return false; 1845 } 1846 case EOpDeclaration: 1847 if (visit == PreVisit) 1848 { 1849 TIntermSequence *sequence = node->getSequence(); 1850 TIntermTyped *variable = (*sequence)[0]->getAsTyped(); 1851 1852 if (variable && (variable->getQualifier() == EvqTemporary || variable->getQualifier() == EvqGlobal)) 1853 { 1854 TStructure *structure = variable->getType().getStruct(); 1855 1856 if (structure) 1857 { 1858 mStructureHLSL->addConstructor(variable->getType(), StructNameString(*structure), NULL); 1859 } 1860 1861 if (!variable->getAsSymbolNode() || variable->getAsSymbolNode()->getSymbol() != "") // Variable declaration 1862 { 1863 if (!mInsideFunction) 1864 { 1865 out << "static "; 1866 } 1867 1868 out << TypeString(variable->getType()) + " "; 1869 1870 for (TIntermSequence::iterator sit = sequence->begin(); sit != sequence->end(); sit++) 1871 { 1872 TIntermSymbol *symbol = (*sit)->getAsSymbolNode(); 1873 1874 if (symbol) 1875 { 1876 symbol->traverse(this); 1877 out << ArrayString(symbol->getType()); 1878 out << " = " + initializer(symbol->getType()); 1879 } 1880 else 1881 { 1882 (*sit)->traverse(this); 1883 } 1884 1885 if (*sit != sequence->back()) 1886 { 1887 out << ", "; 1888 } 1889 } 1890 } 1891 else if (variable->getAsSymbolNode() && variable->getAsSymbolNode()->getSymbol() == "") // Type (struct) declaration 1892 { 1893 // Already added to constructor map 1894 } 1895 else UNREACHABLE(); 1896 } 1897 else if (variable && IsVaryingOut(variable->getQualifier())) 1898 { 1899 for (TIntermSequence::iterator sit = sequence->begin(); sit != sequence->end(); sit++) 1900 { 1901 TIntermSymbol *symbol = (*sit)->getAsSymbolNode(); 1902 1903 if (symbol) 1904 { 1905 // Vertex (output) varyings which are declared but not written to should still be declared to allow successful linking 1906 mReferencedVaryings[symbol->getSymbol()] = symbol; 1907 } 1908 else 1909 { 1910 (*sit)->traverse(this); 1911 } 1912 } 1913 } 1914 1915 return false; 1916 } 1917 else if (visit == InVisit) 1918 { 1919 out << ", "; 1920 } 1921 break; 1922 case EOpInvariantDeclaration: 1923 // Do not do any translation 1924 return false; 1925 case EOpPrototype: 1926 if (visit == PreVisit) 1927 { 1928 out << TypeString(node->getType()) << " " << Decorate(node->getName()) << (mOutputLod0Function ? "Lod0(" : "("); 1929 1930 TIntermSequence *arguments = node->getSequence(); 1931 1932 for (unsigned int i = 0; i < arguments->size(); i++) 1933 { 1934 TIntermSymbol *symbol = (*arguments)[i]->getAsSymbolNode(); 1935 1936 if (symbol) 1937 { 1938 out << argumentString(symbol); 1939 1940 if (i < arguments->size() - 1) 1941 { 1942 out << ", "; 1943 } 1944 } 1945 else UNREACHABLE(); 1946 } 1947 1948 out << ");\n"; 1949 1950 // Also prototype the Lod0 variant if needed 1951 if (mContainsLoopDiscontinuity && !mOutputLod0Function) 1952 { 1953 mOutputLod0Function = true; 1954 node->traverse(this); 1955 mOutputLod0Function = false; 1956 } 1957 1958 return false; 1959 } 1960 break; 1961 case EOpComma: outputTriplet(visit, "(", ", ", ")"); break; 1962 case EOpFunction: 1963 { 1964 TString name = TFunction::unmangleName(node->getName()); 1965 1966 out << TypeString(node->getType()) << " "; 1967 1968 if (name == "main") 1969 { 1970 out << "gl_main("; 1971 } 1972 else 1973 { 1974 out << Decorate(name) << (mOutputLod0Function ? "Lod0(" : "("); 1975 } 1976 1977 TIntermSequence *sequence = node->getSequence(); 1978 TIntermSequence *arguments = (*sequence)[0]->getAsAggregate()->getSequence(); 1979 1980 for (unsigned int i = 0; i < arguments->size(); i++) 1981 { 1982 TIntermSymbol *symbol = (*arguments)[i]->getAsSymbolNode(); 1983 1984 if (symbol) 1985 { 1986 TStructure *structure = symbol->getType().getStruct(); 1987 1988 if (structure) 1989 { 1990 mStructureHLSL->addConstructor(symbol->getType(), StructNameString(*structure), NULL); 1991 } 1992 1993 out << argumentString(symbol); 1994 1995 if (i < arguments->size() - 1) 1996 { 1997 out << ", "; 1998 } 1999 } 2000 else UNREACHABLE(); 2001 } 2002 2003 out << ")\n" 2004 "{\n"; 2005 2006 if (sequence->size() > 1) 2007 { 2008 mInsideFunction = true; 2009 (*sequence)[1]->traverse(this); 2010 mInsideFunction = false; 2011 } 2012 2013 out << "}\n"; 2014 2015 if (mContainsLoopDiscontinuity && !mOutputLod0Function) 2016 { 2017 if (name != "main") 2018 { 2019 mOutputLod0Function = true; 2020 node->traverse(this); 2021 mOutputLod0Function = false; 2022 } 2023 } 2024 2025 return false; 2026 } 2027 break; 2028 case EOpFunctionCall: 2029 { 2030 TString name = TFunction::unmangleName(node->getName()); 2031 bool lod0 = mInsideDiscontinuousLoop || mOutputLod0Function; 2032 TIntermSequence *arguments = node->getSequence(); 2033 2034 if (node->isUserDefined()) 2035 { 2036 out << Decorate(name) << (lod0 ? "Lod0(" : "("); 2037 } 2038 else 2039 { 2040 TBasicType samplerType = (*arguments)[0]->getAsTyped()->getType().getBasicType(); 2041 2042 TextureFunction textureFunction; 2043 textureFunction.sampler = samplerType; 2044 textureFunction.coords = (*arguments)[1]->getAsTyped()->getNominalSize(); 2045 textureFunction.method = TextureFunction::IMPLICIT; 2046 textureFunction.proj = false; 2047 textureFunction.offset = false; 2048 2049 if (name == "texture2D" || name == "textureCube" || name == "texture") 2050 { 2051 textureFunction.method = TextureFunction::IMPLICIT; 2052 } 2053 else if (name == "texture2DProj" || name == "textureProj") 2054 { 2055 textureFunction.method = TextureFunction::IMPLICIT; 2056 textureFunction.proj = true; 2057 } 2058 else if (name == "texture2DLod" || name == "textureCubeLod" || name == "textureLod" || 2059 name == "texture2DLodEXT" || name == "textureCubeLodEXT") 2060 { 2061 textureFunction.method = TextureFunction::LOD; 2062 } 2063 else if (name == "texture2DProjLod" || name == "textureProjLod" || name == "texture2DProjLodEXT") 2064 { 2065 textureFunction.method = TextureFunction::LOD; 2066 textureFunction.proj = true; 2067 } 2068 else if (name == "textureSize") 2069 { 2070 textureFunction.method = TextureFunction::SIZE; 2071 } 2072 else if (name == "textureOffset") 2073 { 2074 textureFunction.method = TextureFunction::IMPLICIT; 2075 textureFunction.offset = true; 2076 } 2077 else if (name == "textureProjOffset") 2078 { 2079 textureFunction.method = TextureFunction::IMPLICIT; 2080 textureFunction.offset = true; 2081 textureFunction.proj = true; 2082 } 2083 else if (name == "textureLodOffset") 2084 { 2085 textureFunction.method = TextureFunction::LOD; 2086 textureFunction.offset = true; 2087 } 2088 else if (name == "textureProjLodOffset") 2089 { 2090 textureFunction.method = TextureFunction::LOD; 2091 textureFunction.proj = true; 2092 textureFunction.offset = true; 2093 } 2094 else if (name == "texelFetch") 2095 { 2096 textureFunction.method = TextureFunction::FETCH; 2097 } 2098 else if (name == "texelFetchOffset") 2099 { 2100 textureFunction.method = TextureFunction::FETCH; 2101 textureFunction.offset = true; 2102 } 2103 else if (name == "textureGrad" || name == "texture2DGradEXT") 2104 { 2105 textureFunction.method = TextureFunction::GRAD; 2106 } 2107 else if (name == "textureGradOffset") 2108 { 2109 textureFunction.method = TextureFunction::GRAD; 2110 textureFunction.offset = true; 2111 } 2112 else if (name == "textureProjGrad" || name == "texture2DProjGradEXT" || name == "textureCubeGradEXT") 2113 { 2114 textureFunction.method = TextureFunction::GRAD; 2115 textureFunction.proj = true; 2116 } 2117 else if (name == "textureProjGradOffset") 2118 { 2119 textureFunction.method = TextureFunction::GRAD; 2120 textureFunction.proj = true; 2121 textureFunction.offset = true; 2122 } 2123 else UNREACHABLE(); 2124 2125 if (textureFunction.method == TextureFunction::IMPLICIT) // Could require lod 0 or have a bias argument 2126 { 2127 unsigned int mandatoryArgumentCount = 2; // All functions have sampler and coordinate arguments 2128 2129 if (textureFunction.offset) 2130 { 2131 mandatoryArgumentCount++; 2132 } 2133 2134 bool bias = (arguments->size() > mandatoryArgumentCount); // Bias argument is optional 2135 2136 if (lod0 || mContext.shaderType == GL_VERTEX_SHADER) 2137 { 2138 if (bias) 2139 { 2140 textureFunction.method = TextureFunction::LOD0BIAS; 2141 } 2142 else 2143 { 2144 textureFunction.method = TextureFunction::LOD0; 2145 } 2146 } 2147 else if (bias) 2148 { 2149 textureFunction.method = TextureFunction::BIAS; 2150 } 2151 } 2152 2153 mUsesTexture.insert(textureFunction); 2154 2155 out << textureFunction.name(); 2156 } 2157 2158 for (TIntermSequence::iterator arg = arguments->begin(); arg != arguments->end(); arg++) 2159 { 2160 if (mOutputType == SH_HLSL11_OUTPUT && IsSampler((*arg)->getAsTyped()->getBasicType())) 2161 { 2162 out << "texture_"; 2163 (*arg)->traverse(this); 2164 out << ", sampler_"; 2165 } 2166 2167 (*arg)->traverse(this); 2168 2169 if (arg < arguments->end() - 1) 2170 { 2171 out << ", "; 2172 } 2173 } 2174 2175 out << ")"; 2176 2177 return false; 2178 } 2179 break; 2180 case EOpParameters: outputTriplet(visit, "(", ", ", ")\n{\n"); break; 2181 case EOpConstructFloat: outputConstructor(visit, node->getType(), "vec1", node->getSequence()); break; 2182 case EOpConstructVec2: outputConstructor(visit, node->getType(), "vec2", node->getSequence()); break; 2183 case EOpConstructVec3: outputConstructor(visit, node->getType(), "vec3", node->getSequence()); break; 2184 case EOpConstructVec4: outputConstructor(visit, node->getType(), "vec4", node->getSequence()); break; 2185 case EOpConstructBool: outputConstructor(visit, node->getType(), "bvec1", node->getSequence()); break; 2186 case EOpConstructBVec2: outputConstructor(visit, node->getType(), "bvec2", node->getSequence()); break; 2187 case EOpConstructBVec3: outputConstructor(visit, node->getType(), "bvec3", node->getSequence()); break; 2188 case EOpConstructBVec4: outputConstructor(visit, node->getType(), "bvec4", node->getSequence()); break; 2189 case EOpConstructInt: outputConstructor(visit, node->getType(), "ivec1", node->getSequence()); break; 2190 case EOpConstructIVec2: outputConstructor(visit, node->getType(), "ivec2", node->getSequence()); break; 2191 case EOpConstructIVec3: outputConstructor(visit, node->getType(), "ivec3", node->getSequence()); break; 2192 case EOpConstructIVec4: outputConstructor(visit, node->getType(), "ivec4", node->getSequence()); break; 2193 case EOpConstructUInt: outputConstructor(visit, node->getType(), "uvec1", node->getSequence()); break; 2194 case EOpConstructUVec2: outputConstructor(visit, node->getType(), "uvec2", node->getSequence()); break; 2195 case EOpConstructUVec3: outputConstructor(visit, node->getType(), "uvec3", node->getSequence()); break; 2196 case EOpConstructUVec4: outputConstructor(visit, node->getType(), "uvec4", node->getSequence()); break; 2197 case EOpConstructMat2: outputConstructor(visit, node->getType(), "mat2", node->getSequence()); break; 2198 case EOpConstructMat3: outputConstructor(visit, node->getType(), "mat3", node->getSequence()); break; 2199 case EOpConstructMat4: outputConstructor(visit, node->getType(), "mat4", node->getSequence()); break; 2200 case EOpConstructStruct: 2201 { 2202 const TString &structName = StructNameString(*node->getType().getStruct()); 2203 mStructureHLSL->addConstructor(node->getType(), structName, node->getSequence()); 2204 outputTriplet(visit, structName + "_ctor(", ", ", ")"); 2205 } 2206 break; 2207 case EOpLessThan: outputTriplet(visit, "(", " < ", ")"); break; 2208 case EOpGreaterThan: outputTriplet(visit, "(", " > ", ")"); break; 2209 case EOpLessThanEqual: outputTriplet(visit, "(", " <= ", ")"); break; 2210 case EOpGreaterThanEqual: outputTriplet(visit, "(", " >= ", ")"); break; 2211 case EOpVectorEqual: outputTriplet(visit, "(", " == ", ")"); break; 2212 case EOpVectorNotEqual: outputTriplet(visit, "(", " != ", ")"); break; 2213 case EOpMod: 2214 { 2215 // We need to look at the number of components in both arguments 2216 const int modValue = (*node->getSequence())[0]->getAsTyped()->getNominalSize() * 10 + 2217 (*node->getSequence())[1]->getAsTyped()->getNominalSize(); 2218 switch (modValue) 2219 { 2220 case 11: mUsesMod1 = true; break; 2221 case 22: mUsesMod2v = true; break; 2222 case 21: mUsesMod2f = true; break; 2223 case 33: mUsesMod3v = true; break; 2224 case 31: mUsesMod3f = true; break; 2225 case 44: mUsesMod4v = true; break; 2226 case 41: mUsesMod4f = true; break; 2227 default: UNREACHABLE(); 2228 } 2229 2230 outputTriplet(visit, "mod(", ", ", ")"); 2231 } 2232 break; 2233 case EOpPow: outputTriplet(visit, "pow(", ", ", ")"); break; 2234 case EOpAtan: 2235 ASSERT(node->getSequence()->size() == 2); // atan(x) is a unary operator 2236 switch ((*node->getSequence())[0]->getAsTyped()->getNominalSize()) 2237 { 2238 case 1: mUsesAtan2_1 = true; break; 2239 case 2: mUsesAtan2_2 = true; break; 2240 case 3: mUsesAtan2_3 = true; break; 2241 case 4: mUsesAtan2_4 = true; break; 2242 default: UNREACHABLE(); 2243 } 2244 outputTriplet(visit, "atanyx(", ", ", ")"); 2245 break; 2246 case EOpMin: outputTriplet(visit, "min(", ", ", ")"); break; 2247 case EOpMax: outputTriplet(visit, "max(", ", ", ")"); break; 2248 case EOpClamp: outputTriplet(visit, "clamp(", ", ", ")"); break; 2249 case EOpMix: outputTriplet(visit, "lerp(", ", ", ")"); break; 2250 case EOpStep: outputTriplet(visit, "step(", ", ", ")"); break; 2251 case EOpSmoothStep: outputTriplet(visit, "smoothstep(", ", ", ")"); break; 2252 case EOpDistance: outputTriplet(visit, "distance(", ", ", ")"); break; 2253 case EOpDot: outputTriplet(visit, "dot(", ", ", ")"); break; 2254 case EOpCross: outputTriplet(visit, "cross(", ", ", ")"); break; 2255 case EOpFaceForward: 2256 { 2257 switch ((*node->getSequence())[0]->getAsTyped()->getNominalSize()) // Number of components in the first argument 2258 { 2259 case 1: mUsesFaceforward1 = true; break; 2260 case 2: mUsesFaceforward2 = true; break; 2261 case 3: mUsesFaceforward3 = true; break; 2262 case 4: mUsesFaceforward4 = true; break; 2263 default: UNREACHABLE(); 2264 } 2265 2266 outputTriplet(visit, "faceforward(", ", ", ")"); 2267 } 2268 break; 2269 case EOpReflect: outputTriplet(visit, "reflect(", ", ", ")"); break; 2270 case EOpRefract: outputTriplet(visit, "refract(", ", ", ")"); break; 2271 case EOpMul: outputTriplet(visit, "(", " * ", ")"); break; 2272 default: UNREACHABLE(); 2273 } 2274 2275 return true; 2276 } 2277 2278 bool OutputHLSL::visitSelection(Visit visit, TIntermSelection *node) 2279 { 2280 TInfoSinkBase &out = mBody; 2281 2282 if (node->usesTernaryOperator()) 2283 { 2284 out << "s" << mUnfoldShortCircuit->getNextTemporaryIndex(); 2285 } 2286 else // if/else statement 2287 { 2288 mUnfoldShortCircuit->traverse(node->getCondition()); 2289 2290 out << "if ("; 2291 2292 node->getCondition()->traverse(this); 2293 2294 out << ")\n"; 2295 2296 outputLineDirective(node->getLine().first_line); 2297 out << "{\n"; 2298 2299 bool discard = false; 2300 2301 if (node->getTrueBlock()) 2302 { 2303 traverseStatements(node->getTrueBlock()); 2304 2305 // Detect true discard 2306 discard = (discard || FindDiscard::search(node->getTrueBlock())); 2307 } 2308 2309 outputLineDirective(node->getLine().first_line); 2310 out << ";\n}\n"; 2311 2312 if (node->getFalseBlock()) 2313 { 2314 out << "else\n"; 2315 2316 outputLineDirective(node->getFalseBlock()->getLine().first_line); 2317 out << "{\n"; 2318 2319 outputLineDirective(node->getFalseBlock()->getLine().first_line); 2320 traverseStatements(node->getFalseBlock()); 2321 2322 outputLineDirective(node->getFalseBlock()->getLine().first_line); 2323 out << ";\n}\n"; 2324 2325 // Detect false discard 2326 discard = (discard || FindDiscard::search(node->getFalseBlock())); 2327 } 2328 2329 // ANGLE issue 486: Detect problematic conditional discard 2330 if (discard && FindSideEffectRewriting::search(node)) 2331 { 2332 mUsesDiscardRewriting = true; 2333 } 2334 } 2335 2336 return false; 2337 } 2338 2339 void OutputHLSL::visitConstantUnion(TIntermConstantUnion *node) 2340 { 2341 writeConstantUnion(node->getType(), node->getUnionArrayPointer()); 2342 } 2343 2344 bool OutputHLSL::visitLoop(Visit visit, TIntermLoop *node) 2345 { 2346 mNestedLoopDepth++; 2347 2348 bool wasDiscontinuous = mInsideDiscontinuousLoop; 2349 2350 if (mContainsLoopDiscontinuity && !mInsideDiscontinuousLoop) 2351 { 2352 mInsideDiscontinuousLoop = containsLoopDiscontinuity(node); 2353 } 2354 2355 if (mOutputType == SH_HLSL9_OUTPUT) 2356 { 2357 if (handleExcessiveLoop(node)) 2358 { 2359 mInsideDiscontinuousLoop = wasDiscontinuous; 2360 mNestedLoopDepth--; 2361 2362 return false; 2363 } 2364 } 2365 2366 TInfoSinkBase &out = mBody; 2367 2368 if (node->getType() == ELoopDoWhile) 2369 { 2370 out << "{do\n"; 2371 2372 outputLineDirective(node->getLine().first_line); 2373 out << "{\n"; 2374 } 2375 else 2376 { 2377 out << "{for("; 2378 2379 if (node->getInit()) 2380 { 2381 node->getInit()->traverse(this); 2382 } 2383 2384 out << "; "; 2385 2386 if (node->getCondition()) 2387 { 2388 node->getCondition()->traverse(this); 2389 } 2390 2391 out << "; "; 2392 2393 if (node->getExpression()) 2394 { 2395 node->getExpression()->traverse(this); 2396 } 2397 2398 out << ")\n"; 2399 2400 outputLineDirective(node->getLine().first_line); 2401 out << "{\n"; 2402 } 2403 2404 if (node->getBody()) 2405 { 2406 traverseStatements(node->getBody()); 2407 } 2408 2409 outputLineDirective(node->getLine().first_line); 2410 out << ";}\n"; 2411 2412 if (node->getType() == ELoopDoWhile) 2413 { 2414 outputLineDirective(node->getCondition()->getLine().first_line); 2415 out << "while(\n"; 2416 2417 node->getCondition()->traverse(this); 2418 2419 out << ");"; 2420 } 2421 2422 out << "}\n"; 2423 2424 mInsideDiscontinuousLoop = wasDiscontinuous; 2425 mNestedLoopDepth--; 2426 2427 return false; 2428 } 2429 2430 bool OutputHLSL::visitBranch(Visit visit, TIntermBranch *node) 2431 { 2432 TInfoSinkBase &out = mBody; 2433 2434 switch (node->getFlowOp()) 2435 { 2436 case EOpKill: 2437 outputTriplet(visit, "discard;\n", "", ""); 2438 break; 2439 case EOpBreak: 2440 if (visit == PreVisit) 2441 { 2442 if (mNestedLoopDepth > 1) 2443 { 2444 mUsesNestedBreak = true; 2445 } 2446 2447 if (mExcessiveLoopIndex) 2448 { 2449 out << "{Break"; 2450 mExcessiveLoopIndex->traverse(this); 2451 out << " = true; break;}\n"; 2452 } 2453 else 2454 { 2455 out << "break;\n"; 2456 } 2457 } 2458 break; 2459 case EOpContinue: outputTriplet(visit, "continue;\n", "", ""); break; 2460 case EOpReturn: 2461 if (visit == PreVisit) 2462 { 2463 if (node->getExpression()) 2464 { 2465 out << "return "; 2466 } 2467 else 2468 { 2469 out << "return;\n"; 2470 } 2471 } 2472 else if (visit == PostVisit) 2473 { 2474 if (node->getExpression()) 2475 { 2476 out << ";\n"; 2477 } 2478 } 2479 break; 2480 default: UNREACHABLE(); 2481 } 2482 2483 return true; 2484 } 2485 2486 void OutputHLSL::traverseStatements(TIntermNode *node) 2487 { 2488 if (isSingleStatement(node)) 2489 { 2490 mUnfoldShortCircuit->traverse(node); 2491 } 2492 2493 node->traverse(this); 2494 } 2495 2496 bool OutputHLSL::isSingleStatement(TIntermNode *node) 2497 { 2498 TIntermAggregate *aggregate = node->getAsAggregate(); 2499 2500 if (aggregate) 2501 { 2502 if (aggregate->getOp() == EOpSequence) 2503 { 2504 return false; 2505 } 2506 else 2507 { 2508 for (TIntermSequence::iterator sit = aggregate->getSequence()->begin(); sit != aggregate->getSequence()->end(); sit++) 2509 { 2510 if (!isSingleStatement(*sit)) 2511 { 2512 return false; 2513 } 2514 } 2515 2516 return true; 2517 } 2518 } 2519 2520 return true; 2521 } 2522 2523 // Handle loops with more than 254 iterations (unsupported by D3D9) by splitting them 2524 // (The D3D documentation says 255 iterations, but the compiler complains at anything more than 254). 2525 bool OutputHLSL::handleExcessiveLoop(TIntermLoop *node) 2526 { 2527 const int MAX_LOOP_ITERATIONS = 254; 2528 TInfoSinkBase &out = mBody; 2529 2530 // Parse loops of the form: 2531 // for(int index = initial; index [comparator] limit; index += increment) 2532 TIntermSymbol *index = NULL; 2533 TOperator comparator = EOpNull; 2534 int initial = 0; 2535 int limit = 0; 2536 int increment = 0; 2537 2538 // Parse index name and intial value 2539 if (node->getInit()) 2540 { 2541 TIntermAggregate *init = node->getInit()->getAsAggregate(); 2542 2543 if (init) 2544 { 2545 TIntermSequence *sequence = init->getSequence(); 2546 TIntermTyped *variable = (*sequence)[0]->getAsTyped(); 2547 2548 if (variable && variable->getQualifier() == EvqTemporary) 2549 { 2550 TIntermBinary *assign = variable->getAsBinaryNode(); 2551 2552 if (assign->getOp() == EOpInitialize) 2553 { 2554 TIntermSymbol *symbol = assign->getLeft()->getAsSymbolNode(); 2555 TIntermConstantUnion *constant = assign->getRight()->getAsConstantUnion(); 2556 2557 if (symbol && constant) 2558 { 2559 if (constant->getBasicType() == EbtInt && constant->isScalar()) 2560 { 2561 index = symbol; 2562 initial = constant->getIConst(0); 2563 } 2564 } 2565 } 2566 } 2567 } 2568 } 2569 2570 // Parse comparator and limit value 2571 if (index != NULL && node->getCondition()) 2572 { 2573 TIntermBinary *test = node->getCondition()->getAsBinaryNode(); 2574 2575 if (test && test->getLeft()->getAsSymbolNode()->getId() == index->getId()) 2576 { 2577 TIntermConstantUnion *constant = test->getRight()->getAsConstantUnion(); 2578 2579 if (constant) 2580 { 2581 if (constant->getBasicType() == EbtInt && constant->isScalar()) 2582 { 2583 comparator = test->getOp(); 2584 limit = constant->getIConst(0); 2585 } 2586 } 2587 } 2588 } 2589 2590 // Parse increment 2591 if (index != NULL && comparator != EOpNull && node->getExpression()) 2592 { 2593 TIntermBinary *binaryTerminal = node->getExpression()->getAsBinaryNode(); 2594 TIntermUnary *unaryTerminal = node->getExpression()->getAsUnaryNode(); 2595 2596 if (binaryTerminal) 2597 { 2598 TOperator op = binaryTerminal->getOp(); 2599 TIntermConstantUnion *constant = binaryTerminal->getRight()->getAsConstantUnion(); 2600 2601 if (constant) 2602 { 2603 if (constant->getBasicType() == EbtInt && constant->isScalar()) 2604 { 2605 int value = constant->getIConst(0); 2606 2607 switch (op) 2608 { 2609 case EOpAddAssign: increment = value; break; 2610 case EOpSubAssign: increment = -value; break; 2611 default: UNIMPLEMENTED(); 2612 } 2613 } 2614 } 2615 } 2616 else if (unaryTerminal) 2617 { 2618 TOperator op = unaryTerminal->getOp(); 2619 2620 switch (op) 2621 { 2622 case EOpPostIncrement: increment = 1; break; 2623 case EOpPostDecrement: increment = -1; break; 2624 case EOpPreIncrement: increment = 1; break; 2625 case EOpPreDecrement: increment = -1; break; 2626 default: UNIMPLEMENTED(); 2627 } 2628 } 2629 } 2630 2631 if (index != NULL && comparator != EOpNull && increment != 0) 2632 { 2633 if (comparator == EOpLessThanEqual) 2634 { 2635 comparator = EOpLessThan; 2636 limit += 1; 2637 } 2638 2639 if (comparator == EOpLessThan) 2640 { 2641 int iterations = (limit - initial) / increment; 2642 2643 if (iterations <= MAX_LOOP_ITERATIONS) 2644 { 2645 return false; // Not an excessive loop 2646 } 2647 2648 TIntermSymbol *restoreIndex = mExcessiveLoopIndex; 2649 mExcessiveLoopIndex = index; 2650 2651 out << "{int "; 2652 index->traverse(this); 2653 out << ";\n" 2654 "bool Break"; 2655 index->traverse(this); 2656 out << " = false;\n"; 2657 2658 bool firstLoopFragment = true; 2659 2660 while (iterations > 0) 2661 { 2662 int clampedLimit = initial + increment * std::min(MAX_LOOP_ITERATIONS, iterations); 2663 2664 if (!firstLoopFragment) 2665 { 2666 out << "if (!Break"; 2667 index->traverse(this); 2668 out << ") {\n"; 2669 } 2670 2671 if (iterations <= MAX_LOOP_ITERATIONS) // Last loop fragment 2672 { 2673 mExcessiveLoopIndex = NULL; // Stops setting the Break flag 2674 } 2675 2676 // for(int index = initial; index < clampedLimit; index += increment) 2677 2678 out << "for("; 2679 index->traverse(this); 2680 out << " = "; 2681 out << initial; 2682 2683 out << "; "; 2684 index->traverse(this); 2685 out << " < "; 2686 out << clampedLimit; 2687 2688 out << "; "; 2689 index->traverse(this); 2690 out << " += "; 2691 out << increment; 2692 out << ")\n"; 2693 2694 outputLineDirective(node->getLine().first_line); 2695 out << "{\n"; 2696 2697 if (node->getBody()) 2698 { 2699 node->getBody()->traverse(this); 2700 } 2701 2702 outputLineDirective(node->getLine().first_line); 2703 out << ";}\n"; 2704 2705 if (!firstLoopFragment) 2706 { 2707 out << "}\n"; 2708 } 2709 2710 firstLoopFragment = false; 2711 2712 initial += MAX_LOOP_ITERATIONS * increment; 2713 iterations -= MAX_LOOP_ITERATIONS; 2714 } 2715 2716 out << "}"; 2717 2718 mExcessiveLoopIndex = restoreIndex; 2719 2720 return true; 2721 } 2722 else UNIMPLEMENTED(); 2723 } 2724 2725 return false; // Not handled as an excessive loop 2726 } 2727 2728 void OutputHLSL::outputTriplet(Visit visit, const TString &preString, const TString &inString, const TString &postString) 2729 { 2730 TInfoSinkBase &out = mBody; 2731 2732 if (visit == PreVisit) 2733 { 2734 out << preString; 2735 } 2736 else if (visit == InVisit) 2737 { 2738 out << inString; 2739 } 2740 else if (visit == PostVisit) 2741 { 2742 out << postString; 2743 } 2744 } 2745 2746 void OutputHLSL::outputLineDirective(int line) 2747 { 2748 if ((mContext.compileOptions & SH_LINE_DIRECTIVES) && (line > 0)) 2749 { 2750 mBody << "\n"; 2751 mBody << "#line " << line; 2752 2753 if (mContext.sourcePath) 2754 { 2755 mBody << " \"" << mContext.sourcePath << "\""; 2756 } 2757 2758 mBody << "\n"; 2759 } 2760 } 2761 2762 TString OutputHLSL::argumentString(const TIntermSymbol *symbol) 2763 { 2764 TQualifier qualifier = symbol->getQualifier(); 2765 const TType &type = symbol->getType(); 2766 TString name = symbol->getSymbol(); 2767 2768 if (name.empty()) // HLSL demands named arguments, also for prototypes 2769 { 2770 name = "x" + str(mUniqueIndex++); 2771 } 2772 else 2773 { 2774 name = Decorate(name); 2775 } 2776 2777 if (mOutputType == SH_HLSL11_OUTPUT && IsSampler(type.getBasicType())) 2778 { 2779 return QualifierString(qualifier) + " " + TextureString(type) + " texture_" + name + ArrayString(type) + ", " + 2780 QualifierString(qualifier) + " " + SamplerString(type) + " sampler_" + name + ArrayString(type); 2781 } 2782 2783 return QualifierString(qualifier) + " " + TypeString(type) + " " + name + ArrayString(type); 2784 } 2785 2786 TString OutputHLSL::initializer(const TType &type) 2787 { 2788 TString string; 2789 2790 size_t size = type.getObjectSize(); 2791 for (size_t component = 0; component < size; component++) 2792 { 2793 string += "0"; 2794 2795 if (component + 1 < size) 2796 { 2797 string += ", "; 2798 } 2799 } 2800 2801 return "{" + string + "}"; 2802 } 2803 2804 void OutputHLSL::outputConstructor(Visit visit, const TType &type, const TString &name, const TIntermSequence *parameters) 2805 { 2806 TInfoSinkBase &out = mBody; 2807 2808 if (visit == PreVisit) 2809 { 2810 mStructureHLSL->addConstructor(type, name, parameters); 2811 2812 out << name + "("; 2813 } 2814 else if (visit == InVisit) 2815 { 2816 out << ", "; 2817 } 2818 else if (visit == PostVisit) 2819 { 2820 out << ")"; 2821 } 2822 } 2823 2824 const ConstantUnion *OutputHLSL::writeConstantUnion(const TType &type, const ConstantUnion *constUnion) 2825 { 2826 TInfoSinkBase &out = mBody; 2827 2828 const TStructure* structure = type.getStruct(); 2829 if (structure) 2830 { 2831 out << StructNameString(*structure) + "_ctor("; 2832 2833 const TFieldList& fields = structure->fields(); 2834 2835 for (size_t i = 0; i < fields.size(); i++) 2836 { 2837 const TType *fieldType = fields[i]->type(); 2838 constUnion = writeConstantUnion(*fieldType, constUnion); 2839 2840 if (i != fields.size() - 1) 2841 { 2842 out << ", "; 2843 } 2844 } 2845 2846 out << ")"; 2847 } 2848 else 2849 { 2850 size_t size = type.getObjectSize(); 2851 bool writeType = size > 1; 2852 2853 if (writeType) 2854 { 2855 out << TypeString(type) << "("; 2856 } 2857 2858 for (size_t i = 0; i < size; i++, constUnion++) 2859 { 2860 switch (constUnion->getType()) 2861 { 2862 case EbtFloat: out << std::min(FLT_MAX, std::max(-FLT_MAX, constUnion->getFConst())); break; 2863 case EbtInt: out << constUnion->getIConst(); break; 2864 case EbtUInt: out << constUnion->getUConst(); break; 2865 case EbtBool: out << constUnion->getBConst(); break; 2866 default: UNREACHABLE(); 2867 } 2868 2869 if (i != size - 1) 2870 { 2871 out << ", "; 2872 } 2873 } 2874 2875 if (writeType) 2876 { 2877 out << ")"; 2878 } 2879 } 2880 2881 return constUnion; 2882 } 2883 2884 } 2885
