kc3-lang/angle/src/compiler/translator/TranslatorESSL.cpp

• Show log

  Commit

• Hash : a7dc51f2
  Author :
  Date : 2022-10-01T08:49:11
  

  Add a framebuffer fetch implementation of PLS
  
  The framebuffer fetch implementation works by attaching PLS backing
  textures to the framebuffer, and then rewriting PLS uniforms as "inout"
  fragment variables. The compiler's existing machinery takes it from
  there and makes it work on GL and Vulkan, and soon Metal.
  
  EXT_shader_framebuffer_fetch is now the preferred backend for pixel
  local storage, but we also use EXT_shader_framebuffer_fetch_non_coherent
  if shader images can't be coherent. This is especially interesting for
  Vulkan, since noncoherent framebuffer fetch is possible without any
  extensions.
  
  Bug: angleproject:7279
  Bug: angleproject:7683
  Bug: angleproject:7684
  Bug: angleproject:7724
  Change-Id: I33f3b2c6df9a5709969d9165c448ea71b096c9e1
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3900142
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Kenneth Russell <kbr@chromium.org>
  Commit-Queue: Chris Dalton <chris@rive.app>
  

Download

• src/compiler/translator/TranslatorESSL.cpp

• //
  // Copyright 2002 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.
  //
  
  #include "compiler/translator/TranslatorESSL.h"
  
  #include "angle_gl.h"
  #include "compiler/translator/BuiltInFunctionEmulatorGLSL.h"
  #include "compiler/translator/OutputESSL.h"
  #include "compiler/translator/tree_ops/RecordConstantPrecision.h"
  
  namespace sh
  {
  
  TranslatorESSL::TranslatorESSL(sh::GLenum type, ShShaderSpec spec)
      : TCompiler(type, spec, SH_ESSL_OUTPUT)
  {}
  
  void TranslatorESSL::initBuiltInFunctionEmulator(BuiltInFunctionEmulator *emu,
                                                   const ShCompileOptions &compileOptions)
  {
      if (compileOptions.emulateAtan2FloatFunction)
      {
          InitBuiltInAtanFunctionEmulatorForGLSLWorkarounds(emu);
      }
  }
  
  bool TranslatorESSL::translate(TIntermBlock *root,
                                 const ShCompileOptions &compileOptions,
                                 PerformanceDiagnostics * /*perfDiagnostics*/)
  {
      TInfoSinkBase &sink = getInfoSink().obj;
  
      int shaderVer = getShaderVersion();
      if (shaderVer > 100)
      {
          sink << "#version " << shaderVer << " es\n";
      }
  
      // Write built-in extension behaviors.
      writeExtensionBehavior(compileOptions);
  
      // Write pragmas after extensions because some drivers consider pragmas
      // like non-preprocessor tokens.
      WritePragma(sink, compileOptions, getPragma());
  
      if (!RecordConstantPrecision(this, root, &getSymbolTable()))
      {
          return false;
      }
  
      // Write emulated built-in functions if needed.
      if (!getBuiltInFunctionEmulator().isOutputEmpty())
      {
          sink << "// BEGIN: Generated code for built-in function emulation\n\n";
          if (getShaderType() == GL_FRAGMENT_SHADER)
          {
              sink << "#if defined(GL_FRAGMENT_PRECISION_HIGH)\n"
                   << "#define emu_precision highp\n"
                   << "#else\n"
                   << "#define emu_precision mediump\n"
                   << "#endif\n\n";
          }
          else
          {
              sink << "#define emu_precision highp\n";
          }
  
          getBuiltInFunctionEmulator().outputEmulatedFunctions(sink);
          sink << "// END: Generated code for built-in function emulation\n\n";
      }
  
      if (getShaderType() == GL_FRAGMENT_SHADER)
      {
          EmitEarlyFragmentTestsGLSL(*this, sink);
      }
  
      if (getShaderType() == GL_COMPUTE_SHADER)
      {
          EmitWorkGroupSizeGLSL(*this, sink);
      }
  
      if (getShaderType() == GL_GEOMETRY_SHADER_EXT)
      {
          WriteGeometryShaderLayoutQualifiers(
              sink, getGeometryShaderInputPrimitiveType(), getGeometryShaderInvocations(),
              getGeometryShaderOutputPrimitiveType(), getGeometryShaderMaxVertices());
      }
  
      // Write translated shader.
      TOutputESSL outputESSL(this, sink, compileOptions);
  
      root->traverse(&outputESSL);
  
      return true;
  }
  
  bool TranslatorESSL::shouldFlattenPragmaStdglInvariantAll()
  {
      // If following the spec to the letter, we should not flatten this pragma.
      // However, the spec's wording means that the pragma applies only to outputs.
      // This contradicts the spirit of using the pragma,
      // because if the pragma is used in a vertex shader,
      // the only way to be able to link it to a fragment shader
      // is to manually qualify each of fragment shader's inputs as invariant.
      // Which defeats the purpose of this pragma - temporarily make all varyings
      // invariant for debugging.
      // Thus, we should be non-conformant to spec's letter here and flatten.
      return true;
  }
  
  void TranslatorESSL::writeExtensionBehavior(const ShCompileOptions &compileOptions)
  {
      TInfoSinkBase &sink                   = getInfoSink().obj;
      const TExtensionBehavior &extBehavior = getExtensionBehavior();
      for (TExtensionBehavior::const_iterator iter = extBehavior.begin(); iter != extBehavior.end();
           ++iter)
      {
          if (iter->second != EBhUndefined)
          {
              const bool isMultiview = (iter->first == TExtension::OVR_multiview) ||
                                       (iter->first == TExtension::OVR_multiview2);
              if (getResources().NV_shader_framebuffer_fetch &&
                  iter->first == TExtension::EXT_shader_framebuffer_fetch)
              {
                  sink << "#extension GL_NV_shader_framebuffer_fetch : "
                       << GetBehaviorString(iter->second) << "\n";
              }
              else if (getResources().NV_draw_buffers && iter->first == TExtension::EXT_draw_buffers)
              {
                  sink << "#extension GL_NV_draw_buffers : " << GetBehaviorString(iter->second)
                       << "\n";
              }
              else if (isMultiview)
              {
                  // Only either OVR_multiview OR OVR_multiview2 should be emitted.
                  if ((iter->first != TExtension::OVR_multiview) ||
                      !IsExtensionEnabled(extBehavior, TExtension::OVR_multiview2))
                  {
                      EmitMultiviewGLSL(*this, compileOptions, iter->first, iter->second, sink);
                  }
              }
              else if (iter->first == TExtension::EXT_geometry_shader ||
                       iter->first == TExtension::OES_geometry_shader)
              {
                  sink << "#ifdef GL_EXT_geometry_shader\n"
                       << "#extension GL_EXT_geometry_shader : " << GetBehaviorString(iter->second)
                       << "\n"
                       << "#elif defined GL_OES_geometry_shader\n"
                       << "#extension GL_OES_geometry_shader : " << GetBehaviorString(iter->second)
                       << "\n";
                  if (iter->second == EBhRequire)
                  {
                      sink << "#else\n"
                           << "#error \"No geometry shader extensions available.\" // Only generate "
                              "this if the extension is \"required\"\n";
                  }
                  sink << "#endif\n";
              }
              else if (iter->first == TExtension::ANGLE_multi_draw)
              {
                  // Don't emit anything. This extension is emulated
                  ASSERT(compileOptions.emulateGLDrawID);
                  continue;
              }
              else if (iter->first == TExtension::ANGLE_base_vertex_base_instance_shader_builtin)
              {
                  // Don't emit anything. This extension is emulated
                  ASSERT(compileOptions.emulateGLBaseVertexBaseInstance);
                  continue;
              }
              else if (iter->first == TExtension::ANGLE_shader_pixel_local_storage)
              {
                  // TODO(anglebug.com/7279): future impl that uses EXT_shader_pixel_local_storage.
                  if (compileOptions.pls.type == ShPixelLocalStorageType::FramebufferFetch)
                  {
                      // Just enable the extension. Appropriate warnings will be generated by the
                      // frontend compiler for GL_ANGLE_shader_pixel_local_storage, if desired.
                      sink << "#extension GL_EXT_shader_framebuffer_fetch : enable\n";
                  }
                  continue;
              }
              else if (iter->first == TExtension::EXT_shader_framebuffer_fetch)
              {
                  sink << "#extension GL_EXT_shader_framebuffer_fetch : "
                       << GetBehaviorString(iter->second) << "\n";
                  continue;
              }
              else if (iter->first == TExtension::EXT_shader_framebuffer_fetch_non_coherent)
              {
                  sink << "#extension GL_EXT_shader_framebuffer_fetch_non_coherent : "
                       << GetBehaviorString(iter->second) << "\n";
                  continue;
              }
              else if (iter->first == TExtension::WEBGL_video_texture)
              {
                  // Don't emit anything. This extension is emulated
                  // TODO(crbug.com/776222): support external image.
                  continue;
              }
              else
              {
                  sink << "#extension " << GetExtensionNameString(iter->first) << " : "
                       << GetBehaviorString(iter->second) << "\n";
              }
          }
      }
  }
  
  }  // namespace sh
  

Download