kc3-lang/angle/src/libANGLE/renderer/vulkan/ProgramPipelineVk.cpp

• Show log

  Commit

• Hash : e77be663
  Author :
  Date : 2022-04-14T05:04:13
  

  Use ProgramExecutable directly in GlslangWrapper.
  
  Using the ProgramExecutable instead of the state means
  we can deal with merged samplers and images immediately.
  This will make it easier to use linear maps when indexing
  program resources for descriptor sets.
  
  Bug: angleproject:3570
  Bug: angleproject:4524
  Change-Id: Icd8ee9fe61730b81fafa2bdc59a2788a0d92ad12
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3580882
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Yuxin Hu <yuxinhu@google.com>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/ProgramPipelineVk.cpp

• //
  // Copyright 2017 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.
  //
  // ProgramPipelineVk.cpp:
  //    Implements the class methods for ProgramPipelineVk.
  //
  
  #include "libANGLE/renderer/vulkan/ProgramPipelineVk.h"
  
  #include "libANGLE/renderer/glslang_wrapper_utils.h"
  #include "libANGLE/renderer/vulkan/GlslangWrapperVk.h"
  
  namespace rx
  {
  
  ProgramPipelineVk::ProgramPipelineVk(const gl::ProgramPipelineState &state)
      : ProgramPipelineImpl(state)
  {}
  
  ProgramPipelineVk::~ProgramPipelineVk() {}
  
  void ProgramPipelineVk::destroy(const gl::Context *context)
  {
      ContextVk *contextVk = vk::GetImpl(context);
      reset(contextVk);
  }
  
  void ProgramPipelineVk::reset(ContextVk *contextVk)
  {
      mExecutable.reset(contextVk);
  }
  
  angle::Result ProgramPipelineVk::link(const gl::Context *glContext,
                                        const gl::ProgramMergedVaryings &mergedVaryings,
                                        const gl::ProgramVaryingPacking &varyingPacking)
  {
      ContextVk *contextVk                      = vk::GetImpl(glContext);
      const gl::ProgramExecutable &glExecutable = mState.getExecutable();
      GlslangSourceOptions options =
          GlslangWrapperVk::CreateSourceOptions(contextVk->getRenderer()->getFeatures());
      GlslangProgramInterfaceInfo glslangProgramInterfaceInfo;
      GlslangWrapperVk::ResetGlslangProgramInterfaceInfo(&glslangProgramInterfaceInfo);
  
      mExecutable.clearVariableInfoMap();
  
      // Now that the program pipeline has all of the programs attached, the various descriptor
      // set/binding locations need to be re-assigned to their correct values.
      const gl::ShaderType linkedTransformFeedbackStage =
          glExecutable.getLinkedTransformFeedbackStage();
  
      // This should be done before assigning varying locations. Otherwise, we can encounter shader
      // interface mismatching problems when the transform feedback stage is not the vertex stage.
      if (options.supportsTransformFeedbackExtension)
      {
          for (const gl::ShaderType shaderType : glExecutable.getLinkedShaderStages())
          {
              const gl::Program *glProgram = mState.getShaderProgram(shaderType);
              if (glProgram && gl::ShaderTypeSupportsTransformFeedback(shaderType))
              {
                  const bool isTransformFeedbackStage =
                      shaderType == linkedTransformFeedbackStage &&
                      !glProgram->getState().getLinkedTransformFeedbackVaryings().empty();
  
                  GlslangAssignTransformFeedbackLocations(
                      shaderType, glProgram->getExecutable(), isTransformFeedbackStage,
                      &glslangProgramInterfaceInfo, &mExecutable.mVariableInfoMap);
              }
          }
      }
  
      mExecutable.mOriginalShaderInfo.clear();
  
      gl::ShaderType frontShaderType = gl::ShaderType::InvalidEnum;
      UniformBindingIndexMap uniformBindingIndexMap;
      for (const gl::ShaderType shaderType : glExecutable.getLinkedShaderStages())
      {
          const bool isTransformFeedbackStage =
              shaderType == linkedTransformFeedbackStage &&
              !glExecutable.getLinkedTransformFeedbackVaryings().empty();
  
          GlslangAssignLocations(options, glExecutable, varyingPacking, shaderType, frontShaderType,
                                 isTransformFeedbackStage, &glslangProgramInterfaceInfo,
                                 &uniformBindingIndexMap, &mExecutable.mVariableInfoMap);
          frontShaderType = shaderType;
  
          const gl::Program *program               = mState.getShaderProgram(shaderType);
          ProgramVk *programVk                     = vk::GetImpl(program);
          ProgramExecutableVk &programExecutableVk = programVk->getExecutable();
          mExecutable.mDefaultUniformBlocks[shaderType] =
              programExecutableVk.getSharedDefaultUniformBlock(shaderType);
  
          mExecutable.mOriginalShaderInfo.initShaderFromProgram(
              shaderType, programExecutableVk.mOriginalShaderInfo);
      }
  
      mExecutable.setAllDefaultUniformsDirty(glExecutable);
  
      if (contextVk->getFeatures().enablePrecisionQualifiers.enabled)
      {
          mExecutable.resolvePrecisionMismatch(mergedVaryings);
      }
  
      return mExecutable.createPipelineLayout(contextVk, mState.getExecutable(), nullptr);
  }  // namespace rx
  
  void ProgramPipelineVk::onProgramUniformUpdate(gl::ShaderType shaderType)
  {
      mExecutable.mDefaultUniformBlocksDirty.set(shaderType);
  }
  }  // namespace rx
  

Download