kc3-lang/angle/src/compiler/translator/TranslatorHLSL.cpp

• Show log

  Commit

• Hash : d2f59bb6
  Author :
  Date : 2016-08-17T11:50:52
  

  Revert "Cover vector dynamic indexing case in SplitSequenceOperator"
  
  This CL was causing inverted rendering in a WebGL application.
  
  This reverts commit 7da9850643f55335a13a4663d226c73d0ac4d3b1.
  
  Vectors or matrices that are dynamically indexed as a part of an
  l-value generate new statements in the RemoveDynamicIndexing AST
  transformation step. SplitSequenceOperator needs to detect this case
  and split the sequence operator before statements are generated from
  its operands to ensure the correct order of execution.
  
  BUG=angleproject:1341
  TEST=angle_end2end_tests
  
  Change-Id: I854f8cce2d46107afa62f48edf3d32c6d5c97eda
  Reviewed-on: https://chromium-review.googlesource.com/371643
  Reviewed-by: Kenneth Russell <kbr@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/compiler/translator/TranslatorHLSL.cpp

• //
  // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  #include "compiler/translator/TranslatorHLSL.h"
  
  #include "compiler/translator/AddDefaultReturnStatements.h"
  #include "compiler/translator/ArrayReturnValueToOutParameter.h"
  #include "compiler/translator/EmulatePrecision.h"
  #include "compiler/translator/ExpandIntegerPowExpressions.h"
  #include "compiler/translator/IntermNodePatternMatcher.h"
  #include "compiler/translator/OutputHLSL.h"
  #include "compiler/translator/RemoveDynamicIndexing.h"
  #include "compiler/translator/RewriteElseBlocks.h"
  #include "compiler/translator/SeparateArrayInitialization.h"
  #include "compiler/translator/SeparateDeclarations.h"
  #include "compiler/translator/SeparateExpressionsReturningArrays.h"
  #include "compiler/translator/SimplifyLoopConditions.h"
  #include "compiler/translator/SplitSequenceOperator.h"
  #include "compiler/translator/UnfoldShortCircuitToIf.h"
  
  TranslatorHLSL::TranslatorHLSL(sh::GLenum type, ShShaderSpec spec, ShShaderOutput output)
      : TCompiler(type, spec, output)
  {
  }
  
  void TranslatorHLSL::translate(TIntermNode *root, int compileOptions)
  {
      const ShBuiltInResources &resources = getResources();
      int numRenderTargets = resources.EXT_draw_buffers ? resources.MaxDrawBuffers : 1;
  
      sh::AddDefaultReturnStatements(root);
  
      SeparateDeclarations(root);
  
      // Note that SimplifyLoopConditions needs to be run before any other AST transformations that
      // may need to generate new statements from loop conditions or loop expressions.
      SimplifyLoopConditions(root, IntermNodePatternMatcher::kExpressionReturningArray |
                                       IntermNodePatternMatcher::kUnfoldedShortCircuitExpression,
                             getTemporaryIndex(), getSymbolTable(), getShaderVersion());
  
      // TODO (oetuaho): Sequence operators should also be split in case there is dynamic indexing of
      // a vector or matrix as an l-value inside (RemoveDynamicIndexing transformation step generates
      // statements in this case).
      SplitSequenceOperator(root, IntermNodePatternMatcher::kExpressionReturningArray |
                                      IntermNodePatternMatcher::kUnfoldedShortCircuitExpression,
                            getTemporaryIndex());
  
      // Note that SeparateDeclarations needs to be run before UnfoldShortCircuitToIf.
      UnfoldShortCircuitToIf(root, getTemporaryIndex());
  
      SeparateExpressionsReturningArrays(root, getTemporaryIndex());
  
      // Note that SeparateDeclarations needs to be run before SeparateArrayInitialization.
      SeparateArrayInitialization(root);
  
      // HLSL doesn't support arrays as return values, we'll need to make functions that have an array
      // as a return value to use an out parameter to transfer the array data instead.
      ArrayReturnValueToOutParameter(root, getTemporaryIndex());
  
      if (!shouldRunLoopAndIndexingValidation(compileOptions))
      {
          // HLSL doesn't support dynamic indexing of vectors and matrices.
          RemoveDynamicIndexing(root, getTemporaryIndex(), getSymbolTable(), getShaderVersion());
      }
  
      // Work around D3D9 bug that would manifest in vertex shaders with selection blocks which
      // use a vertex attribute as a condition, and some related computation in the else block.
      if (getOutputType() == SH_HLSL_3_0_OUTPUT && getShaderType() == GL_VERTEX_SHADER)
      {
          sh::RewriteElseBlocks(root, getTemporaryIndex());
      }
  
      bool precisionEmulation =
          getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision;
  
      if (precisionEmulation)
      {
          EmulatePrecision emulatePrecision(getSymbolTable(), getShaderVersion());
          root->traverse(&emulatePrecision);
          emulatePrecision.updateTree();
          emulatePrecision.writeEmulationHelpers(getInfoSink().obj, getShaderVersion(),
                                                 getOutputType());
      }
  
      if ((compileOptions & SH_EXPAND_SELECT_HLSL_INTEGER_POW_EXPRESSIONS) != 0)
      {
          sh::ExpandIntegerPowExpressions(root, getTemporaryIndex());
      }
  
      sh::OutputHLSL outputHLSL(getShaderType(), getShaderVersion(), getExtensionBehavior(),
          getSourcePath(), getOutputType(), numRenderTargets, getUniforms(), compileOptions);
  
      outputHLSL.output(root, getInfoSink().obj);
  
      mInterfaceBlockRegisterMap = outputHLSL.getInterfaceBlockRegisterMap();
      mUniformRegisterMap = outputHLSL.getUniformRegisterMap();
  }
  
  bool TranslatorHLSL::hasInterfaceBlock(const std::string &interfaceBlockName) const
  {
      return (mInterfaceBlockRegisterMap.count(interfaceBlockName) > 0);
  }
  
  unsigned int TranslatorHLSL::getInterfaceBlockRegister(const std::string &interfaceBlockName) const
  {
      ASSERT(hasInterfaceBlock(interfaceBlockName));
      return mInterfaceBlockRegisterMap.find(interfaceBlockName)->second;
  }
  
  const std::map<std::string, unsigned int> *TranslatorHLSL::getUniformRegisterMap() const
  {
      return &mUniformRegisterMap;
  }

Download