[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.
2004-03-22 22:02:18 +00:00
parent 5b90aafbd6
commit 00291b5cf4
133 changed files with 9550 additions and 1534 deletions
--- a/24
+++ b/24
@@ -68,7 +68,7 @@ if sys.platform == 'linux2' or sys.platform == 'linux-i386':
    # SOLID library information
    solid_lib = []                                              # TODO
    solid_libpath = []                                          # TODO
-    solid_include = ['#extern/solid/include']
+    solid_include = ['#extern/solid']
    qhull_lib = []                                              # TODO
    qhull_libpath = []                                          # TODO
    qhull_include = ['#extern/qhull/include']
@@ -156,7 +156,7 @@ elif sys.platform == 'darwin':
    # SOLID library information
    solid_lib = []                                              # TODO
    solid_libpath = []                                          # TODO
-    solid_include = ['#extern/solid/include']
+    solid_include = ['#extern/solid']
    qhull_lib = []                                              # TODO
    qhull_libpath = []                                          # TODO
    qhull_include = ['#extern/qhull/include']
@@ -247,8 +247,8 @@ elif sys.platform == 'win32':
    use_openal = 'true'
    use_fmod = 'false'
    use_quicktime = 'true'
-    use_sumo = 'false'
-    use_ode = 'true'
+    use_sumo = 'true'
+    use_ode = 'false'
    use_buildinfo = 'false'
    build_blender_dynamic = 'true'
    build_blender_static = 'false'
@@ -313,7 +313,7 @@ elif sys.platform == 'win32':
    # SOLID library information
    solid_lib = ['extern/solid']
    solid_libpath = ['#../lib/windows/solid/lib']
-    solid_include = ['#../lib/windows/solid/include']
+    solid_include = ['#extern/solid']
    qhull_lib = ['qhull']
    qhull_libpath = ['#../lib/windows/qhull/lib']
    qhull_include = ['#extern/qhull/include']
@@ -391,7 +391,7 @@ elif string.find (sys.platform, 'sunos') != -1:
    # SOLID library information
    solid_lib = []                                              # TODO
    solid_libpath = []                                          # TODO
-    solid_include = ['#extern/solid/include']
+    solid_include = ['#extern/solid']
    qhull_lib = []                                              # TODO
    qhull_libpath = []                                          # TODO
    qhull_include = ['#extern/qhull/include']
@@ -558,7 +558,7 @@ elif sys.platform=='openbsd3':
    # SOLID library information
    solid_lib = []                     # TODO
    solid_libpath = []        # TODO
-    solid_include = ['#extern/solid/include']
+    solid_include = ['#extern/solid']
    qhull_lib = []       # TODO
    qhull_libpath = []  # TODO
    qhull_include = ['#extern/qhull/include']
@@ -617,10 +617,10 @@ else:
    config.write ("BUILD_DIR = %r\n"%(root_build_dir))
    config.write ("USE_INTERNATIONAL = %r\n"%(use_international))
    config.write ("BUILD_GAMEENGINE = %r\n"%(use_gameengine))
-    if use_sumo == 'true':
-        config.write ("USE_PHYSICS = 'solid'\n")
-    else:
+    if use_ode == 'true':
        config.write ("USE_PHYSICS = 'ode'\n")
+    else:
+        config.write ("USE_PHYSICS = 'solid'\n")
    config.write ("USE_OPENAL = %r\n"%(use_openal))
    config.write ("USE_FMOD = %r\n"%(use_fmod))
    config.write ("USE_QUICKTIME = %r\n"%(use_quicktime))
@@ -903,9 +903,7 @@ if user_options_dict['BUILD_GAMEENGINE'] == 1:
                           'NG_network',
                           'NG_loopbacknetwork'])
    if user_options_dict['USE_PHYSICS'] == 'solid':
