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

• Show log

  Commit

• Hash : fcf3a1c0
  Author :
  Date : 2024-07-02T16:33:28
  

  GL: Allow shader compilation with cached translated source
  
  Write the translated shader source when serializing shaders. This does
  not increase the size of the shader cache because Vulkan only uses the
  compiledBinary field.
  
  Spawn a ShaderTranslateTask for loading shaders so the GL backend can
  compile the shader on the native driver.
  
  Bug: angleproject:350779978
  Change-Id: I14413a7ca2a0d99653a1082f2c8b4a94cf58626a
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5672740
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/ShaderD3D.h

• //
  // Copyright 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.
  //
  
  // ShaderD3D.h: Defines the rx::ShaderD3D class which implements rx::ShaderImpl.
  
  #ifndef LIBANGLE_RENDERER_D3D_SHADERD3D_H_
  #define LIBANGLE_RENDERER_D3D_SHADERD3D_H_
  
  #include "libANGLE/renderer/ShaderImpl.h"
  
  #include <map>
  #include <memory>
  
  namespace angle
  {
  struct FeaturesD3D;
  }  // namespace angle
  
  namespace gl
  {
  struct Extensions;
  }
  
  namespace rx
  {
  class DynamicHLSL;
  class RendererD3D;
  struct D3DUniform;
  
  // Workarounds attached to each shader. Do not need to expose information about these workarounds so
  // a simple bool struct suffices.
  struct CompilerWorkaroundsD3D
  {
      bool skipOptimization = false;
  
      bool useMaxOptimization = false;
  
      // IEEE strictness needs to be enabled for NANs to work.
      bool enableIEEEStrictness = false;
  };
  
  enum class FragDepthUsage
  {
      Unused,
      Any,
      Greater,
      Less
  };
  
  struct CompiledShaderStateD3D : angle::NonCopyable
  {
      CompiledShaderStateD3D();
      ~CompiledShaderStateD3D();
  
      bool hasUniform(const std::string &name) const;
  
      // Query regular uniforms with their name. Query sampler fields of structs with field selection
      // using dot (.) operator.
      unsigned int getUniformRegister(const std::string &uniformName) const;
  
      unsigned int getUniformBlockRegister(const std::string &blockName) const;
      bool shouldUniformBlockUseStructuredBuffer(const std::string &blockName) const;
      unsigned int getShaderStorageBlockRegister(const std::string &blockName) const;
      bool useImage2DFunction(const std::string &functionName) const;
      const std::set<std::string> &getSlowCompilingUniformBlockSet() const;
      void appendDebugInfo(const std::string &info) { debugInfo += info; }
  
      void generateWorkarounds(CompilerWorkaroundsD3D *workarounds) const;
  
      ShShaderOutput compilerOutputType;
  
      bool usesMultipleRenderTargets;
      bool usesFragColor;
      bool usesFragData;
      bool usesSecondaryColor;
      bool usesFragCoord;
      bool usesFrontFacing;
      bool usesHelperInvocation;
      bool usesPointSize;
      bool usesPointCoord;
      bool usesDepthRange;
      bool usesSampleID;
      bool usesSamplePosition;
      bool usesSampleMaskIn;
      bool usesSampleMask;
      bool hasMultiviewEnabled;
      bool usesVertexID;
      bool usesViewID;
      bool usesDiscardRewriting;
      bool usesNestedBreak;
      bool requiresIEEEStrictCompiling;
      FragDepthUsage fragDepthUsage;
      uint8_t clipDistanceSize;
      uint8_t cullDistanceSize;
  
      std::string debugInfo;
      std::map<std::string, unsigned int> uniformRegisterMap;
      std::map<std::string, unsigned int> uniformBlockRegisterMap;
      std::map<std::string, bool> uniformBlockUseStructuredBufferMap;
      std::set<std::string> slowCompilingUniformBlockSet;
      std::map<std::string, unsigned int> shaderStorageBlockRegisterMap;
      unsigned int readonlyImage2DRegisterIndex;
      unsigned int image2DRegisterIndex;
      std::set<std::string> usedImage2DFunctionNames;
  };
  using SharedCompiledShaderStateD3D = std::shared_ptr<CompiledShaderStateD3D>;
  
  class ShaderD3D : public ShaderImpl
  {
    public:
      ShaderD3D(const gl::ShaderState &state, RendererD3D *renderer);
      ~ShaderD3D() override;
  
      std::shared_ptr<ShaderTranslateTask> compile(const gl::Context *context,
                                                   ShCompileOptions *options) override;
      std::shared_ptr<ShaderTranslateTask> load(const gl::Context *context,
                                                gl::BinaryInputStream *stream) override;
  
      std::string getDebugInfo() const override;
  
      const SharedCompiledShaderStateD3D &getCompiledState() const { return mCompiledState; }
  
    private:
      RendererD3D *mRenderer;
  
      SharedCompiledShaderStateD3D mCompiledState;
  };
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_D3D_SHADERD3D_H_
  

Download