kc3-lang/angle/src/libANGLE/ProgramExecutable.h

• Show log

  Commit

• Hash : 1e1c9d9d
  Author :
  Date : 2023-08-11T15:16:26
  

  Pack and reduce Program::mProgramInput size
  
  Right now mProgramInput is std::vector<sh::ShaderVariable>. It really
  only need a subset of ShaderVariable struct. This CL adds a ProgramInput
  struct so that we can add data members that actually required. This CL
  also makes bools into bitfield and some variables to uint16_t to further
  compact the size. This CL also groups the data memebers other than
  string to basicDataTypeStruct which only contains basic data types and
  the entire struct is memcpied during program binary load and save. This
  not just reduces number of memcpy calls, but also improves reliability
  so that when someone adds a new member into the struct, it will
  automatically load/save correctly.
  
  Bug: b/275102061
  Change-Id: Ic055c986453ed46e56057a0122c9926245fef4d1
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4776267
  Reviewed-by: Roman Lavrov <romanl@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Charlie Lao <cclao@google.com>
  

Download

• src/libANGLE/ProgramExecutable.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.
  //
  // ProgramExecutable.h: Collects the information and interfaces common to both Programs and
  // ProgramPipelines in order to execute/draw with either.
  
  #ifndef LIBANGLE_PROGRAMEXECUTABLE_H_
  #define LIBANGLE_PROGRAMEXECUTABLE_H_
  
  #include "common/BinaryStream.h"
  #include "libANGLE/Caps.h"
  #include "libANGLE/InfoLog.h"
  #include "libANGLE/ProgramLinkedResources.h"
  #include "libANGLE/Shader.h"
  #include "libANGLE/Uniform.h"
  #include "libANGLE/VaryingPacking.h"
  #include "libANGLE/angletypes.h"
  
  namespace gl
  {
  
  // This small structure encapsulates binding sampler uniforms to active GL textures.
  struct SamplerBinding
  {
      SamplerBinding();
      SamplerBinding(TextureType textureTypeIn,
                     GLenum samplerTypeIn,
                     SamplerFormat formatIn,
                     size_t elementCount);
      SamplerBinding(const SamplerBinding &other);
      ~SamplerBinding();
  
      // Necessary for retrieving active textures from the GL state.
      TextureType textureType;
  
      GLenum samplerType;
  
      SamplerFormat format;
  
      // List of all textures bound to this sampler, of type textureType.
      // Cropped by the amount of unused elements reported by the driver.
      std::vector<GLuint> boundTextureUnits;
  };
  
  struct ImageBinding
  {
      ImageBinding();
      ImageBinding(size_t count, TextureType textureTypeIn);
      ImageBinding(GLuint imageUnit, size_t count, TextureType textureTypeIn);
      ImageBinding(const ImageBinding &other);
      ~ImageBinding();
  
      // Necessary for distinguishing between textures with images and texture buffers.
      TextureType textureType;
  
      // List of all textures bound.
      // Cropped by the amount of unused elements reported by the driver.
      std::vector<GLuint> boundImageUnits;
  };
  
  ANGLE_ENABLE_STRUCT_PADDING_WARNINGS
  struct ProgramInput
  {
      ProgramInput();
      ProgramInput(const sh::ShaderVariable &var);
      ProgramInput(const ProgramInput &other);
      ProgramInput &operator=(const ProgramInput &rhs);
  
      GLenum getType() const { return basicDataTypeStruct.type; }
      bool isBuiltIn() const { return basicDataTypeStruct.flagBits.isBuiltIn; }
      bool isArray() const { return basicDataTypeStruct.flagBits.isArray; }
      bool isActive() const { return basicDataTypeStruct.flagBits.active; }
      bool isPatch() const { return basicDataTypeStruct.flagBits.isPatch; }
      int getLocation() const { return basicDataTypeStruct.location; }
      unsigned int getBasicTypeElementCount() const
      {
          return basicDataTypeStruct.basicTypeElementCount;
      }
      unsigned int getArraySizeProduct() const { return basicDataTypeStruct.arraySizeProduct; }
      uint32_t getId() const { return basicDataTypeStruct.id; }
      sh::InterpolationType getInterpolation() const
      {
          return static_cast<sh::InterpolationType>(basicDataTypeStruct.interpolation);
      }
  
      void setLocation(int location) { basicDataTypeStruct.location = location; }
      void resetEffectiveLocation()
      {
          if (basicDataTypeStruct.flagBits.hasImplicitLocation)
          {
              basicDataTypeStruct.location = -1;
          }
      }
  
      std::string name;
      std::string mappedName;
  
      // The struct bellow must only contain data of basic type so that entire struct can memcpy-able.
      struct
      {
          uint16_t type;  // GLenum
          uint16_t arraySizeProduct;
  
          int location;
  
          uint8_t interpolation;  // sh::InterpolationType
          union
          {
              struct
              {
                  uint8_t active : 1;
                  uint8_t isPatch : 1;
                  uint8_t hasImplicitLocation : 1;
                  uint8_t isArray : 1;
                  uint8_t isBuiltIn : 1;
                  uint8_t padding : 3;
              } flagBits;
              uint8_t flagBitsAsUByte;
          };
          int16_t basicTypeElementCount;
  
          uint32_t id;
      } basicDataTypeStruct;
  };
  ANGLE_DISABLE_STRUCT_PADDING_WARNINGS
  
  // A varying with transform feedback enabled. If it's an array, either the whole array or one of its
  // elements specified by 'arrayIndex' can set to be enabled.
  struct TransformFeedbackVarying : public sh::ShaderVariable
  {
      TransformFeedbackVarying() = default;
  
      TransformFeedbackVarying(const sh::ShaderVariable &varyingIn, GLuint arrayIndexIn)
          : sh::ShaderVariable(varyingIn), arrayIndex(arrayIndexIn)
      {
          ASSERT(!isArrayOfArrays());
      }
  
      TransformFeedbackVarying(const sh::ShaderVariable &field, const sh::ShaderVariable &parent)
          : arrayIndex(GL_INVALID_INDEX)
      {
          sh::ShaderVariable *thisVar = this;
          *thisVar                    = field;
          interpolation               = parent.interpolation;
          isInvariant                 = parent.isInvariant;
          ASSERT(parent.isShaderIOBlock || !parent.name.empty());
          if (!parent.name.empty())
          {
              name       = parent.name + "." + name;
              mappedName = parent.mappedName + "." + mappedName;
          }
          structOrBlockName       = parent.structOrBlockName;
          mappedStructOrBlockName = parent.mappedStructOrBlockName;
      }
  
      std::string nameWithArrayIndex() const
      {
          std::stringstream fullNameStr;
          fullNameStr << name;
          if (arrayIndex != GL_INVALID_INDEX)
          {
              fullNameStr << "[" << arrayIndex << "]";
          }
          return fullNameStr.str();
      }
      GLsizei size() const
      {
          return (isArray() && arrayIndex == GL_INVALID_INDEX ? getOutermostArraySize() : 1);
      }
  
      GLuint arrayIndex;
  };
  
  class ProgramState;
  class ProgramPipelineState;
  
  class ProgramExecutable final : public angle::Subject
  {
    public:
      ProgramExecutable();
      ProgramExecutable(const ProgramExecutable &other);
      ~ProgramExecutable() override;
  
      void reset(bool clearInfoLog);
  
      void save(bool isSeparable, gl::BinaryOutputStream *stream) const;
      void load(bool isSeparable, gl::BinaryInputStream *stream);
  
      int getInfoLogLength() const;
      InfoLog &getInfoLog() { return mInfoLog; }
      void getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const;
      std::string getInfoLogString() const;
      void resetInfoLog() { mInfoLog.reset(); }
  
      void resetLinkedShaderStages() { mLinkedShaderStages.reset(); }
      const ShaderBitSet getLinkedShaderStages() const { return mLinkedShaderStages; }
      void setLinkedShaderStages(ShaderType shaderType)
      {
          mLinkedShaderStages.set(shaderType);
          updateCanDrawWith();
      }
      bool hasLinkedShaderStage(ShaderType shaderType) const
      {
          ASSERT(shaderType != ShaderType::InvalidEnum);
          return mLinkedShaderStages[shaderType];
      }
      size_t getLinkedShaderStageCount() const { return mLinkedShaderStages.count(); }
      bool hasLinkedGraphicsShader() const
      {
          return mLinkedShaderStages.any() &&
                 mLinkedShaderStages != gl::ShaderBitSet{gl::ShaderType::Compute};
      }
      bool hasLinkedTessellationShader() const
      {
          return mLinkedShaderStages[ShaderType::TessEvaluation];
      }
  
      ShaderType getLinkedTransformFeedbackStage() const;
  
      const AttributesMask &getActiveAttribLocationsMask() const
      {
          return mActiveAttribLocationsMask;
      }
      bool isAttribLocationActive(size_t attribLocation) const;
      AttributesMask getNonBuiltinAttribLocationsMask() const { return mAttributesMask; }
      unsigned int getMaxActiveAttribLocation() const { return mMaxActiveAttribLocation; }
      ComponentTypeMask getAttributesTypeMask() const { return mAttributesTypeMask; }
      AttributesMask getAttributesMask() const;
  
      const ActiveTextureMask &getActiveSamplersMask() const { return mActiveSamplersMask; }
      void setActiveTextureMask(ActiveTextureMask mask) { mActiveSamplersMask = mask; }
      SamplerFormat getSamplerFormatForTextureUnitIndex(size_t textureUnitIndex) const
      {
          return mActiveSamplerFormats[textureUnitIndex];
      }
      const ShaderBitSet getSamplerShaderBitsForTextureUnitIndex(size_t textureUnitIndex) const
      {
          return mActiveSamplerShaderBits[textureUnitIndex];
      }
      const ActiveTextureMask &getActiveImagesMask() const { return mActiveImagesMask; }
      void setActiveImagesMask(ActiveTextureMask mask) { mActiveImagesMask = mask; }
      const ActiveTextureArray<ShaderBitSet> &getActiveImageShaderBits() const
      {
          return mActiveImageShaderBits;
      }
  
      const ActiveTextureMask &getActiveYUVSamplers() const { return mActiveSamplerYUV; }
  
      const ActiveTextureArray<TextureType> &getActiveSamplerTypes() const
      {
          return mActiveSamplerTypes;
      }
  
      void setActive(size_t textureUnit,
                     const SamplerBinding &samplerBinding,
                     const gl::LinkedUniform &samplerUniform);
      void setInactive(size_t textureUnit);
      void hasSamplerTypeConflict(size_t textureUnit);
      void hasSamplerFormatConflict(size_t textureUnit);
  
      void updateActiveSamplers(const ProgramState &programState);
  
      bool hasDefaultUniforms() const;
      bool hasTextures() const;
      bool hasUniformBuffers() const;
      bool hasStorageBuffers() const;
      bool hasAtomicCounterBuffers() const;
      bool hasImages() const;
      bool hasTransformFeedbackOutput() const
      {
          return !getLinkedTransformFeedbackVaryings().empty();
      }
      bool usesFramebufferFetch() const;
  
      // Count the number of uniform and storage buffer declarations, counting arrays as one.
      size_t getTransformFeedbackBufferCount() const { return mTransformFeedbackStrides.size(); }
  
      void updateCanDrawWith();
      bool hasVertexShader() const { return mCanDrawWith; }
  
      const std::vector<ProgramInput> &getProgramInputs() const { return mProgramInputs; }
      const std::vector<sh::ShaderVariable> &getOutputVariables() const { return mOutputVariables; }
      const std::vector<VariableLocation> &getOutputLocations() const { return mOutputLocations; }
      const std::vector<VariableLocation> &getSecondaryOutputLocations() const
      {
          return mSecondaryOutputLocations;
      }
      const std::vector<LinkedUniform> &getUniforms() const { return mUniforms; }
      const std::vector<std::string> &getUniformNames() const { return mUniformNames; }
      const std::vector<std::string> &getUniformMappedNames() const { return mUniformMappedNames; }
      const std::vector<InterfaceBlock> &getUniformBlocks() const { return mUniformBlocks; }
      const UniformBlockBindingMask &getActiveUniformBlockBindings() const
      {
          return mActiveUniformBlockBindings;
      }
      const std::vector<SamplerBinding> &getSamplerBindings() const { return mSamplerBindings; }
      const std::vector<ImageBinding> &getImageBindings() const { return mImageBindings; }
      std::vector<ImageBinding> *getImageBindings() { return &mImageBindings; }
      const RangeUI &getDefaultUniformRange() const { return mDefaultUniformRange; }
      const RangeUI &getSamplerUniformRange() const { return mSamplerUniformRange; }
      const RangeUI &getImageUniformRange() const { return mImageUniformRange; }
      const RangeUI &getAtomicCounterUniformRange() const { return mAtomicCounterUniformRange; }
      const RangeUI &getFragmentInoutRange() const { return mFragmentInoutRange; }
      bool hasClipDistance() const { return mHasClipDistance; }
      bool hasDiscard() const { return mHasDiscard; }
      bool enablesPerSampleShading() const { return mEnablesPerSampleShading; }
      BlendEquationBitSet getAdvancedBlendEquations() const { return mAdvancedBlendEquations; }
      const std::vector<TransformFeedbackVarying> &getLinkedTransformFeedbackVaryings() const
      {
          return mLinkedTransformFeedbackVaryings;
      }
      GLint getTransformFeedbackBufferMode() const { return mTransformFeedbackBufferMode; }
      GLuint getUniformBlockBinding(GLuint uniformBlockIndex) const
      {
          ASSERT(uniformBlockIndex < mUniformBlocks.size());
          return mUniformBlocks[uniformBlockIndex].binding;
      }
      GLuint getShaderStorageBlockBinding(GLuint blockIndex) const
      {
          ASSERT(blockIndex < mShaderStorageBlocks.size());
          return mShaderStorageBlocks[blockIndex].binding;
      }
      const std::vector<GLsizei> &getTransformFeedbackStrides() const
      {
          return mTransformFeedbackStrides;
      }
      const std::vector<AtomicCounterBuffer> &getAtomicCounterBuffers() const
      {
          return mAtomicCounterBuffers;
      }
      const std::vector<InterfaceBlock> &getShaderStorageBlocks() const
      {
          return mShaderStorageBlocks;
      }
      const LinkedUniform &getUniformByIndex(GLuint index) const
      {
          ASSERT(index < static_cast<size_t>(mUniforms.size()));
          return mUniforms[index];
      }
      const std::string &getUniformNameByIndex(GLuint index) const
      {
          ASSERT(index < static_cast<size_t>(mUniforms.size()));
          return mUniformNames[index];
      }
  
      ANGLE_INLINE GLuint getActiveUniformBlockCount() const
      {
          return static_cast<GLuint>(mUniformBlocks.size());
      }
  
      ANGLE_INLINE GLuint getActiveAtomicCounterBufferCount() const
      {
          return static_cast<GLuint>(mAtomicCounterBuffers.size());
      }
  
      ANGLE_INLINE GLuint getActiveShaderStorageBlockCount() const
      {
          size_t shaderStorageBlocksSize = mShaderStorageBlocks.size();
          return static_cast<GLuint>(shaderStorageBlocksSize);
      }
  
      GLuint getUniformIndexFromImageIndex(GLuint imageIndex) const;
  
      GLuint getUniformIndexFromSamplerIndex(GLuint samplerIndex) const;
  
      void saveLinkedStateInfo(const Context *context, const ProgramState &state);
      const std::vector<sh::ShaderVariable> &getLinkedOutputVaryings(ShaderType shaderType) const
      {
          return mLinkedOutputVaryings[shaderType];
      }
      const std::vector<sh::ShaderVariable> &getLinkedInputVaryings(ShaderType shaderType) const
      {
          return mLinkedInputVaryings[shaderType];
      }
  
      const std::vector<sh::ShaderVariable> &getLinkedUniforms(ShaderType shaderType) const
      {
          return mLinkedUniforms[shaderType];
      }
  
      const std::vector<sh::InterfaceBlock> &getLinkedUniformBlocks(ShaderType shaderType) const
      {
          return mLinkedUniformBlocks[shaderType];
      }
  
      int getLinkedShaderVersion(ShaderType shaderType) const
      {
          return mLinkedShaderVersions[shaderType];
      }
  
      bool isYUVOutput() const;
  
      PrimitiveMode getGeometryShaderInputPrimitiveType() const
      {
          return mGeometryShaderInputPrimitiveType;
      }
  
      PrimitiveMode getGeometryShaderOutputPrimitiveType() const
      {
          return mGeometryShaderOutputPrimitiveType;
      }
  
      int getGeometryShaderInvocations() const { return mGeometryShaderInvocations; }
  
      int getGeometryShaderMaxVertices() const { return mGeometryShaderMaxVertices; }
  
      GLenum getTessGenMode() const { return mTessGenMode; }
  
      void resetCachedValidateSamplersResult() { mCachedValidateSamplersResult.reset(); }
      bool validateSamplers(InfoLog *infoLog, const Caps &caps) const
      {
          // Use the cache if:
          // - we aren't using an info log (which gives the full error).
          // - The sample mapping hasn't changed and we've already validated.
          if (infoLog == nullptr && mCachedValidateSamplersResult.valid())
          {
              return mCachedValidateSamplersResult.value();
          }
  
          return validateSamplersImpl(infoLog, caps);
      }
  
      ComponentTypeMask getFragmentOutputsTypeMask() const { return mDrawBufferTypeMask; }
      DrawBufferMask getActiveOutputVariablesMask() const { return mActiveOutputVariablesMask; }
  
      bool linkUniforms(const Context *context,
                        const ShaderMap<std::vector<sh::ShaderVariable>> &shaderUniforms,
                        InfoLog &infoLog,
                        const ProgramAliasedBindings &uniformLocationBindings,
                        GLuint *combinedImageUniformsCount,
                        std::vector<UnusedUniform> *unusedUniforms,
                        std::vector<VariableLocation> *uniformLocationsOutOrNull);
  
      void copyInputsFromProgram(const ProgramState &programState);
      void copyShaderBuffersFromProgram(const ProgramState &programState, ShaderType shaderType);
      void clearSamplerBindings();
      void copySamplerBindingsFromProgram(const ProgramState &programState);
      void copyImageBindingsFromProgram(const ProgramState &programState);
      void copyOutputsFromProgram(const ProgramState &programState);
      void copyUniformsFromProgramMap(const ShaderMap<Program *> &programs);
  
    private:
      friend class Program;
      friend class ProgramPipeline;
      friend class ProgramState;
  
      void updateActiveImages(const ProgramExecutable &executable);
  
      // Scans the sampler bindings for type conflicts with sampler 'textureUnitIndex'.
      void setSamplerUniformTextureTypeAndFormat(size_t textureUnitIndex,
                                                 std::vector<SamplerBinding> &samplerBindings);
  
      bool linkMergedVaryings(const Context *context,
                              const ProgramMergedVaryings &mergedVaryings,
                              const std::vector<std::string> &transformFeedbackVaryingNames,
                              const LinkingVariables &linkingVariables,
                              bool isSeparable,
                              ProgramVaryingPacking *varyingPacking);
  
      bool linkValidateTransformFeedback(
          const Context *context,
          const ProgramMergedVaryings &varyings,
          ShaderType stage,
          const std::vector<std::string> &transformFeedbackVaryingNames);
  
      void gatherTransformFeedbackVaryings(
          const ProgramMergedVaryings &varyings,
          ShaderType stage,
          const std::vector<std::string> &transformFeedbackVaryingNames);
  
      void updateTransformFeedbackStrides();
  
      bool validateSamplersImpl(InfoLog *infoLog, const Caps &caps) const;
  
      bool linkValidateOutputVariables(const Caps &caps,
                                       const Extensions &extensions,
                                       const Version &version,
                                       GLuint combinedImageUniformsCount,
                                       GLuint combinedShaderStorageBlocksCount,
                                       const std::vector<sh::ShaderVariable> &outputVariables,
                                       int fragmentShaderVersion,
                                       const ProgramAliasedBindings &fragmentOutputLocations,
                                       const ProgramAliasedBindings &fragmentOutputIndices);
  
      void linkSamplerAndImageBindings(GLuint *combinedImageUniformsCount);
      bool linkAtomicCounterBuffers(const Context *context, InfoLog &infoLog);
  
      InfoLog mInfoLog;
  
      ShaderBitSet mLinkedShaderStages;
  
      angle::BitSet<MAX_VERTEX_ATTRIBS> mActiveAttribLocationsMask;
      unsigned int mMaxActiveAttribLocation;
      ComponentTypeMask mAttributesTypeMask;
      // mAttributesMask is identical to mActiveAttribLocationsMask with built-in attributes removed.
      AttributesMask mAttributesMask;
  
      // Cached mask of active samplers and sampler types.
      ActiveTextureMask mActiveSamplersMask;
      ActiveTextureArray<uint32_t> mActiveSamplerRefCounts;
      ActiveTextureArray<TextureType> mActiveSamplerTypes;
      ActiveTextureMask mActiveSamplerYUV;
      ActiveTextureArray<SamplerFormat> mActiveSamplerFormats;
      ActiveTextureArray<ShaderBitSet> mActiveSamplerShaderBits;
  
      // Cached mask of active images.
      ActiveTextureMask mActiveImagesMask;
      ActiveTextureArray<ShaderBitSet> mActiveImageShaderBits;
  
      bool mCanDrawWith;
  
      // Names and mapped names of output variables that are arrays include [0] in the end, similarly
      // to uniforms.
      std::vector<sh::ShaderVariable> mOutputVariables;
      std::vector<VariableLocation> mOutputLocations;
      DrawBufferMask mActiveOutputVariablesMask;
      // EXT_blend_func_extended secondary outputs (ones with index 1)
      std::vector<VariableLocation> mSecondaryOutputLocations;
      bool mYUVOutput;
      // Vertex attributes, Fragment input varyings, etc.
      std::vector<ProgramInput> mProgramInputs;
      std::vector<TransformFeedbackVarying> mLinkedTransformFeedbackVaryings;
      // The size of the data written to each transform feedback buffer per vertex.
      std::vector<GLsizei> mTransformFeedbackStrides;
      GLenum mTransformFeedbackBufferMode;
      // Uniforms are sorted in order:
      //  1. Non-opaque uniforms
      //  2. Sampler uniforms
      //  3. Image uniforms
      //  4. Atomic counter uniforms
      //  5. Subpass Input uniforms (Only for Vulkan)
      //  6. Uniform block uniforms
      // This makes opaque uniform validation easier, since we don't need a separate list.
      // For generating the entries and naming them we follow the spec: GLES 3.1 November 2016 section
      // 7.3.1.1 Naming Active Resources. There's a separate entry for each struct member and each
      // inner array of an array of arrays. Names and mapped names of uniforms that are arrays include
      // [0] in the end. This makes implementation of queries simpler.
      std::vector<LinkedUniform> mUniforms;
      std::vector<std::string> mUniformNames;
      // Only used by GL and D3D backend
      std::vector<std::string> mUniformMappedNames;
      RangeUI mDefaultUniformRange;
      RangeUI mSamplerUniformRange;
      RangeUI mImageUniformRange;
      RangeUI mAtomicCounterUniformRange;
      std::vector<InterfaceBlock> mUniformBlocks;
  
      // For faster iteration on the blocks currently being bound.
      UniformBlockBindingMask mActiveUniformBlockBindings;
  
      std::vector<AtomicCounterBuffer> mAtomicCounterBuffers;
      std::vector<InterfaceBlock> mShaderStorageBlocks;
  
      RangeUI mFragmentInoutRange;
      bool mHasClipDistance;
      bool mHasDiscard;
      bool mEnablesPerSampleShading;
  
      // KHR_blend_equation_advanced supported equation list
      BlendEquationBitSet mAdvancedBlendEquations;
  
      // An array of the samplers that are used by the program
      std::vector<SamplerBinding> mSamplerBindings;
  
      // An array of the images that are used by the program
      std::vector<ImageBinding> mImageBindings;
  
      ShaderMap<std::vector<sh::ShaderVariable>> mLinkedOutputVaryings;
      ShaderMap<std::vector<sh::ShaderVariable>> mLinkedInputVaryings;
      ShaderMap<std::vector<sh::ShaderVariable>> mLinkedUniforms;
      ShaderMap<std::vector<sh::InterfaceBlock>> mLinkedUniformBlocks;
  
      ShaderMap<int> mLinkedShaderVersions;
  
      // GL_EXT_geometry_shader.
      PrimitiveMode mGeometryShaderInputPrimitiveType;
      PrimitiveMode mGeometryShaderOutputPrimitiveType;
      int mGeometryShaderInvocations;
      int mGeometryShaderMaxVertices;
  
      // GL_EXT_tessellation_shader
      int mTessControlShaderVertices;
      GLenum mTessGenMode;
      GLenum mTessGenSpacing;
      GLenum mTessGenVertexOrder;
      GLenum mTessGenPointMode;
  
      // Fragment output variable base types: FLOAT, INT, or UINT.  Ordered by location.
      std::vector<GLenum> mOutputVariableTypes;
      ComponentTypeMask mDrawBufferTypeMask;
  
      // Cache for sampler validation
      mutable Optional<bool> mCachedValidateSamplersResult;
  };
  }  // namespace gl
  
  #endif  // LIBANGLE_PROGRAMEXECUTABLE_H_
  

Download