/* 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 #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" #include #ifdef LIBAGL_USE_GRALLOC_COPYBITS #include #endif // LIBAGL_USE_GRALLOC_COPYBITS namespace android { // ---------------------------------------------------------------------------- static char const * const gVendorString = "Android"; static char const * const gRendererString = "Android PixelFlinger 1.4"; 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 #ifdef GL_OES_compressed_ETC1_RGB8_texture "GL_OES_compressed_ETC1_RGB8_texture " // OK #endif "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 smgr(new EGLSurfaceManager()); c->surfaceManager = smgr.get(); c->surfaceManager->incStrong(c); sp 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 char property[PROPERTY_VALUE_MAX]; if (property_get("debug.sf.hw", property, NULL) > 0) { if (atoi(property) == 0) { // We are using software composition. Do not open copybit return c; } } 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) && (caplighting.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) { int i; 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; i = 10; #ifdef GL_OES_compressed_ETC1_RGB8_texture params[i++] = GL_ETC1_RGB8_OES; #endif 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); }