blob: 0f1f27d8cfb6780a2835a08f0092911e81d6dbc9 [file] [log] [blame]
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001/* libs/opengles/state.cpp
2**
3** Copyright 2006, The Android Open Source Project
4**
Mathias Agopian1473f462009-04-10 14:24:30 -07005** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08008**
Mathias Agopian1473f462009-04-10 14:24:30 -07009** http://www.apache.org/licenses/LICENSE-2.0
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080010**
Mathias Agopian1473f462009-04-10 14:24:30 -070011** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080015** limitations under the License.
16*/
17
18#include <stdlib.h>
19
20#include "context.h"
21#include "fp.h"
22#include "state.h"
23#include "array.h"
24#include "matrix.h"
25#include "vertex.h"
26#include "light.h"
27#include "texture.h"
28#include "BufferObjectManager.h"
29#include "TextureObjectManager.h"
30
Mathias Agopian1473f462009-04-10 14:24:30 -070031#ifdef LIBAGL_USE_GRALLOC_COPYBITS
32#include <hardware/copybit.h>
33#endif // LIBAGL_USE_GRALLOC_COPYBITS
34
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080035namespace android {
36
37// ----------------------------------------------------------------------------
38
39static char const * const gVendorString = "Android";
Mathias Agopiancf335092009-11-12 15:19:42 -080040static char const * const gRendererString = "Android PixelFlinger 1.2";
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080041static char const * const gVersionString = "OpenGL ES-CM 1.0";
42static char const * const gExtensionsString =
43 "GL_OES_byte_coordinates " // OK
44 "GL_OES_fixed_point " // OK
45 "GL_OES_single_precision " // OK
46 "GL_OES_read_format " // OK
47 "GL_OES_compressed_paletted_texture " // OK
48 "GL_OES_draw_texture " // OK
49 "GL_OES_matrix_get " // OK
50 "GL_OES_query_matrix " // OK
51 // "GL_OES_point_size_array " // TODO
52 // "GL_OES_point_sprite " // TODO
Mathias Agopian1473f462009-04-10 14:24:30 -070053 "GL_OES_EGL_image " // OK
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080054 "GL_ARB_texture_compression " // OK
55 "GL_ARB_texture_non_power_of_two " // OK
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080056 "GL_ANDROID_user_clip_plane " // OK
57 "GL_ANDROID_vertex_buffer_object " // OK
58 "GL_ANDROID_generate_mipmap " // OK
59 ;
60
61// ----------------------------------------------------------------------------
62#if 0
63#pragma mark -
64#endif
65
66ogles_context_t *ogles_init(size_t extra)
67{
68 void* const base = malloc(extra + sizeof(ogles_context_t) + 32);
Mathias Agopian1473f462009-04-10 14:24:30 -070069 if (!base) return 0;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080070
71 ogles_context_t *c =
72 (ogles_context_t *)((ptrdiff_t(base) + extra + 31) & ~0x1FL);
73 memset(c, 0, sizeof(ogles_context_t));
74 ggl_init_context(&(c->rasterizer));
Mathias Agopian1473f462009-04-10 14:24:30 -070075
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080076 // XXX: this should be passed as an argument
77 sp<EGLSurfaceManager> smgr(new EGLSurfaceManager());
78 c->surfaceManager = smgr.get();
79 c->surfaceManager->incStrong(c);
80
81 sp<EGLBufferObjectManager> bomgr(new EGLBufferObjectManager());
82 c->bufferObjectManager = bomgr.get();
83 c->bufferObjectManager->incStrong(c);
84
85 ogles_init_array(c);
86 ogles_init_matrix(c);
87 ogles_init_vertex(c);
88 ogles_init_light(c);
89 ogles_init_texture(c);
90
91 c->rasterizer.base = base;
92 c->point.size = TRI_ONE;
93 c->line.width = TRI_ONE;
Mathias Agopian1473f462009-04-10 14:24:30 -070094
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080095 // in OpenGL, writing to the depth buffer is enabled by default.
96 c->rasterizer.procs.depthMask(c, 1);
Mathias Agopian1473f462009-04-10 14:24:30 -070097
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080098 // OpenGL enables dithering by default
99 c->rasterizer.procs.enable(c, GL_DITHER);
100
Mathias Agopian1473f462009-04-10 14:24:30 -0700101 c->copybits.blitEngine = NULL;
102 c->copybits.minScale = 0;
103 c->copybits.maxScale = 0;
Mathias Agopian350d6512009-06-10 16:01:54 -0700104 c->copybits.drawSurfaceBuffer = 0;
Mathias Agopian1473f462009-04-10 14:24:30 -0700105
106#ifdef LIBAGL_USE_GRALLOC_COPYBITS
107 hw_module_t const* module;
108 if (hw_get_module(COPYBIT_HARDWARE_MODULE_ID, &module) == 0) {
109 struct copybit_device_t* copyBits;
110 if (copybit_open(module, &copyBits) == 0) {
111 c->copybits.blitEngine = copyBits;
112 {
113 int minLim = copyBits->get(copyBits,
114 COPYBIT_MINIFICATION_LIMIT);
115 if (minLim != -EINVAL && minLim > 0) {
116 c->copybits.minScale = (1 << 16) / minLim;
117 }
118 }
119 {
120 int magLim = copyBits->get(copyBits,
121 COPYBIT_MAGNIFICATION_LIMIT);
122 if (magLim != -EINVAL && magLim > 0) {
123 c->copybits.maxScale = min(32*1024-1, magLim) << 16;
124 }
125 }
126 }
127 }
128#endif // LIBAGL_USE_GRALLOC_COPYBITS
129
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800130 return c;
131}
132
133void ogles_uninit(ogles_context_t* c)
134{
135 ogles_uninit_array(c);
136 ogles_uninit_matrix(c);
137 ogles_uninit_vertex(c);
138 ogles_uninit_light(c);
139 ogles_uninit_texture(c);
140 c->surfaceManager->decStrong(c);
141 c->bufferObjectManager->decStrong(c);
142 ggl_uninit_context(&(c->rasterizer));
Mathias Agopian1473f462009-04-10 14:24:30 -0700143 free(c->rasterizer.base);
144#ifdef LIBAGL_USE_GRALLOC_COPYBITS
145 if (c->copybits.blitEngine != NULL) {
146 copybit_close((struct copybit_device_t*) c->copybits.blitEngine);
147 }
148#endif // LIBAGL_USE_GRALLOC_COPYBITS
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800149}
150
151void _ogles_error(ogles_context_t* c, GLenum error)
152{
153 if (c->error == GL_NO_ERROR)
154 c->error = error;
155}
156
157static bool stencilop_valid(GLenum op) {
158 switch (op) {
159 case GL_KEEP:
160 case GL_ZERO:
161 case GL_REPLACE:
162 case GL_INCR:
163 case GL_DECR:
164 case GL_INVERT:
165 return true;
166 }
167 return false;
168}
169
170static void enable_disable(ogles_context_t* c, GLenum cap, int enabled)
171{
172 if ((cap >= GL_LIGHT0) && (cap<GL_LIGHT0+OGLES_MAX_LIGHTS)) {
173 c->lighting.lights[cap-GL_LIGHT0].enable = enabled;
174 c->lighting.enabledLights &= ~(1<<(cap-GL_LIGHT0));
175 c->lighting.enabledLights |= (enabled<<(cap-GL_LIGHT0));
176 return;
177 }
178
179 switch (cap) {
180 case GL_POINT_SMOOTH:
181 c->point.smooth = enabled;
182 break;
183 case GL_LINE_SMOOTH:
184 c->line.smooth = enabled;
185 break;
186 case GL_POLYGON_OFFSET_FILL:
187 c->polygonOffset.enable = enabled;
188 break;
189 case GL_CULL_FACE:
190 c->cull.enable = enabled;
191 break;
192 case GL_LIGHTING:
193 c->lighting.enable = enabled;
194 break;
195 case GL_COLOR_MATERIAL:
196 c->lighting.colorMaterial.enable = enabled;
197 break;
198 case GL_NORMALIZE:
199 case GL_RESCALE_NORMAL:
200 c->transforms.rescaleNormals = enabled ? cap : 0;
201 // XXX: invalidate mvit
202 break;
203
204 case GL_CLIP_PLANE0:
205 case GL_CLIP_PLANE1:
206 case GL_CLIP_PLANE2:
207 case GL_CLIP_PLANE3:
208 case GL_CLIP_PLANE4:
209 case GL_CLIP_PLANE5:
210 c->clipPlanes.enable &= ~(1<<(cap-GL_CLIP_PLANE0));
211 c->clipPlanes.enable |= (enabled<<(cap-GL_CLIP_PLANE0));
212 ogles_invalidate_perspective(c);
213 break;
214
215 case GL_FOG:
216 case GL_DEPTH_TEST:
217 ogles_invalidate_perspective(c);
218 // fall-through...
219 case GL_BLEND:
220 case GL_SCISSOR_TEST:
221 case GL_ALPHA_TEST:
222 case GL_COLOR_LOGIC_OP:
223 case GL_DITHER:
224 case GL_STENCIL_TEST:
225 case GL_TEXTURE_2D:
226 // these need to fall through into the rasterizer
227 c->rasterizer.procs.enableDisable(c, cap, enabled);
228 break;
Mathias Agopian1473f462009-04-10 14:24:30 -0700229
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800230 case GL_MULTISAMPLE:
231 case GL_SAMPLE_ALPHA_TO_COVERAGE:
232 case GL_SAMPLE_ALPHA_TO_ONE:
233 case GL_SAMPLE_COVERAGE:
234 // not supported in this implementation
235 break;
236
237 default:
238 ogles_error(c, GL_INVALID_ENUM);
239 return;
240 }
241}
242
243// ----------------------------------------------------------------------------
244}; // namespace android
245// ----------------------------------------------------------------------------
246using namespace android;
247
248#if 0
249#pragma mark -
250#endif
251
252// These ones are super-easy, we're not supporting those features!
253void glSampleCoverage(GLclampf value, GLboolean invert) {
254}
255void glSampleCoveragex(GLclampx value, GLboolean invert) {
256}
257void glStencilFunc(GLenum func, GLint ref, GLuint mask) {
258 ogles_context_t* c = ogles_context_t::get();
259 if (func < GL_NEVER || func > GL_ALWAYS) {
260 ogles_error(c, GL_INVALID_ENUM);
261 return;
262 }
263 // from OpenGL|ES 1.0 sepcification:
264 // If there is no stencil buffer, no stencil modification can occur
265 // and it is as if the stencil test always passes.
266}
267
268void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
269 ogles_context_t* c = ogles_context_t::get();
270 if ((stencilop_valid(fail) &
271 stencilop_valid(zfail) &
272 stencilop_valid(zpass)) == 0) {
273 ogles_error(c, GL_INVALID_ENUM);
274 return;
275 }
276}
277
278// ----------------------------------------------------------------------------
279
280void glAlphaFunc(GLenum func, GLclampf ref)
281{
282 glAlphaFuncx(func, gglFloatToFixed(ref));
283}
284
285void glCullFace(GLenum mode)
286{
287 ogles_context_t* c = ogles_context_t::get();
288 switch (mode) {
289 case GL_FRONT:
290 case GL_BACK:
291 case GL_FRONT_AND_BACK:
292 break;
293 default:
294 ogles_error(c, GL_INVALID_ENUM);
295 }
296 c->cull.cullFace = mode;
297}
298
299void glFrontFace(GLenum mode)
300{
301 ogles_context_t* c = ogles_context_t::get();
302 switch (mode) {
303 case GL_CW:
304 case GL_CCW:
305 break;
306 default:
307 ogles_error(c, GL_INVALID_ENUM);
308 return;
309 }
310 c->cull.frontFace = mode;
311}
312
313void glHint(GLenum target, GLenum mode)
314{
315 ogles_context_t* c = ogles_context_t::get();
316 switch (target) {
317 case GL_FOG_HINT:
318 case GL_GENERATE_MIPMAP_HINT:
319 case GL_LINE_SMOOTH_HINT:
320 break;
321 case GL_POINT_SMOOTH_HINT:
Mathias Agopian1473f462009-04-10 14:24:30 -0700322 c->rasterizer.procs.enableDisable(c,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800323 GGL_POINT_SMOOTH_NICE, mode==GL_NICEST);
324 break;
325 case GL_PERSPECTIVE_CORRECTION_HINT:
326 c->perspective = (mode == GL_NICEST) ? 1 : 0;
327 break;
328 default:
329 ogles_error(c, GL_INVALID_ENUM);
330 }
331}
332
333void glEnable(GLenum cap) {
334 ogles_context_t* c = ogles_context_t::get();
335 enable_disable(c, cap, 1);
336}
337void glDisable(GLenum cap) {
338 ogles_context_t* c = ogles_context_t::get();
339 enable_disable(c, cap, 0);
340}
341
342void glFinish()
343{ // nothing to do for our software implementation
344}
345
346void glFlush()
347{ // nothing to do for our software implementation
348}
349
350GLenum glGetError()
351{
352 // From OpenGL|ES 1.0 specification:
353 // If more than one flag has recorded an error, glGetError returns
354 // and clears an arbitrary error flag value. Thus, glGetError should
355 // always be called in a loop, until it returns GL_NO_ERROR,
356 // if all error flags are to be reset.
357
358 ogles_context_t* c = ogles_context_t::get();
359 if (c->error) {
360 const GLenum ret(c->error);
361 c->error = 0;
362 return ret;
363 }
Mathias Agopian1473f462009-04-10 14:24:30 -0700364
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800365 if (c->rasterizer.error) {
366 const GLenum ret(c->rasterizer.error);
367 c->rasterizer.error = 0;
368 return ret;
369 }
370
371 return GL_NO_ERROR;
372}
373
374const GLubyte* glGetString(GLenum string)
375{
376 switch (string) {
377 case GL_VENDOR: return (const GLubyte*)gVendorString;
378 case GL_RENDERER: return (const GLubyte*)gRendererString;
379 case GL_VERSION: return (const GLubyte*)gVersionString;
380 case GL_EXTENSIONS: return (const GLubyte*)gExtensionsString;
381 }
382 ogles_context_t* c = ogles_context_t::get();
383 ogles_error(c, GL_INVALID_ENUM);
384 return 0;
385}
386
387void glGetIntegerv(GLenum pname, GLint *params)
388{
389 ogles_context_t* c = ogles_context_t::get();
390 switch (pname) {
391 case GL_ALIASED_POINT_SIZE_RANGE:
392 params[0] = 0;
393 params[1] = GGL_MAX_ALIASED_POINT_SIZE;
394 break;
395 case GL_ALIASED_LINE_WIDTH_RANGE:
396 params[0] = 0;
397 params[1] = GGL_MAX_ALIASED_POINT_SIZE;
398 break;
399 case GL_ALPHA_BITS: {
400 int index = c->rasterizer.state.buffers.color.format;
401 GGLFormat const * formats = gglGetPixelFormatTable();
402 params[0] = formats[index].ah - formats[index].al;
Mathias Agopian1473f462009-04-10 14:24:30 -0700403 break;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800404 }
405 case GL_RED_BITS: {
406 int index = c->rasterizer.state.buffers.color.format;
407 GGLFormat const * formats = gglGetPixelFormatTable();
408 params[0] = formats[index].rh - formats[index].rl;
Mathias Agopian1473f462009-04-10 14:24:30 -0700409 break;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800410 }
411 case GL_GREEN_BITS: {
412 int index = c->rasterizer.state.buffers.color.format;
413 GGLFormat const * formats = gglGetPixelFormatTable();
414 params[0] = formats[index].gh - formats[index].gl;
Mathias Agopian1473f462009-04-10 14:24:30 -0700415 break;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800416 }
417 case GL_BLUE_BITS: {
418 int index = c->rasterizer.state.buffers.color.format;
419 GGLFormat const * formats = gglGetPixelFormatTable();
420 params[0] = formats[index].bh - formats[index].bl;
Mathias Agopian1473f462009-04-10 14:24:30 -0700421 break;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800422 }
423 case GL_COMPRESSED_TEXTURE_FORMATS:
424 params[ 0] = GL_PALETTE4_RGB8_OES;
425 params[ 1] = GL_PALETTE4_RGBA8_OES;
426 params[ 2] = GL_PALETTE4_R5_G6_B5_OES;
427 params[ 3] = GL_PALETTE4_RGBA4_OES;
428 params[ 4] = GL_PALETTE4_RGB5_A1_OES;
429 params[ 5] = GL_PALETTE8_RGB8_OES;
430 params[ 6] = GL_PALETTE8_RGBA8_OES;
431 params[ 7] = GL_PALETTE8_R5_G6_B5_OES;
432 params[ 8] = GL_PALETTE8_RGBA4_OES;
433 params[ 9] = GL_PALETTE8_RGB5_A1_OES;
434 break;
435 case GL_DEPTH_BITS:
436 params[0] = c->rasterizer.state.buffers.depth.format ? 0 : 16;
437 break;
438 case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
439 params[0] = GL_RGB;
440 break;
441 case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
442 params[0] = GL_UNSIGNED_SHORT_5_6_5;
443 break;
444 case GL_MAX_LIGHTS:
445 params[0] = OGLES_MAX_LIGHTS;
446 break;
447 case GL_MAX_CLIP_PLANES:
448 params[0] = OGLES_MAX_CLIP_PLANES;
449 break;
450 case GL_MAX_MODELVIEW_STACK_DEPTH:
451 params[0] = OGLES_MODELVIEW_STACK_DEPTH;
452 break;
453 case GL_MAX_PROJECTION_STACK_DEPTH:
454 params[0] = OGLES_PROJECTION_STACK_DEPTH;
455 break;
456 case GL_MAX_TEXTURE_STACK_DEPTH:
457 params[0] = OGLES_TEXTURE_STACK_DEPTH;
458 break;
459 case GL_MAX_TEXTURE_SIZE:
460 params[0] = GGL_MAX_TEXTURE_SIZE;
461 break;
462 case GL_MAX_TEXTURE_UNITS:
463 params[0] = GGL_TEXTURE_UNIT_COUNT;
464 break;
465 case GL_MAX_VIEWPORT_DIMS:
466 params[0] = GGL_MAX_VIEWPORT_DIMS;
467 params[1] = GGL_MAX_VIEWPORT_DIMS;
468 break;
469 case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
470 params[0] = OGLES_NUM_COMPRESSED_TEXTURE_FORMATS;
471 break;
472 case GL_SMOOTH_LINE_WIDTH_RANGE:
473 params[0] = 0;
474 params[1] = GGL_MAX_SMOOTH_LINE_WIDTH;
475 break;
476 case GL_SMOOTH_POINT_SIZE_RANGE:
477 params[0] = 0;
478 params[1] = GGL_MAX_SMOOTH_POINT_SIZE;
479 break;
480 case GL_STENCIL_BITS:
481 params[0] = 0;
482 break;
483 case GL_SUBPIXEL_BITS:
484 params[0] = GGL_SUBPIXEL_BITS;
485 break;
486
487 case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
488 memcpy( params,
489 c->transforms.modelview.top().elements(),
490 16*sizeof(GLint));
491 break;
492 case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
493 memcpy( params,
494 c->transforms.projection.top().elements(),
495 16*sizeof(GLint));
496 break;
497 case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
498 memcpy( params,
499 c->transforms.texture[c->textures.active].top().elements(),
500 16*sizeof(GLint));
501 break;
502
503 default:
504 ogles_error(c, GL_INVALID_ENUM);
505 break;
506 }
507}
508
509// ----------------------------------------------------------------------------
510
511void glPointSize(GLfloat size)
512{
513 ogles_context_t* c = ogles_context_t::get();
514 if (size <= 0) {
515 ogles_error(c, GL_INVALID_ENUM);
516 return;
517 }
518 c->point.size = TRI_FROM_FIXED(gglFloatToFixed(size));
519}
520
521void glPointSizex(GLfixed size)
522{
523 ogles_context_t* c = ogles_context_t::get();
524 if (size <= 0) {
525 ogles_error(c, GL_INVALID_ENUM);
526 return;
527 }
528 c->point.size = TRI_FROM_FIXED(size);
529}
530
531// ----------------------------------------------------------------------------
532
533void glLineWidth(GLfloat width)
534{
535 ogles_context_t* c = ogles_context_t::get();
536 if (width <= 0) {
537 ogles_error(c, GL_INVALID_ENUM);
538 return;
539 }
540 c->line.width = TRI_FROM_FIXED(gglFloatToFixed(width));
541}
542
543void glLineWidthx(GLfixed width)
544{
545 ogles_context_t* c = ogles_context_t::get();
546 if (width <= 0) {
547 ogles_error(c, GL_INVALID_ENUM);
548 return;
549 }
550 c->line.width = TRI_FROM_FIXED(width);
551}
552
553// ----------------------------------------------------------------------------
554
555void glColorMask(GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
556 ogles_context_t* c = ogles_context_t::get();
557 c->rasterizer.procs.colorMask(c, r, g, b, a);
558}
559
560void glDepthMask(GLboolean flag) {
561 ogles_context_t* c = ogles_context_t::get();
562 c->rasterizer.procs.depthMask(c, flag);
563}
564
565void glStencilMask(GLuint mask) {
566 ogles_context_t* c = ogles_context_t::get();
567 c->rasterizer.procs.stencilMask(c, mask);
568}
569
570void glDepthFunc(GLenum func) {
571 ogles_context_t* c = ogles_context_t::get();
572 c->rasterizer.procs.depthFunc(c, func);
573}
574
575void glLogicOp(GLenum opcode) {
576 ogles_context_t* c = ogles_context_t::get();
577 c->rasterizer.procs.logicOp(c, opcode);
578}
579
580void glAlphaFuncx(GLenum func, GLclampx ref) {
581 ogles_context_t* c = ogles_context_t::get();
582 c->rasterizer.procs.alphaFuncx(c, func, ref);
583}
584
585void glBlendFunc(GLenum sfactor, GLenum dfactor) {
586 ogles_context_t* c = ogles_context_t::get();
587 c->rasterizer.procs.blendFunc(c, sfactor, dfactor);
588}
589
590void glClear(GLbitfield mask) {
591 ogles_context_t* c = ogles_context_t::get();
592 c->rasterizer.procs.clear(c, mask);
593}
594
595void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) {
596 ogles_context_t* c = ogles_context_t::get();
597 c->rasterizer.procs.clearColorx(c, red, green, blue, alpha);
598}
599
600void glClearColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a)
601{
602 ogles_context_t* c = ogles_context_t::get();
603 c->rasterizer.procs.clearColorx(c,
604 gglFloatToFixed(r),
605 gglFloatToFixed(g),
606 gglFloatToFixed(b),
607 gglFloatToFixed(a));
608}
609
610void glClearDepthx(GLclampx depth) {
611 ogles_context_t* c = ogles_context_t::get();
612 c->rasterizer.procs.clearDepthx(c, depth);
613}
614
615void glClearDepthf(GLclampf depth)
616{
617 ogles_context_t* c = ogles_context_t::get();
618 c->rasterizer.procs.clearDepthx(c, gglFloatToFixed(depth));
619}
620
621void glClearStencil(GLint s) {
622 ogles_context_t* c = ogles_context_t::get();
623 c->rasterizer.procs.clearStencil(c, s);
624}