-        link_env.Append (LIBS=['PHY_Sumo'])
-        link_env.Append (LIBS=['extern_qhull',
-                               'extern_solid'])
+        link_env.Append (LIBS=['PHY_Sumo', 'PHY_Physics', 'blender_MT', 'extern_solid', 'extern_qhull'])
    else:
        link_env.Append (LIBS=['PHY_Ode',
                               'PHY_Physics'])
--- a/extern/qhull/SConscript
+++ b/extern/qhull/SConscript
@@ -1,10 +1,17 @@
+import sys
+
 qhull_env = Environment()

 # Import the C flags set in the SConstruct file
 Import ('cflags')
 Import ('defines')
 Import ('user_options_dict')
-qhull_env.Append (CCFLAGS = cflags)
+if sys.platform=='linux2' or sys.platform=='linux-i386':
+	qhull_env.Append (CCFLAGS = ['-O2', '-ansi'])
+elif sys.platform=='sunos':
+	qhull_env.Append (CCFLAGS = ['Xc', '-v', '-fast'])
+else:
+	qhull_env.Append (CCFLAGS = cflags)
 qhull_env.Append (CPPDEFINES = defines)

 source_files = ['src/geom.c',
--- a/extern/solid/SConscript
+++ b/extern/solid/SConscript
@@ -13,6 +13,9 @@ cxxflags = []
 if sys.platform=='win32':
    defines += ['WIN32','NDEBUG', '_WINDOWS', '_LIB']
    cflags += ['/MT', '/W3', '/GX', '/O2']
+elif sys.platform=='linux2' or sys.platform=='linux-i386':
+    defines += ['NDEBUG']
+    cflags += ['-O2']
 else:
    print "################################################"
    print 
--- a/extern/solid/SOLID/SOLID.h
+++ b/extern/solid/SOLID/SOLID.h
@@ -0,0 +1,276 @@
+/*
+ * SOLID - Software Library for Interference Detection
+ * 
+ * Copyright (C) 2001-2003  Dtecta.  All rights reserved.
+ *
+ * This library may be distributed under the terms of the Q Public License
+ * (QPL) as defined by Trolltech AS of Norway and appearing in the file
+ * LICENSE.QPL included in the packaging of this file.
+ *
+ * This library may be distributed and/or modified under the terms of the
+ * GNU General Public License (GPL) version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * This library is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Commercial use or any other use of this library not covered by either 
+ * the QPL or the GPL requires an additional license from Dtecta. 
+ * Please contact info@dtecta.com for enquiries about the terms of commercial
+ * use of this library.
+ */
+
+#ifndef SOLID_H
+#define SOLID_H
+
+#include "SOLID_types.h"
+
+#ifdef __cplusplus
+extern "C" { 
+#endif
+    
+	DT_DECLARE_HANDLE(DT_ObjectHandle);
+	DT_DECLARE_HANDLE(DT_SceneHandle);
+	DT_DECLARE_HANDLE(DT_ShapeHandle);
+	DT_DECLARE_HANDLE(DT_VertexBaseHandle);
+	DT_DECLARE_HANDLE(DT_RespTableHandle);
+	DT_DECLARE_HANDLE(DT_ArchiveHandle);
+
+	typedef unsigned int DT_ResponseClass;
+
+	typedef enum DT_ResponseType { 
+		DT_NO_RESPONSE,                  /* No response (obsolete) */              
+		DT_SIMPLE_RESPONSE,              /* No collision data */
+		DT_WITNESSED_RESPONSE,           /* A point common to both objects
+											is returned as collision data
+										 */
+		DT_DEPTH_RESPONSE                /* The penetration depth is returned
+											as collision data. The penetration depth
+											is the shortest vector over which one 
+											object needs to be translated in order
+											to bring the objects in touching contact. 
+										 */ 
+	} DT_ResponseType;
+    
+/* For witnessed response, the following structure represents a common point. The world 
+   coordinates of 'point1' and 'point2' coincide. 'normal' is the zero vector.
+   
+   For depth response, the following structure represents the penetration depth. 
+   'point1' en 'point2' are the witness points of the penetration depth in world coordinates.
+   The penetration depth vector in world coordinates is represented by 'normal'.
+*/
+
+	typedef struct DT_CollData {
+		DT_Vector3 point1;               /* Point in object1 in world coordinates */ 
+		DT_Vector3 point2;               /* Point in object2 in world coordinates */
+		DT_Vector3 normal;               /* point2 - point1 */ 
+	} DT_CollData;
+
+/* A response callback is called by SOLID for each pair of collding objects. 'client-data'
+   is a pointer to an arbitrary structure in the client application. The client objects are
+   pointers to structures in the client application associated with the coliding objects.
+   'coll_data' is the collision data computed by SOLID.
+*/
+
+	typedef DT_Bool (*DT_ResponseCallback)(void *client_data,
+										   void *client_object1,
+										   void *client_object2,
+										   const DT_CollData *coll_data);
+										
+/* Shape definition */
+
+
+	extern DECLSPEC DT_ShapeHandle DT_NewBox(DT_Scalar x, DT_Scalar y, DT_Scalar z);
+	extern DECLSPEC DT_ShapeHandle DT_NewCone(DT_Scalar radius, DT_Scalar height);
+	extern DECLSPEC DT_ShapeHandle DT_NewCylinder(DT_Scalar radius, DT_Scalar height);
+	extern DECLSPEC DT_ShapeHandle DT_NewSphere(DT_Scalar radius);
+	extern DECLSPEC DT_ShapeHandle DT_NewPoint(const DT_Vector3 point);
+	extern DECLSPEC DT_ShapeHandle DT_NewLineSegment(const DT_Vector3 source, const DT_Vector3 target);
+	extern DECLSPEC DT_ShapeHandle DT_NewMinkowski(DT_ShapeHandle shape1, DT_ShapeHandle shape2);
+	extern DECLSPEC DT_ShapeHandle DT_NewHull(DT_ShapeHandle shape1, DT_ShapeHandle shape2);
+
+	extern DECLSPEC DT_VertexBaseHandle DT_NewVertexBase(const void *pointer, DT_Size stride);
+	extern DECLSPEC void DT_DeleteVertexBase(DT_VertexBaseHandle vertexBase);	
+	extern DECLSPEC void DT_ChangeVertexBase(DT_VertexBaseHandle vertexBase, const void *pointer);
+
+	extern DECLSPEC DT_ShapeHandle DT_NewComplexShape(DT_VertexBaseHandle vertexBase);
+	extern DECLSPEC void           DT_EndComplexShape();
+
+	extern DECLSPEC DT_ShapeHandle DT_NewPolytope(DT_VertexBaseHandle vertexBase);
+	extern DECLSPEC void           DT_EndPolytope();
+
+	extern DECLSPEC void DT_Begin();
+	extern DECLSPEC void DT_End();
+
+	extern DECLSPEC void DT_Vertex(const DT_Vector3 vertex);
+	extern DECLSPEC void DT_VertexIndex(DT_Index index);
+
+	extern DECLSPEC void DT_VertexIndices(DT_Count count, const DT_Index *indices);
+	extern DECLSPEC void DT_VertexRange(DT_Index first, DT_Count count); 
+
+	extern DECLSPEC void DT_DeleteShape(DT_ShapeHandle shape);
+
+/* Object  */
+
+	extern DECLSPEC DT_ObjectHandle DT_CreateObject(
+		void *client_object,      /* pointer to object in client memory */
+		DT_ShapeHandle shape  /* the shape or geometry of the object */
+		);
+
+	extern DECLSPEC void DT_DestroyObject(DT_ObjectHandle object);
+
+
+
+	extern DECLSPEC void DT_SetPosition(DT_ObjectHandle object, const DT_Vector3 position);
+	extern DECLSPEC void DT_SetOrientation(DT_ObjectHandle object, const DT_Quaternion orientation);
+	extern DECLSPEC void DT_SetScaling(DT_ObjectHandle object, const DT_Vector3 scaling);
+
+/* The margin is an offset from the actual shape. The actual geometry of an
+   object is the set of points whose distance to the transformed shape is at 
+   most the  margin. During the lifetime of an object the margin can be 
+   modified. 
+*/
+   
+	extern DECLSPEC void DT_SetMargin(DT_ObjectHandle object, DT_Scalar margin);
+
+
+/* These commands assume a column-major 4x4 OpenGL matrix representation */
+
+	extern DECLSPEC void DT_SetMatrixf(DT_ObjectHandle object, const float *m); 
+	extern DECLSPEC void DT_GetMatrixf(DT_ObjectHandle object, float *m); 
+
+	extern DECLSPEC void DT_SetMatrixd(DT_ObjectHandle object, const double *m); 
+	extern DECLSPEC void DT_GetMatrixd(DT_ObjectHandle object, double *m); 
+
+	extern DECLSPEC void DT_GetBBox(DT_ObjectHandle object, DT_Vector3 min, DT_Vector3 max);
+
+
+/* This next command returns the distance between the objects. De returned
+   closest points are given in world coordinates.
+*/
+	extern DECLSPEC DT_Scalar DT_GetClosestPair(DT_ObjectHandle object1, DT_ObjectHandle object2,
+												DT_Vector3 point1, DT_Vector3 point2);  
+
+	extern DECLSPEC DT_Bool   DT_GetCommonPoint(DT_ObjectHandle object1, DT_ObjectHandle object2,
+												DT_Vector3 point);
+
+	extern DECLSPEC DT_Bool   DT_GetPenDepth(DT_ObjectHandle object1, DT_ObjectHandle object2,
+											 DT_Vector3 point1, DT_Vector3 point2);  
+
+/* Scene */
+
+	extern DECLSPEC DT_SceneHandle DT_CreateScene(); 
+	extern DECLSPEC void           DT_DestroyScene(DT_SceneHandle scene);
+
+	extern DECLSPEC void DT_AddObject(DT_SceneHandle scene, DT_ObjectHandle object);
+	extern DECLSPEC void DT_RemoveObject(DT_SceneHandle scene, DT_ObjectHandle object);
+
+/* Note that objects can be assigned to multiple scenes! */
+
+/* Response */
+
+/* Response tables are defined independent of the scenes in which they are used.
+   Multiple response tables can be used in one scene, and a response table
+   can be shared among scenes.
+*/
+	extern DECLSPEC DT_RespTableHandle DT_CreateRespTable(); 
+	extern DECLSPEC void               DT_DestroyRespTable(DT_RespTableHandle respTable); 
+
+/* Responses are defined on (pairs of) response classes. Each response table 
+   maintains its set of response classes.
+*/
+	extern DECLSPEC DT_ResponseClass DT_GenResponseClass(DT_RespTableHandle respTable);
+
+/* To each object for which a response is defined in the response table a
+   response class needs to be assigned. 
+*/
+
+	extern DECLSPEC void DT_SetResponseClass(DT_RespTableHandle respTable,
+											 DT_ObjectHandle object,
+											 DT_ResponseClass responseClass);
+
+	extern DECLSPEC void DT_ClearResponseClass(DT_RespTableHandle respTable, 
+											   DT_ObjectHandle object);
+
+	extern DECLSPEC void DT_CallResponse(DT_RespTableHandle respTable,
+										 DT_ObjectHandle object1,
+										 DT_ObjectHandle object2,
+										 const DT_CollData *coll_data);
+
+/* For each pair of objects multiple responses can be defined. A response is a callback
+   together with its response type and client data. */
+    
+/* Responses can be defined for all pairs of response classes... */
+	extern DECLSPEC void DT_AddDefaultResponse(DT_RespTableHandle respTable,
+											   DT_ResponseCallback response, 
+											   DT_ResponseType type, void *client_data);
+
+	extern DECLSPEC void DT_RemoveDefaultResponse(DT_RespTableHandle respTable,
+												  DT_ResponseCallback response);
+/* ...per response class... */
+	extern DECLSPEC void DT_AddClassResponse(DT_RespTableHandle respTable,
+											 DT_ResponseClass responseClass,
+											 DT_ResponseCallback response,
+											 DT_ResponseType type, void *client_data);
+
+	extern DECLSPEC void DT_RemoveClassResponse(DT_RespTableHandle respTable,
+												DT_ResponseClass responseClass,
+												DT_ResponseCallback response);
+
+/* ... and per pair of response classes...*/
+	extern DECLSPEC void DT_AddPairResponse(DT_RespTableHandle respTable,
+											DT_ResponseClass responseClass1,
+											DT_ResponseClass responseClass2, 
+											DT_ResponseCallback response,
+											DT_ResponseType type, void *client_data);
+	extern DECLSPEC void DT_RemovePairResponse(DT_RespTableHandle respTable,
+											   DT_ResponseClass responseClass1,
+											   DT_ResponseClass responseClass2,
+											   DT_ResponseCallback response);
+
+/* The next command calls the response callbacks for all intersecting pairs of objects in a scene. 
+   'DT_Test' returns the number of pairs of objects for which callbacks have been called. 
+*/
+ 
+	extern DECLSPEC DT_Count DT_Test(DT_SceneHandle scene, DT_RespTableHandle respTable);
+
+/* Set the maximum relative error in the closest points and penetration depth
+   computation. The default for `max_error' is 1.0e-3. Larger errors result
+   in better performance. Non-positive error tolerances are ignored.
+*/ 
+
+	extern DECLSPEC void DT_SetAccuracy(DT_Scalar max_error);
+
+/* Set the maximum tolerance on relative errors due to rounding.  The default for `tol_error' 
+   is the machine epsilon. Very large tolerances result in false collisions. Setting tol_error too small 
+   results in missed collisions. Non-positive error tolerances are ignored. 
+*/ 
+    
+	extern DECLSPEC void DT_SetTolerance(DT_Scalar tol_error);
+
+
+/* This function returns the client pointer to the first object in a scene hit by the ray 
+   (actually a line segment) defined by the points 'from' en 'to'. The spot is the hit point 
+   on the object in local coordinates. 'normal' is the normal to the surface of the object in
+   world coordinates. The ignore_client pointer is used to make one of the objects transparent.
+
+   NB: Currently ray tests are implemented for spheres, boxes, and meshes only!!
+*/   
+
+	extern DECLSPEC void *DT_RayCast(DT_SceneHandle scene, void *ignore_client,
+									 const DT_Vector3 source, const DT_Vector3 target,
+									 DT_Scalar max_param, DT_Scalar *param, DT_Vector3 normal);
+
+/* Similar, only here a single object is tested and a boolean is returned */
+
+	extern DECLSPEC DT_Bool DT_ObjectRayCast(DT_ObjectHandle object,
+											 const DT_Vector3 source, const DT_Vector3 target,
+											 DT_Scalar max_param, DT_Scalar *param, DT_Vector3 normal);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/extern/solid/SOLID/SOLID_broad.h
+++ b/extern/solid/SOLID/SOLID_broad.h
@@ -0,0 +1,75 @@
+/*
+ * SOLID - Software Library for Interference Detection
+ * 
+ * Copyright (C) 2001-2003  Dtecta.  All rights reserved.
+ *
+ * This library may be distributed under the terms of the Q Public License
+ * (QPL) as defined by Trolltech AS of Norway and appearing in the file
+ * LICENSE.QPL included in the packaging of this file.
+ *
+ * This library may be distributed and/or modified under the terms of the
+ * GNU General Public License (GPL) version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * This library is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Commercial use or any other use of this library not covered by either 
+ * the QPL or the GPL requires an additional license from Dtecta. 
+ * Please contact info@dtecta.com for enquiries about the terms of commercial
+ * use of this library.
+ */
+
+#ifndef SOLID_BROAD_H
+#define SOLID_BROAD_H
+
+#include "SOLID_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+	DT_DECLARE_HANDLE(BP_SceneHandle);
+	DT_DECLARE_HANDLE(BP_ProxyHandle);
+	
+	typedef void (*BP_Callback)(void *client_data,
+								void *object1,
+								void *object2);
+
+	typedef bool (*BP_RayCastCallback)(void *client_data,
+									   void *object,
+									   const DT_Vector3 source,
+									   const DT_Vector3 target,
+									   DT_Scalar *lambda);
+	
+	extern DECLSPEC BP_SceneHandle BP_CreateScene(void *client_data,
+												  BP_Callback beginOverlap,
+												  BP_Callback endOverlap);
+	
+	extern DECLSPEC void           BP_DestroyScene(BP_SceneHandle scene);
+	
+	extern DECLSPEC BP_ProxyHandle BP_CreateProxy(BP_SceneHandle scene, 
+												  void *object,
+												  const DT_Vector3 min, 
+												  const DT_Vector3 max);
+	
+	extern DECLSPEC void           BP_DestroyProxy(BP_SceneHandle scene, 
+												  BP_ProxyHandle proxy);
+	
+	extern DECLSPEC void BP_SetBBox(BP_ProxyHandle proxy, 
+									const DT_Vector3 min, 
+									const DT_Vector3 max);
+	
+	extern DECLSPEC void *BP_RayCast(BP_SceneHandle scene, 
+									 BP_RayCastCallback objectRayCast, 
+									 void *client_data,
+									 const DT_Vector3 source,
+									 const DT_Vector3 target,
+									 DT_Scalar *lambda);		
+	
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/extern/solid/SOLID/SOLID_types.h
+++ b/extern/solid/SOLID/SOLID_types.h
@@ -0,0 +1,53 @@
+/*
+ * SOLID - Software Library for Interference Detection
+ * 
+ * Copyright (C) 2001-2003  Dtecta.  All rights reserved.
+ *
+ * This library may be distributed under the terms of the Q Public License
+ * (QPL) as defined by Trolltech AS of Norway and appearing in the file
+ * LICENSE.QPL included in the packaging of this file.
+ *
+ * This library may be distributed and/or modified under the terms of the
+ * GNU General Public License (GPL) version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * This library is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Commercial use or any other use of this library not covered by either 
+ * the QPL or the GPL requires an additional license from Dtecta. 
+ * Please contact info@dtecta.com for enquiries about the terms of commercial
+ * use of this library.
+ */
+
+#ifndef SOLID_TYPES_H
+#define SOLID_TYPES_H
+
+#ifndef DECLSPEC
+# ifdef WIN32
+#  define DECLSPEC __declspec(dllexport)
+# else
+#  define DECLSPEC
+# endif
+#endif
+
+#define DT_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name
+    
+
+typedef unsigned short DT_Index;
+typedef unsigned short DT_Count;
+typedef unsigned int   DT_Size;
+typedef float          DT_Scalar; 
+typedef int            DT_Bool;
+
+#define DT_FALSE 0
+#define DT_TRUE  1
+
+#define DT_CONTINUE 0
+#define DT_DONE 1
+
+typedef DT_Scalar DT_Vector3[3]; 
+typedef DT_Scalar DT_Quaternion[4]; 
+
+#endif
--- 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) {
--- 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;

-/* ---------- theme ----------- */
+typedef enum {
+#define BIFCOLORID_FIRST	(BUTGREY)
+	BUTGREY = 0,
+	BUTGREEN,
+	BUTBLUE,
+	BUTSALMON,
+	MIDGREY,
+	BUTPURPLE,
+	BUTYELLOW,
+	REDALERT,
+	BUTRUST,
+	BUTWHITE,
+	BUTDBLUE,
+	BUTPINK,
+	BUTDPINK,
+	BUTMACTIVE,
+
+	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 */
--- 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 */
 /* *********************** */


--- 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

--- 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
--- 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
--- 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
--- 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;
--- 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");


 }
--- 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;
--- 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();
--- 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);
 }
