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

• Show log

  Commit

• Hash : f00f7ffe
  Author :
  Date : 2017-08-31T14:39:15
  

  Add a Uniform type info table.
  
  Currently most uniform type info is determined by switching on the
  uniform type. Some values are computed from other values, which can
  result in three or more switch statements plus some multiplies or
  other math. This patch attempts to improve the speed by pre computing
  necessary values into constant static tables.
  
  Improves performance by about 7% in a uniform stress test.
  
  BUG=angleproject:1390
  
  Change-Id: I29bef259a17f6d6536171ade4950e2d712bfd39c
  Reviewed-on: https://chromium-review.googlesource.com/643791
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@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
  {
  
  LinkedUniform::LinkedUniform()
      : typeInfo(nullptr), bufferIndex(-1), blockInfo(sh::BlockMemberInfo::getDefaultBlockInfo())
  {
  }
  
  LinkedUniform::LinkedUniform(GLenum typeIn,
                               GLenum precisionIn,
                               const std::string &nameIn,
                               unsigned int arraySizeIn,
                               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;
      arraySize = arraySizeIn;
      binding   = bindingIn;
      offset    = offsetIn;
      location  = locationIn;
  }
  
  LinkedUniform::LinkedUniform(const sh::Uniform &uniform)
      : sh::Uniform(uniform),
        typeInfo(&GetUniformTypeInfo(type)),
        bufferIndex(-1),
        blockInfo(sh::BlockMemberInfo::getDefaultBlockInfo())
  {
  }
  
  LinkedUniform::LinkedUniform(const LinkedUniform &uniform)
      : sh::Uniform(uniform),
        typeInfo(uniform.typeInfo),
        bufferIndex(uniform.bufferIndex),
        blockInfo(uniform.blockInfo)
  {
  }
  
  LinkedUniform &LinkedUniform::operator=(const LinkedUniform &uniform)
  {
      sh::Uniform::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;
  }
  
  ShaderVariableBuffer::ShaderVariableBuffer()
      : binding(0),
        dataSize(0),
        vertexStaticUse(false),
        fragmentStaticUse(false),
        computeStaticUse(false)
  {
  }
  
  ShaderVariableBuffer::~ShaderVariableBuffer()
  {
  }
  
  UniformBlock::UniformBlock() : isArray(false), arrayElement(0)
  {
  }
  
  UniformBlock::UniformBlock(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 UniformBlock::nameWithArrayIndex() const
  {
      std::stringstream fullNameStr;
      fullNameStr << name;
      if (isArray)
      {
          fullNameStr << "[" << arrayElement << "]";
      }
  
      return fullNameStr.str();
  }
  
  std::string UniformBlock::mappedNameWithArrayIndex() const
  {
      std::stringstream fullNameStr;
      fullNameStr << mappedName;
      if (isArray)
      {
          fullNameStr << "[" << arrayElement << "]";
      }
  
      return fullNameStr.str();
  }
  }
  

Download