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

• 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.cpp

• //
  // 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.
  //
  
  #include "libANGLE/Uniform.h"
  
  #include "common/utilities.h"
  
  #include <cstring>
  
  namespace gl
  {
  
  ActiveVariable::ActiveVariable()
  {
  }
  
  ActiveVariable::~ActiveVariable()
  {
  }
  
  ActiveVariable::ActiveVariable(const ActiveVariable &rhs) = default;
  ActiveVariable &ActiveVariable::operator=(const ActiveVariable &rhs) = default;
  
  void ActiveVariable::setActive(ShaderType shaderType, bool used)
  {
      ASSERT(shaderType != ShaderType::InvalidEnum);
      mActiveUseBits.set(shaderType, used);
  }
  
  bool ActiveVariable::isActive(ShaderType shaderType) const
  {
      ASSERT(shaderType != ShaderType::InvalidEnum);
      return mActiveUseBits[shaderType];
  }
  
  void ActiveVariable::unionReferencesWith(const ActiveVariable &other)
  {
      mActiveUseBits |= other.mActiveUseBits;
  }
  
  ShaderType ActiveVariable::getFirstShaderTypeWhereActive() const
  {
      return static_cast<ShaderType>(gl::ScanForward(mActiveUseBits.bits()));
  }
  
  GLuint ActiveVariable::activeShaderCount() const
  {
      return static_cast<GLuint>(mActiveUseBits.count());
  }
  
  LinkedUniform::LinkedUniform()
      : typeInfo(nullptr), bufferIndex(-1), blockInfo(sh::BlockMemberInfo::getDefaultBlockInfo())
  {
  }
  
  LinkedUniform::LinkedUniform(GLenum typeIn,
                               GLenum precisionIn,
                               const std::string &nameIn,
                               const std::vector<unsigned int> &arraySizesIn,
                               const int bindingIn,
                               const int offsetIn,
                               const int locationIn,
                               const int bufferIndexIn,
                               const sh::BlockMemberInfo &blockInfoIn)
      : typeInfo(&GetUniformTypeInfo(typeIn)), bufferIndex(bufferIndexIn), blockInfo(blockInfoIn)
  {
      type      = typeIn;
      precision = precisionIn;
      name      = nameIn;
      arraySizes = arraySizesIn;
      binding   = bindingIn;
      offset    = offsetIn;
      location  = locationIn;
      ASSERT(!isArrayOfArrays());
      ASSERT(!isArray() || !isStruct());
  }
  
  LinkedUniform::LinkedUniform(const sh::Uniform &uniform)
      : sh::Uniform(uniform),
        typeInfo(&GetUniformTypeInfo(type)),
        bufferIndex(-1),
        blockInfo(sh::BlockMemberInfo::getDefaultBlockInfo())
  {
      ASSERT(!isArrayOfArrays());
      ASSERT(!isArray() || !isStruct());
  }
  
  LinkedUniform::LinkedUniform(const LinkedUniform &uniform)
      : sh::Uniform(uniform),
        ActiveVariable(uniform),
        typeInfo(uniform.typeInfo),
        bufferIndex(uniform.bufferIndex),
        blockInfo(uniform.blockInfo)
  {
  }
  
  LinkedUniform &LinkedUniform::operator=(const LinkedUniform &uniform)
  {
      sh::Uniform::operator=(uniform);
      ActiveVariable::operator=(uniform);
      typeInfo             = uniform.typeInfo;
      bufferIndex          = uniform.bufferIndex;
      blockInfo            = uniform.blockInfo;
      return *this;
  }
  
  LinkedUniform::~LinkedUniform()
  {
  }
  
  bool LinkedUniform::isInDefaultBlock() const
  {
      return bufferIndex == -1;
  }
  
  bool LinkedUniform::isSampler() const
  {
      return typeInfo->isSampler;
  }
  
  bool LinkedUniform::isImage() const
  {
      return typeInfo->isImageType;
  }
  
  bool LinkedUniform::isAtomicCounter() const
  {
      return IsAtomicCounterType(type);
  }
  
  bool LinkedUniform::isField() const
  {
      return name.find('.') != std::string::npos;
  }
  
  size_t LinkedUniform::getElementSize() const
  {
      return typeInfo->externalSize;
  }
  
  size_t LinkedUniform::getElementComponents() const
  {
      return typeInfo->componentCount;
  }
  
  BufferVariable::BufferVariable()
      : bufferIndex(-1), blockInfo(sh::BlockMemberInfo::getDefaultBlockInfo()), topLevelArraySize(-1)
  {
  }
  
  BufferVariable::BufferVariable(GLenum typeIn,
                                 GLenum precisionIn,
                                 const std::string &nameIn,
                                 const std::vector<unsigned int> &arraySizesIn,
                                 const int bufferIndexIn,
                                 const sh::BlockMemberInfo &blockInfoIn)
      : bufferIndex(bufferIndexIn), blockInfo(blockInfoIn), topLevelArraySize(-1)
  {
      type      = typeIn;
      precision = precisionIn;
      name      = nameIn;
      arraySizes = arraySizesIn;
  }
  
  BufferVariable::~BufferVariable()
  {
  }
  
  ShaderVariableBuffer::ShaderVariableBuffer() : binding(0), dataSize(0)
  {
  }
  
  ShaderVariableBuffer::ShaderVariableBuffer(const ShaderVariableBuffer &other) = default;
  
  ShaderVariableBuffer::~ShaderVariableBuffer()
  {
  }
  
  int ShaderVariableBuffer::numActiveVariables() const
  {
      return static_cast<int>(memberIndexes.size());
  }
  
  InterfaceBlock::InterfaceBlock() : isArray(false), arrayElement(0)
  {
  }
  
  InterfaceBlock::InterfaceBlock(const std::string &nameIn,
                                 const std::string &mappedNameIn,
                                 bool isArrayIn,
                                 unsigned int arrayElementIn,
                                 int bindingIn)
      : name(nameIn), mappedName(mappedNameIn), isArray(isArrayIn), arrayElement(arrayElementIn)
  {
      binding = bindingIn;
  }
  
  std::string InterfaceBlock::nameWithArrayIndex() const
  {
      std::stringstream fullNameStr;
      fullNameStr << name;
      if (isArray)
      {
          fullNameStr << "[" << arrayElement << "]";
      }
  
      return fullNameStr.str();
  }
  
  std::string InterfaceBlock::mappedNameWithArrayIndex() const
  {
      std::stringstream fullNameStr;
      fullNameStr << mappedName;
      if (isArray)
      {
          fullNameStr << "[" << arrayElement << "]";
      }
  
      return fullNameStr.str();
  }
  }
  

Download