--- 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);
--- 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
 		{

--- 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
--- 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)
--- 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
--- 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();
--- 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)
 	{}
--- 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:
--- 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;
-
 }
--- 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;
--- 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);
--- 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;
--- 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 */

--- 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) 
 		{
--- 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(){
 	};
--- 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
-							 );
+  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_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();
+  m_map_blender_to_gameobject.clear();
+  m_map_mesh_to_gamemesh.clear();
+  m_map_gameobject_to_blender.clear();
 }


--- 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  */ 
--- 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;
--- 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
--- 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',
--- 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)
 {
 }

--- 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
 };

--- 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);
--- 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();
 }


--- 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
--- 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)
 {
 }

--- 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;
--- 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());
 	}
--- 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 */
--- 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)
 {
 }

--- 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 !)
--- 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);
 		}
--- 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
 		{

--- 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

 ###############################

--- 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) {
--- 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())
 							{
--- 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();		
 }
--- 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;
--- 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();
--- 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
--- 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()
--- 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
--- 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)
+				switch (objprop->m_boundclass)
 				{
-					complexshape = DT_Box(objprop->m_boundingbox.m_extends[0],objprop->m_boundingbox.m_extends[1],objprop->m_boundingbox.m_extends[2]);
-				} else
-				{
-					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];
-		
-		// only add polygons that have the collisionflag set
-		if (idx.m_collider)
-		{
-			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++;
+		RAS_Polygon* poly = meshobj->GetPolygon(p);
 	
-				{
-					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]);
-				}
-			}
-			DT_End();
+		// only add polygons that have the collisionflag set
+		if (poly->IsCollider())
+		{
+			numvalidpolys++;
+			break;
 		}
 	}
