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

• Show log

  Commit

• Hash : be59c2fb
  Author :
  Date : 2016-03-07T11:32:34
  

  Fix ambiguous function call issues in HLSL output
  
  D3D compiler can't resolve between these overloaded functions:
  
  float4 vec4(float2x2 x0);
  float4 vec4(float4 x0);
  
  Include the parameter types in the function name to disambiguate
  between overloaded user-defined functions and constructors, like this:
  
  float4 vec4_float2x2(float2x2 x0);
  float4 vec4_float4(float4 x0);
  
  This is only done for float2x2 and float4 parameters, other parameter
  types like float2x3 vs. float3x2 don't need this.
  
  BUG=angleproject:1099
  BUG=angleproject:1030
  TEST=angle_end2end_tests,
       dEQP-GLES3.functional.attribute_location.* (10 more tests pass),
       dEQP-GLES2.functional.attribute_location.*
  
  Change-Id: Ief047d41b0adbc238393c3c13cb29771cbb83d58
  Reviewed-on: https://chromium-review.googlesource.com/329882
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/compiler/translator/StructureHLSL.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.
  //
  // StructureHLSL.h:
  //   Interfaces of methods for HLSL translation of GLSL structures.
  //
  
  #ifndef COMPILER_TRANSLATOR_STRUCTUREHLSL_H_
  #define COMPILER_TRANSLATOR_STRUCTUREHLSL_H_
  
  #include "compiler/translator/Common.h"
  #include "compiler/translator/IntermNode.h"
  
  #include <set>
  
  class TInfoSinkBase;
  class TScopeBracket;
  
  namespace sh
  {
  
  // This helper class assists structure and interface block definitions in determining
  // how to pack std140 structs within HLSL's packing rules.
  class Std140PaddingHelper
  {
    public:
      explicit Std140PaddingHelper(const std::map<TString, int> &structElementIndexes,
                                   unsigned int *uniqueCounter);
      Std140PaddingHelper(const Std140PaddingHelper &other);
      Std140PaddingHelper &operator=(const Std140PaddingHelper &other);
  
      int elementIndex() const { return mElementIndex; }
      int prePadding(const TType &type);
      TString prePaddingString(const TType &type);
      TString postPaddingString(const TType &type, bool useHLSLRowMajorPacking);
  
    private:
      TString next();
  
      unsigned *mPaddingCounter;
      int mElementIndex;
      const std::map<TString, int> *mStructElementIndexes;
  };
  
  class StructureHLSL : angle::NonCopyable
  {
    public:
      StructureHLSL();
  
      // Returns the name of the constructor function. "name" parameter is the name of the type being
      // constructed.
      TString addConstructor(const TType &type,
                             const TString &name,
                             const TIntermSequence *parameters);
      std::string structsHeader() const;
  
      TString defineQualified(const TStructure &structure, bool useHLSLRowMajorPacking, bool useStd140Packing);
      static TString defineNameless(const TStructure &structure);
  
      Std140PaddingHelper getPaddingHelper();
  
    private:
      unsigned mUniquePaddingCounter;
  
      std::map<TString, int> mStd140StructElementIndexes;
  
      typedef std::set<TString> StructNames;
      StructNames mStructNames;
  
      typedef std::set<TString> Constructors;
      Constructors mConstructors;
  
      typedef std::vector<TString> StructDeclarations;
      StructDeclarations mStructDeclarations;
  
      void storeStd140ElementIndex(const TStructure &structure, bool useHLSLRowMajorPacking);
      static TString define(const TStructure &structure, bool useHLSLRowMajorPacking,
                           bool useStd140Packing, Std140PaddingHelper *padHelper);
  };
  
  }
  
  #endif // COMPILER_TRANSLATOR_STRUCTUREHLSL_H_
  

Download