kc3-lang/angle/src/compiler/translator/msl/Pipeline.h

• Show log

  Commit

• Hash : 5d70a41c
  Author :
  Date : 2023-11-30T00:00:00
  

  Metal: Use a separate struct for last fragment data
  
  Used a separate MSL struct type for reading from
  framebuffer attachments to not fetch unnecessary
  draw buffers and to be able to set a sample mask.
  
  Removed TranslatorMSL::isSampleMaskAllowed()
  
  Ensured that the lastFragmentOut variable is not
  added when PLS does not use framebuffer fetch.
  
  Fixed: angleproject:8442
  Change-Id: Ia3320fc6063277479b5aa9b7fea34457465add75
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5079450
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Alexey Knyazev <lexa.knyazev@gmail.com>
  

Download

• src/compiler/translator/msl/Pipeline.h

• //
  // Copyright 2020 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.
  //
  
  #ifndef COMPILER_TRANSLATOR_MSL_PIPELINE_H_
  #define COMPILER_TRANSLATOR_MSL_PIPELINE_H_
  
  #include "compiler/translator/Symbol.h"
  #include "compiler/translator/msl/ModifyStruct.h"
  #include "compiler/translator/msl/Name.h"
  #include "compiler/translator/msl/SymbolEnv.h"
  
  namespace sh
  {
  
  // Data that is scoped as `external` and `internal` for a given pipeline.
  template <typename T>
  struct PipelineScoped
  {
      // Data that is configured to talk externally to the program.
      // May coincide with `internal`, but may also diverge from `internal`.
      const T *external = nullptr;
  
      // Extra data that is configured to talk externally to the program.
      // Used for framebuffer fetch and for adjusting Metal's InstanceId.
      const T *externalExtra = nullptr;
  
      // Data that is configured to talk internally within the program.
      // May coincide with `external`, but may also diverge from `external`.
      const T *internal = nullptr;
  
      // Returns true iff the input coincides with either `external` or `internal` data.
      bool matches(const T &object) const { return external == &object || internal == &object; }
  
      // Both `external` and `internal` representations are non-null.
      bool isTotallyFull() const { return external && internal; }
  
      // Both `external` and `internal` representations are null.
      bool isTotallyEmpty() const { return !external && !internal; }
  
      // Both `external` and `internal` representations are the same.
      bool isUniform() const { return external == internal; }
  };
  
  // Represents a high-level program pipeline.
  class Pipeline
  {
    public:
      enum class Type
      {
          VertexIn,
          VertexOut,
          FragmentIn,
          FragmentOut,
          UserUniforms,
          AngleUniforms,
          NonConstantGlobals,
          InvocationVertexGlobals,
          InvocationFragmentGlobals,
          UniformBuffer,
          Texture,
          Image,
          InstanceId,
      };
  
      enum class Variant
      {
          // For all internal pipeline uses.
          // For external pipeline uses if pipeline does not require splitting or saturation.
          Original,
  
          // Only for external pipeline uses if the pipeline was split or saturated.
          Modified,
      };
  
    public:
      // The type of the pipeline.
      Type type;
  
      // Non-null if a global instance of the pipeline struct already exists.
      // If non-null struct splitting should not be needed.
      const TVariable *globalInstanceVar;
  
    public:
      // Returns true iff the variable belongs to the pipeline.
      bool uses(const TVariable &var) const;
  
      // Returns the name for the struct type that stores variables of this pipeline.
      Name getStructTypeName(Variant variant) const;
  
      // Returns the name for the struct instance that stores variables of this pipeline.
      Name getStructInstanceName(Variant variant) const;
  
      ModifyStructConfig externalStructModifyConfig() const;
  
      // Returns true if the pipeline always requires a non-parameter local instance declaration of
      // the pipeline structures.
      bool alwaysRequiresLocalVariableDeclarationInMain() const;
  
      // Returns true iff the pipeline is an output pipeline. The external pipeline structure should
      // be returned from `main`.
      bool isPipelineOut() const;
  
      AddressSpace externalAddressSpace() const;
  };
  
  // A collection of various pipeline structures.
  struct PipelineStructs : angle::NonCopyable
  {
      PipelineScoped<TStructure> fragmentIn;
      PipelineScoped<TStructure> fragmentOut;
      PipelineScoped<TStructure> vertexIn;
      PipelineScoped<TStructure> vertexOut;
      PipelineScoped<TStructure> userUniforms;
      PipelineScoped<TStructure> angleUniforms;
      PipelineScoped<TStructure> nonConstantGlobals;
      PipelineScoped<TStructure> invocationVertexGlobals;
      PipelineScoped<TStructure> invocationFragmentGlobals;
      PipelineScoped<TStructure> uniformBuffers;
      PipelineScoped<TStructure> texture;
      PipelineScoped<TStructure> image;
      PipelineScoped<TStructure> instanceId;
  
      bool matches(const TStructure &s, bool internal, bool external) const;
  };
  
  }  // namespace sh
  
  #endif  // COMPILER_TRANSLATOR_MSL_PIPELINE_H_
  

Download