/*
** 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 <windows.h>
#include <stdarg.h>
#include <GL/gl.h>
#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);
}