/*
 * $Id$
 *
 * $Date$
 * $Revision$
 *
 * (C) 1999 by Hyperion
 * All rights reserved
 *
 * This file is part of the MiniGL library project
 * See the file Licence.txt for more details
 *
 */


#ifdef _IS_ENABLED_ONLY
GLboolean GET_FUNCNAME()(struct GLContextIFace *Self, GLenum value)
{
	GLboolean result = GL_FALSE;
	GLboolean *data  = &result;
#else
void GET_FUNCNAME()(struct GLContextIFace *Self, GLenum value, GET_TYPE *data)
{
#endif

	GLcontext context = GET_INSTANCE(Self);
	uint32 tmu = context->texture.ActiveTexture;
	uint32 ctmu = context->vertex_array.ClientActiveTexture;
	Matrix *m;

	switch (value) {
		case GL_CURRENT_COLOR:
			*data ++ = FROM_COLOR(context->current.CurrentColor.r);
			*data ++ = FROM_COLOR(context->current.CurrentColor.g);
			*data ++ = FROM_COLOR(context->current.CurrentColor.b);
			*data ++ = FROM_COLOR(context->current.CurrentColor.a);
			break;

		case GL_CURRENT_SECONDARY_COLOR:
			break;                          /* FIXME */

		case GL_CURRENT_INDEX:
			break;                          /* FIXME */

		case GL_CURRENT_TEXTURE_COORDS:
			*data ++ = FROM_FLOAT(context->current.CurTexS[tmu]);
			*data ++ = FROM_FLOAT(context->current.CurTexT[tmu]);
			*data ++ = FROM_FLOAT(0.0);                     /* Always 0 */
			if (context->current.CurTexQValid[tmu]) {
				*data ++ = FROM_FLOAT(context->current.CurTexQ[tmu]);
			}
			else {
				*data ++ = FROM_FLOAT(1.0);
			}
			break;

		case GL_CURRENT_NORMAL:
			*data ++ = FROM_FLOAT(context->current.CurrentNormal.x);
			*data ++ = FROM_FLOAT(context->current.CurrentNormal.y);
			*data ++ = FROM_FLOAT(context->current.CurrentNormal.z);
			break;

		case GL_CURRENT_FOG_COORD:
			*data ++ = FROM_FLOAT(context->current.CurrentFogDepth);
			break;

		case GL_CURRENT_RASTER_POSITION:
			*data ++ = FROM_FLOAT(context->current.RasterPos.x);
			*data ++ = FROM_FLOAT(context->current.RasterPos.y);
			*data ++ = FROM_FLOAT(context->current.RasterPos.z);
			*data ++ = FROM_FLOAT(context->current.RasterPos.w);
			break;

		case GL_CURRENT_RASTER_DISTANCE:
			*data ++ = FROM_FLOAT(context->current.RasterDistance);
			break;

		case GL_CURRENT_RASTER_COLOR:
			*data ++ = FROM_COLOR(context->current.RasterColor.r);
			*data ++ = FROM_COLOR(context->current.RasterColor.g);
			*data ++ = FROM_COLOR(context->current.RasterColor.b);
			*data ++ = FROM_COLOR(context->current.RasterColor.a);
			break;

		case GL_CURRENT_RASTER_INDEX:
			break;                  /* FIXME */

		case GL_CURRENT_RASTER_TEXTURE_COORDS:
			*data ++ = FROM_FLOAT(context->current.RasterTexCoords[tmu].u);
			*data ++ = FROM_FLOAT(context->current.RasterTexCoords[tmu].v);
			*data ++ = FROM_FLOAT(0.0);                     /* Always 0 */
			*data ++ = FROM_FLOAT(context->current.RasterTexCoords[tmu].w);
			break;

		case GL_CURRENT_RASTER_POSITION_VALID:
			*data ++ = FROM_BOOL(context->current.RasterPosValid);
			break;

		case GL_EDGE_FLAG:
			break;                  /* FIXME */

		case GL_CLIENT_ACTIVE_TEXTURE:
			*data ++ = FROM_INT(context->vertex_array.ClientActiveTexture);
			break;

		case GL_VERTEX_ARRAY:
			*data ++ = FROM_BOOL(context->vertex_array.ClientState & GLCS_VERTEX ? GL_TRUE : GL_FALSE);
			break;

		case GL_VERTEX_ARRAY_SIZE:
			*data ++ = FROM_INT(context->vertex_array.VertexArray.size);
			break;

		case GL_VERTEX_ARRAY_TYPE:
			*data ++ = FROM_INT(context->vertex_array.VertexArray.type);
			break;

		case GL_VERTEX_ARRAY_STRIDE:
			*data ++ = FROM_INT(context->vertex_array.VertexArray.stride);
			break;

		case GL_VERTEX_ARRAY_POINTER:
			*data ++ = FROM_INT((GLint)context->vertex_array.VertexArray.pointer);
			break;

		case GL_NORMAL_ARRAY:
			*data ++ = FROM_BOOL(context->vertex_array.ClientState & GLCS_NORMAL ? GL_TRUE : GL_FALSE);
			break;

		case GL_NORMAL_ARRAY_TYPE:
			*data ++ = FROM_INT(context->vertex_array.NormalArray.type);
			break;

		case GL_NORMAL_ARRAY_STRIDE:
			*data ++ = FROM_INT(context->vertex_array.NormalArray.stride);
			break;

		case GL_NORMAL_ARRAY_POINTER:
			*data ++ = FROM_INT((GLint)context->vertex_array.NormalArray.pointer);
			break;

		case GL_FOG_COORD_ARRAY:
		case GL_FOG_COORD_ARRAY_TYPE:
		case GL_FOG_COORD_ARRAY_STRIDE:
		case GL_FOG_COORD_ARRAY_POINTER:
			*data ++ = FROM_BOOL(GL_FALSE);
			break;                  /* FIXME */

		case GL_COLOR_ARRAY:
			*data ++ = FROM_BOOL(context->vertex_array.ClientState & GLCS_COLOR ? GL_TRUE : GL_FALSE);
			break;

		case GL_COLOR_ARRAY_SIZE:
			*data ++ = FROM_INT(context->vertex_array.ColorArray.size);
			break;

		case GL_COLOR_ARRAY_TYPE:
			*data ++ = FROM_INT(context->vertex_array.ColorArray.type);
			break;

		case GL_COLOR_ARRAY_STRIDE:
			*data ++ = FROM_INT(context->vertex_array.ColorArray.stride);
			break;

		case GL_COLOR_ARRAY_POINTER:
			*data ++ = FROM_INT((GLint)context->vertex_array.ColorArray.pointer);
			break;

		case GL_LIST_BASE:
			*data ++ = FROM_INT((GLint)context->DisplayListBaseOffset);
			break;
		case GL_MAX_LIST_NESTING:
			*data ++ = FROM_INT(context->MaxDisplayListNesting);
			break;
		case GL_SECONDARY_COLOR_ARRAY:
		case GL_SECONDARY_COLOR_ARRAY_SIZE:
		case GL_SECONDARY_COLOR_ARRAY_TYPE:
		case GL_SECONDARY_COLOR_ARRAY_STRIDE:
		case GL_SECONDARY_COLOR_ARRAY_POINTER:
			*data ++ = FROM_BOOL(GL_FALSE);
			break;                          /* FIXME */

		case GL_INDEX_ARRAY:
		case GL_INDEX_ARRAY_TYPE:
		case GL_INDEX_ARRAY_STRIDE:
		case GL_INDEX_ARRAY_POINTER:
			*data ++ = FROM_BOOL(GL_FALSE);
			break;                          /* FIXME */

		case GL_TEXTURE_COORD_ARRAY:
			*data ++ = FROM_BOOL(
				(context->vertex_array.ClientState
					& client_texture_state[ctmu])
					? GL_TRUE : GL_FALSE
				);
			break;

		case GL_TEXTURE_COORD_ARRAY_SIZE:
			*data ++ = FROM_INT(context->vertex_array.TexCoordArray[tmu].size);
			break;

		case GL_TEXTURE_COORD_ARRAY_TYPE:
			*data ++ = FROM_INT(context->vertex_array.TexCoordArray[tmu].type);
			break;

		case GL_TEXTURE_COORD_ARRAY_STRIDE:
			*data ++ = FROM_INT(context->vertex_array.TexCoordArray[tmu].stride);
			break;

		case GL_TEXTURE_COORD_ARRAY_POINTER:
			*data ++ = FROM_INT((GLint)context->vertex_array.TexCoordArray[tmu].pointer);
			break;

		case GL_EDGE_FLAG_ARRAY:
		case GL_EDGE_FLAG_ARRAY_STRIDE:
		case GL_EDGE_FLAG_ARRAY_POINTER:
			*data ++ = FROM_BOOL(GL_FALSE);
			break;                          /* FIXME */

		case GL_SELECTION_BUFFER_POINTER:
			*data ++ = FROM_INT((GLint)context->selectionBuffer);

		case GL_MODELVIEW_MATRIX:
			m = CurrentMV; //&context->ModelView[context->ModelViewNr];
			*data ++ = FROM_FLOAT(m->v[OF_11]);
			*data ++ = FROM_FLOAT(m->v[OF_21]);
			*data ++ = FROM_FLOAT(m->v[OF_31]);
			*data ++ = FROM_FLOAT(m->v[OF_41]);
			*data ++ = FROM_FLOAT(m->v[OF_12]);
			*data ++ = FROM_FLOAT(m->v[OF_22]);
			*data ++ = FROM_FLOAT(m->v[OF_32]);
			*data ++ = FROM_FLOAT(m->v[OF_42]);
			*data ++ = FROM_FLOAT(m->v[OF_13]);
			*data ++ = FROM_FLOAT(m->v[OF_23]);
			*data ++ = FROM_FLOAT(m->v[OF_33]);
			*data ++ = FROM_FLOAT(m->v[OF_43]);
			*data ++ = FROM_FLOAT(m->v[OF_14]);
			*data ++ = FROM_FLOAT(m->v[OF_24]);
			*data ++ = FROM_FLOAT(m->v[OF_34]);
			*data ++ = FROM_FLOAT(m->v[OF_44]);
			break;

		case GL_TRANSPOSE_MODELVIEW_MATRIX:
			m = CurrentMV; //&context->ModelView[context->ModelViewNr];
			*data ++ = FROM_FLOAT(m->v[OF_11]);
			*data ++ = FROM_FLOAT(m->v[OF_12]);
			*data ++ = FROM_FLOAT(m->v[OF_13]);
			*data ++ = FROM_FLOAT(m->v[OF_14]);
			*data ++ = FROM_FLOAT(m->v[OF_21]);
			*data ++ = FROM_FLOAT(m->v[OF_22]);
			*data ++ = FROM_FLOAT(m->v[OF_23]);
			*data ++ = FROM_FLOAT(m->v[OF_24]);
			*data ++ = FROM_FLOAT(m->v[OF_31]);
			*data ++ = FROM_FLOAT(m->v[OF_32]);
			*data ++ = FROM_FLOAT(m->v[OF_33]);
			*data ++ = FROM_FLOAT(m->v[OF_34]);
			*data ++ = FROM_FLOAT(m->v[OF_41]);
			*data ++ = FROM_FLOAT(m->v[OF_42]);
			*data ++ = FROM_FLOAT(m->v[OF_43]);
			*data ++ = FROM_FLOAT(m->v[OF_44]);
			break;

		case GL_PROJECTION_MATRIX:
			m = CurrentP; //&context->Projection[context->ProjectionNr];
			*data ++ = FROM_FLOAT(m->v[OF_11]);
			*data ++ = FROM_FLOAT(m->v[OF_21]);
			*data ++ = FROM_FLOAT(m->v[OF_31]);
			*data ++ = FROM_FLOAT(m->v[OF_41]);
			*data ++ = FROM_FLOAT(m->v[OF_12]);
			*data ++ = FROM_FLOAT(m->v[OF_22]);
			*data ++ = FROM_FLOAT(m->v[OF_32]);
			*data ++ = FROM_FLOAT(m->v[OF_42]);
			*data ++ = FROM_FLOAT(m->v[OF_13]);
			*data ++ = FROM_FLOAT(m->v[OF_23]);
			*data ++ = FROM_FLOAT(m->v[OF_33]);
			*data ++ = FROM_FLOAT(m->v[OF_43]);
			*data ++ = FROM_FLOAT(m->v[OF_14]);
			*data ++ = FROM_FLOAT(m->v[OF_24]);
			*data ++ = FROM_FLOAT(m->v[OF_34]);
			*data ++ = FROM_FLOAT(m->v[OF_44]);
			break;

		case GL_TRANSPOSE_PROJECTION_MATRIX:
			m = CurrentP; //&context->Projection[context->ProjectionNr];
			*data ++ = FROM_FLOAT(m->v[OF_11]);
			*data ++ = FROM_FLOAT(m->v[OF_12]);
			*data ++ = FROM_FLOAT(m->v[OF_13]);
			*data ++ = FROM_FLOAT(m->v[OF_14]);
			*data ++ = FROM_FLOAT(m->v[OF_21]);
			*data ++ = FROM_FLOAT(m->v[OF_22]);
			*data ++ = FROM_FLOAT(m->v[OF_23]);
			*data ++ = FROM_FLOAT(m->v[OF_24]);
			*data ++ = FROM_FLOAT(m->v[OF_31]);
			*data ++ = FROM_FLOAT(m->v[OF_32]);
			*data ++ = FROM_FLOAT(m->v[OF_33]);
			*data ++ = FROM_FLOAT(m->v[OF_34]);
			*data ++ = FROM_FLOAT(m->v[OF_41]);
			*data ++ = FROM_FLOAT(m->v[OF_42]);
			*data ++ = FROM_FLOAT(m->v[OF_43]);
			*data ++ = FROM_FLOAT(m->v[OF_44]);
			break;

		case GL_TEXTURE_MATRIX:
			m =     CurrentT; //&context->Texture[context->TextureNr[context->texture.ActiveTexture]][context->texture.ActiveTexture];
			*data ++ = FROM_FLOAT(m->v[OF_11]);
			*data ++ = FROM_FLOAT(m->v[OF_21]);
			*data ++ = FROM_FLOAT(m->v[OF_31]);
			*data ++ = FROM_FLOAT(m->v[OF_41]);
			*data ++ = FROM_FLOAT(m->v[OF_12]);
			*data ++ = FROM_FLOAT(m->v[OF_22]);
			*data ++ = FROM_FLOAT(m->v[OF_32]);
			*data ++ = FROM_FLOAT(m->v[OF_42]);
			*data ++ = FROM_FLOAT(m->v[OF_13]);
			*data ++ = FROM_FLOAT(m->v[OF_23]);
			*data ++ = FROM_FLOAT(m->v[OF_33]);
			*data ++ = FROM_FLOAT(m->v[OF_43]);
			*data ++ = FROM_FLOAT(m->v[OF_14]);
			*data ++ = FROM_FLOAT(m->v[OF_24]);
			*data ++ = FROM_FLOAT(m->v[OF_34]);
			*data ++ = FROM_FLOAT(m->v[OF_44]);
			break;

		case GL_TRANSPOSE_TEXTURE_MATRIX:
			m =     CurrentT; //&context->Texture[context->TextureNr[context->texture.ActiveTexture]][context->texture.ActiveTexture];
			*data ++ = FROM_FLOAT(m->v[OF_11]);
			*data ++ = FROM_FLOAT(m->v[OF_12]);
			*data ++ = FROM_FLOAT(m->v[OF_13]);
			*data ++ = FROM_FLOAT(m->v[OF_14]);
			*data ++ = FROM_FLOAT(m->v[OF_21]);
			*data ++ = FROM_FLOAT(m->v[OF_22]);
			*data ++ = FROM_FLOAT(m->v[OF_23]);
			*data ++ = FROM_FLOAT(m->v[OF_24]);
			*data ++ = FROM_FLOAT(m->v[OF_31]);
			*data ++ = FROM_FLOAT(m->v[OF_32]);
			*data ++ = FROM_FLOAT(m->v[OF_33]);
			*data ++ = FROM_FLOAT(m->v[OF_34]);
			*data ++ = FROM_FLOAT(m->v[OF_41]);
			*data ++ = FROM_FLOAT(m->v[OF_42]);
			*data ++ = FROM_FLOAT(m->v[OF_43]);
			*data ++ = FROM_FLOAT(m->v[OF_44]);
			break;

		case GL_VIEWPORT:
			*data ++ = FROM_INT(context->viewport.x);
			*data ++ = FROM_INT(context->viewport.y);
			*data ++ = FROM_INT(context->viewport.w);
			*data ++ = FROM_INT(context->viewport.h);
			break;

		case GL_DEPTH_RANGE:
			*data ++ = FROM_FLOAT(context->viewport.near);
			*data ++ = FROM_FLOAT(context->viewport.far);
			break;

		case GL_MODELVIEW_STACK_DEPTH:
			*data ++ = FROM_INT(context->ModelViewStackPointer);
			break;

		case GL_PROJECTION_STACK_DEPTH:
			*data ++ = FROM_INT(context->ProjectionStackPointer);
			break;

		case GL_TEXTURE_STACK_DEPTH:
			*data ++ = FROM_INT(context->TextureStackPointer[tmu]);
			break;

		case GL_MATRIX_MODE:
			*data ++ = FROM_INT(context->transform.CurrentMatrixMode);
			break;

		case GL_NORMALIZE:
			*data ++ = FROM_BOOL(context->Normalize);
			break;

		case GL_RESCALE_NORMAL:
			*data ++ = FROM_BOOL(GL_FALSE);
			break;                  /* FIXME */

		case GL_CLIP_PLANE0:
		case GL_CLIP_PLANE1:
		case GL_CLIP_PLANE2:
		case GL_CLIP_PLANE3:
		case GL_CLIP_PLANE4:
		case GL_CLIP_PLANE5:
			*data ++ = FROM_BOOL(context->enable.ClipPlane[value-GL_CLIP_PLANE0]);
			break;

		case GL_FOG_COLOR:
			*data ++ = FROM_COLOR(context->fog.FogColor.r);
			*data ++ = FROM_COLOR(context->fog.FogColor.g);
			*data ++ = FROM_COLOR(context->fog.FogColor.b);
			*data ++ = FROM_COLOR(context->fog.FogColor.a);
			break;

		case GL_FOG_INDEX:
			break;                  /* No index mode */

		case GL_FOG_DENSITY:
			*data ++ = FROM_FLOAT(context->fog.FogDensity);
			break;

		case GL_FOG_START:
			*data ++ = FROM_FLOAT(context->fog.FogStart);
			break;

		case GL_FOG_END:
			*data ++ = FROM_FLOAT(context->fog.FogEnd);
			break;

		case GL_FOG_MODE:
			*data ++ = FROM_FLOAT(context->fog.FogMode);
			break;

		case GL_FOG:
			*data ++ = FROM_BOOL(context->enable.Fog);
			break;

		case GL_COLOR_SUM:
			break;                  /* FIXME */

		case GL_SHADE_MODEL:
			*data ++ = FROM_INT(context->lighting.ShadeModel);
			break;

		case GL_LIGHTING:
			*data ++ = FROM_BOOL(context->enable.Lighting);
			break;

		case GL_COLOR_MATERIAL:
			*data ++ = FROM_BOOL(context->enable.ColorMaterial);
			break;

		case GL_COLOR_MATERIAL_PARAMETER:
			*data ++ = FROM_INT(context->lighting.ColorMaterialParameter);
			break;

		case GL_COLOR_MATERIAL_FACE:
			*data ++ = FROM_INT(context->lighting.ColorMaterialFace);
			break;

		case GL_LIGHT_MODEL_AMBIENT:
			*data ++ = FROM_COLOR(context->lighting.LightModelAmbient.r);
			*data ++ = FROM_COLOR(context->lighting.LightModelAmbient.g);
			*data ++ = FROM_COLOR(context->lighting.LightModelAmbient.b);
			*data ++ = FROM_COLOR(context->lighting.LightModelAmbient.a);
			break;

		case GL_LIGHT_MODEL_LOCAL_VIEWER:
			*data ++ = FROM_BOOL(context->lighting.LightModelLocalViewer);
			break;

		case GL_LIGHT_MODEL_TWO_SIDE:
			*data ++ = FROM_BOOL(context->lighting.LightModelTwoSide);
			break;

		case GL_LIGHT_MODEL_COLOR_CONTROL:
			*data ++ = FROM_INT(context->lighting.LightModelColorControl);
			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:
			*data ++ = FROM_BOOL(context->enable.Light[value-GL_LIGHT0]);
			break;

		case GL_MAX_LIGHTS:
			*data = FROM_INT(MGL_MAX_LIGHTS);
			break;

		case GL_NAME_STACK_DEPTH:
			*data = FROM_INT(context->nameStackPointer + 1);
			break;

		case GL_MAX_NAME_STACK_DEPTH:
			*data = FROM_INT(NAME_STACK_SIZE);
			break;

		case GL_RENDER_MODE:
			*data = FROM_INT(context->renderMode);
			break; // ? was missing with no fall through

		case GL_POINT_SIZE:
			*data ++ = FROM_FLOAT(context->point.PointSize);
			break;

		case GL_POINT_SMOOTH:
			*data ++ = FROM_BOOL(context->enable.PointSmooth);
			break;

		case GL_POINT_SIZE_MIN:
			*data ++ = FROM_FLOAT(0.0);
			break;                          /* FIXME */

		case GL_POINT_SIZE_MAX:
			*data ++ = FROM_FLOAT(8.0);
			break;                          /* FIXME */

		case GL_POINT_SIZE_RANGE:
			*data ++ = FROM_FLOAT(0.0);
			*data ++ = FROM_FLOAT(8.0);
			break;

		case GL_PACK_SWAP_BYTES:
			*data ++ = FROM_BOOL(context->pixel_store.pack.swap_bytes);
			break;

		case GL_PACK_LSB_FIRST:
			*data ++ = FROM_BOOL(context->pixel_store.pack.lsb_first);
			break;

		case GL_PACK_ROW_LENGTH:
			*data ++ = FROM_INT(context->pixel_store.pack.row_length);
			break;

		case GL_PACK_SKIP_ROWS:
			*data ++ = FROM_INT(context->pixel_store.pack.skip_rows);
			break;

		case GL_PACK_SKIP_PIXELS:
			*data ++ = FROM_INT(context->pixel_store.pack.skip_pixels);
			break;

		case GL_PACK_ALIGNMENT:
			*data ++ = FROM_INT(context->pixel_store.pack.alignment);
			break;

		case GL_UNPACK_SWAP_BYTES:
			*data ++ = FROM_BOOL(context->pixel_store.unpack.swap_bytes);
			break;

		case GL_UNPACK_LSB_FIRST:
			*data ++ = FROM_BOOL(context->pixel_store.unpack.lsb_first);
			break;

		case GL_UNPACK_ROW_LENGTH:
			*data ++ = FROM_INT(context->pixel_store.unpack.row_length);
			break;

		case GL_UNPACK_SKIP_ROWS:
			*data ++ = FROM_INT(context->pixel_store.unpack.skip_rows);
			break;

		case GL_UNPACK_SKIP_PIXELS:
			*data ++ = FROM_INT(context->pixel_store.unpack.skip_pixels);
			break;

		case GL_UNPACK_ALIGNMENT:
			*data ++ = FROM_INT(context->pixel_store.unpack.alignment);
			break;

		case GL_MAP_COLOR:
			*data ++ = FROM_BOOL(context->pixel.map_color);
			break;

		case GL_MAP_STENCIL:
			*data ++ = FROM_BOOL(context->pixel.map_stencil);
			break;

		case GL_ALPHA_SCALE:
			*data ++ = FROM_FLOAT(context->pixel.alpha_scale);
			break;

		case GL_BLUE_SCALE:
			*data ++ = FROM_FLOAT(context->pixel.blue_scale);
			break;

		case GL_GREEN_SCALE:
			*data ++ = FROM_FLOAT(context->pixel.green_scale);
			break;

		case GL_RED_SCALE:
			*data ++ = FROM_FLOAT(context->pixel.red_scale);
			break;

		case GL_DEPTH_SCALE:
			*data ++ = FROM_FLOAT(context->pixel.depth_scale);
			break;

		case GL_ALPHA_BIAS:
			*data ++ = FROM_FLOAT(context->pixel.alpha_bias);
			break;

		case GL_BLUE_BIAS:
			*data ++ = FROM_FLOAT(context->pixel.blue_bias);
			break;

		case GL_GREEN_BIAS:
			*data ++ = FROM_FLOAT(context->pixel.green_bias);
			break;

		case GL_RED_BIAS:
			*data ++ = FROM_FLOAT(context->pixel.red_bias);
			break;

		case GL_DEPTH_BIAS:
			*data ++ = FROM_FLOAT(context->pixel.depth_bias);
			break;

		case GL_READ_BUFFER:
			*data ++ = FROM_INT(context->color_buffer.ReadBuffer);
			break;

		case GL_DRAW_BUFFER:
			*data ++ = FROM_INT(context->color_buffer.DrawBuffer);
			break;

		case GL_ZOOM_X:
			*data ++ = FROM_FLOAT(context->pixel.zoom_x);
			break;

		case GL_ZOOM_Y:
			*data ++ = FROM_FLOAT(context->pixel.zoom_y);
			break;

		case GL_MAX_TEXTURE_UNITS:
			*data ++ = FROM_INT(context->NumTextureUnits);
			break;

		case GL_MAX_TEXTURE_SIZE:
			*data ++ = FROM_INT(IWarp3D->W3D_Query(context->w3dContext, W3D_Q_MAXTEXWIDTH, 0));
			break;

		case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: {
			int maxW3DAnisotropy = IWarp3D->W3D_Query(context->w3dContext, W3D_Q_MAXANISOTROPY, 0);
			*data ++ = FROM_INT( (1L<<(maxW3DAnisotropy-1)) );
			break;
		}
		case GL_MAP1_GRID_DOMAIN:
			*data ++ = FROM_INT(context->evaluator.u1.start);
			*data ++ = FROM_INT(context->evaluator.u1.end);
			break;

		case GL_MAP2_GRID_DOMAIN:
			*data ++ = FROM_INT(context->evaluator.u2.start);
			*data ++ = FROM_INT(context->evaluator.u2.end);
			*data ++ = FROM_INT(context->evaluator.v2.start);
			*data ++ = FROM_INT(context->evaluator.v2.end);
			break;

		case GL_MAP1_GRID_SEGMENTS:
			*data ++ = FROM_INT(context->evaluator.u1.num);
			break;

		case GL_MAP2_GRID_SEGMENTS:
			*data ++ = FROM_INT(context->evaluator.u2.num);
			*data ++ = FROM_INT(context->evaluator.v2.num);
			break;

		case GL_ALPHA_TEST_FUNC:
			*data ++ = FROM_INT(context->color_buffer.AlphaTestFunc);
			break;

		case GL_ALPHA_TEST_REF:
			*data ++ = FROM_FLOAT(context->color_buffer.AlphaTestRef);
			break;

		case GL_SCISSOR_BOX:
			*data ++ = FROM_INT(context->scissor.x);
			*data ++ = FROM_INT(context->scissor.y);
			*data ++ = FROM_INT(context->scissor.w);
			*data ++ = FROM_INT(context->scissor.h);
			break;


/* -------------- ONLY ENABLES BEYOND THIS POINT ---------------------- */
/* FIXME: Add other state not required for second milestone */

		case GL_MAP1_TEXTURE_COORD_1:
		case GL_MAP1_TEXTURE_COORD_2:
		case GL_MAP1_TEXTURE_COORD_3:
		case GL_MAP1_TEXTURE_COORD_4:
		case GL_MAP1_VERTEX_3:
		case GL_MAP1_VERTEX_4:
		case GL_MAP1_NORMAL:
		case GL_MAP1_COLOR_4:
			*data ++ = FROM_BOOL(context->enable.Map1[eval_TargetToIndex(value)]);
			break;

		case GL_MAP2_TEXTURE_COORD_1:
		case GL_MAP2_TEXTURE_COORD_2:
		case GL_MAP2_TEXTURE_COORD_3:
		case GL_MAP2_TEXTURE_COORD_4:
		case GL_MAP2_VERTEX_3:
		case GL_MAP2_VERTEX_4:
		case GL_MAP2_NORMAL:
		case GL_MAP2_COLOR_4:
			*data ++ = FROM_BOOL(context->enable.Map1[eval_TargetToIndex(value)]);
			break;

		case GL_AUTO_NORMAL:
			*data ++ = FROM_BOOL(context->enable.AutoNormal);
			break;

		case GL_LINE_SMOOTH:
			*data ++ = FROM_BOOL(context->enable.LineSmooth);
			break;

		case GL_LINE_STIPPLE:
			*data ++ = FROM_BOOL(context->enable.LineStipple);
			break;

		case GL_CULL_FACE:
			*data ++ = FROM_BOOL(context->enable.CullFace);
			break;

		case GL_POLYGON_SMOOTH:
			*data ++ = FROM_BOOL(context->enable.PolygonSmooth);
			break;

		case GL_POLYGON_OFFSET_LINE:
			*data ++ = FROM_BOOL(GL_FALSE);
			break;                  /* FIXME */

		case GL_POLYGON_OFFSET_POINT:
			*data ++ = FROM_BOOL(GL_FALSE);
			break;

		case GL_POLYGON_OFFSET_FILL:
			*data ++ = FROM_BOOL(context->enable.PolygonOffsetFill);
			break;

		case GL_POLYGON_STIPPLE:
			*data ++ = FROM_BOOL(context->enable.PolygonStipple);
			break;

		case GL_TEXTURE_1D:
			*data ++ = FROM_BOOL(context->enable.Texture1D[tmu]);
			break;

		case GL_TEXTURE_2D:
			*data ++ = FROM_BOOL(context->enable.Texture2D[tmu]);
			break;

		case GL_TEXTURE_CUBE_MAP:
			*data ++ = FROM_BOOL(GL_FALSE);
			break;                  /* FIXME */

		case GL_TEXTURE_GEN_S:
			*data ++ = FROM_BOOL(context->enable.TexGenS[tmu]);
			break;

		case GL_TEXTURE_GEN_T:
			*data ++ = FROM_BOOL(context->enable.TexGenT[tmu]);
			break;

		case GL_TEXTURE_GEN_R:
			*data ++ = FROM_BOOL(GL_FALSE);
			break;                  /* FIXME */

		case GL_TEXTURE_GEN_Q:
			*data ++ = FROM_BOOL(context->enable.TexGenQ[tmu]);
			break;

		case GL_SCISSOR_TEST:
			*data ++ = FROM_BOOL(context->enable.ScissorTest);
			break;

		case GL_ALPHA_TEST:
			*data ++ = FROM_BOOL(context->enable.AlphaTest);
			break;

		case GL_STENCIL_TEST:
			*data ++ = FROM_BOOL(context->enable.StencilTest);
			break;

		case GL_DEPTH_TEST:
			*data ++ = FROM_BOOL(context->enable.DepthTest);
			break;

		case GL_BLEND:
			*data ++ = FROM_BOOL(context->enable.Blend);
			break;

		case GL_DITHER:
			*data ++ = FROM_BOOL(context->enable.Dither);
			break;

		default:
			//printf("Unsupported glGet %04x\n", value);
			break;

	}

#ifdef _IS_ENABLED_ONLY
	return result;
#endif
}