From 3b5bbd6adfa88366ac290c6c3ae3cfce63729836 Mon Sep 17 00:00:00 2001 From: Dennis Peeten Date: Sat, 22 Mar 2008 12:27:08 +0000 Subject: Initial check-in of headtrack_demo --- headtrack_demo/headtrack_demo.sln | 20 + headtrack_demo/headtrack_demo.vcproj | 207 +++ headtrack_demo/include/glut/GL/fgl.h | 1707 +++++++++++++++++++++ headtrack_demo/include/glut/GL/fglu.h | 210 +++ headtrack_demo/include/glut/GL/fglut.h | 321 ++++ headtrack_demo/include/glut/GL/glsmap.h | 137 ++ headtrack_demo/include/glut/GL/glut.h | 596 +++++++ headtrack_demo/include/glut/GL/tube.h | 201 +++ headtrack_demo/include/wiiuse/wiiuse.h | 632 ++++++++ headtrack_demo/lib/win32/glut/glut32.dll | Bin 0 -> 180224 bytes headtrack_demo/lib/win32/glut/glut32.dll.manifest | 8 + headtrack_demo/lib/win32/glut/glut32.exp | Bin 0 -> 15582 bytes headtrack_demo/lib/win32/glut/glut32.lib | Bin 0 -> 26872 bytes headtrack_demo/lib/win32/wiiuse/wiiuse.dll | Bin 0 -> 114688 bytes headtrack_demo/lib/win32/wiiuse/wiiuse.lib | Bin 0 -> 7956 bytes headtrack_demo/lib/win32/wiiuse/wiiuse_debug.dll | Bin 0 -> 118784 bytes headtrack_demo/src/main.cpp | 411 +++++ 17 files changed, 4450 insertions(+) create mode 100644 headtrack_demo/headtrack_demo.sln create mode 100644 headtrack_demo/headtrack_demo.vcproj create mode 100644 headtrack_demo/include/glut/GL/fgl.h create mode 100644 headtrack_demo/include/glut/GL/fglu.h create mode 100644 headtrack_demo/include/glut/GL/fglut.h create mode 100644 headtrack_demo/include/glut/GL/glsmap.h create mode 100644 headtrack_demo/include/glut/GL/glut.h create mode 100644 headtrack_demo/include/glut/GL/tube.h create mode 100644 headtrack_demo/include/wiiuse/wiiuse.h create mode 100644 headtrack_demo/lib/win32/glut/glut32.dll create mode 100644 headtrack_demo/lib/win32/glut/glut32.dll.manifest create mode 100644 headtrack_demo/lib/win32/glut/glut32.exp create mode 100644 headtrack_demo/lib/win32/glut/glut32.lib create mode 100644 headtrack_demo/lib/win32/wiiuse/wiiuse.dll create mode 100644 headtrack_demo/lib/win32/wiiuse/wiiuse.lib create mode 100644 headtrack_demo/lib/win32/wiiuse/wiiuse_debug.dll create mode 100644 headtrack_demo/src/main.cpp diff --git a/headtrack_demo/headtrack_demo.sln b/headtrack_demo/headtrack_demo.sln new file mode 100644 index 0000000..b666aa0 --- /dev/null +++ b/headtrack_demo/headtrack_demo.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual Studio 2005 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "headtrack_demo", "headtrack_demo.vcproj", "{EC82A014-53F3-4F72-AC71-CB1C9191CDF3}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {EC82A014-53F3-4F72-AC71-CB1C9191CDF3}.Debug|Win32.ActiveCfg = Debug|Win32 + {EC82A014-53F3-4F72-AC71-CB1C9191CDF3}.Debug|Win32.Build.0 = Debug|Win32 + {EC82A014-53F3-4F72-AC71-CB1C9191CDF3}.Release|Win32.ActiveCfg = Release|Win32 + {EC82A014-53F3-4F72-AC71-CB1C9191CDF3}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/headtrack_demo/headtrack_demo.vcproj b/headtrack_demo/headtrack_demo.vcproj new file mode 100644 index 0000000..b599500 --- /dev/null +++ b/headtrack_demo/headtrack_demo.vcproj @@ -0,0 +1,207 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/headtrack_demo/include/glut/GL/fgl.h b/headtrack_demo/include/glut/GL/fgl.h new file mode 100644 index 0000000..d98ba1d --- /dev/null +++ b/headtrack_demo/include/glut/GL/fgl.h @@ -0,0 +1,1707 @@ + +C GLUT version of "GL/fgl.h" + +C Modifications from SGI IRIX 5.3 version: +C 1) F prefix removed from OpenGL constants. +C 2) Constants over 32 characters truncated to 32 characters. + +C *********************************************************** + +C AttribMask + integer*4 GL_CURRENT_BIT + parameter ( GL_CURRENT_BIT = 1 ) + integer*4 GL_POINT_BIT + parameter ( GL_POINT_BIT = 2 ) + integer*4 GL_LINE_BIT + parameter ( GL_LINE_BIT = 4 ) + integer*4 GL_POLYGON_BIT + parameter ( GL_POLYGON_BIT = 8 ) + integer*4 GL_POLYGON_STIPPLE_BIT + parameter ( GL_POLYGON_STIPPLE_BIT = 16 ) + integer*4 GL_PIXEL_MODE_BIT + parameter ( GL_PIXEL_MODE_BIT = 32 ) + integer*4 GL_LIGHTING_BIT + parameter ( GL_LIGHTING_BIT = 64 ) + integer*4 GL_FOG_BIT + parameter ( GL_FOG_BIT = 128 ) + integer*4 GL_DEPTH_BUFFER_BIT + parameter ( GL_DEPTH_BUFFER_BIT = 256 ) + integer*4 GL_ACCUM_BUFFER_BIT + parameter ( GL_ACCUM_BUFFER_BIT = 512 ) + integer*4 GL_STENCIL_BUFFER_BIT + parameter ( GL_STENCIL_BUFFER_BIT = 1024 ) + integer*4 GL_VIEWPORT_BIT + parameter ( GL_VIEWPORT_BIT = 2048 ) + integer*4 GL_TRANSFORM_BIT + parameter ( GL_TRANSFORM_BIT = 4096 ) + integer*4 GL_ENABLE_BIT + parameter ( GL_ENABLE_BIT = 8192 ) + integer*4 GL_COLOR_BUFFER_BIT + parameter ( GL_COLOR_BUFFER_BIT = 16384 ) + integer*4 GL_HINT_BIT + parameter ( GL_HINT_BIT = 32768 ) + integer*4 GL_EVAL_BIT + parameter ( GL_EVAL_BIT = 65536 ) + integer*4 GL_LIST_BIT + parameter ( GL_LIST_BIT = 131072 ) + integer*4 GL_TEXTURE_BIT + parameter ( GL_TEXTURE_BIT = 262144 ) + integer*4 GL_SCISSOR_BIT + parameter ( GL_SCISSOR_BIT = 524288 ) + integer*4 GL_ALL_ATTRIB_BITS + parameter ( GL_ALL_ATTRIB_BITS = 1048575 ) +C GL_MULTISAMPLE_BIT_EXT + +C ClearBufferMask +C GL_COLOR_BUFFER_BIT +C GL_ACCUM_BUFFER_BIT +C GL_STENCIL_BUFFER_BIT +C GL_DEPTH_BUFFER_BIT + +C Boolean + integer*4 GL_FALSE + parameter ( GL_FALSE = 0 ) + integer*4 GL_TRUE + parameter ( GL_TRUE = 1 ) + +C BeginMode + integer*4 GL_POINTS + parameter ( GL_POINTS = 0 ) + integer*4 GL_LINES + parameter ( GL_LINES = 1 ) + integer*4 GL_LINE_LOOP + parameter ( GL_LINE_LOOP = 2 ) + integer*4 GL_LINE_STRIP + parameter ( GL_LINE_STRIP = 3 ) + integer*4 GL_TRIANGLES + parameter ( GL_TRIANGLES = 4 ) + integer*4 GL_TRIANGLE_STRIP + parameter ( GL_TRIANGLE_STRIP = 5 ) + integer*4 GL_TRIANGLE_FAN + parameter ( GL_TRIANGLE_FAN = 6 ) + integer*4 GL_QUADS + parameter ( GL_QUADS = 7 ) + integer*4 GL_QUAD_STRIP + parameter ( GL_QUAD_STRIP = 8 ) + integer*4 GL_POLYGON + parameter ( GL_POLYGON = 9 ) + +C AccumOp + integer*4 GL_ACCUM + parameter ( GL_ACCUM = 256 ) + integer*4 GL_LOAD + parameter ( GL_LOAD = 257 ) + integer*4 GL_RETURN + parameter ( GL_RETURN = 258 ) + integer*4 GL_MULT + parameter ( GL_MULT = 259 ) + integer*4 GL_ADD + parameter ( GL_ADD = 260 ) + +C AlphaFunction + integer*4 GL_NEVER + parameter ( GL_NEVER = 512 ) + integer*4 GL_LESS + parameter ( GL_LESS = 513 ) + integer*4 GL_EQUAL + parameter ( GL_EQUAL = 514 ) + integer*4 GL_LEQUAL + parameter ( GL_LEQUAL = 515 ) + integer*4 GL_GREATER + parameter ( GL_GREATER = 516 ) + integer*4 GL_NOTEQUAL + parameter ( GL_NOTEQUAL = 517 ) + integer*4 GL_GEQUAL + parameter ( GL_GEQUAL = 518 ) + integer*4 GL_ALWAYS + parameter ( GL_ALWAYS = 519 ) + +C BlendingFactorDest + integer*4 GL_ZERO + parameter ( GL_ZERO = 0 ) + integer*4 GL_ONE + parameter ( GL_ONE = 1 ) + integer*4 GL_SRC_COLOR + parameter ( GL_SRC_COLOR = 768 ) + integer*4 GL_ONE_MINUS_SRC_COLOR + parameter ( GL_ONE_MINUS_SRC_COLOR = 769 ) + integer*4 GL_SRC_ALPHA + parameter ( GL_SRC_ALPHA = 770 ) + integer*4 GL_ONE_MINUS_SRC_ALPHA + parameter ( GL_ONE_MINUS_SRC_ALPHA = 771 ) + integer*4 GL_DST_ALPHA + parameter ( GL_DST_ALPHA = 772 ) + integer*4 GL_ONE_MINUS_DST_ALPHA + parameter ( GL_ONE_MINUS_DST_ALPHA = 773 ) +C GL_CONSTANT_COLOR_EXT +C GL_ONE_MINUS_CONSTANT_COLOR_EXT +C GL_CONSTANT_ALPHA_EXT +C GL_ONE_MINUS_CONSTANT_ALPHA_EXT + +C BlendingFactorSrc +C GL_ZERO +C GL_ONE + integer*4 GL_DST_COLOR + parameter ( GL_DST_COLOR = 774 ) + integer*4 GL_ONE_MINUS_DST_COLOR + parameter ( GL_ONE_MINUS_DST_COLOR = 775 ) + integer*4 GL_SRC_ALPHA_SATURATE + parameter ( GL_SRC_ALPHA_SATURATE = 776 ) +C GL_SRC_ALPHA +C GL_ONE_MINUS_SRC_ALPHA +C GL_DST_ALPHA +C GL_ONE_MINUS_DST_ALPHA +C GL_CONSTANT_COLOR_EXT +C GL_ONE_MINUS_CONSTANT_COLOR_EXT +C GL_CONSTANT_ALPHA_EXT +C GL_ONE_MINUS_CONSTANT_ALPHA_EXT + +C BlendingMode +C GL_LOGIC_OP +C GL_FUNC_ADD_EXT +C GL_MIN_EXT +C GL_MAX_EXT +C GL_FUNC_SUBTRACT_EXT +C GL_FUNC_REVERSE_SUBTRACT_EXT + +C ColorMaterialFace +C GL_FRONT +C GL_BACK +C GL_FRONT_AND_BACK + +C ColorMaterialParameter +C GL_AMBIENT +C GL_DIFFUSE +C GL_SPECULAR +C GL_EMISSION +C GL_AMBIENT_AND_DIFFUSE + +C ConvolutionBorderMode +C GL_REDUCE_EXT + +C ConvolutionParameter +C GL_CONVOLUTION_BORDER_MODE_EXT +C GL_CONVOLUTION_FILTER_SCALE_EXT +C GL_CONVOLUTION_FILTER_BIAS_EXT + +C ConvolutionTarget +C GL_CONVOLUTION_1D_EXT +C GL_CONVOLUTION_2D_EXT + +C CullFaceMode +C GL_FRONT +C GL_BACK +C GL_FRONT_AND_BACK + +C DepthFunction +C GL_NEVER +C GL_LESS +C GL_EQUAL +C GL_LEQUAL +C GL_GREATER +C GL_NOTEQUAL +C GL_GEQUAL +C GL_ALWAYS + +C DrawBufferMode + integer*4 GL_NONE + parameter ( GL_NONE = 0 ) + integer*4 GL_FRONT_LEFT + parameter ( GL_FRONT_LEFT = 1024 ) + integer*4 GL_FRONT_RIGHT + parameter ( GL_FRONT_RIGHT = 1025 ) + integer*4 GL_BACK_LEFT + parameter ( GL_BACK_LEFT = 1026 ) + integer*4 GL_BACK_RIGHT + parameter ( GL_BACK_RIGHT = 1027 ) + integer*4 GL_FRONT + parameter ( GL_FRONT = 1028 ) + integer*4 GL_BACK + parameter ( GL_BACK = 1029 ) + integer*4 GL_LEFT + parameter ( GL_LEFT = 1030 ) + integer*4 GL_RIGHT + parameter ( GL_RIGHT = 1031 ) + integer*4 GL_FRONT_AND_BACK + parameter ( GL_FRONT_AND_BACK = 1032 ) + integer*4 GL_AUX0 + parameter ( GL_AUX0 = 1033 ) + integer*4 GL_AUX1 + parameter ( GL_AUX1 = 1034 ) + integer*4 GL_AUX2 + parameter ( GL_AUX2 = 1035 ) + integer*4 GL_AUX3 + parameter ( GL_AUX3 = 1036 ) + +C Enable +C GL_FOG +C GL_LIGHTING +C GL_TEXTURE_1D +C GL_TEXTURE_2D +C GL_LINE_STIPPLE +C GL_POLYGON_STIPPLE +C GL_CULL_FACE +C GL_ALPHA_TEST +C GL_BLEND +C GL_LOGIC_OP +C GL_DITHER +C GL_STENCIL_TEST +C GL_DEPTH_TEST +C GL_CLIP_PLANE0 +C GL_CLIP_PLANE1 +C GL_CLIP_PLANE2 +C GL_CLIP_PLANE3 +C GL_CLIP_PLANE4 +C GL_CLIP_PLANE5 +C GL_LIGHT0 +C GL_LIGHT1 +C GL_LIGHT2 +C GL_LIGHT3 +C GL_LIGHT4 +C GL_LIGHT5 +C GL_LIGHT6 +C GL_LIGHT7 +C GL_TEXTURE_GEN_S +C GL_TEXTURE_GEN_T +C GL_TEXTURE_GEN_R +C GL_TEXTURE_GEN_Q +C GL_MAP1_VERTEX_3 +C GL_MAP1_VERTEX_4 +C GL_MAP1_COLOR_4 +C GL_MAP1_INDEX +C GL_MAP1_NORMAL +C GL_MAP1_TEXTURE_COORD_1 +C GL_MAP1_TEXTURE_COORD_2 +C GL_MAP1_TEXTURE_COORD_3 +C GL_MAP1_TEXTURE_COORD_4 +C GL_MAP2_VERTEX_3 +C GL_MAP2_VERTEX_4 +C GL_MAP2_COLOR_4 +C GL_MAP2_INDEX +C GL_MAP2_NORMAL +C GL_MAP2_TEXTURE_COORD_1 +C GL_MAP2_TEXTURE_COORD_2 +C GL_MAP2_TEXTURE_COORD_3 +C GL_MAP2_TEXTURE_COORD_4 +C GL_POINT_SMOOTH +C GL_LINE_SMOOTH +C GL_POLYGON_SMOOTH +C GL_SCISSOR_TEST +C GL_COLOR_MATERIAL +C GL_NORMALIZE +C GL_AUTO_NORMAL +C GL_CONVOLUTION_1D_EXT +C GL_CONVOLUTION_2D_EXT +C GL_SEPARABLE_2D_EXT +C GL_HISTOGRAM_EXT +C GL_MINMAX_EXT +C GL_POLYGON_OFFSET_EXT +C GL_TEXTURE_3D_EXT +C GL_MULTISAMPLE_SGIS +C GL_SAMPLE_ALPHA_TO_MASK_SGIS +C GL_SAMPLE_ALPHA_TO_ONE_SGIS +C GL_SAMPLE_MASK_SGIS + +C ErrorCode + integer*4 GL_NO_ERROR + parameter ( GL_NO_ERROR = 0 ) + integer*4 GL_INVALID_ENUM + parameter ( GL_INVALID_ENUM = 1280 ) + integer*4 GL_INVALID_VALUE + parameter ( GL_INVALID_VALUE = 1281 ) + integer*4 GL_INVALID_OPERATION + parameter ( GL_INVALID_OPERATION = 1282 ) + integer*4 GL_STACK_OVERFLOW + parameter ( GL_STACK_OVERFLOW = 1283 ) + integer*4 GL_STACK_UNDERFLOW + parameter ( GL_STACK_UNDERFLOW = 1284 ) + integer*4 GL_OUT_OF_MEMORY + parameter ( GL_OUT_OF_MEMORY = 1285 ) +C GL_TABLE_TOO_LARGE_EXT +C GL_TEXTURE_TOO_LARGE_EXT + +C FeedBackMode + integer*4 GL_2D + parameter ( GL_2D = 1536 ) + integer*4 GL_3D + parameter ( GL_3D = 1537 ) + integer*4 GL_3D_COLOR + parameter ( GL_3D_COLOR = 1538 ) + integer*4 GL_3D_COLOR_TEXTURE + parameter ( GL_3D_COLOR_TEXTURE = 1539 ) + integer*4 GL_4D_COLOR_TEXTURE + parameter ( GL_4D_COLOR_TEXTURE = 1540 ) + +C FeedBackToken + integer*4 GL_PASS_THROUGH_TOKEN + parameter ( GL_PASS_THROUGH_TOKEN = 1792 ) + integer*4 GL_POINT_TOKEN + parameter ( GL_POINT_TOKEN = 1793 ) + integer*4 GL_LINE_TOKEN + parameter ( GL_LINE_TOKEN = 1794 ) + integer*4 GL_POLYGON_TOKEN + parameter ( GL_POLYGON_TOKEN = 1795 ) + integer*4 GL_BITMAP_TOKEN + parameter ( GL_BITMAP_TOKEN = 1796 ) + integer*4 GL_DRAW_PIXEL_TOKEN + parameter ( GL_DRAW_PIXEL_TOKEN = 1797 ) + integer*4 GL_COPY_PIXEL_TOKEN + parameter ( GL_COPY_PIXEL_TOKEN = 1798 ) + integer*4 GL_LINE_RESET_TOKEN + parameter ( GL_LINE_RESET_TOKEN = 1799 ) + +C FogMode +C GL_LINEAR + integer*4 GL_EXP + parameter ( GL_EXP = 2048 ) + integer*4 GL_EXP2 + parameter ( GL_EXP2 = 2049 ) + +C FogParameter +C GL_FOG_COLOR +C GL_FOG_DENSITY +C GL_FOG_END +C GL_FOG_INDEX +C GL_FOG_MODE +C GL_FOG_START + +C FrontFaceDirection + integer*4 GL_CW + parameter ( GL_CW = 2304 ) + integer*4 GL_CCW + parameter ( GL_CCW = 2305 ) + +C GetConvolutionParameter +C GL_CONVOLUTION_BORDER_MODE_EXT +C GL_CONVOLUTION_FILTER_SCALE_EXT +C GL_CONVOLUTION_FILTER_BIAS_EXT +C GL_CONVOLUTION_FORMAT_EXT +C GL_CONVOLUTION_WIDTH_EXT +C GL_CONVOLUTION_HEIGHT_EXT +C GL_MAX_CONVOLUTION_WIDTH_EXT +C GL_MAX_CONVOLUTION_HEIGHT_EXT + +C GetHistogramParameter +C GL_HISTOGRAM_WIDTH_EXT +C GL_HISTOGRAM_FORMAT_EXT +C GL_HISTOGRAM_RED_SIZE_EXT +C GL_HISTOGRAM_GREEN_SIZE_EXT +C GL_HISTOGRAM_BLUE_SIZE_EXT +C GL_HISTOGRAM_ALPHA_SIZE_EXT +C GL_HISTOGRAM_LUMINANCE_SIZE_EXT +C GL_HISTOGRAM_SINK_EXT + +C GetMapTarget + integer*4 GL_COEFF + parameter ( GL_COEFF = 2560 ) + integer*4 GL_ORDER + parameter ( GL_ORDER = 2561 ) + integer*4 GL_DOMAIN + parameter ( GL_DOMAIN = 2562 ) + +C GetMinmaxParameter +C GL_MINMAX_FORMAT_EXT +C GL_MINMAX_SINK_EXT + +C GetPixelMap + integer*4 GL_PIXEL_MAP_I_TO_I + parameter ( GL_PIXEL_MAP_I_TO_I = 3184 ) + integer*4 GL_PIXEL_MAP_S_TO_S + parameter ( GL_PIXEL_MAP_S_TO_S = 3185 ) + integer*4 GL_PIXEL_MAP_I_TO_R + parameter ( GL_PIXEL_MAP_I_TO_R = 3186 ) + integer*4 GL_PIXEL_MAP_I_TO_G + parameter ( GL_PIXEL_MAP_I_TO_G = 3187 ) + integer*4 GL_PIXEL_MAP_I_TO_B + parameter ( GL_PIXEL_MAP_I_TO_B = 3188 ) + integer*4 GL_PIXEL_MAP_I_TO_A + parameter ( GL_PIXEL_MAP_I_TO_A = 3189 ) + integer*4 GL_PIXEL_MAP_R_TO_R + parameter ( GL_PIXEL_MAP_R_TO_R = 3190 ) + integer*4 GL_PIXEL_MAP_G_TO_G + parameter ( GL_PIXEL_MAP_G_TO_G = 3191 ) + integer*4 GL_PIXEL_MAP_B_TO_B + parameter ( GL_PIXEL_MAP_B_TO_B = 3192 ) + integer*4 GL_PIXEL_MAP_A_TO_A + parameter ( GL_PIXEL_MAP_A_TO_A = 3193 ) + +C GetTarget + integer*4 GL_CURRENT_COLOR + parameter ( GL_CURRENT_COLOR = 2816 ) + integer*4 GL_CURRENT_INDEX + parameter ( GL_CURRENT_INDEX = 2817 ) + integer*4 GL_CURRENT_NORMAL + parameter ( GL_CURRENT_NORMAL = 2818 ) + integer*4 GL_CURRENT_TEXTURE_COORDS + parameter ( GL_CURRENT_TEXTURE_COORDS = 2819 ) + integer*4 GL_CURRENT_RASTER_COLOR + parameter ( GL_CURRENT_RASTER_COLOR = 2820 ) + integer*4 GL_CURRENT_RASTER_INDEX + parameter ( GL_CURRENT_RASTER_INDEX = 2821 ) + integer*4 GL_CURRENT_RASTER_TEXTURE_COORDS + parameter ( GL_CURRENT_RASTER_TEXTURE_COORDS = 2822 ) + integer*4 GL_CURRENT_RASTER_POSITION + parameter ( GL_CURRENT_RASTER_POSITION = 2823 ) + integer*4 GL_CURRENT_RASTER_POSITION_VALID + parameter ( GL_CURRENT_RASTER_POSITION_VALID = 2824 ) + integer*4 GL_CURRENT_RASTER_DISTANCE + parameter ( GL_CURRENT_RASTER_DISTANCE = 2825 ) + integer*4 GL_POINT_SMOOTH + parameter ( GL_POINT_SMOOTH = 2832 ) + integer*4 GL_POINT_SIZE + parameter ( GL_POINT_SIZE = 2833 ) + integer*4 GL_POINT_SIZE_RANGE + parameter ( GL_POINT_SIZE_RANGE = 2834 ) + integer*4 GL_POINT_SIZE_GRANULARITY + parameter ( GL_POINT_SIZE_GRANULARITY = 2835 ) + integer*4 GL_LINE_SMOOTH + parameter ( GL_LINE_SMOOTH = 2848 ) + integer*4 GL_LINE_WIDTH + parameter ( GL_LINE_WIDTH = 2849 ) + integer*4 GL_LINE_WIDTH_RANGE + parameter ( GL_LINE_WIDTH_RANGE = 2850 ) + integer*4 GL_LINE_WIDTH_GRANULARITY + parameter ( GL_LINE_WIDTH_GRANULARITY = 2851 ) + integer*4 GL_LINE_STIPPLE + parameter ( GL_LINE_STIPPLE = 2852 ) + integer*4 GL_LINE_STIPPLE_PATTERN + parameter ( GL_LINE_STIPPLE_PATTERN = 2853 ) + integer*4 GL_LINE_STIPPLE_REPEAT + parameter ( GL_LINE_STIPPLE_REPEAT = 2854 ) + integer*4 GL_LIST_MODE + parameter ( GL_LIST_MODE = 2864 ) + integer*4 GL_MAX_LIST_NESTING + parameter ( GL_MAX_LIST_NESTING = 2865 ) + integer*4 GL_LIST_BASE + parameter ( GL_LIST_BASE = 2866 ) + integer*4 GL_LIST_INDEX + parameter ( GL_LIST_INDEX = 2867 ) + integer*4 GL_POLYGON_MODE + parameter ( GL_POLYGON_MODE = 2880 ) + integer*4 GL_POLYGON_SMOOTH + parameter ( GL_POLYGON_SMOOTH = 2881 ) + integer*4 GL_POLYGON_STIPPLE + parameter ( GL_POLYGON_STIPPLE = 2882 ) + integer*4 GL_EDGE_FLAG + parameter ( GL_EDGE_FLAG = 2883 ) + integer*4 GL_CULL_FACE + parameter ( GL_CULL_FACE = 2884 ) + integer*4 GL_CULL_FACE_MODE + parameter ( GL_CULL_FACE_MODE = 2885 ) + integer*4 GL_FRONT_FACE + parameter ( GL_FRONT_FACE = 2886 ) + integer*4 GL_LIGHTING + parameter ( GL_LIGHTING = 2896 ) + integer*4 GL_LIGHT_MODEL_LOCAL_VIEWER + parameter ( GL_LIGHT_MODEL_LOCAL_VIEWER = 2897 ) + integer*4 GL_LIGHT_MODEL_TWO_SIDE + parameter ( GL_LIGHT_MODEL_TWO_SIDE = 2898 ) + integer*4 GL_LIGHT_MODEL_AMBIENT + parameter ( GL_LIGHT_MODEL_AMBIENT = 2899 ) + integer*4 GL_SHADE_MODEL + parameter ( GL_SHADE_MODEL = 2900 ) + integer*4 GL_COLOR_MATERIAL_FACE + parameter ( GL_COLOR_MATERIAL_FACE = 2901 ) + integer*4 GL_COLOR_MATERIAL_PARAMETER + parameter ( GL_COLOR_MATERIAL_PARAMETER = 2902 ) + integer*4 GL_COLOR_MATERIAL + parameter ( GL_COLOR_MATERIAL = 2903 ) + integer*4 GL_FOG + parameter ( GL_FOG = 2912 ) + integer*4 GL_FOG_INDEX + parameter ( GL_FOG_INDEX = 2913 ) + integer*4 GL_FOG_DENSITY + parameter ( GL_FOG_DENSITY = 2914 ) + integer*4 GL_FOG_START + parameter ( GL_FOG_START = 2915 ) + integer*4 GL_FOG_END + parameter ( GL_FOG_END = 2916 ) + integer*4 GL_FOG_MODE + parameter ( GL_FOG_MODE = 2917 ) + integer*4 GL_FOG_COLOR + parameter ( GL_FOG_COLOR = 2918 ) + integer*4 GL_DEPTH_RANGE + parameter ( GL_DEPTH_RANGE = 2928 ) + integer*4 GL_DEPTH_TEST + parameter ( GL_DEPTH_TEST = 2929 ) + integer*4 GL_DEPTH_WRITEMASK + parameter ( GL_DEPTH_WRITEMASK = 2930 ) + integer*4 GL_DEPTH_CLEAR_VALUE + parameter ( GL_DEPTH_CLEAR_VALUE = 2931 ) + integer*4 GL_DEPTH_FUNC + parameter ( GL_DEPTH_FUNC = 2932 ) + integer*4 GL_ACCUM_CLEAR_VALUE + parameter ( GL_ACCUM_CLEAR_VALUE = 2944 ) + integer*4 GL_STENCIL_TEST + parameter ( GL_STENCIL_TEST = 2960 ) + integer*4 GL_STENCIL_CLEAR_VALUE + parameter ( GL_STENCIL_CLEAR_VALUE = 2961 ) + integer*4 GL_STENCIL_FUNC + parameter ( GL_STENCIL_FUNC = 2962 ) + integer*4 GL_STENCIL_VALUE_MASK + parameter ( GL_STENCIL_VALUE_MASK = 2963 ) + integer*4 GL_STENCIL_FAIL + parameter ( GL_STENCIL_FAIL = 2964 ) + integer*4 GL_STENCIL_PASS_DEPTH_FAIL + parameter ( GL_STENCIL_PASS_DEPTH_FAIL = 2965 ) + integer*4 GL_STENCIL_PASS_DEPTH_PASS + parameter ( GL_STENCIL_PASS_DEPTH_PASS = 2966 ) + integer*4 GL_STENCIL_REF + parameter ( GL_STENCIL_REF = 2967 ) + integer*4 GL_STENCIL_WRITEMASK + parameter ( GL_STENCIL_WRITEMASK = 2968 ) + integer*4 GL_MATRIX_MODE + parameter ( GL_MATRIX_MODE = 2976 ) + integer*4 GL_NORMALIZE + parameter ( GL_NORMALIZE = 2977 ) + integer*4 GL_VIEWPORT + parameter ( GL_VIEWPORT = 2978 ) + integer*4 GL_MODELVIEW_STACK_DEPTH + parameter ( GL_MODELVIEW_STACK_DEPTH = 2979 ) + integer*4 GL_PROJECTION_STACK_DEPTH + parameter ( GL_PROJECTION_STACK_DEPTH = 2980 ) + integer*4 GL_TEXTURE_STACK_DEPTH + parameter ( GL_TEXTURE_STACK_DEPTH = 2981 ) + integer*4 GL_MODELVIEW_MATRIX + parameter ( GL_MODELVIEW_MATRIX = 2982 ) + integer*4 GL_PROJECTION_MATRIX + parameter ( GL_PROJECTION_MATRIX = 2983 ) + integer*4 GL_TEXTURE_MATRIX + parameter ( GL_TEXTURE_MATRIX = 2984 ) + integer*4 GL_ATTRIB_STACK_DEPTH + parameter ( GL_ATTRIB_STACK_DEPTH = 2992 ) + integer*4 GL_ALPHA_TEST + parameter ( GL_ALPHA_TEST = 3008 ) + integer*4 GL_ALPHA_TEST_FUNC + parameter ( GL_ALPHA_TEST_FUNC = 3009 ) + integer*4 GL_ALPHA_TEST_REF + parameter ( GL_ALPHA_TEST_REF = 3010 ) + integer*4 GL_DITHER + parameter ( GL_DITHER = 3024 ) + integer*4 GL_BLEND_DST + parameter ( GL_BLEND_DST = 3040 ) + integer*4 GL_BLEND_SRC + parameter ( GL_BLEND_SRC = 3041 ) + integer*4 GL_BLEND + parameter ( GL_BLEND = 3042 ) + integer*4 GL_LOGIC_OP_MODE + parameter ( GL_LOGIC_OP_MODE = 3056 ) + integer*4 GL_LOGIC_OP + parameter ( GL_LOGIC_OP = 3057 ) + integer*4 GL_AUX_BUFFERS + parameter ( GL_AUX_BUFFERS = 3072 ) + integer*4 GL_DRAW_BUFFER + parameter ( GL_DRAW_BUFFER = 3073 ) + integer*4 GL_READ_BUFFER + parameter ( GL_READ_BUFFER = 3074 ) + integer*4 GL_SCISSOR_BOX + parameter ( GL_SCISSOR_BOX = 3088 ) + integer*4 GL_SCISSOR_TEST + parameter ( GL_SCISSOR_TEST = 3089 ) + integer*4 GL_INDEX_CLEAR_VALUE + parameter ( GL_INDEX_CLEAR_VALUE = 3104 ) + integer*4 GL_INDEX_WRITEMASK + parameter ( GL_INDEX_WRITEMASK = 3105 ) + integer*4 GL_COLOR_CLEAR_VALUE + parameter ( GL_COLOR_CLEAR_VALUE = 3106 ) + integer*4 GL_COLOR_WRITEMASK + parameter ( GL_COLOR_WRITEMASK = 3107 ) + integer*4 GL_INDEX_MODE + parameter ( GL_INDEX_MODE = 3120 ) + integer*4 GL_RGBA_MODE + parameter ( GL_RGBA_MODE = 3121 ) + integer*4 GL_DOUBLEBUFFER + parameter ( GL_DOUBLEBUFFER = 3122 ) + integer*4 GL_STEREO + parameter ( GL_STEREO = 3123 ) + integer*4 GL_RENDER_MODE + parameter ( GL_RENDER_MODE = 3136 ) + integer*4 GL_PERSPECTIVE_CORRECTION_HINT + parameter ( GL_PERSPECTIVE_CORRECTION_HINT = 3152 ) + integer*4 GL_POINT_SMOOTH_HINT + parameter ( GL_POINT_SMOOTH_HINT = 3153 ) + integer*4 GL_LINE_SMOOTH_HINT + parameter ( GL_LINE_SMOOTH_HINT = 3154 ) + integer*4 GL_POLYGON_SMOOTH_HINT + parameter ( GL_POLYGON_SMOOTH_HINT = 3155 ) + integer*4 GL_FOG_HINT + parameter ( GL_FOG_HINT = 3156 ) + integer*4 GL_TEXTURE_GEN_S + parameter ( GL_TEXTURE_GEN_S = 3168 ) + integer*4 GL_TEXTURE_GEN_T + parameter ( GL_TEXTURE_GEN_T = 3169 ) + integer*4 GL_TEXTURE_GEN_R + parameter ( GL_TEXTURE_GEN_R = 3170 ) + integer*4 GL_TEXTURE_GEN_Q + parameter ( GL_TEXTURE_GEN_Q = 3171 ) + integer*4 GL_PIXEL_MAP_I_TO_I_SIZE + parameter ( GL_PIXEL_MAP_I_TO_I_SIZE = 3248 ) + integer*4 GL_PIXEL_MAP_S_TO_S_SIZE + parameter ( GL_PIXEL_MAP_S_TO_S_SIZE = 3249 ) + integer*4 GL_PIXEL_MAP_I_TO_R_SIZE + parameter ( GL_PIXEL_MAP_I_TO_R_SIZE = 3250 ) + integer*4 GL_PIXEL_MAP_I_TO_G_SIZE + parameter ( GL_PIXEL_MAP_I_TO_G_SIZE = 3251 ) + integer*4 GL_PIXEL_MAP_I_TO_B_SIZE + parameter ( GL_PIXEL_MAP_I_TO_B_SIZE = 3252 ) + integer*4 GL_PIXEL_MAP_I_TO_A_SIZE + parameter ( GL_PIXEL_MAP_I_TO_A_SIZE = 3253 ) + integer*4 GL_PIXEL_MAP_R_TO_R_SIZE + parameter ( GL_PIXEL_MAP_R_TO_R_SIZE = 3254 ) + integer*4 GL_PIXEL_MAP_G_TO_G_SIZE + parameter ( GL_PIXEL_MAP_G_TO_G_SIZE = 3255 ) + integer*4 GL_PIXEL_MAP_B_TO_B_SIZE + parameter ( GL_PIXEL_MAP_B_TO_B_SIZE = 3256 ) + integer*4 GL_PIXEL_MAP_A_TO_A_SIZE + parameter ( GL_PIXEL_MAP_A_TO_A_SIZE = 3257 ) + integer*4 GL_UNPACK_SWAP_BYTES + parameter ( GL_UNPACK_SWAP_BYTES = 3312 ) + integer*4 GL_UNPACK_LSB_FIRST + parameter ( GL_UNPACK_LSB_FIRST = 3313 ) + integer*4 GL_UNPACK_ROW_LENGTH + parameter ( GL_UNPACK_ROW_LENGTH = 3314 ) + integer*4 GL_UNPACK_SKIP_ROWS + parameter ( GL_UNPACK_SKIP_ROWS = 3315 ) + integer*4 GL_UNPACK_SKIP_PIXELS + parameter ( GL_UNPACK_SKIP_PIXELS = 3316 ) + integer*4 GL_UNPACK_ALIGNMENT + parameter ( GL_UNPACK_ALIGNMENT = 3317 ) + integer*4 GL_PACK_SWAP_BYTES + parameter ( GL_PACK_SWAP_BYTES = 3328 ) + integer*4 GL_PACK_LSB_FIRST + parameter ( GL_PACK_LSB_FIRST = 3329 ) + integer*4 GL_PACK_ROW_LENGTH + parameter ( GL_PACK_ROW_LENGTH = 3330 ) + integer*4 GL_PACK_SKIP_ROWS + parameter ( GL_PACK_SKIP_ROWS = 3331 ) + integer*4 GL_PACK_SKIP_PIXELS + parameter ( GL_PACK_SKIP_PIXELS = 3332 ) + integer*4 GL_PACK_ALIGNMENT + parameter ( GL_PACK_ALIGNMENT = 3333 ) + integer*4 GL_MAP_COLOR + parameter ( GL_MAP_COLOR = 3344 ) + integer*4 GL_MAP_STENCIL + parameter ( GL_MAP_STENCIL = 3345 ) + integer*4 GL_INDEX_SHIFT + parameter ( GL_INDEX_SHIFT = 3346 ) + integer*4 GL_INDEX_OFFSET + parameter ( GL_INDEX_OFFSET = 3347 ) + integer*4 GL_RED_SCALE + parameter ( GL_RED_SCALE = 3348 ) + integer*4 GL_RED_BIAS + parameter ( GL_RED_BIAS = 3349 ) + integer*4 GL_ZOOM_X + parameter ( GL_ZOOM_X = 3350 ) + integer*4 GL_ZOOM_Y + parameter ( GL_ZOOM_Y = 3351 ) + integer*4 GL_GREEN_SCALE + parameter ( GL_GREEN_SCALE = 3352 ) + integer*4 GL_GREEN_BIAS + parameter ( GL_GREEN_BIAS = 3353 ) + integer*4 GL_BLUE_SCALE + parameter ( GL_BLUE_SCALE = 3354 ) + integer*4 GL_BLUE_BIAS + parameter ( GL_BLUE_BIAS = 3355 ) + integer*4 GL_ALPHA_SCALE + parameter ( GL_ALPHA_SCALE = 3356 ) + integer*4 GL_ALPHA_BIAS + parameter ( GL_ALPHA_BIAS = 3357 ) + integer*4 GL_DEPTH_SCALE + parameter ( GL_DEPTH_SCALE = 3358 ) + integer*4 GL_DEPTH_BIAS + parameter ( GL_DEPTH_BIAS = 3359 ) + integer*4 GL_MAX_EVAL_ORDER + parameter ( GL_MAX_EVAL_ORDER = 3376 ) + integer*4 GL_MAX_LIGHTS + parameter ( GL_MAX_LIGHTS = 3377 ) + integer*4 GL_MAX_CLIP_PLANES + parameter ( GL_MAX_CLIP_PLANES = 3378 ) + integer*4 GL_MAX_TEXTURE_SIZE + parameter ( GL_MAX_TEXTURE_SIZE = 3379 ) + integer*4 GL_MAX_PIXEL_MAP_TABLE + parameter ( GL_MAX_PIXEL_MAP_TABLE = 3380 ) + integer*4 GL_MAX_ATTRIB_STACK_DEPTH + parameter ( GL_MAX_ATTRIB_STACK_DEPTH = 3381 ) + integer*4 GL_MAX_MODELVIEW_STACK_DEPTH + parameter ( GL_MAX_MODELVIEW_STACK_DEPTH = 3382 ) + integer*4 GL_MAX_NAME_STACK_DEPTH + parameter ( GL_MAX_NAME_STACK_DEPTH = 3383 ) + integer*4 GL_MAX_PROJECTION_STACK_DEPTH + parameter ( GL_MAX_PROJECTION_STACK_DEPTH = 3384 ) + integer*4 GL_MAX_TEXTURE_STACK_DEPTH + parameter ( GL_MAX_TEXTURE_STACK_DEPTH = 3385 ) + integer*4 GL_MAX_VIEWPORT_DIMS + parameter ( GL_MAX_VIEWPORT_DIMS = 3386 ) + integer*4 GL_SUBPIXEL_BITS + parameter ( GL_SUBPIXEL_BITS = 3408 ) + integer*4 GL_INDEX_BITS + parameter ( GL_INDEX_BITS = 3409 ) + integer*4 GL_RED_BITS + parameter ( GL_RED_BITS = 3410 ) + integer*4 GL_GREEN_BITS + parameter ( GL_GREEN_BITS = 3411 ) + integer*4 GL_BLUE_BITS + parameter ( GL_BLUE_BITS = 3412 ) + integer*4 GL_ALPHA_BITS + parameter ( GL_ALPHA_BITS = 3413 ) + integer*4 GL_DEPTH_BITS + parameter ( GL_DEPTH_BITS = 3414 ) + integer*4 GL_STENCIL_BITS + parameter ( GL_STENCIL_BITS = 3415 ) + integer*4 GL_ACCUM_RED_BITS + parameter ( GL_ACCUM_RED_BITS = 3416 ) + integer*4 GL_ACCUM_GREEN_BITS + parameter ( GL_ACCUM_GREEN_BITS = 3417 ) + integer*4 GL_ACCUM_BLUE_BITS + parameter ( GL_ACCUM_BLUE_BITS = 3418 ) + integer*4 GL_ACCUM_ALPHA_BITS + parameter ( GL_ACCUM_ALPHA_BITS = 3419 ) + integer*4 GL_NAME_STACK_DEPTH + parameter ( GL_NAME_STACK_DEPTH = 3440 ) + integer*4 GL_AUTO_NORMAL + parameter ( GL_AUTO_NORMAL = 3456 ) + integer*4 GL_MAP1_COLOR_4 + parameter ( GL_MAP1_COLOR_4 = 3472 ) + integer*4 GL_MAP1_INDEX + parameter ( GL_MAP1_INDEX = 3473 ) + integer*4 GL_MAP1_NORMAL + parameter ( GL_MAP1_NORMAL = 3474 ) + integer*4 GL_MAP1_TEXTURE_COORD_1 + parameter ( GL_MAP1_TEXTURE_COORD_1 = 3475 ) + integer*4 GL_MAP1_TEXTURE_COORD_2 + parameter ( GL_MAP1_TEXTURE_COORD_2 = 3476 ) + integer*4 GL_MAP1_TEXTURE_COORD_3 + parameter ( GL_MAP1_TEXTURE_COORD_3 = 3477 ) + integer*4 GL_MAP1_TEXTURE_COORD_4 + parameter ( GL_MAP1_TEXTURE_COORD_4 = 3478 ) + integer*4 GL_MAP1_VERTEX_3 + parameter ( GL_MAP1_VERTEX_3 = 3479 ) + integer*4 GL_MAP1_VERTEX_4 + parameter ( GL_MAP1_VERTEX_4 = 3480 ) + integer*4 GL_MAP2_COLOR_4 + parameter ( GL_MAP2_COLOR_4 = 3504 ) + integer*4 GL_MAP2_INDEX + parameter ( GL_MAP2_INDEX = 3505 ) + integer*4 GL_MAP2_NORMAL + parameter ( GL_MAP2_NORMAL = 3506 ) + integer*4 GL_MAP2_TEXTURE_COORD_1 + parameter ( GL_MAP2_TEXTURE_COORD_1 = 3507 ) + integer*4 GL_MAP2_TEXTURE_COORD_2 + parameter ( GL_MAP2_TEXTURE_COORD_2 = 3508 ) + integer*4 GL_MAP2_TEXTURE_COORD_3 + parameter ( GL_MAP2_TEXTURE_COORD_3 = 3509 ) + integer*4 GL_MAP2_TEXTURE_COORD_4 + parameter ( GL_MAP2_TEXTURE_COORD_4 = 3510 ) + integer*4 GL_MAP2_VERTEX_3 + parameter ( GL_MAP2_VERTEX_3 = 3511 ) + integer*4 GL_MAP2_VERTEX_4 + parameter ( GL_MAP2_VERTEX_4 = 3512 ) + integer*4 GL_MAP1_GRID_DOMAIN + parameter ( GL_MAP1_GRID_DOMAIN = 3536 ) + integer*4 GL_MAP1_GRID_SEGMENTS + parameter ( GL_MAP1_GRID_SEGMENTS = 3537 ) + integer*4 GL_MAP2_GRID_DOMAIN + parameter ( GL_MAP2_GRID_DOMAIN = 3538 ) + integer*4 GL_MAP2_GRID_SEGMENTS + parameter ( GL_MAP2_GRID_SEGMENTS = 3539 ) + integer*4 GL_TEXTURE_1D + parameter ( GL_TEXTURE_1D = 3552 ) + integer*4 GL_TEXTURE_2D + parameter ( GL_TEXTURE_2D = 3553 ) +C GL_BLEND_COLOR_EXT +C GL_BLEND_EQUATION_EXT +C GL_CONVOLUTION_1D_EXT +C GL_CONVOLUTION_2D_EXT +C GL_SEPARABLE_2D_EXT +C GL_POST_CONVOLUTION_RED_SCALE_EXT +C GL_POST_CONVOLUTION_GREEN_SCALE_EXT +C GL_POST_CONVOLUTION_BLUE_SCALE_EXT +C GL_POST_CONVOLUTION_ALPHA_SCALE_EXT +C GL_POST_CONVOLUTION_RED_BIAS_EXT +C GL_POST_CONVOLUTION_GREEN_BIAS_EXT +C GL_POST_CONVOLUTION_BLUE_BIAS_EXT +C GL_POST_CONVOLUTION_ALPHA_BIAS_EXT +C GL_HISTOGRAM_EXT +C GL_MINMAX_EXT +C GL_POLYGON_OFFSET_EXT +C GL_POLYGON_OFFSET_FACTOR_EXT +C GL_POLYGON_OFFSET_BIAS_EXT +C GL_PACK_SKIP_IMAGES_EXT +C GL_PACK_IMAGE_HEIGHT_EXT +C GL_UNPACK_SKIP_IMAGES_EXT +C GL_UNPACK_IMAGE_HEIGHT_EXT +C GL_TEXTURE_3D_EXT +C GL_MAX_3D_TEXTURE_SIZE_EXT +C GL_DETAIL_TEXTURE_2D_BINDING_SGIS +C GL_MULTISAMPLE_SGIS +C GL_SAMPLE_ALPHA_TO_MASK_SGIS +C GL_SAMPLE_ALPHA_TO_ONE_SGIS +C GL_SAMPLE_MASK_SGIS +C GL_SAMPLE_BUFFERS_SGIS +C GL_SAMPLES_SGIS +C GL_SAMPLE_MASK_VALUE_SGIS +C GL_SAMPLE_MASK_INVERT_SGIS +C GL_SAMPLE_PATTERN_SGIS + +C GetTextureParameter +C GL_TEXTURE_MAG_FILTER +C GL_TEXTURE_MIN_FILTER +C GL_TEXTURE_WRAP_S +C GL_TEXTURE_WRAP_T + integer*4 GL_TEXTURE_WIDTH + parameter ( GL_TEXTURE_WIDTH = 4096 ) + integer*4 GL_TEXTURE_HEIGHT + parameter ( GL_TEXTURE_HEIGHT = 4097 ) + integer*4 GL_TEXTURE_COMPONENTS + parameter ( GL_TEXTURE_COMPONENTS = 4099 ) + integer*4 GL_TEXTURE_BORDER_COLOR + parameter ( GL_TEXTURE_BORDER_COLOR = 4100 ) + integer*4 GL_TEXTURE_BORDER + parameter ( GL_TEXTURE_BORDER = 4101 ) +C GL_TEXTURE_RED_SIZE_EXT +C GL_TEXTURE_GREEN_SIZE_EXT +C GL_TEXTURE_BLUE_SIZE_EXT +C GL_TEXTURE_ALPHA_SIZE_EXT +C GL_TEXTURE_LUMINANCE_SIZE_EXT +C GL_TEXTURE_INTENSITY_SIZE_EXT +C GL_TEXTURE_DEPTH_EXT +C GL_TEXTURE_WRAP_R_EXT +C GL_DETAIL_TEXTURE_LEVEL_SGIS +C GL_DETAIL_TEXTURE_MODE_SGIS +C GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS +C GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS + +C HintMode + integer*4 GL_DONT_CARE + parameter ( GL_DONT_CARE = 4352 ) + integer*4 GL_FASTEST + parameter ( GL_FASTEST = 4353 ) + integer*4 GL_NICEST + parameter ( GL_NICEST = 4354 ) + +C HintTarget +C GL_PERSPECTIVE_CORRECTION_HINT +C GL_POINT_SMOOTH_HINT +C GL_LINE_SMOOTH_HINT +C GL_POLYGON_SMOOTH_HINT +C GL_FOG_HINT + +C HistogramTarget +C GL_HISTOGRAM_EXT +C GL_PROXY_HISTOGRAM_EXT + +C LightModelParameter +C GL_LIGHT_MODEL_AMBIENT +C GL_LIGHT_MODEL_LOCAL_VIEWER +C GL_LIGHT_MODEL_TWO_SIDE + +C LightParameter + integer*4 GL_AMBIENT + parameter ( GL_AMBIENT = 4608 ) + integer*4 GL_DIFFUSE + parameter ( GL_DIFFUSE = 4609 ) + integer*4 GL_SPECULAR + parameter ( GL_SPECULAR = 4610 ) + integer*4 GL_POSITION + parameter ( GL_POSITION = 4611 ) + integer*4 GL_SPOT_DIRECTION + parameter ( GL_SPOT_DIRECTION = 4612 ) + integer*4 GL_SPOT_EXPONENT + parameter ( GL_SPOT_EXPONENT = 4613 ) + integer*4 GL_SPOT_CUTOFF + parameter ( GL_SPOT_CUTOFF = 4614 ) + integer*4 GL_CONSTANT_ATTENUATION + parameter ( GL_CONSTANT_ATTENUATION = 4615 ) + integer*4 GL_LINEAR_ATTENUATION + parameter ( GL_LINEAR_ATTENUATION = 4616 ) + integer*4 GL_QUADRATIC_ATTENUATION + parameter ( GL_QUADRATIC_ATTENUATION = 4617 ) + +C ListMode + integer*4 GL_COMPILE + parameter ( GL_COMPILE = 4864 ) + integer*4 GL_COMPILE_AND_EXECUTE + parameter ( GL_COMPILE_AND_EXECUTE = 4865 ) + +C ListNameType + integer*4 GL_BYTE + parameter ( GL_BYTE = 5120 ) + integer*4 GL_UNSIGNED_BYTE + parameter ( GL_UNSIGNED_BYTE = 5121 ) + integer*4 GL_SHORT + parameter ( GL_SHORT = 5122 ) + integer*4 GL_UNSIGNED_SHORT + parameter ( GL_UNSIGNED_SHORT = 5123 ) + integer*4 GL_INT + parameter ( GL_INT = 5124 ) + integer*4 GL_UNSIGNED_INT + parameter ( GL_UNSIGNED_INT = 5125 ) + integer*4 GL_FLOAT + parameter ( GL_FLOAT = 5126 ) + integer*4 GL_2_BYTES + parameter ( GL_2_BYTES = 5127 ) + integer*4 GL_3_BYTES + parameter ( GL_3_BYTES = 5128 ) + integer*4 GL_4_BYTES + parameter ( GL_4_BYTES = 5129 ) + +C LogicOp + integer*4 GL_CLEAR + parameter ( GL_CLEAR = 5376 ) + integer*4 GL_AND + parameter ( GL_AND = 5377 ) + integer*4 GL_AND_REVERSE + parameter ( GL_AND_REVERSE = 5378 ) + integer*4 GL_COPY + parameter ( GL_COPY = 5379 ) + integer*4 GL_AND_INVERTED + parameter ( GL_AND_INVERTED = 5380 ) + integer*4 GL_NOOP + parameter ( GL_NOOP = 5381 ) + integer*4 GL_XOR + parameter ( GL_XOR = 5382 ) + integer*4 GL_OR + parameter ( GL_OR = 5383 ) + integer*4 GL_NOR + parameter ( GL_NOR = 5384 ) + integer*4 GL_EQUIV + parameter ( GL_EQUIV = 5385 ) + integer*4 GL_INVERT + parameter ( GL_INVERT = 5386 ) + integer*4 GL_OR_REVERSE + parameter ( GL_OR_REVERSE = 5387 ) + integer*4 GL_COPY_INVERTED + parameter ( GL_COPY_INVERTED = 5388 ) + integer*4 GL_OR_INVERTED + parameter ( GL_OR_INVERTED = 5389 ) + integer*4 GL_NAND + parameter ( GL_NAND = 5390 ) + integer*4 GL_SET + parameter ( GL_SET = 5391 ) + +C MapTarget +C GL_MAP1_COLOR_4 +C GL_MAP1_INDEX +C GL_MAP1_NORMAL +C GL_MAP1_TEXTURE_COORD_1 +C GL_MAP1_TEXTURE_COORD_2 +C GL_MAP1_TEXTURE_COORD_3 +C GL_MAP1_TEXTURE_COORD_4 +C GL_MAP1_VERTEX_3 +C GL_MAP1_VERTEX_4 +C GL_MAP2_COLOR_4 +C GL_MAP2_INDEX +C GL_MAP2_NORMAL +C GL_MAP2_TEXTURE_COORD_1 +C GL_MAP2_TEXTURE_COORD_2 +C GL_MAP2_TEXTURE_COORD_3 +C GL_MAP2_TEXTURE_COORD_4 +C GL_MAP2_VERTEX_3 +C GL_MAP2_VERTEX_4 + +C MaterialFace +C GL_FRONT +C GL_BACK +C GL_FRONT_AND_BACK + +C MaterialParameter + integer*4 GL_EMISSION + parameter ( GL_EMISSION = 5632 ) + integer*4 GL_SHININESS + parameter ( GL_SHININESS = 5633 ) + integer*4 GL_AMBIENT_AND_DIFFUSE + parameter ( GL_AMBIENT_AND_DIFFUSE = 5634 ) + integer*4 GL_COLOR_INDEXES + parameter ( GL_COLOR_INDEXES = 5635 ) +C GL_AMBIENT +C GL_DIFFUSE +C GL_SPECULAR + +C MatrixMode + integer*4 GL_MODELVIEW + parameter ( GL_MODELVIEW = 5888 ) + integer*4 GL_PROJECTION + parameter ( GL_PROJECTION = 5889 ) + integer*4 GL_TEXTURE + parameter ( GL_TEXTURE = 5890 ) + +C MeshMode1 +C GL_POINT +C GL_LINE + +C MeshMode2 +C GL_POINT +C GL_LINE +C GL_FILL + +C MinmaxTarget +C GL_MINMAX_EXT + +C PixelCopyType + integer*4 GL_COLOR + parameter ( GL_COLOR = 6144 ) + integer*4 GL_DEPTH + parameter ( GL_DEPTH = 6145 ) + integer*4 GL_STENCIL + parameter ( GL_STENCIL = 6146 ) + +C PixelFormat + integer*4 GL_COLOR_INDEX + parameter ( GL_COLOR_INDEX = 6400 ) + integer*4 GL_STENCIL_INDEX + parameter ( GL_STENCIL_INDEX = 6401 ) + integer*4 GL_DEPTH_COMPONENT + parameter ( GL_DEPTH_COMPONENT = 6402 ) + integer*4 GL_RED + parameter ( GL_RED = 6403 ) + integer*4 GL_GREEN + parameter ( GL_GREEN = 6404 ) + integer*4 GL_BLUE + parameter ( GL_BLUE = 6405 ) + integer*4 GL_ALPHA + parameter ( GL_ALPHA = 6406 ) + integer*4 GL_RGB + parameter ( GL_RGB = 6407 ) + integer*4 GL_RGBA + parameter ( GL_RGBA = 6408 ) + integer*4 GL_LUMINANCE + parameter ( GL_LUMINANCE = 6409 ) + integer*4 GL_LUMINANCE_ALPHA + parameter ( GL_LUMINANCE_ALPHA = 6410 ) +C GL_ABGR_EXT + +C PixelInternalFormat +C GL_ALPHA4_EXT +C GL_ALPHA8_EXT +C GL_ALPHA12_EXT +C GL_ALPHA16_EXT +C GL_LUMINANCE4_EXT +C GL_LUMINANCE8_EXT +C GL_LUMINANCE12_EXT +C GL_LUMINANCE16_EXT +C GL_LUMINANCE4_ALPHA4_EXT +C GL_LUMINANCE6_ALPHA2_EXT +C GL_LUMINANCE8_ALPHA8_EXT +C GL_LUMINANCE12_ALPHA4_EXT +C GL_LUMINANCE12_ALPHA12_EXT +C GL_LUMINANCE16_ALPHA16_EXT +C GL_INTENSITY_EXT +C GL_INTENSITY4_EXT +C GL_INTENSITY8_EXT +C GL_INTENSITY12_EXT +C GL_INTENSITY16_EXT +C GL_RGB2_EXT +C GL_RGB4_EXT +C GL_RGB5_EXT +C GL_RGB8_EXT +C GL_RGB10_EXT +C GL_RGB12_EXT +C GL_RGB16_EXT +C GL_RGBA2_EXT +C GL_RGBA4_EXT +C GL_RGB5_A1_EXT +C GL_RGBA8_EXT +C GL_RGB10_A2_EXT +C GL_RGBA12_EXT +C GL_RGBA16_EXT + +C PixelMap +C GL_PIXEL_MAP_I_TO_I +C GL_PIXEL_MAP_S_TO_S +C GL_PIXEL_MAP_I_TO_R +C GL_PIXEL_MAP_I_TO_G +C GL_PIXEL_MAP_I_TO_B +C GL_PIXEL_MAP_I_TO_A +C GL_PIXEL_MAP_R_TO_R +C GL_PIXEL_MAP_G_TO_G +C GL_PIXEL_MAP_B_TO_B +C GL_PIXEL_MAP_A_TO_A + +C PixelStore +C GL_UNPACK_SWAP_BYTES +C GL_UNPACK_LSB_FIRST +C GL_UNPACK_ROW_LENGTH +C GL_UNPACK_SKIP_ROWS +C GL_UNPACK_SKIP_PIXELS +C GL_UNPACK_ALIGNMENT +C GL_PACK_SWAP_BYTES +C GL_PACK_LSB_FIRST +C GL_PACK_ROW_LENGTH +C GL_PACK_SKIP_ROWS +C GL_PACK_SKIP_PIXELS +C GL_PACK_ALIGNMENT +C GL_PACK_SKIP_IMAGES_EXT +C GL_PACK_IMAGE_HEIGHT_EXT +C GL_UNPACK_SKIP_IMAGES_EXT +C GL_UNPACK_IMAGE_HEIGHT_EXT + +C PixelTransfer +C GL_MAP_COLOR +C GL_MAP_STENCIL +C GL_INDEX_SHIFT +C GL_INDEX_OFFSET +C GL_RED_SCALE +C GL_RED_BIAS +C GL_GREEN_SCALE +C GL_GREEN_BIAS +C GL_BLUE_SCALE +C GL_BLUE_BIAS +C GL_ALPHA_SCALE +C GL_ALPHA_BIAS +C GL_DEPTH_SCALE +C GL_DEPTH_BIAS +C GL_POST_CONVOLUTION_RED_SCALE_EXT +C GL_POST_CONVOLUTION_GREEN_SCALE_EXT +C GL_POST_CONVOLUTION_BLUE_SCALE_EXT +C GL_POST_CONVOLUTION_ALPHA_SCALE_EXT +C GL_POST_CONVOLUTION_RED_BIAS_EXT +C GL_POST_CONVOLUTION_GREEN_BIAS_EXT +C GL_POST_CONVOLUTION_BLUE_BIAS_EXT +C GL_POST_CONVOLUTION_ALPHA_BIAS_EXT + +C PixelType + integer*4 GL_BITMAP + parameter ( GL_BITMAP = 6656 ) +C GL_BYTE +C GL_UNSIGNED_BYTE +C GL_SHORT +C GL_UNSIGNED_SHORT +C GL_INT +C GL_UNSIGNED_INT +C GL_FLOAT + +C PolygonMode + integer*4 GL_POINT + parameter ( GL_POINT = 6912 ) + integer*4 GL_LINE + parameter ( GL_LINE = 6913 ) + integer*4 GL_FILL + parameter ( GL_FILL = 6914 ) + +C ReadBufferMode +C GL_FRONT_LEFT +C GL_FRONT_RIGHT +C GL_BACK_LEFT +C GL_BACK_RIGHT +C GL_FRONT +C GL_BACK +C GL_LEFT +C GL_RIGHT +C GL_AUX0 +C GL_AUX1 +C GL_AUX2 +C GL_AUX3 + +C RenderingMode + integer*4 GL_RENDER + parameter ( GL_RENDER = 7168 ) + integer*4 GL_FEEDBACK + parameter ( GL_FEEDBACK = 7169 ) + integer*4 GL_SELECT + parameter ( GL_SELECT = 7170 ) + +C SamplePattern +C GL_1PASS_SGIS +C GL_2PASS_0_SGIS +C GL_2PASS_1_SGIS +C GL_4PASS_0_SGIS +C GL_4PASS_1_SGIS +C GL_4PASS_2_SGIS +C GL_4PASS_3_SGIS + +C SeparableTarget +C GL_SEPARABLE_2D_EXT + +C ShadingModel + integer*4 GL_FLAT + parameter ( GL_FLAT = 7424 ) + integer*4 GL_SMOOTH + parameter ( GL_SMOOTH = 7425 ) + +C StencilFunction +C GL_NEVER +C GL_LESS +C GL_EQUAL +C GL_LEQUAL +C GL_GREATER +C GL_NOTEQUAL +C GL_GEQUAL +C GL_ALWAYS + +C StencilOp +C GL_ZERO + integer*4 GL_KEEP + parameter ( GL_KEEP = 7680 ) + integer*4 GL_REPLACE + parameter ( GL_REPLACE = 7681 ) + integer*4 GL_INCR + parameter ( GL_INCR = 7682 ) + integer*4 GL_DECR + parameter ( GL_DECR = 7683 ) +C GL_INVERT + +C StringName + integer*4 GL_VENDOR + parameter ( GL_VENDOR = 7936 ) + integer*4 GL_RENDERER + parameter ( GL_RENDERER = 7937 ) + integer*4 GL_VERSION + parameter ( GL_VERSION = 7938 ) + integer*4 GL_EXTENSIONS + parameter ( GL_EXTENSIONS = 7939 ) + +C TextureCoordName + integer*4 GL_S + parameter ( GL_S = 8192 ) + integer*4 GL_T + parameter ( GL_T = 8193 ) + integer*4 GL_R + parameter ( GL_R = 8194 ) + integer*4 GL_Q + parameter ( GL_Q = 8195 ) + +C TextureEnvMode + integer*4 GL_MODULATE + parameter ( GL_MODULATE = 8448 ) + integer*4 GL_DECAL + parameter ( GL_DECAL = 8449 ) +C GL_BLEND +C GL_REPLACE_EXT + +C TextureEnvParameter + integer*4 GL_TEXTURE_ENV_MODE + parameter ( GL_TEXTURE_ENV_MODE = 8704 ) + integer*4 GL_TEXTURE_ENV_COLOR + parameter ( GL_TEXTURE_ENV_COLOR = 8705 ) + +C TextureEnvTarget + integer*4 GL_TEXTURE_ENV + parameter ( GL_TEXTURE_ENV = 8960 ) + +C TextureGenMode + integer*4 GL_EYE_LINEAR + parameter ( GL_EYE_LINEAR = 9216 ) + integer*4 GL_OBJECT_LINEAR + parameter ( GL_OBJECT_LINEAR = 9217 ) + integer*4 GL_SPHERE_MAP + parameter ( GL_SPHERE_MAP = 9218 ) + +C TextureGenParameter + integer*4 GL_TEXTURE_GEN_MODE + parameter ( GL_TEXTURE_GEN_MODE = 9472 ) + integer*4 GL_OBJECT_PLANE + parameter ( GL_OBJECT_PLANE = 9473 ) + integer*4 GL_EYE_PLANE + parameter ( GL_EYE_PLANE = 9474 ) + +C TextureMagFilter + integer*4 GL_NEAREST + parameter ( GL_NEAREST = 9728 ) + integer*4 GL_LINEAR + parameter ( GL_LINEAR = 9729 ) +C GL_LINEAR_DETAIL_SGIS +C GL_LINEAR_DETAIL_ALPHA_SGIS +C GL_LINEAR_DETAIL_COLOR_SGIS +C GL_LINEAR_SHARPEN_SGIS +C GL_LINEAR_SHARPEN_ALPHA_SGIS +C GL_LINEAR_SHARPEN_COLOR_SGIS + +C TextureMinFilter +C GL_NEAREST +C GL_LINEAR + integer*4 GL_NEAREST_MIPMAP_NEAREST + parameter ( GL_NEAREST_MIPMAP_NEAREST = 9984 ) + integer*4 GL_LINEAR_MIPMAP_NEAREST + parameter ( GL_LINEAR_MIPMAP_NEAREST = 9985 ) + integer*4 GL_NEAREST_MIPMAP_LINEAR + parameter ( GL_NEAREST_MIPMAP_LINEAR = 9986 ) + integer*4 GL_LINEAR_MIPMAP_LINEAR + parameter ( GL_LINEAR_MIPMAP_LINEAR = 9987 ) + +C TextureParameterName + integer*4 GL_TEXTURE_MAG_FILTER + parameter ( GL_TEXTURE_MAG_FILTER = 10240 ) + integer*4 GL_TEXTURE_MIN_FILTER + parameter ( GL_TEXTURE_MIN_FILTER = 10241 ) + integer*4 GL_TEXTURE_WRAP_S + parameter ( GL_TEXTURE_WRAP_S = 10242 ) + integer*4 GL_TEXTURE_WRAP_T + parameter ( GL_TEXTURE_WRAP_T = 10243 ) +C GL_TEXTURE_BORDER_COLOR +C GL_TEXTURE_WRAP_R_EXT +C GL_DETAIL_TEXTURE_LEVEL_SGIS +C GL_DETAIL_TEXTURE_MODE_SGIS + +C TextureTarget +C GL_TEXTURE_1D +C GL_TEXTURE_2D +C GL_PROXY_TEXTURE_1D_EXT +C GL_PROXY_TEXTURE_2D_EXT +C GL_TEXTURE_3D_EXT +C GL_PROXY_TEXTURE_3D_EXT +C GL_DETAIL_TEXTURE_2D_SGIS + +C TextureWrapMode + integer*4 GL_CLAMP + parameter ( GL_CLAMP = 10496 ) + integer*4 GL_REPEAT + parameter ( GL_REPEAT = 10497 ) + +C ClipPlaneName + integer*4 GL_CLIP_PLANE0 + parameter ( GL_CLIP_PLANE0 = 12288 ) + integer*4 GL_CLIP_PLANE1 + parameter ( GL_CLIP_PLANE1 = 12289 ) + integer*4 GL_CLIP_PLANE2 + parameter ( GL_CLIP_PLANE2 = 12290 ) + integer*4 GL_CLIP_PLANE3 + parameter ( GL_CLIP_PLANE3 = 12291 ) + integer*4 GL_CLIP_PLANE4 + parameter ( GL_CLIP_PLANE4 = 12292 ) + integer*4 GL_CLIP_PLANE5 + parameter ( GL_CLIP_PLANE5 = 12293 ) + +C LightName + integer*4 GL_LIGHT0 + parameter ( GL_LIGHT0 = 16384 ) + integer*4 GL_LIGHT1 + parameter ( GL_LIGHT1 = 16385 ) + integer*4 GL_LIGHT2 + parameter ( GL_LIGHT2 = 16386 ) + integer*4 GL_LIGHT3 + parameter ( GL_LIGHT3 = 16387 ) + integer*4 GL_LIGHT4 + parameter ( GL_LIGHT4 = 16388 ) + integer*4 GL_LIGHT5 + parameter ( GL_LIGHT5 = 16389 ) + integer*4 GL_LIGHT6 + parameter ( GL_LIGHT6 = 16390 ) + integer*4 GL_LIGHT7 + parameter ( GL_LIGHT7 = 16391 ) + +C Extensions + integer*4 GL_EXT_abgr + parameter ( GL_EXT_abgr = 1 ) + integer*4 GL_EXT_blend_color + parameter ( GL_EXT_blend_color = 1 ) + integer*4 GL_EXT_blend_logic_op + parameter ( GL_EXT_blend_logic_op = 1 ) + integer*4 GL_EXT_blend_minmax + parameter ( GL_EXT_blend_minmax = 1 ) + integer*4 GL_EXT_blend_subtract + parameter ( GL_EXT_blend_subtract = 1 ) + integer*4 GL_EXT_convolution + parameter ( GL_EXT_convolution = 1 ) + integer*4 GL_EXT_histogram + parameter ( GL_EXT_histogram = 1 ) + integer*4 GL_EXT_polygon_offset + parameter ( GL_EXT_polygon_offset = 1 ) + integer*4 GL_EXT_subtexture + parameter ( GL_EXT_subtexture = 1 ) + integer*4 GL_EXT_texture + parameter ( GL_EXT_texture = 1 ) + integer*4 GL_EXT_texture3D + parameter ( GL_EXT_texture3D = 1 ) + integer*4 GL_SGIS_detail_texture + parameter ( GL_SGIS_detail_texture = 1 ) + integer*4 GL_SGIS_multisample + parameter ( GL_SGIS_multisample = 1 ) + integer*4 GL_SGIS_sharpen_texture + parameter ( GL_SGIS_sharpen_texture = 1 ) + +C EXT_abgr + integer*4 GL_ABGR_EXT + parameter ( GL_ABGR_EXT = 32768 ) + +C EXT_blend_color + integer*4 GL_CONSTANT_COLOR_EXT + parameter ( GL_CONSTANT_COLOR_EXT = 32769 ) + integer*4 GL_ONE_MINUS_CONSTANT_COLOR_EXT + parameter ( GL_ONE_MINUS_CONSTANT_COLOR_EXT = 32770 ) + integer*4 GL_CONSTANT_ALPHA_EXT + parameter ( GL_CONSTANT_ALPHA_EXT = 32771 ) + integer*4 GL_ONE_MINUS_CONSTANT_ALPHA_EXT + parameter ( GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 32772 ) + integer*4 GL_BLEND_COLOR_EXT + parameter ( GL_BLEND_COLOR_EXT = 32773 ) + +C EXT_blend_minmax + integer*4 GL_FUNC_ADD_EXT + parameter ( GL_FUNC_ADD_EXT = 32774 ) + integer*4 GL_MIN_EXT + parameter ( GL_MIN_EXT = 32775 ) + integer*4 GL_MAX_EXT + parameter ( GL_MAX_EXT = 32776 ) + integer*4 GL_BLEND_EQUATION_EXT + parameter ( GL_BLEND_EQUATION_EXT = 32777 ) + +C EXT_blend_subtract + integer*4 GL_FUNC_SUBTRACT_EXT + parameter ( GL_FUNC_SUBTRACT_EXT = 32778 ) + integer*4 GL_FUNC_REVERSE_SUBTRACT_EXT + parameter ( GL_FUNC_REVERSE_SUBTRACT_EXT = 32779 ) + +C EXT_convolution + integer*4 GL_CONVOLUTION_1D_EXT + parameter ( GL_CONVOLUTION_1D_EXT = 32784 ) + integer*4 GL_CONVOLUTION_2D_EXT + parameter ( GL_CONVOLUTION_2D_EXT = 32785 ) + integer*4 GL_SEPARABLE_2D_EXT + parameter ( GL_SEPARABLE_2D_EXT = 32786 ) + integer*4 GL_CONVOLUTION_BORDER_MODE_EXT + parameter ( GL_CONVOLUTION_BORDER_MODE_EXT = 32787 ) + integer*4 GL_CONVOLUTION_FILTER_SCALE_EXT + parameter ( GL_CONVOLUTION_FILTER_SCALE_EXT = 32788 ) + integer*4 GL_CONVOLUTION_FILTER_BIAS_EXT + parameter ( GL_CONVOLUTION_FILTER_BIAS_EXT = 32789 ) + integer*4 GL_REDUCE_EXT + parameter ( GL_REDUCE_EXT = 32790 ) + integer*4 GL_CONVOLUTION_FORMAT_EXT + parameter ( GL_CONVOLUTION_FORMAT_EXT = 32791 ) + integer*4 GL_CONVOLUTION_WIDTH_EXT + parameter ( GL_CONVOLUTION_WIDTH_EXT = 32792 ) + integer*4 GL_CONVOLUTION_HEIGHT_EXT + parameter ( GL_CONVOLUTION_HEIGHT_EXT = 32793 ) + integer*4 GL_MAX_CONVOLUTION_WIDTH_EXT + parameter ( GL_MAX_CONVOLUTION_WIDTH_EXT = 32794 ) + integer*4 GL_MAX_CONVOLUTION_HEIGHT_EXT + parameter ( GL_MAX_CONVOLUTION_HEIGHT_EXT = 32795 ) + integer*4 GL_POST_CONVOLUTION_RED_SCALE_EX + parameter ( GL_POST_CONVOLUTION_RED_SCALE_EX = 32796 ) + integer*4 GL_POST_CONVOLUTION_GREEN_SCALE_ + parameter ( GL_POST_CONVOLUTION_GREEN_SCALE_ = 32797 ) + integer*4 GL_POST_CONVOLUTION_BLUE_SCALE_E + parameter ( GL_POST_CONVOLUTION_BLUE_SCALE_E = 32798 ) + integer*4 GL_POST_CONVOLUTION_ALPHA_SCALE_ + parameter ( GL_POST_CONVOLUTION_ALPHA_SCALE_ = 32799 ) + integer*4 GL_POST_CONVOLUTION_RED_BIAS_EXT + parameter ( GL_POST_CONVOLUTION_RED_BIAS_EXT = 32800 ) + integer*4 GL_POST_CONVOLUTION_GREEN_BIAS_E + parameter ( GL_POST_CONVOLUTION_GREEN_BIAS_E = 32801 ) + integer*4 GL_POST_CONVOLUTION_BLUE_BIAS_EX + parameter ( GL_POST_CONVOLUTION_BLUE_BIAS_EX = 32802 ) + integer*4 GL_POST_CONVOLUTION_ALPHA_BIAS_E + parameter ( GL_POST_CONVOLUTION_ALPHA_BIAS_E = 32803 ) + +C EXT_histogram + integer*4 GL_HISTOGRAM_EXT + parameter ( GL_HISTOGRAM_EXT = 32804 ) + integer*4 GL_PROXY_HISTOGRAM_EXT + parameter ( GL_PROXY_HISTOGRAM_EXT = 32805 ) + integer*4 GL_HISTOGRAM_WIDTH_EXT + parameter ( GL_HISTOGRAM_WIDTH_EXT = 32806 ) + integer*4 GL_HISTOGRAM_FORMAT_EXT + parameter ( GL_HISTOGRAM_FORMAT_EXT = 32807 ) + integer*4 GL_HISTOGRAM_RED_SIZE_EXT + parameter ( GL_HISTOGRAM_RED_SIZE_EXT = 32808 ) + integer*4 GL_HISTOGRAM_GREEN_SIZE_EXT + parameter ( GL_HISTOGRAM_GREEN_SIZE_EXT = 32809 ) + integer*4 GL_HISTOGRAM_BLUE_SIZE_EXT + parameter ( GL_HISTOGRAM_BLUE_SIZE_EXT = 32810 ) + integer*4 GL_HISTOGRAM_ALPHA_SIZE_EXT + parameter ( GL_HISTOGRAM_ALPHA_SIZE_EXT = 32811 ) + integer*4 GL_HISTOGRAM_LUMINANCE_SIZE_EXT + parameter ( GL_HISTOGRAM_LUMINANCE_SIZE_EXT = 32812 ) + integer*4 GL_HISTOGRAM_SINK_EXT + parameter ( GL_HISTOGRAM_SINK_EXT = 32813 ) + integer*4 GL_MINMAX_EXT + parameter ( GL_MINMAX_EXT = 32814 ) + integer*4 GL_MINMAX_FORMAT_EXT + parameter ( GL_MINMAX_FORMAT_EXT = 32815 ) + integer*4 GL_MINMAX_SINK_EXT + parameter ( GL_MINMAX_SINK_EXT = 32816 ) + integer*4 GL_TABLE_TOO_LARGE_EXT + parameter ( GL_TABLE_TOO_LARGE_EXT = 32817 ) + +C EXT_polygon_offset + integer*4 GL_POLYGON_OFFSET_EXT + parameter ( GL_POLYGON_OFFSET_EXT = 32823 ) + integer*4 GL_POLYGON_OFFSET_FACTOR_EXT + parameter ( GL_POLYGON_OFFSET_FACTOR_EXT = 32824 ) + integer*4 GL_POLYGON_OFFSET_BIAS_EXT + parameter ( GL_POLYGON_OFFSET_BIAS_EXT = 32825 ) + +C EXT_texture + integer*4 GL_ALPHA4_EXT + parameter ( GL_ALPHA4_EXT = 32827 ) + integer*4 GL_ALPHA8_EXT + parameter ( GL_ALPHA8_EXT = 32828 ) + integer*4 GL_ALPHA12_EXT + parameter ( GL_ALPHA12_EXT = 32829 ) + integer*4 GL_ALPHA16_EXT + parameter ( GL_ALPHA16_EXT = 32830 ) + integer*4 GL_LUMINANCE4_EXT + parameter ( GL_LUMINANCE4_EXT = 32831 ) + integer*4 GL_LUMINANCE8_EXT + parameter ( GL_LUMINANCE8_EXT = 32832 ) + integer*4 GL_LUMINANCE12_EXT + parameter ( GL_LUMINANCE12_EXT = 32833 ) + integer*4 GL_LUMINANCE16_EXT + parameter ( GL_LUMINANCE16_EXT = 32834 ) + integer*4 GL_LUMINANCE4_ALPHA4_EXT + parameter ( GL_LUMINANCE4_ALPHA4_EXT = 32835 ) + integer*4 GL_LUMINANCE6_ALPHA2_EXT + parameter ( GL_LUMINANCE6_ALPHA2_EXT = 32836 ) + integer*4 GL_LUMINANCE8_ALPHA8_EXT + parameter ( GL_LUMINANCE8_ALPHA8_EXT = 32837 ) + integer*4 GL_LUMINANCE12_ALPHA4_EXT + parameter ( GL_LUMINANCE12_ALPHA4_EXT = 32838 ) + integer*4 GL_LUMINANCE12_ALPHA12_EXT + parameter ( GL_LUMINANCE12_ALPHA12_EXT = 32839 ) + integer*4 GL_LUMINANCE16_ALPHA16_EXT + parameter ( GL_LUMINANCE16_ALPHA16_EXT = 32840 ) + integer*4 GL_INTENSITY_EXT + parameter ( GL_INTENSITY_EXT = 32841 ) + integer*4 GL_INTENSITY4_EXT + parameter ( GL_INTENSITY4_EXT = 32842 ) + integer*4 GL_INTENSITY8_EXT + parameter ( GL_INTENSITY8_EXT = 32843 ) + integer*4 GL_INTENSITY12_EXT + parameter ( GL_INTENSITY12_EXT = 32844 ) + integer*4 GL_INTENSITY16_EXT + parameter ( GL_INTENSITY16_EXT = 32845 ) + integer*4 GL_RGB2_EXT + parameter ( GL_RGB2_EXT = 32846 ) + integer*4 GL_RGB4_EXT + parameter ( GL_RGB4_EXT = 32847 ) + integer*4 GL_RGB5_EXT + parameter ( GL_RGB5_EXT = 32848 ) + integer*4 GL_RGB8_EXT + parameter ( GL_RGB8_EXT = 32849 ) + integer*4 GL_RGB10_EXT + parameter ( GL_RGB10_EXT = 32850 ) + integer*4 GL_RGB12_EXT + parameter ( GL_RGB12_EXT = 32851 ) + integer*4 GL_RGB16_EXT + parameter ( GL_RGB16_EXT = 32852 ) + integer*4 GL_RGBA2_EXT + parameter ( GL_RGBA2_EXT = 32853 ) + integer*4 GL_RGBA4_EXT + parameter ( GL_RGBA4_EXT = 32854 ) + integer*4 GL_RGB5_A1_EXT + parameter ( GL_RGB5_A1_EXT = 32855 ) + integer*4 GL_RGBA8_EXT + parameter ( GL_RGBA8_EXT = 32856 ) + integer*4 GL_RGB10_A2_EXT + parameter ( GL_RGB10_A2_EXT = 32857 ) + integer*4 GL_RGBA12_EXT + parameter ( GL_RGBA12_EXT = 32858 ) + integer*4 GL_RGBA16_EXT + parameter ( GL_RGBA16_EXT = 32859 ) + integer*4 GL_TEXTURE_RED_SIZE_EXT + parameter ( GL_TEXTURE_RED_SIZE_EXT = 32860 ) + integer*4 GL_TEXTURE_GREEN_SIZE_EXT + parameter ( GL_TEXTURE_GREEN_SIZE_EXT = 32861 ) + integer*4 GL_TEXTURE_BLUE_SIZE_EXT + parameter ( GL_TEXTURE_BLUE_SIZE_EXT = 32862 ) + integer*4 GL_TEXTURE_ALPHA_SIZE_EXT + parameter ( GL_TEXTURE_ALPHA_SIZE_EXT = 32863 ) + integer*4 GL_TEXTURE_LUMINANCE_SIZE_EXT + parameter ( GL_TEXTURE_LUMINANCE_SIZE_EXT = 32864 ) + integer*4 GL_TEXTURE_INTENSITY_SIZE_EXT + parameter ( GL_TEXTURE_INTENSITY_SIZE_EXT = 32865 ) + integer*4 GL_REPLACE_EXT + parameter ( GL_REPLACE_EXT = 32866 ) + integer*4 GL_PROXY_TEXTURE_1D_EXT + parameter ( GL_PROXY_TEXTURE_1D_EXT = 32867 ) + integer*4 GL_PROXY_TEXTURE_2D_EXT + parameter ( GL_PROXY_TEXTURE_2D_EXT = 32868 ) + integer*4 GL_TEXTURE_TOO_LARGE_EXT + parameter ( GL_TEXTURE_TOO_LARGE_EXT = 32869 ) + +C EXT_texture3D + integer*4 GL_PACK_SKIP_IMAGES_EXT + parameter ( GL_PACK_SKIP_IMAGES_EXT = 32875 ) + integer*4 GL_PACK_IMAGE_HEIGHT_EXT + parameter ( GL_PACK_IMAGE_HEIGHT_EXT = 32876 ) + integer*4 GL_UNPACK_SKIP_IMAGES_EXT + parameter ( GL_UNPACK_SKIP_IMAGES_EXT = 32877 ) + integer*4 GL_UNPACK_IMAGE_HEIGHT_EXT + parameter ( GL_UNPACK_IMAGE_HEIGHT_EXT = 32878 ) + integer*4 GL_TEXTURE_3D_EXT + parameter ( GL_TEXTURE_3D_EXT = 32879 ) + integer*4 GL_PROXY_TEXTURE_3D_EXT + parameter ( GL_PROXY_TEXTURE_3D_EXT = 32880 ) + integer*4 GL_TEXTURE_DEPTH_EXT + parameter ( GL_TEXTURE_DEPTH_EXT = 32881 ) + integer*4 GL_TEXTURE_WRAP_R_EXT + parameter ( GL_TEXTURE_WRAP_R_EXT = 32882 ) + integer*4 GL_MAX_3D_TEXTURE_SIZE_EXT + parameter ( GL_MAX_3D_TEXTURE_SIZE_EXT = 32883 ) + +C SGIS_detail_texture + integer*4 GL_DETAIL_TEXTURE_2D_SGIS + parameter ( GL_DETAIL_TEXTURE_2D_SGIS = 32917 ) + integer*4 GL_DETAIL_TEXTURE_2D_BINDING_SGI + parameter ( GL_DETAIL_TEXTURE_2D_BINDING_SGI = 32918 ) + integer*4 GL_LINEAR_DETAIL_SGIS + parameter ( GL_LINEAR_DETAIL_SGIS = 32919 ) + integer*4 GL_LINEAR_DETAIL_ALPHA_SGIS + parameter ( GL_LINEAR_DETAIL_ALPHA_SGIS = 32920 ) + integer*4 GL_LINEAR_DETAIL_COLOR_SGIS + parameter ( GL_LINEAR_DETAIL_COLOR_SGIS = 32921 ) + integer*4 GL_DETAIL_TEXTURE_LEVEL_SGIS + parameter ( GL_DETAIL_TEXTURE_LEVEL_SGIS = 32922 ) + integer*4 GL_DETAIL_TEXTURE_MODE_SGIS + parameter ( GL_DETAIL_TEXTURE_MODE_SGIS = 32923 ) + integer*4 GL_DETAIL_TEXTURE_FUNC_POINTS_S + parameter ( GL_DETAIL_TEXTURE_FUNC_POINTS_S = 32924 ) + +C SGIS_multisample + integer*4 GL_MULTISAMPLE_BIT_EXT + parameter ( GL_MULTISAMPLE_BIT_EXT = 536870912 ) + integer*4 GL_MULTISAMPLE_SGIS + parameter ( GL_MULTISAMPLE_SGIS = 32925 ) + integer*4 GL_SAMPLE_ALPHA_TO_MASK_SGIS + parameter ( GL_SAMPLE_ALPHA_TO_MASK_SGIS = 32926 ) + integer*4 GL_SAMPLE_ALPHA_TO_ONE_SGIS + parameter ( GL_SAMPLE_ALPHA_TO_ONE_SGIS = 32927 ) + integer*4 GL_SAMPLE_MASK_SGIS + parameter ( GL_SAMPLE_MASK_SGIS = 32928 ) + integer*4 GL_1PASS_SGIS + parameter ( GL_1PASS_SGIS = 32929 ) + integer*4 GL_2PASS_0_SGIS + parameter ( GL_2PASS_0_SGIS = 32930 ) + integer*4 GL_2PASS_1_SGIS + parameter ( GL_2PASS_1_SGIS = 32931 ) + integer*4 GL_4PASS_0_SGIS + parameter ( GL_4PASS_0_SGIS = 32932 ) + integer*4 GL_4PASS_1_SGIS + parameter ( GL_4PASS_1_SGIS = 32933 ) + integer*4 GL_4PASS_2_SGIS + parameter ( GL_4PASS_2_SGIS = 32934 ) + integer*4 GL_4PASS_3_SGIS + parameter ( GL_4PASS_3_SGIS = 32935 ) + integer*4 GL_SAMPLE_BUFFERS_SGIS + parameter ( GL_SAMPLE_BUFFERS_SGIS = 32936 ) + integer*4 GL_SAMPLES_SGIS + parameter ( GL_SAMPLES_SGIS = 32937 ) + integer*4 GL_SAMPLE_MASK_VALUE_SGIS + parameter ( GL_SAMPLE_MASK_VALUE_SGIS = 32938 ) + integer*4 GL_SAMPLE_MASK_INVERT_SGIS + parameter ( GL_SAMPLE_MASK_INVERT_SGIS = 32939 ) + integer*4 GL_SAMPLE_PATTERN_SGIS + parameter ( GL_SAMPLE_PATTERN_SGIS = 32940 ) + +C SGIS_sharpen_texture + integer*4 GL_LINEAR_SHARPEN_SGIS + parameter ( GL_LINEAR_SHARPEN_SGIS = 32941 ) + integer*4 GL_LINEAR_SHARPEN_ALPHA_SGIS + parameter ( GL_LINEAR_SHARPEN_ALPHA_SGIS = 32942 ) + integer*4 GL_LINEAR_SHARPEN_COLOR_SGIS + parameter ( GL_LINEAR_SHARPEN_COLOR_SGIS = 32943 ) + integer*4 GL_SHARPEN_TEXTURE_FUNC_POINTS_S + parameter ( GL_SHARPEN_TEXTURE_FUNC_POINTS_S = 32944 ) + +C *********************************************************** + + + character*128 fglGetString + integer fglGetError + integer*4 fglRenderMode + logical*1 fglAreTexturesResidentEXT + logical*1 fglIsEnabled + logical*1 fglIsList + logical*1 fglIsTextureEXT + logical*4 fglGenLists + logical*4 fglGenTexturesEXT diff --git a/headtrack_demo/include/glut/GL/fglu.h b/headtrack_demo/include/glut/GL/fglu.h new file mode 100644 index 0000000..75c064c --- /dev/null +++ b/headtrack_demo/include/glut/GL/fglu.h @@ -0,0 +1,210 @@ + +C GLUT version of "GL/fgl.h" + +C Modifications from SGI IRIX 5.3 version: +C 1) F prefix removed from GLU constants. +C 2) Fix GLU_TRUE and GLU_FALSE. + +C *** Generic constants *** + +C Errors: (return value 0 = no error) + integer*4 GLU_INVALID_ENUM + parameter ( GLU_INVALID_ENUM = 100900 ) + integer*4 GLU_INVALID_VALUE + parameter ( GLU_INVALID_VALUE = 100901 ) + integer*4 GLU_OUT_OF_MEMORY + parameter ( GLU_OUT_OF_MEMORY = 100902 ) + +C For laughs: + integer*4 GLU_TRUE + parameter ( GLU_TRUE = 1 ) + integer*4 GLU_FALSE + parameter ( GLU_FALSE = 0 ) + + +C *** Quadric constants *** + +C Types of normals: + integer*4 GLU_SMOOTH + parameter ( GLU_SMOOTH = 100000 ) + integer*4 GLU_FLAT + parameter ( GLU_FLAT = 100001 ) + integer*4 GLU_NONE + parameter ( GLU_NONE = 100002 ) + +C DrawStyle types: + integer*4 GLU_POINT + parameter ( GLU_POINT = 100010 ) + integer*4 GLU_LINE + parameter ( GLU_LINE = 100011 ) + integer*4 GLU_FILL + parameter ( GLU_FILL = 100012 ) + integer*4 GLU_SILHOUETTE + parameter ( GLU_SILHOUETTE = 100013 ) + +C Orientation types: + integer*4 GLU_OUTSIDE + parameter ( GLU_OUTSIDE = 100020 ) + integer*4 GLU_INSIDE + parameter ( GLU_INSIDE = 100021 ) + +C Callback types: +C GLU_ERROR 100103 + + +C *** Tesselation constants *** + +C Callback types: + integer*4 GLU_BEGIN + parameter ( GLU_BEGIN = 100100 ) + integer*4 GLU_VERTEX + parameter ( GLU_VERTEX = 100101 ) + integer*4 GLU_END + parameter ( GLU_END = 100102 ) + integer*4 GLU_ERROR + parameter ( GLU_ERROR = 100103 ) + integer*4 GLU_EDGE_FLAG + parameter ( GLU_EDGE_FLAG = 100104 ) + +C Contours types: + integer*4 GLU_CW + parameter ( GLU_CW = 100120 ) + integer*4 GLU_CCW + parameter ( GLU_CCW = 100121 ) + integer*4 GLU_INTERIOR + parameter ( GLU_INTERIOR = 100122 ) + integer*4 GLU_EXTERIOR + parameter ( GLU_EXTERIOR = 100123 ) + integer*4 GLU_UNKNOWN + parameter ( GLU_UNKNOWN = 100124 ) + + integer*4 GLU_TESS_ERROR1 + parameter ( GLU_TESS_ERROR1 = 100151 ) + integer*4 GLU_TESS_ERROR2 + parameter ( GLU_TESS_ERROR2 = 100152 ) + integer*4 GLU_TESS_ERROR3 + parameter ( GLU_TESS_ERROR3 = 100153 ) + integer*4 GLU_TESS_ERROR4 + parameter ( GLU_TESS_ERROR4 = 100154 ) + integer*4 GLU_TESS_ERROR5 + parameter ( GLU_TESS_ERROR5 = 100155 ) + integer*4 GLU_TESS_ERROR6 + parameter ( GLU_TESS_ERROR6 = 100156 ) + integer*4 GLU_TESS_ERROR7 + parameter ( GLU_TESS_ERROR7 = 100157 ) + integer*4 GLU_TESS_ERROR8 + parameter ( GLU_TESS_ERROR8 = 100158 ) + + +C *** NURBS constants *** + +C Properties: + integer*4 GLU_AUTO_LOAD_MATRIX + parameter ( GLU_AUTO_LOAD_MATRIX = 100200 ) + integer*4 GLU_CULLING + parameter ( GLU_CULLING = 100201 ) + integer*4 GLU_SAMPLING_TOLERANCE + parameter ( GLU_SAMPLING_TOLERANCE = 100203 ) + integer*4 GLU_DISPLAY_MODE + parameter ( GLU_DISPLAY_MODE = 100204 ) + +C Trimming curve types + integer*4 GLU_MAP1_TRIM_2 + parameter ( GLU_MAP1_TRIM_2 = 100210 ) + integer*4 GLU_MAP1_TRIM_3 + parameter ( GLU_MAP1_TRIM_3 = 100211 ) + +C Display modes: +C GLU_FILL 100012 + integer*4 GLU_OUTLINE_POLYGON + parameter ( GLU_OUTLINE_POLYGON = 100240 ) + integer*4 GLU_OUTLINE_PATCH + parameter ( GLU_OUTLINE_PATCH = 100241 ) + +C Callbacks: +C GLU_ERROR 100103 + +C Errors: + integer*4 GLU_NURBS_ERROR1 + parameter ( GLU_NURBS_ERROR1 = 100251 ) + integer*4 GLU_NURBS_ERROR2 + parameter ( GLU_NURBS_ERROR2 = 100252 ) + integer*4 GLU_NURBS_ERROR3 + parameter ( GLU_NURBS_ERROR3 = 100253 ) + integer*4 GLU_NURBS_ERROR4 + parameter ( GLU_NURBS_ERROR4 = 100254 ) + integer*4 GLU_NURBS_ERROR5 + parameter ( GLU_NURBS_ERROR5 = 100255 ) + integer*4 GLU_NURBS_ERROR6 + parameter ( GLU_NURBS_ERROR6 = 100256 ) + integer*4 GLU_NURBS_ERROR7 + parameter ( GLU_NURBS_ERROR7 = 100257 ) + integer*4 GLU_NURBS_ERROR8 + parameter ( GLU_NURBS_ERROR8 = 100258 ) + integer*4 GLU_NURBS_ERROR9 + parameter ( GLU_NURBS_ERROR9 = 100259 ) + integer*4 GLU_NURBS_ERROR10 + parameter ( GLU_NURBS_ERROR10 = 100260 ) + integer*4 GLU_NURBS_ERROR11 + parameter ( GLU_NURBS_ERROR11 = 100261 ) + integer*4 GLU_NURBS_ERROR12 + parameter ( GLU_NURBS_ERROR12 = 100262 ) + integer*4 GLU_NURBS_ERROR13 + parameter ( GLU_NURBS_ERROR13 = 100263 ) + integer*4 GLU_NURBS_ERROR14 + parameter ( GLU_NURBS_ERROR14 = 100264 ) + integer*4 GLU_NURBS_ERROR15 + parameter ( GLU_NURBS_ERROR15 = 100265 ) + integer*4 GLU_NURBS_ERROR16 + parameter ( GLU_NURBS_ERROR16 = 100266 ) + integer*4 GLU_NURBS_ERROR17 + parameter ( GLU_NURBS_ERROR17 = 100267 ) + integer*4 GLU_NURBS_ERROR18 + parameter ( GLU_NURBS_ERROR18 = 100268 ) + integer*4 GLU_NURBS_ERROR19 + parameter ( GLU_NURBS_ERROR19 = 100269 ) + integer*4 GLU_NURBS_ERROR20 + parameter ( GLU_NURBS_ERROR20 = 100270 ) + integer*4 GLU_NURBS_ERROR21 + parameter ( GLU_NURBS_ERROR21 = 100271 ) + integer*4 GLU_NURBS_ERROR22 + parameter ( GLU_NURBS_ERROR22 = 100272 ) + integer*4 GLU_NURBS_ERROR23 + parameter ( GLU_NURBS_ERROR23 = 100273 ) + integer*4 GLU_NURBS_ERROR24 + parameter ( GLU_NURBS_ERROR24 = 100274 ) + integer*4 GLU_NURBS_ERROR25 + parameter ( GLU_NURBS_ERROR25 = 100275 ) + integer*4 GLU_NURBS_ERROR26 + parameter ( GLU_NURBS_ERROR26 = 100276 ) + integer*4 GLU_NURBS_ERROR27 + parameter ( GLU_NURBS_ERROR27 = 100277 ) + integer*4 GLU_NURBS_ERROR28 + parameter ( GLU_NURBS_ERROR28 = 100278 ) + integer*4 GLU_NURBS_ERROR29 + parameter ( GLU_NURBS_ERROR29 = 100279 ) + integer*4 GLU_NURBS_ERROR30 + parameter ( GLU_NURBS_ERROR30 = 100280 ) + integer*4 GLU_NURBS_ERROR31 + parameter ( GLU_NURBS_ERROR31 = 100281 ) + integer*4 GLU_NURBS_ERROR32 + parameter ( GLU_NURBS_ERROR32 = 100282 ) + integer*4 GLU_NURBS_ERROR33 + parameter ( GLU_NURBS_ERROR33 = 100283 ) + integer*4 GLU_NURBS_ERROR34 + parameter ( GLU_NURBS_ERROR34 = 100284 ) + integer*4 GLU_NURBS_ERROR35 + parameter ( GLU_NURBS_ERROR35 = 100285 ) + integer*4 GLU_NURBS_ERROR36 + parameter ( GLU_NURBS_ERROR36 = 100286 ) + integer*4 GLU_NURBS_ERROR37 + parameter ( GLU_NURBS_ERROR37 = 100287 ) + + + character*128 fgluErrorString + character*128 fgluGetString + integer*4 fgluBuild1DMipmaps + integer*4 fgluBuild2DMipmaps + integer*4 fgluProject + integer*4 fgluScaleImage + integer*4 fgluUnProject diff --git a/headtrack_demo/include/glut/GL/fglut.h b/headtrack_demo/include/glut/GL/fglut.h new file mode 100644 index 0000000..efe3d14 --- /dev/null +++ b/headtrack_demo/include/glut/GL/fglut.h @@ -0,0 +1,321 @@ + +C Copyright (c) Mark J. Kilgard, 1994. + +C This program is freely distributable without licensing fees +C and is provided without guarantee or warrantee expressed or +C implied. This program is -not- in the public domain. + +C GLUT Fortran header file + +C display mode bit masks + integer*4 GLUT_RGB + parameter ( GLUT_RGB = 0 ) + integer*4 GLUT_RGBA + parameter ( GLUT_RGBA = 0 ) + integer*4 GLUT_INDEX + parameter ( GLUT_INDEX = 1 ) + integer*4 GLUT_SINGLE + parameter ( GLUT_SINGLE = 0 ) + integer*4 GLUT_DOUBLE + parameter ( GLUT_DOUBLE = 2 ) + integer*4 GLUT_ACCUM + parameter ( GLUT_ACCUM = 4 ) + integer*4 GLUT_ALPHA + parameter ( GLUT_ALPHA = 8 ) + integer*4 GLUT_DEPTH + parameter ( GLUT_DEPTH = 16 ) + integer*4 GLUT_STENCIL + parameter ( GLUT_STENCIL = 32 ) + integer*4 GLUT_MULTISAMPLE + parameter ( GLUT_MULTISAMPLE = 128 ) + integer*4 GLUT_STEREO + parameter ( GLUT_STEREO = 256 ) + +C mouse buttons + integer*4 GLUT_LEFT_BUTTON + parameter ( GLUT_LEFT_BUTTON = 0 ) + integer*4 GLUT_MIDDLE_BUTTON + parameter ( GLUT_MIDDLE_BUTTON = 1 ) + integer*4 GLUT_RIGHT_BUTTON + parameter ( GLUT_RIGHT_BUTTON = 2 ) + +C mouse button callback state + integer*4 GLUT_DOWN + parameter ( GLUT_DOWN = 0 ) + integer*4 GLUT_UP + parameter ( GLUT_UP = 1 ) + +C special key callback values + integer*4 GLUT_KEY_F1 + parameter ( GLUT_KEY_F1 = 1 ) + integer*4 GLUT_KEY_F2 + parameter ( GLUT_KEY_F2 = 2 ) + integer*4 GLUT_KEY_F3 + parameter ( GLUT_KEY_F3 = 3 ) + integer*4 GLUT_KEY_F4 + parameter ( GLUT_KEY_F4 = 4 ) + integer*4 GLUT_KEY_F5 + parameter ( GLUT_KEY_F5 = 5 ) + integer*4 GLUT_KEY_F6 + parameter ( GLUT_KEY_F6 = 6 ) + integer*4 GLUT_KEY_F7 + parameter ( GLUT_KEY_F7 = 7 ) + integer*4 GLUT_KEY_F8 + parameter ( GLUT_KEY_F8 = 8 ) + integer*4 GLUT_KEY_F9 + parameter ( GLUT_KEY_F9 = 9 ) + integer*4 GLUT_KEY_F10 + parameter ( GLUT_KEY_F10 = 10 ) + integer*4 GLUT_KEY_F11 + parameter ( GLUT_KEY_F11 = 11 ) + integer*4 GLUT_KEY_F12 + parameter ( GLUT_KEY_F12 = 12 ) + integer*4 GLUT_KEY_LEFT + parameter ( GLUT_KEY_LEFT = 100 ) + integer*4 GLUT_KEY_UP + parameter ( GLUT_KEY_UP = 101 ) + integer*4 GLUT_KEY_RIGHT + parameter ( GLUT_KEY_RIGHT = 102 ) + integer*4 GLUT_KEY_DOWN + parameter ( GLUT_KEY_DOWN = 103 ) + integer*4 GLUT_KEY_PAGE_UP + parameter ( GLUT_KEY_PAGE_UP = 104 ) + integer*4 GLUT_KEY_PAGE_DOWN + parameter ( GLUT_KEY_PAGE_DOWN = 105 ) + integer*4 GLUT_KEY_HOME + parameter ( GLUT_KEY_HOME = 106 ) + integer*4 GLUT_KEY_END + parameter ( GLUT_KEY_END = 107 ) + integer*4 GLUT_KEY_INSERT + parameter ( GLUT_KEY_INSERT = 108 ) + +C entry/exit callback state + integer*4 GLUT_LEFT + parameter ( GLUT_LEFT = 0 ) + integer*4 GLUT_ENTERED + parameter ( GLUT_ENTERED = 1 ) + +C menu usage callback state + integer*4 GLUT_MENU_NOT_IN_USE + parameter ( GLUT_MENU_NOT_IN_USE = 0 ) + integer*4 GLUT_MENU_IN_USE + parameter ( GLUT_MENU_IN_USE = 1 ) + +C visibility callback state + integer*4 GLUT_NOT_VISIBLE + parameter ( GLUT_NOT_VISIBLE = 0 ) + integer*4 GLUT_VISIBLE + parameter ( GLUT_VISIBLE = 1 ) + +C color index component selection values + integer*4 GLUT_RED + parameter ( GLUT_RED = 0 ) + integer*4 GLUT_GREEN + parameter ( GLUT_GREEN = 1 ) + integer*4 GLUT_BLUE + parameter ( GLUT_BLUE = 2 ) + +C XXX Unfortunately, SGI's Fortran compiler links with +C EXTERNAL data even if it is not used. This defeats +C the purpose of GLUT naming fonts via opaque symbols. +C This means GLUT Fortran programmers should explicitly +C declared EXTERNAL GLUT fonts in subroutines where +C the fonts are used. + +C stroke font opaque names +C external GLUT_STROKE_ROMAN +C external GLUT_STROKE_MONO_ROMAN + +C bitmap font opaque names +C external GLUT_BITMAP_9_BY_15 +C external GLUT_BITMAP_8_BY_13 +C external GLUT_BITMAP_TIMES_ROMAN_10 +C external GLUT_BITMAP_TIMES_ROMAN_24 +C external GLUT_BITMAP_HELVETICA_10 +C external GLUT_BITMAP_HELVETICA_12 +C external GLUT_BITMAP_HELVETICA_18 + +C glutGet parameters + integer*4 GLUT_WINDOW_X + parameter ( GLUT_WINDOW_X = 100 ) + integer*4 GLUT_WINDOW_Y + parameter ( GLUT_WINDOW_Y = 101 ) + integer*4 GLUT_WINDOW_WIDTH + parameter ( GLUT_WINDOW_WIDTH = 102 ) + integer*4 GLUT_WINDOW_HEIGHT + parameter ( GLUT_WINDOW_HEIGHT = 103 ) + integer*4 GLUT_WINDOW_BUFFER_SIZE + parameter ( GLUT_WINDOW_BUFFER_SIZE = 104 ) + integer*4 GLUT_WINDOW_STENCIL_SIZE + parameter ( GLUT_WINDOW_STENCIL_SIZE = 105 ) + integer*4 GLUT_WINDOW_DEPTH_SIZE + parameter ( GLUT_WINDOW_DEPTH_SIZE = 106 ) + integer*4 GLUT_WINDOW_RED_SIZE + parameter ( GLUT_WINDOW_RED_SIZE = 107 ) + integer*4 GLUT_WINDOW_GREEN_SIZE + parameter ( GLUT_WINDOW_GREEN_SIZE = 108 ) + integer*4 GLUT_WINDOW_BLUE_SIZE + parameter ( GLUT_WINDOW_BLUE_SIZE = 109 ) + integer*4 GLUT_WINDOW_ALPHA_SIZE + parameter ( GLUT_WINDOW_ALPHA_SIZE = 110 ) + integer*4 GLUT_WINDOW_ACCUM_RED_SIZE + parameter ( GLUT_WINDOW_ACCUM_RED_SIZE = 111 ) + integer*4 GLUT_WINDOW_ACCUM_GREEN_SIZE + parameter ( GLUT_WINDOW_ACCUM_GREEN_SIZE = 112 ) + integer*4 GLUT_WINDOW_ACCUM_BLUE_SIZE + parameter ( GLUT_WINDOW_ACCUM_BLUE_SIZE = 113 ) + integer*4 GLUT_WINDOW_ACCUM_ALPHA_SIZE + parameter ( GLUT_WINDOW_ACCUM_ALPHA_SIZE = 114 ) + integer*4 GLUT_WINDOW_DOUBLEBUFFER + parameter ( GLUT_WINDOW_DOUBLEBUFFER = 115 ) + integer*4 GLUT_WINDOW_RGBA + parameter ( GLUT_WINDOW_RGBA = 116 ) + integer*4 GLUT_WINDOW_PARENT + parameter ( GLUT_WINDOW_PARENT = 117 ) + integer*4 GLUT_WINDOW_NUM_CHILDREN + parameter ( GLUT_WINDOW_NUM_CHILDREN = 118 ) + integer*4 GLUT_WINDOW_COLORMAP_SIZE + parameter ( GLUT_WINDOW_COLORMAP_SIZE = 119 ) + integer*4 GLUT_WINDOW_NUM_SAMPLES + parameter ( GLUT_WINDOW_NUM_SAMPLES = 120 ) + integer*4 GLUT_WINDOW_STEREO + parameter ( GLUT_WINDOW_STEREO = 121 ) + integer*4 GLUT_WINDOW_CURSOR + parameter ( GLUT_WINDOW_CURSOR = 122 ) + integer*4 GLUT_SCREEN_WIDTH + parameter ( GLUT_SCREEN_WIDTH = 200 ) + integer*4 GLUT_SCREEN_HEIGHT + parameter ( GLUT_SCREEN_HEIGHT = 201 ) + integer*4 GLUT_SCREEN_WIDTH_MM + parameter ( GLUT_SCREEN_WIDTH_MM = 202 ) + integer*4 GLUT_SCREEN_HEIGHT_MM + parameter ( GLUT_SCREEN_HEIGHT_MM = 203 ) + integer*4 GLUT_MENU_NUM_ITEMS + parameter ( GLUT_MENU_NUM_ITEMS = 300 ) + integer*4 GLUT_DISPLAY_MODE_POSSIBLE + parameter ( GLUT_DISPLAY_MODE_POSSIBLE = 400 ) + integer*4 GLUT_INIT_WINDOW_X + parameter ( GLUT_INIT_WINDOW_X = 500 ) + integer*4 GLUT_INIT_WINDOW_Y + parameter ( GLUT_INIT_WINDOW_Y = 501 ) + integer*4 GLUT_INIT_WINDOW_WIDTH + parameter ( GLUT_INIT_WINDOW_WIDTH = 502 ) + integer*4 GLUT_INIT_WINDOW_HEIGHT + parameter ( GLUT_INIT_WINDOW_HEIGHT = 503 ) + integer*4 GLUT_INIT_DISPLAY_MODE + parameter ( GLUT_INIT_DISPLAY_MODE = 504 ) + integer*4 GLUT_ELAPSED_TIME + parameter ( GLUT_ELAPSED_TIME = 700 ) + +C glutDeviceGet parameters + integer*4 GLUT_HAS_KEYBOARD + parameter ( GLUT_HAS_KEYBOARD = 600 ) + integer*4 GLUT_HAS_MOUSE + parameter ( GLUT_HAS_MOUSE = 601 ) + integer*4 GLUT_HAS_SPACEBALL + parameter ( GLUT_HAS_SPACEBALL = 602 ) + integer*4 GLUT_HAS_DIAL_AND_BUTTON_BOX + parameter ( GLUT_HAS_DIAL_AND_BUTTON_BOX = 603 ) + integer*4 GLUT_HAS_TABLET + parameter ( GLUT_HAS_TABLET = 604 ) + integer*4 GLUT_NUM_MOUSE_BUTTONS + parameter ( GLUT_NUM_MOUSE_BUTTONS = 605 ) + integer*4 GLUT_NUM_SPACEBALL_BUTTONS + parameter ( GLUT_NUM_SPACEBALL_BUTTONS = 606 ) + integer*4 GLUT_NUM_BUTTON_BOX_BUTTONS + parameter ( GLUT_NUM_BUTTON_BOX_BUTTONS = 607 ) + integer*4 GLUT_NUM_DIALS + parameter ( GLUT_NUM_DIALS = 608 ) + integer*4 GLUT_NUM_TABLET_BUTTONS + parameter ( GLUT_NUM_TABLET_BUTTONS = 609 ) + +C glutLayerGet parameters + integer*4 GLUT_OVERLAY_POSSIBLE + parameter ( GLUT_OVERLAY_POSSIBLE = 800 ) + integer*4 GLUT_LAYER_IN_USE + parameter ( GLUT_LAYER_IN_USE = 801 ) + integer*4 GLUT_HAS_OVERLAY + parameter ( GLUT_HAS_OVERLAY = 802 ) + integer*4 GLUT_TRANSPARENT_INDEX + parameter ( GLUT_TRANSPARENT_INDEX = 803 ) + integer*4 GLUT_NORMAL_DAMAGED + parameter ( GLUT_NORMAL_DAMAGED = 804 ) + integer*4 GLUT_OVERLAY_DAMAGED + parameter ( GLUT_OVERLAY_DAMAGED = 805 ) + +C glutUseLayer parameters + integer*4 GLUT_NORMAL + parameter ( GLUT_NORMAL = 0 ) + integer*4 GLUT_OVERLAY + parameter ( GLUT_OVERLAY = 1 ) + +C glutGetModifiers return mask + integer*4 GLUT_ACTIVE_SHIFT + parameter ( GLUT_ACTIVE_SHIFT = 1 ) + integer*4 GLUT_ACTIVE_CTRL + parameter ( GLUT_ACTIVE_CTRL = 2 ) + integer*4 GLUT_ACTIVE_ALT + parameter ( GLUT_ACTIVE_ALT = 4 ) + +C glutSetCursor parameters + integer*4 GLUT_CURSOR_RIGHT_ARROW + parameter ( GLUT_CURSOR_RIGHT_ARROW = 0 ) + integer*4 GLUT_CURSOR_LEFT_ARROW + parameter ( GLUT_CURSOR_LEFT_ARROW = 1 ) + integer*4 GLUT_CURSOR_INFO + parameter ( GLUT_CURSOR_INFO = 2 ) + integer*4 GLUT_CURSOR_DESTROY + parameter ( GLUT_CURSOR_DESTROY = 3 ) + integer*4 GLUT_CURSOR_HELP + parameter ( GLUT_CURSOR_HELP = 4 ) + integer*4 GLUT_CURSOR_CYCLE + parameter ( GLUT_CURSOR_CYCLE = 5 ) + integer*4 GLUT_CURSOR_SPRAY + parameter ( GLUT_CURSOR_SPRAY = 6 ) + integer*4 GLUT_CURSOR_WAIT + parameter ( GLUT_CURSOR_WAIT = 7 ) + integer*4 GLUT_CURSOR_TEXT + parameter ( GLUT_CURSOR_TEXT = 8 ) + integer*4 GLUT_CURSOR_CROSSHAIR + parameter ( GLUT_CURSOR_CROSSHAIR = 9 ) + integer*4 GLUT_CURSOR_UP_DOWN + parameter ( GLUT_CURSOR_UP_DOWN = 10 ) + integer*4 GLUT_CURSOR_LEFT_RIGHT + parameter ( GLUT_CURSOR_LEFT_RIGHT = 11 ) + integer*4 GLUT_CURSOR_TOP_SIDE + parameter ( GLUT_CURSOR_TOP_SIDE = 12 ) + integer*4 GLUT_CURSOR_BOTTOM_SIDE + parameter ( GLUT_CURSOR_BOTTOM_SIDE = 13 ) + integer*4 GLUT_CURSOR_LEFT_SIDE + parameter ( GLUT_CURSOR_LEFT_SIDE = 14 ) + integer*4 GLUT_CURSOR_RIGHT_SIDE + parameter ( GLUT_CURSOR_RIGHT_SIDE = 15 ) + integer*4 GLUT_CURSOR_TOP_LEFT_CORNER + parameter ( GLUT_CURSOR_TOP_LEFT_CORNER = 16 ) + integer*4 GLUT_CURSOR_TOP_RIGHT_CORNER + parameter ( GLUT_CURSOR_TOP_RIGHT_CORNER = 17 ) + integer*4 GLUT_CURSOR_BOTTOM_RIGHT_CORNER + parameter ( GLUT_CURSOR_BOTTOM_RIGHT_CORNER = 18 ) + integer*4 GLUT_CURSOR_BOTTOM_LEFT_CORNER + parameter ( GLUT_CURSOR_BOTTOM_LEFT_CORNER = 19 ) + integer*4 GLUT_CURSOR_INHERIT + parameter ( GLUT_CURSOR_INHERIT = 100 ) + integer*4 GLUT_CURSOR_NONE + parameter ( GLUT_CURSOR_NONE = 101 ) + integer*4 GLUT_CURSOR_FULL_CROSSHAIR + parameter ( GLUT_CURSOR_FULL_CROSSHAIR = 102 ) + +C GLUT functions + integer*4 glutcreatewindow + integer*4 glutcreatesubwindow + integer*4 glutgetwindow + integer*4 glutcreatemenu + integer*4 glutgetmenu + real glutgetcolor + integer*4 glutget + integer*4 glutdeviceget + integer*4 glutextensionsupported + +C GLUT NULL name + external glutnull + diff --git a/headtrack_demo/include/glut/GL/glsmap.h b/headtrack_demo/include/glut/GL/glsmap.h new file mode 100644 index 0000000..9f0b592 --- /dev/null +++ b/headtrack_demo/include/glut/GL/glsmap.h @@ -0,0 +1,137 @@ +#ifndef __glsmap_h__ +#define __glsmap_h__ + +/* Copyright (c) Mark J. Kilgard, 1998. */ + +/* This program is freely distributable without licensing fees + and is provided without guarantee or warrantee expressed or + implied. This program is -not- in the public domain. */ + +#if defined(_WIN32) + +/* Try hard to avoid including to avoid name space pollution, + but Win32's needs APIENTRY and WINGDIAPI defined properly. */ +# if 0 +# define WIN32_LEAN_AND_MEAN +# include +# else + /* XXX This is from Win32's */ +# ifndef APIENTRY +# if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) +# define APIENTRY __stdcall +# else +# define APIENTRY +# endif +# endif +# ifndef CALLBACK + /* XXX This is from Win32's */ +# if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) +# define CALLBACK __stdcall +# else +# define CALLBACK +# endif +# endif + /* XXX This is from Win32's and */ +# ifndef WINGDIAPI +# define WINGDIAPI __declspec(dllimport) +# endif + /* XXX This is from Win32's */ +# ifndef _WCHAR_T_DEFINED +typedef unsigned short wchar_t; +# define _WCHAR_T_DEFINED +# endif +# endif + +#pragma warning (disable:4244) /* Disable bogus conversion warnings. */ +#pragma warning (disable:4305) /* VC++ 5.0 version of above warning. */ + +#endif /* _WIN32 */ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + SMAP_CLEAR_SMAP_TEXTURE = 0x1, + SMAP_GENERATE_VIEW_MIPMAPS = 0x2, + SMAP_GENERATE_SMAP_MIPMAPS = 0x4, + SMAP_GENERATE_MIPMAPS = 0x6 /* both of above */ +} SphereMapFlags; + +/* Cube view enumerants. */ +enum { + SMAP_FRONT = 0, + SMAP_TOP = 1, + SMAP_BOTTOM = 2, + SMAP_LEFT = 3, + SMAP_RIGHT = 4, + SMAP_BACK = 5 +}; + +typedef struct _SphereMap SphereMap; + +extern SphereMap *smapCreateSphereMap(SphereMap *shareSmap); +extern void smapDestroySphereMap(SphereMap *smap); + +extern void smapConfigureSphereMapMesh(SphereMap *smap, int steps, int rings, int edgeExtend); + +extern void smapSetSphereMapTexObj(SphereMap *smap, GLuint texobj); +extern void smapSetViewTexObj(SphereMap *smap, GLuint texobj); +extern void smapSetViewTexObjs(SphereMap *smap, GLuint texobjs[6]); +extern void smapGetSphereMapTexObj(SphereMap *smap, GLuint *texobj); +extern void smapGetViewTexObj(SphereMap *smap, GLuint *texobj); +extern void smapGetViewTexObjs(SphereMap *smap, GLuint texobjs[6]); + +extern void smapSetFlags(SphereMap *smap, SphereMapFlags flags); +extern void smapGetFlags(SphereMap *smap, SphereMapFlags *flags); + +extern void smapSetViewOrigin(SphereMap *smap, GLint x, GLint y); +extern void smapSetSphereMapOrigin(SphereMap *smap, GLint x, GLint y); +extern void smapGetViewOrigin(SphereMap *smap, GLint *x, GLint *y); +extern void smapGetSphereMapOrigin(SphereMap *smap, GLint *x, GLint *y); + +extern void smapSetEye(SphereMap *smap, GLfloat eyex, GLfloat eyey, GLfloat eyez); +extern void smapSetEyeVector(SphereMap *smap, GLfloat *eye); +extern void smapSetUp(SphereMap *smap, GLfloat upx, GLfloat upy, GLfloat upz); +extern void smapSetUpVector(SphereMap *smap, GLfloat *up); +extern void smapSetObject(SphereMap *smap, GLfloat objx, GLfloat objy, GLfloat objz); +extern void smapSetObjectVector(SphereMap *smap, GLfloat *obj); +extern void smapGetEye(SphereMap *smap, GLfloat *eyex, GLfloat *eyey, GLfloat *eyez); +extern void smapGetEyeVector(SphereMap *smap, GLfloat *eye); +extern void smapGetUp(SphereMap *smap, GLfloat *upx, GLfloat *upy, GLfloat *upz); +extern void smapGetUpVector(SphereMap *smap, GLfloat *up); +extern void smapGetObject(SphereMap *smap, GLfloat *objx, GLfloat *objy, GLfloat *objz); +extern void smapGetObjectVector(SphereMap *smap, GLfloat *obj); + +extern void smapSetNearFar(SphereMap *smap, GLfloat viewNear, GLfloat viewFar); +extern void smapGetNearFar(SphereMap *smap, GLfloat *viewNear, GLfloat *viewFar); + +extern void smapSetSphereMapTexDim(SphereMap *smap, GLsizei texdim); +extern void smapSetViewTexDim(SphereMap *smap, GLsizei texdim); +extern void smapGetSphereMapTexDim(SphereMap *smap, GLsizei *texdim); +extern void smapGetViewTexDim(SphereMap *smap, GLsizei *texdim); + +extern void smapSetContextData(SphereMap *smap, void *context); +extern void smapGetContextData(SphereMap *smap, void **context); + +extern void smapSetPositionLightsFunc(SphereMap *smap, void (*positionLights)(int view, void *context)); +extern void smapSetDrawViewFunc(SphereMap *smap, void (*drawView)(int view, void *context)); +extern void smapGetPositionLightsFunc(SphereMap *smap, void (**positionLights)(int view, void *context)); +extern void smapGetDrawViewFunc(SphereMap *smap, void (**drawView)(int view, void *context)); + +extern void smapGenViewTex(SphereMap *smap, int view); +extern void smapGenViewTexs(SphereMap *smap); +extern void smapGenSphereMapFromViewTexs(SphereMap *smap); +extern void smapGenSphereMap(SphereMap *smap); +extern void smapGenSphereMapWithOneViewTex(SphereMap *smap); + +extern int smapRvecToSt(float rvec[3], float st[2]); +extern void smapStToRvec(float *st, float *rvec); + +#ifdef __cplusplus +} + +#endif +#endif /* __glsmap_h__ */ diff --git a/headtrack_demo/include/glut/GL/glut.h b/headtrack_demo/include/glut/GL/glut.h new file mode 100644 index 0000000..e0692ad --- /dev/null +++ b/headtrack_demo/include/glut/GL/glut.h @@ -0,0 +1,596 @@ +#ifndef __glut_h__ +#define __glut_h__ + +/* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1998. */ + +/* This program is freely distributable without licensing fees and is + provided without guarantee or warrantee expressed or implied. This + program is -not- in the public domain. */ + +#if defined(_WIN32) + +/* GLUT 3.7 now tries to avoid including + to avoid name space pollution, but Win32's + needs APIENTRY and WINGDIAPI defined properly. */ +# if 0 +# define WIN32_LEAN_AND_MEAN +# include +# else + /* XXX This is from Win32's */ +# ifndef APIENTRY +# define GLUT_APIENTRY_DEFINED +# if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) +# define APIENTRY __stdcall +# else +# define APIENTRY +# endif +# endif + /* XXX This is from Win32's */ +# ifndef CALLBACK +# if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) +# define CALLBACK __stdcall +# else +# define CALLBACK +# endif +# endif + /* XXX This is from Win32's and */ +# ifndef WINGDIAPI +# define GLUT_WINGDIAPI_DEFINED +# define WINGDIAPI __declspec(dllimport) +# endif + /* XXX This is from Win32's */ +# ifndef _WCHAR_T_DEFINED +typedef unsigned short wchar_t; +# define _WCHAR_T_DEFINED +# endif +# endif + +#pragma comment (lib, "winmm.lib") /* link with Windows MultiMedia lib */ +#pragma comment (lib, "opengl32.lib") /* link with Microsoft OpenGL lib */ +#pragma comment (lib, "glu32.lib") /* link with OpenGL Utility lib */ +#pragma comment (lib, "glut32.lib") /* link with Win32 GLUT lib */ + +#pragma warning (disable:4244) /* Disable bogus conversion warnings. */ +#pragma warning (disable:4305) /* VC++ 5.0 version of above warning. */ + +#endif + +#include +#include + +/* define APIENTRY and CALLBACK to null string if we aren't on Win32 */ +#if !defined(_WIN32) +#define APIENTRY +#define GLUT_APIENTRY_DEFINED +#define CALLBACK +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/** + GLUT API revision history: + + GLUT_API_VERSION is updated to reflect incompatible GLUT + API changes (interface changes, semantic changes, deletions, + or additions). + + GLUT_API_VERSION=1 First public release of GLUT. 11/29/94 + + GLUT_API_VERSION=2 Added support for OpenGL/GLX multisampling, + extension. Supports new input devices like tablet, dial and button + box, and Spaceball. Easy to query OpenGL extensions. + + GLUT_API_VERSION=3 glutMenuStatus added. + + GLUT_API_VERSION=4 glutInitDisplayString, glutWarpPointer, + glutBitmapLength, glutStrokeLength, glutWindowStatusFunc, dynamic + video resize subAPI, glutPostWindowRedisplay, glutKeyboardUpFunc, + glutSpecialUpFunc, glutIgnoreKeyRepeat, glutSetKeyRepeat, + glutJoystickFunc, glutForceJoystickFunc (NOT FINALIZED!). +**/ +#ifndef GLUT_API_VERSION /* allow this to be overriden */ +#define GLUT_API_VERSION 3 +#endif + +/** + GLUT implementation revision history: + + GLUT_XLIB_IMPLEMENTATION is updated to reflect both GLUT + API revisions and implementation revisions (ie, bug fixes). + + GLUT_XLIB_IMPLEMENTATION=1 mjk's first public release of + GLUT Xlib-based implementation. 11/29/94 + + GLUT_XLIB_IMPLEMENTATION=2 mjk's second public release of + GLUT Xlib-based implementation providing GLUT version 2 + interfaces. + + GLUT_XLIB_IMPLEMENTATION=3 mjk's GLUT 2.2 images. 4/17/95 + + GLUT_XLIB_IMPLEMENTATION=4 mjk's GLUT 2.3 images. 6/?/95 + + GLUT_XLIB_IMPLEMENTATION=5 mjk's GLUT 3.0 images. 10/?/95 + + GLUT_XLIB_IMPLEMENTATION=7 mjk's GLUT 3.1+ with glutWarpPoitner. 7/24/96 + + GLUT_XLIB_IMPLEMENTATION=8 mjk's GLUT 3.1+ with glutWarpPoitner + and video resize. 1/3/97 + + GLUT_XLIB_IMPLEMENTATION=9 mjk's GLUT 3.4 release with early GLUT 4 routines. + + GLUT_XLIB_IMPLEMENTATION=11 Mesa 2.5's GLUT 3.6 release. + + GLUT_XLIB_IMPLEMENTATION=12 mjk's GLUT 3.6 release with early GLUT 4 routines + signal handling. + + GLUT_XLIB_IMPLEMENTATION=13 mjk's GLUT 3.7 release with GameGLUT support. +**/ +#ifndef GLUT_XLIB_IMPLEMENTATION /* Allow this to be overriden. */ +#define GLUT_XLIB_IMPLEMENTATION 13 +#endif + +/* Display mode bit masks. */ +#define GLUT_RGB 0 +#define GLUT_RGBA GLUT_RGB +#define GLUT_INDEX 1 +#define GLUT_SINGLE 0 +#define GLUT_DOUBLE 2 +#define GLUT_ACCUM 4 +#define GLUT_ALPHA 8 +#define GLUT_DEPTH 16 +#define GLUT_STENCIL 32 +#if (GLUT_API_VERSION >= 2) +#define GLUT_MULTISAMPLE 128 +#define GLUT_STEREO 256 +#endif +#if (GLUT_API_VERSION >= 3) +#define GLUT_LUMINANCE 512 +#endif + +/* Mouse buttons. */ +#define GLUT_LEFT_BUTTON 0 +#define GLUT_MIDDLE_BUTTON 1 +#define GLUT_RIGHT_BUTTON 2 + +/* Mouse button state. */ +#define GLUT_DOWN 0 +#define GLUT_UP 1 + +#if (GLUT_API_VERSION >= 2) +/* function keys */ +#define GLUT_KEY_F1 1 +#define GLUT_KEY_F2 2 +#define GLUT_KEY_F3 3 +#define GLUT_KEY_F4 4 +#define GLUT_KEY_F5 5 +#define GLUT_KEY_F6 6 +#define GLUT_KEY_F7 7 +#define GLUT_KEY_F8 8 +#define GLUT_KEY_F9 9 +#define GLUT_KEY_F10 10 +#define GLUT_KEY_F11 11 +#define GLUT_KEY_F12 12 +/* directional keys */ +#define GLUT_KEY_LEFT 100 +#define GLUT_KEY_UP 101 +#define GLUT_KEY_RIGHT 102 +#define GLUT_KEY_DOWN 103 +#define GLUT_KEY_PAGE_UP 104 +#define GLUT_KEY_PAGE_DOWN 105 +#define GLUT_KEY_HOME 106 +#define GLUT_KEY_END 107 +#define GLUT_KEY_INSERT 108 +#endif + +/* Entry/exit state. */ +#define GLUT_LEFT 0 +#define GLUT_ENTERED 1 + +/* Menu usage state. */ +#define GLUT_MENU_NOT_IN_USE 0 +#define GLUT_MENU_IN_USE 1 + +/* Visibility state. */ +#define GLUT_NOT_VISIBLE 0 +#define GLUT_VISIBLE 1 + +/* Window status state. */ +#define GLUT_HIDDEN 0 +#define GLUT_FULLY_RETAINED 1 +#define GLUT_PARTIALLY_RETAINED 2 +#define GLUT_FULLY_COVERED 3 + +/* Color index component selection values. */ +#define GLUT_RED 0 +#define GLUT_GREEN 1 +#define GLUT_BLUE 2 + +/* Layers for use. */ +#define GLUT_NORMAL 0 +#define GLUT_OVERLAY 1 + +#if defined(_WIN32) +/* Stroke font constants (use these in GLUT program). */ +#define GLUT_STROKE_ROMAN ((void*)0) +#define GLUT_STROKE_MONO_ROMAN ((void*)1) + +/* Bitmap font constants (use these in GLUT program). */ +#define GLUT_BITMAP_9_BY_15 ((void*)2) +#define GLUT_BITMAP_8_BY_13 ((void*)3) +#define GLUT_BITMAP_TIMES_ROMAN_10 ((void*)4) +#define GLUT_BITMAP_TIMES_ROMAN_24 ((void*)5) +#if (GLUT_API_VERSION >= 3) +#define GLUT_BITMAP_HELVETICA_10 ((void*)6) +#define GLUT_BITMAP_HELVETICA_12 ((void*)7) +#define GLUT_BITMAP_HELVETICA_18 ((void*)8) +#endif +#else +/* Stroke font opaque addresses (use constants instead in source code). */ +extern void *glutStrokeRoman; +extern void *glutStrokeMonoRoman; + +/* Stroke font constants (use these in GLUT program). */ +#define GLUT_STROKE_ROMAN (&glutStrokeRoman) +#define GLUT_STROKE_MONO_ROMAN (&glutStrokeMonoRoman) + +/* Bitmap font opaque addresses (use constants instead in source code). */ +extern void *glutBitmap9By15; +extern void *glutBitmap8By13; +extern void *glutBitmapTimesRoman10; +extern void *glutBitmapTimesRoman24; +extern void *glutBitmapHelvetica10; +extern void *glutBitmapHelvetica12; +extern void *glutBitmapHelvetica18; + +/* Bitmap font constants (use these in GLUT program). */ +#define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) +#define GLUT_BITMAP_8_BY_13 (&glutBitmap8By13) +#define GLUT_BITMAP_TIMES_ROMAN_10 (&glutBitmapTimesRoman10) +#define GLUT_BITMAP_TIMES_ROMAN_24 (&glutBitmapTimesRoman24) +#if (GLUT_API_VERSION >= 3) +#define GLUT_BITMAP_HELVETICA_10 (&glutBitmapHelvetica10) +#define GLUT_BITMAP_HELVETICA_12 (&glutBitmapHelvetica12) +#define GLUT_BITMAP_HELVETICA_18 (&glutBitmapHelvetica18) +#endif +#endif + +/* glutGet parameters. */ +#define GLUT_WINDOW_X 100 +#define GLUT_WINDOW_Y 101 +#define GLUT_WINDOW_WIDTH 102 +#define GLUT_WINDOW_HEIGHT 103 +#define GLUT_WINDOW_BUFFER_SIZE 104 +#define GLUT_WINDOW_STENCIL_SIZE 105 +#define GLUT_WINDOW_DEPTH_SIZE 106 +#define GLUT_WINDOW_RED_SIZE 107 +#define GLUT_WINDOW_GREEN_SIZE 108 +#define GLUT_WINDOW_BLUE_SIZE 109 +#define GLUT_WINDOW_ALPHA_SIZE 110 +#define GLUT_WINDOW_ACCUM_RED_SIZE 111 +#define GLUT_WINDOW_ACCUM_GREEN_SIZE 112 +#define GLUT_WINDOW_ACCUM_BLUE_SIZE 113 +#define GLUT_WINDOW_ACCUM_ALPHA_SIZE 114 +#define GLUT_WINDOW_DOUBLEBUFFER 115 +#define GLUT_WINDOW_RGBA 116 +#define GLUT_WINDOW_PARENT 117 +#define GLUT_WINDOW_NUM_CHILDREN 118 +#define GLUT_WINDOW_COLORMAP_SIZE 119 +#if (GLUT_API_VERSION >= 2) +#define GLUT_WINDOW_NUM_SAMPLES 120 +#define GLUT_WINDOW_STEREO 121 +#endif +#if (GLUT_API_VERSION >= 3) +#define GLUT_WINDOW_CURSOR 122 +#endif +#define GLUT_SCREEN_WIDTH 200 +#define GLUT_SCREEN_HEIGHT 201 +#define GLUT_SCREEN_WIDTH_MM 202 +#define GLUT_SCREEN_HEIGHT_MM 203 +#define GLUT_MENU_NUM_ITEMS 300 +#define GLUT_DISPLAY_MODE_POSSIBLE 400 +#define GLUT_INIT_WINDOW_X 500 +#define GLUT_INIT_WINDOW_Y 501 +#define GLUT_INIT_WINDOW_WIDTH 502 +#define GLUT_INIT_WINDOW_HEIGHT 503 +#define GLUT_INIT_DISPLAY_MODE 504 +#if (GLUT_API_VERSION >= 2) +#define GLUT_ELAPSED_TIME 700 +#endif +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) +#define GLUT_WINDOW_FORMAT_ID 123 +#endif + +#if (GLUT_API_VERSION >= 2) +/* glutDeviceGet parameters. */ +#define GLUT_HAS_KEYBOARD 600 +#define GLUT_HAS_MOUSE 601 +#define GLUT_HAS_SPACEBALL 602 +#define GLUT_HAS_DIAL_AND_BUTTON_BOX 603 +#define GLUT_HAS_TABLET 604 +#define GLUT_NUM_MOUSE_BUTTONS 605 +#define GLUT_NUM_SPACEBALL_BUTTONS 606 +#define GLUT_NUM_BUTTON_BOX_BUTTONS 607 +#define GLUT_NUM_DIALS 608 +#define GLUT_NUM_TABLET_BUTTONS 609 +#endif +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) +#define GLUT_DEVICE_IGNORE_KEY_REPEAT 610 +#define GLUT_DEVICE_KEY_REPEAT 611 +#define GLUT_HAS_JOYSTICK 612 +#define GLUT_OWNS_JOYSTICK 613 +#define GLUT_JOYSTICK_BUTTONS 614 +#define GLUT_JOYSTICK_AXES 615 +#define GLUT_JOYSTICK_POLL_RATE 616 +#endif + +#if (GLUT_API_VERSION >= 3) +/* glutLayerGet parameters. */ +#define GLUT_OVERLAY_POSSIBLE 800 +#define GLUT_LAYER_IN_USE 801 +#define GLUT_HAS_OVERLAY 802 +#define GLUT_TRANSPARENT_INDEX 803 +#define GLUT_NORMAL_DAMAGED 804 +#define GLUT_OVERLAY_DAMAGED 805 + +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +/* glutVideoResizeGet parameters. */ +#define GLUT_VIDEO_RESIZE_POSSIBLE 900 +#define GLUT_VIDEO_RESIZE_IN_USE 901 +#define GLUT_VIDEO_RESIZE_X_DELTA 902 +#define GLUT_VIDEO_RESIZE_Y_DELTA 903 +#define GLUT_VIDEO_RESIZE_WIDTH_DELTA 904 +#define GLUT_VIDEO_RESIZE_HEIGHT_DELTA 905 +#define GLUT_VIDEO_RESIZE_X 906 +#define GLUT_VIDEO_RESIZE_Y 907 +#define GLUT_VIDEO_RESIZE_WIDTH 908 +#define GLUT_VIDEO_RESIZE_HEIGHT 909 +#endif + +/* glutUseLayer parameters. */ +#define GLUT_NORMAL 0 +#define GLUT_OVERLAY 1 + +/* glutGetModifiers return mask. */ +#define GLUT_ACTIVE_SHIFT 1 +#define GLUT_ACTIVE_CTRL 2 +#define GLUT_ACTIVE_ALT 4 + +/* glutSetCursor parameters. */ +/* Basic arrows. */ +#define GLUT_CURSOR_RIGHT_ARROW 0 +#define GLUT_CURSOR_LEFT_ARROW 1 +/* Symbolic cursor shapes. */ +#define GLUT_CURSOR_INFO 2 +#define GLUT_CURSOR_DESTROY 3 +#define GLUT_CURSOR_HELP 4 +#define GLUT_CURSOR_CYCLE 5 +#define GLUT_CURSOR_SPRAY 6 +#define GLUT_CURSOR_WAIT 7 +#define GLUT_CURSOR_TEXT 8 +#define GLUT_CURSOR_CROSSHAIR 9 +/* Directional cursors. */ +#define GLUT_CURSOR_UP_DOWN 10 +#define GLUT_CURSOR_LEFT_RIGHT 11 +/* Sizing cursors. */ +#define GLUT_CURSOR_TOP_SIDE 12 +#define GLUT_CURSOR_BOTTOM_SIDE 13 +#define GLUT_CURSOR_LEFT_SIDE 14 +#define GLUT_CURSOR_RIGHT_SIDE 15 +#define GLUT_CURSOR_TOP_LEFT_CORNER 16 +#define GLUT_CURSOR_TOP_RIGHT_CORNER 17 +#define GLUT_CURSOR_BOTTOM_RIGHT_CORNER 18 +#define GLUT_CURSOR_BOTTOM_LEFT_CORNER 19 +/* Inherit from parent window. */ +#define GLUT_CURSOR_INHERIT 100 +/* Blank cursor. */ +#define GLUT_CURSOR_NONE 101 +/* Fullscreen crosshair (if available). */ +#define GLUT_CURSOR_FULL_CROSSHAIR 102 +#endif + +/* GLUT initialization sub-API. */ +extern void APIENTRY glutInit(int *argcp, char **argv); +extern void APIENTRY glutInitDisplayMode(unsigned int mode); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +extern void APIENTRY glutInitDisplayString(const char *string); +#endif +extern void APIENTRY glutInitWindowPosition(int x, int y); +extern void APIENTRY glutInitWindowSize(int width, int height); +extern void APIENTRY glutMainLoop(void); + +/* GLUT window sub-API. */ +extern int APIENTRY glutCreateWindow(const char *title); +extern int APIENTRY glutCreateSubWindow(int win, int x, int y, int width, int height); +extern void APIENTRY glutDestroyWindow(int win); +extern void APIENTRY glutPostRedisplay(void); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11) +extern void APIENTRY glutPostWindowRedisplay(int win); +#endif +extern void APIENTRY glutSwapBuffers(void); +extern int APIENTRY glutGetWindow(void); +extern void APIENTRY glutSetWindow(int win); +extern void APIENTRY glutSetWindowTitle(const char *title); +extern void APIENTRY glutSetIconTitle(const char *title); +extern void APIENTRY glutPositionWindow(int x, int y); +extern void APIENTRY glutReshapeWindow(int width, int height); +extern void APIENTRY glutPopWindow(void); +extern void APIENTRY glutPushWindow(void); +extern void APIENTRY glutIconifyWindow(void); +extern void APIENTRY glutShowWindow(void); +extern void APIENTRY glutHideWindow(void); +#if (GLUT_API_VERSION >= 3) +extern void APIENTRY glutFullScreen(void); +extern void APIENTRY glutSetCursor(int cursor); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +extern void APIENTRY glutWarpPointer(int x, int y); +#endif + +/* GLUT overlay sub-API. */ +extern void APIENTRY glutEstablishOverlay(void); +extern void APIENTRY glutRemoveOverlay(void); +extern void APIENTRY glutUseLayer(GLenum layer); +extern void APIENTRY glutPostOverlayRedisplay(void); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11) +extern void APIENTRY glutPostWindowOverlayRedisplay(int win); +#endif +extern void APIENTRY glutShowOverlay(void); +extern void APIENTRY glutHideOverlay(void); +#endif + +/* GLUT menu sub-API. */ +extern int APIENTRY glutCreateMenu(void (*)(int)); +extern void APIENTRY glutDestroyMenu(int menu); +extern int APIENTRY glutGetMenu(void); +extern void APIENTRY glutSetMenu(int menu); +extern void APIENTRY glutAddMenuEntry(const char *label, int value); +extern void APIENTRY glutAddSubMenu(const char *label, int submenu); +extern void APIENTRY glutChangeToMenuEntry(int item, const char *label, int value); +extern void APIENTRY glutChangeToSubMenu(int item, const char *label, int submenu); +extern void APIENTRY glutRemoveMenuItem(int item); +extern void APIENTRY glutAttachMenu(int button); +extern void APIENTRY glutDetachMenu(int button); + +/* GLUT window callback sub-API. */ +extern void APIENTRY glutDisplayFunc(void (*func)(void)); +extern void APIENTRY glutReshapeFunc(void (*func)(int width, int height)); +extern void APIENTRY glutKeyboardFunc(void (*func)(unsigned char key, int x, int y)); +extern void APIENTRY glutMouseFunc(void (*func)(int button, int state, int x, int y)); +extern void APIENTRY glutMotionFunc(void (*func)(int x, int y)); +extern void APIENTRY glutPassiveMotionFunc(void (*func)(int x, int y)); +extern void APIENTRY glutEntryFunc(void (*func)(int state)); +extern void APIENTRY glutVisibilityFunc(void (*func)(int state)); +extern void APIENTRY glutIdleFunc(void (*func)(void)); +extern void APIENTRY glutTimerFunc(unsigned int millis, void (*func)(int value), int value); +extern void APIENTRY glutMenuStateFunc(void (*func)(int state)); +#if (GLUT_API_VERSION >= 2) +extern void APIENTRY glutSpecialFunc(void (*func)(int key, int x, int y)); +extern void APIENTRY glutSpaceballMotionFunc(void (*func)(int x, int y, int z)); +extern void APIENTRY glutSpaceballRotateFunc(void (*func)(int x, int y, int z)); +extern void APIENTRY glutSpaceballButtonFunc(void (*func)(int button, int state)); +extern void APIENTRY glutButtonBoxFunc(void (*func)(int button, int state)); +extern void APIENTRY glutDialsFunc(void (*func)(int dial, int value)); +extern void APIENTRY glutTabletMotionFunc(void (*func)(int x, int y)); +extern void APIENTRY glutTabletButtonFunc(void (*func)(int button, int state, int x, int y)); +#if (GLUT_API_VERSION >= 3) +extern void APIENTRY glutMenuStatusFunc(void (*func)(int status, int x, int y)); +extern void APIENTRY glutOverlayDisplayFunc(void (*func)(void)); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +extern void APIENTRY glutWindowStatusFunc(void (*func)(int state)); +#endif +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) +extern void APIENTRY glutKeyboardUpFunc(void (*func)(unsigned char key, int x, int y)); +extern void APIENTRY glutSpecialUpFunc(void (*func)(int key, int x, int y)); +extern void APIENTRY glutJoystickFunc(void (*func)(unsigned int buttonMask, int x, int y, int z), int pollInterval); +#endif +#endif +#endif + +/* GLUT color index sub-API. */ +extern void APIENTRY glutSetColor(int, GLfloat red, GLfloat green, GLfloat blue); +extern GLfloat APIENTRY glutGetColor(int ndx, int component); +extern void APIENTRY glutCopyColormap(int win); + +/* GLUT state retrieval sub-API. */ +extern int APIENTRY glutGet(GLenum type); +extern int APIENTRY glutDeviceGet(GLenum type); +#if (GLUT_API_VERSION >= 2) +/* GLUT extension support sub-API */ +extern int APIENTRY glutExtensionSupported(const char *name); +#endif +#if (GLUT_API_VERSION >= 3) +extern int APIENTRY glutGetModifiers(void); +extern int APIENTRY glutLayerGet(GLenum type); +#endif + +/* GLUT font sub-API */ +extern void APIENTRY glutBitmapCharacter(void *font, int character); +extern int APIENTRY glutBitmapWidth(void *font, int character); +extern void APIENTRY glutStrokeCharacter(void *font, int character); +extern int APIENTRY glutStrokeWidth(void *font, int character); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +extern int APIENTRY glutBitmapLength(void *font, const unsigned char *string); +extern int APIENTRY glutStrokeLength(void *font, const unsigned char *string); +#endif + +/* GLUT pre-built models sub-API */ +extern void APIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks); +extern void APIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks); +extern void APIENTRY glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks); +extern void APIENTRY glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks); +extern void APIENTRY glutWireCube(GLdouble size); +extern void APIENTRY glutSolidCube(GLdouble size); +extern void APIENTRY glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings); +extern void APIENTRY glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings); +extern void APIENTRY glutWireDodecahedron(void); +extern void APIENTRY glutSolidDodecahedron(void); +extern void APIENTRY glutWireTeapot(GLdouble size); +extern void APIENTRY glutSolidTeapot(GLdouble size); +extern void APIENTRY glutWireOctahedron(void); +extern void APIENTRY glutSolidOctahedron(void); +extern void APIENTRY glutWireTetrahedron(void); +extern void APIENTRY glutSolidTetrahedron(void); +extern void APIENTRY glutWireIcosahedron(void); +extern void APIENTRY glutSolidIcosahedron(void); + +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +/* GLUT video resize sub-API. */ +extern int APIENTRY glutVideoResizeGet(GLenum param); +extern void APIENTRY glutSetupVideoResizing(void); +extern void APIENTRY glutStopVideoResizing(void); +extern void APIENTRY glutVideoResize(int x, int y, int width, int height); +extern void APIENTRY glutVideoPan(int x, int y, int width, int height); + +/* GLUT debugging sub-API. */ +extern void APIENTRY glutReportErrors(void); +#endif + +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) +/* GLUT device control sub-API. */ +/* glutSetKeyRepeat modes. */ +#define GLUT_KEY_REPEAT_OFF 0 +#define GLUT_KEY_REPEAT_ON 1 +#define GLUT_KEY_REPEAT_DEFAULT 2 + +/* Joystick button masks. */ +#define GLUT_JOYSTICK_BUTTON_A 1 +#define GLUT_JOYSTICK_BUTTON_B 2 +#define GLUT_JOYSTICK_BUTTON_C 4 +#define GLUT_JOYSTICK_BUTTON_D 8 + +extern void APIENTRY glutIgnoreKeyRepeat(int ignore); +extern void APIENTRY glutSetKeyRepeat(int repeatMode); +extern void APIENTRY glutForceJoystickFunc(void); + +/* GLUT game mode sub-API. */ +/* glutGameModeGet. */ +#define GLUT_GAME_MODE_ACTIVE 0 +#define GLUT_GAME_MODE_POSSIBLE 1 +#define GLUT_GAME_MODE_WIDTH 2 +#define GLUT_GAME_MODE_HEIGHT 3 +#define GLUT_GAME_MODE_PIXEL_DEPTH 4 +#define GLUT_GAME_MODE_REFRESH_RATE 5 +#define GLUT_GAME_MODE_DISPLAY_CHANGED 6 + +extern void APIENTRY glutGameModeString(const char *string); +extern int APIENTRY glutEnterGameMode(void); +extern void APIENTRY glutLeaveGameMode(void); +extern int APIENTRY glutGameModeGet(GLenum mode); +#endif + +#ifdef __cplusplus +} + +#endif + +#ifdef GLUT_APIENTRY_DEFINED +# undef GLUT_APIENTRY_DEFINED +# undef APIENTRY +#endif + +#ifdef GLUT_WINGDIAPI_DEFINED +# undef GLUT_WINGDIAPI_DEFINED +# undef WINGDIAPI +#endif + +#endif /* __glut_h__ */ diff --git a/headtrack_demo/include/glut/GL/tube.h b/headtrack_demo/include/glut/GL/tube.h new file mode 100644 index 0000000..fad9317 --- /dev/null +++ b/headtrack_demo/include/glut/GL/tube.h @@ -0,0 +1,201 @@ +/* + * tube.h + * + * FUNCTION: + * Tubing and Extrusion header file. + * This file provides protypes and defines for the extrusion + * and tubing primitives. + * + * HISTORY: + * Linas Vepstas 1990, 1991 + */ + +#ifndef __TUBE_H__ +#define __TUBE_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + GLE API revision history: + + GLE_API_VERSION is updated to reflect GLE API changes (interface + changes, semantic changes, deletions, or additions). + + GLE_API_VERSION=228 GLUT 3.7 release of GLE. +**/ +#ifndef GLE_API_VERSION /* allow this to be overriden */ +#define GLE_API_VERSION 228 +#endif + +/* some types */ +#define gleDouble double +typedef gleDouble gleAffine[2][3]; + +/* ====================================================== */ + +/* defines for tubing join styles */ +#define TUBE_JN_RAW 0x1 +#define TUBE_JN_ANGLE 0x2 +#define TUBE_JN_CUT 0x3 +#define TUBE_JN_ROUND 0x4 +#define TUBE_JN_MASK 0xf /* mask bits */ +#define TUBE_JN_CAP 0x10 + +/* determine how normal vectors are to be handled */ +#define TUBE_NORM_FACET 0x100 +#define TUBE_NORM_EDGE 0x200 +#define TUBE_NORM_PATH_EDGE 0x400 /* for spiral, lathe, helix primitives */ +#define TUBE_NORM_MASK 0xf00 /* mask bits */ + +/* closed or open countours */ +#define TUBE_CONTOUR_CLOSED 0x1000 + +#define GLE_TEXTURE_ENABLE 0x10000 +#define GLE_TEXTURE_STYLE_MASK 0xff +#define GLE_TEXTURE_VERTEX_FLAT 1 +#define GLE_TEXTURE_NORMAL_FLAT 2 +#define GLE_TEXTURE_VERTEX_CYL 3 +#define GLE_TEXTURE_NORMAL_CYL 4 +#define GLE_TEXTURE_VERTEX_SPH 5 +#define GLE_TEXTURE_NORMAL_SPH 6 +#define GLE_TEXTURE_VERTEX_MODEL_FLAT 7 +#define GLE_TEXTURE_NORMAL_MODEL_FLAT 8 +#define GLE_TEXTURE_VERTEX_MODEL_CYL 9 +#define GLE_TEXTURE_NORMAL_MODEL_CYL 10 +#define GLE_TEXTURE_VERTEX_MODEL_SPH 11 +#define GLE_TEXTURE_NORMAL_MODEL_SPH 12 + +#ifdef GL_32 +/* HACK for GL 3.2 -- needed because no way to tell if lighting is on. */ +#define TUBE_LIGHTING_ON 0x80000000 + +#define gleExtrusion extrusion +#define gleSetJoinStyle setjoinstyle +#define gleGetJoinStyle getjoinstyle +#define glePolyCone polycone +#define glePolyCylinder polycylinder +#define gleSuperExtrusion super_extrusion +#define gleTwistExtrusion twist_extrusion +#define gleSpiral spiral +#define gleLathe lathe +#define gleHelicoid helicoid +#define gleToroid toroid +#define gleScrew screw + +#endif /* GL_32 */ + +extern int gleGetJoinStyle (void); +extern void gleSetJoinStyle (int style); /* bitwise OR of flags */ +extern int gleGetNumSlices(void); +extern void gleSetNumSlices(int slices); + +/* draw polyclinder, specified as a polyline */ +extern void glePolyCylinder (int npoints, /* num points in polyline */ + gleDouble point_array[][3], /* polyline vertces */ + float color_array[][3], /* colors at polyline verts */ + gleDouble radius); /* radius of polycylinder */ + +/* draw polycone, specified as a polyline with radii */ +extern void glePolyCone (int npoints, /* numpoints in poly-line */ + gleDouble point_array[][3], /* polyline vertices */ + float color_array[][3], /* colors at polyline verts */ + gleDouble radius_array[]); /* cone radii at polyline verts */ + +/* extrude arbitrary 2D contour along arbitrary 3D path */ +extern void gleExtrusion (int ncp, /* number of contour points */ + gleDouble contour[][2], /* 2D contour */ + gleDouble cont_normal[][2], /* 2D contour normals */ + gleDouble up[3], /* up vector for contour */ + int npoints, /* numpoints in poly-line */ + gleDouble point_array[][3], /* polyline vertices */ + float color_array[][3]); /* colors at polyline verts */ + +/* extrude 2D contour, specifying local rotations (twists) */ +extern void gleTwistExtrusion (int ncp, /* number of contour points */ + gleDouble contour[][2], /* 2D contour */ + gleDouble cont_normal[][2], /* 2D contour normals */ + gleDouble up[3], /* up vector for contour */ + int npoints, /* numpoints in poly-line */ + gleDouble point_array[][3], /* polyline vertices */ + float color_array[][3], /* color at polyline verts */ + gleDouble twist_array[]); /* countour twists (in degrees) */ + +/* extrude 2D contour, specifying local affine tranformations */ +extern void gleSuperExtrusion (int ncp, /* number of contour points */ + gleDouble contour[][2], /* 2D contour */ + gleDouble cont_normal[][2], /* 2D contour normals */ + gleDouble up[3], /* up vector for contour */ + int npoints, /* numpoints in poly-line */ + gleDouble point_array[][3], /* polyline vertices */ + float color_array[][3], /* color at polyline verts */ + gleDouble xform_array[][2][3]); /* 2D contour xforms */ + +/* spiral moves contour along helical path by parallel transport */ +extern void gleSpiral (int ncp, /* number of contour points */ + gleDouble contour[][2], /* 2D contour */ + gleDouble cont_normal[][2], /* 2D contour normals */ + gleDouble up[3], /* up vector for contour */ + gleDouble startRadius, /* spiral starts in x-y plane */ + gleDouble drdTheta, /* change in radius per revolution */ + gleDouble startZ, /* starting z value */ + gleDouble dzdTheta, /* change in Z per revolution */ + gleDouble startXform[2][3], /* starting contour affine xform */ + gleDouble dXformdTheta[2][3], /* tangent change xform per revoln */ + gleDouble startTheta, /* start angle in x-y plane */ + gleDouble sweepTheta); /* degrees to spiral around */ + +/* lathe moves contour along helical path by helically shearing 3D space */ +extern void gleLathe (int ncp, /* number of contour points */ + gleDouble contour[][2], /* 2D contour */ + gleDouble cont_normal[][2], /* 2D contour normals */ + gleDouble up[3], /* up vector for contour */ + gleDouble startRadius, /* spiral starts in x-y plane */ + gleDouble drdTheta, /* change in radius per revolution */ + gleDouble startZ, /* starting z value */ + gleDouble dzdTheta, /* change in Z per revolution */ + gleDouble startXform[2][3], /* starting contour affine xform */ + gleDouble dXformdTheta[2][3], /* tangent change xform per revoln */ + gleDouble startTheta, /* start angle in x-y plane */ + gleDouble sweepTheta); /* degrees to spiral around */ + +/* similar to spiral, except contour is a circle */ +extern void gleHelicoid (gleDouble rToroid, /* circle contour (torus) radius */ + gleDouble startRadius, /* spiral starts in x-y plane */ + gleDouble drdTheta, /* change in radius per revolution */ + gleDouble startZ, /* starting z value */ + gleDouble dzdTheta, /* change in Z per revolution */ + gleDouble startXform[2][3], /* starting contour affine xform */ + gleDouble dXformdTheta[2][3], /* tangent change xform per revoln */ + gleDouble startTheta, /* start angle in x-y plane */ + gleDouble sweepTheta); /* degrees to spiral around */ + +/* similar to lathe, except contour is a circle */ +extern void gleToroid (gleDouble rToroid, /* circle contour (torus) radius */ + gleDouble startRadius, /* spiral starts in x-y plane */ + gleDouble drdTheta, /* change in radius per revolution */ + gleDouble startZ, /* starting z value */ + gleDouble dzdTheta, /* change in Z per revolution */ + gleDouble startXform[2][3], /* starting contour affine xform */ + gleDouble dXformdTheta[2][3], /* tangent change xform per revoln */ + gleDouble startTheta, /* start angle in x-y plane */ + gleDouble sweepTheta); /* degrees to spiral around */ + +/* draws a screw shape */ +extern void gleScrew (int ncp, /* number of contour points */ + gleDouble contour[][2], /* 2D contour */ + gleDouble cont_normal[][2], /* 2D contour normals */ + gleDouble up[3], /* up vector for contour */ + gleDouble startz, /* start of segment */ + gleDouble endz, /* end of segment */ + gleDouble twist); /* number of rotations */ + +extern void gleTextureMode (int mode); + +#ifdef __cplusplus +} + +#endif +#endif /* __TUBE_H__ */ +/* ================== END OF FILE ======================= */ diff --git a/headtrack_demo/include/wiiuse/wiiuse.h b/headtrack_demo/include/wiiuse/wiiuse.h new file mode 100644 index 0000000..6071635 --- /dev/null +++ b/headtrack_demo/include/wiiuse/wiiuse.h @@ -0,0 +1,632 @@ +/* + * wiiuse + * + * Written By: + * Michael Laforest < para > + * Email: < thepara (--AT--) g m a i l [--DOT--] com > + * + * Copyright 2006-2007 + * + * This file is part of wiiuse. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + * $Header$ + * + */ + +/** + * @file + * + * @brief API header file. + * + * If this file is included from inside the wiiuse source + * and not from a third party program, then wiimote_internal.h + * is also included which extends this file. + */ + +#ifndef WIIUSE_H_INCLUDED +#define WIIUSE_H_INCLUDED + +#ifdef _WIN32 + /* windows */ + #include +#else + /* nix */ + #include +#endif + +#ifdef WIIUSE_INTERNAL_H_INCLUDED + #define WCONST +#else + #define WCONST const +#endif + +/* led bit masks */ +#define WIIMOTE_LED_NONE 0x00 +#define WIIMOTE_LED_1 0x10 +#define WIIMOTE_LED_2 0x20 +#define WIIMOTE_LED_3 0x40 +#define WIIMOTE_LED_4 0x80 + +/* button codes */ +#define WIIMOTE_BUTTON_TWO 0x0001 +#define WIIMOTE_BUTTON_ONE 0x0002 +#define WIIMOTE_BUTTON_B 0x0004 +#define WIIMOTE_BUTTON_A 0x0008 +#define WIIMOTE_BUTTON_MINUS 0x0010 +#define WIIMOTE_BUTTON_ZACCEL_BIT6 0x0020 +#define WIIMOTE_BUTTON_ZACCEL_BIT7 0x0040 +#define WIIMOTE_BUTTON_HOME 0x0080 +#define WIIMOTE_BUTTON_LEFT 0x0100 +#define WIIMOTE_BUTTON_RIGHT 0x0200 +#define WIIMOTE_BUTTON_DOWN 0x0400 +#define WIIMOTE_BUTTON_UP 0x0800 +#define WIIMOTE_BUTTON_PLUS 0x1000 +#define WIIMOTE_BUTTON_ZACCEL_BIT4 0x2000 +#define WIIMOTE_BUTTON_ZACCEL_BIT5 0x4000 +#define WIIMOTE_BUTTON_UNKNOWN 0x8000 +#define WIIMOTE_BUTTON_ALL 0x1F9F + +/* nunchul button codes */ +#define NUNCHUK_BUTTON_Z 0x01 +#define NUNCHUK_BUTTON_C 0x02 +#define NUNCHUK_BUTTON_ALL 0x03 + +/* classic controller button codes */ +#define CLASSIC_CTRL_BUTTON_UP 0x0001 +#define CLASSIC_CTRL_BUTTON_LEFT 0x0002 +#define CLASSIC_CTRL_BUTTON_ZR 0x0004 +#define CLASSIC_CTRL_BUTTON_X 0x0008 +#define CLASSIC_CTRL_BUTTON_A 0x0010 +#define CLASSIC_CTRL_BUTTON_Y 0x0020 +#define CLASSIC_CTRL_BUTTON_B 0x0040 +#define CLASSIC_CTRL_BUTTON_ZL 0x0080 +#define CLASSIC_CTRL_BUTTON_FULL_R 0x0200 +#define CLASSIC_CTRL_BUTTON_PLUS 0x0400 +#define CLASSIC_CTRL_BUTTON_HOME 0x0800 +#define CLASSIC_CTRL_BUTTON_MINUS 0x1000 +#define CLASSIC_CTRL_BUTTON_FULL_L 0x2000 +#define CLASSIC_CTRL_BUTTON_DOWN 0x4000 +#define CLASSIC_CTRL_BUTTON_RIGHT 0x8000 +#define CLASSIC_CTRL_BUTTON_ALL 0xFEFF + +/* guitar hero 3 button codes */ +#define GUITAR_HERO_3_BUTTON_STRUM_UP 0x0001 +#define GUITAR_HERO_3_BUTTON_YELLOW 0x0008 +#define GUITAR_HERO_3_BUTTON_GREEN 0x0010 +#define GUITAR_HERO_3_BUTTON_BLUE 0x0020 +#define GUITAR_HERO_3_BUTTON_RED 0x0040 +#define GUITAR_HERO_3_BUTTON_ORANGE 0x0080 +#define GUITAR_HERO_3_BUTTON_PLUS 0x0400 +#define GUITAR_HERO_3_BUTTON_MINUS 0x1000 +#define GUITAR_HERO_3_BUTTON_STRUM_DOWN 0x4000 +#define GUITAR_HERO_3_BUTTON_ALL 0xFEFF + + +/* wiimote option flags */ +#define WIIUSE_SMOOTHING 0x01 +#define WIIUSE_CONTINUOUS 0x02 +#define WIIUSE_ORIENT_THRESH 0x04 +#define WIIUSE_INIT_FLAGS (WIIUSE_SMOOTHING | WIIUSE_ORIENT_THRESH) + +#define WIIUSE_ORIENT_PRECISION 100.0f + +/* expansion codes */ +#define EXP_NONE 0 +#define EXP_NUNCHUK 1 +#define EXP_CLASSIC 2 +#define EXP_GUITAR_HERO_3 3 + +/* IR correction types */ +typedef enum ir_position_t { + WIIUSE_IR_ABOVE, + WIIUSE_IR_BELOW +} ir_position_t; + +/** + * @brief Check if a button is pressed. + * @param dev Pointer to a wiimote_t or expansion structure. + * @param button The button you are interested in. + * @return 1 if the button is pressed, 0 if not. + */ +#define IS_PRESSED(dev, button) ((dev->btns & button) == button) + +/** + * @brief Check if a button is being held. + * @param dev Pointer to a wiimote_t or expansion structure. + * @param button The button you are interested in. + * @return 1 if the button is held, 0 if not. + */ +#define IS_HELD(dev, button) ((dev->btns_held & button) == button) + +/** + * @brief Check if a button is released on this event. \n\n + * This does not mean the button is not pressed, it means \n + * this button was just now released. + * @param dev Pointer to a wiimote_t or expansion structure. + * @param button The button you are interested in. + * @return 1 if the button is released, 0 if not. + * + */ +#define IS_RELEASED(dev, button) ((dev->btns_released & button) == button) + +/** + * @brief Check if a button has just been pressed this event. + * @param dev Pointer to a wiimote_t or expansion structure. + * @param button The button you are interested in. + * @return 1 if the button is pressed, 0 if not. + */ +#define IS_JUST_PRESSED(dev, button) (IS_PRESSED(dev, button) && !IS_HELD(dev, button)) + +#define WIIUSE_USING_ACC(wm) ((wm->state & 0x020) == 0x020) +#define WIIUSE_USING_EXP(wm) ((wm->state & 0x040) == 0x040) +#define WIIUSE_USING_IR(wm) ((wm->state & 0x080) == 0x080) +#define WIIUSE_USING_SPEAKER(wm) ((wm->state & 0x100) == 0x100) + +#define WIIUSE_IS_LED_SET(wm, num) ((wm->leds & WIIMOTE_LED_##num) == WIIMOTE_LED_##num) + +/* + * Largest known payload is 21 bytes. + * Add 2 for the prefix and round up to a power of 2. + */ +#define MAX_PAYLOAD 32 + +/* + * This is left over from an old hack, but it may actually + * be a useful feature to keep so it wasn't removed. + */ +#ifdef WIN32 + #define WIIMOTE_DEFAULT_TIMEOUT 10 + #define WIIMOTE_EXP_TIMEOUT 10 +#endif + +typedef unsigned char byte; +typedef char sbyte; + +struct wiimote_t; +struct vec3b_t; +struct orient_t; +struct gforce_t; + + +/** + * @brief Callback that handles a read event. + * + * @param wm Pointer to a wiimote_t structure. + * @param data Pointer to the filled data block. + * @param len Length in bytes of the data block. + * + * @see wiiuse_init() + * + * A registered function of this type is called automatically by the wiiuse + * library when the wiimote has returned the full data requested by a previous + * call to wiiuse_read_data(). + */ +typedef void (*wiiuse_read_cb)(struct wiimote_t* wm, byte* data, unsigned short len); + + +/** + * @struct read_req_t + * @brief Data read request structure. + */ +struct read_req_t { + wiiuse_read_cb cb; /**< read data callback */ + byte* buf; /**< buffer where read data is written */ + unsigned int addr; /**< the offset that the read started at */ + unsigned short size; /**< the length of the data read */ + unsigned short wait; /**< num bytes still needed to finish read */ + + struct read_req_t* next; /**< next read request in the queue */ +}; + + +/** + * @struct vec2b_t + * @brief Unsigned x,y byte vector. + */ +typedef struct vec2b_t { + byte x, y; +} vec2b_t; + + +/** + * @struct vec3b_t + * @brief Unsigned x,y,z byte vector. + */ +typedef struct vec3b_t { + byte x, y, z; +} vec3b_t; + + +/** + * @struct vec3f_t + * @brief Signed x,y,z float struct. + */ +typedef struct vec3f_t { + float x, y, z; +} vec3f_t; + + +/** + * @struct orient_t + * @brief Orientation struct. + * + * Yaw, pitch, and roll range from -180 to 180 degrees. + */ +typedef struct orient_t { + float roll; /**< roll, this may be smoothed if enabled */ + float pitch; /**< pitch, this may be smoothed if enabled */ + float yaw; + + float a_roll; /**< absolute roll, unsmoothed */ + float a_pitch; /**< absolute pitch, unsmoothed */ +} orient_t; + + +/** + * @struct gforce_t + * @brief Gravity force struct. + */ +typedef struct gforce_t { + float x, y, z; +} gforce_t; + + +/** + * @struct accel_t + * @brief Accelerometer struct. For any device with an accelerometer. + */ +typedef struct accel_t { + struct vec3b_t cal_zero; /**< zero calibration */ + struct vec3b_t cal_g; /**< 1g difference around 0cal */ + + float st_roll; /**< last smoothed roll value */ + float st_pitch; /**< last smoothed roll pitch */ + float st_alpha; /**< alpha value for smoothing [0-1] */ +} accel_t; + + +/** + * @struct ir_dot_t + * @brief A single IR source. + */ +typedef struct ir_dot_t { + byte visible; /**< if the IR source is visible */ + + unsigned int x; /**< interpolated X coordinate */ + unsigned int y; /**< interpolated Y coordinate */ + + short rx; /**< raw X coordinate (0-1023) */ + short ry; /**< raw Y coordinate (0-767) */ + + byte order; /**< increasing order by x-axis value */ + + byte size; /**< size of the IR dot (0-15) */ +} ir_dot_t; + + +/** + * @enum aspect_t + * @brief Screen aspect ratio. + */ +typedef enum aspect_t { + WIIUSE_ASPECT_4_3, + WIIUSE_ASPECT_16_9 +} aspect_t; + + +/** + * @struct ir_t + * @brief IR struct. Hold all data related to the IR tracking. + */ +typedef struct ir_t { + struct ir_dot_t dot[4]; /**< IR dots */ + byte num_dots; /**< number of dots at this time */ + + enum aspect_t aspect; /**< aspect ratio of the screen */ + + enum ir_position_t pos; /**< IR sensor bar position */ + + unsigned int vres[2]; /**< IR virtual screen resolution */ + int offset[2]; /**< IR XY correction offset */ + int state; /**< keeps track of the IR state */ + + int ax; /**< absolute X coordinate */ + int ay; /**< absolute Y coordinate */ + + int x; /**< calculated X coordinate */ + int y; /**< calculated Y coordinate */ + + float distance; /**< pixel distance between first 2 dots*/ + float z; /**< calculated distance */ +} ir_t; + + +/** + * @struct joystick_t + * @brief Joystick calibration structure. + * + * The angle \a ang is relative to the positive y-axis into quadrant I + * and ranges from 0 to 360 degrees. So if the joystick is held straight + * upwards then angle is 0 degrees. If it is held to the right it is 90, + * down is 180, and left is 270. + * + * The magnitude \a mag is the distance from the center to where the + * joystick is being held. The magnitude ranges from 0 to 1. + * If the joystick is only slightly tilted from the center the magnitude + * will be low, but if it is closer to the outter edge the value will + * be higher. + */ +typedef struct joystick_t { + struct vec2b_t max; /**< maximum joystick values */ + struct vec2b_t min; /**< minimum joystick values */ + struct vec2b_t center; /**< center joystick values */ + + float ang; /**< angle the joystick is being held */ + float mag; /**< magnitude of the joystick (range 0-1) */ +} joystick_t; + + +/** + * @struct nunchuk_t + * @brief Nunchuk expansion device. + */ +typedef struct nunchuk_t { + struct accel_t accel_calib; /**< nunchuk accelerometer calibration */ + struct joystick_t js; /**< joystick calibration */ + + int* flags; /**< options flag (points to wiimote_t.flags) */ + + byte btns; /**< what buttons have just been pressed */ + byte btns_held; /**< what buttons are being held down */ + byte btns_released; /**< what buttons were just released this */ + + float orient_threshold; /**< threshold for orient to generate an event */ + int accel_threshold; /**< threshold for accel to generate an event */ + + struct vec3b_t accel; /**< current raw acceleration data */ + struct orient_t orient; /**< current orientation on each axis */ + struct gforce_t gforce; /**< current gravity forces on each axis */ +} nunchuk_t; + + +/** + * @struct classic_ctrl_t + * @brief Classic controller expansion device. + */ +typedef struct classic_ctrl_t { + short btns; /**< what buttons have just been pressed */ + short btns_held; /**< what buttons are being held down */ + short btns_released; /**< what buttons were just released this */ + + float r_shoulder; /**< right shoulder button (range 0-1) */ + float l_shoulder; /**< left shoulder button (range 0-1) */ + + struct joystick_t ljs; /**< left joystick calibration */ + struct joystick_t rjs; /**< right joystick calibration */ +} classic_ctrl_t; + + +/** + * @struct guitar_hero_3_t + * @brief Guitar Hero 3 expansion device. + */ +typedef struct guitar_hero_3_t { + short btns; /**< what buttons have just been pressed */ + short btns_held; /**< what buttons are being held down */ + short btns_released; /**< what buttons were just released this */ + + float whammy_bar; /**< whammy bar (range 0-1) */ + + struct joystick_t js; /**< joystick calibration */ +} guitar_hero_3_t; + + +/** + * @struct expansion_t + * @brief Generic expansion device plugged into wiimote. + */ +typedef struct expansion_t { + int type; /**< type of expansion attached */ + + union { + struct nunchuk_t nunchuk; + struct classic_ctrl_t classic; + struct guitar_hero_3_t gh3; + }; +} expansion_t; + + +/** + * @enum win32_bt_stack_t + * @brief Available bluetooth stacks for Windows. + */ +typedef enum win_bt_stack_t { + WIIUSE_STACK_UNKNOWN, + WIIUSE_STACK_MS, + WIIUSE_STACK_BLUESOLEIL +} win_bt_stack_t; + + +/** + * @struct wiimote_state_t + * @brief Significant data from the previous event. + */ +typedef struct wiimote_state_t { + /* expansion_t */ + float exp_ljs_ang; + float exp_rjs_ang; + float exp_ljs_mag; + float exp_rjs_mag; + unsigned short exp_btns; + struct orient_t exp_orient; + struct vec3b_t exp_accel; + float exp_r_shoulder; + float exp_l_shoulder; + + /* ir_t */ + int ir_ax; + int ir_ay; + float ir_distance; + + struct orient_t orient; + unsigned short btns; + + struct vec3b_t accel; +} wiimote_state_t; + + +/** + * @enum WIIUSE_EVENT_TYPE + * @brief Events that wiiuse can generate from a poll. + */ +typedef enum WIIUSE_EVENT_TYPE { + WIIUSE_NONE = 0, + WIIUSE_EVENT, + WIIUSE_STATUS, + WIIUSE_DISCONNECT, + WIIUSE_NUNCHUK_INSERTED, + WIIUSE_NUNCHUK_REMOVED, + WIIUSE_CLASSIC_CTRL_INSERTED, + WIIUSE_CLASSIC_CTRL_REMOVED, + WIIUSE_GUITAR_HERO_3_CTRL_INSERTED, + WIIUSE_GUITAR_HERO_3_CTRL_REMOVED +} WIIUSE_EVENT_TYPE; + +/** + * @struct wiimote_t + * @brief Wiimote structure. + */ +typedef struct wiimote_t { + WCONST int unid; /**< user specified id */ + + #ifndef WIN32 + WCONST bdaddr_t bdaddr; /**< bt address */ + WCONST char bdaddr_str[18]; /**< readable bt address */ + WCONST int out_sock; /**< output socket */ + WCONST int in_sock; /**< input socket */ + #else + WCONST HANDLE dev_handle; /**< HID handle */ + WCONST OVERLAPPED hid_overlap; /**< overlap handle */ + WCONST enum win_bt_stack_t stack; /**< type of bluetooth stack to use */ + WCONST int timeout; /**< read timeout */ + WCONST byte normal_timeout; /**< normal timeout */ + WCONST byte exp_timeout; /**< timeout for expansion handshake */ + #endif + + WCONST int state; /**< various state flags */ + WCONST byte leds; /**< currently lit leds */ + WCONST float battery_level; /**< battery level */ + + WCONST int flags; /**< options flag */ + + WCONST byte handshake_state; /**< the state of the connection handshake */ + + WCONST struct read_req_t* read_req; /**< list of data read requests */ + WCONST struct accel_t accel_calib; /**< wiimote accelerometer calibration */ + WCONST struct expansion_t exp; /**< wiimote expansion device */ + + WCONST struct vec3b_t accel; /**< current raw acceleration data */ + WCONST struct orient_t orient; /**< current orientation on each axis */ + WCONST struct gforce_t gforce; /**< current gravity forces on each axis */ + + WCONST struct ir_t ir; /**< IR data */ + + WCONST unsigned short btns; /**< what buttons have just been pressed */ + WCONST unsigned short btns_held; /**< what buttons are being held down */ + WCONST unsigned short btns_released; /**< what buttons were just released this */ + + WCONST float orient_threshold; /**< threshold for orient to generate an event */ + WCONST int accel_threshold; /**< threshold for accel to generate an event */ + + WCONST struct wiimote_state_t lstate; /**< last saved state */ + + WCONST WIIUSE_EVENT_TYPE event; /**< type of event that occured */ + WCONST byte event_buf[MAX_PAYLOAD]; /**< event buffer */ +} wiimote; + + +/***************************************** + * + * Include API specific stuff + * + *****************************************/ + +#ifdef _WIN32 + #define WIIUSE_EXPORT_DECL __declspec(dllexport) + #define WIIUSE_IMPORT_DECL __declspec(dllimport) +#else + #define WIIUSE_EXPORT_DECL + #define WIIUSE_IMPORT_DECL +#endif + +#ifdef WIIUSE_COMPILE_LIB + #define WIIUSE_EXPORT WIIUSE_EXPORT_DECL +#else + #define WIIUSE_EXPORT WIIUSE_IMPORT_DECL +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* wiiuse.c */ +WIIUSE_EXPORT extern const char* wiiuse_version(); + +WIIUSE_EXPORT extern struct wiimote_t** wiiuse_init(int wiimotes); +WIIUSE_EXPORT extern void wiiuse_disconnected(struct wiimote_t* wm); +WIIUSE_EXPORT extern void wiiuse_cleanup(struct wiimote_t** wm, int wiimotes); +WIIUSE_EXPORT extern void wiiuse_rumble(struct wiimote_t* wm, int status); +WIIUSE_EXPORT extern void wiiuse_toggle_rumble(struct wiimote_t* wm); +WIIUSE_EXPORT extern void wiiuse_set_leds(struct wiimote_t* wm, int leds); +WIIUSE_EXPORT extern void wiiuse_motion_sensing(struct wiimote_t* wm, int status); +WIIUSE_EXPORT extern int wiiuse_read_data(struct wiimote_t* wm, wiiuse_read_cb read_cb, byte* buffer, unsigned int offset, unsigned short len); +WIIUSE_EXPORT extern int wiiuse_write_data(struct wiimote_t* wm, unsigned int addr, byte* data, byte len); +WIIUSE_EXPORT extern void wiiuse_status(struct wiimote_t* wm); +WIIUSE_EXPORT extern struct wiimote_t* wiiuse_get_by_id(struct wiimote_t** wm, int wiimotes, int unid); +WIIUSE_EXPORT extern int wiiuse_set_flags(struct wiimote_t* wm, int enable, int disable); +WIIUSE_EXPORT extern float wiiuse_set_smooth_alpha(struct wiimote_t* wm, float alpha); +WIIUSE_EXPORT extern void wiiuse_set_bluetooth_stack(struct wiimote_t** wm, int wiimotes, enum win_bt_stack_t type); +WIIUSE_EXPORT extern void wiiuse_set_orient_threshold(struct wiimote_t* wm, float threshold); +WIIUSE_EXPORT extern void wiiuse_resync(struct wiimote_t* wm); +WIIUSE_EXPORT extern void wiiuse_set_timeout(struct wiimote_t** wm, int wiimotes, byte normal_timeout, byte exp_timeout); +WIIUSE_EXPORT extern void wiiuse_set_accel_threshold(struct wiimote_t* wm, int threshold); + +/* connect.c */ +WIIUSE_EXPORT extern int wiiuse_find(struct wiimote_t** wm, int max_wiimotes, int timeout); +WIIUSE_EXPORT extern int wiiuse_connect(struct wiimote_t** wm, int wiimotes); +WIIUSE_EXPORT extern void wiiuse_disconnect(struct wiimote_t* wm); + +/* events.c */ +WIIUSE_EXPORT extern int wiiuse_poll(struct wiimote_t** wm, int wiimotes); + +/* ir.c */ +WIIUSE_EXPORT extern void wiiuse_set_ir(struct wiimote_t* wm, int status); +WIIUSE_EXPORT extern void wiiuse_set_ir_vres(struct wiimote_t* wm, unsigned int x, unsigned int y); +WIIUSE_EXPORT extern void wiiuse_set_ir_position(struct wiimote_t* wm, enum ir_position_t pos); +WIIUSE_EXPORT extern void wiiuse_set_aspect_ratio(struct wiimote_t* wm, enum aspect_t aspect); + +/* nunchuk.c */ +WIIUSE_EXPORT extern void wiiuse_set_nunchuk_orient_threshold(struct nunchuk_t* nc, float threshold); +WIIUSE_EXPORT extern void wiiuse_set_nunchuk_accel_threshold(struct nunchuk_t* nc, int threshold); + + +#ifdef __cplusplus +} +#endif + + +#endif /* WIIUSE_H_INCLUDED */ + diff --git a/headtrack_demo/lib/win32/glut/glut32.dll b/headtrack_demo/lib/win32/glut/glut32.dll new file mode 100644 index 0000000..3d25e08 Binary files /dev/null and b/headtrack_demo/lib/win32/glut/glut32.dll differ diff --git a/headtrack_demo/lib/win32/glut/glut32.dll.manifest b/headtrack_demo/lib/win32/glut/glut32.dll.manifest new file mode 100644 index 0000000..1b520e1 --- /dev/null +++ b/headtrack_demo/lib/win32/glut/glut32.dll.manifest @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/headtrack_demo/lib/win32/glut/glut32.exp b/headtrack_demo/lib/win32/glut/glut32.exp new file mode 100644 index 0000000..901c0a9 Binary files /dev/null and b/headtrack_demo/lib/win32/glut/glut32.exp differ diff --git a/headtrack_demo/lib/win32/glut/glut32.lib b/headtrack_demo/lib/win32/glut/glut32.lib new file mode 100644 index 0000000..82f7bc1 Binary files /dev/null and b/headtrack_demo/lib/win32/glut/glut32.lib differ diff --git a/headtrack_demo/lib/win32/wiiuse/wiiuse.dll b/headtrack_demo/lib/win32/wiiuse/wiiuse.dll new file mode 100644 index 0000000..6855619 Binary files /dev/null and b/headtrack_demo/lib/win32/wiiuse/wiiuse.dll differ diff --git a/headtrack_demo/lib/win32/wiiuse/wiiuse.lib b/headtrack_demo/lib/win32/wiiuse/wiiuse.lib new file mode 100644 index 0000000..c997396 Binary files /dev/null and b/headtrack_demo/lib/win32/wiiuse/wiiuse.lib differ diff --git a/headtrack_demo/lib/win32/wiiuse/wiiuse_debug.dll b/headtrack_demo/lib/win32/wiiuse/wiiuse_debug.dll new file mode 100644 index 0000000..27036f2 Binary files /dev/null and b/headtrack_demo/lib/win32/wiiuse/wiiuse_debug.dll differ diff --git a/headtrack_demo/src/main.cpp b/headtrack_demo/src/main.cpp new file mode 100644 index 0000000..7cf3558 --- /dev/null +++ b/headtrack_demo/src/main.cpp @@ -0,0 +1,411 @@ +#include +#include +#include +#include + +#define _USE_MATH_DEFINES +#include + +struct HeadTrackWiimotes +{ + wiimote** m_ppWiimotes; + int m_iConnected; +} g_Wiimotes; + +struct HeadTrackParameters +{ + double m_dHeadTrackLedDist; //distance between leds on head in millimeters + double m_dRadPerCameraPixel; //radians per camera pixel + double m_dCameraXCenter; //the coordinates of the center of the camera + double m_dCameraYCenter; // + double m_dYAngleCorrection; //the correction added to the verticle angle measured by the camera (in radians) + double m_dCameraYOffset; //the offset in Y direction of the camera relative to the center of the screen (in mm) + double m_dScreenHeightMM; //the height of the screen (in mm) + double m_dScreenAspect; //the aspect ratio of the screen (width/height) + double m_dScreenHeightWorld; //the height of the screen (in world coordinates) +} g_HeadTrackParms; + +enum EyeOrigin { + STEREO_LEFT_EYE, + STEREO_RIGHT_EYE, + MONO_CENTER +}; + +inline void FindIRDots(const ir_t *f_pIR, const ir_dot_t *f_pDot[2]) +{ + //get the first two visible IR dots + for(int i = 0, n = 0; i < 4 && n < 2; i++) + { + if (f_pIR->dot[i].visible) + { + f_pDot[n] = &f_pIR->dot[i]; + n++; + } + } +} + +inline double CalcHeadDistInMM(const ir_dot_t *f_pDot[2], HeadTrackParameters *f_pHTParms) +{ + double l_dX = f_pDot[0]->rx - f_pDot[1]->rx, //difference in x coordinates + l_dY = f_pDot[0]->ry - f_pDot[1]->ry, //difference in y coordinates + l_dDotDist = sqrt(l_dX*l_dX + l_dY*l_dY), //distance between ir dots (in camera pixels) + l_dDotAngle = f_pHTParms->m_dRadPerCameraPixel * l_dDotDist; //the angle between the lines from the camera through the two ir dots (in radians) + + return (0.5 * f_pHTParms->m_dHeadTrackLedDist) / tan(0.5 * l_dDotAngle); //the distance between the head and camera (in mm) +} + +void SetHeadTrackedFrustum(EyeOrigin f_Eye) +{ + //check if there are any wiimotes connected + if (g_Wiimotes.m_iConnected > 0) + { + //check if we see at least 2 IR dots + if (g_Wiimotes.m_ppWiimotes[0]->ir.num_dots >= 2) + { + const ir_dot_t *l_pDot[2]; //shorthand to the ir dots + FindIRDots(&g_Wiimotes.m_ppWiimotes[0]->ir, l_pDot); + + //calculate the distance of the head (in mm) + double l_dHeadDistInMM = CalcHeadDistInMM(l_pDot, &g_HeadTrackParms); //the distance between the head and camera (in mm) + + double l_dEyeXCam, + l_dEyeYCam; + //determine the eye position in camera coordinates + switch(f_Eye) + { + case STEREO_LEFT_EYE: + case STEREO_RIGHT_EYE: + //determine the lower left point + int i ; + if (l_pDot[0]->rx < l_pDot[1]->rx || (l_pDot[0]->rx == l_pDot[1]->rx && l_pDot[0]->ry < l_pDot[1]->ry)) + //0 is the left eye 1 is the right eye + i = (f_Eye==STEREO_LEFT_EYE? 0: 1); + else + //1 is the left eye 0 is the right eye + i = (f_Eye==STEREO_LEFT_EYE? 1: 0); + l_dEyeXCam = (double)l_pDot[i]->rx; + l_dEyeYCam = (double)l_pDot[i]->ry; + break; + + case MONO_CENTER: + default: + l_dEyeXCam = (double)(l_pDot[0]->rx + l_pDot[1]->rx) / 2.0; + l_dEyeYCam = (double)(l_pDot[0]->ry + l_pDot[1]->ry) / 2.0; + break; + } + + //calculate the x and y angles of the eye relative to the camera + double l_dEyeXAngle = g_HeadTrackParms.m_dRadPerCameraPixel * (l_dEyeXCam - g_HeadTrackParms.m_dCameraXCenter), + l_dEyeYAngle = g_HeadTrackParms.m_dRadPerCameraPixel * (l_dEyeYCam - g_HeadTrackParms.m_dCameraYCenter); + + //correct the y angle + l_dEyeYAngle += g_HeadTrackParms.m_dYAngleCorrection; + + //calculate the the x,y,z coordinates of the eye relative to the screen (in mm), note that we assume that the camera + //is placed above or underneath the center of the screen, so for the x axis we dont correct the position, but for the + //y axis we have to take the y-offset of the camera relative to the center of the screen into account. + double l_dEyeX = sin(l_dEyeXAngle) * l_dHeadDistInMM, + l_dEyeY = sin(l_dEyeYAngle) * l_dHeadDistInMM - g_HeadTrackParms.m_dCameraYOffset, + l_dEyeZ = sqrt(l_dHeadDistInMM*l_dHeadDistInMM - (l_dEyeX*l_dEyeX + l_dEyeY*l_dEyeY)); //pythagoras + + //convert the mm to world coordinates + double l_dMmPerWorldCoord = g_HeadTrackParms.m_dScreenHeightMM / g_HeadTrackParms.m_dScreenHeightWorld; + l_dEyeX /= l_dMmPerWorldCoord; + l_dEyeY /= l_dMmPerWorldCoord; + l_dEyeZ /= l_dMmPerWorldCoord; + + //now set a frustum with the near clipping plane at (-1/2 width, -1/2 height, 0), (-1/2 width, -1/2 height, 0) with the + //eye at position (l_dEyeX, l_dEyeY, l_dEyeZ). But because OpenGL expects the eye at position (0,0,0) when specifying a frustum, + //we have to specify our near clipping plane with (-l_dEyeX, -l_dEyeY, -l_dEyeZ) as its origin and translate the modelview + //matrix to (-l_dEyeX, -l_dEyeY, -l_dEyeZ), such that the world origin is in the center of the screen + double l_dHalfHeight = 0.5 * g_HeadTrackParms.m_dScreenHeightWorld, + l_dHalfWidth = l_dHalfHeight * g_HeadTrackParms.m_dScreenAspect; + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + GLdouble l_dZNear = 1.0, + l_dFactor = l_dZNear/l_dEyeZ, + l_dLeft = (-l_dEyeX - l_dHalfWidth) * l_dFactor, + l_dRight = (-l_dEyeX + l_dHalfWidth) * l_dFactor, + l_dBottom = (-l_dEyeY - l_dHalfHeight) * l_dFactor, + l_dTop = (-l_dEyeY + l_dHalfHeight) * l_dFactor; + + glFrustum( l_dLeft, l_dRight, l_dBottom, l_dTop, l_dZNear, l_dEyeZ + 100.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslated(-l_dEyeX, -l_dEyeY, -l_dEyeZ); + } + } +} + +void DrawRasterBox() +{ + double l_dHalfHeight = 0.5 * g_HeadTrackParms.m_dScreenHeightWorld, + l_dHalfWidth = l_dHalfHeight * g_HeadTrackParms.m_dScreenAspect, + l_dDH = g_HeadTrackParms.m_dScreenHeightWorld/20.0, + l_dDW = l_dDH * g_HeadTrackParms.m_dScreenAspect, + l_dBoxDepth = g_HeadTrackParms.m_dScreenHeightWorld, + l_dVariable; + + for (int i = 0; i <= 20; i++) + { + l_dVariable = -l_dHalfHeight + (double)i * l_dDH; + //draw U on xz + glBegin(GL_LINE_STRIP); + glColor3d(0.0, 0.0, 1.0); + glVertex3d(-l_dHalfWidth, l_dVariable, 0.0); + glVertex3d(-l_dHalfWidth, l_dVariable, -l_dBoxDepth); + glVertex3d(l_dHalfWidth, l_dVariable, -l_dBoxDepth); + glVertex3d(l_dHalfWidth, l_dVariable, 0.0); + glEnd(); + + //draw U on yz + l_dVariable = -l_dHalfWidth + (double)i * l_dDW; + glBegin(GL_LINE_STRIP); + glVertex3d(l_dVariable, -l_dHalfHeight, 0.0); + glVertex3d(l_dVariable, -l_dHalfHeight, -l_dBoxDepth); + glVertex3d(l_dVariable, l_dHalfHeight, -l_dBoxDepth); + glVertex3d(l_dVariable, l_dHalfHeight, 0.0); + glEnd(); + + //draw square on xy + l_dVariable = (double)i * -l_dDH; + glBegin(GL_LINE_LOOP); + glVertex3d(-l_dHalfWidth, -l_dHalfHeight, l_dVariable); + glVertex3d(l_dHalfWidth, -l_dHalfHeight, l_dVariable); + glVertex3d(l_dHalfWidth, l_dHalfHeight, l_dVariable); + glVertex3d(-l_dHalfWidth, l_dHalfHeight, l_dVariable); + glEnd(); + } +} + +void Display(void) +{ + //set perspective correction according to the head position + SetHeadTrackedFrustum(MONO_CENTER); + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + DrawRasterBox(); + + glPushMatrix(); + glColor3d(1.0, 0.0, 0.0); + glTranslated(-5.0, 5.0, -15.0); + glutSolidCube(5.0); + glColor3d(0.0, 1.0, 0.0); + glTranslated(10.0, 0.0, 0.0); + glutSolidCube(5.0); + glColor3d(0.0, 0.0, 1.0); + glTranslated(0.0, -10.0, 0.0); + glutSolidCube(5.0); + glColor3d(1.0, 1.0, 0.0); + glTranslated(-10.0, 0.0, 0.0); + glutSolidCube(5.0); + glPopMatrix(); + + glPushMatrix(); + glColor3d(1.0, 1.0, 0.0); + glTranslated(-5.0, 5.0, -5.0); + glutSolidCube(5.0); + glColor3d(0.0, 0.0, 1.0); + glTranslated(10.0, 0.0, 0.0); + glutSolidCube(5.0); + glColor3d(0.0, 1.0, 0.0); + glTranslated(0.0, -10.0, 0.0); + glutSolidCube(5.0); + glColor3d(1.0, 0.0, 0.0); + glTranslated(-10.0, 0.0, 0.0); + glutSolidCube(5.0); + glPopMatrix(); + + glColor3d(1.0, 0.0, 1.0); + + /*glPushMatrix(); + glTranslated(0.0, 0.0, -10.0); + glutSolidSphere(5.0, 8, 16); + glPopMatrix();*/ + + glPushMatrix(); + glTranslated(0.0, 0.0, 5.0); + glScaled(1.0, 1.0, 10.0); + glutSolidCube(2.0); + glPopMatrix(); + + + /*glPushAttrib(GL_LIGHTING_BIT | GL_DEPTH_BUFFER_BIT); + glDisable(GL_LIGHTING); + glDisable(GL_DEPTH_TEST);*/ + /*glColor3d(1.0, 0.0, 0.0); + glRasterPos2i(0, 9); + char l_String[] = "TEST!!\0"; + for (int i=0; i<6; i++) + glutBitmapCharacter( GLUT_BITMAP_HELVETICA_18, l_String[i]);*/ + //glPopAttrib(); + + glutSwapBuffers(); + +} + +void PollWiiMotes() +{ + //wiimotes report back to the host with a frequency of 100 herz + if (wiiuse_poll(g_Wiimotes.m_ppWiimotes, 1)) + { + for (int i=0; i < g_Wiimotes.m_iConnected; i++) + { + switch (g_Wiimotes.m_ppWiimotes[i]->event) + { + //default: + //nothing?? + } + } + } +} + +void Idle(void) +{ + PollWiiMotes(); + glutPostRedisplay(); +} + +void Reshape(int f_iWidth, int f_iHeight) +{ + //set the new viewport dimension + glViewport(0, 0, f_iWidth, f_iHeight); + + //should we set a new projection matrix? + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + + double l_dHalfHeight = 0.5 * g_HeadTrackParms.m_dScreenHeightWorld, + l_dHalfWidth = l_dHalfHeight * g_HeadTrackParms.m_dScreenAspect, + l_zNear = 2.0 * g_HeadTrackParms.m_dScreenHeightWorld; + + glFrustum(-l_dHalfWidth, l_dHalfWidth, -l_dHalfHeight, l_dHalfHeight, l_zNear, l_zNear + 1000.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslated(0.0, 0.0, -l_zNear); +} + + +void ExitProgram() +{ + //disconnect wiimotes + for (int i=0; i 0) + { + if (g_Wiimotes.m_ppWiimotes[0]->ir.num_dots >= 2) + { + const ir_dot_t *l_pDot[2]; //shorthand to the ir dots + FindIRDots(&g_Wiimotes.m_ppWiimotes[0]->ir, l_pDot); + + //calculate the distance of the head (in mm) + double l_dHeadDistInMM = CalcHeadDistInMM(l_pDot, &g_HeadTrackParms), //the distance between the head and camera (in mm) + l_dEyeYCam = (double)(l_pDot[0]->ry + l_pDot[1]->ry) / 2.0; + + // of the eye relative to the camera + g_HeadTrackParms.m_dYAngleCorrection = g_HeadTrackParms.m_dRadPerCameraPixel * (l_dEyeYCam - g_HeadTrackParms.m_dCameraYCenter); + } + } + break; + } +} + +int main(int argc, char **argv) +{ + //init GLUT + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); + glutCreateWindow("HeadTrackDemo"); + + //init OpenGL + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_DEPTH_TEST); + glEnable(GL_COLOR_MATERIAL); + glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); + glClearColor(1.0, 1.0, 1.0, 1.0); + + ////initialise the parameters needed for perspective correction when head tracking + //g_HeadTrackParms.m_dHeadTrackLedDist = 205.0; + //g_HeadTrackParms.m_dRadPerCameraPixel = (41.0*(M_PI/180.0))/1024.0; + //g_HeadTrackParms.m_dCameraXCenter = 1024.0/2.0; + //g_HeadTrackParms.m_dCameraYCenter = 768.0/2.0; + //g_HeadTrackParms.m_dYAngleCorrection = 0.0; //to be initialised correctly + //g_HeadTrackParms.m_dCameraYOffset = 130.0; + //g_HeadTrackParms.m_dScreenHeightMM = 210.0; + //g_HeadTrackParms.m_dScreenAspect = 4.0/3.0; + //g_HeadTrackParms.m_dScreenHeightWorld = 20.0; + + + //initialise the parameters needed for perspective correction when head tracking + g_HeadTrackParms.m_dHeadTrackLedDist = 205.0; + g_HeadTrackParms.m_dRadPerCameraPixel = (41.0*(M_PI/180.0))/1024.0; + g_HeadTrackParms.m_dCameraXCenter = 1024.0/2.0; + g_HeadTrackParms.m_dCameraYCenter = 768.0/2.0; + g_HeadTrackParms.m_dYAngleCorrection = 0.0; //to be initialised correctly + g_HeadTrackParms.m_dCameraYOffset = 205.0; + g_HeadTrackParms.m_dScreenHeightMM = 320.0; + g_HeadTrackParms.m_dScreenAspect = 16.0/10.0; + g_HeadTrackParms.m_dScreenHeightWorld = 20.0; + + //connect to the wiimote(s) + g_Wiimotes.m_ppWiimotes = wiiuse_init(1); + +#ifdef WIN32 + wiiuse_set_bluetooth_stack(g_Wiimotes.m_ppWiimotes, 1, WIIUSE_STACK_MS); +#endif //WIN32 + + int found = wiiuse_find(g_Wiimotes.m_ppWiimotes, 1, 30); + g_Wiimotes.m_iConnected = wiiuse_connect(g_Wiimotes.m_ppWiimotes , 1); + if (g_Wiimotes.m_iConnected) + { + printf("Connected to %i wiimotes (of %i found).\n", g_Wiimotes.m_iConnected, found); + + wiiuse_set_leds(g_Wiimotes.m_ppWiimotes[0], WIIMOTE_LED_1 | WIIMOTE_LED_2 | WIIMOTE_LED_3 | WIIMOTE_LED_4); + wiiuse_rumble(g_Wiimotes.m_ppWiimotes[0], 1); + //wiiuse_motion_sensing(g_Wiimotes.m_ppWiimotes[0], 1); + wiiuse_set_ir(g_Wiimotes.m_ppWiimotes[0], 1); + Sleep(200); + wiiuse_rumble(g_Wiimotes.m_ppWiimotes[0], 0); + } + else + { + printf("Failed to connect to any wiimote.\n"); + return 0; + } + + //register GLUT callback routines + glutDisplayFunc(Display); + glutIdleFunc(Idle); + glutReshapeFunc(Reshape); + glutKeyboardFunc(Keyboard); + + glutFullScreen(); + + glutMainLoop(); + + return 0; +} -- cgit v0.12