diff options
| author | Nathan Letwory <nathan@letworyinteractive.com> | 2004-03-23 01:02:18 +0300 |
|---|---|---|
| committer | Nathan Letwory <nathan@letworyinteractive.com> | 2004-03-23 01:02:18 +0300 |
| commit | 00291b5cf4a0f16ddca425b74ed30e8ac35d40e2 (patch) | |
| tree | 952bb1c2f6fd8c2f34b950597ed0fa73a4ea7594 /source | |
| parent | 5b90aafbd6815e29343f8e9aba9e3e20f85b3cc0 (diff) | |
[GameEngine] Commit all Kester's changes made to the gameengine to restore 2.25 like physics.
[SCons] Build with Solid as default when enabling the gameengine in the build process
[SCons] Build solid and qhull from the extern directory and link statically against them
That was about it.
There are a few things that needs double checking:
* Makefiles
* Projectfiles
* All the other systems than Linux and Windows on which the build (with scons) has been successfully tested.
Diffstat (limited to 'source')
127 files changed, 9114 insertions, 1510 deletions
diff --git a/source/blender/blenkernel/intern/mesh.c b/source/blender/blenkernel/intern/mesh.c index 30221bc21dd..b8fb750e74c 100644 --- a/source/blender/blenkernel/intern/mesh.c +++ b/source/blender/blenkernel/intern/mesh.c @@ -217,7 +217,7 @@ Mesh *add_mesh() me->size[0]= me->size[1]= me->size[2]= 1.0; me->smoothresh= 30; - me->texflag= ME_AUTOSPACE; + me->texflag= AUTOSPACE; me->flag= ME_TWOSIDED; me->subdiv= 1; me->subdivr = 1; @@ -398,7 +398,7 @@ void tex_space_mesh(Mesh *me) boundbox_mesh(me, loc, size); - if(me->texflag & ME_AUTOSPACE) { + if(me->texflag & AUTOSPACE) { if(me->key) { kb= me->key->refkey; if (kb) { diff --git a/source/blender/include/BIF_resources.h b/source/blender/include/BIF_resources.h index 8900df470ca..2fa361a985e 100644 --- a/source/blender/include/BIF_resources.h +++ b/source/blender/include/BIF_resources.h @@ -258,8 +258,72 @@ typedef enum { #define BIFNICONIDS (BIFICONID_LAST-BIFICONID_FIRST + 1) } BIFIconID; +typedef enum { +#define BIFCOLORSHADE_FIRST (COLORSHADE_DARK) + COLORSHADE_DARK, + COLORSHADE_GREY, + COLORSHADE_MEDIUM, + COLORSHADE_HILITE, + COLORSHADE_LIGHT, + COLORSHADE_WHITE, +#define BIFCOLORSHADE_LAST (COLORSHADE_WHITE) +#define BIFNCOLORSHADES (BIFCOLORSHADE_LAST-BIFCOLORSHADE_FIRST + 1) +} BIFColorShade; + +typedef enum { +#define BIFCOLORID_FIRST (BUTGREY) + BUTGREY = 0, + BUTGREEN, + BUTBLUE, + BUTSALMON, + MIDGREY, + BUTPURPLE, + BUTYELLOW, + REDALERT, + BUTRUST, + BUTWHITE, + BUTDBLUE, + BUTPINK, + BUTDPINK, + BUTMACTIVE, -/* ---------- theme ----------- */ + BUTIPO, + BUTAUDIO, + BUTCAMERA, + BUTRANDOM, + BUTEDITOBJECT, + BUTPROPERTY, + BUTSCENE, + BUTMOTION, + BUTMESSAGE, + BUTACTION, + BUTCD, + BUTGAME, + BUTVISIBILITY, + BUTYUCK, + BUTSEASICK, + BUTCHOKE, + BUTIMPERIAL, + + BUTTEXTCOLOR, + BUTTEXTPRESSED, + BUTSBACKGROUND, + + VIEWPORTBACKCOLOR, + VIEWPORTGRIDCOLOR, + VIEWPORTACTIVECOLOR, + VIEWPORTSELECTEDCOLOR, + VIEWPORTUNSELCOLOR, + + EDITVERTSEL, + EDITVERTUNSEL, + EDITEDGESEL, + EDITEDGEUNSEL, + +#define BIFCOLORID_LAST (EDITEDGEUNSEL) +#define BIFNCOLORIDS (BIFCOLORID_LAST-BIFCOLORID_FIRST + 1) + +} BIFColorID; enum { TH_AUTO, /* for buttons, to signal automatic color assignment */ @@ -355,6 +419,8 @@ void BIF_InitTheme(void); void BIF_SetTheme(struct ScrArea *sa); void BIF_resources_init (void); void BIF_resources_free (void); +void BIF_colors_init (void); +void BIF_load_ui_colors (void); // icon API @@ -368,4 +434,6 @@ char *BIF_ThemeGetColorPtr(struct bTheme *btheme, int spacetype, int colorid); char *BIF_ThemeColorsPup(int spacetype); +void BIF_def_color (BIFColorID colorid, unsigned char r, unsigned char g, unsigned char b); + #endif /* BIF_ICONS_H */ diff --git a/source/blender/include/butspace.h b/source/blender/include/butspace.h index 63dcd0376c9..a2e153ef519 100644 --- a/source/blender/include/butspace.h +++ b/source/blender/include/butspace.h @@ -74,6 +74,9 @@ extern void do_mballbuts(unsigned short event); extern void do_latticebuts(unsigned short event); extern void do_fpaintbuts(unsigned short event); +/* dont like it here , rather make a BIF_Buttons_Editing.h or so BM*/ +extern int Buttons_Editing_GetFaceShadows(); + /* shading */ extern void material_panels(void); extern void do_matbuts(unsigned short event); @@ -97,6 +100,9 @@ extern void do_scriptbuts(unsigned short event); /* ipowindow */ extern void do_ipobuts(unsigned short event); // drawipo.c (bad! ton) +/* uvautocalculation */ +void do_uvautocalculationbuts(unsigned short event); +void get_uvautocalculationsettings(float *radius,float *cubesize, int *mapdir, int *mapalign); /* butspace.c */ void test_meshpoin_but(char *name, struct ID **idpp); void test_obpoin_but(char *name, struct ID **idpp); @@ -337,6 +343,14 @@ enum { #define B_VERTEXSMOOTH 2080 #define B_MAKESTICKY 2082 #define B_MAKEVERTCOL 2083 +#define B_CHROMADEPTH 2084 +#define B_ISDEFLECTOR 2085 +#define B_PDEFDAMPING 2086 +#define B_GRAVITY 2087 +#define B_GRAVSTRENGTH 2088 +#define B_GRAVPOWER 2089 +#define B_PDEFRDAMP 2090 +#define B_PDEFPERM 2091 /* *********************** */ #define B_CURVEBUTS 2200 @@ -416,6 +430,12 @@ enum { #define B_SOUNDACT_BROWSE 2712 +#define B_SETSECTOR 2713 +#define B_SETPROP 2714 +#define B_SETACTOR 2715 +#define B_SETMAINACTOR 2716 +#define B_SETDYNA 2717 + /* *********************** */ #define B_FPAINTBUTS 2900 @@ -508,8 +528,37 @@ enum { B_CONSTRAINT_ADD_LOCLIKE, B_CONSTRAINT_ADD_ACTION, B_CONSTRAINT_ADD_LOCKTRACK, - B_CONSTRAINT_ADD_FOLLOWPATH + B_CONSTRAINT_ADD_FOLLOWPATH, + B_CONSTRAINT_ADD_DISTANCELIMIT }; + +/*+++ BM */ +/* *********************** */ +#define B_UVAUTOCALCBUTS 3400 +enum { + B_UVAUTO_REDRAW = 3301, + B_UVAUTO_SPHERE, + B_UVAUTO_CYLINDER, + B_UVAUTO_CYLRADIUS, + B_UVAUTO_WINDOW, + B_UVAUTO_CUBE, + B_UVAUTO_CUBESIZE, + B_UVAUTO_STD1, + B_UVAUTO_STD2, + B_UVAUTO_STD4, + B_UVAUTO_STD8, + B_UVAUTO_BOUNDS1, + B_UVAUTO_BOUNDS2, + B_UVAUTO_BOUNDS4, + B_UVAUTO_BOUNDS8, + B_UVAUTO_TOP, + B_UVAUTO_FACE, + B_UVAUTO_OBJECT, + B_UVAUTO_ALIGNX, + B_UVAUTO_ALIGNY +}; +/* *********************** */ +/*--- BM */ /* *********************** */ diff --git a/source/blender/include/mydevice.h b/source/blender/include/mydevice.h index aad025fa759..6b8c2d305a0 100644 --- a/source/blender/include/mydevice.h +++ b/source/blender/include/mydevice.h @@ -217,6 +217,7 @@ #define REDRAWBUTSSCRIPT 0x401A #define REDRAWBUTSLOGIC 0x401B #define REDRAWBUTSSHADING 0x401C +#define REDRAWBUTSGAME 0x401D #define REDRAWINFO 0x4021 #define RENDERPREVIEW 0x4022 @@ -234,6 +235,7 @@ #define REDRAWTEXT 0x402E #define REDRAWSOUND 0x402F #define REDRAWACTION 0x4030 +#define REDRAWBUTSCONSTRAINT 0x4034 #define REDRAWNLA 0x4031 #define REDRAWSCRIPT 0x4032 diff --git a/source/blender/makesdna/DNA_constraint_types.h b/source/blender/makesdna/DNA_constraint_types.h index d48e18c177a..568baf80845 100644 --- a/source/blender/makesdna/DNA_constraint_types.h +++ b/source/blender/makesdna/DNA_constraint_types.h @@ -79,8 +79,8 @@ typedef struct bKinematicConstraint{ typedef struct bTrackToConstraint{ Object *tar; - int reserved1; /* Track Axis */ - int reserved2; /* Up Axis */ + int reserved1; /* I'll be using reserved1 and reserved2 as Track and Up flags, not sure if that's what they were intented for anyway. Not sure either if it would create backward incompatibility if I were to rename them. - theeth*/ + int reserved2; char subtarget[32]; } bTrackToConstraint; @@ -126,6 +126,17 @@ typedef struct bFollowPathConstraint{ int upflag; } bFollowPathConstraint; +/* Distance Limiting constraints */ +typedef struct bDistanceLimitConstraint{ + Object *tar; + char subtarget[32]; + float pad1; + float pad2; + float distance; + float offset[3]; +} bDistanceLimitConstraint; + + /* Zero-target constraints */ typedef struct bRotationConstraint{ float xmin, xmax; @@ -133,6 +144,8 @@ typedef struct bRotationConstraint{ float zmin, zmax; } bRotationConstraint; + + /* bConstraint.type */ #define CONSTRAINT_TYPE_NULL 0 #define CONSTRAINT_TYPE_CHILDOF 1 /* Unimplemented */ @@ -148,6 +161,7 @@ typedef struct bRotationConstraint{ #define CONSTRAINT_TYPE_PYTHON 11 /* Unimplemented */ #define CONSTRAINT_TYPE_ACTION 12 #define CONSTRAINT_TYPE_LOCKTRACK 13 /* New Tracking constraint that locks an axis in place - theeth */ +#define CONSTRAINT_TYPE_DISTANCELIMIT 14 /* bConstraint.flag */ #define CONSTRAINT_EXPAND 0x00000001 @@ -167,6 +181,39 @@ typedef struct bRotationConstraint{ #define LOCLIKE_X 0x00000001 #define LOCLIKE_Y 0x00000002 #define LOCLIKE_Z 0x00000004 +#define LOCSPACE 0x00000008 + +/* Tracking flags */ +#define LOCK_X 0x00000000 +#define LOCK_Y 0x00000001 +#define LOCK_Z 0x00000002 + +#define UP_X 0x00000000 +#define UP_Y 0x00000001 +#define UP_Z 0x00000002 + +#define TRACK_X 0x00000000 +#define TRACK_Y 0x00000001 +#define TRACK_Z 0x00000002 +#define TRACK_nX 0x00000003 +#define TRACK_nY 0x00000004 +#define TRACK_nZ 0x00000005 + +/* Tracking flags */ +#define LOCK_X 0x00000000 +#define LOCK_Y 0x00000001 +#define LOCK_Z 0x00000002 + +#define UP_X 0x00000000 +#define UP_Y 0x00000001 +#define UP_Z 0x00000002 + +#define TRACK_X 0x00000000 +#define TRACK_Y 0x00000001 +#define TRACK_Z 0x00000002 +#define TRACK_nX 0x00000003 +#define TRACK_nY 0x00000004 +#define TRACK_nZ 0x00000005 /* Tracking flags */ #define LOCK_X 0x00000000 diff --git a/source/blender/makesdna/DNA_mesh_types.h b/source/blender/makesdna/DNA_mesh_types.h index ebfa3818ef8..8198e5329cd 100644 --- a/source/blender/makesdna/DNA_mesh_types.h +++ b/source/blender/makesdna/DNA_mesh_types.h @@ -100,7 +100,7 @@ typedef struct Mesh { /* **************** MESH ********************* */ /* texflag */ -#define ME_AUTOSPACE 1 +#define AUTOSPACE 1 /* me->flag */ #define ME_ISDONE 1 diff --git a/source/blender/makesdna/DNA_object_types.h b/source/blender/makesdna/DNA_object_types.h index c5fa7aeafd5..45536964351 100644 --- a/source/blender/makesdna/DNA_object_types.h +++ b/source/blender/makesdna/DNA_object_types.h @@ -64,6 +64,18 @@ typedef struct BoundBox { float vec[8][3]; } BoundBox; +/* OcInfo and LBuf structs are for the Enji gameengine */ + +typedef struct OcInfo { + float dvec[3]; + float size[3]; +} OcInfo; + +typedef struct LBuf { + short tot, max; + int pad; + struct Object **ob; +} LBuf; typedef struct Object { ID id; @@ -153,6 +165,7 @@ typedef struct Object { * bit 8: Friction is anisotropic * bit 9: Object is a ghost * bit 10: Do rigid body dynamics. + * bit 11: Use bounding object for physics */ int gameflag; /** @@ -165,6 +178,13 @@ typedef struct Object { ListBase constraints; ListBase nlastrips; + + struct Life *life; + + LBuf lbuf; + LBuf port; + + float toonedge, pad2; } Object; /* this work object is defined in object.c */ @@ -250,6 +270,11 @@ extern Object workob; #define OB_SOLID 3 #define OB_SHADED 4 #define OB_TEXTURE 5 +#define OB_TOON_MONO 6 +#define OB_TOON_COLOR 7 +#define OB_TOON_TRANSP 8 +#define OB_TOON_FLAT 9 +#define OB_TOON_SMOOTH 10 /* dtx: flags */ #define OB_AXIS 2 @@ -291,6 +316,7 @@ extern Object workob; #define OB_ANISOTROPIC_FRICTION 256 #define OB_GHOST 512 #define OB_RIGID_BODY 1024 +#define OB_BOUNDS 2048 #define OB_COLLISION_RESPONSE 4096 #define OB_SECTOR 8192 diff --git a/source/blender/src/buttons_logic.c b/source/blender/src/buttons_logic.c index 9781d3ea1f8..3d6987fe9b7 100644 --- a/source/blender/src/buttons_logic.c +++ b/source/blender/src/buttons_logic.c @@ -63,6 +63,8 @@ #include "DNA_sound_types.h" #include "DNA_text_types.h" #include "DNA_view3d_types.h" +#include "DNA_mesh_types.h" +#include "DNA_world_types.h" #include "BKE_library.h" #include "BKE_global.h" @@ -87,7 +89,6 @@ #include "nla.h" /* For __NLA : Important, do not remove */ #include "butspace.h" // own module - /* internals */ /****/ @@ -346,7 +347,31 @@ void do_logic_buts(unsigned short event) if(ob==0) return; switch(event) { + + case B_SETSECTOR: + /* check for inconsistant types */ + ob->gameflag &= ~(OB_PROP|OB_MAINACTOR|OB_DYNAMIC|OB_ACTOR); + ob->dtx |= OB_BOUNDBOX; + allqueue(REDRAWBUTSGAME, 0); + allqueue(REDRAWVIEW3D, 0); + break; + case B_SETPROP: + /* check for inconsistant types */ + ob->gameflag &= ~(OB_SECTOR|OB_MAINACTOR|OB_DYNAMIC|OB_ACTOR); + allqueue(REDRAWBUTSGAME, 0); + allqueue(REDRAWVIEW3D, 0); + break; + + case B_SETACTOR: + case B_SETDYNA: + case B_SETMAINACTOR: + ob->gameflag &= ~(OB_SECTOR|OB_PROP); + allqueue(REDRAWBUTSGAME, 0); + allqueue(REDRAWVIEW3D, 0); + break; + + case B_ADD_PROP: prop= new_property(PROP_FLOAT); make_unique_prop_names(prop->name); @@ -2246,12 +2271,128 @@ static uiBlock *actuator_menu(void *arg_unused) return block; } + +void buttons_enji(uiBlock *block, Object *ob) +{ + uiDefBut(block, TOG|INT|BIT|13, B_SETSECTOR, "Sector", + 10,205,65,19, &ob->gameflag, 0, 0, 0, 0, + "All game elements should be in the Sector boundbox"); + uiDefBut(block, TOG|INT|BIT|14, B_SETPROP, "Prop", + 75,205,65,19, &ob->gameflag, 0, 0, 0, 0, + "An Object fixed within a sector"); + uiBlockSetCol(block, BUTPURPLE); + uiDefBut(block, TOG|INT|BIT|2, B_SETACTOR, "Actor", + 140,205,65,19, &ob->gameflag, 0, 0, 0, 0, + "Objects that are evaluated by the engine "); + if(ob->gameflag & OB_ACTOR) { + uiDefBut(block, TOG|INT|BIT|0, B_SETDYNA, "Dynamic", + 205,205,75,19, &ob->gameflag, 0, 0, 0, 0, + "Motion defined by laws of physics"); + uiDefBut(block, TOG|INT|BIT|15, B_SETMAINACTOR, "MainActor", + 280,205,70,19, &ob->gameflag, 0, 0, 0, 0, ""); + + if(ob->gameflag & OB_DYNAMIC) { + uiDefBut(block, TOG|INT|BIT|6, B_DIFF, "Do Fh", + 10,185,50,19, &ob->gameflag, 0, 0, 0, 0, + "Use Fh settings in Materials"); + uiDefBut(block, TOG|INT|BIT|7, B_DIFF, "Rot Fh", + 60,185,50,19, &ob->gameflag, 0, 0, 0, 0, + "Use face normal to rotate Object"); + + uiBlockSetCol(block, BUTGREY); + uiDefBut(block, NUM|FLO, B_DIFF, "Mass:", + 110, 185, 120, 19, &ob->mass, 0.01, 100.0, 10, 0, + "The mass of the Object"); + uiDefBut(block, NUM|FLO, REDRAWVIEW3D, "Size:", + 230, 185, 120, 19, &ob->inertia, 0.01, 10.0, 10, 0, + "Bounding sphere size"); + uiDefBut(block, NUM|FLO, B_DIFF, "Damp:", + 10, 165, 100, 19, &ob->damping, 0.0, 1.0, 10, 0, + "General movement damping"); + uiDefBut(block, NUM|FLO, B_DIFF, "RotDamp:", + 110, 165, 120, 19, &ob->rdamping, 0.0, 1.0, 10, 0, + "General rotation damping"); + } + } + +} + +void buttons_ketsji(uiBlock *block, Object *ob) +{ + uiDefButI(block, TOG|BIT|2, B_REDR, "Actor", + 10,205,75,19, &ob->gameflag, 0, 0, 0, 0, + "Objects that are evaluated by the engine "); + if(ob->gameflag & OB_ACTOR) { + uiDefButI(block, TOG|BIT|9, B_REDR, "Ghost", 85,205,65,19, + &ob->gameflag, 0, 0, 0, 0, + "Objects that don't restitute collisions (like a ghost)"); + uiDefButI(block, TOG|BIT|0, B_REDR, "Dynamic", 150,205,65,19, + &ob->gameflag, 0, 0, 0, 0, + "Motion defined by laws of physics"); + + if(ob->gameflag & OB_DYNAMIC) { + uiDefButI(block, TOG|BIT|10, B_REDR, "Rigid Body", 215,205,135,19, + &ob->gameflag, 0, 0, 0, 0, + "Enable rolling physics"); + uiDefButI(block, TOG|BIT|6, B_DIFF, "Do Fh", 10,185,50,19, + &ob->gameflag, 0, 0, 0, 0, + "Use Fh settings in Materials"); + uiDefButI(block, TOG|BIT|7, B_DIFF, "Rot Fh", 60,185,50,19, + &ob->gameflag, 0, 0, 0, 0, + "Use face normal to rotate Object"); + uiDefButF(block, NUM, B_DIFF, "Mass:", 110, 185, 80, 19, + &ob->mass, 0.01, 100.0, 10, 0, + "The mass of the Object"); + uiDefButF(block, NUM, REDRAWVIEW3D, "Size:", 190, 185, 80, 19, + &ob->inertia, 0.01, 10.0, 10, 0, + "Bounding sphere size"); + uiDefButF(block, NUM, B_DIFF, "Form:", 270, 185, 80, 19, + &ob->formfactor, 0.01, 100.0, 10, 0, + "Form factor"); + + uiDefButF(block, NUM, B_DIFF, "Damp:", 10, 165, 100, 19, + &ob->damping, 0.0, 1.0, 10, 0, + "General movement damping"); + uiDefButF(block, NUM, B_DIFF, "RotDamp:", 110, 165, 120, 19, + &ob->rdamping, 0.0, 1.0, 10, 0, + "General rotation damping"); + uiDefButI(block, TOG|BIT|8, B_REDR, "Anisotropic", + 230, 165, 120, 19, + &ob->gameflag, 0.0, 1.0, 10, 0, + "Enable anisotropic friction"); + } + + if (ob->gameflag & OB_ANISOTROPIC_FRICTION) { + uiDefButF(block, NUM, B_DIFF, "x friction:", 10, 145, 114, 19, + &ob->anisotropicFriction[0], 0.0, 1.0, 10, 0, + "Relative friction coefficient in the x-direction."); + uiDefButF(block, NUM, B_DIFF, "y friction:", 124, 145, 113, 19, + &ob->anisotropicFriction[1], 0.0, 1.0, 10, 0, + "Relative friction coefficient in the y-direction."); + uiDefButF(block, NUM, B_DIFF, "z friction:", 237, 145, 113, 19, + &ob->anisotropicFriction[2], 0.0, 1.0, 10, 0, + "Relative friction coefficient in the z-direction."); + } + } + + if (!(ob->gameflag & OB_GHOST)) { + uiDefButI(block, TOG|BIT|11, B_REDR, "Bounds", 10, 125, 75, 19, + &ob->gameflag, 0, 0,0, 0, + "Specify a bounds object for physics"); + if (ob->gameflag & OB_BOUNDS) { + uiDefButS(block, MENU, REDRAWVIEW3D, "Boundary Display%t|Box%x0|Sphere%x1|Cylinder%x2|Cone%x3|Polyheder%x4", + 85, 125, 100, 19, &ob->boundtype, 0, 0, 0, 0, "Selects the boundary display type"); + } + } +} + /* never used, see CVS 1.134 for the code */ /* static FreeCamera *new_freecamera(void) */ /* never used, see CVS 1.120 for the code */ /* static uiBlock *freecamera_menu(void) */ + void logic_buts(void) { ID **idar; @@ -2262,11 +2403,15 @@ void logic_buts(void) bActuator *act; uiBlock *block; uiBut *but; + World *wrld; int a; short xco, yco, count, width, ycoo; char *pupstr, name[32]; int butreturn = 0; + wrld= G.scene->world; + if(wrld==0) return; + ob= OBACT; if(ob==0) return; @@ -2277,47 +2422,13 @@ void logic_buts(void) uiBlockSetCol(block, TH_BUT_SETTING2); - uiDefButI(block, TOG|BIT|2, B_REDR, "Actor", - 25,205,60,19, &ob->gameflag, 0, 0, 0, 0, - "Objects that are evaluated by the engine "); - - if(ob->gameflag & OB_ACTOR) { - uiDefButI(block, TOG|BIT|9, B_REDR, "Ghost", 85,205,65,19, &ob->gameflag, 0, 0, 0, 0, "Objects that don't restitute collisions (like a ghost)"); - uiDefButI(block, TOG|BIT|0, B_REDR, "Dynamic", 150,205,65,19, &ob->gameflag, 0, 0, 0, 0, "Motion defined by laws of physics"); - - if(ob->gameflag & OB_DYNAMIC) { - - uiDefButI(block, TOG|BIT|10, B_REDR, "Rigid Body", 215,205,135,19, &ob->gameflag, 0, 0, 0, 0, ""); - - uiDefButI(block, TOG|BIT|6, B_DIFF, "Do Fh", 10,185,50,19, &ob->gameflag, 0, 0, 0, 0, "Use Fh settings in Materials"); - uiDefButI(block, TOG|BIT|7, B_DIFF, "Rot Fh", 60,185,50,19, &ob->gameflag, 0, 0, 0, 0, "Use face normal to rotate Object"); - - uiDefButF(block, NUM, B_DIFF, "Mass:", 110, 185, 80, 19, &ob->mass, 0.01, 100.0, 10, 0, "The mass of the Object"); - uiDefButF(block, NUM, REDRAWVIEW3D, "Size:", 190, 185, 80, 19, &ob->inertia, 0.01, 10.0, 10, 0, "Bounding sphere size"); - uiDefButF(block, NUM, B_DIFF, "Form:", 270, 185, 80, 19, &ob->formfactor, 0.01, 100.0, 10, 0, "Form factor"); - - uiDefButF(block, NUM, B_DIFF, "Damp:", 10, 165, 100, 19, &ob->damping, 0.0, 1.0, 10, 0, "General movement damping"); - uiDefButF(block, NUM, B_DIFF, "RotDamp:", 110, 165, 120, 19, &ob->rdamping, 0.0, 1.0, 10, 0, "General rotation damping"); - uiDefButI(block, TOG|BIT|8, B_REDR, "Anisotropic", 230, 165, 120, 19, - &ob->gameflag, 0.0, 1.0, 10, 0, - "Enable anisotropic friction"); - } - } - - if (ob->gameflag & OB_ANISOTROPIC_FRICTION) { - uiDefButF(block, NUM, B_DIFF, "x friction:", 10, 145, 114, 19, - &ob->anisotropicFriction[0], 0.0, 1.0, 10, 0, - "Relative friction coefficient in the x-direction."); - uiDefButF(block, NUM, B_DIFF, "y friction:", 124, 145, 113, 19, - &ob->anisotropicFriction[1], 0.0, 1.0, 10, 0, - "Relative friction coefficient in the y-direction."); - uiDefButF(block, NUM, B_DIFF, "z friction:", 237, 145, 113, 19, - &ob->anisotropicFriction[2], 0.0, 1.0, 10, 0, - "Relative friction coefficient in the z-direction."); - } - + if (wrld->physicsEngine == 1) + buttons_enji(block, ob); + if ( (wrld->physicsEngine == 4) || (wrld->physicsEngine == 2) ) + buttons_ketsji(block, ob); + uiBlockSetCol(block, TH_AUTO); - uiDefBut(block, BUT, B_ADD_PROP, "ADD property", 10, 110, 340, 24, + uiDefBut(block, BUT, B_ADD_PROP, "ADD property", 10, 90, 340, 24, NULL, 0.0, 100.0, 100, 0, ""); @@ -2327,10 +2438,10 @@ void logic_buts(void) prop= ob->prop.first; while(prop) { - but= uiDefBut(block, BUT, 1, "Del", 10, (short)(90-20*a), 40, 19, NULL, 0.0, 0.0, 1, (float)a, ""); + but= uiDefBut(block, BUT, 1, "Del", 10, (short)(70-20*a), 40, 19, NULL, 0.0, 0.0, 1, (float)a, ""); uiButSetFunc(but, del_property, prop, NULL); - uiDefButS(block, MENU, B_CHANGE_PROP, pupstr, 50, (short)(90-20*a), 60, 19, &prop->type, 0, 0, 0, 0, ""); - but= uiDefBut(block, TEX, 1, "Name:", 110, (short)(90-20*a), 105, 19, prop->name, 0, 31, 0, 0, ""); + uiDefButS(block, MENU, B_CHANGE_PROP, pupstr, 50, (short)(70-20*a), 60, 19, &prop->type, 0, 0, 0, 0, ""); + but= uiDefBut(block, TEX, 1, "Name:", 110, (short)(70-20*a), 105, 19, prop->name, 0, 31, 0, 0, ""); uiButSetFunc(but, make_unique_prop_names_cb, prop->name, (void*) 1); if (strcmp(prop->name, "Text") == 0) { @@ -2340,19 +2451,19 @@ void logic_buts(void) } if(prop->type==PROP_BOOL) { - uiDefButI(block, TOG|BIT|0, B_REDR, "True", 215, (short)(90-20*a), 55, 19, &prop->data, 0, 0, 0, 0, ""); - uiDefButI(block, TOGN|BIT|0, B_REDR, "False", 270, (short)(90-20*a), 55, 19, &prop->data, 0, 0, 0, 0, ""); + uiDefButI(block, TOG|BIT|0, B_REDR, "True", 215, (short)(70-20*a), 55, 19, &prop->data, 0, 0, 0, 0, ""); + uiDefButI(block, TOGN|BIT|0, B_REDR, "False", 270, (short)(70-20*a), 55, 19, &prop->data, 0, 0, 0, 0, ""); } else if(prop->type==PROP_INT) - uiDefButI(block, NUM, butreturn, "", 215, (short)(90-20*a), 110, 19, &prop->data, -10000, 10000, 0, 0, ""); + uiDefButI(block, NUM, butreturn, "", 215, (short)(70-20*a), 110, 19, &prop->data, -10000, 10000, 0, 0, ""); else if(prop->type==PROP_FLOAT) - uiDefButF(block, NUM, butreturn, "", 215, (short)(90-20*a), 110, 19, (float*) &prop->data, -10000, 10000, 100, 0, ""); + uiDefButF(block, NUM, butreturn, "", 215, (short)(70-20*a), 110, 19, (float*) &prop->data, -10000, 10000, 100, 0, ""); else if(prop->type==PROP_STRING) - uiDefBut(block, TEX, butreturn, "", 215, (short)(90-20*a), 110, 19, prop->poin, 0, 127, 0, 0, ""); + uiDefBut(block, TEX, butreturn, "", 215, (short)(70-20*a), 110, 19, prop->poin, 0, 127, 0, 0, ""); else if(prop->type==PROP_TIME) - uiDefButF(block, NUM, butreturn, "", 215, (short)(90-20*a), 110, 19, (float*) &prop->data, -10000, 10000, 0, 0, ""); + uiDefButF(block, NUM, butreturn, "", 215, (short)(70-20*a), 110, 19, (float*) &prop->data, -10000, 10000, 0, 0, ""); - uiDefButS(block, TOG|BIT|0, 0, "D", 325, (short)(90-20*a), 20, 19, &prop->flag, 0, 0, 0, 0, "Print Debug info"); + uiDefButS(block, TOG|BIT|0, 0, "D", 325, (short)(70-20*a), 20, 19, &prop->flag, 0, 0, 0, 0, "Print Debug info"); a++; prop= prop->next; diff --git a/source/blender/src/buttons_scene.c b/source/blender/src/buttons_scene.c index 950e880f037..70bd128686b 100644 --- a/source/blender/src/buttons_scene.c +++ b/source/blender/src/buttons_scene.c @@ -1066,10 +1066,10 @@ static void render_panel_render(void) uiDefButI(block, TOG|BIT|7,0,"x", 665,50,20,23,&G.scene->r.mode, 0, 0, 0, 0, "Disables time difference in field calculations"); uiDefButI(block, TOG|BIT|17,0,"Gauss", 564,30,60,20, &G.scene->r.mode, 0, 0, 0, 0, "Enable Gaussian sampling filter for antialiasing"); - uiDefButF(block, NUM,B_DIFF,"", 624,30,60,20,&G.scene->r.gauss,0.5, 1.5, 100, 2, "Sets the Gaussian filter size)"); + uiDefButF(block, NUM,B_DIFF,"", 624,30,60,20,&G.scene->r.gauss,0.5, 1.5, 100, 2, "Sets the Gaussian filter size"); uiDefButI(block, TOG|BIT|9,REDRAWVIEWCAM, "Border", 564,10,60,20, &G.scene->r.mode, 0, 0, 0, 0, "Render a small cut-out of the image"); - uiDefButI(block, TOG|BIT|2,B_REDR, "Gamma", 624,10,60,20, &G.scene->r.mode, 0, 0, 0, 0, "Enable gamma correction"); + uiDefButI(block, TOG|BIT|2,0, "Gamma", 624,10,60,20, &G.scene->r.mode, 0, 0, 0, 0, "Enable gamma correction"); } diff --git a/source/blender/src/editobject.c b/source/blender/src/editobject.c index 27d319df53b..39a451ae74e 100644 --- a/source/blender/src/editobject.c +++ b/source/blender/src/editobject.c @@ -3229,7 +3229,7 @@ void ob_to_tex_transob(Object *ob, TransOb *tob) if(id==0); else if( GS(id->name)==ID_ME) { me= ob->data; - me->texflag &= ~ME_AUTOSPACE; + me->texflag &= ~AUTOSPACE; tob->loc= me->loc; tob->rot= me->rot; tob->size= me->size; diff --git a/source/blender/src/editsound.c b/source/blender/src/editsound.c index 150a9eca289..2e7a2375ce4 100644 --- a/source/blender/src/editsound.c +++ b/source/blender/src/editsound.c @@ -991,7 +991,7 @@ void sound_init_audio(void) hSystem = SYS_GetSystem(); noaudio = SYS_GetCommandLineInt(hSystem,"noaudio",0); - if (1)/*(noaudio) intrr: disable game engine audio (openal) */ + if (noaudio)/*(noaudio) intrr: disable game engine audio (openal) */ SND_SetDeviceType(snd_e_dummydevice); ghAudioDeviceInterface = SND_GetAudioDevice(); diff --git a/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp b/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp index a70bd6c6f30..490fc56c775 100644 --- a/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp +++ b/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp @@ -53,12 +53,8 @@ #include "KX_PyConstraintBinding.h" #include "RAS_OpenGLRasterizer.h" -#include "RAS_CheckVertexArrays.h" - - -#ifdef WIN32 #include "RAS_VAOpenGLRasterizer.h" -#endif +#include "RAS_GLExtensionManager.h" #include "NG_LoopBackNetworkDeviceInterface.h" #include "SND_DeviceManager.h" @@ -102,6 +98,9 @@ extern "C" void StartKetsjiShell(struct ScrArea *area, strcpy (pathname, maggie->name); STR_String exitstring = ""; BlendFileData *bfd= NULL; + + RAS_GLExtensionManager *extman = new RAS_GLExtensionManager(SYS_GetCommandLineInt(SYS_GetSystem(), "show_extensions", 1)); + extman->LinkExtensions(); do { @@ -121,17 +120,13 @@ extern "C" void StartKetsjiShell(struct ScrArea *area, RAS_IRasterizer* rasterizer = NULL; // let's see if we want to use vertexarrays or not -#ifdef WIN32 int usevta = SYS_GetCommandLineInt(syshandle,"vertexarrays",1); bool useVertexArrays = (usevta > 0); - if (useVertexArrays && RAS_SystemSupportsVertexArrays()) + if (useVertexArrays && extman->QueryVersion(1, 1)) rasterizer = new RAS_VAOpenGLRasterizer(canvas); else rasterizer = new RAS_OpenGLRasterizer(canvas); -#else - rasterizer = new RAS_OpenGLRasterizer(canvas); -#endif // create the inputdevices KX_BlenderKeyboardDevice* keyboarddevice = new KX_BlenderKeyboardDevice(); @@ -374,5 +369,10 @@ extern "C" void StartKetsjiShell(struct ScrArea *area, } } while (exitrequested == KX_EXIT_REQUEST_RESTART_GAME || exitrequested == KX_EXIT_REQUEST_START_OTHER_GAME); + if (extman) + { + delete extman; + extman = NULL; + } if (bfd) BLO_blendfiledata_free(bfd); } diff --git a/source/gameengine/BlenderRoutines/KX_BlenderPolyMaterial.cpp b/source/gameengine/BlenderRoutines/KX_BlenderPolyMaterial.cpp index be87fb0adc2..6d85956172e 100644 --- a/source/gameengine/BlenderRoutines/KX_BlenderPolyMaterial.cpp +++ b/source/gameengine/BlenderRoutines/KX_BlenderPolyMaterial.cpp @@ -88,8 +88,7 @@ void KX_BlenderPolyMaterial::Activate(RAS_IRasterizer* rasty, TCachingInfo& cach rasty->EnableTextures(false); } - //TF_TWOSIDE == 512, todo, make this a ketsji enum - if(m_drawingmode & 512) + if(m_drawingmode & RAS_IRasterizer::KX_TWOSIDE) { rasty->SetCullFace(false); } @@ -97,6 +96,13 @@ void KX_BlenderPolyMaterial::Activate(RAS_IRasterizer* rasty, TCachingInfo& cach { rasty->SetCullFace(true); } + + if (m_drawingmode & RAS_IRasterizer::KX_LINES) { + rasty->SetLines(true); + } + else { + rasty->SetLines(false); + } } rasty->SetSpecularity(m_specular[0],m_specular[1],m_specular[2],m_specularity); diff --git a/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp b/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp index b04ae2a9557..bc3f2ac4035 100644 --- a/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp +++ b/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp @@ -62,6 +62,11 @@ #include "STR_String.h" #include "RAS_BucketManager.h" // for polymaterial (needed for textprinting) +#include "SM_Scene.h" +#include "SumoPhysicsEnvironment.h" +#include "KX_SumoPhysicsController.h" +#include "KX_Scene.h" + KX_BlenderRenderTools::KX_BlenderRenderTools() { } @@ -174,29 +179,32 @@ void KX_BlenderRenderTools::applyTransform(RAS_IRasterizer* rasty,double* oglmat if (objectdrawmode & RAS_IPolyMaterial::SHADOW) { // shadow must be cast to the ground, physics system needed here! - // KX_GameObject* gameobj = (KX_GameObject*) this->m_clientobject; MT_Point3 frompoint(oglmatrix[12],oglmatrix[13],oglmatrix[14]); + KX_GameObject *gameobj = (KX_GameObject*) this->m_clientobject; MT_Vector3 direction = MT_Vector3(0,0,-1); direction.normalize(); direction *= 100000; - // MT_Point3 topoint = frompoint + direction; + MT_Point3 topoint = frompoint + direction; MT_Point3 resultpoint; MT_Vector3 resultnormal; //todo: //use physics abstraction - + KX_Scene* kxscene = (KX_Scene*) m_auxilaryClientInfo; + SumoPhysicsEnvironment *spe = dynamic_cast<SumoPhysicsEnvironment *>( kxscene->GetPhysicsEnvironment()); + SM_Scene *scene = spe->GetSumoScene(); + KX_SumoPhysicsController *spc = dynamic_cast<KX_SumoPhysicsController *>( gameobj->GetPhysicsController()); + KX_GameObject *parent = gameobj->GetParent(); + if (!spc && parent) + spc = dynamic_cast<KX_SumoPhysicsController *>(parent->GetPhysicsController()); + if (parent) + parent->Release(); + SM_Object *thisObj = spc?spc->GetSumoObject():NULL; - //SM_Scene* scene = (SM_Scene*) m_auxilaryClientInfo; - - //SM_Object* hitObj = scene->rayTest(gameobj->GetSumoObject(),frompoint,topoint, - // resultpoint, resultnormal); - - - if (0) //hitObj) + if (scene->rayTest(thisObj, frompoint, topoint, resultpoint, resultnormal)) { MT_Vector3 left(oglmatrix[0],oglmatrix[1],oglmatrix[2]); MT_Vector3 dir = -(left.cross(resultnormal)).normalized(); @@ -204,19 +212,17 @@ void KX_BlenderRenderTools::applyTransform(RAS_IRasterizer* rasty,double* oglmat // for the up vector, we take the 'resultnormal' returned by the physics double maat[16]={ - left[0], left[1],left[2], 0, - dir[0], dir[1],dir[2],0, - resultnormal[0],resultnormal[1],resultnormal[2],0, - 0,0,0,1}; + left[0], left[1], left[2], 0, + dir[0], dir[1], dir[2], 0, + resultnormal[0],resultnormal[1],resultnormal[2], 0, + 0, 0, 0, 1}; glTranslated(resultpoint[0],resultpoint[1],resultpoint[2]); + //glMultMatrixd(oglmatrix); glMultMatrixd(maat); - // glMultMatrixd(oglmatrix); } else { glMultMatrixd(oglmatrix); } - - } else { diff --git a/source/gameengine/BlenderRoutines/Makefile b/source/gameengine/BlenderRoutines/Makefile index 5bc924f642d..7f8cc9d152d 100644 --- a/source/gameengine/BlenderRoutines/Makefile +++ b/source/gameengine/BlenderRoutines/Makefile @@ -39,7 +39,7 @@ include nan_compile.mk CCFLAGS += $(LEVEL_1_CPP_WARNINGS) CPPFLAGS += -I$(OPENGL_HEADERS) -CPPFLAGS += -I$(NAN_SUMO)/include +CPPFLAGS += -I$(NAN_SUMO)/include -I$(NAN_SOLID)/include CPPFLAGS += -I$(NAN_STRING)/include CPPFLAGS += -I$(NAN_MOTO)/include CPPFLAGS += -I$(NAN_BMFONT)/include @@ -65,6 +65,9 @@ CPPFLAGS += -I../SceneGraph CPPFLAGS += -I../../kernel/gen_system CPPFLAGS += -I../Network CPPFLAGS += -I../Network/LoopBackNetwork +CPPFLAGS += -I../Physics/common +CPPFLAGS += -I../Physics/Sumo + ifeq ($(OS),windows) CPPFLAGS += -I../../blender endif diff --git a/source/gameengine/BlenderRoutines/SConscript b/source/gameengine/BlenderRoutines/SConscript index 594f516dc77..bb0b31ac49c 100755 --- a/source/gameengine/BlenderRoutines/SConscript +++ b/source/gameengine/BlenderRoutines/SConscript @@ -1,3 +1,4 @@ +import sys Import ('user_options_dict') Import ('library_env') @@ -33,7 +34,8 @@ kx_blenderhook_env.Append (CPPPATH=['.', '#source/gameengine/Expressions', '#source/gameengine/Network', '#source/gameengine/SceneGraph', - '#source/gameengine/Physics/Sumo/include', + '#source/gameengine/Physics/common', + '#source/gameengine/Physics/Sumo', '#source/gameengine/Physics/Sumo/Fuzzics/include', '#source/gameengine/Network/LoopBackNetwork', '#intern/SoundSystem', @@ -44,4 +46,7 @@ kx_blenderhook_env.Append (CPPPATH=['.', kx_blenderhook_env.Append (CPPPATH = user_options_dict['PYTHON_INCLUDE']) kx_blenderhook_env.Append (CPPPATH = user_options_dict['SOLID_INCLUDE']) +if sys.platform=='win32': + kx_blenderhook_env.Append (CXXFLAGS = ['/GR']) + kx_blenderhook_env.Library (target='#'+user_options_dict['BUILD_DIR']+'/lib/KX_blenderhook', source=source_files) diff --git a/source/gameengine/Converter/BL_ActionActuator.cpp b/source/gameengine/Converter/BL_ActionActuator.cpp index 78967a55ac1..59d7ce16361 100644 --- a/source/gameengine/Converter/BL_ActionActuator.cpp +++ b/source/gameengine/Converter/BL_ActionActuator.cpp @@ -72,8 +72,8 @@ BL_ActionActuator::~BL_ActionActuator() } void BL_ActionActuator::ProcessReplica(){ - bPose *oldpose = m_pose; - bPose *oldbpose = m_blendpose; +// bPose *oldpose = m_pose; +// bPose *oldbpose = m_blendpose; m_pose = NULL; m_blendpose = NULL; @@ -99,7 +99,6 @@ bool BL_ActionActuator::Update(double curtime,double deltatime) { bool bNegativeEvent = false; bool bPositiveEvent = false; - int numevents = m_events.size(); bool keepgoing = true; bool wrap = false; bool apply=true; @@ -114,7 +113,6 @@ bool BL_ActionActuator::Update(double curtime,double deltatime) i--; if ((*i)->GetNumber() == 0.0f) { - int ka=0; bNegativeEvent = true; } else diff --git a/source/gameengine/Converter/BL_ActionActuator.h b/source/gameengine/Converter/BL_ActionActuator.h index 962f807f907..e3708bc6832 100644 --- a/source/gameengine/Converter/BL_ActionActuator.h +++ b/source/gameengine/Converter/BL_ActionActuator.h @@ -51,22 +51,23 @@ public: float stride, PyTypeObject* T=&Type) : SCA_IActuator(gameobj,T), + + m_blendframe(0), + m_lastpos(0, 0, 0), + m_flag(0), m_starttime (starttime), m_endtime(endtime) , m_localtime(starttime), m_lastUpdate(-1), - m_propname(propname), - m_action(action), m_playtype(playtype), - m_flag(0), m_blendin(blendin), - m_blendframe(0), - m_pose(NULL), - m_userpose(NULL), - m_blendpose(NULL), m_priority(priority), m_stridelength(stride), - m_lastpos(0, 0, 0) + m_pose(NULL), + m_blendpose(NULL), + m_userpose(NULL), + m_propname(propname), + m_action(action) { }; virtual ~BL_ActionActuator(); diff --git a/source/gameengine/Converter/BL_ArmatureObject.h b/source/gameengine/Converter/BL_ArmatureObject.h index a438eced5d2..b81a6f0eddd 100644 --- a/source/gameengine/Converter/BL_ArmatureObject.h +++ b/source/gameengine/Converter/BL_ArmatureObject.h @@ -50,9 +50,10 @@ public: struct bArmature *arm, struct bPose *pose) : KX_GameObject(sgReplicationInfo,callbacks), + m_armature(arm), m_pose(pose), m_mrdPose(NULL), - m_armature(arm), + m_lastframe(0.), m_activeAct(NULL), m_activePriority(999) {} diff --git a/source/gameengine/Converter/BL_BlenderDataConversion.cpp b/source/gameengine/Converter/BL_BlenderDataConversion.cpp index c1923bea2d9..0a5b30118a3 100644 --- a/source/gameengine/Converter/BL_BlenderDataConversion.cpp +++ b/source/gameengine/Converter/BL_BlenderDataConversion.cpp @@ -62,7 +62,6 @@ #include "KX_ConvertControllers.h" #include "KX_ConvertSensors.h" -#include "KX_GameObject.h" #include "SCA_LogicManager.h" #include "SCA_EventManager.h" #include "SCA_TimeEventManager.h" @@ -71,6 +70,7 @@ #include "KX_EmptyObject.h" #include "MT_Point3.h" #include "MT_Transform.h" +#include "MT_MinMax.h" #include "SCA_IInputDevice.h" #include "RAS_TexMatrix.h" #include "RAS_ICanvas.h" @@ -175,9 +175,9 @@ static unsigned int KX_Mcol2uint_new(MCol col) unsigned int temp=0; unsigned char *cp= (unsigned char *)&temp; cp[3]=255; - cp[2]= col.r; + cp[0]= col.r; cp[1]= col.g; - cp[0]= col.b; + cp[2]= col.b; return temp; } @@ -580,7 +580,7 @@ void my_tex_space_mesh(Mesh *me) my_boundbox_mesh(me, loc, size); - if(me->texflag & ME_AUTOSPACE) { + if(me->texflag & AUTOSPACE) { if(me->key) { kb= me->key->refkey; if (kb) { @@ -650,9 +650,9 @@ void my_get_local_bounds(Object *ob, float *centre, float *size) size[1]= 0.5*fabs(bb->vec[0][1] - bb->vec[2][1]); size[2]= 0.5*fabs(bb->vec[0][2] - bb->vec[1][2]); - centre[0]= (bb->vec[0][0] + bb->vec[4][0])/2.0; - centre[1]= (bb->vec[0][1] + bb->vec[2][1])/2.0; - centre[2]= (bb->vec[0][2] + bb->vec[1][2])/2.0; + centre[0]= 0.5*(bb->vec[0][0] + bb->vec[4][0]); + centre[1]= 0.5*(bb->vec[0][1] + bb->vec[2][1]); + centre[2]= 0.5*(bb->vec[0][2] + bb->vec[1][2]); } } @@ -699,13 +699,42 @@ void BL_CreatePhysicsObjectNew(KX_GameObject* gameobj, objprop.m_ghost = (blenderobject->gameflag & OB_GHOST) != 0; objprop.m_dynamic_parent=NULL; objprop.m_isdeformable = ((blenderobject->gameflag2 & 2)) != 0; - objprop.m_implicitsphere = false; - objprop.m_implicitbox = false; + objprop.m_boundclass = objprop.m_dyna?KX_BOUNDSPHERE:KX_BOUNDMESH; - if (blenderobject->dtx & OB_BOUNDBOX) + KX_BoxBounds bb; + my_get_local_bounds(blenderobject,objprop.m_boundobject.box.m_center,bb.m_extends); + if (blenderobject->gameflag & OB_BOUNDS) { - objprop.m_implicitsphere = (blenderobject->boundtype == OB_BOUND_SPHERE); - objprop.m_implicitbox = (blenderobject->boundtype == OB_BOUND_BOX); + switch (blenderobject->boundtype) + { + case OB_BOUND_BOX: + objprop.m_boundclass = KX_BOUNDBOX; + //mmm, has to be divided by 2 to be proper extends + objprop.m_boundobject.box.m_extends[0]=2.f*bb.m_extends[0]; + objprop.m_boundobject.box.m_extends[1]=2.f*bb.m_extends[1]; + objprop.m_boundobject.box.m_extends[2]=2.f*bb.m_extends[2]; + break; + case OB_BOUND_SPHERE: + { + objprop.m_boundclass = KX_BOUNDSPHERE; + objprop.m_boundobject.c.m_radius = MT_max(bb.m_extends[0], MT_max(bb.m_extends[1], bb.m_extends[2])); + break; + } + case OB_BOUND_CYLINDER: + { + objprop.m_boundclass = KX_BOUNDCYLINDER; + objprop.m_boundobject.c.m_radius = MT_max(bb.m_extends[0], bb.m_extends[1]); + objprop.m_boundobject.c.m_height = 2.f*bb.m_extends[2]; + break; + } + case OB_BOUND_CONE: + { + objprop.m_boundclass = KX_BOUNDCONE; + objprop.m_boundobject.c.m_radius = MT_max(bb.m_extends[0], bb.m_extends[1]); + objprop.m_boundobject.c.m_height = 2.f*bb.m_extends[2]; + break; + } + } } // get Root Parent of blenderobject @@ -724,13 +753,6 @@ void BL_CreatePhysicsObjectNew(KX_GameObject* gameobj, objprop.m_isactor = (blenderobject->gameflag & OB_ACTOR)!=0; objprop.m_concave = (blenderobject->boundtype & 4) != 0; - - my_get_local_bounds(blenderobject,objprop.m_boundingbox.m_center,objprop.m_boundingbox.m_extends); - //mmm, has to be divided by 2 to be proper extends - objprop.m_boundingbox.m_extends[0]*=2.f; - objprop.m_boundingbox.m_extends[1]*=2.f; - objprop.m_boundingbox.m_extends[2]*=2.f; - switch (physics_engine) { case UseSumo: diff --git a/source/gameengine/Converter/BL_DeformableGameObject.cpp b/source/gameengine/Converter/BL_DeformableGameObject.cpp index 6395dc26617..a17ca6a7c19 100644 --- a/source/gameengine/Converter/BL_DeformableGameObject.cpp +++ b/source/gameengine/Converter/BL_DeformableGameObject.cpp @@ -62,5 +62,4 @@ CValue* BL_DeformableGameObject::GetReplica() ProcessReplica(replica); return replica; - } diff --git a/source/gameengine/Converter/BL_MeshDeformer.cpp b/source/gameengine/Converter/BL_MeshDeformer.cpp index 7608d98dd1f..e9aeb547409 100644 --- a/source/gameengine/Converter/BL_MeshDeformer.cpp +++ b/source/gameengine/Converter/BL_MeshDeformer.cpp @@ -54,7 +54,7 @@ bool BL_MeshDeformer::Apply(RAS_IPolyMaterial *mat) { - int i, j, index; + size_t i, j, index; vecVertexArray array; vecIndexArrays mvarray; vecIndexArrays diarray; diff --git a/source/gameengine/Converter/BL_MeshDeformer.h b/source/gameengine/Converter/BL_MeshDeformer.h index 90b4dd8328c..04e0f3b0628 100644 --- a/source/gameengine/Converter/BL_MeshDeformer.h +++ b/source/gameengine/Converter/BL_MeshDeformer.h @@ -49,11 +49,12 @@ public: void RecalcNormals(); virtual void Relink(GEN_Map<class GEN_HashedPtr, void*>*map){}; BL_MeshDeformer(struct Object* obj, class BL_SkinMeshObject *meshobj): - m_transverts(NULL), - m_tvtot(0), - m_transnors(NULL), m_pMeshObject(meshobj), - m_bmesh((struct Mesh*)(obj->data)){}; + m_bmesh((struct Mesh*)(obj->data)), + m_transnors(NULL), + m_transverts(NULL), + m_tvtot(0) + {}; virtual ~BL_MeshDeformer(); virtual void SetSimulatedTime(double time){}; virtual bool Apply(class RAS_IPolyMaterial *mat); diff --git a/source/gameengine/Converter/BL_SkinDeformer.cpp b/source/gameengine/Converter/BL_SkinDeformer.cpp index f25bf3bf728..4701422a71f 100644 --- a/source/gameengine/Converter/BL_SkinDeformer.cpp +++ b/source/gameengine/Converter/BL_SkinDeformer.cpp @@ -65,7 +65,7 @@ BL_SkinDeformer::~BL_SkinDeformer() bool BL_SkinDeformer::Apply(RAS_IPolyMaterial *mat) { - int i, j, index; + size_t i, j, index; vecVertexArray array; #ifdef __NLA_OLDDEFORM vecMVertArray mvarray; diff --git a/source/gameengine/Converter/BL_SkinDeformer.h b/source/gameengine/Converter/BL_SkinDeformer.h index 97d3d78073c..549f915a285 100644 --- a/source/gameengine/Converter/BL_SkinDeformer.h +++ b/source/gameengine/Converter/BL_SkinDeformer.h @@ -66,8 +66,8 @@ public: class BL_SkinMeshObject *mesh) :BL_MeshDeformer(bmeshobj, mesh), m_armobj(NULL), - m_defbase(&bmeshobj->defbase), - m_lastUpdate(-1) + m_lastUpdate(-1), + m_defbase(&bmeshobj->defbase) { /* Build all precalculatable matrices for bones */ diff --git a/source/gameengine/Converter/BL_SkinMeshObject.cpp b/source/gameengine/Converter/BL_SkinMeshObject.cpp index 98a55662421..2994f424572 100644 --- a/source/gameengine/Converter/BL_SkinMeshObject.cpp +++ b/source/gameengine/Converter/BL_SkinMeshObject.cpp @@ -66,7 +66,7 @@ int BL_SkinMeshObject::FindOrAddDeform(int vtxarray, int mv, struct MDeformVert int numvert = ao->m_MvertArrayCache1[vtxarray]->size(); /* Check to see if this has already been pushed */ - for (int i=0; i<ao->m_MvertArrayCache1[vtxarray]->size(); i++){ + for (size_t i=0; i<ao->m_MvertArrayCache1[vtxarray]->size(); i++){ if (mv == (*ao->m_MvertArrayCache1[vtxarray])[i]) return i; } @@ -84,7 +84,7 @@ int BL_SkinMeshObject::FindVertexArray(int numverts,RAS_IPolyMaterial* polymat) BL_SkinArrayOptimizer* ao = (BL_SkinArrayOptimizer*)GetArrayOptimizer(polymat); - for (int i=0;i<ao->m_VertexArrayCache1.size();i++) + for (size_t i=0;i<ao->m_VertexArrayCache1.size();i++) { if ( (ao->m_TriangleArrayCount[i] + (numverts-2)) < BUCKET_MAX_TRIANGLES) { diff --git a/source/gameengine/Converter/BL_SkinMeshObject.h b/source/gameengine/Converter/BL_SkinMeshObject.h index 40628bd4ee0..c81a667ebdd 100644 --- a/source/gameengine/Converter/BL_SkinMeshObject.h +++ b/source/gameengine/Converter/BL_SkinMeshObject.h @@ -114,7 +114,7 @@ public: int FindVertexArray(int numverts,RAS_IPolyMaterial* polymat); BL_SkinMeshObject(int lightlayer) : RAS_MeshObject (lightlayer) - {}; + { m_class = 1;}; virtual ~BL_SkinMeshObject(){ }; diff --git a/source/gameengine/Converter/KX_BlenderSceneConverter.cpp b/source/gameengine/Converter/KX_BlenderSceneConverter.cpp index 15100cc3a00..4f5804da9b6 100644 --- a/source/gameengine/Converter/KX_BlenderSceneConverter.cpp +++ b/source/gameengine/Converter/KX_BlenderSceneConverter.cpp @@ -34,7 +34,6 @@ #endif #ifdef WIN32 - #pragma warning (disable:4786) // suppress stl-MSVC debug info warning #endif @@ -171,120 +170,92 @@ void KX_BlenderSceneConverter::ConvertScene(const STR_String& scenename, class RAS_IRenderTools* rendertools, class RAS_ICanvas* canvas) { - //find out which physics engine - Scene *blenderscene = GetSceneForName2(m_maggie, scenename); +//find out which physics engine + Scene *blenderscene = GetSceneForName2(m_maggie, scenename); - e_PhysicsEngine physics_engine = UseSumo; + e_PhysicsEngine physics_engine = UseSumo; - if (blenderscene) + /* FIXME: Force physics engine = sumo. + This isn't really a problem - no other physics engines are available. + if (blenderscene) { - int i=0; + int i=0; - if (blenderscene->world) + if (blenderscene->world) { - - switch (blenderscene->world->physicsEngine) + switch (blenderscene->world->physicsEngine) { - - case 1: - { - physics_engine = UseNone; - break; - }; - case 2: - { - physics_engine = UseSumo; - break; - } - case 3: - { - physics_engine = UseODE; - break; - } + case 4: - { - physics_engine = UseDynamo; - break; - } - default: - { - physics_engine = UseODE; - } + { + physics_engine = UseODE; + break; + } + case 3: + { + physics_engine = UseDynamo; + break; + } + case 2: + { + physics_engine = UseSumo; + break; + }; + case 0: + { + physics_engine = UseNone; + } } + } } - - switch (physics_engine) +*/ + switch (physics_engine) { - case UseSumo: - { #ifdef USE_SUMO_SOLID - - PHY_IPhysicsEnvironment* physEnv = - new SumoPhysicsEnvironment(); -#else - physics_engine = UseNone; - - PHY_IPhysicsEnvironment* physEnv = - new DummyPhysicsEnvironment(); - + case UseSumo: + destinationscene ->SetPhysicsEnvironment(new SumoPhysicsEnvironment()); + break; #endif - destinationscene ->SetPhysicsEnvironment(physEnv); - break; - } - case UseODE: - { #ifdef USE_ODE - - PHY_IPhysicsEnvironment* physEnv = - new ODEPhysicsEnvironment(); -#else - PHY_IPhysicsEnvironment* physEnv = - new DummyPhysicsEnvironment(); - + case UseODE: + destinationscene ->SetPhysicsEnvironment(new ODEPhysicsEnvironment()); + break; #endif //USE_ODE - destinationscene ->SetPhysicsEnvironment(physEnv); - break; - } case UseDynamo: - { - } + { + } case UseNone: - { - }; + { + } default: - { - physics_engine = UseNone; - - PHY_IPhysicsEnvironment* physEnv = - new DummyPhysicsEnvironment(); - destinationscene ->SetPhysicsEnvironment(physEnv); - - } + physics_engine = UseNone; + destinationscene ->SetPhysicsEnvironment(new DummyPhysicsEnvironment()); + break; } - BL_ConvertBlenderObjects(m_maggie, - scenename, - destinationscene, - m_ketsjiEngine, - physics_engine, - dictobj, - keyinputdev, - rendertools, - canvas, - this, - m_alwaysUseExpandFraming - ); - - m_map_blender_to_gameactuator.clear(); - m_map_blender_to_gamecontroller.clear(); - - m_map_blender_to_gameobject.clear(); - m_map_mesh_to_gamemesh.clear(); - m_map_gameobject_to_blender.clear(); + BL_ConvertBlenderObjects(m_maggie, + scenename, + destinationscene, + m_ketsjiEngine, + physics_engine, + dictobj, + keyinputdev, + rendertools, + canvas, + this, + m_alwaysUseExpandFraming + ); + + m_map_blender_to_gameactuator.clear(); + m_map_blender_to_gamecontroller.clear(); + + m_map_blender_to_gameobject.clear(); + m_map_mesh_to_gamemesh.clear(); + m_map_gameobject_to_blender.clear(); } diff --git a/source/gameengine/Converter/KX_ConvertActuators.cpp b/source/gameengine/Converter/KX_ConvertActuators.cpp index 0de9ce4bfc3..1b65158e8c0 100644 --- a/source/gameengine/Converter/KX_ConvertActuators.cpp +++ b/source/gameengine/Converter/KX_ConvertActuators.cpp @@ -618,7 +618,7 @@ void BL_ConvertActuators(char* maggiename, case ACT_CONSTRAINT: { float min = 0.0, max = 0.0; - int locrot; + KX_ConstraintActuator::KX_CONSTRAINTTYPE locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_NODEF; bConstraintActuator *conact = (bConstraintActuator*) bact->data; /* convert settings... degrees in the ui become radians */ diff --git a/source/gameengine/Converter/KX_ConvertSensors.cpp b/source/gameengine/Converter/KX_ConvertSensors.cpp index 3ec2c3596e5..525674e1887 100644 --- a/source/gameengine/Converter/KX_ConvertSensors.cpp +++ b/source/gameengine/Converter/KX_ConvertSensors.cpp @@ -297,15 +297,13 @@ void BL_ConvertSensors(struct Object* blenderobject, (blendertouchsensor->name ? blendertouchsensor->name: "")); - //if (gameobj->GetSumoObject()) - //{ - // gamesensor = 0; - //new KX_TouchSensor(eventmgr, - //gameobj, - //gameobj->GetSumoObject(), - //bFindMaterial, - //touchPropOrMatName); - //} + if (gameobj->GetPhysicsController()) + { + gamesensor = new KX_TouchSensor(eventmgr, + gameobj, + bFindMaterial, + touchPropOrMatName); + } } @@ -324,15 +322,13 @@ void BL_ConvertSensors(struct Object* blenderobject, touchpropertyname = (char*) (blendertouchsensor->ma->id.name+2); } bool bFindMaterial = true; - //if (gameobj->GetSumoObject()) - //{ - // gamesensor = 0; - //new KX_TouchSensor(eventmgr, - // gameobj, - // gameobj->GetSumoObject(), - // bFindMaterial, - // touchpropertyname); - //} + if (gameobj->GetPhysicsController()) + { + gamesensor = new KX_TouchSensor(eventmgr, + gameobj, + bFindMaterial, + touchpropertyname); + } } break; } @@ -380,7 +376,7 @@ void BL_ConvertSensors(struct Object* blenderobject, //sumoObj->setMargin(blendernearsensor->dist); //sumoObj->setPosition(gameobj->NodeGetWorldPosition()); bool bFindMaterial = false; - gamesensor = 0;//new KX_NearSensor(eventmgr,gameobj,blendernearsensor->dist,blendernearsensor->resetdist,bFindMaterial,nearpropertyname,kxscene); + gamesensor = new KX_NearSensor(eventmgr,gameobj,blendernearsensor->dist,blendernearsensor->resetdist,bFindMaterial,nearpropertyname,kxscene); } break; @@ -514,7 +510,7 @@ void BL_ConvertSensors(struct Object* blenderobject, case SENS_RADAR: { - /* + SCA_EventManager* eventmgr = logicmgr->FindEventManager(SCA_EventManager::TOUCH_EVENTMGR); if (eventmgr) { @@ -540,14 +536,9 @@ void BL_ConvertSensors(struct Object* blenderobject, //MT_Scalar coneradius = coneheight * (factor / 2); MT_Scalar coneradius = coneheight * factor; - DT_ShapeHandle shape = DT_Cone(coneradius,coneheight); // this sumoObject is not deleted by a gameobj, so delete it ourself // later (memleaks)! - SM_Object* sumoObj = new SM_Object(shape,NULL,NULL,NULL); - sumoObj->setMargin(0.0); - - sumoObj->setPosition(gameobj->NodeGetWorldPosition()); MT_Scalar smallmargin = 0.0; MT_Scalar largemargin = 0.1; @@ -560,13 +551,12 @@ void BL_ConvertSensors(struct Object* blenderobject, radaraxis, smallmargin, largemargin, - sumoObj, bFindMaterial, radarpropertyname, kxscene); } - */ + break; } case SENS_RAY: @@ -586,15 +576,13 @@ void BL_ConvertSensors(struct Object* blenderobject, int axis = blenderraysensor->axisflag; - gamesensor = 0; - /*new KX_RaySensor(eventmgr, + gamesensor = new KX_RaySensor(eventmgr, gameobj, checkname, bFindMaterial, distance, axis, - kxscene->GetSumoScene()); - */ + kxscene); } break; diff --git a/source/gameengine/Converter/Makefile b/source/gameengine/Converter/Makefile index 7340e933a25..0350c86ebc8 100644 --- a/source/gameengine/Converter/Makefile +++ b/source/gameengine/Converter/Makefile @@ -42,7 +42,8 @@ CPPFLAGS += -I$(OPENGL_HEADERS) CPPFLAGS += -I$(NAN_STRING)/include CPPFLAGS += -I$(NAN_SOUNDSYSTEM)/include CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION) -CPPFLAGS += -I$(NAN_FUZZICS)/include -I$(NAN_SUMO)/include -I$(NAN_MOTO)/include +CPPFLAGS += -I$(NAN_FUZZICS)/include -I$(NAN_SUMO) -I$(NAN_MOTO)/include +CPPFLAGS += -I$(NAN_SOLID)/include CPPFLAGS += -I../../blender # these two needed because of blenkernel CPPFLAGS += -I../../blender/imbuf diff --git a/source/gameengine/Converter/SConscript b/source/gameengine/Converter/SConscript index a488ce8e524..315e1be08b9 100755 --- a/source/gameengine/Converter/SConscript +++ b/source/gameengine/Converter/SConscript @@ -50,7 +50,7 @@ kx_converter_env.Append (CPPPATH = ['.', '#source/gameengine/Physics/common', '#source/gameengine/Physics/BlOde', '#source/gameengine/Physics/Dummy', - '#source/gameengine/Physics/Sumo/include', + '#source/gameengine/Physics/Sumo', '#source/gameengine/Physics/Sumo/Fuzzics/include', '#source/gameengine/Network/LoopBackNetwork', '#source/blender/misc', diff --git a/source/gameengine/GameLogic/SCA_AlwaysEventManager.cpp b/source/gameengine/GameLogic/SCA_AlwaysEventManager.cpp index 41b9e45df53..18423c4171f 100644 --- a/source/gameengine/GameLogic/SCA_AlwaysEventManager.cpp +++ b/source/gameengine/GameLogic/SCA_AlwaysEventManager.cpp @@ -45,8 +45,8 @@ using namespace std; SCA_AlwaysEventManager::SCA_AlwaysEventManager(class SCA_LogicManager* logicmgr) - : m_logicmgr(logicmgr), - SCA_EventManager(ALWAYS_EVENTMGR) + : SCA_EventManager(ALWAYS_EVENTMGR), + m_logicmgr(logicmgr) { } diff --git a/source/gameengine/GameLogic/SCA_ISensor.cpp b/source/gameengine/GameLogic/SCA_ISensor.cpp index b95c42b0bae..613a44b09f3 100644 --- a/source/gameengine/GameLogic/SCA_ISensor.cpp +++ b/source/gameengine/GameLogic/SCA_ISensor.cpp @@ -156,6 +156,10 @@ PyMethodDef SCA_ISensor::Methods[] = { METH_VARARGS, GetUseNegPulseMode_doc}, {"setUseNegPulseMode", (PyCFunction) SCA_ISensor::sPySetUseNegPulseMode, METH_VARARGS, SetUseNegPulseMode_doc}, + {"getInvert", (PyCFunction) SCA_ISensor::sPyGetInvert, + METH_VARARGS, GetInvert_doc}, + {"setInvert", (PyCFunction) SCA_ISensor::sPySetInvert, + METH_VARARGS, SetInvert_doc}, {NULL,NULL} //Sentinel }; diff --git a/source/gameengine/GameLogic/SCA_KeyboardManager.cpp b/source/gameengine/GameLogic/SCA_KeyboardManager.cpp index 79dbdbe0dc6..039f0c14801 100644 --- a/source/gameengine/GameLogic/SCA_KeyboardManager.cpp +++ b/source/gameengine/GameLogic/SCA_KeyboardManager.cpp @@ -46,8 +46,8 @@ SCA_KeyboardManager::SCA_KeyboardManager(SCA_LogicManager* logicmgr, SCA_IInputDevice* inputdev) : SCA_EventManager(KEYBOARD_EVENTMGR), - m_logicmanager(logicmgr), - m_inputDevice(inputdev) + m_inputDevice(inputdev), + m_logicmanager(logicmgr) { } @@ -70,7 +70,7 @@ void SCA_KeyboardManager::NextFrame(double curtime,double deltatime) { //const SCA_InputEvent& event = GetEventValue(SCA_IInputDevice::KX_EnumInputs inputcode)=0; // cerr << "SCA_KeyboardManager::NextFrame"<< endl; - for (int i=0;i<m_sensors.size();i++) + for (unsigned int i=0;i<m_sensors.size();i++) { SCA_KeyboardSensor* keysensor = (SCA_KeyboardSensor*)m_sensors[i]; keysensor->Activate(m_logicmanager,NULL); diff --git a/source/gameengine/GameLogic/SCA_LogicManager.cpp b/source/gameengine/GameLogic/SCA_LogicManager.cpp index f33b73199ce..62b532ee5a0 100644 --- a/source/gameengine/GameLogic/SCA_LogicManager.cpp +++ b/source/gameengine/GameLogic/SCA_LogicManager.cpp @@ -50,13 +50,6 @@ SCA_LogicManager::SCA_LogicManager() SCA_LogicManager::~SCA_LogicManager() { - for (vector<SCA_EventManager*>::iterator it = m_eventmanagers.begin();!(it==m_eventmanagers.end());it++) - { - delete (*it); - } - m_eventmanagers.clear(); - m_sensorcontrollermapje.clear(); - int numgameobj = m_mapStringToGameObjects.size(); for (int i = 0; i < numgameobj; i++) { @@ -73,6 +66,12 @@ SCA_LogicManager::~SCA_LogicManager() delete controllerarray; } */ + for (vector<SCA_EventManager*>::iterator it = m_eventmanagers.begin();!(it==m_eventmanagers.end());it++) + { + delete (*it); + } + m_eventmanagers.clear(); + m_sensorcontrollermapje.clear(); } diff --git a/source/gameengine/GameLogic/SCA_MouseManager.cpp b/source/gameengine/GameLogic/SCA_MouseManager.cpp index 8d968e0e54d..96abe2c9135 100644 --- a/source/gameengine/GameLogic/SCA_MouseManager.cpp +++ b/source/gameengine/GameLogic/SCA_MouseManager.cpp @@ -52,8 +52,8 @@ SCA_MouseManager::SCA_MouseManager(SCA_LogicManager* logicmgr, SCA_IInputDevice* mousedev) : SCA_EventManager(MOUSE_EVENTMGR), - m_logicmanager(logicmgr), - m_mousedevice (mousedev) + m_mousedevice (mousedev), + m_logicmanager(logicmgr) { m_xpos = 0; m_ypos = 0; @@ -78,7 +78,7 @@ void SCA_MouseManager::NextFrame(double curtime,double deltatime) { if (m_mousedevice) { - for (int i = 0; i < m_sensors.size(); i++) + for (unsigned int i = 0; i < m_sensors.size(); i++) { SCA_MouseSensor* mousesensor = (SCA_MouseSensor*) m_sensors[i]; // (0,0) is the Upper Left corner in our local window diff --git a/source/gameengine/GameLogic/SCA_PropertyActuator.cpp b/source/gameengine/GameLogic/SCA_PropertyActuator.cpp index dfb6e3f644b..e4820e00f70 100644 --- a/source/gameengine/GameLogic/SCA_PropertyActuator.cpp +++ b/source/gameengine/GameLogic/SCA_PropertyActuator.cpp @@ -46,11 +46,11 @@ /* ------------------------------------------------------------------------- */ SCA_PropertyActuator::SCA_PropertyActuator(SCA_IObject* gameobj,CValue* sourceObj,const STR_String& propname,const STR_String& expr,int acttype,PyTypeObject* T ) -: SCA_IActuator(gameobj,T), -m_propname(propname), -m_exprtxt(expr), -m_type(acttype), -m_sourceObj(sourceObj) + : SCA_IActuator(gameobj,T), + m_type(acttype), + m_propname(propname), + m_exprtxt(expr), + m_sourceObj(sourceObj) { } diff --git a/source/gameengine/GameLogic/SCA_PropertySensor.cpp b/source/gameengine/GameLogic/SCA_PropertySensor.cpp index 6fceddcb5f8..448de107381 100644 --- a/source/gameengine/GameLogic/SCA_PropertySensor.cpp +++ b/source/gameengine/GameLogic/SCA_PropertySensor.cpp @@ -53,12 +53,12 @@ SCA_PropertySensor::SCA_PropertySensor(SCA_EventManager* eventmgr, KX_PROPSENSOR_TYPE checktype, PyTypeObject* T ) : SCA_ISensor(gameobj,eventmgr,T), - m_checkpropname(propname), + m_checktype(checktype), m_checkpropval(propval), m_checkpropmaxval(propmaxval), - m_checktype(checktype), - m_range_expr(NULL), - m_lastresult(false) + m_checkpropname(propname), + m_lastresult(false), + m_range_expr(NULL) { m_recentresult=false; //CParser pars; diff --git a/source/gameengine/GameLogic/SCA_PythonController.cpp b/source/gameengine/GameLogic/SCA_PythonController.cpp index 0d2f74c14cc..a96e17e67d2 100644 --- a/source/gameengine/GameLogic/SCA_PythonController.cpp +++ b/source/gameengine/GameLogic/SCA_PythonController.cpp @@ -50,9 +50,9 @@ SCA_PythonController* SCA_PythonController::m_sCurrentController = NULL; SCA_PythonController::SCA_PythonController(SCA_IObject* gameobj, PyTypeObject* T) : SCA_IController(gameobj, T), - m_pythondictionary(NULL), m_bytecode(NULL), - m_bModified(true) + m_bModified(true), + m_pythondictionary(NULL) { } @@ -285,10 +285,8 @@ PyObject* SCA_PythonController::PyGetActuators(PyObject* self, PyObject* args, PyObject* kwds) { - int index; - PyObject* resultlist = PyList_New(m_linkedactuators.size()); - for (index=0;index<m_linkedactuators.size();index++) + for (unsigned int index=0;index<m_linkedactuators.size();index++) { PyList_SetItem(resultlist,index,m_linkedactuators[index]->AddRef()); } @@ -310,8 +308,7 @@ SCA_PythonController::PyGetSensor(PyObject* self, return NULL; } - int index; - for (index=0;index<m_linkedsensors.size();index++) + for (unsigned int index=0;index<m_linkedsensors.size();index++) { SCA_ISensor* sensor = m_linkedsensors[index]; STR_String realname = sensor->GetName(); @@ -341,8 +338,7 @@ SCA_PythonController::PyGetActuator(PyObject* self, return NULL; } - int index; - for (index=0;index<m_linkedactuators.size();index++) + for (unsigned int index=0;index<m_linkedactuators.size();index++) { SCA_IActuator* actua = m_linkedactuators[index]; STR_String realname = actua->GetName(); @@ -363,10 +359,8 @@ SCA_PythonController::PyGetSensors(PyObject* self, PyObject* args, PyObject* kwds) { - int index; - PyObject* resultlist = PyList_New(m_linkedsensors.size()); - for (index=0;index<m_linkedsensors.size();index++) + for (unsigned int index=0;index<m_linkedsensors.size();index++) { PyList_SetItem(resultlist,index,m_linkedsensors[index]->AddRef()); } diff --git a/source/gameengine/GameLogic/SCA_RandomActuator.cpp b/source/gameengine/GameLogic/SCA_RandomActuator.cpp index 350b2f58b06..4347e5cef67 100644 --- a/source/gameengine/GameLogic/SCA_RandomActuator.cpp +++ b/source/gameengine/GameLogic/SCA_RandomActuator.cpp @@ -56,10 +56,10 @@ SCA_RandomActuator::SCA_RandomActuator(SCA_IObject *gameobj, const STR_String &propName, PyTypeObject* T) : SCA_IActuator(gameobj, T), - m_distribution(mode), m_propname(propName), m_parameter1(para1), - m_parameter2(para2) + m_parameter2(para2), + m_distribution(mode) { m_base = new SCA_RandomNumberGenerator(seed); m_counter = 0; @@ -94,7 +94,7 @@ bool SCA_RandomActuator::Update(double curtime,double deltatime) RemoveAllEvents(); - CValue *tmpval; + CValue *tmpval = NULL; if (bNegativeEvent) return false; // do nothing on negative events @@ -241,7 +241,15 @@ bool SCA_RandomActuator::Update(double curtime,double deltatime) } break; default: - ; /* unknown distribution... */ + { + /* unknown distribution... */ + static bool randomWarning = false; + if (!randomWarning) { + randomWarning = true; + std::cout << "RandomActuator '" << GetName() << "' has an unknown distribution." << std::endl; + } + return false; + } } /* Round up: assign it */ diff --git a/source/gameengine/GameLogic/SCA_RandomEventManager.cpp b/source/gameengine/GameLogic/SCA_RandomEventManager.cpp index ee517e5b915..17cfa351994 100644 --- a/source/gameengine/GameLogic/SCA_RandomEventManager.cpp +++ b/source/gameengine/GameLogic/SCA_RandomEventManager.cpp @@ -45,8 +45,8 @@ using namespace std; #endif SCA_RandomEventManager::SCA_RandomEventManager(class SCA_LogicManager* logicmgr) - : m_logicmgr(logicmgr), - SCA_EventManager(RANDOM_EVENTMGR) + : SCA_EventManager(RANDOM_EVENTMGR), + m_logicmgr(logicmgr) { } diff --git a/source/gameengine/GamePlayer/common/GPC_Engine.cpp b/source/gameengine/GamePlayer/common/GPC_Engine.cpp index a9a099bf070..7316c62f88e 100644 --- a/source/gameengine/GamePlayer/common/GPC_Engine.cpp +++ b/source/gameengine/GamePlayer/common/GPC_Engine.cpp @@ -245,13 +245,13 @@ float GPC_Engine::DetermineProgress(void) void GPC_Engine::UpdateLoadingAnimation(void) { - int delta; + //int delta; float progress = DetermineProgress(); if(progress > m_previousProgress) { - delta = progress - m_previousProgress; +// delta = progress - m_previousProgress; m_previousProgress = progress; if(m_previousProgress > 1.0) m_previousProgress = 1.0; // limit to 1.0 (has to change !) diff --git a/source/gameengine/GamePlayer/common/GPC_PolygonMaterial.cpp b/source/gameengine/GamePlayer/common/GPC_PolygonMaterial.cpp index df34afac615..26b4926ec97 100644 --- a/source/gameengine/GamePlayer/common/GPC_PolygonMaterial.cpp +++ b/source/gameengine/GamePlayer/common/GPC_PolygonMaterial.cpp @@ -324,14 +324,14 @@ int my_set_tpage(TFace *tface) if (!fDoMipMap) { - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, rectw, recth, 0, GL_RGBA, GL_UNSIGNED_BYTE, rect); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, rectw, recth, 0, GL_RGBA, GL_UNSIGNED_BYTE, rect); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } else { int minfilter= fLinearMipMap?GL_LINEAR_MIPMAP_LINEAR:GL_LINEAR_MIPMAP_NEAREST; - gluBuild2DMipmaps(GL_TEXTURE_2D, 4, rectw, recth, GL_RGBA, GL_UNSIGNED_BYTE, rect); + gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, rectw, recth, GL_RGBA, GL_UNSIGNED_BYTE, rect); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minfilter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } diff --git a/source/gameengine/GamePlayer/common/GPC_RenderTools.cpp b/source/gameengine/GamePlayer/common/GPC_RenderTools.cpp index 2c455f44b72..3a7520861f9 100644 --- a/source/gameengine/GamePlayer/common/GPC_RenderTools.cpp +++ b/source/gameengine/GamePlayer/common/GPC_RenderTools.cpp @@ -94,6 +94,11 @@ #include "IMB_imbuf_types.h" // End of Blender includes +#include "SM_Scene.h" +#include "SumoPhysicsEnvironment.h" +#include "KX_SumoPhysicsController.h" +#include "KX_Scene.h" + GPC_RenderTools::GPC_RenderTools() { @@ -454,8 +459,8 @@ void GPC_RenderTools::applyTransform(RAS_IRasterizer* rasty,double* oglmatrix,in if (objectdrawmode & RAS_IPolyMaterial::SHADOW) { // shadow must be cast to the ground, physics system needed here! - KX_GameObject* gameobj = (KX_GameObject*) this->m_clientobject; MT_Point3 frompoint(oglmatrix[12],oglmatrix[13],oglmatrix[14]); + KX_GameObject *gameobj = (KX_GameObject*) this->m_clientobject; MT_Vector3 direction = MT_Vector3(0,0,-1); @@ -466,16 +471,20 @@ void GPC_RenderTools::applyTransform(RAS_IRasterizer* rasty,double* oglmatrix,in MT_Point3 resultpoint; MT_Vector3 resultnormal; - //todo: replace by physicsenvironment raycast - - //SM_Scene* scene = (SM_Scene*) m_auxilaryClientInfo; - - SM_Object* hitObj = 0; - //scene->rayTest(gameobj->GetSumoObject(),frompoint,topoint, - // resultpoint, resultnormal); - + //todo: + //use physics abstraction + KX_Scene* kxscene = (KX_Scene*) m_auxilaryClientInfo; + SumoPhysicsEnvironment *spe = dynamic_cast<SumoPhysicsEnvironment *>( kxscene->GetPhysicsEnvironment()); + SM_Scene *scene = spe->GetSumoScene(); + KX_SumoPhysicsController *spc = dynamic_cast<KX_SumoPhysicsController *>( gameobj->GetPhysicsController()); + KX_GameObject *parent = gameobj->GetParent(); + if (!spc && parent) + spc = dynamic_cast<KX_SumoPhysicsController *>(parent->GetPhysicsController()); + if (parent) + parent->Release(); + SM_Object *thisObj = spc?spc->GetSumoObject():NULL; - if (hitObj) + if (scene->rayTest(thisObj, frompoint, topoint, resultpoint, resultnormal)) { MT_Vector3 left(oglmatrix[0],oglmatrix[1],oglmatrix[2]); MT_Vector3 dir = -(left.cross(resultnormal)).normalized(); @@ -483,19 +492,17 @@ void GPC_RenderTools::applyTransform(RAS_IRasterizer* rasty,double* oglmatrix,in // for the up vector, we take the 'resultnormal' returned by the physics double maat[16]={ - left[0], left[1],left[2], 0, - dir[0], dir[1],dir[2],0, - resultnormal[0],resultnormal[1],resultnormal[2],0, - 0,0,0,1}; + left[0], left[1], left[2], 0, + dir[0], dir[1], dir[2], 0, + resultnormal[0],resultnormal[1],resultnormal[2], 0, + 0, 0, 0, 1}; glTranslated(resultpoint[0],resultpoint[1],resultpoint[2]); + //glMultMatrixd(oglmatrix); glMultMatrixd(maat); - // glMultMatrixd(oglmatrix); } else { glMultMatrixd(oglmatrix); } - - } else { diff --git a/source/gameengine/GamePlayer/common/Makefile b/source/gameengine/GamePlayer/common/Makefile index 535c2efebcb..d10c1f059e0 100644 --- a/source/gameengine/GamePlayer/common/Makefile +++ b/source/gameengine/GamePlayer/common/Makefile @@ -52,6 +52,7 @@ CPPFLAGS += -I$(NAN_FUZZICS)/include CPPFLAGS += -I$(NAN_STRING)/include CPPFLAGS += -I$(NAN_MOTO)/include CPPFLAGS += -I$(NAN_SUMO)/include +CPPFLAGS += -I$(NAN_SOLID)/include CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION) CPPFLAGS += -I$(NAN_BMFONT)/include @@ -67,6 +68,8 @@ CPPFLAGS += -I../../../gameengine/Network/LoopBackNetwork CPPFLAGS += -I../../../gameengine/Rasterizer CPPFLAGS += -I../../../gameengine/SceneGraph CPPFLAGS += -I../../../gameengine/Rasterizer/RAS_OpenGLRasterizer +CPPFLAGS += -I../../../gameengine/Physics/Sumo +CPPFLAGS += -I../../../gameengine/Physics/common ############################### diff --git a/source/gameengine/GamePlayer/ghost/GPG_Application.cpp b/source/gameengine/GamePlayer/ghost/GPG_Application.cpp index 17e9e77b5d3..8aedb666c87 100644 --- a/source/gameengine/GamePlayer/ghost/GPG_Application.cpp +++ b/source/gameengine/GamePlayer/ghost/GPG_Application.cpp @@ -153,6 +153,7 @@ bool GPG_Application::startWindow(STR_String& title, * so that the client rectangle has the size requested. */ m_mainWindow->setClientSize(windowWidth, windowHeight); + m_mainWindow->setCursorVisibility(false); success = initEngine(m_mainWindow, stereoMode); if (success) { @@ -179,6 +180,7 @@ bool GPG_Application::startFullScreen( setting.frequency = frequency; fSystem->beginFullScreen(setting, &m_mainWindow, stereoVisual); + m_mainWindow->setCursorVisibility(false); success = initEngine(m_mainWindow, stereoMode); if (success) { diff --git a/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp b/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp index 1d631a6f740..253a7e47b2d 100644 --- a/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp +++ b/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp @@ -81,6 +81,7 @@ extern "C" #include "RAS_IRasterizer.h" #include "BKE_main.h" +#include "BKE_utildefines.h" #ifdef WIN32 #ifdef NDEBUG @@ -92,6 +93,8 @@ extern "C" const int kMinWindowWidth = 100; const int kMinWindowHeight = 100; +char bprogname[FILE_MAXDIR+FILE_MAXFILE]; + void usage(char* program) { char * consoleoption; @@ -101,18 +104,19 @@ void usage(char* program) consoleoption = ""; #endif - printf("usage: %s [-p l t w h] [-f fw fh fb ff] %s[-g gamengineoptions] " + printf("usage: %s -w [-p l t w h] %s[-g gamengineoptions] " "-s stereomode filename.blend\n", program, consoleoption); + printf(" -w: display in a window\n"); printf(" -p: specify window position\n"); printf(" l = window left coordinate\n"); printf(" t = window top coordinate\n"); printf(" w = window width\n"); printf(" h = window height\n"); - printf(" -f: start game in full screen mode\n"); +/* printf(" -f: start game in full screen mode\n"); printf(" fw = full screen mode pixel width\n"); printf(" fh = full screen mode pixel height\n"); printf(" fb = full screen mode bits per pixel\n"); - printf(" ff = full screen mode frequency\n"); + printf(" ff = full screen mode frequency\n"); */ printf(" -s: start player in stereo\n"); printf(" stereomode = hwpageflip or syncdoubling depending on the type of stereo you want\n"); #ifdef _WIN32 @@ -204,8 +208,8 @@ int main(int argc, char** argv) int i; bool error = false; SYS_SystemHandle syshandle = SYS_GetSystem(); - bool fullScreen = false; - bool fullScreenParFound = false; + bool fullScreen = true; + bool fullScreenParFound = true; bool windowParFound = false; bool closeConsole = true; int stereomode = RAS_IRasterizer::RAS_STEREO_NOSTEREO; @@ -215,8 +219,8 @@ int main(int argc, char** argv) int windowTop = 100; int windowWidth = 640; int windowHeight = 480; - int fullScreenWidth = 640; - int fullScreenHeight= 480; + GHOST_TUns32 fullScreenWidth = 0; + GHOST_TUns32 fullScreenHeight= 0; int fullScreenBpp = 16; int fullScreenFrequency = 60; @@ -225,6 +229,7 @@ int main(int argc, char** argv) signal (SIGFPE, SIG_IGN); #endif /* __alpha__ */ #endif /* __linux__ */ + BLI_where_am_i(bprogname, argv[0]); #ifdef __APPLE__ // Can't use Carbon right now because of double defined type ID (In Carbon.h and DNA_ID.h, sigh) @@ -315,24 +320,12 @@ int main(int argc, char** argv) } break; - case 'f': + case 'w': // Parse window position and size options { - fullScreen = true; - i++; - if ((i + 4) < argc) - { - fullScreenWidth = atoi(argv[i++]); - fullScreenHeight = atoi(argv[i++]); - fullScreenBpp = atoi(argv[i++]); - fullScreenFrequency = atoi(argv[i]); + fullScreen = false; fullScreenParFound = true; - } - else - { - error = true; - printf("error: too few options for fullscreen argument.\n"); - } + i++; } break; case 'c': @@ -403,6 +396,7 @@ int main(int argc, char** argv) GHOST_ISystem* system = GHOST_ISystem::getSystem(); assertd(system); + system->getMainDisplayDimensions(fullScreenWidth, fullScreenHeight); // process first batch of events. If the user // drops a file on top off the blenderplayer icon, we // recieve an event with the filename @@ -570,7 +564,7 @@ int main(int argc, char** argv) bool run = true; while (run) { - system->processEvents(true); + system->processEvents(false); system->dispatchEvents(); if (exitcode = app.getExitRequested()) { diff --git a/source/gameengine/Ketsji/KX_Camera.cpp b/source/gameengine/Ketsji/KX_Camera.cpp index 6b669bcd936..69bf4dd69ce 100644 --- a/source/gameengine/Ketsji/KX_Camera.cpp +++ b/source/gameengine/Ketsji/KX_Camera.cpp @@ -64,7 +64,7 @@ MT_Transform KX_Camera::GetWorldToCamera() const trans.setBasis(NodeGetWorldOrientation()); trans.setOrigin(NodeGetWorldPosition()); - + camtrans.invert(trans); return camtrans; @@ -95,8 +95,8 @@ const MT_Point3 KX_Camera::GetCameraLocation() //return m_trans1.getOrigin(); //return MT_Point3(0,0,0); <----- /* .... I want it in world coords */ - MT_Transform trans; - trans.setBasis(NodeGetWorldOrientation()); + //MT_Transform trans; + //trans.setBasis(NodeGetWorldOrientation()); return NodeGetWorldPosition(); } diff --git a/source/gameengine/Ketsji/KX_CameraActuator.cpp b/source/gameengine/Ketsji/KX_CameraActuator.cpp index df61aaf5243..f1286de1bd4 100644 --- a/source/gameengine/Ketsji/KX_CameraActuator.cpp +++ b/source/gameengine/Ketsji/KX_CameraActuator.cpp @@ -183,8 +183,6 @@ bool KX_CameraActuator::Update(double curtime,double deltatime) MT_Point3 lookat = ((KX_GameObject*)m_ob)->NodeGetWorldPosition(); MT_Matrix3x3 actormat = ((KX_GameObject*)m_ob)->NodeGetWorldOrientation(); - - float fp1[3], fp2[3], rc[3]; float inp, fac; //, factor = 0.0; /* some factor... */ float mindistsq, maxdistsq, distsq; diff --git a/source/gameengine/Ketsji/KX_CameraIpoSGController.h b/source/gameengine/Ketsji/KX_CameraIpoSGController.h index 029aa6d7156..d80847fa5fb 100644 --- a/source/gameengine/Ketsji/KX_CameraIpoSGController.h +++ b/source/gameengine/Ketsji/KX_CameraIpoSGController.h @@ -55,11 +55,12 @@ private: double m_ipotime; public: - KX_CameraIpoSGController() : m_ipotime(0.0), - m_modify_lens(false), - m_modify_clipstart(false), - m_modify_clipend(false), - m_modified(true) + KX_CameraIpoSGController() : + m_modify_lens(false), + m_modify_clipstart(false), + m_modify_clipend(false), + m_modified(true), + m_ipotime(0.0) {} ~KX_CameraIpoSGController(); diff --git a/source/gameengine/Ketsji/KX_ClientObjectInfo.h b/source/gameengine/Ketsji/KX_ClientObjectInfo.h index 0981463ed44..51cb19e8935 100644 --- a/source/gameengine/Ketsji/KX_ClientObjectInfo.h +++ b/source/gameengine/Ketsji/KX_ClientObjectInfo.h @@ -35,12 +35,21 @@ /** * Client Type and Additional Info. This structure can be use instead of a bare void* pointer, for safeness, and additional info for callbacks */ - struct KX_ClientObjectInfo { - int m_type; + enum { + STATIC, + ACTOR, + RESERVED1, + RADAR, + NEAR + } m_type; void* m_clientobject; void* m_auxilary_info; +public: + KX_ClientObjectInfo(void *clientobject) : + m_clientobject(clientobject) + {} }; #endif //__KX_CLIENTOBJECT_INFO_H diff --git a/source/gameengine/Ketsji/KX_ConstraintWrapper.cpp b/source/gameengine/Ketsji/KX_ConstraintWrapper.cpp index 04bec5cb37c..e42ae59e2bb 100644 --- a/source/gameengine/Ketsji/KX_ConstraintWrapper.cpp +++ b/source/gameengine/Ketsji/KX_ConstraintWrapper.cpp @@ -40,8 +40,11 @@ KX_ConstraintWrapper::KX_ConstraintWrapper( PHY_ConstraintType ctype, int constraintId, - PHY_IPhysicsEnvironment* physenv,PyTypeObject *T) -: m_constraintType(ctype),m_constraintId(constraintId),m_physenv(physenv),PyObjectPlus(T) + PHY_IPhysicsEnvironment* physenv,PyTypeObject *T) : + PyObjectPlus(T), + m_constraintId(constraintId), + m_constraintType(ctype), + m_physenv(physenv) { } KX_ConstraintWrapper::~KX_ConstraintWrapper() diff --git a/source/gameengine/Ketsji/KX_ConvertPhysicsObject.h b/source/gameengine/Ketsji/KX_ConvertPhysicsObject.h index bf40baf5594..3ed3e2bfa8f 100644 --- a/source/gameengine/Ketsji/KX_ConvertPhysicsObject.h +++ b/source/gameengine/Ketsji/KX_ConvertPhysicsObject.h @@ -32,22 +32,35 @@ #ifndef KX_CONVERTPHYSICSOBJECTS #define KX_CONVERTPHYSICSOBJECTS - +/* These are defined by the build system... */ //#define USE_SUMO_SOLID -//solid is not available yet - -#define USE_ODE +//#define USE_ODE class RAS_MeshObject; class KX_Scene; +typedef enum { + KX_BOUNDBOX, + KX_BOUNDSPHERE, + KX_BOUNDCYLINDER, + KX_BOUNDCONE, + KX_BOUNDMESH +} KX_BoundBoxClass; -struct KX_Bounds +struct KX_BoxBounds { float m_center[3]; float m_extends[3]; }; +/* Cone/Cylinder */ +struct KX_CBounds +{ + float m_radius; + float m_height; +}; + + struct KX_ObjectProperties { bool m_dyna; @@ -59,9 +72,11 @@ struct KX_ObjectProperties bool m_isactor; bool m_concave; bool m_isdeformable; - bool m_implicitsphere ; - bool m_implicitbox; - KX_Bounds m_boundingbox; + KX_BoundBoxClass m_boundclass; + union { + KX_BoxBounds box; + KX_CBounds c; + } m_boundobject; }; #ifdef USE_ODE diff --git a/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp b/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp index a6e7daadb2c..96716214edc 100644 --- a/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp +++ b/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp @@ -29,7 +29,9 @@ * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ +#ifdef WIN32 #pragma warning (disable : 4786) +#endif // defines USE_ODE to choose physics engine #include "KX_ConvertPhysicsObject.h" @@ -63,7 +65,6 @@ // USE_SUMO_SOLID is defined in headerfile KX_ConvertPhysicsObject.h #ifdef USE_SUMO_SOLID - #include "SumoPhysicsEnvironment.h" #include "KX_SumoPhysicsController.h" @@ -83,16 +84,15 @@ void BL_RegisterSumoObject(KX_GameObject* gameobj,class SM_Scene* sumoScene,DT_S DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj); -void KX_ConvertSumoObject( class KX_GameObject* gameobj, - class RAS_MeshObject* meshobj, - class KX_Scene* kxscene, - PHY_ShapeProps* kxshapeprops, - PHY_MaterialProps* kxmaterial, - struct KX_ObjectProperties* objprop) +void KX_ConvertSumoObject( KX_GameObject* gameobj, + RAS_MeshObject* meshobj, + KX_Scene* kxscene, + PHY_ShapeProps* kxshapeprops, + PHY_MaterialProps* kxmaterial, + struct KX_ObjectProperties* objprop) { - SM_ShapeProps* smprop = new SM_ShapeProps; smprop->m_ang_drag = kxshapeprops->m_ang_drag; @@ -105,6 +105,7 @@ void KX_ConvertSumoObject( class KX_GameObject* gameobj, smprop->m_inertia = kxshapeprops->m_inertia; smprop->m_lin_drag = kxshapeprops->m_lin_drag; smprop->m_mass = kxshapeprops->m_mass; + smprop->m_radius = objprop->m_radius; SM_MaterialProps* smmaterial = new SM_MaterialProps; @@ -116,55 +117,48 @@ void KX_ConvertSumoObject( class KX_GameObject* gameobj, smmaterial->m_friction = kxmaterial->m_friction; smmaterial->m_restitution = kxmaterial->m_restitution; - class SumoPhysicsEnvironment* sumoEnv = + SumoPhysicsEnvironment* sumoEnv = (SumoPhysicsEnvironment*)kxscene->GetPhysicsEnvironment(); SM_Scene* sceneptr = sumoEnv->GetSumoScene(); - - SM_Object* sumoObj=NULL; if (objprop->m_dyna) { - - DT_ShapeHandle shape = DT_Sphere(0.0); - - if (objprop->m_ghost) + DT_ShapeHandle shape = NULL; + switch (objprop->m_boundclass) { - - sumoObj = new SM_Object(shape,NULL,smprop,NULL); - } else - { - sumoObj = new SM_Object(shape,smmaterial,smprop,NULL); + case KX_BOUNDBOX: + shape = DT_NewBox(objprop->m_boundobject.box.m_extends[0], objprop->m_boundobject.box.m_extends[1], objprop->m_boundobject.box.m_extends[2]); + break; + case KX_BOUNDCYLINDER: + shape = DT_NewCylinder(objprop->m_radius, objprop->m_boundobject.c.m_height); + break; + case KX_BOUNDCONE: + shape = DT_NewCone(objprop->m_radius, objprop->m_boundobject.c.m_height); + break; +/* Enabling this allows you to use dynamic mesh objects. It's disabled 'cause it's really slow. */ + case KX_BOUNDMESH: + if (meshobj && meshobj->NumPolygons() > 0) + { + if ((shape = CreateShapeFromMesh(meshobj))) + break; + } + /* If CreateShapeFromMesh fails, fall through and use sphere */ + default: + case KX_BOUNDSPHERE: + shape = DT_NewSphere(objprop->m_radius); + break; + } - double radius = objprop->m_radius; + sumoObj = new SM_Object(shape, !objprop->m_ghost?smmaterial:NULL,smprop,NULL); - MT_Scalar margin = radius;//0.5; - sumoObj->setMargin(margin); + sumoObj->setRigidBody(objprop->m_angular_rigidbody?true:false); - //if (bRigidBody) - //{ - if (objprop->m_in_active_layer) - { - DT_AddObject(sumoEnv->GetSolidScene(), - sumoObj->getObjectHandle()); - } - //} - - if (objprop->m_angular_rigidbody) - { - sumoObj->setRigidBody(true); - } else - { - sumoObj->setRigidBody(false); - } - - bool isDynamic = true; - bool isActor = true; - - BL_RegisterSumoObject(gameobj,sceneptr,sumoEnv->GetSolidScene(),sumoObj,NULL,isDynamic,isActor); + objprop->m_isactor = objprop->m_dyna = true; + BL_RegisterSumoObject(gameobj,sceneptr,sumoEnv->GetSolidScene(),sumoObj,NULL,true, true); } else { @@ -172,20 +166,40 @@ void KX_ConvertSumoObject( class KX_GameObject* gameobj, if (meshobj) { int numpolys = meshobj->NumPolygons(); - { DT_ShapeHandle complexshape=0; - if (objprop->m_implicitbox) - { - complexshape = DT_Box(objprop->m_boundingbox.m_extends[0],objprop->m_boundingbox.m_extends[1],objprop->m_boundingbox.m_extends[2]); - } else + switch (objprop->m_boundclass) { - if (numpolys>0) - { - complexshape = CreateShapeFromMesh(meshobj); - } + case KX_BOUNDBOX: + complexshape = DT_NewBox(objprop->m_boundobject.box.m_extends[0], objprop->m_boundobject.box.m_extends[1], objprop->m_boundobject.box.m_extends[2]); + break; + case KX_BOUNDSPHERE: + complexshape = DT_NewSphere(objprop->m_boundobject.c.m_radius); + break; + case KX_BOUNDCYLINDER: + complexshape = DT_NewCylinder(objprop->m_boundobject.c.m_radius, objprop->m_boundobject.c.m_height); + break; + case KX_BOUNDCONE: + complexshape = DT_NewCone(objprop->m_boundobject.c.m_radius, objprop->m_boundobject.c.m_height); + break; + default: + case KX_BOUNDMESH: + if (numpolys>0) + { + complexshape = CreateShapeFromMesh(meshobj); + //std::cout << "Convert Physics Mesh: " << meshobj->GetName() << std::endl; +/* if (!complexshape) + { + // Something has to be done here - if the object has no polygons, it will not be able to have + // sensors attached to it. + DT_Vector3 pt = {0., 0., 0.}; + complexshape = DT_NewSphere(1.0); + objprop->m_ghost = evilObject = true; + } */ + } + break; } if (complexshape) @@ -209,21 +223,7 @@ void KX_ConvertSumoObject( class KX_GameObject* gameobj, } - if (objprop->m_ghost) - { - sumoObj = new SM_Object(complexshape,NULL,NULL, dynamicParent); - } else - { - sumoObj = new SM_Object(complexshape,smmaterial,NULL, dynamicParent); - } - - if (objprop->m_in_active_layer) - { - DT_AddObject(sumoEnv->GetSolidScene(), - sumoObj->getObjectHandle()); - } - - + sumoObj = new SM_Object(complexshape,!objprop->m_ghost?smmaterial:NULL,NULL, dynamicParent); const STR_String& matname=meshobj->GetMaterialName(0); @@ -232,7 +232,6 @@ void KX_ConvertSumoObject( class KX_GameObject* gameobj, matname.ReadPtr(), objprop->m_dyna, objprop->m_isactor); - } } } @@ -264,35 +263,34 @@ void BL_RegisterSumoObject(KX_GameObject* gameobj,class SM_Scene* sumoScene,DT_S KX_SumoPhysicsController* physicscontroller = new KX_SumoPhysicsController(sumoScene,solidscene,sumoObj,motionstate,isDynamic); gameobj->SetPhysicsController(physicscontroller); physicscontroller->setClientInfo(gameobj); + + if (!gameobj->getClientInfo()) + std::cout << "BL_RegisterSumoObject: WARNING: Object " << gameobj->GetName() << " has no client info" << std::endl; + sumoObj->setClientObject(gameobj->getClientInfo()); gameobj->GetSGNode()->AddSGController(physicscontroller); - //gameobj->GetClientInfo()->m_type = (isActor ? 1 : 0); + gameobj->getClientInfo()->m_type = (isActor ? KX_ClientObjectInfo::ACTOR : KX_ClientObjectInfo::STATIC); //gameobj->GetClientInfo()->m_clientobject = gameobj; // store materialname in auxinfo, needed for touchsensors - //gameobj->GetClientInfo()->m_auxilary_info = (matname? (void*)(matname+2) : NULL); + gameobj->getClientInfo()->m_auxilary_info = (matname? (void*)(matname+2) : NULL); physicscontroller->SetObject(gameobj->GetSGNode()); - + //gameobj->SetDynamicsScaling(MT_Vector3(1.0, 1.0, 1.0)); }; - - DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj) { - DT_ShapeHandle* shapeptr = map_gamemesh_to_sumoshape[GEN_HashedPtr(meshobj)]; + DT_ShapeHandle *shapeptr = map_gamemesh_to_sumoshape[GEN_HashedPtr(meshobj)]; if (shapeptr) { return *shapeptr; } - // todo: shared meshes - DT_ShapeHandle shape = DT_NewComplexShape(); - int p=0; int numpolys = meshobj->NumPolygons(); if (!numpolys) { @@ -300,38 +298,80 @@ DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj) } int numvalidpolys = 0; - - - for (p=0;p<meshobj->m_triangle_indices.size();p++) + for (int p=0; p<numpolys; p++) { - RAS_TriangleIndex& idx = meshobj->m_triangle_indices[p]; - + RAS_Polygon* poly = meshobj->GetPolygon(p); + // only add polygons that have the collisionflag set - if (idx.m_collider) + if (poly->IsCollider()) { - DT_Begin(); - for (int v=0;v<3;v++) - { - int num = meshobj->m_xyz_index_to_vertex_index_mapping[idx.m_index[v]].size(); - if (num != 1) - { - int i=0; - } - RAS_MatArrayIndex& vertindex = meshobj->m_xyz_index_to_vertex_index_mapping[idx.m_index[v]][0]; + numvalidpolys++; + break; + } + } + + if (numvalidpolys < 1) + return NULL; + + DT_ShapeHandle shape = DT_NewComplexShape(NULL); + + + numvalidpolys = 0; - numvalidpolys++; + for (int p2=0; p2<numpolys; p2++) + { + RAS_Polygon* poly = meshobj->GetPolygon(p2); - { - const MT_Point3& pt = meshobj->GetVertex(vertindex.m_array, - vertindex.m_index, - (RAS_IPolyMaterial*)vertindex.m_matid)->xyz(); - DT_Vertex(pt[0],pt[1],pt[2]); - } + // only add polygons that have the collisionflag set + if (poly->IsCollider()) + { /* We have to tesselate here because SOLID can only raycast triangles */ + DT_Begin(); + DT_Vector3 pt; + /* V1 */ + meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, + poly->GetVertexIndexBase().m_indexarray[0], + poly->GetMaterial()->GetPolyMaterial())->xyz().getValue(pt); + DT_Vertex(pt); + /* V2 */ + meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, + poly->GetVertexIndexBase().m_indexarray[1], + poly->GetMaterial()->GetPolyMaterial())->xyz().getValue(pt); + DT_Vertex(pt); + /* V3 */ + meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, + poly->GetVertexIndexBase().m_indexarray[2], + poly->GetMaterial()->GetPolyMaterial())->xyz().getValue(pt); + DT_Vertex(pt); + + numvalidpolys++; + DT_End(); + + if (poly->VertexCount() == 4) + { + DT_Begin(); + /* V1 */ + meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, + poly->GetVertexIndexBase().m_indexarray[0], + poly->GetMaterial()->GetPolyMaterial())->xyz().getValue(pt); + DT_Vertex(pt); + /* V3 */ + meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, + poly->GetVertexIndexBase().m_indexarray[2], + poly->GetMaterial()->GetPolyMaterial())->xyz().getValue(pt); + DT_Vertex(pt); + /* V4 */ + meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, + poly->GetVertexIndexBase().m_indexarray[3], + poly->GetMaterial()->GetPolyMaterial())->xyz().getValue(pt); + DT_Vertex(pt); + + numvalidpolys++; + DT_End(); } - DT_End(); + } } - + DT_EndComplexShape(); if (numvalidpolys > 0) @@ -340,7 +380,7 @@ DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj) return shape; } - // memleak... todo: delete shape + delete shape; return NULL; } diff --git a/source/gameengine/Ketsji/KX_GameActuator.cpp b/source/gameengine/Ketsji/KX_GameActuator.cpp index b3e50359224..dcdb9b00087 100644 --- a/source/gameengine/Ketsji/KX_GameActuator.cpp +++ b/source/gameengine/Ketsji/KX_GameActuator.cpp @@ -113,6 +113,7 @@ bool KX_GameActuator::Update(double curtime, double deltatime) { STR_String exitstring = "restarting game"; m_ketsjiengine->RequestExit(KX_EXIT_REQUEST_RESTART_GAME); + m_ketsjiengine->SetNameNextGame(m_filename); m_scene->AddDebugProperty((this)->GetParent(), exitstring); } break; @@ -146,7 +147,7 @@ bool KX_GameActuator::Update(double curtime, double deltatime) PyTypeObject KX_GameActuator::Type = { PyObject_HEAD_INIT(&PyType_Type) 0, - "KX_SceneActuator", + "KX_GameActuator", sizeof(KX_GameActuator), 0, PyDestructor, @@ -177,9 +178,39 @@ PyParentObject KX_GameActuator::Parents[] = PyMethodDef KX_GameActuator::Methods[] = { + {"getFile", (PyCFunction) KX_GameActuator::sPyGetFile, METH_VARARGS, GetFile_doc}, + {"setFile", (PyCFunction) KX_GameActuator::sPySetFile, METH_VARARGS, SetFile_doc}, {NULL,NULL} //Sentinel }; +/* getFile */ +char KX_GameActuator::GetFile_doc[] = +"getFile()\n" +"get the name of the file to start.\n"; +PyObject* KX_GameActuator::PyGetFile(PyObject* self, PyObject* args, PyObject* kwds) +{ + return PyString_FromString(m_filename); +} + +/* setFile */ +char KX_GameActuator::SetFile_doc[] = +"setFile(name)\n" +"set the name of the file to start.\n"; +PyObject* KX_GameActuator::PySetFile(PyObject* self, PyObject* args, PyObject* kwds) +{ + char* new_file; + + if (!PyArg_ParseTuple(args, "s", &new_file)) + { + return NULL; + } + + m_filename = STR_String(new_file); + + Py_Return; + +} + PyObject* KX_GameActuator::_getattr(char* attr) diff --git a/source/gameengine/Ketsji/KX_GameActuator.h b/source/gameengine/Ketsji/KX_GameActuator.h index 7f2af86db42..4f197cf5841 100644 --- a/source/gameengine/Ketsji/KX_GameActuator.h +++ b/source/gameengine/Ketsji/KX_GameActuator.h @@ -78,7 +78,8 @@ class KX_GameActuator : public SCA_IActuator /* --------------------------------------------------------------------- */ virtual PyObject* _getattr(char *attr); - + KX_PYMETHOD_DOC(KX_GameActuator,GetFile); + KX_PYMETHOD_DOC(KX_GameActuator,SetFile); }; /* end of class KX_GameActuator */ diff --git a/source/gameengine/Ketsji/KX_GameObject.cpp b/source/gameengine/Ketsji/KX_GameObject.cpp index 24f0a36b152..2f30ac645a0 100644 --- a/source/gameengine/Ketsji/KX_GameObject.cpp +++ b/source/gameengine/Ketsji/KX_GameObject.cpp @@ -66,14 +66,15 @@ KX_GameObject::KX_GameObject( PyTypeObject* T ) : SCA_IObject(T), - m_bUseObjectColor(false), m_bDyna(false), m_bSuspendDynamics(false), - m_pPhysicsController1(NULL), - m_bVisible(true) + m_bUseObjectColor(false), + m_bVisible(true), + m_pPhysicsController1(NULL) { m_ignore_activity_culling = false; - m_pClient_info = new KX_ClientObjectInfo(); + m_pClient_info = new KX_ClientObjectInfo(this); + m_pClient_info->m_type = KX_ClientObjectInfo::ACTOR; m_pSGNode = new SG_Node(this,sgReplicationInfo,callbacks); // define the relationship between this node and it's parent. @@ -198,7 +199,7 @@ CValue* KX_GameObject::GetReplica() // this will copy properties and so on... CValue::AddDataToReplica(replica); ProcessReplica(replica); - + return replica; } @@ -222,14 +223,11 @@ void KX_GameObject::ApplyTorque(const MT_Vector3& torque,bool local) void KX_GameObject::ApplyMovement(const MT_Vector3& dloc,bool local) { - if (this->IsDynamic()) + if (m_pPhysicsController1) // (IsDynamic()) { m_pPhysicsController1->RelativeTranslate(dloc,local); } - else - { - GetSGNode()->RelativeTranslate(dloc,GetSGNode()->GetSGParent(),local); - } + GetSGNode()->RelativeTranslate(dloc,GetSGNode()->GetSGParent(),local); } @@ -237,12 +235,14 @@ void KX_GameObject::ApplyMovement(const MT_Vector3& dloc,bool local) void KX_GameObject::ApplyRotation(const MT_Vector3& drot,bool local) { MT_Matrix3x3 rotmat(drot); + rotmat.transpose(); - if (this->IsDynamic()) //m_pPhysicsController) - m_pPhysicsController1->RelativeRotate(rotmat.transposed(),local); - else - // in worldspace - GetSGNode()->RelativeRotate(rotmat.transposed(),local); + //if (m_pPhysicsController1) // (IsDynamic()) + // m_pPhysicsController1->RelativeRotate(rotmat_,local); + // in worldspace + GetSGNode()->RelativeRotate(rotmat,local); + if (m_pPhysicsController1) + m_pPhysicsController1->setOrientation(NodeGetWorldOrientation().getRotation()); } @@ -273,7 +273,7 @@ void KX_GameObject::Bucketize() { double* fl = GetOpenGLMatrix(); - for (int i=0;i<m_meshes.size();i++) + for (size_t i=0;i<m_meshes.size();i++) m_meshes[i]->Bucketize(fl, this, m_bUseObjectColor, m_objectColor); } @@ -283,7 +283,7 @@ void KX_GameObject::RemoveMeshes() { double* fl = GetOpenGLMatrix(); - for (int i=0;i<m_meshes.size();i++) + for (size_t i=0;i<m_meshes.size();i++) m_meshes[i]->RemoveFromBuckets(fl, this); //note: meshes can be shared, and are deleted by KX_BlenderSceneConverter @@ -315,7 +315,7 @@ void KX_GameObject::UpdateTransform() void KX_GameObject::SetDebugColor(unsigned int bgra) { - for (int i=0;i<m_meshes.size();i++) + for (size_t i=0;i<m_meshes.size();i++) m_meshes[i]->DebugColor(bgra); } @@ -411,9 +411,9 @@ KX_GameObject::MarkVisible( * determined on this level. Maybe change this to mesh level * later on? */ - for (int i=0;i<m_meshes.size();i++) + double* fl = GetOpenGLMatrix(); + for (size_t i=0;i<m_meshes.size();i++) { - double* fl = GetOpenGLMatrix(); m_meshes[i]->MarkVisible(fl,this,visible,m_bUseObjectColor,m_objectColor); } } @@ -425,9 +425,9 @@ KX_GameObject::MarkVisible( void ) { - for (int i=0;i<m_meshes.size();i++) + double* fl = GetOpenGLMatrix(); + for (size_t i=0;i<m_meshes.size();i++) { - double* fl = GetOpenGLMatrix(); m_meshes[i]->MarkVisible(fl, this, m_bVisible, @@ -439,8 +439,8 @@ KX_GameObject::MarkVisible( void KX_GameObject::addLinearVelocity(const MT_Vector3& lin_vel,bool local) { -// if (m_pPhysicsController1) -// m_pPhysicsController1->AddLinearVelocity(lin_vel,local); + if (m_pPhysicsController1) + m_pPhysicsController1->SetLinearVelocity(lin_vel + m_pPhysicsController1->GetLinearVelocity(),local); } @@ -972,7 +972,6 @@ PyObject* KX_GameObject::PyGetOrientation(PyObject* self, int row,col; const MT_Matrix3x3& orient = NodeGetWorldOrientation(); - int index = 0; for (row=0;row<3;row++) { PyObject* veclist = PyList_New(3); diff --git a/source/gameengine/Ketsji/KX_GameObject.h b/source/gameengine/Ketsji/KX_GameObject.h index e23a9a53957..6b3101be34d 100644 --- a/source/gameengine/Ketsji/KX_GameObject.h +++ b/source/gameengine/Ketsji/KX_GameObject.h @@ -217,7 +217,7 @@ public: * instance allocated on the heap. Ownership of the new * object belongs with the caller. */ - CValue* + virtual CValue* GetReplica( ); @@ -225,7 +225,7 @@ public: * Inherited from CValue -- Makes sure any internal * data owned by this class is deep copied. Called internally */ - void + virtual void ProcessReplica( KX_GameObject* replica ); @@ -340,6 +340,9 @@ public: m_pSGNode = node; } + /** + * Deprecated & broken + */ bool IsDynamic( ) const { @@ -549,6 +552,7 @@ public: */ void Resume(void); + KX_ClientObjectInfo* getClientInfo() { return m_pClient_info; } /** * @section Python interface functions. */ diff --git a/source/gameengine/Ketsji/KX_IPO_SGController.cpp b/source/gameengine/Ketsji/KX_IPO_SGController.cpp index 8dfced41c1e..2152fa35cd1 100644 --- a/source/gameengine/Ketsji/KX_IPO_SGController.cpp +++ b/source/gameengine/Ketsji/KX_IPO_SGController.cpp @@ -44,17 +44,18 @@ #include "KX_IPO_SGController.h" #include "KX_ScalarInterpolator.h" #include "KX_GameObject.h" +#include "KX_IPhysicsController.h" // All objects should start on frame 1! Will we ever need an object to // start on another frame, the 1.0 should change. KX_IpoSGController::KX_IpoSGController() -: m_ipotime(1.0), - m_modify_position(false), +: m_modify_position(false), m_modify_orientation(false), m_modify_scaling(false), - m_modified(true), m_ipo_as_force(false), - m_force_ipo_acts_local(false) + m_force_ipo_acts_local(false), + m_modified(true), + m_ipotime(1.0) { m_sumo_object = NULL; m_game_object = NULL; @@ -121,6 +122,11 @@ bool KX_IpoSGController::Update(double currentTime) m_sumo_object->calcXform(); } */ + if (m_game_object && ob) { + m_game_object->GetPhysicsController()->ApplyForce(m_force_ipo_acts_local ? + ob->GetWorldOrientation() * m_ipo_xform.GetPosition() : + m_ipo_xform.GetPosition(), false); + } } else { ob->SetLocalPosition(m_ipo_xform.GetPosition()); @@ -137,6 +143,11 @@ bool KX_IpoSGController::Update(double currentTime) m_sumo_object->calcXform(); } */ + if (m_game_object && ob) { + m_game_object->ApplyTorque(m_force_ipo_acts_local ? + ob->GetWorldOrientation() * m_ipo_xform.GetEulerAngles() : + m_ipo_xform.GetEulerAngles(), false); + } } else { ob->SetLocalOrientation(MT_Matrix3x3(m_ipo_xform.GetEulerAngles())); diff --git a/source/gameengine/Ketsji/KX_IPhysicsController.cpp b/source/gameengine/Ketsji/KX_IPhysicsController.cpp index fe43261c0be..475ae0dfba8 100644 --- a/source/gameengine/Ketsji/KX_IPhysicsController.cpp +++ b/source/gameengine/Ketsji/KX_IPhysicsController.cpp @@ -38,8 +38,8 @@ KX_IPhysicsController::KX_IPhysicsController(bool dyna,void* userdata) : m_bDyna(dyna), - m_userdata(userdata), - m_suspendDynamics(false) + m_suspendDynamics(false), + m_userdata(userdata) { }; diff --git a/source/gameengine/Ketsji/KX_IpoActuator.cpp b/source/gameengine/Ketsji/KX_IpoActuator.cpp index de2b31684e0..92333329f9e 100644 --- a/source/gameengine/Ketsji/KX_IpoActuator.cpp +++ b/source/gameengine/Ketsji/KX_IpoActuator.cpp @@ -89,7 +89,6 @@ public: }; - KX_IpoActuator::KX_IpoActuator(SCA_IObject* gameobj, const STR_String& propname, float starttime, @@ -100,16 +99,16 @@ KX_IpoActuator::KX_IpoActuator(SCA_IObject* gameobj, bool force_ipo_local, PyTypeObject* T) : SCA_IActuator(gameobj,T), + m_bNegativeEvent(false), m_starttime (starttime), - m_endtime(endtime) , - m_localtime(starttime), + m_endtime(endtime), m_recurse(recurse), - m_type((IpoActType)acttype) , + m_localtime(starttime), m_direction(1), - m_bNegativeEvent(false), m_propname(propname), m_ipo_as_force(ipo_as_force), - m_force_ipo_local(force_ipo_local) + m_force_ipo_local(force_ipo_local), + m_type((IpoActType)acttype) { // intentionally empty } diff --git a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp index 80a4d13c916..37f5a16de83 100644 --- a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp +++ b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp @@ -102,9 +102,10 @@ const char KX_KetsjiEngine::m_profileLabels[tc_numCategories][15] = { * Constructor of the Ketsji Engine */ KX_KetsjiEngine::KX_KetsjiEngine(KX_ISystem* system) -: m_bInitialized(false), - m_activecam(0), - m_rasterizer(NULL) +: + m_rasterizer(NULL), + m_bInitialized(false), + m_activecam(0) { m_kxsystem = system; m_bFixedTime = false; @@ -587,6 +588,8 @@ void KX_KetsjiEngine::DoSound(KX_Scene* scene) m_logger->StartLog(tc_sound, m_kxsystem->GetTimeInSeconds(), true); KX_Camera* cam = scene->GetActiveCamera(); + if (!cam) + return; MT_Point3 listenerposition = cam->NodeGetWorldPosition(); MT_Vector3 listenervelocity = cam->GetLinearVelocity(); MT_Matrix3x3 listenerorientation = cam->NodeGetWorldOrientation(); @@ -734,6 +737,9 @@ void KX_KetsjiEngine::RenderFrame(KX_Scene* scene) { float left, right, bottom, top, nearfrust, farfrust; KX_Camera* cam = scene->GetActiveCamera(); + + if (!cam) + return; m_rasterizer->DisplayFog(); @@ -998,8 +1004,8 @@ void KX_KetsjiEngine::RemoveScene(const STR_String& scenename) } else { - STR_String tmpname = scenename; - printf("warning: scene %s does not exist, not removed!\n",tmpname.Ptr()); +// STR_String tmpname = scenename; + std::cout << "warning: scene " << scenename << " does not exist, not removed!" << std::endl; } } diff --git a/source/gameengine/Ketsji/KX_LightIpoSGController.h b/source/gameengine/Ketsji/KX_LightIpoSGController.h index 459d091ce80..deba37540d5 100644 --- a/source/gameengine/Ketsji/KX_LightIpoSGController.h +++ b/source/gameengine/Ketsji/KX_LightIpoSGController.h @@ -55,11 +55,12 @@ private: double m_ipotime; public: - KX_LightIpoSGController() : m_ipotime(0.0), - m_modify_energy(false), - m_modify_color(false), - m_modify_dist(false), - m_modified(true) + KX_LightIpoSGController() : + m_modify_energy(false), + m_modify_color(false), + m_modify_dist(false), + m_modified(true), + m_ipotime(0.0) {} virtual ~KX_LightIpoSGController(); diff --git a/source/gameengine/Ketsji/KX_MouseFocusSensor.cpp b/source/gameengine/Ketsji/KX_MouseFocusSensor.cpp index c6f41265690..4e2a731c421 100644 --- a/source/gameengine/Ketsji/KX_MouseFocusSensor.cpp +++ b/source/gameengine/Ketsji/KX_MouseFocusSensor.cpp @@ -51,6 +51,11 @@ #include "KX_Camera.h" #include "KX_MouseFocusSensor.h" +#include "KX_ClientObjectInfo.h" +#include "SM_Object.h" +#include "SM_Scene.h" +#include "SumoPhysicsEnvironment.h" + /* ------------------------------------------------------------------------- */ /* Native functions */ /* ------------------------------------------------------------------------- */ @@ -233,23 +238,23 @@ bool KX_MouseFocusSensor::ParentObjectHasFocus(void) * ignore-object. We don't ignore anything... */ KX_GameObject* thisObj = (KX_GameObject*) GetParent(); - - //SM_Object* hitSMObj = m_sumoScene->rayTest(NULL, - // frompoint3, - // topoint3, - // resultpoint, - // resultnormal); - - KX_GameObject* hitKXObj = 0; + SumoPhysicsEnvironment *spe = dynamic_cast<SumoPhysicsEnvironment* > (m_kxscene->GetPhysicsEnvironment()); + SM_Scene *sumoScene = spe->GetSumoScene(); + + SM_Object* hitSMObj = sumoScene->rayTest(NULL, + frompoint3, + topoint3, + resultpoint, + resultnormal); /* all this casting makes me nervous... */ - //SM_ClientObjectInfo* client_info - // = ( hitSMObj ? - // (SM_ClientObjectInfo*) ((SM_Object*)hitSMObj)->getClientObject() : - // NULL); - //KX_GameObject* hitKXObj = ( client_info ? - // (KX_GameObject*)client_info->m_clientobject : - // NULL); + KX_ClientObjectInfo* client_info + = ( hitSMObj ? + (KX_ClientObjectInfo*) ((SM_Object*)hitSMObj)->getClientObject() : + NULL); + KX_GameObject* hitKXObj = ( client_info ? + (KX_GameObject*)client_info->m_clientobject : + NULL); /* Is this me? In the ray test, there are a lot of extra checks diff --git a/source/gameengine/Ketsji/KX_NearSensor.cpp b/source/gameengine/Ketsji/KX_NearSensor.cpp index 8008e85843f..0b32c748646 100644 --- a/source/gameengine/Ketsji/KX_NearSensor.cpp +++ b/source/gameengine/Ketsji/KX_NearSensor.cpp @@ -38,11 +38,40 @@ #include "KX_TouchEventManager.h" #include "KX_Scene.h" // needed to create a replica +#include "SM_Object.h" + #ifdef HAVE_CONFIG_H #include <config.h> #endif +KX_NearSensor::KX_NearSensor(SCA_EventManager* eventmgr, + KX_GameObject* gameobj, + void *vshape, + double margin, + double resetmargin, + bool bFindMaterial, + const STR_String& touchedpropname, + class KX_Scene* scene, + PyTypeObject* T) + :KX_TouchSensor(eventmgr, + gameobj, + bFindMaterial, + touchedpropname, + /* scene, */ + T), + m_Margin(margin), + m_ResetMargin(resetmargin) -#ifdef PHYSICS_NOT_YET +{ + m_client_info = new KX_ClientObjectInfo(gameobj); + m_client_info->m_type = KX_ClientObjectInfo::NEAR; + + DT_ShapeHandle shape = (DT_ShapeHandle) vshape; + m_sumoObj = new SM_Object(shape,NULL,NULL,NULL); + m_sumoObj->setMargin(m_Margin); + m_sumoObj->setClientObject(m_client_info); + + SynchronizeTransform(); +} KX_NearSensor::KX_NearSensor(SCA_EventManager* eventmgr, KX_GameObject* gameobj, @@ -56,20 +85,27 @@ KX_NearSensor::KX_NearSensor(SCA_EventManager* eventmgr, gameobj, bFindMaterial, touchedpropname, - scene, + /* scene, */ T), m_Margin(margin), - m_ResetMargin(resetmargin), - m_sumoScene(sumoscene) + m_ResetMargin(resetmargin) { - m_client_info.m_type = 4; - m_client_info.m_clientobject = gameobj; - m_client_info.m_auxilary_info = NULL; - sumoObj->setClientObject(&m_client_info); + m_client_info = new KX_ClientObjectInfo(gameobj); + m_client_info->m_type = KX_ClientObjectInfo::NEAR; + m_client_info->m_auxilary_info = NULL; + + m_sumoObj = new SM_Object(DT_NewSphere(0.0),NULL,NULL,NULL); + m_sumoObj->setMargin(m_Margin); + m_sumoObj->setClientObject(m_client_info); + + SynchronizeTransform(); } - +void KX_NearSensor::RegisterSumo(KX_TouchEventManager *touchman) +{ + touchman->GetSumoScene()->addSensor(*m_sumoObj); +} CValue* KX_NearSensor::GetReplica() { @@ -82,6 +118,16 @@ CValue* KX_NearSensor::GetReplica() // this will copy properties and so on... CValue::AddDataToReplica(replica); + replica->m_client_info = new KX_ClientObjectInfo(m_client_info->m_clientobject); + replica->m_client_info->m_type = KX_ClientObjectInfo::NEAR; + replica->m_client_info->m_auxilary_info = NULL; + + replica->m_sumoObj = new SM_Object(DT_NewSphere(0.0),NULL,NULL,NULL); + replica->m_sumoObj->setMargin(m_Margin); + replica->m_sumoObj->setClientObject(replica->m_client_info); + + replica->SynchronizeTransform(); + return replica; } @@ -89,42 +135,11 @@ CValue* KX_NearSensor::GetReplica() void KX_NearSensor::ReParent(SCA_IObject* parent) { - DT_ShapeHandle shape = DT_Sphere(0.0); - - // this sumoObject is not deleted by a gameobj, so delete it ourself - // later (memleaks)! - - SM_Object* sumoObj = new SM_Object(shape,NULL,NULL,NULL); - sumoObj->setMargin(m_Margin); - - //sumoObj->setPosition(gameobj->NodeGetWorldPosition()); - //sumoobj->setPosition(m_sumoObj->getPosition()); - //sumoobj->setOrientation(m_sumoObj->getOrientation()); - //newobj->setRigidBody(this->m_sumoObj->isRigidBody()); - - m_sumoObj = sumoObj; - m_solidHandle = m_sumoObj->getObjectHandle(); - - double radius = m_sumoObj->getMargin(); - sumoObj->setMargin(m_sumoObj->getMargin()); + SCA_ISensor::ReParent(parent); - m_client_info.m_type = 4; - m_client_info.m_clientobject = parent; - m_client_info.m_auxilary_info = NULL; - sumoObj->setClientObject(&m_client_info); - - //m_sumoScene->add(*newobj); + m_client_info->m_clientobject = static_cast<KX_GameObject*>(parent); - if (m_sumoObj) - { - DT_SetObjectResponse(m_resptable, - m_sumoObj->getObjectHandle(), - collisionResponse, - DT_SIMPLE_RESPONSE, - this); - } - - SCA_ISensor::ReParent(parent); + SynchronizeTransform(); } @@ -133,19 +148,20 @@ KX_NearSensor::~KX_NearSensor() { // for nearsensor, the sensor is the 'owner' of sumoobj // for touchsensor, it's the parent - - m_sumoScene->remove(*m_sumoObj); + static_cast<KX_TouchEventManager*>(m_eventmgr)->GetSumoScene()->remove(*m_sumoObj); if (m_sumoObj) delete m_sumoObj; + + if (m_client_info) + delete m_client_info; } - bool KX_NearSensor::Evaluate(CValue* event) { bool result = false; - KX_GameObject* parent = (KX_GameObject*)GetParent(); + KX_GameObject* parent = static_cast<KX_GameObject*>(GetParent()); if (m_bTriggered != m_bLastTriggered) { @@ -172,28 +188,27 @@ bool KX_NearSensor::Evaluate(CValue* event) -void KX_NearSensor::HandleCollision(void* obj1,void* obj2,const DT_CollData * coll_data) +DT_Bool KX_NearSensor::HandleCollision(void* obj1,void* obj2,const DT_CollData * coll_data) { - KX_TouchEventManager* toucheventmgr = (KX_TouchEventManager*)m_eventmgr; - KX_GameObject* parent = (KX_GameObject*)GetParent(); - + KX_TouchEventManager* toucheventmgr = static_cast<KX_TouchEventManager*>(m_eventmgr); + KX_GameObject* parent = static_cast<KX_GameObject*>(GetParent()); + // need the mapping from SM_Objects to gameobjects now - SM_ClientObjectInfo* client_info =(SM_ClientObjectInfo*) (obj1 == m_sumoObj? + KX_ClientObjectInfo* client_info =static_cast<KX_ClientObjectInfo*> (obj1 == m_sumoObj? ((SM_Object*)obj2)->getClientObject() : ((SM_Object*)obj1)->getClientObject()); KX_GameObject* gameobj = ( client_info ? - (KX_GameObject*)client_info->m_clientobject : + static_cast<KX_GameObject*>(client_info->m_clientobject) : NULL); - + if (gameobj && (gameobj != parent)) { if (!m_colliders->SearchValue(gameobj)) m_colliders->Add(gameobj->AddRef()); - // only take valid colliders - if (client_info->m_type == 1) + if (client_info->m_type == KX_ClientObjectInfo::ACTOR) { if ((m_touchedpropname.Length() == 0) || (gameobj->GetProperty(m_touchedpropname))) @@ -202,10 +217,9 @@ void KX_NearSensor::HandleCollision(void* obj1,void* obj2,const DT_CollData * co m_hitObject = gameobj; } } - } else - { - } + + return DT_CONTINUE; } @@ -262,4 +276,3 @@ KX_NearSensor::_getattr(char* attr) _getattr_up(KX_TouchSensor); } -#endif //PHYSICS_NOT_YET diff --git a/source/gameengine/Ketsji/KX_NearSensor.h b/source/gameengine/Ketsji/KX_NearSensor.h index 2240cb0d589..335edbb97ca 100644 --- a/source/gameengine/Ketsji/KX_NearSensor.h +++ b/source/gameengine/Ketsji/KX_NearSensor.h @@ -36,8 +36,10 @@ #define KX_NEARSENSOR_H #include "KX_TouchSensor.h" +#include "KX_ClientObjectInfo.h" class KX_Scene; +class KX_ClientObjectInfo; class KX_NearSensor : public KX_TouchSensor { @@ -45,17 +47,36 @@ class KX_NearSensor : public KX_TouchSensor double m_Margin; double m_ResetMargin; KX_Scene* m_scene; + KX_ClientObjectInfo* m_client_info; +protected: + KX_NearSensor(class SCA_EventManager* eventmgr, + class KX_GameObject* gameobj, + void *shape, + double margin, + double resetmargin, + bool bFindMaterial, + const STR_String& touchedpropname, + class KX_Scene* scene, + PyTypeObject* T=&Type); public: - KX_NearSensor(class SCA_EventManager* eventmgr,class KX_GameObject* gameobj,double margin,double resetmargin,bool bFindMaterial,const STR_String& touchedpropname,class KM_Scene* scene,PyTypeObject* T=&Type); + KX_NearSensor(class SCA_EventManager* eventmgr, + class KX_GameObject* gameobj, + double margin, + double resetmargin, + bool bFindMaterial, + const STR_String& touchedpropname, + class KX_Scene* scene, + PyTypeObject* T=&Type); virtual ~KX_NearSensor(); virtual CValue* GetReplica(); virtual bool Evaluate(CValue* event); virtual void ReParent(SCA_IObject* parent); - //virtual void HandleCollision(void* obj1,void* obj2, - // const DT_CollData * coll_data); - + virtual DT_Bool HandleCollision(void* obj1,void* obj2, + const DT_CollData * coll_data); + virtual void RegisterSumo(KX_TouchEventManager *touchman); + virtual PyObject* _getattr(char *attr); }; diff --git a/source/gameengine/Ketsji/KX_ObColorIpoSGController.h b/source/gameengine/Ketsji/KX_ObColorIpoSGController.h index 2fa37a6369c..02a58ffd95a 100644 --- a/source/gameengine/Ketsji/KX_ObColorIpoSGController.h +++ b/source/gameengine/Ketsji/KX_ObColorIpoSGController.h @@ -48,9 +48,9 @@ private: double m_ipotime; public: - KX_ObColorIpoSGController() : m_ipotime(0.0), - - m_modified(true) + KX_ObColorIpoSGController() : + m_modified(true), + m_ipotime(0.0) {} virtual ~KX_ObColorIpoSGController(); virtual SG_Controller* GetReplica(class SG_Node* destnode); diff --git a/source/gameengine/Ketsji/KX_ObjectActuator.cpp b/source/gameengine/Ketsji/KX_ObjectActuator.cpp index bcbabc384e9..1d913fe6e44 100644 --- a/source/gameengine/Ketsji/KX_ObjectActuator.cpp +++ b/source/gameengine/Ketsji/KX_ObjectActuator.cpp @@ -44,7 +44,6 @@ /* Native functions */ /* ------------------------------------------------------------------------- */ - KX_ObjectActuator:: KX_ObjectActuator( SCA_IObject* gameobj, @@ -64,8 +63,8 @@ KX_ObjectActuator( m_drot(drot), m_linear_velocity(linV), m_angular_velocity(angV), - m_active_combined_velocity (false), - m_bitLocalFlag (flag) + m_bitLocalFlag (flag), + m_active_combined_velocity (false) { } @@ -83,6 +82,11 @@ bool KX_ObjectActuator::Update(double curtime,double deltatime) // it should reconcile the externally set velocity with it's // own velocity. if (m_active_combined_velocity) { + static bool update_resolve_warning = 0; + if (!update_resolve_warning) { + update_resolve_warning = 1; + std::cout << "FIXME: KX_ObjectActuator::Update ResolveCombinedVelocities undefined!" << std::endl; + } //if (parent->GetSumoObject()) { //parent->GetPhysicsController()->ResolveCombinedVelocities( // m_linear_velocity, diff --git a/source/gameengine/Ketsji/KX_PhysicsEngineEnums.h b/source/gameengine/Ketsji/KX_PhysicsEngineEnums.h index 9f6bd6d8f0b..9c1267ff34c 100644 --- a/source/gameengine/Ketsji/KX_PhysicsEngineEnums.h +++ b/source/gameengine/Ketsji/KX_PhysicsEngineEnums.h @@ -34,11 +34,12 @@ enum e_PhysicsEngine { - UseNone=1, - UseSumo, - UseODE, - UseDynamo, - NoSelection + NoSelection = -1, + UseNone = 0, + UseEnji = 1, + UseSumo = 2, + UseDynamo = 3, + UseODE = 4 }; #endif //__KX_PHYSICSENGINEENUMS diff --git a/source/gameengine/Ketsji/KX_PhysicsObjectWrapper.cpp b/source/gameengine/Ketsji/KX_PhysicsObjectWrapper.cpp index 2bba77a966a..d692af82b7a 100644 --- a/source/gameengine/Ketsji/KX_PhysicsObjectWrapper.cpp +++ b/source/gameengine/Ketsji/KX_PhysicsObjectWrapper.cpp @@ -40,8 +40,10 @@ KX_PhysicsObjectWrapper::KX_PhysicsObjectWrapper( PHY_IPhysicsController* ctrl, - PHY_IPhysicsEnvironment* physenv,PyTypeObject *T) -: m_ctrl(ctrl),m_physenv(physenv),PyObjectPlus(T) + PHY_IPhysicsEnvironment* physenv,PyTypeObject *T) : + PyObjectPlus(T), + m_ctrl(ctrl), + m_physenv(physenv) { } diff --git a/source/gameengine/Ketsji/KX_RadarSensor.cpp b/source/gameengine/Ketsji/KX_RadarSensor.cpp index 19e26b6f484..923a38cb7cc 100644 --- a/source/gameengine/Ketsji/KX_RadarSensor.cpp +++ b/source/gameengine/Ketsji/KX_RadarSensor.cpp @@ -39,11 +39,8 @@ /** * RadarSensor constructor. Creates a near-sensor derived class, with a cone collision shape. */ - -#ifdef PHYSICS_NOT_YET - -KX_RadarSensor::KX_RadarSensor(class SCA_EventManager* eventmgr, - class KX_GameObject* gameobj, +KX_RadarSensor::KX_RadarSensor(SCA_EventManager* eventmgr, + KX_GameObject* gameobj, double coneradius, double coneheight, int axis, @@ -57,20 +54,21 @@ KX_RadarSensor::KX_RadarSensor(class SCA_EventManager* eventmgr, : KX_NearSensor( eventmgr, gameobj, + DT_NewCone(coneradius,coneheight), margin, resetmargin, bFindMaterial, touchedpropname, kxscene, T), - m_coneheight(coneheight), m_coneradius(coneradius), + m_coneheight(coneheight), m_axis(axis) { - m_client_info.m_type = 3; - m_client_info.m_clientobject = gameobj; - m_client_info.m_auxilary_info = NULL; - sumoObj->setClientObject(&m_client_info); + m_client_info->m_type = KX_ClientObjectInfo::RADAR; + //m_client_info->m_clientobject = gameobj; + //m_client_info->m_auxilary_info = NULL; + //sumoObj->setClientObject(&m_client_info); } @@ -221,4 +219,3 @@ PyObject* KX_RadarSensor::PyGetConeHeight(PyObject* self, } -#endif //PHYSICS_NOT_YET diff --git a/source/gameengine/Ketsji/KX_RadarSensor.h b/source/gameengine/Ketsji/KX_RadarSensor.h index 77e085d29a3..03364ae9c29 100644 --- a/source/gameengine/Ketsji/KX_RadarSensor.h +++ b/source/gameengine/Ketsji/KX_RadarSensor.h @@ -62,18 +62,18 @@ class KX_RadarSensor : public KX_NearSensor MT_Point3 m_cone_target; public: - KX_RadarSensor(class SCA_EventManager* eventmgr, - class KX_GameObject* gameobj, + + KX_RadarSensor(SCA_EventManager* eventmgr, + KX_GameObject* gameobj, double coneradius, double coneheight, int axis, double margin, double resetmargin, - class SM_Object* sumoObj, bool bFindMaterial, const STR_String& touchedpropname, - class SM_Scene* sumoscene, - PyTypeObject* T=&Type); + class KX_Scene* kxscene, + PyTypeObject* T = &Type); KX_RadarSensor(); virtual ~KX_RadarSensor(); virtual void SynchronizeTransform(); diff --git a/source/gameengine/Ketsji/KX_RayEventManager.h b/source/gameengine/Ketsji/KX_RayEventManager.h index f5280f1fec6..7acc0b04ded 100644 --- a/source/gameengine/Ketsji/KX_RayEventManager.h +++ b/source/gameengine/Ketsji/KX_RayEventManager.h @@ -44,8 +44,8 @@ class KX_RayEventManager : public SCA_EventManager class SCA_LogicManager* m_logicmgr; public: KX_RayEventManager(class SCA_LogicManager* logicmgr) - : m_logicmgr(logicmgr), - SCA_EventManager(RAY_EVENTMGR) + : SCA_EventManager(RAY_EVENTMGR), + m_logicmgr(logicmgr) {} virtual void NextFrame(double curtime,double deltatime); virtual void RegisterSensor(SCA_ISensor* sensor); diff --git a/source/gameengine/Ketsji/KX_RaySensor.cpp b/source/gameengine/Ketsji/KX_RaySensor.cpp index 5cca436327a..c53651712a8 100644 --- a/source/gameengine/Ketsji/KX_RaySensor.cpp +++ b/source/gameengine/Ketsji/KX_RaySensor.cpp @@ -41,6 +41,9 @@ #include "KX_GameObject.h" #include "KX_Scene.h" +#include "SumoPhysicsEnvironment.h" +#include "KX_SumoPhysicsController.h" + #ifdef HAVE_CONFIG_H #include <config.h> #endif @@ -57,10 +60,10 @@ KX_RaySensor::KX_RaySensor(class SCA_EventManager* eventmgr, m_propertyname(propname), m_bFindMaterial(bFindMaterial), m_distance(distance), + m_scene(ketsjiScene), + m_bTriggered(false), m_axis(axis), - m_ketsjiScene(ketsjiScene), m_rayHit(false), - m_bTriggered(false), m_hitObject(NULL) @@ -139,56 +142,78 @@ bool KX_RaySensor::Evaluate(CValue* event) } case 3: // -X { - todir[0] = invmat[0][0] * -1; - todir[1] = invmat[0][1] * -1; - todir[2] = invmat[0][2] * -1; + todir[0] = -invmat[0][0]; + todir[1] = -invmat[0][1]; + todir[2] = -invmat[0][2]; break; } case 4: // -Y { - todir[0] = invmat[1][0] * -1; - todir[1] = invmat[1][1] * -1; - todir[2] = invmat[1][2] * -1; + todir[0] = -invmat[1][0]; + todir[1] = -invmat[1][1]; + todir[2] = -invmat[1][2]; break; } case 5: // -Z { - todir[0] = invmat[2][0] * -1; - todir[1] = invmat[2][1] * -1; - todir[2] = invmat[2][2] * -1; + todir[0] = -invmat[2][0]; + todir[1] = -invmat[2][1]; + todir[2] = -invmat[2][2]; break; } } todir.normalize(); m_rayDirection = todir; - - MT_Point3 topoint = frompoint + (m_distance) * todir; MT_Point3 resultpoint; MT_Vector3 resultnormal; bool ready = false; - /* - do { + SumoPhysicsEnvironment *spe = dynamic_cast<SumoPhysicsEnvironment *>(m_scene->GetPhysicsEnvironment()); + SM_Scene *scene = spe->GetSumoScene(); + KX_SumoPhysicsController *spc = dynamic_cast<KX_SumoPhysicsController *>(obj->GetPhysicsController()); + KX_GameObject *parent = obj->GetParent(); + if (!spc && parent) + spc = dynamic_cast<KX_SumoPhysicsController *>(parent->GetPhysicsController()); + if (parent) + parent->Release(); + SM_Object *thisObj = spc?spc->GetSumoObject():NULL; - - - SM_Object* hitObj = m_sumoScene->rayTest(obj->GetSumoObject(), - frompoint, - topoint, - resultpoint, - resultnormal); + do { + SM_Object* hitObj = scene->rayTest(thisObj, + frompoint, + topoint, + resultpoint, + resultnormal); + if (hitObj) { - KX_ClientObjectInfo* info = (SM_ClientObjectInfo*)hitObj->getClientObject(); - SCA_IObject* hitgameobj = (SCA_IObject*)info->m_clientobject; + + KX_ClientObjectInfo* info = (KX_ClientObjectInfo*)hitObj->getClientObject(); bool bFound = false; - - if (hitgameobj == obj) + + if (!info) + { + std::cout<< "WARNING: Ray sensor " << GetName() << " cannot sense SM_Object " << hitObj << " - no client info.\n" << std::endl; + ready = true; + break; + } + + SCA_IObject *hitgameobj = (SCA_IObject*)info->m_clientobject; + + if (hitgameobj == obj || info->m_type > KX_ClientObjectInfo::ACTOR) { // false hit - MT_Scalar marg = obj->GetSumoObject()->getMargin() ; - frompoint = resultpoint + marg * todir; + KX_SumoPhysicsController *hitspc = dynamic_cast<KX_SumoPhysicsController *> (static_cast<KX_GameObject*> (hitgameobj) ->GetPhysicsController()); + if (hitspc) + { + MT_Scalar marg = hitspc->GetSumoObject()->getMargin(); + if (hitspc->GetSumoObject()->getShapeProps()) + marg += hitspc->GetSumoObject()->getShapeProps()->m_radius; + frompoint = resultpoint + marg * todir; + } else { + ready = true; + } } else { @@ -208,10 +233,7 @@ bool KX_RaySensor::Evaluate(CValue* event) } else { - if (hitgameobj->GetProperty(m_propertyname) != NULL) - { - bFound = true; - } + bFound = hitgameobj->GetProperty(m_propertyname) != NULL; } } @@ -231,7 +253,7 @@ bool KX_RaySensor::Evaluate(CValue* event) } } while (!ready); - */ + /* now pass this result to some controller */ diff --git a/source/gameengine/Ketsji/KX_RaySensor.h b/source/gameengine/Ketsji/KX_RaySensor.h index 4a783b398b4..528f52f27a7 100644 --- a/source/gameengine/Ketsji/KX_RaySensor.h +++ b/source/gameengine/Ketsji/KX_RaySensor.h @@ -44,7 +44,7 @@ class KX_RaySensor : public SCA_ISensor STR_String m_propertyname; bool m_bFindMaterial; double m_distance; - class KX_Scene* m_ketsjiScene; + class KX_Scene* m_scene; bool m_bTriggered; int m_axis; bool m_rayHit; diff --git a/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp b/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp index 784a3e015df..060afe060ee 100644 --- a/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp +++ b/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp @@ -135,8 +135,8 @@ KX_SCA_ReplaceMeshActuator::KX_SCA_ReplaceMeshActuator(SCA_IObject *gameobj, PyTypeObject* T) : SCA_IActuator(gameobj, T), - m_scene(scene), - m_mesh(mesh) + m_mesh(mesh), + m_scene(scene) { } /* End of constructor */ diff --git a/source/gameengine/Ketsji/KX_Scene.cpp b/source/gameengine/Ketsji/KX_Scene.cpp index c2cb001cce8..8a964e07eb5 100644 --- a/source/gameengine/Ketsji/KX_Scene.cpp +++ b/source/gameengine/Ketsji/KX_Scene.cpp @@ -73,6 +73,8 @@ #include "PHY_IPhysicsEnvironment.h" #include "KX_IPhysicsController.h" +#include "SM_Scene.h" +#include "SumoPhysicsEnvironment.h" void* KX_SceneReplicationFunc(SG_IObject* node,void* gameobj,void* scene) { @@ -95,23 +97,20 @@ SG_Callbacks KX_Scene::m_callbacks = SG_Callbacks(KX_SceneReplicationFunc,KX_Sce // (defined in KX_PythonInit.cpp) extern bool gUseVisibilityTemp; - - - KX_Scene::KX_Scene(class SCA_IInputDevice* keyboarddevice, class SCA_IInputDevice* mousedevice, class NG_NetworkDeviceInterface *ndi, class SND_IAudioDevice* adi, const STR_String& sceneName): - m_mousemgr(NULL), m_keyboardmgr(NULL), - m_active_camera(NULL), - m_ueberExecutionPriority(0), - m_adi(adi), + m_mousemgr(NULL), + m_physicsEnvironment(0), m_sceneName(sceneName), + m_adi(adi), m_networkDeviceInterface(ndi), - m_physicsEnvironment(0) + m_active_camera(NULL), + m_ueberExecutionPriority(0) { @@ -130,11 +129,7 @@ KX_Scene::KX_Scene(class SCA_IInputDevice* keyboarddevice, m_keyboardmgr = new SCA_KeyboardManager(m_logicmgr,keyboarddevice); m_mousemgr = new SCA_MouseManager(m_logicmgr,mousedevice); -// m_solidScene = DT_CreateScene(); -// m_respTable = DT_CreateRespTable(); - SCA_AlwaysEventManager* alwaysmgr = new SCA_AlwaysEventManager(m_logicmgr); - //KX_TouchEventManager* touchmgr = new KX_TouchEventManager(m_logicmgr, m_respTable, m_solidScene); SCA_PropertyEventManager* propmgr = new SCA_PropertyEventManager(m_logicmgr); SCA_RandomEventManager* rndmgr = new SCA_RandomEventManager(m_logicmgr); KX_RayEventManager* raymgr = new KX_RayEventManager(m_logicmgr); @@ -145,14 +140,11 @@ KX_Scene::KX_Scene(class SCA_IInputDevice* keyboarddevice, m_logicmgr->RegisterEventManager(propmgr); m_logicmgr->RegisterEventManager(m_keyboardmgr); m_logicmgr->RegisterEventManager(m_mousemgr); - //m_logicmgr->RegisterEventManager(touchmgr); m_logicmgr->RegisterEventManager(m_timemgr); m_logicmgr->RegisterEventManager(rndmgr); m_logicmgr->RegisterEventManager(raymgr); m_logicmgr->RegisterEventManager(netmgr); - //m_sumoScene = new SM_Scene(); - //m_sumoScene->setSecondaryRespTable(m_respTable); m_soundScene = new SND_Scene(adi); assert (m_networkDeviceInterface != NULL); m_networkScene = new NG_NetworkScene(m_networkDeviceInterface); @@ -169,6 +161,7 @@ KX_Scene::KX_Scene(class SCA_IInputDevice* keyboarddevice, KX_Scene::~KX_Scene() { + // int numobj = m_objectlist->GetCount(); //int numrootobjects = GetRootParentList()->GetCount(); @@ -708,6 +701,11 @@ void KX_Scene::NewRemoveObject(class CValue* gameobj) newobj->Release(); if (m_euthanasyobjects->RemoveValue(newobj)) newobj->Release(); + + if (newobj == m_active_camera) + { + m_active_camera = NULL; + } } @@ -979,3 +977,15 @@ void KX_Scene::SetGravity(const MT_Vector3& gravity) { GetPhysicsEnvironment()->setGravity(gravity[0],gravity[1],gravity[2]); } + +void KX_Scene::SetPhysicsEnvironment(class PHY_IPhysicsEnvironment* physEnv) +{ + SumoPhysicsEnvironment *sme = dynamic_cast<SumoPhysicsEnvironment *>(physEnv); + m_physicsEnvironment = physEnv; + if (sme) + { + KX_TouchEventManager* touchmgr = new KX_TouchEventManager(m_logicmgr, sme->GetSumoScene()); + m_logicmgr->RegisterEventManager(touchmgr); + return; + } +} diff --git a/source/gameengine/Ketsji/KX_Scene.h b/source/gameengine/Ketsji/KX_Scene.h index 818368561e6..35f2f9dbb71 100644 --- a/source/gameengine/Ketsji/KX_Scene.h +++ b/source/gameengine/Ketsji/KX_Scene.h @@ -466,10 +466,7 @@ public: return m_physicsEnvironment; } - void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment* physEnv) - { - m_physicsEnvironment = physEnv; - } + void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment* physEnv); void SetGravity(const MT_Vector3& gravity); }; diff --git a/source/gameengine/Ketsji/KX_SceneActuator.cpp b/source/gameengine/Ketsji/KX_SceneActuator.cpp index 4a1d8c74b77..e07719ea680 100644 --- a/source/gameengine/Ketsji/KX_SceneActuator.cpp +++ b/source/gameengine/Ketsji/KX_SceneActuator.cpp @@ -295,12 +295,9 @@ PyObject* KX_SceneActuator::PySetScene(PyObject* self, return NULL; } - if (m_KetsjiEngine->FindScene(scene_name)) - { - /* Scene switch is done by name. */ - m_nextSceneName = scene_name; - } - + /* Scene switch is done by name. */ + m_nextSceneName = scene_name; + Py_Return; } diff --git a/source/gameengine/Ketsji/KX_SumoPhysicsController.cpp b/source/gameengine/Ketsji/KX_SumoPhysicsController.cpp index 12b8775b5cd..57986cd7b78 100644 --- a/source/gameengine/Ketsji/KX_SumoPhysicsController.cpp +++ b/source/gameengine/Ketsji/KX_SumoPhysicsController.cpp @@ -1,4 +1,7 @@ + +#ifdef WIN32 #pragma warning (disable : 4786) +#endif #include "KX_SumoPhysicsController.h" #include "SG_Spatial.h" @@ -107,7 +110,7 @@ SG_Controller* KX_SumoPhysicsController::GetReplica(SG_Node* destnode) //parentcontroller is here be able to avoid collisions between parent/child PHY_IPhysicsController* parentctrl = NULL; - + if (destnode != destnode->GetRootSGParent()) { KX_GameObject* clientgameobj = (KX_GameObject*) destnode->GetRootSGParent()->GetSGClientObject(); @@ -123,7 +126,7 @@ SG_Controller* KX_SumoPhysicsController::GetReplica(SG_Node* destnode) childit!= destnode->GetSGChildren().end(); ++childit ) { - KX_GameObject* clientgameobj = static_cast<KX_GameObject*>( (*childit)->GetSGClientObject()); + KX_GameObject *clientgameobj = static_cast<KX_GameObject*>( (*childit)->GetSGClientObject()); if (clientgameobj) { parentctrl = (KX_SumoPhysicsController*)clientgameobj->GetPhysicsController(); @@ -145,8 +148,7 @@ void KX_SumoPhysicsController::SetObject (SG_IObject* object) // cheating here... KX_GameObject* gameobj = (KX_GameObject*) object->GetSGClientObject(); gameobj->SetPhysicsController(this); - - + GetSumoObject()->setClientObject(gameobj->getClientInfo()); } diff --git a/source/gameengine/Ketsji/KX_SumoPhysicsController.h b/source/gameengine/Ketsji/KX_SumoPhysicsController.h index 523e139fc69..465dd799c2a 100644 --- a/source/gameengine/Ketsji/KX_SumoPhysicsController.h +++ b/source/gameengine/Ketsji/KX_SumoPhysicsController.h @@ -1,3 +1,34 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ #ifndef __KX_SUMOPHYSICSCONTROLLER_H #define __KX_SUMOPHYSICSCONTROLLER_H @@ -27,8 +58,8 @@ public: class SM_Object* sumoObj, class PHY_IMotionState* motionstate ,bool dyna) - : SumoPhysicsController(sumoScene,solidscene,sumoObj,motionstate,dyna), - KX_IPhysicsController(dyna,NULL) + : KX_IPhysicsController(dyna,NULL) , + SumoPhysicsController(sumoScene,solidscene,sumoObj,motionstate,dyna) { }; virtual ~KX_SumoPhysicsController(); diff --git a/source/gameengine/Ketsji/KX_TimeLogger.cpp b/source/gameengine/Ketsji/KX_TimeLogger.cpp index 509f7e13234..766c541b4fc 100644 --- a/source/gameengine/Ketsji/KX_TimeLogger.cpp +++ b/source/gameengine/Ketsji/KX_TimeLogger.cpp @@ -36,8 +36,10 @@ #include <config.h> #endif -KX_TimeLogger::KX_TimeLogger(unsigned int maxNumMeasurements) -: m_maxNumMeasurements(maxNumMeasurements), m_logging(false), m_logStart(0) +KX_TimeLogger::KX_TimeLogger(unsigned int maxNumMeasurements) : + m_maxNumMeasurements(maxNumMeasurements), + m_logStart(0), + m_logging(false) { } @@ -108,7 +110,7 @@ double KX_TimeLogger::GetAverage(void) const unsigned int numMeasurements = m_measurements.size(); if (numMeasurements > 1) { - for (int i = 1; i < numMeasurements; i++) { + for (unsigned int i = 1; i < numMeasurements; i++) { avg += m_measurements[i]; } avg /= (float)numMeasurements - 1; diff --git a/source/gameengine/Ketsji/KX_TouchEventManager.cpp b/source/gameengine/Ketsji/KX_TouchEventManager.cpp index 8c7f18983e5..2186c442f32 100644 --- a/source/gameengine/Ketsji/KX_TouchEventManager.cpp +++ b/source/gameengine/Ketsji/KX_TouchEventManager.cpp @@ -38,33 +38,60 @@ #include <config.h> #endif -#ifdef PHYSICS_NOT_YET +#include "SM_Object.h" KX_TouchEventManager::KX_TouchEventManager(class SCA_LogicManager* logicmgr, - DT_RespTableHandle resphandle, - DT_SceneHandle scenehandle) + SM_Scene *scene) : SCA_EventManager(TOUCH_EVENTMGR), - m_resphandle(resphandle), - m_scenehandle(scenehandle), - m_logicmgr(logicmgr) {} + m_logicmgr(logicmgr), + m_scene(scene) +{ + //m_scene->addTouchCallback(STATIC_RESPONSE, KX_TouchEventManager::collisionResponse, this); + m_scene->addTouchCallback(OBJECT_RESPONSE, KX_TouchEventManager::collisionResponse, this); + m_scene->addTouchCallback(SENSOR_RESPONSE, KX_TouchEventManager::collisionResponse, this); +} -void KX_TouchEventManager::RegisterSensor(SCA_ISensor* sensor) +DT_Bool KX_TouchEventManager::HandleCollision(void* object1,void* object2, + const DT_CollData * coll_data) { + SM_Object * obj1 = (SM_Object *) object1; + SM_Object * obj2 = (SM_Object *) object2; + + for ( vector<SCA_ISensor*>::iterator it = m_sensors.begin(); !(it==m_sensors.end()); it++) + { + KX_GameObject* gameobj = ((KX_GameObject*)((KX_TouchSensor*)*it)->GetParent()); + KX_ClientObjectInfo *client_info = (KX_ClientObjectInfo *) obj1->getClientObject(); +// Enable these printfs to create excesive debug info +// printf("KX_TEM::HC: Sensor %s\tGO: %p o1: %s (%p)", (const char *) (*it)->GetName(), gameobj, (const char *) ((KX_GameObject *) client_info->m_clientobject)->GetName(), client_info->m_clientobject); + if (client_info && client_info->m_clientobject == gameobj) + ((KX_TouchSensor*)*it)->HandleCollision(object1,object2,coll_data); + + client_info = (KX_ClientObjectInfo *) obj2->getClientObject(); +// printf(" o2: %s (%p)\n", (const char *) ((KX_GameObject *) client_info->m_clientobject)->GetName(), client_info->m_clientobject); + if (client_info && client_info->m_clientobject == gameobj) + ((KX_TouchSensor*)*it)->HandleCollision(object1,object2,coll_data); + } + + return DT_CONTINUE; +} +DT_Bool KX_TouchEventManager::collisionResponse(void *client_data, + void *object1, + void *object2, + const DT_CollData *coll_data) +{ + KX_TouchEventManager *touchmgr = (KX_TouchEventManager *) client_data; + touchmgr->HandleCollision(object1, object2, coll_data); + return DT_CONTINUE; +} + +void KX_TouchEventManager::RegisterSensor(SCA_ISensor* sensor) +{ KX_TouchSensor* touchsensor = static_cast<KX_TouchSensor*>(sensor); m_sensors.push_back(touchsensor); - touchsensor->RegisterSumo();//this,m_resphandle); - - //KX_GameObject* gameobj = ((KX_GameObject*)sensor->GetParent()); -// SM_Object* smobj = touchsensor->GetSumoObject();//gameobj->GetSumoObject(); -// if (smobj) -// { -// smobj->calcXform(); -// DT_AddObject(m_scenehandle, -// smobj->getObjectHandle()); -// } + touchsensor->RegisterSumo(this); } @@ -89,10 +116,7 @@ void KX_TouchEventManager::NextFrame(double curtime,double deltatime) vector<SCA_ISensor*>::iterator it; for (it = m_sensors.begin();!(it==m_sensors.end());it++) - ((KX_TouchSensor*)*it)->SynchronizeTransform(); - - if (DT_Test(m_scenehandle,m_resphandle)) - int i = 0; + static_cast<KX_TouchSensor*>(*it)->SynchronizeTransform(); for (it = m_sensors.begin();!(it==m_sensors.end());it++) (*it)->Activate(m_logicmgr,NULL); @@ -107,14 +131,10 @@ void KX_TouchEventManager::RemoveSensor(class SCA_ISensor* sensor) std::find(m_sensors.begin(), m_sensors.end(), sensor); if (!(i == m_sensors.end())) { - //std::swap(*i, m_sensors.back()); - //m_sensors.pop_back(); - //SM_Object* smobj = ((KX_TouchSensor*)*i)->GetSumoObject(); - //DT_RemoveObject(m_scenehandle, - // smobj->getObjectHandle()); + std::swap(*i, m_sensors.back()); + m_sensors.pop_back(); } // remove the sensor forever :) SCA_EventManager::RemoveSensor(sensor); } -#endif diff --git a/source/gameengine/Ketsji/KX_TouchEventManager.h b/source/gameengine/Ketsji/KX_TouchEventManager.h index 711a3abb996..e53dc264494 100644 --- a/source/gameengine/Ketsji/KX_TouchEventManager.h +++ b/source/gameengine/Ketsji/KX_TouchEventManager.h @@ -37,19 +37,30 @@ #include "KX_GameObject.h" #include <vector> -using namespace std; class KX_TouchEventManager : public SCA_EventManager { class SCA_LogicManager* m_logicmgr; + SM_Scene *m_scene; + + static DT_Bool KX_TouchEventManager::collisionResponse(void *client_data, + void *object1, + void *object2, + const DT_CollData *coll_data); + + virtual DT_Bool HandleCollision(void* obj1,void* obj2, + const DT_CollData * coll_data); + public: - KX_TouchEventManager(class SCA_LogicManager* logicmgr); + KX_TouchEventManager(class SCA_LogicManager* logicmgr, + SM_Scene *scene); virtual void NextFrame(double curtime,double deltatime); virtual void EndFrame(); virtual void RemoveSensor(class SCA_ISensor* sensor); virtual void RegisterSensor(SCA_ISensor* sensor); SCA_LogicManager* GetLogicManager() { return m_logicmgr;} + SM_Scene *GetSumoScene() { return m_scene; } }; #endif //__KX_TOUCHEVENTMANAGER diff --git a/source/gameengine/Ketsji/KX_TouchSensor.cpp b/source/gameengine/Ketsji/KX_TouchSensor.cpp index ee2226d03ad..6ae670a842c 100644 --- a/source/gameengine/Ketsji/KX_TouchSensor.cpp +++ b/source/gameengine/Ketsji/KX_TouchSensor.cpp @@ -37,14 +37,14 @@ #include "SCA_LogicManager.h" #include "KX_GameObject.h" #include "KX_TouchEventManager.h" +#include "SM_Object.h" +#include "KX_SumoPhysicsController.h" #include <iostream> #ifdef HAVE_CONFIG_H #include <config.h> #endif -#ifdef PHYSICS_NOT_YET - /* ------------------------------------------------------------------------- */ /* Native functions */ /* ------------------------------------------------------------------------- */ @@ -84,78 +84,81 @@ bool KX_TouchSensor::Evaluate(CValue* event) return result; } -KX_TouchSensor::KX_TouchSensor(SCA_EventManager* eventmgr,KX_GameObject* gameobj,SM_Object* sumoObj,bool bFindMaterial,const STR_String& touchedpropname,PyTypeObject* T) +KX_TouchSensor::KX_TouchSensor(SCA_EventManager* eventmgr,KX_GameObject* gameobj,/*SM_Object* sumoObj,*/bool bFindMaterial,const STR_String& touchedpropname,PyTypeObject* T) :SCA_ISensor(gameobj,eventmgr,T), m_touchedpropname(touchedpropname), m_bFindMaterial(bFindMaterial), -m_sumoObj(sumoObj), +m_eventmgr(eventmgr), +/*m_sumoObj(sumoObj),*/ m_bCollision(false), m_bTriggered(false), m_bLastTriggered(false) { - m_eventmgr = eventmgr; KX_TouchEventManager* touchmgr = (KX_TouchEventManager*) eventmgr; +// m_resptable = touchmgr->GetResponseTable(); - m_resptable = touchmgr->GetResponseTable(); - - m_solidHandle = m_sumoObj->getObjectHandle(); +// m_solidHandle = m_sumoObj->getObjectHandle(); m_hitObject = NULL; m_colliders = new CListValue(); + + KX_ClientObjectInfo *client_info = gameobj->getClientInfo(); + client_info->m_clientobject = gameobj; + client_info->m_auxilary_info = NULL; + + KX_SumoPhysicsController *sphy = dynamic_cast<KX_SumoPhysicsController *>(gameobj->GetPhysicsController()); + if (sphy) + m_sumoObj = sphy->GetSumoObject(); + } KX_TouchSensor::~KX_TouchSensor() { - DT_ClearObjectResponse(m_resptable,m_solidHandle); + //DT_ClearObjectResponse(m_resptable,m_solidHandle); m_colliders->Release(); } void KX_TouchSensor::ReParent(SCA_IObject* parent) { - - m_sumoObj = ((KX_GameObject*)parent)->GetSumoObject(); - m_solidHandle = m_sumoObj->getObjectHandle(); - - m_client_info.m_clientobject = NULL;//parent; - m_client_info.m_auxilary_info = NULL; + KX_GameObject *gameobj = static_cast<KX_GameObject *>(parent); + KX_SumoPhysicsController *sphy = dynamic_cast<KX_SumoPhysicsController *>(((KX_GameObject*)parent)->GetPhysicsController()); + if (sphy) + m_sumoObj = sphy->GetSumoObject(); + +// m_solidHandle = m_sumoObj->getObjectHandle(); + KX_ClientObjectInfo *client_info = gameobj->getClientInfo(); + client_info->m_clientobject = parent; + client_info->m_auxilary_info = NULL; SCA_ISensor::ReParent(parent); } - -void KX_TouchSensor::RegisterSumo() +void KX_TouchSensor::RegisterSumo(KX_TouchEventManager *touchman) { + if (m_sumoObj) + { + touchman->GetSumoScene()->requestCollisionCallback(*m_sumoObj); + // collision + // Deprecated - if (m_sumoObj) - { - // collision - DT_SetObjectResponse( - m_resptable, - m_solidHandle, - collisionResponse, - DT_SIMPLE_RESPONSE, - this); - - } - + } } -void KX_TouchSensor::HandleCollision(void* obj1,void* obj2,const DT_CollData * coll_data) +DT_Bool KX_TouchSensor::HandleCollision(void* obj1,void* obj2,const DT_CollData * coll_data) { KX_TouchEventManager* toucheventmgr = (KX_TouchEventManager*)m_eventmgr; KX_GameObject* parent = (KX_GameObject*)GetParent(); // need the mapping from SM_Objects to gameobjects now - SM_ClientObjectInfo* client_info =(SM_ClientObjectInfo*) (obj1 == m_sumoObj? + KX_ClientObjectInfo* client_info =(KX_ClientObjectInfo*) (obj1 == m_sumoObj? ((SM_Object*)obj2)->getClientObject() : ((SM_Object*)obj1)->getClientObject()); - KX_GameObject* gameobj = ( client_info ? (KX_GameObject*)client_info->m_clientobject : NULL); - + if (gameobj && (gameobj != parent)) { if (!m_colliders->SearchValue(gameobj)) @@ -185,12 +188,14 @@ void KX_TouchSensor::HandleCollision(void* obj1,void* obj2,const DT_CollData { m_bTriggered = true; m_hitObject = gameobj; + //printf("KX_TouchSensor::HandleCollision\n"); } } - + return DT_CONTINUE; } + /* ------------------------------------------------------------------------- */ /* Python functions */ /* ------------------------------------------------------------------------- */ @@ -322,10 +327,11 @@ PyObject* KX_TouchSensor::PyGetHitObjectList(PyObject* self, * - this also doesn't work (obviously) for multi-materials... */ KX_GameObject* gameob = (KX_GameObject*) m_colliders->GetValue(i); - SM_Object* smob = (SM_Object*) gameob->GetSumoObject(); + KX_SumoPhysicsController* spc = dynamic_cast<KX_SumoPhysicsController*>(gameob->GetPhysicsController()); + SM_Object* smob = spc?spc->GetSumoObject():NULL; if (smob) { - SM_ClientObjectInfo* cl_inf = (SM_ClientObjectInfo*) smob->getClientObject(); + KX_ClientObjectInfo* cl_inf = (KX_ClientObjectInfo*) smob->getClientObject(); if (m_touchedpropname == ((char*)cl_inf->m_auxilary_info)) { newList->Add(m_colliders->GetValue(i)->AddRef()); @@ -392,6 +398,5 @@ PyObject* KX_TouchSensor::PySetTouchMaterial(PyObject* self, PyObject* args, PyO Py_Return; } -#endif //#ifdef PHYSICS_NOT_YET /* eof */ diff --git a/source/gameengine/Ketsji/KX_TouchSensor.h b/source/gameengine/Ketsji/KX_TouchSensor.h index 35b23ecc60a..50338827694 100644 --- a/source/gameengine/Ketsji/KX_TouchSensor.h +++ b/source/gameengine/Ketsji/KX_TouchSensor.h @@ -38,8 +38,13 @@ #include "SCA_ISensor.h" #include "ListValue.h" +#include <SOLID/SOLID.h> +#include "SM_Scene.h" + #include "KX_ClientObjectInfo.h" +class KX_TouchEventManager; + class KX_TouchSensor : public SCA_ISensor { protected: @@ -52,10 +57,9 @@ protected: bool m_bFindMaterial; class SCA_EventManager* m_eventmgr; - //class SM_Object* m_sumoObj; - //DT_ObjectHandle m_solidHandle; - //SM_ClientObjectInfo m_client_info; - //DT_RespTableHandle m_resptable; + class SM_Object* m_sumoObj; + DT_ObjectHandle m_solidHandle; + DT_RespTableHandle m_resptable; bool m_bCollision; @@ -67,7 +71,7 @@ protected: public: KX_TouchSensor(class SCA_EventManager* eventmgr, class KX_GameObject* gameobj, - class SM_Object* sumoObj, + /*class SM_Object* sumoObj,*/ bool fFindMaterial, const STR_String& touchedpropname, PyTypeObject* T=&Type) ; @@ -88,25 +92,15 @@ public: virtual bool Evaluate(CValue* event); virtual void ReParent(SCA_IObject* parent); -/* static void collisionResponse(void *client_data, - void *object1, - void *object2, - const DT_CollData *coll_data) { - class KX_TouchSensor* sensor = (class KX_TouchSensor*) client_data; - sensor->HandleCollision(object1,object2,coll_data); - } - - - - void RegisterSumo(); + virtual void RegisterSumo(KX_TouchEventManager* touchman); - virtual void HandleCollision(void* obj1,void* obj2, + virtual DT_Bool HandleCollision(void* obj1,void* obj2, const DT_CollData * coll_data); - // SM_Object* GetSumoObject() { return m_sumoObj; }; + SM_Object* GetSumoObject() { return m_sumoObj; }; - */ + virtual bool IsPositiveTrigger() { bool result = m_bTriggered; @@ -115,7 +109,7 @@ public: } - void EndFrame(); + virtual void EndFrame(); // todo: put some info for collision maybe diff --git a/source/gameengine/Ketsji/KX_WorldIpoController.h b/source/gameengine/Ketsji/KX_WorldIpoController.h index 5967db42235..562a2769807 100644 --- a/source/gameengine/Ketsji/KX_WorldIpoController.h +++ b/source/gameengine/Ketsji/KX_WorldIpoController.h @@ -53,11 +53,12 @@ private: double m_ipotime; public: - KX_WorldIpoController() : m_ipotime(0.0), - m_modify_mist_color(false), - m_modify_mist_start(false), - m_modify_mist_dist(false), - m_modified(true) + KX_WorldIpoController() : + m_modify_mist_color(false), + m_modify_mist_start(false), + m_modify_mist_dist(false), + m_modified(true), + m_ipotime(0.0) {} virtual ~KX_WorldIpoController(); diff --git a/source/gameengine/Ketsji/Makefile b/source/gameengine/Ketsji/Makefile index 3884be14ded..f12e1c08ed4 100644 --- a/source/gameengine/Ketsji/Makefile +++ b/source/gameengine/Ketsji/Makefile @@ -42,7 +42,8 @@ CPPFLAGS += $(OGL_CPPFLAGS) CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION) CPPFLAGS += -I$(NAN_STRING)/include CPPFLAGS += -I$(NAN_SOUNDSYSTEM)/include -CPPFLAGS += -I$(NAN_FUZZICS)/include -I$(NAN_SUMO)/include -I$(NAN_MOTO)/include +CPPFLAGS += -I$(NAN_FUZZICS)/include -I$(NAN_SUMO) -I$(NAN_MOTO)/include +CPPFLAGS += -I$(NAN_SOLID)/include CPPFLAGS += -I../Rasterizer -I../GameLogic -I../SceneGraph CPPFLAGS += -I../BlenderRoutines -I../Expressions CPPFLAGS += -I../../kernel/gen_system diff --git a/source/gameengine/Ketsji/SConscript b/source/gameengine/Ketsji/SConscript index fddf4762013..4789138d1c2 100644 --- a/source/gameengine/Ketsji/SConscript +++ b/source/gameengine/Ketsji/SConscript @@ -1,3 +1,5 @@ +import sys + Import ('user_options_dict') Import ('library_env') @@ -59,6 +61,7 @@ if user_options_dict['USE_PHYSICS'] == 'solid': if user_options_dict['USE_PHYSICS'] == 'ode': source_files += ['KX_OdePhysicsController.cpp'] + ketsji_env.Append (CPPPATH = user_options_dict['SOLID_INCLUDE']) ketsji_env.Append (CPPPATH = ['.', '#source/kernel/gen_system', @@ -90,7 +93,7 @@ ketsji_env.Append (CPPPATH = ['.', '#source/gameengine/Physics/common', '#source/gameengine/Physics/BlOde', '#source/gameengine/Physics/Dummy', - '#source/gameengine/Physics/Sumo/', + '#source/gameengine/Physics/Sumo', '#source/gameengine/Physics/Sumo/include', '#source/gameengine/Physics/Sumo/Fuzzics/include', '#source/gameengine/Network/LoopBackNetwork', @@ -98,6 +101,8 @@ ketsji_env.Append (CPPPATH = ['.', '#source/blender/blenloader' ]) +if sys.platform == 'win32': + ketsji_env.Append (CXXFLAGS = ['/GR']) ketsji_env.Append (CPPPATH = user_options_dict['PYTHON_INCLUDE']) ketsji_env.Library (target='#'+user_options_dict['BUILD_DIR']+'/lib/KX_ketsji', source=source_files) diff --git a/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Debug.h b/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Debug.h new file mode 100644 index 00000000000..48d5906e53d --- /dev/null +++ b/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Debug.h @@ -0,0 +1,26 @@ + + +#ifndef __SM_DEBUG_H__ +#define __SM_DEBUG_H__ + +/* Comment this to disable all SUMO debugging printfs */ + +#define SM_DEBUG + +#ifdef SM_DEBUG + +#include <stdio.h> + +/* Uncomment this to printf all ray casts */ +//#define SM_DEBUG_RAYCAST + +/* Uncomment this to printf collision callbacks */ +//#define SM_DEBUG_BOING + +/* Uncomment this to printf Xform matrix calculations */ +//#define SM_DEBUG_XFORM + +#endif /* SM_DEBUG */ + +#endif /* __SM_DEBUG_H__ */ + diff --git a/source/gameengine/Physics/Sumo/Fuzzics/include/SM_FhObject.h b/source/gameengine/Physics/Sumo/Fuzzics/include/SM_FhObject.h index 36ba075eeff..116eed12cea 100644 --- a/source/gameengine/Physics/Sumo/Fuzzics/include/SM_FhObject.h +++ b/source/gameengine/Physics/Sumo/Fuzzics/include/SM_FhObject.h @@ -1,3 +1,34 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ #ifndef SM_FHOBJECT_H #define SM_FHOBJECT_H @@ -5,19 +36,15 @@ class SM_FhObject : public SM_Object { public: - SM_FhObject() {} - SM_FhObject(const MT_Vector3& ray, SM_Object *client_object) : - SM_Object(DT_Ray(ray[0], ray[1], ray[2]), 0, 0, 0), - m_ray(ray), - m_ray_direction(ray.normalized()), - m_client_object(client_object) {} + virtual ~SM_FhObject(); + SM_FhObject(DT_ShapeHandle rayshape, MT_Vector3 ray, SM_Object *parent_object); const MT_Vector3& getRay() const { return m_ray; } MT_Point3 getSpot() const { return m_pos + m_ray; } const MT_Vector3& getRayDirection() const { return m_ray_direction; } - SM_Object *getClientObject() const { return m_client_object; } + SM_Object *getParentObject() const { return m_parent_object; } - static void ray_hit(void *client_data, + static DT_Bool ray_hit(void *client_data, void *object1, void *object2, const DT_CollData *coll_data); @@ -25,7 +52,7 @@ public: private: MT_Vector3 m_ray; MT_Vector3 m_ray_direction; - SM_Object *m_client_object; + SM_Object *m_parent_object; }; #endif diff --git a/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Object.h b/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Object.h index 5342ba5d3a5..c84a3c2ff56 100644 --- a/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Object.h +++ b/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Object.h @@ -1,9 +1,40 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ #ifndef SM_OBJECT_H #define SM_OBJECT_H #include <vector> -#include "solid.h" +#include <SOLID/SOLID.h> #include "SM_Callback.h" #include "SM_MotionState.h" @@ -15,6 +46,7 @@ class SM_FhObject; // Properties of dynamic objects struct SM_ShapeProps { MT_Scalar m_mass; // Total mass + MT_Scalar m_radius; // Bound sphere size MT_Scalar m_inertia; // Inertia, should be a tensor some time MT_Scalar m_lin_drag; // Linear drag (air, water) 0 = concrete, 1 = vacuum MT_Scalar m_ang_drag; // Angular drag @@ -36,6 +68,7 @@ struct SM_MaterialProps { }; + class SM_Object : public SM_MotionState { public: SM_Object() ; @@ -45,7 +78,6 @@ public: const SM_ShapeProps *shapeProps, SM_Object *dynamicParent ); - virtual ~SM_Object(); bool isDynamic() const; @@ -89,7 +121,7 @@ public: void setMargin(MT_Scalar margin) ; MT_Scalar getMargin() const ; - + const SM_MaterialProps *getMaterialProps() const ; const SM_ShapeProps *getShapeProps() const ; @@ -164,7 +196,8 @@ public: void applyAngularImpulse(const MT_Vector3& impulse); MT_Point3 getWorldCoord(const MT_Point3& local) const; - + MT_Point3 getLocalCoord(const MT_Point3& world) const; + MT_Vector3 getVelocity(const MT_Point3& local) const; @@ -180,9 +213,6 @@ public: DT_ObjectHandle getObjectHandle() const ; DT_ShapeHandle getShapeHandle() const ; - void setClientObject(void *clientobj) ; - void *getClientObject() ; - SM_Object *getDynamicParent() ; void integrateForces(MT_Scalar timeStep); @@ -192,10 +222,9 @@ public: bool isRigidBody() const ; - // This is the callback for handling collisions of dynamic objects static - void + DT_Bool boing( void *client_data, void *object1, @@ -203,6 +232,26 @@ public: const DT_CollData *coll_data ); + static + DT_Bool + fix( + void *client_data, + void *object1, + void *object2, + const DT_CollData *coll_data + ); + + + void *getClientObject() { return m_client_object; } + void setClientObject(void *client_object) { m_client_object = client_object; } + + void relax(); + + void backup() { + m_pos = m_prev_state.getPosition(); + m_orn = m_prev_state.getOrientation(); + m_xform = m_prev_xform; + } private: // return the actual linear_velocity of this object this @@ -217,11 +266,20 @@ private: MT_Vector3 actualAngVelocity( ) const ; + + void dynamicCollision(MT_Point3 local2, + MT_Vector3 normal, + MT_Scalar dist, + MT_Vector3 rel_vel, + MT_Scalar restitution, + MT_Scalar friction_factor, + MT_Scalar invMass + ); typedef std::vector<SM_Callback *> T_CallbackList; - T_CallbackList m_callbackList; // Each object can have multiple callbacks from the client (=game engine) + T_CallbackList m_callbackList; // Each object can have multiple callbacks from the client (=game engine) SM_Object *m_dynamicParent; // Collisions between parent and children are ignored // as the collision callback now has only information @@ -229,7 +287,7 @@ private: // can identify it's clientdata after a collision void *m_client_object; - DT_ShapeHandle m_shape; // Shape for collision detection + DT_ShapeHandle m_shape; // Shape for collision detection // Material and shape properties are not owned by this class. @@ -237,7 +295,7 @@ private: const SM_MaterialProps *m_materialPropsBackup; // Backup in case the object temporarily becomes a ghost. const SM_ShapeProps *m_shapeProps; const SM_ShapeProps *m_shapePropsBackup; // Backup in case the object's dynamics is temporarily suspended - DT_ObjectHandle m_object; // A handle to the corresponding object in SOLID. + DT_ObjectHandle m_object; // A handle to the corresponding object in SOLID. MT_Scalar m_margin; // Offset for the object's shape (also for collision detection) MT_Vector3 m_scaling; // Non-uniform scaling of the object's shape @@ -258,6 +316,8 @@ private: MT_Vector3 m_ang_mom; // Angular momentum (angualr velocity times inertia) MT_Vector3 m_force; // Force on center of mass (afffects linear momentum) MT_Vector3 m_torque; // Torque around center of mass (affects angualr momentum) + + MT_Vector3 m_error; // Error in position:- amount object must be moved to prevent intersection with scene // Here are the values of externally set linear and angular // velocity. These are updated from the outside diff --git a/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Scene.h b/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Scene.h index 1d4a4afc721..7afa2a59084 100644 --- a/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Scene.h +++ b/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Scene.h @@ -2,38 +2,70 @@ * $Id$ * Copyright (C) 2001 NaN Technologies B.V. * The physics scene. + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ - #ifndef SM_SCENE_H #define SM_SCENE_H +#ifdef WIN32 #pragma warning (disable : 4786) +#endif #include <vector> #include <set> #include <utility> //needed for pair -#include "solid.h" +#include <SOLID/SOLID.h> #include "MT_Vector3.h" #include "MT_Point3.h" -class SM_Object; +#include "SM_Object.h" + +typedef enum +{ + FH_RESPONSE, + SENSOR_RESPONSE, /* Touch Sensors */ + CAMERA_RESPONSE, /* Visibility Culling */ + OBJECT_RESPONSE, /* Object Dynamic Geometry Response */ + STATIC_RESPONSE, /* Static Geometry Response */ + + NUM_RESPONSE +}; class SM_Scene { public: - SM_Scene() : - m_scene(DT_CreateScene()), - m_respTable(DT_CreateRespTable()), - m_secondaryRespTable(0), - m_forceField(0.0, 0.0, 0.0) - {} + SM_Scene(); - ~SM_Scene() { - DT_DeleteRespTable(m_respTable); - DT_DeleteScene(m_scene); - } - + ~SM_Scene(); + DT_RespTableHandle getRespTableHandle() const { return m_respTable; } @@ -50,6 +82,9 @@ public: m_forceField = forceField; } + void addTouchCallback(int response_class, DT_ResponseCallback callback, void *user); + + void addSensor(SM_Object& object); void add(SM_Object& object); void remove(SM_Object& object); @@ -61,9 +96,10 @@ public: m_pairList.clear(); } - void setSecondaryRespTable(DT_RespTableHandle secondaryRespTable) { - m_secondaryRespTable = secondaryRespTable; - } + void setSecondaryRespTable(DT_RespTableHandle secondaryRespTable); + DT_RespTableHandle getSecondaryRespTable() { return m_secondaryRespTable; } + + void requestCollisionCallback(SM_Object &object); // Perform an integration step of duration 'timeStep'. @@ -96,7 +132,16 @@ private: // Clear the user set velocities. void clearObjectCombinedVelocities(); - + // This is the callback for handling collisions of dynamic objects + static + DT_Bool + boing( + void *client_data, + void *object1, + void *object2, + const DT_CollData *coll_data + ); + /** internal type */ typedef std::vector<SM_Object *> T_ObjectList; /** internal type */ @@ -106,10 +151,19 @@ private: DT_SceneHandle m_scene; /** Following response table contains the callbacks for the dynmics */ DT_RespTableHandle m_respTable; + DT_ResponseClass m_ResponseClass[NUM_RESPONSE]; /** * Following response table contains callbacks for the client (= * game engine) */ DT_RespTableHandle m_secondaryRespTable; // Handle + DT_ResponseClass m_secondaryResponseClass[NUM_RESPONSE]; + + /** + * Following resposne table contains callbacks for fixing the simulation + * ie making sure colliding objects do not intersect. + */ + DT_RespTableHandle m_fixRespTable; + DT_ResponseClass m_fixResponseClass[NUM_RESPONSE]; /** The acceleration from the force field */ MT_Vector3 m_forceField; diff --git a/source/gameengine/Physics/Sumo/Fuzzics/sample/particle.cpp b/source/gameengine/Physics/Sumo/Fuzzics/sample/particle.cpp index 53b9ae684f3..d7aca326b42 100644 --- a/source/gameengine/Physics/Sumo/Fuzzics/sample/particle.cpp +++ b/source/gameengine/Physics/Sumo/Fuzzics/sample/particle.cpp @@ -17,7 +17,7 @@ #include "SM_FhObject.h" #include "SM_Scene.h" -#include "solid.h" +#include <SOLID/SOLID.h> #ifdef HAVE_CONFIG_H #include <config.h> diff --git a/source/gameengine/Physics/Sumo/Fuzzics/src/Makefile b/source/gameengine/Physics/Sumo/Fuzzics/src/Makefile index 5e3b35f6cf4..b2744c5496a 100644 --- a/source/gameengine/Physics/Sumo/Fuzzics/src/Makefile +++ b/source/gameengine/Physics/Sumo/Fuzzics/src/Makefile @@ -3,11 +3,12 @@ # Copyright (C) 2001 NaN Technologies B.V. LIBNAME = fuzzics -DIR = $(OCGDIR)/sumo +DIR = $(OCGDIR)/gameengine/blphys/$(LIBNAME) include nan_compile.mk CCFLAGS += $(LEVEL_1_CPP_WARNINGS) CPPFLAGS += -I../include -I$(NAN_MOTO)/include -I../../include +CPPFLAGS += -I$(NAN_SOLID)/include diff --git a/source/gameengine/Physics/Sumo/Fuzzics/src/SM_FhObject.cpp b/source/gameengine/Physics/Sumo/Fuzzics/src/SM_FhObject.cpp index 0ba5fd673ca..c6134bde8f8 100644 --- a/source/gameengine/Physics/Sumo/Fuzzics/src/SM_FhObject.cpp +++ b/source/gameengine/Physics/Sumo/Fuzzics/src/SM_FhObject.cpp @@ -1,3 +1,34 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ #include "SM_FhObject.h" #include "MT_MinMax.h" @@ -5,52 +36,82 @@ #include <config.h> #endif -void SM_FhObject::ray_hit(void *client_data, +SM_FhObject::SM_FhObject(DT_ShapeHandle rayshape, MT_Vector3 ray, SM_Object *parent_object) : + SM_Object(rayshape, NULL, NULL, NULL), + m_ray(ray), + m_ray_direction(ray.normalized()), + m_parent_object(parent_object) +{ +} + +SM_FhObject::~SM_FhObject() +{ +} + +DT_Bool SM_FhObject::ray_hit(void *client_data, void *client_object1, void *client_object2, - const DT_CollData *coll_data) { + const DT_CollData *coll_data) +{ + SM_FhObject *fh_object = dynamic_cast<SM_FhObject *>((SM_Object *)client_object2); + if (!fh_object) + { + std::swap(client_object1, client_object2); + fh_object = dynamic_cast<SM_FhObject *>((SM_Object *)client_object2); + } + SM_Object *hit_object = (SM_Object *)client_object1; const SM_MaterialProps *matProps = hit_object->getMaterialProps(); - + if ((matProps == 0) || (matProps->m_fh_distance < MT_EPSILON)) { - return; + return DT_CONTINUE; } - SM_FhObject *fh_object = (SM_FhObject *)client_object2; - SM_Object *cl_object = fh_object->getClientObject(); + SM_Object *cl_object = fh_object->getParentObject(); + + assert(fh_object); if (hit_object == cl_object) { // Shot myself in the foot... - return; + return DT_CONTINUE; } const SM_ShapeProps *shapeProps = cl_object->getShapeProps(); // Exit if the client object is not dynamic. if (shapeProps == 0) { - return; + return DT_CONTINUE; } MT_Point3 lspot; MT_Vector3 normal; - if (DT_ObjectRayTest(hit_object->getObjectHandle(), - fh_object->getPosition().getValue(), - fh_object->getSpot().getValue(), - lspot.getValue(), normal.getValue())) { + DT_Vector3 from, to, dnormal; + DT_Scalar dlspot; + fh_object->getPosition().getValue(from); + fh_object->getSpot().getValue(to); + + + if (DT_ObjectRayCast(hit_object->getObjectHandle(), + from, + to, + 1., + &dlspot, + dnormal)) { + lspot = fh_object->getPosition() + (fh_object->getSpot() - fh_object->getPosition()) * dlspot; const MT_Vector3& ray_dir = fh_object->getRayDirection(); - MT_Scalar dist = MT_distance(fh_object->getPosition(), - hit_object->getWorldCoord(lspot)) - - cl_object->getMargin(); + MT_Scalar dist = MT_distance(fh_object->getPosition(), lspot) - + cl_object->getMargin() - shapeProps->m_radius; - normal.normalize(); - + normal = MT_Vector3(dnormal).safe_normalized(); + if (dist < matProps->m_fh_distance) { if (shapeProps->m_do_fh) { - MT_Vector3 rel_vel = cl_object->getLinearVelocity() - hit_object->getVelocity(lspot); + lspot -= hit_object->getPosition(); + MT_Vector3 rel_vel = cl_object->getLinearVelocity() - hit_object->getVelocity(lspot); MT_Scalar rel_vel_ray = ray_dir.dot(rel_vel); MT_Scalar spring_extent = 1.0 - dist / matProps->m_fh_distance; @@ -84,7 +145,7 @@ void SM_FhObject::ray_hit(void *client_data, if (rel_vel_lateral > MT_EPSILON) { MT_Scalar friction_factor = matProps->m_friction; - MT_Scalar max_friction = friction_factor * MT_max(0.0, i_spring); + MT_Scalar max_friction = friction_factor * MT_max(MT_Scalar(0.0), i_spring); MT_Scalar rel_mom_lateral = rel_vel_lateral / cl_object->getInvMass(); @@ -113,6 +174,8 @@ void SM_FhObject::ray_hit(void *client_data, } } } + + return DT_CONTINUE; } diff --git a/source/gameengine/Physics/Sumo/Fuzzics/src/SM_Object.cpp b/source/gameengine/Physics/Sumo/Fuzzics/src/SM_Object.cpp index 51673b92ffb..84aef195a9e 100644 --- a/source/gameengine/Physics/Sumo/Fuzzics/src/SM_Object.cpp +++ b/source/gameengine/Physics/Sumo/Fuzzics/src/SM_Object.cpp @@ -2,6 +2,34 @@ * $Id$ * Copyright (C) 2001 NaN Technologies B.V. * The basic physics object. + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ #ifdef HAVE_CONFIG_H @@ -17,25 +45,29 @@ #include "SM_Object.h" #include "SM_Scene.h" #include "SM_FhObject.h" +#include "SM_Debug.h" #include "MT_MinMax.h" // Tweak parameters -static MT_Scalar ImpulseThreshold = 0.5; - +static const MT_Scalar ImpulseThreshold = 0.5; +static const MT_Scalar FixThreshold = 0.01; +static const MT_Scalar FixVelocity = 0.01; SM_Object::SM_Object( DT_ShapeHandle shape, const SM_MaterialProps *materialProps, const SM_ShapeProps *shapeProps, - SM_Object *dynamicParent -) : + SM_Object *dynamicParent) : + + m_dynamicParent(dynamicParent), + m_client_object(0), + m_shape(shape), m_materialProps(materialProps), m_materialPropsBackup(0), m_shapeProps(shapeProps), m_shapePropsBackup(0), - m_dynamicParent(dynamicParent), m_object(DT_CreateObject(this, shape)), m_margin(0.0), m_scaling(1.0, 1.0, 1.0), @@ -48,23 +80,22 @@ SM_Object::SM_Object( m_ang_mom(0.0, 0.0, 0.0), m_force(0.0, 0.0, 0.0), m_torque(0.0, 0.0, 0.0), - m_client_object(0), - m_fh_object(0), - + m_error(0.0, 0.0, 0.0), m_combined_lin_vel (0.0, 0.0, 0.0), - m_combined_ang_vel (0.0, 0.0, 0.0) + m_combined_ang_vel (0.0, 0.0, 0.0), + m_fh_object(0) { m_xform.setIdentity(); m_xform.getValue(m_ogl_matrix); if (shapeProps && (shapeProps->m_do_fh || shapeProps->m_do_rot_fh)) { - MT_Vector3 ray(0.0, 0.0, -10.0); - m_fh_object = new SM_FhObject(ray, this); + DT_Vector3 zero = {0., 0., 0.}, ray = {0.0, 0.0, -10.0}; + m_fh_object = new SM_FhObject(DT_NewLineSegment(zero, ray), MT_Vector3(ray), this); + //printf("SM_Object:: WARNING! fh disabled.\n"); } m_suspended = false; } - void SM_Object:: integrateForces( @@ -129,258 +160,310 @@ integrateMomentum( } } +void SM_Object::dynamicCollision(MT_Point3 local2, + MT_Vector3 normal, + MT_Scalar dist, + MT_Vector3 rel_vel, + MT_Scalar restitution, + MT_Scalar friction_factor, + MT_Scalar invMass +) +{ + // Same again but now obj1 is non-dynamic + // Compute the point on obj1 closest to obj2 (= sphere with radius = 0) + // local1 is th point closest to obj2 + // local2 is the local origin of obj2 + if (MT_EPSILON < dist) { + //printf("SM_Object::Boing: local2 = { %0.5f, %0.5f, %0.5f } (%0.5f)\n", + // local2[0], local2[1], local2[2], local2.length()); + + // the normal to the contact plane + normal /= dist; + + // wr2 points from obj2's origin to the global contact point + // wr2 is only needed for rigid bodies (objects for which the + // friction can change the angular momentum). + // vel2 is adapted to denote the velocity of the contact point + // This should look familiar.... + MT_Scalar rel_vel_normal = normal.dot(rel_vel); + + //printf(" rel_vel = { %0.5f, %0.5f, %0.5f } (%0.5f)\n", + // rel_vel[0], rel_vel[1], rel_vel[2], rel_vel.length()); + + if (rel_vel_normal <= 0.0) { + if (-rel_vel_normal < ImpulseThreshold) { + restitution = 0.0; + } + + MT_Scalar impulse = -(1.0 + restitution) * rel_vel_normal / invMass; + applyCenterImpulse( impulse * normal); + +// The friction part starts here!!!!!!!! + + // Compute the lateral component of the relative velocity + // lateral actually points in the opposite direction, i.e., + // into the direction of the friction force. -void SM_Object::boing( +#if 0 + // test - only do friction on the physics part of the + // velocity. + vel1 -= obj1->m_combined_lin_vel; + vel2 -= obj2->m_combined_lin_vel; + + // This should look familiar.... + rel_vel = vel2 - vel1; + rel_vel_normal = normal.dot(rel_vel); +#endif + + MT_Vector3 lateral = rel_vel - normal * rel_vel_normal; + //printf(" lateral = { %0.5f, %0.5f, %0.5f } (%0.5f)\n", + // lateral[0], lateral[1], lateral[2], lateral.length()); + + //const SM_ShapeProps *shapeProps = obj2->getShapeProps(); + + if (m_shapeProps->m_do_anisotropic) { + + // For anisotropic friction we scale the lateral component, + // rather than compute a direction-dependent fricition + // factor. For this the lateral component is transformed to + // local coordinates. + + MT_Matrix3x3 lcs(m_orn); + // We cannot use m_xform.getBasis() for the matrix, since + // it might contain a non-uniform scaling. + // OPT: it's a bit daft to compute the matrix since the + // quaternion itself can be used to do the transformation. + + MT_Vector3 loc_lateral = lateral * lcs; + // lcs is orthogonal so lcs.inversed() == lcs.transposed(), + // and lcs.transposed() * lateral == lateral * lcs. + + const MT_Vector3& friction_scaling = + m_shapeProps->m_friction_scaling; + + // Scale the local lateral... + loc_lateral.scale(friction_scaling[0], + friction_scaling[1], + friction_scaling[2]); + // ... and transform it back to global coordinates + lateral = lcs * loc_lateral; + } + + // A tiny Coulomb friction primer: + // The Coulomb friction law states that the magnitude of the + // maximum possible friction force depends linearly on the + // magnitude of the normal force. + // + // F_max_friction = friction_factor * F_normal + // + // (NB: independent of the contact area!!) + // + // The friction factor depends on the material. + // We use impulses rather than forces but let us not be + // bothered by this. + + + MT_Scalar rel_vel_lateral = lateral.length(); + //printf("rel_vel = { %0.05f, %0.05f, %0.05f}\n", rel_vel[0], rel_vel[1], rel_vel[2]); + //printf("n.l = %0.15f\n", normal.dot(lateral)); /* Should be 0.0 */ + + if (rel_vel_lateral > MT_EPSILON) { + lateral /= rel_vel_lateral; + + // Compute the maximum friction impulse + MT_Scalar max_friction = + friction_factor * MT_max(MT_Scalar(0.0), impulse); + + // I guess the GEN_max is not necessary, so let's check it + + assert(impulse >= 0.0); + + // Here's the trick. We compute the impulse to make the + // lateral velocity zero. (Make the objects stick together + // at the contact point. If this impulse is larger than + // the maximum possible friction impulse, then shrink its + // magnitude to the maximum friction. + + if (isRigidBody()) { + + // For rigid bodies we take the inertia into account, + // since the friction impulse is going to change the + // angular momentum as well. + MT_Vector3 temp = getInvInertia() * local2.cross(lateral); + MT_Scalar impulse_lateral = rel_vel_lateral / + (invMass + lateral.dot(temp.cross(local2))); + + MT_Scalar friction = MT_min(impulse_lateral, max_friction); + applyImpulse(local2 + m_pos, -lateral * friction); + } + else { + MT_Scalar impulse_lateral = rel_vel_lateral / invMass; + + MT_Scalar friction = MT_min(impulse_lateral, max_friction); + applyCenterImpulse( -friction * lateral); + } + + + } + + calcXform(); + notifyClient(); + + } + } +} + +DT_Bool SM_Object::boing( void *client_data, void *object1, void *object2, const DT_CollData *coll_data ){ + //if (!coll_data) + // return DT_CONTINUE; + SM_Scene *scene = (SM_Scene *)client_data; SM_Object *obj1 = (SM_Object *)object1; SM_Object *obj2 = (SM_Object *)object2; scene->addPair(obj1, obj2); // Record this collision for client callbacks + // If one of the objects is a ghost then ignore it for the dynamics + if (obj1->isGhost() || obj2->isGhost()) { + return DT_CONTINUE; + } + + // Objects do not collide with parent objects + if (obj1->getDynamicParent() == obj2 || obj2->getDynamicParent() == obj1) { + return DT_CONTINUE; + } + + if (!obj2->isDynamic()) { + std::swap(obj1, obj2); + } + if (!obj2->isDynamic()) { + return DT_CONTINUE; + } + + // Get collision data from SOLID + DT_Vector3 p1, p2; + if (!DT_GetPenDepth(obj1->getObjectHandle(), obj2->getObjectHandle(), p1, p2)) + return DT_CONTINUE; + MT_Point3 local1(p1), local2(p2); + MT_Vector3 normal(local2 - local1); + MT_Scalar dist = normal.length(); + + local1 -= obj1->m_pos, local2 -= obj2->m_pos; + + // Calculate collision parameters + MT_Vector3 rel_vel = obj1->getVelocity(local1) + obj1->m_combined_lin_vel - + obj2->getVelocity(local2) - obj2->m_combined_lin_vel; + + MT_Scalar restitution = + MT_min(obj1->getMaterialProps()->m_restitution, + obj2->getMaterialProps()->m_restitution); + + MT_Scalar friction_factor = + MT_min(obj1->getMaterialProps()->m_friction, + obj2->getMaterialProps()->m_friction); + + MT_Scalar invMass = obj1->getInvMass() + obj2->getInvMass(); + + // Calculate reactions + if (obj1->isDynamic()) + obj1->dynamicCollision(local1, normal, dist, rel_vel, restitution, friction_factor, invMass); + + if (obj2->isDynamic()) + obj2->dynamicCollision(local2, -normal, dist, -rel_vel, restitution, friction_factor, invMass); + + return DT_CONTINUE; +} + +DT_Bool SM_Object::fix( + void *client_data, + void *object1, + void *object2, + const DT_CollData *coll_data +){ + SM_Scene *scene = (SM_Scene *)client_data; + SM_Object *obj1 = (SM_Object *)object1; + SM_Object *obj2 = (SM_Object *)object2; + // If one of the objects is a ghost then ignore it for the dynamics if (obj1->isGhost() || obj2->isGhost()) { - return; + return DT_CONTINUE; } + if (obj1->getDynamicParent() == obj2 || obj2->getDynamicParent() == obj1) { + return DT_CONTINUE; + } if (!obj2->isDynamic()) { std::swap(obj1, obj2); } if (!obj2->isDynamic()) { - return; + return DT_CONTINUE; } // obj1 points to a dynamic object - + DT_Vector3 p1, p2; + if (!DT_GetPenDepth(obj1->getObjectHandle(), obj2->getObjectHandle(), p1, p2)) + return DT_CONTINUE; + MT_Point3 local1(p1), local2(p2); + // Get collision data from SOLID + MT_Vector3 normal(local2 - local1); // This distinction between dynamic and non-dynamic objects should not be // necessary. Non-dynamic objects are assumed to have infinite mass. - if (obj1->isDynamic()) { - // normal to the contact plane - MT_Vector3 normal = obj2->m_pos - obj1->m_pos; - MT_Scalar dist = normal.length(); - - if (MT_EPSILON < dist && dist <= obj1->getMargin() + obj2->getMargin()) - { - normal /= dist; - // relative velocity of the contact points - MT_Vector3 rel_vel = obj2->actualLinVelocity() - obj1->actualLinVelocity(); - // relative velocity projected onto the normal - MT_Scalar rel_vel_normal = normal.dot(rel_vel); - - // if the objects are approaching eachother... - if (rel_vel_normal < 0.0) { - MT_Scalar restitution; - // ...and the approaching velocity is large enough... - if (-rel_vel_normal > ImpulseThreshold) { - // ...this must be a true collision. - restitution = - MT_min(obj1->getMaterialProps()->m_restitution, - obj2->getMaterialProps()->m_restitution); - } - else { - // otherwise, it is a resting contact, and thus the - // relative velocity must be made zero - restitution = 0.0; - // We also need to interfere with the positions of the - // objects, otherwise they might drift into eachother. - MT_Vector3 penalty = normal * - (0.5 * (obj1->getMargin() + obj2->getMargin() - dist)); - obj1->m_pos -= penalty; - obj2->m_pos += penalty; - } - - // Compute the impulse necessary to yield the desired relative velocity... - MT_Scalar impulse = -(1.0 + restitution) * rel_vel_normal / - (obj1->getInvMass() + obj2->getInvMass()); - - // ... and apply it. - obj1->applyCenterImpulse(-impulse * normal); - obj2->applyCenterImpulse( impulse * normal); - } + MT_Vector3 error = normal * 0.5f; + obj1->m_error += error; + obj2->m_error -= error; + // Remove the velocity component in the normal direction + // Calculate collision parameters + MT_Vector3 rel_vel = obj1->getLinearVelocity() - obj2->getLinearVelocity(); + if (normal.length() > FixThreshold && rel_vel.length() < FixVelocity) { + normal.normalize(); + MT_Scalar rel_vel_normal = 0.49*(normal.dot(rel_vel)); + + obj1->addLinearVelocity(-rel_vel_normal*normal); + obj2->addLinearVelocity(rel_vel_normal*normal); } } else { // Same again but now obj1 is non-dynamic - - // Compute the point on obj1 closest to obj2 (= sphere with radius = 0) - MT_Point3 local1, local2; - MT_Scalar dist = DT_GetClosestPair(obj1->m_object, obj2->m_object, - local1.getValue(), local2.getValue()); - - // local1 is th point closest to obj2 - // local2 is the local origin of obj2 - - if (MT_EPSILON < dist && dist <= obj2->getMargin()) { - MT_Point3 world1 = obj1->getWorldCoord(local1); - MT_Point3 world2 = obj2->getWorldCoord(local2); - MT_Vector3 vel1 = obj1->getVelocity(local1) + obj1->m_combined_lin_vel; - MT_Vector3 vel2 = obj2->getVelocity(local2) + obj2->m_combined_lin_vel; - - // the normal to the contact plane - MT_Vector3 normal = world2 - world1; - normal /= dist; - - // wr2 points from obj2's origin to the global contact point - // wr2 is only needed for rigid bodies (objects for which the - // friction can change the angular momentum). - // vel2 is adapted to denote the velocity of the contact point - MT_Vector3 wr2; - if (obj2->isRigidBody()) { - wr2 = -obj2->getMargin() * normal; - vel2 += obj2->actualAngVelocity().cross(wr2); - } - - - // This should look familiar.... - MT_Vector3 rel_vel = vel2 - vel1; - MT_Scalar rel_vel_normal = normal.dot(rel_vel); - - if (rel_vel_normal < 0.0) { - MT_Scalar restitution; - if (-rel_vel_normal > ImpulseThreshold) { - restitution = - MT_min(obj1->getMaterialProps()->m_restitution, - obj2->getMaterialProps()->m_restitution); - } - else { - restitution = 0.0; - // We fix drift by moving obj2 only, since obj1 was - // non-dynamic. - obj2->m_pos += normal * (obj2->getMargin() - dist); - - } - - MT_Scalar impulse = -(1.0 + restitution) * rel_vel_normal / - (obj1->getInvMass() + obj2->getInvMass()); - - - obj2->applyCenterImpulse( impulse * normal); - -// The friction part starts here!!!!!!!! - - // Compute the lateral component of the relative velocity - // lateral actually points in the opposite direction, i.e., - // into the direction of the friction force. - -#if 1 - // test - only do friction on the physics part of the - // velocity. - vel1 -= obj1->m_combined_lin_vel; - vel2 -= obj2->m_combined_lin_vel; - - // This should look familiar.... - rel_vel = vel2 - vel1; - rel_vel_normal = normal.dot(rel_vel); -#endif - - MT_Vector3 lateral = normal * rel_vel_normal - rel_vel; - - const SM_ShapeProps *shapeProps = obj2->getShapeProps(); - - if (shapeProps->m_do_anisotropic) { - - // For anisotropic friction we scale the lateral component, - // rather than compute a direction-dependent fricition - // factor. For this the lateral component is transformed to - // local coordinates. - - MT_Matrix3x3 lcs(obj2->m_orn); - // We cannot use m_xform.getBasis() for the matrix, since - // it might contain a non-uniform scaling. - // OPT: it's a bit daft to compute the matrix since the - // quaternion itself can be used to do the transformation. - - MT_Vector3 loc_lateral = lateral * lcs; - // lcs is orthogonal so lcs.inversed() == lcs.transposed(), - // and lcs.transposed() * lateral == lateral * lcs. - - const MT_Vector3& friction_scaling = - shapeProps->m_friction_scaling; - - // Scale the local lateral... - loc_lateral.scale(friction_scaling[0], - friction_scaling[1], - friction_scaling[2]); - // ... and transform it back to global coordinates - lateral = lcs * loc_lateral; - } - - // A tiny Coulomb friction primer: - // The Coulomb friction law states that the magnitude of the - // maximum possible friction force depends linearly on the - // magnitude of the normal force. - // - // F_max_friction = friction_factor * F_normal - // - // (NB: independent of the contact area!!) - // - // The friction factor depends on the material. - // We use impulses rather than forces but let us not be - // bothered by this. - - - MT_Scalar rel_vel_lateral = lateral.length(); - - if (rel_vel_lateral > MT_EPSILON) { - lateral /= rel_vel_lateral; - - MT_Scalar friction_factor = - MT_min(obj1->getMaterialProps()->m_friction, - obj2->getMaterialProps()->m_friction); - - // Compute the maximum friction impulse - - MT_Scalar max_friction = - friction_factor * MT_max(0.0, impulse); - - // I guess the GEN_max is not necessary, so let's check it - - assert(impulse >= 0.0); - - // Here's the trick. We compute the impulse to make the - // lateral velocity zero. (Make the objects stick together - // at the contact point. If this impulse is larger than - // the maximum possible friction impulse, then shrink its - // magnitude to the maximum friction. - - if (obj2->isRigidBody()) { - - // For rigid bodies we take the inertia into account, - // since the friciton impulse is going to change the - // angular momentum as well. - MT_Scalar impulse_lateral = rel_vel_lateral / - (obj1->getInvMass() + obj2->getInvMass() + - ((obj2->getInvInertia() * wr2.cross(lateral)).cross(wr2)).dot(lateral)); - MT_Scalar friction = MT_min(impulse_lateral, max_friction); - obj2->applyImpulse(world2 + wr2, friction * lateral); - } - else { - MT_Scalar impulse_lateral = rel_vel_lateral / - (obj1->getInvMass() + obj2->getInvMass()); - - MT_Scalar friction = MT_min(impulse_lateral, max_friction); - obj2->applyCenterImpulse( friction * lateral); - } - } - - obj2->calcXform(); - obj2->notifyClient(); - } + obj2->m_error -= normal; + MT_Vector3 rel_vel = obj2->getLinearVelocity(); + if (normal.length() > FixThreshold && rel_vel.length() < FixVelocity) { + // Calculate collision parameters + normal.normalize(); + MT_Scalar rel_vel_normal = -0.99*(normal.dot(rel_vel)); + + obj2->addLinearVelocity(rel_vel_normal*normal); } } + + return DT_CONTINUE; } - - +void SM_Object::relax(void) +{ + if (m_error.fuzzyZero()) + return; + //std::cout << "SM_Object::relax: { " << m_error << " }" << std::endl; + + m_pos += m_error; + m_error.setValue(0., 0., 0.); +/* m_pos.getValue(pos); + DT_SetPosition(m_object, pos); + m_xform.setOrigin(m_pos); + m_xform.getValue(m_ogl_matrix); */ + calcXform(); + notifyClient(); +} + SM_Object::SM_Object( ) { // warning no initialization of variables done by moto. @@ -388,8 +471,11 @@ SM_Object::SM_Object( SM_Object:: ~SM_Object() { - delete m_fh_object; - DT_DeleteObject(m_object); + if (m_fh_object) + delete m_fh_object; + + DT_DestroyObject(m_object); + m_object = NULL; } bool @@ -489,14 +575,35 @@ registerCallback( void SM_Object:: calcXform() { +#ifdef SM_DEBUG_XFORM + printf("SM_Object::calcXform m_pos = { %-0.5f, %-0.5f, %-0.5f }\n", + m_pos[0], m_pos[1], m_pos[2]); + printf(" m_orn = { %-0.5f, %-0.5f, %-0.5f, %-0.5f }\n", + m_orn[0], m_orn[1], m_orn[2], m_orn[3]); + printf(" m_scaling = { %-0.5f, %-0.5f, %-0.5f }\n", + m_scaling[0], m_scaling[1], m_scaling[2]); +#endif m_xform.setOrigin(m_pos); m_xform.setBasis(MT_Matrix3x3(m_orn, m_scaling)); m_xform.getValue(m_ogl_matrix); + + /* Blender has been known to crash here. + This usually means SM_Object *this has been deleted more than once. */ DT_SetMatrixd(m_object, m_ogl_matrix); if (m_fh_object) { m_fh_object->setPosition(m_pos); m_fh_object->calcXform(); } +#ifdef SM_DEBUG_XFORM + printf("\n | %-0.5f %-0.5f %-0.5f %-0.5f |\n", + m_ogl_matrix[0], m_ogl_matrix[4], m_ogl_matrix[ 8], m_ogl_matrix[12]); + printf( " | %-0.5f %-0.5f %-0.5f %-0.5f |\n", + m_ogl_matrix[1], m_ogl_matrix[5], m_ogl_matrix[ 9], m_ogl_matrix[13]); + printf( "m_ogl_matrix = | %-0.5f %-0.5f %-0.5f %-0.5f |\n", + m_ogl_matrix[2], m_ogl_matrix[6], m_ogl_matrix[10], m_ogl_matrix[14]); + printf( " | %-0.5f %-0.5f %-0.5f %-0.5f |\n\n", + m_ogl_matrix[3], m_ogl_matrix[7], m_ogl_matrix[11], m_ogl_matrix[15]); +#endif } // Call callbacks to notify the client of a change of placement @@ -561,7 +668,7 @@ setMargin( MT_Scalar margin ) { m_margin = margin; - DT_SetMargin(m_object, margin); + DT_SetMargin(m_object, margin); } MT_Scalar @@ -841,11 +948,18 @@ getVelocity( // For displaced objects the velocity is faked using the previous state. // Dynamic objects get their own velocity, not the faked velocity. // (Dynamic objects shouldn't be displaced in the first place!!) - +/* FIXME: -KM- Valgrind report: +==17624== Use of uninitialised value of size 8 +==17624== at 0x831F925: MT_Vector3::dot(MT_Vector3 const&) const (MT_Tuple3.h:60) +==17624== by 0x82E4574: SM_Object::getVelocity(MT_Point3 const&) const (MT_Matrix3x3.h:81) +==17624== by 0x82E324D: SM_Object::boing(void*, void*, void*, DT_CollData const*) (SM_Object.cpp:319) +==17624== by 0x83E7308: DT_Encounter::exactTest(DT_RespTable const*, int&) const (in /home/kester/blender-src/DEBUG/blender) +*/ return m_prev_kinematic && !isDynamic() ? (m_xform(local) - m_prev_xform(local)) / m_timeStep : - m_lin_vel + m_ang_vel.cross(m_xform.getBasis() * local); + m_lin_vel + m_ang_vel.cross(local); + // m_lin_vel + m_ang_vel.cross(m_xform.getBasis() * local); // NB: m_xform.getBasis() * local == m_xform(local) - m_xform.getOrigin() } @@ -898,21 +1012,6 @@ getShapeHandle( return m_shape; } - void -SM_Object:: -setClientObject( - void *clientobj -) { - m_client_object = clientobj; -} - - void * -SM_Object:: -getClientObject( -){ - return m_client_object; -} - SM_Object * SM_Object:: getDynamicParent( diff --git a/source/gameengine/Physics/Sumo/Fuzzics/src/SM_Scene.cpp b/source/gameengine/Physics/Sumo/Fuzzics/src/SM_Scene.cpp index 424796ea71e..5ac65cbd816 100644 --- a/source/gameengine/Physics/Sumo/Fuzzics/src/SM_Scene.cpp +++ b/source/gameengine/Physics/Sumo/Fuzzics/src/SM_Scene.cpp @@ -2,6 +2,34 @@ * $Id$ * Copyright (C) 2001 NaN Technologies B.V. * The physics scene. + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ #ifdef HAVE_CONFIG_H @@ -16,31 +44,101 @@ #include "SM_Object.h" #include "SM_FhObject.h" +#include "SM_Debug.h" + #include <algorithm> +SM_Scene::SM_Scene() : + m_scene(DT_CreateScene()), + m_respTable(DT_CreateRespTable()), + m_secondaryRespTable(DT_CreateRespTable()), + m_fixRespTable(DT_CreateRespTable()), + m_forceField(0.0, 0.0, 0.0) +{ + for (int i = 0 ; i < NUM_RESPONSE; i++) + { + m_ResponseClass[i] = DT_GenResponseClass(m_respTable); + m_secondaryResponseClass[i] = DT_GenResponseClass(m_secondaryRespTable); + m_fixResponseClass[i] = DT_GenResponseClass(m_fixRespTable); + } + + /* Sensor */ + DT_AddPairResponse(m_respTable, m_ResponseClass[SENSOR_RESPONSE], m_ResponseClass[SENSOR_RESPONSE], 0, DT_NO_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[SENSOR_RESPONSE], m_ResponseClass[STATIC_RESPONSE], SM_Scene::boing, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[SENSOR_RESPONSE], m_ResponseClass[OBJECT_RESPONSE], SM_Scene::boing, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[SENSOR_RESPONSE], m_ResponseClass[FH_RESPONSE], 0, DT_NO_RESPONSE, this); + + /* Static */ + DT_AddPairResponse(m_respTable, m_ResponseClass[STATIC_RESPONSE], m_ResponseClass[SENSOR_RESPONSE], SM_Scene::boing, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[STATIC_RESPONSE], m_ResponseClass[STATIC_RESPONSE], 0, DT_NO_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[STATIC_RESPONSE], m_ResponseClass[OBJECT_RESPONSE], SM_Object::boing, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[STATIC_RESPONSE], m_ResponseClass[FH_RESPONSE], SM_FhObject::ray_hit, DT_SIMPLE_RESPONSE, this); + + /* Object */ + DT_AddPairResponse(m_respTable, m_ResponseClass[OBJECT_RESPONSE], m_ResponseClass[SENSOR_RESPONSE], SM_Scene::boing, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[OBJECT_RESPONSE], m_ResponseClass[STATIC_RESPONSE], SM_Object::boing, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[OBJECT_RESPONSE], m_ResponseClass[OBJECT_RESPONSE], SM_Object::boing, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[OBJECT_RESPONSE], m_ResponseClass[FH_RESPONSE], SM_FhObject::ray_hit, DT_SIMPLE_RESPONSE, this); + + /* Fh Object */ + DT_AddPairResponse(m_respTable, m_ResponseClass[FH_RESPONSE], m_ResponseClass[SENSOR_RESPONSE], 0, DT_NO_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[FH_RESPONSE], m_ResponseClass[STATIC_RESPONSE], SM_FhObject::ray_hit, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[FH_RESPONSE], m_ResponseClass[OBJECT_RESPONSE], SM_FhObject::ray_hit, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_respTable, m_ResponseClass[FH_RESPONSE], m_ResponseClass[FH_RESPONSE], 0, DT_NO_RESPONSE, this); + + /* Object (Fix Pass) */ + DT_AddPairResponse(m_fixRespTable, m_ResponseClass[OBJECT_RESPONSE], m_ResponseClass[SENSOR_RESPONSE], 0, DT_NO_RESPONSE, this); + DT_AddPairResponse(m_fixRespTable, m_ResponseClass[OBJECT_RESPONSE], m_ResponseClass[STATIC_RESPONSE], SM_Object::fix, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_fixRespTable, m_ResponseClass[OBJECT_RESPONSE], m_ResponseClass[OBJECT_RESPONSE], SM_Object::fix, DT_SIMPLE_RESPONSE, this); + DT_AddPairResponse(m_fixRespTable, m_ResponseClass[OBJECT_RESPONSE], m_ResponseClass[FH_RESPONSE], 0, DT_NO_RESPONSE, this); +} + +void SM_Scene::addTouchCallback(int response_class, DT_ResponseCallback callback, void *user) +{ + DT_AddClassResponse(m_secondaryRespTable, m_secondaryResponseClass[response_class], callback, DT_SIMPLE_RESPONSE, user); +} + +void SM_Scene::addSensor(SM_Object& object) +{ + object.calcXform(); + m_objectList.push_back(&object); + DT_AddObject(m_scene, object.getObjectHandle()); + DT_SetResponseClass(m_respTable, object.getObjectHandle(), m_ResponseClass[SENSOR_RESPONSE]); + DT_SetResponseClass(m_secondaryRespTable, object.getObjectHandle(), m_secondaryResponseClass[SENSOR_RESPONSE]); + DT_SetResponseClass(m_fixRespTable, object.getObjectHandle(), m_fixResponseClass[SENSOR_RESPONSE]); +} + void SM_Scene::add(SM_Object& object) { object.calcXform(); m_objectList.push_back(&object); DT_AddObject(m_scene, object.getObjectHandle()); if (object.isDynamic()) { - DT_SetObjectResponse(m_respTable, object.getObjectHandle(), - SM_Object::boing, DT_SIMPLE_RESPONSE, this); - } + DT_SetResponseClass(m_respTable, object.getObjectHandle(), m_ResponseClass[OBJECT_RESPONSE]); + DT_SetResponseClass(m_secondaryRespTable, object.getObjectHandle(), m_secondaryResponseClass[OBJECT_RESPONSE]); + DT_SetResponseClass(m_fixRespTable, object.getObjectHandle(), m_fixResponseClass[OBJECT_RESPONSE]); + } else { + DT_SetResponseClass(m_respTable, object.getObjectHandle(), m_ResponseClass[STATIC_RESPONSE]); + DT_SetResponseClass(m_secondaryRespTable, object.getObjectHandle(), m_secondaryResponseClass[STATIC_RESPONSE]); + DT_SetResponseClass(m_fixRespTable, object.getObjectHandle(), m_fixResponseClass[STATIC_RESPONSE]); + } - if (object.getDynamicParent()) { - DT_SetPairResponse(m_respTable, object.getObjectHandle(), - object.getDynamicParent()->getObjectHandle(), - 0, DT_NO_RESPONSE, 0); - } SM_FhObject *fh_object = object.getFhObject(); if (fh_object) { DT_AddObject(m_scene, fh_object->getObjectHandle()); - DT_SetObjectResponse(m_respTable, fh_object->getObjectHandle(), - SM_FhObject::ray_hit, DT_SIMPLE_RESPONSE, this); + DT_SetResponseClass(m_respTable, fh_object->getObjectHandle(), m_ResponseClass[FH_RESPONSE]); + DT_SetResponseClass(m_secondaryRespTable, fh_object->getObjectHandle(), m_secondaryResponseClass[FH_RESPONSE]); + DT_SetResponseClass(m_fixRespTable, fh_object->getObjectHandle(), m_fixResponseClass[FH_RESPONSE]); } } +void SM_Scene::requestCollisionCallback(SM_Object &object) +{ + DT_SetResponseClass(m_respTable, object.getObjectHandle(), m_ResponseClass[OBJECT_RESPONSE]); + DT_SetResponseClass(m_secondaryRespTable, object.getObjectHandle(), m_secondaryResponseClass[OBJECT_RESPONSE]); +// DT_SetResponseClass(m_fixRespTable, object.getObjectHandle(), m_fixResponseClass[OBJECT_RESPONSE]); +} + void SM_Scene::remove(SM_Object& object) { T_ObjectList::iterator i = std::find(m_objectList.begin(), m_objectList.end(), &object); @@ -49,21 +147,11 @@ void SM_Scene::remove(SM_Object& object) { std::swap(*i, m_objectList.back()); m_objectList.pop_back(); DT_RemoveObject(m_scene, object.getObjectHandle()); - if (object.isDynamic()) { - DT_ClearObjectResponse(m_respTable, object.getObjectHandle()); - } - - if (object.getDynamicParent()) { - DT_ClearPairResponse(m_respTable, object.getObjectHandle(), - object.getDynamicParent()->getObjectHandle()); - } SM_FhObject *fh_object = object.getFhObject(); if (fh_object) { DT_RemoveObject(m_scene, fh_object->getObjectHandle()); - DT_ClearObjectResponse(m_respTable, - fh_object->getObjectHandle()); } } else { @@ -81,29 +169,28 @@ void SM_Scene::proceed(MT_Scalar timeStep, MT_Scalar subSampling) { // equal to subSampling (might be a little smaller). int num_samples = (int)ceil(timeStep / subSampling); - MT_Scalar subStep = timeStep / num_samples; T_ObjectList::iterator i; // Apply a forcefield (such as gravity) for (i = m_objectList.begin(); i != m_objectList.end(); ++i) { (*i)->applyForceField(m_forceField); + //(*i)->integrateForces(subStep); + //(*i)->integrateMomentum(subStep); } // Do the integration steps per object. int step; for (step = 0; step != num_samples; ++step) { + for (i = m_objectList.begin(); i != m_objectList.end(); ++i) { (*i)->integrateForces(subStep); - } - + //(*i)->backup(); // And second we update the object positions by performing // an integration step for each object - for (i = m_objectList.begin(); i != m_objectList.end(); ++i) { (*i)->integrateMomentum(subStep); } -#if 0 // I changed the order of the next 2 statements. // Originally objects were first integrated with a call // to proceed(). However if external objects were @@ -113,17 +200,18 @@ void SM_Scene::proceed(MT_Scalar timeStep, MT_Scalar subSampling) { // So now first we let the physics scene respond to // new forces, velocities set externally. -#endif // The collsion and friction impulses are computed here. DT_Test(m_scene, m_respTable); - } - // clear the user set velocities. #if 0 clearObjectCombinedVelocities(); #endif + for (step = 0; step < 5 && DT_Test(m_scene, m_fixRespTable); step++) + for (i = m_objectList.begin(); i != m_objectList.end(); ++i) + (*i)->relax(); + // Finish this timestep by saving al state information for the next // timestep and clearing the accumulated forces. @@ -132,7 +220,7 @@ void SM_Scene::proceed(MT_Scalar timeStep, MT_Scalar subSampling) { (*i)->saveReactionForce(timeStep); (*i)->clearForce(); } - + // For each pair of object that collided, call the corresponding callback. // Additional collisions of a pair within the same time step are ignored. @@ -152,14 +240,25 @@ void SM_Scene::proceed(MT_Scalar timeStep, MT_Scalar subSampling) { SM_Object *SM_Scene::rayTest(void *ignore_client, const MT_Point3& from, const MT_Point3& to, MT_Point3& result, MT_Vector3& normal) const { - MT_Point3 local; +#ifdef SM_DEBUG_RAYCAST + std::cout << "ray: { " << from << " } - { " << to << " }" << std::endl; +#endif + DT_Vector3 n, dfrom, dto; + DT_Scalar param; + from.getValue(dfrom); + to.getValue(dto); SM_Object *hit_object = (SM_Object *) - DT_RayTest(m_scene, ignore_client, from.getValue(), to.getValue(), - local.getValue(), normal.getValue()); + DT_RayCast(m_scene, ignore_client, dfrom, dto, 1., ¶m, n); if (hit_object) { - result = hit_object->getWorldCoord(local); + //result = hit_object->getWorldCoord(from + (to - from)*param); + result = from + (to - from) * param; + normal.setValue(n); +#ifdef SM_DEBUG_RAYCAST + std::cout << "ray: { " << from << " } -> { " << to << " }: { " << result + << " } (" << param << "), normal = { " << normal << " }" << std::endl; +#endif } return hit_object; @@ -178,6 +277,34 @@ void SM_Scene::clearObjectCombinedVelocities() { } +void SM_Scene::setSecondaryRespTable(DT_RespTableHandle secondaryRespTable) { + m_secondaryRespTable = secondaryRespTable; +} +DT_Bool SM_Scene::boing( + void *client_data, + void *object1, + void *object2, + const DT_CollData *coll_data +){ + SM_Scene *scene = (SM_Scene *)client_data; + SM_Object *obj1 = (SM_Object *)object1; + SM_Object *obj2 = (SM_Object *)object2; + + scene->addPair(obj1, obj2); // Record this collision for client callbacks +#ifdef SM_DEBUG_BOING + printf("SM_Scene::boing\n"); +#endif + + return DT_CONTINUE; +} + +SM_Scene::~SM_Scene() +{ +/* if (m_objectList.begin() != m_objectList.end()) + std::cout << "SM_Scene::~SM_Scene: There are still objects in the Sumo scene!" << std::endl; */ + DT_DestroyRespTable(m_respTable); + DT_DestroyScene(m_scene); +} diff --git a/source/gameengine/Physics/Sumo/Makefile b/source/gameengine/Physics/Sumo/Makefile index deb59c2d18f..eef7ee3b40d 100644 --- a/source/gameengine/Physics/Sumo/Makefile +++ b/source/gameengine/Physics/Sumo/Makefile @@ -33,6 +33,7 @@ LIBNAME = sumo DIR = $(OCGDIR)/gameengine/blphys/$(LIBNAME) +DIRS = Fuzzics include nan_compile.mk @@ -42,7 +43,10 @@ CPPFLAGS += -I$(OPENGL_HEADERS) CPPFLAGS += -I$(NAN_STRING)/include CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION) -CPPFLAGS += -I$(NAN_FUZZICS)/include -I$(NAN_SUMO)/include -I$(NAN_MOTO)/include +CPPFLAGS += -I$(NAN_FUZZICS)/include -I$(NAN_SUMO) -I$(NAN_MOTO)/include +CPPFLAGS += -I$(NAN_SOLID)/include CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include CPPFLAGS += -I../../Physics/common CPPFLAGS += -I../../Physics/Dummy + +include nan_subdirs.mk diff --git a/source/gameengine/Physics/Sumo/SConscript b/source/gameengine/Physics/Sumo/SConscript index c58e98ca4ce..dba05693c1e 100755 --- a/source/gameengine/Physics/Sumo/SConscript +++ b/source/gameengine/Physics/Sumo/SConscript @@ -1,3 +1,4 @@ +import sys Import ('user_options_dict') Import ('library_env') @@ -15,6 +16,9 @@ phy_sumo_env.Append (CPPPATH = ['.', '#/intern/moto/include' ]) -phy_sumo_env.Append (CPPPATH = user_options_dict['solid_include']) +phy_sumo_env.Append (CPPPATH = user_options_dict['SOLID_INCLUDE']) + +if sys.platform=='win32': + phy_sumo_env.Append (CXXFLAGS = ['/GR']) phy_sumo_env.Library (target='#'+user_options_dict['BUILD_DIR']+'/lib/PHY_Sumo', source=source_files) diff --git a/source/gameengine/Physics/Sumo/SumoPhysicsController.cpp b/source/gameengine/Physics/Sumo/SumoPhysicsController.cpp index d89e43cd04b..76f5f6e891d 100644 --- a/source/gameengine/Physics/Sumo/SumoPhysicsController.cpp +++ b/source/gameengine/Physics/Sumo/SumoPhysicsController.cpp @@ -47,16 +47,16 @@ SumoPhysicsController::SumoPhysicsController( bool dyna) : + m_sumoObj(sumoObj) , m_sumoScene(sumoScene), m_solidscene(solidscene), - m_sumoObj(sumoObj) , m_bFirstTime(true), - m_MotionState(motionstate), - m_bDyna(dyna) + m_bDyna(dyna), + m_MotionState(motionstate) { if (m_sumoObj) { - m_sumoObj->setClientObject(this); + //m_sumoObj->setClientObject(this); //if it is a dyna, register for a callback m_sumoObj->registerCallback(*this); } @@ -70,12 +70,6 @@ SumoPhysicsController::~SumoPhysicsController() { m_sumoScene->remove(*m_sumoObj); - - DT_ObjectHandle objhandle = (DT_ObjectHandle) m_sumoObj->getObjectHandle(); - if (objhandle) - { - DT_RemoveObject(m_solidscene,objhandle); - } delete m_sumoObj; } } @@ -169,6 +163,7 @@ void SumoPhysicsController::RelativeTranslate(float dlocX,float dlocY,float dlo MT_Vector3 dloc(dlocX,dlocY,dlocZ); MT_Point3 newpos = m_sumoObj->getPosition(); + newpos += (local ? mat * dloc : dloc); m_sumoObj->setPosition(newpos); } @@ -184,7 +179,7 @@ void SumoPhysicsController::RelativeRotate(const float drot[9],bool local) GetWorldOrientation(currentOrn); m_sumoObj->setOrientation(m_sumoObj->getOrientation()*(local ? - drotmat.getRotation() : (currentOrn.inverse() * drotmat * currentOrn)).getRotation()); + drotmat : (currentOrn.inverse() * drotmat * currentOrn)).getRotation()); } } @@ -395,22 +390,13 @@ void SumoPhysicsController::PostProcessReplica(class PHY_IMotionState* motionst m_sumoObj->setRigidBody(orgsumoobject->isRigidBody()); - double radius = orgsumoobject->getMargin(); m_sumoObj->setMargin(orgsumoobject->getMargin()); m_sumoObj->setPosition(orgsumoobject->getPosition()); m_sumoObj->setOrientation(orgsumoobject->getOrientation()); + //if it is a dyna, register for a callback + m_sumoObj->registerCallback(*this); + m_sumoScene->add(* (m_sumoObj)); - - if (m_sumoObj) - { - m_sumoObj->setClientObject(this); - //if it is a dyna, register for a callback - m_sumoObj->registerCallback(*this); - } - - - DT_AddObject(m_solidscene,m_sumoObj->getObjectHandle()); - } void SumoPhysicsController::SetSimulatedTime(float time) diff --git a/source/gameengine/Physics/Sumo/SumoPhysicsController.h b/source/gameengine/Physics/Sumo/SumoPhysicsController.h index 4b5fa48dced..4dd12b8b291 100644 --- a/source/gameengine/Physics/Sumo/SumoPhysicsController.h +++ b/source/gameengine/Physics/Sumo/SumoPhysicsController.h @@ -48,17 +48,6 @@ class SumoPhysicsController : public PHY_IPhysicsController , public SM_Callback { - class SM_Object* m_sumoObj; - class SM_Scene* m_sumoScene; // needed for replication - DT_SceneHandle m_solidscene; - bool m_bFirstTime; - bool m_bDyna; - - float m_friction; - float m_restitution; - - - bool m_suspendDynamics; public: SumoPhysicsController( @@ -149,6 +138,17 @@ public: private: + class SM_Object* m_sumoObj; + class SM_Scene* m_sumoScene; // needed for replication + DT_SceneHandle m_solidscene; + bool m_bFirstTime; + bool m_bDyna; + + float m_friction; + float m_restitution; + + + bool m_suspendDynamics; bool m_firstTime; bool m_bFullRigidBody; diff --git a/source/gameengine/Physics/Sumo/SumoPhysicsEnvironment.cpp b/source/gameengine/Physics/Sumo/SumoPhysicsEnvironment.cpp index ea18666a72d..3e59be6a816 100644 --- a/source/gameengine/Physics/Sumo/SumoPhysicsEnvironment.cpp +++ b/source/gameengine/Physics/Sumo/SumoPhysicsEnvironment.cpp @@ -38,6 +38,8 @@ #include <config.h> #endif +#include <SOLID/SOLID.h> + const MT_Scalar UpperBoundForFuzzicsIntegrator = 0.01; // At least 100Hz (isn't this CPU hungry ?) @@ -46,11 +48,8 @@ SumoPhysicsEnvironment::SumoPhysicsEnvironment() { // seperate collision scene for events m_solidScene = DT_CreateScene(); - m_respTable = DT_CreateRespTable(); m_sumoScene = new SM_Scene(); - m_sumoScene->setSecondaryRespTable(m_respTable); - } @@ -58,9 +57,8 @@ SumoPhysicsEnvironment::SumoPhysicsEnvironment() SumoPhysicsEnvironment::~SumoPhysicsEnvironment() { delete m_sumoScene; - - DT_DeleteScene(m_solidScene); - DT_DeleteRespTable(m_respTable); + DT_DestroyScene(m_solidScene); + //DT_DestroyRespTable(m_respTable); } void SumoPhysicsEnvironment::proceed(double timeStep) @@ -94,13 +92,28 @@ void SumoPhysicsEnvironment::removeConstraint(int constraintid) } } -PHY_IPhysicsController* SumoPhysicsEnvironment::rayTest(void* ignoreClient, float fromX,float fromY,float fromZ, float toX,float toY,float toZ, - float& hitX,float& hitY,float& hitZ,float& normalX,float& normalY,float& normalZ) +PHY_IPhysicsController* SumoPhysicsEnvironment::rayTest(void* ignoreClient, + float fromX,float fromY,float fromZ, + float toX,float toY,float toZ, + float& hitX,float& hitY,float& hitZ, + float& normalX,float& normalY,float& normalZ) { //collision detection / raytesting - //m_sumoScene->rayTest(ignoreclient,from,to,result,normal); + MT_Point3 hit, normal; + /* FIXME: Return type is not a PHY_IPhysicsController */ + PHY_IPhysicsController *ret = (PHY_IPhysicsController *) m_sumoScene->rayTest(ignoreClient,MT_Point3(fromX, fromY, fromZ),MT_Point3(toX, toY, toZ), hit, normal); + + hitX = hit[0]; + hitY = hit[1]; + hitZ = hit[2]; - return NULL; + normalX = normal[0]; + normalY = normal[1]; + normalZ = normal[2]; + + assert(false); + + return ret; } diff --git a/source/gameengine/Physics/Sumo/SumoPhysicsEnvironment.h b/source/gameengine/Physics/Sumo/SumoPhysicsEnvironment.h index 9be32303a75..ff4bf35415e 100644 --- a/source/gameengine/Physics/Sumo/SumoPhysicsEnvironment.h +++ b/source/gameengine/Physics/Sumo/SumoPhysicsEnvironment.h @@ -33,7 +33,7 @@ #define _SUMOPhysicsEnvironment #include "PHY_IPhysicsEnvironment.h" -#include "solid.h" +#include <SOLID/SOLID.h> /** * Physics Environment takes care of stepping the simulation and is a container for physics entities (rigidbodies,constraints, materials etc.) @@ -45,7 +45,6 @@ class SumoPhysicsEnvironment : public PHY_IPhysicsEnvironment class SM_Scene* m_sumoScene; DT_SceneHandle m_solidScene; - DT_RespTableHandle m_respTable; public: SumoPhysicsEnvironment(); diff --git a/source/gameengine/Rasterizer/RAS_BucketManager.cpp b/source/gameengine/Rasterizer/RAS_BucketManager.cpp index 38eee62b954..9b8f455d518 100644 --- a/source/gameengine/Rasterizer/RAS_BucketManager.cpp +++ b/source/gameengine/Rasterizer/RAS_BucketManager.cpp @@ -49,6 +49,7 @@ #include "RAS_BucketManager.h" + RAS_BucketManager::RAS_BucketManager() { @@ -63,11 +64,7 @@ RAS_BucketManager::~RAS_BucketManager() void RAS_BucketManager::Renderbuckets( const MT_Transform& cameratrans, RAS_IRasterizer* rasty, RAS_IRenderTools* rendertools) { - int numbuckets = m_MaterialBuckets.size(); - - //default_gl_light(); - - int i; + std::vector<RAS_MaterialBucket*>::iterator bucket; rasty->EnableTextures(false); rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_ENABLED); @@ -76,84 +73,66 @@ void RAS_BucketManager::Renderbuckets( rasty->ClearCachingInfo(); RAS_MaterialBucket::StartFrame(); - - for (i=0;i<numbuckets;i++) + for (bucket = m_MaterialBuckets.begin(); bucket != m_MaterialBuckets.end(); bucket++) { - RAS_MaterialBucket** bucketptr = m_MaterialBuckets.at(i); - if (bucketptr) - { - (*bucketptr)->ClearScheduledPolygons(); - } + (*bucket)->ClearScheduledPolygons(); } - - vector<RAS_MaterialBucket*> alphabuckets; - - // if no visibility method is define, everything is drawn - - for (i=0;i<numbuckets;i++) + for (bucket = m_AlphaBuckets.begin(); bucket != m_AlphaBuckets.end(); bucket++) { - RAS_MaterialBucket** bucketptr = m_MaterialBuckets.at(i); - if (bucketptr) - { - if (!(*bucketptr)->IsTransparant()) - { - (*bucketptr)->Render(cameratrans,rasty,rendertools); - } else - { - alphabuckets.push_back(*bucketptr); - } - } + (*bucket)->ClearScheduledPolygons(); } + + for (bucket = m_MaterialBuckets.begin(); bucket != m_MaterialBuckets.end(); bucket++) + (*bucket)->Render(cameratrans,rasty,rendertools); rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_DISABLED); - int numalphabuckets = alphabuckets.size(); - for (vector<RAS_MaterialBucket*>::const_iterator it=alphabuckets.begin(); - !(it==alphabuckets.end());it++) + for (bucket = m_AlphaBuckets.begin(); bucket != m_AlphaBuckets.end(); bucket++) { - (*it)->Render(cameratrans,rasty,rendertools); + (*bucket)->Render(cameratrans,rasty,rendertools); } - alphabuckets.clear(); - - - RAS_MaterialBucket::EndFrame(); - rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_ENABLED); + + RAS_MaterialBucket::EndFrame(); } RAS_MaterialBucket* RAS_BucketManager::RAS_BucketManagerFindBucket(RAS_IPolyMaterial * material) { - - RAS_MaterialBucket** bucketptr = m_MaterialBuckets[*material]; - RAS_MaterialBucket* bucket=NULL; - if (!bucketptr) + std::vector<RAS_MaterialBucket*>::iterator it; + for (it = m_MaterialBuckets.begin(); it != m_MaterialBuckets.end(); it++) { - bucket = new RAS_MaterialBucket(material); - m_MaterialBuckets.insert(*material,bucket); - - } else + if (*(*it)->GetPolyMaterial() == *material) + return *it; + } + + for (it = m_AlphaBuckets.begin(); it != m_AlphaBuckets.end(); it++) { - bucket = *bucketptr; + if (*(*it)->GetPolyMaterial() == *material) + return *it; } - + + RAS_MaterialBucket *bucket = new RAS_MaterialBucket(material); + if (bucket->IsTransparant()) + m_AlphaBuckets.push_back(bucket); + else + m_MaterialBuckets.push_back(bucket); + return bucket; } void RAS_BucketManager::RAS_BucketManagerClearAll() { - - int numbuckets = m_MaterialBuckets.size(); - for (int i=0;i<numbuckets;i++) + std::vector<RAS_MaterialBucket*>::iterator it; + for (it = m_MaterialBuckets.begin(); it != m_MaterialBuckets.end(); it++) { - RAS_MaterialBucket** bucketptr = m_MaterialBuckets.at(i); - if (bucketptr) - { - delete (*bucketptr); - *bucketptr=NULL; - - } + delete (*it); + } + for (it = m_AlphaBuckets.begin(); it != m_AlphaBuckets.end(); it++) + { + delete(*it); } - m_MaterialBuckets.clear(); + m_MaterialBuckets.clear(); + m_AlphaBuckets.clear(); } diff --git a/source/gameengine/Rasterizer/RAS_BucketManager.h b/source/gameengine/Rasterizer/RAS_BucketManager.h index 72427473fc1..834ae574bbc 100644 --- a/source/gameengine/Rasterizer/RAS_BucketManager.h +++ b/source/gameengine/Rasterizer/RAS_BucketManager.h @@ -38,10 +38,13 @@ #include "RAS_MaterialBucket.h" #include "GEN_Map.h" +#include <vector> + class RAS_BucketManager { - - GEN_Map<class RAS_IPolyMaterial,class RAS_MaterialBucket*> m_MaterialBuckets; + //GEN_Map<class RAS_IPolyMaterial,class RAS_MaterialBucket*> m_MaterialBuckets; + std::vector<class RAS_MaterialBucket*> m_MaterialBuckets; + std::vector<class RAS_MaterialBucket*> m_AlphaBuckets; public: RAS_BucketManager(); diff --git a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp index 1a11a0400f4..88fb5349764 100644 --- a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp +++ b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp @@ -67,7 +67,6 @@ RAS_IPolyMaterial::RAS_IPolyMaterial(const STR_String& texname, bool RAS_IPolyMaterial::Equals(const RAS_IPolyMaterial& lhs) const { return ( - this->m_texturename == lhs.m_texturename && this->m_tile == lhs.m_tile && this->m_tilexrep == lhs.m_tilexrep && this->m_tileyrep == lhs.m_tileyrep && @@ -75,7 +74,8 @@ bool RAS_IPolyMaterial::Equals(const RAS_IPolyMaterial& lhs) const this->m_drawingmode == lhs.m_drawingmode && this->m_bIsTriangle == lhs.m_bIsTriangle && this->m_lightlayer == lhs.m_lightlayer && - this->m_materialname == lhs.m_materialname + this->m_texturename.hash() == lhs.m_texturename.hash() && + this->m_materialname.hash() == lhs.m_materialname.hash() ); } diff --git a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h index 57d2ad9bc9a..01c3e80c055 100644 --- a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h +++ b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h @@ -47,13 +47,13 @@ class RAS_IPolyMaterial { //todo: remove these variables from this interface/protocol class protected: - STR_HashedString m_texturename; - STR_String m_materialname; //also needed for touchsensor - int m_tile; - int m_tilexrep,m_tileyrep; - int m_drawingmode; // tface->mode - int m_transparant; - int m_lightlayer; + STR_HashedString m_texturename; + STR_HashedString m_materialname; //also needed for touchsensor + int m_tile; + int m_tilexrep,m_tileyrep; + int m_drawingmode; // tface->mode + int m_transparant; + int m_lightlayer; bool m_bIsTriangle; public: diff --git a/source/gameengine/Rasterizer/RAS_IRasterizer.h b/source/gameengine/Rasterizer/RAS_IRasterizer.h index 2adfe596f01..144342e86cf 100644 --- a/source/gameengine/Rasterizer/RAS_IRasterizer.h +++ b/source/gameengine/Rasterizer/RAS_IRasterizer.h @@ -70,6 +70,11 @@ public: KX_DEPTHMASK_DISABLED }; + enum { + KX_TWOSIDE = 512, + KX_LINES = 32768 + }; + enum { RAS_STEREO_NOSTEREO = 1, RAS_STEREO_QUADBUFFERED, @@ -162,6 +167,7 @@ public: virtual void EnableTextures(bool enable)=0; virtual void SetCullFace(bool enable)=0; + virtual void SetLines(bool enable)=0; virtual double GetTime()=0; diff --git a/source/gameengine/Rasterizer/RAS_IRenderTools.h b/source/gameengine/Rasterizer/RAS_IRenderTools.h index 629d16e79d8..91b8fab5d18 100644 --- a/source/gameengine/Rasterizer/RAS_IRenderTools.h +++ b/source/gameengine/Rasterizer/RAS_IRenderTools.h @@ -64,8 +64,8 @@ public: RAS_IRenderTools( ) : - m_modified(true), - m_clientobject(NULL) + m_clientobject(NULL), + m_modified(true) { }; diff --git a/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp b/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp index d9e27c9c8d0..39de3a400aa 100644 --- a/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp +++ b/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp @@ -173,6 +173,8 @@ void RAS_MaterialBucket::Render(const MT_Transform& cameratrans, rendertools->SetClientObject((*m_meshSlots.begin()).m_clientObj); } + + //printf("RAS_MatBucket::Render: %d m_meshSlots\n", m_meshSlots.size()); bool dolights = m_material->GetDrawingMode()&16; @@ -191,6 +193,7 @@ void RAS_MaterialBucket::Render(const MT_Transform& cameratrans, for (T_MeshSlotList::const_iterator it = m_meshSlots.begin(); ! (it == m_meshSlots.end());it++) { + //printf("RAS_MatBucket::Render: (%p) %s MeshSlot %s\n", this, it->m_mesh->m_class?"Skin":"Mesh", (const char *)(*it).m_mesh->GetName()); if ((*it).m_bVisible) { rendertools->SetClientObject((*it).m_clientObj); @@ -245,6 +248,7 @@ void RAS_MaterialBucket::Render(const MT_Transform& cameratrans, rendertools->PopMatrix(); } + //printf("gets here\n"); } } diff --git a/source/gameengine/Rasterizer/RAS_MaterialBucket.h b/source/gameengine/Rasterizer/RAS_MaterialBucket.h index 6e5307ca5ed..e43273e9dcc 100644 --- a/source/gameengine/Rasterizer/RAS_MaterialBucket.h +++ b/source/gameengine/Rasterizer/RAS_MaterialBucket.h @@ -74,7 +74,7 @@ public: mutable bool m_bObjectColor; mutable MT_Vector4 m_RGBAcolor; - KX_MeshSlot() :m_bVisible(true), m_pDeformer(NULL) {} + KX_MeshSlot() :m_pDeformer(NULL), m_bVisible(true) {} // KX_MeshSlot() :m_bVisible(true) {} bool Less(const KX_MeshSlot& lhs) const; diff --git a/source/gameengine/Rasterizer/RAS_MeshObject.cpp b/source/gameengine/Rasterizer/RAS_MeshObject.cpp index 2a7323d845a..ce86d52d2bb 100644 --- a/source/gameengine/Rasterizer/RAS_MeshObject.cpp +++ b/source/gameengine/Rasterizer/RAS_MeshObject.cpp @@ -68,7 +68,8 @@ KX_ArrayOptimizer::~KX_ArrayOptimizer() RAS_MeshObject::RAS_MeshObject(int lightlayer) : m_bModified(true), - m_lightlayer(lightlayer) + m_lightlayer(lightlayer), + m_class(0) { } @@ -86,7 +87,7 @@ RAS_MeshObject::~RAS_MeshObject() -int RAS_MeshObject::GetLightLayer() +unsigned int RAS_MeshObject::GetLightLayer() { return m_lightlayer; } @@ -100,13 +101,13 @@ int RAS_MeshObject::NumMaterials() -const STR_String& RAS_MeshObject::GetMaterialName(int matid) +const STR_String& RAS_MeshObject::GetMaterialName(unsigned int matid) { if (m_materials.size() > 0 && (matid < m_materials.size())) { BucketMaterialSet::iterator it = m_materials.begin(); - for (int i = 1; i < m_materials.size(); i++) + for (unsigned int i = 1; i < m_materials.size(); i++) { it++; } @@ -118,7 +119,7 @@ const STR_String& RAS_MeshObject::GetMaterialName(int matid) -RAS_MaterialBucket* RAS_MeshObject::GetMaterialBucket(int matid) +RAS_MaterialBucket* RAS_MeshObject::GetMaterialBucket(unsigned int matid) { RAS_MaterialBucket* bucket = NULL; @@ -181,12 +182,12 @@ const STR_String& RAS_MeshObject::GetName() -const STR_String& RAS_MeshObject::GetTextureName(int matid) +const STR_String& RAS_MeshObject::GetTextureName(unsigned int matid) { if (m_materials.size() > 0 && (matid < m_materials.size())) { BucketMaterialSet::iterator it = m_materials.begin(); - for (int i = 1; i < m_materials.size(); i++) + for (unsigned int i = 1; i < m_materials.size(); i++) { it++; } @@ -321,7 +322,7 @@ int RAS_MeshObject::FindOrAddVertex(int vtxarray, idx.m_array = vtxarray; idx.m_index = numverts; idx.m_matid = (int) mat; - m_xyz_index_to_vertex_index_mapping[orgindex].push_back(idx); + m_xyz_index_to_vertex_index_mapping[orgindex].push_back(idx); return numverts; } @@ -354,8 +355,8 @@ int RAS_MeshObject::GetVertexArrayLength(RAS_IPolyMaterial* mat) -RAS_TexVert* RAS_MeshObject::GetVertex(int matid, - int index) +RAS_TexVert* RAS_MeshObject::GetVertex(unsigned int matid, + unsigned int index) { RAS_TexVert* vertex = NULL; @@ -368,7 +369,7 @@ RAS_TexVert* RAS_MeshObject::GetVertex(int matid, const vecVertexArray & vertexvec = GetVertexCache(mat); vector<KX_VertexArray*>::const_iterator it = vertexvec.begin(); - for (int len = 0; it != vertexvec.end(); it++) + for (unsigned int len = 0; it != vertexvec.end(); it++) { if (index < len + (*it)->size()) { @@ -521,7 +522,7 @@ int RAS_MeshObject::FindVertexArray(int numverts, KX_ArrayOptimizer* ao = GetArrayOptimizer(polymat); - for (int i=0;i<ao->m_VertexArrayCache1.size();i++) + for (unsigned int i=0;i<ao->m_VertexArrayCache1.size();i++) { if ( (ao->m_TriangleArrayCount[i] + (numverts-2)) < BUCKET_MAX_TRIANGLES) { @@ -532,10 +533,6 @@ int RAS_MeshObject::FindVertexArray(int numverts, break; } } - else - { - int i=0; - } } if (array == -1) diff --git a/source/gameengine/Rasterizer/RAS_MeshObject.h b/source/gameengine/Rasterizer/RAS_MeshObject.h index 3aeed836ba0..e26715ef210 100644 --- a/source/gameengine/Rasterizer/RAS_MeshObject.h +++ b/source/gameengine/Rasterizer/RAS_MeshObject.h @@ -66,7 +66,9 @@ public: struct RAS_TriangleIndex { public: - int m_index[3]; + int m_index[3]; + int m_array; + RAS_IPolyMaterial* m_matid; bool m_collider; }; @@ -131,12 +133,14 @@ public: vector<RAS_IPolyMaterial*> m_sortedMaterials; vector<vector<RAS_MatArrayIndex> > m_xyz_index_to_vertex_index_mapping; vector<RAS_TriangleIndex > m_triangle_indices; + + int m_class; - int GetLightLayer(); + unsigned int GetLightLayer(); int NumMaterials(); - const STR_String& GetMaterialName(int matid); - RAS_MaterialBucket* GetMaterialBucket(int matid); - const STR_String& GetTextureName(int matid); + const STR_String& GetMaterialName(unsigned int matid); + RAS_MaterialBucket* GetMaterialBucket(unsigned int matid); + const STR_String& GetTextureName(unsigned int matid); virtual void AddPolygon(RAS_Polygon* poly); void UpdateMaterialList(); @@ -217,8 +221,8 @@ public: int GetVertexArrayLength(RAS_IPolyMaterial* mat); RAS_TexVert* GetVertex( - int matid, - int index + unsigned int matid, + unsigned int index ); const vecIndexArrays& GetIndexCache (RAS_IPolyMaterial* mat); diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp deleted file mode 100644 index f3c5b851112..00000000000 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp +++ /dev/null @@ -1,69 +0,0 @@ -/** - * $Id$ - * - * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** - * - * 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 2 - * of the License, or (at your option) any later version. The Blender - * Foundation also sells licenses for use in proprietary software under - * the Blender License. See http://www.blender.org/BL/ for information - * about this. - * - * 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, write to the Free Software Foundation, - * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. - * All rights reserved. - * - * The Original Code is: all of this file. - * - * Contributor(s): none yet. - * - * ***** END GPL/BL DUAL LICENSE BLOCK ***** - */ -#include "RAS_CheckVertexArrays.h" - -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif - -#ifdef WIN32 -#include <windows.h> -#endif // WIN32 -#ifdef __APPLE__ -#include <OpenGL/gl.h> -#else -#include <GL/gl.h> -#endif - -#include "STR_String.h" - - -bool RAS_SystemSupportsVertexArrays() { - - bool result = false; - - char* ext = (char*) glGetString(GL_EXTENSIONS); - STR_String extensions; - - if (ext) - extensions = STR_String(ext); - -#ifdef WIN32 - if (extensions.Find("GL_EXT_compiled_vertex_array") >= 0) - { - result=true; - } -#endif //WIN32 - - return result; - -} diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h deleted file mode 100644 index b87abb9c3dd..00000000000 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h +++ /dev/null @@ -1,38 +0,0 @@ -/** - * $Id$ - * - * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** - * - * 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 2 - * of the License, or (at your option) any later version. The Blender - * Foundation also sells licenses for use in proprietary software under - * the Blender License. See http://www.blender.org/BL/ for information - * about this. - * - * 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, write to the Free Software Foundation, - * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. - * All rights reserved. - * - * The Original Code is: all of this file. - * - * Contributor(s): none yet. - * - * ***** END GPL/BL DUAL LICENSE BLOCK ***** - */ -#ifndef __RAS_CHECKVERTEXARRAYS -#define __RAS_CHECKVERTEXARRAYS - -bool RAS_SystemSupportsVertexArrays(); - -#endif //__RAS_CHECKVERTEXARRAYS - diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp new file mode 100644 index 00000000000..1ae8b25eb4d --- /dev/null +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp @@ -0,0 +1,4373 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +/* + The extension manager's job is to link at runtime OpenGL extension + functions. + + Since the various platform have different methods of finding a fn + pointer, this file attempts to encapsulate all that, so it gets a + little messy. Hopefully we can +*/ +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#ifdef WIN32 +# include <windows.h> + +# include <GL/gl.h> + +#elif defined(__APPLE__) +# include <Carbon/Carbon.h> + +# include <OpenGL/gl.h> + +#else /* UNIX */ +# include <GL/gl.h> +# include <GL/glx.h> + +# include <dlfcn.h> +#endif + +#include <vector> +#include <iostream> +#include <algorithm> + +#include "STR_String.h" + +#include "RAS_GLExtensionManager.h" + +/* ----------------------------------------------------------------------------- + + Platform specific functions section. + + Required Functions: + static void bglInitEntryPoints (void) -- Loads the GL library + static void bglDeallocEntryPoints (void) -- Frees the GL library + static void *bglGetProcAddress(const GLubyte* entry) -- Finds the address of + the GL function entry + +*/ +#ifdef __APPLE__ +/* http://developer.apple.com/qa/qa2001/qa1188.html */ +CFBundleRef gBundleRefOpenGL = NULL; + +// ------------------------- + +static OSStatus bglInitEntryPoints (void) +{ + OSStatus err = noErr; + const Str255 frameworkName = "\pOpenGL.framework"; + FSRefParam fileRefParam; + FSRef fileRef; + CFURLRef bundleURLOpenGL; + + memset(&fileRefParam, 0, sizeof(fileRefParam)); + memset(&fileRef, 0, sizeof(fileRef)); + + fileRefParam.ioNamePtr = frameworkName; + fileRefParam.newRef = &fileRef; + + // Frameworks directory/folder + err = FindFolder (kSystemDomain, kFrameworksFolderType, false, + &fileRefParam.ioVRefNum, &fileRefParam.ioDirID); + if (noErr != err) { + DebugStr ("\pCould not find frameworks folder"); + return err; + } + err = PBMakeFSRefSync (&fileRefParam); // make FSRef for folder + if (noErr != err) { + DebugStr ("\pCould make FSref to frameworks folder"); + return err; + } + // create URL to folder + bundleURLOpenGL = CFURLCreateFromFSRef (kCFAllocatorDefault, + &fileRef); + if (!bundleURLOpenGL) { + DebugStr ("\pCould create OpenGL Framework bundle URL"); + return paramErr; + } + // create ref to GL's bundle + gBundleRefOpenGL = CFBundleCreate (kCFAllocatorDefault, + bundleURLOpenGL); + if (!gBundleRefOpenGL) { + DebugStr ("\pCould not create OpenGL Framework bundle"); + return paramErr; + } + CFRelease (bundleURLOpenGL); // release created bundle + // if the code was successfully loaded, look for our function. + if (!CFBundleLoadExecutable (gBundleRefOpenGL)) { + DebugStr ("\pCould not load MachO executable"); + return paramErr; + } + return err; +} + +// ------------------------- + +static void bglDeallocEntryPoints (void) +{ + if (gBundleRefOpenGL != NULL) { + // unload the bundle's code. + CFBundleUnloadExecutable (gBundleRefOpenGL); + CFRelease (gBundleRefOpenGL); + gBundleRefOpenGL = NULL; + } +} + +// ------------------------- + +static void * bglGetProcAddress (const GLubyte * pszProc) +{ + if (!gBundleRefOpenGL) + return NULL; + + return CFBundleGetFunctionPointerForName (gBundleRefOpenGL, + CFStringCreateWithCStringNoCopy (NULL, + (const char *) pszProc, CFStringGetSystemEncoding (), NULL)); +} +#elif defined(GLX_ARB_get_proc_address) +/* Not all glx.h define PFNGLXGETPROCADDRESSARBPROC ! + We define our own if needed. */ +#ifdef HAVE_PFNGLXGETPROCADDRESSARBPROC +#define PFNBGLXGETPROCADDRESSARBPROC PFNGLXGETPROCADDRESSARBPROC +#else +typedef void (*(*PFNBGLXGETPROCADDRESSARBPROC)(const GLubyte *procname))(); +#endif + +void *_getProcAddress(const GLubyte *procName) { return NULL; } +PFNBGLXGETPROCADDRESSARBPROC bglGetProcAddress; + +static void bglInitEntryPoints (void) +{ + Display *dpy = glXGetCurrentDisplay(); + std::vector<STR_String> Xextensions = STR_String(glXQueryExtensionsString(dpy, DefaultScreen(dpy))).Explode(' '); + if (std::find(Xextensions.begin(), Xextensions.end(), "GLX_ARB_get_proc_address") != Xextensions.end()) + { + void *libGL = dlopen("libGL.so", RTLD_LAZY); + if (libGL) + { + bglGetProcAddress = (PFNBGLXGETPROCADDRESSARBPROC) (dlsym(libGL, "glXGetProcAddressARB")); + dlclose(libGL); + if (!bglGetProcAddress) + bglGetProcAddress = (PFNBGLXGETPROCADDRESSARBPROC) _getProcAddress; + } + } +} + +static void bglDeallocEntryPoints (void) {} + +#elif defined(WIN32) +static void bglInitEntryPoints (void) {} +static void bglDeallocEntryPoints (void) {} + +#define bglGetProcAddress(entry) wglGetProcAddress((LPCSTR) entry) + +#else /* Unknown Platform - disable extensions */ +static void bglInitEntryPoints (void) {} +static void bglDeallocEntryPoints (void) {} + +static void *bglGetProcAddress(const GLubyte* entry) +{ + /* No Extensions! */ + return NULL; +} + +#endif /* End Platform Specific */ + +/* ----------------------------------------------------------------------------- + + GL Extension Manager. +*/ + +RAS_GLExtensionManager::RAS_GLExtensionManager(int debug) : + m_debug(debug) +{ + bglInitEntryPoints (); //init bundle + EnableExtension(_BGL_TEST); + LinkExtensions(); +} + +RAS_GLExtensionManager::~RAS_GLExtensionManager() +{ + bglDeallocEntryPoints(); +} + +bool RAS_GLExtensionManager::QueryExtension(STR_String extension_name) +{ + return std::find(extensions.begin(), extensions.end(), extension_name) != extensions.end(); +} + +bool RAS_GLExtensionManager::QueryExtension(RAS_GLExtensionManager::ExtensionName name) +{ + unsigned int num = (unsigned int) name; + if (num >= NUM_EXTENSIONS) + return false; + + return (enabled_extensions[num/(8*sizeof(unsigned int))] & (1<<(num%(8*sizeof(unsigned int))))) != 0; +} + +bool RAS_GLExtensionManager::QueryVersion(int major, int minor) +{ + STR_String gl_version = STR_String((const char *) glGetString(GL_VERSION)); + int i = gl_version.Find('.'); + STR_String gl_major = gl_version.Left(i); + STR_String gl_minor = gl_version.Mid(i+1, gl_version.FindOneOf(". ", i+1) - i - 1); + + if (m_debug) + { + static bool doQueryVersion = true; + if (doQueryVersion) + { + doQueryVersion = false; + std::cout << "GL_VERSION: " << gl_major << "." << gl_minor << " (" << gl_version << ")" << std::endl; + } + } + + if (gl_major.ToInt() >= major && gl_minor.ToInt() >= minor) + return true; + + return false; +} + + +void RAS_GLExtensionManager::EnableExtension(RAS_GLExtensionManager::ExtensionName name) +{ + unsigned int num = (unsigned int) name; + if (num < NUM_EXTENSIONS) + enabled_extensions[num/(8*sizeof(unsigned int))] |= (1<<(num%(8*sizeof(unsigned int)))); +} + +/******************************************************************************* +1. Extension function entry points go here + +Need to #ifdef (compile time test for extension) +Add null functions if appropriate + +Some extensions have been incorporated into the core GL, eg Multitexture was +added in GL v1.1. If Blender calls one of these functions before they are +linked, it will crash. Even worse, if Blender *indirectly* calls one of these +functions, (ie the GL implementation calls them itself) Blender will crash. + +We fix this by adding them to the RAS_GL namespace - the functions are now +private to the gameengine. Code can transparently use extensions by adding: + +using namespace RAS_GL; + +to their source. Cunning like a weasel. + +/******************************************************************************/ + +namespace RAS_GL { +/* Generated from mkglext.py */ + +/* GL_EXT_compiled_vertex_array */ +#ifdef GL_EXT_compiled_vertex_array +static void APIENTRY _lockfunc(GLint first,GLsizei count) {}; +static void APIENTRY _unlockfunc() {}; +PFNGLLOCKARRAYSEXTPROC glLockArraysEXT=_lockfunc; +PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT=_unlockfunc; +#endif + +#if defined(GL_ARB_transpose_matrix) +PFNGLLOADTRANSPOSEMATRIXFARBPROC glLoadTransposeMatrixfARB; +PFNGLLOADTRANSPOSEMATRIXDARBPROC glLoadTransposeMatrixdARB; +PFNGLMULTTRANSPOSEMATRIXFARBPROC glMultTransposeMatrixfARB; +PFNGLMULTTRANSPOSEMATRIXDARBPROC glMultTransposeMatrixdARB; +#endif + +#if defined(GL_ARB_multisample) +PFNGLSAMPLECOVERAGEARBPROC glSampleCoverageARB; +#endif + +#if defined(GL_ARB_texture_env_add) +#endif + +#if defined(GL_ARB_texture_cube_map) +#endif + +#if defined(GL_ARB_texture_compression) +PFNGLCOMPRESSEDTEXIMAGE3DARBPROC glCompressedTexImage3DARB; +PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB; +PFNGLCOMPRESSEDTEXIMAGE1DARBPROC glCompressedTexImage1DARB; +PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC glCompressedTexSubImage3DARB; +PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC glCompressedTexSubImage2DARB; +PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC glCompressedTexSubImage1DARB; +PFNGLGETCOMPRESSEDTEXIMAGEARBPROC glGetCompressedTexImageARB; +#endif + +#if defined(GL_ARB_texture_border_clamp) +#endif + +#if defined(GL_ARB_vertex_blend) +PFNGLWEIGHTBVARBPROC glWeightbvARB; +PFNGLWEIGHTSVARBPROC glWeightsvARB; +PFNGLWEIGHTIVARBPROC glWeightivARB; +PFNGLWEIGHTFVARBPROC glWeightfvARB; +PFNGLWEIGHTDVARBPROC glWeightdvARB; +PFNGLWEIGHTUBVARBPROC glWeightubvARB; +PFNGLWEIGHTUSVARBPROC glWeightusvARB; +PFNGLWEIGHTUIVARBPROC glWeightuivARB; +PFNGLWEIGHTPOINTERARBPROC glWeightPointerARB; +PFNGLVERTEXBLENDARBPROC glVertexBlendARB; +#endif + +#if defined(GL_ARB_matrix_palette) +PFNGLCURRENTPALETTEMATRIXARBPROC glCurrentPaletteMatrixARB; +PFNGLMATRIXINDEXUBVARBPROC glMatrixIndexubvARB; +PFNGLMATRIXINDEXUSVARBPROC glMatrixIndexusvARB; +PFNGLMATRIXINDEXUIVARBPROC glMatrixIndexuivARB; +PFNGLMATRIXINDEXPOINTERARBPROC glMatrixIndexPointerARB; +#endif + +#if defined(GL_ARB_texture_env_combine) +#endif + +#if defined(GL_ARB_texture_env_crossbar) +#endif + +#if defined(GL_ARB_texture_env_dot3) +#endif + +#if defined(GL_ARB_texture_mirrored_repeat) +#endif + +#if defined(GL_ARB_depth_texture) +#endif + +#if defined(GL_ARB_shadow) +#endif + +#if defined(GL_ARB_shadow_ambient) +#endif + +#if defined(GL_ARB_window_pos) +PFNGLWINDOWPOS2DARBPROC glWindowPos2dARB; +PFNGLWINDOWPOS2DVARBPROC glWindowPos2dvARB; +PFNGLWINDOWPOS2FARBPROC glWindowPos2fARB; +PFNGLWINDOWPOS2FVARBPROC glWindowPos2fvARB; +PFNGLWINDOWPOS2IARBPROC glWindowPos2iARB; +PFNGLWINDOWPOS2IVARBPROC glWindowPos2ivARB; +PFNGLWINDOWPOS2SARBPROC glWindowPos2sARB; +PFNGLWINDOWPOS2SVARBPROC glWindowPos2svARB; +PFNGLWINDOWPOS3DARBPROC glWindowPos3dARB; +PFNGLWINDOWPOS3DVARBPROC glWindowPos3dvARB; +PFNGLWINDOWPOS3FARBPROC glWindowPos3fARB; +PFNGLWINDOWPOS3FVARBPROC glWindowPos3fvARB; +PFNGLWINDOWPOS3IARBPROC glWindowPos3iARB; +PFNGLWINDOWPOS3IVARBPROC glWindowPos3ivARB; +PFNGLWINDOWPOS3SARBPROC glWindowPos3sARB; +PFNGLWINDOWPOS3SVARBPROC glWindowPos3svARB; +#endif + +#if defined(GL_ARB_vertex_program) +PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB; +PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB; +PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB; +PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB; +PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB; +PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB; +PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB; +PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB; +PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB; +PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB; +PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB; +PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB; +PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB; +PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB; +PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB; +PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB; +PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB; +PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB; +PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4NbvARB; +PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4NivARB; +PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4NsvARB; +PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4NubARB; +PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4NubvARB; +PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4NuivARB; +PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4NusvARB; +PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB; +PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB; +PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB; +PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB; +PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB; +PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB; +PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB; +PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB; +PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB; +PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB; +PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB; +PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB; +PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB; +PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB; +PFNGLPROGRAMSTRINGARBPROC glProgramStringARB; +PFNGLBINDPROGRAMARBPROC glBindProgramARB; +PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB; +PFNGLGENPROGRAMSARBPROC glGenProgramsARB; +PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB; +PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB; +PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB; +PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB; +PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB; +PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB; +PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB; +PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB; +PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB; +PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB; +PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB; +PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB; +PFNGLGETPROGRAMIVARBPROC glGetProgramivARB; +PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB; +PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB; +PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB; +PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB; +PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB; +PFNGLISPROGRAMARBPROC glIsProgramARB; +#endif + +#if defined(GL_ARB_fragment_program) +#endif + +#if defined(GL_ARB_vertex_buffer_object) +PFNGLBINDBUFFERARBPROC glBindBufferARB; +PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB; +PFNGLGENBUFFERSARBPROC glGenBuffersARB; +PFNGLISBUFFERARBPROC glIsBufferARB; +PFNGLBUFFERDATAARBPROC glBufferDataARB; +PFNGLBUFFERSUBDATAARBPROC glBufferSubDataARB; +PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB; +PFNGLMAPBUFFERARBPROC glMapBufferARB; +PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB; +PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB; +PFNGLGETBUFFERPOINTERVARBPROC glGetBufferPointervARB; +#endif + +#if defined(GL_ARB_occlusion_query) +PFNGLGENQUERIESARBPROC glGenQueriesARB; +PFNGLDELETEQUERIESARBPROC glDeleteQueriesARB; +PFNGLISQUERYARBPROC glIsQueryARB; +PFNGLBEGINQUERYARBPROC glBeginQueryARB; +PFNGLENDQUERYARBPROC glEndQueryARB; +PFNGLGETQUERYIVARBPROC glGetQueryivARB; +PFNGLGETQUERYOBJECTIVARBPROC glGetQueryObjectivARB; +PFNGLGETQUERYOBJECTUIVARBPROC glGetQueryObjectuivARB; +#endif + +#if defined(GL_ARB_shader_objects) +PFNGLDELETEOBJECTARBPROC glDeleteObjectARB; +PFNGLGETHANDLEARBPROC glGetHandleARB; +PFNGLDETACHOBJECTARBPROC glDetachObjectARB; +PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB; +PFNGLSHADERSOURCEARBPROC glShaderSourceARB; +PFNGLCOMPILESHADERARBPROC glCompileShaderARB; +PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB; +PFNGLATTACHOBJECTARBPROC glAttachObjectARB; +PFNGLLINKPROGRAMARBPROC glLinkProgramARB; +PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB; +PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB; +PFNGLUNIFORM1FARBPROC glUniform1fARB; +PFNGLUNIFORM2FARBPROC glUniform2fARB; +PFNGLUNIFORM3FARBPROC glUniform3fARB; +PFNGLUNIFORM4FARBPROC glUniform4fARB; +PFNGLUNIFORM1IARBPROC glUniform1iARB; +PFNGLUNIFORM2IARBPROC glUniform2iARB; +PFNGLUNIFORM3IARBPROC glUniform3iARB; +PFNGLUNIFORM4IARBPROC glUniform4iARB; +PFNGLUNIFORM1FVARBPROC glUniform1fvARB; +PFNGLUNIFORM2FVARBPROC glUniform2fvARB; +PFNGLUNIFORM3FVARBPROC glUniform3fvARB; +PFNGLUNIFORM4FVARBPROC glUniform4fvARB; +PFNGLUNIFORM1IVARBPROC glUniform1ivARB; +PFNGLUNIFORM2IVARBPROC glUniform2ivARB; +PFNGLUNIFORM3IVARBPROC glUniform3ivARB; +PFNGLUNIFORM4IVARBPROC glUniform4ivARB; +PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB; +PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB; +PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB; +PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB; +PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB; +PFNGLGETINFOLOGARBPROC glGetInfoLogARB; +PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB; +PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB; +PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB; +PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB; +PFNGLGETUNIFORMIVARBPROC glGetUniformivARB; +PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB; +#endif + +#if defined(GL_ARB_vertex_shader) +PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB; +PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB; +PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB; +#endif + +#if defined(GL_ARB_fragment_shader) +#endif + +#if defined(GL_ARB_shading_language_100) +#endif + +#if defined(GL_ARB_texture_non_power_of_two) +#endif + +#if defined(GL_ARB_point_sprite) +#endif + +#if defined(GL_ARB_fragment_program_shadow) +#endif + +#if defined(GL_EXT_abgr) +#endif + +#if defined(GL_EXT_texture3D) +PFNGLTEXIMAGE3DEXTPROC glTexImage3DEXT; +PFNGLTEXSUBIMAGE3DEXTPROC glTexSubImage3DEXT; +#endif + +#if defined(GL_SGIS_texture_filter4) +PFNGLGETTEXFILTERFUNCSGISPROC glGetTexFilterFuncSGIS; +PFNGLTEXFILTERFUNCSGISPROC glTexFilterFuncSGIS; +#endif + +#if defined(GL_EXT_histogram) +PFNGLGETHISTOGRAMEXTPROC glGetHistogramEXT; +PFNGLGETHISTOGRAMPARAMETERFVEXTPROC glGetHistogramParameterfvEXT; +PFNGLGETHISTOGRAMPARAMETERIVEXTPROC glGetHistogramParameterivEXT; +PFNGLGETMINMAXEXTPROC glGetMinmaxEXT; +PFNGLGETMINMAXPARAMETERFVEXTPROC glGetMinmaxParameterfvEXT; +PFNGLGETMINMAXPARAMETERIVEXTPROC glGetMinmaxParameterivEXT; +PFNGLHISTOGRAMEXTPROC glHistogramEXT; +PFNGLMINMAXEXTPROC glMinmaxEXT; +PFNGLRESETHISTOGRAMEXTPROC glResetHistogramEXT; +PFNGLRESETMINMAXEXTPROC glResetMinmaxEXT; +#endif + +#if defined(GL_EXT_convolution) +PFNGLCONVOLUTIONFILTER1DEXTPROC glConvolutionFilter1DEXT; +PFNGLCONVOLUTIONFILTER2DEXTPROC glConvolutionFilter2DEXT; +PFNGLCONVOLUTIONPARAMETERFEXTPROC glConvolutionParameterfEXT; +PFNGLCONVOLUTIONPARAMETERFVEXTPROC glConvolutionParameterfvEXT; +PFNGLCONVOLUTIONPARAMETERIEXTPROC glConvolutionParameteriEXT; +PFNGLCONVOLUTIONPARAMETERIVEXTPROC glConvolutionParameterivEXT; +PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC glCopyConvolutionFilter1DEXT; +PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC glCopyConvolutionFilter2DEXT; +PFNGLGETCONVOLUTIONFILTEREXTPROC glGetConvolutionFilterEXT; +PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC glGetConvolutionParameterfvEXT; +PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC glGetConvolutionParameterivEXT; +PFNGLGETSEPARABLEFILTEREXTPROC glGetSeparableFilterEXT; +PFNGLSEPARABLEFILTER2DEXTPROC glSeparableFilter2DEXT; +#endif + +#if defined(GL_SGI_color_table) +PFNGLCOLORTABLESGIPROC glColorTableSGI; +PFNGLCOLORTABLEPARAMETERFVSGIPROC glColorTableParameterfvSGI; +PFNGLCOLORTABLEPARAMETERIVSGIPROC glColorTableParameterivSGI; +PFNGLCOPYCOLORTABLESGIPROC glCopyColorTableSGI; +PFNGLGETCOLORTABLESGIPROC glGetColorTableSGI; +PFNGLGETCOLORTABLEPARAMETERFVSGIPROC glGetColorTableParameterfvSGI; +PFNGLGETCOLORTABLEPARAMETERIVSGIPROC glGetColorTableParameterivSGI; +#endif + +#if defined(GL_SGIX_pixel_texture) +PFNGLPIXELTEXGENSGIXPROC glPixelTexGenSGIX; +#endif + +#if defined(GL_SGIS_pixel_texture) +PFNGLPIXELTEXGENPARAMETERISGISPROC glPixelTexGenParameteriSGIS; +PFNGLPIXELTEXGENPARAMETERIVSGISPROC glPixelTexGenParameterivSGIS; +PFNGLPIXELTEXGENPARAMETERFSGISPROC glPixelTexGenParameterfSGIS; +PFNGLPIXELTEXGENPARAMETERFVSGISPROC glPixelTexGenParameterfvSGIS; +PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC glGetPixelTexGenParameterivSGIS; +PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC glGetPixelTexGenParameterfvSGIS; +#endif + +#if defined(GL_SGIS_texture4D) +PFNGLTEXIMAGE4DSGISPROC glTexImage4DSGIS; +PFNGLTEXSUBIMAGE4DSGISPROC glTexSubImage4DSGIS; +#endif + +#if defined(GL_SGI_texture_color_table) +#endif + +#if defined(GL_EXT_cmyka) +#endif + +#if defined(GL_SGIS_detail_texture) +PFNGLDETAILTEXFUNCSGISPROC glDetailTexFuncSGIS; +PFNGLGETDETAILTEXFUNCSGISPROC glGetDetailTexFuncSGIS; +#endif + +#if defined(GL_SGIS_sharpen_texture) +PFNGLSHARPENTEXFUNCSGISPROC glSharpenTexFuncSGIS; +PFNGLGETSHARPENTEXFUNCSGISPROC glGetSharpenTexFuncSGIS; +#endif + +#if defined(GL_EXT_packed_pixels) +#endif + +#if defined(GL_SGIS_texture_lod) +#endif + +#if defined(GL_SGIS_multisample) +PFNGLSAMPLEMASKSGISPROC glSampleMaskSGIS; +PFNGLSAMPLEPATTERNSGISPROC glSamplePatternSGIS; +#endif + +#if defined(GL_EXT_rescale_normal) +#endif + +#if defined(GL_EXT_misc_attribute) +#endif + +#if defined(GL_SGIS_generate_mipmap) +#endif + +#if defined(GL_SGIX_clipmap) +#endif + +#if defined(GL_SGIX_shadow) +#endif + +#if defined(GL_SGIS_texture_edge_clamp) +#endif + +#if defined(GL_SGIS_texture_border_clamp) +#endif + +#if defined(GL_EXT_blend_minmax) +PFNGLBLENDEQUATIONEXTPROC glBlendEquationEXT; +#endif + +#if defined(GL_EXT_blend_subtract) +#endif + +#if defined(GL_EXT_blend_logic_op) +#endif + +#if defined(GL_SGIX_interlace) +#endif + +#if defined(GL_SGIX_sprite) +PFNGLSPRITEPARAMETERFSGIXPROC glSpriteParameterfSGIX; +PFNGLSPRITEPARAMETERFVSGIXPROC glSpriteParameterfvSGIX; +PFNGLSPRITEPARAMETERISGIXPROC glSpriteParameteriSGIX; +PFNGLSPRITEPARAMETERIVSGIXPROC glSpriteParameterivSGIX; +#endif + +#if defined(GL_SGIX_texture_multi_buffer) +#endif + +#if defined(GL_SGIX_instruments) +PFNGLGETINSTRUMENTSSGIXPROC glGetInstrumentsSGIX; +PFNGLINSTRUMENTSBUFFERSGIXPROC glInstrumentsBufferSGIX; +PFNGLPOLLINSTRUMENTSSGIXPROC glPollInstrumentsSGIX; +PFNGLREADINSTRUMENTSSGIXPROC glReadInstrumentsSGIX; +PFNGLSTARTINSTRUMENTSSGIXPROC glStartInstrumentsSGIX; +PFNGLSTOPINSTRUMENTSSGIXPROC glStopInstrumentsSGIX; +#endif + +#if defined(GL_SGIX_texture_scale_bias) +#endif + +#if defined(GL_SGIX_framezoom) +PFNGLFRAMEZOOMSGIXPROC glFrameZoomSGIX; +#endif + +#if defined(GL_SGIX_tag_sample_buffer) +PFNGLTAGSAMPLEBUFFERSGIXPROC glTagSampleBufferSGIX; +#endif + +#if defined(GL_SGIX_reference_plane) +PFNGLREFERENCEPLANESGIXPROC glReferencePlaneSGIX; +#endif + +#if defined(GL_SGIX_flush_raster) +PFNGLFLUSHRASTERSGIXPROC glFlushRasterSGIX; +#endif + +#if defined(GL_SGIX_depth_texture) +#endif + +#if defined(GL_SGIS_fog_function) +PFNGLFOGFUNCSGISPROC glFogFuncSGIS; +PFNGLGETFOGFUNCSGISPROC glGetFogFuncSGIS; +#endif + +#if defined(GL_SGIX_fog_offset) +#endif + +#if defined(GL_HP_image_transform) +PFNGLIMAGETRANSFORMPARAMETERIHPPROC glImageTransformParameteriHP; +PFNGLIMAGETRANSFORMPARAMETERFHPPROC glImageTransformParameterfHP; +PFNGLIMAGETRANSFORMPARAMETERIVHPPROC glImageTransformParameterivHP; +PFNGLIMAGETRANSFORMPARAMETERFVHPPROC glImageTransformParameterfvHP; +PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC glGetImageTransformParameterivHP; +PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC glGetImageTransformParameterfvHP; +#endif + +#if defined(GL_HP_convolution_border_modes) +#endif + +#if defined(GL_SGIX_texture_add_env) +#endif + +#if defined(GL_EXT_color_subtable) +PFNGLCOLORSUBTABLEEXTPROC glColorSubTableEXT; +PFNGLCOPYCOLORSUBTABLEEXTPROC glCopyColorSubTableEXT; +#endif + +#if defined(GL_PGI_vertex_hints) +#endif + +#if defined(GL_PGI_misc_hints) +PFNGLHINTPGIPROC glHintPGI; +#endif + +#if defined(GL_EXT_paletted_texture) +PFNGLCOLORTABLEEXTPROC glColorTableEXT; +PFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT; +PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT; +PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT; +#endif + +#if defined(GL_EXT_clip_volume_hint) +#endif + +#if defined(GL_SGIX_list_priority) +PFNGLGETLISTPARAMETERFVSGIXPROC glGetListParameterfvSGIX; +PFNGLGETLISTPARAMETERIVSGIXPROC glGetListParameterivSGIX; +PFNGLLISTPARAMETERFSGIXPROC glListParameterfSGIX; +PFNGLLISTPARAMETERFVSGIXPROC glListParameterfvSGIX; +PFNGLLISTPARAMETERISGIXPROC glListParameteriSGIX; +PFNGLLISTPARAMETERIVSGIXPROC glListParameterivSGIX; +#endif + +#if defined(GL_SGIX_ir_instrument1) +#endif + +#if defined(GL_SGIX_texture_lod_bias) +#endif + +#if defined(GL_SGIX_shadow_ambient) +#endif + +#if defined(GL_EXT_index_texture) +#endif + +#if defined(GL_EXT_index_material) +PFNGLINDEXMATERIALEXTPROC glIndexMaterialEXT; +#endif + +#if defined(GL_EXT_index_func) +PFNGLINDEXFUNCEXTPROC glIndexFuncEXT; +#endif + +#if defined(GL_EXT_index_array_formats) +#endif + +#if defined(GL_EXT_cull_vertex) +PFNGLCULLPARAMETERDVEXTPROC glCullParameterdvEXT; +PFNGLCULLPARAMETERFVEXTPROC glCullParameterfvEXT; +#endif + +#if defined(GL_SGIX_ycrcb) +#endif + +#if defined(GL_IBM_rasterpos_clip) +#endif + +#if defined(GL_HP_texture_lighting) +#endif + +#if defined(GL_EXT_draw_range_elements) +PFNGLDRAWRANGEELEMENTSEXTPROC glDrawRangeElementsEXT; +#endif + +#if defined(GL_WIN_phong_shading) +#endif + +#if defined(GL_WIN_specular_fog) +#endif + +#if defined(GL_EXT_light_texture) +PFNGLAPPLYTEXTUREEXTPROC glApplyTextureEXT; +PFNGLTEXTURELIGHTEXTPROC glTextureLightEXT; +PFNGLTEXTUREMATERIALEXTPROC glTextureMaterialEXT; +#endif + +#if defined(GL_SGIX_blend_alpha_minmax) +#endif + +#if defined(GL_EXT_bgra) +#endif + +#if defined(GL_SGIX_async) +PFNGLASYNCMARKERSGIXPROC glAsyncMarkerSGIX; +PFNGLFINISHASYNCSGIXPROC glFinishAsyncSGIX; +PFNGLPOLLASYNCSGIXPROC glPollAsyncSGIX; +PFNGLGENASYNCMARKERSSGIXPROC glGenAsyncMarkersSGIX; +PFNGLDELETEASYNCMARKERSSGIXPROC glDeleteAsyncMarkersSGIX; +PFNGLISASYNCMARKERSGIXPROC glIsAsyncMarkerSGIX; +#endif + +#if defined(GL_SGIX_async_pixel) +#endif + +#if defined(GL_SGIX_async_histogram) +#endif + +#if defined(GL_INTEL_parallel_arrays) +PFNGLVERTEXPOINTERVINTELPROC glVertexPointervINTEL; +PFNGLNORMALPOINTERVINTELPROC glNormalPointervINTEL; +PFNGLCOLORPOINTERVINTELPROC glColorPointervINTEL; +PFNGLTEXCOORDPOINTERVINTELPROC glTexCoordPointervINTEL; +#endif + +#if defined(GL_HP_occlusion_test) +#endif + +#if defined(GL_EXT_pixel_transform) +PFNGLPIXELTRANSFORMPARAMETERIEXTPROC glPixelTransformParameteriEXT; +PFNGLPIXELTRANSFORMPARAMETERFEXTPROC glPixelTransformParameterfEXT; +PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC glPixelTransformParameterivEXT; +PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC glPixelTransformParameterfvEXT; +#endif + +#if defined(GL_EXT_pixel_transform_color_table) +#endif + +#if defined(GL_EXT_shared_texture_palette) +#endif + +#if defined(GL_EXT_separate_specular_color) +#endif + +#if defined(GL_EXT_secondary_color) +PFNGLSECONDARYCOLOR3BEXTPROC glSecondaryColor3bEXT; +PFNGLSECONDARYCOLOR3BVEXTPROC glSecondaryColor3bvEXT; +PFNGLSECONDARYCOLOR3DEXTPROC glSecondaryColor3dEXT; +PFNGLSECONDARYCOLOR3DVEXTPROC glSecondaryColor3dvEXT; +PFNGLSECONDARYCOLOR3FEXTPROC glSecondaryColor3fEXT; +PFNGLSECONDARYCOLOR3FVEXTPROC glSecondaryColor3fvEXT; +PFNGLSECONDARYCOLOR3IEXTPROC glSecondaryColor3iEXT; +PFNGLSECONDARYCOLOR3IVEXTPROC glSecondaryColor3ivEXT; +PFNGLSECONDARYCOLOR3SEXTPROC glSecondaryColor3sEXT; +PFNGLSECONDARYCOLOR3SVEXTPROC glSecondaryColor3svEXT; +PFNGLSECONDARYCOLOR3UBEXTPROC glSecondaryColor3ubEXT; +PFNGLSECONDARYCOLOR3UBVEXTPROC glSecondaryColor3ubvEXT; +PFNGLSECONDARYCOLOR3UIEXTPROC glSecondaryColor3uiEXT; +PFNGLSECONDARYCOLOR3UIVEXTPROC glSecondaryColor3uivEXT; +PFNGLSECONDARYCOLOR3USEXTPROC glSecondaryColor3usEXT; +PFNGLSECONDARYCOLOR3USVEXTPROC glSecondaryColor3usvEXT; +PFNGLSECONDARYCOLORPOINTEREXTPROC glSecondaryColorPointerEXT; +#endif + +#if defined(GL_EXT_texture_perturb_normal) +PFNGLTEXTURENORMALEXTPROC glTextureNormalEXT; +#endif + +#if defined(GL_EXT_multi_draw_arrays) +PFNGLMULTIDRAWARRAYSEXTPROC glMultiDrawArraysEXT; +PFNGLMULTIDRAWELEMENTSEXTPROC glMultiDrawElementsEXT; +#endif + +#if defined(GL_EXT_fog_coord) +PFNGLFOGCOORDFEXTPROC glFogCoordfEXT; +PFNGLFOGCOORDFVEXTPROC glFogCoordfvEXT; +PFNGLFOGCOORDDEXTPROC glFogCoorddEXT; +PFNGLFOGCOORDDVEXTPROC glFogCoorddvEXT; +PFNGLFOGCOORDPOINTEREXTPROC glFogCoordPointerEXT; +#endif + +#if defined(GL_REND_screen_coordinates) +#endif + +#if defined(GL_EXT_coordinate_frame) +PFNGLTANGENT3BEXTPROC glTangent3bEXT; +PFNGLTANGENT3BVEXTPROC glTangent3bvEXT; +PFNGLTANGENT3DEXTPROC glTangent3dEXT; +PFNGLTANGENT3DVEXTPROC glTangent3dvEXT; +PFNGLTANGENT3FEXTPROC glTangent3fEXT; +PFNGLTANGENT3FVEXTPROC glTangent3fvEXT; +PFNGLTANGENT3IEXTPROC glTangent3iEXT; +PFNGLTANGENT3IVEXTPROC glTangent3ivEXT; +PFNGLTANGENT3SEXTPROC glTangent3sEXT; +PFNGLTANGENT3SVEXTPROC glTangent3svEXT; +PFNGLBINORMAL3BEXTPROC glBinormal3bEXT; +PFNGLBINORMAL3BVEXTPROC glBinormal3bvEXT; +PFNGLBINORMAL3DEXTPROC glBinormal3dEXT; +PFNGLBINORMAL3DVEXTPROC glBinormal3dvEXT; +PFNGLBINORMAL3FEXTPROC glBinormal3fEXT; +PFNGLBINORMAL3FVEXTPROC glBinormal3fvEXT; +PFNGLBINORMAL3IEXTPROC glBinormal3iEXT; +PFNGLBINORMAL3IVEXTPROC glBinormal3ivEXT; +PFNGLBINORMAL3SEXTPROC glBinormal3sEXT; +PFNGLBINORMAL3SVEXTPROC glBinormal3svEXT; +PFNGLTANGENTPOINTEREXTPROC glTangentPointerEXT; +PFNGLBINORMALPOINTEREXTPROC glBinormalPointerEXT; +#endif + +#if defined(GL_EXT_texture_env_combine) +#endif + +#if defined(GL_APPLE_specular_vector) +#endif + +#if defined(GL_APPLE_transform_hint) +#endif + +#if defined(GL_SUNX_constant_data) +PFNGLFINISHTEXTURESUNXPROC glFinishTextureSUNX; +#endif + +#if defined(GL_SUN_global_alpha) +PFNGLGLOBALALPHAFACTORBSUNPROC glGlobalAlphaFactorbSUN; +PFNGLGLOBALALPHAFACTORSSUNPROC glGlobalAlphaFactorsSUN; +PFNGLGLOBALALPHAFACTORISUNPROC glGlobalAlphaFactoriSUN; +PFNGLGLOBALALPHAFACTORFSUNPROC glGlobalAlphaFactorfSUN; +PFNGLGLOBALALPHAFACTORDSUNPROC glGlobalAlphaFactordSUN; +PFNGLGLOBALALPHAFACTORUBSUNPROC glGlobalAlphaFactorubSUN; +PFNGLGLOBALALPHAFACTORUSSUNPROC glGlobalAlphaFactorusSUN; +PFNGLGLOBALALPHAFACTORUISUNPROC glGlobalAlphaFactoruiSUN; +#endif + +#if defined(GL_SUN_triangle_list) +PFNGLREPLACEMENTCODEUISUNPROC glReplacementCodeuiSUN; +PFNGLREPLACEMENTCODEUSSUNPROC glReplacementCodeusSUN; +PFNGLREPLACEMENTCODEUBSUNPROC glReplacementCodeubSUN; +PFNGLREPLACEMENTCODEUIVSUNPROC glReplacementCodeuivSUN; +PFNGLREPLACEMENTCODEUSVSUNPROC glReplacementCodeusvSUN; +PFNGLREPLACEMENTCODEUBVSUNPROC glReplacementCodeubvSUN; +PFNGLREPLACEMENTCODEPOINTERSUNPROC glReplacementCodePointerSUN; +#endif + +#if defined(GL_SUN_vertex) +PFNGLCOLOR4UBVERTEX2FSUNPROC glColor4ubVertex2fSUN; +PFNGLCOLOR4UBVERTEX2FVSUNPROC glColor4ubVertex2fvSUN; +PFNGLCOLOR4UBVERTEX3FSUNPROC glColor4ubVertex3fSUN; +PFNGLCOLOR4UBVERTEX3FVSUNPROC glColor4ubVertex3fvSUN; +PFNGLCOLOR3FVERTEX3FSUNPROC glColor3fVertex3fSUN; +PFNGLCOLOR3FVERTEX3FVSUNPROC glColor3fVertex3fvSUN; +PFNGLNORMAL3FVERTEX3FSUNPROC glNormal3fVertex3fSUN; +PFNGLNORMAL3FVERTEX3FVSUNPROC glNormal3fVertex3fvSUN; +PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC glColor4fNormal3fVertex3fSUN; +PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC glColor4fNormal3fVertex3fvSUN; +PFNGLTEXCOORD2FVERTEX3FSUNPROC glTexCoord2fVertex3fSUN; +PFNGLTEXCOORD2FVERTEX3FVSUNPROC glTexCoord2fVertex3fvSUN; +PFNGLTEXCOORD4FVERTEX4FSUNPROC glTexCoord4fVertex4fSUN; +PFNGLTEXCOORD4FVERTEX4FVSUNPROC glTexCoord4fVertex4fvSUN; +PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC glTexCoord2fColor4ubVertex3fSUN; +PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC glTexCoord2fColor4ubVertex3fvSUN; +PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC glTexCoord2fColor3fVertex3fSUN; +PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC glTexCoord2fColor3fVertex3fvSUN; +PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC glTexCoord2fNormal3fVertex3fSUN; +PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC glTexCoord2fNormal3fVertex3fvSUN; +PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC glTexCoord2fColor4fNormal3fVertex3fSUN; +PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC glTexCoord2fColor4fNormal3fVertex3fvSUN; +PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC glTexCoord4fColor4fNormal3fVertex4fSUN; +PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC glTexCoord4fColor4fNormal3fVertex4fvSUN; +PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC glReplacementCodeuiVertex3fSUN; +PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC glReplacementCodeuiVertex3fvSUN; +PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC glReplacementCodeuiColor4ubVertex3fSUN; +PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC glReplacementCodeuiColor4ubVertex3fvSUN; +PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC glReplacementCodeuiColor3fVertex3fSUN; +PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC glReplacementCodeuiColor3fVertex3fvSUN; +PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC glReplacementCodeuiNormal3fVertex3fSUN; +PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiNormal3fVertex3fvSUN; +PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiColor4fNormal3fVertex3fSUN; +PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiColor4fNormal3fVertex3fvSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fVertex3fSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fVertex3fvSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; +#endif + +#if defined(GL_EXT_blend_func_separate) +PFNGLBLENDFUNCSEPARATEEXTPROC glBlendFuncSeparateEXT; +#endif + +#if defined(GL_INGR_color_clamp) +#endif + +#if defined(GL_INGR_interlace_read) +#endif + +#if defined(GL_EXT_stencil_wrap) +#endif + +#if defined(GL_EXT_422_pixels) +#endif + +#if defined(GL_NV_texgen_reflection) +#endif + +#if defined(GL_SUN_convolution_border_modes) +#endif + +#if defined(GL_EXT_texture_env_add) +#endif + +#if defined(GL_EXT_texture_lod_bias) +#endif + +#if defined(GL_EXT_texture_filter_anisotropic) +#endif + +#if defined(GL_EXT_vertex_weighting) +PFNGLVERTEXWEIGHTFEXTPROC glVertexWeightfEXT; +PFNGLVERTEXWEIGHTFVEXTPROC glVertexWeightfvEXT; +PFNGLVERTEXWEIGHTPOINTEREXTPROC glVertexWeightPointerEXT; +#endif + +#if defined(GL_NV_light_max_exponent) +#endif + +#if defined(GL_NV_vertex_array_range) +PFNGLFLUSHVERTEXARRAYRANGENVPROC glFlushVertexArrayRangeNV; +PFNGLVERTEXARRAYRANGENVPROC glVertexArrayRangeNV; +#endif + +#if defined(GL_NV_register_combiners) +PFNGLCOMBINERPARAMETERFVNVPROC glCombinerParameterfvNV; +PFNGLCOMBINERPARAMETERFNVPROC glCombinerParameterfNV; +PFNGLCOMBINERPARAMETERIVNVPROC glCombinerParameterivNV; +PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV; +PFNGLCOMBINERINPUTNVPROC glCombinerInputNV; +PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV; +PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV; +PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV; +PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV; +PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV; +PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV; +PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfvNV; +PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameterivNV; +#endif + +#if defined(GL_NV_fog_distance) +#endif + +#if defined(GL_NV_texgen_emboss) +#endif + +#if defined(GL_NV_blend_square) +#endif + +#if defined(GL_NV_texture_env_combine4) +#endif + +#if defined(GL_MESA_resize_buffers) +PFNGLRESIZEBUFFERSMESAPROC glResizeBuffersMESA; +#endif + +#if defined(GL_MESA_window_pos) +PFNGLWINDOWPOS2DMESAPROC glWindowPos2dMESA; +PFNGLWINDOWPOS2DVMESAPROC glWindowPos2dvMESA; +PFNGLWINDOWPOS2FMESAPROC glWindowPos2fMESA; +PFNGLWINDOWPOS2FVMESAPROC glWindowPos2fvMESA; +PFNGLWINDOWPOS2IMESAPROC glWindowPos2iMESA; +PFNGLWINDOWPOS2IVMESAPROC glWindowPos2ivMESA; +PFNGLWINDOWPOS2SMESAPROC glWindowPos2sMESA; +PFNGLWINDOWPOS2SVMESAPROC glWindowPos2svMESA; +PFNGLWINDOWPOS3DMESAPROC glWindowPos3dMESA; +PFNGLWINDOWPOS3DVMESAPROC glWindowPos3dvMESA; +PFNGLWINDOWPOS3FMESAPROC glWindowPos3fMESA; +PFNGLWINDOWPOS3FVMESAPROC glWindowPos3fvMESA; +PFNGLWINDOWPOS3IMESAPROC glWindowPos3iMESA; +PFNGLWINDOWPOS3IVMESAPROC glWindowPos3ivMESA; +PFNGLWINDOWPOS3SMESAPROC glWindowPos3sMESA; +PFNGLWINDOWPOS3SVMESAPROC glWindowPos3svMESA; +PFNGLWINDOWPOS4DMESAPROC glWindowPos4dMESA; +PFNGLWINDOWPOS4DVMESAPROC glWindowPos4dvMESA; +PFNGLWINDOWPOS4FMESAPROC glWindowPos4fMESA; +PFNGLWINDOWPOS4FVMESAPROC glWindowPos4fvMESA; +PFNGLWINDOWPOS4IMESAPROC glWindowPos4iMESA; +PFNGLWINDOWPOS4IVMESAPROC glWindowPos4ivMESA; +PFNGLWINDOWPOS4SMESAPROC glWindowPos4sMESA; +PFNGLWINDOWPOS4SVMESAPROC glWindowPos4svMESA; +#endif + +#if defined(GL_IBM_cull_vertex) +#endif + +#if defined(GL_IBM_multimode_draw_arrays) +PFNGLMULTIMODEDRAWARRAYSIBMPROC glMultiModeDrawArraysIBM; +PFNGLMULTIMODEDRAWELEMENTSIBMPROC glMultiModeDrawElementsIBM; +#endif + +#if defined(GL_IBM_vertex_array_lists) +PFNGLCOLORPOINTERLISTIBMPROC glColorPointerListIBM; +PFNGLSECONDARYCOLORPOINTERLISTIBMPROC glSecondaryColorPointerListIBM; +PFNGLEDGEFLAGPOINTERLISTIBMPROC glEdgeFlagPointerListIBM; +PFNGLFOGCOORDPOINTERLISTIBMPROC glFogCoordPointerListIBM; +PFNGLINDEXPOINTERLISTIBMPROC glIndexPointerListIBM; +PFNGLNORMALPOINTERLISTIBMPROC glNormalPointerListIBM; +PFNGLTEXCOORDPOINTERLISTIBMPROC glTexCoordPointerListIBM; +PFNGLVERTEXPOINTERLISTIBMPROC glVertexPointerListIBM; +#endif + +#if defined(GL_3DFX_texture_compression_FXT1) +#endif + +#if defined(GL_3DFX_multisample) +#endif + +#if defined(GL_3DFX_tbuffer) +PFNGLTBUFFERMASK3DFXPROC glTbufferMask3DFX; +#endif + +#if defined(GL_SGIX_vertex_preclip) +#endif + +#if defined(GL_SGIX_resample) +#endif + +#if defined(GL_SGIS_texture_color_mask) +PFNGLTEXTURECOLORMASKSGISPROC glTextureColorMaskSGIS; +#endif + +#if defined(GL_EXT_texture_env_dot3) +#endif + +#if defined(GL_ATI_texture_mirror_once) +#endif + +#if defined(GL_NV_fence) +PFNGLDELETEFENCESNVPROC glDeleteFencesNV; +PFNGLGENFENCESNVPROC glGenFencesNV; +PFNGLISFENCENVPROC glIsFenceNV; +PFNGLTESTFENCENVPROC glTestFenceNV; +PFNGLGETFENCEIVNVPROC glGetFenceivNV; +PFNGLFINISHFENCENVPROC glFinishFenceNV; +PFNGLSETFENCENVPROC glSetFenceNV; +#endif + +#if defined(GL_NV_evaluators) +PFNGLMAPCONTROLPOINTSNVPROC glMapControlPointsNV; +PFNGLMAPPARAMETERIVNVPROC glMapParameterivNV; +PFNGLMAPPARAMETERFVNVPROC glMapParameterfvNV; +PFNGLGETMAPCONTROLPOINTSNVPROC glGetMapControlPointsNV; +PFNGLGETMAPPARAMETERIVNVPROC glGetMapParameterivNV; +PFNGLGETMAPPARAMETERFVNVPROC glGetMapParameterfvNV; +PFNGLGETMAPATTRIBPARAMETERIVNVPROC glGetMapAttribParameterivNV; +PFNGLGETMAPATTRIBPARAMETERFVNVPROC glGetMapAttribParameterfvNV; +PFNGLEVALMAPSNVPROC glEvalMapsNV; +#endif + +#if defined(GL_NV_packed_depth_stencil) +#endif + +#if defined(GL_NV_register_combiners2) +PFNGLCOMBINERSTAGEPARAMETERFVNVPROC glCombinerStageParameterfvNV; +PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC glGetCombinerStageParameterfvNV; +#endif + +#if defined(GL_NV_texture_compression_vtc) +#endif + +#if defined(GL_NV_texture_rectangle) +#endif + +#if defined(GL_NV_texture_shader) +#endif + +#if defined(GL_NV_texture_shader2) +#endif + +#if defined(GL_NV_vertex_array_range2) +#endif + +#if defined(GL_NV_vertex_program) +PFNGLAREPROGRAMSRESIDENTNVPROC glAreProgramsResidentNV; +PFNGLBINDPROGRAMNVPROC glBindProgramNV; +PFNGLDELETEPROGRAMSNVPROC glDeleteProgramsNV; +PFNGLEXECUTEPROGRAMNVPROC glExecuteProgramNV; +PFNGLGENPROGRAMSNVPROC glGenProgramsNV; +PFNGLGETPROGRAMPARAMETERDVNVPROC glGetProgramParameterdvNV; +PFNGLGETPROGRAMPARAMETERFVNVPROC glGetProgramParameterfvNV; +PFNGLGETPROGRAMIVNVPROC glGetProgramivNV; +PFNGLGETPROGRAMSTRINGNVPROC glGetProgramStringNV; +PFNGLGETTRACKMATRIXIVNVPROC glGetTrackMatrixivNV; +PFNGLGETVERTEXATTRIBDVNVPROC glGetVertexAttribdvNV; +PFNGLGETVERTEXATTRIBFVNVPROC glGetVertexAttribfvNV; +PFNGLGETVERTEXATTRIBIVNVPROC glGetVertexAttribivNV; +PFNGLGETVERTEXATTRIBPOINTERVNVPROC glGetVertexAttribPointervNV; +PFNGLISPROGRAMNVPROC glIsProgramNV; +PFNGLLOADPROGRAMNVPROC glLoadProgramNV; +PFNGLPROGRAMPARAMETER4DNVPROC glProgramParameter4dNV; +PFNGLPROGRAMPARAMETER4DVNVPROC glProgramParameter4dvNV; +PFNGLPROGRAMPARAMETER4FNVPROC glProgramParameter4fNV; +PFNGLPROGRAMPARAMETER4FVNVPROC glProgramParameter4fvNV; +PFNGLPROGRAMPARAMETERS4DVNVPROC glProgramParameters4dvNV; +PFNGLPROGRAMPARAMETERS4FVNVPROC glProgramParameters4fvNV; +PFNGLREQUESTRESIDENTPROGRAMSNVPROC glRequestResidentProgramsNV; +PFNGLTRACKMATRIXNVPROC glTrackMatrixNV; +PFNGLVERTEXATTRIBPOINTERNVPROC glVertexAttribPointerNV; +PFNGLVERTEXATTRIB1DNVPROC glVertexAttrib1dNV; +PFNGLVERTEXATTRIB1DVNVPROC glVertexAttrib1dvNV; +PFNGLVERTEXATTRIB1FNVPROC glVertexAttrib1fNV; +PFNGLVERTEXATTRIB1FVNVPROC glVertexAttrib1fvNV; +PFNGLVERTEXATTRIB1SNVPROC glVertexAttrib1sNV; +PFNGLVERTEXATTRIB1SVNVPROC glVertexAttrib1svNV; +PFNGLVERTEXATTRIB2DNVPROC glVertexAttrib2dNV; +PFNGLVERTEXATTRIB2DVNVPROC glVertexAttrib2dvNV; +PFNGLVERTEXATTRIB2FNVPROC glVertexAttrib2fNV; +PFNGLVERTEXATTRIB2FVNVPROC glVertexAttrib2fvNV; +PFNGLVERTEXATTRIB2SNVPROC glVertexAttrib2sNV; +PFNGLVERTEXATTRIB2SVNVPROC glVertexAttrib2svNV; +PFNGLVERTEXATTRIB3DNVPROC glVertexAttrib3dNV; +PFNGLVERTEXATTRIB3DVNVPROC glVertexAttrib3dvNV; +PFNGLVERTEXATTRIB3FNVPROC glVertexAttrib3fNV; +PFNGLVERTEXATTRIB3FVNVPROC glVertexAttrib3fvNV; +PFNGLVERTEXATTRIB3SNVPROC glVertexAttrib3sNV; +PFNGLVERTEXATTRIB3SVNVPROC glVertexAttrib3svNV; +PFNGLVERTEXATTRIB4DNVPROC glVertexAttrib4dNV; +PFNGLVERTEXATTRIB4DVNVPROC glVertexAttrib4dvNV; +PFNGLVERTEXATTRIB4FNVPROC glVertexAttrib4fNV; +PFNGLVERTEXATTRIB4FVNVPROC glVertexAttrib4fvNV; +PFNGLVERTEXATTRIB4SNVPROC glVertexAttrib4sNV; +PFNGLVERTEXATTRIB4SVNVPROC glVertexAttrib4svNV; +PFNGLVERTEXATTRIB4UBNVPROC glVertexAttrib4ubNV; +PFNGLVERTEXATTRIB4UBVNVPROC glVertexAttrib4ubvNV; +PFNGLVERTEXATTRIBS1DVNVPROC glVertexAttribs1dvNV; +PFNGLVERTEXATTRIBS1FVNVPROC glVertexAttribs1fvNV; +PFNGLVERTEXATTRIBS1SVNVPROC glVertexAttribs1svNV; +PFNGLVERTEXATTRIBS2DVNVPROC glVertexAttribs2dvNV; +PFNGLVERTEXATTRIBS2FVNVPROC glVertexAttribs2fvNV; +PFNGLVERTEXATTRIBS2SVNVPROC glVertexAttribs2svNV; +PFNGLVERTEXATTRIBS3DVNVPROC glVertexAttribs3dvNV; +PFNGLVERTEXATTRIBS3FVNVPROC glVertexAttribs3fvNV; +PFNGLVERTEXATTRIBS3SVNVPROC glVertexAttribs3svNV; +PFNGLVERTEXATTRIBS4DVNVPROC glVertexAttribs4dvNV; +PFNGLVERTEXATTRIBS4FVNVPROC glVertexAttribs4fvNV; +PFNGLVERTEXATTRIBS4SVNVPROC glVertexAttribs4svNV; +PFNGLVERTEXATTRIBS4UBVNVPROC glVertexAttribs4ubvNV; +#endif + +#if defined(GL_SGIX_texture_coordinate_clamp) +#endif + +#if defined(GL_OML_interlace) +#endif + +#if defined(GL_OML_subsample) +#endif + +#if defined(GL_OML_resample) +#endif + +#if defined(GL_NV_copy_depth_to_color) +#endif + +#if defined(GL_ATI_envmap_bumpmap) +PFNGLTEXBUMPPARAMETERIVATIPROC glTexBumpParameterivATI; +PFNGLTEXBUMPPARAMETERFVATIPROC glTexBumpParameterfvATI; +PFNGLGETTEXBUMPPARAMETERIVATIPROC glGetTexBumpParameterivATI; +PFNGLGETTEXBUMPPARAMETERFVATIPROC glGetTexBumpParameterfvATI; +#endif + +#if defined(GL_ATI_fragment_shader) +PFNGLGENFRAGMENTSHADERSATIPROC glGenFragmentShadersATI; +PFNGLBINDFRAGMENTSHADERATIPROC glBindFragmentShaderATI; +PFNGLDELETEFRAGMENTSHADERATIPROC glDeleteFragmentShaderATI; +PFNGLBEGINFRAGMENTSHADERATIPROC glBeginFragmentShaderATI; +PFNGLENDFRAGMENTSHADERATIPROC glEndFragmentShaderATI; +PFNGLPASSTEXCOORDATIPROC glPassTexCoordATI; +PFNGLSAMPLEMAPATIPROC glSampleMapATI; +PFNGLCOLORFRAGMENTOP1ATIPROC glColorFragmentOp1ATI; +PFNGLCOLORFRAGMENTOP2ATIPROC glColorFragmentOp2ATI; +PFNGLCOLORFRAGMENTOP3ATIPROC glColorFragmentOp3ATI; +PFNGLALPHAFRAGMENTOP1ATIPROC glAlphaFragmentOp1ATI; +PFNGLALPHAFRAGMENTOP2ATIPROC glAlphaFragmentOp2ATI; +PFNGLALPHAFRAGMENTOP3ATIPROC glAlphaFragmentOp3ATI; +PFNGLSETFRAGMENTSHADERCONSTANTATIPROC glSetFragmentShaderConstantATI; +#endif + +#if defined(GL_ATI_pn_triangles) +#endif + +#if defined(GL_ATI_vertex_array_object) && 0 +PFNGLNEWOBJECTBUFFERATIPROC glNewObjectBufferATI; +PFNGLISOBJECTBUFFERATIPROC glIsObjectBufferATI; +PFNGLUPDATEOBJECTBUFFERATIPROC glUpdateObjectBufferATI; +PFNGLGETOBJECTBUFFERFVATIPROC glGetObjectBufferfvATI; +PFNGLGETOBJECTBUFFERIVATIPROC glGetObjectBufferivATI; +/* glDeleteObjectBufferATI became glFreeObjectBufferATI in GL_ATI_vertex_array_object v1.1 */ +PFNGLFREEOBJECTBUFFERATIPROC glFreeObjectBufferATI; +PFNGLARRAYOBJECTATIPROC glArrayObjectATI; +PFNGLGETARRAYOBJECTFVATIPROC glGetArrayObjectfvATI; +PFNGLGETARRAYOBJECTIVATIPROC glGetArrayObjectivATI; +PFNGLVARIANTARRAYOBJECTATIPROC glVariantArrayObjectATI; +PFNGLGETVARIANTARRAYOBJECTFVATIPROC glGetVariantArrayObjectfvATI; +PFNGLGETVARIANTARRAYOBJECTIVATIPROC glGetVariantArrayObjectivATI; +#endif + +#if defined(GL_EXT_vertex_shader) +PFNGLBEGINVERTEXSHADEREXTPROC glBeginVertexShaderEXT; +PFNGLENDVERTEXSHADEREXTPROC glEndVertexShaderEXT; +PFNGLBINDVERTEXSHADEREXTPROC glBindVertexShaderEXT; +PFNGLGENVERTEXSHADERSEXTPROC glGenVertexShadersEXT; +PFNGLDELETEVERTEXSHADEREXTPROC glDeleteVertexShaderEXT; +PFNGLSHADEROP1EXTPROC glShaderOp1EXT; +PFNGLSHADEROP2EXTPROC glShaderOp2EXT; +PFNGLSHADEROP3EXTPROC glShaderOp3EXT; +PFNGLSWIZZLEEXTPROC glSwizzleEXT; +PFNGLWRITEMASKEXTPROC glWriteMaskEXT; +PFNGLINSERTCOMPONENTEXTPROC glInsertComponentEXT; +PFNGLEXTRACTCOMPONENTEXTPROC glExtractComponentEXT; +PFNGLGENSYMBOLSEXTPROC glGenSymbolsEXT; +PFNGLSETINVARIANTEXTPROC glSetInvariantEXT; +PFNGLSETLOCALCONSTANTEXTPROC glSetLocalConstantEXT; +PFNGLVARIANTBVEXTPROC glVariantbvEXT; +PFNGLVARIANTSVEXTPROC glVariantsvEXT; +PFNGLVARIANTIVEXTPROC glVariantivEXT; +PFNGLVARIANTFVEXTPROC glVariantfvEXT; +PFNGLVARIANTDVEXTPROC glVariantdvEXT; +PFNGLVARIANTUBVEXTPROC glVariantubvEXT; +PFNGLVARIANTUSVEXTPROC glVariantusvEXT; +PFNGLVARIANTUIVEXTPROC glVariantuivEXT; +PFNGLVARIANTPOINTEREXTPROC glVariantPointerEXT; +PFNGLENABLEVARIANTCLIENTSTATEEXTPROC glEnableVariantClientStateEXT; +PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC glDisableVariantClientStateEXT; +PFNGLBINDLIGHTPARAMETEREXTPROC glBindLightParameterEXT; +PFNGLBINDMATERIALPARAMETEREXTPROC glBindMaterialParameterEXT; +PFNGLBINDTEXGENPARAMETEREXTPROC glBindTexGenParameterEXT; +PFNGLBINDTEXTUREUNITPARAMETEREXTPROC glBindTextureUnitParameterEXT; +PFNGLBINDPARAMETEREXTPROC glBindParameterEXT; +PFNGLISVARIANTENABLEDEXTPROC glIsVariantEnabledEXT; +PFNGLGETVARIANTBOOLEANVEXTPROC glGetVariantBooleanvEXT; +PFNGLGETVARIANTINTEGERVEXTPROC glGetVariantIntegervEXT; +PFNGLGETVARIANTFLOATVEXTPROC glGetVariantFloatvEXT; +PFNGLGETVARIANTPOINTERVEXTPROC glGetVariantPointervEXT; +PFNGLGETINVARIANTBOOLEANVEXTPROC glGetInvariantBooleanvEXT; +PFNGLGETINVARIANTINTEGERVEXTPROC glGetInvariantIntegervEXT; +PFNGLGETINVARIANTFLOATVEXTPROC glGetInvariantFloatvEXT; +PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC glGetLocalConstantBooleanvEXT; +PFNGLGETLOCALCONSTANTINTEGERVEXTPROC glGetLocalConstantIntegervEXT; +PFNGLGETLOCALCONSTANTFLOATVEXTPROC glGetLocalConstantFloatvEXT; +#endif + +#if defined(GL_ATI_vertex_streams) +PFNGLVERTEXSTREAM1SATIPROC glVertexStream1sATI; +PFNGLVERTEXSTREAM1SVATIPROC glVertexStream1svATI; +PFNGLVERTEXSTREAM1IATIPROC glVertexStream1iATI; +PFNGLVERTEXSTREAM1IVATIPROC glVertexStream1ivATI; +PFNGLVERTEXSTREAM1FATIPROC glVertexStream1fATI; +PFNGLVERTEXSTREAM1FVATIPROC glVertexStream1fvATI; +PFNGLVERTEXSTREAM1DATIPROC glVertexStream1dATI; +PFNGLVERTEXSTREAM1DVATIPROC glVertexStream1dvATI; +PFNGLVERTEXSTREAM2SATIPROC glVertexStream2sATI; +PFNGLVERTEXSTREAM2SVATIPROC glVertexStream2svATI; +PFNGLVERTEXSTREAM2IATIPROC glVertexStream2iATI; +PFNGLVERTEXSTREAM2IVATIPROC glVertexStream2ivATI; +PFNGLVERTEXSTREAM2FATIPROC glVertexStream2fATI; +PFNGLVERTEXSTREAM2FVATIPROC glVertexStream2fvATI; +PFNGLVERTEXSTREAM2DATIPROC glVertexStream2dATI; +PFNGLVERTEXSTREAM2DVATIPROC glVertexStream2dvATI; +PFNGLVERTEXSTREAM3SATIPROC glVertexStream3sATI; +PFNGLVERTEXSTREAM3SVATIPROC glVertexStream3svATI; +PFNGLVERTEXSTREAM3IATIPROC glVertexStream3iATI; +PFNGLVERTEXSTREAM3IVATIPROC glVertexStream3ivATI; +PFNGLVERTEXSTREAM3FATIPROC glVertexStream3fATI; +PFNGLVERTEXSTREAM3FVATIPROC glVertexStream3fvATI; +PFNGLVERTEXSTREAM3DATIPROC glVertexStream3dATI; +PFNGLVERTEXSTREAM3DVATIPROC glVertexStream3dvATI; +PFNGLVERTEXSTREAM4SATIPROC glVertexStream4sATI; +PFNGLVERTEXSTREAM4SVATIPROC glVertexStream4svATI; +PFNGLVERTEXSTREAM4IATIPROC glVertexStream4iATI; +PFNGLVERTEXSTREAM4IVATIPROC glVertexStream4ivATI; +PFNGLVERTEXSTREAM4FATIPROC glVertexStream4fATI; +PFNGLVERTEXSTREAM4FVATIPROC glVertexStream4fvATI; +PFNGLVERTEXSTREAM4DATIPROC glVertexStream4dATI; +PFNGLVERTEXSTREAM4DVATIPROC glVertexStream4dvATI; +PFNGLNORMALSTREAM3BATIPROC glNormalStream3bATI; +PFNGLNORMALSTREAM3BVATIPROC glNormalStream3bvATI; +PFNGLNORMALSTREAM3SATIPROC glNormalStream3sATI; +PFNGLNORMALSTREAM3SVATIPROC glNormalStream3svATI; +PFNGLNORMALSTREAM3IATIPROC glNormalStream3iATI; +PFNGLNORMALSTREAM3IVATIPROC glNormalStream3ivATI; +PFNGLNORMALSTREAM3FATIPROC glNormalStream3fATI; +PFNGLNORMALSTREAM3FVATIPROC glNormalStream3fvATI; +PFNGLNORMALSTREAM3DATIPROC glNormalStream3dATI; +PFNGLNORMALSTREAM3DVATIPROC glNormalStream3dvATI; +PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC glClientActiveVertexStreamATI; +PFNGLVERTEXBLENDENVIATIPROC glVertexBlendEnviATI; +PFNGLVERTEXBLENDENVFATIPROC glVertexBlendEnvfATI; +#endif + +#if defined(GL_ATI_element_array) +PFNGLELEMENTPOINTERATIPROC glElementPointerATI; +PFNGLDRAWELEMENTARRAYATIPROC glDrawElementArrayATI; +PFNGLDRAWRANGEELEMENTARRAYATIPROC glDrawRangeElementArrayATI; +#endif + +#if defined(GL_SUN_mesh_array) +PFNGLDRAWMESHARRAYSSUNPROC glDrawMeshArraysSUN; +#endif + +#if defined(GL_SUN_slice_accum) +#endif + +#if defined(GL_NV_multisample_filter_hint) +#endif + +#if defined(GL_NV_depth_clamp) +#endif + +#if defined(GL_NV_occlusion_query) +PFNGLGENOCCLUSIONQUERIESNVPROC glGenOcclusionQueriesNV; +PFNGLDELETEOCCLUSIONQUERIESNVPROC glDeleteOcclusionQueriesNV; +PFNGLISOCCLUSIONQUERYNVPROC glIsOcclusionQueryNV; +PFNGLBEGINOCCLUSIONQUERYNVPROC glBeginOcclusionQueryNV; +PFNGLENDOCCLUSIONQUERYNVPROC glEndOcclusionQueryNV; +PFNGLGETOCCLUSIONQUERYIVNVPROC glGetOcclusionQueryivNV; +PFNGLGETOCCLUSIONQUERYUIVNVPROC glGetOcclusionQueryuivNV; +#endif + +#if defined(GL_NV_point_sprite) +PFNGLPOINTPARAMETERINVPROC glPointParameteriNV; +PFNGLPOINTPARAMETERIVNVPROC glPointParameterivNV; +#endif + +#if defined(GL_NV_texture_shader3) +#endif + +#if defined(GL_NV_vertex_program1_1) +#endif + +#if defined(GL_EXT_shadow_funcs) +#endif + +#if defined(GL_EXT_stencil_two_side) +PFNGLACTIVESTENCILFACEEXTPROC glActiveStencilFaceEXT; +#endif + +#if defined(GL_ATI_text_fragment_shader) +#endif + +#if defined(GL_APPLE_client_storage) +#endif + +#if defined(GL_APPLE_element_array) +PFNGLELEMENTPOINTERAPPLEPROC glElementPointerAPPLE; +PFNGLDRAWELEMENTARRAYAPPLEPROC glDrawElementArrayAPPLE; +PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC glDrawRangeElementArrayAPPLE; +PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC glMultiDrawElementArrayAPPLE; +PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC glMultiDrawRangeElementArrayAPPLE; +#endif + +#if defined(GL_APPLE_fence) +PFNGLGENFENCESAPPLEPROC glGenFencesAPPLE; +PFNGLDELETEFENCESAPPLEPROC glDeleteFencesAPPLE; +PFNGLSETFENCEAPPLEPROC glSetFenceAPPLE; +PFNGLISFENCEAPPLEPROC glIsFenceAPPLE; +PFNGLTESTFENCEAPPLEPROC glTestFenceAPPLE; +PFNGLFINISHFENCEAPPLEPROC glFinishFenceAPPLE; +PFNGLTESTOBJECTAPPLEPROC glTestObjectAPPLE; +PFNGLFINISHOBJECTAPPLEPROC glFinishObjectAPPLE; +#endif + +#if defined(GL_APPLE_vertex_array_object) +PFNGLBINDVERTEXARRAYAPPLEPROC glBindVertexArrayAPPLE; +PFNGLDELETEVERTEXARRAYSAPPLEPROC glDeleteVertexArraysAPPLE; +PFNGLGENVERTEXARRAYSAPPLEPROC glGenVertexArraysAPPLE; +PFNGLISVERTEXARRAYAPPLEPROC glIsVertexArrayAPPLE; +#endif + +#if defined(GL_APPLE_vertex_array_range) +PFNGLVERTEXARRAYRANGEAPPLEPROC glVertexArrayRangeAPPLE; +PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC glFlushVertexArrayRangeAPPLE; +PFNGLVERTEXARRAYPARAMETERIAPPLEPROC glVertexArrayParameteriAPPLE; +#endif + +#if defined(GL_APPLE_ycbcr_422) +#endif + +#if defined(GL_S3_s3tc) +#endif + +#if defined(GL_ATI_draw_buffers) +PFNGLDRAWBUFFERSATIPROC glDrawBuffersATI; +#endif + +#if defined(GL_ATI_texture_env_combine3) +#endif + +#if defined(GL_ATI_texture_float) +#endif + +#if defined(GL_NV_float_buffer) +#endif + +#if defined(GL_NV_fragment_program) +PFNGLPROGRAMNAMEDPARAMETER4FNVPROC glProgramNamedParameter4fNV; +PFNGLPROGRAMNAMEDPARAMETER4DNVPROC glProgramNamedParameter4dNV; +PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC glProgramNamedParameter4fvNV; +PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC glProgramNamedParameter4dvNV; +PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC glGetProgramNamedParameterfvNV; +PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC glGetProgramNamedParameterdvNV; +#endif + +#if defined(GL_NV_half_float) +PFNGLVERTEX2HNVPROC glVertex2hNV; +PFNGLVERTEX2HVNVPROC glVertex2hvNV; +PFNGLVERTEX3HNVPROC glVertex3hNV; +PFNGLVERTEX3HVNVPROC glVertex3hvNV; +PFNGLVERTEX4HNVPROC glVertex4hNV; +PFNGLVERTEX4HVNVPROC glVertex4hvNV; +PFNGLNORMAL3HNVPROC glNormal3hNV; +PFNGLNORMAL3HVNVPROC glNormal3hvNV; +PFNGLCOLOR3HNVPROC glColor3hNV; +PFNGLCOLOR3HVNVPROC glColor3hvNV; +PFNGLCOLOR4HNVPROC glColor4hNV; +PFNGLCOLOR4HVNVPROC glColor4hvNV; +PFNGLTEXCOORD1HNVPROC glTexCoord1hNV; +PFNGLTEXCOORD1HVNVPROC glTexCoord1hvNV; +PFNGLTEXCOORD2HNVPROC glTexCoord2hNV; +PFNGLTEXCOORD2HVNVPROC glTexCoord2hvNV; +PFNGLTEXCOORD3HNVPROC glTexCoord3hNV; +PFNGLTEXCOORD3HVNVPROC glTexCoord3hvNV; +PFNGLTEXCOORD4HNVPROC glTexCoord4hNV; +PFNGLTEXCOORD4HVNVPROC glTexCoord4hvNV; +PFNGLMULTITEXCOORD1HNVPROC glMultiTexCoord1hNV; +PFNGLMULTITEXCOORD1HVNVPROC glMultiTexCoord1hvNV; +PFNGLMULTITEXCOORD2HNVPROC glMultiTexCoord2hNV; +PFNGLMULTITEXCOORD2HVNVPROC glMultiTexCoord2hvNV; +PFNGLMULTITEXCOORD3HNVPROC glMultiTexCoord3hNV; +PFNGLMULTITEXCOORD3HVNVPROC glMultiTexCoord3hvNV; +PFNGLMULTITEXCOORD4HNVPROC glMultiTexCoord4hNV; +PFNGLMULTITEXCOORD4HVNVPROC glMultiTexCoord4hvNV; +PFNGLFOGCOORDHNVPROC glFogCoordhNV; +PFNGLFOGCOORDHVNVPROC glFogCoordhvNV; +PFNGLSECONDARYCOLOR3HNVPROC glSecondaryColor3hNV; +PFNGLSECONDARYCOLOR3HVNVPROC glSecondaryColor3hvNV; +PFNGLVERTEXWEIGHTHNVPROC glVertexWeighthNV; +PFNGLVERTEXWEIGHTHVNVPROC glVertexWeighthvNV; +PFNGLVERTEXATTRIB1HNVPROC glVertexAttrib1hNV; +PFNGLVERTEXATTRIB1HVNVPROC glVertexAttrib1hvNV; +PFNGLVERTEXATTRIB2HNVPROC glVertexAttrib2hNV; +PFNGLVERTEXATTRIB2HVNVPROC glVertexAttrib2hvNV; +PFNGLVERTEXATTRIB3HNVPROC glVertexAttrib3hNV; +PFNGLVERTEXATTRIB3HVNVPROC glVertexAttrib3hvNV; +PFNGLVERTEXATTRIB4HNVPROC glVertexAttrib4hNV; +PFNGLVERTEXATTRIB4HVNVPROC glVertexAttrib4hvNV; +PFNGLVERTEXATTRIBS1HVNVPROC glVertexAttribs1hvNV; +PFNGLVERTEXATTRIBS2HVNVPROC glVertexAttribs2hvNV; +PFNGLVERTEXATTRIBS3HVNVPROC glVertexAttribs3hvNV; +PFNGLVERTEXATTRIBS4HVNVPROC glVertexAttribs4hvNV; +#endif + +#if defined(GL_NV_pixel_data_range) +PFNGLPIXELDATARANGENVPROC glPixelDataRangeNV; +PFNGLFLUSHPIXELDATARANGENVPROC glFlushPixelDataRangeNV; +#endif + +#if defined(GL_NV_primitive_restart) +PFNGLPRIMITIVERESTARTNVPROC glPrimitiveRestartNV; +PFNGLPRIMITIVERESTARTINDEXNVPROC glPrimitiveRestartIndexNV; +#endif + +#if defined(GL_NV_texture_expand_normal) +#endif + +#if defined(GL_NV_vertex_program2) +#endif + +#if defined(GL_ATI_map_object_buffer) +PFNGLMAPOBJECTBUFFERATIPROC glMapObjectBufferATI; +PFNGLUNMAPOBJECTBUFFERATIPROC glUnmapObjectBufferATI; +#endif + +#if defined(GL_ATI_separate_stencil) +PFNGLSTENCILOPSEPARATEATIPROC glStencilOpSeparateATI; +PFNGLSTENCILFUNCSEPARATEATIPROC glStencilFuncSeparateATI; +#endif + +#if defined(GL_ATI_vertex_attrib_array_object) +PFNGLVERTEXATTRIBARRAYOBJECTATIPROC glVertexAttribArrayObjectATI; +PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC glGetVertexAttribArrayObjectfvATI; +PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC glGetVertexAttribArrayObjectivATI; +#endif + +#if defined(GL_EXT_depth_bounds_test) +PFNGLDEPTHBOUNDSEXTPROC glDepthBoundsEXT; +#endif + +#if defined(GL_EXT_texture_mirror_clamp) +#endif + +#if defined(GL_EXT_blend_equation_separate) +PFNGLBLENDEQUATIONSEPARATEEXTPROC glBlendEquationSeparateEXT; +#endif + +#if defined(GL_MESA_pack_invert) +#endif + +#if defined(GL_MESA_ycbcr_texture) +#endif + +/* End mkglext.py */ +}; + +using namespace RAS_GL; + +/******************************************************************************* +2. Query extension functions here + +Need to #ifdef (compile time test for extension) +Use QueryExtension("GL_EXT_name") to test at runtime. +Use bglGetProcAddress to find entry point +Use EnableExtension(_GL_EXT_...) to allow Blender to use the extension. + + ******************************************************************************/ +void RAS_GLExtensionManager::LinkExtensions() +{ + static bool doDebugMessages = true; + extensions = STR_String((const char *) glGetString(GL_EXTENSIONS)).Explode(' '); + + /* Generated from mkglext.py */ + +#ifdef GL_EXT_compiled_vertex_array + if (QueryExtension("GL_EXT_compiled_vertex_array")) + { + glUnlockArraysEXT = reinterpret_cast<PFNGLUNLOCKARRAYSEXTPROC>(bglGetProcAddress((const GLubyte *) "glUnlockArraysEXT")); + glLockArraysEXT = reinterpret_cast<PFNGLLOCKARRAYSEXTPROC>(bglGetProcAddress((const GLubyte *) "glLockArraysEXT")); + if (glUnlockArraysEXT && glLockArraysEXT) + { + EnableExtension(_GL_EXT_compiled_vertex_array); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_compiled_vertex_array" << std::endl; + } else { + glUnlockArraysEXT = _unlockfunc; + glLockArraysEXT = _lockfunc; + std::cout << "ERROR: GL_EXT_compiled_vertex_array implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_multitexture")) + { + EnableExtension(_GL_ARB_multitexture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_multitexture" << std::endl; + } + +#if defined(GL_ARB_transpose_matrix) + if (QueryExtension("GL_ARB_transpose_matrix")) + { + glLoadTransposeMatrixfARB = reinterpret_cast<PFNGLLOADTRANSPOSEMATRIXFARBPROC>(bglGetProcAddress((const GLubyte *) "glLoadTransposeMatrixfARB")); + glLoadTransposeMatrixdARB = reinterpret_cast<PFNGLLOADTRANSPOSEMATRIXDARBPROC>(bglGetProcAddress((const GLubyte *) "glLoadTransposeMatrixdARB")); + glMultTransposeMatrixfARB = reinterpret_cast<PFNGLMULTTRANSPOSEMATRIXFARBPROC>(bglGetProcAddress((const GLubyte *) "glMultTransposeMatrixfARB")); + glMultTransposeMatrixdARB = reinterpret_cast<PFNGLMULTTRANSPOSEMATRIXDARBPROC>(bglGetProcAddress((const GLubyte *) "glMultTransposeMatrixdARB")); + if (glLoadTransposeMatrixfARB && glLoadTransposeMatrixdARB && glMultTransposeMatrixfARB && glMultTransposeMatrixdARB) { + EnableExtension(_GL_ARB_transpose_matrix); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_transpose_matrix" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_transpose_matrix implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_multisample) + if (QueryExtension("GL_ARB_multisample")) + { + glSampleCoverageARB = reinterpret_cast<PFNGLSAMPLECOVERAGEARBPROC>(bglGetProcAddress((const GLubyte *) "glSampleCoverageARB")); + if (glSampleCoverageARB) { + EnableExtension(_GL_ARB_multisample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_multisample" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_multisample implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_texture_env_add")) + { + EnableExtension(_GL_ARB_texture_env_add); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_env_add" << std::endl; + } + + if (QueryExtension("GL_ARB_texture_cube_map")) + { + EnableExtension(_GL_ARB_texture_cube_map); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_cube_map" << std::endl; + } + +#if defined(GL_ARB_texture_compression) + if (QueryExtension("GL_ARB_texture_compression")) + { + glCompressedTexImage3DARB = reinterpret_cast<PFNGLCOMPRESSEDTEXIMAGE3DARBPROC>(bglGetProcAddress((const GLubyte *) "glCompressedTexImage3DARB")); + glCompressedTexImage2DARB = reinterpret_cast<PFNGLCOMPRESSEDTEXIMAGE2DARBPROC>(bglGetProcAddress((const GLubyte *) "glCompressedTexImage2DARB")); + glCompressedTexImage1DARB = reinterpret_cast<PFNGLCOMPRESSEDTEXIMAGE1DARBPROC>(bglGetProcAddress((const GLubyte *) "glCompressedTexImage1DARB")); + glCompressedTexSubImage3DARB = reinterpret_cast<PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC>(bglGetProcAddress((const GLubyte *) "glCompressedTexSubImage3DARB")); + glCompressedTexSubImage2DARB = reinterpret_cast<PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC>(bglGetProcAddress((const GLubyte *) "glCompressedTexSubImage2DARB")); + glCompressedTexSubImage1DARB = reinterpret_cast<PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC>(bglGetProcAddress((const GLubyte *) "glCompressedTexSubImage1DARB")); + glGetCompressedTexImageARB = reinterpret_cast<PFNGLGETCOMPRESSEDTEXIMAGEARBPROC>(bglGetProcAddress((const GLubyte *) "glGetCompressedTexImageARB")); + if (glCompressedTexImage3DARB && glCompressedTexImage2DARB && glCompressedTexImage1DARB && glCompressedTexSubImage3DARB && glCompressedTexSubImage2DARB && glCompressedTexSubImage1DARB && glGetCompressedTexImageARB) { + EnableExtension(_GL_ARB_texture_compression); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_compression" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_texture_compression implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_texture_border_clamp")) + { + EnableExtension(_GL_ARB_texture_border_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_border_clamp" << std::endl; + } + +#if defined(GL_ARB_vertex_blend) + if (QueryExtension("GL_ARB_vertex_blend")) + { + glWeightbvARB = reinterpret_cast<PFNGLWEIGHTBVARBPROC>(bglGetProcAddress((const GLubyte *) "glWeightbvARB")); + glWeightsvARB = reinterpret_cast<PFNGLWEIGHTSVARBPROC>(bglGetProcAddress((const GLubyte *) "glWeightsvARB")); + glWeightivARB = reinterpret_cast<PFNGLWEIGHTIVARBPROC>(bglGetProcAddress((const GLubyte *) "glWeightivARB")); + glWeightfvARB = reinterpret_cast<PFNGLWEIGHTFVARBPROC>(bglGetProcAddress((const GLubyte *) "glWeightfvARB")); + glWeightdvARB = reinterpret_cast<PFNGLWEIGHTDVARBPROC>(bglGetProcAddress((const GLubyte *) "glWeightdvARB")); + glWeightubvARB = reinterpret_cast<PFNGLWEIGHTUBVARBPROC>(bglGetProcAddress((const GLubyte *) "glWeightubvARB")); + glWeightusvARB = reinterpret_cast<PFNGLWEIGHTUSVARBPROC>(bglGetProcAddress((const GLubyte *) "glWeightusvARB")); + glWeightuivARB = reinterpret_cast<PFNGLWEIGHTUIVARBPROC>(bglGetProcAddress((const GLubyte *) "glWeightuivARB")); + glWeightPointerARB = reinterpret_cast<PFNGLWEIGHTPOINTERARBPROC>(bglGetProcAddress((const GLubyte *) "glWeightPointerARB")); + glVertexBlendARB = reinterpret_cast<PFNGLVERTEXBLENDARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexBlendARB")); + if (glWeightbvARB && glWeightsvARB && glWeightivARB && glWeightfvARB && glWeightdvARB && glWeightubvARB && glWeightusvARB && glWeightuivARB && glWeightPointerARB && glVertexBlendARB) { + EnableExtension(_GL_ARB_vertex_blend); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_vertex_blend" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_vertex_blend implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_matrix_palette) + if (QueryExtension("GL_ARB_matrix_palette")) + { + glCurrentPaletteMatrixARB = reinterpret_cast<PFNGLCURRENTPALETTEMATRIXARBPROC>(bglGetProcAddress((const GLubyte *) "glCurrentPaletteMatrixARB")); + glMatrixIndexubvARB = reinterpret_cast<PFNGLMATRIXINDEXUBVARBPROC>(bglGetProcAddress((const GLubyte *) "glMatrixIndexubvARB")); + glMatrixIndexusvARB = reinterpret_cast<PFNGLMATRIXINDEXUSVARBPROC>(bglGetProcAddress((const GLubyte *) "glMatrixIndexusvARB")); + glMatrixIndexuivARB = reinterpret_cast<PFNGLMATRIXINDEXUIVARBPROC>(bglGetProcAddress((const GLubyte *) "glMatrixIndexuivARB")); + glMatrixIndexPointerARB = reinterpret_cast<PFNGLMATRIXINDEXPOINTERARBPROC>(bglGetProcAddress((const GLubyte *) "glMatrixIndexPointerARB")); + if (glCurrentPaletteMatrixARB && glMatrixIndexubvARB && glMatrixIndexusvARB && glMatrixIndexuivARB && glMatrixIndexPointerARB) { + EnableExtension(_GL_ARB_matrix_palette); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_matrix_palette" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_matrix_palette implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_texture_env_combine")) + { + EnableExtension(_GL_ARB_texture_env_combine); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_env_combine" << std::endl; + } + + if (QueryExtension("GL_ARB_texture_env_crossbar")) + { + EnableExtension(_GL_ARB_texture_env_crossbar); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_env_crossbar" << std::endl; + } + + if (QueryExtension("GL_ARB_texture_env_dot3")) + { + EnableExtension(_GL_ARB_texture_env_dot3); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_env_dot3" << std::endl; + } + + if (QueryExtension("GL_ARB_texture_mirrored_repeat")) + { + EnableExtension(_GL_ARB_texture_mirrored_repeat); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_mirrored_repeat" << std::endl; + } + + if (QueryExtension("GL_ARB_depth_texture")) + { + EnableExtension(_GL_ARB_depth_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_depth_texture" << std::endl; + } + + if (QueryExtension("GL_ARB_shadow")) + { + EnableExtension(_GL_ARB_shadow); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_shadow" << std::endl; + } + + if (QueryExtension("GL_ARB_shadow_ambient")) + { + EnableExtension(_GL_ARB_shadow_ambient); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_shadow_ambient" << std::endl; + } + +#if defined(GL_ARB_window_pos) + if (QueryExtension("GL_ARB_window_pos")) + { + glWindowPos2dARB = reinterpret_cast<PFNGLWINDOWPOS2DARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2dARB")); + glWindowPos2dvARB = reinterpret_cast<PFNGLWINDOWPOS2DVARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2dvARB")); + glWindowPos2fARB = reinterpret_cast<PFNGLWINDOWPOS2FARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2fARB")); + glWindowPos2fvARB = reinterpret_cast<PFNGLWINDOWPOS2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2fvARB")); + glWindowPos2iARB = reinterpret_cast<PFNGLWINDOWPOS2IARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2iARB")); + glWindowPos2ivARB = reinterpret_cast<PFNGLWINDOWPOS2IVARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2ivARB")); + glWindowPos2sARB = reinterpret_cast<PFNGLWINDOWPOS2SARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2sARB")); + glWindowPos2svARB = reinterpret_cast<PFNGLWINDOWPOS2SVARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2svARB")); + glWindowPos3dARB = reinterpret_cast<PFNGLWINDOWPOS3DARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3dARB")); + glWindowPos3dvARB = reinterpret_cast<PFNGLWINDOWPOS3DVARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3dvARB")); + glWindowPos3fARB = reinterpret_cast<PFNGLWINDOWPOS3FARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3fARB")); + glWindowPos3fvARB = reinterpret_cast<PFNGLWINDOWPOS3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3fvARB")); + glWindowPos3iARB = reinterpret_cast<PFNGLWINDOWPOS3IARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3iARB")); + glWindowPos3ivARB = reinterpret_cast<PFNGLWINDOWPOS3IVARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3ivARB")); + glWindowPos3sARB = reinterpret_cast<PFNGLWINDOWPOS3SARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3sARB")); + glWindowPos3svARB = reinterpret_cast<PFNGLWINDOWPOS3SVARBPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3svARB")); + if (glWindowPos2dARB && glWindowPos2dvARB && glWindowPos2fARB && glWindowPos2fvARB && glWindowPos2iARB && glWindowPos2ivARB && glWindowPos2sARB && glWindowPos2svARB && glWindowPos3dARB && glWindowPos3dvARB && glWindowPos3fARB && glWindowPos3fvARB && glWindowPos3iARB && glWindowPos3ivARB && glWindowPos3sARB && glWindowPos3svARB) { + EnableExtension(_GL_ARB_window_pos); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_window_pos" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_window_pos implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_vertex_program) + if (QueryExtension("GL_ARB_vertex_program")) + { + glVertexAttrib1dARB = reinterpret_cast<PFNGLVERTEXATTRIB1DARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1dARB")); + glVertexAttrib1dvARB = reinterpret_cast<PFNGLVERTEXATTRIB1DVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1dvARB")); + glVertexAttrib1fARB = reinterpret_cast<PFNGLVERTEXATTRIB1FARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1fARB")); + glVertexAttrib1fvARB = reinterpret_cast<PFNGLVERTEXATTRIB1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1fvARB")); + glVertexAttrib1sARB = reinterpret_cast<PFNGLVERTEXATTRIB1SARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1sARB")); + glVertexAttrib1svARB = reinterpret_cast<PFNGLVERTEXATTRIB1SVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1svARB")); + glVertexAttrib2dARB = reinterpret_cast<PFNGLVERTEXATTRIB2DARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2dARB")); + glVertexAttrib2dvARB = reinterpret_cast<PFNGLVERTEXATTRIB2DVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2dvARB")); + glVertexAttrib2fARB = reinterpret_cast<PFNGLVERTEXATTRIB2FARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2fARB")); + glVertexAttrib2fvARB = reinterpret_cast<PFNGLVERTEXATTRIB2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2fvARB")); + glVertexAttrib2sARB = reinterpret_cast<PFNGLVERTEXATTRIB2SARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2sARB")); + glVertexAttrib2svARB = reinterpret_cast<PFNGLVERTEXATTRIB2SVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2svARB")); + glVertexAttrib3dARB = reinterpret_cast<PFNGLVERTEXATTRIB3DARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3dARB")); + glVertexAttrib3dvARB = reinterpret_cast<PFNGLVERTEXATTRIB3DVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3dvARB")); + glVertexAttrib3fARB = reinterpret_cast<PFNGLVERTEXATTRIB3FARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3fARB")); + glVertexAttrib3fvARB = reinterpret_cast<PFNGLVERTEXATTRIB3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3fvARB")); + glVertexAttrib3sARB = reinterpret_cast<PFNGLVERTEXATTRIB3SARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3sARB")); + glVertexAttrib3svARB = reinterpret_cast<PFNGLVERTEXATTRIB3SVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3svARB")); + glVertexAttrib4NbvARB = reinterpret_cast<PFNGLVERTEXATTRIB4NBVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NbvARB")); + glVertexAttrib4NivARB = reinterpret_cast<PFNGLVERTEXATTRIB4NIVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NivARB")); + glVertexAttrib4NsvARB = reinterpret_cast<PFNGLVERTEXATTRIB4NSVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NsvARB")); + glVertexAttrib4NubARB = reinterpret_cast<PFNGLVERTEXATTRIB4NUBARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NubARB")); + glVertexAttrib4NubvARB = reinterpret_cast<PFNGLVERTEXATTRIB4NUBVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NubvARB")); + glVertexAttrib4NuivARB = reinterpret_cast<PFNGLVERTEXATTRIB4NUIVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NuivARB")); + glVertexAttrib4NusvARB = reinterpret_cast<PFNGLVERTEXATTRIB4NUSVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NusvARB")); + glVertexAttrib4bvARB = reinterpret_cast<PFNGLVERTEXATTRIB4BVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4bvARB")); + glVertexAttrib4dARB = reinterpret_cast<PFNGLVERTEXATTRIB4DARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4dARB")); + glVertexAttrib4dvARB = reinterpret_cast<PFNGLVERTEXATTRIB4DVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4dvARB")); + glVertexAttrib4fARB = reinterpret_cast<PFNGLVERTEXATTRIB4FARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4fARB")); + glVertexAttrib4fvARB = reinterpret_cast<PFNGLVERTEXATTRIB4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4fvARB")); + glVertexAttrib4ivARB = reinterpret_cast<PFNGLVERTEXATTRIB4IVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4ivARB")); + glVertexAttrib4sARB = reinterpret_cast<PFNGLVERTEXATTRIB4SARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4sARB")); + glVertexAttrib4svARB = reinterpret_cast<PFNGLVERTEXATTRIB4SVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4svARB")); + glVertexAttrib4ubvARB = reinterpret_cast<PFNGLVERTEXATTRIB4UBVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4ubvARB")); + glVertexAttrib4uivARB = reinterpret_cast<PFNGLVERTEXATTRIB4UIVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4uivARB")); + glVertexAttrib4usvARB = reinterpret_cast<PFNGLVERTEXATTRIB4USVARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4usvARB")); + glVertexAttribPointerARB = reinterpret_cast<PFNGLVERTEXATTRIBPOINTERARBPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribPointerARB")); + glEnableVertexAttribArrayARB = reinterpret_cast<PFNGLENABLEVERTEXATTRIBARRAYARBPROC>(bglGetProcAddress((const GLubyte *) "glEnableVertexAttribArrayARB")); + glDisableVertexAttribArrayARB = reinterpret_cast<PFNGLDISABLEVERTEXATTRIBARRAYARBPROC>(bglGetProcAddress((const GLubyte *) "glDisableVertexAttribArrayARB")); + glProgramStringARB = reinterpret_cast<PFNGLPROGRAMSTRINGARBPROC>(bglGetProcAddress((const GLubyte *) "glProgramStringARB")); + glBindProgramARB = reinterpret_cast<PFNGLBINDPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glBindProgramARB")); + glDeleteProgramsARB = reinterpret_cast<PFNGLDELETEPROGRAMSARBPROC>(bglGetProcAddress((const GLubyte *) "glDeleteProgramsARB")); + glGenProgramsARB = reinterpret_cast<PFNGLGENPROGRAMSARBPROC>(bglGetProcAddress((const GLubyte *) "glGenProgramsARB")); + glProgramEnvParameter4dARB = reinterpret_cast<PFNGLPROGRAMENVPARAMETER4DARBPROC>(bglGetProcAddress((const GLubyte *) "glProgramEnvParameter4dARB")); + glProgramEnvParameter4dvARB = reinterpret_cast<PFNGLPROGRAMENVPARAMETER4DVARBPROC>(bglGetProcAddress((const GLubyte *) "glProgramEnvParameter4dvARB")); + glProgramEnvParameter4fARB = reinterpret_cast<PFNGLPROGRAMENVPARAMETER4FARBPROC>(bglGetProcAddress((const GLubyte *) "glProgramEnvParameter4fARB")); + glProgramEnvParameter4fvARB = reinterpret_cast<PFNGLPROGRAMENVPARAMETER4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glProgramEnvParameter4fvARB")); + glProgramLocalParameter4dARB = reinterpret_cast<PFNGLPROGRAMLOCALPARAMETER4DARBPROC>(bglGetProcAddress((const GLubyte *) "glProgramLocalParameter4dARB")); + glProgramLocalParameter4dvARB = reinterpret_cast<PFNGLPROGRAMLOCALPARAMETER4DVARBPROC>(bglGetProcAddress((const GLubyte *) "glProgramLocalParameter4dvARB")); + glProgramLocalParameter4fARB = reinterpret_cast<PFNGLPROGRAMLOCALPARAMETER4FARBPROC>(bglGetProcAddress((const GLubyte *) "glProgramLocalParameter4fARB")); + glProgramLocalParameter4fvARB = reinterpret_cast<PFNGLPROGRAMLOCALPARAMETER4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glProgramLocalParameter4fvARB")); + glGetProgramEnvParameterdvARB = reinterpret_cast<PFNGLGETPROGRAMENVPARAMETERDVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramEnvParameterdvARB")); + glGetProgramEnvParameterfvARB = reinterpret_cast<PFNGLGETPROGRAMENVPARAMETERFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramEnvParameterfvARB")); + glGetProgramLocalParameterdvARB = reinterpret_cast<PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramLocalParameterdvARB")); + glGetProgramLocalParameterfvARB = reinterpret_cast<PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramLocalParameterfvARB")); + glGetProgramivARB = reinterpret_cast<PFNGLGETPROGRAMIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramivARB")); + glGetProgramStringARB = reinterpret_cast<PFNGLGETPROGRAMSTRINGARBPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramStringARB")); + glGetVertexAttribdvARB = reinterpret_cast<PFNGLGETVERTEXATTRIBDVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribdvARB")); + glGetVertexAttribfvARB = reinterpret_cast<PFNGLGETVERTEXATTRIBFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribfvARB")); + glGetVertexAttribivARB = reinterpret_cast<PFNGLGETVERTEXATTRIBIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribivARB")); + glGetVertexAttribPointervARB = reinterpret_cast<PFNGLGETVERTEXATTRIBPOINTERVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribPointervARB")); + glIsProgramARB = reinterpret_cast<PFNGLISPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glIsProgramARB")); + if (glVertexAttrib1dARB && glVertexAttrib1dvARB && glVertexAttrib1fARB && glVertexAttrib1fvARB && glVertexAttrib1sARB && glVertexAttrib1svARB && glVertexAttrib2dARB && glVertexAttrib2dvARB && glVertexAttrib2fARB && glVertexAttrib2fvARB && glVertexAttrib2sARB && glVertexAttrib2svARB && glVertexAttrib3dARB && glVertexAttrib3dvARB && glVertexAttrib3fARB && glVertexAttrib3fvARB && glVertexAttrib3sARB && glVertexAttrib3svARB && glVertexAttrib4NbvARB && glVertexAttrib4NivARB && glVertexAttrib4NsvARB && glVertexAttrib4NubARB && glVertexAttrib4NubvARB && glVertexAttrib4NuivARB && glVertexAttrib4NusvARB && glVertexAttrib4bvARB && glVertexAttrib4dARB && glVertexAttrib4dvARB && glVertexAttrib4fARB && glVertexAttrib4fvARB && glVertexAttrib4ivARB && glVertexAttrib4sARB && glVertexAttrib4svARB && glVertexAttrib4ubvARB && glVertexAttrib4uivARB && glVertexAttrib4usvARB && glVertexAttribPointerARB && glEnableVertexAttribArrayARB && glDisableVertexAttribArrayARB && glProgramStringARB && glBindProgramARB && glDeleteProgramsARB && glGenProgramsARB && glProgramEnvParameter4dARB && glProgramEnvParameter4dvARB && glProgramEnvParameter4fARB && glProgramEnvParameter4fvARB && glProgramLocalParameter4dARB && glProgramLocalParameter4dvARB && glProgramLocalParameter4fARB && glProgramLocalParameter4fvARB && glGetProgramEnvParameterdvARB && glGetProgramEnvParameterfvARB && glGetProgramLocalParameterdvARB && glGetProgramLocalParameterfvARB && glGetProgramivARB && glGetProgramStringARB && glGetVertexAttribdvARB && glGetVertexAttribfvARB && glGetVertexAttribivARB && glGetVertexAttribPointervARB && glIsProgramARB) { + EnableExtension(_GL_ARB_vertex_program); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_vertex_program" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_vertex_program implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_fragment_program")) + { + EnableExtension(_GL_ARB_fragment_program); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_fragment_program" << std::endl; + } + +#if defined(GL_ARB_vertex_buffer_object) + if (QueryExtension("GL_ARB_vertex_buffer_object")) + { + glBindBufferARB = reinterpret_cast<PFNGLBINDBUFFERARBPROC>(bglGetProcAddress((const GLubyte *) "glBindBufferARB")); + glDeleteBuffersARB = reinterpret_cast<PFNGLDELETEBUFFERSARBPROC>(bglGetProcAddress((const GLubyte *) "glDeleteBuffersARB")); + glGenBuffersARB = reinterpret_cast<PFNGLGENBUFFERSARBPROC>(bglGetProcAddress((const GLubyte *) "glGenBuffersARB")); + glIsBufferARB = reinterpret_cast<PFNGLISBUFFERARBPROC>(bglGetProcAddress((const GLubyte *) "glIsBufferARB")); + glBufferDataARB = reinterpret_cast<PFNGLBUFFERDATAARBPROC>(bglGetProcAddress((const GLubyte *) "glBufferDataARB")); + glBufferSubDataARB = reinterpret_cast<PFNGLBUFFERSUBDATAARBPROC>(bglGetProcAddress((const GLubyte *) "glBufferSubDataARB")); + glGetBufferSubDataARB = reinterpret_cast<PFNGLGETBUFFERSUBDATAARBPROC>(bglGetProcAddress((const GLubyte *) "glGetBufferSubDataARB")); + glMapBufferARB = reinterpret_cast<PFNGLMAPBUFFERARBPROC>(bglGetProcAddress((const GLubyte *) "glMapBufferARB")); + glUnmapBufferARB = reinterpret_cast<PFNGLUNMAPBUFFERARBPROC>(bglGetProcAddress((const GLubyte *) "glUnmapBufferARB")); + glGetBufferParameterivARB = reinterpret_cast<PFNGLGETBUFFERPARAMETERIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetBufferParameterivARB")); + glGetBufferPointervARB = reinterpret_cast<PFNGLGETBUFFERPOINTERVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetBufferPointervARB")); + if (glBindBufferARB && glDeleteBuffersARB && glGenBuffersARB && glIsBufferARB && glBufferDataARB && glBufferSubDataARB && glGetBufferSubDataARB && glMapBufferARB && glUnmapBufferARB && glGetBufferParameterivARB && glGetBufferPointervARB) { + EnableExtension(_GL_ARB_vertex_buffer_object); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_vertex_buffer_object" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_vertex_buffer_object implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_occlusion_query) + if (QueryExtension("GL_ARB_occlusion_query")) + { + glGenQueriesARB = reinterpret_cast<PFNGLGENQUERIESARBPROC>(bglGetProcAddress((const GLubyte *) "glGenQueriesARB")); + glDeleteQueriesARB = reinterpret_cast<PFNGLDELETEQUERIESARBPROC>(bglGetProcAddress((const GLubyte *) "glDeleteQueriesARB")); + glIsQueryARB = reinterpret_cast<PFNGLISQUERYARBPROC>(bglGetProcAddress((const GLubyte *) "glIsQueryARB")); + glBeginQueryARB = reinterpret_cast<PFNGLBEGINQUERYARBPROC>(bglGetProcAddress((const GLubyte *) "glBeginQueryARB")); + glEndQueryARB = reinterpret_cast<PFNGLENDQUERYARBPROC>(bglGetProcAddress((const GLubyte *) "glEndQueryARB")); + glGetQueryivARB = reinterpret_cast<PFNGLGETQUERYIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetQueryivARB")); + glGetQueryObjectivARB = reinterpret_cast<PFNGLGETQUERYOBJECTIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetQueryObjectivARB")); + glGetQueryObjectuivARB = reinterpret_cast<PFNGLGETQUERYOBJECTUIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetQueryObjectuivARB")); + if (glGenQueriesARB && glDeleteQueriesARB && glIsQueryARB && glBeginQueryARB && glEndQueryARB && glGetQueryivARB && glGetQueryObjectivARB && glGetQueryObjectuivARB) { + EnableExtension(_GL_ARB_occlusion_query); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_occlusion_query" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_occlusion_query implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_shader_objects) + if (QueryExtension("GL_ARB_shader_objects")) + { + glDeleteObjectARB = reinterpret_cast<PFNGLDELETEOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glDeleteObjectARB")); + glGetHandleARB = reinterpret_cast<PFNGLGETHANDLEARBPROC>(bglGetProcAddress((const GLubyte *) "glGetHandleARB")); + glDetachObjectARB = reinterpret_cast<PFNGLDETACHOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glDetachObjectARB")); + glCreateShaderObjectARB = reinterpret_cast<PFNGLCREATESHADEROBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glCreateShaderObjectARB")); + glShaderSourceARB = reinterpret_cast<PFNGLSHADERSOURCEARBPROC>(bglGetProcAddress((const GLubyte *) "glShaderSourceARB")); + glCompileShaderARB = reinterpret_cast<PFNGLCOMPILESHADERARBPROC>(bglGetProcAddress((const GLubyte *) "glCompileShaderARB")); + glCreateProgramObjectARB = reinterpret_cast<PFNGLCREATEPROGRAMOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glCreateProgramObjectARB")); + glAttachObjectARB = reinterpret_cast<PFNGLATTACHOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glAttachObjectARB")); + glLinkProgramARB = reinterpret_cast<PFNGLLINKPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glLinkProgramARB")); + glUseProgramObjectARB = reinterpret_cast<PFNGLUSEPROGRAMOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glUseProgramObjectARB")); + glValidateProgramARB = reinterpret_cast<PFNGLVALIDATEPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glValidateProgramARB")); + glUniform1fARB = reinterpret_cast<PFNGLUNIFORM1FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1fARB")); + glUniform2fARB = reinterpret_cast<PFNGLUNIFORM2FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2fARB")); + glUniform3fARB = reinterpret_cast<PFNGLUNIFORM3FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3fARB")); + glUniform4fARB = reinterpret_cast<PFNGLUNIFORM4FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4fARB")); + glUniform1iARB = reinterpret_cast<PFNGLUNIFORM1IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1iARB")); + glUniform2iARB = reinterpret_cast<PFNGLUNIFORM2IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2iARB")); + glUniform3iARB = reinterpret_cast<PFNGLUNIFORM3IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3iARB")); + glUniform4iARB = reinterpret_cast<PFNGLUNIFORM4IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4iARB")); + glUniform1fvARB = reinterpret_cast<PFNGLUNIFORM1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1fvARB")); + glUniform2fvARB = reinterpret_cast<PFNGLUNIFORM2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2fvARB")); + glUniform3fvARB = reinterpret_cast<PFNGLUNIFORM3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3fvARB")); + glUniform4fvARB = reinterpret_cast<PFNGLUNIFORM4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4fvARB")); + glUniform1ivARB = reinterpret_cast<PFNGLUNIFORM1IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1ivARB")); + glUniform2ivARB = reinterpret_cast<PFNGLUNIFORM2IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2ivARB")); + glUniform3ivARB = reinterpret_cast<PFNGLUNIFORM3IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3ivARB")); + glUniform4ivARB = reinterpret_cast<PFNGLUNIFORM4IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4ivARB")); + glUniformMatrix2fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix2fvARB")); + glUniformMatrix3fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix3fvARB")); + glUniformMatrix4fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix4fvARB")); + glGetObjectParameterfvARB = reinterpret_cast<PFNGLGETOBJECTPARAMETERFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectParameterfvARB")); + glGetObjectParameterivARB = reinterpret_cast<PFNGLGETOBJECTPARAMETERIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectParameterivARB")); + glGetInfoLogARB = reinterpret_cast<PFNGLGETINFOLOGARBPROC>(bglGetProcAddress((const GLubyte *) "glGetInfoLogARB")); + glGetAttachedObjectsARB = reinterpret_cast<PFNGLGETATTACHEDOBJECTSARBPROC>(bglGetProcAddress((const GLubyte *) "glGetAttachedObjectsARB")); + glGetUniformLocationARB = reinterpret_cast<PFNGLGETUNIFORMLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformLocationARB")); + glGetActiveUniformARB = reinterpret_cast<PFNGLGETACTIVEUNIFORMARBPROC>(bglGetProcAddress((const GLubyte *) "glGetActiveUniformARB")); + glGetUniformfvARB = reinterpret_cast<PFNGLGETUNIFORMFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformfvARB")); + glGetUniformivARB = reinterpret_cast<PFNGLGETUNIFORMIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformivARB")); + glGetShaderSourceARB = reinterpret_cast<PFNGLGETSHADERSOURCEARBPROC>(bglGetProcAddress((const GLubyte *) "glGetShaderSourceARB")); + if (glDeleteObjectARB && glGetHandleARB && glDetachObjectARB && glCreateShaderObjectARB && glShaderSourceARB && glCompileShaderARB && glCreateProgramObjectARB && glAttachObjectARB && glLinkProgramARB && glUseProgramObjectARB && glValidateProgramARB && glUniform1fARB && glUniform2fARB && glUniform3fARB && glUniform4fARB && glUniform1iARB && glUniform2iARB && glUniform3iARB && glUniform4iARB && glUniform1fvARB && glUniform2fvARB && glUniform3fvARB && glUniform4fvARB && glUniform1ivARB && glUniform2ivARB && glUniform3ivARB && glUniform4ivARB && glUniformMatrix2fvARB && glUniformMatrix3fvARB && glUniformMatrix4fvARB && glGetObjectParameterfvARB && glGetObjectParameterivARB && glGetInfoLogARB && glGetAttachedObjectsARB && glGetUniformLocationARB && glGetActiveUniformARB && glGetUniformfvARB && glGetUniformivARB && glGetShaderSourceARB) { + EnableExtension(_GL_ARB_shader_objects); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_shader_objects" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_shader_objects implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_vertex_shader) + if (QueryExtension("GL_ARB_vertex_shader")) + { + glBindAttribLocationARB = reinterpret_cast<PFNGLBINDATTRIBLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glBindAttribLocationARB")); + glGetActiveAttribARB = reinterpret_cast<PFNGLGETACTIVEATTRIBARBPROC>(bglGetProcAddress((const GLubyte *) "glGetActiveAttribARB")); + glGetAttribLocationARB = reinterpret_cast<PFNGLGETATTRIBLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glGetAttribLocationARB")); + if (glBindAttribLocationARB && glGetActiveAttribARB && glGetAttribLocationARB) { + EnableExtension(_GL_ARB_vertex_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_vertex_shader" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_vertex_shader implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_fragment_shader")) + { + EnableExtension(_GL_ARB_fragment_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_fragment_shader" << std::endl; + } + + if (QueryExtension("GL_ARB_shading_language_100")) + { + EnableExtension(_GL_ARB_shading_language_100); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_shading_language_100" << std::endl; + } + + if (QueryExtension("GL_ARB_texture_non_power_of_two")) + { + EnableExtension(_GL_ARB_texture_non_power_of_two); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_non_power_of_two" << std::endl; + } + + if (QueryExtension("GL_ARB_point_sprite")) + { + EnableExtension(_GL_ARB_point_sprite); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_point_sprite" << std::endl; + } + + if (QueryExtension("GL_ARB_fragment_program_shadow")) + { + EnableExtension(_GL_ARB_fragment_program_shadow); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_fragment_program_shadow" << std::endl; + } + + if (QueryExtension("GL_EXT_abgr")) + { + EnableExtension(_GL_EXT_abgr); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_abgr" << std::endl; + } + +#if defined(GL_EXT_texture3D) + if (QueryExtension("GL_EXT_texture3D")) + { + glTexImage3DEXT = reinterpret_cast<PFNGLTEXIMAGE3DEXTPROC>(bglGetProcAddress((const GLubyte *) "glTexImage3DEXT")); + glTexSubImage3DEXT = reinterpret_cast<PFNGLTEXSUBIMAGE3DEXTPROC>(bglGetProcAddress((const GLubyte *) "glTexSubImage3DEXT")); + if (glTexImage3DEXT && glTexSubImage3DEXT) { + EnableExtension(_GL_EXT_texture3D); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture3D" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_texture3D implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIS_texture_filter4) + if (QueryExtension("GL_SGIS_texture_filter4")) + { + glGetTexFilterFuncSGIS = reinterpret_cast<PFNGLGETTEXFILTERFUNCSGISPROC>(bglGetProcAddress((const GLubyte *) "glGetTexFilterFuncSGIS")); + glTexFilterFuncSGIS = reinterpret_cast<PFNGLTEXFILTERFUNCSGISPROC>(bglGetProcAddress((const GLubyte *) "glTexFilterFuncSGIS")); + if (glGetTexFilterFuncSGIS && glTexFilterFuncSGIS) { + EnableExtension(_GL_SGIS_texture_filter4); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture_filter4" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_texture_filter4 implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_histogram) + if (QueryExtension("GL_EXT_histogram")) + { + glGetHistogramEXT = reinterpret_cast<PFNGLGETHISTOGRAMEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetHistogramEXT")); + glGetHistogramParameterfvEXT = reinterpret_cast<PFNGLGETHISTOGRAMPARAMETERFVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetHistogramParameterfvEXT")); + glGetHistogramParameterivEXT = reinterpret_cast<PFNGLGETHISTOGRAMPARAMETERIVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetHistogramParameterivEXT")); + glGetMinmaxEXT = reinterpret_cast<PFNGLGETMINMAXEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetMinmaxEXT")); + glGetMinmaxParameterfvEXT = reinterpret_cast<PFNGLGETMINMAXPARAMETERFVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetMinmaxParameterfvEXT")); + glGetMinmaxParameterivEXT = reinterpret_cast<PFNGLGETMINMAXPARAMETERIVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetMinmaxParameterivEXT")); + glHistogramEXT = reinterpret_cast<PFNGLHISTOGRAMEXTPROC>(bglGetProcAddress((const GLubyte *) "glHistogramEXT")); + glMinmaxEXT = reinterpret_cast<PFNGLMINMAXEXTPROC>(bglGetProcAddress((const GLubyte *) "glMinmaxEXT")); + glResetHistogramEXT = reinterpret_cast<PFNGLRESETHISTOGRAMEXTPROC>(bglGetProcAddress((const GLubyte *) "glResetHistogramEXT")); + glResetMinmaxEXT = reinterpret_cast<PFNGLRESETMINMAXEXTPROC>(bglGetProcAddress((const GLubyte *) "glResetMinmaxEXT")); + if (glGetHistogramEXT && glGetHistogramParameterfvEXT && glGetHistogramParameterivEXT && glGetMinmaxEXT && glGetMinmaxParameterfvEXT && glGetMinmaxParameterivEXT && glHistogramEXT && glMinmaxEXT && glResetHistogramEXT && glResetMinmaxEXT) { + EnableExtension(_GL_EXT_histogram); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_histogram" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_histogram implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_convolution) + if (QueryExtension("GL_EXT_convolution")) + { + glConvolutionFilter1DEXT = reinterpret_cast<PFNGLCONVOLUTIONFILTER1DEXTPROC>(bglGetProcAddress((const GLubyte *) "glConvolutionFilter1DEXT")); + glConvolutionFilter2DEXT = reinterpret_cast<PFNGLCONVOLUTIONFILTER2DEXTPROC>(bglGetProcAddress((const GLubyte *) "glConvolutionFilter2DEXT")); + glConvolutionParameterfEXT = reinterpret_cast<PFNGLCONVOLUTIONPARAMETERFEXTPROC>(bglGetProcAddress((const GLubyte *) "glConvolutionParameterfEXT")); + glConvolutionParameterfvEXT = reinterpret_cast<PFNGLCONVOLUTIONPARAMETERFVEXTPROC>(bglGetProcAddress((const GLubyte *) "glConvolutionParameterfvEXT")); + glConvolutionParameteriEXT = reinterpret_cast<PFNGLCONVOLUTIONPARAMETERIEXTPROC>(bglGetProcAddress((const GLubyte *) "glConvolutionParameteriEXT")); + glConvolutionParameterivEXT = reinterpret_cast<PFNGLCONVOLUTIONPARAMETERIVEXTPROC>(bglGetProcAddress((const GLubyte *) "glConvolutionParameterivEXT")); + glCopyConvolutionFilter1DEXT = reinterpret_cast<PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC>(bglGetProcAddress((const GLubyte *) "glCopyConvolutionFilter1DEXT")); + glCopyConvolutionFilter2DEXT = reinterpret_cast<PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC>(bglGetProcAddress((const GLubyte *) "glCopyConvolutionFilter2DEXT")); + glGetConvolutionFilterEXT = reinterpret_cast<PFNGLGETCONVOLUTIONFILTEREXTPROC>(bglGetProcAddress((const GLubyte *) "glGetConvolutionFilterEXT")); + glGetConvolutionParameterfvEXT = reinterpret_cast<PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetConvolutionParameterfvEXT")); + glGetConvolutionParameterivEXT = reinterpret_cast<PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetConvolutionParameterivEXT")); + glGetSeparableFilterEXT = reinterpret_cast<PFNGLGETSEPARABLEFILTEREXTPROC>(bglGetProcAddress((const GLubyte *) "glGetSeparableFilterEXT")); + glSeparableFilter2DEXT = reinterpret_cast<PFNGLSEPARABLEFILTER2DEXTPROC>(bglGetProcAddress((const GLubyte *) "glSeparableFilter2DEXT")); + if (glConvolutionFilter1DEXT && glConvolutionFilter2DEXT && glConvolutionParameterfEXT && glConvolutionParameterfvEXT && glConvolutionParameteriEXT && glConvolutionParameterivEXT && glCopyConvolutionFilter1DEXT && glCopyConvolutionFilter2DEXT && glGetConvolutionFilterEXT && glGetConvolutionParameterfvEXT && glGetConvolutionParameterivEXT && glGetSeparableFilterEXT && glSeparableFilter2DEXT) { + EnableExtension(_GL_EXT_convolution); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_convolution" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_convolution implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGI_color_table) + if (QueryExtension("GL_SGI_color_table")) + { + glColorTableSGI = reinterpret_cast<PFNGLCOLORTABLESGIPROC>(bglGetProcAddress((const GLubyte *) "glColorTableSGI")); + glColorTableParameterfvSGI = reinterpret_cast<PFNGLCOLORTABLEPARAMETERFVSGIPROC>(bglGetProcAddress((const GLubyte *) "glColorTableParameterfvSGI")); + glColorTableParameterivSGI = reinterpret_cast<PFNGLCOLORTABLEPARAMETERIVSGIPROC>(bglGetProcAddress((const GLubyte *) "glColorTableParameterivSGI")); + glCopyColorTableSGI = reinterpret_cast<PFNGLCOPYCOLORTABLESGIPROC>(bglGetProcAddress((const GLubyte *) "glCopyColorTableSGI")); + glGetColorTableSGI = reinterpret_cast<PFNGLGETCOLORTABLESGIPROC>(bglGetProcAddress((const GLubyte *) "glGetColorTableSGI")); + glGetColorTableParameterfvSGI = reinterpret_cast<PFNGLGETCOLORTABLEPARAMETERFVSGIPROC>(bglGetProcAddress((const GLubyte *) "glGetColorTableParameterfvSGI")); + glGetColorTableParameterivSGI = reinterpret_cast<PFNGLGETCOLORTABLEPARAMETERIVSGIPROC>(bglGetProcAddress((const GLubyte *) "glGetColorTableParameterivSGI")); + if (glColorTableSGI && glColorTableParameterfvSGI && glColorTableParameterivSGI && glCopyColorTableSGI && glGetColorTableSGI && glGetColorTableParameterfvSGI && glGetColorTableParameterivSGI) { + EnableExtension(_GL_SGI_color_table); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGI_color_table" << std::endl; + } else { + std::cout << "ERROR: GL_SGI_color_table implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIX_pixel_texture) + if (QueryExtension("GL_SGIX_pixel_texture")) + { + glPixelTexGenSGIX = reinterpret_cast<PFNGLPIXELTEXGENSGIXPROC>(bglGetProcAddress((const GLubyte *) "glPixelTexGenSGIX")); + if (glPixelTexGenSGIX) { + EnableExtension(_GL_SGIX_pixel_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_pixel_texture" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_pixel_texture implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIS_pixel_texture) + if (QueryExtension("GL_SGIS_pixel_texture")) + { + glPixelTexGenParameteriSGIS = reinterpret_cast<PFNGLPIXELTEXGENPARAMETERISGISPROC>(bglGetProcAddress((const GLubyte *) "glPixelTexGenParameteriSGIS")); + glPixelTexGenParameterivSGIS = reinterpret_cast<PFNGLPIXELTEXGENPARAMETERIVSGISPROC>(bglGetProcAddress((const GLubyte *) "glPixelTexGenParameterivSGIS")); + glPixelTexGenParameterfSGIS = reinterpret_cast<PFNGLPIXELTEXGENPARAMETERFSGISPROC>(bglGetProcAddress((const GLubyte *) "glPixelTexGenParameterfSGIS")); + glPixelTexGenParameterfvSGIS = reinterpret_cast<PFNGLPIXELTEXGENPARAMETERFVSGISPROC>(bglGetProcAddress((const GLubyte *) "glPixelTexGenParameterfvSGIS")); + glGetPixelTexGenParameterivSGIS = reinterpret_cast<PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC>(bglGetProcAddress((const GLubyte *) "glGetPixelTexGenParameterivSGIS")); + glGetPixelTexGenParameterfvSGIS = reinterpret_cast<PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC>(bglGetProcAddress((const GLubyte *) "glGetPixelTexGenParameterfvSGIS")); + if (glPixelTexGenParameteriSGIS && glPixelTexGenParameterivSGIS && glPixelTexGenParameterfSGIS && glPixelTexGenParameterfvSGIS && glGetPixelTexGenParameterivSGIS && glGetPixelTexGenParameterfvSGIS) { + EnableExtension(_GL_SGIS_pixel_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_pixel_texture" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_pixel_texture implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIS_texture4D) + if (QueryExtension("GL_SGIS_texture4D")) + { + glTexImage4DSGIS = reinterpret_cast<PFNGLTEXIMAGE4DSGISPROC>(bglGetProcAddress((const GLubyte *) "glTexImage4DSGIS")); + glTexSubImage4DSGIS = reinterpret_cast<PFNGLTEXSUBIMAGE4DSGISPROC>(bglGetProcAddress((const GLubyte *) "glTexSubImage4DSGIS")); + if (glTexImage4DSGIS && glTexSubImage4DSGIS) { + EnableExtension(_GL_SGIS_texture4D); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture4D" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_texture4D implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGI_texture_color_table")) + { + EnableExtension(_GL_SGI_texture_color_table); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGI_texture_color_table" << std::endl; + } + + if (QueryExtension("GL_EXT_cmyka")) + { + EnableExtension(_GL_EXT_cmyka); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_cmyka" << std::endl; + } + +#if defined(GL_SGIS_detail_texture) + if (QueryExtension("GL_SGIS_detail_texture")) + { + glDetailTexFuncSGIS = reinterpret_cast<PFNGLDETAILTEXFUNCSGISPROC>(bglGetProcAddress((const GLubyte *) "glDetailTexFuncSGIS")); + glGetDetailTexFuncSGIS = reinterpret_cast<PFNGLGETDETAILTEXFUNCSGISPROC>(bglGetProcAddress((const GLubyte *) "glGetDetailTexFuncSGIS")); + if (glDetailTexFuncSGIS && glGetDetailTexFuncSGIS) { + EnableExtension(_GL_SGIS_detail_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_detail_texture" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_detail_texture implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIS_sharpen_texture) + if (QueryExtension("GL_SGIS_sharpen_texture")) + { + glSharpenTexFuncSGIS = reinterpret_cast<PFNGLSHARPENTEXFUNCSGISPROC>(bglGetProcAddress((const GLubyte *) "glSharpenTexFuncSGIS")); + glGetSharpenTexFuncSGIS = reinterpret_cast<PFNGLGETSHARPENTEXFUNCSGISPROC>(bglGetProcAddress((const GLubyte *) "glGetSharpenTexFuncSGIS")); + if (glSharpenTexFuncSGIS && glGetSharpenTexFuncSGIS) { + EnableExtension(_GL_SGIS_sharpen_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_sharpen_texture" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_sharpen_texture implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_packed_pixels")) + { + EnableExtension(_GL_EXT_packed_pixels); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_packed_pixels" << std::endl; + } + + if (QueryExtension("GL_SGIS_texture_lod")) + { + EnableExtension(_GL_SGIS_texture_lod); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture_lod" << std::endl; + } + +#if defined(GL_SGIS_multisample) + if (QueryExtension("GL_SGIS_multisample")) + { + glSampleMaskSGIS = reinterpret_cast<PFNGLSAMPLEMASKSGISPROC>(bglGetProcAddress((const GLubyte *) "glSampleMaskSGIS")); + glSamplePatternSGIS = reinterpret_cast<PFNGLSAMPLEPATTERNSGISPROC>(bglGetProcAddress((const GLubyte *) "glSamplePatternSGIS")); + if (glSampleMaskSGIS && glSamplePatternSGIS) { + EnableExtension(_GL_SGIS_multisample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_multisample" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_multisample implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_rescale_normal")) + { + EnableExtension(_GL_EXT_rescale_normal); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_rescale_normal" << std::endl; + } + + if (QueryExtension("GL_EXT_misc_attribute")) + { + EnableExtension(_GL_EXT_misc_attribute); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_misc_attribute" << std::endl; + } + + if (QueryExtension("GL_SGIS_generate_mipmap")) + { + EnableExtension(_GL_SGIS_generate_mipmap); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_generate_mipmap" << std::endl; + } + + if (QueryExtension("GL_SGIX_clipmap")) + { + EnableExtension(_GL_SGIX_clipmap); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_clipmap" << std::endl; + } + + if (QueryExtension("GL_SGIX_shadow")) + { + EnableExtension(_GL_SGIX_shadow); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_shadow" << std::endl; + } + + if (QueryExtension("GL_SGIS_texture_edge_clamp")) + { + EnableExtension(_GL_SGIS_texture_edge_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture_edge_clamp" << std::endl; + } + + if (QueryExtension("GL_SGIS_texture_border_clamp")) + { + EnableExtension(_GL_SGIS_texture_border_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture_border_clamp" << std::endl; + } + +#if defined(GL_EXT_blend_minmax) + if (QueryExtension("GL_EXT_blend_minmax")) + { + glBlendEquationEXT = reinterpret_cast<PFNGLBLENDEQUATIONEXTPROC>(bglGetProcAddress((const GLubyte *) "glBlendEquationEXT")); + if (glBlendEquationEXT) { + EnableExtension(_GL_EXT_blend_minmax); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_blend_minmax" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_blend_minmax implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_blend_subtract")) + { + EnableExtension(_GL_EXT_blend_subtract); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_blend_subtract" << std::endl; + } + + if (QueryExtension("GL_EXT_blend_logic_op")) + { + EnableExtension(_GL_EXT_blend_logic_op); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_blend_logic_op" << std::endl; + } + + if (QueryExtension("GL_SGIX_interlace")) + { + EnableExtension(_GL_SGIX_interlace); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_interlace" << std::endl; + } + +#if defined(GL_SGIX_sprite) + if (QueryExtension("GL_SGIX_sprite")) + { + glSpriteParameterfSGIX = reinterpret_cast<PFNGLSPRITEPARAMETERFSGIXPROC>(bglGetProcAddress((const GLubyte *) "glSpriteParameterfSGIX")); + glSpriteParameterfvSGIX = reinterpret_cast<PFNGLSPRITEPARAMETERFVSGIXPROC>(bglGetProcAddress((const GLubyte *) "glSpriteParameterfvSGIX")); + glSpriteParameteriSGIX = reinterpret_cast<PFNGLSPRITEPARAMETERISGIXPROC>(bglGetProcAddress((const GLubyte *) "glSpriteParameteriSGIX")); + glSpriteParameterivSGIX = reinterpret_cast<PFNGLSPRITEPARAMETERIVSGIXPROC>(bglGetProcAddress((const GLubyte *) "glSpriteParameterivSGIX")); + if (glSpriteParameterfSGIX && glSpriteParameterfvSGIX && glSpriteParameteriSGIX && glSpriteParameterivSGIX) { + EnableExtension(_GL_SGIX_sprite); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_sprite" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_sprite implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_texture_multi_buffer")) + { + EnableExtension(_GL_SGIX_texture_multi_buffer); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_texture_multi_buffer" << std::endl; + } + +#if defined(GL_SGIX_instruments) + if (QueryExtension("GL_SGIX_instruments")) + { + glGetInstrumentsSGIX = reinterpret_cast<PFNGLGETINSTRUMENTSSGIXPROC>(bglGetProcAddress((const GLubyte *) "glGetInstrumentsSGIX")); + glInstrumentsBufferSGIX = reinterpret_cast<PFNGLINSTRUMENTSBUFFERSGIXPROC>(bglGetProcAddress((const GLubyte *) "glInstrumentsBufferSGIX")); + glPollInstrumentsSGIX = reinterpret_cast<PFNGLPOLLINSTRUMENTSSGIXPROC>(bglGetProcAddress((const GLubyte *) "glPollInstrumentsSGIX")); + glReadInstrumentsSGIX = reinterpret_cast<PFNGLREADINSTRUMENTSSGIXPROC>(bglGetProcAddress((const GLubyte *) "glReadInstrumentsSGIX")); + glStartInstrumentsSGIX = reinterpret_cast<PFNGLSTARTINSTRUMENTSSGIXPROC>(bglGetProcAddress((const GLubyte *) "glStartInstrumentsSGIX")); + glStopInstrumentsSGIX = reinterpret_cast<PFNGLSTOPINSTRUMENTSSGIXPROC>(bglGetProcAddress((const GLubyte *) "glStopInstrumentsSGIX")); + if (glGetInstrumentsSGIX && glInstrumentsBufferSGIX && glPollInstrumentsSGIX && glReadInstrumentsSGIX && glStartInstrumentsSGIX && glStopInstrumentsSGIX) { + EnableExtension(_GL_SGIX_instruments); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_instruments" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_instruments implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_texture_scale_bias")) + { + EnableExtension(_GL_SGIX_texture_scale_bias); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_texture_scale_bias" << std::endl; + } + +#if defined(GL_SGIX_framezoom) + if (QueryExtension("GL_SGIX_framezoom")) + { + glFrameZoomSGIX = reinterpret_cast<PFNGLFRAMEZOOMSGIXPROC>(bglGetProcAddress((const GLubyte *) "glFrameZoomSGIX")); + if (glFrameZoomSGIX) { + EnableExtension(_GL_SGIX_framezoom); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_framezoom" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_framezoom implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIX_tag_sample_buffer) + if (QueryExtension("GL_SGIX_tag_sample_buffer")) + { + glTagSampleBufferSGIX = reinterpret_cast<PFNGLTAGSAMPLEBUFFERSGIXPROC>(bglGetProcAddress((const GLubyte *) "glTagSampleBufferSGIX")); + if (glTagSampleBufferSGIX) { + EnableExtension(_GL_SGIX_tag_sample_buffer); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_tag_sample_buffer" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_tag_sample_buffer implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIX_reference_plane) + if (QueryExtension("GL_SGIX_reference_plane")) + { + glReferencePlaneSGIX = reinterpret_cast<PFNGLREFERENCEPLANESGIXPROC>(bglGetProcAddress((const GLubyte *) "glReferencePlaneSGIX")); + if (glReferencePlaneSGIX) { + EnableExtension(_GL_SGIX_reference_plane); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_reference_plane" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_reference_plane implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIX_flush_raster) + if (QueryExtension("GL_SGIX_flush_raster")) + { + glFlushRasterSGIX = reinterpret_cast<PFNGLFLUSHRASTERSGIXPROC>(bglGetProcAddress((const GLubyte *) "glFlushRasterSGIX")); + if (glFlushRasterSGIX) { + EnableExtension(_GL_SGIX_flush_raster); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_flush_raster" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_flush_raster implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_depth_texture")) + { + EnableExtension(_GL_SGIX_depth_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_depth_texture" << std::endl; + } + +#if defined(GL_SGIS_fog_function) + if (QueryExtension("GL_SGIS_fog_function")) + { + glFogFuncSGIS = reinterpret_cast<PFNGLFOGFUNCSGISPROC>(bglGetProcAddress((const GLubyte *) "glFogFuncSGIS")); + glGetFogFuncSGIS = reinterpret_cast<PFNGLGETFOGFUNCSGISPROC>(bglGetProcAddress((const GLubyte *) "glGetFogFuncSGIS")); + if (glFogFuncSGIS && glGetFogFuncSGIS) { + EnableExtension(_GL_SGIS_fog_function); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_fog_function" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_fog_function implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_fog_offset")) + { + EnableExtension(_GL_SGIX_fog_offset); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_fog_offset" << std::endl; + } + +#if defined(GL_HP_image_transform) + if (QueryExtension("GL_HP_image_transform")) + { + glImageTransformParameteriHP = reinterpret_cast<PFNGLIMAGETRANSFORMPARAMETERIHPPROC>(bglGetProcAddress((const GLubyte *) "glImageTransformParameteriHP")); + glImageTransformParameterfHP = reinterpret_cast<PFNGLIMAGETRANSFORMPARAMETERFHPPROC>(bglGetProcAddress((const GLubyte *) "glImageTransformParameterfHP")); + glImageTransformParameterivHP = reinterpret_cast<PFNGLIMAGETRANSFORMPARAMETERIVHPPROC>(bglGetProcAddress((const GLubyte *) "glImageTransformParameterivHP")); + glImageTransformParameterfvHP = reinterpret_cast<PFNGLIMAGETRANSFORMPARAMETERFVHPPROC>(bglGetProcAddress((const GLubyte *) "glImageTransformParameterfvHP")); + glGetImageTransformParameterivHP = reinterpret_cast<PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC>(bglGetProcAddress((const GLubyte *) "glGetImageTransformParameterivHP")); + glGetImageTransformParameterfvHP = reinterpret_cast<PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC>(bglGetProcAddress((const GLubyte *) "glGetImageTransformParameterfvHP")); + if (glImageTransformParameteriHP && glImageTransformParameterfHP && glImageTransformParameterivHP && glImageTransformParameterfvHP && glGetImageTransformParameterivHP && glGetImageTransformParameterfvHP) { + EnableExtension(_GL_HP_image_transform); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_HP_image_transform" << std::endl; + } else { + std::cout << "ERROR: GL_HP_image_transform implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_HP_convolution_border_modes")) + { + EnableExtension(_GL_HP_convolution_border_modes); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_HP_convolution_border_modes" << std::endl; + } + + if (QueryExtension("GL_SGIX_texture_add_env")) + { + EnableExtension(_GL_SGIX_texture_add_env); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_texture_add_env" << std::endl; + } + +#if defined(GL_EXT_color_subtable) + if (QueryExtension("GL_EXT_color_subtable")) + { + glColorSubTableEXT = reinterpret_cast<PFNGLCOLORSUBTABLEEXTPROC>(bglGetProcAddress((const GLubyte *) "glColorSubTableEXT")); + glCopyColorSubTableEXT = reinterpret_cast<PFNGLCOPYCOLORSUBTABLEEXTPROC>(bglGetProcAddress((const GLubyte *) "glCopyColorSubTableEXT")); + if (glColorSubTableEXT && glCopyColorSubTableEXT) { + EnableExtension(_GL_EXT_color_subtable); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_color_subtable" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_color_subtable implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_PGI_vertex_hints")) + { + EnableExtension(_GL_PGI_vertex_hints); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_PGI_vertex_hints" << std::endl; + } + +#if defined(GL_PGI_misc_hints) + if (QueryExtension("GL_PGI_misc_hints")) + { + glHintPGI = reinterpret_cast<PFNGLHINTPGIPROC>(bglGetProcAddress((const GLubyte *) "glHintPGI")); + if (glHintPGI) { + EnableExtension(_GL_PGI_misc_hints); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_PGI_misc_hints" << std::endl; + } else { + std::cout << "ERROR: GL_PGI_misc_hints implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_paletted_texture) + if (QueryExtension("GL_EXT_paletted_texture")) + { + glColorTableEXT = reinterpret_cast<PFNGLCOLORTABLEEXTPROC>(bglGetProcAddress((const GLubyte *) "glColorTableEXT")); + glGetColorTableEXT = reinterpret_cast<PFNGLGETCOLORTABLEEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetColorTableEXT")); + glGetColorTableParameterivEXT = reinterpret_cast<PFNGLGETCOLORTABLEPARAMETERIVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetColorTableParameterivEXT")); + glGetColorTableParameterfvEXT = reinterpret_cast<PFNGLGETCOLORTABLEPARAMETERFVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetColorTableParameterfvEXT")); + if (glColorTableEXT && glGetColorTableEXT && glGetColorTableParameterivEXT && glGetColorTableParameterfvEXT) { + EnableExtension(_GL_EXT_paletted_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_paletted_texture" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_paletted_texture implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_clip_volume_hint")) + { + EnableExtension(_GL_EXT_clip_volume_hint); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_clip_volume_hint" << std::endl; + } + +#if defined(GL_SGIX_list_priority) + if (QueryExtension("GL_SGIX_list_priority")) + { + glGetListParameterfvSGIX = reinterpret_cast<PFNGLGETLISTPARAMETERFVSGIXPROC>(bglGetProcAddress((const GLubyte *) "glGetListParameterfvSGIX")); + glGetListParameterivSGIX = reinterpret_cast<PFNGLGETLISTPARAMETERIVSGIXPROC>(bglGetProcAddress((const GLubyte *) "glGetListParameterivSGIX")); + glListParameterfSGIX = reinterpret_cast<PFNGLLISTPARAMETERFSGIXPROC>(bglGetProcAddress((const GLubyte *) "glListParameterfSGIX")); + glListParameterfvSGIX = reinterpret_cast<PFNGLLISTPARAMETERFVSGIXPROC>(bglGetProcAddress((const GLubyte *) "glListParameterfvSGIX")); + glListParameteriSGIX = reinterpret_cast<PFNGLLISTPARAMETERISGIXPROC>(bglGetProcAddress((const GLubyte *) "glListParameteriSGIX")); + glListParameterivSGIX = reinterpret_cast<PFNGLLISTPARAMETERIVSGIXPROC>(bglGetProcAddress((const GLubyte *) "glListParameterivSGIX")); + if (glGetListParameterfvSGIX && glGetListParameterivSGIX && glListParameterfSGIX && glListParameterfvSGIX && glListParameteriSGIX && glListParameterivSGIX) { + EnableExtension(_GL_SGIX_list_priority); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_list_priority" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_list_priority implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_ir_instrument1")) + { + EnableExtension(_GL_SGIX_ir_instrument1); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_ir_instrument1" << std::endl; + } + + if (QueryExtension("GL_SGIX_texture_lod_bias")) + { + EnableExtension(_GL_SGIX_texture_lod_bias); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_texture_lod_bias" << std::endl; + } + + if (QueryExtension("GL_SGIX_shadow_ambient")) + { + EnableExtension(_GL_SGIX_shadow_ambient); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_shadow_ambient" << std::endl; + } + + if (QueryExtension("GL_EXT_index_texture")) + { + EnableExtension(_GL_EXT_index_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_index_texture" << std::endl; + } + +#if defined(GL_EXT_index_material) + if (QueryExtension("GL_EXT_index_material")) + { + glIndexMaterialEXT = reinterpret_cast<PFNGLINDEXMATERIALEXTPROC>(bglGetProcAddress((const GLubyte *) "glIndexMaterialEXT")); + if (glIndexMaterialEXT) { + EnableExtension(_GL_EXT_index_material); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_index_material" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_index_material implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_index_func) + if (QueryExtension("GL_EXT_index_func")) + { + glIndexFuncEXT = reinterpret_cast<PFNGLINDEXFUNCEXTPROC>(bglGetProcAddress((const GLubyte *) "glIndexFuncEXT")); + if (glIndexFuncEXT) { + EnableExtension(_GL_EXT_index_func); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_index_func" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_index_func implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_index_array_formats")) + { + EnableExtension(_GL_EXT_index_array_formats); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_index_array_formats" << std::endl; + } + +#if defined(GL_EXT_cull_vertex) + if (QueryExtension("GL_EXT_cull_vertex")) + { + glCullParameterdvEXT = reinterpret_cast<PFNGLCULLPARAMETERDVEXTPROC>(bglGetProcAddress((const GLubyte *) "glCullParameterdvEXT")); + glCullParameterfvEXT = reinterpret_cast<PFNGLCULLPARAMETERFVEXTPROC>(bglGetProcAddress((const GLubyte *) "glCullParameterfvEXT")); + if (glCullParameterdvEXT && glCullParameterfvEXT) { + EnableExtension(_GL_EXT_cull_vertex); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_cull_vertex" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_cull_vertex implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_ycrcb")) + { + EnableExtension(_GL_SGIX_ycrcb); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_ycrcb" << std::endl; + } + + if (QueryExtension("GL_IBM_rasterpos_clip")) + { + EnableExtension(_GL_IBM_rasterpos_clip); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_IBM_rasterpos_clip" << std::endl; + } + + if (QueryExtension("GL_HP_texture_lighting")) + { + EnableExtension(_GL_HP_texture_lighting); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_HP_texture_lighting" << std::endl; + } + +#if defined(GL_EXT_draw_range_elements) + if (QueryExtension("GL_EXT_draw_range_elements")) + { + glDrawRangeElementsEXT = reinterpret_cast<PFNGLDRAWRANGEELEMENTSEXTPROC>(bglGetProcAddress((const GLubyte *) "glDrawRangeElementsEXT")); + if (glDrawRangeElementsEXT) { + EnableExtension(_GL_EXT_draw_range_elements); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_draw_range_elements" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_draw_range_elements implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_WIN_phong_shading")) + { + EnableExtension(_GL_WIN_phong_shading); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_WIN_phong_shading" << std::endl; + } + + if (QueryExtension("GL_WIN_specular_fog")) + { + EnableExtension(_GL_WIN_specular_fog); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_WIN_specular_fog" << std::endl; + } + +#if defined(GL_EXT_light_texture) + if (QueryExtension("GL_EXT_light_texture")) + { + glApplyTextureEXT = reinterpret_cast<PFNGLAPPLYTEXTUREEXTPROC>(bglGetProcAddress((const GLubyte *) "glApplyTextureEXT")); + glTextureLightEXT = reinterpret_cast<PFNGLTEXTURELIGHTEXTPROC>(bglGetProcAddress((const GLubyte *) "glTextureLightEXT")); + glTextureMaterialEXT = reinterpret_cast<PFNGLTEXTUREMATERIALEXTPROC>(bglGetProcAddress((const GLubyte *) "glTextureMaterialEXT")); + if (glApplyTextureEXT && glTextureLightEXT && glTextureMaterialEXT) { + EnableExtension(_GL_EXT_light_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_light_texture" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_light_texture implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_blend_alpha_minmax")) + { + EnableExtension(_GL_SGIX_blend_alpha_minmax); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_blend_alpha_minmax" << std::endl; + } + + if (QueryExtension("GL_EXT_bgra")) + { + EnableExtension(_GL_EXT_bgra); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_bgra" << std::endl; + } + +#if defined(GL_SGIX_async) + if (QueryExtension("GL_SGIX_async")) + { + glAsyncMarkerSGIX = reinterpret_cast<PFNGLASYNCMARKERSGIXPROC>(bglGetProcAddress((const GLubyte *) "glAsyncMarkerSGIX")); + glFinishAsyncSGIX = reinterpret_cast<PFNGLFINISHASYNCSGIXPROC>(bglGetProcAddress((const GLubyte *) "glFinishAsyncSGIX")); + glPollAsyncSGIX = reinterpret_cast<PFNGLPOLLASYNCSGIXPROC>(bglGetProcAddress((const GLubyte *) "glPollAsyncSGIX")); + glGenAsyncMarkersSGIX = reinterpret_cast<PFNGLGENASYNCMARKERSSGIXPROC>(bglGetProcAddress((const GLubyte *) "glGenAsyncMarkersSGIX")); + glDeleteAsyncMarkersSGIX = reinterpret_cast<PFNGLDELETEASYNCMARKERSSGIXPROC>(bglGetProcAddress((const GLubyte *) "glDeleteAsyncMarkersSGIX")); + glIsAsyncMarkerSGIX = reinterpret_cast<PFNGLISASYNCMARKERSGIXPROC>(bglGetProcAddress((const GLubyte *) "glIsAsyncMarkerSGIX")); + if (glAsyncMarkerSGIX && glFinishAsyncSGIX && glPollAsyncSGIX && glGenAsyncMarkersSGIX && glDeleteAsyncMarkersSGIX && glIsAsyncMarkerSGIX) { + EnableExtension(_GL_SGIX_async); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_async" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_async implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_async_pixel")) + { + EnableExtension(_GL_SGIX_async_pixel); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_async_pixel" << std::endl; + } + + if (QueryExtension("GL_SGIX_async_histogram")) + { + EnableExtension(_GL_SGIX_async_histogram); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_async_histogram" << std::endl; + } + +#if defined(GL_INTEL_parallel_arrays) + if (QueryExtension("GL_INTEL_parallel_arrays")) + { + glVertexPointervINTEL = reinterpret_cast<PFNGLVERTEXPOINTERVINTELPROC>(bglGetProcAddress((const GLubyte *) "glVertexPointervINTEL")); + glNormalPointervINTEL = reinterpret_cast<PFNGLNORMALPOINTERVINTELPROC>(bglGetProcAddress((const GLubyte *) "glNormalPointervINTEL")); + glColorPointervINTEL = reinterpret_cast<PFNGLCOLORPOINTERVINTELPROC>(bglGetProcAddress((const GLubyte *) "glColorPointervINTEL")); + glTexCoordPointervINTEL = reinterpret_cast<PFNGLTEXCOORDPOINTERVINTELPROC>(bglGetProcAddress((const GLubyte *) "glTexCoordPointervINTEL")); + if (glVertexPointervINTEL && glNormalPointervINTEL && glColorPointervINTEL && glTexCoordPointervINTEL) { + EnableExtension(_GL_INTEL_parallel_arrays); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_INTEL_parallel_arrays" << std::endl; + } else { + std::cout << "ERROR: GL_INTEL_parallel_arrays implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_HP_occlusion_test")) + { + EnableExtension(_GL_HP_occlusion_test); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_HP_occlusion_test" << std::endl; + } + +#if defined(GL_EXT_pixel_transform) + if (QueryExtension("GL_EXT_pixel_transform")) + { + glPixelTransformParameteriEXT = reinterpret_cast<PFNGLPIXELTRANSFORMPARAMETERIEXTPROC>(bglGetProcAddress((const GLubyte *) "glPixelTransformParameteriEXT")); + glPixelTransformParameterfEXT = reinterpret_cast<PFNGLPIXELTRANSFORMPARAMETERFEXTPROC>(bglGetProcAddress((const GLubyte *) "glPixelTransformParameterfEXT")); + glPixelTransformParameterivEXT = reinterpret_cast<PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC>(bglGetProcAddress((const GLubyte *) "glPixelTransformParameterivEXT")); + glPixelTransformParameterfvEXT = reinterpret_cast<PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC>(bglGetProcAddress((const GLubyte *) "glPixelTransformParameterfvEXT")); + if (glPixelTransformParameteriEXT && glPixelTransformParameterfEXT && glPixelTransformParameterivEXT && glPixelTransformParameterfvEXT) { + EnableExtension(_GL_EXT_pixel_transform); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_pixel_transform" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_pixel_transform implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_pixel_transform_color_table")) + { + EnableExtension(_GL_EXT_pixel_transform_color_table); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_pixel_transform_color_table" << std::endl; + } + + if (QueryExtension("GL_EXT_shared_texture_palette")) + { + EnableExtension(_GL_EXT_shared_texture_palette); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_shared_texture_palette" << std::endl; + } + + if (QueryExtension("GL_EXT_separate_specular_color")) + { + EnableExtension(_GL_EXT_separate_specular_color); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_separate_specular_color" << std::endl; + } + +#if defined(GL_EXT_secondary_color) + if (QueryExtension("GL_EXT_secondary_color")) + { + glSecondaryColor3bEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3BEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3bEXT")); + glSecondaryColor3bvEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3BVEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3bvEXT")); + glSecondaryColor3dEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3DEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3dEXT")); + glSecondaryColor3dvEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3DVEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3dvEXT")); + glSecondaryColor3fEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3FEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3fEXT")); + glSecondaryColor3fvEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3FVEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3fvEXT")); + glSecondaryColor3iEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3IEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3iEXT")); + glSecondaryColor3ivEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3IVEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3ivEXT")); + glSecondaryColor3sEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3SEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3sEXT")); + glSecondaryColor3svEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3SVEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3svEXT")); + glSecondaryColor3ubEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3UBEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3ubEXT")); + glSecondaryColor3ubvEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3UBVEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3ubvEXT")); + glSecondaryColor3uiEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3UIEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3uiEXT")); + glSecondaryColor3uivEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3UIVEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3uivEXT")); + glSecondaryColor3usEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3USEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3usEXT")); + glSecondaryColor3usvEXT = reinterpret_cast<PFNGLSECONDARYCOLOR3USVEXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3usvEXT")); + glSecondaryColorPointerEXT = reinterpret_cast<PFNGLSECONDARYCOLORPOINTEREXTPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColorPointerEXT")); + if (glSecondaryColor3bEXT && glSecondaryColor3bvEXT && glSecondaryColor3dEXT && glSecondaryColor3dvEXT && glSecondaryColor3fEXT && glSecondaryColor3fvEXT && glSecondaryColor3iEXT && glSecondaryColor3ivEXT && glSecondaryColor3sEXT && glSecondaryColor3svEXT && glSecondaryColor3ubEXT && glSecondaryColor3ubvEXT && glSecondaryColor3uiEXT && glSecondaryColor3uivEXT && glSecondaryColor3usEXT && glSecondaryColor3usvEXT && glSecondaryColorPointerEXT) { + EnableExtension(_GL_EXT_secondary_color); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_secondary_color" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_secondary_color implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_texture_perturb_normal) + if (QueryExtension("GL_EXT_texture_perturb_normal")) + { + glTextureNormalEXT = reinterpret_cast<PFNGLTEXTURENORMALEXTPROC>(bglGetProcAddress((const GLubyte *) "glTextureNormalEXT")); + if (glTextureNormalEXT) { + EnableExtension(_GL_EXT_texture_perturb_normal); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_perturb_normal" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_texture_perturb_normal implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_multi_draw_arrays) + if (QueryExtension("GL_EXT_multi_draw_arrays")) + { + glMultiDrawArraysEXT = reinterpret_cast<PFNGLMULTIDRAWARRAYSEXTPROC>(bglGetProcAddress((const GLubyte *) "glMultiDrawArraysEXT")); + glMultiDrawElementsEXT = reinterpret_cast<PFNGLMULTIDRAWELEMENTSEXTPROC>(bglGetProcAddress((const GLubyte *) "glMultiDrawElementsEXT")); + if (glMultiDrawArraysEXT && glMultiDrawElementsEXT) { + EnableExtension(_GL_EXT_multi_draw_arrays); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_multi_draw_arrays" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_multi_draw_arrays implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_fog_coord) + if (QueryExtension("GL_EXT_fog_coord")) + { + glFogCoordfEXT = reinterpret_cast<PFNGLFOGCOORDFEXTPROC>(bglGetProcAddress((const GLubyte *) "glFogCoordfEXT")); + glFogCoordfvEXT = reinterpret_cast<PFNGLFOGCOORDFVEXTPROC>(bglGetProcAddress((const GLubyte *) "glFogCoordfvEXT")); + glFogCoorddEXT = reinterpret_cast<PFNGLFOGCOORDDEXTPROC>(bglGetProcAddress((const GLubyte *) "glFogCoorddEXT")); + glFogCoorddvEXT = reinterpret_cast<PFNGLFOGCOORDDVEXTPROC>(bglGetProcAddress((const GLubyte *) "glFogCoorddvEXT")); + glFogCoordPointerEXT = reinterpret_cast<PFNGLFOGCOORDPOINTEREXTPROC>(bglGetProcAddress((const GLubyte *) "glFogCoordPointerEXT")); + if (glFogCoordfEXT && glFogCoordfvEXT && glFogCoorddEXT && glFogCoorddvEXT && glFogCoordPointerEXT) { + EnableExtension(_GL_EXT_fog_coord); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_fog_coord" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_fog_coord implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_REND_screen_coordinates")) + { + EnableExtension(_GL_REND_screen_coordinates); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_REND_screen_coordinates" << std::endl; + } + +#if defined(GL_EXT_coordinate_frame) + if (QueryExtension("GL_EXT_coordinate_frame")) + { + glTangent3bEXT = reinterpret_cast<PFNGLTANGENT3BEXTPROC>(bglGetProcAddress((const GLubyte *) "glTangent3bEXT")); + glTangent3bvEXT = reinterpret_cast<PFNGLTANGENT3BVEXTPROC>(bglGetProcAddress((const GLubyte *) "glTangent3bvEXT")); + glTangent3dEXT = reinterpret_cast<PFNGLTANGENT3DEXTPROC>(bglGetProcAddress((const GLubyte *) "glTangent3dEXT")); + glTangent3dvEXT = reinterpret_cast<PFNGLTANGENT3DVEXTPROC>(bglGetProcAddress((const GLubyte *) "glTangent3dvEXT")); + glTangent3fEXT = reinterpret_cast<PFNGLTANGENT3FEXTPROC>(bglGetProcAddress((const GLubyte *) "glTangent3fEXT")); + glTangent3fvEXT = reinterpret_cast<PFNGLTANGENT3FVEXTPROC>(bglGetProcAddress((const GLubyte *) "glTangent3fvEXT")); + glTangent3iEXT = reinterpret_cast<PFNGLTANGENT3IEXTPROC>(bglGetProcAddress((const GLubyte *) "glTangent3iEXT")); + glTangent3ivEXT = reinterpret_cast<PFNGLTANGENT3IVEXTPROC>(bglGetProcAddress((const GLubyte *) "glTangent3ivEXT")); + glTangent3sEXT = reinterpret_cast<PFNGLTANGENT3SEXTPROC>(bglGetProcAddress((const GLubyte *) "glTangent3sEXT")); + glTangent3svEXT = reinterpret_cast<PFNGLTANGENT3SVEXTPROC>(bglGetProcAddress((const GLubyte *) "glTangent3svEXT")); + glBinormal3bEXT = reinterpret_cast<PFNGLBINORMAL3BEXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormal3bEXT")); + glBinormal3bvEXT = reinterpret_cast<PFNGLBINORMAL3BVEXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormal3bvEXT")); + glBinormal3dEXT = reinterpret_cast<PFNGLBINORMAL3DEXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormal3dEXT")); + glBinormal3dvEXT = reinterpret_cast<PFNGLBINORMAL3DVEXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormal3dvEXT")); + glBinormal3fEXT = reinterpret_cast<PFNGLBINORMAL3FEXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormal3fEXT")); + glBinormal3fvEXT = reinterpret_cast<PFNGLBINORMAL3FVEXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormal3fvEXT")); + glBinormal3iEXT = reinterpret_cast<PFNGLBINORMAL3IEXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormal3iEXT")); + glBinormal3ivEXT = reinterpret_cast<PFNGLBINORMAL3IVEXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormal3ivEXT")); + glBinormal3sEXT = reinterpret_cast<PFNGLBINORMAL3SEXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormal3sEXT")); + glBinormal3svEXT = reinterpret_cast<PFNGLBINORMAL3SVEXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormal3svEXT")); + glTangentPointerEXT = reinterpret_cast<PFNGLTANGENTPOINTEREXTPROC>(bglGetProcAddress((const GLubyte *) "glTangentPointerEXT")); + glBinormalPointerEXT = reinterpret_cast<PFNGLBINORMALPOINTEREXTPROC>(bglGetProcAddress((const GLubyte *) "glBinormalPointerEXT")); + if (glTangent3bEXT && glTangent3bvEXT && glTangent3dEXT && glTangent3dvEXT && glTangent3fEXT && glTangent3fvEXT && glTangent3iEXT && glTangent3ivEXT && glTangent3sEXT && glTangent3svEXT && glBinormal3bEXT && glBinormal3bvEXT && glBinormal3dEXT && glBinormal3dvEXT && glBinormal3fEXT && glBinormal3fvEXT && glBinormal3iEXT && glBinormal3ivEXT && glBinormal3sEXT && glBinormal3svEXT && glTangentPointerEXT && glBinormalPointerEXT) { + EnableExtension(_GL_EXT_coordinate_frame); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_coordinate_frame" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_coordinate_frame implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_texture_env_combine")) + { + EnableExtension(_GL_EXT_texture_env_combine); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_env_combine" << std::endl; + } + + if (QueryExtension("GL_APPLE_specular_vector")) + { + EnableExtension(_GL_APPLE_specular_vector); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_specular_vector" << std::endl; + } + + if (QueryExtension("GL_APPLE_transform_hint")) + { + EnableExtension(_GL_APPLE_transform_hint); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_transform_hint" << std::endl; + } + +#if defined(GL_SUNX_constant_data) + if (QueryExtension("GL_SUNX_constant_data")) + { + glFinishTextureSUNX = reinterpret_cast<PFNGLFINISHTEXTURESUNXPROC>(bglGetProcAddress((const GLubyte *) "glFinishTextureSUNX")); + if (glFinishTextureSUNX) { + EnableExtension(_GL_SUNX_constant_data); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUNX_constant_data" << std::endl; + } else { + std::cout << "ERROR: GL_SUNX_constant_data implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SUN_global_alpha) + if (QueryExtension("GL_SUN_global_alpha")) + { + glGlobalAlphaFactorbSUN = reinterpret_cast<PFNGLGLOBALALPHAFACTORBSUNPROC>(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactorbSUN")); + glGlobalAlphaFactorsSUN = reinterpret_cast<PFNGLGLOBALALPHAFACTORSSUNPROC>(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactorsSUN")); + glGlobalAlphaFactoriSUN = reinterpret_cast<PFNGLGLOBALALPHAFACTORISUNPROC>(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactoriSUN")); + glGlobalAlphaFactorfSUN = reinterpret_cast<PFNGLGLOBALALPHAFACTORFSUNPROC>(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactorfSUN")); + glGlobalAlphaFactordSUN = reinterpret_cast<PFNGLGLOBALALPHAFACTORDSUNPROC>(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactordSUN")); + glGlobalAlphaFactorubSUN = reinterpret_cast<PFNGLGLOBALALPHAFACTORUBSUNPROC>(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactorubSUN")); + glGlobalAlphaFactorusSUN = reinterpret_cast<PFNGLGLOBALALPHAFACTORUSSUNPROC>(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactorusSUN")); + glGlobalAlphaFactoruiSUN = reinterpret_cast<PFNGLGLOBALALPHAFACTORUISUNPROC>(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactoruiSUN")); + if (glGlobalAlphaFactorbSUN && glGlobalAlphaFactorsSUN && glGlobalAlphaFactoriSUN && glGlobalAlphaFactorfSUN && glGlobalAlphaFactordSUN && glGlobalAlphaFactorubSUN && glGlobalAlphaFactorusSUN && glGlobalAlphaFactoruiSUN) { + EnableExtension(_GL_SUN_global_alpha); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_global_alpha" << std::endl; + } else { + std::cout << "ERROR: GL_SUN_global_alpha implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SUN_triangle_list) + if (QueryExtension("GL_SUN_triangle_list")) + { + glReplacementCodeuiSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUISUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiSUN")); + glReplacementCodeusSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUSSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeusSUN")); + glReplacementCodeubSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUBSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeubSUN")); + glReplacementCodeuivSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUIVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuivSUN")); + glReplacementCodeusvSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUSVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeusvSUN")); + glReplacementCodeubvSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUBVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeubvSUN")); + glReplacementCodePointerSUN = reinterpret_cast<PFNGLREPLACEMENTCODEPOINTERSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodePointerSUN")); + if (glReplacementCodeuiSUN && glReplacementCodeusSUN && glReplacementCodeubSUN && glReplacementCodeuivSUN && glReplacementCodeusvSUN && glReplacementCodeubvSUN && glReplacementCodePointerSUN) { + EnableExtension(_GL_SUN_triangle_list); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_triangle_list" << std::endl; + } else { + std::cout << "ERROR: GL_SUN_triangle_list implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SUN_vertex) + if (QueryExtension("GL_SUN_vertex")) + { + glColor4ubVertex2fSUN = reinterpret_cast<PFNGLCOLOR4UBVERTEX2FSUNPROC>(bglGetProcAddress((const GLubyte *) "glColor4ubVertex2fSUN")); + glColor4ubVertex2fvSUN = reinterpret_cast<PFNGLCOLOR4UBVERTEX2FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glColor4ubVertex2fvSUN")); + glColor4ubVertex3fSUN = reinterpret_cast<PFNGLCOLOR4UBVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glColor4ubVertex3fSUN")); + glColor4ubVertex3fvSUN = reinterpret_cast<PFNGLCOLOR4UBVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glColor4ubVertex3fvSUN")); + glColor3fVertex3fSUN = reinterpret_cast<PFNGLCOLOR3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glColor3fVertex3fSUN")); + glColor3fVertex3fvSUN = reinterpret_cast<PFNGLCOLOR3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glColor3fVertex3fvSUN")); + glNormal3fVertex3fSUN = reinterpret_cast<PFNGLNORMAL3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glNormal3fVertex3fSUN")); + glNormal3fVertex3fvSUN = reinterpret_cast<PFNGLNORMAL3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glNormal3fVertex3fvSUN")); + glColor4fNormal3fVertex3fSUN = reinterpret_cast<PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glColor4fNormal3fVertex3fSUN")); + glColor4fNormal3fVertex3fvSUN = reinterpret_cast<PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glColor4fNormal3fVertex3fvSUN")); + glTexCoord2fVertex3fSUN = reinterpret_cast<PFNGLTEXCOORD2FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2fVertex3fSUN")); + glTexCoord2fVertex3fvSUN = reinterpret_cast<PFNGLTEXCOORD2FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2fVertex3fvSUN")); + glTexCoord4fVertex4fSUN = reinterpret_cast<PFNGLTEXCOORD4FVERTEX4FSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord4fVertex4fSUN")); + glTexCoord4fVertex4fvSUN = reinterpret_cast<PFNGLTEXCOORD4FVERTEX4FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord4fVertex4fvSUN")); + glTexCoord2fColor4ubVertex3fSUN = reinterpret_cast<PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor4ubVertex3fSUN")); + glTexCoord2fColor4ubVertex3fvSUN = reinterpret_cast<PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor4ubVertex3fvSUN")); + glTexCoord2fColor3fVertex3fSUN = reinterpret_cast<PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor3fVertex3fSUN")); + glTexCoord2fColor3fVertex3fvSUN = reinterpret_cast<PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor3fVertex3fvSUN")); + glTexCoord2fNormal3fVertex3fSUN = reinterpret_cast<PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2fNormal3fVertex3fSUN")); + glTexCoord2fNormal3fVertex3fvSUN = reinterpret_cast<PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2fNormal3fVertex3fvSUN")); + glTexCoord2fColor4fNormal3fVertex3fSUN = reinterpret_cast<PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor4fNormal3fVertex3fSUN")); + glTexCoord2fColor4fNormal3fVertex3fvSUN = reinterpret_cast<PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor4fNormal3fVertex3fvSUN")); + glTexCoord4fColor4fNormal3fVertex4fSUN = reinterpret_cast<PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord4fColor4fNormal3fVertex4fSUN")); + glTexCoord4fColor4fNormal3fVertex4fvSUN = reinterpret_cast<PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord4fColor4fNormal3fVertex4fvSUN")); + glReplacementCodeuiVertex3fSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiVertex3fSUN")); + glReplacementCodeuiVertex3fvSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiVertex3fvSUN")); + glReplacementCodeuiColor4ubVertex3fSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor4ubVertex3fSUN")); + glReplacementCodeuiColor4ubVertex3fvSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor4ubVertex3fvSUN")); + glReplacementCodeuiColor3fVertex3fSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor3fVertex3fSUN")); + glReplacementCodeuiColor3fVertex3fvSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor3fVertex3fvSUN")); + glReplacementCodeuiNormal3fVertex3fSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiNormal3fVertex3fSUN")); + glReplacementCodeuiNormal3fVertex3fvSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiNormal3fVertex3fvSUN")); + glReplacementCodeuiColor4fNormal3fVertex3fSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor4fNormal3fVertex3fSUN")); + glReplacementCodeuiColor4fNormal3fVertex3fvSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor4fNormal3fVertex3fvSUN")); + glReplacementCodeuiTexCoord2fVertex3fSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fVertex3fSUN")); + glReplacementCodeuiTexCoord2fVertex3fvSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fVertex3fvSUN")); + glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")); + glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")); + glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")); + glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = reinterpret_cast<PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC>(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")); + if (glColor4ubVertex2fSUN && glColor4ubVertex2fvSUN && glColor4ubVertex3fSUN && glColor4ubVertex3fvSUN && glColor3fVertex3fSUN && glColor3fVertex3fvSUN && glNormal3fVertex3fSUN && glNormal3fVertex3fvSUN && glColor4fNormal3fVertex3fSUN && glColor4fNormal3fVertex3fvSUN && glTexCoord2fVertex3fSUN && glTexCoord2fVertex3fvSUN && glTexCoord4fVertex4fSUN && glTexCoord4fVertex4fvSUN && glTexCoord2fColor4ubVertex3fSUN && glTexCoord2fColor4ubVertex3fvSUN && glTexCoord2fColor3fVertex3fSUN && glTexCoord2fColor3fVertex3fvSUN && glTexCoord2fNormal3fVertex3fSUN && glTexCoord2fNormal3fVertex3fvSUN && glTexCoord2fColor4fNormal3fVertex3fSUN && glTexCoord2fColor4fNormal3fVertex3fvSUN && glTexCoord4fColor4fNormal3fVertex4fSUN && glTexCoord4fColor4fNormal3fVertex4fvSUN && glReplacementCodeuiVertex3fSUN && glReplacementCodeuiVertex3fvSUN && glReplacementCodeuiColor4ubVertex3fSUN && glReplacementCodeuiColor4ubVertex3fvSUN && glReplacementCodeuiColor3fVertex3fSUN && glReplacementCodeuiColor3fVertex3fvSUN && glReplacementCodeuiNormal3fVertex3fSUN && glReplacementCodeuiNormal3fVertex3fvSUN && glReplacementCodeuiColor4fNormal3fVertex3fSUN && glReplacementCodeuiColor4fNormal3fVertex3fvSUN && glReplacementCodeuiTexCoord2fVertex3fSUN && glReplacementCodeuiTexCoord2fVertex3fvSUN && glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN && glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN && glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN && glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) { + EnableExtension(_GL_SUN_vertex); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_vertex" << std::endl; + } else { + std::cout << "ERROR: GL_SUN_vertex implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_blend_func_separate) + if (QueryExtension("GL_EXT_blend_func_separate")) + { + glBlendFuncSeparateEXT = reinterpret_cast<PFNGLBLENDFUNCSEPARATEEXTPROC>(bglGetProcAddress((const GLubyte *) "glBlendFuncSeparateEXT")); + if (glBlendFuncSeparateEXT) { + EnableExtension(_GL_EXT_blend_func_separate); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_blend_func_separate" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_blend_func_separate implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_INGR_color_clamp")) + { + EnableExtension(_GL_INGR_color_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_INGR_color_clamp" << std::endl; + } + + if (QueryExtension("GL_INGR_interlace_read")) + { + EnableExtension(_GL_INGR_interlace_read); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_INGR_interlace_read" << std::endl; + } + + if (QueryExtension("GL_EXT_stencil_wrap")) + { + EnableExtension(_GL_EXT_stencil_wrap); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_stencil_wrap" << std::endl; + } + + if (QueryExtension("GL_EXT_422_pixels")) + { + EnableExtension(_GL_EXT_422_pixels); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_422_pixels" << std::endl; + } + + if (QueryExtension("GL_NV_texgen_reflection")) + { + EnableExtension(_GL_NV_texgen_reflection); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texgen_reflection" << std::endl; + } + + if (QueryExtension("GL_SUN_convolution_border_modes")) + { + EnableExtension(_GL_SUN_convolution_border_modes); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_convolution_border_modes" << std::endl; + } + + if (QueryExtension("GL_EXT_texture_env_add")) + { + EnableExtension(_GL_EXT_texture_env_add); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_env_add" << std::endl; + } + + if (QueryExtension("GL_EXT_texture_lod_bias")) + { + EnableExtension(_GL_EXT_texture_lod_bias); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_lod_bias" << std::endl; + } + + if (QueryExtension("GL_EXT_texture_filter_anisotropic")) + { + EnableExtension(_GL_EXT_texture_filter_anisotropic); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_filter_anisotropic" << std::endl; + } + +#if defined(GL_EXT_vertex_weighting) + if (QueryExtension("GL_EXT_vertex_weighting")) + { + glVertexWeightfEXT = reinterpret_cast<PFNGLVERTEXWEIGHTFEXTPROC>(bglGetProcAddress((const GLubyte *) "glVertexWeightfEXT")); + glVertexWeightfvEXT = reinterpret_cast<PFNGLVERTEXWEIGHTFVEXTPROC>(bglGetProcAddress((const GLubyte *) "glVertexWeightfvEXT")); + glVertexWeightPointerEXT = reinterpret_cast<PFNGLVERTEXWEIGHTPOINTEREXTPROC>(bglGetProcAddress((const GLubyte *) "glVertexWeightPointerEXT")); + if (glVertexWeightfEXT && glVertexWeightfvEXT && glVertexWeightPointerEXT) { + EnableExtension(_GL_EXT_vertex_weighting); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_vertex_weighting" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_vertex_weighting implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_light_max_exponent")) + { + EnableExtension(_GL_NV_light_max_exponent); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_light_max_exponent" << std::endl; + } + +#if defined(GL_NV_vertex_array_range) + if (QueryExtension("GL_NV_vertex_array_range")) + { + glFlushVertexArrayRangeNV = reinterpret_cast<PFNGLFLUSHVERTEXARRAYRANGENVPROC>(bglGetProcAddress((const GLubyte *) "glFlushVertexArrayRangeNV")); + glVertexArrayRangeNV = reinterpret_cast<PFNGLVERTEXARRAYRANGENVPROC>(bglGetProcAddress((const GLubyte *) "glVertexArrayRangeNV")); + if (glFlushVertexArrayRangeNV && glVertexArrayRangeNV) { + EnableExtension(_GL_NV_vertex_array_range); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_vertex_array_range" << std::endl; + } else { + std::cout << "ERROR: GL_NV_vertex_array_range implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_register_combiners) + if (QueryExtension("GL_NV_register_combiners")) + { + glCombinerParameterfvNV = reinterpret_cast<PFNGLCOMBINERPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glCombinerParameterfvNV")); + glCombinerParameterfNV = reinterpret_cast<PFNGLCOMBINERPARAMETERFNVPROC>(bglGetProcAddress((const GLubyte *) "glCombinerParameterfNV")); + glCombinerParameterivNV = reinterpret_cast<PFNGLCOMBINERPARAMETERIVNVPROC>(bglGetProcAddress((const GLubyte *) "glCombinerParameterivNV")); + glCombinerParameteriNV = reinterpret_cast<PFNGLCOMBINERPARAMETERINVPROC>(bglGetProcAddress((const GLubyte *) "glCombinerParameteriNV")); + glCombinerInputNV = reinterpret_cast<PFNGLCOMBINERINPUTNVPROC>(bglGetProcAddress((const GLubyte *) "glCombinerInputNV")); + glCombinerOutputNV = reinterpret_cast<PFNGLCOMBINEROUTPUTNVPROC>(bglGetProcAddress((const GLubyte *) "glCombinerOutputNV")); + glFinalCombinerInputNV = reinterpret_cast<PFNGLFINALCOMBINERINPUTNVPROC>(bglGetProcAddress((const GLubyte *) "glFinalCombinerInputNV")); + glGetCombinerInputParameterfvNV = reinterpret_cast<PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetCombinerInputParameterfvNV")); + glGetCombinerInputParameterivNV = reinterpret_cast<PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetCombinerInputParameterivNV")); + glGetCombinerOutputParameterfvNV = reinterpret_cast<PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetCombinerOutputParameterfvNV")); + glGetCombinerOutputParameterivNV = reinterpret_cast<PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetCombinerOutputParameterivNV")); + glGetFinalCombinerInputParameterfvNV = reinterpret_cast<PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetFinalCombinerInputParameterfvNV")); + glGetFinalCombinerInputParameterivNV = reinterpret_cast<PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetFinalCombinerInputParameterivNV")); + if (glCombinerParameterfvNV && glCombinerParameterfNV && glCombinerParameterivNV && glCombinerParameteriNV && glCombinerInputNV && glCombinerOutputNV && glFinalCombinerInputNV && glGetCombinerInputParameterfvNV && glGetCombinerInputParameterivNV && glGetCombinerOutputParameterfvNV && glGetCombinerOutputParameterivNV && glGetFinalCombinerInputParameterfvNV && glGetFinalCombinerInputParameterivNV) { + EnableExtension(_GL_NV_register_combiners); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_register_combiners" << std::endl; + } else { + std::cout << "ERROR: GL_NV_register_combiners implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_fog_distance")) + { + EnableExtension(_GL_NV_fog_distance); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_fog_distance" << std::endl; + } + + if (QueryExtension("GL_NV_texgen_emboss")) + { + EnableExtension(_GL_NV_texgen_emboss); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texgen_emboss" << std::endl; + } + + if (QueryExtension("GL_NV_blend_square")) + { + EnableExtension(_GL_NV_blend_square); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_blend_square" << std::endl; + } + + if (QueryExtension("GL_NV_texture_env_combine4")) + { + EnableExtension(_GL_NV_texture_env_combine4); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_env_combine4" << std::endl; + } + +#if defined(GL_MESA_resize_buffers) + if (QueryExtension("GL_MESA_resize_buffers")) + { + glResizeBuffersMESA = reinterpret_cast<PFNGLRESIZEBUFFERSMESAPROC>(bglGetProcAddress((const GLubyte *) "glResizeBuffersMESA")); + if (glResizeBuffersMESA) { + EnableExtension(_GL_MESA_resize_buffers); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_MESA_resize_buffers" << std::endl; + } else { + std::cout << "ERROR: GL_MESA_resize_buffers implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_MESA_window_pos) + if (QueryExtension("GL_MESA_window_pos")) + { + glWindowPos2dMESA = reinterpret_cast<PFNGLWINDOWPOS2DMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2dMESA")); + glWindowPos2dvMESA = reinterpret_cast<PFNGLWINDOWPOS2DVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2dvMESA")); + glWindowPos2fMESA = reinterpret_cast<PFNGLWINDOWPOS2FMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2fMESA")); + glWindowPos2fvMESA = reinterpret_cast<PFNGLWINDOWPOS2FVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2fvMESA")); + glWindowPos2iMESA = reinterpret_cast<PFNGLWINDOWPOS2IMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2iMESA")); + glWindowPos2ivMESA = reinterpret_cast<PFNGLWINDOWPOS2IVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2ivMESA")); + glWindowPos2sMESA = reinterpret_cast<PFNGLWINDOWPOS2SMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2sMESA")); + glWindowPos2svMESA = reinterpret_cast<PFNGLWINDOWPOS2SVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos2svMESA")); + glWindowPos3dMESA = reinterpret_cast<PFNGLWINDOWPOS3DMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3dMESA")); + glWindowPos3dvMESA = reinterpret_cast<PFNGLWINDOWPOS3DVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3dvMESA")); + glWindowPos3fMESA = reinterpret_cast<PFNGLWINDOWPOS3FMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3fMESA")); + glWindowPos3fvMESA = reinterpret_cast<PFNGLWINDOWPOS3FVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3fvMESA")); + glWindowPos3iMESA = reinterpret_cast<PFNGLWINDOWPOS3IMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3iMESA")); + glWindowPos3ivMESA = reinterpret_cast<PFNGLWINDOWPOS3IVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3ivMESA")); + glWindowPos3sMESA = reinterpret_cast<PFNGLWINDOWPOS3SMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3sMESA")); + glWindowPos3svMESA = reinterpret_cast<PFNGLWINDOWPOS3SVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos3svMESA")); + glWindowPos4dMESA = reinterpret_cast<PFNGLWINDOWPOS4DMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos4dMESA")); + glWindowPos4dvMESA = reinterpret_cast<PFNGLWINDOWPOS4DVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos4dvMESA")); + glWindowPos4fMESA = reinterpret_cast<PFNGLWINDOWPOS4FMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos4fMESA")); + glWindowPos4fvMESA = reinterpret_cast<PFNGLWINDOWPOS4FVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos4fvMESA")); + glWindowPos4iMESA = reinterpret_cast<PFNGLWINDOWPOS4IMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos4iMESA")); + glWindowPos4ivMESA = reinterpret_cast<PFNGLWINDOWPOS4IVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos4ivMESA")); + glWindowPos4sMESA = reinterpret_cast<PFNGLWINDOWPOS4SMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos4sMESA")); + glWindowPos4svMESA = reinterpret_cast<PFNGLWINDOWPOS4SVMESAPROC>(bglGetProcAddress((const GLubyte *) "glWindowPos4svMESA")); + if (glWindowPos2dMESA && glWindowPos2dvMESA && glWindowPos2fMESA && glWindowPos2fvMESA && glWindowPos2iMESA && glWindowPos2ivMESA && glWindowPos2sMESA && glWindowPos2svMESA && glWindowPos3dMESA && glWindowPos3dvMESA && glWindowPos3fMESA && glWindowPos3fvMESA && glWindowPos3iMESA && glWindowPos3ivMESA && glWindowPos3sMESA && glWindowPos3svMESA && glWindowPos4dMESA && glWindowPos4dvMESA && glWindowPos4fMESA && glWindowPos4fvMESA && glWindowPos4iMESA && glWindowPos4ivMESA && glWindowPos4sMESA && glWindowPos4svMESA) { + EnableExtension(_GL_MESA_window_pos); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_MESA_window_pos" << std::endl; + } else { + std::cout << "ERROR: GL_MESA_window_pos implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_IBM_cull_vertex")) + { + EnableExtension(_GL_IBM_cull_vertex); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_IBM_cull_vertex" << std::endl; + } + +#if defined(GL_IBM_multimode_draw_arrays) + if (QueryExtension("GL_IBM_multimode_draw_arrays")) + { + glMultiModeDrawArraysIBM = reinterpret_cast<PFNGLMULTIMODEDRAWARRAYSIBMPROC>(bglGetProcAddress((const GLubyte *) "glMultiModeDrawArraysIBM")); + glMultiModeDrawElementsIBM = reinterpret_cast<PFNGLMULTIMODEDRAWELEMENTSIBMPROC>(bglGetProcAddress((const GLubyte *) "glMultiModeDrawElementsIBM")); + if (glMultiModeDrawArraysIBM && glMultiModeDrawElementsIBM) { + EnableExtension(_GL_IBM_multimode_draw_arrays); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_IBM_multimode_draw_arrays" << std::endl; + } else { + std::cout << "ERROR: GL_IBM_multimode_draw_arrays implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_IBM_vertex_array_lists) + if (QueryExtension("GL_IBM_vertex_array_lists")) + { + glColorPointerListIBM = reinterpret_cast<PFNGLCOLORPOINTERLISTIBMPROC>(bglGetProcAddress((const GLubyte *) "glColorPointerListIBM")); + glSecondaryColorPointerListIBM = reinterpret_cast<PFNGLSECONDARYCOLORPOINTERLISTIBMPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColorPointerListIBM")); + glEdgeFlagPointerListIBM = reinterpret_cast<PFNGLEDGEFLAGPOINTERLISTIBMPROC>(bglGetProcAddress((const GLubyte *) "glEdgeFlagPointerListIBM")); + glFogCoordPointerListIBM = reinterpret_cast<PFNGLFOGCOORDPOINTERLISTIBMPROC>(bglGetProcAddress((const GLubyte *) "glFogCoordPointerListIBM")); + glIndexPointerListIBM = reinterpret_cast<PFNGLINDEXPOINTERLISTIBMPROC>(bglGetProcAddress((const GLubyte *) "glIndexPointerListIBM")); + glNormalPointerListIBM = reinterpret_cast<PFNGLNORMALPOINTERLISTIBMPROC>(bglGetProcAddress((const GLubyte *) "glNormalPointerListIBM")); + glTexCoordPointerListIBM = reinterpret_cast<PFNGLTEXCOORDPOINTERLISTIBMPROC>(bglGetProcAddress((const GLubyte *) "glTexCoordPointerListIBM")); + glVertexPointerListIBM = reinterpret_cast<PFNGLVERTEXPOINTERLISTIBMPROC>(bglGetProcAddress((const GLubyte *) "glVertexPointerListIBM")); + if (glColorPointerListIBM && glSecondaryColorPointerListIBM && glEdgeFlagPointerListIBM && glFogCoordPointerListIBM && glIndexPointerListIBM && glNormalPointerListIBM && glTexCoordPointerListIBM && glVertexPointerListIBM) { + EnableExtension(_GL_IBM_vertex_array_lists); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_IBM_vertex_array_lists" << std::endl; + } else { + std::cout << "ERROR: GL_IBM_vertex_array_lists implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_3DFX_texture_compression_FXT1")) + { + EnableExtension(_GL_3DFX_texture_compression_FXT1); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_3DFX_texture_compression_FXT1" << std::endl; + } + + if (QueryExtension("GL_3DFX_multisample")) + { + EnableExtension(_GL_3DFX_multisample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_3DFX_multisample" << std::endl; + } + +#if defined(GL_3DFX_tbuffer) + if (QueryExtension("GL_3DFX_tbuffer")) + { + glTbufferMask3DFX = reinterpret_cast<PFNGLTBUFFERMASK3DFXPROC>(bglGetProcAddress((const GLubyte *) "glTbufferMask3DFX")); + if (glTbufferMask3DFX) { + EnableExtension(_GL_3DFX_tbuffer); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_3DFX_tbuffer" << std::endl; + } else { + std::cout << "ERROR: GL_3DFX_tbuffer implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_vertex_preclip")) + { + EnableExtension(_GL_SGIX_vertex_preclip); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_vertex_preclip" << std::endl; + } + + if (QueryExtension("GL_SGIX_resample")) + { + EnableExtension(_GL_SGIX_resample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_resample" << std::endl; + } + +#if defined(GL_SGIS_texture_color_mask) + if (QueryExtension("GL_SGIS_texture_color_mask")) + { + glTextureColorMaskSGIS = reinterpret_cast<PFNGLTEXTURECOLORMASKSGISPROC>(bglGetProcAddress((const GLubyte *) "glTextureColorMaskSGIS")); + if (glTextureColorMaskSGIS) { + EnableExtension(_GL_SGIS_texture_color_mask); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture_color_mask" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_texture_color_mask implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_texture_env_dot3")) + { + EnableExtension(_GL_EXT_texture_env_dot3); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_env_dot3" << std::endl; + } + + if (QueryExtension("GL_ATI_texture_mirror_once")) + { + EnableExtension(_GL_ATI_texture_mirror_once); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_texture_mirror_once" << std::endl; + } + +#if defined(GL_NV_fence) + if (QueryExtension("GL_NV_fence")) + { + glDeleteFencesNV = reinterpret_cast<PFNGLDELETEFENCESNVPROC>(bglGetProcAddress((const GLubyte *) "glDeleteFencesNV")); + glGenFencesNV = reinterpret_cast<PFNGLGENFENCESNVPROC>(bglGetProcAddress((const GLubyte *) "glGenFencesNV")); + glIsFenceNV = reinterpret_cast<PFNGLISFENCENVPROC>(bglGetProcAddress((const GLubyte *) "glIsFenceNV")); + glTestFenceNV = reinterpret_cast<PFNGLTESTFENCENVPROC>(bglGetProcAddress((const GLubyte *) "glTestFenceNV")); + glGetFenceivNV = reinterpret_cast<PFNGLGETFENCEIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetFenceivNV")); + glFinishFenceNV = reinterpret_cast<PFNGLFINISHFENCENVPROC>(bglGetProcAddress((const GLubyte *) "glFinishFenceNV")); + glSetFenceNV = reinterpret_cast<PFNGLSETFENCENVPROC>(bglGetProcAddress((const GLubyte *) "glSetFenceNV")); + if (glDeleteFencesNV && glGenFencesNV && glIsFenceNV && glTestFenceNV && glGetFenceivNV && glFinishFenceNV && glSetFenceNV) { + EnableExtension(_GL_NV_fence); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_fence" << std::endl; + } else { + std::cout << "ERROR: GL_NV_fence implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_evaluators) + if (QueryExtension("GL_NV_evaluators")) + { + glMapControlPointsNV = reinterpret_cast<PFNGLMAPCONTROLPOINTSNVPROC>(bglGetProcAddress((const GLubyte *) "glMapControlPointsNV")); + glMapParameterivNV = reinterpret_cast<PFNGLMAPPARAMETERIVNVPROC>(bglGetProcAddress((const GLubyte *) "glMapParameterivNV")); + glMapParameterfvNV = reinterpret_cast<PFNGLMAPPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glMapParameterfvNV")); + glGetMapControlPointsNV = reinterpret_cast<PFNGLGETMAPCONTROLPOINTSNVPROC>(bglGetProcAddress((const GLubyte *) "glGetMapControlPointsNV")); + glGetMapParameterivNV = reinterpret_cast<PFNGLGETMAPPARAMETERIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetMapParameterivNV")); + glGetMapParameterfvNV = reinterpret_cast<PFNGLGETMAPPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetMapParameterfvNV")); + glGetMapAttribParameterivNV = reinterpret_cast<PFNGLGETMAPATTRIBPARAMETERIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetMapAttribParameterivNV")); + glGetMapAttribParameterfvNV = reinterpret_cast<PFNGLGETMAPATTRIBPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetMapAttribParameterfvNV")); + glEvalMapsNV = reinterpret_cast<PFNGLEVALMAPSNVPROC>(bglGetProcAddress((const GLubyte *) "glEvalMapsNV")); + if (glMapControlPointsNV && glMapParameterivNV && glMapParameterfvNV && glGetMapControlPointsNV && glGetMapParameterivNV && glGetMapParameterfvNV && glGetMapAttribParameterivNV && glGetMapAttribParameterfvNV && glEvalMapsNV) { + EnableExtension(_GL_NV_evaluators); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_evaluators" << std::endl; + } else { + std::cout << "ERROR: GL_NV_evaluators implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_packed_depth_stencil")) + { + EnableExtension(_GL_NV_packed_depth_stencil); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_packed_depth_stencil" << std::endl; + } + +#if defined(GL_NV_register_combiners2) + if (QueryExtension("GL_NV_register_combiners2")) + { + glCombinerStageParameterfvNV = reinterpret_cast<PFNGLCOMBINERSTAGEPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glCombinerStageParameterfvNV")); + glGetCombinerStageParameterfvNV = reinterpret_cast<PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetCombinerStageParameterfvNV")); + if (glCombinerStageParameterfvNV && glGetCombinerStageParameterfvNV) { + EnableExtension(_GL_NV_register_combiners2); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_register_combiners2" << std::endl; + } else { + std::cout << "ERROR: GL_NV_register_combiners2 implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_texture_compression_vtc")) + { + EnableExtension(_GL_NV_texture_compression_vtc); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_compression_vtc" << std::endl; + } + + if (QueryExtension("GL_NV_texture_rectangle")) + { + EnableExtension(_GL_NV_texture_rectangle); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_rectangle" << std::endl; + } + + if (QueryExtension("GL_NV_texture_shader")) + { + EnableExtension(_GL_NV_texture_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_shader" << std::endl; + } + + if (QueryExtension("GL_NV_texture_shader2")) + { + EnableExtension(_GL_NV_texture_shader2); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_shader2" << std::endl; + } + + if (QueryExtension("GL_NV_vertex_array_range2")) + { + EnableExtension(_GL_NV_vertex_array_range2); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_vertex_array_range2" << std::endl; + } + +#if defined(GL_NV_vertex_program) + if (QueryExtension("GL_NV_vertex_program")) + { + glAreProgramsResidentNV = reinterpret_cast<PFNGLAREPROGRAMSRESIDENTNVPROC>(bglGetProcAddress((const GLubyte *) "glAreProgramsResidentNV")); + glBindProgramNV = reinterpret_cast<PFNGLBINDPROGRAMNVPROC>(bglGetProcAddress((const GLubyte *) "glBindProgramNV")); + glDeleteProgramsNV = reinterpret_cast<PFNGLDELETEPROGRAMSNVPROC>(bglGetProcAddress((const GLubyte *) "glDeleteProgramsNV")); + glExecuteProgramNV = reinterpret_cast<PFNGLEXECUTEPROGRAMNVPROC>(bglGetProcAddress((const GLubyte *) "glExecuteProgramNV")); + glGenProgramsNV = reinterpret_cast<PFNGLGENPROGRAMSNVPROC>(bglGetProcAddress((const GLubyte *) "glGenProgramsNV")); + glGetProgramParameterdvNV = reinterpret_cast<PFNGLGETPROGRAMPARAMETERDVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramParameterdvNV")); + glGetProgramParameterfvNV = reinterpret_cast<PFNGLGETPROGRAMPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramParameterfvNV")); + glGetProgramivNV = reinterpret_cast<PFNGLGETPROGRAMIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramivNV")); + glGetProgramStringNV = reinterpret_cast<PFNGLGETPROGRAMSTRINGNVPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramStringNV")); + glGetTrackMatrixivNV = reinterpret_cast<PFNGLGETTRACKMATRIXIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetTrackMatrixivNV")); + glGetVertexAttribdvNV = reinterpret_cast<PFNGLGETVERTEXATTRIBDVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribdvNV")); + glGetVertexAttribfvNV = reinterpret_cast<PFNGLGETVERTEXATTRIBFVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribfvNV")); + glGetVertexAttribivNV = reinterpret_cast<PFNGLGETVERTEXATTRIBIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribivNV")); + glGetVertexAttribPointervNV = reinterpret_cast<PFNGLGETVERTEXATTRIBPOINTERVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribPointervNV")); + glIsProgramNV = reinterpret_cast<PFNGLISPROGRAMNVPROC>(bglGetProcAddress((const GLubyte *) "glIsProgramNV")); + glLoadProgramNV = reinterpret_cast<PFNGLLOADPROGRAMNVPROC>(bglGetProcAddress((const GLubyte *) "glLoadProgramNV")); + glProgramParameter4dNV = reinterpret_cast<PFNGLPROGRAMPARAMETER4DNVPROC>(bglGetProcAddress((const GLubyte *) "glProgramParameter4dNV")); + glProgramParameter4dvNV = reinterpret_cast<PFNGLPROGRAMPARAMETER4DVNVPROC>(bglGetProcAddress((const GLubyte *) "glProgramParameter4dvNV")); + glProgramParameter4fNV = reinterpret_cast<PFNGLPROGRAMPARAMETER4FNVPROC>(bglGetProcAddress((const GLubyte *) "glProgramParameter4fNV")); + glProgramParameter4fvNV = reinterpret_cast<PFNGLPROGRAMPARAMETER4FVNVPROC>(bglGetProcAddress((const GLubyte *) "glProgramParameter4fvNV")); + glProgramParameters4dvNV = reinterpret_cast<PFNGLPROGRAMPARAMETERS4DVNVPROC>(bglGetProcAddress((const GLubyte *) "glProgramParameters4dvNV")); + glProgramParameters4fvNV = reinterpret_cast<PFNGLPROGRAMPARAMETERS4FVNVPROC>(bglGetProcAddress((const GLubyte *) "glProgramParameters4fvNV")); + glRequestResidentProgramsNV = reinterpret_cast<PFNGLREQUESTRESIDENTPROGRAMSNVPROC>(bglGetProcAddress((const GLubyte *) "glRequestResidentProgramsNV")); + glTrackMatrixNV = reinterpret_cast<PFNGLTRACKMATRIXNVPROC>(bglGetProcAddress((const GLubyte *) "glTrackMatrixNV")); + glVertexAttribPointerNV = reinterpret_cast<PFNGLVERTEXATTRIBPOINTERNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribPointerNV")); + glVertexAttrib1dNV = reinterpret_cast<PFNGLVERTEXATTRIB1DNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1dNV")); + glVertexAttrib1dvNV = reinterpret_cast<PFNGLVERTEXATTRIB1DVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1dvNV")); + glVertexAttrib1fNV = reinterpret_cast<PFNGLVERTEXATTRIB1FNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1fNV")); + glVertexAttrib1fvNV = reinterpret_cast<PFNGLVERTEXATTRIB1FVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1fvNV")); + glVertexAttrib1sNV = reinterpret_cast<PFNGLVERTEXATTRIB1SNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1sNV")); + glVertexAttrib1svNV = reinterpret_cast<PFNGLVERTEXATTRIB1SVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1svNV")); + glVertexAttrib2dNV = reinterpret_cast<PFNGLVERTEXATTRIB2DNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2dNV")); + glVertexAttrib2dvNV = reinterpret_cast<PFNGLVERTEXATTRIB2DVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2dvNV")); + glVertexAttrib2fNV = reinterpret_cast<PFNGLVERTEXATTRIB2FNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2fNV")); + glVertexAttrib2fvNV = reinterpret_cast<PFNGLVERTEXATTRIB2FVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2fvNV")); + glVertexAttrib2sNV = reinterpret_cast<PFNGLVERTEXATTRIB2SNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2sNV")); + glVertexAttrib2svNV = reinterpret_cast<PFNGLVERTEXATTRIB2SVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2svNV")); + glVertexAttrib3dNV = reinterpret_cast<PFNGLVERTEXATTRIB3DNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3dNV")); + glVertexAttrib3dvNV = reinterpret_cast<PFNGLVERTEXATTRIB3DVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3dvNV")); + glVertexAttrib3fNV = reinterpret_cast<PFNGLVERTEXATTRIB3FNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3fNV")); + glVertexAttrib3fvNV = reinterpret_cast<PFNGLVERTEXATTRIB3FVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3fvNV")); + glVertexAttrib3sNV = reinterpret_cast<PFNGLVERTEXATTRIB3SNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3sNV")); + glVertexAttrib3svNV = reinterpret_cast<PFNGLVERTEXATTRIB3SVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3svNV")); + glVertexAttrib4dNV = reinterpret_cast<PFNGLVERTEXATTRIB4DNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4dNV")); + glVertexAttrib4dvNV = reinterpret_cast<PFNGLVERTEXATTRIB4DVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4dvNV")); + glVertexAttrib4fNV = reinterpret_cast<PFNGLVERTEXATTRIB4FNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4fNV")); + glVertexAttrib4fvNV = reinterpret_cast<PFNGLVERTEXATTRIB4FVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4fvNV")); + glVertexAttrib4sNV = reinterpret_cast<PFNGLVERTEXATTRIB4SNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4sNV")); + glVertexAttrib4svNV = reinterpret_cast<PFNGLVERTEXATTRIB4SVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4svNV")); + glVertexAttrib4ubNV = reinterpret_cast<PFNGLVERTEXATTRIB4UBNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4ubNV")); + glVertexAttrib4ubvNV = reinterpret_cast<PFNGLVERTEXATTRIB4UBVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4ubvNV")); + glVertexAttribs1dvNV = reinterpret_cast<PFNGLVERTEXATTRIBS1DVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs1dvNV")); + glVertexAttribs1fvNV = reinterpret_cast<PFNGLVERTEXATTRIBS1FVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs1fvNV")); + glVertexAttribs1svNV = reinterpret_cast<PFNGLVERTEXATTRIBS1SVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs1svNV")); + glVertexAttribs2dvNV = reinterpret_cast<PFNGLVERTEXATTRIBS2DVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs2dvNV")); + glVertexAttribs2fvNV = reinterpret_cast<PFNGLVERTEXATTRIBS2FVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs2fvNV")); + glVertexAttribs2svNV = reinterpret_cast<PFNGLVERTEXATTRIBS2SVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs2svNV")); + glVertexAttribs3dvNV = reinterpret_cast<PFNGLVERTEXATTRIBS3DVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs3dvNV")); + glVertexAttribs3fvNV = reinterpret_cast<PFNGLVERTEXATTRIBS3FVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs3fvNV")); + glVertexAttribs3svNV = reinterpret_cast<PFNGLVERTEXATTRIBS3SVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs3svNV")); + glVertexAttribs4dvNV = reinterpret_cast<PFNGLVERTEXATTRIBS4DVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs4dvNV")); + glVertexAttribs4fvNV = reinterpret_cast<PFNGLVERTEXATTRIBS4FVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs4fvNV")); + glVertexAttribs4svNV = reinterpret_cast<PFNGLVERTEXATTRIBS4SVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs4svNV")); + glVertexAttribs4ubvNV = reinterpret_cast<PFNGLVERTEXATTRIBS4UBVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs4ubvNV")); + if (glAreProgramsResidentNV && glBindProgramNV && glDeleteProgramsNV && glExecuteProgramNV && glGenProgramsNV && glGetProgramParameterdvNV && glGetProgramParameterfvNV && glGetProgramivNV && glGetProgramStringNV && glGetTrackMatrixivNV && glGetVertexAttribdvNV && glGetVertexAttribfvNV && glGetVertexAttribivNV && glGetVertexAttribPointervNV && glIsProgramNV && glLoadProgramNV && glProgramParameter4dNV && glProgramParameter4dvNV && glProgramParameter4fNV && glProgramParameter4fvNV && glProgramParameters4dvNV && glProgramParameters4fvNV && glRequestResidentProgramsNV && glTrackMatrixNV && glVertexAttribPointerNV && glVertexAttrib1dNV && glVertexAttrib1dvNV && glVertexAttrib1fNV && glVertexAttrib1fvNV && glVertexAttrib1sNV && glVertexAttrib1svNV && glVertexAttrib2dNV && glVertexAttrib2dvNV && glVertexAttrib2fNV && glVertexAttrib2fvNV && glVertexAttrib2sNV && glVertexAttrib2svNV && glVertexAttrib3dNV && glVertexAttrib3dvNV && glVertexAttrib3fNV && glVertexAttrib3fvNV && glVertexAttrib3sNV && glVertexAttrib3svNV && glVertexAttrib4dNV && glVertexAttrib4dvNV && glVertexAttrib4fNV && glVertexAttrib4fvNV && glVertexAttrib4sNV && glVertexAttrib4svNV && glVertexAttrib4ubNV && glVertexAttrib4ubvNV && glVertexAttribs1dvNV && glVertexAttribs1fvNV && glVertexAttribs1svNV && glVertexAttribs2dvNV && glVertexAttribs2fvNV && glVertexAttribs2svNV && glVertexAttribs3dvNV && glVertexAttribs3fvNV && glVertexAttribs3svNV && glVertexAttribs4dvNV && glVertexAttribs4fvNV && glVertexAttribs4svNV && glVertexAttribs4ubvNV) { + EnableExtension(_GL_NV_vertex_program); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_vertex_program" << std::endl; + } else { + std::cout << "ERROR: GL_NV_vertex_program implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_texture_coordinate_clamp")) + { + EnableExtension(_GL_SGIX_texture_coordinate_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_texture_coordinate_clamp" << std::endl; + } + + if (QueryExtension("GL_OML_interlace")) + { + EnableExtension(_GL_OML_interlace); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_OML_interlace" << std::endl; + } + + if (QueryExtension("GL_OML_subsample")) + { + EnableExtension(_GL_OML_subsample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_OML_subsample" << std::endl; + } + + if (QueryExtension("GL_OML_resample")) + { + EnableExtension(_GL_OML_resample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_OML_resample" << std::endl; + } + + if (QueryExtension("GL_NV_copy_depth_to_color")) + { + EnableExtension(_GL_NV_copy_depth_to_color); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_copy_depth_to_color" << std::endl; + } + +#if defined(GL_ATI_envmap_bumpmap) + if (QueryExtension("GL_ATI_envmap_bumpmap")) + { + glTexBumpParameterivATI = reinterpret_cast<PFNGLTEXBUMPPARAMETERIVATIPROC>(bglGetProcAddress((const GLubyte *) "glTexBumpParameterivATI")); + glTexBumpParameterfvATI = reinterpret_cast<PFNGLTEXBUMPPARAMETERFVATIPROC>(bglGetProcAddress((const GLubyte *) "glTexBumpParameterfvATI")); + glGetTexBumpParameterivATI = reinterpret_cast<PFNGLGETTEXBUMPPARAMETERIVATIPROC>(bglGetProcAddress((const GLubyte *) "glGetTexBumpParameterivATI")); + glGetTexBumpParameterfvATI = reinterpret_cast<PFNGLGETTEXBUMPPARAMETERFVATIPROC>(bglGetProcAddress((const GLubyte *) "glGetTexBumpParameterfvATI")); + if (glTexBumpParameterivATI && glTexBumpParameterfvATI && glGetTexBumpParameterivATI && glGetTexBumpParameterfvATI) { + EnableExtension(_GL_ATI_envmap_bumpmap); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_envmap_bumpmap" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_envmap_bumpmap implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ATI_fragment_shader) + if (QueryExtension("GL_ATI_fragment_shader")) + { + glGenFragmentShadersATI = reinterpret_cast<PFNGLGENFRAGMENTSHADERSATIPROC>(bglGetProcAddress((const GLubyte *) "glGenFragmentShadersATI")); + glBindFragmentShaderATI = reinterpret_cast<PFNGLBINDFRAGMENTSHADERATIPROC>(bglGetProcAddress((const GLubyte *) "glBindFragmentShaderATI")); + glDeleteFragmentShaderATI = reinterpret_cast<PFNGLDELETEFRAGMENTSHADERATIPROC>(bglGetProcAddress((const GLubyte *) "glDeleteFragmentShaderATI")); + glBeginFragmentShaderATI = reinterpret_cast<PFNGLBEGINFRAGMENTSHADERATIPROC>(bglGetProcAddress((const GLubyte *) "glBeginFragmentShaderATI")); + glEndFragmentShaderATI = reinterpret_cast<PFNGLENDFRAGMENTSHADERATIPROC>(bglGetProcAddress((const GLubyte *) "glEndFragmentShaderATI")); + glPassTexCoordATI = reinterpret_cast<PFNGLPASSTEXCOORDATIPROC>(bglGetProcAddress((const GLubyte *) "glPassTexCoordATI")); + glSampleMapATI = reinterpret_cast<PFNGLSAMPLEMAPATIPROC>(bglGetProcAddress((const GLubyte *) "glSampleMapATI")); + glColorFragmentOp1ATI = reinterpret_cast<PFNGLCOLORFRAGMENTOP1ATIPROC>(bglGetProcAddress((const GLubyte *) "glColorFragmentOp1ATI")); + glColorFragmentOp2ATI = reinterpret_cast<PFNGLCOLORFRAGMENTOP2ATIPROC>(bglGetProcAddress((const GLubyte *) "glColorFragmentOp2ATI")); + glColorFragmentOp3ATI = reinterpret_cast<PFNGLCOLORFRAGMENTOP3ATIPROC>(bglGetProcAddress((const GLubyte *) "glColorFragmentOp3ATI")); + glAlphaFragmentOp1ATI = reinterpret_cast<PFNGLALPHAFRAGMENTOP1ATIPROC>(bglGetProcAddress((const GLubyte *) "glAlphaFragmentOp1ATI")); + glAlphaFragmentOp2ATI = reinterpret_cast<PFNGLALPHAFRAGMENTOP2ATIPROC>(bglGetProcAddress((const GLubyte *) "glAlphaFragmentOp2ATI")); + glAlphaFragmentOp3ATI = reinterpret_cast<PFNGLALPHAFRAGMENTOP3ATIPROC>(bglGetProcAddress((const GLubyte *) "glAlphaFragmentOp3ATI")); + glSetFragmentShaderConstantATI = reinterpret_cast<PFNGLSETFRAGMENTSHADERCONSTANTATIPROC>(bglGetProcAddress((const GLubyte *) "glSetFragmentShaderConstantATI")); + if (glGenFragmentShadersATI && glBindFragmentShaderATI && glDeleteFragmentShaderATI && glBeginFragmentShaderATI && glEndFragmentShaderATI && glPassTexCoordATI && glSampleMapATI && glColorFragmentOp1ATI && glColorFragmentOp2ATI && glColorFragmentOp3ATI && glAlphaFragmentOp1ATI && glAlphaFragmentOp2ATI && glAlphaFragmentOp3ATI && glSetFragmentShaderConstantATI) { + EnableExtension(_GL_ATI_fragment_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_fragment_shader" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_fragment_shader implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ATI_pn_triangles")) + { + EnableExtension(_GL_ATI_pn_triangles); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_pn_triangles" << std::endl; + } + +#if defined(GL_ATI_vertex_array_object) && 0 + if (QueryExtension("GL_ATI_vertex_array_object")) + { + glNewObjectBufferATI = reinterpret_cast<PFNGLNEWOBJECTBUFFERATIPROC>(bglGetProcAddress((const GLubyte *) "glNewObjectBufferATI")); + glIsObjectBufferATI = reinterpret_cast<PFNGLISOBJECTBUFFERATIPROC>(bglGetProcAddress((const GLubyte *) "glIsObjectBufferATI")); + glUpdateObjectBufferATI = reinterpret_cast<PFNGLUPDATEOBJECTBUFFERATIPROC>(bglGetProcAddress((const GLubyte *) "glUpdateObjectBufferATI")); + glGetObjectBufferfvATI = reinterpret_cast<PFNGLGETOBJECTBUFFERFVATIPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectBufferfvATI")); + glGetObjectBufferivATI = reinterpret_cast<PFNGLGETOBJECTBUFFERIVATIPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectBufferivATI")); + glFreeObjectBufferATI = reinterpret_cast<PFNGLFREEOBJECTBUFFERATIPROC>(bglGetProcAddress((const GLubyte *) "glFreeObjectBufferATI")); + glArrayObjectATI = reinterpret_cast<PFNGLARRAYOBJECTATIPROC>(bglGetProcAddress((const GLubyte *) "glArrayObjectATI")); + glGetArrayObjectfvATI = reinterpret_cast<PFNGLGETARRAYOBJECTFVATIPROC>(bglGetProcAddress((const GLubyte *) "glGetArrayObjectfvATI")); + glGetArrayObjectivATI = reinterpret_cast<PFNGLGETARRAYOBJECTIVATIPROC>(bglGetProcAddress((const GLubyte *) "glGetArrayObjectivATI")); + glVariantArrayObjectATI = reinterpret_cast<PFNGLVARIANTARRAYOBJECTATIPROC>(bglGetProcAddress((const GLubyte *) "glVariantArrayObjectATI")); + glGetVariantArrayObjectfvATI = reinterpret_cast<PFNGLGETVARIANTARRAYOBJECTFVATIPROC>(bglGetProcAddress((const GLubyte *) "glGetVariantArrayObjectfvATI")); + glGetVariantArrayObjectivATI = reinterpret_cast<PFNGLGETVARIANTARRAYOBJECTIVATIPROC>(bglGetProcAddress((const GLubyte *) "glGetVariantArrayObjectivATI")); + if (glNewObjectBufferATI && glIsObjectBufferATI && glUpdateObjectBufferATI && glGetObjectBufferfvATI && glGetObjectBufferivATI && glFreeObjectBufferATI && glArrayObjectATI && glGetArrayObjectfvATI && glGetArrayObjectivATI && glVariantArrayObjectATI && glGetVariantArrayObjectfvATI && glGetVariantArrayObjectivATI) { + EnableExtension(_GL_ATI_vertex_array_object); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_vertex_array_object" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_vertex_array_object implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_vertex_shader) + if (QueryExtension("GL_EXT_vertex_shader")) + { + glBeginVertexShaderEXT = reinterpret_cast<PFNGLBEGINVERTEXSHADEREXTPROC>(bglGetProcAddress((const GLubyte *) "glBeginVertexShaderEXT")); + glEndVertexShaderEXT = reinterpret_cast<PFNGLENDVERTEXSHADEREXTPROC>(bglGetProcAddress((const GLubyte *) "glEndVertexShaderEXT")); + glBindVertexShaderEXT = reinterpret_cast<PFNGLBINDVERTEXSHADEREXTPROC>(bglGetProcAddress((const GLubyte *) "glBindVertexShaderEXT")); + glGenVertexShadersEXT = reinterpret_cast<PFNGLGENVERTEXSHADERSEXTPROC>(bglGetProcAddress((const GLubyte *) "glGenVertexShadersEXT")); + glDeleteVertexShaderEXT = reinterpret_cast<PFNGLDELETEVERTEXSHADEREXTPROC>(bglGetProcAddress((const GLubyte *) "glDeleteVertexShaderEXT")); + glShaderOp1EXT = reinterpret_cast<PFNGLSHADEROP1EXTPROC>(bglGetProcAddress((const GLubyte *) "glShaderOp1EXT")); + glShaderOp2EXT = reinterpret_cast<PFNGLSHADEROP2EXTPROC>(bglGetProcAddress((const GLubyte *) "glShaderOp2EXT")); + glShaderOp3EXT = reinterpret_cast<PFNGLSHADEROP3EXTPROC>(bglGetProcAddress((const GLubyte *) "glShaderOp3EXT")); + glSwizzleEXT = reinterpret_cast<PFNGLSWIZZLEEXTPROC>(bglGetProcAddress((const GLubyte *) "glSwizzleEXT")); + glWriteMaskEXT = reinterpret_cast<PFNGLWRITEMASKEXTPROC>(bglGetProcAddress((const GLubyte *) "glWriteMaskEXT")); + glInsertComponentEXT = reinterpret_cast<PFNGLINSERTCOMPONENTEXTPROC>(bglGetProcAddress((const GLubyte *) "glInsertComponentEXT")); + glExtractComponentEXT = reinterpret_cast<PFNGLEXTRACTCOMPONENTEXTPROC>(bglGetProcAddress((const GLubyte *) "glExtractComponentEXT")); + glGenSymbolsEXT = reinterpret_cast<PFNGLGENSYMBOLSEXTPROC>(bglGetProcAddress((const GLubyte *) "glGenSymbolsEXT")); + glSetInvariantEXT = reinterpret_cast<PFNGLSETINVARIANTEXTPROC>(bglGetProcAddress((const GLubyte *) "glSetInvariantEXT")); + glSetLocalConstantEXT = reinterpret_cast<PFNGLSETLOCALCONSTANTEXTPROC>(bglGetProcAddress((const GLubyte *) "glSetLocalConstantEXT")); + glVariantbvEXT = reinterpret_cast<PFNGLVARIANTBVEXTPROC>(bglGetProcAddress((const GLubyte *) "glVariantbvEXT")); + glVariantsvEXT = reinterpret_cast<PFNGLVARIANTSVEXTPROC>(bglGetProcAddress((const GLubyte *) "glVariantsvEXT")); + glVariantivEXT = reinterpret_cast<PFNGLVARIANTIVEXTPROC>(bglGetProcAddress((const GLubyte *) "glVariantivEXT")); + glVariantfvEXT = reinterpret_cast<PFNGLVARIANTFVEXTPROC>(bglGetProcAddress((const GLubyte *) "glVariantfvEXT")); + glVariantdvEXT = reinterpret_cast<PFNGLVARIANTDVEXTPROC>(bglGetProcAddress((const GLubyte *) "glVariantdvEXT")); + glVariantubvEXT = reinterpret_cast<PFNGLVARIANTUBVEXTPROC>(bglGetProcAddress((const GLubyte *) "glVariantubvEXT")); + glVariantusvEXT = reinterpret_cast<PFNGLVARIANTUSVEXTPROC>(bglGetProcAddress((const GLubyte *) "glVariantusvEXT")); + glVariantuivEXT = reinterpret_cast<PFNGLVARIANTUIVEXTPROC>(bglGetProcAddress((const GLubyte *) "glVariantuivEXT")); + glVariantPointerEXT = reinterpret_cast<PFNGLVARIANTPOINTEREXTPROC>(bglGetProcAddress((const GLubyte *) "glVariantPointerEXT")); + glEnableVariantClientStateEXT = reinterpret_cast<PFNGLENABLEVARIANTCLIENTSTATEEXTPROC>(bglGetProcAddress((const GLubyte *) "glEnableVariantClientStateEXT")); + glDisableVariantClientStateEXT = reinterpret_cast<PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC>(bglGetProcAddress((const GLubyte *) "glDisableVariantClientStateEXT")); + glBindLightParameterEXT = reinterpret_cast<PFNGLBINDLIGHTPARAMETEREXTPROC>(bglGetProcAddress((const GLubyte *) "glBindLightParameterEXT")); + glBindMaterialParameterEXT = reinterpret_cast<PFNGLBINDMATERIALPARAMETEREXTPROC>(bglGetProcAddress((const GLubyte *) "glBindMaterialParameterEXT")); + glBindTexGenParameterEXT = reinterpret_cast<PFNGLBINDTEXGENPARAMETEREXTPROC>(bglGetProcAddress((const GLubyte *) "glBindTexGenParameterEXT")); + glBindTextureUnitParameterEXT = reinterpret_cast<PFNGLBINDTEXTUREUNITPARAMETEREXTPROC>(bglGetProcAddress((const GLubyte *) "glBindTextureUnitParameterEXT")); + glBindParameterEXT = reinterpret_cast<PFNGLBINDPARAMETEREXTPROC>(bglGetProcAddress((const GLubyte *) "glBindParameterEXT")); + glIsVariantEnabledEXT = reinterpret_cast<PFNGLISVARIANTENABLEDEXTPROC>(bglGetProcAddress((const GLubyte *) "glIsVariantEnabledEXT")); + glGetVariantBooleanvEXT = reinterpret_cast<PFNGLGETVARIANTBOOLEANVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetVariantBooleanvEXT")); + glGetVariantIntegervEXT = reinterpret_cast<PFNGLGETVARIANTINTEGERVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetVariantIntegervEXT")); + glGetVariantFloatvEXT = reinterpret_cast<PFNGLGETVARIANTFLOATVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetVariantFloatvEXT")); + glGetVariantPointervEXT = reinterpret_cast<PFNGLGETVARIANTPOINTERVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetVariantPointervEXT")); + glGetInvariantBooleanvEXT = reinterpret_cast<PFNGLGETINVARIANTBOOLEANVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetInvariantBooleanvEXT")); + glGetInvariantIntegervEXT = reinterpret_cast<PFNGLGETINVARIANTINTEGERVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetInvariantIntegervEXT")); + glGetInvariantFloatvEXT = reinterpret_cast<PFNGLGETINVARIANTFLOATVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetInvariantFloatvEXT")); + glGetLocalConstantBooleanvEXT = reinterpret_cast<PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetLocalConstantBooleanvEXT")); + glGetLocalConstantIntegervEXT = reinterpret_cast<PFNGLGETLOCALCONSTANTINTEGERVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetLocalConstantIntegervEXT")); + glGetLocalConstantFloatvEXT = reinterpret_cast<PFNGLGETLOCALCONSTANTFLOATVEXTPROC>(bglGetProcAddress((const GLubyte *) "glGetLocalConstantFloatvEXT")); + if (glBeginVertexShaderEXT && glEndVertexShaderEXT && glBindVertexShaderEXT && glGenVertexShadersEXT && glDeleteVertexShaderEXT && glShaderOp1EXT && glShaderOp2EXT && glShaderOp3EXT && glSwizzleEXT && glWriteMaskEXT && glInsertComponentEXT && glExtractComponentEXT && glGenSymbolsEXT && glSetInvariantEXT && glSetLocalConstantEXT && glVariantbvEXT && glVariantsvEXT && glVariantivEXT && glVariantfvEXT && glVariantdvEXT && glVariantubvEXT && glVariantusvEXT && glVariantuivEXT && glVariantPointerEXT && glEnableVariantClientStateEXT && glDisableVariantClientStateEXT && glBindLightParameterEXT && glBindMaterialParameterEXT && glBindTexGenParameterEXT && glBindTextureUnitParameterEXT && glBindParameterEXT && glIsVariantEnabledEXT && glGetVariantBooleanvEXT && glGetVariantIntegervEXT && glGetVariantFloatvEXT && glGetVariantPointervEXT && glGetInvariantBooleanvEXT && glGetInvariantIntegervEXT && glGetInvariantFloatvEXT && glGetLocalConstantBooleanvEXT && glGetLocalConstantIntegervEXT && glGetLocalConstantFloatvEXT) { + EnableExtension(_GL_EXT_vertex_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_vertex_shader" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_vertex_shader implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ATI_vertex_streams) + if (QueryExtension("GL_ATI_vertex_streams")) + { + glVertexStream1sATI = reinterpret_cast<PFNGLVERTEXSTREAM1SATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream1sATI")); + glVertexStream1svATI = reinterpret_cast<PFNGLVERTEXSTREAM1SVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream1svATI")); + glVertexStream1iATI = reinterpret_cast<PFNGLVERTEXSTREAM1IATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream1iATI")); + glVertexStream1ivATI = reinterpret_cast<PFNGLVERTEXSTREAM1IVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream1ivATI")); + glVertexStream1fATI = reinterpret_cast<PFNGLVERTEXSTREAM1FATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream1fATI")); + glVertexStream1fvATI = reinterpret_cast<PFNGLVERTEXSTREAM1FVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream1fvATI")); + glVertexStream1dATI = reinterpret_cast<PFNGLVERTEXSTREAM1DATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream1dATI")); + glVertexStream1dvATI = reinterpret_cast<PFNGLVERTEXSTREAM1DVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream1dvATI")); + glVertexStream2sATI = reinterpret_cast<PFNGLVERTEXSTREAM2SATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream2sATI")); + glVertexStream2svATI = reinterpret_cast<PFNGLVERTEXSTREAM2SVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream2svATI")); + glVertexStream2iATI = reinterpret_cast<PFNGLVERTEXSTREAM2IATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream2iATI")); + glVertexStream2ivATI = reinterpret_cast<PFNGLVERTEXSTREAM2IVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream2ivATI")); + glVertexStream2fATI = reinterpret_cast<PFNGLVERTEXSTREAM2FATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream2fATI")); + glVertexStream2fvATI = reinterpret_cast<PFNGLVERTEXSTREAM2FVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream2fvATI")); + glVertexStream2dATI = reinterpret_cast<PFNGLVERTEXSTREAM2DATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream2dATI")); + glVertexStream2dvATI = reinterpret_cast<PFNGLVERTEXSTREAM2DVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream2dvATI")); + glVertexStream3sATI = reinterpret_cast<PFNGLVERTEXSTREAM3SATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream3sATI")); + glVertexStream3svATI = reinterpret_cast<PFNGLVERTEXSTREAM3SVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream3svATI")); + glVertexStream3iATI = reinterpret_cast<PFNGLVERTEXSTREAM3IATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream3iATI")); + glVertexStream3ivATI = reinterpret_cast<PFNGLVERTEXSTREAM3IVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream3ivATI")); + glVertexStream3fATI = reinterpret_cast<PFNGLVERTEXSTREAM3FATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream3fATI")); + glVertexStream3fvATI = reinterpret_cast<PFNGLVERTEXSTREAM3FVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream3fvATI")); + glVertexStream3dATI = reinterpret_cast<PFNGLVERTEXSTREAM3DATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream3dATI")); + glVertexStream3dvATI = reinterpret_cast<PFNGLVERTEXSTREAM3DVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream3dvATI")); + glVertexStream4sATI = reinterpret_cast<PFNGLVERTEXSTREAM4SATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream4sATI")); + glVertexStream4svATI = reinterpret_cast<PFNGLVERTEXSTREAM4SVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream4svATI")); + glVertexStream4iATI = reinterpret_cast<PFNGLVERTEXSTREAM4IATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream4iATI")); + glVertexStream4ivATI = reinterpret_cast<PFNGLVERTEXSTREAM4IVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream4ivATI")); + glVertexStream4fATI = reinterpret_cast<PFNGLVERTEXSTREAM4FATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream4fATI")); + glVertexStream4fvATI = reinterpret_cast<PFNGLVERTEXSTREAM4FVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream4fvATI")); + glVertexStream4dATI = reinterpret_cast<PFNGLVERTEXSTREAM4DATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream4dATI")); + glVertexStream4dvATI = reinterpret_cast<PFNGLVERTEXSTREAM4DVATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexStream4dvATI")); + glNormalStream3bATI = reinterpret_cast<PFNGLNORMALSTREAM3BATIPROC>(bglGetProcAddress((const GLubyte *) "glNormalStream3bATI")); + glNormalStream3bvATI = reinterpret_cast<PFNGLNORMALSTREAM3BVATIPROC>(bglGetProcAddress((const GLubyte *) "glNormalStream3bvATI")); + glNormalStream3sATI = reinterpret_cast<PFNGLNORMALSTREAM3SATIPROC>(bglGetProcAddress((const GLubyte *) "glNormalStream3sATI")); + glNormalStream3svATI = reinterpret_cast<PFNGLNORMALSTREAM3SVATIPROC>(bglGetProcAddress((const GLubyte *) "glNormalStream3svATI")); + glNormalStream3iATI = reinterpret_cast<PFNGLNORMALSTREAM3IATIPROC>(bglGetProcAddress((const GLubyte *) "glNormalStream3iATI")); + glNormalStream3ivATI = reinterpret_cast<PFNGLNORMALSTREAM3IVATIPROC>(bglGetProcAddress((const GLubyte *) "glNormalStream3ivATI")); + glNormalStream3fATI = reinterpret_cast<PFNGLNORMALSTREAM3FATIPROC>(bglGetProcAddress((const GLubyte *) "glNormalStream3fATI")); + glNormalStream3fvATI = reinterpret_cast<PFNGLNORMALSTREAM3FVATIPROC>(bglGetProcAddress((const GLubyte *) "glNormalStream3fvATI")); + glNormalStream3dATI = reinterpret_cast<PFNGLNORMALSTREAM3DATIPROC>(bglGetProcAddress((const GLubyte *) "glNormalStream3dATI")); + glNormalStream3dvATI = reinterpret_cast<PFNGLNORMALSTREAM3DVATIPROC>(bglGetProcAddress((const GLubyte *) "glNormalStream3dvATI")); + glClientActiveVertexStreamATI = reinterpret_cast<PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC>(bglGetProcAddress((const GLubyte *) "glClientActiveVertexStreamATI")); + glVertexBlendEnviATI = reinterpret_cast<PFNGLVERTEXBLENDENVIATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexBlendEnviATI")); + glVertexBlendEnvfATI = reinterpret_cast<PFNGLVERTEXBLENDENVFATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexBlendEnvfATI")); + if (glVertexStream1sATI && glVertexStream1svATI && glVertexStream1iATI && glVertexStream1ivATI && glVertexStream1fATI && glVertexStream1fvATI && glVertexStream1dATI && glVertexStream1dvATI && glVertexStream2sATI && glVertexStream2svATI && glVertexStream2iATI && glVertexStream2ivATI && glVertexStream2fATI && glVertexStream2fvATI && glVertexStream2dATI && glVertexStream2dvATI && glVertexStream3sATI && glVertexStream3svATI && glVertexStream3iATI && glVertexStream3ivATI && glVertexStream3fATI && glVertexStream3fvATI && glVertexStream3dATI && glVertexStream3dvATI && glVertexStream4sATI && glVertexStream4svATI && glVertexStream4iATI && glVertexStream4ivATI && glVertexStream4fATI && glVertexStream4fvATI && glVertexStream4dATI && glVertexStream4dvATI && glNormalStream3bATI && glNormalStream3bvATI && glNormalStream3sATI && glNormalStream3svATI && glNormalStream3iATI && glNormalStream3ivATI && glNormalStream3fATI && glNormalStream3fvATI && glNormalStream3dATI && glNormalStream3dvATI && glClientActiveVertexStreamATI && glVertexBlendEnviATI && glVertexBlendEnvfATI) { + EnableExtension(_GL_ATI_vertex_streams); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_vertex_streams" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_vertex_streams implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ATI_element_array) + if (QueryExtension("GL_ATI_element_array")) + { + glElementPointerATI = reinterpret_cast<PFNGLELEMENTPOINTERATIPROC>(bglGetProcAddress((const GLubyte *) "glElementPointerATI")); + glDrawElementArrayATI = reinterpret_cast<PFNGLDRAWELEMENTARRAYATIPROC>(bglGetProcAddress((const GLubyte *) "glDrawElementArrayATI")); + glDrawRangeElementArrayATI = reinterpret_cast<PFNGLDRAWRANGEELEMENTARRAYATIPROC>(bglGetProcAddress((const GLubyte *) "glDrawRangeElementArrayATI")); + if (glElementPointerATI && glDrawElementArrayATI && glDrawRangeElementArrayATI) { + EnableExtension(_GL_ATI_element_array); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_element_array" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_element_array implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SUN_mesh_array) + if (QueryExtension("GL_SUN_mesh_array")) + { + glDrawMeshArraysSUN = reinterpret_cast<PFNGLDRAWMESHARRAYSSUNPROC>(bglGetProcAddress((const GLubyte *) "glDrawMeshArraysSUN")); + if (glDrawMeshArraysSUN) { + EnableExtension(_GL_SUN_mesh_array); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_mesh_array" << std::endl; + } else { + std::cout << "ERROR: GL_SUN_mesh_array implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SUN_slice_accum")) + { + EnableExtension(_GL_SUN_slice_accum); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_slice_accum" << std::endl; + } + + if (QueryExtension("GL_NV_multisample_filter_hint")) + { + EnableExtension(_GL_NV_multisample_filter_hint); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_multisample_filter_hint" << std::endl; + } + + if (QueryExtension("GL_NV_depth_clamp")) + { + EnableExtension(_GL_NV_depth_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_depth_clamp" << std::endl; + } + +#if defined(GL_NV_occlusion_query) + if (QueryExtension("GL_NV_occlusion_query")) + { + glGenOcclusionQueriesNV = reinterpret_cast<PFNGLGENOCCLUSIONQUERIESNVPROC>(bglGetProcAddress((const GLubyte *) "glGenOcclusionQueriesNV")); + glDeleteOcclusionQueriesNV = reinterpret_cast<PFNGLDELETEOCCLUSIONQUERIESNVPROC>(bglGetProcAddress((const GLubyte *) "glDeleteOcclusionQueriesNV")); + glIsOcclusionQueryNV = reinterpret_cast<PFNGLISOCCLUSIONQUERYNVPROC>(bglGetProcAddress((const GLubyte *) "glIsOcclusionQueryNV")); + glBeginOcclusionQueryNV = reinterpret_cast<PFNGLBEGINOCCLUSIONQUERYNVPROC>(bglGetProcAddress((const GLubyte *) "glBeginOcclusionQueryNV")); + glEndOcclusionQueryNV = reinterpret_cast<PFNGLENDOCCLUSIONQUERYNVPROC>(bglGetProcAddress((const GLubyte *) "glEndOcclusionQueryNV")); + glGetOcclusionQueryivNV = reinterpret_cast<PFNGLGETOCCLUSIONQUERYIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetOcclusionQueryivNV")); + glGetOcclusionQueryuivNV = reinterpret_cast<PFNGLGETOCCLUSIONQUERYUIVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetOcclusionQueryuivNV")); + if (glGenOcclusionQueriesNV && glDeleteOcclusionQueriesNV && glIsOcclusionQueryNV && glBeginOcclusionQueryNV && glEndOcclusionQueryNV && glGetOcclusionQueryivNV && glGetOcclusionQueryuivNV) { + EnableExtension(_GL_NV_occlusion_query); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_occlusion_query" << std::endl; + } else { + std::cout << "ERROR: GL_NV_occlusion_query implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_point_sprite) + if (QueryExtension("GL_NV_point_sprite")) + { + glPointParameteriNV = reinterpret_cast<PFNGLPOINTPARAMETERINVPROC>(bglGetProcAddress((const GLubyte *) "glPointParameteriNV")); + glPointParameterivNV = reinterpret_cast<PFNGLPOINTPARAMETERIVNVPROC>(bglGetProcAddress((const GLubyte *) "glPointParameterivNV")); + if (glPointParameteriNV && glPointParameterivNV) { + EnableExtension(_GL_NV_point_sprite); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_point_sprite" << std::endl; + } else { + std::cout << "ERROR: GL_NV_point_sprite implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_texture_shader3")) + { + EnableExtension(_GL_NV_texture_shader3); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_shader3" << std::endl; + } + + if (QueryExtension("GL_NV_vertex_program1_1")) + { + EnableExtension(_GL_NV_vertex_program1_1); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_vertex_program1_1" << std::endl; + } + + if (QueryExtension("GL_EXT_shadow_funcs")) + { + EnableExtension(_GL_EXT_shadow_funcs); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_shadow_funcs" << std::endl; + } + +#if defined(GL_EXT_stencil_two_side) + if (QueryExtension("GL_EXT_stencil_two_side")) + { + glActiveStencilFaceEXT = reinterpret_cast<PFNGLACTIVESTENCILFACEEXTPROC>(bglGetProcAddress((const GLubyte *) "glActiveStencilFaceEXT")); + if (glActiveStencilFaceEXT) { + EnableExtension(_GL_EXT_stencil_two_side); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_stencil_two_side" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_stencil_two_side implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ATI_text_fragment_shader")) + { + EnableExtension(_GL_ATI_text_fragment_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_text_fragment_shader" << std::endl; + } + + if (QueryExtension("GL_APPLE_client_storage")) + { + EnableExtension(_GL_APPLE_client_storage); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_client_storage" << std::endl; + } + +#if defined(GL_APPLE_element_array) + if (QueryExtension("GL_APPLE_element_array")) + { + glElementPointerAPPLE = reinterpret_cast<PFNGLELEMENTPOINTERAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glElementPointerAPPLE")); + glDrawElementArrayAPPLE = reinterpret_cast<PFNGLDRAWELEMENTARRAYAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glDrawElementArrayAPPLE")); + glDrawRangeElementArrayAPPLE = reinterpret_cast<PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glDrawRangeElementArrayAPPLE")); + glMultiDrawElementArrayAPPLE = reinterpret_cast<PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glMultiDrawElementArrayAPPLE")); + glMultiDrawRangeElementArrayAPPLE = reinterpret_cast<PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glMultiDrawRangeElementArrayAPPLE")); + if (glElementPointerAPPLE && glDrawElementArrayAPPLE && glDrawRangeElementArrayAPPLE && glMultiDrawElementArrayAPPLE && glMultiDrawRangeElementArrayAPPLE) { + EnableExtension(_GL_APPLE_element_array); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_element_array" << std::endl; + } else { + std::cout << "ERROR: GL_APPLE_element_array implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_APPLE_fence) + if (QueryExtension("GL_APPLE_fence")) + { + glGenFencesAPPLE = reinterpret_cast<PFNGLGENFENCESAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glGenFencesAPPLE")); + glDeleteFencesAPPLE = reinterpret_cast<PFNGLDELETEFENCESAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glDeleteFencesAPPLE")); + glSetFenceAPPLE = reinterpret_cast<PFNGLSETFENCEAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glSetFenceAPPLE")); + glIsFenceAPPLE = reinterpret_cast<PFNGLISFENCEAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glIsFenceAPPLE")); + glTestFenceAPPLE = reinterpret_cast<PFNGLTESTFENCEAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glTestFenceAPPLE")); + glFinishFenceAPPLE = reinterpret_cast<PFNGLFINISHFENCEAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glFinishFenceAPPLE")); + glTestObjectAPPLE = reinterpret_cast<PFNGLTESTOBJECTAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glTestObjectAPPLE")); + glFinishObjectAPPLE = reinterpret_cast<PFNGLFINISHOBJECTAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glFinishObjectAPPLE")); + if (glGenFencesAPPLE && glDeleteFencesAPPLE && glSetFenceAPPLE && glIsFenceAPPLE && glTestFenceAPPLE && glFinishFenceAPPLE && glTestObjectAPPLE && glFinishObjectAPPLE) { + EnableExtension(_GL_APPLE_fence); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_fence" << std::endl; + } else { + std::cout << "ERROR: GL_APPLE_fence implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_APPLE_vertex_array_object) + if (QueryExtension("GL_APPLE_vertex_array_object")) + { + glBindVertexArrayAPPLE = reinterpret_cast<PFNGLBINDVERTEXARRAYAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glBindVertexArrayAPPLE")); + glDeleteVertexArraysAPPLE = reinterpret_cast<PFNGLDELETEVERTEXARRAYSAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glDeleteVertexArraysAPPLE")); + glGenVertexArraysAPPLE = reinterpret_cast<PFNGLGENVERTEXARRAYSAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glGenVertexArraysAPPLE")); + glIsVertexArrayAPPLE = reinterpret_cast<PFNGLISVERTEXARRAYAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glIsVertexArrayAPPLE")); + if (glBindVertexArrayAPPLE && glDeleteVertexArraysAPPLE && glGenVertexArraysAPPLE && glIsVertexArrayAPPLE) { + EnableExtension(_GL_APPLE_vertex_array_object); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_vertex_array_object" << std::endl; + } else { + std::cout << "ERROR: GL_APPLE_vertex_array_object implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_APPLE_vertex_array_range) + if (QueryExtension("GL_APPLE_vertex_array_range")) + { + glVertexArrayRangeAPPLE = reinterpret_cast<PFNGLVERTEXARRAYRANGEAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glVertexArrayRangeAPPLE")); + glFlushVertexArrayRangeAPPLE = reinterpret_cast<PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glFlushVertexArrayRangeAPPLE")); + glVertexArrayParameteriAPPLE = reinterpret_cast<PFNGLVERTEXARRAYPARAMETERIAPPLEPROC>(bglGetProcAddress((const GLubyte *) "glVertexArrayParameteriAPPLE")); + if (glVertexArrayRangeAPPLE && glFlushVertexArrayRangeAPPLE && glVertexArrayParameteriAPPLE) { + EnableExtension(_GL_APPLE_vertex_array_range); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_vertex_array_range" << std::endl; + } else { + std::cout << "ERROR: GL_APPLE_vertex_array_range implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_APPLE_ycbcr_422")) + { + EnableExtension(_GL_APPLE_ycbcr_422); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_ycbcr_422" << std::endl; + } + + if (QueryExtension("GL_S3_s3tc")) + { + EnableExtension(_GL_S3_s3tc); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_S3_s3tc" << std::endl; + } + +#if defined(GL_ATI_draw_buffers) + if (QueryExtension("GL_ATI_draw_buffers")) + { + glDrawBuffersATI = reinterpret_cast<PFNGLDRAWBUFFERSATIPROC>(bglGetProcAddress((const GLubyte *) "glDrawBuffersATI")); + if (glDrawBuffersATI) { + EnableExtension(_GL_ATI_draw_buffers); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_draw_buffers" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_draw_buffers implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ATI_texture_env_combine3")) + { + EnableExtension(_GL_ATI_texture_env_combine3); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_texture_env_combine3" << std::endl; + } + + if (QueryExtension("GL_ATI_texture_float")) + { + EnableExtension(_GL_ATI_texture_float); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_texture_float" << std::endl; + } + + if (QueryExtension("GL_NV_float_buffer")) + { + EnableExtension(_GL_NV_float_buffer); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_float_buffer" << std::endl; + } + +#if defined(GL_NV_fragment_program) + if (QueryExtension("GL_NV_fragment_program")) + { + glProgramNamedParameter4fNV = reinterpret_cast<PFNGLPROGRAMNAMEDPARAMETER4FNVPROC>(bglGetProcAddress((const GLubyte *) "glProgramNamedParameter4fNV")); + glProgramNamedParameter4dNV = reinterpret_cast<PFNGLPROGRAMNAMEDPARAMETER4DNVPROC>(bglGetProcAddress((const GLubyte *) "glProgramNamedParameter4dNV")); + glProgramNamedParameter4fvNV = reinterpret_cast<PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC>(bglGetProcAddress((const GLubyte *) "glProgramNamedParameter4fvNV")); + glProgramNamedParameter4dvNV = reinterpret_cast<PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC>(bglGetProcAddress((const GLubyte *) "glProgramNamedParameter4dvNV")); + glGetProgramNamedParameterfvNV = reinterpret_cast<PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramNamedParameterfvNV")); + glGetProgramNamedParameterdvNV = reinterpret_cast<PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC>(bglGetProcAddress((const GLubyte *) "glGetProgramNamedParameterdvNV")); + if (glProgramNamedParameter4fNV && glProgramNamedParameter4dNV && glProgramNamedParameter4fvNV && glProgramNamedParameter4dvNV && glGetProgramNamedParameterfvNV && glGetProgramNamedParameterdvNV) { + EnableExtension(_GL_NV_fragment_program); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_fragment_program" << std::endl; + } else { + std::cout << "ERROR: GL_NV_fragment_program implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_half_float) + if (QueryExtension("GL_NV_half_float")) + { + glVertex2hNV = reinterpret_cast<PFNGLVERTEX2HNVPROC>(bglGetProcAddress((const GLubyte *) "glVertex2hNV")); + glVertex2hvNV = reinterpret_cast<PFNGLVERTEX2HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertex2hvNV")); + glVertex3hNV = reinterpret_cast<PFNGLVERTEX3HNVPROC>(bglGetProcAddress((const GLubyte *) "glVertex3hNV")); + glVertex3hvNV = reinterpret_cast<PFNGLVERTEX3HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertex3hvNV")); + glVertex4hNV = reinterpret_cast<PFNGLVERTEX4HNVPROC>(bglGetProcAddress((const GLubyte *) "glVertex4hNV")); + glVertex4hvNV = reinterpret_cast<PFNGLVERTEX4HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertex4hvNV")); + glNormal3hNV = reinterpret_cast<PFNGLNORMAL3HNVPROC>(bglGetProcAddress((const GLubyte *) "glNormal3hNV")); + glNormal3hvNV = reinterpret_cast<PFNGLNORMAL3HVNVPROC>(bglGetProcAddress((const GLubyte *) "glNormal3hvNV")); + glColor3hNV = reinterpret_cast<PFNGLCOLOR3HNVPROC>(bglGetProcAddress((const GLubyte *) "glColor3hNV")); + glColor3hvNV = reinterpret_cast<PFNGLCOLOR3HVNVPROC>(bglGetProcAddress((const GLubyte *) "glColor3hvNV")); + glColor4hNV = reinterpret_cast<PFNGLCOLOR4HNVPROC>(bglGetProcAddress((const GLubyte *) "glColor4hNV")); + glColor4hvNV = reinterpret_cast<PFNGLCOLOR4HVNVPROC>(bglGetProcAddress((const GLubyte *) "glColor4hvNV")); + glTexCoord1hNV = reinterpret_cast<PFNGLTEXCOORD1HNVPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord1hNV")); + glTexCoord1hvNV = reinterpret_cast<PFNGLTEXCOORD1HVNVPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord1hvNV")); + glTexCoord2hNV = reinterpret_cast<PFNGLTEXCOORD2HNVPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2hNV")); + glTexCoord2hvNV = reinterpret_cast<PFNGLTEXCOORD2HVNVPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord2hvNV")); + glTexCoord3hNV = reinterpret_cast<PFNGLTEXCOORD3HNVPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord3hNV")); + glTexCoord3hvNV = reinterpret_cast<PFNGLTEXCOORD3HVNVPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord3hvNV")); + glTexCoord4hNV = reinterpret_cast<PFNGLTEXCOORD4HNVPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord4hNV")); + glTexCoord4hvNV = reinterpret_cast<PFNGLTEXCOORD4HVNVPROC>(bglGetProcAddress((const GLubyte *) "glTexCoord4hvNV")); + glMultiTexCoord1hNV = reinterpret_cast<PFNGLMULTITEXCOORD1HNVPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1hNV")); + glMultiTexCoord1hvNV = reinterpret_cast<PFNGLMULTITEXCOORD1HVNVPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1hvNV")); + glMultiTexCoord2hNV = reinterpret_cast<PFNGLMULTITEXCOORD2HNVPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2hNV")); + glMultiTexCoord2hvNV = reinterpret_cast<PFNGLMULTITEXCOORD2HVNVPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2hvNV")); + glMultiTexCoord3hNV = reinterpret_cast<PFNGLMULTITEXCOORD3HNVPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3hNV")); + glMultiTexCoord3hvNV = reinterpret_cast<PFNGLMULTITEXCOORD3HVNVPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3hvNV")); + glMultiTexCoord4hNV = reinterpret_cast<PFNGLMULTITEXCOORD4HNVPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4hNV")); + glMultiTexCoord4hvNV = reinterpret_cast<PFNGLMULTITEXCOORD4HVNVPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4hvNV")); + glFogCoordhNV = reinterpret_cast<PFNGLFOGCOORDHNVPROC>(bglGetProcAddress((const GLubyte *) "glFogCoordhNV")); + glFogCoordhvNV = reinterpret_cast<PFNGLFOGCOORDHVNVPROC>(bglGetProcAddress((const GLubyte *) "glFogCoordhvNV")); + glSecondaryColor3hNV = reinterpret_cast<PFNGLSECONDARYCOLOR3HNVPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3hNV")); + glSecondaryColor3hvNV = reinterpret_cast<PFNGLSECONDARYCOLOR3HVNVPROC>(bglGetProcAddress((const GLubyte *) "glSecondaryColor3hvNV")); + glVertexWeighthNV = reinterpret_cast<PFNGLVERTEXWEIGHTHNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexWeighthNV")); + glVertexWeighthvNV = reinterpret_cast<PFNGLVERTEXWEIGHTHVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexWeighthvNV")); + glVertexAttrib1hNV = reinterpret_cast<PFNGLVERTEXATTRIB1HNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1hNV")); + glVertexAttrib1hvNV = reinterpret_cast<PFNGLVERTEXATTRIB1HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib1hvNV")); + glVertexAttrib2hNV = reinterpret_cast<PFNGLVERTEXATTRIB2HNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2hNV")); + glVertexAttrib2hvNV = reinterpret_cast<PFNGLVERTEXATTRIB2HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib2hvNV")); + glVertexAttrib3hNV = reinterpret_cast<PFNGLVERTEXATTRIB3HNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3hNV")); + glVertexAttrib3hvNV = reinterpret_cast<PFNGLVERTEXATTRIB3HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib3hvNV")); + glVertexAttrib4hNV = reinterpret_cast<PFNGLVERTEXATTRIB4HNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4hNV")); + glVertexAttrib4hvNV = reinterpret_cast<PFNGLVERTEXATTRIB4HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttrib4hvNV")); + glVertexAttribs1hvNV = reinterpret_cast<PFNGLVERTEXATTRIBS1HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs1hvNV")); + glVertexAttribs2hvNV = reinterpret_cast<PFNGLVERTEXATTRIBS2HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs2hvNV")); + glVertexAttribs3hvNV = reinterpret_cast<PFNGLVERTEXATTRIBS3HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs3hvNV")); + glVertexAttribs4hvNV = reinterpret_cast<PFNGLVERTEXATTRIBS4HVNVPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribs4hvNV")); + if (glVertex2hNV && glVertex2hvNV && glVertex3hNV && glVertex3hvNV && glVertex4hNV && glVertex4hvNV && glNormal3hNV && glNormal3hvNV && glColor3hNV && glColor3hvNV && glColor4hNV && glColor4hvNV && glTexCoord1hNV && glTexCoord1hvNV && glTexCoord2hNV && glTexCoord2hvNV && glTexCoord3hNV && glTexCoord3hvNV && glTexCoord4hNV && glTexCoord4hvNV && glMultiTexCoord1hNV && glMultiTexCoord1hvNV && glMultiTexCoord2hNV && glMultiTexCoord2hvNV && glMultiTexCoord3hNV && glMultiTexCoord3hvNV && glMultiTexCoord4hNV && glMultiTexCoord4hvNV && glFogCoordhNV && glFogCoordhvNV && glSecondaryColor3hNV && glSecondaryColor3hvNV && glVertexWeighthNV && glVertexWeighthvNV && glVertexAttrib1hNV && glVertexAttrib1hvNV && glVertexAttrib2hNV && glVertexAttrib2hvNV && glVertexAttrib3hNV && glVertexAttrib3hvNV && glVertexAttrib4hNV && glVertexAttrib4hvNV && glVertexAttribs1hvNV && glVertexAttribs2hvNV && glVertexAttribs3hvNV && glVertexAttribs4hvNV) { + EnableExtension(_GL_NV_half_float); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_half_float" << std::endl; + } else { + std::cout << "ERROR: GL_NV_half_float implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_pixel_data_range) + if (QueryExtension("GL_NV_pixel_data_range")) + { + glPixelDataRangeNV = reinterpret_cast<PFNGLPIXELDATARANGENVPROC>(bglGetProcAddress((const GLubyte *) "glPixelDataRangeNV")); + glFlushPixelDataRangeNV = reinterpret_cast<PFNGLFLUSHPIXELDATARANGENVPROC>(bglGetProcAddress((const GLubyte *) "glFlushPixelDataRangeNV")); + if (glPixelDataRangeNV && glFlushPixelDataRangeNV) { + EnableExtension(_GL_NV_pixel_data_range); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_pixel_data_range" << std::endl; + } else { + std::cout << "ERROR: GL_NV_pixel_data_range implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_primitive_restart) + if (QueryExtension("GL_NV_primitive_restart")) + { + glPrimitiveRestartNV = reinterpret_cast<PFNGLPRIMITIVERESTARTNVPROC>(bglGetProcAddress((const GLubyte *) "glPrimitiveRestartNV")); + glPrimitiveRestartIndexNV = reinterpret_cast<PFNGLPRIMITIVERESTARTINDEXNVPROC>(bglGetProcAddress((const GLubyte *) "glPrimitiveRestartIndexNV")); + if (glPrimitiveRestartNV && glPrimitiveRestartIndexNV) { + EnableExtension(_GL_NV_primitive_restart); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_primitive_restart" << std::endl; + } else { + std::cout << "ERROR: GL_NV_primitive_restart implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_texture_expand_normal")) + { + EnableExtension(_GL_NV_texture_expand_normal); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_expand_normal" << std::endl; + } + + if (QueryExtension("GL_NV_vertex_program2")) + { + EnableExtension(_GL_NV_vertex_program2); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_vertex_program2" << std::endl; + } + +#if defined(GL_ATI_map_object_buffer) + if (QueryExtension("GL_ATI_map_object_buffer")) + { + glMapObjectBufferATI = reinterpret_cast<PFNGLMAPOBJECTBUFFERATIPROC>(bglGetProcAddress((const GLubyte *) "glMapObjectBufferATI")); + glUnmapObjectBufferATI = reinterpret_cast<PFNGLUNMAPOBJECTBUFFERATIPROC>(bglGetProcAddress((const GLubyte *) "glUnmapObjectBufferATI")); + if (glMapObjectBufferATI && glUnmapObjectBufferATI) { + EnableExtension(_GL_ATI_map_object_buffer); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_map_object_buffer" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_map_object_buffer implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ATI_separate_stencil) + if (QueryExtension("GL_ATI_separate_stencil")) + { + glStencilOpSeparateATI = reinterpret_cast<PFNGLSTENCILOPSEPARATEATIPROC>(bglGetProcAddress((const GLubyte *) "glStencilOpSeparateATI")); + glStencilFuncSeparateATI = reinterpret_cast<PFNGLSTENCILFUNCSEPARATEATIPROC>(bglGetProcAddress((const GLubyte *) "glStencilFuncSeparateATI")); + if (glStencilOpSeparateATI && glStencilFuncSeparateATI) { + EnableExtension(_GL_ATI_separate_stencil); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_separate_stencil" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_separate_stencil implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ATI_vertex_attrib_array_object) + if (QueryExtension("GL_ATI_vertex_attrib_array_object")) + { + glVertexAttribArrayObjectATI = reinterpret_cast<PFNGLVERTEXATTRIBARRAYOBJECTATIPROC>(bglGetProcAddress((const GLubyte *) "glVertexAttribArrayObjectATI")); + glGetVertexAttribArrayObjectfvATI = reinterpret_cast<PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribArrayObjectfvATI")); + glGetVertexAttribArrayObjectivATI = reinterpret_cast<PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC>(bglGetProcAddress((const GLubyte *) "glGetVertexAttribArrayObjectivATI")); + if (glVertexAttribArrayObjectATI && glGetVertexAttribArrayObjectfvATI && glGetVertexAttribArrayObjectivATI) { + EnableExtension(_GL_ATI_vertex_attrib_array_object); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_vertex_attrib_array_object" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_vertex_attrib_array_object implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_depth_bounds_test) + if (QueryExtension("GL_EXT_depth_bounds_test")) + { + glDepthBoundsEXT = reinterpret_cast<PFNGLDEPTHBOUNDSEXTPROC>(bglGetProcAddress((const GLubyte *) "glDepthBoundsEXT")); + if (glDepthBoundsEXT) { + EnableExtension(_GL_EXT_depth_bounds_test); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_depth_bounds_test" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_depth_bounds_test implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_texture_mirror_clamp")) + { + EnableExtension(_GL_EXT_texture_mirror_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_mirror_clamp" << std::endl; + } + +#if defined(GL_EXT_blend_equation_separate) + if (QueryExtension("GL_EXT_blend_equation_separate")) + { + glBlendEquationSeparateEXT = reinterpret_cast<PFNGLBLENDEQUATIONSEPARATEEXTPROC>(bglGetProcAddress((const GLubyte *) "glBlendEquationSeparateEXT")); + if (glBlendEquationSeparateEXT) { + EnableExtension(_GL_EXT_blend_equation_separate); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_blend_equation_separate" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_blend_equation_separate implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_MESA_pack_invert")) + { + EnableExtension(_GL_MESA_pack_invert); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_MESA_pack_invert" << std::endl; + } + + if (QueryExtension("GL_MESA_ycbcr_texture")) + { + EnableExtension(_GL_MESA_ycbcr_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_MESA_ycbcr_texture" << std::endl; + } + + + /* End mkglext.py */ + doDebugMessages = false; +} + diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h new file mode 100644 index 00000000000..8f570ee356c --- /dev/null +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h @@ -0,0 +1,1718 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef __RAS_GLEXTENSIONMANAGER_H__ +#define __RAS_GLEXTENSIONMANAGER_H__ + +#ifdef __APPLE__ +#include <OpenGL/gl.h> +#else +#include <GL/gl.h> +#endif + +class RAS_GLExtensionManager +{ +public: + /* http://oss.sgi.com/projects/ogl-sample/registry/ */ + typedef enum { + /* ARB Extensions */ + _GL_ARB_multitexture , + _GLX_ARB_get_proc_address , + _GL_ARB_transpose_matrix , + _WGL_ARB_buffer_region , + _GL_ARB_multisample , + _GL_ARB_texture_env_add , + _GL_ARB_texture_cube_map , + _WGL_ARB_extensions_string , + _WGL_ARB_pixel_format , + _WGL_ARB_make_current_read , + _WGL_ARB_pbuffer , + _GL_ARB_texture_compression , + _GL_ARB_texture_border_clamp , + _GL_ARB_point_parameters , + _GL_ARB_vertex_blend , + _GL_ARB_matrix_palette , + _GL_ARB_texture_env_combine , + _GL_ARB_texture_env_crossbar , + _GL_ARB_texture_env_dot3 , + _WGL_ARB_render_texture , + _GL_ARB_texture_mirrored_repeat , + _GL_ARB_depth_texture , + _GL_ARB_shadow , + _GL_ARB_shadow_ambient , + _GL_ARB_window_pos , + _GL_ARB_vertex_program , + _GL_ARB_fragment_program , + _GL_ARB_vertex_buffer_object , + _GL_ARB_occlusion_query , + _GL_ARB_shader_objects , + _GL_ARB_vertex_shader , + _GL_ARB_fragment_shader , + _GL_ARB_shading_language_100 , + _GL_ARB_texture_non_power_of_two , + _GL_ARB_point_sprite , + _GL_ARB_fragment_program_shadow , + + /* Non ARB Extensions */ + _GL_EXT_abgr , + _GL_EXT_blend_color , + _GL_EXT_polygon_offset , + _GL_EXT_texture , + _GL_EXT_texture3D , + _GL_SGIS_texture_filter4 , + _GL_EXT_subtexture , + _GL_EXT_copy_texture , + _GL_EXT_histogram , + _GL_EXT_convolution , + _GL_SGI_color_matrix , + _GL_SGI_color_table , + _GL_SGIS_pixel_texture , + _GL_SGIS_texture4D , + _GL_SGI_texture_color_table , + _GL_EXT_cmyka , + _GL_EXT_texture_object , + _GL_SGIS_detail_texture , + _GL_SGIS_sharpen_texture , + _GL_EXT_packed_pixels , + _GL_SGIS_texture_lod , + _GL_SGIS_multisample , + _GL_EXT_rescale_normal , + _GLX_EXT_visual_info , + _GL_EXT_vertex_array , + _GL_EXT_misc_attribute , + _GL_SGIS_generate_mipmap , + _GL_SGIX_clipmap , + _GL_SGIX_shadow , + _GL_SGIS_texture_edge_clamp , + _GL_SGIS_texture_border_clamp , + _GL_EXT_blend_minmax , + _GL_EXT_blend_subtract , + _GL_EXT_blend_logic_op , + _GLX_SGI_swap_control , + _GLX_SGI_video_sync , + _GLX_SGI_make_current_read , + _GLX_SGIX_video_source , + _GLX_EXT_visual_rating , + _GL_SGIX_interlace , + _GLX_EXT_import_context , + _GLX_SGIX_fbconfig , + _GLX_SGIX_pbuffer , + _GL_SGIS_texture_select , + _GL_SGIX_sprite , + _GL_SGIX_texture_multi_buffer , + _GL_EXT_point_parameters , + _GL_SGIX_instruments , + _GL_SGIX_texture_scale_bias , + _GL_SGIX_framezoom , + _GL_SGIX_tag_sample_buffer , + _GL_SGIX_reference_plane , + _GL_SGIX_flush_raster , + _GLX_SGI_cushion , + _GL_SGIX_depth_texture , + _GL_SGIS_fog_function , + _GL_SGIX_fog_offset , + _GL_HP_image_transform , + _GL_HP_convolution_border_modes , + _GL_SGIX_texture_add_env , + _GL_EXT_color_subtable , + _GLU_EXT_object_space_tess , + _GL_PGI_vertex_hints , + _GL_PGI_misc_hints , + _GL_EXT_paletted_texture , + _GL_EXT_clip_volume_hint , + _GL_SGIX_list_priority , + _GL_SGIX_ir_instrument1 , + _GLX_SGIX_video_resize , + _GL_SGIX_texture_lod_bias , + _GLU_SGI_filter4_parameters , + _GLX_SGIX_dm_buffer , + _GL_SGIX_shadow_ambient , + _GLX_SGIX_swap_group , + _GLX_SGIX_swap_barrier , + _GL_EXT_index_texture , + _GL_EXT_index_material , + _GL_EXT_index_func , + _GL_EXT_index_array_formats , + _GL_EXT_compiled_vertex_array , + _GL_EXT_cull_vertex , + _GLU_EXT_nurbs_tessellator , + _GL_SGIX_ycrcb , + _GL_EXT_fragment_lighting , + _GL_IBM_rasterpos_clip , + _GL_HP_texture_lighting , + _GL_EXT_draw_range_elements , + _GL_WIN_phong_shading , + _GL_WIN_specular_fog , + _GLX_SGIS_color_range , + _GL_EXT_light_texture , + _GL_SGIX_blend_alpha_minmax , + _GL_EXT_scene_marker , + _GL_SGIX_pixel_texture_bits , + _GL_EXT_bgra , + _GL_SGIX_async , + _GL_SGIX_async_pixel , + _GL_SGIX_async_histogram , + _GL_INTEL_texture_scissor , + _GL_INTEL_parallel_arrays , + _GL_HP_occlusion_test , + _GL_EXT_pixel_transform , + _GL_EXT_pixel_transform_color_table , + _GL_EXT_shared_texture_palette , + _GLX_SGIS_blended_overlay , + _GL_EXT_separate_specular_color , + _GL_EXT_secondary_color , + _GL_EXT_texture_env , + _GL_EXT_texture_perturb_normal , + _GL_EXT_multi_draw_arrays , + _GL_EXT_fog_coord , + _GL_REND_screen_coordinates , + _GL_EXT_coordinate_frame , + _GL_EXT_texture_env_combine , + _GL_APPLE_specular_vector , + _GL_SGIX_pixel_texture , + _GL_APPLE_transform_hint , + _GL_SUNX_constant_data , + _GL_SUN_global_alpha , + _GL_SUN_triangle_list , + _GL_SUN_vertex , + _WGL_EXT_display_color_table , + _WGL_EXT_extensions_string , + _WGL_EXT_make_current_read , + _WGL_EXT_pixel_format , + _WGL_EXT_pbuffer , + _WGL_EXT_swap_control , + _GL_EXT_blend_func_separate , + _GL_INGR_color_clamp , + _GL_INGR_interlace_read , + _GL_EXT_stencil_wrap , + _WGL_EXT_depth_float , + _GL_EXT_422_pixels , + _GL_NV_texgen_reflection , + _GL_SGIX_texture_range , + _GL_SUN_convolution_border_modes , + _GLX_SUN_get_transparent_index , + _GL_EXT_texture_env_add , + _GL_EXT_texture_lod_bias , + _GL_EXT_texture_filter_anisotropic , + _GL_EXT_vertex_weighting , + _GL_NV_light_max_exponent , + _GL_NV_vertex_array_range , + _GL_NV_register_combiners , + _GL_NV_fog_distance , + _GL_NV_texgen_emboss , + _GL_NV_blend_square , + _GL_NV_texture_env_combine4 , + _GL_MESA_resize_buffers , + _GL_MESA_window_pos , + _GL_EXT_texture_compression_s3tc , + _GL_IBM_cull_vertex , + _GL_IBM_multimode_draw_arrays , + _GL_IBM_vertex_array_lists , + _GL_3DFX_texture_compression_FXT1 , + _GL_3DFX_multisample , + _GL_3DFX_tbuffer , + _WGL_EXT_multisample , + _GL_SGIX_vertex_preclip , + _GL_SGIX_resample , + _GL_SGIS_texture_color_mask , + _GLX_MESA_copy_sub_buffer , + _GLX_MESA_pixmap_colormap , + _GLX_MESA_release_buffers , + _GLX_MESA_set_3dfx_mode , + _GL_EXT_texture_env_dot3 , + _GL_ATI_texture_mirror_once , + _GL_NV_fence , + _GL_IBM_static_data , + _GL_IBM_texture_mirrored_repeat , + _GL_NV_evaluators , + _GL_NV_packed_depth_stencil , + _GL_NV_register_combiners2 , + _GL_NV_texture_compression_vtc , + _GL_NV_texture_rectangle , + _GL_NV_texture_shader , + _GL_NV_texture_shader2 , + _GL_NV_vertex_array_range2 , + _GL_NV_vertex_program , + _GLX_SGIX_visual_select_group , + _GL_SGIX_texture_coordinate_clamp , + _GLX_OML_swap_method , + _GLX_OML_sync_control , + _GL_OML_interlace , + _GL_OML_subsample , + _GL_OML_resample , + _WGL_OML_sync_control , + _GL_NV_copy_depth_to_color , + _GL_ATI_envmap_bumpmap , + _GL_ATI_fragment_shader , + _GL_ATI_pn_triangles , + _GL_ATI_vertex_array_object , + _GL_EXT_vertex_shader , + _GL_ATI_vertex_streams , + _WGL_I3D_digital_video_control , + _WGL_I3D_gamma , + _WGL_I3D_genlock , + _WGL_I3D_image_buffer , + _WGL_I3D_swap_frame_lock , + _WGL_I3D_swap_frame_usage , + _GL_ATI_element_array , + _GL_SUN_mesh_array , + _GL_SUN_slice_accum , + _GL_NV_multisample_filter_hint , + _GL_NV_depth_clamp , + _GL_NV_occlusion_query , + _GL_NV_point_sprite , + _WGL_NV_render_depth_texture , + _WGL_NV_render_texture_rectangle , + _GL_NV_texture_shader3 , + _GL_NV_vertex_program1_1 , + _GL_EXT_shadow_funcs , + _GL_EXT_stencil_two_side , + _GL_ATI_text_fragment_shader , + _GL_APPLE_client_storage , + _GL_APPLE_element_array , + _GL_APPLE_fence , + _GL_APPLE_vertex_array_object , + _GL_APPLE_vertex_array_range , + _GL_APPLE_ycbcr_422 , + _GL_S3_s3tc , + _GL_ATI_draw_buffers , + _WGL_ATI_pixel_format_float , + _GL_ATI_texture_env_combine3 , + _GL_ATI_texture_float , + _GL_NV_float_buffer , + _GL_NV_fragment_program , + _GL_NV_half_float , + _GL_NV_pixel_data_range , + _GL_NV_primitive_restart , + _GL_NV_texture_expand_normal , + _GL_NV_vertex_program2 , + _GL_ATI_map_object_buffer , + _GL_ATI_separate_stencil , + _GL_ATI_vertex_attrib_array_object , + _GL_OES_byte_coordinates , + _GL_OES_fixed_point , + _GL_OES_single_precision , + _GL_OES_compressed_paletted_texture , + _GL_OES_read_format , + _GL_OES_query_matrix , + _GL_EXT_depth_bounds_test , + _GL_EXT_texture_mirror_clamp , + _GL_EXT_blend_equation_separate , + _GL_MESA_pack_invert , + _GL_MESA_ycbcr_texture, + + /* Finished */ + _BGL_TEST, + NUM_EXTENSIONS + } ExtensionName; + + bool QueryExtension(ExtensionName name); + bool QueryVersion(int major, int minor); + + void LinkExtensions(); + + RAS_GLExtensionManager(int debug = 0); + // FIXME: GLX only + //RAS_GLExtensionManager(Display *dpy, int screen); + ~RAS_GLExtensionManager(); + +private: + std::vector<STR_String> extensions; + /* Bit array of available extensions */ + unsigned int enabled_extensions[(NUM_EXTENSIONS + 8*sizeof(unsigned int) - 1)/(8*sizeof(unsigned int))]; + int m_debug; + + bool QueryExtension(STR_String extension_name); + void EnableExtension(ExtensionName name); + +}; + +namespace RAS_GL { + +/* Begin mkglext.h */ + +/* GL_EXT_compiled_vertex_array */ +/* Always safe to call: will default to noop */ +#ifdef GL_EXT_compiled_vertex_array +extern PFNGLLOCKARRAYSEXTPROC glLockArraysEXT; +extern PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT; +#else +static inline void glLockArraysEXT(GLint x, GLsizei y) {} +static inline void glUnlockArraysEXT(void) {} +#endif + +#if defined(GL_ARB_transpose_matrix) +extern PFNGLLOADTRANSPOSEMATRIXFARBPROC glLoadTransposeMatrixfARB; +extern PFNGLLOADTRANSPOSEMATRIXDARBPROC glLoadTransposeMatrixdARB; +extern PFNGLMULTTRANSPOSEMATRIXFARBPROC glMultTransposeMatrixfARB; +extern PFNGLMULTTRANSPOSEMATRIXDARBPROC glMultTransposeMatrixdARB; +#endif + +#if defined(GL_ARB_multisample) +extern PFNGLSAMPLECOVERAGEARBPROC glSampleCoverageARB; +#endif + +#if defined(GL_ARB_texture_env_add) +#endif + +#if defined(GL_ARB_texture_cube_map) +#endif + +#if defined(GL_ARB_texture_compression) +extern PFNGLCOMPRESSEDTEXIMAGE3DARBPROC glCompressedTexImage3DARB; +extern PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB; +extern PFNGLCOMPRESSEDTEXIMAGE1DARBPROC glCompressedTexImage1DARB; +extern PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC glCompressedTexSubImage3DARB; +extern PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC glCompressedTexSubImage2DARB; +extern PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC glCompressedTexSubImage1DARB; +extern PFNGLGETCOMPRESSEDTEXIMAGEARBPROC glGetCompressedTexImageARB; +#endif + +#if defined(GL_ARB_texture_border_clamp) +#endif + +#if defined(GL_ARB_point_parameters) +extern PFNGLPOINTPARAMETERFARBPROC glPointParameterfARB; +extern PFNGLPOINTPARAMETERFVARBPROC glPointParameterfvARB; +#endif + +#if defined(GL_ARB_vertex_blend) +extern PFNGLWEIGHTBVARBPROC glWeightbvARB; +extern PFNGLWEIGHTSVARBPROC glWeightsvARB; +extern PFNGLWEIGHTIVARBPROC glWeightivARB; +extern PFNGLWEIGHTFVARBPROC glWeightfvARB; +extern PFNGLWEIGHTDVARBPROC glWeightdvARB; +extern PFNGLWEIGHTUBVARBPROC glWeightubvARB; +extern PFNGLWEIGHTUSVARBPROC glWeightusvARB; +extern PFNGLWEIGHTUIVARBPROC glWeightuivARB; +extern PFNGLWEIGHTPOINTERARBPROC glWeightPointerARB; +extern PFNGLVERTEXBLENDARBPROC glVertexBlendARB; +#endif + +#if defined(GL_ARB_matrix_palette) +extern PFNGLCURRENTPALETTEMATRIXARBPROC glCurrentPaletteMatrixARB; +extern PFNGLMATRIXINDEXUBVARBPROC glMatrixIndexubvARB; +extern PFNGLMATRIXINDEXUSVARBPROC glMatrixIndexusvARB; +extern PFNGLMATRIXINDEXUIVARBPROC glMatrixIndexuivARB; +extern PFNGLMATRIXINDEXPOINTERARBPROC glMatrixIndexPointerARB; +#endif + +#if defined(GL_ARB_texture_env_combine) +#endif + +#if defined(GL_ARB_texture_env_crossbar) +#endif + +#if defined(GL_ARB_texture_env_dot3) +#endif + +#if defined(GL_ARB_texture_mirrored_repeat) +#endif + +#if defined(GL_ARB_depth_texture) +#endif + +#if defined(GL_ARB_shadow) +#endif + +#if defined(GL_ARB_shadow_ambient) +#endif + +#if defined(GL_ARB_window_pos) +extern PFNGLWINDOWPOS2DARBPROC glWindowPos2dARB; +extern PFNGLWINDOWPOS2DVARBPROC glWindowPos2dvARB; +extern PFNGLWINDOWPOS2FARBPROC glWindowPos2fARB; +extern PFNGLWINDOWPOS2FVARBPROC glWindowPos2fvARB; +extern PFNGLWINDOWPOS2IARBPROC glWindowPos2iARB; +extern PFNGLWINDOWPOS2IVARBPROC glWindowPos2ivARB; +extern PFNGLWINDOWPOS2SARBPROC glWindowPos2sARB; +extern PFNGLWINDOWPOS2SVARBPROC glWindowPos2svARB; +extern PFNGLWINDOWPOS3DARBPROC glWindowPos3dARB; +extern PFNGLWINDOWPOS3DVARBPROC glWindowPos3dvARB; +extern PFNGLWINDOWPOS3FARBPROC glWindowPos3fARB; +extern PFNGLWINDOWPOS3FVARBPROC glWindowPos3fvARB; +extern PFNGLWINDOWPOS3IARBPROC glWindowPos3iARB; +extern PFNGLWINDOWPOS3IVARBPROC glWindowPos3ivARB; +extern PFNGLWINDOWPOS3SARBPROC glWindowPos3sARB; +extern PFNGLWINDOWPOS3SVARBPROC glWindowPos3svARB; +#endif + +#if defined(GL_ARB_vertex_program) +extern PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB; +extern PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB; +extern PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB; +extern PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB; +extern PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB; +extern PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB; +extern PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB; +extern PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB; +extern PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB; +extern PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB; +extern PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB; +extern PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB; +extern PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB; +extern PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB; +extern PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB; +extern PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB; +extern PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB; +extern PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB; +extern PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4NbvARB; +extern PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4NivARB; +extern PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4NsvARB; +extern PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4NubARB; +extern PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4NubvARB; +extern PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4NuivARB; +extern PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4NusvARB; +extern PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB; +extern PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB; +extern PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB; +extern PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB; +extern PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB; +extern PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB; +extern PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB; +extern PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB; +extern PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB; +extern PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB; +extern PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB; +extern PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB; +extern PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB; +extern PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB; +extern PFNGLPROGRAMSTRINGARBPROC glProgramStringARB; +extern PFNGLBINDPROGRAMARBPROC glBindProgramARB; +extern PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB; +extern PFNGLGENPROGRAMSARBPROC glGenProgramsARB; +extern PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB; +extern PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB; +extern PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB; +extern PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB; +extern PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB; +extern PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB; +extern PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB; +extern PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB; +extern PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB; +extern PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB; +extern PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB; +extern PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB; +extern PFNGLGETPROGRAMIVARBPROC glGetProgramivARB; +extern PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB; +extern PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB; +extern PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB; +extern PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB; +extern PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB; +extern PFNGLISPROGRAMARBPROC glIsProgramARB; +#endif + +#if defined(GL_ARB_fragment_program) +#endif + +#if defined(GL_ARB_vertex_buffer_object) +extern PFNGLBINDBUFFERARBPROC glBindBufferARB; +extern PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB; +extern PFNGLGENBUFFERSARBPROC glGenBuffersARB; +extern PFNGLISBUFFERARBPROC glIsBufferARB; +extern PFNGLBUFFERDATAARBPROC glBufferDataARB; +extern PFNGLBUFFERSUBDATAARBPROC glBufferSubDataARB; +extern PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB; +extern PFNGLMAPBUFFERARBPROC glMapBufferARB; +extern PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB; +extern PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB; +extern PFNGLGETBUFFERPOINTERVARBPROC glGetBufferPointervARB; +#endif + +#if defined(GL_ARB_occlusion_query) +extern PFNGLGENQUERIESARBPROC glGenQueriesARB; +extern PFNGLDELETEQUERIESARBPROC glDeleteQueriesARB; +extern PFNGLISQUERYARBPROC glIsQueryARB; +extern PFNGLBEGINQUERYARBPROC glBeginQueryARB; +extern PFNGLENDQUERYARBPROC glEndQueryARB; +extern PFNGLGETQUERYIVARBPROC glGetQueryivARB; +extern PFNGLGETQUERYOBJECTIVARBPROC glGetQueryObjectivARB; +extern PFNGLGETQUERYOBJECTUIVARBPROC glGetQueryObjectuivARB; +#endif + +#if defined(GL_ARB_shader_objects) +extern PFNGLDELETEOBJECTARBPROC glDeleteObjectARB; +extern PFNGLGETHANDLEARBPROC glGetHandleARB; +extern PFNGLDETACHOBJECTARBPROC glDetachObjectARB; +extern PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB; +extern PFNGLSHADERSOURCEARBPROC glShaderSourceARB; +extern PFNGLCOMPILESHADERARBPROC glCompileShaderARB; +extern PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB; +extern PFNGLATTACHOBJECTARBPROC glAttachObjectARB; +extern PFNGLLINKPROGRAMARBPROC glLinkProgramARB; +extern PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB; +extern PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB; +extern PFNGLUNIFORM1FARBPROC glUniform1fARB; +extern PFNGLUNIFORM2FARBPROC glUniform2fARB; +extern PFNGLUNIFORM3FARBPROC glUniform3fARB; +extern PFNGLUNIFORM4FARBPROC glUniform4fARB; +extern PFNGLUNIFORM1IARBPROC glUniform1iARB; +extern PFNGLUNIFORM2IARBPROC glUniform2iARB; +extern PFNGLUNIFORM3IARBPROC glUniform3iARB; +extern PFNGLUNIFORM4IARBPROC glUniform4iARB; +extern PFNGLUNIFORM1FVARBPROC glUniform1fvARB; +extern PFNGLUNIFORM2FVARBPROC glUniform2fvARB; +extern PFNGLUNIFORM3FVARBPROC glUniform3fvARB; +extern PFNGLUNIFORM4FVARBPROC glUniform4fvARB; +extern PFNGLUNIFORM1IVARBPROC glUniform1ivARB; +extern PFNGLUNIFORM2IVARBPROC glUniform2ivARB; +extern PFNGLUNIFORM3IVARBPROC glUniform3ivARB; +extern PFNGLUNIFORM4IVARBPROC glUniform4ivARB; +extern PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB; +extern PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB; +extern PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB; +extern PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB; +extern PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB; +extern PFNGLGETINFOLOGARBPROC glGetInfoLogARB; +extern PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB; +extern PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB; +extern PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB; +extern PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB; +extern PFNGLGETUNIFORMIVARBPROC glGetUniformivARB; +extern PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB; +#endif + +#if defined(GL_ARB_vertex_shader) +extern PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB; +extern PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB; +extern PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB; +#endif + +#if defined(GL_ARB_fragment_shader) +#endif + +#if defined(GL_ARB_shading_language_100) +#endif + +#if defined(GL_ARB_texture_non_power_of_two) +#endif + +#if defined(GL_ARB_point_sprite) +#endif + +#if defined(GL_ARB_fragment_program_shadow) +#endif + +#if defined(GL_EXT_abgr) +#endif + +#if defined(GL_EXT_texture3D) +extern PFNGLTEXIMAGE3DEXTPROC glTexImage3DEXT; +extern PFNGLTEXSUBIMAGE3DEXTPROC glTexSubImage3DEXT; +#endif + +#if defined(GL_SGIS_texture_filter4) +extern PFNGLGETTEXFILTERFUNCSGISPROC glGetTexFilterFuncSGIS; +extern PFNGLTEXFILTERFUNCSGISPROC glTexFilterFuncSGIS; +#endif + +#if defined(GL_EXT_histogram) +extern PFNGLGETHISTOGRAMEXTPROC glGetHistogramEXT; +extern PFNGLGETHISTOGRAMPARAMETERFVEXTPROC glGetHistogramParameterfvEXT; +extern PFNGLGETHISTOGRAMPARAMETERIVEXTPROC glGetHistogramParameterivEXT; +extern PFNGLGETMINMAXEXTPROC glGetMinmaxEXT; +extern PFNGLGETMINMAXPARAMETERFVEXTPROC glGetMinmaxParameterfvEXT; +extern PFNGLGETMINMAXPARAMETERIVEXTPROC glGetMinmaxParameterivEXT; +extern PFNGLHISTOGRAMEXTPROC glHistogramEXT; +extern PFNGLMINMAXEXTPROC glMinmaxEXT; +extern PFNGLRESETHISTOGRAMEXTPROC glResetHistogramEXT; +extern PFNGLRESETMINMAXEXTPROC glResetMinmaxEXT; +#endif + +#if defined(GL_EXT_convolution) +extern PFNGLCONVOLUTIONFILTER1DEXTPROC glConvolutionFilter1DEXT; +extern PFNGLCONVOLUTIONFILTER2DEXTPROC glConvolutionFilter2DEXT; +extern PFNGLCONVOLUTIONPARAMETERFEXTPROC glConvolutionParameterfEXT; +extern PFNGLCONVOLUTIONPARAMETERFVEXTPROC glConvolutionParameterfvEXT; +extern PFNGLCONVOLUTIONPARAMETERIEXTPROC glConvolutionParameteriEXT; +extern PFNGLCONVOLUTIONPARAMETERIVEXTPROC glConvolutionParameterivEXT; +extern PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC glCopyConvolutionFilter1DEXT; +extern PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC glCopyConvolutionFilter2DEXT; +extern PFNGLGETCONVOLUTIONFILTEREXTPROC glGetConvolutionFilterEXT; +extern PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC glGetConvolutionParameterfvEXT; +extern PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC glGetConvolutionParameterivEXT; +extern PFNGLGETSEPARABLEFILTEREXTPROC glGetSeparableFilterEXT; +extern PFNGLSEPARABLEFILTER2DEXTPROC glSeparableFilter2DEXT; +#endif + +#if defined(GL_SGI_color_table) +extern PFNGLCOLORTABLESGIPROC glColorTableSGI; +extern PFNGLCOLORTABLEPARAMETERFVSGIPROC glColorTableParameterfvSGI; +extern PFNGLCOLORTABLEPARAMETERIVSGIPROC glColorTableParameterivSGI; +extern PFNGLCOPYCOLORTABLESGIPROC glCopyColorTableSGI; +extern PFNGLGETCOLORTABLESGIPROC glGetColorTableSGI; +extern PFNGLGETCOLORTABLEPARAMETERFVSGIPROC glGetColorTableParameterfvSGI; +extern PFNGLGETCOLORTABLEPARAMETERIVSGIPROC glGetColorTableParameterivSGI; +#endif + +#if defined(GL_SGIX_pixel_texture) +extern PFNGLPIXELTEXGENSGIXPROC glPixelTexGenSGIX; +#endif + +#if defined(GL_SGIS_pixel_texture) +extern PFNGLPIXELTEXGENPARAMETERISGISPROC glPixelTexGenParameteriSGIS; +extern PFNGLPIXELTEXGENPARAMETERIVSGISPROC glPixelTexGenParameterivSGIS; +extern PFNGLPIXELTEXGENPARAMETERFSGISPROC glPixelTexGenParameterfSGIS; +extern PFNGLPIXELTEXGENPARAMETERFVSGISPROC glPixelTexGenParameterfvSGIS; +extern PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC glGetPixelTexGenParameterivSGIS; +extern PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC glGetPixelTexGenParameterfvSGIS; +#endif + +#if defined(GL_SGIS_texture4D) +extern PFNGLTEXIMAGE4DSGISPROC glTexImage4DSGIS; +extern PFNGLTEXSUBIMAGE4DSGISPROC glTexSubImage4DSGIS; +#endif + +#if defined(GL_SGI_texture_color_table) +#endif + +#if defined(GL_EXT_cmyka) +#endif + +#if defined(GL_SGIS_detail_texture) +extern PFNGLDETAILTEXFUNCSGISPROC glDetailTexFuncSGIS; +extern PFNGLGETDETAILTEXFUNCSGISPROC glGetDetailTexFuncSGIS; +#endif + +#if defined(GL_SGIS_sharpen_texture) +extern PFNGLSHARPENTEXFUNCSGISPROC glSharpenTexFuncSGIS; +extern PFNGLGETSHARPENTEXFUNCSGISPROC glGetSharpenTexFuncSGIS; +#endif + +#if defined(GL_EXT_packed_pixels) +#endif + +#if defined(GL_SGIS_texture_lod) +#endif + +#if defined(GL_SGIS_multisample) +extern PFNGLSAMPLEMASKSGISPROC glSampleMaskSGIS; +extern PFNGLSAMPLEPATTERNSGISPROC glSamplePatternSGIS; +#endif + +#if defined(GL_EXT_rescale_normal) +#endif + +#if defined(GL_EXT_misc_attribute) +#endif + +#if defined(GL_SGIS_generate_mipmap) +#endif + +#if defined(GL_SGIX_clipmap) +#endif + +#if defined(GL_SGIX_shadow) +#endif + +#if defined(GL_SGIS_texture_edge_clamp) +#endif + +#if defined(GL_SGIS_texture_border_clamp) +#endif + +#if defined(GL_EXT_blend_minmax) +extern PFNGLBLENDEQUATIONEXTPROC glBlendEquationEXT; +#endif + +#if defined(GL_EXT_blend_subtract) +#endif + +#if defined(GL_EXT_blend_logic_op) +#endif + +#if defined(GL_SGIX_interlace) +#endif + +#if defined(GL_SGIX_sprite) +extern PFNGLSPRITEPARAMETERFSGIXPROC glSpriteParameterfSGIX; +extern PFNGLSPRITEPARAMETERFVSGIXPROC glSpriteParameterfvSGIX; +extern PFNGLSPRITEPARAMETERISGIXPROC glSpriteParameteriSGIX; +extern PFNGLSPRITEPARAMETERIVSGIXPROC glSpriteParameterivSGIX; +#endif + +#if defined(GL_SGIX_texture_multi_buffer) +#endif + +#if defined(GL_SGIX_instruments) +extern PFNGLGETINSTRUMENTSSGIXPROC glGetInstrumentsSGIX; +extern PFNGLINSTRUMENTSBUFFERSGIXPROC glInstrumentsBufferSGIX; +extern PFNGLPOLLINSTRUMENTSSGIXPROC glPollInstrumentsSGIX; +extern PFNGLREADINSTRUMENTSSGIXPROC glReadInstrumentsSGIX; +extern PFNGLSTARTINSTRUMENTSSGIXPROC glStartInstrumentsSGIX; +extern PFNGLSTOPINSTRUMENTSSGIXPROC glStopInstrumentsSGIX; +#endif + +#if defined(GL_SGIX_texture_scale_bias) +#endif + +#if defined(GL_SGIX_framezoom) +extern PFNGLFRAMEZOOMSGIXPROC glFrameZoomSGIX; +#endif + +#if defined(GL_SGIX_tag_sample_buffer) +extern PFNGLTAGSAMPLEBUFFERSGIXPROC glTagSampleBufferSGIX; +#endif + +#if defined(GL_SGIX_reference_plane) +extern PFNGLREFERENCEPLANESGIXPROC glReferencePlaneSGIX; +#endif + +#if defined(GL_SGIX_flush_raster) +extern PFNGLFLUSHRASTERSGIXPROC glFlushRasterSGIX; +#endif + +#if defined(GL_SGIX_depth_texture) +#endif + +#if defined(GL_SGIS_fog_function) +extern PFNGLFOGFUNCSGISPROC glFogFuncSGIS; +extern PFNGLGETFOGFUNCSGISPROC glGetFogFuncSGIS; +#endif + +#if defined(GL_SGIX_fog_offset) +#endif + +#if defined(GL_HP_image_transform) +extern PFNGLIMAGETRANSFORMPARAMETERIHPPROC glImageTransformParameteriHP; +extern PFNGLIMAGETRANSFORMPARAMETERFHPPROC glImageTransformParameterfHP; +extern PFNGLIMAGETRANSFORMPARAMETERIVHPPROC glImageTransformParameterivHP; +extern PFNGLIMAGETRANSFORMPARAMETERFVHPPROC glImageTransformParameterfvHP; +extern PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC glGetImageTransformParameterivHP; +extern PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC glGetImageTransformParameterfvHP; +#endif + +#if defined(GL_HP_convolution_border_modes) +#endif + +#if defined(GL_SGIX_texture_add_env) +#endif + +#if defined(GL_EXT_color_subtable) +extern PFNGLCOLORSUBTABLEEXTPROC glColorSubTableEXT; +extern PFNGLCOPYCOLORSUBTABLEEXTPROC glCopyColorSubTableEXT; +#endif + +#if defined(GL_PGI_vertex_hints) +#endif + +#if defined(GL_PGI_misc_hints) +extern PFNGLHINTPGIPROC glHintPGI; +#endif + +#if defined(GL_EXT_paletted_texture) +extern PFNGLCOLORTABLEEXTPROC glColorTableEXT; +extern PFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT; +extern PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT; +extern PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT; +#endif + +#if defined(GL_EXT_clip_volume_hint) +#endif + +#if defined(GL_SGIX_list_priority) +extern PFNGLGETLISTPARAMETERFVSGIXPROC glGetListParameterfvSGIX; +extern PFNGLGETLISTPARAMETERIVSGIXPROC glGetListParameterivSGIX; +extern PFNGLLISTPARAMETERFSGIXPROC glListParameterfSGIX; +extern PFNGLLISTPARAMETERFVSGIXPROC glListParameterfvSGIX; +extern PFNGLLISTPARAMETERISGIXPROC glListParameteriSGIX; +extern PFNGLLISTPARAMETERIVSGIXPROC glListParameterivSGIX; +#endif + +#if defined(GL_SGIX_ir_instrument1) +#endif + +#if defined(GL_SGIX_texture_lod_bias) +#endif + +#if defined(GL_SGIX_shadow_ambient) +#endif + +#if defined(GL_EXT_index_texture) +#endif + +#if defined(GL_EXT_index_material) +extern PFNGLINDEXMATERIALEXTPROC glIndexMaterialEXT; +#endif + +#if defined(GL_EXT_index_func) +extern PFNGLINDEXFUNCEXTPROC glIndexFuncEXT; +#endif + +#if defined(GL_EXT_index_array_formats) +#endif + +#if defined(GL_EXT_cull_vertex) +extern PFNGLCULLPARAMETERDVEXTPROC glCullParameterdvEXT; +extern PFNGLCULLPARAMETERFVEXTPROC glCullParameterfvEXT; +#endif + +#if defined(GL_SGIX_ycrcb) +#endif + +#if defined(GL_IBM_rasterpos_clip) +#endif + +#if defined(GL_HP_texture_lighting) +#endif + +#if defined(GL_EXT_draw_range_elements) +extern PFNGLDRAWRANGEELEMENTSEXTPROC glDrawRangeElementsEXT; +#endif + +#if defined(GL_WIN_phong_shading) +#endif + +#if defined(GL_WIN_specular_fog) +#endif + +#if defined(GL_EXT_light_texture) +extern PFNGLAPPLYTEXTUREEXTPROC glApplyTextureEXT; +extern PFNGLTEXTURELIGHTEXTPROC glTextureLightEXT; +extern PFNGLTEXTUREMATERIALEXTPROC glTextureMaterialEXT; +#endif + +#if defined(GL_SGIX_blend_alpha_minmax) +#endif + +#if defined(GL_EXT_bgra) +#endif + +#if defined(GL_SGIX_async) +extern PFNGLASYNCMARKERSGIXPROC glAsyncMarkerSGIX; +extern PFNGLFINISHASYNCSGIXPROC glFinishAsyncSGIX; +extern PFNGLPOLLASYNCSGIXPROC glPollAsyncSGIX; +extern PFNGLGENASYNCMARKERSSGIXPROC glGenAsyncMarkersSGIX; +extern PFNGLDELETEASYNCMARKERSSGIXPROC glDeleteAsyncMarkersSGIX; +extern PFNGLISASYNCMARKERSGIXPROC glIsAsyncMarkerSGIX; +#endif + +#if defined(GL_SGIX_async_pixel) +#endif + +#if defined(GL_SGIX_async_histogram) +#endif + +#if defined(GL_INTEL_parallel_arrays) +extern PFNGLVERTEXPOINTERVINTELPROC glVertexPointervINTEL; +extern PFNGLNORMALPOINTERVINTELPROC glNormalPointervINTEL; +extern PFNGLCOLORPOINTERVINTELPROC glColorPointervINTEL; +extern PFNGLTEXCOORDPOINTERVINTELPROC glTexCoordPointervINTEL; +#endif + +#if defined(GL_HP_occlusion_test) +#endif + +#if defined(GL_EXT_pixel_transform) +extern PFNGLPIXELTRANSFORMPARAMETERIEXTPROC glPixelTransformParameteriEXT; +extern PFNGLPIXELTRANSFORMPARAMETERFEXTPROC glPixelTransformParameterfEXT; +extern PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC glPixelTransformParameterivEXT; +extern PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC glPixelTransformParameterfvEXT; +#endif + +#if defined(GL_EXT_pixel_transform_color_table) +#endif + +#if defined(GL_EXT_shared_texture_palette) +#endif + +#if defined(GL_EXT_separate_specular_color) +#endif + +#if defined(GL_EXT_secondary_color) +extern PFNGLSECONDARYCOLOR3BEXTPROC glSecondaryColor3bEXT; +extern PFNGLSECONDARYCOLOR3BVEXTPROC glSecondaryColor3bvEXT; +extern PFNGLSECONDARYCOLOR3DEXTPROC glSecondaryColor3dEXT; +extern PFNGLSECONDARYCOLOR3DVEXTPROC glSecondaryColor3dvEXT; +extern PFNGLSECONDARYCOLOR3FEXTPROC glSecondaryColor3fEXT; +extern PFNGLSECONDARYCOLOR3FVEXTPROC glSecondaryColor3fvEXT; +extern PFNGLSECONDARYCOLOR3IEXTPROC glSecondaryColor3iEXT; +extern PFNGLSECONDARYCOLOR3IVEXTPROC glSecondaryColor3ivEXT; +extern PFNGLSECONDARYCOLOR3SEXTPROC glSecondaryColor3sEXT; +extern PFNGLSECONDARYCOLOR3SVEXTPROC glSecondaryColor3svEXT; +extern PFNGLSECONDARYCOLOR3UBEXTPROC glSecondaryColor3ubEXT; +extern PFNGLSECONDARYCOLOR3UBVEXTPROC glSecondaryColor3ubvEXT; +extern PFNGLSECONDARYCOLOR3UIEXTPROC glSecondaryColor3uiEXT; +extern PFNGLSECONDARYCOLOR3UIVEXTPROC glSecondaryColor3uivEXT; +extern PFNGLSECONDARYCOLOR3USEXTPROC glSecondaryColor3usEXT; +extern PFNGLSECONDARYCOLOR3USVEXTPROC glSecondaryColor3usvEXT; +extern PFNGLSECONDARYCOLORPOINTEREXTPROC glSecondaryColorPointerEXT; +#endif + +#if defined(GL_EXT_texture_perturb_normal) +extern PFNGLTEXTURENORMALEXTPROC glTextureNormalEXT; +#endif + +#if defined(GL_EXT_multi_draw_arrays) +extern PFNGLMULTIDRAWARRAYSEXTPROC glMultiDrawArraysEXT; +extern PFNGLMULTIDRAWELEMENTSEXTPROC glMultiDrawElementsEXT; +#endif + +#if defined(GL_EXT_fog_coord) +extern PFNGLFOGCOORDFEXTPROC glFogCoordfEXT; +extern PFNGLFOGCOORDFVEXTPROC glFogCoordfvEXT; +extern PFNGLFOGCOORDDEXTPROC glFogCoorddEXT; +extern PFNGLFOGCOORDDVEXTPROC glFogCoorddvEXT; +extern PFNGLFOGCOORDPOINTEREXTPROC glFogCoordPointerEXT; +#endif + +#if defined(GL_REND_screen_coordinates) +#endif + +#if defined(GL_EXT_coordinate_frame) +extern PFNGLTANGENT3BEXTPROC glTangent3bEXT; +extern PFNGLTANGENT3BVEXTPROC glTangent3bvEXT; +extern PFNGLTANGENT3DEXTPROC glTangent3dEXT; +extern PFNGLTANGENT3DVEXTPROC glTangent3dvEXT; +extern PFNGLTANGENT3FEXTPROC glTangent3fEXT; +extern PFNGLTANGENT3FVEXTPROC glTangent3fvEXT; +extern PFNGLTANGENT3IEXTPROC glTangent3iEXT; +extern PFNGLTANGENT3IVEXTPROC glTangent3ivEXT; +extern PFNGLTANGENT3SEXTPROC glTangent3sEXT; +extern PFNGLTANGENT3SVEXTPROC glTangent3svEXT; +extern PFNGLBINORMAL3BEXTPROC glBinormal3bEXT; +extern PFNGLBINORMAL3BVEXTPROC glBinormal3bvEXT; +extern PFNGLBINORMAL3DEXTPROC glBinormal3dEXT; +extern PFNGLBINORMAL3DVEXTPROC glBinormal3dvEXT; +extern PFNGLBINORMAL3FEXTPROC glBinormal3fEXT; +extern PFNGLBINORMAL3FVEXTPROC glBinormal3fvEXT; +extern PFNGLBINORMAL3IEXTPROC glBinormal3iEXT; +extern PFNGLBINORMAL3IVEXTPROC glBinormal3ivEXT; +extern PFNGLBINORMAL3SEXTPROC glBinormal3sEXT; +extern PFNGLBINORMAL3SVEXTPROC glBinormal3svEXT; +extern PFNGLTANGENTPOINTEREXTPROC glTangentPointerEXT; +extern PFNGLBINORMALPOINTEREXTPROC glBinormalPointerEXT; +#endif + +#if defined(GL_EXT_texture_env_combine) +#endif + +#if defined(GL_APPLE_specular_vector) +#endif + +#if defined(GL_APPLE_transform_hint) +#endif + +#if defined(GL_SUNX_constant_data) +extern PFNGLFINISHTEXTURESUNXPROC glFinishTextureSUNX; +#endif + +#if defined(GL_SUN_global_alpha) +extern PFNGLGLOBALALPHAFACTORBSUNPROC glGlobalAlphaFactorbSUN; +extern PFNGLGLOBALALPHAFACTORSSUNPROC glGlobalAlphaFactorsSUN; +extern PFNGLGLOBALALPHAFACTORISUNPROC glGlobalAlphaFactoriSUN; +extern PFNGLGLOBALALPHAFACTORFSUNPROC glGlobalAlphaFactorfSUN; +extern PFNGLGLOBALALPHAFACTORDSUNPROC glGlobalAlphaFactordSUN; +extern PFNGLGLOBALALPHAFACTORUBSUNPROC glGlobalAlphaFactorubSUN; +extern PFNGLGLOBALALPHAFACTORUSSUNPROC glGlobalAlphaFactorusSUN; +extern PFNGLGLOBALALPHAFACTORUISUNPROC glGlobalAlphaFactoruiSUN; +#endif + +#if defined(GL_SUN_triangle_list) +extern PFNGLREPLACEMENTCODEUISUNPROC glReplacementCodeuiSUN; +extern PFNGLREPLACEMENTCODEUSSUNPROC glReplacementCodeusSUN; +extern PFNGLREPLACEMENTCODEUBSUNPROC glReplacementCodeubSUN; +extern PFNGLREPLACEMENTCODEUIVSUNPROC glReplacementCodeuivSUN; +extern PFNGLREPLACEMENTCODEUSVSUNPROC glReplacementCodeusvSUN; +extern PFNGLREPLACEMENTCODEUBVSUNPROC glReplacementCodeubvSUN; +extern PFNGLREPLACEMENTCODEPOINTERSUNPROC glReplacementCodePointerSUN; +#endif + +#if defined(GL_SUN_vertex) +extern PFNGLCOLOR4UBVERTEX2FSUNPROC glColor4ubVertex2fSUN; +extern PFNGLCOLOR4UBVERTEX2FVSUNPROC glColor4ubVertex2fvSUN; +extern PFNGLCOLOR4UBVERTEX3FSUNPROC glColor4ubVertex3fSUN; +extern PFNGLCOLOR4UBVERTEX3FVSUNPROC glColor4ubVertex3fvSUN; +extern PFNGLCOLOR3FVERTEX3FSUNPROC glColor3fVertex3fSUN; +extern PFNGLCOLOR3FVERTEX3FVSUNPROC glColor3fVertex3fvSUN; +extern PFNGLNORMAL3FVERTEX3FSUNPROC glNormal3fVertex3fSUN; +extern PFNGLNORMAL3FVERTEX3FVSUNPROC glNormal3fVertex3fvSUN; +extern PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC glColor4fNormal3fVertex3fSUN; +extern PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC glColor4fNormal3fVertex3fvSUN; +extern PFNGLTEXCOORD2FVERTEX3FSUNPROC glTexCoord2fVertex3fSUN; +extern PFNGLTEXCOORD2FVERTEX3FVSUNPROC glTexCoord2fVertex3fvSUN; +extern PFNGLTEXCOORD4FVERTEX4FSUNPROC glTexCoord4fVertex4fSUN; +extern PFNGLTEXCOORD4FVERTEX4FVSUNPROC glTexCoord4fVertex4fvSUN; +extern PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC glTexCoord2fColor4ubVertex3fSUN; +extern PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC glTexCoord2fColor4ubVertex3fvSUN; +extern PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC glTexCoord2fColor3fVertex3fSUN; +extern PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC glTexCoord2fColor3fVertex3fvSUN; +extern PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC glTexCoord2fNormal3fVertex3fSUN; +extern PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC glTexCoord2fNormal3fVertex3fvSUN; +extern PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC glTexCoord2fColor4fNormal3fVertex3fSUN; +extern PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC glTexCoord2fColor4fNormal3fVertex3fvSUN; +extern PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC glTexCoord4fColor4fNormal3fVertex4fSUN; +extern PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC glTexCoord4fColor4fNormal3fVertex4fvSUN; +extern PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC glReplacementCodeuiVertex3fSUN; +extern PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC glReplacementCodeuiVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC glReplacementCodeuiColor4ubVertex3fSUN; +extern PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC glReplacementCodeuiColor4ubVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC glReplacementCodeuiColor3fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC glReplacementCodeuiColor3fVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC glReplacementCodeuiNormal3fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiNormal3fVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiColor4fNormal3fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiColor4fNormal3fVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; +#endif + +#if defined(GL_EXT_blend_func_separate) +extern PFNGLBLENDFUNCSEPARATEEXTPROC glBlendFuncSeparateEXT; +#endif + +#if defined(GL_INGR_color_clamp) +#endif + +#if defined(GL_INGR_interlace_read) +#endif + +#if defined(GL_EXT_stencil_wrap) +#endif + +#if defined(GL_EXT_422_pixels) +#endif + +#if defined(GL_NV_texgen_reflection) +#endif + +#if defined(GL_SUN_convolution_border_modes) +#endif + +#if defined(GL_EXT_texture_env_add) +#endif + +#if defined(GL_EXT_texture_lod_bias) +#endif + +#if defined(GL_EXT_texture_filter_anisotropic) +#endif + +#if defined(GL_EXT_vertex_weighting) +extern PFNGLVERTEXWEIGHTFEXTPROC glVertexWeightfEXT; +extern PFNGLVERTEXWEIGHTFVEXTPROC glVertexWeightfvEXT; +extern PFNGLVERTEXWEIGHTPOINTEREXTPROC glVertexWeightPointerEXT; +#endif + +#if defined(GL_NV_light_max_exponent) +#endif + +#if defined(GL_NV_vertex_array_range) +extern PFNGLFLUSHVERTEXARRAYRANGENVPROC glFlushVertexArrayRangeNV; +extern PFNGLVERTEXARRAYRANGENVPROC glVertexArrayRangeNV; +#endif + +#if defined(GL_NV_register_combiners) +extern PFNGLCOMBINERPARAMETERFVNVPROC glCombinerParameterfvNV; +extern PFNGLCOMBINERPARAMETERFNVPROC glCombinerParameterfNV; +extern PFNGLCOMBINERPARAMETERIVNVPROC glCombinerParameterivNV; +extern PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV; +extern PFNGLCOMBINERINPUTNVPROC glCombinerInputNV; +extern PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV; +extern PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV; +extern PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV; +extern PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV; +extern PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV; +extern PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV; +extern PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfvNV; +extern PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameterivNV; +#endif + +#if defined(GL_NV_fog_distance) +#endif + +#if defined(GL_NV_texgen_emboss) +#endif + +#if defined(GL_NV_blend_square) +#endif + +#if defined(GL_NV_texture_env_combine4) +#endif + +#if defined(GL_MESA_resize_buffers) +extern PFNGLRESIZEBUFFERSMESAPROC glResizeBuffersMESA; +#endif + +#if defined(GL_MESA_window_pos) +extern PFNGLWINDOWPOS2DMESAPROC glWindowPos2dMESA; +extern PFNGLWINDOWPOS2DVMESAPROC glWindowPos2dvMESA; +extern PFNGLWINDOWPOS2FMESAPROC glWindowPos2fMESA; +extern PFNGLWINDOWPOS2FVMESAPROC glWindowPos2fvMESA; +extern PFNGLWINDOWPOS2IMESAPROC glWindowPos2iMESA; +extern PFNGLWINDOWPOS2IVMESAPROC glWindowPos2ivMESA; +extern PFNGLWINDOWPOS2SMESAPROC glWindowPos2sMESA; +extern PFNGLWINDOWPOS2SVMESAPROC glWindowPos2svMESA; +extern PFNGLWINDOWPOS3DMESAPROC glWindowPos3dMESA; +extern PFNGLWINDOWPOS3DVMESAPROC glWindowPos3dvMESA; +extern PFNGLWINDOWPOS3FMESAPROC glWindowPos3fMESA; +extern PFNGLWINDOWPOS3FVMESAPROC glWindowPos3fvMESA; +extern PFNGLWINDOWPOS3IMESAPROC glWindowPos3iMESA; +extern PFNGLWINDOWPOS3IVMESAPROC glWindowPos3ivMESA; +extern PFNGLWINDOWPOS3SMESAPROC glWindowPos3sMESA; +extern PFNGLWINDOWPOS3SVMESAPROC glWindowPos3svMESA; +extern PFNGLWINDOWPOS4DMESAPROC glWindowPos4dMESA; +extern PFNGLWINDOWPOS4DVMESAPROC glWindowPos4dvMESA; +extern PFNGLWINDOWPOS4FMESAPROC glWindowPos4fMESA; +extern PFNGLWINDOWPOS4FVMESAPROC glWindowPos4fvMESA; +extern PFNGLWINDOWPOS4IMESAPROC glWindowPos4iMESA; +extern PFNGLWINDOWPOS4IVMESAPROC glWindowPos4ivMESA; +extern PFNGLWINDOWPOS4SMESAPROC glWindowPos4sMESA; +extern PFNGLWINDOWPOS4SVMESAPROC glWindowPos4svMESA; +#endif + +#if defined(GL_IBM_cull_vertex) +#endif + +#if defined(GL_IBM_multimode_draw_arrays) +extern PFNGLMULTIMODEDRAWARRAYSIBMPROC glMultiModeDrawArraysIBM; +extern PFNGLMULTIMODEDRAWELEMENTSIBMPROC glMultiModeDrawElementsIBM; +#endif + +#if defined(GL_IBM_vertex_array_lists) +extern PFNGLCOLORPOINTERLISTIBMPROC glColorPointerListIBM; +extern PFNGLSECONDARYCOLORPOINTERLISTIBMPROC glSecondaryColorPointerListIBM; +extern PFNGLEDGEFLAGPOINTERLISTIBMPROC glEdgeFlagPointerListIBM; +extern PFNGLFOGCOORDPOINTERLISTIBMPROC glFogCoordPointerListIBM; +extern PFNGLINDEXPOINTERLISTIBMPROC glIndexPointerListIBM; +extern PFNGLNORMALPOINTERLISTIBMPROC glNormalPointerListIBM; +extern PFNGLTEXCOORDPOINTERLISTIBMPROC glTexCoordPointerListIBM; +extern PFNGLVERTEXPOINTERLISTIBMPROC glVertexPointerListIBM; +#endif + +#if defined(GL_3DFX_texture_compression_FXT1) +#endif + +#if defined(GL_3DFX_multisample) +#endif + +#if defined(GL_3DFX_tbuffer) +extern PFNGLTBUFFERMASK3DFXPROC glTbufferMask3DFX; +#endif + +#if defined(GL_SGIX_vertex_preclip) +#endif + +#if defined(GL_SGIX_resample) +#endif + +#if defined(GL_SGIS_texture_color_mask) +extern PFNGLTEXTURECOLORMASKSGISPROC glTextureColorMaskSGIS; +#endif + +#if defined(GL_EXT_texture_env_dot3) +#endif + +#if defined(GL_ATI_texture_mirror_once) +#endif + +#if defined(GL_NV_fence) +extern PFNGLDELETEFENCESNVPROC glDeleteFencesNV; +extern PFNGLGENFENCESNVPROC glGenFencesNV; +extern PFNGLISFENCENVPROC glIsFenceNV; +extern PFNGLTESTFENCENVPROC glTestFenceNV; +extern PFNGLGETFENCEIVNVPROC glGetFenceivNV; +extern PFNGLFINISHFENCENVPROC glFinishFenceNV; +extern PFNGLSETFENCENVPROC glSetFenceNV; +#endif + +#if defined(GL_NV_evaluators) +extern PFNGLMAPCONTROLPOINTSNVPROC glMapControlPointsNV; +extern PFNGLMAPPARAMETERIVNVPROC glMapParameterivNV; +extern PFNGLMAPPARAMETERFVNVPROC glMapParameterfvNV; +extern PFNGLGETMAPCONTROLPOINTSNVPROC glGetMapControlPointsNV; +extern PFNGLGETMAPPARAMETERIVNVPROC glGetMapParameterivNV; +extern PFNGLGETMAPPARAMETERFVNVPROC glGetMapParameterfvNV; +extern PFNGLGETMAPATTRIBPARAMETERIVNVPROC glGetMapAttribParameterivNV; +extern PFNGLGETMAPATTRIBPARAMETERFVNVPROC glGetMapAttribParameterfvNV; +extern PFNGLEVALMAPSNVPROC glEvalMapsNV; +#endif + +#if defined(GL_NV_packed_depth_stencil) +#endif + +#if defined(GL_NV_register_combiners2) +extern PFNGLCOMBINERSTAGEPARAMETERFVNVPROC glCombinerStageParameterfvNV; +extern PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC glGetCombinerStageParameterfvNV; +#endif + +#if defined(GL_NV_texture_compression_vtc) +#endif + +#if defined(GL_NV_texture_rectangle) +#endif + +#if defined(GL_NV_texture_shader) +#endif + +#if defined(GL_NV_texture_shader2) +#endif + +#if defined(GL_NV_vertex_array_range2) +#endif + +#if defined(GL_NV_vertex_program) +extern PFNGLAREPROGRAMSRESIDENTNVPROC glAreProgramsResidentNV; +extern PFNGLBINDPROGRAMNVPROC glBindProgramNV; +extern PFNGLDELETEPROGRAMSNVPROC glDeleteProgramsNV; +extern PFNGLEXECUTEPROGRAMNVPROC glExecuteProgramNV; +extern PFNGLGENPROGRAMSNVPROC glGenProgramsNV; +extern PFNGLGETPROGRAMPARAMETERDVNVPROC glGetProgramParameterdvNV; +extern PFNGLGETPROGRAMPARAMETERFVNVPROC glGetProgramParameterfvNV; +extern PFNGLGETPROGRAMIVNVPROC glGetProgramivNV; +extern PFNGLGETPROGRAMSTRINGNVPROC glGetProgramStringNV; +extern PFNGLGETTRACKMATRIXIVNVPROC glGetTrackMatrixivNV; +extern PFNGLGETVERTEXATTRIBDVNVPROC glGetVertexAttribdvNV; +extern PFNGLGETVERTEXATTRIBFVNVPROC glGetVertexAttribfvNV; +extern PFNGLGETVERTEXATTRIBIVNVPROC glGetVertexAttribivNV; +extern PFNGLGETVERTEXATTRIBPOINTERVNVPROC glGetVertexAttribPointervNV; +extern PFNGLISPROGRAMNVPROC glIsProgramNV; +extern PFNGLLOADPROGRAMNVPROC glLoadProgramNV; +extern PFNGLPROGRAMPARAMETER4DNVPROC glProgramParameter4dNV; +extern PFNGLPROGRAMPARAMETER4DVNVPROC glProgramParameter4dvNV; +extern PFNGLPROGRAMPARAMETER4FNVPROC glProgramParameter4fNV; +extern PFNGLPROGRAMPARAMETER4FVNVPROC glProgramParameter4fvNV; +extern PFNGLPROGRAMPARAMETERS4DVNVPROC glProgramParameters4dvNV; +extern PFNGLPROGRAMPARAMETERS4FVNVPROC glProgramParameters4fvNV; +extern PFNGLREQUESTRESIDENTPROGRAMSNVPROC glRequestResidentProgramsNV; +extern PFNGLTRACKMATRIXNVPROC glTrackMatrixNV; +extern PFNGLVERTEXATTRIBPOINTERNVPROC glVertexAttribPointerNV; +extern PFNGLVERTEXATTRIB1DNVPROC glVertexAttrib1dNV; +extern PFNGLVERTEXATTRIB1DVNVPROC glVertexAttrib1dvNV; +extern PFNGLVERTEXATTRIB1FNVPROC glVertexAttrib1fNV; +extern PFNGLVERTEXATTRIB1FVNVPROC glVertexAttrib1fvNV; +extern PFNGLVERTEXATTRIB1SNVPROC glVertexAttrib1sNV; +extern PFNGLVERTEXATTRIB1SVNVPROC glVertexAttrib1svNV; +extern PFNGLVERTEXATTRIB2DNVPROC glVertexAttrib2dNV; +extern PFNGLVERTEXATTRIB2DVNVPROC glVertexAttrib2dvNV; +extern PFNGLVERTEXATTRIB2FNVPROC glVertexAttrib2fNV; +extern PFNGLVERTEXATTRIB2FVNVPROC glVertexAttrib2fvNV; +extern PFNGLVERTEXATTRIB2SNVPROC glVertexAttrib2sNV; +extern PFNGLVERTEXATTRIB2SVNVPROC glVertexAttrib2svNV; +extern PFNGLVERTEXATTRIB3DNVPROC glVertexAttrib3dNV; +extern PFNGLVERTEXATTRIB3DVNVPROC glVertexAttrib3dvNV; +extern PFNGLVERTEXATTRIB3FNVPROC glVertexAttrib3fNV; +extern PFNGLVERTEXATTRIB3FVNVPROC glVertexAttrib3fvNV; +extern PFNGLVERTEXATTRIB3SNVPROC glVertexAttrib3sNV; +extern PFNGLVERTEXATTRIB3SVNVPROC glVertexAttrib3svNV; +extern PFNGLVERTEXATTRIB4DNVPROC glVertexAttrib4dNV; +extern PFNGLVERTEXATTRIB4DVNVPROC glVertexAttrib4dvNV; +extern PFNGLVERTEXATTRIB4FNVPROC glVertexAttrib4fNV; +extern PFNGLVERTEXATTRIB4FVNVPROC glVertexAttrib4fvNV; +extern PFNGLVERTEXATTRIB4SNVPROC glVertexAttrib4sNV; +extern PFNGLVERTEXATTRIB4SVNVPROC glVertexAttrib4svNV; +extern PFNGLVERTEXATTRIB4UBNVPROC glVertexAttrib4ubNV; +extern PFNGLVERTEXATTRIB4UBVNVPROC glVertexAttrib4ubvNV; +extern PFNGLVERTEXATTRIBS1DVNVPROC glVertexAttribs1dvNV; +extern PFNGLVERTEXATTRIBS1FVNVPROC glVertexAttribs1fvNV; +extern PFNGLVERTEXATTRIBS1SVNVPROC glVertexAttribs1svNV; +extern PFNGLVERTEXATTRIBS2DVNVPROC glVertexAttribs2dvNV; +extern PFNGLVERTEXATTRIBS2FVNVPROC glVertexAttribs2fvNV; +extern PFNGLVERTEXATTRIBS2SVNVPROC glVertexAttribs2svNV; +extern PFNGLVERTEXATTRIBS3DVNVPROC glVertexAttribs3dvNV; +extern PFNGLVERTEXATTRIBS3FVNVPROC glVertexAttribs3fvNV; +extern PFNGLVERTEXATTRIBS3SVNVPROC glVertexAttribs3svNV; +extern PFNGLVERTEXATTRIBS4DVNVPROC glVertexAttribs4dvNV; +extern PFNGLVERTEXATTRIBS4FVNVPROC glVertexAttribs4fvNV; +extern PFNGLVERTEXATTRIBS4SVNVPROC glVertexAttribs4svNV; +extern PFNGLVERTEXATTRIBS4UBVNVPROC glVertexAttribs4ubvNV; +#endif + +#if defined(GL_SGIX_texture_coordinate_clamp) +#endif + +#if defined(GL_OML_interlace) +#endif + +#if defined(GL_OML_subsample) +#endif + +#if defined(GL_OML_resample) +#endif + +#if defined(GL_NV_copy_depth_to_color) +#endif + +#if defined(GL_ATI_envmap_bumpmap) +extern PFNGLTEXBUMPPARAMETERIVATIPROC glTexBumpParameterivATI; +extern PFNGLTEXBUMPPARAMETERFVATIPROC glTexBumpParameterfvATI; +extern PFNGLGETTEXBUMPPARAMETERIVATIPROC glGetTexBumpParameterivATI; +extern PFNGLGETTEXBUMPPARAMETERFVATIPROC glGetTexBumpParameterfvATI; +#endif + +#if defined(GL_ATI_fragment_shader) +extern PFNGLGENFRAGMENTSHADERSATIPROC glGenFragmentShadersATI; +extern PFNGLBINDFRAGMENTSHADERATIPROC glBindFragmentShaderATI; +extern PFNGLDELETEFRAGMENTSHADERATIPROC glDeleteFragmentShaderATI; +extern PFNGLBEGINFRAGMENTSHADERATIPROC glBeginFragmentShaderATI; +extern PFNGLENDFRAGMENTSHADERATIPROC glEndFragmentShaderATI; +extern PFNGLPASSTEXCOORDATIPROC glPassTexCoordATI; +extern PFNGLSAMPLEMAPATIPROC glSampleMapATI; +extern PFNGLCOLORFRAGMENTOP1ATIPROC glColorFragmentOp1ATI; +extern PFNGLCOLORFRAGMENTOP2ATIPROC glColorFragmentOp2ATI; +extern PFNGLCOLORFRAGMENTOP3ATIPROC glColorFragmentOp3ATI; +extern PFNGLALPHAFRAGMENTOP1ATIPROC glAlphaFragmentOp1ATI; +extern PFNGLALPHAFRAGMENTOP2ATIPROC glAlphaFragmentOp2ATI; +extern PFNGLALPHAFRAGMENTOP3ATIPROC glAlphaFragmentOp3ATI; +extern PFNGLSETFRAGMENTSHADERCONSTANTATIPROC glSetFragmentShaderConstantATI; +#endif + +#if defined(GL_ATI_pn_triangles) +#endif + +#if defined(GL_ATI_vertex_array_object) && 0 +extern PFNGLNEWOBJECTBUFFERATIPROC glNewObjectBufferATI; +extern PFNGLISOBJECTBUFFERATIPROC glIsObjectBufferATI; +extern PFNGLUPDATEOBJECTBUFFERATIPROC glUpdateObjectBufferATI; +extern PFNGLGETOBJECTBUFFERFVATIPROC glGetObjectBufferfvATI; +extern PFNGLGETOBJECTBUFFERIVATIPROC glGetObjectBufferivATI; +extern PFNGLFREEOBJECTBUFFERATIPROC glFreeObjectBufferATI; +extern PFNGLARRAYOBJECTATIPROC glArrayObjectATI; +extern PFNGLGETARRAYOBJECTFVATIPROC glGetArrayObjectfvATI; +extern PFNGLGETARRAYOBJECTIVATIPROC glGetArrayObjectivATI; +extern PFNGLVARIANTARRAYOBJECTATIPROC glVariantArrayObjectATI; +extern PFNGLGETVARIANTARRAYOBJECTFVATIPROC glGetVariantArrayObjectfvATI; +extern PFNGLGETVARIANTARRAYOBJECTIVATIPROC glGetVariantArrayObjectivATI; +#endif + +#if defined(GL_EXT_vertex_shader) +extern PFNGLBEGINVERTEXSHADEREXTPROC glBeginVertexShaderEXT; +extern PFNGLENDVERTEXSHADEREXTPROC glEndVertexShaderEXT; +extern PFNGLBINDVERTEXSHADEREXTPROC glBindVertexShaderEXT; +extern PFNGLGENVERTEXSHADERSEXTPROC glGenVertexShadersEXT; +extern PFNGLDELETEVERTEXSHADEREXTPROC glDeleteVertexShaderEXT; +extern PFNGLSHADEROP1EXTPROC glShaderOp1EXT; +extern PFNGLSHADEROP2EXTPROC glShaderOp2EXT; +extern PFNGLSHADEROP3EXTPROC glShaderOp3EXT; +extern PFNGLSWIZZLEEXTPROC glSwizzleEXT; +extern PFNGLWRITEMASKEXTPROC glWriteMaskEXT; +extern PFNGLINSERTCOMPONENTEXTPROC glInsertComponentEXT; +extern PFNGLEXTRACTCOMPONENTEXTPROC glExtractComponentEXT; +extern PFNGLGENSYMBOLSEXTPROC glGenSymbolsEXT; +extern PFNGLSETINVARIANTEXTPROC glSetInvariantEXT; +extern PFNGLSETLOCALCONSTANTEXTPROC glSetLocalConstantEXT; +extern PFNGLVARIANTBVEXTPROC glVariantbvEXT; +extern PFNGLVARIANTSVEXTPROC glVariantsvEXT; +extern PFNGLVARIANTIVEXTPROC glVariantivEXT; +extern PFNGLVARIANTFVEXTPROC glVariantfvEXT; +extern PFNGLVARIANTDVEXTPROC glVariantdvEXT; +extern PFNGLVARIANTUBVEXTPROC glVariantubvEXT; +extern PFNGLVARIANTUSVEXTPROC glVariantusvEXT; +extern PFNGLVARIANTUIVEXTPROC glVariantuivEXT; +extern PFNGLVARIANTPOINTEREXTPROC glVariantPointerEXT; +extern PFNGLENABLEVARIANTCLIENTSTATEEXTPROC glEnableVariantClientStateEXT; +extern PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC glDisableVariantClientStateEXT; +extern PFNGLBINDLIGHTPARAMETEREXTPROC glBindLightParameterEXT; +extern PFNGLBINDMATERIALPARAMETEREXTPROC glBindMaterialParameterEXT; +extern PFNGLBINDTEXGENPARAMETEREXTPROC glBindTexGenParameterEXT; +extern PFNGLBINDTEXTUREUNITPARAMETEREXTPROC glBindTextureUnitParameterEXT; +extern PFNGLBINDPARAMETEREXTPROC glBindParameterEXT; +extern PFNGLISVARIANTENABLEDEXTPROC glIsVariantEnabledEXT; +extern PFNGLGETVARIANTBOOLEANVEXTPROC glGetVariantBooleanvEXT; +extern PFNGLGETVARIANTINTEGERVEXTPROC glGetVariantIntegervEXT; +extern PFNGLGETVARIANTFLOATVEXTPROC glGetVariantFloatvEXT; +extern PFNGLGETVARIANTPOINTERVEXTPROC glGetVariantPointervEXT; +extern PFNGLGETINVARIANTBOOLEANVEXTPROC glGetInvariantBooleanvEXT; +extern PFNGLGETINVARIANTINTEGERVEXTPROC glGetInvariantIntegervEXT; +extern PFNGLGETINVARIANTFLOATVEXTPROC glGetInvariantFloatvEXT; +extern PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC glGetLocalConstantBooleanvEXT; +extern PFNGLGETLOCALCONSTANTINTEGERVEXTPROC glGetLocalConstantIntegervEXT; +extern PFNGLGETLOCALCONSTANTFLOATVEXTPROC glGetLocalConstantFloatvEXT; +#endif + +#if defined(GL_ATI_vertex_streams) +extern PFNGLVERTEXSTREAM1SATIPROC glVertexStream1sATI; +extern PFNGLVERTEXSTREAM1SVATIPROC glVertexStream1svATI; +extern PFNGLVERTEXSTREAM1IATIPROC glVertexStream1iATI; +extern PFNGLVERTEXSTREAM1IVATIPROC glVertexStream1ivATI; +extern PFNGLVERTEXSTREAM1FATIPROC glVertexStream1fATI; +extern PFNGLVERTEXSTREAM1FVATIPROC glVertexStream1fvATI; +extern PFNGLVERTEXSTREAM1DATIPROC glVertexStream1dATI; +extern PFNGLVERTEXSTREAM1DVATIPROC glVertexStream1dvATI; +extern PFNGLVERTEXSTREAM2SATIPROC glVertexStream2sATI; +extern PFNGLVERTEXSTREAM2SVATIPROC glVertexStream2svATI; +extern PFNGLVERTEXSTREAM2IATIPROC glVertexStream2iATI; +extern PFNGLVERTEXSTREAM2IVATIPROC glVertexStream2ivATI; +extern PFNGLVERTEXSTREAM2FATIPROC glVertexStream2fATI; +extern PFNGLVERTEXSTREAM2FVATIPROC glVertexStream2fvATI; +extern PFNGLVERTEXSTREAM2DATIPROC glVertexStream2dATI; +extern PFNGLVERTEXSTREAM2DVATIPROC glVertexStream2dvATI; +extern PFNGLVERTEXSTREAM3SATIPROC glVertexStream3sATI; +extern PFNGLVERTEXSTREAM3SVATIPROC glVertexStream3svATI; +extern PFNGLVERTEXSTREAM3IATIPROC glVertexStream3iATI; +extern PFNGLVERTEXSTREAM3IVATIPROC glVertexStream3ivATI; +extern PFNGLVERTEXSTREAM3FATIPROC glVertexStream3fATI; +extern PFNGLVERTEXSTREAM3FVATIPROC glVertexStream3fvATI; +extern PFNGLVERTEXSTREAM3DATIPROC glVertexStream3dATI; +extern PFNGLVERTEXSTREAM3DVATIPROC glVertexStream3dvATI; +extern PFNGLVERTEXSTREAM4SATIPROC glVertexStream4sATI; +extern PFNGLVERTEXSTREAM4SVATIPROC glVertexStream4svATI; +extern PFNGLVERTEXSTREAM4IATIPROC glVertexStream4iATI; +extern PFNGLVERTEXSTREAM4IVATIPROC glVertexStream4ivATI; +extern PFNGLVERTEXSTREAM4FATIPROC glVertexStream4fATI; +extern PFNGLVERTEXSTREAM4FVATIPROC glVertexStream4fvATI; +extern PFNGLVERTEXSTREAM4DATIPROC glVertexStream4dATI; +extern PFNGLVERTEXSTREAM4DVATIPROC glVertexStream4dvATI; +extern PFNGLNORMALSTREAM3BATIPROC glNormalStream3bATI; +extern PFNGLNORMALSTREAM3BVATIPROC glNormalStream3bvATI; +extern PFNGLNORMALSTREAM3SATIPROC glNormalStream3sATI; +extern PFNGLNORMALSTREAM3SVATIPROC glNormalStream3svATI; +extern PFNGLNORMALSTREAM3IATIPROC glNormalStream3iATI; +extern PFNGLNORMALSTREAM3IVATIPROC glNormalStream3ivATI; +extern PFNGLNORMALSTREAM3FATIPROC glNormalStream3fATI; +extern PFNGLNORMALSTREAM3FVATIPROC glNormalStream3fvATI; +extern PFNGLNORMALSTREAM3DATIPROC glNormalStream3dATI; +extern PFNGLNORMALSTREAM3DVATIPROC glNormalStream3dvATI; +extern PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC glClientActiveVertexStreamATI; +extern PFNGLVERTEXBLENDENVIATIPROC glVertexBlendEnviATI; +extern PFNGLVERTEXBLENDENVFATIPROC glVertexBlendEnvfATI; +#endif + +#if defined(GL_ATI_element_array) +extern PFNGLELEMENTPOINTERATIPROC glElementPointerATI; +extern PFNGLDRAWELEMENTARRAYATIPROC glDrawElementArrayATI; +extern PFNGLDRAWRANGEELEMENTARRAYATIPROC glDrawRangeElementArrayATI; +#endif + +#if defined(GL_SUN_mesh_array) +extern PFNGLDRAWMESHARRAYSSUNPROC glDrawMeshArraysSUN; +#endif + +#if defined(GL_SUN_slice_accum) +#endif + +#if defined(GL_NV_multisample_filter_hint) +#endif + +#if defined(GL_NV_depth_clamp) +#endif + +#if defined(GL_NV_occlusion_query) +extern PFNGLGENOCCLUSIONQUERIESNVPROC glGenOcclusionQueriesNV; +extern PFNGLDELETEOCCLUSIONQUERIESNVPROC glDeleteOcclusionQueriesNV; +extern PFNGLISOCCLUSIONQUERYNVPROC glIsOcclusionQueryNV; +extern PFNGLBEGINOCCLUSIONQUERYNVPROC glBeginOcclusionQueryNV; +extern PFNGLENDOCCLUSIONQUERYNVPROC glEndOcclusionQueryNV; +extern PFNGLGETOCCLUSIONQUERYIVNVPROC glGetOcclusionQueryivNV; +extern PFNGLGETOCCLUSIONQUERYUIVNVPROC glGetOcclusionQueryuivNV; +#endif + +#if defined(GL_NV_point_sprite) +extern PFNGLPOINTPARAMETERINVPROC glPointParameteriNV; +extern PFNGLPOINTPARAMETERIVNVPROC glPointParameterivNV; +#endif + +#if defined(GL_NV_texture_shader3) +#endif + +#if defined(GL_NV_vertex_program1_1) +#endif + +#if defined(GL_EXT_shadow_funcs) +#endif + +#if defined(GL_EXT_stencil_two_side) +extern PFNGLACTIVESTENCILFACEEXTPROC glActiveStencilFaceEXT; +#endif + +#if defined(GL_ATI_text_fragment_shader) +#endif + +#if defined(GL_APPLE_client_storage) +#endif + +#if defined(GL_APPLE_element_array) +extern PFNGLELEMENTPOINTERAPPLEPROC glElementPointerAPPLE; +extern PFNGLDRAWELEMENTARRAYAPPLEPROC glDrawElementArrayAPPLE; +extern PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC glDrawRangeElementArrayAPPLE; +extern PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC glMultiDrawElementArrayAPPLE; +extern PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC glMultiDrawRangeElementArrayAPPLE; +#endif + +#if defined(GL_APPLE_fence) +extern PFNGLGENFENCESAPPLEPROC glGenFencesAPPLE; +extern PFNGLDELETEFENCESAPPLEPROC glDeleteFencesAPPLE; +extern PFNGLSETFENCEAPPLEPROC glSetFenceAPPLE; +extern PFNGLISFENCEAPPLEPROC glIsFenceAPPLE; +extern PFNGLTESTFENCEAPPLEPROC glTestFenceAPPLE; +extern PFNGLFINISHFENCEAPPLEPROC glFinishFenceAPPLE; +extern PFNGLTESTOBJECTAPPLEPROC glTestObjectAPPLE; +extern PFNGLFINISHOBJECTAPPLEPROC glFinishObjectAPPLE; +#endif + +#if defined(GL_APPLE_vertex_array_object) +extern PFNGLBINDVERTEXARRAYAPPLEPROC glBindVertexArrayAPPLE; +extern PFNGLDELETEVERTEXARRAYSAPPLEPROC glDeleteVertexArraysAPPLE; +extern PFNGLGENVERTEXARRAYSAPPLEPROC glGenVertexArraysAPPLE; +extern PFNGLISVERTEXARRAYAPPLEPROC glIsVertexArrayAPPLE; +#endif + +#if defined(GL_APPLE_vertex_array_range) +extern PFNGLVERTEXARRAYRANGEAPPLEPROC glVertexArrayRangeAPPLE; +extern PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC glFlushVertexArrayRangeAPPLE; +extern PFNGLVERTEXARRAYPARAMETERIAPPLEPROC glVertexArrayParameteriAPPLE; +#endif + +#if defined(GL_APPLE_ycbcr_422) +#endif + +#if defined(GL_S3_s3tc) +#endif + +#if defined(GL_ATI_draw_buffers) +extern PFNGLDRAWBUFFERSATIPROC glDrawBuffersATI; +#endif + +#if defined(GL_ATI_texture_env_combine3) +#endif + +#if defined(GL_ATI_texture_float) +#endif + +#if defined(GL_NV_float_buffer) +#endif + +#if defined(GL_NV_fragment_program) +extern PFNGLPROGRAMNAMEDPARAMETER4FNVPROC glProgramNamedParameter4fNV; +extern PFNGLPROGRAMNAMEDPARAMETER4DNVPROC glProgramNamedParameter4dNV; +extern PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC glProgramNamedParameter4fvNV; +extern PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC glProgramNamedParameter4dvNV; +extern PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC glGetProgramNamedParameterfvNV; +extern PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC glGetProgramNamedParameterdvNV; +#endif + +#if defined(GL_NV_half_float) +extern PFNGLVERTEX2HNVPROC glVertex2hNV; +extern PFNGLVERTEX2HVNVPROC glVertex2hvNV; +extern PFNGLVERTEX3HNVPROC glVertex3hNV; +extern PFNGLVERTEX3HVNVPROC glVertex3hvNV; +extern PFNGLVERTEX4HNVPROC glVertex4hNV; +extern PFNGLVERTEX4HVNVPROC glVertex4hvNV; +extern PFNGLNORMAL3HNVPROC glNormal3hNV; +extern PFNGLNORMAL3HVNVPROC glNormal3hvNV; +extern PFNGLCOLOR3HNVPROC glColor3hNV; +extern PFNGLCOLOR3HVNVPROC glColor3hvNV; +extern PFNGLCOLOR4HNVPROC glColor4hNV; +extern PFNGLCOLOR4HVNVPROC glColor4hvNV; +extern PFNGLTEXCOORD1HNVPROC glTexCoord1hNV; +extern PFNGLTEXCOORD1HVNVPROC glTexCoord1hvNV; +extern PFNGLTEXCOORD2HNVPROC glTexCoord2hNV; +extern PFNGLTEXCOORD2HVNVPROC glTexCoord2hvNV; +extern PFNGLTEXCOORD3HNVPROC glTexCoord3hNV; +extern PFNGLTEXCOORD3HVNVPROC glTexCoord3hvNV; +extern PFNGLTEXCOORD4HNVPROC glTexCoord4hNV; +extern PFNGLTEXCOORD4HVNVPROC glTexCoord4hvNV; +extern PFNGLMULTITEXCOORD1HNVPROC glMultiTexCoord1hNV; +extern PFNGLMULTITEXCOORD1HVNVPROC glMultiTexCoord1hvNV; +extern PFNGLMULTITEXCOORD2HNVPROC glMultiTexCoord2hNV; +extern PFNGLMULTITEXCOORD2HVNVPROC glMultiTexCoord2hvNV; +extern PFNGLMULTITEXCOORD3HNVPROC glMultiTexCoord3hNV; +extern PFNGLMULTITEXCOORD3HVNVPROC glMultiTexCoord3hvNV; +extern PFNGLMULTITEXCOORD4HNVPROC glMultiTexCoord4hNV; +extern PFNGLMULTITEXCOORD4HVNVPROC glMultiTexCoord4hvNV; +extern PFNGLFOGCOORDHNVPROC glFogCoordhNV; +extern PFNGLFOGCOORDHVNVPROC glFogCoordhvNV; +extern PFNGLSECONDARYCOLOR3HNVPROC glSecondaryColor3hNV; +extern PFNGLSECONDARYCOLOR3HVNVPROC glSecondaryColor3hvNV; +extern PFNGLVERTEXWEIGHTHNVPROC glVertexWeighthNV; +extern PFNGLVERTEXWEIGHTHVNVPROC glVertexWeighthvNV; +extern PFNGLVERTEXATTRIB1HNVPROC glVertexAttrib1hNV; +extern PFNGLVERTEXATTRIB1HVNVPROC glVertexAttrib1hvNV; +extern PFNGLVERTEXATTRIB2HNVPROC glVertexAttrib2hNV; +extern PFNGLVERTEXATTRIB2HVNVPROC glVertexAttrib2hvNV; +extern PFNGLVERTEXATTRIB3HNVPROC glVertexAttrib3hNV; +extern PFNGLVERTEXATTRIB3HVNVPROC glVertexAttrib3hvNV; +extern PFNGLVERTEXATTRIB4HNVPROC glVertexAttrib4hNV; +extern PFNGLVERTEXATTRIB4HVNVPROC glVertexAttrib4hvNV; +extern PFNGLVERTEXATTRIBS1HVNVPROC glVertexAttribs1hvNV; +extern PFNGLVERTEXATTRIBS2HVNVPROC glVertexAttribs2hvNV; +extern PFNGLVERTEXATTRIBS3HVNVPROC glVertexAttribs3hvNV; +extern PFNGLVERTEXATTRIBS4HVNVPROC glVertexAttribs4hvNV; +#endif + +#if defined(GL_NV_pixel_data_range) +extern PFNGLPIXELDATARANGENVPROC glPixelDataRangeNV; +extern PFNGLFLUSHPIXELDATARANGENVPROC glFlushPixelDataRangeNV; +#endif + +#if defined(GL_NV_primitive_restart) +extern PFNGLPRIMITIVERESTARTNVPROC glPrimitiveRestartNV; +extern PFNGLPRIMITIVERESTARTINDEXNVPROC glPrimitiveRestartIndexNV; +#endif + +#if defined(GL_NV_texture_expand_normal) +#endif + +#if defined(GL_NV_vertex_program2) +#endif + +#if defined(GL_ATI_map_object_buffer) +extern PFNGLMAPOBJECTBUFFERATIPROC glMapObjectBufferATI; +extern PFNGLUNMAPOBJECTBUFFERATIPROC glUnmapObjectBufferATI; +#endif + +#if defined(GL_ATI_separate_stencil) +extern PFNGLSTENCILOPSEPARATEATIPROC glStencilOpSeparateATI; +extern PFNGLSTENCILFUNCSEPARATEATIPROC glStencilFuncSeparateATI; +#endif + +#if defined(GL_ATI_vertex_attrib_array_object) +extern PFNGLVERTEXATTRIBARRAYOBJECTATIPROC glVertexAttribArrayObjectATI; +extern PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC glGetVertexAttribArrayObjectfvATI; +extern PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC glGetVertexAttribArrayObjectivATI; +#endif + +#if defined(GL_EXT_depth_bounds_test) +extern PFNGLDEPTHBOUNDSEXTPROC glDepthBoundsEXT; +#endif + +#if defined(GL_EXT_texture_mirror_clamp) +#endif + +#if defined(GL_EXT_blend_equation_separate) +extern PFNGLBLENDEQUATIONSEPARATEEXTPROC glBlendEquationSeparateEXT; +#endif + +#if defined(GL_MESA_pack_invert) +#endif + +#if defined(GL_MESA_ycbcr_texture) +#endif + +/* end mkglext.py */ + +} /* namespace RAS_GL */ + +#endif /* __RAS_GLEXTENSIONMANAGER_H__ */ diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp index b1c3e5b1996..b7f375e770c 100644 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp @@ -1,3 +1,33 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ #include "RAS_OpenGLRasterizer.h" #ifdef HAVE_CONFIG_H @@ -23,8 +53,8 @@ RAS_OpenGLRasterizer::RAS_OpenGLRasterizer(RAS_ICanvas* canvas) :RAS_IRasterizer(canvas), m_2DCanvas(canvas), m_fogenabled(false), - m_materialCachingInfo(0), - m_noOfScanlines(32) + m_noOfScanlines(32), + m_materialCachingInfo(0) { m_viewmatrix.Identity(); m_stereomode = RAS_STEREO_NOSTEREO; @@ -314,11 +344,14 @@ void RAS_OpenGLRasterizer::SetDepthMask(int depthmask) case KX_DEPTHMASK_ENABLED: { glDepthMask(GL_TRUE); + //glDisable ( GL_ALPHA_TEST ); break; }; case KX_DEPTHMASK_DISABLED: { glDepthMask(GL_FALSE); + //glAlphaFunc ( GL_GREATER, 0.0 ) ; + //glEnable ( GL_ALPHA_TEST ) ; break; }; default: @@ -441,7 +474,6 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, const MT_Vector4& rgbacolor ) { - static const GLsizei vtxstride = sizeof(RAS_TexVert); GLenum drawmode; switch (mode) { @@ -460,7 +492,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, } const RAS_TexVert* vertexarray ; - int numindices,vt; + unsigned int numindices,vt; for (vt=0;vt<vertexarrays.size();vt++) { @@ -468,8 +500,6 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, const KX_IndexArray & indexarray = (*indexarrays[vt]); numindices = indexarray.size(); - int numverts = vertexarrays[vt]->size(); - if (!numindices) break; @@ -480,7 +510,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, { glBegin(GL_LINES); vindex=0; - for (int i=0;i<numindices;i+=2) + for (unsigned int i=0;i<numindices;i+=2) { glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ()); glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ()); @@ -494,7 +524,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, vindex=0; if (useObjectColor) { - for (int i=0;i<numindices;i+=4) + for (unsigned int i=0;i<numindices;i+=4) { glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]); @@ -509,7 +539,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); + glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; @@ -522,35 +552,31 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, } else { - for (int i=0;i<numindices;i+=4) + for (unsigned int i=0;i<numindices;i+=4) { - char *cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); // This looks curiously endian unsafe to me. // However it depends on the way the colors are packed into // the m_rgba field of RAS_TexVert - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); @@ -566,7 +592,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, vindex=0; if (useObjectColor) { - for (int i=0;i<numindices;i+=3) + for (unsigned int i=0;i<numindices;i+=3) { glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]); @@ -589,25 +615,22 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, } else { - for (int i=0;i<numindices;i+=3) + for (unsigned int i=0;i<numindices;i+=3) { - char *cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); @@ -636,7 +659,6 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray ) { bool recalc; - static const GLsizei vtxstride = sizeof(RAS_TexVert); GLenum drawmode; switch (mode) { @@ -655,7 +677,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray } const RAS_TexVert* vertexarray ; - int numindices,vt; + unsigned int numindices,vt; for (vt=0;vt<vertexarrays.size();vt++) { @@ -663,8 +685,6 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray const KX_IndexArray & indexarray = (*indexarrays[vt]); numindices = indexarray.size(); - int numverts = vertexarrays[vt]->size(); - if (!numindices) break; @@ -675,7 +695,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray { glBegin(GL_LINES); vindex=0; - for (int i=0;i<numindices;i+=2) + for (unsigned int i=0;i<numindices;i+=2) { glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ()); glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ()); @@ -689,7 +709,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray vindex=0; if (useObjectColor) { - for (int i=0;i<numindices;i+=4) + for (unsigned int i=0;i<numindices;i+=4) { MT_Point3 mv1, mv2, mv3, mv4, fnor; /* Calc a new face normal */ @@ -739,9 +759,8 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray } else { - for (int i=0;i<numindices;i+=4) + for (unsigned int i=0;i<numindices;i+=4) { - char *cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); // This looks curiously endian unsafe to me. // However it depends on the way the colors are packed into // the m_rgba field of RAS_TexVert @@ -765,31 +784,28 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray glNormal3f(fnor[0], fnor[1], fnor[2]); } - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); if (!recalc) glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); if (!recalc) glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); if (!recalc) glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); if (!recalc) glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); @@ -806,7 +822,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray vindex=0; if (useObjectColor) { - for (int i=0;i<numindices;i+=3) + for (unsigned int i=0;i<numindices;i+=3) { MT_Point3 mv1, mv2, mv3, fnor; /* Calc a new face normal */ @@ -848,7 +864,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray } else { - for (int i=0;i<numindices;i+=3) + for (unsigned int i=0;i<numindices;i+=3) { MT_Point3 mv1, mv2, mv3, fnor; /* Calc a new face normal */ @@ -868,24 +884,21 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray glNormal3f(fnor[0], fnor[1], fnor[2]); } - char *cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); if (!recalc) glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); if (!recalc) glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); vindex++; - cp= (char *)&(vertexarray[(indexarray[vindex])].getRGBA()); - glColor4ub(cp[0], cp[1], cp[2], cp[3]); + glColor4ubv((const GLubyte *)&(vertexarray[(indexarray[vindex])].getRGBA())); if (!recalc) glNormal3sv(vertexarray[(indexarray[vindex])].getNormal()); glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1()); @@ -916,8 +929,6 @@ void RAS_OpenGLRasterizer::IndexPrimitives_3DText(const vecVertexArray & vertexa const MT_Vector4& rgbacolor ) { - unsigned char* mypointer=NULL; - static const GLsizei vtxstride = sizeof(RAS_TexVert); GLenum drawmode; switch (mode) { @@ -937,8 +948,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_3DText(const vecVertexArray & vertexa const RAS_TexVert* vertexarray ; - int numindices ; - int vt; + unsigned int numindices, vt; if (useObjectColor) { @@ -956,8 +966,6 @@ void RAS_OpenGLRasterizer::IndexPrimitives_3DText(const vecVertexArray & vertexa const KX_IndexArray & indexarray = (*indexarrays[vt]); numindices = indexarray.size(); - int numverts = vertexarrays[vt]->size(); - if (!numindices) break; @@ -968,7 +976,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_3DText(const vecVertexArray & vertexa { glBegin(GL_LINES); vindex=0; - for (int i=0;i<numindices;i+=2) + for (unsigned int i=0;i<numindices;i+=2) { glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ()); glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ()); @@ -979,7 +987,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_3DText(const vecVertexArray & vertexa case 2: { vindex=0; - for (int i=0;i<numindices;i+=4) + for (unsigned int i=0;i<numindices;i+=4) { float v1[3],v2[3],v3[3],v4[3]; @@ -1017,7 +1025,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_3DText(const vecVertexArray & vertexa { glBegin(GL_TRIANGLES); vindex=0; - for (int i=0;i<numindices;i+=3) + for (unsigned int i=0;i<numindices;i+=3) { float v1[3],v2[3],v3[3]; @@ -1199,7 +1207,13 @@ void RAS_OpenGLRasterizer::SetCullFace(bool enable) glDisable(GL_CULL_FACE); } - +void RAS_OpenGLRasterizer::SetLines(bool enable) +{ + if (enable) + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + else + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); +} void RAS_OpenGLRasterizer::SetSpecularity(float specX, float specY, diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h index 52359ca2480..24f0e42c91d 100644 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h @@ -95,7 +95,7 @@ public: KX_WIREFRAME, KX_SOLID, KX_SHADED, - KX_TEXTURED + KX_TEXTURED }; enum @@ -195,6 +195,7 @@ public: virtual void EnableTextures(bool enable); virtual void SetCullFace(bool enable); + virtual void SetLines(bool enable); virtual MT_Matrix4x4 GetFrustumMatrix( float left, diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.cpp index 6350390ef76..bac291da00a 100644 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.cpp +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.cpp @@ -1,33 +1,61 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * 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 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * 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, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ #ifdef HAVE_CONFIG_H #include <config.h> #endif -#ifdef WIN32 - #include "RAS_VAOpenGLRasterizer.h" -#include <windows.h> -#include "GL/gl.h" - -typedef void (APIENTRY *GLLOCKARRAYSEXTPTR)(GLint first,GLsizei count); -typedef void (APIENTRY *GLUNLOCKARRAYSEXTPTR)(void); -void APIENTRY RAS_lockfunc(GLint first,GLsizei count) {}; -void APIENTRY RAS_unlockfunc() {}; -GLLOCKARRAYSEXTPTR glLockArraysEXT=RAS_lockfunc; -GLUNLOCKARRAYSEXTPTR glUnlockArraysEXT=RAS_unlockfunc; - - +#ifdef WIN32 +#include <windows.h> +#endif // WIN32 +#ifdef __APPLE__ +#include <OpenGL/gl.h> +#else +#include <GL/gl.h> +#endif #include "STR_String.h" #include "RAS_TexVert.h" #include "MT_CmMatrix4x4.h" #include "RAS_IRenderTools.h" // rendering text +#include "RAS_GLExtensionManager.h" + +using namespace RAS_GL; + RAS_VAOpenGLRasterizer::RAS_VAOpenGLRasterizer(RAS_ICanvas* canvas) :RAS_OpenGLRasterizer(canvas) { - int i = 0; } @@ -38,7 +66,7 @@ RAS_VAOpenGLRasterizer::~RAS_VAOpenGLRasterizer() -bool RAS_VAOpenGLRasterizer::Init() +bool RAS_VAOpenGLRasterizer::Init(void) { bool result = RAS_OpenGLRasterizer::Init(); @@ -48,15 +76,7 @@ bool RAS_VAOpenGLRasterizer::Init() // if possible, add extensions to other platforms too, if this // rasterizer becomes messy just derive one for each platform // (ie. KX_Win32Rasterizer, KX_LinuxRasterizer etc.) - - glUnlockArraysEXT = reinterpret_cast<GLUNLOCKARRAYSEXTPTR>(wglGetProcAddress("glUnlockArraysEXT")); - if (!glUnlockArraysEXT) - result = false; - - glLockArraysEXT = reinterpret_cast<GLLOCKARRAYSEXTPTR>(wglGetProcAddress("glLockArraysEXT")); - if (!glLockArraysEXT) - result=false; - + glEnableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); @@ -149,7 +169,7 @@ void RAS_VAOpenGLRasterizer::IndexPrimitives( const vecVertexArray& vertexarrays } } const RAS_TexVert* vertexarray; - int numindices,vt; + unsigned int numindices, vt; if (drawmode != GL_LINES) { if (useObjectColor) @@ -177,14 +197,10 @@ void RAS_VAOpenGLRasterizer::IndexPrimitives( const vecVertexArray& vertexarrays if (!numindices) break; - mypointer = (unsigned char*)(vertexarray); - glVertexPointer(3,GL_FLOAT,vtxstride,mypointer); - mypointer+= 3*sizeof(float); - glTexCoordPointer(2,GL_FLOAT,vtxstride,mypointer); - mypointer+= 2*sizeof(float); - glColorPointer(4,GL_UNSIGNED_BYTE,vtxstride,mypointer); - mypointer += sizeof(int); - glNormalPointer(GL_SHORT,vtxstride,mypointer); + glVertexPointer(3,GL_FLOAT,vtxstride,vertexarray->getLocalXYZ()); + glTexCoordPointer(2,GL_FLOAT,vtxstride,vertexarray->getUV1()); + glColorPointer(4,GL_UNSIGNED_BYTE,vtxstride,&vertexarray->getRGBA()); + glNormalPointer(GL_SHORT,vtxstride,vertexarray->getNormal()); glLockArraysEXT(0,numverts); // here the actual drawing takes places glDrawElements(drawmode,numindices,GL_UNSIGNED_INT,&(indexarray[0])); @@ -212,5 +228,3 @@ bool RAS_VAOpenGLRasterizer::Stereo() return false; } - -#endif //WIN32 diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript index 003ddbf404e..f45f3c6fc8d 100755 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript @@ -3,7 +3,7 @@ Import ('library_env') ras_openglrasterizer_env = library_env.Copy () -source_files = ['RAS_CheckVertexArrays.cpp', +source_files = ['RAS_GLExtensionManager.cpp', 'RAS_OpenGLRasterizer.cpp', 'RAS_VAOpenGLRasterizer.cpp'] diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/mkglext.py b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/mkglext.py new file mode 100644 index 00000000000..416629b3aac --- /dev/null +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/mkglext.py @@ -0,0 +1,538 @@ +#!/usr/bin/python +# +# $Id$ +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# 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 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# 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, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** + +# +# mkglext.py generates code for linking extensions. +# +# It reads the glext.h header from stdin and writes code to stdout. +# +# Usage: mkglext.py < glext.h > tmp +# Code can be copied & pasted from tmp to GL_ExtensionManager.cpp. +# +# glext.h is available here: http://oss.sgi.com/projects/ogl-sample/ABI/glext.h +# + +from sys import stdin +import string, re + +glext_h = string.split(stdin.read(), '\n') + +# These extensions have been incorporated into the core GL or been superceded. +# Code will not be generated for these extensions +blacklist = [ + "GL_EXT_multisample", + "GL_INGR_blend_func_separate", + "GL_SGIX_fragment_lighting", + "GL_SGIX_polynomial_ffd", + "GL_SGIS_point_parameters", + "GL_EXT_texture_object", + "GL_EXT_subtexture", + "GL_EXT_copy_texture", + "GL_EXT_vertex_array", + "GL_EXT_point_parameters", + "GL_EXT_blend_color", + "GL_EXT_polygon_offset", + "GL_EXT_texture"] + +# Only code for these extensions will be generated. Extensions on both the +# blacklist & whitelist will not have code generated. +# This list is from http://oss.sgi.com/projects/ogl-sample/registry/ at 14-Mar-04 +whitelist = [ + # ARB Extensions + "GL_ARB_multitexture", + "GLX_ARB_get_proc_address", + "GL_ARB_transpose_matrix", + "WGL_ARB_buffer_region", + "GL_ARB_multisample", + "GL_ARB_texture_env_add", + "GL_ARB_texture_cube_map", + "WGL_ARB_extensions_string", + "WGL_ARB_pixel_format", + "WGL_ARB_make_current_read", + "WGL_ARB_pbuffer", + "GL_ARB_texture_compression", + "GL_ARB_texture_border_clamp", + "GL_ARB_point_parameters", + "GL_ARB_vertex_blend", + "GL_ARB_matrix_palette", + "GL_ARB_texture_env_combine", + "GL_ARB_texture_env_crossbar", + "GL_ARB_texture_env_dot3", + "WGL_ARB_render_texture", + "GL_ARB_texture_mirrored_repeat", + "GL_ARB_depth_texture", + "GL_ARB_shadow", + "GL_ARB_shadow_ambient", + "GL_ARB_window_pos", + "GL_ARB_vertex_program", + "GL_ARB_fragment_program", + "GL_ARB_vertex_buffer_object", + "GL_ARB_occlusion_query", + "GL_ARB_shader_objects", + "GL_ARB_vertex_shader", + "GL_ARB_fragment_shader", + "GL_ARB_shading_language_100", + "GL_ARB_texture_non_power_of_two", + "GL_ARB_point_sprite", + "GL_ARB_fragment_program_shadow", + + # Non ARB Extensions + "GL_EXT_abgr", + "GL_EXT_blend_color", + "GL_EXT_polygon_offset", + "GL_EXT_texture", + "GL_EXT_texture3D", + "GL_SGIS_texture_filter4", + "GL_EXT_subtexture", + "GL_EXT_copy_texture", + "GL_EXT_histogram", + "GL_EXT_convolution", + "GL_SGI_color_matrix", + "GL_SGI_color_table", + "GL_SGIS_pixel_texture", + "GL_SGIS_texture4D", + "GL_SGI_texture_color_table", + "GL_EXT_cmyka", + "GL_EXT_texture_object", + "GL_SGIS_detail_texture", + "GL_SGIS_sharpen_texture", + "GL_EXT_packed_pixels", + "GL_SGIS_texture_lod", + "GL_SGIS_multisample", + "GL_EXT_rescale_normal", + "GLX_EXT_visual_info", + "GL_EXT_vertex_array", + "GL_EXT_misc_attribute", + "GL_SGIS_generate_mipmap", + "GL_SGIX_clipmap", + "GL_SGIX_shadow", + "GL_SGIS_texture_edge_clamp", + "GL_SGIS_texture_border_clamp", + "GL_EXT_blend_minmax", + "GL_EXT_blend_subtract", + "GL_EXT_blend_logic_op", + "GLX_SGI_swap_control", + "GLX_SGI_video_sync", + "GLX_SGI_make_current_read", + "GLX_SGIX_video_source", + "GLX_EXT_visual_rating", + "GL_SGIX_interlace", + "GLX_EXT_import_context", + "GLX_SGIX_fbconfig", + "GLX_SGIX_pbuffer", + "GL_SGIS_texture_select", + "GL_SGIX_sprite", + "GL_SGIX_texture_multi_buffer", + "GL_EXT_point_parameters", + "GL_SGIX_instruments", + "GL_SGIX_texture_scale_bias", + "GL_SGIX_framezoom", + "GL_SGIX_tag_sample_buffer", + "GL_SGIX_reference_plane", + "GL_SGIX_flush_raster", + "GLX_SGI_cushion", + "GL_SGIX_depth_texture", + "GL_SGIS_fog_function", + "GL_SGIX_fog_offset", + "GL_HP_image_transform", + "GL_HP_convolution_border_modes", + "GL_SGIX_texture_add_env", + "GL_EXT_color_subtable", + "GLU_EXT_object_space_tess", + "GL_PGI_vertex_hints", + "GL_PGI_misc_hints", + "GL_EXT_paletted_texture", + "GL_EXT_clip_volume_hint", + "GL_SGIX_list_priority", + "GL_SGIX_ir_instrument1", + "GLX_SGIX_video_resize", + "GL_SGIX_texture_lod_bias", + "GLU_SGI_filter4_parameters", + "GLX_SGIX_dm_buffer", + "GL_SGIX_shadow_ambient", + "GLX_SGIX_swap_group", + "GLX_SGIX_swap_barrier", + "GL_EXT_index_texture", + "GL_EXT_index_material", + "GL_EXT_index_func", + "GL_EXT_index_array_formats", + "GL_EXT_compiled_vertex_array", + "GL_EXT_cull_vertex", + "GLU_EXT_nurbs_tessellator", + "GL_SGIX_ycrcb", + "GL_EXT_fragment_lighting", + "GL_IBM_rasterpos_clip", + "GL_HP_texture_lighting", + "GL_EXT_draw_range_elements", + "GL_WIN_phong_shading", + "GL_WIN_specular_fog", + "GLX_SGIS_color_range", + "GL_EXT_light_texture", + "GL_SGIX_blend_alpha_minmax", + "GL_EXT_scene_marker", + "GL_SGIX_pixel_texture_bits", + "GL_EXT_bgra", + "GL_SGIX_async", + "GL_SGIX_async_pixel", + "GL_SGIX_async_histogram", + "GL_INTEL_texture_scissor", + "GL_INTEL_parallel_arrays", + "GL_HP_occlusion_test", + "GL_EXT_pixel_transform", + "GL_EXT_pixel_transform_color_table", + "GL_EXT_shared_texture_palette", + "GLX_SGIS_blended_overlay", + "GL_EXT_separate_specular_color", + "GL_EXT_secondary_color", + "GL_EXT_texture_env", + "GL_EXT_texture_perturb_normal", + "GL_EXT_multi_draw_arrays", + "GL_EXT_fog_coord", + "GL_REND_screen_coordinates", + "GL_EXT_coordinate_frame", + "GL_EXT_texture_env_combine", + "GL_APPLE_specular_vector", + "GL_SGIX_pixel_texture", + "GL_APPLE_transform_hint", + "GL_SUNX_constant_data", + "GL_SUN_global_alpha", + "GL_SUN_triangle_list", + "GL_SUN_vertex", + "WGL_EXT_display_color_table", + "WGL_EXT_extensions_string", + "WGL_EXT_make_current_read", + "WGL_EXT_pixel_format", + "WGL_EXT_pbuffer", + "WGL_EXT_swap_control", + "GL_EXT_blend_func_separate", + "GL_INGR_color_clamp", + "GL_INGR_interlace_read", + "GL_EXT_stencil_wrap", + "WGL_EXT_depth_float", + "GL_EXT_422_pixels", + "GL_NV_texgen_reflection", + "GL_SGIX_texture_range", + "GL_SUN_convolution_border_modes", + "GLX_SUN_get_transparent_index", + "GL_EXT_texture_env_add", + "GL_EXT_texture_lod_bias", + "GL_EXT_texture_filter_anisotropic", + "GL_EXT_vertex_weighting", + "GL_NV_light_max_exponent", + "GL_NV_vertex_array_range", + "GL_NV_register_combiners", + "GL_NV_fog_distance", + "GL_NV_texgen_emboss", + "GL_NV_blend_square", + "GL_NV_texture_env_combine4", + "GL_MESA_resize_buffers", + "GL_MESA_window_pos", + "GL_EXT_texture_compression_s3tc", + "GL_IBM_cull_vertex", + "GL_IBM_multimode_draw_arrays", + "GL_IBM_vertex_array_lists", + "GL_3DFX_texture_compression_FXT1", + "GL_3DFX_multisample", + "GL_3DFX_tbuffer", + "WGL_EXT_multisample", + "GL_SGIX_vertex_preclip", + "GL_SGIX_resample", + "GL_SGIS_texture_color_mask", + "GLX_MESA_copy_sub_buffer", + "GLX_MESA_pixmap_colormap", + "GLX_MESA_release_buffers", + "GLX_MESA_set_3dfx_mode", + "GL_EXT_texture_env_dot3", + "GL_ATI_texture_mirror_once", + "GL_NV_fence", + "GL_IBM_static_data", + "GL_IBM_texture_mirrored_repeat", + "GL_NV_evaluators", + "GL_NV_packed_depth_stencil", + "GL_NV_register_combiners2", + "GL_NV_texture_compression_vtc", + "GL_NV_texture_rectangle", + "GL_NV_texture_shader", + "GL_NV_texture_shader2", + "GL_NV_vertex_array_range2", + "GL_NV_vertex_program", + "GLX_SGIX_visual_select_group", + "GL_SGIX_texture_coordinate_clamp", + "GLX_OML_swap_method", + "GLX_OML_sync_control", + "GL_OML_interlace", + "GL_OML_subsample", + "GL_OML_resample", + "WGL_OML_sync_control", + "GL_NV_copy_depth_to_color", + "GL_ATI_envmap_bumpmap", + "GL_ATI_fragment_shader", + "GL_ATI_pn_triangles", + "GL_ATI_vertex_array_object", + "GL_EXT_vertex_shader", + "GL_ATI_vertex_streams", + "WGL_I3D_digital_video_control", + "WGL_I3D_gamma", + "WGL_I3D_genlock", + "WGL_I3D_image_buffer", + "WGL_I3D_swap_frame_lock", + "WGL_I3D_swap_frame_usage", + "GL_ATI_element_array", + "GL_SUN_mesh_array", + "GL_SUN_slice_accum", + "GL_NV_multisample_filter_hint", + "GL_NV_depth_clamp", + "GL_NV_occlusion_query", + "GL_NV_point_sprite", + "WGL_NV_render_depth_texture", + "WGL_NV_render_texture_rectangle", + "GL_NV_texture_shader3", + "GL_NV_vertex_program1_1", + "GL_EXT_shadow_funcs", + "GL_EXT_stencil_two_side", + "GL_ATI_text_fragment_shader", + "GL_APPLE_client_storage", + "GL_APPLE_element_array", + "GL_APPLE_fence", + "GL_APPLE_vertex_array_object", + "GL_APPLE_vertex_array_range", + "GL_APPLE_ycbcr_422", + "GL_S3_s3tc", + "GL_ATI_draw_buffers", + "WGL_ATI_pixel_format_float", + "GL_ATI_texture_env_combine3", + "GL_ATI_texture_float", + "GL_NV_float_buffer", + "GL_NV_fragment_program", + "GL_NV_half_float", + "GL_NV_pixel_data_range", + "GL_NV_primitive_restart", + "GL_NV_texture_expand_normal", + "GL_NV_vertex_program2", + "GL_ATI_map_object_buffer", + "GL_ATI_separate_stencil", + "GL_ATI_vertex_attrib_array_object", + "GL_OES_byte_coordinates", + "GL_OES_fixed_point", + "GL_OES_single_precision", + "GL_OES_compressed_paletted_texture", + "GL_OES_read_format", + "GL_OES_query_matrix", + "GL_EXT_depth_bounds_test", + "GL_EXT_texture_mirror_clamp", + "GL_EXT_blend_equation_separate", + "GL_MESA_pack_invert", + "GL_MESA_ycbcr_texture"] + +""" +Example code output: +#ifdef GL_EXT_compiled_vertex_array + if (QueryExtension("GL_EXT_compiled_vertex_array")) + { + glUnlockArraysEXT = reinterpret_cast<PFNGLUNLOCKARRAYSEXTPROC>(bglGetProcAddress((const GLubyte *) "glUnlockArraysEXT")); + glLockArraysEXT = reinterpret_cast<PFNGLLOCKARRAYSEXTPROC>(bglGetProcAddress((const GLubyte *) "glLockArraysEXT")); + if (glUnlockArraysEXT && glLockArraysEXT) + { + EnableExtension(_GL_EXT_compiled_vertex_array); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_compiled_vertex_array" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_compiled_vertex_array implementation is broken!" << std::endl; + } + } +#endif +""" +def writeext(ext, fnlist): + if (find(blacklist, ext)): + return + if (len(fnlist) == 0): + print "\tif (QueryExtension(\"" + ext + "\"))" + print "\t{" + print "\t\tEnableExtension(_" + ext + ");" + print "\t\tif (m_debug && doDebugMessages)" + print "\t\t\tstd::cout << \"Enabled " + ext + "\" << std::endl;" + print "\t}" + print + return + print "#if defined(" + ext + ")" + print "\tif (QueryExtension(\"" + ext + "\"))" + print "\t{" + for fn in fnlist: + print "\t\t" + fn[0] + " = reinterpret_cast<" + fn[1] + ">(bglGetProcAddress((const GLubyte *) \"" + fn[0] + "\"));" + errcheck = "" + for fn in fnlist: + if (errcheck == ""): + errcheck = fn[0] + else: + errcheck = errcheck + " && " + fn[0] + print "\t\tif (" + errcheck + ") {" + print "\t\t\tEnableExtension(_" + ext + ");" + print "\t\t\tif (m_debug && doDebugMessages)" + print "\t\t\t\tstd::cout << \"Enabled " + ext + "\" << std::endl;" + print "\t\t} else {" + print "\t\t\tstd::cout << \"ERROR: " + ext + " implementation is broken!\" << std::endl;" + print "\t\t}" + print "\t}" + print "#endif" + print + +""" +Example Output: +#if defined(GL_EXT_compiled_vertex_array) +PFNGLLOCKARRAYSEXTPROC glLockArraysEXT; +PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT; +#endif +""" +def writeproto(ext, fnlist): + if (find(blacklist, ext) or not find(whitelist, ext)): + return + print "#if defined(" + ext + ")" + for fn in fnlist: + print fn[1] + " " + fn[0] + ";" + print "#endif" + print + +""" +#ifdef GL_EXT_compiled_vertex_array +extern PFNGLLOCKARRAYSEXTPROC glLockArraysEXT; +extern PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT; +#endif +""" +def writeheader(ext, fnlisti): + if (find(blacklist, ext) or not find(whitelist, ext)): + return + print "#if defined(" + ext + ")" + for fn in fnlist: + print "extern " + fn[1] + " " + fn[0] + ";" + print "#endif" + print + +def find(l, x): + for i in l: + if (i == x): + return 1 + return 0 + +ext = "" +fns = [] +fnlist = [] +ifdef = 0 +for i in glext_h: + line = re.search('^#ifn?def', i) + if (line): + ifdef = ifdef + 1 + + line = re.search('^#ifndef (GL_.*)', i) + if (line): + if (not re.search('GL_VERSION.*', line.group(1)) and find(whitelist, line.group(1))): + ext = line.group(1) + + line = re.search('^#endif', i) + if (line): + ifdef = ifdef - 1 + if (ifdef == 0 and ext != ""): + writeproto(ext, fnlist) + ext = "" + fns = [] + fnlist = [] + if (ext != ""): + line = re.search('.*(gl.*) \(.*\);', i) + if (line): + fns += [line.group(1)] + line = re.search('.*PFN(.*)PROC.*', i) + if (line): + for j in fns: + if (string.lower(line.group(1)) == string.lower(j)): + fnlist += [(j, "PFN" + line.group(1) + "PROC")] + +ext = "" +fns = [] +fnlist = [] +ifdef = 0 +for i in glext_h: + line = re.search('^#ifn?def', i) + if (line): + ifdef = ifdef + 1 + + line = re.search('^#ifndef (GL_.*)', i) + if (line): + if (not re.search('GL_VERSION.*', line.group(1)) and find(whitelist, line.group(1))): + ext = line.group(1) + + line = re.search('^#endif', i) + if (line): + ifdef = ifdef - 1 + if (ifdef == 0 and ext != ""): + writeext(ext, fnlist) + ext = "" + fns = [] + fnlist = [] + if (ext != ""): + line = re.search('.*(gl.*) \(.*\);', i) + if (line): + fns += [line.group(1)] + line = re.search('.*PFN(.*)PROC.*', i) + if (line): + for j in fns: + if (string.lower(line.group(1)) == string.lower(j)): + fnlist += [(j, "PFN" + line.group(1) + "PROC")] + +ext = "" +fns = [] +fnlist = [] +ifdef = 0 +for i in glext_h: + line = re.search('^#ifn?def', i) + if (line): + ifdef = ifdef + 1 + + line = re.search('^#ifndef (GL_.*)', i) + if (line): + if (not re.search('GL_VERSION.*', line.group(1)) and find(whitelist, line.group(1))): + ext = line.group(1) + + line = re.search('^#endif', i) + if (line): + ifdef = ifdef - 1 + if (ifdef == 0 and ext != ""): + writeheader(ext, fnlist) + ext = "" + fns = [] + fnlist = [] + if (ext != ""): + line = re.search('.*(gl.*) \(.*\);', i) + if (line): + fns += [line.group(1)] + line = re.search('.*PFN(.*)PROC.*', i) + if (line): + for j in fns: + if (string.lower(line.group(1)) == string.lower(j)): + fnlist += [(j, "PFN" + line.group(1) + "PROC")] diff --git a/source/gameengine/Rasterizer/RAS_TexVert.cpp b/source/gameengine/Rasterizer/RAS_TexVert.cpp index c29a16c71d8..c5b193cc941 100644 --- a/source/gameengine/Rasterizer/RAS_TexVert.cpp +++ b/source/gameengine/Rasterizer/RAS_TexVert.cpp @@ -52,11 +52,6 @@ RAS_TexVert::RAS_TexVert(const MT_Point3& xyz, -const float* RAS_TexVert::getUV1 () const -{ - return m_uv1; -} - const MT_Point3& RAS_TexVert::xyz() @@ -97,8 +92,14 @@ void RAS_TexVert::SetNormal(const MT_Vector3& normal) } - +#ifndef RAS_TexVert_INLINE // leave multiline for debugging +const float* RAS_TexVert::getUV1 () const +{ + return m_uv1; +} + + const short* RAS_TexVert::getNormal() const { return m_normal; @@ -118,7 +119,7 @@ const unsigned int& RAS_TexVert::getRGBA() const return m_rgba; } - +#endif // compare two vertices, and return TRUE if both are almost identical (they can be shared) bool RAS_TexVert::closeTo(const RAS_TexVert* other) @@ -153,3 +154,11 @@ short RAS_TexVert::getFlag() const { return m_flag; } + +void RAS_TexVert::getOffsets(void* &xyz, void* &uv1, void* &rgba, void* &normal) const +{ + xyz = (void *) m_localxyz; + uv1 = (void *) m_uv1; + rgba = (void *) m_rgba; + normal = (void *) m_normal; +} diff --git a/source/gameengine/Rasterizer/RAS_TexVert.h b/source/gameengine/Rasterizer/RAS_TexVert.h index 0e19ea61d9d..cd529e7d586 100644 --- a/source/gameengine/Rasterizer/RAS_TexVert.h +++ b/source/gameengine/Rasterizer/RAS_TexVert.h @@ -42,14 +42,16 @@ static MT_Point2 g_pt2; #define TV_CALCFACENORMAL 0x0001 +#define RAS_TexVert_INLINE 1 + class RAS_TexVert { - float m_localxyz[3]; // 3*4=12 = 24 - float m_uv1[2]; // 2*4=8 = 24 + 16 = 40 - unsigned int m_rgba; //4 = 40 + 4 = 44 - short m_normal[3]; //3*2=6 = 50 - short m_flag; //32 bytes total size, fits nice = 52 = not fit nice + float m_localxyz[3]; // 3*4 = 12 = 24 + float m_uv1[2]; // 2*4 = 8 = 24 + 16 = 40 + unsigned int m_rgba; // 4 = 40 + 4 = 44 + short m_normal[3]; // 3*2 = 6 = 50 + short m_flag; // 32 bytes total size, fits nice = 52 = not fit nice public: @@ -64,11 +66,28 @@ public: ~RAS_TexVert() {}; // leave multiline for debugging +#ifdef RAS_TexVert_INLINE + const float* getUV1 () const { + return m_uv1; + }; + + const float* getLocalXYZ() const { + return m_localxyz; + }; + + const short* getNormal() const { + return m_normal; + } + + const unsigned int& getRGBA() const { + return m_rgba; + } +#else const float* getUV1 () const; - - //const float* getUV1 () const { - // return m_uv1; - //}; + const short* getNormal() const; + const float* getLocalXYZ() const; + const unsigned int& getRGBA() const; +#endif const MT_Point3& xyz(); @@ -77,14 +96,7 @@ public: void SetRGBA(const unsigned int rgba); void SetNormal(const MT_Vector3& normal); void SetFlag(const short flag); - // leave multiline for debugging - const short* getNormal() const; - //const float* getLocalXYZ() const { - // return m_localxyz; - //}; - - const float* getLocalXYZ() const; - const unsigned int& getRGBA() const; + // compare two vertices, and return TRUE if both are almost identical (they can be shared) bool closeTo(const RAS_TexVert* other); @@ -92,6 +104,7 @@ public: const MT_Point2& otheruv, const unsigned int otherrgba, short othernormal[3]) const; + void getOffsets(void*&xyz, void *&uv1, void *&rgba, void *&normal) const; }; #endif //__RAS_TEXVERT diff --git a/source/gameengine/SceneGraph/SG_Node.cpp b/source/gameengine/SceneGraph/SG_Node.cpp index c3e4ef79c28..821bc86af16 100644 --- a/source/gameengine/SceneGraph/SG_Node.cpp +++ b/source/gameengine/SceneGraph/SG_Node.cpp @@ -55,8 +55,8 @@ SG_Node::SG_Node( const SG_Node & other ) : SG_Spatial(other), - m_SGparent(other.m_SGparent), - m_children(other.m_children) + m_children(other.m_children), + m_SGparent(other.m_SGparent) { // nothing to do } |