+	
+	if (numvalidpolys < 1)
+		return NULL;
+	
+	DT_ShapeHandle shape = DT_NewComplexShape(NULL);
+	
+	
+	numvalidpolys = 0;

+	for (int p2=0; p2<numpolys; p2++)
+	{
+		RAS_Polygon* poly = meshobj->GetPolygon(p2);
+	
+		// 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_EndComplexShape();

 	if (numvalidpolys > 0)
@@ -340,7 +380,7 @@ DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj)
 		return shape;
 	}

-	// memleak... todo: delete shape
+	delete shape;
 	return NULL;
 }

--- 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)
--- 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 */

--- 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);
--- 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.
 	 */
--- 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()));
--- 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)
 {
 };

--- 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_starttime (starttime),
-	m_endtime(endtime) ,
-	m_localtime(starttime),
-	m_recurse(recurse),
-	m_type((IpoActType)acttype) ,
-	m_direction(1),
 	m_bNegativeEvent(false),
+	m_starttime (starttime),
+	m_endtime(endtime),
+	m_recurse(recurse),
+	m_localtime(starttime),
+	m_direction(1),
 	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
 }
--- 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;
 	}
 }

--- 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();
--- 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();
 	
+	SumoPhysicsEnvironment *spe = dynamic_cast<SumoPhysicsEnvironment* > (m_kxscene->GetPhysicsEnvironment());
+	SM_Scene *sumoScene = spe->GetSumoScene();

