kc3-lang/angle/src/compiler/translator/UniformHLSL.h

• Show log

  Commit

• Hash : 9696316d
  Author :
  Date : 2016-03-21T11:54:33
  

  Support ESSL structs containing samplers on D3D
  
  Since HLSL can't natively handle samplers in structs, samplers need to
  be extracted out of structs into separate variables in the translated
  shader code. In HLSL 4.1, samplers that were in structs go into the
  normal sampler arrays and are identified by index constants. In other
  HLSL versions, samplers that were in structs are translated as uniform
  variables.
  
  These transformations are done inside the HLSL output classes, not as
  tree transformations. This helps to keep the uniform API provided by
  the shader translator intact.
  
  Wherever a struct containing samplers is passed into a user-defined
  function, the translated HLSL code passes the separate sampler
  variables alongside a struct where the samplers have been removed.
  
  The D3D backend in libANGLE queries the uniform registers of any
  samplers that were in uniform structs, and adds them to the register
  maps, so that correct sampler state gets assigned to them.
  
  The extracted sampler variables are prefixed with "angle_" instead of
  the usual "_" to prevent any name conflicts between them and regular
  variables.
  
  BUG=angleproject:504
  TEST=angle_end2end_tests,
       dEQP-GLES*.functional.shaders.struct.uniform.* (all pass),
       dEQP-GLES*.functional.uniform_api.* (most now pass)
  
  Change-Id: Ib79cba2fa0ff8257a973d70dfd917a64f0ca1efb
  Reviewed-on: https://chromium-review.googlesource.com/333743
  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/UniformHLSL.h

• //
  // Copyright (c) 2014 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.
  //
  // UniformHLSL.h:
  //   Methods for GLSL to HLSL translation for uniforms and interface blocks.
  //
  
  #ifndef COMPILER_TRANSLATOR_UNIFORMHLSL_H_
  #define COMPILER_TRANSLATOR_UNIFORMHLSL_H_
  
  #include "compiler/translator/OutputHLSL.h"
  #include "compiler/translator/UtilsHLSL.h"
  
  namespace sh
  {
  class StructureHLSL;
  
  class UniformHLSL : angle::NonCopyable
  {
    public:
      UniformHLSL(StructureHLSL *structureHLSL, ShShaderOutput outputType, const std::vector<Uniform> &uniforms);
  
      void reserveUniformRegisters(unsigned int registerCount);
      void reserveInterfaceBlockRegisters(unsigned int registerCount);
      void uniformsHeader(TInfoSinkBase &out,
                          ShShaderOutput outputType,
                          const ReferencedSymbols &referencedUniforms);
  
      // Must be called after uniformsHeader
      void samplerMetadataUniforms(TInfoSinkBase &out, const char *reg);
  
      TString interfaceBlocksHeader(const ReferencedSymbols &referencedInterfaceBlocks);
  
      // Used for direct index references
      static TString interfaceBlockInstanceString(const TInterfaceBlock& interfaceBlock, unsigned int arrayIndex);
  
      const std::map<std::string, unsigned int> &getInterfaceBlockRegisterMap() const
      {
          return mInterfaceBlockRegisterMap;
      }
      const std::map<std::string, unsigned int> &getUniformRegisterMap() const
      {
          return mUniformRegisterMap;
      }
  
    private:
      TString interfaceBlockString(const TInterfaceBlock &interfaceBlock, unsigned int registerIndex, unsigned int arrayIndex);
      TString interfaceBlockMembersString(const TInterfaceBlock &interfaceBlock, TLayoutBlockStorage blockStorage);
      TString interfaceBlockStructString(const TInterfaceBlock &interfaceBlock);
      const Uniform *findUniformByName(const TString &name) const;
  
      void outputHLSL4_0_FL9_3Sampler(TInfoSinkBase &out,
                                      const TType &type,
                                      const TName &name,
                                      const unsigned int registerIndex);
  
      void outputUniform(TInfoSinkBase &out,
                         const TType &type,
                         const TName &name,
                         const unsigned int registerIndex);
  
      // Returns the uniform's register index
      unsigned int assignUniformRegister(const TType &type,
                                         const TString &name,
                                         unsigned int *outRegisterCount);
      unsigned int assignSamplerInStructUniformRegister(const TType &type,
                                                        const TString &name,
                                                        unsigned int *outRegisterCount);
  
      void outputHLSLSamplerUniformGroup(
          TInfoSinkBase &out,
          const HLSLTextureSamplerGroup textureGroup,
          const TVector<const TIntermSymbol *> &group,
          const TMap<const TIntermSymbol *, TString> &samplerInStructSymbolsToAPINames,
          unsigned int *groupTextureRegisterIndex);
  
      unsigned int mUniformRegister;
      unsigned int mInterfaceBlockRegister;
      unsigned int mSamplerRegister;
      StructureHLSL *mStructureHLSL;
      ShShaderOutput mOutputType;
  
      const std::vector<Uniform> &mUniforms;
      std::map<std::string, unsigned int> mInterfaceBlockRegisterMap;
      std::map<std::string, unsigned int> mUniformRegisterMap;
  };
  
  }
  
  #endif // COMPILER_TRANSLATOR_UNIFORMHLSL_H_
  

Download