src/third_party/angle/src/libGLESv2/renderer/d3d/DynamicHLSL.h

   1 //
   2 // Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6 // DynamicHLSL.h: Interface for link and run-time HLSL generation
   7 //
   8
   9 #ifndef LIBGLESV2_RENDERER_DYNAMIC_HLSL_H_
  10 #define LIBGLESV2_RENDERER_DYNAMIC_HLSL_H_
  11
  12 #include "common/angleutils.h"
  13 #include "libGLESv2/constants.h"
  14
  15 #include "angle_gl.h"
  16
  17 #include <vector>
  18 #include <map>
  19
  20 namespace rx
  21 {
  22 class Renderer;
  23 }
  24
  25 namespace sh
  26 {
  27 struct Attribute;
  28 struct ShaderVariable;
  29 }
  30
  31 namespace gl
  32 {
  33 class InfoLog;
  34 struct VariableLocation;
  35 struct LinkedVarying;
  36 struct VertexAttribute;
  37 struct VertexFormat;
  38 struct PackedVarying;
  39 }
  40
  41 namespace rx
  42 {
  43 class Renderer;
  44 class ShaderD3D;
  45
  46 typedef const gl::PackedVarying *VaryingPacking[gl::IMPLEMENTATION_MAX_VARYING_VECTORS][4];
  47
  48 struct PixelShaderOutputVariable
  49 {
  50     GLenum type;
  51     std::string name;
  52     std::string source;
  53     size_t outputIndex;
  54 };
  55
  56 class DynamicHLSL
  57 {
  58   public:
  59     explicit DynamicHLSL(rx::Renderer *const renderer);
  60
  61     int packVaryings(gl::InfoLog &infoLog, VaryingPacking packing, rx::ShaderD3D *fragmentShader,
  62                      rx::ShaderD3D *vertexShader, const std::vector<std::string>& transformFeedbackVaryings);
  63     std::string generateVertexShaderForInputLayout(const std::string &sourceShader, const gl::VertexFormat inputLayout[],
  64                                                    const sh::Attribute shaderAttributes[]) const;
  65     std::string generatePixelShaderForOutputSignature(const std::string &sourceShader, const std::vector<PixelShaderOutputVariable> &outputVariables,
  66                                                       bool usesFragDepth, const std::vector<GLenum> &outputLayout) const;
  67     bool generateShaderLinkHLSL(gl::InfoLog &infoLog, int registers, const VaryingPacking packing,
  68                                 std::string& pixelHLSL, std::string& vertexHLSL,
  69                                 rx::ShaderD3D *fragmentShader, rx::ShaderD3D *vertexShader,
  70                                 const std::vector<std::string>& transformFeedbackVaryings,
  71                                 std::vector<gl::LinkedVarying> *linkedVaryings,
  72                                 std::map<int, gl::VariableLocation> *programOutputVars,
  73                                 std::vector<PixelShaderOutputVariable> *outPixelShaderKey,
  74                                 bool *outUsesFragDepth) const;
  75
  76     std::string generateGeometryShaderHLSL(int registers, rx::ShaderD3D *fragmentShader, rx::ShaderD3D *vertexShader) const;
  77     void getInputLayoutSignature(const gl::VertexFormat inputLayout[], GLenum signature[]) const;
  78
  79   private:
  80     DISALLOW_COPY_AND_ASSIGN(DynamicHLSL);
  81
  82     rx::Renderer *const mRenderer;
  83
  84     struct SemanticInfo;
  85
  86     std::string getVaryingSemantic(bool pointSize) const;
  87     SemanticInfo getSemanticInfo(int startRegisters, bool fragCoord, bool pointCoord, bool pointSize,
  88                                         bool pixelShader) const;
  89     std::string generateVaryingLinkHLSL(const SemanticInfo &info, const std::string &varyingHLSL) const;
  90     std::string generateVaryingHLSL(const ShaderD3D *shader) const;
  91     void storeUserLinkedVaryings(const rx::ShaderD3D *vertexShader, std::vector<gl::LinkedVarying> *linkedVaryings) const;
  92     void storeBuiltinLinkedVaryings(const SemanticInfo &info, std::vector<gl::LinkedVarying> *linkedVaryings) const;
  93     void defineOutputVariables(rx::ShaderD3D *fragmentShader, std::map<int, gl::VariableLocation> *programOutputVars) const;
  94     std::string generatePointSpriteHLSL(int registers, rx::ShaderD3D *fragmentShader, rx::ShaderD3D *vertexShader) const;
  95
  96     // Prepend an underscore
  97     static std::string decorateVariable(const std::string &name);
  98
  99     std::string generateAttributeConversionHLSL(const gl::VertexFormat &vertexFormat, const sh::ShaderVariable &shaderAttrib) const;
 100 };
 101
 102 }
 103
 104 #endif // LIBGLESV2_RENDERER_DYNAMIC_HLSL_H_