-	//SM_Object* hitSMObj = m_sumoScene->rayTest(NULL, 
-	//										   frompoint3,
-	//										   topoint3,
-	//										   resultpoint, 
-	//										   resultnormal);
-	
-	KX_GameObject* hitKXObj = 0;
+	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
--- 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());
-	
-	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);
-	
-	if (m_sumoObj)
-	{
-		DT_SetObjectResponse(m_resptable,
-			m_sumoObj->getObjectHandle(),
-			collisionResponse,
-			DT_SIMPLE_RESPONSE,
-			this);
-	}
-
 	SCA_ISensor::ReParent(parent);
+	
+	m_client_info->m_clientobject = static_cast<KX_GameObject*>(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
--- 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);

 };
--- 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);
--- 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,
--- 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
--- 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)
 {
 }

--- 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
--- 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();
--- 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);
--- 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_axis(axis),
-					m_ketsjiScene(ketsjiScene),
-					m_rayHit(false),
+					m_scene(ketsjiScene),
 					m_bTriggered(false),
+					m_axis(axis),
+					m_rayHit(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 */
--- 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;
--- 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 */

--- 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;
+	}
+}
--- 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);
 };
--- 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;
 }

--- 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());
 }


--- 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();
--- 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;
--- 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);
+}
+
+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
--- 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
--- 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)
 {
+	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_sumoObj = ((KX_GameObject*)parent)->GetSumoObject();
-	m_solidHandle = m_sumoObj->getObjectHandle();
-
-	m_client_info.m_clientobject = NULL;//parent;
-	m_client_info.m_auxilary_info = NULL;
+//	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 */
--- 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);
-	}
-	
+	virtual void RegisterSumo(KX_TouchEventManager* touchman);

