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

• Show log

  Commit

• Hash : 29fba5e0
  Author :
  Date : 2019-07-04T17:08:41
  

  Vulkan: Prepare for variable-stage pipelines
  
  Compute (single-stage pipeline) is upcoming, but this change prepares
  GlslangWrapper to handle any number of stages (mostly).  Additionally,
  this change binds each resource to each stage based on whether it's
  active, so that we don't hit the per-stage limit of resources by binding
  every resource to every stage.
  
  Bug: angleproject:3633
  Bug: angleproject:3562
  Change-Id: Ifebf691482846e0371c6e314f514226a4cfee258
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1689330
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@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);
  }
  
  void ActiveVariable::unionReferencesWith(const ActiveVariable &other)
  {
      mActiveUseBits |= other.mActiveUseBits;
  }
  
  ShaderType ActiveVariable::getFirstShaderTypeWhereActive() const
  {
      return static_cast<ShaderType>(ScanForward(mActiveUseBits.bits()));
  }
  
  GLuint ActiveVariable::activeShaderCount() const
  {
      return static_cast<GLuint>(mActiveUseBits.count());
  }
  
  LinkedUniform::LinkedUniform()
      : typeInfo(nullptr), bufferIndex(-1), blockInfo(sh::kDefaultBlockMemberInfo)
  {}
  
  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::kDefaultBlockMemberInfo)
  {
      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::kDefaultBlockMemberInfo), 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();
  }
  }  // namespace gl
  

Download