kc3-lang/angle/src/compiler/translator/spirv/BuiltinsWorkaround.cpp

• Show log

  Commit

• Hash : 074eec2f
  Author :
  Date : 2025-10-02T15:31:19
  

  Translator: remove angle_BaseVertex/Instance from built-ins
  
  These aren't built-ins, they are just used for emulation.  Instead of
  listing them in the built-in variables, they are now created as uniforms
  during emulation.
  
  This change also gives gl_BaseVertex/Instance their own qualifiers so
  they aren't considered uniforms.  The emulation pass is also optimized
  to do fewer passes.
  
  Bug: angleproject:349994211
  Change-Id: I44fd345fd4a2dc4a001eb294952a984ae710d606
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/7004388
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/compiler/translator/spirv/BuiltinsWorkaround.cpp

• //
  // Copyright 2019 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/spirv/BuiltinsWorkaround.h"
  
  #include "angle_gl.h"
  #include "compiler/translator/Symbol.h"
  #include "compiler/translator/SymbolTable.h"
  #include "compiler/translator/tree_util/BuiltIn.h"
  
  namespace sh
  {
  
  namespace
  {
  constexpr const ImmutableString kGlInstanceIDString("gl_InstanceID");
  constexpr const ImmutableString kGlVertexIDString("gl_VertexID");
  
  class TBuiltinsWorkaround : public TIntermTraverser
  {
    public:
      TBuiltinsWorkaround(TSymbolTable *symbolTable,
                          const ShCompileOptions &options,
                          const TVariable *emulatedBaseInstance)
          : TIntermTraverser(true, false, false, symbolTable),
            mCompileOptions(options),
            mEmulatedBaseInstance(emulatedBaseInstance)
      {}
  
      void visitSymbol(TIntermSymbol *node) override;
  
    private:
      void ensureVersionIsAtLeast(int version);
  
      const ShCompileOptions &mCompileOptions;
      const TVariable *mEmulatedBaseInstance;
  };
  
  void TBuiltinsWorkaround::visitSymbol(TIntermSymbol *node)
  {
      if (node->variable().symbolType() == SymbolType::BuiltIn &&
          node->getName() == kGlInstanceIDString)
      {
          TIntermSymbol *instanceIndexRef = new TIntermSymbol(BuiltInVariable::gl_InstanceIndex());
  
          if (mEmulatedBaseInstance != nullptr)
          {
              TIntermSymbol *baseInstanceRef = new TIntermSymbol(mEmulatedBaseInstance);
  
              TIntermBinary *subBaseInstance =
                  new TIntermBinary(EOpSub, instanceIndexRef, baseInstanceRef);
              queueReplacement(subBaseInstance, OriginalNode::IS_DROPPED);
          }
          else
          {
              queueReplacement(instanceIndexRef, OriginalNode::IS_DROPPED);
          }
      }
      else if (node->getName() == kGlVertexIDString)
      {
          TIntermSymbol *vertexIndexRef = new TIntermSymbol(BuiltInVariable::gl_VertexIndex());
          queueReplacement(vertexIndexRef, OriginalNode::IS_DROPPED);
      }
  }
  
  const TVariable *FindEmulatedBaseInstance(TIntermBlock *root)
  {
      for (TIntermNode *node : *root->getSequence())
      {
          TIntermDeclaration *decl = node->getAsDeclarationNode();
          if (decl == nullptr)
          {
              continue;
          }
  
          const TIntermSequence &sequence = *(decl->getSequence());
          ASSERT(!sequence.empty());
  
          TIntermSymbol *symbol = sequence[0]->getAsSymbolNode();
          if (symbol == nullptr)
          {
              continue;
          }
  
          if (symbol->variable().symbolType() == SymbolType::AngleInternal &&
              symbol->variable().name() == "angle_BaseInstance")
          {
              return &symbol->variable();
          }
      }
      return nullptr;
  }
  }  // anonymous namespace
  
  [[nodiscard]] bool ShaderBuiltinsWorkaround(TCompiler *compiler,
                                              TIntermBlock *root,
                                              TSymbolTable *symbolTable,
                                              const ShCompileOptions &compileOptions)
  {
      TBuiltinsWorkaround builtins(symbolTable, compileOptions, FindEmulatedBaseInstance(root));
      root->traverse(&builtins);
      if (!builtins.updateTree(compiler, root))
      {
          return false;
      }
      return true;
  }
  
  }  // namespace sh
  

Download