-	
-	void RegisterSumo();
-
-  	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

--- 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();
--- 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
--- 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)
--- a/source/gameengine/Physics/Sumo/Fuzzics/include/SM_Debug.h
+++ 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__ */
+
--- 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
--- 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
--- 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;
--- 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>
--- 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

--- 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())) {
-		
-		const MT_Vector3& ray_dir = fh_object->getRayDirection();
-		MT_Scalar dist = MT_distance(fh_object->getPosition(), 
-									 hit_object->getWorldCoord(lspot)) - 
-			cl_object->getMargin();
-
-		normal.normalize();
+	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(), lspot) - 
+			cl_object->getMargin() - shapeProps->m_radius;
+
+		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;
 }


--- 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;

-void SM_Object::boing(
+		// 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.
+
+#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;  
 	
-	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;
+		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
+		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));

-		// 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->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(
--- 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., &param, 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);
+}
--- 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
--- 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)
--- 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)
--- 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;
--- 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;
 }


--- 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();
--- 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();
+	}
+	for (bucket = m_AlphaBuckets.begin(); bucket != m_AlphaBuckets.end(); bucket++)
+	{
+		(*bucket)->ClearScheduledPolygons();
 	}

-	vector<RAS_MaterialBucket*> alphabuckets;
-
-	// if no visibility method is define, everything is drawn
-	
-	for (i=0;i<numbuckets;i++)
-	{
-		RAS_MaterialBucket** bucketptr = m_MaterialBuckets.at(i);
-		if (bucketptr)
-		{
-			if (!(*bucketptr)->IsTransparant())
-			{
-				(*bucketptr)->Render(cameratrans,rasty,rendertools);
-			} else
-			{
-				alphabuckets.push_back(*bucketptr);
-			}
-		}
-	}
+	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
-	{
-		bucket = *bucketptr;
+		if (*(*it)->GetPolyMaterial() == *material)
+			return *it;
 	}
-
+	
+	for (it = m_AlphaBuckets.begin(); it != m_AlphaBuckets.end(); it++)
+	{
+		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();
 }
--- 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();
--- 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()
 	);
 }

--- 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:
--- 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;

--- 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)
 	{
 	};

--- 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");
 	}
 }

--- 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;
--- 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)
--- 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);
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp
@@ -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;
-
-}
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h
@@ -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
-
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp
+++ 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;
+}
+
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h
+++ 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__ */
--- 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,
--- 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,
--- 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"
+
+#ifdef WIN32
 #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;
-
-
-
+#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
--- 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']

--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/mkglext.py
+++ 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")]
--- 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;
+}
--- 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
--- 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
 }