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

• Show log

  Commit

• Hash : 855d964b
  Author :
  Date : 2017-05-17T14:05:06
  

  Prefix user-defined names in GLSL output
  
  Now user-defined names are prefixed by _u in GLSL output in case name
  hashing is not on. Internal names such as names of temporary variables
  created in AST transformations are written out as such.
  
  This makes handling of internal function names and internal variable
  names consistent. It also removes the possibility of name conflicts
  between user-defined names and internal names in case name hashing is
  not on. In the same vein, it makes it safe to use GLSL reserved words
  that are not reserved in ESSL as variable names in case name hashing
  is not on.
  
  This also makes the GLSL output more consistent with how names are
  handled in HLSL output. Name hashing code is shared between
  VariableInfo and OutputGLSLBase to ensure names are handled
  consistently in both. The name that's used in the shader source for a
  given interface variable is written out to ShaderVariable::mappedName.
  
  An exception needs to be made for identifiers close to the length
  limit, since adding any prefix would take them over the limit. But
  they can be just written out as such, since we don't have any builtins
  or ANGLE internal variables that have as long names and could create a
  conflict.
  
  BUG=angleproject:2139
  BUG=angleproject:2038
  TEST=angle_unittests, angle_end2end_tests, WebGL conformance tests
  
  Change-Id: Id6ed052c4fab2d091227dc9a3668083053b67a38
  Reviewed-on: https://chromium-review.googlesource.com/507647
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Jamie Madill <jmadill@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 offset,
                    const int location,
                    const int bufferIndex,
                    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()
      {
          if (mLazyData.empty())
          {
              // dataSize() will init the data store.
              size_t size = dataSize();
              memset(mLazyData.data(), 0, size);
          }
  
          return mLazyData.data();
      }
      const uint8_t *data() const;
      bool isSampler() const;
      bool isImage() const;
      bool isAtomicCounter() 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;
  
      // Identifies the containing buffer backed resource -- interface block or atomic counter buffer.
      int bufferIndex;
      sh::BlockMemberInfo blockInfo;
  
    private:
      mutable angle::MemoryBuffer mLazyData;
  };
  
  // Parent struct for atomic counter, uniform block, and shader storage block buffer, which all
  // contain a group of shader variables, and have a GL buffer backed.
  struct ShaderVariableBuffer
  {
      ShaderVariableBuffer();
      virtual ~ShaderVariableBuffer();
      ShaderVariableBuffer(const ShaderVariableBuffer &other) = default;
      ShaderVariableBuffer &operator=(const ShaderVariableBuffer &other) = default;
      int numActiveVariables() const { return static_cast<int>(memberIndexes.size()); }
  
      int binding;
      unsigned int dataSize;
      std::vector<unsigned int> memberIndexes;
  
      bool vertexStaticUse;
      bool fragmentStaticUse;
      bool computeStaticUse;
  };
  
  using AtomicCounterBuffer = ShaderVariableBuffer;
  
  // Helper struct representing a single shader uniform block
  struct UniformBlock : public ShaderVariableBuffer
  {
      UniformBlock();
      UniformBlock(const std::string &nameIn,
                   const std::string &mappedNameIn,
                   bool isArrayIn,
                   unsigned int arrayElementIn,
                   int bindingIn);
      UniformBlock(const UniformBlock &other) = default;
      UniformBlock &operator=(const UniformBlock &other) = default;
  
      std::string nameWithArrayIndex() const;
      std::string mappedNameWithArrayIndex() const;
  
      std::string name;
      std::string mappedName;
      bool isArray;
      unsigned int arrayElement;
  };
  
  }
  
  #endif   // LIBANGLE_UNIFORM_H_
  

Download