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

• Show log

  Commit

• Hash : 6ca2b65c
  Author :
  Date : 2017-02-19T18:05:10
  

  Implement location layout qualifier for uniforms
  
  This is a complete implementation of the uniform location layout
  qualifier. Uniform location set in the shader is plumbed to shader
  linking, which does several link-time checks for conflicts and
  recursively applies the location to struct members.
  
  Validate that location is consistent as specified in the table in
  section 9.2.1 of the ESSL 3.10.4 spec. The location set in the shader
  overrides the one set via the CHROMIUM_bind_uniform_location API.
  
  Location conflicts must be checked even if the uniforms are not
  statically used. Because of this unused uniforms are now recorded
  during uniform linking. After linking checks are done, unused uniforms
  are pruned from the program state.
  
  Location is validated against the maximum number of uniform locations
  at compile time as specified in section 4.4.3 of the ESSL 3.10.4 spec.
  
  All dEQP uniform location tests don't yet pass due to unrelated bugs.
  
  BUG=angleproject:1442
  TEST=angle_end2end_tests, dEQP-GLES31.functional.uniform_location.*
  
  Change-Id: I1f968e971f521fbc804b01e1a7c2b4d14f24d20f
  Reviewed-on: https://chromium-review.googlesource.com/447942
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

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()
      : blockIndex(-1), blockInfo(sh::BlockMemberInfo::getDefaultBlockInfo())
  {
  }
  
  LinkedUniform::LinkedUniform(GLenum typeIn,
                               GLenum precisionIn,
                               const std::string &nameIn,
                               unsigned int arraySizeIn,
                               const int bindingIn,
                               const int locationIn,
                               const int blockIndexIn,
                               const sh::BlockMemberInfo &blockInfoIn)
      : blockIndex(blockIndexIn), blockInfo(blockInfoIn)
  {
      type      = typeIn;
      precision = precisionIn;
      name      = nameIn;
      arraySize = arraySizeIn;
      binding   = bindingIn;
      location  = locationIn;
  }
  
  LinkedUniform::LinkedUniform(const sh::Uniform &uniform)
      : sh::Uniform(uniform), blockIndex(-1), blockInfo(sh::BlockMemberInfo::getDefaultBlockInfo())
  {
  }
  
  LinkedUniform::LinkedUniform(const LinkedUniform &uniform)
      : sh::Uniform(uniform), blockIndex(uniform.blockIndex), blockInfo(uniform.blockInfo)
  {
      // This function is not intended to be called during runtime.
      ASSERT(uniform.mLazyData.empty());
  }
  
  LinkedUniform &LinkedUniform::operator=(const LinkedUniform &uniform)
  {
      // This function is not intended to be called during runtime.
      ASSERT(uniform.mLazyData.empty());
  
      sh::Uniform::operator=(uniform);
      blockIndex           = uniform.blockIndex;
      blockInfo            = uniform.blockInfo;
  
      return *this;
  }
  
  LinkedUniform::~LinkedUniform()
  {
  }
  
  bool LinkedUniform::isInDefaultBlock() const
  {
      return blockIndex == -1;
  }
  
  size_t LinkedUniform::dataSize() const
  {
      ASSERT(type != GL_STRUCT_ANGLEX);
      if (mLazyData.empty())
      {
          mLazyData.resize(VariableExternalSize(type) * elementCount());
          ASSERT(!mLazyData.empty());
      }
  
      return mLazyData.size();
  }
  
  uint8_t *LinkedUniform::data()
  {
      if (mLazyData.empty())
      {
          // dataSize() will init the data store.
          size_t size = dataSize();
          memset(mLazyData.data(), 0, size);
      }
  
      return mLazyData.data();
  }
  
  const uint8_t *LinkedUniform::data() const
  {
      return const_cast<LinkedUniform *>(this)->data();
  }
  
  bool LinkedUniform::isSampler() const
  {
      return IsSamplerType(type);
  }
  
  bool LinkedUniform::isImage() const
  {
      return IsImageType(type);
  }
  
  bool LinkedUniform::isField() const
  {
      return name.find('.') != std::string::npos;
  }
  
  size_t LinkedUniform::getElementSize() const
  {
      return VariableExternalSize(type);
  }
  
  size_t LinkedUniform::getElementComponents() const
  {
      return VariableComponentCount(type);
  }
  
  uint8_t *LinkedUniform::getDataPtrToElement(size_t elementIndex)
  {
      ASSERT((!isArray() && elementIndex == 0) || (isArray() && elementIndex < arraySize));
      return data() + (elementIndex > 0 ? (getElementSize() * elementIndex) : 0u);
  }
  
  const uint8_t *LinkedUniform::getDataPtrToElement(size_t elementIndex) const
  {
      return const_cast<LinkedUniform *>(this)->getDataPtrToElement(elementIndex);
  }
  
  UniformBlock::UniformBlock()
      : isArray(false),
        arrayElement(0),
        dataSize(0),
        vertexStaticUse(false),
        fragmentStaticUse(false),
        computeStaticUse(false)
  {
  }
  
  UniformBlock::UniformBlock(const std::string &nameIn, bool isArrayIn, unsigned int arrayElementIn)
      : name(nameIn),
        isArray(isArrayIn),
        arrayElement(arrayElementIn),
        dataSize(0),
        vertexStaticUse(false),
        fragmentStaticUse(false),
        computeStaticUse(false)
  {
  }
  
  std::string UniformBlock::nameWithArrayIndex() const
  {
      std::stringstream fullNameStr;
      fullNameStr << name;
      if (isArray)
      {
          fullNameStr << "[" << arrayElement << "]";
      }
  
      return fullNameStr.str();
  }
  }
  

Download