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

• 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.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
  {
  
  // Helper struct representing a single shader uniform
  struct LinkedUniform : public sh::Uniform
  {
      LinkedUniform();
      LinkedUniform(GLenum type,
                    GLenum precision,
                    const std::string &name,
                    unsigned int arraySize,
                    const int binding,
                    const int location,
                    const int blockIndex,
                    const sh::BlockMemberInfo &blockInfo);
      LinkedUniform(const sh::Uniform &uniform);
      LinkedUniform(const LinkedUniform &uniform);
      LinkedUniform &operator=(const LinkedUniform &uniform);
      ~LinkedUniform();
  
      size_t dataSize() const;
      uint8_t *data();
      const uint8_t *data() const;
      bool isSampler() const;
      bool isImage() const;
      bool isInDefaultBlock() const;
      bool isField() const;
      size_t getElementSize() const;
      size_t getElementComponents() const;
      uint8_t *getDataPtrToElement(size_t elementIndex);
      const uint8_t *getDataPtrToElement(size_t elementIndex) const;
  
      int blockIndex;
      sh::BlockMemberInfo blockInfo;
  
    private:
      mutable angle::MemoryBuffer mLazyData;
  };
  
  // Helper struct representing a single shader uniform block
  struct UniformBlock
  {
      UniformBlock();
      UniformBlock(const std::string &nameIn, bool isArrayIn, unsigned int arrayElementIn);
      UniformBlock(const UniformBlock &other) = default;
      UniformBlock &operator=(const UniformBlock &other) = default;
  
      std::string nameWithArrayIndex() const;
  
      std::string name;
      bool isArray;
      unsigned int arrayElement;
      unsigned int dataSize;
  
      bool vertexStaticUse;
      bool fragmentStaticUse;
      bool computeStaticUse;
  
      std::vector<unsigned int> memberUniformIndexes;
  };
  
  }
  
  #endif   // LIBANGLE_UNIFORM_H_
  

Download