/* ** Copyright 1992, Silicon Graphics, Inc. ** All Rights Reserved. ** ** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.; ** the contents of this file may not be disclosed to third parties, copied or ** duplicated in any form, in whole or in part, without the prior written ** permission of Silicon Graphics, Inc. ** ** RESTRICTED RIGHTS LEGEND: ** Use, duplication or disclosure by the Government is subject to restrictions ** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data ** and Computer Software clause at DFARS 252.227-7013, and/or in similar or ** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished - ** rights reserved under the Copyright Laws of the United States. */ #include #include #include #include "conform.h" #include "pathdata.h" #include "path.h" #include "util.h" #include "utils.h" struct _enumInfoRec { char name[40]; long value; } enumInfo[] = { { "GL_2_BYTES", GL_2_BYTES }, { "GL_3_BYTES", GL_3_BYTES }, { "GL_4_BYTES", GL_4_BYTES }, { "GL_2D", GL_2D }, { "GL_3D", GL_3D }, { "GL_3D_COLOR", GL_3D_COLOR }, { "GL_3D_COLOR_TEXTURE", GL_3D_COLOR_TEXTURE }, { "GL_4D_COLOR_TEXTURE", GL_4D_COLOR_TEXTURE }, { "GL_ACCUM", GL_ACCUM }, { "GL_ACCUM_ALPHA_BITS", GL_ACCUM_ALPHA_BITS }, { "GL_ACCUM_BLUE_BITS", GL_ACCUM_BLUE_BITS }, { "GL_ACCUM_CLEAR_VALUE", GL_ACCUM_CLEAR_VALUE }, { "GL_ACCUM_GREEN_BITS", GL_ACCUM_GREEN_BITS }, { "GL_ACCUM_RED_BITS", GL_ACCUM_RED_BITS }, { "GL_ADD", GL_ADD }, { "GL_ALL_ATTRIB_BITS", GL_ALL_ATTRIB_BITS }, { "GL_ALPHA", GL_ALPHA }, { "GL_ALPHA_BIAS", GL_ALPHA_BIAS }, { "GL_ALPHA_BITS", GL_ALPHA_BITS }, { "GL_ALPHA_SCALE", GL_ALPHA_SCALE }, { "GL_ALPHA_TEST", GL_ALPHA_TEST }, { "GL_ALPHA_TEST_FUNC", GL_ALPHA_TEST_FUNC }, { "GL_ALPHA_TEST_REF", GL_ALPHA_TEST_REF }, { "GL_ALWAYS", GL_ALWAYS }, { "GL_AMBIENT", GL_AMBIENT }, { "GL_AMBIENT_AND_DIFFUSE", GL_AMBIENT_AND_DIFFUSE }, { "GL_AND", GL_AND }, { "GL_AND_INVERTED", GL_AND_INVERTED }, { "GL_AND_REVERSE", GL_AND_REVERSE }, { "GL_ATTRIB_STACK_DEPTH", GL_ATTRIB_STACK_DEPTH }, { "GL_AUTO_NORMAL", GL_AUTO_NORMAL }, { "GL_AUX_BUFFERS", GL_AUX_BUFFERS }, { "GL_AUX0", GL_AUX0 }, { "GL_AUX1", GL_AUX1 }, { "GL_AUX2", GL_AUX2 }, { "GL_AUX3", GL_AUX3 }, { "GL_BACK", GL_BACK }, { "GL_BACK_LEFT", GL_BACK_LEFT }, { "GL_BACK_RIGHT", GL_BACK_RIGHT }, { "GL_BITMAP", GL_BITMAP }, { "GL_BITMAP_TOKEN", GL_BITMAP_TOKEN }, { "GL_BLEND", GL_BLEND }, { "GL_BLEND_DST", GL_BLEND_DST }, { "GL_BLEND_SRC", GL_BLEND_SRC }, { "GL_BLUE", GL_BLUE }, { "GL_BLUE_BIAS", GL_BLUE_BIAS }, { "GL_BLUE_BITS", GL_BLUE_BITS }, { "GL_BLUE_SCALE", GL_BLUE_SCALE }, { "GL_BYTE", GL_BYTE }, { "GL_CCW", GL_CCW }, { "GL_CLAMP", GL_CLAMP }, { "GL_CLEAR", GL_CLEAR }, { "GL_CLIP_PLANE0", GL_CLIP_PLANE0 }, { "GL_CLIP_PLANE1", GL_CLIP_PLANE1 }, { "GL_CLIP_PLANE2", GL_CLIP_PLANE2 }, { "GL_CLIP_PLANE3", GL_CLIP_PLANE3 }, { "GL_CLIP_PLANE4", GL_CLIP_PLANE4 }, { "GL_CLIP_PLANE5", GL_CLIP_PLANE5 }, { "GL_COEFF", GL_COEFF }, { "GL_COLOR", GL_COLOR }, { "GL_COLOR_CLEAR_VALUE", GL_COLOR_CLEAR_VALUE }, { "GL_COLOR_INDEX", GL_COLOR_INDEX }, { "GL_COLOR_INDEXES", GL_COLOR_INDEXES }, { "GL_COLOR_MATERIAL", GL_COLOR_MATERIAL }, { "GL_COLOR_MATERIAL_FACE", GL_COLOR_MATERIAL_FACE }, { "GL_COLOR_MATERIAL_PARAMETER", GL_COLOR_MATERIAL_PARAMETER }, { "GL_COLOR_WRITEMASK", GL_COLOR_WRITEMASK }, { "GL_COMPILE", GL_COMPILE }, { "GL_COMPILE_AND_EXECUTE", GL_COMPILE_AND_EXECUTE }, { "GL_CONSTANT_ATTENUATION", GL_CONSTANT_ATTENUATION }, { "GL_COPY", GL_COPY }, { "GL_COPY_INVERTED", GL_COPY_INVERTED }, { "GL_COPY_PIXEL_TOKEN", GL_COPY_PIXEL_TOKEN }, { "GL_CULL_FACE", GL_CULL_FACE }, { "GL_CULL_FACE_MODE", GL_CULL_FACE_MODE }, { "GL_CURRENT_COLOR", GL_CURRENT_COLOR }, { "GL_CURRENT_INDEX", GL_CURRENT_INDEX }, { "GL_CURRENT_NORMAL", GL_CURRENT_NORMAL }, { "GL_CURRENT_RASTER_COLOR", GL_CURRENT_RASTER_COLOR }, { "GL_CURRENT_RASTER_INDEX", GL_CURRENT_RASTER_INDEX }, { "GL_CURRENT_RASTER_POSITION", GL_CURRENT_RASTER_POSITION }, { "GL_CURRENT_RASTER_POSITION_VALID", GL_CURRENT_RASTER_POSITION_VALID }, { "GL_CURRENT_RASTER_TEXTURE_COORDS", GL_CURRENT_RASTER_TEXTURE_COORDS }, { "GL_CURRENT_TEXTURE_COORDS", GL_CURRENT_TEXTURE_COORDS }, { "GL_CW", GL_CW }, { "GL_DECAL", GL_DECAL }, { "GL_DECR", GL_DECR }, { "GL_DEPTH", GL_DEPTH }, { "GL_DEPTH_BIAS", GL_DEPTH_BIAS }, { "GL_DEPTH_BITS", GL_DEPTH_BITS }, { "GL_DEPTH_CLEAR_VALUE", GL_DEPTH_CLEAR_VALUE }, { "GL_DEPTH_COMPONENT", GL_DEPTH_COMPONENT }, { "GL_DEPTH_FUNC", GL_DEPTH_FUNC }, { "GL_DEPTH_RANGE", GL_DEPTH_RANGE }, { "GL_DEPTH_SCALE", GL_DEPTH_SCALE }, { "GL_DEPTH_TEST", GL_DEPTH_TEST }, { "GL_DEPTH_WRITEMASK", GL_DEPTH_WRITEMASK }, { "GL_DIFFUSE", GL_DIFFUSE }, { "GL_DITHER", GL_DITHER }, { "GL_DOMAIN", GL_DOMAIN }, { "GL_DONT_CARE", GL_DONT_CARE }, { "GL_DOUBLEBUFFER", GL_DOUBLEBUFFER }, { "GL_DRAW_BUFFER", GL_DRAW_BUFFER }, { "GL_DRAW_PIXEL_TOKEN", GL_DRAW_PIXEL_TOKEN }, { "GL_DST_ALPHA", GL_DST_ALPHA }, { "GL_DST_COLOR", GL_DST_COLOR }, { "GL_EDGE_FLAG", GL_EDGE_FLAG }, { "GL_EMISSION", GL_EMISSION }, { "GL_EQUAL", GL_EQUAL }, { "GL_EQUIV", GL_EQUIV }, { "GL_EXP", GL_EXP }, { "GL_EXP2", GL_EXP2 }, { "GL_EXTENSIONS", GL_EXTENSIONS }, { "GL_EYE_LINEAR", GL_EYE_LINEAR }, { "GL_EYE_PLANE", GL_EYE_PLANE }, { "GL_FASTEST", GL_FASTEST }, { "GL_FEEDBACK", GL_FEEDBACK }, { "GL_FILL", GL_FILL }, { "GL_FLAT", GL_FLAT }, { "GL_FLOAT", GL_FLOAT }, { "GL_FOG", GL_FOG }, { "GL_FOG_COLOR", GL_FOG_COLOR }, { "GL_FOG_DENSITY", GL_FOG_DENSITY }, { "GL_FOG_END", GL_FOG_END }, { "GL_FOG_HINT", GL_FOG_HINT }, { "GL_FOG_INDEX", GL_FOG_INDEX }, { "GL_FOG_MODE", GL_FOG_MODE }, { "GL_FOG_START", GL_FOG_START }, { "GL_FRONT", GL_FRONT }, { "GL_FRONT_AND_BACK", GL_FRONT_AND_BACK }, { "GL_FRONT_FACE", GL_FRONT_FACE }, { "GL_FRONT_LEFT", GL_FRONT_LEFT }, { "GL_FRONT_RIGHT", GL_FRONT_RIGHT }, { "GL_GEQUAL", GL_GEQUAL }, { "GL_GREATER", GL_GREATER }, { "GL_GREEN", GL_GREEN }, { "GL_GREEN_BIAS", GL_GREEN_BIAS }, { "GL_GREEN_BITS", GL_GREEN_BITS }, { "GL_GREEN_SCALE", GL_GREEN_SCALE }, { "GL_INCR", GL_INCR }, { "GL_INDEX_BITS", GL_INDEX_BITS }, { "GL_INDEX_CLEAR_VALUE", GL_INDEX_CLEAR_VALUE }, { "GL_INDEX_MODE", GL_INDEX_MODE }, { "GL_INDEX_OFFSET", GL_INDEX_OFFSET }, { "GL_INDEX_SHIFT", GL_INDEX_SHIFT }, { "GL_INDEX_WRITEMASK", GL_INDEX_WRITEMASK }, { "GL_INT", GL_INT }, { "GL_INVALID_ENUM", GL_INVALID_ENUM }, { "GL_INVALID_OPERATION", GL_INVALID_OPERATION }, { "GL_INVALID_VALUE", GL_INVALID_VALUE }, { "GL_INVERT", GL_INVERT }, { "GL_KEEP", GL_KEEP }, { "GL_LEFT", GL_LEFT }, { "GL_LEQUAL", GL_LEQUAL }, { "GL_LESS", GL_LESS }, { "GL_LIGHT_MODEL_AMBIENT", GL_LIGHT_MODEL_AMBIENT }, { "GL_LIGHT_MODEL_LOCAL_VIEWER", GL_LIGHT_MODEL_LOCAL_VIEWER }, { "GL_LIGHT_MODEL_TWO_SIDE", GL_LIGHT_MODEL_TWO_SIDE }, { "GL_LIGHT0", GL_LIGHT0 }, { "GL_LIGHT1", GL_LIGHT1 }, { "GL_LIGHT2", GL_LIGHT2 }, { "GL_LIGHT3", GL_LIGHT3 }, { "GL_LIGHT4", GL_LIGHT4 }, { "GL_LIGHT5", GL_LIGHT5 }, { "GL_LIGHT6", GL_LIGHT6 }, { "GL_LIGHT7", GL_LIGHT7 }, { "GL_LIGHTING", GL_LIGHTING }, { "GL_LINE", GL_LINE }, { "GL_LINE_LOOP", GL_LINE_LOOP }, { "GL_LINE_RESET_TOKEN", GL_LINE_RESET_TOKEN }, { "GL_LINE_SMOOTH", GL_LINE_SMOOTH }, { "GL_LINE_SMOOTH_HINT", GL_LINE_SMOOTH_HINT }, { "GL_LINE_STIPPLE", GL_LINE_STIPPLE }, { "GL_LINE_STIPPLE_PATTERN", GL_LINE_STIPPLE_PATTERN }, { "GL_LINE_STIPPLE_REPEAT", GL_LINE_STIPPLE_REPEAT }, { "GL_LINE_STRIP", GL_LINE_STRIP }, { "GL_LINE_TOKEN", GL_LINE_TOKEN }, { "GL_LINE_WIDTH", GL_LINE_WIDTH }, { "GL_LINE_WIDTH_GRANULARITY", GL_LINE_WIDTH_GRANULARITY }, { "GL_LINE_WIDTH_RANGE", GL_LINE_WIDTH_RANGE }, { "GL_LINEAR", GL_LINEAR }, { "GL_LINEAR_ATTENUATION", GL_LINEAR_ATTENUATION }, { "GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST }, { "GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR }, { "GL_LINES", GL_LINES }, { "GL_LIST_BASE", GL_LIST_BASE }, { "GL_LIST_INDEX", GL_LIST_INDEX }, { "GL_LIST_MODE", GL_LIST_MODE }, { "GL_LOAD", GL_LOAD }, { "GL_LOGIC_OP", GL_LOGIC_OP }, { "GL_LOGIC_OP_MODE", GL_LOGIC_OP_MODE }, { "GL_LUMINANCE", GL_LUMINANCE }, { "GL_LUMINANCE_ALPHA", GL_LUMINANCE_ALPHA }, { "GL_MAP_COLOR", GL_MAP_COLOR }, { "GL_MAP_STENCIL", GL_MAP_STENCIL }, { "GL_MAP1_COLOR_4", GL_MAP1_COLOR_4 }, { "GL_MAP1_GRID_DOMAIN", GL_MAP1_GRID_DOMAIN }, { "GL_MAP1_GRID_SEGMENTS", GL_MAP1_GRID_SEGMENTS }, { "GL_MAP1_INDEX", GL_MAP1_INDEX }, { "GL_MAP1_NORMAL", GL_MAP1_NORMAL }, { "GL_MAP1_TEXTURE_COORD_1", GL_MAP1_TEXTURE_COORD_1 }, { "GL_MAP1_TEXTURE_COORD_2", GL_MAP1_TEXTURE_COORD_2 }, { "GL_MAP1_TEXTURE_COORD_3", GL_MAP1_TEXTURE_COORD_3 }, { "GL_MAP1_TEXTURE_COORD_4", GL_MAP1_TEXTURE_COORD_4 }, { "GL_MAP1_VERTEX_3", GL_MAP1_VERTEX_3 }, { "GL_MAP1_VERTEX_4", GL_MAP1_VERTEX_4 }, { "GL_MAP2_COLOR_4", GL_MAP2_COLOR_4 }, { "GL_MAP2_GRID_DOMAIN", GL_MAP2_GRID_DOMAIN }, { "GL_MAP2_GRID_SEGMENTS", GL_MAP2_GRID_SEGMENTS }, { "GL_MAP2_INDEX", GL_MAP2_INDEX }, { "GL_MAP2_NORMAL", GL_MAP2_NORMAL }, { "GL_MAP2_TEXTURE_COORD_1", GL_MAP2_TEXTURE_COORD_1 }, { "GL_MAP2_TEXTURE_COORD_2", GL_MAP2_TEXTURE_COORD_2 }, { "GL_MAP2_TEXTURE_COORD_3", GL_MAP2_TEXTURE_COORD_3 }, { "GL_MAP2_TEXTURE_COORD_4", GL_MAP2_TEXTURE_COORD_4 }, { "GL_MAP2_VERTEX_3", GL_MAP2_VERTEX_3 }, { "GL_MAP2_VERTEX_4", GL_MAP2_VERTEX_4 }, { "GL_MATRIX_MODE", GL_MATRIX_MODE }, { "GL_MAX_ATTRIB_STACK_DEPTH", GL_MAX_ATTRIB_STACK_DEPTH }, { "GL_MAX_CLIP_PLANES", GL_MAX_CLIP_PLANES }, { "GL_MAX_EVAL_ORDER", GL_MAX_EVAL_ORDER }, { "GL_MAX_LIGHTS", GL_MAX_LIGHTS }, { "GL_MAX_LIST_NESTING", GL_MAX_LIST_NESTING }, { "GL_MAX_MODELVIEW_STACK_DEPTH", GL_MAX_MODELVIEW_STACK_DEPTH }, { "GL_MAX_NAME_STACK_DEPTH", GL_MAX_NAME_STACK_DEPTH }, { "GL_MAX_PIXEL_MAP_TABLE", GL_MAX_PIXEL_MAP_TABLE }, { "GL_MAX_PROJECTION_STACK_DEPTH", GL_MAX_PROJECTION_STACK_DEPTH }, { "GL_MAX_TEXTURE_SIZE", GL_MAX_TEXTURE_SIZE }, { "GL_MAX_TEXTURE_STACK_DEPTH", GL_MAX_TEXTURE_STACK_DEPTH }, { "GL_MAX_VIEWPORT_DIMS", GL_MAX_VIEWPORT_DIMS }, { "GL_MODELVIEW", GL_MODELVIEW }, { "GL_MODELVIEW_MATRIX", GL_MODELVIEW_MATRIX }, { "GL_MODELVIEW_STACK_DEPTH", GL_MODELVIEW_STACK_DEPTH }, { "GL_MODULATE", GL_MODULATE }, { "GL_MULT", GL_MULT }, { "GL_NAME_STACK_DEPTH", GL_NAME_STACK_DEPTH }, { "GL_NAND", GL_NAND }, { "GL_NEAREST", GL_NEAREST }, { "GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR }, { "GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST }, { "GL_NEVER", GL_NEVER }, { "GL_NICEST", GL_NICEST }, { "GL_NONE", GL_NONE }, { "GL_NOOP", GL_NOOP }, { "GL_NOR", GL_NOR }, { "GL_NORMALIZE", GL_NORMALIZE }, { "GL_NOTEQUAL", GL_NOTEQUAL }, { "GL_OBJECT_LINEAR", GL_OBJECT_LINEAR }, { "GL_OBJECT_PLANE", GL_OBJECT_PLANE }, { "GL_ONE", GL_ONE }, { "GL_ONE_MINUS_DST_ALPHA", GL_ONE_MINUS_DST_ALPHA }, { "GL_ONE_MINUS_DST_COLOR", GL_ONE_MINUS_DST_COLOR }, { "GL_ONE_MINUS_SRC_ALPHA", GL_ONE_MINUS_SRC_ALPHA }, { "GL_ONE_MINUS_SRC_COLOR", GL_ONE_MINUS_SRC_COLOR }, { "GL_OR", GL_OR }, { "GL_OR_INVERTED", GL_OR_INVERTED }, { "GL_OR_REVERSE", GL_OR_REVERSE }, { "GL_ORDER", GL_ORDER }, { "GL_OUT_OF_MEMORY", GL_OUT_OF_MEMORY }, { "GL_PACK_ALIGNMENT", GL_PACK_ALIGNMENT }, { "GL_PACK_LSB_FIRST", GL_PACK_LSB_FIRST }, { "GL_PACK_ROW_LENGTH", GL_PACK_ROW_LENGTH }, { "GL_PACK_SKIP_PIXELS", GL_PACK_SKIP_PIXELS }, { "GL_PACK_SKIP_ROWS", GL_PACK_SKIP_ROWS }, { "GL_PACK_SWAP_BYTES", GL_PACK_SWAP_BYTES }, { "GL_PASS_THROUGH_TOKEN", GL_PASS_THROUGH_TOKEN }, { "GL_PERSPECTIVE_CORRECTION_HINT", GL_PERSPECTIVE_CORRECTION_HINT }, { "GL_PIXEL_MAP_A_TO_A", GL_PIXEL_MAP_A_TO_A }, { "GL_PIXEL_MAP_A_TO_A_SIZE", GL_PIXEL_MAP_A_TO_A_SIZE }, { "GL_PIXEL_MAP_B_TO_B", GL_PIXEL_MAP_B_TO_B }, { "GL_PIXEL_MAP_B_TO_B_SIZE", GL_PIXEL_MAP_B_TO_B_SIZE }, { "GL_PIXEL_MAP_G_TO_G", GL_PIXEL_MAP_G_TO_G }, { "GL_PIXEL_MAP_G_TO_G_SIZE", GL_PIXEL_MAP_G_TO_G_SIZE }, { "GL_PIXEL_MAP_I_TO_A", GL_PIXEL_MAP_I_TO_A }, { "GL_PIXEL_MAP_I_TO_A_SIZE", GL_PIXEL_MAP_I_TO_A_SIZE }, { "GL_PIXEL_MAP_I_TO_B", GL_PIXEL_MAP_I_TO_B }, { "GL_PIXEL_MAP_I_TO_B_SIZE", GL_PIXEL_MAP_I_TO_B_SIZE }, { "GL_PIXEL_MAP_I_TO_G", GL_PIXEL_MAP_I_TO_G }, { "GL_PIXEL_MAP_I_TO_G_SIZE", GL_PIXEL_MAP_I_TO_G_SIZE }, { "GL_PIXEL_MAP_I_TO_I", GL_PIXEL_MAP_I_TO_I }, { "GL_PIXEL_MAP_I_TO_I_SIZE", GL_PIXEL_MAP_I_TO_I_SIZE }, { "GL_PIXEL_MAP_I_TO_R", GL_PIXEL_MAP_I_TO_R }, { "GL_PIXEL_MAP_I_TO_R_SIZE", GL_PIXEL_MAP_I_TO_R_SIZE }, { "GL_PIXEL_MAP_R_TO_R", GL_PIXEL_MAP_R_TO_R }, { "GL_PIXEL_MAP_R_TO_R_SIZE", GL_PIXEL_MAP_R_TO_R_SIZE }, { "GL_PIXEL_MAP_S_TO_S", GL_PIXEL_MAP_S_TO_S }, { "GL_PIXEL_MAP_S_TO_S_SIZE", GL_PIXEL_MAP_S_TO_S_SIZE }, { "GL_POINT", GL_POINT }, { "GL_POINT_SIZE", GL_POINT_SIZE }, { "GL_POINT_SIZE_GRANULARITY", GL_POINT_SIZE_GRANULARITY }, { "GL_POINT_SIZE_RANGE", GL_POINT_SIZE_RANGE }, { "GL_POINT_SMOOTH", GL_POINT_SMOOTH }, { "GL_POINT_SMOOTH_HINT", GL_POINT_SMOOTH_HINT }, { "GL_POINT_TOKEN", GL_POINT_TOKEN }, { "GL_POINTS", GL_POINTS }, { "GL_POLYGON", GL_POLYGON }, { "GL_POLYGON_MODE", GL_POLYGON_MODE }, { "GL_POLYGON_SMOOTH", GL_POLYGON_SMOOTH }, { "GL_POLYGON_SMOOTH_HINT", GL_POLYGON_SMOOTH_HINT }, { "GL_POLYGON_STIPPLE", GL_POLYGON_STIPPLE }, { "GL_POLYGON_TOKEN", GL_POLYGON_TOKEN }, { "GL_POSITION", GL_POSITION }, { "GL_PROJECTION", GL_PROJECTION }, { "GL_PROJECTION_MATRIX", GL_PROJECTION_MATRIX }, { "GL_PROJECTION_STACK_DEPTH", GL_PROJECTION_STACK_DEPTH }, { "GL_Q", GL_Q }, { "GL_QUAD_STRIP", GL_QUAD_STRIP }, { "GL_QUADRATIC_ATTENUATION", GL_QUADRATIC_ATTENUATION }, { "GL_QUADS", GL_QUADS }, { "GL_R", GL_R }, { "GL_READ_BUFFER", GL_READ_BUFFER }, { "GL_RED", GL_RED }, { "GL_RED_BIAS", GL_RED_BIAS }, { "GL_RED_BITS", GL_RED_BITS }, { "GL_RED_SCALE", GL_RED_SCALE }, { "GL_RENDER", GL_RENDER }, { "GL_RENDER_MODE", GL_RENDER_MODE }, { "GL_RENDERER", GL_RENDERER }, { "GL_REPEAT", GL_REPEAT }, { "GL_REPLACE", GL_REPLACE }, { "GL_RETURN", GL_RETURN }, { "GL_RGB", GL_RGB }, { "GL_RGBA", GL_RGBA }, { "GL_RGBA_MODE", GL_RGBA_MODE }, { "GL_RIGHT", GL_RIGHT }, { "GL_S", GL_S }, { "GL_SHININESS", GL_SHININESS }, { "GL_SPECULAR", GL_SPECULAR }, { "GL_SRC_ALPHA", GL_SRC_ALPHA }, { "GL_SRC_ALPHA_SATURATE", GL_SRC_ALPHA_SATURATE }, { "GL_SRC_COLOR", GL_SRC_COLOR }, { "GL_SCISSOR_BOX", GL_SCISSOR_BOX }, { "GL_SCISSOR_TEST", GL_SCISSOR_TEST }, { "GL_SELECT", GL_SELECT }, { "GL_SET", GL_SET }, { "GL_SHADE_MODEL", GL_SHADE_MODEL }, { "GL_SHORT", GL_SHORT }, { "GL_SMOOTH", GL_SMOOTH }, { "GL_SPHERE_MAP", GL_SPHERE_MAP }, { "GL_SPOT_CUTOFF", GL_SPOT_CUTOFF }, { "GL_SPOT_DIRECTION", GL_SPOT_DIRECTION }, { "GL_SPOT_EXPONENT", GL_SPOT_EXPONENT }, { "GL_STACK_OVERFLOW", GL_STACK_OVERFLOW }, { "GL_STACK_UNDERFLOW", GL_STACK_UNDERFLOW }, { "GL_STENCIL", GL_STENCIL }, { "GL_STENCIL_BITS", GL_STENCIL_BITS }, { "GL_STENCIL_CLEAR_VALUE", GL_STENCIL_CLEAR_VALUE }, { "GL_STENCIL_FAIL", GL_STENCIL_FAIL }, { "GL_STENCIL_FUNC", GL_STENCIL_FUNC }, { "GL_STENCIL_INDEX", GL_STENCIL_INDEX }, { "GL_STENCIL_PASS_DEPTH_FAIL", GL_STENCIL_PASS_DEPTH_FAIL }, { "GL_STENCIL_PASS_DEPTH_PASS", GL_STENCIL_PASS_DEPTH_PASS }, { "GL_STENCIL_REF", GL_STENCIL_REF }, { "GL_STENCIL_TEST", GL_STENCIL_TEST }, { "GL_STENCIL_VALUE_MASK", GL_STENCIL_VALUE_MASK }, { "GL_STENCIL_WRITEMASK", GL_STENCIL_WRITEMASK }, { "GL_STEREO", GL_STEREO }, { "GL_SUBPIXEL_BITS", GL_SUBPIXEL_BITS }, { "GL_T", GL_T }, { "GL_TEXTURE", GL_TEXTURE }, { "GL_TEXTURE_1D", GL_TEXTURE_1D }, { "GL_TEXTURE_2D", GL_TEXTURE_2D }, { "GL_TEXTURE_BORDER", GL_TEXTURE_BORDER }, { "GL_TEXTURE_BORDER_COLOR", GL_TEXTURE_BORDER_COLOR }, { "GL_TEXTURE_COMPONENTS", GL_TEXTURE_COMPONENTS }, { "GL_TEXTURE_ENV", GL_TEXTURE_ENV }, { "GL_TEXTURE_ENV_COLOR", GL_TEXTURE_ENV_COLOR }, { "GL_TEXTURE_ENV_MODE", GL_TEXTURE_ENV_MODE }, { "GL_TEXTURE_GEN_MODE", GL_TEXTURE_GEN_MODE }, { "GL_TEXTURE_GEN_Q", GL_TEXTURE_GEN_Q }, { "GL_TEXTURE_GEN_R", GL_TEXTURE_GEN_R }, { "GL_TEXTURE_GEN_S", GL_TEXTURE_GEN_S }, { "GL_TEXTURE_GEN_T", GL_TEXTURE_GEN_T }, { "GL_TEXTURE_HEIGHT", GL_TEXTURE_HEIGHT }, { "GL_TEXTURE_MAG_FILTER", GL_TEXTURE_MAG_FILTER }, { "GL_TEXTURE_MATRIX", GL_TEXTURE_MATRIX }, { "GL_TEXTURE_MIN_FILTER", GL_TEXTURE_MIN_FILTER }, { "GL_TEXTURE_STACK_DEPTH", GL_TEXTURE_STACK_DEPTH }, { "GL_TEXTURE_WIDTH", GL_TEXTURE_WIDTH }, { "GL_TEXTURE_WRAP_S", GL_TEXTURE_WRAP_S }, { "GL_TEXTURE_WRAP_T", GL_TEXTURE_WRAP_T }, { "GL_TRIANGLES", GL_TRIANGLES }, { "GL_TRIANGLE_FAN", GL_TRIANGLE_FAN }, { "GL_TRIANGLE_STRIP", GL_TRIANGLE_STRIP }, { "GL_UNPACK_ALIGNMENT", GL_UNPACK_ALIGNMENT }, { "GL_UNPACK_LSB_FIRST", GL_UNPACK_LSB_FIRST }, { "GL_UNPACK_ROW_LENGTH", GL_UNPACK_ROW_LENGTH }, { "GL_UNPACK_SKIP_PIXELS", GL_UNPACK_SKIP_PIXELS }, { "GL_UNPACK_SKIP_ROWS", GL_UNPACK_SKIP_ROWS }, { "GL_UNPACK_SWAP_BYTES", GL_UNPACK_SWAP_BYTES }, { "GL_UNSIGNED_BYTE", GL_UNSIGNED_BYTE }, { "GL_UNSIGNED_INT", GL_UNSIGNED_INT }, { "GL_UNSIGNED_SHORT", GL_UNSIGNED_SHORT }, { "GL_VENDOR", GL_VENDOR }, { "GL_VIEWPORT", GL_VIEWPORT }, { "GL_XOR", GL_XOR }, { "GL_ZERO", GL_ZERO }, { "GL_ZOOM_X", GL_ZOOM_X }, { "GL_ZOOM_Y", GL_ZOOM_Y }, { "GL_VERSION", GL_VERSION }, { "Bad enumeration", GL_NULL } }; void AutoClearColor(GLint color) { if (buffer.colorMode == GL_RGB) { glClearColor(colorMap[color][0], colorMap[color][1], colorMap[color][2], 1.0); } else { glClearIndex(color); } } void AutoColor(GLint color) { if (buffer.colorMode == GL_RGB) { glColor4f(colorMap[color][0], colorMap[color][1], colorMap[color][2], 1.0); } else { glIndexi(color); } } long AutoColorCompare(GLfloat buf, GLint color) { if (ABS(buf-(GLfloat)color) < epsilon.zero) { return GL_TRUE; } else { return GL_FALSE; } } void ErrorReport(char *fileName, long line, char *errStr) { char buf[80]; long flag, i, j, k, l; Output(1, " failed.\n"); Output(2, " File - %s, line - %d.\n", fileName, line); if (errStr) { i = 0; while (1) { while (1) { if (errStr[i] == 0x0) { flag = GL_TRUE; break; } else if (errStr[i] != ' ' && errStr[i] != '\n') { flag = GL_FALSE; break; } else { i++; } } if (flag == GL_TRUE) { break; } j = i; k = i; while (1) { while (1) { if (errStr[j] == 0x0 || errStr[j] == '\n') { flag = GL_TRUE; break; } else if (errStr[j] == ' ') { flag = GL_FALSE; break; } else { j++; } } if (j-i+1 > 80-10) { if (k == i) { k = i + 60; for (l = 0; l < 80-10; l++, i++) { buf[l] = errStr[i]; } buf[l] = 0; Output(2, " %s-\n", buf); } else { for (l = 0; i != k; l++, i++) { buf[l] = errStr[i]; } buf[l] = 0; Output(2, " %s\n", buf); } i = k; break; } else { if (flag == GL_TRUE) { for (l = 0; i != j; l++, i++) { buf[l] = errStr[i]; } buf[l] = 0; Output(2, " %s\n", buf); i = j; break; } else { k = j; j++; } } } } } StateReport(); if (machine.pathLevel != 0) { PathReport(); } } void GetEnumName(long value, char *str) { long i; for (i = 0; enumInfo[i].value != GL_NULL; i++) { if (enumInfo[i].value == value) { STRCOPY(str, enumInfo[i].name); return; } } StrMake(str, "%d (%s)", value, enumInfo[i].name); } long GLErrorReport(void) { char buf[40]; long error; error = glGetError(); if (error != GL_NO_ERROR) { Output(1, " failed.\n"); GetEnumName(error, buf); Output(2, " GL Error - %s.\n", buf); StateReport(); if (machine.pathLevel != 0) { PathReport(); } while ((error = glGetError()) != GL_NO_ERROR) { GetEnumName(error, buf); Output(2, " GL Error - %s.\n", buf); } return ERROR; } else { return NO_ERROR; } } void MakeIdentMatrix(GLfloat *buf) { long i; for (i = 0; i < 16; i++) { buf[i] = 0.0; } for (i = 0; i < 4; i++) { buf[i*4+i] = 1.0; } } void Ortho2D(double left, double right, double bottom, double top) { GLfloat m[4][4], deltaX, deltaY; GLint mode; MakeIdentMatrix(&m[0][0]); deltaX = right - left; deltaY = top - bottom; m[0][0] = 2.0 / deltaX; m[3][0] = -(right + left) / deltaX; m[1][1] = 2.0 / deltaY; m[3][1] = -(top + bottom) / deltaY; m[2][2] = -1.0; glGetIntegerv(GL_MATRIX_MODE, &mode); glMatrixMode(GL_PROJECTION); glLoadMatrixf(&m[0][0]); glMatrixMode(mode); } void Ortho3D(double left, double right, double bottom, double top, double zNear, double zFar) { GLfloat m[4][4], deltaX, deltaY, deltaZ; GLint mode; MakeIdentMatrix(&m[0][0]); deltaX = right - left; deltaY = top - bottom; deltaZ = zFar - zNear; m[0][0] = 2.0 / deltaX; m[3][0] = -(right + left) / deltaX; m[1][1] = 2.0 / deltaY; m[3][1] = -(top + bottom) / deltaY; m[2][2] = -2.0 / deltaZ; m[3][2] = -(zFar + zNear) / deltaZ; glGetIntegerv(GL_MATRIX_MODE, &mode); glMatrixMode(GL_PROJECTION); glLoadMatrixf(&m[0][0]); glMatrixMode((GLenum)mode); } void Output(long level, char *format, ...) { va_list args; va_start(args, format); if (machine.verboseLevel >= level) { vprintf(format, args); fflush(stdout); } va_end(args); } GLfloat Random(GLfloat low, GLfloat hi) { GLfloat x; x = (GLfloat)((double)RAND() / RAND_MAX); return (x * (hi - low) + low); } void ReadScreen(GLint x, GLint y, GLsizei w, GLsizei h, GLenum type, GLfloat *buf) { long repeat=1, i, j; switch (type) { case GL_AUTO_COLOR: case GL_COLOR_INDEX: case GL_STENCIL_INDEX: case GL_DEPTH_COMPONENT: case GL_RED: case GL_GREEN: case GL_BLUE: case GL_ALPHA: repeat = 1; break; case GL_RGB: case GL_LUMINANCE: repeat = 3; break; case GL_RGBA: case GL_LUMINANCE_ALPHA: repeat = 4; break; } for (i = 0; i < w*h*repeat; i++) { buf[i] = 0.0; } if (machine.failMode == GL_TRUE) { return; } if (type == GL_AUTO_COLOR) { if (buffer.colorMode == GL_COLOR_INDEX) { GLint *tmpBuf = (GLint *)MALLOC(w*h*sizeof(GLint)); glReadPixels(x, y, w, h, GL_COLOR_INDEX, GL_INT, (GLvoid *)tmpBuf); for (i = 0; i < w*h; i++) { if (tmpBuf[i] < 4) { buf[i] = tmpBuf[i]; } } FREE(tmpBuf); } else { GLfloat *tmpBuf = (GLfloat *)MALLOC(w*h*3*sizeof(GLfloat)); GLfloat *ptr = buf; glReadPixels(x, y, w, h, GL_RGB, GL_FLOAT, (GLvoid *)tmpBuf); for (i = 0; i < w*h*3; i += 3) { for (j = 0; j < 4; j++) { if (ABS(tmpBuf[i]-colorMap[j][0]) < epsilon.zero && ABS(tmpBuf[i+1]-colorMap[j][1]) < epsilon.zero && ABS(tmpBuf[i+2]-colorMap[j][2]) < epsilon.zero) { *ptr = (GLfloat)j; break; } } ptr++; } FREE(tmpBuf); } } else { if (buffer.colorMode == GL_COLOR_INDEX) { if (type == GL_RGB || type == GL_RGBA) { GLint *tmpBuf = (GLint *)MALLOC(w*h*sizeof(GLint)); GLfloat *ptr = buf; long max = (long)POW(2.0, (float)buffer.ciBits) - 1; glReadPixels(x, y, w, h, GL_COLOR_INDEX, GL_INT, (GLvoid *)tmpBuf); for (i = 0; i < w*h; i++) { if (tmpBuf[i] < max) { *ptr++ = colorMap[tmpBuf[i]][0]; *ptr++ = colorMap[tmpBuf[i]][1]; *ptr++ = colorMap[tmpBuf[i]][2]; if (type == GL_RGBA) { *ptr++ = 1.0; } } else { ptr += 3; if (type == GL_RGBA) { ptr++; } } } FREE(tmpBuf); } else { glReadPixels(x, y, w, h, type, GL_FLOAT, (GLvoid *)buf); } } else { glReadPixels(x, y, w, h, type, GL_FLOAT, (GLvoid *)buf); } } } void ResetMatrix(void) { GLfloat buf[16]; MakeIdentMatrix(buf); glMatrixMode(GL_MODELVIEW); glLoadMatrixf(buf); glMatrixMode(GL_PROJECTION); glLoadMatrixf(buf); glMatrixMode(GL_TEXTURE); glLoadMatrixf(buf); } long Round(float x) { return (long)(x + 0.5); } void StrMake(char *str, char *format, ...) { va_list args; va_start(args, format); vsprintf(str, format, args); va_end(args); }