kc3-lang/angle/src/libANGLE/renderer/d3d/DynamicHLSL.h

• Show log

  Commit

• Hash : 9fc3682c
  Author :
  Date : 2015-11-18T13:08:07
  

  D3D: Rework varying packing code.
  
  In D3D we pack varyings by making a register map, and using the
  recommended GLSL ES algorithm to reserve register space. We use
  this map to assign row and column slots to each varying and then
  produce a semantic index value.
  
  The existing scheme had a number of bugs, and was failing several
  angle_end2end_tests. The new design cleans up the code somewhat
  and uses a different counting scheme for the semantic indexes:
  just sort the varyings in packing order and use a simple
  incrementing semantic index per varying. In SM4+, the HLSL compiler
  sorts and packs the varyings correctly itself, and in SM3, handle
  the cases we don't support by returning an error instead of a D3D
  compiler link error.
  
  Also refactor how we store varying information for TF Feedback/
  StreamOut. Only store the necessary D3D information, instead of
  extra information like the name and type.
  
  This fixes several tests in GLSLTest/*. This also will allow us to
  fix interpolation qualifier packing and the structure packing in
  HLSL, which seems to work differently than the rest of the varying
  types.
  
  BUG=angleproject:1202
  TEST=bots,dEQP-GLES3.functional.transform_feedback.*
  
  Change-Id: Ie5bfbb4f71d8bf97f39115fc46d2e61b131df639
  Reviewed-on: https://chromium-review.googlesource.com/311241
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Tested-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/DynamicHLSL.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.
  //
  // DynamicHLSL.h: Interface for link and run-time HLSL generation
  //
  
  #ifndef LIBANGLE_RENDERER_D3D_DYNAMICHLSL_H_
  #define LIBANGLE_RENDERER_D3D_DYNAMICHLSL_H_
  
  #include <map>
  #include <vector>
  
  #include "angle_gl.h"
  #include "common/angleutils.h"
  #include "libANGLE/Constants.h"
  #include "libANGLE/Program.h"
  #include "libANGLE/formatutils.h"
  #include "libANGLE/renderer/d3d/RendererD3D.h"
  
  namespace sh
  {
  struct Attribute;
  struct ShaderVariable;
  }
  
  namespace gl
  {
  class InfoLog;
  struct VariableLocation;
  struct VertexAttribute;
  struct Data;
  }
  
  namespace rx
  {
  struct PackedVarying;
  class ProgramD3DMetadata;
  class ShaderD3D;
  class VaryingPacking;
  
  struct PixelShaderOutputVariable
  {
      GLenum type;
      std::string name;
      std::string source;
      size_t outputIndex;
  };
  
  class DynamicHLSL : angle::NonCopyable
  {
    public:
      explicit DynamicHLSL(RendererD3D *const renderer);
  
      std::string generateVertexShaderForInputLayout(
          const std::string &sourceShader,
          const gl::InputLayout &inputLayout,
          const std::vector<sh::Attribute> &shaderAttributes) const;
      std::string generatePixelShaderForOutputSignature(
          const std::string &sourceShader,
          const std::vector<PixelShaderOutputVariable> &outputVariables,
          bool usesFragDepth,
          const std::vector<GLenum> &outputLayout) const;
      bool generateShaderLinkHLSL(const gl::Data &data,
                                  const gl::Program::Data &programData,
                                  const ProgramD3DMetadata &programMetadata,
                                  const VaryingPacking &varyingPacking,
                                  std::string *pixelHLSL,
                                  std::string *vertexHLSL) const;
  
      std::string generateGeometryShaderPreamble(const VaryingPacking &varyingPacking) const;
  
      std::string generateGeometryShaderHLSL(gl::PrimitiveType primitiveType,
                                             const gl::Data &data,
                                             const gl::Program::Data &programData,
                                             const std::string &preambleString) const;
  
      void getPixelShaderOutputKey(const gl::Data &data,
                                   const gl::Program::Data &programData,
                                   const ProgramD3DMetadata &metadata,
                                   std::vector<PixelShaderOutputVariable> *outPixelShaderKey);
  
    private:
      RendererD3D *const mRenderer;
  
      void generateVaryingLinkHLSL(ShaderType shaderType,
                                   const VaryingPacking &varyingPacking,
                                   std::stringstream &linkStream) const;
      void generateVaryingHLSL(const VaryingPacking &varyingPacking,
                               std::stringstream &hlslStream) const;
  
      // Prepend an underscore
      static std::string decorateVariable(const std::string &name);
  
      std::string generateAttributeConversionHLSL(gl::VertexFormatType vertexFormatType,
                                                  const sh::ShaderVariable &shaderAttrib) const;
  };
  
  std::string GetVaryingSemantic(int majorShaderModel, bool programUsesPointSize);
  }
  
  #endif  // LIBANGLE_RENDERER_D3D_DYNAMICHLSL_H_
  

Download