1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
//
// 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.
//
// Implementation of the state class for mananging GLES 3 Vertex Array Objects.
//
#include "libANGLE/VertexArray.h"
#include "libANGLE/Buffer.h"
#include "libANGLE/renderer/VertexArrayImpl.h"
namespace gl
{
VertexArray::VertexArray(rx::VertexArrayImpl *impl, GLuint id, size_t maxAttribs)
: mId(id),
mVertexArray(impl),
mVertexAttributes(maxAttribs),
mMaxEnabledAttribute(0)
{
ASSERT(impl != NULL);
}
VertexArray::~VertexArray()
{
SafeDelete(mVertexArray);
for (size_t i = 0; i < getMaxAttribs(); i++)
{
mVertexAttributes[i].buffer.set(NULL);
}
mElementArrayBuffer.set(NULL);
}
GLuint VertexArray::id() const
{
return mId;
}
void VertexArray::detachBuffer(GLuint bufferName)
{
for (size_t attribute = 0; attribute < getMaxAttribs(); attribute++)
{
if (mVertexAttributes[attribute].buffer.id() == bufferName)
{
mVertexAttributes[attribute].buffer.set(NULL);
}
}
if (mElementArrayBuffer.id() == bufferName)
{
mElementArrayBuffer.set(NULL);
}
}
const VertexAttribute& VertexArray::getVertexAttribute(size_t attributeIndex) const
{
ASSERT(attributeIndex < getMaxAttribs());
return mVertexAttributes[attributeIndex];
}
const std::vector<VertexAttribute> &VertexArray::getVertexAttributes() const
{
return mVertexAttributes;
}
void VertexArray::setVertexAttribDivisor(GLuint index, GLuint divisor)
{
ASSERT(index < getMaxAttribs());
mVertexAttributes[index].divisor = divisor;
mVertexArray->setAttributeDivisor(index, divisor);
}
void VertexArray::enableAttribute(unsigned int attributeIndex, bool enabledState)
{
ASSERT(attributeIndex < getMaxAttribs());
mVertexAttributes[attributeIndex].enabled = enabledState;
mVertexArray->enableAttribute(attributeIndex, enabledState);
// Update state cache
if (enabledState)
{
mMaxEnabledAttribute = std::max(attributeIndex, mMaxEnabledAttribute);
}
else if (mMaxEnabledAttribute == attributeIndex)
{
while (mMaxEnabledAttribute > 0 && !mVertexAttributes[mMaxEnabledAttribute].enabled)
{
--mMaxEnabledAttribute;
}
}
}
void VertexArray::setAttributeState(unsigned int attributeIndex, gl::Buffer *boundBuffer, GLint size, GLenum type,
bool normalized, bool pureInteger, GLsizei stride, const void *pointer)
{
ASSERT(attributeIndex < getMaxAttribs());
mVertexAttributes[attributeIndex].buffer.set(boundBuffer);
mVertexAttributes[attributeIndex].size = size;
mVertexAttributes[attributeIndex].type = type;
mVertexAttributes[attributeIndex].normalized = normalized;
mVertexAttributes[attributeIndex].pureInteger = pureInteger;
mVertexAttributes[attributeIndex].stride = stride;
mVertexAttributes[attributeIndex].pointer = pointer;
mVertexArray->setAttribute(attributeIndex, mVertexAttributes[attributeIndex]);
}
void VertexArray::setElementArrayBuffer(Buffer *buffer)
{
mElementArrayBuffer.set(buffer);
mVertexArray->setElementArrayBuffer(buffer);
}
}
|
