[Scummvm-git-logs] scummvm master -> 3258545086258da93a9a2839f7b7929683c78acd
aquadran
noreply at scummvm.org
Sun Feb 19 11:24:48 UTC 2023
This automated email contains information about 1 new commit which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .
Summary:
3258545086 TINYGL: Update GL header to version 1.2
Commit: 3258545086258da93a9a2839f7b7929683c78acd
https://github.com/scummvm/scummvm/commit/3258545086258da93a9a2839f7b7929683c78acd
Author: Paweł Kołodziejski (aquadran at gmail.com)
Date: 2023-02-19T12:24:39+01:00
Commit Message:
TINYGL: Update GL header to version 1.2
Changed paths:
graphics/tinygl/gl.h
diff --git a/graphics/tinygl/gl.h b/graphics/tinygl/gl.h
index c204f0e9508..c1791558c1a 100644
--- a/graphics/tinygl/gl.h
+++ b/graphics/tinygl/gl.h
@@ -31,11 +31,10 @@
#define GRAPHICS_TGL_H
#define TGL_VERSION_1_1 1
+#define TGL_VERSION_1_2 1
enum {
- // Boolean values
- TGL_FALSE = 0,
- TGL_TRUE = 1,
+ // --- GL 1.0 ---
// Data types
TGL_BYTE = 0x1400,
@@ -45,7 +44,6 @@ enum {
TGL_INT = 0x1404,
TGL_UNSIGNED_INT = 0x1405,
TGL_FLOAT = 0x1406,
- TGL_DOUBLE = 0x140A,
TGL_2_BYTES = 0x1407,
TGL_3_BYTES = 0x1408,
TGL_4_BYTES = 0x1409,
@@ -63,54 +61,6 @@ enum {
TGL_POLYGON = 0x0009,
TGL_EDGE_FLAG = 0x0B43,
- // Vertex Arrays
- TGL_VERTEX_ARRAY = 0x8074,
- TGL_NORMAL_ARRAY = 0x8075,
- TGL_COLOR_ARRAY = 0x8076,
- TGL_INDEX_ARRAY = 0x8077,
- TGL_TEXTURE_COORD_ARRAY = 0x8078,
- TGL_EDGE_FLAG_ARRAY = 0x8079,
- TGL_VERTEX_ARRAY_SIZE = 0x807A,
- TGL_VERTEX_ARRAY_TYPE = 0x807B,
- TGL_VERTEX_ARRAY_STRIDE = 0x807C,
- TGL_VERTEX_ARRAY_COUNT = 0x807D,
- TGL_NORMAL_ARRAY_TYPE = 0x807E,
- TGL_NORMAL_ARRAY_STRIDE = 0x807F,
- TGL_NORMAL_ARRAY_COUNT = 0x8080,
- TGL_COLOR_ARRAY_SIZE = 0x8081,
- TGL_COLOR_ARRAY_TYPE = 0x8082,
- TGL_COLOR_ARRAY_STRIDE = 0x8083,
- TGL_COLOR_ARRAY_COUNT = 0x8084,
- TGL_INDEX_ARRAY_TYPE = 0x8085,
- TGL_INDEX_ARRAY_STRIDE = 0x8086,
- TGL_INDEX_ARRAY_COUNT = 0x8087,
- TGL_TEXTURE_COORD_ARRAY_SIZE = 0x8088,
- TGL_TEXTURE_COORD_ARRAY_TYPE = 0x8089,
- TGL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A,
- TGL_TEXTURE_COORD_ARRAY_COUNT = 0x808B,
- TGL_EDGE_FLAG_ARRAY_STRIDE = 0x808C,
- TGL_EDGE_FLAG_ARRAY_COUNT = 0x808D,
- TGL_VERTEX_ARRAY_POINTER = 0x808E,
- TGL_NORMAL_ARRAY_POINTER = 0x808F,
- TGL_COLOR_ARRAY_POINTER = 0x8090,
- TGL_INDEX_ARRAY_POINTER = 0x8091,
- TGL_TEXTURE_COORD_ARRAY_POINTER = 0x8092,
- TGL_EDGE_FLAG_ARRAY_POINTER = 0x8093,
- TGL_V2F = 0x2A20,
- TGL_V3F = 0x2A21,
- TGL_C4UB_V2F = 0x2A22,
- TGL_C4UB_V3F = 0x2A23,
- TGL_C3F_V3F = 0x2A24,
- TGL_N3F_V3F = 0x2A25,
- TGL_C4F_N3F_V3F = 0x2A26,
- TGL_T2F_V3F = 0x2A27,
- TGL_T4F_V4F = 0x2A28,
- TGL_T2F_C4UB_V3F = 0x2A29,
- TGL_T2F_C3F_V3F = 0x2A2A,
- TGL_T2F_N3F_V3F = 0x2A2B,
- TGL_T2F_C4F_N3F_V3F = 0x2A2C,
- TGL_T4F_C4F_N3F_V4F = 0x2A2D,
-
// Matrix Mode
TGL_MATRIX_MODE = 0x0BA0,
TGL_MODELVIEW = 0x1700,
@@ -146,13 +96,6 @@ enum {
TGL_POLYGON_STIPPLE = 0x0B42,
TGL_FRONT_FACE = 0x0B46,
TGL_POLYGON_MODE = 0x0B40,
- TGL_POLYGON_OFFSET_FACTOR = 0x3038,
- TGL_POLYGON_OFFSET_UNITS = 0x2A00,
- TGL_POLYGON_OFFSET_POINT = 0x2A01,
- TGL_POLYGON_OFFSET_LINE = 0x2A02,
- TGL_POLYGON_OFFSET_FILL = 0x8037,
- TGL_SHADOW_MASK_MODE = 0x0C40,
- TGL_SHADOW_MODE = 0x0C41,
// Display Lists
TGL_COMPILE = 0x1300,
@@ -243,8 +186,8 @@ enum {
TGL_BLEND = 0x0BE2,
TGL_BLEND_SRC = 0x0BE1,
TGL_BLEND_DST = 0x0BE0,
- TGL_ZERO = 0,
- TGL_ONE = 1,
+ //TGL_ZERO = 0,
+ //TGL_ONE = 1,
TGL_SRC_COLOR = 0x0300,
TGL_ONE_MINUS_SRC_COLOR = 0x0301,
TGL_DST_COLOR = 0x0306,
@@ -254,10 +197,6 @@ enum {
TGL_DST_ALPHA = 0x0304,
TGL_ONE_MINUS_DST_ALPHA = 0x0305,
TGL_SRC_ALPHA_SATURATE = 0x0308,
- TGL_CONSTANT_COLOR = 0x8001,
- TGL_ONE_MINUS_CONSTANT_COLOR = 0x8002,
- TGL_CONSTANT_ALPHA = 0x8003,
- TGL_ONE_MINUS_CONSTANT_ALPHA = 0x8004,
// Render Mode
TGL_FEEDBACK = 0x1C01,
@@ -327,11 +266,9 @@ enum {
TGL_REPLACE = 0x1E01,
TGL_INCR = 0x1E02,
TGL_DECR = 0x1E03,
- TGL_INCR_WRAP = 0x8507,
- TGL_DECR_WRAP = 0x8508,
- // Buffers, Pixel Drawing/Reading
- TGL_NONE = 0,
+ // Buffers, Pixel Drawing / Reading
+ //TGL_NONE = 0,
TGL_LEFT = 0x0406,
TGL_RIGHT = 0x0407,
//TGL_FRONT = 0x0404,
@@ -384,7 +321,6 @@ enum {
TGL_MAX_TEXTURE_SIZE = 0x0D33,
TGL_MAX_PIXEL_MAP_TABLE = 0x0D34,
TGL_MAX_VIEWPORT_DIMS = 0x0D3A,
- TGL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B,
// Gets
TGL_ATTRIB_STACK_DEPTH = 0x0BB0,
@@ -538,8 +474,6 @@ enum {
TGL_NEAREST = 0x2600,
TGL_REPEAT = 0x2901,
TGL_CLAMP = 0x2900,
- TGL_CLAMP_TO_EDGE = 0x812F,
- TGL_MIRRORED_REPEAT = 0x8370,
TGL_S = 0x2000,
TGL_T = 0x2001,
TGL_R = 0x2002,
@@ -547,12 +481,91 @@ enum {
TGL_TEXTURE_GEN_R = 0x0C62,
TGL_TEXTURE_GEN_Q = 0x0C63,
+ // Utility
+ TGL_VENDOR = 0x1F00,
+ TGL_RENDERER = 0x1F01,
+ TGL_VERSION = 0x1F02,
+ TGL_EXTENSIONS = 0x1F03,
+
+
+ // --- GL 1.1 ---
+
+ // Gets
+ TGL_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1,
+ TGL_INDEX_LOGIC_OP = 0x0BF1,
+ TGL_COLOR_LOGIC_OP = 0x0BF2,
+
+ // Texture mapping
TGL_PROXY_TEXTURE_1D = 0x8063,
TGL_PROXY_TEXTURE_2D = 0x8064,
TGL_TEXTURE_PRIORITY = 0x8066,
TGL_TEXTURE_RESIDENT = 0x8067,
- TGL_TEXTURE_1D_BINDING = 0x8068,
- TGL_TEXTURE_2D_BINDING = 0x8069,
+ TGL_TEXTURE_BINDING_1D = 0x8068,
+ TGL_TEXTURE_BINDING_2D = 0x8069,
+ TGL_TEXTURE_INTERNAL_FORMAT = 0x1003,
+ TGL_TEXTURE_RED_SIZE = 0x805C,
+ TGL_TEXTURE_GREEN_SIZE = 0x805D,
+ TGL_TEXTURE_BLUE_SIZE = 0x805E,
+ TGL_TEXTURE_ALPHA_SIZE = 0x805F,
+ TGL_TEXTURE_LUMINANCE_SIZE = 0x8060,
+ TGL_TEXTURE_INTENSITY_SIZE = 0x8061,
+
+ // Data types
+ TGL_DOUBLE = 0x140A,
+
+ // Polygons
+ TGL_POLYGON_OFFSET_FACTOR = 0x3038,
+ TGL_POLYGON_OFFSET_UNITS = 0x2A00,
+ TGL_POLYGON_OFFSET_POINT = 0x2A01,
+ TGL_POLYGON_OFFSET_LINE = 0x2A02,
+ TGL_POLYGON_OFFSET_FILL = 0x8037,
+
+ // Vertex Arrays
+ TGL_VERTEX_ARRAY = 0x8074,
+ TGL_NORMAL_ARRAY = 0x8075,
+ TGL_COLOR_ARRAY = 0x8076,
+ TGL_INDEX_ARRAY = 0x8077,
+ TGL_TEXTURE_COORD_ARRAY = 0x8078,
+ TGL_EDGE_FLAG_ARRAY = 0x8079,
+ TGL_VERTEX_ARRAY_SIZE = 0x807A,
+ TGL_VERTEX_ARRAY_TYPE = 0x807B,
+ TGL_VERTEX_ARRAY_STRIDE = 0x807C,
+ TGL_NORMAL_ARRAY_TYPE = 0x807E,
+ TGL_NORMAL_ARRAY_STRIDE = 0x807F,
+ TGL_COLOR_ARRAY_SIZE = 0x8081,
+ TGL_COLOR_ARRAY_TYPE = 0x8082,
+ TGL_COLOR_ARRAY_STRIDE = 0x8083,
+ TGL_INDEX_ARRAY_TYPE = 0x8085,
+ TGL_INDEX_ARRAY_STRIDE = 0x8086,
+ TGL_TEXTURE_COORD_ARRAY_SIZE = 0x8088,
+ TGL_TEXTURE_COORD_ARRAY_TYPE = 0x8089,
+ TGL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A,
+ TGL_EDGE_FLAG_ARRAY_STRIDE = 0x808C,
+ TGL_VERTEX_ARRAY_POINTER = 0x808E,
+ TGL_NORMAL_ARRAY_POINTER = 0x808F,
+ TGL_COLOR_ARRAY_POINTER = 0x8090,
+ TGL_INDEX_ARRAY_POINTER = 0x8091,
+ TGL_TEXTURE_COORD_ARRAY_POINTER = 0x8092,
+ TGL_EDGE_FLAG_ARRAY_POINTER = 0x8093,
+ TGL_FEEDBACK_BUFFER_POINTER = 0x0DF0,
+ TGL_FEEDBACK_BUFFER_SIZE = 0x0DF1,
+ TGL_FEEDBACK_BUFFER_TYPE = 0x0DF2,
+ TGL_SELECTION_BUFFER_POINTER = 0x0DF3,
+ TGL_SELECTION_BUFFER_SIZE = 0x0DF4,
+ TGL_V2F = 0x2A20,
+ TGL_V3F = 0x2A21,
+ TGL_C4UB_V2F = 0x2A22,
+ TGL_C4UB_V3F = 0x2A23,
+ TGL_C3F_V3F = 0x2A24,
+ TGL_N3F_V3F = 0x2A25,
+ TGL_C4F_N3F_V3F = 0x2A26,
+ TGL_T2F_V3F = 0x2A27,
+ TGL_T4F_V4F = 0x2A28,
+ TGL_T2F_C4UB_V3F = 0x2A29,
+ TGL_T2F_C3F_V3F = 0x2A2A,
+ TGL_T2F_N3F_V3F = 0x2A2B,
+ TGL_T2F_C4F_N3F_V3F = 0x2A2C,
+ TGL_T4F_C4F_N3F_V4F = 0x2A2D,
// Internal texture formats
TGL_ALPHA4 = 0x803B,
@@ -588,6 +601,41 @@ enum {
TGL_RGB10_A2 = 0x8059,
TGL_RGBA12 = 0x805A,
TGL_RGBA16 = 0x805B,
+
+ // Implementation limits
+ TGL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B,
+
+
+ // --- GL 1.2 ---
+
+ // Texture mapping
+ TGL_TEXTURE_BINDING_3D = 0x806A,
+ TGL_TEXTURE_3D = 0x806F,
+ TGL_PROXY_TEXTURE_3D = 0x8070,
+ TGL_TEXTURE_DEPTH = 0x8071,
+ TGL_TEXTURE_WRAP_R = 0x8072,
+ TGL_CLAMP_TO_EDGE = 0x812F,
+ TGL_TEXTURE_MIN_LOD = 0x813A,
+ TGL_TEXTURE_MAX_LOD = 0x813B,
+ TGL_TEXTURE_BASE_LEVEL = 0x813C,
+ TGL_TEXTURE_MAX_LEVEL = 0x813D,
+
+ // Pixel Mode / Transfer
+ TGL_PACK_SKIP_IMAGES = 0x806B,
+ TGL_PACK_IMAGE_HEIGHT = 0x806C,
+ TGL_UNPACK_SKIP_IMAGES = 0x806D,
+ TGL_UNPACK_IMAGE_HEIGHT = 0x806E,
+
+ // Implementation limits
+ TGL_MAX_3D_TEXTURE_SIZE = 0x8073,
+ TGL_MAX_ELEMENTS_VERTICES = 0x80E8,
+ TGL_MAX_ELEMENTS_INDICES = 0x80E9,
+
+ // Internal texture formats
+ TGL_UNSIGNED_BYTE_3_3_2 = 0x8032,
+ TGL_UNSIGNED_BYTE_2_3_3_REV = 0x8362,
+ TGL_UNSIGNED_INT_10_10_10_2 = 0x8036,
+ TGL_UNSIGNED_INT_2_10_10_10_REV = 0x8368,
TGL_UNSIGNED_SHORT_5_6_5 = 0x8363,
TGL_UNSIGNED_SHORT_5_6_5_REV = 0x8364,
TGL_UNSIGNED_INT_8_8_8_8 = 0x8035,
@@ -596,81 +644,45 @@ enum {
TGL_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366,
TGL_UNSIGNED_SHORT_4_4_4_4 = 0x8033,
TGL_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365,
+ TGL_BGR = 0x80E0,
+ TGL_BGRA = 0x80E1,
- // Utility
- TGL_VENDOR = 0x1F00,
- TGL_RENDERER = 0x1F01,
- TGL_VERSION = 0x1F02,
- TGL_EXTENSIONS = 0x1F03,
+ // Gets
+ TGL_SMOOTH_POINT_SIZE_RANGE = 0x0B12,
+ TGL_SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13,
+ TGL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22,
+ TGL_SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23,
+ TGL_ALIASED_LINE_WIDTH_RANGE = 0x846E,
+ TGL_RESCALE_NORMAL = 0x803A,
+ TGL_LIGHT_MODEL_COLOR_CONTROL = 0x81F8,
+ TGL_SINGLE_COLOR = 0x81F9,
+ TGL_SEPARATE_SPECULAR_COLOR = 0x81FA,
+ TGL_ALIASED_POINT_SIZE_RANGE = 0x846D,
+
+
+ // --- GL 1.4 --- selected
+
+ // Texture mapping
+ TGL_MIRRORED_REPEAT = 0x8370,
+
+ // Stencil
+ TGL_INCR_WRAP = 0x8507,
+ TGL_DECR_WRAP = 0x8508,
+};
+enum {
// Errors
+ TGL_NO_ERROR = 0,
TGL_INVALID_VALUE = 0x0501,
TGL_INVALID_ENUM = 0x0500,
TGL_INVALID_OPERATION = 0x0502,
TGL_STACK_OVERFLOW = 0x0503,
TGL_STACK_UNDERFLOW = 0x0504,
TGL_OUT_OF_MEMORY = 0x0505,
-
- // 1.0 Extensions
-
- // TGL_EXT_blend_minmax and TGL_EXT_blend_color
- TGL_CONSTANT_COLOR_EXT = 0x8001,
- TGL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002,
- TGL_CONSTANT_ALPHA_EXT = 0x8003,
- TGL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004,
- TGL_BLEND_EQUATION_EXT = 0x8009,
- TGL_MIN_EXT = 0x8007,
- TGL_MAX_EXT = 0x8008,
- TGL_FUNC_ADD_EXT = 0x8006,
- TGL_FUNC_SUBTRACT_EXT = 0x800A,
- TGL_FUNC_REVERSE_SUBTRACT_EXT = 0x800B,
- TGL_BLEND_COLOR_EXT = 0x8005,
-
- // TGL_EXT_polygon_offset
- TGL_POLYGON_OFFSET_EXT = 0x8037,
- TGL_POLYGON_OFFSET_FACTOR_EXT = 0x8038,
- TGL_POLYGON_OFFSET_BIAS_EXT = 0x8039,
-
- // TGL_EXT_vertex_array
- TGL_VERTEX_ARRAY_EXT = 0x8074,
- TGL_NORMAL_ARRAY_EXT = 0x8075,
- TGL_COLOR_ARRAY_EXT = 0x8076,
- TGL_INDEX_ARRAY_EXT = 0x8077,
- TGL_TEXTURE_COORD_ARRAY_EXT = 0x8078,
- TGL_EDGE_FLAG_ARRAY_EXT = 0x8079,
- TGL_VERTEX_ARRAY_SIZE_EXT = 0x807A,
- TGL_VERTEX_ARRAY_TYPE_EXT = 0x807B,
- TGL_VERTEX_ARRAY_STRIDE_EXT = 0x807C,
- TGL_VERTEX_ARRAY_COUNT_EXT = 0x807D,
- TGL_NORMAL_ARRAY_TYPE_EXT = 0x807E,
- TGL_NORMAL_ARRAY_STRIDE_EXT = 0x807F,
- TGL_NORMAL_ARRAY_COUNT_EXT = 0x8080,
- TGL_COLOR_ARRAY_SIZE_EXT = 0x8081,
- TGL_COLOR_ARRAY_TYPE_EXT = 0x8082,
- TGL_COLOR_ARRAY_STRIDE_EXT = 0x8083,
- TGL_COLOR_ARRAY_COUNT_EXT = 0x8084,
- TGL_INDEX_ARRAY_TYPE_EXT = 0x8085,
- TGL_INDEX_ARRAY_STRIDE_EXT = 0x8086,
- TGL_INDEX_ARRAY_COUNT_EXT = 0x8087,
- TGL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088,
- TGL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089,
- TGL_TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A,
- TGL_TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B,
- TGL_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C,
- TGL_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D,
- TGL_VERTEX_ARRAY_POINTER_EXT = 0x808E,
- TGL_NORMAL_ARRAY_POINTER_EXT = 0x808F,
- TGL_COLOR_ARRAY_POINTER_EXT = 0x8090,
- TGL_INDEX_ARRAY_POINTER_EXT = 0x8091,
- TGL_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092,
- TGL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093,
-
- // Color-types from 1.2, from SDL_opengl.h
- TGL_BGR = 0x80E0,
- TGL_BGRA = 0x80E1
};
enum {
+ // Attrib Mask
TGL_CURRENT_BIT = 0x00000001,
TGL_POINT_BIT = 0x00000002,
TGL_LINE_BIT = 0x00000004,
@@ -694,7 +706,23 @@ enum {
TGL_ALL_ATTRIB_BITS = 0x000fffff
};
-// some types
+enum {
+ // Client Attrib Mask
+ TGL_CLIENT_PIXEL_STORE_BIT = 1,
+ TGL_CLIENT_VERTEX_ARRAY_BIT = 2,
+ TGL_CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF,
+};
+
+enum {
+ // Special numbers
+ TGL_FALSE = 0,
+ TGL_TRUE = 1,
+ TGL_NONE = 0,
+ TGL_ZERO = 0,
+ TGL_ONE = 1,
+};
+
+// basic types
typedef int TGLenum;
typedef void TGLvoid;
@@ -716,67 +744,128 @@ typedef double TGLclampd;
void tglEnable(TGLenum code);
void tglDisable(TGLenum code);
+TGLboolean tglIsEnabled(TGLenum cap);
void tglShadeModel(TGLenum mode);
void tglCullFace(TGLenum mode);
void tglPolygonMode(TGLenum face, TGLenum mode);
-void tglBegin(TGLenum type);
-void tglEnd();
+void tglLineStipple(TGLint factor, TGLushort pattern);
+void tglPolygonStipple(const TGLubyte *mask);
+void tglGetPolygonStipple(TGLubyte *mask);
-#define PROTO_GL1(name) \
-void tgl ## name ## 1f(TGLfloat); \
-void tgl ## name ## 1d(TGLdouble); \
-void tgl ## name ## 1fv(const TGLfloat *); \
-void tgl ## name ## 1dv(const TGLdouble *);
-
-#define PROTO_GL2(name) \
-void tgl ## name ## 2f(TGLfloat, TGLfloat); \
-void tgl ## name ## 2d(TGLdouble, TGLdouble); \
-void tgl ## name ## 2fv(const TGLfloat *); \
-void tgl ## name ## 2dv(const TGLdouble *);
-
-#define PROTO_GL3(name) \
-void tgl ## name ## 3f(TGLfloat, TGLfloat, TGLfloat); \
-void tgl ## name ## 3d(TGLdouble, TGLdouble, TGLdouble); \
-void tgl ## name ## 3fv(const TGLfloat *); \
-void tgl ## name ## 3dv(const TGLdouble *);
-
-#define PROTO_GL4(name) \
-void tgl ## name ## 4f(TGLfloat, TGLfloat, TGLfloat, TGLfloat); \
-void tgl ## name ## 4d(TGLdouble, TGLdouble, TGLdouble, TGLdouble); \
-void tgl ## name ## 4fv(const TGLfloat *); \
-void tgl ## name ## 4dv(const TGLdouble *);
-
-PROTO_GL2(Vertex)
-PROTO_GL3(Vertex)
-PROTO_GL4(Vertex)
-
-PROTO_GL3(Color)
-PROTO_GL4(Color)
-void tglColor3ub(TGLubyte r, TGLubyte g, TGLubyte b);
-void tglColor4ub(TGLubyte r, TGLubyte g, TGLubyte b, TGLubyte a);
-
-PROTO_GL3(Normal)
-
-PROTO_GL1(TexCoord)
-PROTO_GL2(TexCoord)
-PROTO_GL3(TexCoord)
-PROTO_GL4(TexCoord)
+void tglLineWidth(TGLfloat width);
+void tglPointSize(TGLfloat size);
void tglEdgeFlag(TGLboolean flag);
+void tglEdgeFlagv(const TGLboolean *flag);
+
+void tglBegin(TGLenum type);
+void tglEnd();
+
+// rects
+void tglRects(TGLshort x1, TGLshort y1, TGLshort x2, TGLshort y2);
+void tglRecti(TGLint x1, TGLint y1, TGLint x2, TGLint y2);
+void tglRectf(TGLfloat x1, TGLfloat y1, TGLfloat x2, TGLfloat y2);
+void tglRectd(TGLdouble x1, TGLdouble y1, TGLdouble x2, TGLdouble y2);
+void tglRectsv(const TGLshort *v1, const TGLshort *v2);
+void tglRectiv(const TGLint *v1, const TGLint *v2);
+void tglRectfv(const TGLfloat *v1, const TGLfloat *v2);
+void tglRectdv(const TGLdouble *v1, const TGLdouble *v2);
+
+// vertexs
+void tglVertex2s(TGLshort x, TGLshort y);
+void tglVertex2i(TGLint x, TGLint y);
+void tglVertex2f(TGLfloat x, TGLfloat y);
+void tglVertex2d(TGLdouble x, TGLdouble y);
+void tglVertex2sv(const TGLshort *v);
+void tglVertex2iv(const TGLint *v);
+void tglVertex2fv(const TGLfloat *v);
+void tglVertex2dv(const TGLdouble *v);
+void tglVertex3s(TGLshort x, TGLshort y, TGLshort z);
+void tglVertex3i(TGLint x, TGLint y, TGLint z);
+void tglVertex3f(TGLfloat x, TGLfloat y, TGLfloat z);
+void tglVertex3d(TGLdouble x, TGLdouble y, TGLdouble z);
+void tglVertex3sv(const TGLshort *v);
+void tglVertex3dv(const TGLint *v);
+void tglVertex3fv(const TGLfloat *v);
+void tglVertex3dv(const TGLdouble *v);
+void tglVertex4s(TGLshort x, TGLshort y, TGLshort z, TGLshort w);
+void tglVertex4i(TGLint x, TGLint y, TGLint z, TGLint w);
+void tglVertex4f(TGLfloat x, TGLfloat y, TGLfloat z, TGLfloat w);
+void tglVertex4d(TGLdouble x, TGLdouble y, TGLdouble z, TGLdouble w);
+void tglVertex4sv(const TGLshort *v);
+void tglVertex4iv(const TGLint *v);
+void tglVertex4fv(const TGLfloat *v);
+void tglVertex4dv(const TGLdouble *v);
+
+// normals
+void tglNormal3s(TGLshort nx, TGLshort ny, TGLshort nz);
+void tglNormal3i(TGLint nx, TGLint ny, TGLint nz);
+void tglNormal3f(TGLfloat nx, TGLfloat ny, TGLfloat nz);
+void tglNormal3d(TGLdouble nx, TGLdouble ny, TGLdouble nz);
+void tglNormal3sv(const TGLshort *v);
+void tglNormal3dv(const TGLint *v);
+void tglNormal3fv(const TGLfloat *v);
+void tglNormal3dv(const TGLdouble *v);
+
+// colors
+void tglColor3s(TGLshort red, TGLshort green, TGLshort blue);
+void tglColor3i(TGLint red, TGLint green, TGLint blue);
+void tglColor3f(TGLfloat red, TGLfloat green, TGLfloat blue);
+void tglColor3d(TGLdouble red, TGLdouble green, TGLdouble blue);
+void tglColor3sv(const TGLshort *v);
+void tglColor3dv(const TGLint *v);
+void tglColor3fv(const TGLfloat *v);
+void tglColor3dv(const TGLdouble *v);
+void tglColor3b(TGLbyte red, TGLbyte green, TGLbyte blue);
+void tglColor3ub(TGLubyte red, TGLubyte green, TGLubyte blue);
+void tglColor3us(TGLushort red, TGLushort green, TGLushort blue);
+void tglColor3ui(TGLuint red, TGLuint green, TGLuint blue);
+void tglColor3bv(const TGLbyte *v);
+void tglColor3ubv(const TGLubyte *v);
+void tglColor3usv(const TGLushort *v);
+void tglColor3uiv(const TGLuint *v);
+void tglColor4s(TGLshort red, TGLshort green, TGLshort blue, TGLshort alpha);
+void tglColor4i(TGLint red, TGLint green, TGLint b, TGLint alpha);
+void tglColor4f(TGLfloat red, TGLfloat green, TGLfloat blue, TGLfloat alpha);
+void tglColor4d(TGLdouble red, TGLdouble green, TGLdouble blue, TGLdouble alpha);
+void tglColor4sv(const TGLshort *v);
+void tglColor4iv(const TGLint *v);
+void tglColor4fv(const TGLfloat *v);
+void tglColor4dv(const TGLdouble *v);
+void tglColor4b(TGLbyte red, TGLbyte green, TGLbyte blue, TGLbyte alpha);
+void tglColor4ub(TGLubyte red, TGLubyte green, TGLubyte blue, TGLubyte alpha);
+void tglColor4us(TGLushort red, TGLushort green, TGLushort blue, TGLushort alpha);
+void tglColor4ui(TGLuint red, TGLuint green, TGLuint blue, TGLuint alpha);
+void tglColor4bv(const TGLbyte *v);
+void tglColor4ubv(const TGLubyte *v);
+void tglColor4usv(const TGLushort *v);
+void tglColor4uiv(const TGLuint *v);
+void tglIndexs(TGLshort c);
+void tglIndexi(TGLint c);
+void tglIndexf(TGLfloat c);
+void tglIndexd(TGLdouble c);
+void tglIndexsv(const TGLshort *c);
+void tglIndexiv(const TGLint *c);
+void tglIndexfv(const TGLfloat *c);
+void tglIndexdv(const TGLdouble *c);
// matrix
void tglMatrixMode(TGLenum mode);
void tglLoadMatrixf(const TGLfloat *m);
+void tglLoadMatrixd(const TGLdouble *m);
void tglLoadIdentity();
void tglMultMatrixf(const TGLfloat *m);
+void tglMultMatrixd(const TGLdouble *m);
void tglPushMatrix();
void tglPopMatrix();
void tglRotatef(TGLfloat angle, TGLfloat x, TGLfloat y, TGLfloat z);
+void tglRotated(TGLdouble angle, TGLdouble x, TGLdouble y, TGLdouble z);
void tglTranslatef(TGLfloat x, TGLfloat y, TGLfloat z);
+void tglTranslated(TGLdouble x, TGLdouble y, TGLdouble z);
void tglScalef(TGLfloat x, TGLfloat y, TGLfloat z);
-
+void tglScaled(TGLdouble x, TGLdouble y, TGLdouble z);
void tglViewport(TGLint x, TGLint y, TGLsizei width, TGLsizei height);
void tglFrustum(TGLdouble left, TGLdouble right, TGLdouble bottom, TGLdouble top,
TGLdouble nearv, TGLdouble farv);
@@ -789,48 +878,165 @@ TGLboolean tglIsList(TGLuint list);
void tglNewList(TGLuint list, TGLenum mode);
void tglEndList();
void tglCallList(TGLuint list);
+void tglCallLists(TGLsizei n, TGLenum type, const TGLvoid *lists);
+void tglDeleteLists(TGLuint list, TGLsizei range);
+void tglListBase(TGLuint base);
// clear
void tglClear(TGLbitfield mask);
-void tglClearColor(TGLfloat r, TGLfloat g, TGLfloat b, TGLfloat a);
+void tglClearColor(TGLfloat red, TGLfloat green, TGLfloat blue, TGLfloat alpha);
void tglClearDepth(TGLdouble depth);
void tglClearStencil(TGLint s);
+void tglClearAccum(TGLfloat red, TGLfloat green, TGLfloat blue, TGLfloat alpha);
+void tglClearIndex(TGLfloat c);
+
+// buffer
+void tglPixelStorei(TGLenum pname, TGLint param);
+void tglPixelStoref(TGLenum pname, TGLfloat param);
+void tglPixelZoom(TGLfloat xfactor, TGLfloat yfactor);
+void tglPixelTransferf(TGLenum pname, TGLfloat param);
+void tglPixelTransferi(TGLenum pname, TGLint param);
+void tglPixelMapfv(TGLenum map, TGLsizei mapsize, const TGLfloat *values);
+void tglPixelMapuiv(TGLenum map, TGLsizei mapsize, const TGLuint *values);
+void tglPixelMapusv(TGLenum map, TGLsizei mapsize, const TGLushort *values);
+void tglCopyPixels(TGLint x, TGLint y, TGLsizei width, TGLsizei height, TGLenum type);
+void tglDrawPixels(TGLsizei width, TGLsizei height, TGLenum format, TGLenum type, const TGLvoid *pixels);
+void tglGetPixelMapfv(TGLenum map, TGLfloat *values);
+void tglGetPixelMapuiv(TGLenum map, TGLuint *values);
+void tglGetPixelMapusv(TGLenum map, TGLushort *values);
+void tglDrawBuffer(TGLenum mode);
+void tglReadBuffer(TGLenum mode);
+void tglReadPixels(TGLint x, TGLint y, TGLsizei width, TGLsizei height,
+ TGLenum format, TGLenum type, TGLvoid *pixels);
+void tglRasterPos2s(TGLshort x, TGLshort y);
+void tglRasterPos2i(TGLint x, TGLint y);
+void tglRasterPos2f(TGLfloat x, TGLfloat y);
+void tglRasterPos2d(TGLdouble x, TGLdouble y);
+void tglRasterPos2sv(const TGLshort *v);
+void tglRasterPos2iv(const TGLint *v);
+void tglRasterPos2fv(const TGLfloat *v);
+void tglRasterPos2dv(const TGLdouble *v);
+void tglRasterPos3s(TGLshort x, TGLshort y, TGLshort z);
+void tglRasterPos3i(TGLint x, TGLint y, TGLint z);
+void tglRasterPos3f(TGLfloat x, TGLfloat y, TGLfloat z);
+void tglRasterPos3d(TGLdouble x, TGLdouble y, TGLdouble z);
+void tglRasterPos3sv(const TGLshort *v);
+void tglRasterPos3dv(const TGLint *v);
+void tglRasterPos3fv(const TGLfloat *v);
+void tglRasterPos3dv(const TGLdouble *v);
+void tglRasterPos4s(TGLshort x, TGLshort y, TGLshort z, TGLshort w);
+void tglRasterPos4i(TGLint x, TGLint y, TGLint z, TGLint w);
+void tglRasterPos4f(TGLfloat x, TGLfloat y, TGLfloat z, TGLfloat w);
+void tglRasterPos4d(TGLdouble x, TGLdouble y, TGLdouble z, TGLdouble w);
+void tglRasterPos4sv(const TGLshort *v);
+void tglRasterPos4iv(const TGLint *v);
+void tglRasterPos4fv(const TGLfloat *v);
+void tglRasterPos4dv(const TGLdouble *v);
// stencil buffer
void tglStencilFunc(TGLenum func, TGLint ref, TGLuint mask);
void tglStencilOp(TGLenum sfail, TGLenum dpfail, TGLenum dppass);
void tglStencilMask(TGLuint mask);
+// accum buffer
+void tglAccum(TGLenum op, TGLfloat value);
+
// selection
int tglRenderMode(TGLenum mode);
void tglSelectBuffer(TGLsizei size, TGLuint *buffer);
+// feedback
+void tglFeedbackBuffer(TGLsizei size, TGLenum type, TGLfloat *buffer);
+void tglPassThrough(TGLfloat token);
+
void tglInitNames();
void tglPushName(TGLuint name);
void tglPopName();
void tglLoadName(TGLuint name);
// textures
-void tglGenTextures(TGLsizei n, TGLuint *textures);
-void tglDeleteTextures(TGLsizei n, const TGLuint *textures);
-void tglBindTexture(TGLenum target, TGLuint texture);
+void tglTexImage1D(TGLenum target, TGLint level, TGLint internalformat,
+ TGLsizei width, TGLint border, TGLint format,
+ TGLenum type, const TGLvoid *pixels);
void tglTexImage2D(TGLenum target, TGLint level, TGLint internalformat,
TGLsizei width, TGLsizei height, TGLint border,
TGLenum format, TGLenum type, const void *pixels);
+void tglTexEnvf(TGLenum target, TGLenum pname, TGLfloat param);
+void tglTexEnvfv(TGLenum target, TGLenum pname, const TGLfloat *params);
void tglTexEnvi(TGLenum target, TGLenum pname, TGLint param);
+void tglTexEnviv(TGLenum target, TGLenum pname, const TGLint *params);
+void tglTexGend(TGLenum coord, TGLenum pname, TGLdouble param);
+void tglTexGendv(TGLenum coord, TGLenum pname, const TGLdouble *params);
+void tglTexGenf(TGLenum coord, TGLenum pname, TGLfloat param);
+void tglTexGenfv(TGLenum coord, TGLenum pname, const TGLfloat *params);
+void tglTexGeni(TGLenum coord, TGLenum pname, TGLint param);
+void tglTexGeniv(TGLenum coord, TGLenum pname, const TGLint *params);
+void tglTexParameterf(TGLenum target, TGLenum pname, TGLfloat param);
+void tglTexParameterfv(TGLenum target, TGLenum pname, const TGLfloat *params);
void tglTexParameteri(TGLenum target, TGLenum pname, TGLint param);
-void tglPixelStorei(TGLenum pname, TGLint param);
+void tglTexParameteriv(TGLenum target, TGLenum pname, const TGLint *params);
+void tglGetTexEnvfv(TGLenum target, TGLenum pname, TGLfloat *params);
+void tglGetTexEnviv(TGLenum target, TGLenum pname, TGLint *params);
+void tglGetTexImage(TGLenum target, TGLint level, TGLenum format, TGLenum type, TGLvoid *pixels);
+void tglGetTexParameterfv(TGLenum target, TGLenum pname, TGLfloat *params);
+void tglGetTexParameteriv(TGLenum target, TGLenum pname, TGLint *params);
+void tglGetTexLevelParameterfv(TGLenum target, TGLint level, TGLenum pname, TGLfloat *params);
+void tglGetTexLevelParameteriv(TGLenum target, TGLint level, TGLenum pname, TGLint *params);
+void tglGetTexGenfv(TGLenum coord, TGLenum pname, TGLfloat *params);
+void tglGetTexGeniv(TGLenum coord, TGLenum pname, TGLint *params);
+void tglTexCoord1s(TGLshort s);
+void tglTexCoord1i(TGLint s);
+void tglTexCoord1f(TGLfloat s);
+void tglTexCoord1d(TGLdouble s);
+void tglTexCoord1sv(const TGLshort *v);
+void tglTexCoord1iv(const TGLint *v);
+void tglTexCoord1fv(const TGLfloat *v);
+void tglTexCoord1dv(const TGLdouble *v);
+void tglTexCoord2s(TGLshort s, TGLshort t);
+void tglTexCoord2i(TGLint s, TGLint t);
+void tglTexCoord2f(TGLfloat s, TGLfloat t);
+void tglTexCoord2d(TGLdouble s, TGLdouble t);
+void tglTexCoord2sv(const TGLshort *v);
+void tglTexCoord2iv(const TGLint *v);
+void tglTexCoord2fv(const TGLfloat *v);
+void tglTexCoord2dv(const TGLdouble *v);
+void tglTexCoord3s(TGLshort s, TGLshort t, TGLshort r);
+void tglTexCoord3i(TGLint s, TGLint t, TGLint r);
+void tglTexCoord3f(TGLfloat s, TGLfloat t, TGLfloat r);
+void tglTexCoord3d(TGLdouble s, TGLdouble t, TGLdouble r);
+void tglTexCoord3sv(const TGLshort *v);
+void tglTexCoord3dv(const TGLint *v);
+void tglTexCoord3fv(const TGLfloat *v);
+void tglTexCoord3dv(const TGLdouble *v);
+void tglTexCoord4s(TGLshort s, TGLshort t, TGLshort r, TGLshort q);
+void tglTexCoord4i(TGLint s, TGLint t, TGLint r, TGLint q);
+void tglTexCoord4f(TGLfloat s, TGLfloat t, TGLfloat r, TGLfloat q);
+void tglTexCoord4d(TGLdouble s, TGLdouble t, TGLdouble r, TGLdouble q);
+void tglTexCoord4sv(const TGLshort *v);
+void tglTexCoord4iv(const TGLint *v);
+void tglTexCoord4fv(const TGLfloat *v);
+void tglTexCoord4dv(const TGLdouble *v);
// material
-void tglMaterialfv(TGLenum mode, TGLenum type, const TGLfloat *v);
-void tglMaterialf(TGLenum mode, TGLenum type, TGLfloat v);
-void tglColorMaterial(TGLenum mode, TGLenum type);
+void tglMaterialfv(TGLenum face, TGLenum pname, const TGLfloat *params);
+void tglMaterialf(TGLenum face, TGLenum pname, TGLfloat param);
+void tglMaterialiv(TGLenum face, TGLenum pname, const TGLint *params);
+void tglMateriali(TGLenum face, TGLenum pname, TGLint param);
+void tglColorMaterial(TGLenum face, TGLenum mode);
+void tglGetMaterialfv(TGLenum face, TGLenum pname, TGLfloat *params);
+void tglGetMaterialiv(TGLenum face, TGLenum pname, TGLint *params);
// lighting
-void tglLightfv(TGLenum light, TGLenum type, const TGLfloat *v);
-void tglLightf(TGLenum light, TGLenum type, const TGLfloat v);
+void tglLightfv(TGLenum light, TGLenum pname, const TGLfloat *params);
+void tglLightf(TGLenum light, TGLenum pname, const TGLfloat param);
+void tglLightiv(TGLenum light, TGLenum pname, const TGLint *params);
+void tglLighti(TGLenum light, TGLenum pname, const TGLint param);
+void tglLightModelf(TGLenum pname, TGLfloat param);
void tglLightModeli(TGLenum pname, TGLint param);
-void tglLightModelfv(TGLenum pname, const TGLfloat *param);
+void tglLightModelfv(TGLenum pname, const TGLfloat *params);
+void tglLightModeliv(TGLenum pname, const TGLfloat *params);
+void tglGetLightfv(TGLenum light, TGLenum pname, TGLfloat *params);
+void tglGetLightiv(TGLenum light, TGLenum pname, TGLint *params);
// fog
void tglFogfv(TGLenum pname, const TGLfloat *params);
@@ -838,30 +1044,127 @@ void tglFogf(TGLenum pname, TGLfloat param);
void tglFogiv(TGLenum pname, const TGLint *params);
void tglFogi(TGLenum pname, TGLint param);
+
+// gets
+TGLenum tglGetError();
+const TGLubyte *tglGetString(TGLenum name);
+void tglGetIntegerv(TGLenum pname, TGLint *data);
+void tglGetFloatv(TGLenum pname, TGLfloat *data);
+void tglGetDoublev(TGLenum pname, TGLdouble *data);
+void tglGetBooleanv(TGLenum pname, TGLboolean *params);
+void tglGetClipPlane(TGLenum plane, TGLdouble *equation);
+void tglGetMapdv(TGLenum target, TGLenum query, TGLdouble *v);
+void tglGetMapfv(TGLenum target, TGLenum query, TGLfloat *v);
+void tglGetMapiv(TGLenum target, TGLenum query, TGLint *v);
+
// misc
void tglFlush();
+void tglFinish();
void tglHint(TGLenum target, TGLenum mode);
-void tglGetIntegerv(TGLenum pname, TGLint *data);
-void tglGetFloatv(TGLenum pname, TGLfloat *data);
+void tglLogicOp(TGLenum opcode);
+void tglScissor(TGLint x, TGLint y, TGLsizei width, TGLsizei height);
void tglFrontFace(TGLenum mode);
-void tglColorMask(TGLboolean r, TGLboolean g, TGLboolean b, TGLboolean a);
+void tglColorMask(TGLboolean red, TGLboolean green, TGLboolean blue, TGLboolean alpha);
void tglDepthMask(TGLboolean flag);
+void tglIndexMask(TGLuint mask);
void tglBlendFunc(TGLenum sfactor, TGLenum dfactor);
void tglAlphaFunc(TGLenum func, TGLclampf ref);
void tglDepthFunc(TGLenum func);
+void tglDepthRange(TGLclampd zNear, TGLclampd zFar);
+void tglPopAttrib();
+void tglPushAttrib(TGLbitfield mask);
+void tglMap1d(TGLenum target, TGLdouble u1, TGLdouble u2, TGLint stride, TGLint order, const TGLdouble *points);
+void tglMap1f(TGLenum target, TGLfloat u1, TGLfloat u2, TGLint stride, TGLint order, const TGLfloat *points);
+void tglMap2d(TGLenum target, TGLdouble u1, TGLdouble u2, TGLint ustride, TGLint uorder,
+ TGLdouble v1, TGLdouble v2, TGLint vstride, TGLint vorder, const TGLdouble *points);
+void tglMap2f(TGLenum target, TGLfloat u1, TGLfloat u2, TGLint ustride, TGLint uorder,
+ TGLfloat v1, TGLfloat v2, TGLint vstride, TGLint vorder, const TGLfloat *points);
+void tglMapGrid1d(TGLint un, TGLdouble u1, TGLdouble u2);
+void tglMapGrid1f(TGLint un, TGLfloat u1, TGLfloat u2);
+void tglMapGrid2d(TGLint un, TGLdouble u1, TGLdouble u2, TGLint vn, TGLdouble v1, TGLdouble v2);
+void tglMapGrid2f(TGLint un, TGLfloat u1, TGLfloat u2, TGLint vn, TGLfloat v1, TGLfloat v2);
+void tglEvalCoord1d(TGLdouble u);
+void tglEvalCoord1dv(const TGLdouble *u);
+void tglEvalCoord1f(TGLfloat u);
+void tglEvalCoord1fv(const TGLfloat *u);
+void tglEvalCoord2d(TGLint un, TGLdouble u1, TGLdouble u2, TGLint vn, TGLdouble v1, TGLdouble v2);
+void tglEvalCoord2dv(const TGLdouble *u);
+void tglEvalCoord2f(TGLint un, TGLfloat u1, TGLfloat u2, TGLint vn, TGLfloat v1, TGLfloat v2);
+void tglEvalCoord2fv(const TGLfloat *u);
+void tglEvalMesh1(TGLenum mode, TGLint i1, TGLint i2);
+void tglEvalMesh2(TGLenum mode, TGLint i1, TGLint i2, TGLint j1, TGLint j2);
+void tglEvalPoint1(TGLint i);
+void tglEvalPoint2(TGLint i, TGLint j);
+
+
+// --- GL 1.1 ---
+
+// textures
+void tglBindTexture(TGLenum target, TGLuint texture);
+void tglGenTextures(TGLsizei n, TGLuint *textures);
+void tglDeleteTextures(TGLsizei n, const TGLuint *textures);
+void tglCopyTexImage1D(TGLenum target, TGLint level, TGLenum internalFormat,
+ TGLint x, TGLint y, TGLsizei width, TGLint border);
+void tglCopyTexImage2D(TGLenum target, TGLint level, TGLenum internalFormat,
+ TGLint x, TGLint y, TGLsizei width, TGLsizei height,
+ TGLint border);
+void tglCopyTexSubImage1D(TGLenum target, TGLint level, TGLint xoffset,
+ TGLint x, TGLint y, TGLsizei width);
+void tglCopyTexSubImage2D(TGLenum target, TGLint level, TGLint xoffset,
+ TGLint yoffset, TGLint x, TGLint y,
+ TGLsizei width, TGLsizei height);
+void tglTexSubImage1D(TGLenum target, TGLint level, TGLint xoffset,
+ TGLsizei width, TGLenum format, TGLenum type,
+ const TGLvoid *pixels);
+void tglTexSubImage2D(TGLenum target, TGLint level, TGLint xoffset,
+ TGLint yoffset, TGLsizei width, TGLsizei height,
+ TGLenum format, TGLenum type, const TGLvoid *pixels);
+TGLboolean tglIsTexture(TGLuint texture);
+TGLboolean tglAreTexturesResident(TGLsizei n, const TGLuint *textures, TGLboolean *residences);
+void tglPrioritizeTextures(TGLsizei n, const TGLuint *textures, const TGLclampf *priorities);
// arrays
void tglEnableClientState(TGLenum array);
void tglDisableClientState(TGLenum array);
-void tglArrayElement(TGLint i);
+void tglArrayElement(TGLint index);
+void tglInterleavedArrays(TGLenum format, TGLsizei stride, const TGLvoid *pointer);
void tglDrawArrays(TGLenum mode, TGLint first, TGLsizei count);
void tglDrawElements(TGLenum mode, TGLsizei count, TGLenum type, const TGLvoid *indices);
void tglVertexPointer(TGLint size, TGLenum type, TGLsizei stride, const TGLvoid *pointer);
void tglColorPointer(TGLint size, TGLenum type, TGLsizei stride, const TGLvoid *pointer);
void tglNormalPointer(TGLenum type, TGLsizei stride, const TGLvoid *pointer);
void tglTexCoordPointer(TGLint size, TGLenum type, TGLsizei stride, const TGLvoid *pointer);
+void tglIndexPointer(TGLenum type, TGLsizei stride, const TGLvoid *pointer);
+void tglGetPointerv(TGLenum pname, TGLvoid **params);
+void tglEdgeFlagPointer(TGLsizei stride, const TGLvoid *pointer);
// polygon offset
void tglPolygonOffset(TGLfloat factor, TGLfloat units);
+// colors
+void tglIndexub(TGLubyte c);
+void tglIndexubv(const TGLubyte *c);
+
+// misc
+void tglPopClientAttrib();
+void tglPushClientAttrib(TGLbitfield mask);
+
+
+// --- GL 1.2 ---
+
+// arrays
+void tglDrawRangeElements(TGLenum mode, TGLuint start, TGLuint end,
+ TGLsizei count, TGLenum type, const void *indices);
+
+// textures
+void tglTexImage3D(TGLenum target, TGLint level, TGLint internalformat,
+ TGLsizei width, TGLsizei height, TGLsizei depth,
+ TGLint border, TGLenum format, TGLenum type,
+ const void *data);
+void tglTexSubImage3D(TGLenum target, TGLint level, TGLint xoffset, TGLint yoffset,
+ TGLint zoffset, TGLsizei width, TGLsizei height, TGLsizei depth,
+ TGLenum format, TGLenum type, const void *pixels);
+void tglCopyTexSubImage3D(TGLenum target, TGLint level, TGLint xoffset, TGLint yoffset,
+ TGLint zoffset, TGLint x, TGLint y, TGLsizei width, TGLsizei height);
+
#endif
More information about the Scummvm-git-logs
mailing list