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

• Show log

  Commit

• Hash : b741c761
  Author :
  Date : 2016-06-29T15:49:22
  

  Support precision emulation on HLSL
  
  Re-submit with missing virtual destructor and angle::NonCopyable
  added.
  
  Add precision emulation support to HLSL 4.1 output. This makes it
  possible for developers to test their shaders for precision issues
  easily on Chrome on Windows without having to use the GL backend. The
  patch has been verified with Chrome on Windows to reproduce some
  precision bugs in real-world WebGL content, including old versions of
  the babylon.js library.
  
  The EmulatePrecision AST transformation still relies on writing out
  raw shader code for the rounding functions, with raw HLSL code added
  alongside pre-existing GLSL and ESSL code. In some ways it would be
  nicer to do the EmulatePrecision step as a pure AST transformation,
  but on the other hand the raw code is much more readable and easier
  to optimize.
  
  To better support multiple output languages in EmulatePrecision, add a
  RoundingHelperWriter class that has different subclasses for writing
  the rounding functions in different languages.
  
  The unit tests are expanded to cover the HLSL output of precision
  emulation. The parts of the tests that require the HLSL output are
  only active on Windows where ANGLE_ENABLE_HLSL define is added to the
  unit tests. Putting the HLSL tests in an entirely separate file is a
  worse alternative, since it would require either a lot of code
  duplication or add a lot of boilerplate to the individual tests.
  
  BUG=angleproject:1437
  TEST=angle_unittests
  
  Change-Id: I47d501037c206f4bd8b976d3acab9b21c717084c
  Reviewed-on: https://chromium-review.googlesource.com/360152
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  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/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/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);
  
      // 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