1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "GLClientState.h"
17 #include "ErrorLog.h"
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include "glUtils.h"
22 #include <cutils/log.h>
23
24 #ifndef MAX
25 #define MAX(a, b) ((a) < (b) ? (b) : (a))
26 #endif
27
GLClientState(int nLocations)28 GLClientState::GLClientState(int nLocations)
29 {
30 if (nLocations < LAST_LOCATION) {
31 nLocations = LAST_LOCATION;
32 }
33 m_nLocations = nLocations;
34 m_states = new VertexAttribState[m_nLocations];
35 for (int i = 0; i < m_nLocations; i++) {
36 m_states[i].enabled = 0;
37 m_states[i].enableDirty = false;
38 }
39 m_currentArrayVbo = 0;
40 m_currentIndexVbo = 0;
41 // init gl constans;
42 m_states[VERTEX_LOCATION].glConst = GL_VERTEX_ARRAY;
43 m_states[NORMAL_LOCATION].glConst = GL_NORMAL_ARRAY;
44 m_states[COLOR_LOCATION].glConst = GL_COLOR_ARRAY;
45 m_states[POINTSIZE_LOCATION].glConst = GL_POINT_SIZE_ARRAY_OES;
46 m_states[TEXCOORD0_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
47 m_states[TEXCOORD1_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
48 m_states[TEXCOORD2_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
49 m_states[TEXCOORD3_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
50 m_states[TEXCOORD4_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
51 m_states[TEXCOORD5_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
52 m_states[TEXCOORD6_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
53 m_states[TEXCOORD7_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
54 m_states[MATRIXINDEX_LOCATION].glConst = GL_MATRIX_INDEX_ARRAY_OES;
55 m_states[WEIGHT_LOCATION].glConst = GL_WEIGHT_ARRAY_OES;
56 m_activeTexture = 0;
57 m_currentProgram = 0;
58
59 m_pixelStore.unpack_alignment = 4;
60 m_pixelStore.pack_alignment = 4;
61
62 memset(m_tex.unit, 0, sizeof(m_tex.unit));
63 m_tex.activeUnit = &m_tex.unit[0];
64 m_tex.textures = NULL;
65 m_tex.numTextures = 0;
66 m_tex.allocTextures = 0;
67 }
68
~GLClientState()69 GLClientState::~GLClientState()
70 {
71 delete m_states;
72 }
73
enable(int location,int state)74 void GLClientState::enable(int location, int state)
75 {
76 if (!validLocation(location)) {
77 return;
78 }
79
80 m_states[location].enableDirty |= (state != m_states[location].enabled);
81 m_states[location].enabled = state;
82 }
83
setState(int location,int size,GLenum type,GLboolean normalized,GLsizei stride,const void * data)84 void GLClientState::setState(int location, int size, GLenum type, GLboolean normalized, GLsizei stride, const void *data)
85 {
86 if (!validLocation(location)) {
87 return;
88 }
89 m_states[location].size = size;
90 m_states[location].type = type;
91 m_states[location].stride = stride;
92 m_states[location].data = (void*)data;
93 m_states[location].bufferObject = m_currentArrayVbo;
94 m_states[location].elementSize = glSizeof(type) * size;
95 m_states[location].normalized = normalized;
96 }
97
setBufferObject(int location,GLuint id)98 void GLClientState::setBufferObject(int location, GLuint id)
99 {
100 if (!validLocation(location)) {
101 return;
102 }
103
104 m_states[location].bufferObject = id;
105 }
106
getState(int location)107 const GLClientState::VertexAttribState * GLClientState::getState(int location)
108 {
109 if (!validLocation(location)) {
110 return NULL;
111 }
112 return & m_states[location];
113 }
114
getStateAndEnableDirty(int location,bool * enableChanged)115 const GLClientState::VertexAttribState * GLClientState::getStateAndEnableDirty(int location, bool *enableChanged)
116 {
117 if (!validLocation(location)) {
118 return NULL;
119 }
120
121 if (enableChanged) {
122 *enableChanged = m_states[location].enableDirty;
123 }
124
125 m_states[location].enableDirty = false;
126 return & m_states[location];
127 }
128
getLocation(GLenum loc)129 int GLClientState::getLocation(GLenum loc)
130 {
131 int retval;
132
133 switch(loc) {
134 case GL_VERTEX_ARRAY:
135 retval = int(VERTEX_LOCATION);
136 break;
137 case GL_NORMAL_ARRAY:
138 retval = int(NORMAL_LOCATION);
139 break;
140 case GL_COLOR_ARRAY:
141 retval = int(COLOR_LOCATION);
142 break;
143 case GL_POINT_SIZE_ARRAY_OES:
144 retval = int(POINTSIZE_LOCATION);
145 break;
146 case GL_TEXTURE_COORD_ARRAY:
147 retval = int (TEXCOORD0_LOCATION + m_activeTexture);
148 break;
149 case GL_MATRIX_INDEX_ARRAY_OES:
150 retval = int (MATRIXINDEX_LOCATION);
151 break;
152 case GL_WEIGHT_ARRAY_OES:
153 retval = int (WEIGHT_LOCATION);
154 break;
155 default:
156 retval = loc;
157 }
158 return retval;
159 }
160
getClientStatePointer(GLenum pname,GLvoid ** params)161 void GLClientState::getClientStatePointer(GLenum pname, GLvoid** params)
162 {
163 const GLClientState::VertexAttribState *state = NULL;
164 switch (pname) {
165 case GL_VERTEX_ARRAY_POINTER: {
166 state = getState(GLClientState::VERTEX_LOCATION);
167 break;
168 }
169 case GL_NORMAL_ARRAY_POINTER: {
170 state = getState(GLClientState::NORMAL_LOCATION);
171 break;
172 }
173 case GL_COLOR_ARRAY_POINTER: {
174 state = getState(GLClientState::COLOR_LOCATION);
175 break;
176 }
177 case GL_TEXTURE_COORD_ARRAY_POINTER: {
178 state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION);
179 break;
180 }
181 case GL_POINT_SIZE_ARRAY_POINTER_OES: {
182 state = getState(GLClientState::POINTSIZE_LOCATION);
183 break;
184 }
185 case GL_MATRIX_INDEX_ARRAY_POINTER_OES: {
186 state = getState(GLClientState::MATRIXINDEX_LOCATION);
187 break;
188 }
189 case GL_WEIGHT_ARRAY_POINTER_OES: {
190 state = getState(GLClientState::WEIGHT_LOCATION);
191 break;
192 }
193 }
194 if (state && params)
195 *params = state->data;
196 }
197
setPixelStore(GLenum param,GLint value)198 int GLClientState::setPixelStore(GLenum param, GLint value)
199 {
200 int retval = 0;
201 switch(param) {
202 case GL_UNPACK_ALIGNMENT:
203 if (value == 1 || value == 2 || value == 4 || value == 8) {
204 m_pixelStore.unpack_alignment = value;
205 } else {
206 retval = GL_INVALID_VALUE;
207 }
208 break;
209 case GL_PACK_ALIGNMENT:
210 if (value == 1 || value == 2 || value == 4 || value == 8) {
211 m_pixelStore.pack_alignment = value;
212 } else {
213 retval = GL_INVALID_VALUE;
214 }
215 break;
216 default:
217 retval = GL_INVALID_ENUM;
218 }
219 return retval;
220 }
221
222
223
224
pixelDataSize(GLsizei width,GLsizei height,GLenum format,GLenum type,int pack) const225 size_t GLClientState::pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) const
226 {
227 int pixelsize = glUtilsPixelBitSize(format, type) >> 3;
228
229 int alignment = pack ? m_pixelStore.pack_alignment : m_pixelStore.unpack_alignment;
230
231 if (pixelsize == 0 ) {
232 ERR("unknown pixel size: width: %d height: %d format: %d type: %d pack: %d align: %d\n",
233 width, height, format, type, pack, alignment);
234 }
235 size_t linesize = pixelsize * width;
236 size_t aligned_linesize = int(linesize / alignment) * alignment;
237 if (aligned_linesize < linesize) {
238 aligned_linesize += alignment;
239 }
240 return aligned_linesize * height;
241 }
242
setActiveTextureUnit(GLenum texture)243 GLenum GLClientState::setActiveTextureUnit(GLenum texture)
244 {
245 GLuint unit = texture - GL_TEXTURE0;
246 if (unit >= MAX_TEXTURE_UNITS) {
247 return GL_INVALID_OPERATION;
248 }
249 m_tex.activeUnit = &m_tex.unit[unit];
250 return GL_NO_ERROR;
251 }
252
getActiveTextureUnit() const253 GLenum GLClientState::getActiveTextureUnit() const
254 {
255 return GL_TEXTURE0 + (m_tex.activeUnit - &m_tex.unit[0]);
256 }
257
enableTextureTarget(GLenum target)258 void GLClientState::enableTextureTarget(GLenum target)
259 {
260 switch (target) {
261 case GL_TEXTURE_2D:
262 m_tex.activeUnit->enables |= (1u << TEXTURE_2D);
263 break;
264 case GL_TEXTURE_EXTERNAL_OES:
265 m_tex.activeUnit->enables |= (1u << TEXTURE_EXTERNAL);
266 break;
267 }
268 }
269
disableTextureTarget(GLenum target)270 void GLClientState::disableTextureTarget(GLenum target)
271 {
272 switch (target) {
273 case GL_TEXTURE_2D:
274 m_tex.activeUnit->enables &= ~(1u << TEXTURE_2D);
275 break;
276 case GL_TEXTURE_EXTERNAL_OES:
277 m_tex.activeUnit->enables &= ~(1u << TEXTURE_EXTERNAL);
278 break;
279 }
280 }
281
getPriorityEnabledTarget(GLenum allDisabled) const282 GLenum GLClientState::getPriorityEnabledTarget(GLenum allDisabled) const
283 {
284 unsigned int enables = m_tex.activeUnit->enables;
285 if (enables & (1u << TEXTURE_EXTERNAL)) {
286 return GL_TEXTURE_EXTERNAL_OES;
287 } else if (enables & (1u << TEXTURE_2D)) {
288 return GL_TEXTURE_2D;
289 } else {
290 return allDisabled;
291 }
292 }
293
compareTexId(const void * pid,const void * prec)294 int GLClientState::compareTexId(const void* pid, const void* prec)
295 {
296 const GLuint* id = (const GLuint*)pid;
297 const TextureRec* rec = (const TextureRec*)prec;
298 return (GLint)(*id) - (GLint)rec->id;
299 }
300
bindTexture(GLenum target,GLuint texture,GLboolean * firstUse)301 GLenum GLClientState::bindTexture(GLenum target, GLuint texture,
302 GLboolean* firstUse)
303 {
304 GLboolean first = GL_FALSE;
305 TextureRec* texrec = NULL;
306 if (texture != 0) {
307 if (m_tex.textures) {
308 texrec = (TextureRec*)bsearch(&texture, m_tex.textures,
309 m_tex.numTextures, sizeof(TextureRec), compareTexId);
310 }
311 if (!texrec) {
312 if (!(texrec = addTextureRec(texture, target))) {
313 return GL_OUT_OF_MEMORY;
314 }
315 first = GL_TRUE;
316 }
317 if (target != texrec->target) {
318 return GL_INVALID_OPERATION;
319 }
320 }
321
322 switch (target) {
323 case GL_TEXTURE_2D:
324 m_tex.activeUnit->texture[TEXTURE_2D] = texture;
325 break;
326 case GL_TEXTURE_EXTERNAL_OES:
327 m_tex.activeUnit->texture[TEXTURE_EXTERNAL] = texture;
328 break;
329 }
330
331 if (firstUse) {
332 *firstUse = first;
333 }
334
335 return GL_NO_ERROR;
336 }
337
addTextureRec(GLuint id,GLenum target)338 GLClientState::TextureRec* GLClientState::addTextureRec(GLuint id,
339 GLenum target)
340 {
341 if (m_tex.numTextures == m_tex.allocTextures) {
342 const GLuint MAX_TEXTURES = 0xFFFFFFFFu;
343
344 GLuint newAlloc;
345 if (MAX_TEXTURES - m_tex.allocTextures >= m_tex.allocTextures) {
346 newAlloc = MAX(4, 2 * m_tex.allocTextures);
347 } else {
348 if (m_tex.allocTextures == MAX_TEXTURES) {
349 return NULL;
350 }
351 newAlloc = MAX_TEXTURES;
352 }
353
354 TextureRec* newTextures = (TextureRec*)realloc(m_tex.textures,
355 newAlloc * sizeof(TextureRec));
356 if (!newTextures) {
357 return NULL;
358 }
359
360 m_tex.textures = newTextures;
361 m_tex.allocTextures = newAlloc;
362 }
363
364 TextureRec* tex = m_tex.textures + m_tex.numTextures;
365 TextureRec* prev = tex - 1;
366 while (tex != m_tex.textures && id < prev->id) {
367 *tex-- = *prev--;
368 }
369 tex->id = id;
370 tex->target = target;
371 m_tex.numTextures++;
372
373 return tex;
374 }
375
getBoundTexture(GLenum target) const376 GLuint GLClientState::getBoundTexture(GLenum target) const
377 {
378 switch (target) {
379 case GL_TEXTURE_2D:
380 return m_tex.activeUnit->texture[TEXTURE_2D];
381 case GL_TEXTURE_EXTERNAL_OES:
382 return m_tex.activeUnit->texture[TEXTURE_EXTERNAL];
383 default:
384 return 0;
385 }
386 }
387
deleteTextures(GLsizei n,const GLuint * textures)388 void GLClientState::deleteTextures(GLsizei n, const GLuint* textures)
389 {
390 // Updating the textures array could be made more efficient when deleting
391 // several textures:
392 // - compacting the array could be done in a single pass once the deleted
393 // textures are marked, or
394 // - could swap deleted textures to the end and re-sort.
395 TextureRec* texrec;
396 for (const GLuint* texture = textures; texture != textures + n; texture++) {
397 texrec = (TextureRec*)bsearch(texture, m_tex.textures,
398 m_tex.numTextures, sizeof(TextureRec), compareTexId);
399 if (texrec) {
400 const TextureRec* end = m_tex.textures + m_tex.numTextures;
401 memmove(texrec, texrec + 1,
402 (end - texrec - 1) * sizeof(TextureRec));
403 m_tex.numTextures--;
404
405 for (TextureUnit* unit = m_tex.unit;
406 unit != m_tex.unit + MAX_TEXTURE_UNITS;
407 unit++)
408 {
409 if (unit->texture[TEXTURE_2D] == *texture) {
410 unit->texture[TEXTURE_2D] = 0;
411 } else if (unit->texture[TEXTURE_EXTERNAL] == *texture) {
412 unit->texture[TEXTURE_EXTERNAL] = 0;
413 }
414 }
415 }
416 }
417 }
418