kc3-lang/angle/src/libANGLE/renderer/vulkan/ProgramVk.h

• Show log

  Commit

• Hash : dee4d7a5
  Author :
  Date : 2020-04-10T10:22:56
  

  Vulkan: Early fragment tests optimization
  
  Checks if early fragment tests as an optimization is feasible and enable
  it if we can. In the link time, if context state diagrees with
  optimization (in rare case), then remove the
  ExecutionModeEarlyFragmentTests sprv op code.
  
  Bug: angleproject:4508
  Change-Id: Ifbb06c0ffb050a9f3ddb16ab50362e908b4b9cf6
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2136490
  Commit-Queue: Charlie Lao <cclao@google.com>
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Reviewed-by: Courtney Goeltzenleuchter <courtneygo@google.com>
  

Download

• src/libANGLE/renderer/vulkan/ProgramVk.h

• //
  // Copyright 2016 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.
  //
  // ProgramVk.h:
  //    Defines the class interface for ProgramVk, implementing ProgramImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_PROGRAMVK_H_
  #define LIBANGLE_RENDERER_VULKAN_PROGRAMVK_H_
  
  #include <array>
  
  #include "common/utilities.h"
  #include "libANGLE/renderer/ProgramImpl.h"
  #include "libANGLE/renderer/glslang_wrapper_utils.h"
  #include "libANGLE/renderer/vulkan/ContextVk.h"
  #include "libANGLE/renderer/vulkan/ProgramExecutableVk.h"
  #include "libANGLE/renderer/vulkan/RendererVk.h"
  #include "libANGLE/renderer/vulkan/TransformFeedbackVk.h"
  #include "libANGLE/renderer/vulkan/vk_helpers.h"
  
  namespace rx
  {
  ANGLE_INLINE bool UseLineRaster(const ContextVk *contextVk, gl::PrimitiveMode mode)
  {
      return contextVk->getFeatures().basicGLLineRasterization.enabled && gl::IsLineMode(mode);
  }
  
  class ProgramVk : public ProgramImpl
  {
    public:
      ProgramVk(const gl::ProgramState &state);
      ~ProgramVk() override;
      void destroy(const gl::Context *context) override;
  
      std::unique_ptr<LinkEvent> load(const gl::Context *context,
                                      gl::BinaryInputStream *stream,
                                      gl::InfoLog &infoLog) override;
      void save(const gl::Context *context, gl::BinaryOutputStream *stream) override;
      void setBinaryRetrievableHint(bool retrievable) override;
      void setSeparable(bool separable) override;
  
      void fillProgramStateMap(gl::ShaderMap<const gl::ProgramState *> *programStatesOut);
  
      std::unique_ptr<LinkEvent> link(const gl::Context *context,
                                      const gl::ProgramLinkedResources &resources,
                                      gl::InfoLog &infoLog) override;
      GLboolean validate(const gl::Caps &caps, gl::InfoLog *infoLog) override;
  
      void setUniform1fv(GLint location, GLsizei count, const GLfloat *v) override;
      void setUniform2fv(GLint location, GLsizei count, const GLfloat *v) override;
      void setUniform3fv(GLint location, GLsizei count, const GLfloat *v) override;
      void setUniform4fv(GLint location, GLsizei count, const GLfloat *v) override;
      void setUniform1iv(GLint location, GLsizei count, const GLint *v) override;
      void setUniform2iv(GLint location, GLsizei count, const GLint *v) override;
      void setUniform3iv(GLint location, GLsizei count, const GLint *v) override;
      void setUniform4iv(GLint location, GLsizei count, const GLint *v) override;
      void setUniform1uiv(GLint location, GLsizei count, const GLuint *v) override;
      void setUniform2uiv(GLint location, GLsizei count, const GLuint *v) override;
      void setUniform3uiv(GLint location, GLsizei count, const GLuint *v) override;
      void setUniform4uiv(GLint location, GLsizei count, const GLuint *v) override;
      void setUniformMatrix2fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
      void setUniformMatrix3fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
      void setUniformMatrix4fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
      void setUniformMatrix2x3fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
      void setUniformMatrix3x2fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
      void setUniformMatrix2x4fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
      void setUniformMatrix4x2fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
      void setUniformMatrix3x4fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
      void setUniformMatrix4x3fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
  
      void getUniformfv(const gl::Context *context, GLint location, GLfloat *params) const override;
      void getUniformiv(const gl::Context *context, GLint location, GLint *params) const override;
      void getUniformuiv(const gl::Context *context, GLint location, GLuint *params) const override;
  
      angle::Result updateShaderUniforms(ContextVk *contextVk,
                                         gl::ShaderType shaderType,
                                         uint32_t *outOffset,
                                         bool *anyNewBufferAllocated);
      angle::Result updateUniforms(ContextVk *contextVk);
  
      // For testing only.
      void setDefaultUniformBlocksMinSizeForTesting(size_t minSize);
  
      bool dirtyUniforms() const { return mDefaultUniformBlocksDirty.any(); }
  
      // Used in testing only.
      vk::DynamicDescriptorPool *getDynamicDescriptorPool(uint32_t poolIndex)
      {
          return &mExecutable.mDynamicDescriptorPools[poolIndex];
      }
  
      const ProgramExecutableVk &getExecutable() const { return mExecutable; }
      ProgramExecutableVk &getExecutable() { return mExecutable; }
  
      gl::ShaderMap<DefaultUniformBlock> &getDefaultUniformBlocks() { return mDefaultUniformBlocks; }
  
      ANGLE_INLINE angle::Result initGraphicsShaderProgram(ContextVk *contextVk,
                                                           const gl::ShaderType shaderType,
                                                           ProgramTransformOptionBits optionBits,
                                                           ProgramInfo &programInfo)
      {
          return initProgram(contextVk, shaderType, optionBits, &programInfo);
      }
  
      ANGLE_INLINE angle::Result initComputeProgram(ContextVk *contextVk, ProgramInfo &programInfo)
      {
          ProgramTransformOptionBits optionBits;
          return initProgram(contextVk, gl::ShaderType::Compute, optionBits, &programInfo);
      }
  
      ShaderInfo &getShaderInfo() { return mShaderInfo; }
  
      GlslangProgramInterfaceInfo &getGlslangProgramInterfaceInfo()
      {
          return mGlslangProgramInterfaceInfo;
      }
  
    private:
      template <int cols, int rows>
      void setUniformMatrixfv(GLint location,
                              GLsizei count,
                              GLboolean transpose,
                              const GLfloat *value);
  
      void reset(ContextVk *contextVk);
      angle::Result initDefaultUniformBlocks(const gl::Context *glContext);
      void generateUniformLayoutMapping(gl::ShaderMap<sh::BlockLayoutMap> &layoutMap,
                                        gl::ShaderMap<size_t> &requiredBufferSize);
      void initDefaultUniformLayoutMapping(gl::ShaderMap<sh::BlockLayoutMap> &layoutMap);
      angle::Result resizeUniformBlockMemory(ContextVk *contextVk,
                                             gl::ShaderMap<size_t> &requiredBufferSize);
  
      template <class T>
      void getUniformImpl(GLint location, T *v, GLenum entryPointType) const;
  
      template <typename T>
      void setUniformImpl(GLint location, GLsizei count, const T *v, GLenum entryPointType);
      angle::Result linkImpl(const gl::Context *glContext, gl::InfoLog &infoLog);
      void linkResources(const gl::ProgramLinkedResources &resources);
  
      ANGLE_INLINE angle::Result initProgram(ContextVk *contextVk,
                                             const gl::ShaderType shaderType,
                                             ProgramTransformOptionBits optionBits,
                                             ProgramInfo *programInfo)
      {
          ASSERT(mShaderInfo.valid());
  
          // Create the program pipeline.  This is done lazily and once per combination of
          // specialization constants.
          if (!programInfo->valid(shaderType))
          {
              ANGLE_TRY(programInfo->initProgram(contextVk, shaderType, mShaderInfo,
                                                 mExecutable.mVariableInfoMap, optionBits));
          }
          ASSERT(programInfo->valid(shaderType));
  
          return angle::Result::Continue;
      }
  
      gl::ShaderMap<DefaultUniformBlock> mDefaultUniformBlocks;
      gl::ShaderBitSet mDefaultUniformBlocksDirty;
  
      // We keep the SPIR-V code to use for draw call pipeline creation.
      ShaderInfo mShaderInfo;
  
      GlslangProgramInterfaceInfo mGlslangProgramInterfaceInfo;
  
      ProgramExecutableVk mExecutable;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_PROGRAMVK_H_
  

Download