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

• Show log

  Commit

• Hash : 7da98506
  Author :
  Date : 2016-07-20T18:45:09
  

  Cover vector dynamic indexing case in SplitSequenceOperator
  
  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: I84e41a59c88fb5d0111669cab60312b930531a22
  Reviewed-on: https://chromium-review.googlesource.com/361695
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

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/ArrayReturnValueToOutParameter.h"
  #include "compiler/translator/EmulatePrecision.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/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;
  
      SeparateDeclarations(root);
  
      // 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 |
                                IntermNodePatternMatcher::kDynamicIndexingOfVectorOrMatrixInLValue,
                            getTemporaryIndex(), getSymbolTable(), getShaderVersion());
  
      // 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());
      }
  
      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