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

• Show log

  Commit

• Hash : 98c2e169
  Author :
  Date : 2022-05-20T16:17:49
  

  Vulkan: Reduce pre-rotation spec const to bool
  
  The specialization constant now only dictates whether x and y should be
  swapped.  The complete 8 possible states of rotation and y-flip are
  achieved by using this swap in combination with a driver uniform for x
  and y flip.
  
  Swapping is still a specialization constant to avoid degrading
  performance of dFdx/dFdy which otherwise would need both to be evaluated
  instead of one.  On platforms which don't support pre-rotation, the
  specialization constant will never change and driver uniforms entirely
  govern y-flip.  On platforms that do support pre-rotation, only two
  variations of the pipeline are needed.
  
  Bug: angleproject:7366
  Change-Id: I73f84e89fa9349d2098fa5b21573aee57d93a30c
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3663151
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Lingfeng Yang <lfy@google.com>
  Reviewed-by: Charlie Lao <cclao@google.com>
  

Download

• src/libANGLE/renderer/vulkan/ShaderVk.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.
  //
  // ShaderVk.cpp:
  //    Implements the class methods for ShaderVk.
  //
  
  #include "libANGLE/renderer/vulkan/ShaderVk.h"
  
  #include "common/debug.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/renderer/vulkan/ContextVk.h"
  #include "platform/FeaturesVk_autogen.h"
  
  namespace rx
  {
  
  ShaderVk::ShaderVk(const gl::ShaderState &state) : ShaderImpl(state) {}
  
  ShaderVk::~ShaderVk() {}
  
  std::shared_ptr<WaitableCompileEvent> ShaderVk::compile(const gl::Context *context,
                                                          gl::ShCompilerInstance *compilerInstance,
                                                          ShCompileOptions options)
  {
      ShCompileOptions compileOptions = 0;
  
      ContextVk *contextVk = vk::GetImpl(context);
  
      if (context->isWebGL())
      {
          // Only WebGL requires initialization of local variables, others don't.
          // Extra initialization in spirv shader may affect performance.
          compileOptions |= SH_INITIALIZE_UNINITIALIZED_LOCALS;
  
          // WebGL shaders may contain OOB array accesses which in turn cause undefined behavior,
          // which may result in security issues. See https://crbug.com/1189110.
          compileOptions |= SH_CLAMP_INDIRECT_ARRAY_BOUNDS;
  
          if (mState.getShaderType() != gl::ShaderType::Compute)
          {
              compileOptions |= SH_INIT_OUTPUT_VARIABLES;
          }
      }
  
      if (contextVk->getFeatures().clampPointSize.enabled)
      {
          compileOptions |= SH_CLAMP_POINT_SIZE;
      }
  
      if (contextVk->getFeatures().basicGLLineRasterization.enabled)
      {
          compileOptions |= SH_ADD_BRESENHAM_LINE_RASTER_EMULATION;
      }
  
      if (contextVk->getFeatures().emulateAdvancedBlendEquations.enabled)
      {
          compileOptions |= SH_ADD_ADVANCED_BLEND_EQUATIONS_EMULATION;
      }
  
      if (contextVk->emulateSeamfulCubeMapSampling())
      {
          compileOptions |= SH_EMULATE_SEAMFUL_CUBE_MAP_SAMPLING;
      }
  
      if (!contextVk->getFeatures().enablePrecisionQualifiers.enabled)
      {
          compileOptions |= SH_IGNORE_PRECISION_QUALIFIERS;
      }
  
      if (contextVk->getFeatures().forceFragmentShaderPrecisionHighpToMediump.enabled)
      {
          compileOptions |= SH_FORCE_SHADER_PRECISION_HIGHP_TO_MEDIUMP;
      }
  
      // Let compiler use specialized constant for pre-rotation.
      if (!contextVk->getFeatures().forceDriverUniformOverSpecConst.enabled)
      {
          compileOptions |= SH_USE_SPECIALIZATION_CONSTANT;
      }
  
      if (contextVk->getFeatures().supportsTransformFeedbackExtension.enabled)
      {
          compileOptions |= SH_ADD_VULKAN_XFB_EXTENSION_SUPPORT_CODE;
      }
      else if (mState.getShaderType() == gl::ShaderType::Vertex &&
               contextVk->getFeatures().emulateTransformFeedback.enabled)
      {
          compileOptions |= SH_ADD_VULKAN_XFB_EMULATION_SUPPORT_CODE;
      }
  
      if (contextVk->getFeatures().generateSPIRVThroughGlslang.enabled)
      {
          compileOptions |= SH_GENERATE_SPIRV_THROUGH_GLSLANG;
      }
  
      if (contextVk->getFeatures().roundOutputAfterDithering.enabled)
      {
          compileOptions |= SH_ROUND_OUTPUT_AFTER_DITHERING;
      }
  
      return compileImpl(context, compilerInstance, mState.getSource(), compileOptions | options);
  }
  
  std::string ShaderVk::getDebugInfo() const
  {
      return mState.getCompiledBinary().empty() ? "" : "<binary blob>";
  }
  
  }  // namespace rx
  

Download