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

• Show log

  Commit

• Hash : c9d442d7
  Author :
  Date : 2016-01-20T11:17:24
  

  Sync dirty objects at the GL layer.
  
  The dirty bit system currently puts dirty objects in line with the
  rest of the dirty state. This means at the Renderer level, the sync
  manager code would call back to the GL layer to sync the specific
  objects that are dirty. This is a bit of a layering violation (impl
  layer mutating top-level objects) and also a bit of repeated boiler-
  plate code.
  
  Fix this by treating dirty objects in a separate dirty bit set, called
  the dirty objects. This also has the benefit of allowing us to re-
  implement the dirty object set at a later date, if we want to store
  them in a list, or other structure.
  
  Also don't skip the state sync at the GL level if there are no GL
  dirty bits. The Impl might have some dirty bits locally, and it's
  better to call syncState and do the no-op check in the Impl than it
  is to also sync local state at every sync point (draw call, read, etc)
  in each Impl.
  
  BUG=angleproject:1260
  
  Change-Id: Id5d4beb2a1c4e3ad351edf54e3f32e828d5f5da3
  Reviewed-on: https://chromium-review.googlesource.com/318790
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Tested-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/VertexArray.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.
  //
  // This class contains prototypes for representing GLES 3 Vertex Array Objects:
  //
  //   The buffer objects that are to be used by the vertex stage of the GL are collected
  //   together to form a vertex array object. All state related to the definition of data used
  //   by the vertex processor is encapsulated in a vertex array object.
  //
  
  #ifndef LIBANGLE_VERTEXARRAY_H_
  #define LIBANGLE_VERTEXARRAY_H_
  
  #include "libANGLE/RefCountObject.h"
  #include "libANGLE/Constants.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/State.h"
  #include "libANGLE/VertexAttribute.h"
  
  #include <vector>
  
  namespace rx
  {
  class ImplFactory;
  class VertexArrayImpl;
  }
  
  namespace gl
  {
  class Buffer;
  
  class VertexArray final : public LabeledObject
  {
    public:
      VertexArray(rx::ImplFactory *factory, GLuint id, size_t maxAttribs);
      ~VertexArray();
  
      GLuint id() const;
  
      void setLabel(const std::string &label) override;
      const std::string &getLabel() const override;
  
      const VertexAttribute &getVertexAttribute(size_t attributeIndex) const;
  
      void detachBuffer(GLuint bufferName);
      void setVertexAttribDivisor(size_t index, GLuint divisor);
      void enableAttribute(size_t attributeIndex, bool enabledState);
      void setAttributeState(size_t attributeIndex, gl::Buffer *boundBuffer, GLint size, GLenum type,
                             bool normalized, bool pureInteger, GLsizei stride, const void *pointer);
  
      void setElementArrayBuffer(Buffer *buffer);
  
      const BindingPointer<Buffer> &getElementArrayBuffer() const { return mData.getElementArrayBuffer(); }
      size_t getMaxAttribs() const { return mData.getVertexAttributes().size(); }
      const std::vector<VertexAttribute> &getVertexAttributes() const { return mData.getVertexAttributes(); }
  
      rx::VertexArrayImpl *getImplementation() { return mVertexArray; }
      const rx::VertexArrayImpl *getImplementation() const { return mVertexArray; }
  
      size_t getMaxEnabledAttribute() const { return mData.getMaxEnabledAttribute(); }
  
      class Data final : public angle::NonCopyable
      {
        public:
          explicit Data(size_t maxAttribs);
          ~Data();
  
          const std::string &getLabel() const { return mLabel; }
  
          const BindingPointer<Buffer> &getElementArrayBuffer() const { return mElementArrayBuffer; }
          size_t getMaxAttribs() const { return mVertexAttributes.size(); }
          size_t getMaxEnabledAttribute() const { return mMaxEnabledAttribute; }
          const std::vector<VertexAttribute> &getVertexAttributes() const { return mVertexAttributes; }
          const VertexAttribute &getVertexAttribute(size_t index) const
          {
              return mVertexAttributes[index];
          }
  
        private:
          friend class VertexArray;
          std::string mLabel;
          std::vector<VertexAttribute> mVertexAttributes;
          BindingPointer<Buffer> mElementArrayBuffer;
          size_t mMaxEnabledAttribute;
      };
  
      enum DirtyBitType
      {
          DIRTY_BIT_ELEMENT_ARRAY_BUFFER,
  
          // Reserve bits for enabled flags
          DIRTY_BIT_ATTRIB_0_ENABLED,
          DIRTY_BIT_ATTRIB_MAX_ENABLED = DIRTY_BIT_ATTRIB_0_ENABLED + gl::MAX_VERTEX_ATTRIBS,
  
          // Reserve bits for attrib pointers
          DIRTY_BIT_ATTRIB_0_POINTER   = DIRTY_BIT_ATTRIB_MAX_ENABLED,
          DIRTY_BIT_ATTRIB_MAX_POINTER = DIRTY_BIT_ATTRIB_0_POINTER + gl::MAX_VERTEX_ATTRIBS,
  
          // Reserve bits for divisors
          DIRTY_BIT_ATTRIB_0_DIVISOR   = DIRTY_BIT_ATTRIB_MAX_POINTER,
          DIRTY_BIT_ATTRIB_MAX_DIVISOR = DIRTY_BIT_ATTRIB_0_DIVISOR + gl::MAX_VERTEX_ATTRIBS,
  
          DIRTY_BIT_UNKNOWN = DIRTY_BIT_ATTRIB_MAX_DIVISOR,
          DIRTY_BIT_MAX     = DIRTY_BIT_UNKNOWN,
      };
  
      typedef std::bitset<DIRTY_BIT_MAX> DirtyBits;
  
      void syncImplState();
      bool hasAnyDirtyBit() const { return mDirtyBits.any(); }
  
    private:
      GLuint mId;
  
      rx::VertexArrayImpl *mVertexArray;
  
      Data mData;
      DirtyBits mDirtyBits;
  };
  
  }
  
  #endif // LIBANGLE_VERTEXARRAY_H_
  

Download