/opengles/src/Context.cpp
http://ftk.googlecode.com/ · C++ · 1339 lines · 977 code · 298 blank · 64 comment · 78 complexity · 252f6380eda9bdc1e49d67a518fcf459 MD5 · raw file
- // ==========================================================================
- //
- // context.cpp Rendering Context Class for 3D Rendering Library
- //
- // --------------------------------------------------------------------------
- //
- // 08-07-2003 Hans-Martin Will initial version
- //
- // --------------------------------------------------------------------------
- //
- // Copyright (c) 2004, Hans-Martin Will. All rights reserved.
- //
- // Redistribution and use in source and binary forms, with or without
- // modification, are permitted provided that the following conditions are
- // met:
- //
- // * Redistributions of source code must retain the above copyright
- // notice, this list of conditions and the following disclaimer.
- // * Redistributions in binary form must reproduce the above copyright
- // notice, this list of conditions and the following disclaimer in the
- // documentation and/or other materials provided with the distribution.
- //
- // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
- // OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- // THE POSSIBILITY OF SUCH DAMAGE.
- //
- // ==========================================================================
- #include "stdafx.h"
- #include "Context.h"
- #include "Surface.h"
- #include "Rasterizer.h"
- #include "Utils.h"
- using namespace EGL;
- // --------------------------------------------------------------------------
- // Constructor and destructor
- // --------------------------------------------------------------------------
- Context :: Context(const Config & config)
- :
- m_Config(config),
- m_DrawSurface(0),
- m_ReadSurface(0),
- m_LastError(GL_NO_ERROR),
- // transformation matrices
- m_ModelViewMatrixStack(16),
- m_CurrentMatrixStack(&m_ModelViewMatrixStack),
- m_MatrixMode(GL_MODELVIEW),
- m_Scissor(0, 0, config.GetConfigAttrib(EGL_WIDTH), config.GetConfigAttrib(EGL_HEIGHT)),
- m_Viewport(0, 0, config.GetConfigAttrib(EGL_WIDTH), config.GetConfigAttrib(EGL_HEIGHT)),
- m_CurrentPaletteMatrix(0),
- // server flags
- m_ClipPlaneEnabled(0),
- m_LightingEnabled(false),
- m_TwoSidedLightning(false),
- m_LightEnabled(0), // no light on
- m_CullFaceEnabled(false),
- m_DitherEnabled(false),
- m_ReverseFaceOrientation(false),
- m_CullMode(CullModeBack),
- m_ColorMaterialEnabled(false),
- m_NormalizeEnabled(false),
- m_RescaleNormalEnabled(false),
- m_PolygonOffsetFillEnabled(false),
- m_MultiSampleEnabled(false),
- m_SampleAlphaToCoverageEnabled(false),
- m_SampleAlphaToOneEnabled(false),
- m_SampleCoverageEnabled(false),
- m_ScissorTestEnabled(false),
- m_MatrixPaletteEnabled(false),
- m_MatrixModePaletteEnabled(false),
- m_ActiveTexture(0),
- m_ClientActiveTexture(0),
- // point parameters
- m_PointSize(EGL_ONE),
- m_PointSizeMin(EGL_ONE),
- m_PointSizeMax(EGL_ONE), // what is the correct value?
- m_PointFadeThresholdSize(EGL_ONE),
- m_PointSizeAttenuate(false),
- // fog parameters for setup phase
- m_FogMode(FogModeExp),
- m_FogStart(0),
- m_FogEnd(EGL_ONE),
- m_FogGradient(EGL_ONE),
- m_FogGradientShift(0),
- m_FogDensity(EGL_ONE),
- // client flags
- m_VertexArrayEnabled(false),
- m_NormalArrayEnabled(false),
- m_ColorArrayEnabled(false),
- m_PointSizeArrayEnabled(false),
- // buffers
- m_CurrentArrayBuffer(0),
- m_CurrentElementArrayBuffer(0),
- // general context state
- m_Current(false),
- m_Disposed(false),
- m_ViewportInitialized(false),
- m_DefaultNormal(0, 0, EGL_ONE),
- m_DefaultRGBA(EGL_ONE, EGL_ONE, EGL_ONE, EGL_ONE),
- // pixel store state
- m_PixelStorePackAlignment(4),
- m_PixelStoreUnpackAlignment(4),
- // SGIS_generate_mipmap extension
- m_GenerateMipmaps(false),
- // hints
- m_PerspectiveCorrectionHint(GL_DONT_CARE),
- m_PointSmoothHint(GL_DONT_CARE),
- m_LineSmoothHint(GL_DONT_CARE),
- m_FogHint(GL_DONT_CARE),
- m_GenerateMipmapHint(GL_DONT_CARE)
- {
- DepthRangex(VIEWPORT_NEAR, VIEWPORT_FAR);
- ClearDepthx(EGL_ONE);
- ClearStencil(0);
- m_Rasterizer = new Rasterizer(GetRasterizerState());
- m_Buffers.Allocate(); // default buffer
- m_LightModelAmbient.r = m_LightModelAmbient.g = m_LightModelAmbient.b = F(0.2f);
- m_LightModelAmbient.a = F(1.0);
- m_Lights[0].SetDiffuseColor(FractionalColor(F(1.0), F(1.0), F(1.0), F(1.0)));
- m_Lights[0].SetSpecularColor(FractionalColor(F(1.0), F(1.0), F(1.0), F(1.0)));
- m_PointDistanceAttenuation[0] = EGL_ONE;
- m_PointDistanceAttenuation[1] = 0;
- m_PointDistanceAttenuation[2] = 0;
- size_t defaultTexture = m_Textures.Allocate();
- for (size_t unit = 0; unit < EGL_NUM_TEXTURE_UNITS; ++unit) {
- m_TexCoordArrayEnabled[unit] = false;
- m_Rasterizer->SetTexture(unit, m_Textures.GetObject(defaultTexture));
- }
- memset(&m_ClipPlanes, 0, sizeof(m_ClipPlanes));
- }
- Context :: ~Context() {
- if (m_DrawSurface != 0) {
- m_DrawSurface->SetCurrentContext(0);
- }
- if (m_ReadSurface != 0 && m_ReadSurface != m_DrawSurface) {
- m_ReadSurface->SetCurrentContext(0);
- }
- m_ReadSurface = m_DrawSurface = 0;
- if (m_Rasterizer != 0) {
- delete m_Rasterizer;
- m_Rasterizer = 0;
- }
- }
- void Context :: SetReadSurface(EGL::Surface * surface) {
- if (m_ReadSurface != 0 && m_ReadSurface != m_DrawSurface && m_ReadSurface != surface) {
- m_ReadSurface->SetCurrentContext(0);
- }
- m_ReadSurface = surface;
- m_ReadSurface->SetCurrentContext(this);
- }
- void Context :: SetDrawSurface(EGL::Surface * surface) {
- if (m_DrawSurface != 0 && m_ReadSurface != m_DrawSurface && m_DrawSurface != surface) {
- m_DrawSurface->SetCurrentContext(0);
- }
- if (surface != 0 && !m_ViewportInitialized) {
- U16 width = surface->GetWidth();
- U16 height = surface->GetHeight();
- Viewport(0, 0, width, height);
- Scissor(0, 0, width, height);
- m_ViewportInitialized = true;
- }
- m_DrawSurface = surface;
- m_DrawSurface->SetCurrentContext(this);
- m_Rasterizer->SetSurface(surface);
- UpdateScissorTest();
- }
- void Context :: Dispose() {
- if (m_Current) {
- m_Disposed = true;
- } else {
- delete this;
- }
- }
- void Context :: SetCurrent(bool current) {
- m_Current = current;
- if (!m_Current && m_Disposed) {
- delete this;
- }
- }
- // --------------------------------------------------------------------------
- // Error handling
- // --------------------------------------------------------------------------
- GLenum Context :: GetError(void) {
- GLenum result = m_LastError;
- m_LastError = GL_NO_ERROR;
- return result;
- }
- void Context :: RecordError(GLenum error) {
- if (error != GL_NO_ERROR && m_LastError == GL_NO_ERROR) {
- m_LastError = error;
- }
- }
- // --------------------------------------------------------------------------
- // Clearing
- // --------------------------------------------------------------------------
- void Context :: Clear(GLbitfield mask) {
- if (m_DrawSurface == 0) {
- return;
- }
- if ((mask & (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != mask) {
- RecordError(GL_INVALID_VALUE);
- return;
- }
- if (m_ScissorTestEnabled) {
- if (mask & GL_COLOR_BUFFER_BIT) {
- // is clamping [min, max] or [min, max)
- m_DrawSurface->ClearColorBuffer(m_ColorClearValue,
- m_RasterizerState.GetColorMask(), m_Scissor);
- }
- if (mask & GL_DEPTH_BUFFER_BIT) {
- // actually need to transform depth to correct value
- EGL_Fixed clearValue = EGL_MAP_0_1(m_DepthClearValue);
- m_DrawSurface->ClearDepthBuffer(clearValue, m_RasterizerState.GetDepthMask(), m_Scissor);
- }
- if (mask & GL_STENCIL_BUFFER_BIT) {
- m_DrawSurface->ClearStencilBuffer(m_StencilClearValue, m_RasterizerState.GetStencilMask(), m_Scissor);
- }
- } else {
- if (mask & GL_COLOR_BUFFER_BIT) {
- // is clamping [min, max] or [min, max)
- m_DrawSurface->ClearColorBuffer(m_ColorClearValue, m_RasterizerState.GetColorMask());
- }
- if (mask & GL_DEPTH_BUFFER_BIT) {
- // actually need to transform depth to correct value
- EGL_Fixed clearValue = EGL_MAP_0_1(m_DepthClearValue);
- m_DrawSurface->ClearDepthBuffer(clearValue, m_RasterizerState.GetDepthMask());
- }
- if (mask & GL_STENCIL_BUFFER_BIT) {
- m_DrawSurface->ClearStencilBuffer(m_StencilClearValue, m_RasterizerState.GetStencilMask());
- }
- }
- }
- void Context :: ClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) {
- m_ColorClearValue = FractionalColor(red, green, blue, alpha);
- }
- void Context :: ClearDepthx(GLclampx depth) {
- m_DepthClearValue = EGL_CLAMP(depth, 0, EGL_ONE);
- }
- void Context :: ClearStencil(GLint s) {
- m_StencilClearValue = s;
- }
- // --------------------------------------------------------------------------
- //
- // --------------------------------------------------------------------------
- void Context :: Toggle(GLenum cap, bool value) {
- switch (cap) {
- case GL_LIGHTING:
- m_LightingEnabled = value;
- break;
- case GL_FOG:
- GetRasterizerState()->EnableFog(value);
- break;
- case GL_TEXTURE_2D:
- GetRasterizerState()->EnableTexture(m_ActiveTexture, value);
- break;
- case GL_CULL_FACE:
- m_CullFaceEnabled = value;
- break;
- case GL_ALPHA_TEST:
- GetRasterizerState()->EnableAlphaTest(value);
- break;
- case GL_BLEND:
- GetRasterizerState()->EnableBlending(value);
- break;
- case GL_COLOR_LOGIC_OP:
- GetRasterizerState()->EnableLogicOp(value);
- break;
- case GL_DITHER:
- m_DitherEnabled = value;
- break;
- case GL_STENCIL_TEST:
- GetRasterizerState()->EnableStencilTest(value);
- break;
- case GL_DEPTH_TEST:
- GetRasterizerState()->EnableDepthTest(value);
- break;
- case GL_LIGHT0:
- case GL_LIGHT1:
- case GL_LIGHT2:
- case GL_LIGHT3:
- case GL_LIGHT4:
- case GL_LIGHT5:
- case GL_LIGHT6:
- case GL_LIGHT7:
- {
- int mask = 1 << (cap - GL_LIGHT0);
- if (value) {
- m_LightEnabled |= mask;
- } else {
- m_LightEnabled &= ~mask;
- }
- }
- break;
- case GL_POINT_SMOOTH:
- GetRasterizerState()->SetPointSmoothEnabled(value);
- break;
- case GL_POINT_SPRITE_OES:
- GetRasterizerState()->SetPointSpriteEnabled(value);
- break;
- case GL_LINE_SMOOTH:
- GetRasterizerState()->SetLineSmoothEnabled(value);
- break;
- case GL_SCISSOR_TEST:
- m_ScissorTestEnabled = value;
- UpdateScissorTest();
- break;
- case GL_COLOR_MATERIAL:
- m_ColorMaterialEnabled = value;
- break;
- case GL_NORMALIZE:
- m_NormalizeEnabled = value;
- 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:
- {
- size_t plane = cap - GL_CLIP_PLANE0;
- U32 mask = ~(1u << plane);
- U32 bit = value ? (1u << plane) : 0;
- m_ClipPlaneEnabled = (m_ClipPlaneEnabled & mask) | bit;
- }
- break;
- case GL_RESCALE_NORMAL:
- m_RescaleNormalEnabled = value;
- UpdateInverseModelViewMatrix();
- break;
- case GL_POLYGON_OFFSET_FILL:
- GetRasterizerState()->EnablePolygonOffsetFill(value);
- break;
- case GL_MULTISAMPLE:
- m_MultiSampleEnabled = value;
- break;
- case GL_SAMPLE_ALPHA_TO_COVERAGE:
- m_SampleAlphaToCoverageEnabled = value;
- break;
- case GL_SAMPLE_ALPHA_TO_ONE:
- m_SampleAlphaToOneEnabled = value;
- break;
- case GL_SAMPLE_COVERAGE:
- m_SampleCoverageEnabled = value;
- break;
- case GL_MATRIX_PALETTE_OES:
- m_MatrixPaletteEnabled = value;
- break;
- default:
- RecordError(GL_INVALID_ENUM);
- return;
- }
- }
- void Context :: Disable(GLenum cap) {
- Toggle(cap, false);
- }
- void Context :: Enable(GLenum cap) {
- Toggle(cap, true);
- }
- void Context :: Hint(GLenum target, GLenum mode) {
- if (mode != GL_DONT_CARE && mode != GL_FASTEST && mode != GL_NICEST) {
- RecordError(GL_INVALID_ENUM);
- return;
- }
- switch (target) {
- case GL_FOG_HINT:
- m_FogHint = mode;
- break;
- case GL_LINE_SMOOTH_HINT:
- m_LineSmoothHint = mode;
- break;
- case GL_PERSPECTIVE_CORRECTION_HINT:
- m_PerspectiveCorrectionHint = mode;
- break;
- case GL_POINT_SMOOTH_HINT:
- m_PointSmoothHint = mode;
- break;
- case GL_GENERATE_MIPMAP_HINT:
- m_GenerateMipmapHint = mode;
- break;
- default:
- RecordError(GL_INVALID_ENUM);
- return;
- }
- }
- namespace {
- static const GLenum formats[] = {
- GL_PALETTE4_RGB8_OES,
- GL_PALETTE4_RGBA8_OES,
- GL_PALETTE4_R5_G6_B5_OES,
- GL_PALETTE4_RGBA4_OES,
- GL_PALETTE4_RGB5_A1_OES,
- GL_PALETTE8_RGB8_OES,
- GL_PALETTE8_RGBA8_OES,
- GL_PALETTE8_R5_G6_B5_OES,
- GL_PALETTE8_RGBA4_OES,
- GL_PALETTE8_RGB5_A1_OES
- };
- void CopyRect(const Rect & rect, GLint * params) {
- params[0] = rect.x;
- params[1] = rect.y;
- params[2] = rect.width;
- params[3] = rect.height;
- }
- GLenum EnumFromComparisonFunc(RasterizerState::ComparisonFunc func) {
- switch (func) {
- case RasterizerState::CompFuncNever: return GL_NEVER;
- case RasterizerState::CompFuncLess: return GL_LESS;
- case RasterizerState::CompFuncLEqual: return GL_LEQUAL;
- case RasterizerState::CompFuncGreater: return GL_GREATER;
- case RasterizerState::CompFuncGEqual: return GL_GEQUAL;
- case RasterizerState::CompFuncEqual: return GL_EQUAL;
- case RasterizerState::CompFuncNotEqual: return GL_NOTEQUAL;
- case RasterizerState::CompFuncAlways: return GL_ALWAYS;
- default: return 0;
- }
- }
- GLenum EnumFromStencilOp(RasterizerState::StencilOp op) {
- switch (op) {
- case RasterizerState::StencilOpKeep: return GL_KEEP;
- case RasterizerState::StencilOpZero: return GL_ZERO;
- case RasterizerState::StencilOpReplace: return GL_REPLACE;
- case RasterizerState::StencilOpIncr: return GL_INCR;
- case RasterizerState::StencilOpDecr: return GL_DECR;
- case RasterizerState::StencilOpInvert: return GL_INVERT;
- default: return 0;
- }
- }
- GLenum EnumFromLogicOp(RasterizerState::LogicOp op) {
- switch (op) {
- case RasterizerState::LogicOpClear: return GL_CLEAR;
- case RasterizerState::LogicOpAnd: return GL_AND;
- case RasterizerState::LogicOpAndReverse: return GL_AND_REVERSE;
- case RasterizerState::LogicOpCopy: return GL_COPY;
- case RasterizerState::LogicOpAndInverted: return GL_AND_INVERTED;
- case RasterizerState::LogicOpNoop: return GL_NOOP;
- case RasterizerState::LogicOpXor: return GL_XOR;
- case RasterizerState::LogicOpOr: return GL_OR;
- case RasterizerState::LogicOpNor: return GL_NOR;
- case RasterizerState::LogicOpEquiv: return GL_EQUIV;
- case RasterizerState::LogicOpInvert: return GL_INVERT;
- case RasterizerState::LogicOpOrReverse: return GL_OR_REVERSE;
- case RasterizerState::LogicOpCopyInverted: return GL_COPY_INVERTED;
- case RasterizerState::LogicOpOrInverted: return GL_OR_INVERTED;
- case RasterizerState::LogicOpNand: return GL_NAND;
- case RasterizerState::LogicOpSet: return GL_SET;
- default: return 0;
- }
- }
- GLenum EnumFromBlendFuncSrc(RasterizerState::BlendFuncSrc sfactor) {
- switch (sfactor) {
- case RasterizerState::BlendFuncSrcZero: return GL_ZERO;
- case RasterizerState::BlendFuncSrcOne: return GL_ONE;
- case RasterizerState::BlendFuncSrcDstColor: return GL_DST_COLOR;
- case RasterizerState::BlendFuncSrcOneMinusDstColor: return GL_ONE_MINUS_DST_COLOR;
- case RasterizerState::BlendFuncSrcSrcAlpha: return GL_SRC_ALPHA;
- case RasterizerState::BlendFuncSrcOneMinusSrcAlpha: return GL_ONE_MINUS_SRC_ALPHA;
- case RasterizerState::BlendFuncSrcDstAlpha: return GL_DST_ALPHA;
- case RasterizerState::BlendFuncSrcOneMinusDstAlpha: return GL_ONE_MINUS_DST_ALPHA;
- case RasterizerState::BlendFuncSrcSrcAlphaSaturate: return GL_SRC_ALPHA_SATURATE;
- default: return 0;
- }
- }
- GLenum EnumFromBlendFuncDst(RasterizerState::BlendFuncDst dfactor) {
- switch (dfactor) {
- case RasterizerState::BlendFuncDstZero: return GL_ZERO;
- case RasterizerState::BlendFuncDstSrcColor: return GL_SRC_COLOR;
- case RasterizerState::BlendFuncDstOneMinusSrcColor: return GL_ONE_MINUS_SRC_COLOR;
- case RasterizerState::BlendFuncDstSrcAlpha: return GL_SRC_ALPHA;
- case RasterizerState::BlendFuncDstOneMinusSrcAlpha: return GL_ONE_MINUS_SRC_ALPHA;
- case RasterizerState::BlendFuncDstDstAlpha: return GL_DST_ALPHA;
- case RasterizerState::BlendFuncDstOneMinusDstAlpha: return GL_ONE_MINUS_DST_ALPHA;
- case RasterizerState::BlendFuncDstOne: return GL_ONE;
- default: return 0;
- }
- }
- }
- void Context :: GetIntegerv(GLenum pname, GLint *params) {
- switch (pname) {
- /* 1.0 stuff */
- case GL_SMOOTH_LINE_WIDTH_RANGE:
- case GL_SMOOTH_POINT_SIZE_RANGE:
- case GL_ALIASED_POINT_SIZE_RANGE:
- case GL_ALIASED_LINE_WIDTH_RANGE:
- params[0] = params[1] = 1;
- return;
- case GL_ALPHA_BITS:
- params[0] = m_Config.GetConfigAttrib(EGL_ALPHA_SIZE);
- break;
- case GL_BLUE_BITS:
- params[0] = m_Config.GetConfigAttrib(EGL_BLUE_SIZE);
- break;
- case GL_DEPTH_BITS:
- params[0] = m_Config.GetConfigAttrib(EGL_DEPTH_SIZE);
- break;
- case GL_GREEN_BITS:
- params[0] = m_Config.GetConfigAttrib(EGL_GREEN_SIZE);
- break;
- case GL_RED_BITS:
- params[0] = m_Config.GetConfigAttrib(EGL_RED_SIZE);
- break;
- case GL_STENCIL_BITS:
- params[0] = m_Config.GetConfigAttrib(EGL_STENCIL_SIZE);
- break;
- case GL_SUBPIXEL_BITS:
- params[0] = m_Config.GetConfigAttrib(EGL_SAMPLES);
- break;
- case GL_COMPRESSED_TEXTURE_FORMATS:
- {
- size_t numFormats = sizeof(formats) / sizeof(formats[0]);
- for (size_t index = 0; index < numFormats; ++index)
- params[index] = formats[index];
- }
- break;
- case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
- params[0] = sizeof(formats) / sizeof(formats[0]);
- break;
- case GL_MAX_ELEMENTS_INDICES:
- case GL_MAX_ELEMENTS_VERTICES:
- params[0] = INT_MAX;
- break;
- case GL_MAX_LIGHTS:
- params[0] = EGL_NUMBER_LIGHTS;
- break;
- case GL_MAX_CLIP_PLANES:
- params[0] = NUM_CLIP_PLANES;
- break;
- case GL_MAX_MODELVIEW_STACK_DEPTH:
- params[0] = m_ModelViewMatrixStack.GetStackSize();
- break;
- case GL_MODELVIEW_STACK_DEPTH:
- params[0] = m_ModelViewMatrixStack.GetCurrentStackSize();
- break;
- case GL_MAX_PROJECTION_STACK_DEPTH:
- params[0] = m_ProjectionMatrixStack.GetStackSize();
- break;
- case GL_PROJECTION_STACK_DEPTH:
- params[0] = m_ProjectionMatrixStack.GetCurrentStackSize();
- break;
- case GL_MAX_TEXTURE_STACK_DEPTH:
- params[0] = m_TextureMatrixStack[m_ActiveTexture].GetStackSize();
- break;
- case GL_TEXTURE_STACK_DEPTH:
- params[0] = m_TextureMatrixStack[m_ActiveTexture].GetCurrentStackSize();
- break;
- case GL_MAX_TEXTURE_SIZE:
- params[0] = RasterizerState::MaxTextureSize;
- break;
- case GL_MAX_TEXTURE_UNITS:
- params[0] = EGL_NUM_TEXTURE_UNITS;
- break;
- case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
- params[0] = GL_UNSIGNED_SHORT_5_6_5;
- break;
- case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
- params[0] = GL_RGB;
- break;
- case GL_MAX_VIEWPORT_DIMS:
- params[0] = m_Config.m_Width;
- params[1] = m_Config.m_Height;
- break;
- case GL_MAX_PALETTE_MATRICES_OES:
- case GL_MAX_VERTEX_UNITS_OES:
- params[0] = MATRIX_PALETTE_SIZE;
- break;
- // params[0] = EGL_NUM_TEXTURE_UNITS;
- // break;
- case GL_VERTEX_ARRAY_SIZE:
- params[0] = m_VertexArray.size;
- break;
- case GL_VERTEX_ARRAY_STRIDE:
- params[0] = m_VertexArray.stride;
- break;
- case GL_VERTEX_ARRAY_TYPE:
- params[0] = m_VertexArray.type;
- break;
- case GL_NORMAL_ARRAY_STRIDE:
- params[0] = m_NormalArray.stride;
- break;
- case GL_NORMAL_ARRAY_TYPE:
- params[0] = m_NormalArray.type;
- break;
- case GL_COLOR_ARRAY_SIZE:
- params[0] = m_ColorArray.size;
- break;
- case GL_COLOR_ARRAY_STRIDE:
- params[0] = m_ColorArray.stride;
- break;
- case GL_COLOR_ARRAY_TYPE:
- params[0] = m_ColorArray.type;
- break;
- case GL_TEXTURE_COORD_ARRAY_SIZE:
- params[0] = m_TexCoordArray[m_ClientActiveTexture].size;
- break;
- case GL_TEXTURE_COORD_ARRAY_STRIDE:
- params[0] = m_TexCoordArray[m_ClientActiveTexture].stride;
- break;
- case GL_TEXTURE_COORD_ARRAY_TYPE:
- params[0] = m_TexCoordArray[m_ClientActiveTexture].type;
- break;
- case GL_MATRIX_INDEX_ARRAY_SIZE_OES:
- params[0] = m_MatrixIndexArray.size;
- break;
- case GL_MATRIX_INDEX_ARRAY_TYPE_OES:
- params[0] = m_MatrixIndexArray.type;
- break;
- case GL_MATRIX_INDEX_ARRAY_STRIDE_OES:
- params[0] = m_MatrixIndexArray.stride;
- break;
- case GL_WEIGHT_ARRAY_SIZE_OES:
- params[0] = m_WeightArray.size;
- break;
- case GL_WEIGHT_ARRAY_TYPE_OES:
- params[0] = m_WeightArray.type;
- break;
- case GL_WEIGHT_ARRAY_STRIDE_OES:
- params[0] = m_WeightArray.stride;
- break;
- case GL_POINT_SIZE_ARRAY_TYPE_OES:
- params[0] = m_PointSizeArray.type;
- break;
- case GL_POINT_SIZE_ARRAY_STRIDE_OES:
- params[0] = m_PointSizeArray.stride;
- break;
- case GL_VERTEX_ARRAY_BUFFER_BINDING:
- params[0] = m_VertexArray.boundBuffer;
- break;
- case GL_NORMAL_ARRAY_BUFFER_BINDING:
- params[0] = m_NormalArray.boundBuffer;
- break;
- case GL_COLOR_ARRAY_BUFFER_BINDING:
- params[0] = m_ColorArray.boundBuffer;
- break;
- case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
- params[0] = m_TexCoordArray[m_ClientActiveTexture].boundBuffer;
- break;
- case GL_ELEMENT_ARRAY_BUFFER_BINDING:
- params[0] = m_CurrentElementArrayBuffer;
- break;
- case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
- params[0] = m_PointSizeArray.boundBuffer;
- break;
- case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES:
- params[0] = m_MatrixIndexArray.boundBuffer;
- break;
- case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES:
- params[0] = m_WeightArray.boundBuffer;
- break;
- case GL_ARRAY_BUFFER_BINDING:
- params[0] = m_CurrentArrayBuffer;
- break;
- case GL_UNPACK_ALIGNMENT:
- params[0] = m_PixelStoreUnpackAlignment;
- break;
- case GL_PACK_ALIGNMENT:
- params[0] = m_PixelStorePackAlignment;
- break;
- case GL_STENCIL_CLEAR_VALUE:
- params[0] = m_StencilClearValue;
- break;
- case GL_DEPTH_CLEAR_VALUE:
- params[0] = EGL_Mul(0x7fffffff, m_DepthClearValue);
- break;
- case GL_SCISSOR_BOX:
- CopyRect(m_Scissor, params);
- break;
- case GL_SAMPLE_BUFFERS:
- params[0] = m_Config.m_SampleBuffers;
- break;
- case GL_SAMPLES:
- params[0] = m_Config.m_Samples;
- break;
- case GL_VIEWPORT:
- CopyRect(m_Viewport, params);
- break;
- case GL_STENCIL_WRITEMASK:
- params[0] = m_RasterizerState.GetStencilMask();
- break;
- case GL_STENCIL_VALUE_MASK:
- params[0] = m_RasterizerState.GetStencilComparisonMask();
- break;
- case GL_STENCIL_REF:
- params[0] = m_RasterizerState.GetStencilRef();
- break;
- case GL_ALPHA_TEST_REF:
- params[0] = EGL_Mul(0x7fffffff, m_RasterizerState.GetAlphaRef());
- break;
- case GL_ALPHA_TEST_FUNC:
- params[0] = EnumFromComparisonFunc(m_RasterizerState.GetAlphaFunc());
- break;
- case GL_STENCIL_FUNC:
- params[0] = EnumFromComparisonFunc(m_RasterizerState.GetStencilFunc());
- break;
- case GL_STENCIL_FAIL:
- params[0] = EnumFromStencilOp(m_RasterizerState.GetStencilOpFail());
- break;
- case GL_STENCIL_PASS_DEPTH_FAIL:
- params[0] = EnumFromStencilOp(m_RasterizerState.GetStencilOpFailZFail());
- break;
- case GL_STENCIL_PASS_DEPTH_PASS:
- params[0] = EnumFromStencilOp(m_RasterizerState.GetStencilOpFailZPass());
- break;
- case GL_DEPTH_FUNC:
- params[0] = EnumFromComparisonFunc(m_RasterizerState.GetDepthFunc());
- break;
- case GL_LOGIC_OP_MODE:
- params[0] = EnumFromLogicOp(m_RasterizerState.GetLogicOp());
- break;
- case GL_BLEND_SRC:
- params[0] = EnumFromBlendFuncSrc(m_RasterizerState.GetBlendFuncSrc());
- break;
- case GL_BLEND_DST:
- params[0] = EnumFromBlendFuncDst(m_RasterizerState.GetBlendFuncDst());
- break;
- case GL_FOG_MODE:
- {
- switch (m_FogMode) {
- case FogLinear: params[0] = GL_LINEAR; break;
- case FogModeExp: params[0] = GL_EXP; break;
- case FogModeExp2: params[0] = GL_EXP2; break;
- }
- }
- break;
- case GL_SHADE_MODEL:
- {
- switch (m_RasterizerState.GetShadeModel()) {
- case RasterizerState::ShadeModelFlat: params[0] = GL_FLAT;
- case RasterizerState::ShadeModelSmooth: params[0] = GL_SMOOTH;
- }
- }
- break;
- case GL_CULL_FACE_MODE:
- {
- switch (m_CullMode) {
- case CullModeFront: params[0] = GL_FRONT; break;
- case CullModeBack: params[0] = GL_BACK; break;
- case CullModeBackAndFront: params[0] = GL_FRONT_AND_BACK; break;
- }
- }
- break;
- case GL_FRONT_FACE:
- params[0] = m_ReverseFaceOrientation ? GL_CW : GL_CCW;
- break;
- case GL_MATRIX_MODE:
- params[0] = m_MatrixMode;
- break;
- case GL_ACTIVE_TEXTURE:
- params[0] = GL_TEXTURE0 + m_ActiveTexture;
- break;
- case GL_CLIENT_ACTIVE_TEXTURE:
- params[0] = GL_TEXTURE0 + m_ClientActiveTexture;
- break;
- case GL_TEXTURE_BINDING_2D:
- {
- size_t index = m_Textures.GetIndex(m_Rasterizer->GetTexture(m_ActiveTexture));
- if (index == ~0) {
- params[0] = 0;
- } else {
- params[0] = index;
- }
- }
- break;
- case GL_COORD_REPLACE_OES:
- params[0] = m_RasterizerState.IsPointCoordReplaceEnabled(m_ActiveTexture);
- break;
- case GL_CURRENT_COLOR:
- {
- params[0] = EGL_Mul(0x7fffffff, m_DefaultRGBA.r);
- params[1] = EGL_Mul(0x7fffffff, m_DefaultRGBA.g);
- params[2] = EGL_Mul(0x7fffffff, m_DefaultRGBA.b);
- params[3] = EGL_Mul(0x7fffffff, m_DefaultRGBA.a);
- }
- break;
- case GL_PERSPECTIVE_CORRECTION_HINT:
- params[0] = m_PerspectiveCorrectionHint;
- break;
- case GL_POINT_SMOOTH_HINT:
- params[0] = m_PointSmoothHint;
- break;
- case GL_LINE_SMOOTH_HINT:
- params[0] = m_LineSmoothHint;
- break;
- case GL_FOG_HINT:
- params[0] = m_FogHint;
- break;
- case GL_GENERATE_MIPMAP_HINT:
- params[0] = m_GenerateMipmapHint;
- break;
- default:
- RecordError(GL_INVALID_ENUM);
- }
- }
- const GLubyte * Context :: GetString(GLenum name) {
- switch (name) {
- case GL_VENDOR:
- return (GLubyte *) EGL_CONFIG_VENDOR;
- case GL_VERSION:
- return (GLubyte *) EGL_CONFIG_VERSION;
- case GL_RENDERER:
- return (GLubyte *) EGL_CONFIG_RENDERER;
- case GL_EXTENSIONS:
- return (GLubyte *) EGL_CONFIG_EXTENSIONS;
- default:
- RecordError(GL_INVALID_ENUM);
- return 0;
- }
- }
- void Context :: Finish(void) { }
- void Context :: Flush(void) { }
- void Context :: GetBooleanv(GLenum pname, GLboolean *params) {
- switch (pname) {
- case GL_LIGHT_MODEL_TWO_SIDE:
- params[0] = m_TwoSidedLightning;
- break;
- case GL_COLOR_WRITEMASK:
- {
- Color mask = m_RasterizerState.GetColorMask();
- params[0] = mask.R() != 0;
- params[1] = mask.G() != 0;
- params[2] = mask.B() != 0;
- params[3] = mask.A() != 0;
- }
- break;
- case GL_DEPTH_WRITEMASK:
- params[0] = m_RasterizerState.GetDepthMask();
- break;
- case GL_SAMPLE_COVERAGE_INVERT:
- params[0] = m_RasterizerState.GetSampleCoverageInvert();
- break;
- default:
- RecordError(GL_INVALID_ENUM);
- return;
- }
- }
- bool Context :: GetFixedv(GLenum pname, GLfixed *params) {
- switch (pname) {
- case GL_CURRENT_COLOR:
- CopyColor(m_DefaultRGBA, params);
- break;
- case GL_CURRENT_TEXTURE_COORDS:
- CopyVector(m_DefaultTextureCoords[m_ActiveTexture], params);
- break;
- case GL_CURRENT_NORMAL:
- params[0] = m_DefaultNormal.x();
- params[1] = m_DefaultNormal.y();
- params[2] = m_DefaultNormal.z();
- break;
- case GL_MODELVIEW_MATRIX:
- CopyMatrix(m_ModelViewMatrixStack.CurrentMatrix(), params);
- break;
- case GL_PROJECTION_MATRIX:
- CopyMatrix(m_ProjectionMatrixStack.CurrentMatrix(), params);
- break;
- case GL_TEXTURE_MATRIX:
- CopyMatrix(m_TextureMatrixStack[m_ActiveTexture].CurrentMatrix(), params);
- break;
- case GL_FOG_COLOR:
- CopyColor(m_RasterizerState.GetFogColor(), params);
- break;
- case GL_FOG_DENSITY:
- params[0] = m_FogDensity;
- break;
- case GL_FOG_START:
- params[0] = m_FogStart;
- break;
- case GL_FOG_END:
- params[0] = m_FogEnd;
- break;
- case GL_LIGHT_MODEL_AMBIENT:
- CopyColor(m_LightModelAmbient, params);
- break;
- case GL_COLOR_CLEAR_VALUE:
- CopyColor(m_ColorClearValue, params);
- break;
- case GL_ALIASED_LINE_WIDTH_RANGE:
- case GL_ALIASED_POINT_SIZE_RANGE:
- case GL_SMOOTH_LINE_WIDTH_RANGE:
- case GL_SMOOTH_POINT_SIZE_RANGE:
- params[0] = params[1] = EGL_ONE;
- break;
- case GL_POLYGON_OFFSET_UNITS:
- params[0] = m_RasterizerState.GetPolygonOffsetUnits();
- break;
- case GL_POLYGON_OFFSET_FACTOR:
- params[0] = m_RasterizerState.GetPolygonOffsetFactor();
- break;
- case GL_SAMPLE_COVERAGE_VALUE:
- params[0] = m_RasterizerState.GetSampleCoverage();
- break;
- case GL_POINT_SIZE_MIN:
- params[0] = m_PointSizeMin;
- break;
- case GL_POINT_SIZE_MAX:
- params[0] = m_PointSizeMax;
- break;
- case GL_POINT_FADE_THRESHOLD_SIZE:
- params[0] = m_PointFadeThresholdSize;
- break;
- case GL_POINT_DISTANCE_ATTENUATION:
- params[0] = m_PointDistanceAttenuation[0];
- params[1] = m_PointDistanceAttenuation[1];
- params[2] = m_PointDistanceAttenuation[2];
- break;
- case GL_DEPTH_RANGE:
- params[0] = m_DepthRangeNear;
- params[1] = m_DepthRangeFar;
- break;
- case GL_POINT_SIZE:
- case GL_LINE_WIDTH:
- params[0] = EGL_ONE;
- break;
- default:
- RecordError(GL_INVALID_ENUM);
- return false;
- }
- return true;
- }
- void Context :: GetPointerv(GLenum pname, void **params) {
- switch (pname) {
- case GL_VERTEX_ARRAY_POINTER:
- params[0] = const_cast<void *>(m_VertexArray.pointer);
- break;
- case GL_NORMAL_ARRAY_POINTER:
- params[0] = const_cast<void *>(m_NormalArray.pointer);
- break;
- case GL_COLOR_ARRAY_POINTER:
- params[0] = const_cast<void *>(m_ColorArray.pointer);
- break;
- case GL_TEXTURE_COORD_ARRAY_POINTER:
- params[0] = const_cast<void *>(m_TexCoordArray[m_ClientActiveTexture].pointer);
- break;
- case GL_MATRIX_INDEX_ARRAY_POINTER_OES:
- params[0] = const_cast<void *>(m_MatrixIndexArray.pointer);
- break;
- case GL_WEIGHT_ARRAY_POINTER_OES:
- params[0] = const_cast<void *>(m_WeightArray.pointer);
- break;
- case GL_POINT_SIZE_ARRAY_POINTER_OES:
- params[0] = const_cast<void *>(m_PointSizeArray.pointer);
- break;
- default:
- RecordError(GL_INVALID_ENUM);
- break;
- }
- }
- GLboolean Context :: IsEnabled(GLenum cap) {
- switch (cap) {
- case GL_VERTEX_ARRAY:
- return m_VertexArrayEnabled;
- case GL_NORMAL_ARRAY:
- return m_NormalArrayEnabled;
- case GL_COLOR_ARRAY:
- return m_ColorArrayEnabled;
- case GL_TEXTURE_COORD_ARRAY:
- return m_TexCoordArrayEnabled[m_ClientActiveTexture];
- case GL_MATRIX_INDEX_ARRAY_OES:
- return m_MatrixIndexArrayEnabled;
- case GL_WEIGHT_ARRAY_OES:
- return m_WeightArrayEnabled;
- case GL_POINT_SIZE_ARRAY_OES:
- return m_PointSizeArrayEnabled;
- case GL_NORMALIZE:
- return m_NormalizeEnabled;
- case GL_RESCALE_NORMAL:
- return m_RescaleNormalEnabled;
- case GL_LIGHT0:
- case GL_LIGHT1:
- case GL_LIGHT2:
- case GL_LIGHT3:
- case GL_LIGHT4:
- case GL_LIGHT5:
- case GL_LIGHT6:
- case GL_LIGHT7:
- {
- int mask = 1 << (cap - GL_LIGHT0);
- return (m_LightEnabled & mask) != 0;
- }
- case GL_CLIP_PLANE0:
- case GL_CLIP_PLANE1:
- case GL_CLIP_PLANE2:
- case GL_CLIP_PLANE3:
- case GL_CLIP_PLANE4:
- case GL_CLIP_PLANE5:
- {
- U32 bit = 1u << (cap - GL_CLIP_PLANE0);
- return (m_ClipPlaneEnabled & bit) != 0;
- }
- break;
- case GL_FOG:
- return m_RasterizerState.IsEnabledFog();
- case GL_LIGHTING:
- return m_LightingEnabled;
- case GL_COLOR_MATERIAL:
- return m_ColorMaterialEnabled;
- case GL_POINT_SMOOTH:
- return m_RasterizerState.IsPointSmoothEnabled();
- case GL_LINE_SMOOTH:
- return m_RasterizerState.IsLineSmoothEnabled();
- case GL_CULL_FACE:
- return m_CullFaceEnabled;
- case GL_POLYGON_OFFSET_FILL:
- return m_RasterizerState.IsEnabledPolygonOffsetFill();
- case GL_SCISSOR_TEST:
- return m_ScissorTestEnabled;
- case GL_ALPHA_TEST:
- return m_RasterizerState.IsEnabledAlphaTest();
- case GL_STENCIL_TEST:
- return m_RasterizerState.IsEnabledStencilTest();
- case GL_DEPTH_TEST:
- return m_RasterizerState.IsEnabledDepthTest();
- case GL_BLEND:
- return m_RasterizerState.IsEnabledBlending();
- case GL_COLOR_LOGIC_OP:
- return m_RasterizerState.IsEnabledLogicOp();
- case GL_TEXTURE_2D:
- return m_RasterizerState.IsEnabledTexture(m_ActiveTexture);
- case GL_MATRIX_PALETTE_OES:
- return m_MatrixPaletteEnabled;
- case GL_POINT_SPRITE_OES:
- return m_RasterizerState.IsPointSpriteEnabled();
- case GL_MULTISAMPLE:
- return m_MultiSampleEnabled;
- case GL_SAMPLE_ALPHA_TO_COVERAGE:
- return m_SampleAlphaToCoverageEnabled;
- case GL_SAMPLE_ALPHA_TO_ONE:
- return m_SampleAlphaToOneEnabled;
- case GL_SAMPLE_COVERAGE:
- return m_SampleCoverageEnabled;
- case GL_DITHER:
- return m_DitherEnabled;
- default:
- RecordError(GL_INVALID_ENUM);
- return false;
- }
- }