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

• Show log

  Commit

• Hash : 7a8fe156
  Author :
  Date : 2018-04-28T12:59:58
  

  ES31: Add link validation on MAX_COMBINED_SHADER_OUTPUT_RESOURCES
  
  This patch adds the link validation on the maximum combined shader
  output resources required in OpenGL ES 3.1 SPEC.
  
  OpenGL ES 3.1 SPEC has restrictions on the sum of the number of all
  active images, shader storage blocks and fragment shader outputs. A
  link error will be generated if this sum exceeds the implementation-
  dependent value of MAX_COMBINED_SHADER_OUTPUT_RESOURCES.
  
  In order not to affect the existing image tests, this patch also
  sets a temporary value for maxCombinedShaderOutputResources on D3D11
  back-ends. We will set more accurate values for all the UAV related
  resource limits in the next patch.
  
  BUG=angleproject:2345
  TEST=dEQP-GLES31.functional.state_query.integer.max_combined_shader_output_resources_*
  
  Change-Id: Ib83a19ef0ae0b9af3422b5c970c7c07d96b2359d
  Reviewed-on: https://chromium-review.googlesource.com/1039155
  Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/libANGLE/Uniform.h

• //
  // Copyright (c) 2010-2013 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 LIBANGLE_UNIFORM_H_
  #define LIBANGLE_UNIFORM_H_
  
  #include <string>
  #include <vector>
  
  #include "angle_gl.h"
  #include "common/debug.h"
  #include "common/MemoryBuffer.h"
  #include "compiler/translator/blocklayout.h"
  #include "libANGLE/angletypes.h"
  
  namespace gl
  {
  struct UniformTypeInfo;
  
  struct ActiveVariable
  {
      ActiveVariable();
      ActiveVariable(const ActiveVariable &rhs);
      virtual ~ActiveVariable();
  
      ActiveVariable &operator=(const ActiveVariable &rhs);
  
      ShaderType getFirstShaderTypeWhereActive() const;
      void setActive(ShaderType shaderType, bool used);
      void unionReferencesWith(const ActiveVariable &other);
      bool isActive(ShaderType shaderType) const;
      GLuint activeShaderCount() const;
  
    private:
      ShaderBitSet mActiveUseBits;
  };
  
  // Helper struct representing a single shader uniform
  struct LinkedUniform : public sh::Uniform, public ActiveVariable
  {
      LinkedUniform();
      LinkedUniform(GLenum type,
                    GLenum precision,
                    const std::string &name,
                    const std::vector<unsigned int> &arraySizes,
                    const int binding,
                    const int offset,
                    const int location,
                    const int bufferIndex,
                    const sh::BlockMemberInfo &blockInfo);
      LinkedUniform(const sh::Uniform &uniform);
      LinkedUniform(const LinkedUniform &uniform);
      LinkedUniform &operator=(const LinkedUniform &uniform);
      ~LinkedUniform() override;
  
      bool isSampler() const;
      bool isImage() const;
      bool isAtomicCounter() const;
      bool isInDefaultBlock() const;
      bool isField() const;
      size_t getElementSize() const;
      size_t getElementComponents() const;
  
      const UniformTypeInfo *typeInfo;
  
      // Identifies the containing buffer backed resource -- interface block or atomic counter buffer.
      int bufferIndex;
      sh::BlockMemberInfo blockInfo;
  };
  
  struct BufferVariable : public sh::ShaderVariable, public ActiveVariable
  {
      BufferVariable();
      BufferVariable(GLenum type,
                     GLenum precision,
                     const std::string &name,
                     const std::vector<unsigned int> &arraySizes,
                     const int bufferIndex,
                     const sh::BlockMemberInfo &blockInfo);
      ~BufferVariable() override;
  
      int bufferIndex;
      sh::BlockMemberInfo blockInfo;
  
      int topLevelArraySize;
  };
  
  // Parent struct for atomic counter, uniform block, and shader storage block buffer, which all
  // contain a group of shader variables, and have a GL buffer backed.
  struct ShaderVariableBuffer : public ActiveVariable
  {
      ShaderVariableBuffer();
      ShaderVariableBuffer(const ShaderVariableBuffer &other);
      ~ShaderVariableBuffer() override;
      int numActiveVariables() const;
  
      int binding;
      unsigned int dataSize;
      std::vector<unsigned int> memberIndexes;
  };
  
  using AtomicCounterBuffer = ShaderVariableBuffer;
  
  // Helper struct representing a single shader interface block
  struct InterfaceBlock : public ShaderVariableBuffer
  {
      InterfaceBlock();
      InterfaceBlock(const std::string &nameIn,
                     const std::string &mappedNameIn,
                     bool isArrayIn,
                     unsigned int arrayElementIn,
                     int bindingIn);
  
      std::string nameWithArrayIndex() const;
      std::string mappedNameWithArrayIndex() const;
  
      std::string name;
      std::string mappedName;
      bool isArray;
      unsigned int arrayElement;
  };
  
  }
  
  #endif   // LIBANGLE_UNIFORM_H_
  

Download