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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
package javax.media.opengl;
import java.nio.*;
/**
*
* The total number of bytes hold by the referenced buffer is:
* getComponentSize()* getComponentNumber() * getElementNumber()
*
*/
public interface GLArrayData {
/**
* Returns true if this data set is intended for a GLSL vertex shader attribute,
* otherwise false, ie intended for fixed function vertex pointer
*/
public boolean isVertexAttribute();
/**
* The index of the predefined array index, see list below,
* or -1 in case of a shader attribute array.
*
* @see javax.media.opengl.GL#GL_VERTEX_ARRAY
* @see javax.media.opengl.GL#GL_NORMAL_ARRAY
* @see javax.media.opengl.GL#GL_COLOR_ARRAY
* @see javax.media.opengl.GL#GL_TEXTURE_COORD_ARRAY
*/
public int getIndex();
/**
* The name of the reflecting shader array attribute.
*/
public String getName();
/**
* Set a new name for this array.
*/
public void setName(String newName);
/**
* Returns the shader attribute location for this name,
* -1 if not yet determined
*/
public int getLocation();
/**
* Sets the determined location of the shader attribute
* This is usually done within ShaderState.
*
* @see javax.media.opengl.glsl.ShaderState#glVertexAttribPointer(GL2ES2, GLArrayData)
*/
public void setLocation(int v);
public boolean sealed();
/**
* Determines wheather the data is server side (VBO),
* or a client side array (false).
*/
public boolean isVBO();
/**
* The offset, if it's an VBO, otherwise -1
*/
public long getOffset();
/**
* The VBO name, if it's an VBO, otherwise -1
*/
public int getVBOName();
/**
* The VBO buffer usage, if it's an VBO, otherwise -1
*/
public int getBufferUsage();
/**
* The Buffer holding the data, may be null in case of VBO
*/
public Buffer getBuffer();
/**
* Is the buffer written to the GPU ?
*/
public boolean isBufferWritten();
/**
* Marks the buffer written to the GPU
*/
public void setBufferWritten(boolean written);
/**
* The number of components per element
*/
public int getComponentNumber();
/**
* The component's GL data type, ie. GL_FLOAT
*/
public int getComponentType();
/**
* The components size in bytes
*/
public int getComponentSize();
/**
* Return the number of elements.
*/
public int getElementNumber();
/**
* True, if GL shall normalize fixed point data while converting
* them into float
*/
public boolean getNormalized();
/**
* The distance to the next payload,
* allowing interleaved arrays.
*/
public int getStride();
public String toString();
//
// Data and GL state modification ..
//
public void destroy(GL gl);
public void reset(GL gl);
/**
* If seal is true, it
* disable write operations to the buffer.
* Calls flip, ie limit:=position and position:=0.
* Also enables the buffer for OpenGL, and passes the data.
*
* If seal is false, it
* enable write operations continuing
* at the buffer position, where you left off at seal(true),
* ie position:=limit and limit:=capacity.
* Also disables the buffer for OpenGL.
*
* @see #seal(boolean)
*/
public void seal(GL gl, boolean seal);
/**
* Enables/disables the buffer, which implies
* the client state, binding the VBO
* and transfering the data if not done yet.
*
* The above will only be executed,
* if the buffer is disabled,
* or 'setEnableAlways' was called with 'true'.
*
* @see #setEnableAlways(boolean)
*/
public void enableBuffer(GL gl, boolean enable);
/**
* Affects the behavior of 'enableBuffer'.
*
* The default is 'false'
*
* This is usefull when you mix up
* GLArrayData usage with conventional GL array calls.
*
* @see #enableBuffer(GL, boolean)
*/
public void setEnableAlways(boolean always);
//
// Data modification ..
//
public void reset();
/**
* If seal is true, it
* disable write operations to the buffer.
* Calls flip, ie limit:=position and position:=0.
*
* If seal is false, it
* enable write operations continuing
* at the buffer position, where you left off at seal(true),
* ie position:=limit and limit:=capacity.
*
*/
public void seal(boolean seal);
public void rewind();
public void padding(int done);
public void put(Buffer v);
public void putb(byte v);
public void puts(short v);
public void puti(int v);
public void putx(int v);
public void putf(float v);
public void putd(double v);
}
|
