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
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
public GLES2Impl(GLProfile glp, GLContextImpl context) {
this._context = context;
if(null != context) {
this.bufferSizeTracker = context.getBufferSizeTracker();
this.bufferStateTracker = context.getBufferStateTracker();
this.glStateTracker = context.getGLStateTracker();
} else {
this.bufferSizeTracker = null;
this.bufferStateTracker = null;
this.glStateTracker = null;
}
this.glProfile = glp;
}
@Override
public final boolean isGL4bc() {
return false;
}
@Override
public final boolean isGL4() {
return false;
}
@Override
public final boolean isGL3bc() {
return false;
}
@Override
public final boolean isGL3() {
return false;
}
public final boolean isGL2() {
return false;
}
@Override
public final boolean isGLES1() {
return false;
}
@Override
public final boolean isGLES2() {
return true;
}
@Override
public final boolean isGLES() {
return true;
}
@Override
public final boolean isGL2ES1() {
return false;
}
@Override
public final boolean isGL2ES2() {
return true;
}
@Override
public final boolean isGLES2Compatible() {
return true;
}
@Override
public final boolean isGL2GL3() {
return false;
}
@Override
public final boolean hasGLSL() {
return true;
}
@Override
public boolean isNPOTTextureAvailable() {
return true;
}
@Override
public final GL4bc getGL4bc() throws GLException {
throw new GLException("Not a GL4bc implementation");
}
@Override
public final GL4 getGL4() throws GLException {
throw new GLException("Not a GL4 implementation");
}
@Override
public final GL3bc getGL3bc() throws GLException {
throw new GLException("Not a GL3bc implementation");
}
@Override
public final GL3 getGL3() throws GLException {
throw new GLException("Not a GL3 implementation");
}
@Override
public final GL2 getGL2() throws GLException {
throw new GLException("Not a GL2 implementation");
}
@Override
public final GLES1 getGLES1() throws GLException {
throw new GLException("Not a GLES1 implementation");
}
@Override
public final GLES2 getGLES2() throws GLException {
return this;
}
@Override
public final GL2ES1 getGL2ES1() throws GLException {
throw new GLException("Not a GL2ES1 implementation");
}
@Override
public final GL2ES2 getGL2ES2() throws GLException {
return this;
}
@Override
public final GL2GL3 getGL2GL3() throws GLException {
throw new GLException("Not a GL2GL3 implementation");
}
//
// Helpers for ensuring the correct amount of texture data
//
private final GLBufferSizeTracker bufferSizeTracker;
private final GLBufferStateTracker bufferStateTracker;
private final GLStateTracker glStateTracker;
private final boolean checkBufferObject(boolean enabled,
int state,
String kind, boolean throwException) {
final int buffer = bufferStateTracker.getBoundBufferObject(state, this);
if (enabled) {
if (0 == buffer) {
if(throwException) {
throw new GLException(kind + " must be enabled to call this method");
}
return false;
}
} else {
if (0 != buffer) {
if(throwException) {
throw new GLException(kind + " must be disabled to call this method");
}
return false;
}
}
return true;
}
private final boolean checkArrayVBODisabled(boolean throwException) {
return checkBufferObject(false, // enabled
GL.GL_ARRAY_BUFFER,
"array vertex_buffer_object", throwException);
}
private final boolean checkArrayVBOEnabled(boolean throwException) {
return checkBufferObject(true, // enabled
GL.GL_ARRAY_BUFFER,
"array vertex_buffer_object", throwException);
}
private final boolean checkElementVBODisabled(boolean throwException) {
return checkBufferObject(false, // enabled
GL.GL_ELEMENT_ARRAY_BUFFER,
"element vertex_buffer_object", throwException);
}
private final boolean checkElementVBOEnabled(boolean throwException) {
return checkBufferObject(true, // enabled
GL.GL_ELEMENT_ARRAY_BUFFER,
"element vertex_buffer_object", throwException);
}
private final boolean checkUnpackPBODisabled(boolean throwException) {
// PBO n/a for ES 1.1 or ES 2.0
return true;
}
private final boolean checkUnpackPBOEnabled(boolean throwException) {
// PBO n/a for ES 1.1 or ES 2.0
return false;
}
private final boolean checkPackPBODisabled(boolean throwException) {
// PBO n/a for ES 1.1 or ES 2.0
return true;
}
private final boolean checkPackPBOEnabled(boolean throwException) {
// PBO n/a for ES 1.1 or ES 2.0
return false;
}
private final HashMap<MemoryObject, MemoryObject> arbMemCache = new HashMap<MemoryObject, MemoryObject>();
/** Entry point to C language function: <br> <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code> */
@Override
public final java.nio.ByteBuffer glMapBuffer(int target, int access) {
final long __addr_ = ((GLES2ProcAddressTable)_context.getGLProcAddressTable())._addressof_glMapBuffer;
if (__addr_ == 0) {
throw new GLException("Method \"glMapBuffer\" not available");
}
final long sz = bufferSizeTracker.getBufferSize(bufferStateTracker, target, this);
if (0 == sz) {
return null;
}
final long addr = dispatch_glMapBuffer(target, access, __addr_);
if (0 == addr) {
return null;
}
ByteBuffer buffer;
MemoryObject memObj0 = new MemoryObject(addr, sz); // object and key
MemoryObject memObj1 = MemoryObject.getOrAddSafe(arbMemCache, memObj0);
if(memObj0 == memObj1) {
// just added ..
if(null != memObj0.getBuffer()) {
throw new InternalError();
}
buffer = newDirectByteBuffer(addr, sz);
Buffers.nativeOrder(buffer);
memObj0.setBuffer(buffer);
} else {
// already mapped
buffer = memObj1.getBuffer();
if(null == buffer) {
throw new InternalError();
}
}
buffer.position(0);
return buffer;
}
/** Encapsulates function pointer for OpenGL function <br>: <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code> */
native private long dispatch_glMapBuffer(int target, int access, long glProcAddress);
native private ByteBuffer newDirectByteBuffer(long addr, long capacity);
@Override
public final void glClearDepth(double depth) {
glClearDepthf((float)depth);
}
@Override
public final void glDepthRange(double zNear, double zFar) {
glDepthRangef((float)zNear, (float)zFar);
}
|
