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

• Show log

  Commit

• Hash : af713a24
  Author :
  Date : 2017-04-19T09:10:56
  

  ES31: Implement binding layout for uniform blocks
  
  The binding point of uniform blocks can be specified in shaders with
  this CL. See spec ESSL 3.10, section 4.4.4, page 58 for more info.
  
  dEQP-GLES31.functional.ubo.* still can't completely pass as
  the missing of arrays-of-arrays feature. Neither can
  dEQP-GLES31.functional.layout_binding.ubo.* due to the incomplete
  implementation of program interface APIs.
  
  TEST=angle_end2end_tests:UniformBufferTest
  BUG=angleproject:1442
  
  Change-Id: If95d468fc109834a132b9b817730d3fdc3a615da
  Reviewed-on: https://chromium-review.googlesource.com/483848
  Commit-Queue: Jie A Chen <jie.a.chen@intel.com>
  Commit-Queue: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

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,
                   int bindingIn);
      UniformBlock(const UniformBlock &other) = default;
      UniformBlock &operator=(const UniformBlock &other) = default;
  
      std::string nameWithArrayIndex() const;
  
      std::string name;
      bool isArray;
      unsigned int arrayElement;
      int binding;
      unsigned int dataSize;
  
      bool vertexStaticUse;
      bool fragmentStaticUse;
      bool computeStaticUse;
  
      std::vector<unsigned int> memberUniformIndexes;
  };
  
  }
  
  #endif   // LIBANGLE_UNIFORM_H_
  

Download