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

• Show log

  Commit

• Hash : c759b8b4
  Author :
  Date : 2019-01-03T15:16:50
  

  Vulkan: More Vertex Array optimizations.
  
  Inlines a number of Vulkan vertex array methods.
  
  Also changes the way vertex buffers are bound. Note that Vulkan doesn't
  support NULL buffer bindings. Thus we create an emulated NULL buffer
  to work around the problem of having gaps in the bound vertex buffers.
  This allows us to use a single bind call for ranges of vertex buffers
  even when there are gaps.
  
  Also changes how vertex array dirty bits are reset. Instead of calling
  memset to clear the affected buffers we pass a mutable pointer to the
  Vertex Array sync state. This allows us to only reset the dirty bits
  that we sync. This saves on the memory clearing time.
  
  Improves perf by about 10% in the Vulkan VBO state change test.
  
  Bug: angleproject:3014
  Change-Id: Ib7b742dff7897fc891606a652ea0b64255a24c86
  Reviewed-on: https://chromium-review.googlesource.com/c/1390360
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/VertexAttribute.h

• //
  // Copyright (c) 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.
  //
  // Helper structures about Generic Vertex Attribute.
  //
  
  #ifndef LIBANGLE_VERTEXATTRIBUTE_H_
  #define LIBANGLE_VERTEXATTRIBUTE_H_
  
  #include "libANGLE/Buffer.h"
  #include "libANGLE/angletypes.h"
  
  namespace gl
  {
  class VertexArray;
  
  //
  // Implementation of Generic Vertex Attribute Bindings for ES3.1. The members are intentionally made
  // private in order to hide implementation details.
  //
  class VertexBinding final : angle::NonCopyable
  {
    public:
      VertexBinding();
      explicit VertexBinding(GLuint boundAttribute);
      VertexBinding(VertexBinding &&binding);
      ~VertexBinding();
      VertexBinding &operator=(VertexBinding &&binding);
  
      GLuint getStride() const { return mStride; }
      void setStride(GLuint strideIn) { mStride = strideIn; }
  
      GLuint getDivisor() const { return mDivisor; }
      void setDivisor(GLuint divisorIn) { mDivisor = divisorIn; }
  
      GLintptr getOffset() const { return mOffset; }
      void setOffset(GLintptr offsetIn) { mOffset = offsetIn; }
  
      const BindingPointer<Buffer> &getBuffer() const { return mBuffer; }
  
      ANGLE_INLINE void setBuffer(const gl::Context *context, Buffer *bufferIn, bool containerIsBound)
      {
          if (containerIsBound)
          {
              if (mBuffer.get())
                  mBuffer->onNonTFBindingChanged(-1);
              if (bufferIn)
                  bufferIn->onNonTFBindingChanged(1);
          }
          mBuffer.set(context, bufferIn);
      }
  
      void onContainerBindingChanged(const Context *context, int incr) const;
  
      const AttributesMask &getBoundAttributesMask() const { return mBoundAttributesMask; }
  
      void setBoundAttribute(size_t index) { mBoundAttributesMask.set(index); }
  
      void resetBoundAttribute(size_t index) { mBoundAttributesMask.reset(index); }
  
    private:
      GLuint mStride;
      GLuint mDivisor;
      GLintptr mOffset;
  
      BindingPointer<Buffer> mBuffer;
  
      // Mapping from this binding to all of the attributes that are using this binding.
      AttributesMask mBoundAttributesMask;
  };
  
  //
  // Implementation of Generic Vertex Attributes for ES3.1
  //
  struct VertexAttribute final : private angle::NonCopyable
  {
      explicit VertexAttribute(GLuint bindingIndex);
      VertexAttribute(VertexAttribute &&attrib);
      VertexAttribute &operator=(VertexAttribute &&attrib);
  
      // Called from VertexArray.
      void updateCachedElementLimit(const VertexBinding &binding);
      GLint64 getCachedElementLimit() const { return mCachedElementLimit; }
  
      bool enabled;  // For glEnable/DisableVertexAttribArray
      GLenum type;
      GLuint size;
      bool normalized;
      bool pureInteger;
  
      const void *pointer;
      GLuint relativeOffset;
  
      GLuint vertexAttribArrayStride;  // ONLY for queries of VERTEX_ATTRIB_ARRAY_STRIDE
      GLuint bindingIndex;
  
      // Special value for the cached element limit on the integer overflow case.
      static constexpr GLint64 kIntegerOverflow = std::numeric_limits<GLint64>::min();
  
    private:
      // This is kept in sync by the VertexArray. It is used to optimize draw call validation.
      GLint64 mCachedElementLimit;
  };
  
  size_t ComputeVertexAttributeTypeSize(const VertexAttribute &attrib);
  
  // Warning: you should ensure binding really matches attrib.bindingIndex before using this function.
  size_t ComputeVertexAttributeStride(const VertexAttribute &attrib, const VertexBinding &binding);
  
  // Warning: you should ensure binding really matches attrib.bindingIndex before using this function.
  GLintptr ComputeVertexAttributeOffset(const VertexAttribute &attrib, const VertexBinding &binding);
  
  size_t ComputeVertexBindingElementCount(GLuint divisor, size_t drawCount, size_t instanceCount);
  
  GLenum GetVertexAttributeBaseType(const VertexAttribute &attrib);
  
  struct VertexAttribCurrentValueData
  {
      union
      {
          GLfloat FloatValues[4];
          GLint IntValues[4];
          GLuint UnsignedIntValues[4];
      };
      GLenum Type;
  
      VertexAttribCurrentValueData();
  
      void setFloatValues(const GLfloat floatValues[4]);
      void setIntValues(const GLint intValues[4]);
      void setUnsignedIntValues(const GLuint unsignedIntValues[4]);
  };
  
  bool operator==(const VertexAttribCurrentValueData &a, const VertexAttribCurrentValueData &b);
  bool operator!=(const VertexAttribCurrentValueData &a, const VertexAttribCurrentValueData &b);
  
  }  // namespace gl
  
  #include "VertexAttribute.inl"
  
  #endif  // LIBANGLE_VERTEXATTRIBUTE_H_
  

Download