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

• Show log

  Commit

• Hash : f39e0f01
  Author :
  Date : 2020-09-07T23:07:37
  

  Vulkan: Use subpass to unresolve render-to-texture attachments
  
  GL_EXT_multisampled_render_to_texture allows singlesampled textures to
  be used with multisampled framebuffers in such a way that the final
  resolve operation is automatically done.  In Vulkan terminology, the
  render-to-texture GL attachment is used as a Vulkan subpass resolve
  attachment with an implicit (ideally-)lazy-memory multisampled image as
  the color attachment.
  
  This extension expects that if the texture is drawn to after the
  automatic resolve, the implicit multisampled image would take its
  fragment colors from the singlesampled image.  In other words, the
  opposite of a resolve operation should be automatically performed at the
  start of the render pass.  This change refers to this operation as
  "unresolve".
  
  The goal of this extension is to allow tiling GPUs to always keep
  multisampled data on tile memory and only ever load/store singlesampled
  data.  The latter is achieved by using a subpass resolve attachment and
  setting storeOp of the multisampled color attachment to DONT_CARE.  This
  change achieves the former by using an initial subpass that uses the
  resolve attachment as input attachment, draws into the multisampled
  color attachment and sets loadOp of said attachment to DONT_CARE.
  
  Bug: angleproject:4881
  Change-Id: I99f410530365963567c77a7d62fc9db1500e5e3e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2397206
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

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

• //
  // 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.
  //
  // GlslangWrapperVk: Wrapper for Vulkan's glslang compiler.
  //
  
  #include "libANGLE/renderer/vulkan/GlslangWrapperVk.h"
  
  #include "libANGLE/renderer/vulkan/ContextVk.h"
  #include "libANGLE/renderer/vulkan/vk_cache_utils.h"
  
  namespace rx
  {
  namespace
  {
  angle::Result ErrorHandler(vk::Context *context, GlslangError)
  {
      ANGLE_VK_CHECK(context, false, VK_ERROR_INVALID_SHADER_NV);
      return angle::Result::Stop;
  }
  
  }  // namespace
  
  // static
  GlslangSourceOptions GlslangWrapperVk::CreateSourceOptions(const angle::FeaturesVk &features)
  {
      GlslangSourceOptions options;
  
      options.useOldRewriteStructSamplers = features.forceOldRewriteStructSamplers.enabled;
      options.supportsTransformFeedbackExtension =
          features.supportsTransformFeedbackExtension.enabled;
      options.emulateTransformFeedback = features.emulateTransformFeedback.enabled;
      options.emulateBresenhamLines    = features.basicGLLineRasterization.enabled;
  
      return options;
  }
  
  // static
  void GlslangWrapperVk::ResetGlslangProgramInterfaceInfo(
      GlslangProgramInterfaceInfo *glslangProgramInterfaceInfo)
  {
      glslangProgramInterfaceInfo->uniformsAndXfbDescriptorSetIndex =
          ToUnderlying(DescriptorSetIndex::UniformsAndXfb);
      glslangProgramInterfaceInfo->currentUniformBindingIndex = 0;
      glslangProgramInterfaceInfo->textureDescriptorSetIndex =
          ToUnderlying(DescriptorSetIndex::Texture);
      glslangProgramInterfaceInfo->currentTextureBindingIndex = 0;
      glslangProgramInterfaceInfo->shaderResourceDescriptorSetIndex =
          ToUnderlying(DescriptorSetIndex::ShaderResource);
      glslangProgramInterfaceInfo->currentShaderResourceBindingIndex = 0;
      glslangProgramInterfaceInfo->driverUniformsDescriptorSetIndex =
          ToUnderlying(DescriptorSetIndex::DriverUniforms);
  
      glslangProgramInterfaceInfo->locationsUsedForXfbExtension = 0;
  }
  
  // static
  void GlslangWrapperVk::GetShaderSource(const angle::FeaturesVk &features,
                                         const gl::ProgramState &programState,
                                         const gl::ProgramLinkedResources &resources,
                                         GlslangProgramInterfaceInfo *programInterfaceInfo,
                                         gl::ShaderMap<std::string> *shaderSourcesOut,
                                         ShaderMapInterfaceVariableInfoMap *variableInfoMapOut)
  {
      GlslangSourceOptions options = CreateSourceOptions(features);
      GlslangGetShaderSource(options, programState, resources, programInterfaceInfo, shaderSourcesOut,
                             variableInfoMapOut);
  }
  
  // static
  angle::Result GlslangWrapperVk::GetShaderCode(vk::Context *context,
                                                const gl::ShaderBitSet &linkedShaderStages,
                                                const gl::Caps &glCaps,
                                                const gl::ShaderMap<std::string> &shaderSources,
                                                gl::ShaderMap<std::vector<uint32_t>> *shaderCodeOut)
  {
      return GlslangGetShaderSpirvCode(
          [context](GlslangError error) { return ErrorHandler(context, error); }, linkedShaderStages,
          glCaps, shaderSources, shaderCodeOut);
  }
  
  // static
  angle::Result GlslangWrapperVk::TransformSpirV(
      vk::Context *context,
      const gl::ShaderType shaderType,
      bool removeEarlyFragmentTestsOptimization,
      const ShaderInterfaceVariableInfoMap &variableInfoMap,
      const SpirvBlob &initialSpirvBlob,
      SpirvBlob *shaderCodeOut)
  {
      const bool removeDebugInfo = !context->getRenderer()->getEnableValidationLayers();
  
      return GlslangTransformSpirvCode(
          [context](GlslangError error) { return ErrorHandler(context, error); }, shaderType,
          removeEarlyFragmentTestsOptimization, removeDebugInfo, variableInfoMap, initialSpirvBlob,
          shaderCodeOut);
  }
  
  // static
  angle::Result GlslangWrapperVk::CompileShaderOneOff(vk::Context *context,
                                                      gl::ShaderType shaderType,
                                                      const std::string &shaderSource,
                                                      SpirvBlob *spirvBlobOut)
  {
      return GlslangCompileShaderOneOff(
          [context](GlslangError error) { return ErrorHandler(context, error); }, shaderType,
          shaderSource, spirvBlobOut);
  }
  }  // namespace rx
  

Download