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

• Show log

  Commit

• Hash : a5316a18
  Author :
  Date : 2015-05-15T15:25:16
  

  Separate expressions returning arrays for HLSL output
  
  Complex array expressions need to be broken down in HLSL output so that they
  are built out of simple combinations of operations and symbols.
  
  In practice this means that array constructors, array assignments and functions
  that return arrays inside complex expressions need to be replaced by symbols.
  
  After this change, ANGLE passes all dEQP-GLES3.functional.shaders.arrays
  tests.
  
  The old SimplifyArrayAssignment stub is removed, the new name
  SeparateExpressionsReturningArrays more closely reflects what the function
  needs to do.
  
  BUG=angleproject:971, angleproject:941
  TEST=dEQP-GLES3.functional.shaders.arrays.*, WebGL 2 conformance tests
  
  Change-Id: Iab8dde72b1126dc2f958ffb5b1b830fe3ce25912
  Reviewed-on: https://chromium-review.googlesource.com/272122
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Zhenyao Mo <zmo@chromium.org>
  Tested-by: 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/OutputHLSL.h"
  #include "compiler/translator/SeparateArrayInitialization.h"
  #include "compiler/translator/SeparateDeclarations.h"
  #include "compiler/translator/SeparateExpressionsReturningArrays.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);
  
      unsigned int temporaryIndex = 0;
  
      // Note that SeparateDeclarations needs to be run before UnfoldShortCircuitToIf.
      UnfoldShortCircuitToIf(root, &temporaryIndex);
  
      SeparateExpressionsReturningArrays(root, &temporaryIndex);
  
      // 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);
  
      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;
  }
  
  bool TranslatorHLSL::hasUniform(const std::string &uniformName) const
  {
      return (mUniformRegisterMap.count(uniformName) > 0);
  }
  
  unsigned int TranslatorHLSL::getUniformRegister(const std::string &uniformName) const
  {
      ASSERT(hasUniform(uniformName));
      return mUniformRegisterMap.find(uniformName)->second;
  }
  

Download