625 lines
18 KiB
C++
625 lines
18 KiB
C++
/* libs/opengles/state.cpp
|
|
**
|
|
** Copyright 2006, The Android Open Source Project
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "context.h"
|
|
#include "fp.h"
|
|
#include "state.h"
|
|
#include "array.h"
|
|
#include "matrix.h"
|
|
#include "vertex.h"
|
|
#include "light.h"
|
|
#include "texture.h"
|
|
#include "BufferObjectManager.h"
|
|
#include "TextureObjectManager.h"
|
|
|
|
#ifdef LIBAGL_USE_GRALLOC_COPYBITS
|
|
#include <hardware/copybit.h>
|
|
#endif // LIBAGL_USE_GRALLOC_COPYBITS
|
|
|
|
namespace android {
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static char const * const gVendorString = "Android";
|
|
static char const * const gRendererString = "Android PixelFlinger 1.1";
|
|
static char const * const gVersionString = "OpenGL ES-CM 1.0";
|
|
static char const * const gExtensionsString =
|
|
"GL_OES_byte_coordinates " // OK
|
|
"GL_OES_fixed_point " // OK
|
|
"GL_OES_single_precision " // OK
|
|
"GL_OES_read_format " // OK
|
|
"GL_OES_compressed_paletted_texture " // OK
|
|
"GL_OES_draw_texture " // OK
|
|
"GL_OES_matrix_get " // OK
|
|
"GL_OES_query_matrix " // OK
|
|
// "GL_OES_point_size_array " // TODO
|
|
// "GL_OES_point_sprite " // TODO
|
|
"GL_OES_EGL_image " // OK
|
|
"GL_ARB_texture_compression " // OK
|
|
"GL_ARB_texture_non_power_of_two " // OK
|
|
"GL_ANDROID_user_clip_plane " // OK
|
|
"GL_ANDROID_vertex_buffer_object " // OK
|
|
"GL_ANDROID_generate_mipmap " // OK
|
|
;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
ogles_context_t *ogles_init(size_t extra)
|
|
{
|
|
void* const base = malloc(extra + sizeof(ogles_context_t) + 32);
|
|
if (!base) return 0;
|
|
|
|
ogles_context_t *c =
|
|
(ogles_context_t *)((ptrdiff_t(base) + extra + 31) & ~0x1FL);
|
|
memset(c, 0, sizeof(ogles_context_t));
|
|
ggl_init_context(&(c->rasterizer));
|
|
|
|
// XXX: this should be passed as an argument
|
|
sp<EGLSurfaceManager> smgr(new EGLSurfaceManager());
|
|
c->surfaceManager = smgr.get();
|
|
c->surfaceManager->incStrong(c);
|
|
|
|
sp<EGLBufferObjectManager> bomgr(new EGLBufferObjectManager());
|
|
c->bufferObjectManager = bomgr.get();
|
|
c->bufferObjectManager->incStrong(c);
|
|
|
|
ogles_init_array(c);
|
|
ogles_init_matrix(c);
|
|
ogles_init_vertex(c);
|
|
ogles_init_light(c);
|
|
ogles_init_texture(c);
|
|
|
|
c->rasterizer.base = base;
|
|
c->point.size = TRI_ONE;
|
|
c->line.width = TRI_ONE;
|
|
|
|
// in OpenGL, writing to the depth buffer is enabled by default.
|
|
c->rasterizer.procs.depthMask(c, 1);
|
|
|
|
// OpenGL enables dithering by default
|
|
c->rasterizer.procs.enable(c, GL_DITHER);
|
|
|
|
c->copybits.blitEngine = NULL;
|
|
c->copybits.minScale = 0;
|
|
c->copybits.maxScale = 0;
|
|
c->copybits.drawSurfaceBuffer = 0;
|
|
|
|
#ifdef LIBAGL_USE_GRALLOC_COPYBITS
|
|
hw_module_t const* module;
|
|
if (hw_get_module(COPYBIT_HARDWARE_MODULE_ID, &module) == 0) {
|
|
struct copybit_device_t* copyBits;
|
|
if (copybit_open(module, ©Bits) == 0) {
|
|
c->copybits.blitEngine = copyBits;
|
|
{
|
|
int minLim = copyBits->get(copyBits,
|
|
COPYBIT_MINIFICATION_LIMIT);
|
|
if (minLim != -EINVAL && minLim > 0) {
|
|
c->copybits.minScale = (1 << 16) / minLim;
|
|
}
|
|
}
|
|
{
|
|
int magLim = copyBits->get(copyBits,
|
|
COPYBIT_MAGNIFICATION_LIMIT);
|
|
if (magLim != -EINVAL && magLim > 0) {
|
|
c->copybits.maxScale = min(32*1024-1, magLim) << 16;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif // LIBAGL_USE_GRALLOC_COPYBITS
|
|
|
|
return c;
|
|
}
|
|
|
|
void ogles_uninit(ogles_context_t* c)
|
|
{
|
|
ogles_uninit_array(c);
|
|
ogles_uninit_matrix(c);
|
|
ogles_uninit_vertex(c);
|
|
ogles_uninit_light(c);
|
|
ogles_uninit_texture(c);
|
|
c->surfaceManager->decStrong(c);
|
|
c->bufferObjectManager->decStrong(c);
|
|
ggl_uninit_context(&(c->rasterizer));
|
|
free(c->rasterizer.base);
|
|
#ifdef LIBAGL_USE_GRALLOC_COPYBITS
|
|
if (c->copybits.blitEngine != NULL) {
|
|
copybit_close((struct copybit_device_t*) c->copybits.blitEngine);
|
|
}
|
|
#endif // LIBAGL_USE_GRALLOC_COPYBITS
|
|
}
|
|
|
|
void _ogles_error(ogles_context_t* c, GLenum error)
|
|
{
|
|
if (c->error == GL_NO_ERROR)
|
|
c->error = error;
|
|
}
|
|
|
|
static bool stencilop_valid(GLenum op) {
|
|
switch (op) {
|
|
case GL_KEEP:
|
|
case GL_ZERO:
|
|
case GL_REPLACE:
|
|
case GL_INCR:
|
|
case GL_DECR:
|
|
case GL_INVERT:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void enable_disable(ogles_context_t* c, GLenum cap, int enabled)
|
|
{
|
|
if ((cap >= GL_LIGHT0) && (cap<GL_LIGHT0+OGLES_MAX_LIGHTS)) {
|
|
c->lighting.lights[cap-GL_LIGHT0].enable = enabled;
|
|
c->lighting.enabledLights &= ~(1<<(cap-GL_LIGHT0));
|
|
c->lighting.enabledLights |= (enabled<<(cap-GL_LIGHT0));
|
|
return;
|
|
}
|
|
|
|
switch (cap) {
|
|
case GL_POINT_SMOOTH:
|
|
c->point.smooth = enabled;
|
|
break;
|
|
case GL_LINE_SMOOTH:
|
|
c->line.smooth = enabled;
|
|
break;
|
|
case GL_POLYGON_OFFSET_FILL:
|
|
c->polygonOffset.enable = enabled;
|
|
break;
|
|
case GL_CULL_FACE:
|
|
c->cull.enable = enabled;
|
|
break;
|
|
case GL_LIGHTING:
|
|
c->lighting.enable = enabled;
|
|
break;
|
|
case GL_COLOR_MATERIAL:
|
|
c->lighting.colorMaterial.enable = enabled;
|
|
break;
|
|
case GL_NORMALIZE:
|
|
case GL_RESCALE_NORMAL:
|
|
c->transforms.rescaleNormals = enabled ? cap : 0;
|
|
// XXX: invalidate mvit
|
|
break;
|
|
|
|
case GL_CLIP_PLANE0:
|
|
case GL_CLIP_PLANE1:
|
|
case GL_CLIP_PLANE2:
|
|
case GL_CLIP_PLANE3:
|
|
case GL_CLIP_PLANE4:
|
|
case GL_CLIP_PLANE5:
|
|
c->clipPlanes.enable &= ~(1<<(cap-GL_CLIP_PLANE0));
|
|
c->clipPlanes.enable |= (enabled<<(cap-GL_CLIP_PLANE0));
|
|
ogles_invalidate_perspective(c);
|
|
break;
|
|
|
|
case GL_FOG:
|
|
case GL_DEPTH_TEST:
|
|
ogles_invalidate_perspective(c);
|
|
// fall-through...
|
|
case GL_BLEND:
|
|
case GL_SCISSOR_TEST:
|
|
case GL_ALPHA_TEST:
|
|
case GL_COLOR_LOGIC_OP:
|
|
case GL_DITHER:
|
|
case GL_STENCIL_TEST:
|
|
case GL_TEXTURE_2D:
|
|
// these need to fall through into the rasterizer
|
|
c->rasterizer.procs.enableDisable(c, cap, enabled);
|
|
break;
|
|
|
|
case GL_MULTISAMPLE:
|
|
case GL_SAMPLE_ALPHA_TO_COVERAGE:
|
|
case GL_SAMPLE_ALPHA_TO_ONE:
|
|
case GL_SAMPLE_COVERAGE:
|
|
// not supported in this implementation
|
|
break;
|
|
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
}; // namespace android
|
|
// ----------------------------------------------------------------------------
|
|
using namespace android;
|
|
|
|
#if 0
|
|
#pragma mark -
|
|
#endif
|
|
|
|
// These ones are super-easy, we're not supporting those features!
|
|
void glSampleCoverage(GLclampf value, GLboolean invert) {
|
|
}
|
|
void glSampleCoveragex(GLclampx value, GLboolean invert) {
|
|
}
|
|
void glStencilFunc(GLenum func, GLint ref, GLuint mask) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (func < GL_NEVER || func > GL_ALWAYS) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
// from OpenGL|ES 1.0 sepcification:
|
|
// If there is no stencil buffer, no stencil modification can occur
|
|
// and it is as if the stencil test always passes.
|
|
}
|
|
|
|
void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if ((stencilop_valid(fail) &
|
|
stencilop_valid(zfail) &
|
|
stencilop_valid(zpass)) == 0) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void glAlphaFunc(GLenum func, GLclampf ref)
|
|
{
|
|
glAlphaFuncx(func, gglFloatToFixed(ref));
|
|
}
|
|
|
|
void glCullFace(GLenum mode)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
switch (mode) {
|
|
case GL_FRONT:
|
|
case GL_BACK:
|
|
case GL_FRONT_AND_BACK:
|
|
break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
}
|
|
c->cull.cullFace = mode;
|
|
}
|
|
|
|
void glFrontFace(GLenum mode)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
switch (mode) {
|
|
case GL_CW:
|
|
case GL_CCW:
|
|
break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
c->cull.frontFace = mode;
|
|
}
|
|
|
|
void glHint(GLenum target, GLenum mode)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
switch (target) {
|
|
case GL_FOG_HINT:
|
|
case GL_GENERATE_MIPMAP_HINT:
|
|
case GL_LINE_SMOOTH_HINT:
|
|
break;
|
|
case GL_POINT_SMOOTH_HINT:
|
|
c->rasterizer.procs.enableDisable(c,
|
|
GGL_POINT_SMOOTH_NICE, mode==GL_NICEST);
|
|
break;
|
|
case GL_PERSPECTIVE_CORRECTION_HINT:
|
|
c->perspective = (mode == GL_NICEST) ? 1 : 0;
|
|
break;
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
}
|
|
}
|
|
|
|
void glEnable(GLenum cap) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
enable_disable(c, cap, 1);
|
|
}
|
|
void glDisable(GLenum cap) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
enable_disable(c, cap, 0);
|
|
}
|
|
|
|
void glFinish()
|
|
{ // nothing to do for our software implementation
|
|
}
|
|
|
|
void glFlush()
|
|
{ // nothing to do for our software implementation
|
|
}
|
|
|
|
GLenum glGetError()
|
|
{
|
|
// From OpenGL|ES 1.0 specification:
|
|
// If more than one flag has recorded an error, glGetError returns
|
|
// and clears an arbitrary error flag value. Thus, glGetError should
|
|
// always be called in a loop, until it returns GL_NO_ERROR,
|
|
// if all error flags are to be reset.
|
|
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (c->error) {
|
|
const GLenum ret(c->error);
|
|
c->error = 0;
|
|
return ret;
|
|
}
|
|
|
|
if (c->rasterizer.error) {
|
|
const GLenum ret(c->rasterizer.error);
|
|
c->rasterizer.error = 0;
|
|
return ret;
|
|
}
|
|
|
|
return GL_NO_ERROR;
|
|
}
|
|
|
|
const GLubyte* glGetString(GLenum string)
|
|
{
|
|
switch (string) {
|
|
case GL_VENDOR: return (const GLubyte*)gVendorString;
|
|
case GL_RENDERER: return (const GLubyte*)gRendererString;
|
|
case GL_VERSION: return (const GLubyte*)gVersionString;
|
|
case GL_EXTENSIONS: return (const GLubyte*)gExtensionsString;
|
|
}
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return 0;
|
|
}
|
|
|
|
void glGetIntegerv(GLenum pname, GLint *params)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
switch (pname) {
|
|
case GL_ALIASED_POINT_SIZE_RANGE:
|
|
params[0] = 0;
|
|
params[1] = GGL_MAX_ALIASED_POINT_SIZE;
|
|
break;
|
|
case GL_ALIASED_LINE_WIDTH_RANGE:
|
|
params[0] = 0;
|
|
params[1] = GGL_MAX_ALIASED_POINT_SIZE;
|
|
break;
|
|
case GL_ALPHA_BITS: {
|
|
int index = c->rasterizer.state.buffers.color.format;
|
|
GGLFormat const * formats = gglGetPixelFormatTable();
|
|
params[0] = formats[index].ah - formats[index].al;
|
|
break;
|
|
}
|
|
case GL_RED_BITS: {
|
|
int index = c->rasterizer.state.buffers.color.format;
|
|
GGLFormat const * formats = gglGetPixelFormatTable();
|
|
params[0] = formats[index].rh - formats[index].rl;
|
|
break;
|
|
}
|
|
case GL_GREEN_BITS: {
|
|
int index = c->rasterizer.state.buffers.color.format;
|
|
GGLFormat const * formats = gglGetPixelFormatTable();
|
|
params[0] = formats[index].gh - formats[index].gl;
|
|
break;
|
|
}
|
|
case GL_BLUE_BITS: {
|
|
int index = c->rasterizer.state.buffers.color.format;
|
|
GGLFormat const * formats = gglGetPixelFormatTable();
|
|
params[0] = formats[index].bh - formats[index].bl;
|
|
break;
|
|
}
|
|
case GL_COMPRESSED_TEXTURE_FORMATS:
|
|
params[ 0] = GL_PALETTE4_RGB8_OES;
|
|
params[ 1] = GL_PALETTE4_RGBA8_OES;
|
|
params[ 2] = GL_PALETTE4_R5_G6_B5_OES;
|
|
params[ 3] = GL_PALETTE4_RGBA4_OES;
|
|
params[ 4] = GL_PALETTE4_RGB5_A1_OES;
|
|
params[ 5] = GL_PALETTE8_RGB8_OES;
|
|
params[ 6] = GL_PALETTE8_RGBA8_OES;
|
|
params[ 7] = GL_PALETTE8_R5_G6_B5_OES;
|
|
params[ 8] = GL_PALETTE8_RGBA4_OES;
|
|
params[ 9] = GL_PALETTE8_RGB5_A1_OES;
|
|
break;
|
|
case GL_DEPTH_BITS:
|
|
params[0] = c->rasterizer.state.buffers.depth.format ? 0 : 16;
|
|
break;
|
|
case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
|
|
params[0] = GL_RGB;
|
|
break;
|
|
case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
|
|
params[0] = GL_UNSIGNED_SHORT_5_6_5;
|
|
break;
|
|
case GL_MAX_LIGHTS:
|
|
params[0] = OGLES_MAX_LIGHTS;
|
|
break;
|
|
case GL_MAX_CLIP_PLANES:
|
|
params[0] = OGLES_MAX_CLIP_PLANES;
|
|
break;
|
|
case GL_MAX_MODELVIEW_STACK_DEPTH:
|
|
params[0] = OGLES_MODELVIEW_STACK_DEPTH;
|
|
break;
|
|
case GL_MAX_PROJECTION_STACK_DEPTH:
|
|
params[0] = OGLES_PROJECTION_STACK_DEPTH;
|
|
break;
|
|
case GL_MAX_TEXTURE_STACK_DEPTH:
|
|
params[0] = OGLES_TEXTURE_STACK_DEPTH;
|
|
break;
|
|
case GL_MAX_TEXTURE_SIZE:
|
|
params[0] = GGL_MAX_TEXTURE_SIZE;
|
|
break;
|
|
case GL_MAX_TEXTURE_UNITS:
|
|
params[0] = GGL_TEXTURE_UNIT_COUNT;
|
|
break;
|
|
case GL_MAX_VIEWPORT_DIMS:
|
|
params[0] = GGL_MAX_VIEWPORT_DIMS;
|
|
params[1] = GGL_MAX_VIEWPORT_DIMS;
|
|
break;
|
|
case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
|
|
params[0] = OGLES_NUM_COMPRESSED_TEXTURE_FORMATS;
|
|
break;
|
|
case GL_SMOOTH_LINE_WIDTH_RANGE:
|
|
params[0] = 0;
|
|
params[1] = GGL_MAX_SMOOTH_LINE_WIDTH;
|
|
break;
|
|
case GL_SMOOTH_POINT_SIZE_RANGE:
|
|
params[0] = 0;
|
|
params[1] = GGL_MAX_SMOOTH_POINT_SIZE;
|
|
break;
|
|
case GL_STENCIL_BITS:
|
|
params[0] = 0;
|
|
break;
|
|
case GL_SUBPIXEL_BITS:
|
|
params[0] = GGL_SUBPIXEL_BITS;
|
|
break;
|
|
|
|
case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
memcpy( params,
|
|
c->transforms.modelview.top().elements(),
|
|
16*sizeof(GLint));
|
|
break;
|
|
case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
memcpy( params,
|
|
c->transforms.projection.top().elements(),
|
|
16*sizeof(GLint));
|
|
break;
|
|
case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
|
|
memcpy( params,
|
|
c->transforms.texture[c->textures.active].top().elements(),
|
|
16*sizeof(GLint));
|
|
break;
|
|
|
|
default:
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void glPointSize(GLfloat size)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (size <= 0) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
c->point.size = TRI_FROM_FIXED(gglFloatToFixed(size));
|
|
}
|
|
|
|
void glPointSizex(GLfixed size)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (size <= 0) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
c->point.size = TRI_FROM_FIXED(size);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void glLineWidth(GLfloat width)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (width <= 0) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
c->line.width = TRI_FROM_FIXED(gglFloatToFixed(width));
|
|
}
|
|
|
|
void glLineWidthx(GLfixed width)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
if (width <= 0) {
|
|
ogles_error(c, GL_INVALID_ENUM);
|
|
return;
|
|
}
|
|
c->line.width = TRI_FROM_FIXED(width);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void glColorMask(GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.colorMask(c, r, g, b, a);
|
|
}
|
|
|
|
void glDepthMask(GLboolean flag) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.depthMask(c, flag);
|
|
}
|
|
|
|
void glStencilMask(GLuint mask) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.stencilMask(c, mask);
|
|
}
|
|
|
|
void glDepthFunc(GLenum func) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.depthFunc(c, func);
|
|
}
|
|
|
|
void glLogicOp(GLenum opcode) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.logicOp(c, opcode);
|
|
}
|
|
|
|
void glAlphaFuncx(GLenum func, GLclampx ref) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.alphaFuncx(c, func, ref);
|
|
}
|
|
|
|
void glBlendFunc(GLenum sfactor, GLenum dfactor) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.blendFunc(c, sfactor, dfactor);
|
|
}
|
|
|
|
void glClear(GLbitfield mask) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.clear(c, mask);
|
|
}
|
|
|
|
void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.clearColorx(c, red, green, blue, alpha);
|
|
}
|
|
|
|
void glClearColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.clearColorx(c,
|
|
gglFloatToFixed(r),
|
|
gglFloatToFixed(g),
|
|
gglFloatToFixed(b),
|
|
gglFloatToFixed(a));
|
|
}
|
|
|
|
void glClearDepthx(GLclampx depth) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.clearDepthx(c, depth);
|
|
}
|
|
|
|
void glClearDepthf(GLclampf depth)
|
|
{
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.clearDepthx(c, gglFloatToFixed(depth));
|
|
}
|
|
|
|
void glClearStencil(GLint s) {
|
|
ogles_context_t* c = ogles_context_t::get();
|
|
c->rasterizer.procs.clearStencil(c, s);
|
|
}
|