| // |
| // 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/State.h" |
| #include "libANGLE/VertexAttribute.h" |
| |
| #include <vector> |
| |
| namespace rx |
| { |
| class ImplFactory; |
| class VertexArrayImpl; |
| } |
| |
| namespace gl |
| { |
| class Buffer; |
| |
| // Used in other places. |
| typedef std::bitset<MAX_VERTEX_ATTRIBS> AttributesMask; |
| |
| class VertexArray |
| { |
| public: |
| VertexArray(rx::ImplFactory *factory, GLuint id, size_t maxAttribs); |
| ~VertexArray(); |
| |
| GLuint id() const; |
| |
| 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 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::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(); |
| |
| private: |
| GLuint mId; |
| |
| rx::VertexArrayImpl *mVertexArray; |
| |
| Data mData; |
| DirtyBits mDirtyBits; |
| }; |
| |
| } |
| |
| #endif // LIBANGLE_VERTEXARRAY_H_ |