bullet: headers diff between 2.74 and 2.75 versions

	BasicDemo.h	BasicDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef BASIC_DEMO_H	#ifndef BASIC_DEMO_H
	#define BASIC_DEMO_H	#define BASIC_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"

	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;

	///BasicDemo is good starting point for learning the code base and porting.	///BasicDemo is good starting point for learning the code base and porting.

	class BasicDemo : public DemoApplication	class BasicDemo : public GlutDemoApplication
	{	{

	//keep the collision shapes, for deletion/cleanup	//keep the collision shapes, for deletion/cleanup
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	btBroadphaseInterface* m_broadphase;	btBroadphaseInterface* m_broadphase;

	btCollisionDispatcher* m_dispatcher;	btCollisionDispatcher* m_dispatcher;

	btConstraintSolver* m_solver;	btConstraintSolver* m_solver;

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	BenchmarkDemo.h	BenchmarkDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef BENCHMARK_DEMO_H	#ifndef BENCHMARK_DEMO_H
	#define BENCHMARK_DEMO_H	#define BENCHMARK_DEMO_H


	#include "DemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"

		#include "LinearMath/btTransform.h"

		class btDynamicsWorld;

	#define NUMRAYS 500	#define NUMRAYS 500


		class btRigidBody;
	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;


		#ifndef USE_GLUT_DEMO_APPLICATION
		///empty placeholder
		class DemoApplication
		{
		protected:

		btDynamicsWorld* m_dynamicsWorld;
		public:
		virtual void myinit() {}
		virtual btDynamicsWorld* getDynamicsWorld()
		{
		return m_dynamicsWorld;
		}

		btScalar getDeltaTimeMicroseconds()
		{
		return 1.f;
		}

		void renderme() {}
		void setCameraDistance(btScalar dist){}
		void clientResetScene(){}
		btRigidBody* localCreateRigidBody(float mass, const btTransform&
		startTransform,btCollisionShape* shape);

		};
	///BenchmarkDemo is provides several performance tests	///BenchmarkDemo is provides several performance tests
	class BenchmarkDemo : public DemoApplication	class BenchmarkDemo : public DemoApplication

		#else
		#include "GlutDemoApplication.h"
		class BenchmarkDemo : public GlutDemoApplication
		#endif

	{	{

	//keep the collision shapes, for deletion/cleanup	//keep the collision shapes, for deletion/cleanup
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	btAlignedObjectArray<class RagDoll*> m_ragdolls;	btAlignedObjectArray<class RagDoll*> m_ragdolls;

	btBroadphaseInterface* m_overlappingPairCache;	btBroadphaseInterface* m_overlappingPairCache;

	btCollisionDispatcher* m_dispatcher;	btCollisionDispatcher* m_dispatcher;

End of changes. 5 change blocks.
	1 lines changed or deleted	36 lines changed or added

	Box.h	Box.h

	skipping to change at line 25	skipping to change at line 25
	*/	*/

	#ifndef __BOX_H__	#ifndef __BOX_H__
	#define __BOX_H__	#define __BOX_H__

	#ifndef PE_REF	#ifndef PE_REF
	#define PE_REF(a) a&	#define PE_REF(a) a&
	#endif	#endif

	#include <math.h>	#include <math.h>


		//#include "BulletMultiThreaded/vectormath/scalar/cpp/vectormath_aos.h"
	#include <vectormath_aos.h>	#include <vectormath_aos.h>

	using namespace Vectormath::Aos;	using namespace Vectormath::Aos;

	enum FeatureType { F, E, V };	enum FeatureType { F, E, V };

	//------------------------------------------------------------------------- ---	//------------------------------------------------------------------------- ---
	// Box	// Box
	//------------------------------------------------------------------------- ---	//------------------------------------------------------------------------- ---
	///The Box is an internal class used by the boxBoxDistance calculation.	///The Box is an internal class used by the boxBoxDistance calculation.

End of changes. 1 change blocks.
	0 lines changed or deleted	2 lines changed or added

	BspDemo.h	BspDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef BSP_DEMO_H	#ifndef BSP_DEMO_H
	#define BSP_DEMO_H	#define BSP_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"

	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;

	///BspDemo shows the convex collision detection, by converting a Quake BSP file into convex objects and allowing interaction with boxes.	///BspDemo shows the convex collision detection, by converting a Quake BSP file into convex objects and allowing interaction with boxes.

	class BspDemo : public DemoApplication	class BspDemo : public GlutDemoApplication
	{	{
	public:	public:

	//keep the collision shapes, for deletion/cleanup	//keep the collision shapes, for deletion/cleanup
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	btBroadphaseInterface* m_broadphase;	btBroadphaseInterface* m_broadphase;

	btCollisionDispatcher* m_dispatcher;	btCollisionDispatcher* m_dispatcher;

	btConstraintSolver* m_solver;	btConstraintSolver* m_solver;

	btDefaultCollisionConfiguration* m_collisionConfiguration;	btDefaultCollisionConfiguration* m_collisionConfiguration;

	virtual ~BspDemo();	virtual ~BspDemo();


	void initPhysics(char* bspfilename);	virtual void initPhysics();

		void initPhysics(const char* bspfilename);

	virtual void clientMoveAndDisplay();	virtual void clientMoveAndDisplay();

	virtual void displayCallback();	virtual void displayCallback();

	static DemoApplication* Create()	static DemoApplication* Create()
	{	{
	BspDemo* demo = new BspDemo;	BspDemo* demo = new BspDemo;
	demo->myinit();	demo->myinit();
	demo->initPhysics("BspDemo.bsp");	demo->initPhysics("BspDemo.bsp");

End of changes. 3 change blocks.
	3 lines changed or deleted	5 lines changed or added

	Bullet-C-Api.h	Bullet-C-Api.h

	skipping to change at line 147	skipping to change at line 147

	/* get world transform */	/* get world transform */
	extern void plGetOpenGLMatrix(plRigidBodyHandle object, plReal* matrix);	extern void plGetOpenGLMatrix(plRigidBodyHandle object, plReal* matrix);
	extern void plGetPosition(plRigidBodyHandle object,plVector3 pos ition);	extern void plGetPosition(plRigidBodyHandle object,plVector3 pos ition);
	extern void plGetOrientation(plRigidBodyHandle object,plQuaternion o rientation);	extern void plGetOrientation(plRigidBodyHandle object,plQuaternion o rientation);

	/* set world transform (position/orientation) */	/* set world transform (position/orientation) */
	extern void plSetPosition(plRigidBodyHandle object, const plVector3 position);	extern void plSetPosition(plRigidBodyHandle object, const plVector3 position);
	extern void plSetOrientation(plRigidBodyHandle object, const plQuat ernion orientation);	extern void plSetOrientation(plRigidBodyHandle object, const plQuat ernion orientation);
	extern void plSetEuler(plReal yaw,plReal pitch,plReal roll, plQuate rnion orient);	extern void plSetEuler(plReal yaw,plReal pitch,plReal roll, plQuate rnion orient);

		extern void plSetOpenGLMatrix(plRigidBodyHandle object, plReal* mat rix);

	typedef struct plRayCastResult {	typedef struct plRayCastResult {
	plRigidBodyHandle m_body;	plRigidBodyHandle m_body;
	plCollisionShapeHandle m_shape;	plCollisionShapeHandle m_shape;
	plVector3 m_positionWorld;	plVector3 m_positionWorld;
	plVector3 m_normalWorld;	plVector3 m_normalWorld;
	} plRayCastResult;	} plRayCastResult;

	extern int plRayCast(plDynamicsWorldHandle world, const plVector3 r ayStart, const plVector3 rayEnd, plRayCastResult res);	extern int plRayCast(plDynamicsWorldHandle world, const plVector3 r ayStart, const plVector3 rayEnd, plRayCastResult res);


End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	CcdPhysicsDemo.h	CcdPhysicsDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef CCD_PHYSICS_DEMO_H	#ifndef CCD_PHYSICS_DEMO_H
	#define CCD_PHYSICS_DEMO_H	#define CCD_PHYSICS_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"

	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;

	///CcdPhysicsDemo shows basic stacking using Bullet physics, and allows tog gle of Ccd (using key '1')	///CcdPhysicsDemo shows basic stacking using Bullet physics, and allows tog gle of Ccd (using key '1')

	class CcdPhysicsDemo : public DemoApplication	class CcdPhysicsDemo : public GlutDemoApplication
	{	{

	//keep the collision shapes, for deletion/cleanup	//keep the collision shapes, for deletion/cleanup
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	btBroadphaseInterface* m_broadphase;	btBroadphaseInterface* m_broadphase;

	btCollisionDispatcher* m_dispatcher;	btCollisionDispatcher* m_dispatcher;

	#ifdef USE_PARALLEL_DISPATCHER	#ifdef USE_PARALLEL_DISPATCHER

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	CharacterDemo.h	CharacterDemo.h

	skipping to change at line 29	skipping to change at line 29
	//#define DYNAMIC_CHARACTER_CONTROLLER 1	//#define DYNAMIC_CHARACTER_CONTROLLER 1

	#include "BulletCollision/CollisionShapes/btConvexHullShape.h"	#include "BulletCollision/CollisionShapes/btConvexHullShape.h"

	class btCharacterControllerInterface;	class btCharacterControllerInterface;
	class btDynamicCharacterController;	class btDynamicCharacterController;
	class btKinematicCharacterController;	class btKinematicCharacterController;

	class btCollisionShape;	class btCollisionShape;


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"

	///CharacterDemo shows how to setup and use the built-in raycast vehicle	///CharacterDemo shows how to setup and use the built-in raycast vehicle

	class CharacterDemo : public DemoApplication	class CharacterDemo : public GlutDemoApplication
	{	{
	public:	public:

	#ifdef DYNAMIC_CHARACTER_CONTROLLER	#ifdef DYNAMIC_CHARACTER_CONTROLLER
	btCharacterControllerInterface* m_character;	btCharacterControllerInterface* m_character;
	#else	#else
	btKinematicCharacterController* m_character;	btKinematicCharacterController* m_character;
	class btPairCachingGhostObject* m_ghostObject;	class btPairCachingGhostObject* m_ghostObject;
	#endif	#endif


End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	CollisionDemo.h	CollisionDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef COLLISION_DEMO_H	#ifndef COLLISION_DEMO_H
	#define COLLISION_DEMO_H	#define COLLISION_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"

	///CollisionDemo shows the low-level direct access to GJK	///CollisionDemo shows the low-level direct access to GJK

	class CollisionDemo : public DemoApplication	class CollisionDemo : public GlutDemoApplication
	{	{
	public:	public:

	void initPhysics();	void initPhysics();

	virtual void clientMoveAndDisplay();	virtual void clientMoveAndDisplay();

	virtual void displayCallback();	virtual void displayCallback();

	};	};

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	ConcaveDemo.h	ConcaveDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef CONCAVE_DEMO_H	#ifndef CONCAVE_DEMO_H
	#define CONCAVE_DEMO_H	#define CONCAVE_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"

	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;
	class btTriangleIndexVertexArray;	class btTriangleIndexVertexArray;

	///ConcaveDemo shows usage of static concave triangle meshes	///ConcaveDemo shows usage of static concave triangle meshes
	///It also shows per-triangle material (friction/restitution) through Custo mMaterialCombinerCallback	///It also shows per-triangle material (friction/restitution) through Custo mMaterialCombinerCallback

	class ConcaveDemo : public DemoApplication	class ConcaveDemo : public GlutDemoApplication
	{	{

	//keep the collision shapes, for deletion/cleanup	//keep the collision shapes, for deletion/cleanup
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	btTriangleIndexVertexArray* m_indexVertexArrays;	btTriangleIndexVertexArray* m_indexVertexArrays;

	btBroadphaseInterface* m_broadphase;	btBroadphaseInterface* m_broadphase;

	btCollisionDispatcher* m_dispatcher;	btCollisionDispatcher* m_dispatcher;

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	ConstraintDemo.h	ConstraintDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef CONSTRAINT_DEMO_H	#ifndef CONSTRAINT_DEMO_H
	#define CONSTRAINT_DEMO_H	#define CONSTRAINT_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"

	///ConstraintDemo shows how to create a constraint, like Hinge or btGeneric D6constraint	///ConstraintDemo shows how to create a constraint, like Hinge or btGeneric D6constraint

	class ConstraintDemo : public DemoApplication	class ConstraintDemo : public GlutDemoApplication
	{	{
	//keep track of variables to delete memory at the end	//keep track of variables to delete memory at the end
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	class btBroadphaseInterface* m_overlappingPairCache;	class btBroadphaseInterface* m_overlappingPairCache;

	class btCollisionDispatcher* m_dispatcher;	class btCollisionDispatcher* m_dispatcher;

	class btConstraintSolver* m_constraintSolver;	class btConstraintSolver* m_constraintSolver;


	skipping to change at line 52	skipping to change at line 52
	virtual void displayCallback();	virtual void displayCallback();

	static DemoApplication* Create()	static DemoApplication* Create()
	{	{
	ConstraintDemo* demo = new ConstraintDemo();	ConstraintDemo* demo = new ConstraintDemo();
	demo->myinit();	demo->myinit();
	demo->initPhysics();	demo->initPhysics();
	return demo;	return demo;
	}	}


		// for cone-twist motor driving
		float m_Time;
		class btConeTwistConstraint* m_ctc;

	};	};

	#endif //CONSTRAINT_DEMO_H	#endif //CONSTRAINT_DEMO_H

End of changes. 3 change blocks.
	2 lines changed or deleted	6 lines changed or added

	ContinuousConvexCollision.h	ContinuousConvexCollision.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef CONTINUOUS_CONVEX_COLLISION_DEMO_H	#ifndef CONTINUOUS_CONVEX_COLLISION_DEMO_H
	#define CONTINUOUS_CONVEX_COLLISION_DEMO_H	#define CONTINUOUS_CONVEX_COLLISION_DEMO_H


	#include "DemoApplication.h"

	///ContinuousConvexCollisionDemo shows the working of the continuous collis ion detection, including linear and angular motion	///ContinuousConvexCollisionDemo shows the working of the continuous collis ion detection, including linear and angular motion

	class btContinuousConvexCollisionDemo : public DemoApplication	#include "GlutDemoApplication.h"
		class btContinuousConvexCollisionDemo : public GlutDemoApplication
	{	{
	public:	public:

	void initPhysics();	void initPhysics();

	virtual void clientMoveAndDisplay();	virtual void clientMoveAndDisplay();

	virtual void displayCallback();	virtual void displayCallback();

	};	};

End of changes. 2 change blocks.
	3 lines changed or deleted	2 lines changed or added

	ConvexDecompositionDemo.h	ConvexDecompositionDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef CONVEX_DECOMPOSITION_DEMO_H	#ifndef CONVEX_DECOMPOSITION_DEMO_H
	#define CONVEX_DECOMPOSITION_DEMO_H	#define CONVEX_DECOMPOSITION_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"

	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;
	class btTriangleMesh;	class btTriangleMesh;

	///ConvexDecompositionDemo shows automatic convex decomposition of a concav e mesh	///ConvexDecompositionDemo shows automatic convex decomposition of a concav e mesh

	class ConvexDecompositionDemo : public DemoApplication	class ConvexDecompositionDemo : public GlutDemoApplication
	{	{

	public:	public:

	//keep the collision shapes, for deletion/cleanup	//keep the collision shapes, for deletion/cleanup
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	btAlignedObjectArray<btTriangleMesh*> m_trimeshes;	btAlignedObjectArray<btTriangleMesh*> m_trimeshes;

	btBroadphaseInterface* m_broadphase;	btBroadphaseInterface* m_broadphase;

	btCollisionDispatcher* m_dispatcher;	btCollisionDispatcher* m_dispatcher;

	btConstraintSolver* m_solver;	btConstraintSolver* m_solver;

	btDefaultCollisionConfiguration* m_collisionConfiguration;	btDefaultCollisionConfiguration* m_collisionConfiguration;


		virtual void initPhysics();

	void initPhysics(const char* filename);	void initPhysics(const char* filename);

	void exitPhysics();	void exitPhysics();

	virtual ~ConvexDecompositionDemo()	virtual ~ConvexDecompositionDemo()
	{	{
	exitPhysics();	exitPhysics();
	}	}

	virtual void clientMoveAndDisplay();	virtual void clientMoveAndDisplay();

End of changes. 3 change blocks.
	2 lines changed or deleted	4 lines changed or added

	DemoApplication.h	DemoApplication.h

	skipping to change at line 63	skipping to change at line 63
	btCollisionShape* m_shootBoxShape;	btCollisionShape* m_shootBoxShape;

	float m_cameraDistance;	float m_cameraDistance;
	int m_debugMode;	int m_debugMode;

	float m_ele;	float m_ele;
	float m_azi;	float m_azi;
	btVector3 m_cameraPosition;	btVector3 m_cameraPosition;
	btVector3 m_cameraTargetPosition;//look at	btVector3 m_cameraTargetPosition;//look at


		int m_mouseOldX;
		int m_mouseOldY;
		int m_mouseButtons;
		public:
		int m_modifierKeys;
		protected:

	float m_scaleBottom;	float m_scaleBottom;
	float m_scaleFactor;	float m_scaleFactor;
	btVector3 m_cameraUp;	btVector3 m_cameraUp;
	int m_forwardAxis;	int m_forwardAxis;

	int m_glutScreenWidth;	int m_glutScreenWidth;
	int m_glutScreenHeight;	int m_glutScreenHeight;


		int m_ortho;

	float m_ShootBoxInitialSpeed;	float m_ShootBoxInitialSpeed;

	bool m_stepping;	bool m_stepping;
	bool m_singleStep;	bool m_singleStep;
	bool m_idle;	bool m_idle;
	int m_lastKey;	int m_lastKey;


	void showProfileInfo(float& xOffset,float& yStart, float yIncr);	void showProfileInfo(int& xOffset,int& yStart, int yIncr);
	void renderscene(int pass);	void renderscene(int pass);

	GL_ShapeDrawer* m_shapeDrawer;	GL_ShapeDrawer* m_shapeDrawer;
	bool m_enableshadows;	bool m_enableshadows;
	btVector3 m_sundirection;	btVector3 m_sundirection;

	public:	public:

	DemoApplication();	DemoApplication();

	virtual ~DemoApplication();	virtual ~DemoApplication();

	btDynamicsWorld* getDynamicsWorld()	btDynamicsWorld* getDynamicsWorld()
	{	{
	return m_dynamicsWorld;	return m_dynamicsWorld;
	}	}


		virtual void initPhysics() = 0;

	virtual void setDrawClusters(bool drawClusters)	virtual void setDrawClusters(bool drawClusters)
	{	{

	}	}

	void overrideGLShapeDrawer (GL_ShapeDrawer* shapeDrawer);	void overrideGLShapeDrawer (GL_ShapeDrawer* shapeDrawer);

	void setOrthographicProjection();	void setOrthographicProjection();
	void resetPerspectiveProjection();	void resetPerspectiveProjection();


	skipping to change at line 176	skipping to change at line 187
	float getCameraDistance();	float getCameraDistance();
	void setCameraDistance(float dist);	void setCameraDistance(float dist);
	void moveAndDisplay();	void moveAndDisplay();

	virtual void clientMoveAndDisplay() = 0;	virtual void clientMoveAndDisplay() = 0;

	virtual void clientResetScene();	virtual void clientResetScene();

	///Demo functions	///Demo functions
	virtual void setShootBoxShape ();	virtual void setShootBoxShape ();

	void shootBox(const btVector3& destination);	virtual void shootBox(const btVector3& destination);

	btVector3 getRayTo(int x,int y);	btVector3 getRayTo(int x,int y);

	btRigidBody* localCreateRigidBody(float mass, const btTransform& startTransform,btCollisionShape* shape);	btRigidBody* localCreateRigidBody(float mass, const btTransform& startTransform,btCollisionShape* shape);

	///callback methods by glut	///callback methods by glut

	virtual void keyboardCallback(unsigned char key, int x, int y);	virtual void keyboardCallback(unsigned char key, int x, int y);


	virtual void specialKeyboard(int key, int x, int y);	virtual void keyboardUpCallback(unsigned char key, int x, int y) {}


	virtual void specialKeyboardUp(int key, int x, int y);	virtual void specialKeyboard(int key, int x, int y){}

		virtual void specialKeyboardUp(int key, int x, int y){}

	virtual void reshape(int w, int h);	virtual void reshape(int w, int h);

	virtual void mouseFunc(int button, int state, int x, int y);	virtual void mouseFunc(int button, int state, int x, int y);

	virtual void mouseMotionFunc(int x,int y);	virtual void mouseMotionFunc(int x,int y);

	virtual void displayCallback();	virtual void displayCallback();

	virtual void renderme();	virtual void renderme();


		virtual void swapBuffers() = 0;

		virtual void updateModifierKeys() = 0;

	void stepLeft();	void stepLeft();
	void stepRight();	void stepRight();
	void stepFront();	void stepFront();
	void stepBack();	void stepBack();
	void zoomIn();	void zoomIn();
	void zoomOut();	void zoomOut();

	bool isIdle() const	bool isIdle() const
	{	{
	return m_idle;	return m_idle;

End of changes. 8 change blocks.
	4 lines changed or deleted	21 lines changed or added

	ForkLiftDemo.h	ForkLiftDemo.h

	skipping to change at line 26	skipping to change at line 26
	#define FORKLIFT_DEMO_H	#define FORKLIFT_DEMO_H

	class btVehicleTuning;	class btVehicleTuning;
	struct btVehicleRaycaster;	struct btVehicleRaycaster;
	class btCollisionShape;	class btCollisionShape;

	#include "BulletDynamics/Vehicle/btRaycastVehicle.h"	#include "BulletDynamics/Vehicle/btRaycastVehicle.h"
	#include "BulletDynamics/ConstraintSolver/btHingeConstraint.h"	#include "BulletDynamics/ConstraintSolver/btHingeConstraint.h"
	#include "BulletDynamics/ConstraintSolver/btSliderConstraint.h"	#include "BulletDynamics/ConstraintSolver/btSliderConstraint.h"


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"

	///VehicleDemo shows how to setup and use the built-in raycast vehicle	///VehicleDemo shows how to setup and use the built-in raycast vehicle

	class ForkLiftDemo : public DemoApplication	class ForkLiftDemo : public GlutDemoApplication
	{	{
	public:	public:

	btRigidBody* m_carChassis;	btRigidBody* m_carChassis;

	//----------------------------	//----------------------------
	btRigidBody* m_liftBody;	btRigidBody* m_liftBody;
	btVector3 m_liftStartPos;	btVector3 m_liftStartPos;
	btHingeConstraint* m_liftHinge;	btHingeConstraint* m_liftHinge;


	skipping to change at line 70	skipping to change at line 70

	class btDefaultCollisionConfiguration* m_collisionConfiguration;	class btDefaultCollisionConfiguration* m_collisionConfiguration;

	class btTriangleIndexVertexArray* m_indexVertexArrays;	class btTriangleIndexVertexArray* m_indexVertexArrays;

	btVector3* m_vertices;	btVector3* m_vertices;

	btRaycastVehicle::btVehicleTuning m_tuning;	btRaycastVehicle::btVehicleTuning m_tuning;
	btVehicleRaycaster* m_vehicleRayCaster;	btVehicleRaycaster* m_vehicleRayCaster;
	btRaycastVehicle* m_vehicle;	btRaycastVehicle* m_vehicle;

		btCollisionShape* m_wheelShape;

	float m_cameraHeight;	float m_cameraHeight;

	float m_minCameraDistance;	float m_minCameraDistance;
	float m_maxCameraDistance;	float m_maxCameraDistance;

	ForkLiftDemo();	ForkLiftDemo();

	virtual ~ForkLiftDemo();	virtual ~ForkLiftDemo();


End of changes. 3 change blocks.
	2 lines changed or deleted	3 lines changed or added

	GL_ShapeDrawer.h	GL_ShapeDrawer.h

	skipping to change at line 60	skipping to change at line 60
	virtual void drawOpenGL(btScalar* m, const btColl isionShape* shape, const btVector3& color,int debugMode,const btVecto r3& worldBoundsMin,const btVector3& worldBoundsMax);	virtual void drawOpenGL(btScalar* m, const btColl isionShape* shape, const btVector3& color,int debugMode,const btVecto r3& worldBoundsMin,const btVector3& worldBoundsMax);
	virtual void drawShadow(btScalar* m, const btVect or3& extrusion,const btCollisionShape* shape,const btVector3& worldBoundsMi n,const btVector3& worldBoundsMax);	virtual void drawShadow(btScalar* m, const btVect or3& extrusion,const btCollisionShape* shape,const btVector3& worldBoundsMi n,const btVector3& worldBoundsMax);

	bool enableTexture(bool enable) { bool p=m_textur eenabled;m_textureenabled=enable;return(p); }	bool enableTexture(bool enable) { bool p=m_textur eenabled;m_textureenabled=enable;return(p); }
	bool hasTextureEnabled() const	bool hasTextureEnabled() const
	{	{
	return m_textureenabled;	return m_textureenabled;
	}	}

	static void drawCylinder(float radius,float half Height, int upAxis);	static void drawCylinder(float radius,float half Height, int upAxis);

		void drawSphere(btScalar r, int lats, int longs);
	static void drawCoordSystem();	static void drawCoordSystem();

	};	};

	void OGL_displaylist_register_shape(btCollisionShape * shape);	void OGL_displaylist_register_shape(btCollisionShape * shape);
	void OGL_displaylist_clean();	void OGL_displaylist_clean();

	#endif //GL_SHAPE_DRAWER_H	#endif //GL_SHAPE_DRAWER_H

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	GenericJointDemo.h	GenericJointDemo.h

	skipping to change at line 22	skipping to change at line 22
	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

	Written by: Marten Svanfeldt	Written by: Marten Svanfeldt
	*/	*/

	#ifndef GENERIGJOINTDEMO_H	#ifndef GENERIGJOINTDEMO_H
	#define GENERIGJOINTDEMO_H	#define GENERIGJOINTDEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"
	#include "Ragdoll.h"	#include "Ragdoll.h"


	class GenericJointDemo : public DemoApplication	class GenericJointDemo : public GlutDemoApplication
	{	{

	btAlignedObjectArray<class RagDoll*> m_ragdolls;	btAlignedObjectArray<class RagDoll*> m_ragdolls;

	public:	public:
	void initPhysics();	void initPhysics();

	void spawnRagdoll(bool random = false);	void spawnRagdoll(bool random = false);

	virtual void clientMoveAndDisplay();	virtual void clientMoveAndDisplay();

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	GimpactTestDemo.h	GimpactTestDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef TEST_CONCAVE_DEMO_H	#ifndef TEST_CONCAVE_DEMO_H
	#define TEST_CONCAVE_DEMO_H	#define TEST_CONCAVE_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	class btTriangleIndexVertexArray;	class btTriangleIndexVertexArray;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;

	//#define BULLET_TRIANGLE_COLLISION 1	//#define BULLET_TRIANGLE_COLLISION 1
	#define BULLET_GIMPACT 1	#define BULLET_GIMPACT 1

	#define BULLET_GIMPACT_CONVEX_DECOMPOSITION 1	//#define BULLET_GIMPACT_CONVEX_DECOMPOSITION 1

	#define TEST_GIMPACT_TORUS	#define TEST_GIMPACT_TORUS

	#ifdef BULLET_GIMPACT	#ifdef BULLET_GIMPACT

	#include "BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h"	#include "BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h"
	#ifdef BULLET_GIMPACT_CONVEX_DECOMPOSITION	#ifdef BULLET_GIMPACT_CONVEX_DECOMPOSITION
	#include "../Extras/GIMPACTUtils/btGImpactConvexDecompositionShape.h "	#include "../Extras/GIMPACTUtils/btGImpactConvexDecompositionShape.h "
	#endif	#endif


	skipping to change at line 47	skipping to change at line 47
	#include "BulletCollision/Gimpact/btConcaveConcaveCollisionAlgorithm.h"	#include "BulletCollision/Gimpact/btConcaveConcaveCollisionAlgorithm.h"
	#include "BulletCollision/Gimpact/btGIMPACTMeshShape.h"	#include "BulletCollision/Gimpact/btGIMPACTMeshShape.h"

	#endif	#endif

	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;

	///GimpactConcaveDemo shows usage of static concave triangle meshes	///GimpactConcaveDemo shows usage of static concave triangle meshes
	///It also shows per-triangle material (friction/restitution) through Custo mMaterialCombinerCallback	///It also shows per-triangle material (friction/restitution) through Custo mMaterialCombinerCallback

	class GimpactConcaveDemo : public DemoApplication	class GimpactConcaveDemo : public GlutDemoApplication
	{	{

	public:	public:
	GimpactConcaveDemo()	GimpactConcaveDemo()
	: m_trimeshShape(NULL),	: m_trimeshShape(NULL),
	m_trimeshShape2(NULL),	m_trimeshShape2(NULL),
	m_indexVertexArrays(NULL),	m_indexVertexArrays(NULL),
	m_indexVertexArrays2(NULL),	m_indexVertexArrays2(NULL),
	m_collisionConfiguration(NULL),	m_collisionConfiguration(NULL),
	m_dispatcher(NULL),	m_dispatcher(NULL),

End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	GlutStuff.h	GlutStuff.h

	skipping to change at line 28	skipping to change at line 28
	#ifdef WIN32//for glut.h	#ifdef WIN32//for glut.h
	#include <windows.h>	#include <windows.h>
	#endif	#endif

	//think different	//think different
	#if defined(__APPLE__) && !defined (VMDMESA)	#if defined(__APPLE__) && !defined (VMDMESA)
	#include <OpenGL/gl.h>	#include <OpenGL/gl.h>
	#include <OpenGL/glu.h>	#include <OpenGL/glu.h>
	#include <GLUT/glut.h>	#include <GLUT/glut.h>
	#else	#else


	#include <GL/glut.h>	#include <GL/glut.h>

		#ifdef _WINDOWS
		#include <windows.h>
		#include <GL/gl.h>
		#include <GL/glu.h>
		#endif
	#endif	#endif


		#define BT_KEY_K 'k'
		#define BT_KEY_LEFT GLUT_KEY_LEFT
		#define BT_KEY_RIGHT GLUT_KEY_RIGHT
		#define BT_KEY_UP GLUT_KEY_UP
		#define BT_KEY_DOWN GLUT_KEY_DOWN
		#define BT_KEY_F1 GLUT_KEY_F1
		#define BT_KEY_F2 GLUT_KEY_F2
		#define BT_KEY_F3 GLUT_KEY_F3
		#define BT_KEY_F4 GLUT_KEY_F4
		#define BT_KEY_F5 GLUT_KEY_F5
		#define BT_KEY_PAGEUP GLUT_KEY_PAGE_UP
		#define BT_KEY_PAGEDOWN GLUT_KEY_PAGE_DOWN
		#define BT_KEY_END GLUT_KEY_END
		#define BT_KEY_HOME GLUT_KEY_HOME
		#define BT_ACTIVE_ALT GLUT_ACTIVE_ALT
		#define BT_ACTIVE_CTRL GLUT_ACTIVE_ALT
		#define BT_ACTIVE_SHIFT GLUT_ACTIVE_SHIFT

	#if BT_USE_FREEGLUT	#if BT_USE_FREEGLUT
	#include "GL/freeglut_ext.h" //to be able to return from glutMainLoop()	#include "GL/freeglut_ext.h" //to be able to return from glutMainLoop()
	#endif	#endif

	class DemoApplication;	class DemoApplication;

	int glutmain(int argc, char *argv,int width,int height,const char title,D emoApplication* demoApp);	int glutmain(int argc, char *argv,int width,int height,const char title,D emoApplication* demoApp);

	#if defined(BT_USE_DOUBLE_PRECISION)	#if defined(BT_USE_DOUBLE_PRECISION)
	#define btglLoadMatrix glLoadMatrixd	#define btglLoadMatrix glLoadMatrixd

End of changes. 3 change blocks.
	0 lines changed or deleted	24 lines changed or added

	HfFluidDemo.h	HfFluidDemo.h

	skipping to change at line 21	skipping to change at line 21
	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

	Experimental Buoyancy fluid demo written by John McCutchan	Experimental Buoyancy fluid demo written by John McCutchan
	*/	*/

	#ifndef HFFLUID_DEMO_H	#ifndef HFFLUID_DEMO_H
	#define HFFLUID_DEMO_H	#define HFFLUID_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"
	#include "BulletHfFluid/btHfFluid.h"	#include "BulletHfFluid/btHfFluid.h"

	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;

	class btHfFluidRigidDynamicsWorld;	class btHfFluidRigidDynamicsWorld;
	///collisions between a btSoftBody and a btRigidBody	///collisions between a btSoftBody and a btRigidBody
	class btFluidRididCollisionAlgorithm;	class btFluidRididCollisionAlgorithm;

	///experimental buyancy fluid demo	///experimental buyancy fluid demo
	///CcdPhysicsDemo shows basic stacking using Bullet physics, and allows tog gle of Ccd (using key '1')	///CcdPhysicsDemo shows basic stacking using Bullet physics, and allows tog gle of Ccd (using key '1')

	class HfFluidDemo : public DemoApplication	class HfFluidDemo : public GlutDemoApplication
	{	{
	public:	public:
	btAlignedObjectArray<btFluidRididCollisionAlgorithm*> m_FluidRigidCo llisionAlgorithms;	btAlignedObjectArray<btFluidRididCollisionAlgorithm*> m_FluidRigidCo llisionAlgorithms;

	bool m_au tocam;	bool m_au tocam;
	bool m_cu tting;	bool m_cu tting;
	bool m_ra ycast;	bool m_ra ycast;
	btScalar m_an imtime;	btScalar m_an imtime;
	btClock m_cl ock;	btClock m_cl ock;
	int m_lastmousepos[2];	int m_lastmousepos[2];

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	MotorDemo.h	MotorDemo.h

	skipping to change at line 19	skipping to change at line 19
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef MOTORDEMO_H	#ifndef MOTORDEMO_H
	#define MOTORDEMO_H	#define MOTORDEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"
	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;


	class MotorDemo : public DemoApplication	class MotorDemo : public GlutDemoApplication
	{	{
	float m_Time;	float m_Time;
	float m_fCyclePeriod; // in milliseconds	float m_fCyclePeriod; // in milliseconds
	float m_fMuscleStrength;	float m_fMuscleStrength;

	btAlignedObjectArray<class TestRig*> m_rigs;	btAlignedObjectArray<class TestRig*> m_rigs;

	//keep the collision shapes, for deletion/cleanup	//keep the collision shapes, for deletion/cleanup
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;


	skipping to change at line 74	skipping to change at line 74
	virtual void keyboardCallback(unsigned char key, int x, int y);	virtual void keyboardCallback(unsigned char key, int x, int y);

	static DemoApplication* Create()	static DemoApplication* Create()
	{	{
	MotorDemo* demo = new MotorDemo();	MotorDemo* demo = new MotorDemo();
	demo->myinit();	demo->myinit();
	demo->initPhysics();	demo->initPhysics();
	return demo;	return demo;
	}	}


		void setMotorTargets(btScalar deltaTime);

	};	};

	#endif	#endif

End of changes. 3 change blocks.
	2 lines changed or deleted	4 lines changed or added

	MultiMaterialDemo.h	MultiMaterialDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef CONCAVE_DEMO_H	#ifndef CONCAVE_DEMO_H
	#define CONCAVE_DEMO_H	#define CONCAVE_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"

	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;
	class btTriangleIndexVertexArray;	class btTriangleIndexVertexArray;

	///MultiMaterialDemo shows usage of static concave triangle meshes	///MultiMaterialDemo shows usage of static concave triangle meshes
	///It also shows per-triangle material (friction/restitution) through Custo mMaterialCombinerCallback	///It also shows per-triangle material (friction/restitution) through Custo mMaterialCombinerCallback

	class MultiMaterialDemo : public DemoApplication	class MultiMaterialDemo : public GlutDemoApplication
	{	{

	//keep the collision shapes, for deletion/cleanup	//keep the collision shapes, for deletion/cleanup
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	btTriangleIndexVertexArray* m_indexVertexArrays;	btTriangleIndexVertexArray* m_indexVertexArrays;

	btBroadphaseInterface* m_broadphase;	btBroadphaseInterface* m_broadphase;

	btCollisionDispatcher* m_dispatcher;	btCollisionDispatcher* m_dispatcher;

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	MultiThreadedDemo.h	MultiThreadedDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef MULTI_THREADED_DEMO_H	#ifndef MULTI_THREADED_DEMO_H
	#define MULTI_THREADED_DEMO_H	#define MULTI_THREADED_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"

	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;

	///MultiThreadedDemo shows basic stacking using Bullet physics, and allows toggle of Ccd (using key '1')	///MultiThreadedDemo shows basic stacking using Bullet physics, and allows toggle of Ccd (using key '1')

	class MultiThreadedDemo : public DemoApplication	class MultiThreadedDemo : public GlutDemoApplication
	{	{

	//keep the collision shapes, for deletion/cleanup	//keep the collision shapes, for deletion/cleanup
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	btBroadphaseInterface* m_broadphase;	btBroadphaseInterface* m_broadphase;

	btCollisionDispatcher* m_dispatcher;	btCollisionDispatcher* m_dispatcher;

	class btThreadSupportInterface* m_threadSupportColli sion;	class btThreadSupportInterface* m_threadSupportColli sion;

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	PosixThreadSupport.h	PosixThreadSupport.h

	skipping to change at line 111	skipping to change at line 111
	virtual void waitForResponse(unsigned int puiArgument0, unsigned in t puiArgument1);	virtual void waitForResponse(unsigned int puiArgument0, unsigned in t puiArgument1);

	///start the spus (can be called at the beginning of each frame, to make su re that the right SPU program is loaded)	///start the spus (can be called at the beginning of each frame, to make su re that the right SPU program is loaded)
	virtual void startSPU();	virtual void startSPU();

	///tell the task scheduler we are done with the SPU tasks	///tell the task scheduler we are done with the SPU tasks
	virtual void stopSPU();	virtual void stopSPU();

	virtual void setNumTasks(int numTasks) {}	virtual void setNumTasks(int numTasks) {}


		virtual int getNumTasks() const
		{
		return m_activeSpuStatus.size();
		}
	};	};

	#endif // POSIX_THREAD_SUPPORT_H	#endif // POSIX_THREAD_SUPPORT_H

	#endif // USE_PTHREADS	#endif // USE_PTHREADS

End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	PpuAddressSpace.h	PpuAddressSpace.h
	#ifndef __PPU_ADDRESS_SPACE_H	#ifndef __PPU_ADDRESS_SPACE_H
	#define __PPU_ADDRESS_SPACE_H	#define __PPU_ADDRESS_SPACE_H

	#ifdef WIN32	#ifdef WIN32
	//stop those casting warnings until we have a better solution for ppu_addre ss_t / void* / uint64 conversions	//stop those casting warnings until we have a better solution for ppu_addre ss_t / void* / uint64 conversions
	#pragma warning (disable: 4311)	#pragma warning (disable: 4311)
	#pragma warning (disable: 4312)	#pragma warning (disable: 4312)
	#endif //WIN32	#endif //WIN32


	#ifdef USE_ADDR64	#if defined(_WIN64) \|\| defined(__LP64__) \|\| defined(__x86_64__) \|\| defined( USE_ADDR64)
	typedef uint64_t ppu_address_t;	typedef uint64_t ppu_address_t;
	#else	#else
	typedef uint32_t ppu_address_t;	typedef uint32_t ppu_address_t;
	#endif	#endif

	#endif	#endif

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	RagdollDemo.h	RagdollDemo.h

	skipping to change at line 22	skipping to change at line 22
	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

	Written by: Marten Svanfeldt	Written by: Marten Svanfeldt
	*/	*/

	#ifndef RAGDOLLDEMO_H	#ifndef RAGDOLLDEMO_H
	#define RAGDOLLDEMO_H	#define RAGDOLLDEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"
	class btBroadphaseInterface;	class btBroadphaseInterface;
	class btCollisionShape;	class btCollisionShape;
	class btOverlappingPairCache;	class btOverlappingPairCache;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btConstraintSolver;	class btConstraintSolver;
	struct btCollisionAlgorithmCreateFunc;	struct btCollisionAlgorithmCreateFunc;
	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;


	class RagdollDemo : public DemoApplication	class RagdollDemo : public GlutDemoApplication
	{	{

	btAlignedObjectArray<class RagDoll*> m_ragdolls;	btAlignedObjectArray<class RagDoll*> m_ragdolls;

	//keep the collision shapes, for deletion/cleanup	//keep the collision shapes, for deletion/cleanup
	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	btBroadphaseInterface* m_broadphase;	btBroadphaseInterface* m_broadphase;

	btCollisionDispatcher* m_dispatcher;	btCollisionDispatcher* m_dispatcher;

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	Raytracer.h	Raytracer.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef RAYTRACER_H	#ifndef RAYTRACER_H
	#define RAYTRACER_H	#define RAYTRACER_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"

	class btDefaultCollisionConfiguration;	class btDefaultCollisionConfiguration;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btAxisSweep3;	class btAxisSweep3;
	class btCollisionWorld;	class btCollisionWorld;

	///Raytracer shows the inner working of the ray casting, using ray tracing rendering into a texture.	///Raytracer shows the inner working of the ray casting, using ray tracing rendering into a texture.

	class Raytracer : public DemoApplication	class Raytracer : public GlutDemoApplication
	{	{

	btDefaultCollisionConfiguration* m_collisionConfiguration;	btDefaultCollisionConfiguration* m_collisionConfiguration;
	btCollisionDispatcher* m_dispatcher;	btCollisionDispatcher* m_dispatcher;
	btAxisSweep3* m_overlappingPairCache;	btAxisSweep3* m_overlappingPairCache;
	btCollisionWorld* m_collisionWorld;	btCollisionWorld* m_collisionWorld;
	bool m_initialized;	bool m_initialized;

	public:	public:


End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	RenderTexture.h	RenderTexture.h

	skipping to change at line 20	skipping to change at line 20

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef RENDER_TEXTURE_H	#ifndef RENDER_TEXTURE_H
	#define RENDER_TEXTURE_H	#define RENDER_TEXTURE_H

	#include "LinearMath/btVector3.h"	#include "LinearMath/btVector3.h"

	#include "BMF_FontData.h"	#include "GLDebugFont.h"

	///	///
	///renderTexture provides a software-render context (setpixel/printf)	///renderTexture provides a software-render context (setpixel/printf)
	///	///
	class renderTexture	class renderTexture
	{	{
	int m_height;	int m_height;
	int m_width;	int m_width;
	unsigned char* m_buffer;	unsigned char* m_buffer;


	skipping to change at line 58	skipping to change at line 58
	unsigned char* pixel = &m_buffer[ (x+ym_width) 4];	unsigned char* pixel = &m_buffer[ (x+ym_width) 4];
	return btVector4(pixel[0]*1.f/255.f,	return btVector4(pixel[0]*1.f/255.f,
	pixel[1]*1.f/255.f,	pixel[1]*1.f/255.f,
	pixel[2]*1.f/255.f,	pixel[2]*1.f/255.f,
	pixel[3]*1.f/255.f);	pixel[3]*1.f/255.f);
	}	}

	const unsigned char* getBuffer() const { return m_buffer;}	const unsigned char* getBuffer() const { return m_buffer;}
	int getWidth() const { return m_width;}	int getWidth() const { return m_width;}
	int getHeight() const { return m_height;}	int getHeight() const { return m_height;}

	void grapicalPrintf(char* str, BMF_FontData* fontData, int startx = 0,int starty=0);	void grapicalPrintf(char* str, void* fontData, int startx = 0,int s tarty=0);

	};	};

	#endif //RENDER_TEXTURE_H	#endif //RENDER_TEXTURE_H

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	SequentialThreadSupport.h	SequentialThreadSupport.h

	skipping to change at line 81	skipping to change at line 81
	virtual void sendRequest(uint32_t uiCommand, ppu_address_t uiArgumen t0, uint32_t uiArgument1);	virtual void sendRequest(uint32_t uiCommand, ppu_address_t uiArgumen t0, uint32_t uiArgument1);
	///check for messages from SPUs	///check for messages from SPUs
	virtual void waitForResponse(unsigned int puiArgument0, unsigned in t puiArgument1);	virtual void waitForResponse(unsigned int puiArgument0, unsigned in t puiArgument1);
	///start the spus (can be called at the beginning of each frame, to make su re that the right SPU program is loaded)	///start the spus (can be called at the beginning of each frame, to make su re that the right SPU program is loaded)
	virtual void startSPU();	virtual void startSPU();
	///tell the task scheduler we are done with the SPU tasks	///tell the task scheduler we are done with the SPU tasks
	virtual void stopSPU();	virtual void stopSPU();

	virtual void setNumTasks(int numTasks);	virtual void setNumTasks(int numTasks);


		virtual int getNumTasks() const
		{
		return 1;
		}

	};	};

	#endif //SEQUENTIAL_THREAD_SUPPORT_H	#endif //SEQUENTIAL_THREAD_SUPPORT_H

End of changes. 1 change blocks.
	0 lines changed or deleted	5 lines changed or added

	SimplexDemo.h	SimplexDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef SIMPLEX_DEMO_H	#ifndef SIMPLEX_DEMO_H
	#define SIMPLEX_DEMO_H	#define SIMPLEX_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"

	///SimplexDemo shows the working of the sub-distance algorithm, used inside GJK	///SimplexDemo shows the working of the sub-distance algorithm, used inside GJK

	class SimplexDemo : public DemoApplication	class SimplexDemo : public GlutDemoApplication
	{	{
	public:	public:

	void initPhysics();	void initPhysics();

	virtual void clientMoveAndDisplay();	virtual void clientMoveAndDisplay();

	virtual void displayCallback();	virtual void displayCallback();

	};	};

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	SpuCollisionObjectWrapper.h	SpuCollisionObjectWrapper.h

	skipping to change at line 16	skipping to change at line 16
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/


		#ifndef SPU_COLLISION_OBJECT_WRAPPER_H
		#define SPU_COLLISION_OBJECT_WRAPPER_H

	#include "PlatformDefinitions.h"	#include "PlatformDefinitions.h"
	#include "BulletCollision/CollisionDispatch/btCollisionObject.h"	#include "BulletCollision/CollisionDispatch/btCollisionObject.h"

	ATTRIBUTE_ALIGNED16(class) SpuCollisionObjectWrapper	ATTRIBUTE_ALIGNED16(class) SpuCollisionObjectWrapper
	{	{
	protected:	protected:
	int m_shapeType;	int m_shapeType;
	float m_margin;	float m_margin;
	ppu_address_t m_collisionObjectPtr;	ppu_address_t m_collisionObjectPtr;

	public:	public:
	SpuCollisionObjectWrapper ();	SpuCollisionObjectWrapper ();

	SpuCollisionObjectWrapper (const btCollisionObject* collisionObject) ;	SpuCollisionObjectWrapper (const btCollisionObject* collisionObject) ;

	int getShapeType () const;	int getShapeType () const;
	float getCollisionMargin () const;	float getCollisionMargin () const;
	ppu_address_t getCollisionObjectPtr () const;	ppu_address_t getCollisionObjectPtr () const;
	};	};


		#endif //SPU_COLLISION_OBJECT_WRAPPER_H

End of changes. 2 change blocks.
	0 lines changed or deleted	3 lines changed or added

	SpuCollisionTaskProcess.h	SpuCollisionTaskProcess.h

	skipping to change at line 71	skipping to change at line 71
	//	//
	// struct CollisionTask_LocalStoreMemory* m_lsMemory;	// struct CollisionTask_LocalStoreMemory* m_lsMemory;
	//}	//}
	//	//
	//#if defined(__CELLOS_LV2__) \|\| defined(USE_LIBSPE2)	//#if defined(__CELLOS_LV2__) \|\| defined(USE_LIBSPE2)
	//__attribute__ ((aligned (16)))	//__attribute__ ((aligned (16)))
	//#endif	//#endif
	//;	//;

	///MidphaseWorkUnitInput stores individual primitive versus mesh collision detection input, to be processed by the SPU.	///MidphaseWorkUnitInput stores individual primitive versus mesh collision detection input, to be processed by the SPU.

	struct SpuGatherAndProcessWorkUnitInput	ATTRIBUTE_ALIGNED16(struct) SpuGatherAndProcessWorkUnitInput
	{	{
	uint64_t m_pairArrayPtr;	uint64_t m_pairArrayPtr;
	int m_startIndex;	int m_startIndex;
	int m_endIndex;	int m_endIndex;
	};	};

	/// SpuCollisionTaskProcess handles SPU processing of collision pairs.	/// SpuCollisionTaskProcess handles SPU processing of collision pairs.
	/// Maintains a set of task buffers.	/// Maintains a set of task buffers.
	/// When the task is full, the task is issued for SPUs to process. Contact output goes into btPersistentManifold	/// When the task is full, the task is issued for SPUs to process. Contact output goes into btPersistentManifold
	/// associated with each task.	/// associated with each task.

	skipping to change at line 125	skipping to change at line 125
	~SpuCollisionTaskProcess();	~SpuCollisionTaskProcess();

	///call initialize in the beginning of the frame, before addCollisio nPairToTask	///call initialize in the beginning of the frame, before addCollisio nPairToTask
	void initialize2(bool useEpa = false);	void initialize2(bool useEpa = false);

	///batch up additional work to a current task for SPU processing. Wh en batch is full, it issues the task.	///batch up additional work to a current task for SPU processing. Wh en batch is full, it issues the task.
	void addWorkToTask(void* pairArrayPtr,int startIndex,int endIndex);	void addWorkToTask(void* pairArrayPtr,int startIndex,int endIndex);

	///call flush to submit potential outstanding work to SPUs and wait for all involved SPUs to be finished	///call flush to submit potential outstanding work to SPUs and wait for all involved SPUs to be finished
	void flush2();	void flush2();


		/// set the maximum number of SPU tasks allocated
		void setNumTasks(int maxNumTasks);

		int getNumTasks() const
		{
		return m_maxNumOutstandingTasks;
		}
	};	};

	#define MIDPHASE_TASK_PTR(task) (&m_workUnitTaskBuffers[0] + MIDPHASE_WORKU NIT_TASK_SIZE*task)	#define MIDPHASE_TASK_PTR(task) (&m_workUnitTaskBuffers[0] + MIDPHASE_WORKU NIT_TASK_SIZE*task)
	#define MIDPHASE_ENTRY_PTR(task,page,entry) (MIDPHASE_TASK_PTR(task) + MIDP HASE_WORKUNIT_PAGE_SIZEpage + sizeof(SpuGatherAndProcessWorkUnitInput)ent ry)	#define MIDPHASE_ENTRY_PTR(task,page,entry) (MIDPHASE_TASK_PTR(task) + MIDP HASE_WORKUNIT_PAGE_SIZEpage + sizeof(SpuGatherAndProcessWorkUnitInput)ent ry)
	#define MIDPHASE_OUTPUT_PTR(task) (&m_contactOutputBuffers[0] + MIDPHASE_MA X_CONTACT_BUFFER_SIZE*task)	#define MIDPHASE_OUTPUT_PTR(task) (&m_contactOutputBuffers[0] + MIDPHASE_MA X_CONTACT_BUFFER_SIZE*task)
	#define MIDPHASE_TREENODES_PTR(task) (&m_complexShapeBuffers[0] + MIDPHASE_ COMPLEX_SHAPE_BUFFER_SIZE*task)	#define MIDPHASE_TREENODES_PTR(task) (&m_complexShapeBuffers[0] + MIDPHASE_ COMPLEX_SHAPE_BUFFER_SIZE*task)

	#define MIDPHASE_WORKUNIT_PAGE_SIZE (16)	#define MIDPHASE_WORKUNIT_PAGE_SIZE (16)

		//#define MIDPHASE_WORKUNIT_PAGE_SIZE (128)

	#define MIDPHASE_NUM_WORKUNIT_PAGES 1	#define MIDPHASE_NUM_WORKUNIT_PAGES 1
	#define MIDPHASE_WORKUNIT_TASK_SIZE (MIDPHASE_WORKUNIT_PAGE_SIZE*MIDPHASE_N UM_WORKUNIT_PAGES)	#define MIDPHASE_WORKUNIT_TASK_SIZE (MIDPHASE_WORKUNIT_PAGE_SIZE*MIDPHASE_N UM_WORKUNIT_PAGES)
	#define MIDPHASE_NUM_WORKUNITS_PER_PAGE (MIDPHASE_WORKUNIT_PAGE_SIZE / size of(SpuGatherAndProcessWorkUnitInput))	#define MIDPHASE_NUM_WORKUNITS_PER_PAGE (MIDPHASE_WORKUNIT_PAGE_SIZE / size of(SpuGatherAndProcessWorkUnitInput))
	#define MIDPHASE_NUM_WORKUNITS_PER_TASK (MIDPHASE_NUM_WORKUNITS_PER_PAGE*MI DPHASE_NUM_WORKUNIT_PAGES)	#define MIDPHASE_NUM_WORKUNITS_PER_TASK (MIDPHASE_NUM_WORKUNITS_PER_PAGE*MI DPHASE_NUM_WORKUNIT_PAGES)

	#endif // SPU_COLLISION_TASK_PROCESS_H	#endif // SPU_COLLISION_TASK_PROCESS_H

End of changes. 3 change blocks.
	1 lines changed or deleted	10 lines changed or added

	SpuContactResult.h	SpuContactResult.h

	skipping to change at line 28	skipping to change at line 28

	#ifndef WIN32	#ifndef WIN32
	#include <stdint.h>	#include <stdint.h>
	#endif	#endif

	#include "../SpuDoubleBuffer.h"	#include "../SpuDoubleBuffer.h"

	#include "LinearMath/btTransform.h"	#include "LinearMath/btTransform.h"

	#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"	#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"

		#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorI
		nterface.h"

		class btCollisionShape;

	struct SpuCollisionPairInput	struct SpuCollisionPairInput
	{	{
	ppu_address_t m_collisionShapes[2];	ppu_address_t m_collisionShapes[2];

	void* m_spuCollisionShapes[2];	btCollisionShape* m_spuCollisionShapes[2];

	ppu_address_t m_persistentManifoldPtr;	ppu_address_t m_persistentManifoldPtr;
	btVector3 m_primitiveDimensions0;	btVector3 m_primitiveDimensions0;
	btVector3 m_primitiveDimensions1;	btVector3 m_primitiveDimensions1;
	int m_shapeType0;	int m_shapeType0;
	int m_shapeType1;	int m_shapeType1;
	float m_collisionMargin0;	float m_collisionMargin0;
	float m_collisionMargin1;	float m_collisionMargin1;

	btTransform m_worldTransform0;	btTransform m_worldTransform0;
	btTransform m_worldTransform1;	btTransform m_worldTransform1;

	bool m_isSwapped;	bool m_isSwapped;
	bool m_useEpa;	bool m_useEpa;
	};	};


	struct SpuClosestPointInput	struct SpuClosestPointInput : public btDiscreteCollisionDetectorInterface:: ClosestPointInput
	{	{

	SpuClosestPointInput()
	:m_maximumDistanceSquared(float(1e30)),
	m_stackAlloc(0)
	{
	}

	btTransform m_transformA;
	btTransform m_transformB;
	float m_maximumDistanceSquared;
	class btStackAlloc* m_stackAlloc;
	struct SpuConvexPolyhedronVertexData* m_convexVertexData[2];	struct SpuConvexPolyhedronVertexData* m_convexVertexData[2];
	};	};

	///SpuContactResult exports the contact points using double-buffered DMA tr ansfers, only when needed	///SpuContactResult exports the contact points using double-buffered DMA tr ansfers, only when needed
	///So when an existing contact point is duplicated, no transfer/refresh is performed.	///So when an existing contact point is duplicated, no transfer/refresh is performed.

	class SpuContactResult	class SpuContactResult : public btDiscreteCollisionDetectorInterface::Resul t
	{	{
	btTransform m_rootWorldTransform0;	btTransform m_rootWorldTransform0;
	btTransform m_rootWorldTransform1;	btTransform m_rootWorldTransform1;
	ppu_address_t m_manifoldAddress;	ppu_address_t m_manifoldAddress;

	btPersistentManifold* m_spuManifold;	btPersistentManifold* m_spuManifold;
	bool m_RequiresWriteBack;	bool m_RequiresWriteBack;
	btScalar m_combinedFriction;	btScalar m_combinedFriction;
	btScalar m_combinedRestitution;	btScalar m_combinedRestitution;


	skipping to change at line 90	skipping to change at line 83

	public:	public:
	SpuContactResult();	SpuContactResult();
	virtual ~SpuContactResult();	virtual ~SpuContactResult();

	btPersistentManifold* GetSpuManifold() const	btPersistentManifold* GetSpuManifold() const
	{	{
	return m_spuManifold;	return m_spuManifold;
	}	}


	virtual void setShapeIdentifiers(int partId0,int index0,	virtual void setShapeIdentifiersA(int partId0,int index0);
	int partId1,int index1);	virtual void setShapeIdentifiersB(int partId1,int index1);

	void setContactInfo(btPersistentManifold* spuManifold, pp u_address_t manifoldAddress,const btTransform& worldTrans0,const btTransfor m& worldTrans1, btScalar restitution0,btScalar restitution1, btScalar frict ion0,btScalar friction01, bool isSwapped);	void setContactInfo(btPersistentManifold* spuManifold, pp u_address_t manifoldAddress,const btTransform& worldTrans0,const btTransfor m& worldTrans1, btScalar restitution0,btScalar restitution1, btScalar frict ion0,btScalar friction01, bool isSwapped);

	void writeDoubleBufferedManifold(btPersistentManifold* lsManifold, btPersistentManifold* mmManifold);	void writeDoubleBufferedManifold(btPersistentManifold* lsManifold, btPersistentManifold* mmManifold);


	virtual void addContactPoint(const btVector3& normalOnBInWorld,cons t btVector3& pointInWorld,float depth);	virtual void addContactPoint(const btVector3& normalOnBInWorld,cons t btVector3& pointInWorld,btScalar depth);

	void flush();	void flush();
	};	};

	#endif //SPU_CONTACT_RESULT2_H	#endif //SPU_CONTACT_RESULT2_H

End of changes. 7 change blocks.
	16 lines changed or deleted	10 lines changed or added

	SpuDoubleBuffer.h	SpuDoubleBuffer.h

	skipping to change at line 63	skipping to change at line 63
	this->m_frontBuffer = &this->m_buffer0[0];	this->m_frontBuffer = &this->m_buffer0[0];
	this->m_backBuffer = &this->m_buffer1[0];	this->m_backBuffer = &this->m_buffer1[0];
	}	}

	template<class T, int size>	template<class T, int size>
	void	void
	DoubleBuffer<T,size>::backBufferDmaGet(uint64_t ea, unsigned int numBytes, unsigned int tag)	DoubleBuffer<T,size>::backBufferDmaGet(uint64_t ea, unsigned int numBytes, unsigned int tag)
	{	{
	m_dmaPending = true;	m_dmaPending = true;
	m_dmaTag = tag;	m_dmaTag = tag;

	m_backBuffer = (T*)cellDmaLargeGetReadOnly(m_backBuffer, ea, numByte	if (numBytes)
	s, tag, 0, 0);	{
		m_backBuffer = (T*)cellDmaLargeGetReadOnly(m_backBuffer, ea,
		numBytes, tag, 0, 0);
		}
	}	}

	template<class T, int size>	template<class T, int size>
	void	void
	DoubleBuffer<T,size>::backBufferDmaPut(uint64_t ea, unsigned int numBytes, unsigned int tag)	DoubleBuffer<T,size>::backBufferDmaPut(uint64_t ea, unsigned int numBytes, unsigned int tag)
	{	{
	m_dmaPending = true;	m_dmaPending = true;
	m_dmaTag = tag;	m_dmaTag = tag;
	cellDmaLargePut(m_backBuffer, ea, numBytes, tag, 0, 0);	cellDmaLargePut(m_backBuffer, ea, numBytes, tag, 0, 0);
	}	}

End of changes. 1 change blocks.
	2 lines changed or deleted	5 lines changed or added

	SpuGatheringCollisionTask.h	SpuGatheringCollisionTask.h

	skipping to change at line 25	skipping to change at line 25

	#ifndef SPU_GATHERING_COLLISION_TASK_H	#ifndef SPU_GATHERING_COLLISION_TASK_H
	#define SPU_GATHERING_COLLISION_TASK_H	#define SPU_GATHERING_COLLISION_TASK_H

	#include "../PlatformDefinitions.h"	#include "../PlatformDefinitions.h"
	//#define DEBUG_SPU_COLLISION_DETECTION 1	//#define DEBUG_SPU_COLLISION_DETECTION 1

	///Task Description for SPU collision detection	///Task Description for SPU collision detection
	struct SpuGatherAndProcessPairsTaskDesc	struct SpuGatherAndProcessPairsTaskDesc
	{	{

	ppu_address_t inPtr;//m_pairArrayPtr;	ppu_address_t m_inPairPtr;//m_pairArrayPtr;
	//mutex variable	//mutex variable
	uint32_t m_someMutexVariableInMainMemory;	uint32_t m_someMutexVariableInMainMemory;

	ppu_address_t m_dispatcher;	ppu_address_t m_dispatcher;

	uint32_t numOnLastPage;	uint32_t numOnLastPage;

	uint16_t numPages;	uint16_t numPages;
	uint16_t taskId;	uint16_t taskId;
	bool m_useEpa;	bool m_useEpa;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	SpuMinkowskiPenetrationDepthSolver.h	SpuMinkowskiPenetrationDepthSolver.h

	skipping to change at line 20	skipping to change at line 20
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef MINKOWSKI_PENETRATION_DEPTH_SOLVER_H	#ifndef MINKOWSKI_PENETRATION_DEPTH_SOLVER_H
	#define MINKOWSKI_PENETRATION_DEPTH_SOLVER_H	#define MINKOWSKI_PENETRATION_DEPTH_SOLVER_H


	#include "SpuConvexPenetrationDepthSolver.h"	#include "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolv er.h"

	class btStackAlloc;	class btStackAlloc;
	class btIDebugDraw;	class btIDebugDraw;

	class SpuVoronoiSimplexSolver;	class btVoronoiSimplexSolver;
		class btConvexShape;

	///MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation.	///MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation.
	///Implementation is based on sampling the depth using support mapping, and using GJK step to get the witness points.	///Implementation is based on sampling the depth using support mapping, and using GJK step to get the witness points.

	class SpuMinkowskiPenetrationDepthSolver : public SpuConvexPenetrationDepth Solver	class SpuMinkowskiPenetrationDepthSolver : public btConvexPenetrationDepthS olver
	{	{
	public:	public:

		SpuMinkowskiPenetrationDepthSolver() {}
		virtual ~SpuMinkowskiPenetrationDepthSolver() {};


	virtual bool calcPenDepth( SpuVoronoiSimplexSolver& simplexSolver,	virtual bool calcPenDepth( btSimplexSolverInterface& simplex
	void* convexA,void* convexB,int shapeTypeA, int shapeTypeB,	Solver,
	float marginA, float marginB,	const btConvexShape* convexA,const btConvexShape* convexB,
	btTransform& transA,const btTransform& transB,	const btTransform& transA,const btTr
	btVector3& v, btVector3& pa, btVector3& pb,	ansform& transB,
	class btIDebugDraw* debugDraw,btStackAlloc* stackAll	btVector3& v, btVector3& pa, btVector3& pb,
	oc,	class btIDebugDraw* debugDraw,btStackAlloc*
	struct SpuConvexPolyhedronVertexData* convexVertexDa	stackAlloc
	taA,	);
	struct SpuConvexPolyhedronVertexData* convexVertexDa
	taB
	) const;

	};	};

	#endif //MINKOWSKI_PENETRATION_DEPTH_SOLVER_H	#endif //MINKOWSKI_PENETRATION_DEPTH_SOLVER_H

End of changes. 5 change blocks.
	15 lines changed or deleted	15 lines changed or added

	TerrainDemo.h	TerrainDemo.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef TERRAIN_DEMO_H	#ifndef TERRAIN_DEMO_H
	#define TERRAIN_DEMO_H	#define TERRAIN_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"

	// all we need to expose publicly is the factory method!	// all we need to expose publicly is the factory method!

	DemoApplication * btCreateTerrainDemo(void);	GlutDemoApplication * btCreateTerrainDemo(void);

	#endif //TERRAIN_DEMO_H	#endif //TERRAIN_DEMO_H

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	UserCollisionAlgorithm.h	UserCollisionAlgorithm.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/
	#ifndef USER_COLLISION_ALGORITHM_DEMO_H	#ifndef USER_COLLISION_ALGORITHM_DEMO_H
	#define USER_COLLISION_ALGORITHM_DEMO_H	#define USER_COLLISION_ALGORITHM_DEMO_H


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"

	///UserCollisionAlgorithmDemo shows how to register and use your own collis ion algorithm for a certain shape pair type	///UserCollisionAlgorithmDemo shows how to register and use your own collis ion algorithm for a certain shape pair type

	class UserCollisionAlgorithm : public DemoApplication	class UserCollisionAlgorithm : public GlutDemoApplication
	{	{
	public:	public:

	void initPhysics();	void initPhysics();

	virtual void clientMoveAndDisplay();	virtual void clientMoveAndDisplay();

	virtual void displayCallback();	virtual void displayCallback();

	};	};

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	VehicleDemo.h	VehicleDemo.h

	skipping to change at line 24	skipping to change at line 24
	*/	*/
	#ifndef VEHICLE_DEMO_H	#ifndef VEHICLE_DEMO_H
	#define VEHICLE_DEMO_H	#define VEHICLE_DEMO_H

	class btVehicleTuning;	class btVehicleTuning;
	struct btVehicleRaycaster;	struct btVehicleRaycaster;
	class btCollisionShape;	class btCollisionShape;

	#include "BulletDynamics/Vehicle/btRaycastVehicle.h"	#include "BulletDynamics/Vehicle/btRaycastVehicle.h"


	#include "DemoApplication.h"	#include "GlutDemoApplication.h"

	///VehicleDemo shows how to setup and use the built-in raycast vehicle	///VehicleDemo shows how to setup and use the built-in raycast vehicle

	class VehicleDemo : public DemoApplication	class VehicleDemo : public GlutDemoApplication
	{	{
	public:	public:

	btRigidBody* m_carChassis;	btRigidBody* m_carChassis;

	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;	btAlignedObjectArray<btCollisionShape*> m_collisionShapes;

	class btBroadphaseInterface* m_overlappingPairCache;	class btBroadphaseInterface* m_overlappingPairCache;

	class btCollisionDispatcher* m_dispatcher;	class btCollisionDispatcher* m_dispatcher;

	skipping to change at line 50	skipping to change at line 50

	class btDefaultCollisionConfiguration* m_collisionConfiguration;	class btDefaultCollisionConfiguration* m_collisionConfiguration;

	class btTriangleIndexVertexArray* m_indexVertexArrays;	class btTriangleIndexVertexArray* m_indexVertexArrays;

	btVector3* m_vertices;	btVector3* m_vertices;

	btRaycastVehicle::btVehicleTuning m_tuning;	btRaycastVehicle::btVehicleTuning m_tuning;
	btVehicleRaycaster* m_vehicleRayCaster;	btVehicleRaycaster* m_vehicleRayCaster;
	btRaycastVehicle* m_vehicle;	btRaycastVehicle* m_vehicle;

		btCollisionShape* m_wheelShape;

	float m_cameraHeight;	float m_cameraHeight;

	float m_minCameraDistance;	float m_minCameraDistance;
	float m_maxCameraDistance;	float m_maxCameraDistance;

	VehicleDemo();	VehicleDemo();

	virtual ~VehicleDemo();	virtual ~VehicleDemo();


End of changes. 3 change blocks.
	2 lines changed or deleted	3 lines changed or added

	Win32ThreadSupport.h	Win32ThreadSupport.h

	skipping to change at line 60	skipping to change at line 60

	void* m_eventCompletetHandle;	void* m_eventCompletetHandle;
	char m_eventCompletetHandleName[32];	char m_eventCompletetHandleName[32];

	};	};
	private:	private:

	btAlignedObjectArray<btSpuStatus> m_activeSpuStatus;	btAlignedObjectArray<btSpuStatus> m_activeSpuStatus;
	btAlignedObjectArray<void*> m_completeHandles;	btAlignedObjectArray<void*> m_completeHandles;


		int m_maxNumTasks;
	public:	public:
	///Setup and initialize SPU/CELL/Libspe2	///Setup and initialize SPU/CELL/Libspe2

	struct Win32ThreadConstructionInfo	struct Win32ThreadConstructionInfo
	{	{
	Win32ThreadConstructionInfo(char* uniqueName,	Win32ThreadConstructionInfo(char* uniqueName,
	Win3 2ThreadFunc userThreadFunc,	Win3 2ThreadFunc userThreadFunc,
	Win3 2lsMemorySetupFunc lsMemoryFunc,	Win3 2lsMemorySetupFunc lsMemoryFunc,
	int numThreads=1,	int numThreads=1,
	int threadStackSize=65535	int threadStackSize=65535

	skipping to change at line 109	skipping to change at line 110
	virtual void waitForResponse(unsigned int puiArgument0, unsigned in t puiArgument1);	virtual void waitForResponse(unsigned int puiArgument0, unsigned in t puiArgument1);

	///start the spus (can be called at the beginning of each frame, to make su re that the right SPU program is loaded)	///start the spus (can be called at the beginning of each frame, to make su re that the right SPU program is loaded)
	virtual void startSPU();	virtual void startSPU();

	///tell the task scheduler we are done with the SPU tasks	///tell the task scheduler we are done with the SPU tasks
	virtual void stopSPU();	virtual void stopSPU();

	virtual void setNumTasks(int numTasks)	virtual void setNumTasks(int numTasks)
	{	{

		m_maxNumTasks = numTasks;
		}

		virtual int getNumTasks() const
		{
		return m_maxNumTasks;
	}	}

	};	};

	#endif //WIN32_THREAD_SUPPORT_H	#endif //WIN32_THREAD_SUPPORT_H

	#endif //USE_WIN32_THREADING	#endif //USE_WIN32_THREADING

End of changes. 2 change blocks.
	0 lines changed or deleted	7 lines changed or added

	btAlignedObjectArray.h	btAlignedObjectArray.h

	skipping to change at line 166	skipping to change at line 166
	m_size--;	m_size--;
	m_data[m_size].~T();	m_data[m_size].~T();
	}	}

	///resize changes the number of elements in the array. If th e new size is larger, the new elements will be constructed using the option al second argument.	///resize changes the number of elements in the array. If th e new size is larger, the new elements will be constructed using the option al second argument.
	///when the new number of elements is smaller, the destructo r will be called, but memory will not be freed, to reduce performance overh ead of run-time memory (de)allocations.	///when the new number of elements is smaller, the destructo r will be called, but memory will not be freed, to reduce performance overh ead of run-time memory (de)allocations.
	SIMD_FORCE_INLINE void resize(int newsize, const T& fillData=T())	SIMD_FORCE_INLINE void resize(int newsize, const T& fillData=T())
	{	{
	int curSize = size();	int curSize = size();


	if (newsize < size())	if (newsize < curSize)
	{	{

	for(int i = curSize; i < newsize; i++)	for(int i = newsize; i < curSize; i++)
	{	{
	m_data[i].~T();	m_data[i].~T();
	}	}
	} else	} else
	{	{
	if (newsize > size())	if (newsize > size())
	{	{
	reserve(newsize);	reserve(newsize);
	}	}
	#ifdef BT_USE_PLACEMENT_NEW	#ifdef BT_USE_PLACEMENT_NEW

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	btBoxShape.h	btBoxShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btBroadphaseProxy.h	btBroadphaseProxy.h

	skipping to change at line 48	skipping to change at line 48
	IMPLICIT_CONVEX_SHAPES_START_HERE,	IMPLICIT_CONVEX_SHAPES_START_HERE,
	SPHERE_SHAPE_PROXYTYPE,	SPHERE_SHAPE_PROXYTYPE,
	MULTI_SPHERE_SHAPE_PROXYTYPE,	MULTI_SPHERE_SHAPE_PROXYTYPE,
	CAPSULE_SHAPE_PROXYTYPE,	CAPSULE_SHAPE_PROXYTYPE,
	CONE_SHAPE_PROXYTYPE,	CONE_SHAPE_PROXYTYPE,
	CONVEX_SHAPE_PROXYTYPE,	CONVEX_SHAPE_PROXYTYPE,
	CYLINDER_SHAPE_PROXYTYPE,	CYLINDER_SHAPE_PROXYTYPE,
	UNIFORM_SCALING_SHAPE_PROXYTYPE,	UNIFORM_SCALING_SHAPE_PROXYTYPE,
	MINKOWSKI_SUM_SHAPE_PROXYTYPE,	MINKOWSKI_SUM_SHAPE_PROXYTYPE,
	MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE,	MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE,

		BOX_2D_SHAPE_PROXYTYPE,
		CONVEX_2D_SHAPE_PROXYTYPE,
	CUSTOM_CONVEX_SHAPE_TYPE,	CUSTOM_CONVEX_SHAPE_TYPE,
	//concave shapes	//concave shapes
	CONCAVE_SHAPES_START_HERE,	CONCAVE_SHAPES_START_HERE,
	//keep all the convex shapetype below here, for the check IsConvexSh ape in broadphase proxy!	//keep all the convex shapetype below here, for the check IsConvexSh ape in broadphase proxy!
	TRIANGLE_MESH_SHAPE_PROXYTYPE,	TRIANGLE_MESH_SHAPE_PROXYTYPE,
	SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE,	SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE,
	///used for demo integration FAST/Swift collision library and Bullet	///used for demo integration FAST/Swift collision library and Bullet
	FAST_CONCAVE_MESH_PROXYTYPE,	FAST_CONCAVE_MESH_PROXYTYPE,
	//terrain	//terrain
	TERRAIN_SHAPE_PROXYTYPE,	TERRAIN_SHAPE_PROXYTYPE,

	skipping to change at line 152	skipping to change at line 154
	}	}
	static SIMD_FORCE_INLINE bool isCompound(int proxyType)	static SIMD_FORCE_INLINE bool isCompound(int proxyType)
	{	{
	return (proxyType == COMPOUND_SHAPE_PROXYTYPE);	return (proxyType == COMPOUND_SHAPE_PROXYTYPE);
	}	}
	static SIMD_FORCE_INLINE bool isInfinite(int proxyType)	static SIMD_FORCE_INLINE bool isInfinite(int proxyType)
	{	{
	return (proxyType == STATIC_PLANE_PROXYTYPE);	return (proxyType == STATIC_PLANE_PROXYTYPE);
	}	}


		static SIMD_FORCE_INLINE bool isConvex2d(int proxyType)
		{
		return (proxyType == BOX_2D_SHAPE_PROXYTYPE) \|\| (proxyType =
		= CONVEX_2D_SHAPE_PROXYTYPE);
		}

	}	}
	;	;

	class btCollisionAlgorithm;	class btCollisionAlgorithm;

	struct btBroadphaseProxy;	struct btBroadphaseProxy;

	///The btBroadphasePair class contains a pair of aabb-overlapping objects.	///The btBroadphasePair class contains a pair of aabb-overlapping objects.
	///A btDispatcher can search a btCollisionAlgorithm that performs exact/nar rowphase collision detection on the actual collision shapes.	///A btDispatcher can search a btCollisionAlgorithm that performs exact/nar rowphase collision detection on the actual collision shapes.
	ATTRIBUTE_ALIGNED16(struct) btBroadphasePair	ATTRIBUTE_ALIGNED16(struct) btBroadphasePair

End of changes. 2 change blocks.
	0 lines changed or deleted	8 lines changed or added

	btBvhTriangleMeshShape.h	btBvhTriangleMeshShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btCapsuleShape.h	btCapsuleShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

	skipping to change at line 79	skipping to change at line 79
	{	{
	int radiusAxis = (m_upAxis+2)%3;	int radiusAxis = (m_upAxis+2)%3;
	return m_implicitShapeDimensions[radiusAxis];	return m_implicitShapeDimensions[radiusAxis];
	}	}

	btScalar getHalfHeight() const	btScalar getHalfHeight() const
	{	{
	return m_implicitShapeDimensions[m_upAxis];	return m_implicitShapeDimensions[m_upAxis];
	}	}


		virtual void setLocalScaling(const btVector3& scaling)
		{
		btVector3 oldMargin(getMargin(),getMargin(),getMargin());
		btVector3 implicitShapeDimensionsWithMargin = m_implicitShap
		eDimensions+oldMargin;
		btVector3 unScaledImplicitShapeDimensionsWithMargin = implic
		itShapeDimensionsWithMargin / m_localScaling;

		btConvexInternalShape::setLocalScaling(scaling);

		m_implicitShapeDimensions = (unScaledImplicitShapeDimensions
		WithMargin * m_localScaling) - oldMargin;

		}
	};	};

	///btCapsuleShapeX represents a capsule around the Z axis	///btCapsuleShapeX represents a capsule around the Z axis
	///the total height is height+2*radius, so the height is just the height be tween the center of each 'sphere' of the capsule caps.	///the total height is height+2*radius, so the height is just the height be tween the center of each 'sphere' of the capsule caps.
	class btCapsuleShapeX : public btCapsuleShape	class btCapsuleShapeX : public btCapsuleShape
	{	{
	public:	public:

	btCapsuleShapeX(btScalar radius,btScalar height);	btCapsuleShapeX(btScalar radius,btScalar height);


End of changes. 2 change blocks.
	1 lines changed or deleted	15 lines changed or added

	btCharacterControllerInterface.h	btCharacterControllerInterface.h

	skipping to change at line 33	skipping to change at line 33
	class btRigidBody;	class btRigidBody;
	class btCollisionWorld;	class btCollisionWorld;

	class btCharacterControllerInterface : public btActionInterface	class btCharacterControllerInterface : public btActionInterface
	{	{
	public:	public:
	btCharacterControllerInterface () {};	btCharacterControllerInterface () {};
	virtual ~btCharacterControllerInterface () {};	virtual ~btCharacterControllerInterface () {};

	virtual void setWalkDirection(const btVector3& walkDirection) = 0 ;	virtual void setWalkDirection(const btVector3& walkDirection) = 0 ;

		virtual void setVelocityForTimeInterval(const btVector3& velocity , btScalar timeInterval) = 0;
	virtual void reset () = 0;	virtual void reset () = 0;
	virtual void warp (const btVector3& origin) = 0;	virtual void warp (const btVector3& origin) = 0;

	virtual void preStep ( btCollisionWorld* collisionWorld) = 0;	virtual void preStep ( btCollisionWorld* collisionWorld) = 0;
	virtual void playerStep (btCollisionWorld* collisionWorld, btScal ar dt) = 0;	virtual void playerStep (btCollisionWorld* collisionWorld, btScal ar dt) = 0;
	virtual bool canJump () const = 0;	virtual bool canJump () const = 0;
	virtual void jump () = 0;	virtual void jump () = 0;

	virtual bool onGround () const = 0;	virtual bool onGround () const = 0;
	};	};

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	btCollisionMargin.h	btCollisionMargin.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btCollisionObject.h	btCollisionObject.h

	skipping to change at line 388	skipping to change at line 388
	}	}

	btScalar getCcdSquareMotionThreshold() const	btScalar getCcdSquareMotionThreshold() const
	{	{
	return m_ccdMotionThreshold*m_ccdMotionThreshold;	return m_ccdMotionThreshold*m_ccdMotionThreshold;
	}	}

	/// Don't do continuous collision detection if the motion (in one st ep) is less then m_ccdMotionThreshold	/// Don't do continuous collision detection if the motion (in one st ep) is less then m_ccdMotionThreshold
	void setCcdMotionThreshold(btScalar ccdMotionThreshold)	void setCcdMotionThreshold(btScalar ccdMotionThreshold)
	{	{

	m_ccdMotionThreshold = ccdMotionThreshold*ccdMotionThreshold ;	m_ccdMotionThreshold = ccdMotionThreshold;
	}	}

	///users can point to their objects, userPointer is not used by Bull et	///users can point to their objects, userPointer is not used by Bull et
	void* getUserPointer() const	void* getUserPointer() const
	{	{
	return m_userObjectPointer;	return m_userObjectPointer;
	}	}

	///users can point to their objects, userPointer is not used by Bull et	///users can point to their objects, userPointer is not used by Bull et
	void setUserPointer(void* userPointer)	void setUserPointer(void* userPointer)

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btCollisionWorld.h	btCollisionWorld.h

	skipping to change at line 93	skipping to change at line 93
	btDispatcher* m_dispatcher1;	btDispatcher* m_dispatcher1;

	btDispatcherInfo m_dispatchInfo;	btDispatcherInfo m_dispatchInfo;

	btStackAlloc* m_stackAlloc;	btStackAlloc* m_stackAlloc;

	btBroadphaseInterface* m_broadphasePairCache;	btBroadphaseInterface* m_broadphasePairCache;

	btIDebugDraw* m_debugDrawer;	btIDebugDraw* m_debugDrawer;


		///m_forceUpdateAllAabbs can be set to false as an optimization to o
		nly update active object AABBs
		///it is true by default, because it is error-prone (setting the pos
		ition of static objects wouldn't update their AABB)
		bool m_forceUpdateAllAabbs;

	public:	public:

	//this constructor doesn't own the dispatcher and paircache/broadpha se	//this constructor doesn't own the dispatcher and paircache/broadpha se
	btCollisionWorld(btDispatcher* dispatcher,btBroadphaseInterface* bro adphasePairCache, btCollisionConfiguration* collisionConfiguration);	btCollisionWorld(btDispatcher* dispatcher,btBroadphaseInterface* bro adphasePairCache, btCollisionConfiguration* collisionConfiguration);

	virtual ~btCollisionWorld();	virtual ~btCollisionWorld();

	void setBroadphase(btBroadphaseInterface* pairCache)	void setBroadphase(btBroadphaseInterface* pairCache)
	{	{
	m_broadphasePairCache = pairCache;	m_broadphasePairCache = pairCache;

	skipping to change at line 368	skipping to change at line 372
	const btTransform& colObjWorldTran sform,	const btTransform& colObjWorldTran sform,
	RayResultCallback& resultCallback) ;	RayResultCallback& resultCallback) ;

	/// objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.	/// objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.
	static void objectQuerySingle(const btConvexShape* castShape, co nst btTransform& rayFromTrans,const btTransform& rayToTrans,	static void objectQuerySingle(const btConvexShape* castShape, co nst btTransform& rayFromTrans,const btTransform& rayToTrans,
	btCollisionObject* collisionObject ,	btCollisionObject* collisionObject ,
	const btCollisionShape* collisionS hape,	const btCollisionShape* collisionS hape,
	const btTransform& colObjWorldTran sform,	const btTransform& colObjWorldTran sform,
	ConvexResultCallback& resultCallba ck, btScalar allowedPenetration);	ConvexResultCallback& resultCallba ck, btScalar allowedPenetration);


	void addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=btBroadphaseProxy::DefaultFilter,short int collisi onFilterMask=btBroadphaseProxy::AllFilter);	virtual void addCollisionObject(btCollisionObject* collisionObjec t,short int collisionFilterGroup=btBroadphaseProxy::DefaultFilter,short int collisionFilterMask=btBroadphaseProxy::AllFilter);

	btCollisionObjectArray& getCollisionObjectArray()	btCollisionObjectArray& getCollisionObjectArray()
	{	{
	return m_collisionObjects;	return m_collisionObjects;
	}	}

	const btCollisionObjectArray& getCollisionObjectArray() const	const btCollisionObjectArray& getCollisionObjectArray() const
	{	{
	return m_collisionObjects;	return m_collisionObjects;
	}	}


	void removeCollisionObject(btCollisionObject* collisionObject);	virtual void removeCollisionObject(btCollisionObject* collisionOb ject);

	virtual void performDiscreteCollisionDetection();	virtual void performDiscreteCollisionDetection();

	btDispatcherInfo& getDispatchInfo()	btDispatcherInfo& getDispatchInfo()
	{	{
	return m_dispatchInfo;	return m_dispatchInfo;
	}	}

	const btDispatcherInfo& getDispatchInfo() const	const btDispatcherInfo& getDispatchInfo() const
	{	{
	return m_dispatchInfo;	return m_dispatchInfo;
	}	}


		bool getForceUpdateAllAabbs() const
		{
		return m_forceUpdateAllAabbs;
		}
		void setForceUpdateAllAabbs( bool forceUpdateAllAabbs)
		{
		m_forceUpdateAllAabbs = forceUpdateAllAabbs;
		}

	};	};

	#endif //COLLISION_WORLD_H	#endif //COLLISION_WORLD_H

End of changes. 4 change blocks.
	2 lines changed or deleted	17 lines changed or added

	btCompoundShape.h	btCompoundShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btConcaveShape.h	btConcaveShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btConeShape.h	btConeShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btConeTwistConstraint.h	btConeTwistConstraint.h

	skipping to change at line 18	skipping to change at line 18
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

	Written by: Marcus Hennix	Written by: Marcus Hennix
	*/	*/


		/*
		Overview:

		btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, le
		g etc).
		It is a fixed translation, 3 degree-of-freedom (DOF) rotational "joint".
		It divides the 3 rotational DOFs into swing (movement within a cone) and tw
		ist.
		Swing is divided into swing1 and swing2 which can have different limits, gi
		ving an elliptical shape.
		(Note: the cone's base isn't flat, so this ellipse is "embedded" on the sur
		face of a sphere.)

		In the contraint's frame of reference:
		twist is along the x-axis,
		and swing 1 and 2 are along the z and y axes respectively.
		*/

	#ifndef CONETWISTCONSTRAINT_H	#ifndef CONETWISTCONSTRAINT_H
	#define CONETWISTCONSTRAINT_H	#define CONETWISTCONSTRAINT_H

	#include "LinearMath/btVector3.h"	#include "LinearMath/btVector3.h"
	#include "btJacobianEntry.h"	#include "btJacobianEntry.h"
	#include "btTypedConstraint.h"	#include "btTypedConstraint.h"

	class btRigidBody;	class btRigidBody;

	///btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)	///btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)

	skipping to change at line 95	skipping to change at line 109
	btConeTwistConstraint(btRigidBody& rbA,btRigidBody& rbB,const btTran sform& rbAFrame, const btTransform& rbBFrame);	btConeTwistConstraint(btRigidBody& rbA,btRigidBody& rbB,const btTran sform& rbAFrame, const btTransform& rbBFrame);

	btConeTwistConstraint(btRigidBody& rbA,const btTransform& rbAFrame);	btConeTwistConstraint(btRigidBody& rbA,const btTransform& rbAFrame);

	btConeTwistConstraint();	btConeTwistConstraint();

	virtual void buildJacobian();	virtual void buildJacobian();

	virtual void getInfo1 (btConstraintInfo1* info);	virtual void getInfo1 (btConstraintInfo1* info);


		void getInfo1NonVirtual(btConstraintInfo1* info);

	virtual void getInfo2 (btConstraintInfo2* info);	virtual void getInfo2 (btConstraintInfo2* info);


		void getInfo2NonVirtual(btConstraintInfo2* info,const btTransform
		& transA,const btTransform& transB,const btMatrix3x3& invInertiaWorldA,cons
		t btMatrix3x3& invInertiaWorldB);

	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep);	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep);

	void updateRHS(btScalar timeStep);	void updateRHS(btScalar timeStep);

	const btRigidBody& getRigidBodyA() const	const btRigidBody& getRigidBodyA() const
	{	{
	return m_rbA;	return m_rbA;
	}	}
	const btRigidBody& getRigidBodyB() const	const btRigidBody& getRigidBodyB() const
	{	{

	skipping to change at line 140	skipping to change at line 158
	{	{
	m_swingSpan1 = limitValue;	m_swingSpan1 = limitValue;
	break;	break;
	}	}
	default:	default:
	{	{
	}	}
	};	};
	}	}


	void setLimit(btScalar _swingSpan1,btScalar _swingSpan2,btScalar	// setLimit(), a few notes:
	_twistSpan, btScalar _softness = 1.f, btScalar _biasFactor = 0.3f, btScala	// _softness:
	r _relaxationFactor = 1.0f)	// 0->1, recommend ~0.8->1.
		// describes % of limits where movement is free.
		// beyond this softness %, the limit is gradually enfor
		ced until the "hard" (1.0) limit is reached.
		// _biasFactor:
		// 0->1?, recommend 0.3 +/-0.3 or so.
		// strength with which constraint resists zeroth order
		(angular, not angular velocity) limit violation.
		// __relaxationFactor:
		// 0->1, recommend to stay near 1.
		// the lower the value, the less the constraint will fi
		ght velocities which violate the angular limits.
		void setLimit(btScalar _swingSpan1,btScalar _swingSpan2,btScalar
		_twistSpan, btScalar _softness = 1.f, btScalar _biasFactor = 0.3f, btScalar
		_relaxationFactor = 1.0f)
	{	{
	m_swingSpan1 = _swingSpan1;	m_swingSpan1 = _swingSpan1;
	m_swingSpan2 = _swingSpan2;	m_swingSpan2 = _swingSpan2;
	m_twistSpan = _twistSpan;	m_twistSpan = _twistSpan;

	m_limitSoftness = _softness;	m_limitSoftness = _softness;
	m_biasFactor = _biasFactor;	m_biasFactor = _biasFactor;
	m_relaxationFactor = _relaxationFactor;	m_relaxationFactor = _relaxationFactor;
	}	}


	skipping to change at line 170	skipping to change at line 199
	{	{
	return m_solveTwistLimit;	return m_solveTwistLimit;
	}	}

	inline btScalar getTwistLimitSign()	inline btScalar getTwistLimitSign()
	{	{
	return m_twistLimitSign;	return m_twistLimitSign;
	}	}

	void calcAngleInfo();	void calcAngleInfo();

	void calcAngleInfo2();	void calcAngleInfo2(const btTransform& transA, const btTransform& tr ansB,const btMatrix3x3& invInertiaWorldA,const btMatrix3x3& invInertiaWorld B);

	inline btScalar getSwingSpan1()	inline btScalar getSwingSpan1()
	{	{
	return m_swingSpan1;	return m_swingSpan1;
	}	}
	inline btScalar getSwingSpan2()	inline btScalar getSwingSpan2()
	{	{
	return m_swingSpan2;	return m_swingSpan2;
	}	}
	inline btScalar getTwistSpan()	inline btScalar getTwistSpan()

End of changes. 5 change blocks.
	4 lines changed or deleted	42 lines changed or added

	btContactConstraint.h	btContactConstraint.h

	skipping to change at line 19	skipping to change at line 19
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef CONTACT_CONSTRAINT_H	#ifndef CONTACT_CONSTRAINT_H
	#define CONTACT_CONSTRAINT_H	#define CONTACT_CONSTRAINT_H


	///@todo: make into a proper class working with the iterative constraint so
	lver

	class btRigidBody;
	#include "LinearMath/btVector3.h"	#include "LinearMath/btVector3.h"

	#include "LinearMath/btScalar.h"	#include "btJacobianEntry.h"
	struct btContactSolverInfo;	#include "btTypedConstraint.h"
	class btManifoldPoint;	#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"


	enum {	///btContactConstraint can be automatically created to solve contact constr
	DEFAULT_CONTACT_SOLVER_TYPE=0,	aints using the unified btTypedConstraint interface
	CONTACT_SOLVER_TYPE1,	ATTRIBUTE_ALIGNED16(class) btContactConstraint : public btTypedConstraint
	CONTACT_SOLVER_TYPE2,	{
	USER_CONTACT_SOLVER_TYPE1,	protected:
	MAX_CONTACT_SOLVER_TYPES
	};


	typedef btScalar (*ContactSolverFunc)(btRigidBody& body1,	btPersistentManifold m_contactManifold;
	btR
	igidBody& body2,
	cla
	ss btManifoldPoint& contactPoint,
	con
	st btContactSolverInfo& info);


	///stores some extra information to each contact point. It is not in the co	public:
	ntact point, because that want to keep the collision detection independent
	from the constraint solver.	btContactConstraint();
	struct btConstraintPersistentData
	{	btContactConstraint(btPersistentManifold* contactManifold,btRigidBod
	inline btConstraintPersistentData()	y& rbA,btRigidBody& rbB);
	:m_appliedImpulse(btScalar(0.)),
	m_prevAppliedImpulse(btScalar(0.)),	void setContactManifold(btPersistentManifold* contactManifold);
	m_accumulatedTangentImpulse0(btScalar(0.)),
	m_accumulatedTangentImpulse1(btScalar(0.)),	btPersistentManifold* getContactManifold()
	m_jacDiagABInv(btScalar(0.)),
	m_persistentLifeTime(0),
	m_restitution(btScalar(0.)),
	m_friction(btScalar(0.)),
	m_penetration(btScalar(0.)),
	m_contactSolverFunc(0),
	m_frictionSolverFunc(0)
	{	{

		return &m_contactManifold;
	}	}


	/// total applied impulse during most recent	const btPersistentManifold* getContactManifold() const
	frame	{
	btScalar m_appliedImpulse;	return &m_contactManifold;
	btScalar m_prevAppliedImpulse;	}
	btScalar m_accumulatedTangentImpulse0;
	btScalar m_accumulatedTangentImpulse1;


	btScalar m_jacDiagABInv;	virtual ~btContactConstraint();
	btScalar m_jacDiagABInvTangent0;
	btScalar m_jacDiagABInvTangent1;
	int m_persistentLifeTime;
	btScalar m_restitution;
	btScalar m_friction;
	btScalar m_penetration;
	btVector3 m_frictionWorldTangential0;
	btVector3 m_frictionWorldTangential1;


	btVector3 m_frictionAngularComponent0A;	virtual void getInfo1 (btConstraintInfo1* info);
	btVector3 m_frictionAngularComponent0B;
	btVector3 m_frictionAngularComponent1A;
	btVector3 m_frictionAngularComponent1B;


	//some data doesn't need to be persistent over frame	virtual void getInfo2 (btConstraintInfo2* info);
	s: todo: clean/reuse this
	btVector3 m_angularComponentA;
	btVector3 m_angularComponentB;


	ContactSolverFunc m_contactSolverFunc;	///obsolete methods
	ContactSolverFunc m_frictionSolverFunc;	virtual void buildJacobian();

		///obsolete methods
		virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver
		Body& bodyB,btScalar timeStep);

	};	};


	///bilateral constraint between two dynamic objects	///resolveSingleBilateral is an obsolete methods used for vehicle friction
	///positive distance = separation, negative distance = penetration	between two dynamic objects
	void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1,	void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1,
	btRigidBody& body2, const btVector3& pos2,	btRigidBody& body2, const btVector3& pos2,
	btScalar distance, const btVector3& normal,btScalar& impulse ,btScalar timeStep);	btScalar distance, const btVector3& normal,btScalar& impulse ,btScalar timeStep);


	///contact constraint resolution:
	///calculate and apply impulse to satisfy non-penetration and non-negative
	relative velocity constraint
	///positive distance = separation, negative distance = penetration
	btScalar resolveSingleCollision(
	btRigidBody& body1,
	btRigidBody& body2,
	btManifoldPoint& contactPoint,
	const btContactSolverInfo& info);

	btScalar resolveSingleFriction(
	btRigidBody& body1,
	btRigidBody& body2,
	btManifoldPoint& contactPoint,
	const btContactSolverInfo& solverInfo
	);

	btScalar resolveSingleCollisionCombined(
	btRigidBody& body1,
	btRigidBody& body2,
	btManifoldPoint& contactPoint,
	const btContactSolverInfo& solverInfo
	);

	#endif //CONTACT_CONSTRAINT_H	#endif //CONTACT_CONSTRAINT_H

End of changes. 13 change blocks.
	89 lines changed or deleted	35 lines changed or added

	btContactSolverInfo.h	btContactSolverInfo.h

	skipping to change at line 76	skipping to change at line 76
	m_maxErrorReduction = btScalar(20.);	m_maxErrorReduction = btScalar(20.);
	m_numIterations = 10;	m_numIterations = 10;
	m_erp = btScalar(0.2);	m_erp = btScalar(0.2);
	m_erp2 = btScalar(0.1);	m_erp2 = btScalar(0.1);
	m_globalCfm = btScalar(0.);	m_globalCfm = btScalar(0.);
	m_sor = btScalar(1.);	m_sor = btScalar(1.);
	m_splitImpulse = false;	m_splitImpulse = false;
	m_splitImpulsePenetrationThreshold = -0.02f;	m_splitImpulsePenetrationThreshold = -0.02f;
	m_linearSlop = btScalar(0.0);	m_linearSlop = btScalar(0.0);
	m_warmstartingFactor=btScalar(0.85);	m_warmstartingFactor=btScalar(0.85);

	m_solverMode = SOLVER_USE_WARMSTARTING \| SOLVER_SIMD ;//SOLV ER_RANDMIZE_ORDER	m_solverMode = SOLVER_USE_WARMSTARTING \| SOLVER_SIMD;// \| SO LVER_RANDMIZE_ORDER;
	m_restingContactRestitutionThreshold = 2;//resting contact l ifetime threshold to disable restitution	m_restingContactRestitutionThreshold = 2;//resting contact l ifetime threshold to disable restitution
	}	}
	};	};

	#endif //CONTACT_SOLVER_INFO	#endif //CONTACT_SOLVER_INFO

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btConvexCast.h	btConvexCast.h

	skipping to change at line 42	skipping to change at line 42
	///RayResult stores the closest result	///RayResult stores the closest result
	/// alternatively, add a callback method to decide about closest/all results	/// alternatively, add a callback method to decide about closest/all results
	struct CastResult	struct CastResult
	{	{
	//virtual bool addRayResult(const btVector3& normal,btScala r fraction) = 0;	//virtual bool addRayResult(const btVector3& normal,btScala r fraction) = 0;

	virtual void DebugDraw(btScalar fraction) {(void)fra ction;}	virtual void DebugDraw(btScalar fraction) {(void)fra ction;}
	virtual void drawCoordSystem(const btTransform& trans) {( void)trans;}	virtual void drawCoordSystem(const btTransform& trans) {( void)trans;}

	CastResult()	CastResult()

	:m_fraction(btScalar(1e30)),	:m_fraction(btScalar(BT_LARGE_FLOAT)),
	m_debugDrawer(0),	m_debugDrawer(0),
	m_allowedPenetration(btScalar(0))	m_allowedPenetration(btScalar(0))
	{	{
	}	}

	virtual ~CastResult() {};	virtual ~CastResult() {};

	btTransform m_hitTransformA;	btTransform m_hitTransformA;
	btTransform m_hitTransformB;	btTransform m_hitTransformB;
	btVector3 m_normal;	btVector3 m_normal;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btConvexInternalShape.h	btConvexInternalShape.h

		/*
		Bullet Continuous Collision Detection and Physics Library
		Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

		This software is provided 'as-is', without any express or implied warranty.
		In no event will the authors be held liable for any damages arising from th
		e use of this software.
		Permission is granted to anyone to use this software for any purpose,
		including commercial applications, and to alter it and redistribute it free
		ly,
		subject to the following restrictions:

		1. The origin of this software must not be misrepresented; you must not cla
		im that you wrote the original software. If you use this software in a prod
		uct, an acknowledgment in the product documentation would be appreciated bu
		t is not required.
		2. Altered source versions must be plainly marked as such, and must not be
		misrepresented as being the original software.
		3. This notice may not be removed or altered from any source distribution.
		*/

	#ifndef BT_CONVEX_INTERNAL_SHAPE_H	#ifndef BT_CONVEX_INTERNAL_SHAPE_H
	#define BT_CONVEX_INTERNAL_SHAPE_H	#define BT_CONVEX_INTERNAL_SHAPE_H

	#include "btConvexShape.h"	#include "btConvexShape.h"

		#include "LinearMath/btAabbUtil2.h"

	///The btConvexInternalShape is an internal base class, shared by most conv ex shape implementations.	///The btConvexInternalShape is an internal base class, shared by most conv ex shape implementations.
	class btConvexInternalShape : public btConvexShape	class btConvexInternalShape : public btConvexShape
	{	{

	protected:	protected:

	//local scaling. collisionMargin is not scaled !	//local scaling. collisionMargin is not scaled !
	btVector3 m_localScaling;	btVector3 m_localScaling;


	skipping to change at line 85	skipping to change at line 100

	virtual void getPreferredPenetrationDirection(int index, btVector 3& penetrationVector) const	virtual void getPreferredPenetrationDirection(int index, btVector 3& penetrationVector) const
	{	{
	(void)penetrationVector;	(void)penetrationVector;
	(void)index;	(void)index;
	btAssert(0);	btAssert(0);
	}	}

	};	};


		///btConvexInternalAabbCachingShape adds local aabb caching for convex shap
		es, to avoid expensive bounding box calculations
		class btConvexInternalAabbCachingShape : public btConvexInternalShape
		{
		btVector3 m_localAabbMin;
		btVector3 m_localAabbMax;
		bool m_isLocalAabbValid;

		protected:

		btConvexInternalAabbCachingShape();

		void setCachedLocalAabb (const btVector3& aabbMin, const btVector3&
		aabbMax)
		{
		m_isLocalAabbValid = true;
		m_localAabbMin = aabbMin;
		m_localAabbMax = aabbMax;
		}

		inline void getCachedLocalAabb (btVector3& aabbMin, btVector3& aabbM
		ax) const
		{
		btAssert(m_isLocalAabbValid);
		aabbMin = m_localAabbMin;
		aabbMax = m_localAabbMax;
		}

		inline void getNonvirtualAabb(const btTransform& trans,btVector3& aa
		bbMin,btVector3& aabbMax, btScalar margin) const
		{

		//lazy evaluation of local aabb
		btAssert(m_isLocalAabbValid);
		btTransformAabb(m_localAabbMin,m_localAabbMax,margin,trans,a
		abbMin,aabbMax);
		}

		public:

		virtual void setLocalScaling(const btVector3& scaling);

		virtual void getAabb(const btTransform& t,btVector3& aabbMin,btVecto
		r3& aabbMax) const;

		void recalcLocalAabb();

		};

	#endif //BT_CONVEX_INTERNAL_SHAPE_H	#endif //BT_CONVEX_INTERNAL_SHAPE_H

End of changes. 3 change blocks.
	0 lines changed or deleted	70 lines changed or added

	btConvexPenetrationDepthSolver.h	btConvexPenetrationDepthSolver.h

	skipping to change at line 16	skipping to change at line 16
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/


	#ifndef CONVEX_PENETRATION_DEPTH_H	#ifndef __CONVEX_PENETRATION_DEPTH_H
	#define CONVEX_PENETRATION_DEPTH_H	#define __CONVEX_PENETRATION_DEPTH_H

	class btStackAlloc;	class btStackAlloc;
	class btVector3;	class btVector3;
	#include "btSimplexSolverInterface.h"	#include "btSimplexSolverInterface.h"
	class btConvexShape;	class btConvexShape;
	class btTransform;	class btTransform;

	///ConvexPenetrationDepthSolver provides an interface for penetration depth calculation.	///ConvexPenetrationDepthSolver provides an interface for penetration depth calculation.
	class btConvexPenetrationDepthSolver	class btConvexPenetrationDepthSolver
	{	{

End of changes. 1 change blocks.
	2 lines changed or deleted	2 lines changed or added

	btConvexPlaneCollisionAlgorithm.h	btConvexPlaneCollisionAlgorithm.h

	skipping to change at line 63	skipping to change at line 63
	manifoldArray.push_back(m_manifoldPtr);	manifoldArray.push_back(m_manifoldPtr);
	}	}
	}	}

	struct CreateFunc :public btCollisionAlgorithmCreateFunc	struct CreateFunc :public btCollisionAlgorithmCreateFunc
	{	{
	int m_numPerturbationIterations;	int m_numPerturbationIterations;
	int m_minimumPointsPerturbationThreshold;	int m_minimumPointsPerturbationThreshold;

	CreateFunc()	CreateFunc()

	: m_numPerturbationIterations(3),	: m_numPerturbationIterations(1),
	m_minimumPointsPerturbationThreshold(3)	m_minimumPointsPerturbationThreshold(1)
	{	{
	}	}

	virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCol lisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionOb ject* body1)	virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCol lisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionOb ject* body1)
	{	{
	void* mem = ci.m_dispatcher1->allocateCollisionAlgor ithm(sizeof(btConvexPlaneCollisionAlgorithm));	void* mem = ci.m_dispatcher1->allocateCollisionAlgor ithm(sizeof(btConvexPlaneCollisionAlgorithm));
	if (!m_swapped)	if (!m_swapped)
	{	{
	return new(mem) btConvexPlaneCollisionAlgori thm(0,ci,body0,body1,false,m_numPerturbationIterations,m_minimumPointsPertu rbationThreshold);	return new(mem) btConvexPlaneCollisionAlgori thm(0,ci,body0,body1,false,m_numPerturbationIterations,m_minimumPointsPertu rbationThreshold);
	} else	} else

End of changes. 1 change blocks.
	2 lines changed or deleted	2 lines changed or added

	btConvexPointCloudShape.h	btConvexPointCloudShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef BT_CONVEX_POINT_CLOUD_SHAPE_H	#ifndef BT_CONVEX_POINT_CLOUD_SHAPE_H
	#define BT_CONVEX_POINT_CLOUD_SHAPE_H	#define BT_CONVEX_POINT_CLOUD_SHAPE_H

	#include "btPolyhedralConvexShape.h"	#include "btPolyhedralConvexShape.h"
	#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for t he types	#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for t he types
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"

	///The btConvexPointCloudShape implements an implicit convex hull of an arr ay of vertices.	///The btConvexPointCloudShape implements an implicit convex hull of an arr ay of vertices.

	ATTRIBUTE_ALIGNED16(class) btConvexPointCloudShape : public btPolyhedralCon vexShape	ATTRIBUTE_ALIGNED16(class) btConvexPointCloudShape : public btPolyhedralCon vexAabbCachingShape
	{	{
	btVector3* m_unscaledPoints;	btVector3* m_unscaledPoints;
	int m_numPoints;	int m_numPoints;

	public:	public:
	BT_DECLARE_ALIGNED_ALLOCATOR();	BT_DECLARE_ALIGNED_ALLOCATOR();


		btConvexPointCloudShape()
		{
		m_localScaling.setValue(1.f,1.f,1.f);
		m_shapeType = CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE;
		m_unscaledPoints = 0;
		m_numPoints = 0;
		}

	btConvexPointCloudShape(btVector3* points,int numPoints, const btVec tor3& localScaling,bool computeAabb = true)	btConvexPointCloudShape(btVector3* points,int numPoints, const btVec tor3& localScaling,bool computeAabb = true)
	{	{
	m_localScaling = localScaling;	m_localScaling = localScaling;
	m_shapeType = CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE;	m_shapeType = CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE;
	m_unscaledPoints = points;	m_unscaledPoints = points;
	m_numPoints = numPoints;	m_numPoints = numPoints;

	if (computeAabb)	if (computeAabb)
	recalcLocalAabb();	recalcLocalAabb();
	}	}


	void setPoints (btVector3* points, int numPoints, bool computeAabb = true)	void setPoints (btVector3* points, int numPoints, bool computeAabb = true,const btVector3& localScaling=btVector3(1.f,1.f,1.f))
	{	{
	m_unscaledPoints = points;	m_unscaledPoints = points;
	m_numPoints = numPoints;	m_numPoints = numPoints;

		m_localScaling = localScaling;

	if (computeAabb)	if (computeAabb)
	recalcLocalAabb();	recalcLocalAabb();
	}	}

	SIMD_FORCE_INLINE btVector3* getUnscaledPoints()	SIMD_FORCE_INLINE btVector3* getUnscaledPoints()
	{	{
	return m_unscaledPoints;	return m_unscaledPoints;
	}	}


End of changes. 5 change blocks.
	3 lines changed or deleted	12 lines changed or added

	btConvexShape.h	btConvexShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btConvexTriangleMeshShape.h	btConvexTriangleMeshShape.h

		/*
		Bullet Continuous Collision Detection and Physics Library
		Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

		This software is provided 'as-is', without any express or implied warranty.
		In no event will the authors be held liable for any damages arising from th
		e use of this software.
		Permission is granted to anyone to use this software for any purpose,
		including commercial applications, and to alter it and redistribute it free
		ly,
		subject to the following restrictions:

		1. The origin of this software must not be misrepresented; you must not cla
		im that you wrote the original software. If you use this software in a prod
		uct, an acknowledgment in the product documentation would be appreciated bu
		t is not required.
		2. Altered source versions must be plainly marked as such, and must not be
		misrepresented as being the original software.
		3. This notice may not be removed or altered from any source distribution.
		*/
	#ifndef CONVEX_TRIANGLEMESH_SHAPE_H	#ifndef CONVEX_TRIANGLEMESH_SHAPE_H
	#define CONVEX_TRIANGLEMESH_SHAPE_H	#define CONVEX_TRIANGLEMESH_SHAPE_H

	#include "btPolyhedralConvexShape.h"	#include "btPolyhedralConvexShape.h"
	#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for t he types	#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for t he types

	/// The btConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good as btConvexHullShape.	/// The btConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good as btConvexHullShape.
	/// A small benefit of this class is that it uses the btStridingMeshInterfa ce, so you can avoid the duplication of the triangle mesh data. Nevertheles s, most users should use the much better performing btConvexHullShape inste ad.	/// A small benefit of this class is that it uses the btStridingMeshInterfa ce, so you can avoid the duplication of the triangle mesh data. Nevertheles s, most users should use the much better performing btConvexHullShape inste ad.

	class btConvexTriangleMeshShape : public btPolyhedralConvexShape	class btConvexTriangleMeshShape : public btPolyhedralConvexAabbCachingShape
	{	{

	class btStridingMeshInterface* m_stridingMesh;	class btStridingMeshInterface* m_stridingMesh;

	public:	public:
	btConvexTriangleMeshShape(btStridingMeshInterface* meshInterface, bo ol calcAabb = true);	btConvexTriangleMeshShape(btStridingMeshInterface* meshInterface, bo ol calcAabb = true);

	class btStridingMeshInterface* getMeshInterface()	class btStridingMeshInterface* getMeshInterface()
	{	{
	return m_stridingMesh;	return m_stridingMesh;

End of changes. 2 change blocks.
	1 lines changed or deleted	21 lines changed or added

	btCudaBroadphase.h	btCudaBroadphase.h
	/*	/*

	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library, http://bulletphy
	Copyright (c) 2003-2008 Erwin Coumans http://continuousphysics.com/Bullet/	sics.org
		Copyright (C) 2006, 2007 Sony Computer Entertainment Inc.

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef CUDA_BROADPHASE_H	#ifndef CUDA_BROADPHASE_H
	#define CUDA_BROADPHASE_H	#define CUDA_BROADPHASE_H

	#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h"	#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h"


	#include "btCudaBroadphaseKernel.h"	#include "../../src/BulletMultiThreaded/btGpu3DGridBroadphaseSharedTypes.h"
		#include "../../src/BulletMultiThreaded/btGpu3DGridBroadphase.h"
	///The bt3DGridBroadphase uses CUDA to compute overlapping pairs using a GP
	U.
	class bt3DGridBroadphase : public btSimpleBroadphase
	{
	protected:
	bool m_bInitialized;
	unsigned int m_numBodies;
	unsigned int m_numCells;
	unsigned int m_maxPairsPerBody;
	btScalar m_cellFactorAABB;
	unsigned int m_maxBodiesPerCell;
	btCudaBroadphaseParams m_params;
	btScalar m_maxRadius;
	// CPU data
	unsigned int* m_hBodiesHash;
	unsigned int* m_hCellStart;
	unsigned int* m_hPairBuffStartCurr;
	btCuda3F1U* m_hAABB;
	unsigned int* m_hPairBuff;
	unsigned int* m_hPairScan;
	unsigned int* m_hPairOut;
	// large proxies
	int m_numLargeHandles;
	int m_maxLargeHandles;
	int m_LastLargeHandleIndex;
	btSimpleBroadphaseProxy* m_pLargeHandles;
	void* m_pLargeHandlesRawPtr;
	int m_firstFreeLargeHandle;
	int allocLargeHandle()
	{
	btAssert(m_numLargeHandles < m_maxLargeHandles);
	int freeLargeHandle = m_firstFreeLargeHandle;
	m_firstFreeLargeHandle = m_pLargeHandles[freeLargeHandle].Ge
	tNextFree();
	m_numLargeHandles++;
	if(freeLargeHandle > m_LastLargeHandleIndex)
	{
	m_LastLargeHandleIndex = freeLargeHandle;
	}
	return freeLargeHandle;
	}
	void freeLargeHandle(btSimpleBroadphaseProxy* proxy)
	{
	int handle = int(proxy - m_pLargeHandles);
	btAssert((handle >= 0) && (handle < m_maxHandles));
	if(handle == m_LastLargeHandleIndex)
	{
	m_LastLargeHandleIndex--;
	}
	proxy->SetNextFree(m_firstFreeLargeHandle);
	m_firstFreeLargeHandle = handle;
	proxy->m_clientObject = 0;
	m_numLargeHandles--;
	}
	bool isLargeProxy(const btVector3& aabbMin, const btVector3& aabbMa
	x);
	bool isLargeProxy(btBroadphaseProxy* proxy);
	// debug
	unsigned int m_numPairsAdded;
	unsigned int m_numPairsRemoved;
	unsigned int m_numOverflows;
	//
	public:
	bt3DGridBroadphase(const btVector3& worldAabbMin,const btVector3& wo
	rldAabbMax,
	int gridSizeX, int gridSizeY, int
	gridSizeZ,
	int maxSmallProxies, int maxLarge
	Proxies, int maxPairsPerBody,
	int maxBodiesPerCell = 8,
	btScalar cellFactorAABB = btScala
	r(1.0f));
	virtual ~bt3DGridBroadphase();
	virtual void calculateOverlappingPairs(btDispatcher* dispatcher);

	virtual btBroadphaseProxy* createProxy(const btVector3& aabbMin
	, const btVector3& aabbMax,int shapeType,void* userPtr ,short int collisio
	nFilterGroup,short int collisionFilterMask, btDispatcher* dispatcher,void*
	multiSapProxy);
	virtual void destroyProxy(btBroadphaseProxy* proxy,btDispatcher*
	dispatcher);
	virtual void rayTest(const btVector3& rayFrom,const btVector3& ra
	yTo, btBroadphaseRayCallback& rayCallback);
	protected:
	void _initialize();
	void _finalize();
	void addPairsToCache(btDispatcher* dispatcher);
	void addLarge2LargePairsToCache(btDispatcher* dispatcher);


	// overrides for CPU version	///The btCudaBroadphase uses CUDA-capable GPU to compute overlapping pairs
	virtual void setParameters(btCudaBroadphaseParams* hostParams);
	virtual void prepareAABB();
	virtual void calcHashAABB();
	virtual void sortHash();
	virtual void findCellStart();
	virtual void findOverlappingPairs();
	virtual void findPairsLarge();
	virtual void computePairCacheChanges();
	virtual void scanOverlappingPairBuff();
	virtual void squeezeOverlappingPairBuff();
	};


	///The btCudaBroadphase uses CUDA to compute overlapping pairs using a GPU.	class btCudaBroadphase : public btGpu3DGridBroadphase
	class btCudaBroadphase : public bt3DGridBroadphase
	{	{
	protected:	protected:
	// GPU data	// GPU data
	unsigned int* m_dBodiesHash[2];	unsigned int* m_dBodiesHash[2];
	unsigned int* m_dCellStart;	unsigned int* m_dCellStart;
	unsigned int* m_dPairBuff;	unsigned int* m_dPairBuff;
	unsigned int* m_dPairBuffStartCurr;	unsigned int* m_dPairBuffStartCurr;

	btCuda3F1U* m_dAABB;	bt3DGrid3F1U* m_dAABB;
	unsigned int* m_dPairScan;	unsigned int* m_dPairScan;
	unsigned int* m_dPairOut;	unsigned int* m_dPairOut;
	public:	public:

	btCudaBroadphase(const btVector3& worldAabbMin,const btVector3& worl	btCudaBroadphase( btOverlappingPairCache* overlappingPairCache
	dAabbMax,	,
	int gridS	const btVector3& worldAabbMi
	izeX, int gridSizeY, int gridSizeZ,	n,const btVector3& worldAabbMax,
	int maxSm	int gridSizeX, int gridSizeY
	allProxies, int maxLargeProxies, int maxPairsPerBody,	, int gridSizeZ,
	int maxBo	int maxSmallProxies, int max
	diesPerCell = 8,	LargeProxies, int maxPairsPerSmallProxies,
	btScalar	int maxSmallProxiesPerCell =
	cellFactorAABB = btScalar(1.0f));	8);
	virtual ~btCudaBroadphase();	virtual ~btCudaBroadphase();
	protected:	protected:
	void _initialize();	void _initialize();
	void _finalize();	void _finalize();
	void allocateArray(void** devPtr, unsigned int size);	void allocateArray(void** devPtr, unsigned int size);
	void freeArray(void* devPtr);	void freeArray(void* devPtr);
	// overrides for CUDA version	// overrides for CUDA version

	virtual void setParameters(btCudaBroadphaseParams* hostParams);	virtual void setParameters(bt3DGridBroadphaseParams* hostParams);
	virtual void prepareAABB();	virtual void prepareAABB();
	virtual void calcHashAABB();	virtual void calcHashAABB();
	virtual void sortHash();	virtual void sortHash();
	virtual void findCellStart();	virtual void findCellStart();
	virtual void findOverlappingPairs();	virtual void findOverlappingPairs();
	virtual void findPairsLarge();	virtual void findPairsLarge();
	virtual void computePairCacheChanges();	virtual void computePairCacheChanges();
	virtual void scanOverlappingPairBuff();	virtual void scanOverlappingPairBuff();
	virtual void squeezeOverlappingPairBuff();	virtual void squeezeOverlappingPairBuff();

		virtual void resetPool(btDispatcher* dispatcher);
	};	};


	#endif //CUDA_BROADPHASE_H	#endif //CUDA_BROADPHASE_H

End of changes. 9 change blocks.
	118 lines changed or deleted	21 lines changed or added

	btCylinderShape.h	btCylinderShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef CYLINDER_MINKOWSKI_H	#ifndef CYLINDER_MINKOWSKI_H
	#define CYLINDER_MINKOWSKI_H	#define CYLINDER_MINKOWSKI_H

	#include "btBoxShape.h"	#include "btBoxShape.h"
	#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for t he types	#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for t he types
	#include "LinearMath/btVector3.h"	#include "LinearMath/btVector3.h"

	/// The btCylinderShape class implements a cylinder shape primitive, center ed around the origin. Its central axis aligned with the Y axis. btCylinderS hapeX is aligned with the X axis and btCylinderShapeZ around the Z axis.	/// The btCylinderShape class implements a cylinder shape primitive, center ed around the origin. Its central axis aligned with the Y axis. btCylinderS hapeX is aligned with the X axis and btCylinderShapeZ around the Z axis.

	class btCylinderShape : public btBoxShape	class btCylinderShape : public btConvexInternalShape

	{	{

	protected:	protected:

	int m_upAxis;	int m_upAxis;

	public:	public:


		btVector3 getHalfExtentsWithMargin() const
		{
		btVector3 halfExtents = getHalfExtentsWithoutMargin();
		btVector3 margin(getMargin(),getMargin(),getMargin());
		halfExtents += margin;
		return halfExtents;
		}

		const btVector3& getHalfExtentsWithoutMargin() const
		{
		return m_implicitShapeDimensions;//changed in Bullet 2.63: a
		ssume the scaling and margin are included
		}

	btCylinderShape (const btVector3& halfExtents);	btCylinderShape (const btVector3& halfExtents);


	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
	void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabb Max) const;	void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabb Max) const;


		virtual void calculateLocalInertia(btScalar mass,btVector3& inert
		ia) const;

	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec)const;	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec)const;

	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(co nst btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(co nst btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;


		virtual void setMargin(btScalar collisionMargin)
		{
		//correct the m_implicitShapeDimensions for the margin
		btVector3 oldMargin(getMargin(),getMargin(),getMargin());
		btVector3 implicitShapeDimensionsWithMargin = m_implicitShap
		eDimensions+oldMargin;

		btConvexInternalShape::setMargin(collisionMargin);
		btVector3 newMargin(getMargin(),getMargin(),getMargin());
		m_implicitShapeDimensions = implicitShapeDimensionsWithMargi
		n - newMargin;

		}

	virtual btVector3 localGetSupportingVertex(const btVector3& ve c) const	virtual btVector3 localGetSupportingVertex(const btVector3& ve c) const
	{	{

	btVector3 supVertex;	btVector3 supVertex;
	supVertex = localGetSupportingVertexWithoutMargin(vec);	supVertex = localGetSupportingVertexWithoutMargin(vec);

	if ( getMargin()!=btScalar(0.) )	if ( getMargin()!=btScalar(0.) )
	{	{
	btVector3 vecnorm = vec;	btVector3 vecnorm = vec;
	if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON) )	if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON) )

End of changes. 6 change blocks.
	3 lines changed or deleted	34 lines changed or added

	btDbvt.h	btDbvt.h

	skipping to change at line 59	skipping to change at line 59

	// Enable benchmarking code	// Enable benchmarking code
	#define DBVT_ENABLE_BENCHMARK 0	#define DBVT_ENABLE_BENCHMARK 0

	// Inlining	// Inlining
	#define DBVT_INLINE SIMD_FORCE_INLINE	#define DBVT_INLINE SIMD_FORCE_INLINE

	// Specific methods implementation	// Specific methods implementation

	//SSE gives errors on a MSVC 7.1	//SSE gives errors on a MSVC 7.1

	#ifdef BT_USE_SSE	#if defined (BT_USE_SSE) && defined (WIN32)
	#define DBVT_SELECT_IMPL DBVT_IMPL_SSE	#define DBVT_SELECT_IMPL DBVT_IMPL_SSE
	#define DBVT_MERGE_IMPL DBVT_IMPL_SSE	#define DBVT_MERGE_IMPL DBVT_IMPL_SSE
	#define DBVT_INT0_IMPL DBVT_IMPL_SSE	#define DBVT_INT0_IMPL DBVT_IMPL_SSE
	#else	#else
	#define DBVT_SELECT_IMPL DBVT_IMPL_GENERIC	#define DBVT_SELECT_IMPL DBVT_IMPL_GENERIC
	#define DBVT_MERGE_IMPL DBVT_IMPL_GENERIC	#define DBVT_MERGE_IMPL DBVT_IMPL_GENERIC
	#define DBVT_INT0_IMPL DBVT_IMPL_GENERIC	#define DBVT_INT0_IMPL DBVT_IMPL_GENERIC
	#endif	#endif

	#if (DBVT_SELECT_IMPL==DBVT_IMPL_SSE)\|\| \	#if (DBVT_SELECT_IMPL==DBVT_IMPL_SSE)\|\| \

	skipping to change at line 484	skipping to change at line 484
	pi=btVector3(mi.x(),mi.y(),mx.z());break;	pi=btVector3(mi.x(),mi.y(),mx.z());break;
	case (0+0+4): px=btVector3(mi.x(),mi.y(),mx.z());	case (0+0+4): px=btVector3(mi.x(),mi.y(),mx.z());
	pi=btVector3(mx.x(),mx.y(),mi.z());break;	pi=btVector3(mx.x(),mx.y(),mi.z());break;
	case (1+0+4): px=btVector3(mx.x(),mi.y(),mx.z());	case (1+0+4): px=btVector3(mx.x(),mi.y(),mx.z());
	pi=btVector3(mi.x(),mx.y(),mi.z());break;	pi=btVector3(mi.x(),mx.y(),mi.z());break;
	case (0+2+4): px=btVector3(mi.x(),mx.y(),mx.z());	case (0+2+4): px=btVector3(mi.x(),mx.y(),mx.z());
	pi=btVector3(mx.x(),mi.y(),mi.z());break;	pi=btVector3(mx.x(),mi.y(),mi.z());break;
	case (1+2+4): px=btVector3(mx.x(),mx.y(),mx.z());	case (1+2+4): px=btVector3(mx.x(),mx.y(),mx.z());
	pi=btVector3(mi.x(),mi.y(),mi.z());break;	pi=btVector3(mi.x(),mi.y(),mi.z());break;
	}	}

	if((dot(n,px)+o)<0) return(-1);	if((btDot(n,px)+o)<0) return(-1);
	if((dot(n,pi)+o)>=0) return(+1);	if((btDot(n,pi)+o)>=0) return(+1);
	return(0);	return(0);
	}	}

	//	//
	DBVT_INLINE btScalar btDbvtAabbMm::ProjectMinimum(const btVector3& v,unsi gned signs) const	DBVT_INLINE btScalar btDbvtAabbMm::ProjectMinimum(const btVector3& v,unsi gned signs) const
	{	{
	const btVector3* b[]={&mx,&mi};	const btVector3* b[]={&mx,&mi};
	const btVector3 p( b[(signs>>0)&1]->x(),	const btVector3 p( b[(signs>>0)&1]->x(),
	b[(signs>>1)&1]->y(),	b[(signs>>1)&1]->y(),
	b[(signs>>2)&1]->z());	b[(signs>>2)&1]->z());

	return(dot(p,v));	return(btDot(p,v));
	}	}

	//	//
	DBVT_INLINE void btDbvtAabbMm::AddSpan(const btVector3& d,btS calar& smi,btScalar& smx) const	DBVT_INLINE void btDbvtAabbMm::AddSpan(const btVector3& d,btS calar& smi,btScalar& smx) const
	{	{
	for(int i=0;i<3;++i)	for(int i=0;i<3;++i)
	{	{
	if(d[i]<0)	if(d[i]<0)
	{ smi+=mx[i]d[i];smx+=mi[i]d[i]; }	{ smi+=mx[i]d[i];smx+=mi[i]d[i]; }
	else	else

	skipping to change at line 989	skipping to change at line 989
	const btVect or3& rayFrom,	const btVect or3& rayFrom,
	const btVect or3& rayTo,	const btVect or3& rayTo,
	DBVT_IPOLICY )	DBVT_IPOLICY )
	{	{
	DBVT_CHECKTYPE	DBVT_CHECKTYPE
	if(root)	if(root)
	{	{
	btVector3 rayDir = (rayTo-rayFrom);	btVector3 rayDir = (rayTo-rayFrom);
	rayDir.normalize ();	rayDir.normalize ();


	///what about division by zero? --> just set rayDire ction[i] to INF/1e30	///what about division by zero? --> just set rayDire ction[i] to INF/BT_LARGE_FLOAT
	btVector3 rayDirectionInverse;	btVector3 rayDirectionInverse;

	rayDirectionInverse[0] = rayDir[0] == btScalar(0.0)	rayDirectionInverse[0] = rayDir[0] == btScalar(0.0)
	? btScalar(1e30) : btScalar(1.0) / rayDir[0];	? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[0];
	rayDirectionInverse[1] = rayDir[1] == btScalar(0.0)	rayDirectionInverse[1] = rayDir[1] == btScalar(0.0)
	? btScalar(1e30) : btScalar(1.0) / rayDir[1];	? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[1];
	rayDirectionInverse[2] = rayDir[2] == btScalar(0.0)	rayDirectionInverse[2] = rayDir[2] == btScalar(0.0)
	? btScalar(1e30) : btScalar(1.0) / rayDir[2];	? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[2];
	unsigned int signs[3] = { rayDirectionInverse[0] < 0 .0, rayDirectionInverse[1] < 0.0, rayDirectionInverse[2] < 0.0};	unsigned int signs[3] = { rayDirectionInverse[0] < 0 .0, rayDirectionInverse[1] < 0.0, rayDirectionInverse[2] < 0.0};

	btScalar lambda_max = rayDir.dot(rayTo-rayFrom);	btScalar lambda_max = rayDir.dot(rayTo-rayFrom);

	btVector3 resultNormal;	btVector3 resultNormal;

	btAlignedObjectArray<const btDbvtNode*> stack;	btAlignedObjectArray<const btDbvtNode*> stack;

	int depth=1;	int depth=1;
	int treshold=DOUBLE_STACKSIZE-2;	int treshold=DOUBLE_STACKSIZE-2;

End of changes. 5 change blocks.
	11 lines changed or deleted	11 lines changed or added

	btDefaultCollisionConfiguration.h	btDefaultCollisionConfiguration.h

	skipping to change at line 30	skipping to change at line 30
	class btVoronoiSimplexSolver;	class btVoronoiSimplexSolver;
	class btConvexPenetrationDepthSolver;	class btConvexPenetrationDepthSolver;

	struct btDefaultCollisionConstructionInfo	struct btDefaultCollisionConstructionInfo
	{	{
	btStackAlloc* m_stackAlloc;	btStackAlloc* m_stackAlloc;
	btPoolAllocator* m_persistentManifoldPool;	btPoolAllocator* m_persistentManifoldPool;
	btPoolAllocator* m_collisionAlgorithmPool;	btPoolAllocator* m_collisionAlgorithmPool;
	int m_defaultMaxPersistentManifo ldPoolSize;	int m_defaultMaxPersistentManifo ldPoolSize;
	int m_defaultMaxCollisionAlgorit hmPoolSize;	int m_defaultMaxCollisionAlgorit hmPoolSize;

		int m_customCollisionAlgorithmMa xElementSize;
	int m_defaultStackAllocatorSize;	int m_defaultStackAllocatorSize;

		int m_useEpaPenetrationAlgorithm ;

	btDefaultCollisionConstructionInfo()	btDefaultCollisionConstructionInfo()
	:m_stackAlloc(0),	:m_stackAlloc(0),
	m_persistentManifoldPool(0),	m_persistentManifoldPool(0),
	m_collisionAlgorithmPool(0),	m_collisionAlgorithmPool(0),
	m_defaultMaxPersistentManifoldPoolSize(4096),	m_defaultMaxPersistentManifoldPoolSize(4096),
	m_defaultMaxCollisionAlgorithmPoolSize(4096),	m_defaultMaxCollisionAlgorithmPoolSize(4096),

	m_defaultStackAllocatorSize(0)	m_customCollisionAlgorithmMaxElementSize(0),
		m_defaultStackAllocatorSize(0),
		m_useEpaPenetrationAlgorithm(true)
	{	{
	}	}
	};	};

	///btCollisionConfiguration allows to configure Bullet collision detection	///btCollisionConfiguration allows to configure Bullet collision detection
	///stack allocator, pool memory allocators	///stack allocator, pool memory allocators
	///@todo: describe the meaning	///@todo: describe the meaning
	class btDefaultCollisionConfiguration : public btCollisionConfiguration	class btDefaultCollisionConfiguration : public btCollisionConfiguration
	{	{


End of changes. 3 change blocks.
	1 lines changed or deleted	5 lines changed or added

	btDiscreteCollisionDetectorInterface.h	btDiscreteCollisionDetectorInterface.h

	skipping to change at line 35	skipping to change at line 35
	/// distance is between closest points on B and closest point on A. So you can calculate closest point on A	/// distance is between closest points on B and closest point on A. So you can calculate closest point on A
	/// by taking closestPointInA = closestPointInB + m_distance * m_normalOnSu rfaceB	/// by taking closestPointInA = closestPointInB + m_distance * m_normalOnSu rfaceB
	struct btDiscreteCollisionDetectorInterface	struct btDiscreteCollisionDetectorInterface
	{	{

	struct Result	struct Result
	{	{

	virtual ~Result(){}	virtual ~Result(){}


	///setShapeIdentifiers provides experimental support for per	///setShapeIdentifiersA/B provides experimental support for
	-triangle material / custom material combiner	per-triangle material / custom material combiner
	virtual void setShapeIdentifiers(int partId0,int index0,	virtual void setShapeIdentifiersA(int partId0,int index0)=0;
	int partId1,int index1)=0;	virtual void setShapeIdentifiersB(int partId1,int index1)=0;
	virtual void addContactPoint(const btVector3& normalOnBInWor ld,const btVector3& pointInWorld,btScalar depth)=0;	virtual void addContactPoint(const btVector3& normalOnBInWor ld,const btVector3& pointInWorld,btScalar depth)=0;
	};	};

	struct ClosestPointInput	struct ClosestPointInput
	{	{
	ClosestPointInput()	ClosestPointInput()

	:m_maximumDistanceSquared(btScalar(1e30)),	:m_maximumDistanceSquared(btScalar(BT_LARGE_FLOAT)),
	m_stackAlloc(0)	m_stackAlloc(0)
	{	{
	}	}

	btTransform m_transformA;	btTransform m_transformA;
	btTransform m_transformB;	btTransform m_transformB;
	btScalar m_maximumDistanceSquared;	btScalar m_maximumDistanceSquared;
	btStackAlloc* m_stackAlloc;	btStackAlloc* m_stackAlloc;
	};	};


	skipping to change at line 70	skipping to change at line 71
	virtual void getClosestPoints(const ClosestPointInput& input,Resu lt& output,class btIDebugDraw* debugDraw,bool swapResults=false) = 0;	virtual void getClosestPoints(const ClosestPointInput& input,Resu lt& output,class btIDebugDraw* debugDraw,bool swapResults=false) = 0;

	};	};

	struct btStorageResult : public btDiscreteCollisionDetectorInterface::Resul t	struct btStorageResult : public btDiscreteCollisionDetectorInterface::Resul t
	{	{
	btVector3 m_normalOnSurfaceB;	btVector3 m_normalOnSurfaceB;
	btVector3 m_closestPointInB;	btVector3 m_closestPointInB;
	btScalar m_distance; //negative means penetration !	btScalar m_distance; //negative means penetration !


	btStorageResult() : m_distance(btScalar(1e30))	btStorageResult() : m_distance(btScalar(BT_LARGE_FLOAT))
	{	{

	}	}
	virtual ~btStorageResult() {};	virtual ~btStorageResult() {};

	virtual void addContactPoint(const btVector3& normalOnBInWor ld,const btVector3& pointInWorld,btScalar depth)	virtual void addContactPoint(const btVector3& normalOnBInWor ld,const btVector3& pointInWorld,btScalar depth)
	{	{
	if (depth < m_distance)	if (depth < m_distance)
	{	{
	m_normalOnSurfaceB = normalOnBInWorld;	m_normalOnSurfaceB = normalOnBInWorld;

End of changes. 3 change blocks.
	6 lines changed or deleted	6 lines changed or added

	btDiscreteDynamicsWorld.h	btDiscreteDynamicsWorld.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

	skipping to change at line 43	skipping to change at line 43
	class btDiscreteDynamicsWorld : public btDynamicsWorld	class btDiscreteDynamicsWorld : public btDynamicsWorld
	{	{
	protected:	protected:

	btConstraintSolver* m_constraintSolver;	btConstraintSolver* m_constraintSolver;

	btSimulationIslandManager* m_islandManager;	btSimulationIslandManager* m_islandManager;

	btAlignedObjectArray<btTypedConstraint*> m_constraints;	btAlignedObjectArray<btTypedConstraint*> m_constraints;


		btAlignedObjectArray<btRigidBody*> m_nonStaticRigidBodies;

	btVector3 m_gravity;	btVector3 m_gravity;

	//for variable timesteps	//for variable timesteps
	btScalar m_localTime;	btScalar m_localTime;
	//for variable timesteps	//for variable timesteps

	bool m_ownsIslandManager;	bool m_ownsIslandManager;
	bool m_ownsConstraintSolver;	bool m_ownsConstraintSolver;

		bool m_synchronizeAllMotionStates;

	btAlignedObjectArray<btActionInterface*> m_actions;	btAlignedObjectArray<btActionInterface*> m_actions;

	int m_profileTimings;	int m_profileTimings;

	virtual void predictUnconstraintMotion(btScalar timeStep);	virtual void predictUnconstraintMotion(btScalar timeStep);

	virtual void integrateTransforms(btScalar timeStep);	virtual void integrateTransforms(btScalar timeStep);

	virtual void calculateSimulationIslands();	virtual void calculateSimulationIslands();

	skipping to change at line 118	skipping to change at line 121

	btCollisionWorld* getCollisionWorld()	btCollisionWorld* getCollisionWorld()
	{	{
	return this;	return this;
	}	}

	virtual void setGravity(const btVector3& gravity);	virtual void setGravity(const btVector3& gravity);

	virtual btVector3 getGravity () const;	virtual btVector3 getGravity () const;


		virtual void addCollisionObject(btCollisionObject* collisionObjec
		t,short int collisionFilterGroup=btBroadphaseProxy::StaticFilter,short int
		collisionFilterMask=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::Stati
		cFilter);

	virtual void addRigidBody(btRigidBody* body);	virtual void addRigidBody(btRigidBody* body);

	virtual void addRigidBody(btRigidBody* body, short group, short m ask);	virtual void addRigidBody(btRigidBody* body, short group, short m ask);

	virtual void removeRigidBody(btRigidBody* body);	virtual void removeRigidBody(btRigidBody* body);


		///removeCollisionObject will first check if it is a rigid body, if
		so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObj
		ect
		virtual void removeCollisionObject(btCollisionObject* collisionOb
		ject);

	void debugDrawObject(const btTransform& worldTransform, const btC ollisionShape* shape, const btVector3& color);	void debugDrawObject(const btTransform& worldTransform, const btC ollisionShape* shape, const btVector3& color);

	void debugDrawConstraint(btTypedConstraint* constraint);	void debugDrawConstraint(btTypedConstraint* constraint);

	virtual void debugDrawWorld();	virtual void debugDrawWorld();

	virtual void setConstraintSolver(btConstraintSolver* solver);	virtual void setConstraintSolver(btConstraintSolver* solver);

	virtual btConstraintSolver* getConstraintSolver();	virtual btConstraintSolver* getConstraintSolver();


	skipping to change at line 171	skipping to change at line 179

	///obsolete, use addAction instead	///obsolete, use addAction instead
	virtual void addVehicle(btActionInterface* vehicle);	virtual void addVehicle(btActionInterface* vehicle);
	///obsolete, use removeAction instead	///obsolete, use removeAction instead
	virtual void removeVehicle(btActionInterface* vehicle);	virtual void removeVehicle(btActionInterface* vehicle);
	///obsolete, use addAction instead	///obsolete, use addAction instead
	virtual void addCharacter(btActionInterface* character);	virtual void addCharacter(btActionInterface* character);
	///obsolete, use removeAction instead	///obsolete, use removeAction instead
	virtual void removeCharacter(btActionInterface* character);	virtual void removeCharacter(btActionInterface* character);


		void setSynchronizeAllMotionStates(bool synchronizeAll)
		{
		m_synchronizeAllMotionStates = synchronizeAll;
		}
		bool getSynchronizeAllMotionStates() const
		{
		return m_synchronizeAllMotionStates;
		}

	};	};

	#endif //BT_DISCRETE_DYNAMICS_WORLD_H	#endif //BT_DISCRETE_DYNAMICS_WORLD_H

End of changes. 6 change blocks.
	1 lines changed or deleted	24 lines changed or added

	btDispatcher.h	btDispatcher.h

	skipping to change at line 48	skipping to change at line 48
	:m_timeStep(btScalar(0.)),	:m_timeStep(btScalar(0.)),
	m_stepCount(0),	m_stepCount(0),
	m_dispatchFunc(DISPATCH_DISCRETE),	m_dispatchFunc(DISPATCH_DISCRETE),
	m_timeOfImpact(btScalar(1.)),	m_timeOfImpact(btScalar(1.)),
	m_useContinuous(false),	m_useContinuous(false),
	m_debugDraw(0),	m_debugDraw(0),
	m_enableSatConvex(false),	m_enableSatConvex(false),
	m_enableSPU(true),	m_enableSPU(true),
	m_useEpa(true),	m_useEpa(true),
	m_allowedCcdPenetration(btScalar(0.04)),	m_allowedCcdPenetration(btScalar(0.04)),

	m_useConvexConservativeDistanceUtil(true),	m_useConvexConservativeDistanceUtil(false),
	m_convexConservativeDistanceThreshold(0.0f),	m_convexConservativeDistanceThreshold(0.0f),
	m_stackAllocator(0)	m_stackAllocator(0)
	{	{

	}	}
	btScalar m_timeStep;	btScalar m_timeStep;
	int m_stepCount;	int m_stepCount;
	int m_dispatchFunc;	int m_dispatchFunc;
	mutable btScalar m_timeOfImpact;	mutable btScalar m_timeOfImpact;
	bool m_useContinuous;	bool m_useContinuous;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btDynamicsWorld.h	btDynamicsWorld.h

	skipping to change at line 43	skipping to change at line 43
	BT_DISCRETE_DYNAMICS_WORLD=2,	BT_DISCRETE_DYNAMICS_WORLD=2,
	BT_CONTINUOUS_DYNAMICS_WORLD=3	BT_CONTINUOUS_DYNAMICS_WORLD=3
	};	};

	///The btDynamicsWorld is the interface class for several dynamics implemen tation, basic, discrete, parallel, and continuous etc.	///The btDynamicsWorld is the interface class for several dynamics implemen tation, basic, discrete, parallel, and continuous etc.
	class btDynamicsWorld : public btCollisionWorld	class btDynamicsWorld : public btCollisionWorld
	{	{

	protected:	protected:
	btInternalTickCallback m_internalTickCallback;	btInternalTickCallback m_internalTickCallback;

		btInternalTickCallback m_internalPreTickCallback;
	void* m_worldUserInfo;	void* m_worldUserInfo;

	btContactSolverInfo m_solverInfo;	btContactSolverInfo m_solverInfo;

	public:	public:

	btDynamicsWorld(btDispatcher* dispatcher,btBroadphaseInterfa ce* broadphase,btCollisionConfiguration* collisionConfiguration)	btDynamicsWorld(btDispatcher* dispatcher,btBroadphaseInterfa ce* broadphase,btCollisionConfiguration* collisionConfiguration)

	:btCollisionWorld(dispatcher,broadphase,collisionConfigurati on), m_internalTickCallback(0), m_worldUserInfo(0)	:btCollisionWorld(dispatcher,broadphase,collisionConfigurati on), m_internalTickCallback(0),m_internalPreTickCallback(0), m_worldUserInf o(0)
	{	{
	}	}

	virtual ~btDynamicsWorld()	virtual ~btDynamicsWorld()
	{	{
	}	}

	///stepSimulation proceeds the simulation over 'timeStep', u nits in preferably in seconds.	///stepSimulation proceeds the simulation over 'timeStep', u nits in preferably in seconds.
	///By default, Bullet will subdivide the timestep in constan t substeps of each 'fixedTimeStep'.	///By default, Bullet will subdivide the timestep in constan t substeps of each 'fixedTimeStep'.
	///in order to keep the simulation real-time, the maximum nu mber of substeps can be clamped to 'maxSubSteps'.	///in order to keep the simulation real-time, the maximum nu mber of substeps can be clamped to 'maxSubSteps'.

	skipping to change at line 103	skipping to change at line 104

	virtual btTypedConstraint* getConstraint(int index) { (void)index; return 0; }	virtual btTypedConstraint* getConstraint(int index) { (void)index; return 0; }

	virtual const btTypedConstraint* getConstraint(int index) co nst { (void)index; return 0; }	virtual const btTypedConstraint* getConstraint(int index) co nst { (void)index; return 0; }

	virtual btDynamicsWorldType getWorldType() const=0;	virtual btDynamicsWorldType getWorldType() const=0;

	virtual void clearForces() = 0;	virtual void clearForces() = 0;

	/// Set the callback for when an internal tick (simulation s ubstep) happens, optional user info	/// Set the callback for when an internal tick (simulation s ubstep) happens, optional user info

	void setInternalTickCallback(btInternalTickCallback cb, void * worldUserInfo=0)	void setInternalTickCallback(btInternalTickCallback cb, void * worldUserInfo=0,bool isPreTick=false)
	{	{

	m_internalTickCallback = cb;	if (isPreTick)
		{
		m_internalPreTickCallback = cb;
		} else
		{
		m_internalTickCallback = cb;
		}
	m_worldUserInfo = worldUserInfo;	m_worldUserInfo = worldUserInfo;
	}	}

	void setWorldUserInfo(void* worldUserInfo)	void setWorldUserInfo(void* worldUserInfo)
	{	{
	m_worldUserInfo = worldUserInfo;	m_worldUserInfo = worldUserInfo;
	}	}

	void* getWorldUserInfo() const	void* getWorldUserInfo() const
	{	{

End of changes. 4 change blocks.
	3 lines changed or deleted	10 lines changed or added

	btEmptyShape.h	btEmptyShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btGImpactShape.h	btGImpactShape.h

	skipping to change at line 287	skipping to change at line 287
	/*!	/*!
	This class only can manage Convex subshapes	This class only can manage Convex subshapes
	*/	*/
	class btGImpactCompoundShape : public btGImpactShapeInterface	class btGImpactCompoundShape : public btGImpactShapeInterface
	{	{
	public:	public:
	//! compound primitive manager	//! compound primitive manager
	class CompoundPrimitiveManager:public btPrimitiveManagerBase	class CompoundPrimitiveManager:public btPrimitiveManagerBase
	{	{
	public:	public:

		virtual ~CompoundPrimitiveManager() {}
	btGImpactCompoundShape * m_compoundShape;	btGImpactCompoundShape * m_compoundShape;

	CompoundPrimitiveManager(const CompoundPrimitiveManager& com pound)	CompoundPrimitiveManager(const CompoundPrimitiveManager& com pound)
	{	{
	m_compoundShape = compound.m_compoundShape;	m_compoundShape = compound.m_compoundShape;
	}	}

	CompoundPrimitiveManager(btGImpactCompoundShape * compoundSh ape)	CompoundPrimitiveManager(btGImpactCompoundShape * compoundSh ape)
	{	{
	m_compoundShape = compoundShape;	m_compoundShape = compoundShape;

	skipping to change at line 555	skipping to change at line 556
	m_lock_count = 0;	m_lock_count = 0;
	vertexbase = 0;	vertexbase = 0;
	numverts = 0;	numverts = 0;
	stride = 0;	stride = 0;
	indexbase = 0;	indexbase = 0;
	indexstride = 0;	indexstride = 0;
	numfaces = 0;	numfaces = 0;

	}	}


		virtual ~TrimeshPrimitiveManager() {}

	void lock()	void lock()
	{	{
	if(m_lock_count>0)	if(m_lock_count>0)
	{	{
	m_lock_count++;	m_lock_count++;
	return;	return;
	}	}
	m_meshInterface->getLockedReadOnlyVertexIndexBase(	m_meshInterface->getLockedReadOnlyVertexIndexBase(
	&vertexbase,numverts,	&vertexbase,numverts,
	type, stride,&indexbase, indexstride, numfac es,indicestype,m_part);	type, stride,&indexbase, indexstride, numfac es,indicestype,m_part);

End of changes. 2 change blocks.
	0 lines changed or deleted	3 lines changed or added

	btGeneric6DofConstraint.h	btGeneric6DofConstraint.h

	skipping to change at line 15	skipping to change at line 15
	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/


		/// 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev
		/// Added support for generic constraint solver through getInfo1/getInfo2 m
		ethods

	/*	/*
	2007-09-09	2007-09-09
	btGeneric6DofConstraint Refactored by Francisco Le?n	btGeneric6DofConstraint Refactored by Francisco Le?n
	email: projectileman@yahoo.com	email: projectileman@yahoo.com
	http://gimpact.sf.net	http://gimpact.sf.net
	*/	*/

	#ifndef GENERIC_6DOF_CONSTRAINT_H	#ifndef GENERIC_6DOF_CONSTRAINT_H
	#define GENERIC_6DOF_CONSTRAINT_H	#define GENERIC_6DOF_CONSTRAINT_H


	skipping to change at line 53	skipping to change at line 57
	btScalar m_limitSoftness;//! Relaxation factor	btScalar m_limitSoftness;//! Relaxation factor
	btScalar m_ERP;//!< Error tolerance factor when joint is at limit	btScalar m_ERP;//!< Error tolerance factor when joint is at limit
	btScalar m_bounce;//!< restitution factor	btScalar m_bounce;//!< restitution factor
	bool m_enableMotor;	bool m_enableMotor;

	//!@}	//!@}

	//! temp_variables	//! temp_variables
	//!@{	//!@{
	btScalar m_currentLimitError;//! How much is violated this limit	btScalar m_currentLimitError;//! How much is violated this limit

		btScalar m_currentPosition; //! current value of angle
	int m_currentLimit;//!< 0=free, 1=at lo limit, 2=at hi limit	int m_currentLimit;//!< 0=free, 1=at lo limit, 2=at hi limit
	btScalar m_accumulatedImpulse;	btScalar m_accumulatedImpulse;
	//!@}	//!@}

	btRotationalLimitMotor()	btRotationalLimitMotor()
	{	{
	m_accumulatedImpulse = 0.f;	m_accumulatedImpulse = 0.f;
	m_targetVelocity = 0;	m_targetVelocity = 0;
	m_maxMotorForce = 0.1f;	m_maxMotorForce = 0.1f;
	m_maxLimitForce = 300.0f;	m_maxLimitForce = 300.0f;

	m_loLimit = -SIMD_INFINITY;	m_loLimit = 1.0f;
	m_hiLimit = SIMD_INFINITY;	m_hiLimit = -1.0f;
	m_ERP = 0.5f;	m_ERP = 0.5f;
	m_bounce = 0.0f;	m_bounce = 0.0f;
	m_damping = 1.0f;	m_damping = 1.0f;
	m_limitSoftness = 0.5f;	m_limitSoftness = 0.5f;
	m_currentLimit = 0;	m_currentLimit = 0;
	m_currentLimitError = 0;	m_currentLimitError = 0;
	m_enableMotor = false;	m_enableMotor = false;
	}	}

	btRotationalLimitMotor(const btRotationalLimitMotor & limot)	btRotationalLimitMotor(const btRotationalLimitMotor & limot)

	skipping to change at line 129	skipping to change at line 134
	//! Linear_Limit_parameters	//! Linear_Limit_parameters
	//!@{	//!@{
	btScalar m_limitSoftness;//!< Softness for linear limit	btScalar m_limitSoftness;//!< Softness for linear limit
	btScalar m_damping;//!< Damping for linear limit	btScalar m_damping;//!< Damping for linear limit
	btScalar m_restitution;//! Bounce parameter for linear limit	btScalar m_restitution;//! Bounce parameter for linear limit
	//!@}	//!@}
	bool m_enableMotor[3];	bool m_enableMotor[3];
	btVector3 m_targetVelocity;//!< target motor velocity	btVector3 m_targetVelocity;//!< target motor velocity
	btVector3 m_maxMotorForce;//!< max force on motor	btVector3 m_maxMotorForce;//!< max force on motor
	btVector3 m_currentLimitError;//! How much is violated this limit	btVector3 m_currentLimitError;//! How much is violated this limit

		btVector3 m_currentLinearDiff;//! Current relative offset of constrai nt frames
	int m_currentLimit[3];//!< 0=free, 1=at lower li mit, 2=at upper limit	int m_currentLimit[3];//!< 0=free, 1=at lower li mit, 2=at upper limit

	btTranslationalLimitMotor()	btTranslationalLimitMotor()
	{	{
	m_lowerLimit.setValue(0.f,0.f,0.f);	m_lowerLimit.setValue(0.f,0.f,0.f);
	m_upperLimit.setValue(0.f,0.f,0.f);	m_upperLimit.setValue(0.f,0.f,0.f);
	m_accumulatedImpulse.setValue(0.f,0.f,0.f);	m_accumulatedImpulse.setValue(0.f,0.f,0.f);

	m_limitSoftness = 0.7f;	m_limitSoftness = 0.7f;
	m_damping = btScalar(1.0f);	m_damping = btScalar(1.0f);

	skipping to change at line 277	skipping to change at line 283

	//!@}	//!@}

	btGeneric6DofConstraint& operator=(btGeneric6DofConstraint& othe r)	btGeneric6DofConstraint& operator=(btGeneric6DofConstraint& othe r)
	{	{
	btAssert(0);	btAssert(0);
	(void) other;	(void) other;
	return *this;	return *this;
	}	}


	int setAngularLimits(btConstraintInfo2 *info, int row_offset);	int setAngularLimits(btConstraintInfo2 *info, int row_offset,const b tTransform& transA,const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB,const btVector3& angVelA,const btVector3& angVelB);


	int setLinearLimits(btConstraintInfo2 *info);	int setLinearLimits(btConstraintInfo2 *info,const btTransform& trans A,const btTransform& transB,const btVector3& linVelA,const btVector3& linVe lB,const btVector3& angVelA,const btVector3& angVelB);

	void buildLinearJacobian(	void buildLinearJacobian(
	btJacobianEntry & jacLinear,const btVector3 & normalWorld,	btJacobianEntry & jacLinear,const btVector3 & normalWorld,
	const btVector3 & pivotAInW,const btVector3 & pivotBInW);	const btVector3 & pivotAInW,const btVector3 & pivotBInW);

	void buildAngularJacobian(btJacobianEntry & jacAngular,const btVector3 & jointAxisW);	void buildAngularJacobian(btJacobianEntry & jacAngular,const btVector3 & jointAxisW);

	// tests linear limits	// tests linear limits
	void calculateLinearInfo();	void calculateLinearInfo();


	skipping to change at line 307	skipping to change at line 313

	btGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTra nsform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrame A);	btGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTra nsform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrame A);

	btGeneric6DofConstraint();	btGeneric6DofConstraint();

	//! Calcs global transform of the offsets	//! Calcs global transform of the offsets
	/*!	/*!
	Calcs the global transform for the joint offset for body A an B, and also calcs the agle differences between the bodies.	Calcs the global transform for the joint offset for body A an B, and also calcs the agle differences between the bodies.
	\sa btGeneric6DofConstraint.getCalculatedTransformA , btGeneric6DofC onstraint.getCalculatedTransformB, btGeneric6DofConstraint.calculateAngleIn fo	\sa btGeneric6DofConstraint.getCalculatedTransformA , btGeneric6DofC onstraint.getCalculatedTransformB, btGeneric6DofConstraint.calculateAngleIn fo
	*/	*/

	void calculateTransforms();	void calculateTransforms(const btTransform& transA,const btTransform& t
		ransB);

		void calculateTransforms();

	//! Gets the global transform of the offset for body A	//! Gets the global transform of the offset for body A
	/*!	/*!
	\sa btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.ge tFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo.	\sa btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.ge tFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo.
	*/	*/
	const btTransform & getCalculatedTransformA() const	const btTransform & getCalculatedTransformA() const
	{	{
	return m_calculatedTransformA;	return m_calculatedTransformA;
	}	}


	skipping to change at line 352	skipping to change at line 360
	btTransform & getFrameOffsetB()	btTransform & getFrameOffsetB()
	{	{
	return m_frameInB;	return m_frameInB;
	}	}

	//! performs Jacobian calculation, and also calculates angle differe nces and axis	//! performs Jacobian calculation, and also calculates angle differe nces and axis
	virtual void buildJacobian();	virtual void buildJacobian();

	virtual void getInfo1 (btConstraintInfo1* info);	virtual void getInfo1 (btConstraintInfo1* info);


		void getInfo1NonVirtual (btConstraintInfo1* info);

	virtual void getInfo2 (btConstraintInfo2* info);	virtual void getInfo2 (btConstraintInfo2* info);


		void getInfo2NonVirtual (btConstraintInfo2* info,const btTransform&
		transA,const btTransform& transB,const btVector3& linVelA,const btVector3&
		linVelB,const btVector3& angVelA,const btVector3& angVelB);

	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep);	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep);

	void updateRHS(btScalar timeStep);	void updateRHS(btScalar timeStep);

	//! Get the rotation axis in global coordinates	//! Get the rotation axis in global coordinates
	/*!	/*!
	\pre btGeneric6DofConstraint.buildJacobian must be called previously .	\pre btGeneric6DofConstraint.buildJacobian must be called previously .
	*/	*/
	btVector3 getAxis(int axis_index) const;	btVector3 getAxis(int axis_index) const;

	//! Get the relative Euler angle	//! Get the relative Euler angle
	/*!	/*!

	\pre btGeneric6DofConstraint.buildJacobian must be called previously .	\pre btGeneric6DofConstraint::calculateTransforms() must be called p reviously.
	*/	*/
	btScalar getAngle(int axis_index) const;	btScalar getAngle(int axis_index) const;


		//! Get the relative position of the constraint pivot
		/*!
		\pre btGeneric6DofConstraint::calculateTransforms() must be called p
		reviously.
		*/
		btScalar getRelativePivotPosition(int axis_index) const;

	//! Test angular limit.	//! Test angular limit.
	/*!	/*!
	Calculates angular correction and returns true if limit needs to be corrected.	Calculates angular correction and returns true if limit needs to be corrected.

	\pre btGeneric6DofConstraint.buildJacobian must be called previously .	\pre btGeneric6DofConstraint::calculateTransforms() must be called p reviously.
	*/	*/
	bool testAngularLimitMotor(int axis_index);	bool testAngularLimitMotor(int axis_index);

	void setLinearLowerLimit(const btVector3& linearLower)	void setLinearLowerLimit(const btVector3& linearLower)
	{	{
	m_linearLimits.m_lowerLimit = linearLower;	m_linearLimits.m_lowerLimit = linearLower;
	}	}

	void setLinearUpperLimit(const btVector3& linearUpper)	void setLinearUpperLimit(const btVector3& linearUpper)
	{	{
	m_linearLimits.m_upperLimit = linearUpper;	m_linearLimits.m_upperLimit = linearUpper;
	}	}

	void setAngularLowerLimit(const btVector3& angularLower)	void setAngularLowerLimit(const btVector3& angularLower)
	{	{

	m_angularLimits[0].m_loLimit = angularLower.getX();	for(int i = 0; i < 3; i++)
	m_angularLimits[1].m_loLimit = angularLower.getY();	m_angularLimits[i].m_loLimit = btNormalizeAngle(angu
	m_angularLimits[2].m_loLimit = angularLower.getZ();	larLower[i]);
	}	}

	void setAngularUpperLimit(const btVector3& angularUpper)	void setAngularUpperLimit(const btVector3& angularUpper)
	{	{

	m_angularLimits[0].m_hiLimit = angularUpper.getX();	for(int i = 0; i < 3; i++)
	m_angularLimits[1].m_hiLimit = angularUpper.getY();	m_angularLimits[i].m_hiLimit = btNormalizeAngle(angu
	m_angularLimits[2].m_hiLimit = angularUpper.getZ();	larUpper[i]);
	}	}

	//! Retrieves the angular limit informacion	//! Retrieves the angular limit informacion
	btRotationalLimitMotor * getRotationalLimitMotor(int index)	btRotationalLimitMotor * getRotationalLimitMotor(int index)
	{	{
	return &m_angularLimits[index];	return &m_angularLimits[index];
	}	}

	//! Retrieves the limit informacion	//! Retrieves the limit informacion
	btTranslationalLimitMotor * getTranslationalLimitMotor()	btTranslationalLimitMotor * getTranslationalLimitMotor()

	skipping to change at line 423	skipping to change at line 439
	//first 3 are linear, next 3 are angular	//first 3 are linear, next 3 are angular
	void setLimit(int axis, btScalar lo, btScalar hi)	void setLimit(int axis, btScalar lo, btScalar hi)
	{	{
	if(axis<3)	if(axis<3)
	{	{
	m_linearLimits.m_lowerLimit[axis] = lo;	m_linearLimits.m_lowerLimit[axis] = lo;
	m_linearLimits.m_upperLimit[axis] = hi;	m_linearLimits.m_upperLimit[axis] = hi;
	}	}
	else	else
	{	{

		lo = btNormalizeAngle(lo);
		hi = btNormalizeAngle(hi);
	m_angularLimits[axis-3].m_loLimit = lo;	m_angularLimits[axis-3].m_loLimit = lo;
	m_angularLimits[axis-3].m_hiLimit = hi;	m_angularLimits[axis-3].m_hiLimit = hi;
	}	}
	}	}

	//! Test limit	//! Test limit
	/*!	/*!
	- free means upper < lower,	- free means upper < lower,
	- locked means upper == lower	- locked means upper == lower
	- limited means upper > lower	- limited means upper > lower

	skipping to change at line 445	skipping to change at line 463
	bool isLimited(int limitIndex)	bool isLimited(int limitIndex)
	{	{
	if(limitIndex<3)	if(limitIndex<3)
	{	{
	return m_linearLimits.isLimited(limitIndex);	return m_linearLimits.isLimited(limitIndex);

	}	}
	return m_angularLimits[limitIndex-3].isLimited();	return m_angularLimits[limitIndex-3].isLimited();
	}	}


	const btRigidBody& getRigidBodyA() const
	{
	return m_rbA;
	}
	const btRigidBody& getRigidBodyB() const
	{
	return m_rbB;
	}

	virtual void calcAnchorPos(void); // overridable	virtual void calcAnchorPos(void); // overridable

	int get_limit_motor_info2( btRotationalLimitMotor * limot,	int get_limit_motor_info2( btRotationalLimitMotor * limot,

	btRigidBody * body0, btRigidBody * body1,	const btTran sform& transA,const btTransform& transB,const btVector3& linVelA,const btVe ctor3& linVelB,const btVector3& angVelA,const btVector3& angVelB,
	btConstraint Info2 *info, int row, btVector3& ax1, int rotational);	btConstraint Info2 *info, int row, btVector3& ax1, int rotational);

	};	};

	#endif //GENERIC_6DOF_CONSTRAINT_H	#endif //GENERIC_6DOF_CONSTRAINT_H

End of changes. 17 change blocks.
	23 lines changed or deleted	39 lines changed or added

	btGenericPoolAllocator.h	btGenericPoolAllocator.h

	skipping to change at line 26	skipping to change at line 26
	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef BT_GENERIC_POOL_ALLOCATOR_H	#ifndef BT_GENERIC_POOL_ALLOCATOR_H
	#define BT_GENERIC_POOL_ALLOCATOR_H	#define BT_GENERIC_POOL_ALLOCATOR_H

	#include <limits.h>	#include <limits.h>
	#include <stdio.h>	#include <stdio.h>

	#include <memory.h>	#include <string.h>
	#include "LinearMath/btAlignedAllocator.h"	#include "LinearMath/btAlignedAllocator.h"

	#define BT_UINT_MAX UINT_MAX	#define BT_UINT_MAX UINT_MAX
	#define BT_DEFAULT_MAX_POOLS 16	#define BT_DEFAULT_MAX_POOLS 16

	//! Generic Pool class	//! Generic Pool class
	class btGenericMemoryPool	class btGenericMemoryPool
	{	{
	public:	public:
	unsigned char * m_pool; //[m_element_size*m_max_element_count];	unsigned char * m_pool; //[m_element_size*m_max_element_count];

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btGjkEpa2.h	btGjkEpa2.h

	skipping to change at line 58	skipping to change at line 58
	static bool Distance( const btConvexShape* shape0,const bt Transform& wtrs0,	static bool Distance( const btConvexShape* shape0,const bt Transform& wtrs0,
	const btConvexShape* shape1,const btTransform& wtrs1,	const btConvexShape* shape1,const btTransform& wtrs1,
	const btVector3& gue ss,	const btVector3& gue ss,
	sResults& results);	sResults& results);

	static bool Penetration(const btConvexShape* shape0,const btTran sform& wtrs0,	static bool Penetration(const btConvexShape* shape0,const btTran sform& wtrs0,
	const btConvexShape* shape1,const btTransform& wtrs1,	const btConvexShape* shape1,const btTransform& wtrs1,
	const btVector3& gue ss,	const btVector3& gue ss,
	sResults& results,	sResults& results,
	bool usemargins=true );	bool usemargins=true );

		#ifndef __SPU__
	static btScalar SignedDistance( const btVector3& position,	static btScalar SignedDistance( const btVector3& position,
	btScalar mar gin,	btScalar mar gin,
	const btConv exShape* shape,	const btConv exShape* shape,
	const btTran sform& wtrs,	const btTran sform& wtrs,
	sResults& re sults);	sResults& re sults);

	static bool SignedDistance( const btConvexShape* shape0,const bt Transform& wtrs0,	static bool SignedDistance( const btConvexShape* shape0,const bt Transform& wtrs0,
	const btConv exShape* shape1,const btTransform& wtrs1,	const btConv exShape* shape1,const btTransform& wtrs1,
	const btVect or3& guess,	const btVect or3& guess,
	sResults& re sults);	sResults& re sults);

		#endif //__SPU__

	};	};

	#endif	#endif

End of changes. 2 change blocks.
	1 lines changed or deleted	3 lines changed or added

	btGjkPairDetector.h	btGjkPairDetector.h

	skipping to change at line 35	skipping to change at line 35

	/// btGjkPairDetector uses GJK to implement the btDiscreteCollisionDetector Interface	/// btGjkPairDetector uses GJK to implement the btDiscreteCollisionDetector Interface
	class btGjkPairDetector : public btDiscreteCollisionDetectorInterface	class btGjkPairDetector : public btDiscreteCollisionDetectorInterface
	{	{

	btVector3 m_cachedSeparatingAxis;	btVector3 m_cachedSeparatingAxis;
	btConvexPenetrationDepthSolver* m_penetrationDepthSolver;	btConvexPenetrationDepthSolver* m_penetrationDepthSolver;
	btSimplexSolverInterface* m_simplexSolver;	btSimplexSolverInterface* m_simplexSolver;
	const btConvexShape* m_minkowskiA;	const btConvexShape* m_minkowskiA;
	const btConvexShape* m_minkowskiB;	const btConvexShape* m_minkowskiB;

		int m_shapeTypeA;
		int m_shapeTypeB;
		btScalar m_marginA;
		btScalar m_marginB;

	bool m_ignoreMargin;	bool m_ignoreMargin;
	btScalar m_cachedSeparatingDistance;	btScalar m_cachedSeparatingDistance;

	public:	public:

	//some debugging to fix degeneracy problems	//some debugging to fix degeneracy problems
	int m_lastUsedMethod;	int m_lastUsedMethod;
	int m_curIter;	int m_curIter;
	int m_degenerateSimplex;	int m_degenerateSimplex;
	int m_catchDegeneracies;	int m_catchDegeneracies;

	btGjkPairDetector(const btConvexShape* objectA,const btConvexShape* objectB,btSimplexSolverInterface* simplexSolver,btConvexPenetrationDepthSol ver* penetrationDepthSolver);	btGjkPairDetector(const btConvexShape* objectA,const btConvexShape* objectB,btSimplexSolverInterface* simplexSolver,btConvexPenetrationDepthSol ver* penetrationDepthSolver);

		btGjkPairDetector(const btConvexShape* objectA,const btConvexShape* objectB,int shapeTypeA,int shapeTypeB,btScalar marginA, btScalar marginB, b tSimplexSolverInterface* simplexSolver,btConvexPenetrationDepthSolver* pe netrationDepthSolver);
	virtual ~btGjkPairDetector() {};	virtual ~btGjkPairDetector() {};

	virtual void getClosestPoints(const ClosestPointInput& input,Resu lt& output,class btIDebugDraw* debugDraw,bool swapResults=false);	virtual void getClosestPoints(const ClosestPointInput& input,Resu lt& output,class btIDebugDraw* debugDraw,bool swapResults=false);


		void getClosestPointsNonVirtual(const ClosestPointInput& input,Re
		sult& output,class btIDebugDraw* debugDraw);

	void setMinkowskiA(btConvexShape* minkA)	void setMinkowskiA(btConvexShape* minkA)
	{	{
	m_minkowskiA = minkA;	m_minkowskiA = minkA;
	}	}

	void setMinkowskiB(btConvexShape* minkB)	void setMinkowskiB(btConvexShape* minkB)
	{	{
	m_minkowskiB = minkB;	m_minkowskiB = minkB;
	}	}
	void setCachedSeperatingAxis(const btVector3& seperatingAxis)	void setCachedSeperatingAxis(const btVector3& seperatingAxis)

End of changes. 3 change blocks.
	0 lines changed or deleted	9 lines changed or added

	btHashMap.h	btHashMap.h
	#ifndef BT_HASH_MAP_H	#ifndef BT_HASH_MAP_H
	#define BT_HASH_MAP_H	#define BT_HASH_MAP_H

	#include "btAlignedObjectArray.h"	#include "btAlignedObjectArray.h"


		///very basic hashable string implementation, compatible with btHashMap
		struct btHashString
		{
		const char* m_string;
		unsigned int m_hash;

		SIMD_FORCE_INLINE unsigned int getHash()const
		{
		return m_hash;
		}

		btHashString(const char* name)
		:m_string(name)
		{
		/* magic numbers from http://www.isthe.com/chongo/tech/comp/
		fnv/ */
		static const unsigned int InitialFNV = 2166136261u;
		static const unsigned int FNVMultiple = 16777619u;

		/* Fowler / Noll / Vo (FNV) Hash */
		unsigned int hash = InitialFNV;

		for(int i = 0; m_string[i]; i++)
		{
		hash = hash ^ (m_string[i]); /* xor the low 8
		bits */
		hash = hash * FNVMultiple; /* multiply by the magic
		number */
		}
		m_hash = hash;
		}

		int portableStringCompare(const char* src, const char* dst) con
		st
		{
		int ret = 0 ;

		while( ! (ret = (unsigned char )src - *(unsigned c
		har )dst) && dst)
		++src, ++dst;

		if ( ret < 0 )
		ret = -1 ;
		else if ( ret > 0 )
		ret = 1 ;

		return( ret );
		}

		const bool equals(const btHashString& other) const
		{
		return (m_string == other.m_string) \|\|
		(0==portableStringCompare(m_string,other.m_string));

		}

		};

	const int BT_HASH_NULL=0xffffffff;	const int BT_HASH_NULL=0xffffffff;

	template <class Value>	template <class Value>
	class btHashKey	class btHashKey
	{	{
	int m_uid;	int m_uid;
	public:	public:

	btHashKey(int uid)	btHashKey(int uid)
	:m_uid(uid)	:m_uid(uid)
	{	{
	}	}


	int getUid() const	int getUid1() const
	{	{
	return m_uid;	return m_uid;
	}	}


		bool equals(const btHashKey<Value>& other) const
		{
		return getUid1() == other.getUid1();
		}
	//to our success	//to our success
	SIMD_FORCE_INLINE unsigned int getHash()const	SIMD_FORCE_INLINE unsigned int getHash()const
	{	{
	int key = m_uid;	int key = m_uid;
	// Thomas Wang's hash	// Thomas Wang's hash
	key += ~(key << 15);	key += ~(key << 15);
	key ^= (key >> 10);	key ^= (key >> 10);
	key += (key << 3);	key += (key << 3);
	key ^= (key >> 6);	key ^= (key >> 6);
	key += ~(key << 11);	key += ~(key << 11);
	key ^= (key >> 16);	key ^= (key >> 16);
	return key;	return key;
	}	}


	btHashKey getKey(const Value& value) const
	{
	return btHashKey(value.getUid());
	}
	};	};

	template <class Value>	template <class Value>
	class btHashKeyPtr	class btHashKeyPtr
	{	{
	int m_uid;	int m_uid;
	public:	public:

	btHashKeyPtr(int uid)	btHashKeyPtr(int uid)
	:m_uid(uid)	:m_uid(uid)
	{	{
	}	}


	int getUid() const	int getUid1() const
	{	{
	return m_uid;	return m_uid;
	}	}


		bool equals(const btHashKeyPtr<Value>& other) const
		{
		return getUid1() == other.getUid1();
		}

	//to our success	//to our success
	SIMD_FORCE_INLINE unsigned int getHash()const	SIMD_FORCE_INLINE unsigned int getHash()const
	{	{
	int key = m_uid;	int key = m_uid;
	// Thomas Wang's hash	// Thomas Wang's hash
	key += ~(key << 15);	key += ~(key << 15);
	key ^= (key >> 10);	key ^= (key >> 10);
	key += (key << 3);	key += (key << 3);
	key ^= (key >> 6);	key ^= (key >> 6);
	key += ~(key << 11);	key += ~(key << 11);
	key ^= (key >> 16);	key ^= (key >> 16);
	return key;	return key;
	}	}


	btHashKeyPtr getKey(const Value& value) const
	{
	return btHashKeyPtr(value->getUid());
	}
	};	};

	///The btHashMap template class implements a generic and lightweight hashma p.	///The btHashMap template class implements a generic and lightweight hashma p.
	///A basic sample of how to use btHashMap is located in Demos\BasicDemo\mai n.cpp	///A basic sample of how to use btHashMap is located in Demos\BasicDemo\mai n.cpp
	template <class Key, class Value>	template <class Key, class Value>
	class btHashMap	class btHashMap
	{	{

	btAlignedObjectArray<int> m_hashTable;	btAlignedObjectArray<int> m_hashTable;
	btAlignedObjectArray<int> m_next;	btAlignedObjectArray<int> m_next;

	skipping to change at line 88	skipping to change at line 142
	};	};

	///The btHashMap template class implements a generic and lightweight hashma p.	///The btHashMap template class implements a generic and lightweight hashma p.
	///A basic sample of how to use btHashMap is located in Demos\BasicDemo\mai n.cpp	///A basic sample of how to use btHashMap is located in Demos\BasicDemo\mai n.cpp
	template <class Key, class Value>	template <class Key, class Value>
	class btHashMap	class btHashMap
	{	{

	btAlignedObjectArray<int> m_hashTable;	btAlignedObjectArray<int> m_hashTable;
	btAlignedObjectArray<int> m_next;	btAlignedObjectArray<int> m_next;


	btAlignedObjectArray<Value> m_valueArray;	btAlignedObjectArray<Value> m_valueArray;

		btAlignedObjectArray<Key> m_keyArray;

	void growTables(const Key& key)	void growTables(const Key& key)
	{	{
	int newCapacity = m_valueArray.capacity();	int newCapacity = m_valueArray.capacity();

	if (m_hashTable.size() < newCapacity)	if (m_hashTable.size() < newCapacity)
	{	{
	//grow hashtable and next table	//grow hashtable and next table
	int curHashtableSize = m_hashTable.size();	int curHashtableSize = m_hashTable.size();


	skipping to change at line 115	skipping to change at line 171
	{	{
	m_hashTable[i] = BT_HASH_NULL;	m_hashTable[i] = BT_HASH_NULL;
	}	}
	for (i = 0; i < newCapacity; ++i)	for (i = 0; i < newCapacity; ++i)
	{	{
	m_next[i] = BT_HASH_NULL;	m_next[i] = BT_HASH_NULL;
	}	}

	for(i=0;i<curHashtableSize;i++)	for(i=0;i<curHashtableSize;i++)
	{	{

	const Value& value = m_valueArray[i];	//const Value& value = m_valueArray[i];
		//const Key& key = m_keyArray[i];


	int hashValue = key.getKey(value).getHas h() & (m_valueArray.capacity()-1); // New hash value with new mask	int hashValue = m_keyArray[i].getHash() & (m_valueArray.capacity()-1); // New hash value with new mask
	m_next[i] = m_hashTable[hashValue];	m_next[i] = m_hashTable[hashValue];
	m_hashTable[hashValue] = i;	m_hashTable[hashValue] = i;
	}	}

	}	}
	}	}

	public:	public:

	void insert(const Key& key, const Value& value) {	void insert(const Key& key, const Value& value) {
	int hash = key.getHash() & (m_valueArray.capacity()-1);	int hash = key.getHash() & (m_valueArray.capacity()-1);

	//don't add it if it is already there
	if (find(key))	//replace value if the key is already there
		int index = findIndex(key);
		if (index != BT_HASH_NULL)
	{	{

		m_valueArray[index]=value;
	return;	return;
	}	}


	int count = m_valueArray.size();	int count = m_valueArray.size();
	int oldCapacity = m_valueArray.capacity();	int oldCapacity = m_valueArray.capacity();
	m_valueArray.push_back(value);	m_valueArray.push_back(value);

		m_keyArray.push_back(key);

	int newCapacity = m_valueArray.capacity();	int newCapacity = m_valueArray.capacity();
	if (oldCapacity < newCapacity)	if (oldCapacity < newCapacity)
	{	{
	growTables(key);	growTables(key);
	//hash with new capacity	//hash with new capacity
	hash = key.getHash() & (m_valueArray.capacity()-1);	hash = key.getHash() & (m_valueArray.capacity()-1);
	}	}
	m_next[count] = m_hashTable[hash];	m_next[count] = m_hashTable[hash];
	m_hashTable[hash] = count;	m_hashTable[hash] = count;
	}	}

	skipping to change at line 190	skipping to change at line 253
	// We now move the last pair into spot of the	// We now move the last pair into spot of the
	// pair being removed. We need to fix the hash	// pair being removed. We need to fix the hash
	// table indices to support the move.	// table indices to support the move.

	int lastPairIndex = m_valueArray.size() - 1;	int lastPairIndex = m_valueArray.size() - 1;

	// If the removed pair is the last pair, we are done.	// If the removed pair is the last pair, we are done.
	if (lastPairIndex == pairIndex)	if (lastPairIndex == pairIndex)
	{	{
	m_valueArray.pop_back();	m_valueArray.pop_back();

		m_keyArray.pop_back();
	return;	return;
	}	}

	// Remove the last pair from the hash table.	// Remove the last pair from the hash table.

	const Value* lastValue = &m_valueArray[lastPairIndex];	int lastHash = m_keyArray[lastPairIndex].getHash() & (m_valu
	int lastHash = key.getKey(*lastValue).getHash() & (m_valueAr	eArray.capacity()-1);
	ray.capacity()-1);

	index = m_hashTable[lastHash];	index = m_hashTable[lastHash];
	btAssert(index != BT_HASH_NULL);	btAssert(index != BT_HASH_NULL);

	previous = BT_HASH_NULL;	previous = BT_HASH_NULL;
	while (index != lastPairIndex)	while (index != lastPairIndex)
	{	{
	previous = index;	previous = index;
	index = m_next[index];	index = m_next[index];
	}	}

	skipping to change at line 219	skipping to change at line 282
	btAssert(m_next[previous] == lastPairIndex);	btAssert(m_next[previous] == lastPairIndex);
	m_next[previous] = m_next[lastPairIndex];	m_next[previous] = m_next[lastPairIndex];
	}	}
	else	else
	{	{
	m_hashTable[lastHash] = m_next[lastPairIndex];	m_hashTable[lastHash] = m_next[lastPairIndex];
	}	}

	// Copy the last pair into the remove pair's spot.	// Copy the last pair into the remove pair's spot.
	m_valueArray[pairIndex] = m_valueArray[lastPairIndex];	m_valueArray[pairIndex] = m_valueArray[lastPairIndex];

		m_keyArray[pairIndex] = m_keyArray[lastPairIndex];

	// Insert the last pair into the hash table	// Insert the last pair into the hash table
	m_next[pairIndex] = m_hashTable[lastHash];	m_next[pairIndex] = m_hashTable[lastHash];
	m_hashTable[lastHash] = pairIndex;	m_hashTable[lastHash] = pairIndex;

	m_valueArray.pop_back();	m_valueArray.pop_back();

		m_keyArray.pop_back();

	}	}

	int size() const	int size() const
	{	{
	return m_valueArray.size();	return m_valueArray.size();
	}	}

	const Value* getAtIndex(int index) const	const Value* getAtIndex(int index) const
	{	{

	skipping to change at line 273	skipping to change at line 338
	int index = findIndex(key);	int index = findIndex(key);
	if (index == BT_HASH_NULL)	if (index == BT_HASH_NULL)
	{	{
	return NULL;	return NULL;
	}	}
	return &m_valueArray[index];	return &m_valueArray[index];
	}	}

	int findIndex(const Key& key) const	int findIndex(const Key& key) const
	{	{

	int hash = key.getHash() & (m_valueArray.capacity()-1);	unsigned int hash = key.getHash() & (m_valueArray.capacity() -1);


	if (hash >= m_hashTable.size())	if (hash >= (unsigned int)m_hashTable.size())
	{	{
	return BT_HASH_NULL;	return BT_HASH_NULL;
	}	}

	int index = m_hashTable[hash];	int index = m_hashTable[hash];

	while ((index != BT_HASH_NULL) && (key.getUid() == key.getKe y(m_valueArray[index]).getUid()) == false)	while ((index != BT_HASH_NULL) && key.equals(m_keyArray[inde x]) == false)
	{	{
	index = m_next[index];	index = m_next[index];
	}	}
	return index;	return index;
	}	}

	void clear()	void clear()
	{	{
	m_hashTable.clear();	m_hashTable.clear();
	m_next.clear();	m_next.clear();
	m_valueArray.clear();	m_valueArray.clear();

		m_keyArray.clear();
	}	}

	};	};

	#endif //BT_HASH_MAP_H	#endif //BT_HASH_MAP_H

End of changes. 23 change blocks.
	20 lines changed or deleted	91 lines changed or added

	btHeightfieldTerrainShape.h	btHeightfieldTerrainShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btHingeConstraint.h	btHingeConstraint.h

	skipping to change at line 29	skipping to change at line 29
	#define HINGECONSTRAINT_H	#define HINGECONSTRAINT_H

	#include "LinearMath/btVector3.h"	#include "LinearMath/btVector3.h"
	#include "btJacobianEntry.h"	#include "btJacobianEntry.h"
	#include "btTypedConstraint.h"	#include "btTypedConstraint.h"

	class btRigidBody;	class btRigidBody;

	/// hinge constraint between two rigidbodies each with a pivotpoint that de scibes the axis location in local space	/// hinge constraint between two rigidbodies each with a pivotpoint that de scibes the axis location in local space
	/// axis defines the orientation of the hinge axis	/// axis defines the orientation of the hinge axis

	class btHingeConstraint : public btTypedConstraint	ATTRIBUTE_ALIGNED16(class) btHingeConstraint : public btTypedConstraint
	{	{
	#ifdef IN_PARALLELL_SOLVER	#ifdef IN_PARALLELL_SOLVER
	public:	public:
	#endif	#endif
	btJacobianEntry m_jac[3]; //3 orthogonal linear constraints	btJacobianEntry m_jac[3]; //3 orthogonal linear constraints
	btJacobianEntry m_jacAng[3]; //2 orthogonal angular constraints+ 1 f or limit/motor	btJacobianEntry m_jacAng[3]; //2 orthogonal angular constraints+ 1 f or limit/motor

	btTransform m_rbAFrame; // constraint axii. Assumes z is hinge axis.	btTransform m_rbAFrame; // constraint axii. Assumes z is hinge axis.
	btTransform m_rbBFrame;	btTransform m_rbBFrame;


	skipping to change at line 65	skipping to change at line 65
	btScalar m_accLimitImpulse;	btScalar m_accLimitImpulse;
	btScalar m_hingeAngle;	btScalar m_hingeAngle;
	btScalar m_referenceSign;	btScalar m_referenceSign;

	bool m_angularOnly;	bool m_angularOnly;
	bool m_enableAngularMotor;	bool m_enableAngularMotor;
	bool m_solveLimit;	bool m_solveLimit;
	bool m_useSolveConstraintObsolete;	bool m_useSolveConstraintObsolete;
	bool m_useReferenceFrameA;	bool m_useReferenceFrameA;


		btScalar m_accMotorImpulse;

	public:	public:

	btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3 & pivotInA,const btVector3& pivotInB, btVector3& axisInA,btVector3& axisInB , bool useReferenceFrameA = false);	btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3 & pivotInA,const btVector3& pivotInB, btVector3& axisInA,btVector3& axisInB , bool useReferenceFrameA = false);

	btHingeConstraint(btRigidBody& rbA,const btVector3& pivotInA,btVecto r3& axisInA, bool useReferenceFrameA = false);	btHingeConstraint(btRigidBody& rbA,const btVector3& pivotInA,btVecto r3& axisInA, bool useReferenceFrameA = false);

	btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransfo rm& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA = false) ;	btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransfo rm& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA = false) ;

	btHingeConstraint(btRigidBody& rbA,const btTransform& rbAFrame, bool useReferenceFrameA = false);	btHingeConstraint(btRigidBody& rbA,const btTransform& rbAFrame, bool useReferenceFrameA = false);

	btHingeConstraint();	btHingeConstraint();

	virtual void buildJacobian();	virtual void buildJacobian();

	virtual void getInfo1 (btConstraintInfo1* info);	virtual void getInfo1 (btConstraintInfo1* info);


		void getInfo1NonVirtual(btConstraintInfo1* info);

	virtual void getInfo2 (btConstraintInfo2* info);	virtual void getInfo2 (btConstraintInfo2* info);


		void getInfo2NonVirtual(btConstraintInfo2* info,const btTransform
		& transA,const btTransform& transB,const btVector3& angVelA,const btVector3
		& angVelB);

		void getInfo2Internal(btConstraintInfo2* info,const btTransform&
		transA,const btTransform& transB,const btVector3& angVelA,const btVector3&
		angVelB);

	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep);	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep);

	void updateRHS(btScalar timeStep);	void updateRHS(btScalar timeStep);

	const btRigidBody& getRigidBodyA() const	const btRigidBody& getRigidBodyA() const
	{	{
	return m_rbA;	return m_rbA;
	}	}
	const btRigidBody& getRigidBodyB() const	const btRigidBody& getRigidBodyB() const
	{	{

	skipping to change at line 118	skipping to change at line 126
	m_angularOnly = angularOnly;	m_angularOnly = angularOnly;
	}	}

	void enableAngularMotor(bool enableMotor,btScalar targetVelocity, btScalar maxMotorImpulse)	void enableAngularMotor(bool enableMotor,btScalar targetVelocity, btScalar maxMotorImpulse)
	{	{
	m_enableAngularMotor = enableMotor;	m_enableAngularMotor = enableMotor;
	m_motorTargetVelocity = targetVelocity;	m_motorTargetVelocity = targetVelocity;
	m_maxMotorImpulse = maxMotorImpulse;	m_maxMotorImpulse = maxMotorImpulse;
	}	}


		// extra motor API, including ability to set a target rotation (as o
		pposed to angular velocity)
		// note: setMotorTarget sets angular velocity under the hood, so you
		must call it every tick to
		// maintain a given angular target.
		void enableMotor(bool enableMotor) { m_enableAngularMotor = ena
		bleMotor; }
		void setMaxMotorImpulse(btScalar maxMotorImpulse) { m_maxMotorImpuls
		e = maxMotorImpulse; }
		void setMotorTarget(const btQuaternion& qAinB, btScalar dt); // qAin
		B is rotation of body A wrt body B.
		void setMotorTarget(btScalar targetAngle, btScalar dt);

	void setLimit(btScalar low,btScalar high,btScalar _softness = 0.9 f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f)	void setLimit(btScalar low,btScalar high,btScalar _softness = 0.9 f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f)
	{	{

	m_lowerLimit = low;	m_lowerLimit = btNormalizeAngle(low);
	m_upperLimit = high;	m_upperLimit = btNormalizeAngle(high);

	m_limitSoftness = _softness;	m_limitSoftness = _softness;
	m_biasFactor = _biasFactor;	m_biasFactor = _biasFactor;
	m_relaxationFactor = _relaxationFactor;	m_relaxationFactor = _relaxationFactor;

	}	}


		void setAxis(btVector3& axisInA)
		{
		btVector3 rbAxisA1, rbAxisA2;
		btPlaneSpace1(axisInA, rbAxisA1, rbAxisA2);
		btVector3 pivotInA = m_rbAFrame.getOrigin();
		// m_rbAFrame.getOrigin() = pivotInA;
		m_rbAFrame.getBasis().setValue( rbAxisA1.getX(),rbAxisA2.get
		X(),axisInA.getX(),

		rbAxisA1.getY(),rbAxisA2.getY(),axisInA.getY(),

		rbAxisA1.getZ(),rbAxisA2.getZ(),axisInA.getZ() );

		btVector3 axisInB = m_rbA.getCenterOfMassTransform().getBasi
		s() * axisInA;

		btQuaternion rotationArc = shortestArcQuat(axisInA,axisInB);
		btVector3 rbAxisB1 = quatRotate(rotationArc,rbAxisA1);
		btVector3 rbAxisB2 = axisInB.cross(rbAxisB1);

		m_rbBFrame.getOrigin() = m_rbA.getCenterOfMassTransform()(pi
		votInA);
		m_rbBFrame.getBasis().setValue( rbAxisB1.getX(),rbAxisB2.get
		X(),axisInB.getX(),

		rbAxisB1.getY(),rbAxisB2.getY(),axisInB.getY(),

		rbAxisB1.getZ(),rbAxisB2.getZ(),axisInB.getZ() );
		}

	btScalar getLowerLimit() const	btScalar getLowerLimit() const
	{	{
	return m_lowerLimit;	return m_lowerLimit;
	}	}

	btScalar getUpperLimit() const	btScalar getUpperLimit() const
	{	{
	return m_upperLimit;	return m_upperLimit;
	}	}

	btScalar getHingeAngle();	btScalar getHingeAngle();


	void testLimit();	btScalar getHingeAngle(const btTransform& transA,const btTransform& transB);


	const btTransform& getAFrame() { return m_rbAFrame; };	void testLimit(const btTransform& transA,const btTransform& transB);
	const btTransform& getBFrame() { return m_rbBFrame; };
		const btTransform& getAFrame() const { return m_rbAFrame; };
		const btTransform& getBFrame() const { return m_rbBFrame; };

		btTransform& getAFrame() { return m_rbAFrame; };
		btTransform& getBFrame() { return m_rbBFrame; };

	inline int getSolveLimit()	inline int getSolveLimit()
	{	{
	return m_solveLimit;	return m_solveLimit;
	}	}

	inline btScalar getLimitSign()	inline btScalar getLimitSign()
	{	{
	return m_limitSign;	return m_limitSign;
	}	}

End of changes. 9 change blocks.
	6 lines changed or deleted	66 lines changed or added

	btIDebugDraw.h	btIDebugDraw.h
	/*	/*

	Copyright (c) 2005 Gino van den Bergen / Erwin Coumans http://continuousphy	Bullet Continuous Collision Detection and Physics Library
	sics.com	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	Permission is hereby granted, free of charge, to any person or organization
	obtaining a copy of the software and accompanying documentation covered by
	this license (the "Software") to use, reproduce, display, distribute,
	execute, and transmit the Software, and to prepare derivative works of the
	Software, and to permit third-parties to whom the Software is furnished to
	do so, all subject to the following:


	The copyright notices in the Software and this entire statement, including	This software is provided 'as-is', without any express or implied warranty.
	the above license grant, this restriction and the following disclaimer,	In no event will the authors be held liable for any damages arising from th
	must be included in all copies of the Software, in whole or in part, and	e use of this software.
	all derivative works of the Software, unless such copies or derivative	Permission is granted to anyone to use this software for any purpose,
	works are solely in the form of machine-executable object code generated by	including commercial applications, and to alter it and redistribute it free
	a source language processor.	ly,
		subject to the following restrictions:


	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR	1. The origin of this software must not be misrepresented; you must not cla
	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,	im that you wrote the original software. If you use this software in a prod
	FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT	uct, an acknowledgment in the product documentation would be appreciated bu
	SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE	t is not required.
	FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,	2. Altered source versions must be plainly marked as such, and must not be
	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER	misrepresented as being the original software.
	DEALINGS IN THE SOFTWARE.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef IDEBUG_DRAW__H	#ifndef IDEBUG_DRAW__H
	#define IDEBUG_DRAW__H	#define IDEBUG_DRAW__H

	#include "btVector3.h"	#include "btVector3.h"
	#include "btTransform.h"	#include "btTransform.h"

	///The btIDebugDraw interface class allows hooking up a debug renderer to v isually debug simulations.	///The btIDebugDraw interface class allows hooking up a debug renderer to v isually debug simulations.
	///Typical use case: create a debug drawer object, and assign it to a btCol lisionWorld or btDynamicsWorld using setDebugDrawer and call debugDrawWorld .	///Typical use case: create a debug drawer object, and assign it to a btCol lisionWorld or btDynamicsWorld using setDebugDrawer and call debugDrawWorld .

	skipping to change at line 56	skipping to change at line 45
	DBG_DrawContactPoints=8,	DBG_DrawContactPoints=8,
	DBG_NoDeactivation=16,	DBG_NoDeactivation=16,
	DBG_NoHelpText = 32,	DBG_NoHelpText = 32,
	DBG_DrawText=64,	DBG_DrawText=64,
	DBG_ProfileTimings = 128,	DBG_ProfileTimings = 128,
	DBG_EnableSatComparison = 256,	DBG_EnableSatComparison = 256,
	DBG_DisableBulletLCP = 512,	DBG_DisableBulletLCP = 512,
	DBG_EnableCCD = 1024,	DBG_EnableCCD = 1024,
	DBG_DrawConstraints = (1 << 11),	DBG_DrawConstraints = (1 << 11),
	DBG_DrawConstraintLimits = (1 << 12),	DBG_DrawConstraintLimits = (1 << 12),

		DBG_FastWireframe = (1<<13),
	DBG_MAX_DEBUG_DRAW_MODE	DBG_MAX_DEBUG_DRAW_MODE
	};	};

	virtual ~btIDebugDraw() {};	virtual ~btIDebugDraw() {};

	virtual void drawLine(const btVector3& from,const btVector3& to, const btVector3& fromColor, const btVector3& toColor)	virtual void drawLine(const btVector3& from,const btVector3& to, const btVector3& fromColor, const btVector3& toColor)
	{	{
	drawLine (from, to, fromColor);	drawLine (from, to, fromColor);
	}	}


End of changes. 4 change blocks.
	22 lines changed or deleted	17 lines changed or added

	btJacobianEntry.h	btJacobianEntry.h

	skipping to change at line 30	skipping to change at line 30
	#include "BulletDynamics/Dynamics/btRigidBody.h"	#include "BulletDynamics/Dynamics/btRigidBody.h"

	//notes:	//notes:
	// Another memory optimization would be to store m_1MinvJt in the remaining 3 w components	// Another memory optimization would be to store m_1MinvJt in the remaining 3 w components
	// which makes the btJacobianEntry memory layout 16 bytes	// which makes the btJacobianEntry memory layout 16 bytes
	// if you only are interested in angular part, just feed massInvA and massI nvB zero	// if you only are interested in angular part, just feed massInvA and massI nvB zero

	/// Jacobian entry is an abstraction that allows to describe constraints	/// Jacobian entry is an abstraction that allows to describe constraints
	/// it can be used in combination with a constraint solver	/// it can be used in combination with a constraint solver
	/// Can be used to relate the effect of an impulse to the constraint error	/// Can be used to relate the effect of an impulse to the constraint error

	class btJacobianEntry	ATTRIBUTE_ALIGNED16(class) btJacobianEntry
	{	{
	public:	public:
	btJacobianEntry() {};	btJacobianEntry() {};
	//constraint between two different rigidbodies	//constraint between two different rigidbodies
	btJacobianEntry(	btJacobianEntry(
	const btMatrix3x3& world2A,	const btMatrix3x3& world2A,
	const btMatrix3x3& world2B,	const btMatrix3x3& world2B,
	const btVector3& rel_pos1,const btVector3& rel_pos2,	const btVector3& rel_pos1,const btVector3& rel_pos2,
	const btVector3& jointAxis,	const btVector3& jointAxis,
	const btVector3& inertiaInvA,	const btVector3& inertiaInvA,

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btKinematicCharacterController.h	btKinematicCharacterController.h

	skipping to change at line 23	skipping to change at line 23
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef KINEMATIC_CHARACTER_CONTROLLER_H	#ifndef KINEMATIC_CHARACTER_CONTROLLER_H
	#define KINEMATIC_CHARACTER_CONTROLLER_H	#define KINEMATIC_CHARACTER_CONTROLLER_H

	#include "LinearMath/btVector3.h"	#include "LinearMath/btVector3.h"

	#include "btCharacterControllerInterface.h"	#include "btCharacterControllerInterface.h"


		#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"

	class btCollisionShape;	class btCollisionShape;
	class btRigidBody;	class btRigidBody;
	class btCollisionWorld;	class btCollisionWorld;
	class btCollisionDispatcher;	class btCollisionDispatcher;
	class btPairCachingGhostObject;	class btPairCachingGhostObject;

	///btKinematicCharacterController is an object that supports a sliding moti on in a world.	///btKinematicCharacterController is an object that supports a sliding moti on in a world.
	///It uses a ghost object and convex sweep test to test for upcoming collis ions. This is combined with discrete collision detection to recover from pe netrations.	///It uses a ghost object and convex sweep test to test for upcoming collis ions. This is combined with discrete collision detection to recover from pe netrations.
	///Interaction between btKinematicCharacterController and dynamic rigid bod ies needs to be explicity implemented by the user.	///Interaction between btKinematicCharacterController and dynamic rigid bod ies needs to be explicity implemented by the user.
	class btKinematicCharacterController : public btCharacterControllerInterfac e	class btKinematicCharacterController : public btCharacterControllerInterfac e

	skipping to change at line 52	skipping to change at line 54
	btScalar m_maxJumpHeight;	btScalar m_maxJumpHeight;

	btScalar m_turnAngle;	btScalar m_turnAngle;

	btScalar m_stepHeight;	btScalar m_stepHeight;

	btScalar m_addedMargin;//@todo: remove this and fix the code	btScalar m_addedMargin;//@todo: remove this and fix the code

	///this is the desired walk direction, set by the user	///this is the desired walk direction, set by the user
	btVector3 m_walkDirection;	btVector3 m_walkDirection;

		btVector3 m_normalizedDirection;

	//some internal variables	//some internal variables
	btVector3 m_currentPosition;	btVector3 m_currentPosition;
	btScalar m_currentStepOffset;	btScalar m_currentStepOffset;
	btVector3 m_targetPosition;	btVector3 m_targetPosition;

	///keep track of the contact manifolds	///keep track of the contact manifolds
	btManifoldArray m_manifoldArray;	btManifoldArray m_manifoldArray;

	bool m_touchingContact;	bool m_touchingContact;
	btVector3 m_touchingNormal;	btVector3 m_touchingNormal;

	bool m_useGhostObjectSweepTest;	bool m_useGhostObjectSweepTest;

		bool m_useWalkDirection;
		float m_velocityTimeInterval;
	int m_upAxis;	int m_upAxis;

	btVector3 computeReflectionDirection (const btVector3& direction, co nst btVector3& normal);	btVector3 computeReflectionDirection (const btVector3& direction, co nst btVector3& normal);
	btVector3 parallelComponent (const btVector3& direction, const btVec tor3& normal);	btVector3 parallelComponent (const btVector3& direction, const btVec tor3& normal);
	btVector3 perpindicularComponent (const btVector3& direction, const btVector3& normal);	btVector3 perpindicularComponent (const btVector3& direction, const btVector3& normal);

	bool recoverFromPenetration ( btCollisionWorld* collisionWorld);	bool recoverFromPenetration ( btCollisionWorld* collisionWorld);
	void stepUp (btCollisionWorld* collisionWorld);	void stepUp (btCollisionWorld* collisionWorld);
	void updateTargetPositionBasedOnCollision (const btVector3& hit_norm al, btScalar tangentMag = btScalar(0.0), btScalar normalMag = btScalar(1.0) );	void updateTargetPositionBasedOnCollision (const btVector3& hit_norm al, btScalar tangentMag = btScalar(0.0), btScalar normalMag = btScalar(1.0) );
	void stepForwardAndStrafe (btCollisionWorld* collisionWorld, const b tVector3& walkMove);	void stepForwardAndStrafe (btCollisionWorld* collisionWorld, const b tVector3& walkMove);

	skipping to change at line 100	skipping to change at line 104

	void setUpAxis (int axis)	void setUpAxis (int axis)
	{	{
	if (axis < 0)	if (axis < 0)
	axis = 0;	axis = 0;
	if (axis > 2)	if (axis > 2)
	axis = 2;	axis = 2;
	m_upAxis = axis;	m_upAxis = axis;
	}	}


	virtual void setWalkDirection(const btVector3& walkDirection)	/// This should probably be called setPositionIncrementPerSimulatorS
	{	tep.
	m_walkDirection = walkDirection;	/// This is neither a direction nor a velocity, but the amount to
	}	/// increment the position each simulation iteration, regardless
		/// of dt.
		/// This call will reset any velocity set by setVelocityForTimeInter
		val().
		virtual void setWalkDirection(const btVector3& walkDirection);

		/// Caller provides a velocity with which the character should move
		for
		/// the given time period. After the time period, velocity is res
		et
		/// to zero.
		/// This call will reset any walk direction set by setWalkDirection(
		).
		/// Negative time intervals will result in no motion.
		virtual void setVelocityForTimeInterval(const btVector3& velocity,
		btScalar timeInterval);

	void reset ();	void reset ();
	void warp (const btVector3& origin);	void warp (const btVector3& origin);

	void preStep ( btCollisionWorld* collisionWorld);	void preStep ( btCollisionWorld* collisionWorld);
	void playerStep ( btCollisionWorld* collisionWorld, btScalar dt);	void playerStep ( btCollisionWorld* collisionWorld, btScalar dt);

	void setFallSpeed (btScalar fallSpeed);	void setFallSpeed (btScalar fallSpeed);
	void setJumpSpeed (btScalar jumpSpeed);	void setJumpSpeed (btScalar jumpSpeed);
	void setMaxJumpHeight (btScalar maxJumpHeight);	void setMaxJumpHeight (btScalar maxJumpHeight);

End of changes. 4 change blocks.
	5 lines changed or deleted	24 lines changed or added

	btManifoldResult.h	btManifoldResult.h

	skipping to change at line 30	skipping to change at line 30
	#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"	#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
	class btManifoldPoint;	class btManifoldPoint;

	#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorI nterface.h"	#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorI nterface.h"

	#include "LinearMath/btTransform.h"	#include "LinearMath/btTransform.h"

	typedef bool (ContactAddedCallback)(btManifoldPoint& cp, const btColl isionObject colObj0,int partId0,int index0,const btCollisionObject* colObj 1,int partId1,int index1);	typedef bool (ContactAddedCallback)(btManifoldPoint& cp, const btColl isionObject colObj0,int partId0,int index0,const btCollisionObject* colObj 1,int partId1,int index1);
	extern ContactAddedCallback gContactAddedCallback;	extern ContactAddedCallback gContactAddedCallback;


		//#define DEBUG_PART_INDEX 1

	///btManifoldResult is a helper class to manage contact results.	///btManifoldResult is a helper class to manage contact results.
	class btManifoldResult : public btDiscreteCollisionDetectorInterface::Resul t	class btManifoldResult : public btDiscreteCollisionDetectorInterface::Resul t
	{	{
	btPersistentManifold* m_manifoldPtr;	btPersistentManifold* m_manifoldPtr;

	//we need this for compounds	//we need this for compounds
	btTransform m_rootTransA;	btTransform m_rootTransA;
	btTransform m_rootTransB;	btTransform m_rootTransB;

	btCollisionObject* m_body0;	btCollisionObject* m_body0;
	btCollisionObject* m_body1;	btCollisionObject* m_body1;
	int m_partId0;	int m_partId0;
	int m_partId1;	int m_partId1;
	int m_index0;	int m_index0;
	int m_index1;	int m_index1;

	public:	public:

	btManifoldResult()	btManifoldResult()

		#ifdef DEBUG_PART_INDEX
		:
		m_partId0(-1),
		m_partId1(-1),
		m_index0(-1),
		m_index1(-1)
		#endif //DEBUG_PART_INDEX
	{	{
	}	}

	btManifoldResult(btCollisionObject* body0,btCollisionObject* body1);	btManifoldResult(btCollisionObject* body0,btCollisionObject* body1);

	virtual ~btManifoldResult() {};	virtual ~btManifoldResult() {};

	void setPersistentManifold(btPersistentManifold* manifoldPtr)	void setPersistentManifold(btPersistentManifold* manifoldPtr)
	{	{
	m_manifoldPtr = manifoldPtr;	m_manifoldPtr = manifoldPtr;

	skipping to change at line 70	skipping to change at line 79

	const btPersistentManifold* getPersistentManifold() const	const btPersistentManifold* getPersistentManifold() const
	{	{
	return m_manifoldPtr;	return m_manifoldPtr;
	}	}
	btPersistentManifold* getPersistentManifold()	btPersistentManifold* getPersistentManifold()
	{	{
	return m_manifoldPtr;	return m_manifoldPtr;
	}	}


	virtual void setShapeIdentifiers(int partId0,int index0, int partId1,int index1)	virtual void setShapeIdentifiersA(int partId0,int index0)
	{	{

	m_partId0=partId0;	m_partId0=partId0;
	m_partId1=partId1;	m_index0=index0;
	m_index0=index0;	}
	m_index1=index1;
		virtual void setShapeIdentifiersB( int partId1,int index1)
		{
		m_partId1=partId1;
		m_index1=index1;
	}	}

	virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth);	virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth);

	SIMD_FORCE_INLINE void refreshContactPoints()	SIMD_FORCE_INLINE void refreshContactPoints()
	{	{
	btAssert(m_manifoldPtr);	btAssert(m_manifoldPtr);
	if (!m_manifoldPtr->getNumContacts())	if (!m_manifoldPtr->getNumContacts())
	return;	return;


	skipping to change at line 97	skipping to change at line 110

	if (isSwapped)	if (isSwapped)
	{	{
	m_manifoldPtr->refreshContactPoints(m_rootTransB,m_r ootTransA);	m_manifoldPtr->refreshContactPoints(m_rootTransB,m_r ootTransA);
	} else	} else
	{	{
	m_manifoldPtr->refreshContactPoints(m_rootTransA,m_r ootTransB);	m_manifoldPtr->refreshContactPoints(m_rootTransA,m_r ootTransB);
	}	}
	}	}


		const btCollisionObject* getBody0Internal() const
		{
		return m_body0;
		}

		const btCollisionObject* getBody1Internal() const
		{
		return m_body1;
		}

	};	};

	#endif //MANIFOLD_RESULT_H	#endif //MANIFOLD_RESULT_H

End of changes. 5 change blocks.
	5 lines changed or deleted	28 lines changed or added

	btMaterial.h	btMaterial.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2008 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btMatrix3x3.h	btMatrix3x3.h

	skipping to change at line 497	skipping to change at line 497
	{	{
	setValue(m.tdotx(m_el[0]), m.tdoty(m_el[0]), m.tdotz(m_el[0] ),	setValue(m.tdotx(m_el[0]), m.tdoty(m_el[0]), m.tdotz(m_el[0] ),
	m.tdotx(m_el[1]), m.tdoty(m_el[1]), m.tdotz (m_el[1]),	m.tdotx(m_el[1]), m.tdoty(m_el[1]), m.tdotz (m_el[1]),
	m.tdotx(m_el[2]), m.tdoty(m_el[2]), m.tdotz (m_el[2]));	m.tdotx(m_el[2]), m.tdoty(m_el[2]), m.tdotz (m_el[2]));
	return *this;	return *this;
	}	}

	SIMD_FORCE_INLINE btScalar	SIMD_FORCE_INLINE btScalar
	btMatrix3x3::determinant() const	btMatrix3x3::determinant() const
	{	{

	return triple((this)[0], (this)[1], (*this)[2]);	return btTriple((this)[0], (this)[1], (*this)[2]);
	}	}

	SIMD_FORCE_INLINE btMatrix3x3	SIMD_FORCE_INLINE btMatrix3x3
	btMatrix3x3::absolute() const	btMatrix3x3::absolute() const
	{	{
	return btMatrix3x3(	return btMatrix3x3(
	btFabs(m_el[0].x()), btFabs(m_el[0].y()), btFabs(m_e l[0].z()),	btFabs(m_el[0].x()), btFabs(m_el[0].y()), btFabs(m_e l[0].z()),
	btFabs(m_el[1].x()), btFabs(m_el[1].y()), btFabs(m_e l[1].z()),	btFabs(m_el[1].x()), btFabs(m_el[1].y()), btFabs(m_e l[1].z()),
	btFabs(m_el[2].x()), btFabs(m_el[2].y()), btFabs(m_e l[2].z()));	btFabs(m_el[2].x()), btFabs(m_el[2].y()), btFabs(m_e l[2].z()));
	}	}

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btMinkowskiSumShape.h	btMinkowskiSumShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btMultiSapBroadphase.h	btMultiSapBroadphase.h

	skipping to change at line 129	skipping to change at line 129
	}	}
	virtual const btOverlappingPairCache* getOverlappingPairCache() co nst	virtual const btOverlappingPairCache* getOverlappingPairCache() co nst
	{	{
	return m_overlappingPairs;	return m_overlappingPairs;
	}	}

	///getAabb returns the axis aligned bounding box in the 'global' coo rdinate frame	///getAabb returns the axis aligned bounding box in the 'global' coo rdinate frame
	///will add some transform later	///will add some transform later
	virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax ) const	virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax ) const
	{	{

	aabbMin.setValue(-1e30f,-1e30f,-1e30f);	aabbMin.setValue(-BT_LARGE_FLOAT,-BT_LARGE_FLOAT,-BT_LARGE_F
	aabbMax.setValue(1e30f,1e30f,1e30f);	LOAT);
		aabbMax.setValue(BT_LARGE_FLOAT,BT_LARGE_FLOAT,BT_LARGE_FLOA
		T);
	}	}

	void buildTree(const btVector3& bvhAabbMin,const btVector3& bvhAa bbMax);	void buildTree(const btVector3& bvhAabbMin,const btVector3& bvhAa bbMax);

	virtual void printStats();	virtual void printStats();

	void quicksort (btBroadphasePairArray& a, int lo, int hi);	void quicksort (btBroadphasePairArray& a, int lo, int hi);

	///reset broadphase internal structures, to ensure determinism/repro ducability	///reset broadphase internal structures, to ensure determinism/repro ducability
	virtual void resetPool(btDispatcher* dispatcher);	virtual void resetPool(btDispatcher* dispatcher);

End of changes. 1 change blocks.
	2 lines changed or deleted	4 lines changed or added

	btMultiSphereShape.h	btMultiSphereShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef MULTI_SPHERE_MINKOWSKI_H	#ifndef MULTI_SPHERE_MINKOWSKI_H
	#define MULTI_SPHERE_MINKOWSKI_H	#define MULTI_SPHERE_MINKOWSKI_H

	#include "btConvexInternalShape.h"	#include "btConvexInternalShape.h"
	#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for t he types	#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for t he types

		#include "LinearMath/btAlignedObjectArray.h"
	#define MAX_NUM_SPHERES 5	#include "LinearMath/btAabbUtil2.h"

	///The btMultiSphereShape represents the convex hull of a collection of sph eres. You can create special capsules or other smooth volumes.	///The btMultiSphereShape represents the convex hull of a collection of sph eres. You can create special capsules or other smooth volumes.

	///It is possible to animate the spheres for deformation.	///It is possible to animate the spheres for deformation, but call 'recalcL
	class btMultiSphereShape : public btConvexInternalShape	ocalAabb' after changing any sphere position/radius
		class btMultiSphereShape : public btConvexInternalAabbCachingShape
	{	{


	btVector3 m_localPositions[MAX_NUM_SPHERES];	btAlignedObjectArray<btVector3> m_localPositionArray;
	btScalar m_radi[MAX_NUM_SPHERES];	btAlignedObjectArray<btScalar> m_radiArray;
	btVector3 m_inertiaHalfExtents;

	int m_numSpheres;

	public:	public:

	btMultiSphereShape (const btVector3& inertiaHalfExtents,const btVect or3* positions,const btScalar* radi,int numSpheres);	btMultiSphereShape (const btVector3* positions,const btScalar* radi, int numSpheres);

	///CollisionShape Interface	///CollisionShape Interface
	virtual void calculateLocalInertia(btScalar mass,btVector3& inert ia) const;	virtual void calculateLocalInertia(btScalar mass,btVector3& inert ia) const;

	/// btConvexShape Interface	/// btConvexShape Interface
	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec)const;	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec)const;

	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(co nst btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(co nst btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;

	int getSphereCount() const	int getSphereCount() const
	{	{

	return m_numSpheres;	return m_localPositionArray.size();
	}	}

	const btVector3& getSpherePosition(int index) const	const btVector3& getSpherePosition(int index) const
	{	{

	return m_localPositions[index];	return m_localPositionArray[index];
	}	}

	btScalar getSphereRadius(int index) const	btScalar getSphereRadius(int index) const
	{	{

	return m_radi[index];	return m_radiArray[index];
	}	}

	virtual const char* getName()const	virtual const char* getName()const
	{	{
	return "MultiSphere";	return "MultiSphere";
	}	}

	};	};

	#endif //MULTI_SPHERE_MINKOWSKI_H	#endif //MULTI_SPHERE_MINKOWSKI_H

End of changes. 8 change blocks.
	15 lines changed or deleted	12 lines changed or added

	btMultimaterialTriangleMeshShape.h	btMultimaterialTriangleMeshShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2008 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btPersistentManifold.h	btPersistentManifold.h

	skipping to change at line 33	skipping to change at line 33

	struct btCollisionResult;	struct btCollisionResult;

	///maximum contact breaking and merging threshold	///maximum contact breaking and merging threshold
	extern btScalar gContactBreakingThreshold;	extern btScalar gContactBreakingThreshold;

	typedef bool (ContactDestroyedCallback)(void userPersistentData);	typedef bool (ContactDestroyedCallback)(void userPersistentData);
	typedef bool (ContactProcessedCallback)(btManifoldPoint& cp,void body0,vo id* body1);	typedef bool (ContactProcessedCallback)(btManifoldPoint& cp,void body0,vo id* body1);
	extern ContactDestroyedCallback gContactDestroyedCallback;	extern ContactDestroyedCallback gContactDestroyedCallback;


		enum btContactManifoldTypes
		{
		BT_PERSISTENT_MANIFOLD_TYPE = 1,
		MAX_CONTACT_MANIFOLD_TYPE
		};

	#define MANIFOLD_CACHE_SIZE 4	#define MANIFOLD_CACHE_SIZE 4

	///btPersistentManifold is a contact point cache, it stays persistent as lo ng as objects are overlapping in the broadphase.	///btPersistentManifold is a contact point cache, it stays persistent as lo ng as objects are overlapping in the broadphase.
	///Those contact points are created by the collision narrow phase.	///Those contact points are created by the collision narrow phase.
	///The cache can be empty, or hold 1,2,3 or 4 points. Some collision algori thms (GJK) might only add one point at a time.	///The cache can be empty, or hold 1,2,3 or 4 points. Some collision algori thms (GJK) might only add one point at a time.
	///updates/refreshes old contact points, and throw them away if necessary ( distance becomes too large)	///updates/refreshes old contact points, and throw them away if necessary ( distance becomes too large)
	///reduces the cache to 4 points, when more then 4 points are added, using following rules:	///reduces the cache to 4 points, when more then 4 points are added, using following rules:
	///the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points	///the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points
	///note that some pairs of objects might have more then one contact manifol d.	///note that some pairs of objects might have more then one contact manifol d.

	ATTRIBUTE_ALIGNED16( class) btPersistentManifold	ATTRIBUTE_ALIGNED16( class) btPersistentManifold : public btTypedObject
	{	{

	btManifoldPoint m_pointCache[MANIFOLD_CACHE_SIZE];	btManifoldPoint m_pointCache[MANIFOLD_CACHE_SIZE];

	/// this two body pointers can point to the physics rigidbody class.	/// this two body pointers can point to the physics rigidbody class.
	/// void* will allow any rigidbody class	/// void* will allow any rigidbody class
	void* m_body0;	void* m_body0;
	void* m_body1;	void* m_body1;
	int m_cachedPoints;	int m_cachedPoints;


	skipping to change at line 70	skipping to change at line 76

	public:	public:

	BT_DECLARE_ALIGNED_ALLOCATOR();	BT_DECLARE_ALIGNED_ALLOCATOR();

	int m_index1a;	int m_index1a;

	btPersistentManifold();	btPersistentManifold();

	btPersistentManifold(void* body0,void* body1,int , btScalar contactB reakingThreshold,btScalar contactProcessingThreshold)	btPersistentManifold(void* body0,void* body1,int , btScalar contactB reakingThreshold,btScalar contactProcessingThreshold)

	: m_body0(body0),m_body1(body1),m_cachedPoints(0),	: btTypedObject(BT_PERSISTENT_MANIFOLD_TYPE),
		m_body0(body0),m_body1(body1),m_cachedPoints(0),
	m_contactBreakingThreshold(contactBreakingThreshold),	m_contactBreakingThreshold(contactBreakingThreshold),
	m_contactProcessingThreshold(contactProcessingThreshold)	m_contactProcessingThreshold(contactProcessingThreshold)
	{	{


	}	}

	SIMD_FORCE_INLINE void* getBody0() { return m_body0;}	SIMD_FORCE_INLINE void* getBody0() { return m_body0;}
	SIMD_FORCE_INLINE void* getBody1() { return m_body1;}	SIMD_FORCE_INLINE void* getBody1() { return m_body1;}

	SIMD_FORCE_INLINE const void* getBody0() const { return m_body0;}	SIMD_FORCE_INLINE const void* getBody0() const { return m_body0;}
	SIMD_FORCE_INLINE const void* getBody1() const { return m_body1;}	SIMD_FORCE_INLINE const void* getBody1() const { return m_body1;}

	void setBodies(void* body0,void* body1)	void setBodies(void* body0,void* body1)
	{	{

End of changes. 4 change blocks.
	3 lines changed or deleted	9 lines changed or added

	btPoint2PointConstraint.h	btPoint2PointConstraint.h

	skipping to change at line 39	skipping to change at line 39
	m_damping(btScalar(1.)),	m_damping(btScalar(1.)),
	m_impulseClamp(btScalar(0.))	m_impulseClamp(btScalar(0.))
	{	{
	}	}
	btScalar m_tau;	btScalar m_tau;
	btScalar m_damping;	btScalar m_damping;
	btScalar m_impulseClamp;	btScalar m_impulseClamp;
	};	};

	/// point to point constraint between two rigidbodies each with a pivotpoin t that descibes the 'ballsocket' location in local space	/// point to point constraint between two rigidbodies each with a pivotpoin t that descibes the 'ballsocket' location in local space

	class btPoint2PointConstraint : public btTypedConstraint	ATTRIBUTE_ALIGNED16(class) btPoint2PointConstraint : public btTypedConstrai nt
	{	{
	#ifdef IN_PARALLELL_SOLVER	#ifdef IN_PARALLELL_SOLVER
	public:	public:
	#endif	#endif
	btJacobianEntry m_jac[3]; //3 orthogonal linear constraints	btJacobianEntry m_jac[3]; //3 orthogonal linear constraints

	btVector3 m_pivotInA;	btVector3 m_pivotInA;
	btVector3 m_pivotInB;	btVector3 m_pivotInB;

	public:	public:

	skipping to change at line 66	skipping to change at line 66
	btPoint2PointConstraint(btRigidBody& rbA,btRigidBody& rbB, const btV ector3& pivotInA,const btVector3& pivotInB);	btPoint2PointConstraint(btRigidBody& rbA,btRigidBody& rbB, const btV ector3& pivotInA,const btVector3& pivotInB);

	btPoint2PointConstraint(btRigidBody& rbA,const btVector3& pivotInA);	btPoint2PointConstraint(btRigidBody& rbA,const btVector3& pivotInA);

	btPoint2PointConstraint();	btPoint2PointConstraint();

	virtual void buildJacobian();	virtual void buildJacobian();

	virtual void getInfo1 (btConstraintInfo1* info);	virtual void getInfo1 (btConstraintInfo1* info);


		void getInfo1NonVirtual (btConstraintInfo1* info);

	virtual void getInfo2 (btConstraintInfo2* info);	virtual void getInfo2 (btConstraintInfo2* info);


		void getInfo2NonVirtual (btConstraintInfo2* info, const btTransform&
		body0_trans, const btTransform& body1_trans);

	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep);	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep);

	void updateRHS(btScalar timeStep);	void updateRHS(btScalar timeStep);

	void setPivotA(const btVector3& pivotA)	void setPivotA(const btVector3& pivotA)
	{	{
	m_pivotInA = pivotA;	m_pivotInA = pivotA;
	}	}

	void setPivotB(const btVector3& pivotB)	void setPivotB(const btVector3& pivotB)

End of changes. 3 change blocks.
	1 lines changed or deleted	6 lines changed or added

	btPointCollector.h	btPointCollector.h

	skipping to change at line 31	skipping to change at line 31
	struct btPointCollector : public btDiscreteCollisionDetectorInterface::Resu lt	struct btPointCollector : public btDiscreteCollisionDetectorInterface::Resu lt
	{	{

	btVector3 m_normalOnBInWorld;	btVector3 m_normalOnBInWorld;
	btVector3 m_pointInWorld;	btVector3 m_pointInWorld;
	btScalar m_distance;//negative means penetration	btScalar m_distance;//negative means penetration

	bool m_hasResult;	bool m_hasResult;

	btPointCollector ()	btPointCollector ()

	: m_distance(btScalar(1e30)),m_hasResult(false)	: m_distance(btScalar(BT_LARGE_FLOAT)),m_hasResult(false)
	{	{
	}	}


	virtual void setShapeIdentifiers(int partId0,int index0, int partId1,int index1)	virtual void setShapeIdentifiersA(int partId0,int index0)
	{	{
	(void)partId0;	(void)partId0;
	(void)index0;	(void)index0;


		}
		virtual void setShapeIdentifiersB(int partId1,int index1)
		{
	(void)partId1;	(void)partId1;
	(void)index1;	(void)index1;

	//??
	}	}

	virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)	virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
	{	{
	if (depth< m_distance)	if (depth< m_distance)
	{	{
	m_hasResult = true;	m_hasResult = true;
	m_normalOnBInWorld = normalOnBInWorld;	m_normalOnBInWorld = normalOnBInWorld;
	m_pointInWorld = pointInWorld;	m_pointInWorld = pointInWorld;
	//negative means penetration	//negative means penetration

End of changes. 4 change blocks.
	3 lines changed or deleted	6 lines changed or added

	btPolyhedralConvexShape.h	btPolyhedralConvexShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef BU_SHAPE	#ifndef BU_SHAPE
	#define BU_SHAPE	#define BU_SHAPE

	#include "LinearMath/btMatrix3x3.h"	#include "LinearMath/btMatrix3x3.h"

	#include "LinearMath/btAabbUtil2.h"
	#include "btConvexInternalShape.h"	#include "btConvexInternalShape.h"

	///The btPolyhedralConvexShape is an internal interface class for polyhedra l convex shapes.	///The btPolyhedralConvexShape is an internal interface class for polyhedra l convex shapes.
	class btPolyhedralConvexShape : public btConvexInternalShape	class btPolyhedralConvexShape : public btConvexInternalShape
	{	{

	protected:	protected:

	btVector3 m_localAabbMin;
	btVector3 m_localAabbMax;
	bool m_isLocalAabbValid;

	public:	public:

	btPolyhedralConvexShape();	btPolyhedralConvexShape();

	//brute force implementations	//brute force implementations

	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec)const;	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec)const;
	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(co nst btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(co nst btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;

	virtual void calculateLocalInertia(btScalar mass,btVector3& inert ia) const;	virtual void calculateLocalInertia(btScalar mass,btVector3& inert ia) const;


		virtual int getNumVertices() const = 0 ;
		virtual int getNumEdges() const = 0;
		virtual void getEdge(int i,btVector3& pa,btVector3& pb) const = 0;
		virtual void getVertex(int i,btVector3& vtx) const = 0;
		virtual int getNumPlanes() const = 0;
		virtual void getPlane(btVector3& planeNormal,btVector3& planeSupport
		,int i ) const = 0;
		// virtual int getIndex(int i) const = 0 ;

		virtual bool isInside(const btVector3& pt,btScalar tolerance) const
		= 0;

		};

		///The btPolyhedralConvexAabbCachingShape adds aabb caching to the btPolyhe
		dralConvexShape
		class btPolyhedralConvexAabbCachingShape : public btPolyhedralConvexShape
		{

		btVector3 m_localAabbMin;
		btVector3 m_localAabbMax;
		bool m_isLocalAabbValid;

		protected:

	void setCachedLocalAabb (const btVector3& aabbMin, const btVector3& aabbMax)	void setCachedLocalAabb (const btVector3& aabbMin, const btVector3& aabbMax)
	{	{
	m_isLocalAabbValid = true;	m_isLocalAabbValid = true;
	m_localAabbMin = aabbMin;	m_localAabbMin = aabbMin;
	m_localAabbMax = aabbMax;	m_localAabbMax = aabbMax;
	}	}

	inline void getCachedLocalAabb (btVector3& aabbMin, btVector3& aabbM ax) const	inline void getCachedLocalAabb (btVector3& aabbMin, btVector3& aabbM ax) const
	{	{
	btAssert(m_isLocalAabbValid);	btAssert(m_isLocalAabbValid);
	aabbMin = m_localAabbMin;	aabbMin = m_localAabbMin;
	aabbMax = m_localAabbMax;	aabbMax = m_localAabbMax;
	}	}


		public:

		btPolyhedralConvexAabbCachingShape();

	inline void getNonvirtualAabb(const btTransform& trans,btVector3& aa bbMin,btVector3& aabbMax, btScalar margin) const	inline void getNonvirtualAabb(const btTransform& trans,btVector3& aa bbMin,btVector3& aabbMax, btScalar margin) const
	{	{

	//lazy evaluation of local aabb	//lazy evaluation of local aabb
	btAssert(m_isLocalAabbValid);	btAssert(m_isLocalAabbValid);
	btTransformAabb(m_localAabbMin,m_localAabbMax,margin,trans,a abbMin,aabbMax);	btTransformAabb(m_localAabbMin,m_localAabbMax,margin,trans,a abbMin,aabbMax);
	}	}


	virtual void getAabb(const btTransform& t,btVector3& aabbMin,btVecto
	r3& aabbMax) const;

	virtual void setLocalScaling(const btVector3& scaling);	virtual void setLocalScaling(const btVector3& scaling);


	void recalcLocalAabb();	virtual void getAabb(const btTransform& t,btVector3& aabbMin,btVecto
		r3& aabbMax) const;
	virtual int getNumVertices() const = 0 ;
	virtual int getNumEdges() const = 0;
	virtual void getEdge(int i,btVector3& pa,btVector3& pb) const = 0;
	virtual void getVertex(int i,btVector3& vtx) const = 0;
	virtual int getNumPlanes() const = 0;
	virtual void getPlane(btVector3& planeNormal,btVector3& planeSupport
	,int i ) const = 0;
	// virtual int getIndex(int i) const = 0 ;

	virtual bool isInside(const btVector3& pt,btScalar tolerance) const
	= 0;


	/// optional Hull is for optional Separating Axis Test Hull collisio	void recalcLocalAabb();
	n detection, see Hull.cpp
	class Hull* m_optionalHull;

	};	};

	#endif //BU_SHAPE	#endif //BU_SHAPE

End of changes. 8 change blocks.
	24 lines changed or deleted	33 lines changed or added

	btQuaternion.h	btQuaternion.h

	skipping to change at line 208	skipping to change at line 208
	btAssert(s != btScalar(0.0));	btAssert(s != btScalar(0.0));
	return btAcos(dot(q) / s);	return btAcos(dot(q) / s);
	}	}
	/*@brief Return the angle of rotation represented by this quaternion /	/*@brief Return the angle of rotation represented by this quaternion /
	btScalar getAngle() const	btScalar getAngle() const
	{	{
	btScalar s = btScalar(2.) * btAcos(m_floats[3]);	btScalar s = btScalar(2.) * btAcos(m_floats[3]);
	return s;	return s;
	}	}


	/*@brief Return the inverse of this quaternion /	/**@brief Return the axis of the rotation represented by this quater
		nion */
		btVector3 getAxis() const
		{
		btScalar s_squared = btScalar(1.) - btPow(m_floats[3], btSca
		lar(2.));
		if (s_squared < btScalar(10.) * SIMD_EPSILON) //Check for di
		vide by zero
		return btVector3(1.0, 0.0, 0.0); // Arbitrary
		btScalar s = btSqrt(s_squared);
		return btVector3(m_floats[0] / s, m_floats[1] / s, m_floats[
		2] / s);
		}

		/*@brief Return the inverse of this quaternion /
	btQuaternion inverse() const	btQuaternion inverse() const
	{	{
	return btQuaternion(-m_floats[0], -m_floats[1], -m_floats[2] , m_floats[3]);	return btQuaternion(-m_floats[0], -m_floats[1], -m_floats[2] , m_floats[3]);
	}	}

	/**@brief Return the sum of this quaternion and the other	/**@brief Return the sum of this quaternion and the other
	* @param q2 The other quaternion */	* @param q2 The other quaternion */
	SIMD_FORCE_INLINE btQuaternion	SIMD_FORCE_INLINE btQuaternion
	operator+(const btQuaternion& q2) const	operator+(const btQuaternion& q2) const
	{	{

	skipping to change at line 250	skipping to change at line 260
	SIMD_FORCE_INLINE btQuaternion farthest( const btQuaternion& qd) con st	SIMD_FORCE_INLINE btQuaternion farthest( const btQuaternion& qd) con st
	{	{
	btQuaternion diff,sum;	btQuaternion diff,sum;
	diff = *this - qd;	diff = *this - qd;
	sum = *this + qd;	sum = *this + qd;
	if( diff.dot(diff) > sum.dot(sum) )	if( diff.dot(diff) > sum.dot(sum) )
	return qd;	return qd;
	return (-qd);	return (-qd);
	}	}


		/*@todo document this and it's use /
		SIMD_FORCE_INLINE btQuaternion nearest( const btQuaternion& qd) cons
		t
		{
		btQuaternion diff,sum;
		diff = *this - qd;
		sum = *this + qd;
		if( diff.dot(diff) < sum.dot(sum) )
		return qd;
		return (-qd);
		}

	/**@brief Return the quaternion which is the result of Spherical Linear I nterpolation between this and the other quaternion	/**@brief Return the quaternion which is the result of Spherical Linear I nterpolation between this and the other quaternion
	* @param q The other quaternion to interpolate with	* @param q The other quaternion to interpolate with
	* @param t The ratio between this and q to interpolate. If t = 0 the re sult is this, if t=1 the result is q.	* @param t The ratio between this and q to interpolate. If t = 0 the re sult is this, if t=1 the result is q.
	* Slerp interpolates assuming constant velocity. */	* Slerp interpolates assuming constant velocity. */
	btQuaternion slerp(const btQuaternion& q, const btScalar& t) const	btQuaternion slerp(const btQuaternion& q, const btScalar& t) const
	{	{
	btScalar theta = angle(q);	btScalar theta = angle(q);
	if (theta != btScalar(0.0))	if (theta != btScalar(0.0))
	{	{
	btScalar d = btScalar(1.0) / btSin(theta);	btScalar d = btScalar(1.0) / btSin(theta);

	skipping to change at line 371	skipping to change at line 392
	return btVector3(q.getX(),q.getY(),q.getZ());	return btVector3(q.getX(),q.getY(),q.getZ());
	}	}

	SIMD_FORCE_INLINE btQuaternion	SIMD_FORCE_INLINE btQuaternion
	shortestArcQuat(const btVector3& v0, const btVector3& v1) // Game Programmi ng Gems 2.10. make sure v0,v1 are normalized	shortestArcQuat(const btVector3& v0, const btVector3& v1) // Game Programmi ng Gems 2.10. make sure v0,v1 are normalized
	{	{
	btVector3 c = v0.cross(v1);	btVector3 c = v0.cross(v1);
	btScalar d = v0.dot(v1);	btScalar d = v0.dot(v1);

	if (d < -1.0 + SIMD_EPSILON)	if (d < -1.0 + SIMD_EPSILON)

	return btQuaternion(0.0f,1.0f,0.0f,0.0f); // just pick any v	{
	ector	btVector3 n,unused;
		btPlaneSpace1(v0,n,unused);
		return btQuaternion(n.x(),n.y(),n.z(),0.0f); // just pick an
		y vector that is orthogonal to v0
		}

	btScalar s = btSqrt((1.0f + d) * 2.0f);	btScalar s = btSqrt((1.0f + d) * 2.0f);
	btScalar rs = 1.0f / s;	btScalar rs = 1.0f / s;

	return btQuaternion(c.getX()rs,c.getY()rs,c.getZ()rs,s 0.5f);	return btQuaternion(c.getX()rs,c.getY()rs,c.getZ()rs,s 0.5f);
	}	}

	SIMD_FORCE_INLINE btQuaternion	SIMD_FORCE_INLINE btQuaternion
	shortestArcQuatNormalize2(btVector3& v0,btVector3& v1)	shortestArcQuatNormalize2(btVector3& v0,btVector3& v1)
	{	{

End of changes. 3 change blocks.
	3 lines changed or deleted	33 lines changed or added

	btRigidBody.h	btRigidBody.h

	skipping to change at line 46	skipping to change at line 46
	///- C) Kinematic objects, which are objects without mass, but the user can move them. There is on-way interaction, and Bullet calculates a velocity b ased on the timestep and previous and current world transform.	///- C) Kinematic objects, which are objects without mass, but the user can move them. There is on-way interaction, and Bullet calculates a velocity b ased on the timestep and previous and current world transform.
	///Bullet automatically deactivates dynamic rigid bodies, when the velocity is below a threshold for a given time.	///Bullet automatically deactivates dynamic rigid bodies, when the velocity is below a threshold for a given time.
	///Deactivated (sleeping) rigid bodies don't take any processing time, exce pt a minor broadphase collision detection impact (to allow active objects t o activate/wake up sleeping objects)	///Deactivated (sleeping) rigid bodies don't take any processing time, exce pt a minor broadphase collision detection impact (to allow active objects t o activate/wake up sleeping objects)
	class btRigidBody : public btCollisionObject	class btRigidBody : public btCollisionObject
	{	{

	btMatrix3x3 m_invInertiaTensorWorld;	btMatrix3x3 m_invInertiaTensorWorld;
	btVector3 m_linearVelocity;	btVector3 m_linearVelocity;
	btVector3 m_angularVelocity;	btVector3 m_angularVelocity;
	btScalar m_inverseMass;	btScalar m_inverseMass;

	btScalar m_angularFactor;	btVector3 m_angularFactor;
		btVector3 m_linearFactor;

	btVector3 m_gravity;	btVector3 m_gravity;
	btVector3 m_gravity_acceleration;	btVector3 m_gravity_acceleration;
	btVector3 m_invInertiaLocal;	btVector3 m_invInertiaLocal;
	btVector3 m_totalForce;	btVector3 m_totalForce;
	btVector3 m_totalTorque;	btVector3 m_totalTorque;

	btScalar m_linearDamping;	btScalar m_linearDamping;
	btScalar m_angularDamping;	btScalar m_angularDamping;


	skipping to change at line 216	skipping to change at line 217
	SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const {	SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const {
	return m_collisionShape;	return m_collisionShape;
	}	}

	SIMD_FORCE_INLINE btCollisionShape* getCollisionShape() {	SIMD_FORCE_INLINE btCollisionShape* getCollisionShape() {
	return m_collisionShape;	return m_collisionShape;
	}	}

	void setMassProps(btScalar mass, const btVector3& inertia);	void setMassProps(btScalar mass, const btVector3& inertia);


		const btVector3& getLinearFactor() const
		{
		return m_linearFactor;
		}
		void setLinearFactor(const btVector3& linearFactor)
		{
		m_linearFactor = linearFactor;
		}
	btScalar getInvMass() const { return m_inverseMass; }	btScalar getInvMass() const { return m_inverseMass; }
	const btMatrix3x3& getInvInertiaTensorWorld() const {	const btMatrix3x3& getInvInertiaTensorWorld() const {
	return m_invInertiaTensorWorld;	return m_invInertiaTensorWorld;
	}	}

	void integrateVelocities(btScalar step);	void integrateVelocities(btScalar step);

	void setCenterOfMassTransform(const btTransform& xform);	void setCenterOfMassTransform(const btTransform& xform);

	void applyCentralForce(const btVector3& force)	void applyCentralForce(const btVector3& force)
	{	{

	m_totalForce += force;	m_totalForce += force*m_linearFactor;
	}	}

	const btVector3& getTotalForce()	const btVector3& getTotalForce()
	{	{
	return m_totalForce;	return m_totalForce;
	};	};

	const btVector3& getTotalTorque()	const btVector3& getTotalTorque()
	{	{
	return m_totalTorque;	return m_totalTorque;

	skipping to change at line 258	skipping to change at line 267
	}	}

	void setSleepingThresholds(btScalar linear,btScalar angular)	void setSleepingThresholds(btScalar linear,btScalar angular)
	{	{
	m_linearSleepingThreshold = linear;	m_linearSleepingThreshold = linear;
	m_angularSleepingThreshold = angular;	m_angularSleepingThreshold = angular;
	}	}

	void applyTorque(const btVector3& torque)	void applyTorque(const btVector3& torque)
	{	{

	m_totalTorque += torque;	m_totalTorque += torque*m_angularFactor;
	}	}

	void applyForce(const btVector3& force, const btVector3& rel_pos)	void applyForce(const btVector3& force, const btVector3& rel_pos)
	{	{
	applyCentralForce(force);	applyCentralForce(force);

	applyTorque(rel_pos.cross(force)*m_angularFactor);	applyTorque(rel_pos.cross(force*m_linearFactor));
	}	}

	void applyCentralImpulse(const btVector3& impulse)	void applyCentralImpulse(const btVector3& impulse)
	{	{

	m_linearVelocity += impulse * m_inverseMass;	m_linearVelocity += impulse m_linearFactor m_inverseMass;
	}	}

	void applyTorqueImpulse(const btVector3& torque)	void applyTorqueImpulse(const btVector3& torque)
	{	{

	m_angularVelocity += m_invInertiaTensorWorld * torqu e;	m_angularVelocity += m_invInertiaTensorWorld * torqu e * m_angularFactor;
	}	}

	void applyImpulse(const btVector3& impulse, const btVector3& rel_pos )	void applyImpulse(const btVector3& impulse, const btVector3& rel_pos )
	{	{
	if (m_inverseMass != btScalar(0.))	if (m_inverseMass != btScalar(0.))
	{	{
	applyCentralImpulse(impulse);	applyCentralImpulse(impulse);
	if (m_angularFactor)	if (m_angularFactor)
	{	{

	applyTorqueImpulse(rel_pos.cross(impulse)*m_ angularFactor);	applyTorqueImpulse(rel_pos.cross(impulse*m_l inearFactor));
	}	}
	}	}
	}	}

	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
	SIMD_FORCE_INLINE void internalApplyImpulse(const btVector3& linearC omponent, const btVector3& angularComponent,btScalar impulseMagnitude)	SIMD_FORCE_INLINE void internalApplyImpulse(const btVector3& linearC omponent, const btVector3& angularComponent,btScalar impulseMagnitude)
	{	{
	if (m_inverseMass != btScalar(0.))	if (m_inverseMass != btScalar(0.))
	{	{

	m_linearVelocity += linearComponent*impulseMagnitude ;	m_linearVelocity += linearComponentm_linearFactori mpulseMagnitude;
	if (m_angularFactor)	if (m_angularFactor)
	{	{

	m_angularVelocity += angularComponentimpuls eMagnitudem_angularFactor;	m_angularVelocity += angularComponentm_angu larFactorimpulseMagnitude;
	}	}
	}	}
	}	}

	void clearForces()	void clearForces()
	{	{
	m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar (0.0));	m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar (0.0));
	m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScala r(0.0));	m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScala r(0.0));
	}	}


	skipping to change at line 439	skipping to change at line 448
	{	{
	m_optionalMotionState = motionState;	m_optionalMotionState = motionState;
	if (m_optionalMotionState)	if (m_optionalMotionState)
	motionState->getWorldTransform(m_worldTransform);	motionState->getWorldTransform(m_worldTransform);
	}	}

	//for experimental overriding of friction/contact solver func	//for experimental overriding of friction/contact solver func
	int m_contactSolverType;	int m_contactSolverType;
	int m_frictionSolverType;	int m_frictionSolverType;


	void setAngularFactor(btScalar angFac)	void setAngularFactor(const btVector3& angFac)
	{	{
	m_angularFactor = angFac;	m_angularFactor = angFac;
	}	}

	btScalar getAngularFactor() const
		void setAngularFactor(btScalar angFac)
		{
		m_angularFactor.setValue(angFac,angFac,angFac);
		}
		const btVector3& getAngularFactor() const
	{	{
	return m_angularFactor;	return m_angularFactor;
	}	}

	//is this rigidbody added to a btCollisionWorld/btDynamicsWorld/btBr oadphase?	//is this rigidbody added to a btCollisionWorld/btDynamicsWorld/btBr oadphase?
	bool isInWorld() const	bool isInWorld() const
	{	{
	return (getBroadphaseProxy() != 0);	return (getBroadphaseProxy() != 0);
	}	}


End of changes. 12 change blocks.
	11 lines changed or deleted	25 lines changed or added

	btScalar.h	btScalar.h
	/*	/*

	Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans http://continu ousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bullet.googlecode.com

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

	skipping to change at line 19	skipping to change at line 19

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef SIMD___SCALAR_H	#ifndef SIMD___SCALAR_H
	#define SIMD___SCALAR_H	#define SIMD___SCALAR_H

	#include <math.h>	#include <math.h>


	#include <stdlib.h>//size_t for MSVC 6.0	#include <stdlib.h>//size_t for MSVC 6.0


	#include <cstdlib>	#include <cstdlib>
	#include <cfloat>	#include <cfloat>
	#include <float.h>	#include <float.h>


	#define BT_BULLET_VERSION 274	/* SVN $Revision$ on $Date$ from http://bullet.googlecode.com*/
		#define BT_BULLET_VERSION 275

	inline int btGetVersion()	inline int btGetVersion()
	{	{
	return BT_BULLET_VERSION;	return BT_BULLET_VERSION;
	}	}

	#if defined(DEBUG) \|\| defined (_DEBUG)	#if defined(DEBUG) \|\| defined (_DEBUG)
	#define BT_DEBUG	#define BT_DEBUG
	#endif	#endif


	skipping to change at line 127	skipping to change at line 126
	#endif	#endif
	//btFullAssert is optional, slows down a lot	//btFullAssert is optional, slows down a lot
	#define btFullAssert(x)	#define btFullAssert(x)

	#define btLikely(_c) __builtin_expect((_c), 1)	#define btLikely(_c) __builtin_expect((_c), 1)
	#define btUnlikely(_c) __builtin_expect((_c), 0)	#define btUnlikely(_c) __builtin_expect((_c), 0)

	#else	#else
	//non-windows systems	//non-windows systems


		#if (defined (__APPLE__) && defined (__i386__) && (!defined (BT_USE_DOUBLE_
		PRECISION)))
		#define BT_USE_SSE
		#include <emmintrin.h>

		#define SIMD_FORCE_INLINE inline
		///@todo: check out alignment methods for other platforms/compilers
		#define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16)))
		#define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128)))
		#ifndef assert
		#include <assert.h>
		#endif

		#if defined(DEBUG) \|\| defined (_DEBUG)
		#define btAssert assert
		#else
		#define btAssert(x)
		#endif

		//btFullAssert is optional, slows down a lot
		#define btFullAssert(x)
		#define btLikely(_c) _c
		#define btUnlikely(_c) _c

		#else

	#define SIMD_FORCE_INLINE inline	#define SIMD_FORCE_INLINE inline
	///@todo: check out alignment methods for other platforms/co mpilers	///@todo: check out alignment methods for other platforms/co mpilers
	///#define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16)))	///#define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16)))
	///#define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128)))	///#define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128)))
	#define ATTRIBUTE_ALIGNED16(a) a	#define ATTRIBUTE_ALIGNED16(a) a
	#define ATTRIBUTE_ALIGNED128(a) a	#define ATTRIBUTE_ALIGNED128(a) a
	#ifndef assert	#ifndef assert
	#include <assert.h>	#include <assert.h>
	#endif	#endif

	#if defined(DEBUG) \|\| defined (_DEBUG)	#if defined(DEBUG) \|\| defined (_DEBUG)
	#define btAssert assert	#define btAssert assert
	#else	#else
	#define btAssert(x)	#define btAssert(x)
	#endif	#endif

	//btFullAssert is optional, slows down a lot	//btFullAssert is optional, slows down a lot
	#define btFullAssert(x)	#define btFullAssert(x)
	#define btLikely(_c) _c	#define btLikely(_c) _c
	#define btUnlikely(_c) _c	#define btUnlikely(_c) _c

		#endif //__APPLE__

	#endif // LIBSPE2	#endif // LIBSPE2

	#endif //__CELLOS_LV2__	#endif //__CELLOS_LV2__
	#endif	#endif


	/// older compilers (gcc 3.x) and Sun needs double version of sqrt etc.
	/// exclude Apple Intel (i's assumed to be a Macbook or new Intel Dual Core
	Processor)
	#if defined (__sun) \|\| defined (__sun__) \|\| defined (__sparc) \|\| (defined (
	__APPLE__) && ! defined (__i386__))
	//use slow double float precision operation on those platforms
	#ifndef BT_USE_DOUBLE_PRECISION
	#define BT_FORCE_DOUBLE_FUNCTIONS
	#endif
	#endif

	///The btScalar type abstracts floating point numbers, to easily switch bet ween double and single floating point precision.	///The btScalar type abstracts floating point numbers, to easily switch bet ween double and single floating point precision.
	#if defined(BT_USE_DOUBLE_PRECISION)	#if defined(BT_USE_DOUBLE_PRECISION)
	typedef double btScalar;	typedef double btScalar;

		//this number could be bigger in double precision
		#define BT_LARGE_FLOAT 1e30
	#else	#else
	typedef float btScalar;	typedef float btScalar;

		//keep BT_LARGE_FLOAT*BT_LARGE_FLOAT < FLT_MAX
		#define BT_LARGE_FLOAT 1e18f
	#endif	#endif

	#define BT_DECLARE_ALIGNED_ALLOCATOR() \	#define BT_DECLARE_ALIGNED_ALLOCATOR() \
	SIMD_FORCE_INLINE void* operator new(size_t sizeInBytes) { return btAl ignedAlloc(sizeInBytes,16); } \	SIMD_FORCE_INLINE void* operator new(size_t sizeInBytes) { return btAl ignedAlloc(sizeInBytes,16); } \
	SIMD_FORCE_INLINE void operator delete(void* ptr) { btAlignedFr ee(ptr); } \	SIMD_FORCE_INLINE void operator delete(void* ptr) { btAlignedFr ee(ptr); } \
	SIMD_FORCE_INLINE void* operator new(size_t, void* ptr) { return ptr; } \	SIMD_FORCE_INLINE void* operator new(size_t, void* ptr) { return ptr; } \
	SIMD_FORCE_INLINE void operator delete(void, void) { } \	SIMD_FORCE_INLINE void operator delete(void, void) { } \
	SIMD_FORCE_INLINE void* operator new[](size_t sizeInBytes) { return bt AlignedAlloc(sizeInBytes,16); } \	SIMD_FORCE_INLINE void* operator new[](size_t sizeInBytes) { return bt AlignedAlloc(sizeInBytes,16); } \
	SIMD_FORCE_INLINE void operator delete[](void* ptr) { btAligned Free(ptr); } \	SIMD_FORCE_INLINE void operator delete[](void* ptr) { btAligned Free(ptr); } \
	SIMD_FORCE_INLINE void* operator new[](size_t, void* ptr) { return ptr ; } \	SIMD_FORCE_INLINE void* operator new[](size_t, void* ptr) { return ptr ; } \

	skipping to change at line 193	skipping to change at line 213
	SIMD_FORCE_INLINE btScalar btCos(btScalar x) { return cos(x); }	SIMD_FORCE_INLINE btScalar btCos(btScalar x) { return cos(x); }
	SIMD_FORCE_INLINE btScalar btSin(btScalar x) { return sin(x); }	SIMD_FORCE_INLINE btScalar btSin(btScalar x) { return sin(x); }
	SIMD_FORCE_INLINE btScalar btTan(btScalar x) { return tan(x); }	SIMD_FORCE_INLINE btScalar btTan(btScalar x) { return tan(x); }
	SIMD_FORCE_INLINE btScalar btAcos(btScalar x) { return acos(x); }	SIMD_FORCE_INLINE btScalar btAcos(btScalar x) { return acos(x); }
	SIMD_FORCE_INLINE btScalar btAsin(btScalar x) { return asin(x); }	SIMD_FORCE_INLINE btScalar btAsin(btScalar x) { return asin(x); }
	SIMD_FORCE_INLINE btScalar btAtan(btScalar x) { return atan(x); }	SIMD_FORCE_INLINE btScalar btAtan(btScalar x) { return atan(x); }
	SIMD_FORCE_INLINE btScalar btAtan2(btScalar x, btScalar y) { return atan2(x , y); }	SIMD_FORCE_INLINE btScalar btAtan2(btScalar x, btScalar y) { return atan2(x , y); }
	SIMD_FORCE_INLINE btScalar btExp(btScalar x) { return exp(x); }	SIMD_FORCE_INLINE btScalar btExp(btScalar x) { return exp(x); }
	SIMD_FORCE_INLINE btScalar btLog(btScalar x) { return log(x); }	SIMD_FORCE_INLINE btScalar btLog(btScalar x) { return log(x); }
	SIMD_FORCE_INLINE btScalar btPow(btScalar x,btScalar y) { return pow(x,y); }	SIMD_FORCE_INLINE btScalar btPow(btScalar x,btScalar y) { return pow(x,y); }

		SIMD_FORCE_INLINE btScalar btFmod(btScalar x,btScalar y) { return fmod(x,y) ; }

	#else	#else

	SIMD_FORCE_INLINE btScalar btSqrt(btScalar y)	SIMD_FORCE_INLINE btScalar btSqrt(btScalar y)
	{	{
	#ifdef USE_APPROXIMATION	#ifdef USE_APPROXIMATION
	double x, z, tempf;	double x, z, tempf;
	unsigned long tfptr = ((unsigned long )&tempf) + 1;	unsigned long tfptr = ((unsigned long )&tempf) + 1;

	tempf = y;	tempf = y;

	skipping to change at line 230	skipping to change at line 251
	SIMD_FORCE_INLINE btScalar btAcos(btScalar x) {	SIMD_FORCE_INLINE btScalar btAcos(btScalar x) {
	btAssert(x <= btScalar(1.));	btAssert(x <= btScalar(1.));
	return acosf(x);	return acosf(x);
	}	}
	SIMD_FORCE_INLINE btScalar btAsin(btScalar x) { return asinf(x); }	SIMD_FORCE_INLINE btScalar btAsin(btScalar x) { return asinf(x); }
	SIMD_FORCE_INLINE btScalar btAtan(btScalar x) { return atanf(x); }	SIMD_FORCE_INLINE btScalar btAtan(btScalar x) { return atanf(x); }
	SIMD_FORCE_INLINE btScalar btAtan2(btScalar x, btScalar y) { return atan2f( x, y); }	SIMD_FORCE_INLINE btScalar btAtan2(btScalar x, btScalar y) { return atan2f( x, y); }
	SIMD_FORCE_INLINE btScalar btExp(btScalar x) { return expf(x); }	SIMD_FORCE_INLINE btScalar btExp(btScalar x) { return expf(x); }
	SIMD_FORCE_INLINE btScalar btLog(btScalar x) { return logf(x); }	SIMD_FORCE_INLINE btScalar btLog(btScalar x) { return logf(x); }
	SIMD_FORCE_INLINE btScalar btPow(btScalar x,btScalar y) { return powf(x,y); }	SIMD_FORCE_INLINE btScalar btPow(btScalar x,btScalar y) { return powf(x,y); }

		SIMD_FORCE_INLINE btScalar btFmod(btScalar x,btScalar y) { return fmodf(x,y ); }

	#endif	#endif

	#define SIMD_2_PI btScalar(6.283185307179586232)	#define SIMD_2_PI btScalar(6.283185307179586232)
	#define SIMD_PI (SIMD_2_PI * btScalar(0.5))	#define SIMD_PI (SIMD_2_PI * btScalar(0.5))
	#define SIMD_HALF_PI (SIMD_2_PI * btScalar(0.25))	#define SIMD_HALF_PI (SIMD_2_PI * btScalar(0.25))
	#define SIMD_RADS_PER_DEG (SIMD_2_PI / btScalar(360.0))	#define SIMD_RADS_PER_DEG (SIMD_2_PI / btScalar(360.0))
	#define SIMD_DEGS_PER_RAD (btScalar(360.0) / SIMD_2_PI)	#define SIMD_DEGS_PER_RAD (btScalar(360.0) / SIMD_2_PI)

		#define SIMDSQRT12 btScalar(0.7071067811865475244008443621048490)

		#define btRecipSqrt(x) ((btScalar)(btScalar(1.0)/btSqrt(btScalar(x))))
		/* reciprocal square root */

	#ifdef BT_USE_DOUBLE_PRECISION	#ifdef BT_USE_DOUBLE_PRECISION
	#define SIMD_EPSILON DBL_EPSILON	#define SIMD_EPSILON DBL_EPSILON
	#define SIMD_INFINITY DBL_MAX	#define SIMD_INFINITY DBL_MAX
	#else	#else
	#define SIMD_EPSILON FLT_EPSILON	#define SIMD_EPSILON FLT_EPSILON
	#define SIMD_INFINITY FLT_MAX	#define SIMD_INFINITY FLT_MAX
	#endif	#endif

	SIMD_FORCE_INLINE btScalar btAtan2Fast(btScalar y, btScalar x)	SIMD_FORCE_INLINE btScalar btAtan2Fast(btScalar y, btScalar x)

	skipping to change at line 422	skipping to change at line 447
	dst[2] = src[5];	dst[2] = src[5];
	dst[3] = src[4];	dst[3] = src[4];
	dst[4] = src[3];	dst[4] = src[3];
	dst[5] = src[2];	dst[5] = src[2];
	dst[6] = src[1];	dst[6] = src[1];
	dst[7] = src[0];	dst[7] = src[0];

	return d;	return d;
	}	}


		// returns normalized value in range [-SIMD_PI, SIMD_PI]
		SIMD_FORCE_INLINE btScalar btNormalizeAngle(btScalar angleInRadians)
		{
		angleInRadians = btFmod(angleInRadians, SIMD_2_PI);
		if(angleInRadians < -SIMD_PI)
		{
		return angleInRadians + SIMD_2_PI;
		}
		else if(angleInRadians > SIMD_PI)
		{
		return angleInRadians - SIMD_2_PI;
		}
		else
		{
		return angleInRadians;
		}
		}

		///rudimentary class to provide type info
		struct btTypedObject
		{
		btTypedObject(int objectType)
		:m_objectType(objectType)
		{
		}
		int m_objectType;
		inline int getObjectType() const
		{
		return m_objectType;
		}
		};
	#endif //SIMD___SCALAR_H	#endif //SIMD___SCALAR_H

End of changes. 13 change blocks.
	15 lines changed or deleted	71 lines changed or added

	btScaledBvhTriangleMeshShape.h	btScaledBvhTriangleMeshShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2008 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btSequentialImpulseConstraintSolver.h	btSequentialImpulseConstraintSolver.h

	skipping to change at line 24	skipping to change at line 24
	*/	*/

	#ifndef SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H	#ifndef SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
	#define SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H	#define SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H

	#include "btConstraintSolver.h"	#include "btConstraintSolver.h"
	class btIDebugDraw;	class btIDebugDraw;
	#include "btContactConstraint.h"	#include "btContactConstraint.h"
	#include "btSolverBody.h"	#include "btSolverBody.h"
	#include "btSolverConstraint.h"	#include "btSolverConstraint.h"

		#include "btTypedConstraint.h"
		#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h"

	///The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (iterative LCP) method.	///The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (iterative LCP) method.
	class btSequentialImpulseConstraintSolver : public btConstraintSolver	class btSequentialImpulseConstraintSolver : public btConstraintSolver
	{	{
	protected:	protected:

	btAlignedObjectArray<btSolverBody> m_tmpSolverBodyPool;	btAlignedObjectArray<btSolverBody> m_tmpSolverBodyPool;
	btConstraintArray m_tmpSolverContactConstraint Pool;	btConstraintArray m_tmpSolverContactConstraint Pool;
	btConstraintArray m_tmpSolverNonContactConstra intPool;	btConstraintArray m_tmpSolverNonContactConstra intPool;
	btConstraintArray m_tmpSolverContactFrictionCo nstraintPool;	btConstraintArray m_tmpSolverContactFrictionCo nstraintPool;
	btAlignedObjectArray<int> m_orderTmpConstraintPool;	btAlignedObjectArray<int> m_orderTmpConstraintPool;
	btAlignedObjectArray<int> m_orderFrictionConstraintPool;	btAlignedObjectArray<int> m_orderFrictionConstraintPool;

		btAlignedObjectArray<btTypedConstraint::btConstraintInfo1> m_tmpCons traintSizesPool;

	btSolverConstraint& addFrictionConstraint(const btVector3& norma lAxis,int solverBodyIdA,int solverBodyIdB,int frictionIndex,btManifoldPoint & cp,const btVector3& rel_pos1,const btVector3& rel_pos2,btCollisionObject* colObj0,btCollisionObject* colObj1, btScalar relaxation);	btSolverConstraint& addFrictionConstraint(const btVector3& norma lAxis,int solverBodyIdA,int solverBodyIdB,int frictionIndex,btManifoldPoint & cp,const btVector3& rel_pos1,const btVector3& rel_pos2,btCollisionObject* colObj0,btCollisionObject* colObj1, btScalar relaxation);

	///m_btSeed2 is used for re-arranging the constraint rows. improves convergence/quality of friction	///m_btSeed2 is used for re-arranging the constraint rows. improves convergence/quality of friction
	unsigned long m_btSeed2;	unsigned long m_btSeed2;

	void initSolverBody(btSolverBody* solverBody, btCollisionObject* collisionObject);	void initSolverBody(btSolverBody* solverBody, btCollisionObject* collisionObject);
	btScalar restitutionCurve(btScalar rel_vel, btScalar restitution);	btScalar restitutionCurve(btScalar rel_vel, btScalar restitution);

	void convertContact(btPersistentManifold* manifold,const btContac tSolverInfo& infoGlobal);	void convertContact(btPersistentManifold* manifold,const btContac tSolverInfo& infoGlobal);


		void resolveSplitPenetrationSIMD(
		btSolverBody& body1,
		btSolverBody& body2,
		const btSolverConstraint& contactConstraint);

	void resolveSplitPenetrationImpulseCacheFriendly(	void resolveSplitPenetrationImpulseCacheFriendly(
	btSolverBody& body1,	btSolverBody& body1,
	btSolverBody& body2,	btSolverBody& body2,

	const btSolverConstraint& contactConstraint,	const btSolverConstraint& contactConstraint);
	const btContactSolverInfo& solverInfo);

	//internal method	//internal method
	int getOrInitSolverBody(btCollisionObject& body);	int getOrInitSolverBody(btCollisionObject& body);

	void resolveSingleConstraintRowGeneric(btSolverBody& body1,btSolv erBody& body2,const btSolverConstraint& contactConstraint);	void resolveSingleConstraintRowGeneric(btSolverBody& body1,btSolv erBody& body2,const btSolverConstraint& contactConstraint);

	void resolveSingleConstraintRowGenericSIMD(btSolverBody& body1,bt SolverBody& body2,const btSolverConstraint& contactConstraint);	void resolveSingleConstraintRowGenericSIMD(btSolverBody& body1,bt SolverBody& body2,const btSolverConstraint& contactConstraint);

	void resolveSingleConstraintRowLowerLimit(btSolverBody& body1,btS olverBody& body2,const btSolverConstraint& contactConstraint);	void resolveSingleConstraintRowLowerLimit(btSolverBody& body1,btS olverBody& body2,const btSolverConstraint& contactConstraint);


End of changes. 4 change blocks.
	2 lines changed or deleted	9 lines changed or added

	btSimpleBroadphase.h	btSimpleBroadphase.h

	skipping to change at line 140	skipping to change at line 140
	{	{
	return m_pairCache;	return m_pairCache;
	}	}

	bool testAabbOverlap(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);	bool testAabbOverlap(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);

	///getAabb returns the axis aligned bounding box in the 'global' coo rdinate frame	///getAabb returns the axis aligned bounding box in the 'global' coo rdinate frame
	///will add some transform later	///will add some transform later
	virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax ) const	virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax ) const
	{	{

	aabbMin.setValue(-1e30f,-1e30f,-1e30f);	aabbMin.setValue(-BT_LARGE_FLOAT,-BT_LARGE_FLOAT,-BT_LARGE_F
	aabbMax.setValue(1e30f,1e30f,1e30f);	LOAT);
		aabbMax.setValue(BT_LARGE_FLOAT,BT_LARGE_FLOAT,BT_LARGE_FLOA
		T);
	}	}

	virtual void printStats()	virtual void printStats()
	{	{
	// printf("btSimpleBroadphase.h\n");	// printf("btSimpleBroadphase.h\n");
	// printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_m axHandles);	// printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_m axHandles);
	}	}
	};	};

	#endif //SIMPLE_BROADPHASE_H	#endif //SIMPLE_BROADPHASE_H

End of changes. 1 change blocks.
	2 lines changed or deleted	4 lines changed or added

	btSimpleDynamicsWorld.h	btSimpleDynamicsWorld.h

	skipping to change at line 59	skipping to change at line 59
	virtual int stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.));	virtual int stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.));

	virtual void setGravity(const btVector3& gravity);	virtual void setGravity(const btVector3& gravity);

	virtual btVector3 getGravity () const;	virtual btVector3 getGravity () const;

	virtual void addRigidBody(btRigidBody* body);	virtual void addRigidBody(btRigidBody* body);

	virtual void removeRigidBody(btRigidBody* body);	virtual void removeRigidBody(btRigidBody* body);


		///removeCollisionObject will first check if it is a rigid body, if
		so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObj
		ect
		virtual void removeCollisionObject(btCollisionObject* collisionOb
		ject);

	virtual void updateAabbs();	virtual void updateAabbs();

	virtual void synchronizeMotionStates();	virtual void synchronizeMotionStates();

	virtual void setConstraintSolver(btConstraintSolver* solver);	virtual void setConstraintSolver(btConstraintSolver* solver);

	virtual btConstraintSolver* getConstraintSolver();	virtual btConstraintSolver* getConstraintSolver();

	virtual btDynamicsWorldType getWorldType() const	virtual btDynamicsWorldType getWorldType() const
	{	{

End of changes. 1 change blocks.
	0 lines changed or deleted	6 lines changed or added

	btSliderConstraint.h	btSliderConstraint.h

	skipping to change at line 28	skipping to change at line 28
	April 04, 2008	April 04, 2008

	TODO:	TODO:
	- add clamping od accumulated impulse to improve stability	- add clamping od accumulated impulse to improve stability
	- add conversion for ODE constraint solver	- add conversion for ODE constraint solver
	*/	*/

	#ifndef SLIDER_CONSTRAINT_H	#ifndef SLIDER_CONSTRAINT_H
	#define SLIDER_CONSTRAINT_H	#define SLIDER_CONSTRAINT_H


	//-------------------------------------------------------------------------
	----

	#include "LinearMath/btVector3.h"	#include "LinearMath/btVector3.h"
	#include "btJacobianEntry.h"	#include "btJacobianEntry.h"
	#include "btTypedConstraint.h"	#include "btTypedConstraint.h"


	//-------------------------------------------------------------------------
	----

	class btRigidBody;	class btRigidBody;


	//-------------------------------------------------------------------------
	----

	#define SLIDER_CONSTRAINT_DEF_SOFTNESS (btScalar(1.0))	#define SLIDER_CONSTRAINT_DEF_SOFTNESS (btScalar(1.0))
	#define SLIDER_CONSTRAINT_DEF_DAMPING (btScalar(1.0))	#define SLIDER_CONSTRAINT_DEF_DAMPING (btScalar(1.0))
	#define SLIDER_CONSTRAINT_DEF_RESTITUTION (btScalar(0.7))	#define SLIDER_CONSTRAINT_DEF_RESTITUTION (btScalar(0.7))


	//-------------------------------------------------------------------------
	----

	class btSliderConstraint : public btTypedConstraint	class btSliderConstraint : public btTypedConstraint
	{	{
	protected:	protected:
	///for backwards compatibility during the transition to 'getInfo/get Info2'	///for backwards compatibility during the transition to 'getInfo/get Info2'
	bool m_useSolveConstraintObsolete;	bool m_useSolveConstraintObsolete;
	btTransform m_frameInA;	btTransform m_frameInA;
	btTransform m_frameInB;	btTransform m_frameInB;
	// use frameA fo define limits, if true	// use frameA fo define limits, if true
	bool m_useLinearReferenceFrameA;	bool m_useLinearReferenceFrameA;
	// linear limits	// linear limits

	skipping to change at line 129	skipping to change at line 121
	bool m_poweredAngMotor;	bool m_poweredAngMotor;
	btScalar m_targetAngMotorVelocity;	btScalar m_targetAngMotorVelocity;
	btScalar m_maxAngMotorForce;	btScalar m_maxAngMotorForce;
	btScalar m_accumulatedAngMotorImpulse;	btScalar m_accumulatedAngMotorImpulse;

	//------------------------	//------------------------
	void initParams();	void initParams();
	public:	public:
	// constructors	// constructors
	btSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransfor m& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);	btSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransfor m& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);

		btSliderConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameB);
	btSliderConstraint();	btSliderConstraint();
	// overrides	// overrides
	virtual void buildJacobian();	virtual void buildJacobian();
	virtual void getInfo1 (btConstraintInfo1* info);	virtual void getInfo1 (btConstraintInfo1* info);


		void getInfo1NonVirtual(btConstraintInfo1* info);

	virtual void getInfo2 (btConstraintInfo2* info);	virtual void getInfo2 (btConstraintInfo2* info);


		void getInfo2NonVirtual(btConstraintInfo2* info, const btTransform&
		transA, const btTransform& transB,const btVector3& linVelA,const btVector3&
		linVelB, btScalar rbAinvMass,btScalar rbBinvMass);

	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep);	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep);

	// access	// access
	const btRigidBody& getRigidBodyA() const { return m_rbA; }	const btRigidBody& getRigidBodyA() const { return m_rbA; }
	const btRigidBody& getRigidBodyB() const { return m_rbB; }	const btRigidBody& getRigidBodyB() const { return m_rbB; }
	const btTransform & getCalculatedTransformA() const { return m_calculat edTransformA; }	const btTransform & getCalculatedTransformA() const { return m_calculat edTransformA; }
	const btTransform & getCalculatedTransformB() const { return m_calculat edTransformB; }	const btTransform & getCalculatedTransformB() const { return m_calculat edTransformB; }
	const btTransform & getFrameOffsetA() const { return m_frameInA; }	const btTransform & getFrameOffsetA() const { return m_frameInA; }
	const btTransform & getFrameOffsetB() const { return m_frameInB; }	const btTransform & getFrameOffsetB() const { return m_frameInB; }
	btTransform & getFrameOffsetA() { return m_frameInA; }	btTransform & getFrameOffsetA() { return m_frameInA; }
	btTransform & getFrameOffsetB() { return m_frameInB; }	btTransform & getFrameOffsetB() { return m_frameInB; }
	btScalar getLowerLinLimit() { return m_lowerLinLimit; }	btScalar getLowerLinLimit() { return m_lowerLinLimit; }
	void setLowerLinLimit(btScalar lowerLimit) { m_lowerLinLimit = lowerLim it; }	void setLowerLinLimit(btScalar lowerLimit) { m_lowerLinLimit = lowerLim it; }
	btScalar getUpperLinLimit() { return m_upperLinLimit; }	btScalar getUpperLinLimit() { return m_upperLinLimit; }
	void setUpperLinLimit(btScalar upperLimit) { m_upperLinLimit = upperLim it; }	void setUpperLinLimit(btScalar upperLimit) { m_upperLinLimit = upperLim it; }
	btScalar getLowerAngLimit() { return m_lowerAngLimit; }	btScalar getLowerAngLimit() { return m_lowerAngLimit; }

	void setLowerAngLimit(btScalar lowerLimit) { m_lowerAngLimit = lowerLim it; }	void setLowerAngLimit(btScalar lowerLimit) { m_lowerAngLimit = btNormal izeAngle(lowerLimit); }
	btScalar getUpperAngLimit() { return m_upperAngLimit; }	btScalar getUpperAngLimit() { return m_upperAngLimit; }

	void setUpperAngLimit(btScalar upperLimit) { m_upperAngLimit = upperLim it; }	void setUpperAngLimit(btScalar upperLimit) { m_upperAngLimit = btNormal izeAngle(upperLimit); }
	bool getUseLinearReferenceFrameA() { return m_useLinearReferenceFram eA; }	bool getUseLinearReferenceFrameA() { return m_useLinearReferenceFram eA; }
	btScalar getSoftnessDirLin() { return m_softnessDirLin; }	btScalar getSoftnessDirLin() { return m_softnessDirLin; }
	btScalar getRestitutionDirLin() { return m_restitutionDirLin; }	btScalar getRestitutionDirLin() { return m_restitutionDirLin; }
	btScalar getDampingDirLin() { return m_dampingDirLin ; }	btScalar getDampingDirLin() { return m_dampingDirLin ; }
	btScalar getSoftnessDirAng() { return m_softnessDirAng; }	btScalar getSoftnessDirAng() { return m_softnessDirAng; }
	btScalar getRestitutionDirAng() { return m_restitutionDirAng; }	btScalar getRestitutionDirAng() { return m_restitutionDirAng; }
	btScalar getDampingDirAng() { return m_dampingDirAng; }	btScalar getDampingDirAng() { return m_dampingDirAng; }
	btScalar getSoftnessLimLin() { return m_softnessLimLin; }	btScalar getSoftnessLimLin() { return m_softnessLimLin; }
	btScalar getRestitutionLimLin() { return m_restitutionLimLin; }	btScalar getRestitutionLimLin() { return m_restitutionLimLin; }
	btScalar getDampingLimLin() { return m_dampingLimLin; }	btScalar getDampingLimLin() { return m_dampingLimLin; }

	skipping to change at line 215	skipping to change at line 212

	// access for ODE solver	// access for ODE solver
	bool getSolveLinLimit() { return m_solveLinLim; }	bool getSolveLinLimit() { return m_solveLinLim; }
	btScalar getLinDepth() { return m_depth[0]; }	btScalar getLinDepth() { return m_depth[0]; }
	bool getSolveAngLimit() { return m_solveAngLim; }	bool getSolveAngLimit() { return m_solveAngLim; }
	btScalar getAngDepth() { return m_angDepth; }	btScalar getAngDepth() { return m_angDepth; }
	// internal	// internal
	void buildJacobianInt(btRigidBody& rbA, btRigidBody& rbB, const b tTransform& frameInA, const btTransform& frameInB);	void buildJacobianInt(btRigidBody& rbA, btRigidBody& rbB, const b tTransform& frameInA, const btTransform& frameInB);
	void solveConstraintInt(btRigidBody& rbA, btSolverBody& bodyA,btR igidBody& rbB, btSolverBody& bodyB);	void solveConstraintInt(btRigidBody& rbA, btSolverBody& bodyA,btR igidBody& rbB, btSolverBody& bodyB);
	// shared code used by ODE solver	// shared code used by ODE solver

	void calculateTransforms(void);	void calculateTransforms(const btTransform& transA,const btTransf
	void testLinLimits(void);	orm& transB);
		void testLinLimits();
	void testLinLimits2(btConstraintInfo2* info);	void testLinLimits2(btConstraintInfo2* info);

	void testAngLimits(void);	void testAngLimits();
	// access for PE Solver	// access for PE Solver

	btVector3 getAncorInA(void);	btVector3 getAncorInA();
	btVector3 getAncorInB(void);	btVector3 getAncorInB();
	};	};


	//-------------------------------------------------------------------------
	----

	#endif //SLIDER_CONSTRAINT_H	#endif //SLIDER_CONSTRAINT_H

End of changes. 13 change blocks.
	22 lines changed or deleted	15 lines changed or added

	btSoftBody.h	btSoftBody.h

	skipping to change at line 112	skipping to change at line 112
	//	//
	// Flags	// Flags
	//	//

	///fCollision	///fCollision
	struct fCollision { enum _ {	struct fCollision { enum _ {
	RVSmask = 0x000f, ///Rigid versus soft mask	RVSmask = 0x000f, ///Rigid versus soft mask
	SDF_RS = 0x0001, ///SDF based rigid vs soft	SDF_RS = 0x0001, ///SDF based rigid vs soft
	CL_RS = 0x0002, ///Cluster vs convex rigid vs soft	CL_RS = 0x0002, ///Cluster vs convex rigid vs soft


	SVSmask = 0x00f0, ///Rigid versus soft mask	SVSmask = 0x0030, ///Rigid versus soft mask
	VF_SS = 0x0010, ///Vertex vs face soft vs soft handl ing	VF_SS = 0x0010, ///Vertex vs face soft vs soft handl ing
	CL_SS = 0x0020, ///Cluster vs cluster soft vs soft h andling	CL_SS = 0x0020, ///Cluster vs cluster soft vs soft h andling

		CL_SELF = 0x0040, ///Cluster soft body self collision
	/* presets */	/* presets */
	Default = SDF_RS,	Default = SDF_RS,
	END	END
	};};	};};

	///fMaterial	///fMaterial
	struct fMaterial { enum _ {	struct fMaterial { enum _ {
	DebugDraw = 0x0001, /// Enable debug draw	DebugDraw = 0x0001, /// Enable debug draw
	/* presets */	/* presets */
	Default = DebugDraw,	Default = DebugDraw,

	skipping to change at line 222	skipping to change at line 223
	btVector3 m_c3; // gradient	btVector3 m_c3; // gradient
	};	};
	/* Face */	/* Face */
	struct Face : Feature	struct Face : Feature
	{	{
	Node* m_n[3]; // Node pointers	Node* m_n[3]; // Node pointers
	btVector3 m_normal; // Normal	btVector3 m_normal; // Normal
	btScalar m_ra; // Rest area	btScalar m_ra; // Rest area
	btDbvtNode* m_leaf; // Leaf data	btDbvtNode* m_leaf; // Leaf data
	};	};

		/* Tetra */
		struct Tetra : Feature
		{
		Node* m_n[4];
		// Node pointers
		btScalar m_rv;
		// Rest volume
		btDbvtNode* m_leaf;
		// Leaf data
		btVector3 m_c0[4];
		// gradients
		btScalar m_c1;
		// (4*kVST)/(im0+im1+im2+im3)
		btScalar m_c2;
		// m_c1/sum(\|g0..3\|^2)
		};
	/* RContact */	/* RContact */
	struct RContact	struct RContact
	{	{
	sCti m_cti; // Contact infos	sCti m_cti; // Contact infos
	Node* m_node; // Owner node	Node* m_node; // Owner node
	btMatrix3x3 m_c0; // Impulse matrix	btMatrix3x3 m_c0; // Impulse matrix
	btVector3 m_c1; // Relative anchor	btVector3 m_c1; // Relative anchor
	btScalar m_c2; // ima*dt	btScalar m_c2; // ima*dt
	btScalar m_c3; // Friction	btScalar m_c3; // Friction
	btScalar m_c4; // Hardness	btScalar m_c4; // Hardness

	skipping to change at line 299	skipping to change at line 310
	btVector3 m_dimpulses[ 2];	btVector3 m_dimpulses[ 2];
	int m_nv impulses;	int m_nv impulses;
	int m_nd impulses;	int m_nd impulses;
	btVector3 m_lv;	btVector3 m_lv;
	btVector3 m_av;	btVector3 m_av;
	btDbvtNode* m_leaf;	btDbvtNode* m_leaf;
	btScalar m_ndamping; /* Node damping */	btScalar m_ndamping; /* Node damping */
	btScalar m_ldamping; /* Linear damping */	btScalar m_ldamping; /* Linear damping */
	btScalar m_adamping; /* Angular damping */	btScalar m_adamping; /* Angular damping */
	btScalar m_matching;	btScalar m_matching;

		btScalar m_maxSelfCol
		lisionImpulse;
		btScalar m_selfCollis
		ionImpulseFactor;
		bool m_containsAn
		chor;
	bool m_collide;	bool m_collide;
	int m_cl usterIndex;	int m_cl usterIndex;

	Cluster() : m_leaf(0),m_ndamping(0),m_ldamping(0),m_adamping	Cluster() : m_leaf(0),m_ndamping(0),m_ldamping(0),m_adamping
	(0),m_matching(0) {}	(0),m_matching(0)
		,m_maxSelfCollisionImpulse(100.f),
		m_selfCollisionImpulseFactor(0.01f),
		m_containsAnchor(false)
		{}
	};	};
	/* Impulse */	/* Impulse */
	struct Impulse	struct Impulse
	{	{
	btVector3 m_velocity;	btVector3 m_velocity;
	btVector3 m_drift;	btVector3 m_drift;
	int m_as Velocity:1;	int m_as Velocity:1;
	int m_as Drift:1;	int m_as Drift:1;
	Impulse() : m_velocity(0,0,0),m_drift(0,0,0),m_asVelocity(0) ,m_asDrift(0) {}	Impulse() : m_velocity(0,0,0),m_drift(0,0,0),m_asVelocity(0) ,m_asDrift(0) {}
	Impulse operator -() const	Impulse operator -() const

	skipping to change at line 372	skipping to change at line 390
	return(identity);	return(identity);
	}	}
	btVector3 linearVeloci ty() const	btVector3 linearVeloci ty() const
	{	{
	if(m_rigid) return(m_rigid->getLinearVelocity());	if(m_rigid) return(m_rigid->getLinearVelocity());
	if(m_soft) return(m_soft->m_lv);	if(m_soft) return(m_soft->m_lv);
	return(btVector3(0,0,0));	return(btVector3(0,0,0));
	}	}
	btVector3 angularVeloc ity(const btVector3& rpos) const	btVector3 angularVeloc ity(const btVector3& rpos) const
	{	{

	if(m_rigid) return(cross(m_rigid->getAngularVelocity	if(m_rigid) return(btCross(m_rigid->getAngularVeloci
	(),rpos));	ty(),rpos));
	if(m_soft) return(cross(m_soft->m_av,rpos));	if(m_soft) return(btCross(m_soft->m_av,rpos));
	return(btVector3(0,0,0));	return(btVector3(0,0,0));
	}	}
	btVector3 angularVeloc ity() const	btVector3 angularVeloc ity() const
	{	{
	if(m_rigid) return(m_rigid->getAngularVelocity());	if(m_rigid) return(m_rigid->getAngularVelocity());
	if(m_soft) return(m_soft->m_av);	if(m_soft) return(m_soft->m_av);
	return(btVector3(0,0,0));	return(btVector3(0,0,0));
	}	}
	btVector3 velocity(con st btVector3& rpos) const	btVector3 velocity(con st btVector3& rpos) const
	{	{

	skipping to change at line 398	skipping to change at line 416
	if(m_rigid) m_rigid->applyImpulse(impulse,rpos);	if(m_rigid) m_rigid->applyImpulse(impulse,rpos);
	if(m_soft) btSoftBody::clusterVImpulse(m_soft,r pos,impulse);	if(m_soft) btSoftBody::clusterVImpulse(m_soft,r pos,impulse);
	}	}
	void applyDImpuls e(const btVector3& impulse,const btVector3& rpos) const	void applyDImpuls e(const btVector3& impulse,const btVector3& rpos) const
	{	{
	if(m_rigid) m_rigid->applyImpulse(impulse,rpos);	if(m_rigid) m_rigid->applyImpulse(impulse,rpos);
	if(m_soft) btSoftBody::clusterDImpulse(m_soft,r pos,impulse);	if(m_soft) btSoftBody::clusterDImpulse(m_soft,r pos,impulse);
	}	}
	void applyImpulse (const Impulse& impulse,const btVector3& rpos) const	void applyImpulse (const Impulse& impulse,const btVector3& rpos) const
	{	{

	if(impulse.m_asVelocity) applyVImpulse(impuls	if(impulse.m_asVelocity)
	e.m_velocity,rpos);	{
	if(impulse.m_asDrift) applyDImpulse(impuls	// printf("impulse.m_velocity = %f,%f,%f\n",imp
	e.m_drift,rpos);	ulse.m_velocity.getX(),impulse.m_velocity.getY(),impulse.m_velocity.getZ())
		;
		applyVImpulse(impulse.m_velocity,rpos);
		}
		if(impulse.m_asDrift)
		{
		// printf("impulse.m_drift = %f,%f,%f\n",impuls
		e.m_drift.getX(),impulse.m_drift.getY(),impulse.m_drift.getZ());
		applyDImpulse(impulse.m_drift,rpos);
		}
	}	}
	void applyVAImpul se(const btVector3& impulse) const	void applyVAImpul se(const btVector3& impulse) const
	{	{
	if(m_rigid) m_rigid->applyTorqueImpulse(impulse) ;	if(m_rigid) m_rigid->applyTorqueImpulse(impulse) ;
	if(m_soft) btSoftBody::clusterVAImpulse(m_soft, impulse);	if(m_soft) btSoftBody::clusterVAImpulse(m_soft, impulse);
	}	}
	void applyDAImpul se(const btVector3& impulse) const	void applyDAImpul se(const btVector3& impulse) const
	{	{
	if(m_rigid) m_rigid->applyTorqueImpulse(impulse) ;	if(m_rigid) m_rigid->applyTorqueImpulse(impulse) ;
	if(m_soft) btSoftBody::clusterDAImpulse(m_soft, impulse);	if(m_soft) btSoftBody::clusterDAImpulse(m_soft, impulse);

	skipping to change at line 576	skipping to change at line 602
	//	//

	typedef void (psolver_t)(btSoftBody,btScalar,btScalar);	typedef void (psolver_t)(btSoftBody,btScalar,btScalar);
	typedef void (vsolver_t)(btSoftBody,btScalar);	typedef void (vsolver_t)(btSoftBody,btScalar);
	typedef btAlignedObjectArray<Cluster*> tClusterArray;	typedef btAlignedObjectArray<Cluster*> tClusterArray;
	typedef btAlignedObjectArray<Note> tNoteArray;	typedef btAlignedObjectArray<Note> tNoteArray;
	typedef btAlignedObjectArray<Node> tNodeArray;	typedef btAlignedObjectArray<Node> tNodeArray;
	typedef btAlignedObjectArray<btDbvtNode*> tLeafArray;	typedef btAlignedObjectArray<btDbvtNode*> tLeafArray;
	typedef btAlignedObjectArray<Link> tLinkArray;	typedef btAlignedObjectArray<Link> tLinkArray;
	typedef btAlignedObjectArray<Face> tFaceArray;	typedef btAlignedObjectArray<Face> tFaceArray;

		typedef btAlignedObjectArray<Tetra> tTetraArray;
	typedef btAlignedObjectArray<Anchor> tAnchorArray;	typedef btAlignedObjectArray<Anchor> tAnchorArray;
	typedef btAlignedObjectArray<RContact> tRContactArray;	typedef btAlignedObjectArray<RContact> tRContactArray;
	typedef btAlignedObjectArray<SContact> tSContactArray;	typedef btAlignedObjectArray<SContact> tSContactArray;
	typedef btAlignedObjectArray<Material*> tMaterialArray;	typedef btAlignedObjectArray<Material*> tMaterialArray;
	typedef btAlignedObjectArray<Joint*> tJointArray;	typedef btAlignedObjectArray<Joint*> tJointArray;
	typedef btAlignedObjectArray<btSoftBody*> tSoftBodyArray;	typedef btAlignedObjectArray<btSoftBody*> tSoftBodyArray;

	//	//
	// Fields	// Fields
	//	//

	Config m_cfg; // C onfiguration	Config m_cfg; // C onfiguration
	SolverState m_sst; // S olver state	SolverState m_sst; // S olver state
	Pose m_pose; // P ose	Pose m_pose; // P ose
	void* m_tag; // U ser data	void* m_tag; // U ser data
	btSoftBodyWorldInfo* m_worldInfo; // World info	btSoftBodyWorldInfo* m_worldInfo; // World info
	tNoteArray m_notes; // N otes	tNoteArray m_notes; // N otes
	tNodeArray m_nodes; // N odes	tNodeArray m_nodes; // N odes
	tLinkArray m_links; // L inks	tLinkArray m_links; // L inks
	tFaceArray m_faces; // F aces	tFaceArray m_faces; // F aces

		tTetraArray m_tetras; // T etras
	tAnchorArray m_anchors; // Anchors	tAnchorArray m_anchors; // Anchors
	tRContactArray m_rcontacts; // Rigid contacts	tRContactArray m_rcontacts; // Rigid contacts
	tSContactArray m_scontacts; // Soft contacts	tSContactArray m_scontacts; // Soft contacts
	tJointArray m_joints; // J oints	tJointArray m_joints; // J oints
	tMaterialArray m_materials; // Materials	tMaterialArray m_materials; // Materials
	btScalar m_timeacc; // T ime accumulator	btScalar m_timeacc; // T ime accumulator
	btVector3 m_bounds[2]; // Spatial b ounds	btVector3 m_bounds[2]; // Spatial b ounds
	bool m_bUpdateRtCst; // Update ru ntime constants	bool m_bUpdateRtCst; // Update ru ntime constants
	btDbvt m_ndbvt; // N odes tree	btDbvt m_ndbvt; // N odes tree
	btDbvt m_fdbvt; // F aces tree	btDbvt m_fdbvt; // F aces tree

	skipping to change at line 683	skipping to change at line 711
	void appendLink( Node* node0,	void appendLink( Node* node0,
	Node* node1,	Node* node1,
	Material* mat=0,	Material* mat=0,
	bool bcheckexist=false);	bool bcheckexist=false);
	/* Append face */	/* Append face */
	void appendFace(int model=-1,Material* ma t=0);	void appendFace(int model=-1,Material* ma t=0);
	void appendFace( int node0,	void appendFace( int node0,
	int node1,	int node1,
	int node2,	int node2,
	Material* mat=0);	Material* mat=0);

		void appendTetra(int model,Material* mat);
		//
		void appendTetra(int node0,

		int node1,

		int node2,

		int node3,

		Material* mat=0);

	/* Append anchor */	/* Append anchor */
	void appendAnchor( int node,	void appendAnchor( int node,
	btRigidBody* body, bool disableCollisionBetweenLinkedBodies= false);	btRigidBody* body, bool disableCollisionBetweenLinkedBodies= false);
	/* Append linear joint */	/* Append linear joint */
	void appendLinearJoint(const LJoint::Spec s& specs,Cluster* body0,Body body1);	void appendLinearJoint(const LJoint::Spec s& specs,Cluster* body0,Body body1);
	void appendLinearJoint(const LJoint::Spec s& specs,Body body=Body());	void appendLinearJoint(const LJoint::Spec s& specs,Body body=Body());
	void appendLinearJoint(const LJoint::Spec s& specs,btSoftBody* body);	void appendLinearJoint(const LJoint::Spec s& specs,btSoftBody* body);
	/* Append linear joint */	/* Append linear joint */
	void appendAngularJoint(const AJoint::Spe cs& specs,Cluster* body0,Body body1);	void appendAngularJoint(const AJoint::Spe cs& specs,Cluster* body0,Body body1);
	void appendAngularJoint(const AJoint::Spe cs& specs,Body body=Body());	void appendAngularJoint(const AJoint::Spe cs& specs,Body body=Body());

	skipping to change at line 720	skipping to change at line 756
	btScalar mass);	btScalar mass);
	/* Get mass */	/* Get mass */
	btScalar getMass( int node) co nst;	btScalar getMass( int node) co nst;
	/* Get total mass */	/* Get total mass */
	btScalar getTotalMass() const;	btScalar getTotalMass() const;
	/* Set total mass (weighted by previous masses) */	/* Set total mass (weighted by previous masses) */
	void setTotalMass( btScalar mass,	void setTotalMass( btScalar mass,
	bool fromfaces=false);	bool fromfaces=false);
	/* Set total density */	/* Set total density */
	void setTotalDensity(btScalar density);	void setTotalDensity(btScalar density);

		/* Set volume mass (using tetrahedrons)
		*/
		void setVolumeMass( btScalar mas
		s);
		/* Set volume density (using tetrahedrons)
		*/
		void setVolumeDensity( btScalar den
		sity);
	/* Transform */	/* Transform */
	void transform( const btTran sform& trs);	void transform( const btTran sform& trs);
	/* Translate */	/* Translate */
	void translate( const btVect or3& trs);	void translate( const btVect or3& trs);
	/* Rotate */	/* Rotate */
	void rotate( const btQuaternion& rot);	void rotate( const btQuaternion& rot);
	/* Scale */	/* Scale */
	void scale( const btVector3& scl);	void scale( const btVector3& scl);
	/* Set current state as pose */	/* Set current state as pose */
	void setPose( bool bvolume ,	void setPose( bool bvolume ,

	skipping to change at line 757	skipping to change at line 797
	static void clusterDCImpulse(Cluster* cluster,co nst btVector3& impulse);	static void clusterDCImpulse(Cluster* cluster,co nst btVector3& impulse);
	/* Generate bending constraints based on distance in the adjency gra ph */	/* Generate bending constraints based on distance in the adjency gra ph */
	int generateBendingConstraints( int distance,	int generateBendingConstraints( int distance,
	Material* mat=0);	Material* mat=0);
	/* Randomize constraints to reduce solver bias */	/* Randomize constraints to reduce solver bias */
	void randomizeConstraints();	void randomizeConstraints();
	/* Release clusters */	/* Release clusters */
	void releaseCluster(int index);	void releaseCluster(int index);
	void releaseClusters();	void releaseClusters();
	/* Generate clusters (K-mean) */	/* Generate clusters (K-mean) */

		///generateClusters with k=0 will create a convex cluster for each t
		etrahedron or triangle
		///otherwise an approximation will be used (better performance)
	int generateClusters(int k,int m axiterations=8192);	int generateClusters(int k,int m axiterations=8192);
	/* Refine */	/* Refine */
	void refine(ImplicitFn* ifn,btScalar accu rary,bool cut);	void refine(ImplicitFn* ifn,btScalar accu rary,bool cut);
	/* CutLink */	/* CutLink */
	bool cutLink(int node0,int node1,btScalar position);	bool cutLink(int node0,int node1,btScalar position);
	bool cutLink(const Node* node0,const Node * node1,btScalar position);	bool cutLink(const Node* node0,const Node * node1,btScalar position);

	///Ray casting using rayFrom and rayTo in worldspace, (not direction !)	///Ray casting using rayFrom and rayTo in worldspace, (not direction !)
	bool rayTest(const btVector3& rayFrom,	bool rayTest(const btVector3& rayFrom,
	const btVector3& rayTo,	const btVector3& rayTo,

End of changes. 12 change blocks.
	10 lines changed or deleted	71 lines changed or added

	btSoftBodyHelpers.h	btSoftBodyHelpers.h

	skipping to change at line 117	skipping to change at line 117
	int res);	int res);
	/* Create from trimesh */	/* Create from trimesh */
	static btSoftBody* CreateFromTriMesh( btSoftBodyWo rldInfo& worldInfo,	static btSoftBody* CreateFromTriMesh( btSoftBodyWo rldInfo& worldInfo,
	const btScalar* vertices,	const btScalar* vertices,
	const int* triangles,	const int* triangles,
	int ntriangles);	int ntriangles);
	/* Create from convex-hull */	/* Create from convex-hull */
	static btSoftBody* CreateFromConvexHull( btSoftBodyWo rldInfo& worldInfo,	static btSoftBody* CreateFromConvexHull( btSoftBodyWo rldInfo& worldInfo,
	const btVector3* vertices,	const btVector3* vertices,
	int nvertices);	int nvertices);


		/* Export TetGen compatible .smesh file
		*/
		static void ExportAsSMeshFile( btSo
		ftBody* psb,

		const char* filename);
		/* Create from TetGen .ele, .face, .node files
		*/
		static btSoftBody* CreateFromTetGenFile( btSoftBodyWo
		rldInfo& worldInfo,

		const char* ele,

		const char* face,

		const char* node,

		bool bfacelinks,

		bool btetralinks,

		bool bfacesfromtetras);
		/* Create from TetGen .ele, .face, .node data
		*/
		static btSoftBody* CreateFromTetGenData( btSoftBodyWo
		rldInfo& worldInfo,

		const char* ele,

		const char* face,

		const char* node,

		bool bfacelinks,

		bool btetralinks,

		bool bfacesfromtetras);

	};	};

	#endif //SOFT_BODY_HELPERS_H	#endif //SOFT_BODY_HELPERS_H

End of changes. 1 change blocks.
	0 lines changed or deleted	40 lines changed or added

	btSoftBodyInternals.h	btSoftBodyInternals.h

	skipping to change at line 125	skipping to change at line 125
	class btSoftClusterCollisionShape : public btConvexInternalShape	class btSoftClusterCollisionShape : public btConvexInternalShape
	{	{
	public:	public:
	const btSoftBody::Cluster* m_cluster;	const btSoftBody::Cluster* m_cluster;

	btSoftClusterCollisionShape (const btSoftBody::Cluster* cluster) : m _cluster(cluster) { setMargin(0); }	btSoftClusterCollisionShape (const btSoftBody::Cluster* cluster) : m _cluster(cluster) { setMargin(0); }

	virtual btVector3 localGetSupportingVertex(const btVector3& ve c) const	virtual btVector3 localGetSupportingVertex(const btVector3& ve c) const
	{	{
	btSoftBody::Node* const * n=&m_cluster->m_nodes[0];	btSoftBody::Node* const * n=&m_cluster->m_nodes[0];

	btScalar d=dot(vec,n[0]->m_x);	btScalar d=btDot(vec,n[0]->m_x);
	int j=0;	int j=0;
	for(int i=1,ni=m_cluster->m_nodes.size();i<ni;++i)	for(int i=1,ni=m_cluster->m_nodes.size();i<ni;++i)
	{	{

	const btScalar k=dot(vec,n[i]->m_x);	const btScalar k=btDot(vec,n[i]->m_x);
	if(k>d) { d=k;j=i; }	if(k>d) { d=k;j=i; }
	}	}
	return(n[j]->m_x);	return(n[j]->m_x);
	}	}
	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec)const	virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec)const
	{	{
	return(localGetSupportingVertex(vec));	return(localGetSupportingVertex(vec));
	}	}
	//notice that the vectors should be unit length	//notice that the vectors should be unit length
	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(co nst btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(co nst btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const

	skipping to change at line 296	skipping to change at line 296
	static inline btMatrix3x3 Mul(const btMatrix3x3& a,	static inline btMatrix3x3 Mul(const btMatrix3x3& a,
	btScalar b)	btScalar b)
	{	{
	btMatrix3x3 r;	btMatrix3x3 r;
	for(int i=0;i<3;++i) r[i]=a[i]*b;	for(int i=0;i<3;++i) r[i]=a[i]*b;
	return(r);	return(r);
	}	}
	//	//
	static inline void Orthogonalize(btMatrix3x3& m)	static inline void Orthogonalize(btMatrix3x3& m)
	{	{

	m[2]=cross(m[0],m[1]).normalized();	m[2]=btCross(m[0],m[1]).normalized();
	m[1]=cross(m[2],m[0]).normalized();	m[1]=btCross(m[2],m[0]).normalized();
	m[0]=cross(m[1],m[2]).normalized();	m[0]=btCross(m[1],m[2]).normalized();
	}	}
	//	//
	static inline btMatrix3x3 MassMatrix(btScalar im,const btMatrix3x3& iw i,const btVector3& r)	static inline btMatrix3x3 MassMatrix(btScalar im,const btMatrix3x3& iw i,const btVector3& r)
	{	{
	const btMatrix3x3 cr=Cross(r);	const btMatrix3x3 cr=Cross(r);
	return(Sub(Diagonal(im),criwicr));	return(Sub(Diagonal(im),criwicr));
	}	}

	//	//
	static inline btMatrix3x3 ImpulseMatrix( btScalar dt,	static inline btMatrix3x3 ImpulseMatrix( btScalar dt,

	skipping to change at line 335	skipping to change at line 335
	static inline btMatrix3x3 AngularImpulseMatrix( const btMatrix3x3& i ia,	static inline btMatrix3x3 AngularImpulseMatrix( const btMatrix3x3& i ia,
	const btMatrix3x3& iib)	const btMatrix3x3& iib)
	{	{
	return(Add(iia,iib).inverse());	return(Add(iia,iib).inverse());
	}	}

	//	//
	static inline btVector3 ProjectOnAxis( const btVector3& v,	static inline btVector3 ProjectOnAxis( const btVector3& v,
	const btVector3& a)	const btVector3& a)
	{	{

	return(a*dot(v,a));	return(a*btDot(v,a));
	}	}
	//	//
	static inline btVector3 ProjectOnPlane( const btVector3& v,	static inline btVector3 ProjectOnPlane( const btVector3& v,
	const btVector3& a)	const btVector3& a)
	{	{
	return(v-ProjectOnAxis(v,a));	return(v-ProjectOnAxis(v,a));
	}	}

	//	//
	static inline void ProjectOrigin( const btVector3& a,	static inline void ProjectOrigin( const btVector3& a,
	const btVector3& b,	const btVector3& b,
	btVector3& prj,	btVector3& prj,
	btScalar& sqd)	btScalar& sqd)
	{	{
	const btVector3 d=b-a;	const btVector3 d=b-a;
	const btScalar m2=d.length2();	const btScalar m2=d.length2();
	if(m2>SIMD_EPSILON)	if(m2>SIMD_EPSILON)
	{	{

	const btScalar t=Clamp<btScalar>(-dot(a,d)/m2,0,1);	const btScalar t=Clamp<btScalar>(-btDot(a,d)/m2,0,1);
	const btVector3 p=a+d*t;	const btVector3 p=a+d*t;
	const btScalar l2=p.length2();	const btScalar l2=p.length2();
	if(l2<sqd)	if(l2<sqd)
	{	{
	prj=p;	prj=p;
	sqd=l2;	sqd=l2;
	}	}
	}	}
	}	}
	//	//
	static inline void ProjectOrigin( const btVector3& a,	static inline void ProjectOrigin( const btVector3& a,
	const btVector3& b,	const btVector3& b,
	const btVector3& c,	const btVector3& c,
	btVector3& prj,	btVector3& prj,
	btScalar& sqd)	btScalar& sqd)
	{	{

	const btVector3& q=cross(b-a,c-a);	const btVector3& q=btCross(b-a,c-a);
	const btScalar m2=q.length2();	const btScalar m2=q.length2();
	if(m2>SIMD_EPSILON)	if(m2>SIMD_EPSILON)
	{	{
	const btVector3 n=q/btSqrt(m2);	const btVector3 n=q/btSqrt(m2);

	const btScalar k=dot(a,n);	const btScalar k=btDot(a,n);
	const btScalar k2=k*k;	const btScalar k2=k*k;
	if(k2<sqd)	if(k2<sqd)
	{	{
	const btVector3 p=n*k;	const btVector3 p=n*k;

	if( (dot(cross(a-p,b-p),q)>0)&&	if( (btDot(btCross(a-p,b-p),q)>0)&&
	(dot(cross(b-p,c-p),q)>0)&&	(btDot(btCross(b-p,c-p),q)>0)&&
	(dot(cross(c-p,a-p),q)>0))	(btDot(btCross(c-p,a-p),q)>0))
	{	{
	prj=p;	prj=p;
	sqd=k2;	sqd=k2;
	}	}
	else	else
	{	{
	ProjectOrigin(a,b,prj,sqd);	ProjectOrigin(a,b,prj,sqd);
	ProjectOrigin(b,c,prj,sqd);	ProjectOrigin(b,c,prj,sqd);
	ProjectOrigin(c,a,prj,sqd);	ProjectOrigin(c,a,prj,sqd);
	}	}

	skipping to change at line 413	skipping to change at line 413
	con st btVector3& coord)	con st btVector3& coord)
	{	{
	return(acoord.x()+bcoord.y()+c*coord.z());	return(acoord.x()+bcoord.y()+c*coord.z());
	}	}
	//	//
	static inline btVector3 BaryCoord( const btVector3& a,	static inline btVector3 BaryCoord( const btVector3& a,
	co nst btVector3& b,	co nst btVector3& b,
	co nst btVector3& c,	co nst btVector3& c,
	co nst btVector3& p)	co nst btVector3& p)
	{	{

	const btScalar w[]={ cross(a-p,b-p).length(),	const btScalar w[]={ btCross(a-p,b-p).length(),
	cross(b-p,c-p).length(),	btCross(b-p,c-p).length(),
	cross(c-p,a-p).length()};	btCross(c-p,a-p).length()};
	const btScalar isum=1/(w[0]+w[1]+w[2]);	const btScalar isum=1/(w[0]+w[1]+w[2]);
	return(btVector3(w[1]isum,w[2]isum,w[0]*isum));	return(btVector3(w[1]isum,w[2]isum,w[0]*isum));
	}	}

	//	//
	static btScalar ImplicitSolve( btSoftBody:: ImplicitFn* fn,	static btScalar ImplicitSolve( btSoftBody:: ImplicitFn* fn,
	const btVector3& a,	const btVector3& a,
	const btVector3& b,	const btVector3& b,
	const btScalar accuracy,	const btScalar accuracy,
	const int maxiterations=256)	const int maxiterations=256)

	skipping to change at line 485	skipping to change at line 485
	return((f.m_n[0]->m_x+f.m_n[1]->m_x+f.m_n[2]->m_x)/3);	return((f.m_n[0]->m_x+f.m_n[1]->m_x+f.m_n[2]->m_x)/3);
	}	}

	//	//
	static inline btScalar AreaOf( const btVector3& x0,	static inline btScalar AreaOf( const btVector3& x0,
	c onst btVector3& x1,	c onst btVector3& x1,
	c onst btVector3& x2)	c onst btVector3& x2)
	{	{
	const btVector3 a=x1-x0;	const btVector3 a=x1-x0;
	const btVector3 b=x2-x0;	const btVector3 b=x2-x0;

	const btVector3 cr=cross(a,b);	const btVector3 cr=btCross(a,b);
	const btScalar area=cr.length();	const btScalar area=cr.length();
	return(area);	return(area);
	}	}

	//	//
	static inline btScalar VolumeOf( const btVector3& x0,	static inline btScalar VolumeOf( const btVector3& x0,
	con st btVector3& x1,	con st btVector3& x1,
	con st btVector3& x2,	con st btVector3& x2,
	con st btVector3& x3)	con st btVector3& x3)
	{	{
	const btVector3 a=x1-x0;	const btVector3 a=x1-x0;
	const btVector3 b=x2-x0;	const btVector3 b=x2-x0;
	const btVector3 c=x3-x0;	const btVector3 c=x3-x0;

	return(dot(a,cross(b,c)));	return(btDot(a,btCross(b,c)));
	}	}

	//	//
	static void EvaluateMedium( const btSoft BodyWorldInfo* wfi,	static void EvaluateMedium( const btSoft BodyWorldInfo* wfi,
	const btVector3& x,	const btVector3& x,
	btSoftBody::sMedium& medium)	btSoftBody::sMedium& medium)
	{	{
	medium.m_velocity = btVector3(0,0,0);	medium.m_velocity = btVector3(0,0,0);
	medium.m_pressure = 0;	medium.m_pressure = 0;
	medium.m_density = wfi->air_density;	medium.m_density = wfi->air_density;
	if(wfi->water_density>0)	if(wfi->water_density>0)
	{	{

	const btScalar depth=-(dot(x,wfi->water_normal)+wfi->water_ offset);	const btScalar depth=-(btDot(x,wfi->water_normal)+wfi->wate r_offset);
	if(depth>0)	if(depth>0)
	{	{
	medium.m_density = wfi->water_density;	medium.m_density = wfi->water_density;
	medium.m_pressure = depthwfi->water_den sitywfi->m_gravity.length();	medium.m_pressure = depthwfi->water_den sitywfi->m_gravity.length();
	}	}
	}	}
	}	}

	//	//
	static inline void ApplyClampedForce( btSoftBody:: Node& n,	static inline void ApplyClampedForce( btSoftBody:: Node& n,

	skipping to change at line 654	skipping to change at line 654
	//	//
	struct btSoftColliders	struct btSoftColliders
	{	{
	//	//
	// ClusterBase	// ClusterBase
	//	//
	struct ClusterBase : btDbvt::ICollide	struct ClusterBase : btDbvt::ICollide
	{	{
	btScalar erp;	btScalar erp;
	btScalar idt;	btScalar idt;

	btScalar margin;	btScalar m_margin;
	btScalar friction;	btScalar friction;
	btScalar threshold;	btScalar threshold;
	ClusterBase()	ClusterBase()
	{	{
	erp =(btScalar)1;	erp =(btScalar)1;
	idt =0;	idt =0;

	margin =0;	m_margin =0;
	friction =0;	friction =0;
	threshold =(btScalar)0;	threshold =(btScalar)0;
	}	}
	bool SolveContact( const btGjkE paSolver2::sResults& res,	bool SolveContact( const btGjkE paSolver2::sResults& res,
	btSoftBody::Body ba,btSoftBody::Body bb,	btSoftBody::Body ba,btSoftBody::Body bb,
	btSoftBody::CJoint& joint)	btSoftBody::CJoint& joint)
	{	{

	if(res.distance<margin)	if(res.distance<m_margin)
	{	{

		btVector3 norm = res.normal;
		norm.normalize();//is it necessary?

	const btVector3 ra=res.witnesses[0]- ba.xform().getOrigin();	const btVector3 ra=res.witnesses[0]- ba.xform().getOrigin();
	const btVector3 rb=res.witnesses[1]- bb.xform().getOrigin();	const btVector3 rb=res.witnesses[1]- bb.xform().getOrigin();
	const btVector3 va=ba.velocity(ra);	const btVector3 va=ba.velocity(ra);
	const btVector3 vb=bb.velocity(rb);	const btVector3 vb=bb.velocity(rb);
	const btVector3 vrel=va-vb;	const btVector3 vrel=va-vb;

	const btScalar rvac=dot(vrel,res.no	const btScalar rvac=btDot(vrel,norm
	rmal);	);
	const btScalar depth=res.distance-m	btScalar depth=res.distance-m
	argin;	_margin;
	const btVector3 iv=res.normal*rvac;
		// printf("depth=%f\n",depth);
		const btVector3 iv=norm*rvac;
	const btVector3 fv=vrel-iv;	const btVector3 fv=vrel-iv;
	joint.m_bodies[0] = ba;	joint.m_bodies[0] = ba;
	joint.m_bodies[1] = bb;	joint.m_bodies[1] = bb;
	joint.m_refs[0] = ra*ba.xform( ).getBasis();	joint.m_refs[0] = ra*ba.xform( ).getBasis();
	joint.m_refs[1] = rb*bb.xform( ).getBasis();	joint.m_refs[1] = rb*bb.xform( ).getBasis();
	joint.m_rpos[0] = ra;	joint.m_rpos[0] = ra;
	joint.m_rpos[1] = rb;	joint.m_rpos[1] = rb;
	joint.m_cfm = 1;	joint.m_cfm = 1;
	joint.m_erp = 1;	joint.m_erp = 1;
	joint.m_life = 0;	joint.m_life = 0;
	joint.m_maxlife = 0;	joint.m_maxlife = 0;
	joint.m_split = 1;	joint.m_split = 1;

	joint.m_drift = depth*res.no
	rmal;	joint.m_drift = depth*norm;
	joint.m_normal = res.normal;
		joint.m_normal = norm;
		// printf("normal=%f,%f,%f\n",res.normal.getX()
		,res.normal.getY(),res.normal.getZ());
	joint.m_delete = false;	joint.m_delete = false;
	joint.m_friction = fv.length2() <(-rvac*friction)?1:friction;	joint.m_friction = fv.length2() <(-rvac*friction)?1:friction;
	joint.m_massmatrix = ImpulseMatri x( ba.invMass(),ba.invWorldInertia(),joint.m_rpos[0],	joint.m_massmatrix = ImpulseMatri x( ba.invMass(),ba.invWorldInertia(),joint.m_rpos[0],
	bb.invMass(),bb.invWorldInertia(),jo int.m_rpos[1]);	bb.invMass(),bb.invWorldInertia(),jo int.m_rpos[1]);


	return(true);	return(true);
	}	}
	return(false);	return(false);
	}	}
	};	};
	//	//
	// CollideCL_RS	// CollideCL_RS
	//	//
	struct CollideCL_RS : ClusterBase	struct CollideCL_RS : ClusterBase
	{	{

	skipping to change at line 714	skipping to change at line 723
	//	//
	struct CollideCL_RS : ClusterBase	struct CollideCL_RS : ClusterBase
	{	{
	btSoftBody* psb;	btSoftBody* psb;

	btCollisionObject* m_colObj;	btCollisionObject* m_colObj;
	void Process(const btDbvtNode* leaf)	void Process(const btDbvtNode* leaf)
	{	{
	btSoftBody::Cluster* cluster=(btSoftBody: :Cluster*)leaf->data;	btSoftBody::Cluster* cluster=(btSoftBody: :Cluster*)leaf->data;
	btSoftClusterCollisionShape cshape(cluster);	btSoftClusterCollisionShape cshape(cluster);


	const btConvexShape* rshape=(const btConv exShape*)m_colObj->getCollisionShape();	const btConvexShape* rshape=(const btConv exShape*)m_colObj->getCollisionShape();


		///don't collide an anchored cluster with a static/k
		inematic object
		if(m_colObj->isStaticOrKinematicObject() && cluster-
		>m_containsAnchor)
		return;

	btGjkEpaSolver2::sResults res;	btGjkEpaSolver2::sResults res;
	if(btGjkEpaSolver2::SignedDistance( &cshape,btTr ansform::getIdentity(),	if(btGjkEpaSolver2::SignedDistance( &cshape,btTr ansform::getIdentity(),
	rshape,m_colObj->getInterpolationWorldTransf orm(),	rshape,m_colObj->getInterpolationWorldTransf orm(),
	btVector3(1,0,0),res))	btVector3(1,0,0),res))
	{	{
	btSoftBody::CJoint joint;	btSoftBody::CJoint joint;
	if(SolveContact(res,cluster,m_colObj,joint)) //prb,joint))	if(SolveContact(res,cluster,m_colObj,joint)) //prb,joint))
	{	{
	btSoftBody::CJoint* pj=new(btAli gnedAlloc(sizeof(btSoftBody::CJoint),16)) btSoftBody::CJoint();	btSoftBody::CJoint* pj=new(btAli gnedAlloc(sizeof(btSoftBody::CJoint),16)) btSoftBody::CJoint();
	*pj=joint;psb->m_joints.push_back(pj );	*pj=joint;psb->m_joints.push_back(pj );

	skipping to change at line 743	skipping to change at line 758
	pj->m_split *= psb- >m_cfg.kSR_SPLT_CL;	pj->m_split *= psb- >m_cfg.kSR_SPLT_CL;
	}	}
	}	}
	}	}
	}	}
	void Process(btSoftBody* ps,btCollisionObject* co lOb)	void Process(btSoftBody* ps,btCollisionObject* co lOb)
	{	{
	psb = ps;	psb = ps;
	m_colObj = colOb;	m_colObj = colOb;
	idt = ps->m_sst.isdt;	idt = ps->m_sst.isdt;

	margin = m_colObj->getCollisionShape( )->getMargin();	m_margin = m_colObj->getCollisi onShape()->getMargin()+psb->getCollisionShape()->getMargin();
	///Bullet rigid body uses multiply instead of minimu m to determine combined friction. Some customization would be useful.	///Bullet rigid body uses multiply instead of minimu m to determine combined friction. Some customization would be useful.
	friction = btMin(psb->m_cfg.kDF,m_colOb j->getFriction());	friction = btMin(psb->m_cfg.kDF,m_colOb j->getFriction());
	btVector3 mins;	btVector3 mins;
	btVector3 maxs;	btVector3 maxs;

	ATTRIBUTE_ALIGNED16(btDbvtVolume) volu me;	ATTRIBUTE_ALIGNED16(btDbvtVolume) volu me;
	colOb->getCollisionShape()->getAabb(colOb->getInterp olationWorldTransform(),mins,maxs);	colOb->getCollisionShape()->getAabb(colOb->getInterp olationWorldTransform(),mins,maxs);
	volume=btDbvtVolume::FromMM(mins,maxs);	volume=btDbvtVolume::FromMM(mins,maxs);

	volume.Expand(btVector3(1,1,1)*margin);	volume.Expand(btVector3(1,1,1)*m_margin);
	ps->m_cdbvt.collideTV(ps->m_cdbvt.m_root,volume,*thi s);	ps->m_cdbvt.collideTV(ps->m_cdbvt.m_root,volume,*thi s);
	}	}
	};	};
	//	//
	// CollideCL_SS	// CollideCL_SS
	//	//
	struct CollideCL_SS : ClusterBase	struct CollideCL_SS : ClusterBase
	{	{
	btSoftBody* bodies[2];	btSoftBody* bodies[2];
	void Process(const btDbvtNode* la,const btDbvtNod e* lb)	void Process(const btDbvtNode* la,const btDbvtNod e* lb)

	skipping to change at line 802	skipping to change at line 817
	{	{
	static int count=0;	static int count=0;
	count++;	count++;
	//printf("count=%d\n",count);	//printf("count=%d\n",count);

	}	}
	}	}
	void Process(btSoftBody* psa,btSoftBody* psb)	void Process(btSoftBody* psa,btSoftBody* psb)
	{	{
	idt = psa->m_sst.isdt;	idt = psa->m_sst.isdt;

	margin = (psa->getCollisionShape()->g	//m_margin = (psa->getCollisionSh
	etMargin()+psb->getCollisionShape()->getMargin())/2;	ape()->getMargin()+psb->getCollisionShape()->getMargin())/2;
		m_margin = (psa->getCollisionSh
		ape()->getMargin()+psb->getCollisionShape()->getMargin());
	friction = btMin(psa->m_cfg.kDF,psb->m_ cfg.kDF);	friction = btMin(psa->m_cfg.kDF,psb->m_ cfg.kDF);
	bodies[0] = psa;	bodies[0] = psa;
	bodies[1] = psb;	bodies[1] = psb;
	psa->m_cdbvt.collideTT(psa->m_cdbvt.m_root,psb->m_cd bvt.m_root,*this);	psa->m_cdbvt.collideTT(psa->m_cdbvt.m_root,psb->m_cd bvt.m_root,*this);
	}	}
	};	};
	//	//
	// CollideSDF_RS	// CollideSDF_RS
	//	//
	struct CollideSDF_RS : btDbvt::ICollide	struct CollideSDF_RS : btDbvt::ICollide

	skipping to change at line 838	skipping to change at line 854
	const btScalar ms=ima+imb;	const btScalar ms=ima+imb;
	if(ms>0)	if(ms>0)
	{	{
	const btTransform& wtr=m_rigidB ody?m_rigidBody->getInterpolationWorldTransform() : m_colObj1->getWorldTran sform();	const btTransform& wtr=m_rigidB ody?m_rigidBody->getInterpolationWorldTransform() : m_colObj1->getWorldTran sform();
	static const btMatrix3x3 iwiS tatic(0,0,0,0,0,0,0,0,0);	static const btMatrix3x3 iwiS tatic(0,0,0,0,0,0,0,0,0);
	const btMatrix3x3& iwi=m_rigidB ody?m_rigidBody->getInvInertiaTensorWorld() : iwiStatic;	const btMatrix3x3& iwi=m_rigidB ody?m_rigidBody->getInvInertiaTensorWorld() : iwiStatic;
	const btVector3 ra=n.m_x-wtr .getOrigin();	const btVector3 ra=n.m_x-wtr .getOrigin();
	const btVector3 va=m_rigidBo dy ? m_rigidBody->getVelocityInLocalPoint(ra)*psb->m_sst.sdt : btVector3(0, 0,0);	const btVector3 va=m_rigidBo dy ? m_rigidBody->getVelocityInLocalPoint(ra)*psb->m_sst.sdt : btVector3(0, 0,0);
	const btVector3 vb=n.m_x-n.m _q;	const btVector3 vb=n.m_x-n.m _q;
	const btVector3 vr=vb-va;	const btVector3 vr=vb-va;

	const btScalar dn=dot(vr,c. m_cti.m_normal);	const btScalar dn=btDot(vr, c.m_cti.m_normal);
	const btVector3 fv=vr-c.m_ct i.m_normal*dn;	const btVector3 fv=vr-c.m_ct i.m_normal*dn;
	const btScalar fc=psb->m_cf g.kDF*m_colObj1->getFriction();	const btScalar fc=psb->m_cf g.kDF*m_colObj1->getFriction();
	c.m_node = &n;	c.m_node = &n;
	c.m_c0 = ImpulseMatri x(psb->m_sst.sdt,ima,imb,iwi,ra);	c.m_c0 = ImpulseMatri x(psb->m_sst.sdt,ima,imb,iwi,ra);
	c.m_c1 = ra;	c.m_c1 = ra;
	c.m_c2 = ima*psb->m_s st.sdt;	c.m_c2 = ima*psb->m_s st.sdt;
	c.m_c3 = fv.length2() <(btFabs(dn)*fc)?0:1-fc;	c.m_c3 = fv.length2() <(btFabs(dn)*fc)?0:1-fc;
	c.m_c4 = m_colObj1->i sStaticOrKinematicObject()?psb->m_cfg.kKHR:psb->m_cfg.kCHR;	c.m_c4 = m_colObj1->i sStaticOrKinematicObject()?psb->m_cfg.kKHR:psb->m_cfg.kCHR;
	psb->m_rcontacts.push_back(c);	psb->m_rcontacts.push_back(c);
	if (m_rigidBody)	if (m_rigidBody)

End of changes. 25 change blocks.
	34 lines changed or deleted	53 lines changed or added

	btSoftRigidDynamicsWorld.h	btSoftRigidDynamicsWorld.h

	skipping to change at line 52	skipping to change at line 52
	void solveSoftBodiesConstraints();	void solveSoftBodiesConstraints();

	public:	public:

	btSoftRigidDynamicsWorld(btDispatcher* dispatcher,btBroadphaseInterf ace* pairCache,btConstraintSolver* constraintSolver,btCollisionConfiguratio n* collisionConfiguration);	btSoftRigidDynamicsWorld(btDispatcher* dispatcher,btBroadphaseInterf ace* pairCache,btConstraintSolver* constraintSolver,btCollisionConfiguratio n* collisionConfiguration);

	virtual ~btSoftRigidDynamicsWorld();	virtual ~btSoftRigidDynamicsWorld();

	virtual void debugDrawWorld();	virtual void debugDrawWorld();


	void addSoftBody(btSoftBody* body);	void addSoftBody(btSoftBody* body,short int collisionFilterGroup= btBroadphaseProxy::DefaultFilter,short int collisionFilterMask=btBroadphase Proxy::AllFilter);

	void removeSoftBody(btSoftBody* body);	void removeSoftBody(btSoftBody* body);


		///removeCollisionObject will first check if it is a rigid body, if
		so call removeRigidBody otherwise call btDiscreteDynamicsWorld::removeColli
		sionObject
		virtual void removeCollisionObject(btCollisionObject* collisionOb
		ject);

	int getDrawFlags() const { return(m_drawFlags); }	int getDrawFlags() const { return(m_drawFlags); }
	void setDrawFlags(int f) { m_drawFlags=f; }	void setDrawFlags(int f) { m_drawFlags=f; }

	btSoftBodyWorldInfo& getWorldInfo()	btSoftBodyWorldInfo& getWorldInfo()
	{	{
	return m_sbi;	return m_sbi;
	}	}
	const btSoftBodyWorldInfo& getWorldInfo() const	const btSoftBodyWorldInfo& getWorldInfo() const
	{	{
	return m_sbi;	return m_sbi;

End of changes. 2 change blocks.
	1 lines changed or deleted	7 lines changed or added

	btSolverBody.h	btSolverBody.h

	skipping to change at line 111	skipping to change at line 111
	#else	#else
	#define btSimdScalar btScalar	#define btSimdScalar btScalar
	#endif	#endif

	///The btSolverBody is an internal datastructure for the constraint solver. Only necessary data is packed to increase cache coherence/performance.	///The btSolverBody is an internal datastructure for the constraint solver. Only necessary data is packed to increase cache coherence/performance.
	ATTRIBUTE_ALIGNED16 (struct) btSolverBody	ATTRIBUTE_ALIGNED16 (struct) btSolverBody
	{	{
	BT_DECLARE_ALIGNED_ALLOCATOR();	BT_DECLARE_ALIGNED_ALLOCATOR();
	btVector3 m_deltaLinearVelocity;	btVector3 m_deltaLinearVelocity;
	btVector3 m_deltaAngularVelocity;	btVector3 m_deltaAngularVelocity;

	btScalar m_angularFactor;	btVector3 m_angularFactor;
	btScalar m_invMass;	btVector3 m_invMass;
	btScalar m_friction;	btScalar m_friction;
	btRigidBody* m_originalBody;	btRigidBody* m_originalBody;
	btVector3 m_pushVelocity;	btVector3 m_pushVelocity;

	//btVector3 m_turnVelocity;	btVector3 m_turnVelocity;

	SIMD_FORCE_INLINE void getVelocityInLocalPointObsolete(const btVect or3& rel_pos, btVector3& velocity ) const	SIMD_FORCE_INLINE void getVelocityInLocalPointObsolete(const btVect or3& rel_pos, btVector3& velocity ) const
	{	{
	if (m_originalBody)	if (m_originalBody)
	velocity = m_originalBody->getLinearVelocity()+m_del taLinearVelocity + (m_originalBody->getAngularVelocity()+m_deltaAngularVelo city).cross(rel_pos);	velocity = m_originalBody->getLinearVelocity()+m_del taLinearVelocity + (m_originalBody->getAngularVelocity()+m_deltaAngularVelo city).cross(rel_pos);
	else	else
	velocity.setValue(0,0,0);	velocity.setValue(0,0,0);
	}	}

	SIMD_FORCE_INLINE void getAngularVelocity(btVector3& angVel) const	SIMD_FORCE_INLINE void getAngularVelocity(btVector3& angVel) const

	skipping to change at line 144	skipping to change at line 144
	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
	SIMD_FORCE_INLINE void applyImpulse(const btVector3& linearComponent , const btVector3& angularComponent,const btScalar impulseMagnitude)	SIMD_FORCE_INLINE void applyImpulse(const btVector3& linearComponent , const btVector3& angularComponent,const btScalar impulseMagnitude)
	{	{
	//if (m_invMass)	//if (m_invMass)
	{	{
	m_deltaLinearVelocity += linearComponent*impulseMagn itude;	m_deltaLinearVelocity += linearComponent*impulseMagn itude;
	m_deltaAngularVelocity += angularComponent(impulseM agnitudem_angularFactor);	m_deltaAngularVelocity += angularComponent(impulseM agnitudem_angularFactor);
	}	}
	}	}


	/*	SIMD_FORCE_INLINE void internalApplyPushImpulse(const btVector3& lin
		earComponent, const btVector3& angularComponent,btScalar impulseMagnitude)
		{
		if (m_originalBody)
		{
		m_pushVelocity += linearComponent*impulseMagnitude;
		m_turnVelocity += angularComponent*(impulseMagnitude
		*m_angularFactor);
		}
		}

	void writebackVelocity()	void writebackVelocity()
	{	{

	if (m_invMass)	if (m_originalBody)
	{	{
	m_originalBody->setLinearVelocity(m_originalBody->ge tLinearVelocity()+ m_deltaLinearVelocity);	m_originalBody->setLinearVelocity(m_originalBody->ge tLinearVelocity()+ m_deltaLinearVelocity);
	m_originalBody->setAngularVelocity(m_originalBody->g etAngularVelocity()+m_deltaAngularVelocity);	m_originalBody->setAngularVelocity(m_originalBody->g etAngularVelocity()+m_deltaAngularVelocity);

	//m_originalBody->setCompanionId(-1);	//m_originalBody->setCompanionId(-1);
	}	}
	}	}

	*/


	void writebackVelocity(btScalar timeStep=0)	void writebackVelocity(btScalar timeStep)
	{	{

	if (m_invMass)	if (m_originalBody)
	{	{

	m_originalBody->setLinearVelocity(m_originalBody->ge tLinearVelocity()+m_deltaLinearVelocity);	m_originalBody->setLinearVelocity(m_originalBody->ge tLinearVelocity()+ m_deltaLinearVelocity);
	m_originalBody->setAngularVelocity(m_originalBody->g etAngularVelocity()+m_deltaAngularVelocity);	m_originalBody->setAngularVelocity(m_originalBody->g etAngularVelocity()+m_deltaAngularVelocity);


		//correct the position/orientation based on push/tur
		n recovery
		btTransform newTransform;
		btTransformUtil::integrateTransform(m_originalBody->
		getWorldTransform(),m_pushVelocity,m_turnVelocity,timeStep,newTransform);
		m_originalBody->setWorldTransform(newTransform);

	//m_originalBody->setCompanionId(-1);	//m_originalBody->setCompanionId(-1);
	}	}
	}	}

	};	};

	#endif //BT_SOLVER_BODY_H	#endif //BT_SOLVER_BODY_H

End of changes. 9 change blocks.
	9 lines changed or deleted	25 lines changed or added

	btSolverConstraint.h	btSolverConstraint.h

	skipping to change at line 79	skipping to change at line 79
	{	{
	void* m_originalContactPoint;	void* m_originalContactPoint;
	btScalar m_unusedPadding4;	btScalar m_unusedPadding4;
	};	};

	btScalar m_rhs;	btScalar m_rhs;
	btScalar m_cfm;	btScalar m_cfm;
	btScalar m_lowerLimit;	btScalar m_lowerLimit;
	btScalar m_upperLimit;	btScalar m_upperLimit;


		btScalar m_rhsPenetration;

	enum btSolverConstraintType	enum btSolverConstraintType
	{	{
	BT_SOLVER_CONTACT_1D = 0,	BT_SOLVER_CONTACT_1D = 0,
	BT_SOLVER_FRICTION_1D	BT_SOLVER_FRICTION_1D
	};	};
	};	};

	typedef btAlignedObjectArray<btSolverConstraint> btConstraintArray;	typedef btAlignedObjectArray<btSolverConstraint> btConstraintArray;

	#endif //BT_SOLVER_CONSTRAINT_H	#endif //BT_SOLVER_CONSTRAINT_H

End of changes. 1 change blocks.
	0 lines changed or deleted	2 lines changed or added

	btSphereShape.h	btSphereShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btStaticPlaneShape.h	btStaticPlaneShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btStridingMeshInterface.h	btStridingMeshInterface.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btThreadSupportInterface.h	btThreadSupportInterface.h

	skipping to change at line 44	skipping to change at line 44

	///start the spus (can be called at the beginning of each frame, to make su re that the right SPU program is loaded)	///start the spus (can be called at the beginning of each frame, to make su re that the right SPU program is loaded)
	virtual void startSPU() =0;	virtual void startSPU() =0;

	///tell the task scheduler we are done with the SPU tasks	///tell the task scheduler we are done with the SPU tasks
	virtual void stopSPU()=0;	virtual void stopSPU()=0;

	///tell the task scheduler to use no more than numTasks tasks	///tell the task scheduler to use no more than numTasks tasks
	virtual void setNumTasks(int numTasks)=0;	virtual void setNumTasks(int numTasks)=0;


		virtual int getNumTasks() const = 0;

	};	};

	#endif //THREAD_SUPPORT_INTERFACE_H	#endif //THREAD_SUPPORT_INTERFACE_H

End of changes. 1 change blocks.
	0 lines changed or deleted	2 lines changed or added

	btTransformUtil.h	btTransformUtil.h

	skipping to change at line 21	skipping to change at line 21
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef SIMD_TRANSFORM_UTIL_H	#ifndef SIMD_TRANSFORM_UTIL_H
	#define SIMD_TRANSFORM_UTIL_H	#define SIMD_TRANSFORM_UTIL_H

	#include "btTransform.h"	#include "btTransform.h"
	#define ANGULAR_MOTION_THRESHOLD btScalar(0.5)*SIMD_HALF_PI	#define ANGULAR_MOTION_THRESHOLD btScalar(0.5)*SIMD_HALF_PI


	#define SIMDSQRT12 btScalar(0.7071067811865475244008443621048490)

	#define btRecipSqrt(x) ((btScalar)(btScalar(1.0)/btSqrt(btScalar(x))))
	/* reciprocal square root */

	SIMD_FORCE_INLINE btVector3 btAabbSupport(const btVector3& halfExtents,cons t btVector3& supportDir)	SIMD_FORCE_INLINE btVector3 btAabbSupport(const btVector3& halfExtents,cons t btVector3& supportDir)
	{	{
	return btVector3(supportDir.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(),	return btVector3(supportDir.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(),
	supportDir.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(),	supportDir.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(),
	supportDir.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z());	supportDir.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z());
	}	}


	SIMD_FORCE_INLINE void btPlaneSpace1 (const btVector3& n, btVector3& p, btV
	ector3& q)
	{
	if (btFabs(n.z()) > SIMDSQRT12) {
	// choose p in y-z plane
	btScalar a = n[1]n[1] + n[2]n[2];
	btScalar k = btRecipSqrt (a);
	p.setValue(0,-n[2]k,n[1]k);
	// set q = n x p
	q.setValue(ak,-n[0]p[2],n[0]*p[1]);
	}
	else {
	// choose p in x-y plane
	btScalar a = n.x()n.x() + n.y()n.y();
	btScalar k = btRecipSqrt (a);
	p.setValue(-n.y()k,n.x()k,0);
	// set q = n x p
	q.setValue(-n.z()p.y(),n.z()p.x(),a*k);
	}
	}

	/// Utils related to temporal transforms	/// Utils related to temporal transforms
	class btTransformUtil	class btTransformUtil
	{	{

	public:	public:

	static void integrateTransform(const btTransform& curTrans,const btV ector3& linvel,const btVector3& angvel,btScalar timeStep,btTransform& predi ctedTransform)	static void integrateTransform(const btTransform& curTrans,const btV ector3& linvel,const btVector3& angvel,btScalar timeStep,btTransform& predi ctedTransform)
	{	{
	predictedTransform.setOrigin(curTrans.getOrigin() + linvel * timeStep);	predictedTransform.setOrigin(curTrans.getOrigin() + linvel * timeStep);
	// #define QUATERNION_DERIVATIVE	// #define QUATERNION_DERIVATIVE

	skipping to change at line 114	skipping to change at line 90
	calculateDiffAxisAngleQuaternion(orn0,orn1,axis,angl e);	calculateDiffAxisAngleQuaternion(orn0,orn1,axis,angl e);
	angVel = axis * angle / timeStep;	angVel = axis * angle / timeStep;
	} else	} else
	{	{
	angVel.setValue(0,0,0);	angVel.setValue(0,0,0);
	}	}
	}	}

	static void calculateDiffAxisAngleQuaternion(const btQuaternion& orn 0,const btQuaternion& orn1a,btVector3& axis,btScalar& angle)	static void calculateDiffAxisAngleQuaternion(const btQuaternion& orn 0,const btQuaternion& orn1a,btVector3& axis,btScalar& angle)
	{	{

	btQuaternion orn1 = orn0.farthest(orn1a);	btQuaternion orn1 = orn0.nearest(orn1a);
	btQuaternion dorn = orn1 * orn0.inverse();	btQuaternion dorn = orn1 * orn0.inverse();
	///floating point inaccuracy can lead to w component > 1..., which breaks	///floating point inaccuracy can lead to w component > 1..., which breaks
	dorn.normalize();	dorn.normalize();
	angle = dorn.getAngle();	angle = dorn.getAngle();
	axis = btVector3(dorn.x(),dorn.y(),dorn.z());	axis = btVector3(dorn.x(),dorn.y(),dorn.z());
	axis[3] = btScalar(0.);	axis[3] = btScalar(0.);
	//check for axis length	//check for axis length
	btScalar len = axis.length2();	btScalar len = axis.length2();
	if (len < SIMD_EPSILON*SIMD_EPSILON)	if (len < SIMD_EPSILON*SIMD_EPSILON)
	axis = btVector3(btScalar(1.),btScalar(0.),btScalar( 0.));	axis = btVector3(btScalar(1.),btScalar(0.),btScalar( 0.));

	skipping to change at line 222	skipping to change at line 198
	}	}

	m_posA = toPosA;	m_posA = toPosA;
	m_posB = toPosB;	m_posB = toPosB;
	m_ornA = toOrnA;	m_ornA = toOrnA;
	m_ornB = toOrnB;	m_ornB = toOrnB;
	}	}

	void initSeparatingDistance(const btVector3& separatingVector,btS calar separatingDistance,const btTransform& transA,const btTransform& trans B)	void initSeparatingDistance(const btVector3& separatingVector,btS calar separatingDistance,const btTransform& transA,const btTransform& trans B)
	{	{

	m_separatingNormal = separatingVector;
	m_separatingDistance = separatingDistance;	m_separatingDistance = separatingDistance;


	const btVector3& toPosA = transA.getOrigin();	if (m_separatingDistance>0.f)
	const btVector3& toPosB = transB.getOrigin();	{
	btQuaternion toOrnA = transA.getRotation();	m_separatingNormal = separatingVector;
	btQuaternion toOrnB = transB.getRotation();
	m_posA = toPosA;	const btVector3& toPosA = transA.getOrigin();
	m_posB = toPosB;	const btVector3& toPosB = transB.getOrigin();
	m_ornA = toOrnA;	btQuaternion toOrnA = transA.getRotation();
	m_ornB = toOrnB;	btQuaternion toOrnB = transB.getRotation();
		m_posA = toPosA;
		m_posB = toPosB;
		m_ornA = toOrnA;
		m_ornB = toOrnB;
		}
	}	}

	};	};

	#endif //SIMD_TRANSFORM_UTIL_H	#endif //SIMD_TRANSFORM_UTIL_H

End of changes. 5 change blocks.
	36 lines changed or deleted	14 lines changed or added

	btTriangleBuffer.h	btTriangleBuffer.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btTriangleCallback.h	btTriangleCallback.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btTriangleIndexVertexArray.h	btTriangleIndexVertexArray.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

	skipping to change at line 29	skipping to change at line 29
	#include "btStridingMeshInterface.h"	#include "btStridingMeshInterface.h"
	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"
	#include "LinearMath/btScalar.h"	#include "LinearMath/btScalar.h"

	///The btIndexedMesh indexes a single vertex and index array. Multiple btIn dexedMesh objects can be passed into a btTriangleIndexVertexArray using add IndexedMesh.	///The btIndexedMesh indexes a single vertex and index array. Multiple btIn dexedMesh objects can be passed into a btTriangleIndexVertexArray using add IndexedMesh.
	///Instead of the number of indices, we pass the number of triangles.	///Instead of the number of indices, we pass the number of triangles.
	ATTRIBUTE_ALIGNED16( struct) btIndexedMesh	ATTRIBUTE_ALIGNED16( struct) btIndexedMesh
	{	{
	BT_DECLARE_ALIGNED_ALLOCATOR();	BT_DECLARE_ALIGNED_ALLOCATOR();


	int m_numTriangles;	int m_numTriangles;
	const unsigned char * m_triangleIndexBase;	const unsigned char * m_triangleIndexBase;
	int m_triangleIndexStride;	int m_triangleIndexStride;
	int m_numVertices;	int m_numVertices;
	const unsigned char * m_vertexBase;	const unsigned char * m_vertexBase;
	int m_vertexStride;	int m_vertexStride;
	// The index type is set when adding an indexed mesh to the
	// btTriangleIndexVertexArray, do not set it manually	// The index type is set when adding an indexed mesh to the
	PHY_ScalarType m_indexType;	// btTriangleIndexVertexArray, do not set it manually
	int pad;	PHY_ScalarType m_indexType;

		// The vertex type has a default type similar to Bullet's precision mode
		(float or double)
		// but can be set manually if you for example run Bullet with double pre
		cision but have
		// mesh data in single precision..
		PHY_ScalarType m_vertexType;

		btIndexedMesh()
		:m_indexType(PHY_INTEGER),
		#ifdef BT_USE_DOUBLE_PRECISION
		m_vertexType(PHY_DOUBLE)
		#else // BT_USE_DOUBLE_PRECISION
		m_vertexType(PHY_FLOAT)
		#endif // BT_USE_DOUBLE_PRECISION
		{
		}
	}	}
	;	;

	typedef btAlignedObjectArray<btIndexedMesh> IndexedMeshArray;	typedef btAlignedObjectArray<btIndexedMesh> IndexedMeshArray;

	///The btTriangleIndexVertexArray allows to access multiple triangle meshes , by indexing into existing triangle/index arrays.	///The btTriangleIndexVertexArray allows to access multiple triangle meshes , by indexing into existing triangle/index arrays.
	///Additional meshes can be added using addIndexedMesh	///Additional meshes can be added using addIndexedMesh
	///No duplcate is made of the vertex/index data, it only indexes into exter nal vertex/index arrays.	///No duplcate is made of the vertex/index data, it only indexes into exter nal vertex/index arrays.
	///So keep those arrays around during the lifetime of this btTriangleIndexV ertexArray.	///So keep those arrays around during the lifetime of this btTriangleIndexV ertexArray.
	ATTRIBUTE_ALIGNED16( class) btTriangleIndexVertexArray : public btStridingM eshInterface	ATTRIBUTE_ALIGNED16( class) btTriangleIndexVertexArray : public btStridingM eshInterface

End of changes. 2 change blocks.
	11 lines changed or deleted	28 lines changed or added

	btTriangleIndexVertexMaterialArray.h	btTriangleIndexVertexMaterialArray.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btTriangleMesh.h	btTriangleMesh.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

	skipping to change at line 42	skipping to change at line 42
	btAlignedObjectArray<unsigned int> m_32bitIndices;	btAlignedObjectArray<unsigned int> m_32bitIndices;
	btAlignedObjectArray<unsigned short int> m_16bitIndic es;	btAlignedObjectArray<unsigned short int> m_16bitIndic es;
	bool m_use32bitIndices;	bool m_use32bitIndices;
	bool m_use4componentVertices;	bool m_use4componentVertices;

	public:	public:
	btScalar m_weldingThreshold;	btScalar m_weldingThreshold;

	btTriangleMesh (bool use32bitIndices=true,bool use4component Vertices=true);	btTriangleMesh (bool use32bitIndices=true,bool use4component Vertices=true);


	int findOrAddVertex(const btVector3& vertex, boo
	l removeDuplicateVertices);
	void addIndex(int index);

	bool getUse32bitIndices() const	bool getUse32bitIndices() const
	{	{
	return m_use32bitIndices;	return m_use32bitIndices;
	}	}

	bool getUse4componentVertices() const	bool getUse4componentVertices() const
	{	{
	return m_use4componentVertices;	return m_use4componentVertices;
	}	}
	///By default addTriangle won't search for duplicate vertice s, because the search is very slow for large triangle meshes.	///By default addTriangle won't search for duplicate vertice s, because the search is very slow for large triangle meshes.
	///In general it is better to directly use btTriangleIndexVe rtexArray instead.	///In general it is better to directly use btTriangleIndexVe rtexArray instead.
	void addTriangle(const btVector3& vertex0,const btVector3 & vertex1,const btVector3& vertex2, bool removeDuplicateVertices=false);	void addTriangle(const btVector3& vertex0,const btVector3 & vertex1,const btVector3& vertex2, bool removeDuplicateVertices=false);

	int getNumTriangles() const;	int getNumTriangles() const;

	virtual void preallocateVertices(int numverts){(void) num verts;}	virtual void preallocateVertices(int numverts){(void) num verts;}
	virtual void preallocateIndices(int numindices){(void) nu mindices;}	virtual void preallocateIndices(int numindices){(void) nu mindices;}


		///findOrAddVertex is an internal method, use addTriangle in
		stead
		int findOrAddVertex(const btVector3& vertex, boo
		l removeDuplicateVertices);
		///addIndex is an internal method, use addTriangle instead
		void addIndex(int index);

	};	};

	#endif //TRIANGLE_MESH_H	#endif //TRIANGLE_MESH_H

End of changes. 3 change blocks.
	5 lines changed or deleted	8 lines changed or added

	btTriangleMeshShape.h	btTriangleMeshShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btTriangleShape.h	btTriangleShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef OBB_TRIANGLE_MINKOWSKI_H	#ifndef OBB_TRIANGLE_MINKOWSKI_H
	#define OBB_TRIANGLE_MINKOWSKI_H	#define OBB_TRIANGLE_MINKOWSKI_H

	#include "btConvexShape.h"	#include "btConvexShape.h"
	#include "btBoxShape.h"	#include "btBoxShape.h"


	class btTriangleShape : public btPolyhedralConvexShape	ATTRIBUTE_ALIGNED16(class) btTriangleShape : public btPolyhedralConvexShape
	{	{

	public:	public:

	btVector3 m_vertices1[3];	btVector3 m_vertices1[3];

	virtual int getNumVertices() const	virtual int getNumVertices() const
	{	{
	return 3;	return 3;
	}	}


		btVector3& getVertexPtr(int index)
		{
		return m_vertices1[index];
		}

	const btVector3& getVertexPtr(int index) const	const btVector3& getVertexPtr(int index) const
	{	{
	return m_vertices1[index];	return m_vertices1[index];
	}	}
	virtual void getVertex(int index,btVector3& vert) const	virtual void getVertex(int index,btVector3& vert) const
	{	{
	vert = m_vertices1[index];	vert = m_vertices1[index];
	}	}

	virtual int getNumEdges() const	virtual int getNumEdges() const

	skipping to change at line 78	skipping to change at line 83
	{	{
	for (int i=0;i<numVectors;i++)	for (int i=0;i<numVectors;i++)
	{	{
	const btVector3& dir = vectors[i];	const btVector3& dir = vectors[i];
	btVector3 dots(dir.dot(m_vertices1[0]), dir.dot(m_ve rtices1[1]), dir.dot(m_vertices1[2]));	btVector3 dots(dir.dot(m_vertices1[0]), dir.dot(m_ve rtices1[1]), dir.dot(m_vertices1[2]));
	supportVerticesOut[i] = m_vertices1[dots.maxAxis()];	supportVerticesOut[i] = m_vertices1[dots.maxAxis()];
	}	}

	}	}


		btTriangleShape() : btPolyhedralConvexShape ()
		{
		m_shapeType = TRIANGLE_SHAPE_PROXYTYPE;
		}

	btTriangleShape(const btVector3& p0,const btVector3& p1,const btVect or3& p2) : btPolyhedralConvexShape ()	btTriangleShape(const btVector3& p0,const btVector3& p1,const btVect or3& p2) : btPolyhedralConvexShape ()
	{	{
	m_shapeType = TRIANGLE_SHAPE_PROXYTYPE;	m_shapeType = TRIANGLE_SHAPE_PROXYTYPE;
	m_vertices1[0] = p0;	m_vertices1[0] = p0;
	m_vertices1[1] = p1;	m_vertices1[1] = p1;
	m_vertices1[2] = p2;	m_vertices1[2] = p2;
	}	}

	virtual void getPlane(btVector3& planeNormal,btVector3& planeSupport ,int i) const	virtual void getPlane(btVector3& planeNormal,btVector3& planeSupport ,int i) const
	{	{

End of changes. 4 change blocks.
	2 lines changed or deleted	12 lines changed or added

	btTypedConstraint.h	btTypedConstraint.h

	skipping to change at line 22	skipping to change at line 22
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/

	#ifndef TYPED_CONSTRAINT_H	#ifndef TYPED_CONSTRAINT_H
	#define TYPED_CONSTRAINT_H	#define TYPED_CONSTRAINT_H

	class btRigidBody;	class btRigidBody;
	#include "LinearMath/btScalar.h"	#include "LinearMath/btScalar.h"
	#include "btSolverConstraint.h"	#include "btSolverConstraint.h"

		#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
	struct btSolverBody;	struct btSolverBody;

	enum btTypedConstraintType	enum btTypedConstraintType
	{	{

	POINT2POINT_CONSTRAINT_TYPE,	POINT2POINT_CONSTRAINT_TYPE=MAX_CONTACT_MANIFOLD_TYPE+1,
	HINGE_CONSTRAINT_TYPE,	HINGE_CONSTRAINT_TYPE,
	CONETWIST_CONSTRAINT_TYPE,	CONETWIST_CONSTRAINT_TYPE,
	D6_CONSTRAINT_TYPE,	D6_CONSTRAINT_TYPE,

	SLIDER_CONSTRAINT_TYPE	SLIDER_CONSTRAINT_TYPE,
		CONTACT_CONSTRAINT_TYPE
	};	};

	///TypedConstraint is the baseclass for Bullet constraints and vehicles	///TypedConstraint is the baseclass for Bullet constraints and vehicles

	class btTypedConstraint	class btTypedConstraint : public btTypedObject
	{	{
	int m_userConstraintType;	int m_userConstraintType;
	int m_userConstraintId;	int m_userConstraintId;

		bool m_needsFeedback;
	btTypedConstraintType m_constraintType;

	btTypedConstraint& operator=(btTypedConstraint& other)	btTypedConstraint& operator=(btTypedConstraint& other)
	{	{
	btAssert(0);	btAssert(0);
	(void) other;	(void) other;
	return *this;	return *this;
	}	}

	protected:	protected:
	btRigidBody& m_rbA;	btRigidBody& m_rbA;
	btRigidBody& m_rbB;	btRigidBody& m_rbB;
	btScalar m_appliedImpulse;	btScalar m_appliedImpulse;
	btScalar m_dbgDrawSize;	btScalar m_dbgDrawSize;


		btVector3 m_appliedLinearImpulse;
		btVector3 m_appliedAngularImpulseA;
		btVector3 m_appliedAngularImpulseB;

	public:	public:

	btTypedConstraint(btTypedConstraintType type);	btTypedConstraint(btTypedConstraintType type);
	virtual ~btTypedConstraint() {};	virtual ~btTypedConstraint() {};
	btTypedConstraint(btTypedConstraintType type, btRigidBody& rbA);	btTypedConstraint(btTypedConstraintType type, btRigidBody& rbA);
	btTypedConstraint(btTypedConstraintType type, btRigidBody& rbA,btRig idBody& rbB);	btTypedConstraint(btTypedConstraintType type, btRigidBody& rbA,btRig idBody& rbB);

	struct btConstraintInfo1 {	struct btConstraintInfo1 {
	int m_numConstraintRows,nub;	int m_numConstraintRows,nub;
	};	};

	skipping to change at line 92	skipping to change at line 97
	btScalar m_constraintError,cfm;	btScalar m_constraintError,cfm;

	// lo and hi limits for variables (set to -/+ infinity on en try).	// lo and hi limits for variables (set to -/+ infinity on en try).
	btScalar m_lowerLimit,m_upperLimit;	btScalar m_lowerLimit,m_upperLimit;

	// findex vector for variables. see the LCP solver interface for a	// findex vector for variables. see the LCP solver interface for a
	// description of what this does. this is set to -1 on entry .	// description of what this does. this is set to -1 on entry .
	// note that the returned indexes are relative to the first index of	// note that the returned indexes are relative to the first index of
	// the constraint.	// the constraint.
	int *findex;	int *findex;

		// number of solver iterations
		int m_numIterations;
	};	};


		///internal method used by the constraint solver, don't use them dir ectly
	virtual void buildJacobian() = 0;	virtual void buildJacobian() = 0;


		///internal method used by the constraint solver, don't use them dir ectly
	virtual void setupSolverConstraint(btConstraintArray& ca, int sol verBodyA,int solverBodyB, btScalar timeStep)	virtual void setupSolverConstraint(btConstraintArray& ca, int sol verBodyA,int solverBodyB, btScalar timeStep)
	{	{
	}	}


		///internal method used by the constraint solver, don't use them dir
		ectly
	virtual void getInfo1 (btConstraintInfo1* info)=0;	virtual void getInfo1 (btConstraintInfo1* info)=0;


		///internal method used by the constraint solver, don't use them dir ectly
	virtual void getInfo2 (btConstraintInfo2* info)=0;	virtual void getInfo2 (btConstraintInfo2* info)=0;


		///internal method used by the constraint solver, don't use them dir
		ectly
		void internalSetAppliedImpulse(btScalar appliedImpulse)
		{
		m_appliedImpulse = appliedImpulse;
		}

		///internal method used by the constraint solver, don't use them dir
		ectly
	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep) = 0;	virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolver Body& bodyB,btScalar timeStep) = 0;


		///internal method used by the constraint solver, don't use them dir ectly
	btScalar getMotorFactor(btScalar pos, btScalar lowLim, btScalar uppL im, btScalar vel, btScalar timeFact);	btScalar getMotorFactor(btScalar pos, btScalar lowLim, btScalar uppL im, btScalar vel, btScalar timeFact);

	const btRigidBody& getRigidBodyA() const	const btRigidBody& getRigidBodyA() const
	{	{
	return m_rbA;	return m_rbA;
	}	}
	const btRigidBody& getRigidBodyB() const	const btRigidBody& getRigidBodyB() const
	{	{
	return m_rbB;	return m_rbB;
	}	}

	skipping to change at line 150	skipping to change at line 170
	int getUserConstraintId() const	int getUserConstraintId() const
	{	{
	return m_userConstraintId;	return m_userConstraintId;
	}	}

	int getUid() const	int getUid() const
	{	{
	return m_userConstraintId;	return m_userConstraintId;
	}	}


		bool needsFeedback() const
		{
		return m_needsFeedback;
		}

		///enableFeedback will allow to read the applied linear and angular
		impulse
		///use getAppliedImpulse, getAppliedLinearImpulse and getAppliedAngu
		larImpulse to read feedback information
		void enableFeedback(bool needsFeedback)
		{
		m_needsFeedback = needsFeedback;
		}

		///getAppliedImpulse is an estimated total applied impulse.
		///This feedback could be used to determine breaking constraints or
		playing sounds.
	btScalar getAppliedImpulse() const	btScalar getAppliedImpulse() const
	{	{

		btAssert(m_needsFeedback);
	return m_appliedImpulse;	return m_appliedImpulse;
	}	}


		const btVector3& getAppliedLinearImpulse() const
		{
		btAssert(m_needsFeedback);
		return m_appliedLinearImpulse;
		}

		btVector3& getAppliedLinearImpulse()
		{
		btAssert(m_needsFeedback);
		return m_appliedLinearImpulse;
		}

		const btVector3& getAppliedAngularImpulseA() const
		{
		btAssert(m_needsFeedback);
		return m_appliedAngularImpulseA;
		}

		btVector3& getAppliedAngularImpulseA()
		{
		btAssert(m_needsFeedback);
		return m_appliedAngularImpulseA;
		}

		const btVector3& getAppliedAngularImpulseB() const
		{
		btAssert(m_needsFeedback);
		return m_appliedAngularImpulseB;
		}

		btVector3& getAppliedAngularImpulseB()
		{
		btAssert(m_needsFeedback);
		return m_appliedAngularImpulseB;
		}

	btTypedConstraintType getConstraintType () const	btTypedConstraintType getConstraintType () const
	{	{

	return m_constraintType;	return btTypedConstraintType(m_objectType);
	}	}

	void setDbgDrawSize(btScalar dbgDrawSize)	void setDbgDrawSize(btScalar dbgDrawSize)
	{	{
	m_dbgDrawSize = dbgDrawSize;	m_dbgDrawSize = dbgDrawSize;
	}	}
	btScalar getDbgDrawSize()	btScalar getDbgDrawSize()
	{	{
	return m_dbgDrawSize;	return m_dbgDrawSize;
	}	}

	};	};


		// returns angle in range [-SIMD_2_PI, SIMD_2_PI], closest to one of the li
		mits
		// all arguments should be normalized angles (i.e. in range [-SIMD_PI, SIMD
		_PI])
		SIMD_FORCE_INLINE btScalar btAdjustAngleToLimits(btScalar angleInRadians, b
		tScalar angleLowerLimitInRadians, btScalar angleUpperLimitInRadians)
		{
		if(angleLowerLimitInRadians >= angleUpperLimitInRadians)
		{
		return angleInRadians;
		}
		else if(angleInRadians < angleLowerLimitInRadians)
		{
		btScalar diffLo = btNormalizeAngle(angleLowerLimitInRadians
		- angleInRadians); // this is positive
		btScalar diffHi = btFabs(btNormalizeAngle(angleUpperLimitInR
		adians - angleInRadians));
		return (diffLo < diffHi) ? angleInRadians : (angleInRadians
		+ SIMD_2_PI);
		}
		else if(angleInRadians > angleUpperLimitInRadians)
		{
		btScalar diffHi = btNormalizeAngle(angleInRadians - angleUpp
		erLimitInRadians); // this is positive
		btScalar diffLo = btFabs(btNormalizeAngle(angleInRadians - a
		ngleLowerLimitInRadians));
		return (diffLo < diffHi) ? (angleInRadians - SIMD_2_PI) : an
		gleInRadians;
		}
		else
		{
		return angleInRadians;
		}
		}

	#endif //TYPED_CONSTRAINT_H	#endif //TYPED_CONSTRAINT_H

End of changes. 18 change blocks.
	6 lines changed or deleted	118 lines changed or added

	btUniformScalingShape.h	btUniformScalingShape.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	btVector3.h	btVector3.h

	skipping to change at line 31	skipping to change at line 31
	/**@brief btVector3 can be used to represent 3D points and vectors.	/**@brief btVector3 can be used to represent 3D points and vectors.
	* It has an un-used w component to suit 16-byte alignment when btVector3 i s stored in containers. This extra component can be used by derived classes (Quaternion?) or by user	* It has an un-used w component to suit 16-byte alignment when btVector3 i s stored in containers. This extra component can be used by derived classes (Quaternion?) or by user
	* Ideally, this class should be replaced by a platform optimized SIMD vers ion that keeps the data in registers	* Ideally, this class should be replaced by a platform optimized SIMD vers ion that keeps the data in registers
	*/	*/

	ATTRIBUTE_ALIGNED16(class) btVector3	ATTRIBUTE_ALIGNED16(class) btVector3
	{	{
	public:	public:

	#if defined (__SPU__) && defined (__CELLOS_LV2__)	#if defined (__SPU__) && defined (__CELLOS_LV2__)

	union {
	vec_float4 mVec128;
	btScalar m_floats[4];	btScalar m_floats[4];

	};
	public:	public:

	vec_float4 get128() const	SIMD_FORCE_INLINE const vec_float4& get128() const
	{	{

	return mVec128;	return ((const vec_float4)&m_floats[0]);
	}	}
	public:	public:
	#else //__CELLOS_LV2__ __SPU__	#else //__CELLOS_LV2__ __SPU__
	#ifdef BT_USE_SSE // WIN32	#ifdef BT_USE_SSE // WIN32
	union {	union {
	__m128 mVec128;	__m128 mVec128;
	btScalar m_floats[4];	btScalar m_floats[4];
	};	};
	SIMD_FORCE_INLINE __m128 get128() const	SIMD_FORCE_INLINE __m128 get128() const
	{	{

	skipping to change at line 302	skipping to change at line 299
	btSetMin(m_floats[1], other.m_floats[1]);	btSetMin(m_floats[1], other.m_floats[1]);
	btSetMin(m_floats[2], other.m_floats[2]);	btSetMin(m_floats[2], other.m_floats[2]);
	btSetMin(m_floats[3], other.w());	btSetMin(m_floats[3], other.w());
	}	}

	SIMD_FORCE_INLINE void setValue(const btScalar& x, const bt Scalar& y, const btScalar& z)	SIMD_FORCE_INLINE void setValue(const btScalar& x, const bt Scalar& y, const btScalar& z)
	{	{
	m_floats[0]=x;	m_floats[0]=x;
	m_floats[1]=y;	m_floats[1]=y;
	m_floats[2]=z;	m_floats[2]=z;

	m_floats[3] = 0.f;	m_floats[3] = btScalar(0.);
	}	}

	void getSkewSymmetricMatrix(btVector3* v0,btVector3* v1,b tVector3* v2) const	void getSkewSymmetricMatrix(btVector3* v0,btVector3* v1,b tVector3* v2) const
	{	{
	v0->setValue(0. ,-z() ,y());	v0->setValue(0. ,-z() ,y());
	v1->setValue(z() ,0. ,-x( ));	v1->setValue(z() ,0. ,-x( ));
	v2->setValue(-y() ,x() ,0.);	v2->setValue(-y() ,x() ,0.);
	}	}


		void setZero()
		{
		setValue(btScalar(0.),btScalar(0.),btScalar(0.));
		}

	};	};

	/*@brief Return the sum of two vectors (Point symantics)/	/*@brief Return the sum of two vectors (Point symantics)/
	SIMD_FORCE_INLINE btVector3	SIMD_FORCE_INLINE btVector3
	operator+(const btVector3& v1, const btVector3& v2)	operator+(const btVector3& v1, const btVector3& v2)
	{	{
	return btVector3(v1.m_floats[0] + v2.m_floats[0], v1.m_floats[1] + v 2.m_floats[1], v1.m_floats[2] + v2.m_floats[2]);	return btVector3(v1.m_floats[0] + v2.m_floats[0], v1.m_floats[1] + v 2.m_floats[1], v1.m_floats[2] + v2.m_floats[2]);
	}	}

	/*@brief Return the elementwise product of two vectors /	/*@brief Return the elementwise product of two vectors /

	skipping to change at line 372	skipping to change at line 374

	/*@brief Return the vector inversely scaled by s /	/*@brief Return the vector inversely scaled by s /
	SIMD_FORCE_INLINE btVector3	SIMD_FORCE_INLINE btVector3
	operator/(const btVector3& v1, const btVector3& v2)	operator/(const btVector3& v1, const btVector3& v2)
	{	{
	return btVector3(v1.m_floats[0] / v2.m_floats[0],v1.m_floats[1] / v2 .m_floats[1],v1.m_floats[2] / v2.m_floats[2]);	return btVector3(v1.m_floats[0] / v2.m_floats[0],v1.m_floats[1] / v2 .m_floats[1],v1.m_floats[2] / v2.m_floats[2]);
	}	}

	/*@brief Return the dot product between two vectors /	/*@brief Return the dot product between two vectors /
	SIMD_FORCE_INLINE btScalar	SIMD_FORCE_INLINE btScalar

	dot(const btVector3& v1, const btVector3& v2)	btDot(const btVector3& v1, const btVector3& v2)
	{	{
	return v1.dot(v2);	return v1.dot(v2);
	}	}

	/*@brief Return the distance squared between two vectors /	/*@brief Return the distance squared between two vectors /
	SIMD_FORCE_INLINE btScalar	SIMD_FORCE_INLINE btScalar

	distance2(const btVector3& v1, const btVector3& v2)	btDistance2(const btVector3& v1, const btVector3& v2)
	{	{
	return v1.distance2(v2);	return v1.distance2(v2);
	}	}

	/*@brief Return the distance between two vectors /	/*@brief Return the distance between two vectors /
	SIMD_FORCE_INLINE btScalar	SIMD_FORCE_INLINE btScalar

	distance(const btVector3& v1, const btVector3& v2)	btDistance(const btVector3& v1, const btVector3& v2)
	{	{
	return v1.distance(v2);	return v1.distance(v2);
	}	}

	/*@brief Return the angle between two vectors /	/*@brief Return the angle between two vectors /
	SIMD_FORCE_INLINE btScalar	SIMD_FORCE_INLINE btScalar

	angle(const btVector3& v1, const btVector3& v2)	btAngle(const btVector3& v1, const btVector3& v2)
	{	{
	return v1.angle(v2);	return v1.angle(v2);
	}	}

	/*@brief Return the cross product of two vectors /	/*@brief Return the cross product of two vectors /
	SIMD_FORCE_INLINE btVector3	SIMD_FORCE_INLINE btVector3

	cross(const btVector3& v1, const btVector3& v2)	btCross(const btVector3& v1, const btVector3& v2)
	{	{
	return v1.cross(v2);	return v1.cross(v2);
	}	}

	SIMD_FORCE_INLINE btScalar	SIMD_FORCE_INLINE btScalar

	triple(const btVector3& v1, const btVector3& v2, const btVector3& v3)	btTriple(const btVector3& v1, const btVector3& v2, const btVector3& v3)
	{	{
	return v1.triple(v2, v3);	return v1.triple(v2, v3);
	}	}

	/**@brief Return the linear interpolation between two vectors	/**@brief Return the linear interpolation between two vectors
	* @param v1 One vector	* @param v1 One vector
	* @param v2 The other vector	* @param v2 The other vector
	* @param t The ration of this to v (t = 0 => return v1, t=1 => return v2) */	* @param t The ration of this to v (t = 0 => return v1, t=1 => return v2) */
	SIMD_FORCE_INLINE btVector3	SIMD_FORCE_INLINE btVector3
	lerp(const btVector3& v1, const btVector3& v2, const btScalar& t)	lerp(const btVector3& v1, const btVector3& v2, const btScalar& t)

	skipping to change at line 475	skipping to change at line 477
	btFabs(m_floats[1]),	btFabs(m_floats[1]),
	btFabs(m_floats[2]),	btFabs(m_floats[2]),
	btFabs(m_floats[3]));	btFabs(m_floats[3]));
	}	}

	btScalar getW() const { return m_floats[3];}	btScalar getW() const { return m_floats[3];}

	SIMD_FORCE_INLINE int maxAxis4() const	SIMD_FORCE_INLINE int maxAxis4() const
	{	{
	int maxIndex = -1;	int maxIndex = -1;

	btScalar maxVal = btScalar(-1e30);	btScalar maxVal = btScalar(-BT_LARGE_FLOAT);
	if (m_floats[0] > maxVal)	if (m_floats[0] > maxVal)
	{	{
	maxIndex = 0;	maxIndex = 0;
	maxVal = m_floats[0];	maxVal = m_floats[0];
	}	}
	if (m_floats[1] > maxVal)	if (m_floats[1] > maxVal)
	{	{
	maxIndex = 1;	maxIndex = 1;
	maxVal = m_floats[1];	maxVal = m_floats[1];
	}	}

	skipping to change at line 504	skipping to change at line 506
	maxVal = m_floats[3];	maxVal = m_floats[3];
	}	}

	return maxIndex;	return maxIndex;

	}	}

	SIMD_FORCE_INLINE int minAxis4() const	SIMD_FORCE_INLINE int minAxis4() const
	{	{
	int minIndex = -1;	int minIndex = -1;

	btScalar minVal = btScalar(1e30);	btScalar minVal = btScalar(BT_LARGE_FLOAT);
	if (m_floats[0] < minVal)	if (m_floats[0] < minVal)
	{	{
	minIndex = 0;	minIndex = 0;
	minVal = m_floats[0];	minVal = m_floats[0];
	}	}
	if (m_floats[1] < minVal)	if (m_floats[1] < minVal)
	{	{
	minIndex = 1;	minIndex = 1;
	minVal = m_floats[1];	minVal = m_floats[1];
	}	}

	skipping to change at line 609	skipping to change at line 611
	{	{

	btVector3 swappedVec;	btVector3 swappedVec;
	for (int i=0;i<4;i++)	for (int i=0;i<4;i++)
	{	{
	btSwapScalarEndian(vector[i],swappedVec[i]);	btSwapScalarEndian(vector[i],swappedVec[i]);
	}	}
	vector = swappedVec;	vector = swappedVec;
	}	}


		SIMD_FORCE_INLINE void btPlaneSpace1 (const btVector3& n, btVector3& p, btV
		ector3& q)
		{
		if (btFabs(n.z()) > SIMDSQRT12) {
		// choose p in y-z plane
		btScalar a = n[1]n[1] + n[2]n[2];
		btScalar k = btRecipSqrt (a);
		p.setValue(0,-n[2]k,n[1]k);
		// set q = n x p
		q.setValue(ak,-n[0]p[2],n[0]*p[1]);
		}
		else {
		// choose p in x-y plane
		btScalar a = n.x()n.x() + n.y()n.y();
		btScalar k = btRecipSqrt (a);
		p.setValue(-n.y()k,n.x()k,0);
		// set q = n x p
		q.setValue(-n.z()p.y(),n.z()p.x(),a*k);
		}
		}

	#endif //SIMD__VECTOR3_H	#endif //SIMD__VECTOR3_H

End of changes. 15 change blocks.
	14 lines changed or deleted	37 lines changed or added

	bt_constraint.h	bt_constraint.h

	skipping to change at line 30	skipping to change at line 30
	Written by: Nicola Candussi <nicola@fluidinteractive.com>	Written by: Nicola Candussi <nicola@fluidinteractive.com>
	*/	*/

	//bt_constraint.h	//bt_constraint.h

	#ifndef DYN_BT_CONSTRAINT_H	#ifndef DYN_BT_CONSTRAINT_H
	#define DYN_BT_CONSTRAINT_H	#define DYN_BT_CONSTRAINT_H

	#include "btBulletCollisionCommon.h"	#include "btBulletCollisionCommon.h"
	#include "btBulletDynamicsCommon.h"	#include "btBulletDynamicsCommon.h"

		#include "shared_ptr.h"

	class bt_constraint_t	class bt_constraint_t
	{	{
	public:	public:

	protected:	protected:
	friend class bt_solver_t;	friend class bt_solver_t;

	bt_constraint_t() { }	bt_constraint_t() { }

	btTypedConstraint* constraint() { return m_constrai nt.get(); }	btTypedConstraint* constraint() { return m_constrai nt.get(); }
	void set_constraint(btTypedConstraint *constraint) { return m_constrai nt.reset(constraint); }	void set_constraint(btTypedConstraint *constraint) { return m_constrai nt.reset(constraint); }

		virtual void update_constraint() = 0;

	public:	public:
	friend class bt_rigid_body_t;	friend class bt_rigid_body_t;

	virtual ~bt_constraint_t() { }	virtual ~bt_constraint_t() { }

	protected:	protected:
	shared_ptr<btTypedConstraint> m_constraint;	shared_ptr<btTypedConstraint> m_constraint;
	};	};


End of changes. 2 change blocks.
	0 lines changed or deleted	2 lines changed or added

	bt_nail_constraint.h	bt_nail_constraint.h

	skipping to change at line 45	skipping to change at line 45
	btPoint2PointConstraint* p2pc = static_cast<btPoint2PointConstraint *>(m_constraint.get());	btPoint2PointConstraint* p2pc = static_cast<btPoint2PointConstraint *>(m_constraint.get());
	p2pc->m_setting.m_damping = d;	p2pc->m_setting.m_damping = d;
	}	}

	virtual float damping() const {	virtual float damping() const {
	btPoint2PointConstraint const* p2pc = static_cast<btPoint2PointCons traint const*>(m_constraint.get());	btPoint2PointConstraint const* p2pc = static_cast<btPoint2PointCons traint const*>(m_constraint.get());
	return p2pc->m_setting.m_damping;	return p2pc->m_setting.m_damping;
	}	}

	//	//

	virtual void set_pivot(vec3f const &p) {	virtual void set_pivotA(vec3f const &p) {
	btPoint2PointConstraint* p2pc = static_cast<btPoint2PointConstraint *>(m_constraint.get());	btPoint2PointConstraint* p2pc = static_cast<btPoint2PointConstraint *>(m_constraint.get());
	btVector3 bt_pivot(p[0], p[1], p[2]);	btVector3 bt_pivot(p[0], p[1], p[2]);
	p2pc->setPivotA(bt_pivot);	p2pc->setPivotA(bt_pivot);
	p2pc->setPivotB(m_constraint->getRigidBodyA().getCenterOfMassTransf orm()(bt_pivot));	p2pc->setPivotB(m_constraint->getRigidBodyA().getCenterOfMassTransf orm()(bt_pivot));
	// p2pc->buildJacobian();	// p2pc->buildJacobian();
	}	}


	virtual void get_pivot(vec3f &p) const {	virtual void get_pivotA(vec3f &p) const {
	btPoint2PointConstraint const* p2pc = static_cast<btPoint2PointCons traint const*>(m_constraint.get());	btPoint2PointConstraint const* p2pc = static_cast<btPoint2PointCons traint const*>(m_constraint.get());
	p[0] = p2pc->getPivotInA().x();	p[0] = p2pc->getPivotInA().x();
	p[1] = p2pc->getPivotInA().y();	p[1] = p2pc->getPivotInA().y();
	p[2] = p2pc->getPivotInA().z();	p[2] = p2pc->getPivotInA().z();
	}	}

	virtual void get_world_pivot(vec3f &p) const {	virtual void get_world_pivot(vec3f &p) const {
	btPoint2PointConstraint const* p2pc = static_cast<btPoint2PointCons traint const*>(m_constraint.get());	btPoint2PointConstraint const* p2pc = static_cast<btPoint2PointCons traint const*>(m_constraint.get());
	p[0] = p2pc->getPivotInB().x();	p[0] = p2pc->getPivotInB().x();
	p[1] = p2pc->getPivotInB().y();	p[1] = p2pc->getPivotInB().y();
	p[2] = p2pc->getPivotInB().z();	p[2] = p2pc->getPivotInB().z();
	}	}


		virtual void set_world(vec3f const &p) {
		btPoint2PointConstraint* p2pc = static_cast<btPoint2PointConstraint
		*>(m_constraint.get());
		btVector3 world(p[0], p[1], p[2]);
		btVector3 pivotA = p2pc->getRigidBodyA().getWorldTransform()
		.inverse() (world);
		p2pc->setPivotA(pivotA);
		p2pc->setPivotB(world);
		p2pc->buildJacobian();
		}

		virtual void get_world(vec3f &p) const {
		btPoint2PointConstraint const* p2pc = static_cast<btPoint2PointCons
		traint const*>(m_constraint.get());
		p[0] = p2pc->getPivotInB().x();
		p[1] = p2pc->getPivotInB().y();
		p[2] = p2pc->getPivotInB().z();
		}

		virtual void update_constraint()
		{
		btPoint2PointConstraint* p2pc = static_cast<btPoint2PointConstraint
		*>(m_constraint.get());
		btVector3 world = p2pc->getPivotInB();
		btVector3 pivotA = p2pc->getRigidBodyA().getWorldTransform()
		.inverse() (world);
		p2pc->setPivotA(pivotA);
		}
	protected:	protected:
	friend class bt_solver_t;	friend class bt_solver_t;

	bt_nail_constraint_t(rigid_body_impl_t* rb, vec3f const& pivot):	bt_nail_constraint_t(rigid_body_impl_t* rb, vec3f const& pivot):
	nail_constraint_impl_t()	nail_constraint_impl_t()
	{	{
	btRigidBody& bt_body = static_cast<bt_rigid_body_t>(rb)->body();	btRigidBody& bt_body = static_cast<bt_rigid_body_t>(rb)->body();

		btVector3 pivotA = bt_body.getCenterOfMassPosition();
	m_constraint.reset(new btPoint2PointConstraint(bt_body, btVector3(p	m_constraint.reset(new btPoint2PointConstraint(bt_body, -pivotA));
	ivot[0], pivot[1], pivot[2])));	rb->add_constraint(this);
	}	}

	private:	private:

	};	};

	#endif	#endif

End of changes. 4 change blocks.
	5 lines changed or deleted	33 lines changed or added

	bt_rigid_body.h	bt_rigid_body.h

	skipping to change at line 31	skipping to change at line 31
	*/	*/

	//bt_rigid_body.h	//bt_rigid_body.h

	#ifndef DYN_BT_RIGID_BODY_H	#ifndef DYN_BT_RIGID_BODY_H
	#define DYN_BT_RIGID_BODY_H	#define DYN_BT_RIGID_BODY_H

	#include "shared_ptr.h"	#include "shared_ptr.h"
	#include "rigid_body_impl.h"	#include "rigid_body_impl.h"
	#include "bt_collision_shape.h"	#include "bt_collision_shape.h"

		#include "LinearMath/btAlignedObjectArray.h"
		#include "constraint/bt_constraint.h"

	class bt_rigid_body_t: public rigid_body_impl_t {	class bt_rigid_body_t: public rigid_body_impl_t {
	public:	public:
	virtual void get_transform(mat4x4f &xform) const	virtual void get_transform(mat4x4f &xform) const
	{	{
	float m[16];	float m[16];
	m_body->getWorldTransform().getOpenGLMatrix(m);	m_body->getWorldTransform().getOpenGLMatrix(m);
	xform = trans(cmat<float, 4, 4>(m));	xform = trans(cmat<float, 4, 4>(m));
	}	}


	skipping to change at line 156	skipping to change at line 158
	virtual void apply_central_force(vec3f const& f)	virtual void apply_central_force(vec3f const& f)
	{	{
	m_body->applyCentralForce(btVector3(f[0], f[1], f[2]));	m_body->applyCentralForce(btVector3(f[0], f[1], f[2]));
	}	}

	virtual void apply_torque(vec3f const& t)	virtual void apply_torque(vec3f const& t)
	{	{
	m_body->applyTorque(btVector3(t[0], t[1], t[2]));	m_body->applyTorque(btVector3(t[0], t[1], t[2]));
	}	}


		virtual void update_constraint()
		{
		int count = m_constraintRef.size();
		for(int i=0; i<count; i++)
		{
		m_constraintRef[i]->update_constraint();
		}
		}

	btRigidBody* body() { return m_body.get(); }	btRigidBody* body() { return m_body.get(); }


		virtual void add_constraint(bt_constraint_t* constraint)
		{
		m_constraintRef.push_back(constraint);
		}
		virtual void remove_constraint(bt_constraint_t* constraint)
		{
		m_constraintRef.remove(constraint);
		}
	protected:	protected:
	friend class bt_solver_t;	friend class bt_solver_t;

		btAlignedObjectArray<bt_constraint_t*> m_constraintRef;

	bt_rigid_body_t(collision_shape_impl_t* cs):	bt_rigid_body_t(collision_shape_impl_t* cs):
	m_collision_shape(cs),	m_collision_shape(cs),
	m_mass(1),	m_mass(1),
	m_inertia(2.0/5.0, 2.0/5.0, 2.0/5.0),	m_inertia(2.0/5.0, 2.0/5.0, 2.0/5.0),
	m_linear_damping(0),	m_linear_damping(0),
	m_angular_damping(0)	m_angular_damping(0)
	{	{
	bt_collision_shape_t* bt_shape = dynamic_cast<bt_collision_shape_t* >(cs);	bt_collision_shape_t* bt_shape = dynamic_cast<bt_collision_shape_t* >(cs);
	btRigidBody::btRigidBodyConstructionInfo rbInfo(m_mass, NULL, bt_sh ape->shape(), m_inertia);	btRigidBody::btRigidBodyConstructionInfo rbInfo(m_mass, NULL, bt_sh ape->shape(), m_inertia);

End of changes. 4 change blocks.
	0 lines changed or deleted	20 lines changed or added

	bt_solver.h	bt_solver.h

	skipping to change at line 40	skipping to change at line 40
	#include "BulletCollision/Gimpact/btGImpactShape.h"	#include "BulletCollision/Gimpact/btGImpactShape.h"
	#include "BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h"	#include "BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h"

	#include "solver_impl.h"	#include "solver_impl.h"
	#include "bt_rigid_body.h"	#include "bt_rigid_body.h"
	#include "bt_sphere_shape.h"	#include "bt_sphere_shape.h"
	#include "bt_plane_shape.h"	#include "bt_plane_shape.h"
	#include "bt_box_shape.h"	#include "bt_box_shape.h"
	#include "bt_convex_hull_shape.h"	#include "bt_convex_hull_shape.h"
	#include "bt_mesh_shape.h"	#include "bt_mesh_shape.h"

	#include "bt_nail_constraint.h"	#include "constraint/bt_nail_constraint.h"
		#include "constraint/bt_hinge_constraint.h"
		#include "constraint/bt_slider_constraint.h"
		#include "constraint/bt_sixdof_constraint.h"

	class bt_solver_t: public solver_impl_t	class bt_solver_t: public solver_impl_t
	{	{
	public:	public:
	virtual rigid_body_impl_t* create_rigid_body(collision_shape_impl_t* cs ) {	virtual rigid_body_impl_t* create_rigid_body(collision_shape_impl_t* cs ) {
	return new bt_rigid_body_t(cs);	return new bt_rigid_body_t(cs);
	}	}

	virtual collision_shape_impl_t* create_sphere_shape(float radius) {	virtual collision_shape_impl_t* create_sphere_shape(float radius) {
	return new bt_sphere_shape_t(radius);	return new bt_sphere_shape_t(radius);

	skipping to change at line 79	skipping to change at line 82
	vec3f const* normals,	vec3f const* normals,
	unsigned int const *i ndices, size_t num_indices)	unsigned int const *i ndices, size_t num_indices)
	{	{
	return new bt_mesh_shape_t(vertices, num_vertices, normals, indices , num_indices);	return new bt_mesh_shape_t(vertices, num_vertices, normals, indices , num_indices);
	}	}

	virtual nail_constraint_impl_t* create_nail_constraint(rigid_body_impl_ t* rb, vec3f const& pivot)	virtual nail_constraint_impl_t* create_nail_constraint(rigid_body_impl_ t* rb, vec3f const& pivot)
	{	{
	return new bt_nail_constraint_t(rb, pivot);	return new bt_nail_constraint_t(rb, pivot);
	}	}

		virtual hinge_constraint_impl_t* create_hinge_constraint(rigid_body_imp
		l_t* rb, vec3f const& pivot)
		{
		return new bt_hinge_constraint_t(rb, pivot);
		}
		virtual slider_constraint_impl_t* create_slider_constraint(rigid_body_i
		mpl_t* rbA, vec3f const& pivotA, rigid_body_impl_t* rbB, vec3f const& pivot
		B)
		{
		return new bt_slider_constraint_t(rbA, pivotA, rbB, pivotB);
		}
		virtual sixdof_constraint_impl_t* create_sixdof_constraint(rigid_body_i
		mpl_t* rbA, vec3f const& pivotA, rigid_body_impl_t* rbB, vec3f const& pivot
		B)
		{
		return new bt_sixdof_constraint_t(rbA, pivotA, rbB, pivotB);
		}

	virtual void add_rigid_body(rigid_body_impl_t* rb)	virtual void add_rigid_body(rigid_body_impl_t* rb)
	{	{
	bt_rigid_body_t* bt_body = static_cast<bt_rigid_body_t*>(rb);	bt_rigid_body_t* bt_body = static_cast<bt_rigid_body_t*>(rb);
	m_dynamicsWorld->addRigidBody(bt_body->body());	m_dynamicsWorld->addRigidBody(bt_body->body());
	}	}

	virtual void remove_rigid_body(rigid_body_impl_t* rb)	virtual void remove_rigid_body(rigid_body_impl_t* rb)
	{	{
	bt_rigid_body_t* bt_body = static_cast<bt_rigid_body_t*>(rb);	bt_rigid_body_t* bt_body = static_cast<bt_rigid_body_t*>(rb);

End of changes. 2 change blocks.
	1 lines changed or deleted	21 lines changed or added

	gim_memory.h	gim_memory.h

	skipping to change at line 36	skipping to change at line 36

	This library is distributed in the hope that it will be useful,	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
	GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD .TXT for more details.	GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD .TXT for more details.

	--------------------------------------------------------------------------- --	--------------------------------------------------------------------------- --
	*/	*/

	#include "gim_math.h"	#include "gim_math.h"

	#include <memory.h>	#include <string.h>

	#ifdef PREFETCH	#ifdef PREFETCH
	#include <xmmintrin.h> // for prefetch	#include <xmmintrin.h> // for prefetch
	#define pfval 64	#define pfval 64
	#define pfval2 128	#define pfval2 128
	//! Prefetch 64	//! Prefetch 64
	#define pf(_x,_i) _mm_prefetch((void *)(_x + _i + pfval), 0)	#define pf(_x,_i) _mm_prefetch((void *)(_x + _i + pfval), 0)
	//! Prefetch 128	//! Prefetch 128
	#define pf2(_x,_i) _mm_prefetch((void *)(_x + _i + pfval2), 0)	#define pf2(_x,_i) _mm_prefetch((void *)(_x + _i + pfval2), 0)
	#else	#else

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	glext.h	glext.h
	#ifndef __glext_h_	#ifndef __glext_h_
	#define __glext_h_	#define __glext_h_

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif


	/*	/**************************************************************************
	** Copyright 1998, 1999, 2000, 2001, NVIDIA Corporation.	****
	** All rights Reserved.
	**	Copyright NVIDIA Corporation 2006
	** THE INFORMATION CONTAINED HEREIN IS PROPRIETARY AND CONFIDENTIAL TO
	** NVIDIA, CORPORATION. USE, REPRODUCTION OR DISCLOSURE TO ANY THIRD PARTY	TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVID
	** IS SUBJECT TO WRITTEN PRE-APPROVAL BY NVIDIA, CORPORATION.	ED
	*/	AS IS AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRE
		SS
		OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
		MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL
		NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, O
		R
		CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES F
		OR
		LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMAT
		ION,
		OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR INABILITY TO USE
		THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
		DAMAGES.

		***************************************************************************
		***/

	/*	/*
	** License Applicability. Except to the extent portions of this file are	** License Applicability. Except to the extent portions of this file are
	** made subject to an alternative license as permitted in the SGI Free	** made subject to an alternative license as permitted in the SGI Free
	** Software License B, Version 1.1 (the "License"), the contents of this	** Software License B, Version 1.1 (the "License"), the contents of this
	** file are subject only to the provisions of the License. You may not use	** file are subject only to the provisions of the License. You may not use
	** this file except in compliance with the License. You may obtain a copy	** this file except in compliance with the License. You may obtain a copy
	** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600	** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
	** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:	** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
	**	**
	** http://oss.sgi.com/projects/FreeB	** http://oss.sgi.com/projects/FreeB
	**	**
	** Note that, as provided in the License, the Software is distributed on an	** Note that, as provided in the License, the Software is distributed on an
	** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS	** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
	** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND	** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
	** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A	** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
	** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.	** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
	**	**
	** Original Code. The Original Code is: OpenGL Sample Implementation,	** Original Code. The Original Code is: OpenGL Sample Implementation,
	** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,	** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,

	** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.	** Inc. The Original Code is Copyright (c) 1991-2004 Silicon Graphics, Inc.
	** Copyright in any portions created by third parties is as indicated	** Copyright in any portions created by third parties is as indicated
	** elsewhere herein. All Rights Reserved.	** elsewhere herein. All Rights Reserved.
	**	**
	** Additional Notice Provisions: This software was created using the	** Additional Notice Provisions: This software was created using the
	** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has	** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
	** not been independently verified as being compliant with the OpenGL(R)	** not been independently verified as being compliant with the OpenGL(R)
	** version 1.2.1 Specification.	** version 1.2.1 Specification.
	*/	*/


	#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)	#ifndef GLAPIENTRY
	#define WIN32_LEAN_AND_MEAN 1	# ifdef _WIN32
	#include <windows.h>	# if (_MSC_VER >= 800) \|\| defined(_STDCALL_SUPPORTED) /* Mimic <windef.h>
		*/
		# define GLAPIENTRY __stdcall
		# else
		# define GLAPIENTRY
		# endif
		# else
		# define GLAPIENTRY
		# endif
	#endif	#endif


	#ifndef APIENTRY	#ifndef GLAPI
	#define APIENTRY	# define GLAPI extern
		#endif

		#ifndef GLAPIENTRYP
		# define GLAPIENTRYP GLAPIENTRY *
	#endif	#endif

	/*************************************************************/	/*************************************************************/

	/* Header file version number, required by OpenGL ABI for Linux */	/* Header file version number, required by OpenGL ABI for Linux */

	#define GL_GLEXT_VERSION 6	/* glext.h last updated 2005/06/06 */
		/* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */
		#define GL_GLEXT_VERSION 28

	#ifndef GL_VERSION_1_2	#ifndef GL_VERSION_1_2

		#define GL_UNSIGNED_BYTE_3_3_2 0x8032
		#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
		#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
		#define GL_UNSIGNED_INT_8_8_8_8 0x8035
		#define GL_UNSIGNED_INT_10_10_10_2 0x8036
		#define GL_RESCALE_NORMAL 0x803A
		#define GL_TEXTURE_BINDING_3D 0x806A
		#define GL_PACK_SKIP_IMAGES 0x806B
		#define GL_PACK_IMAGE_HEIGHT 0x806C
		#define GL_UNPACK_SKIP_IMAGES 0x806D
		#define GL_UNPACK_IMAGE_HEIGHT 0x806E
		#define GL_TEXTURE_3D 0x806F
		#define GL_PROXY_TEXTURE_3D 0x8070
		#define GL_TEXTURE_DEPTH 0x8071
		#define GL_TEXTURE_WRAP_R 0x8072
		#define GL_MAX_3D_TEXTURE_SIZE 0x8073
		#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
		#define GL_UNSIGNED_SHORT_5_6_5 0x8363
		#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
		#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
		#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
		#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
		#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
		#define GL_BGR 0x80E0
		#define GL_BGRA 0x80E1
		#define GL_MAX_ELEMENTS_VERTICES 0x80E8
		#define GL_MAX_ELEMENTS_INDICES 0x80E9
		#define GL_CLAMP_TO_EDGE 0x812F
		#define GL_TEXTURE_MIN_LOD 0x813A
		#define GL_TEXTURE_MAX_LOD 0x813B
		#define GL_TEXTURE_BASE_LEVEL 0x813C
		#define GL_TEXTURE_MAX_LEVEL 0x813D
		#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
		#define GL_SINGLE_COLOR 0x81F9
		#define GL_SEPARATE_SPECULAR_COLOR 0x81FA
		#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12
		#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13
		#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22
		#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23
		#define GL_ALIASED_POINT_SIZE_RANGE 0x846D
		#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
		#endif

		#ifndef GL_ARB_imaging
	#define GL_CONSTANT_COLOR 0x8001	#define GL_CONSTANT_COLOR 0x8001
	#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002	#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
	#define GL_CONSTANT_ALPHA 0x8003	#define GL_CONSTANT_ALPHA 0x8003
	#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004	#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
	#define GL_BLEND_COLOR 0x8005	#define GL_BLEND_COLOR 0x8005
	#define GL_FUNC_ADD 0x8006	#define GL_FUNC_ADD 0x8006
	#define GL_MIN 0x8007	#define GL_MIN 0x8007
	#define GL_MAX 0x8008	#define GL_MAX 0x8008
	#define GL_BLEND_EQUATION 0x8009	#define GL_BLEND_EQUATION 0x8009
	#define GL_FUNC_SUBTRACT 0x800A	#define GL_FUNC_SUBTRACT 0x800A

	skipping to change at line 106	skipping to change at line 171
	#define GL_HISTOGRAM_RED_SIZE 0x8028	#define GL_HISTOGRAM_RED_SIZE 0x8028
	#define GL_HISTOGRAM_GREEN_SIZE 0x8029	#define GL_HISTOGRAM_GREEN_SIZE 0x8029
	#define GL_HISTOGRAM_BLUE_SIZE 0x802A	#define GL_HISTOGRAM_BLUE_SIZE 0x802A
	#define GL_HISTOGRAM_ALPHA_SIZE 0x802B	#define GL_HISTOGRAM_ALPHA_SIZE 0x802B
	#define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C	#define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C
	#define GL_HISTOGRAM_SINK 0x802D	#define GL_HISTOGRAM_SINK 0x802D
	#define GL_MINMAX 0x802E	#define GL_MINMAX 0x802E
	#define GL_MINMAX_FORMAT 0x802F	#define GL_MINMAX_FORMAT 0x802F
	#define GL_MINMAX_SINK 0x8030	#define GL_MINMAX_SINK 0x8030
	#define GL_TABLE_TOO_LARGE 0x8031	#define GL_TABLE_TOO_LARGE 0x8031

	#define GL_UNSIGNED_BYTE_3_3_2 0x8032
	#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
	#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
	#define GL_UNSIGNED_INT_8_8_8_8 0x8035
	#define GL_UNSIGNED_INT_10_10_10_2 0x8036
	#define GL_RESCALE_NORMAL 0x803A
	#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
	#define GL_UNSIGNED_SHORT_5_6_5 0x8363
	#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
	#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
	#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
	#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
	#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
	#define GL_COLOR_MATRIX 0x80B1	#define GL_COLOR_MATRIX 0x80B1
	#define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2	#define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2
	#define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3	#define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3
	#define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4	#define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4
	#define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5	#define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5
	#define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6	#define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6
	#define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7	#define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7
	#define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8	#define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8
	#define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9	#define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9
	#define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA	#define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA

		#define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB
	#define GL_COLOR_TABLE 0x80D0	#define GL_COLOR_TABLE 0x80D0
	#define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1	#define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1
	#define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2	#define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2
	#define GL_PROXY_COLOR_TABLE 0x80D3	#define GL_PROXY_COLOR_TABLE 0x80D3
	#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4	#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4
	#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5	#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5
	#define GL_COLOR_TABLE_SCALE 0x80D6	#define GL_COLOR_TABLE_SCALE 0x80D6
	#define GL_COLOR_TABLE_BIAS 0x80D7	#define GL_COLOR_TABLE_BIAS 0x80D7
	#define GL_COLOR_TABLE_FORMAT 0x80D8	#define GL_COLOR_TABLE_FORMAT 0x80D8
	#define GL_COLOR_TABLE_WIDTH 0x80D9	#define GL_COLOR_TABLE_WIDTH 0x80D9
	#define GL_COLOR_TABLE_RED_SIZE 0x80DA	#define GL_COLOR_TABLE_RED_SIZE 0x80DA
	#define GL_COLOR_TABLE_GREEN_SIZE 0x80DB	#define GL_COLOR_TABLE_GREEN_SIZE 0x80DB
	#define GL_COLOR_TABLE_BLUE_SIZE 0x80DC	#define GL_COLOR_TABLE_BLUE_SIZE 0x80DC
	#define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD	#define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD
	#define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE	#define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE
	#define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF	#define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF

	#define GL_CLAMP_TO_EDGE 0x812F	#define GL_CONSTANT_BORDER 0x8151
	#define GL_TEXTURE_MIN_LOD 0x813A	#define GL_REPLICATE_BORDER 0x8153
	#define GL_TEXTURE_MAX_LOD 0x813B	#define GL_CONVOLUTION_BORDER_COLOR 0x8154
	#define GL_TEXTURE_BASE_LEVEL 0x813C	#endif
	#define GL_TEXTURE_MAX_LEVEL 0x813D
		#ifndef GL_VERSION_1_3
		#define GL_TEXTURE0 0x84C0
		#define GL_TEXTURE1 0x84C1
		#define GL_TEXTURE2 0x84C2
		#define GL_TEXTURE3 0x84C3
		#define GL_TEXTURE4 0x84C4
		#define GL_TEXTURE5 0x84C5
		#define GL_TEXTURE6 0x84C6
		#define GL_TEXTURE7 0x84C7
		#define GL_TEXTURE8 0x84C8
		#define GL_TEXTURE9 0x84C9
		#define GL_TEXTURE10 0x84CA
		#define GL_TEXTURE11 0x84CB
		#define GL_TEXTURE12 0x84CC
		#define GL_TEXTURE13 0x84CD
		#define GL_TEXTURE14 0x84CE
		#define GL_TEXTURE15 0x84CF
		#define GL_TEXTURE16 0x84D0
		#define GL_TEXTURE17 0x84D1
		#define GL_TEXTURE18 0x84D2
		#define GL_TEXTURE19 0x84D3
		#define GL_TEXTURE20 0x84D4
		#define GL_TEXTURE21 0x84D5
		#define GL_TEXTURE22 0x84D6
		#define GL_TEXTURE23 0x84D7
		#define GL_TEXTURE24 0x84D8
		#define GL_TEXTURE25 0x84D9
		#define GL_TEXTURE26 0x84DA
		#define GL_TEXTURE27 0x84DB
		#define GL_TEXTURE28 0x84DC
		#define GL_TEXTURE29 0x84DD
		#define GL_TEXTURE30 0x84DE
		#define GL_TEXTURE31 0x84DF
		#define GL_ACTIVE_TEXTURE 0x84E0
		#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1
		#define GL_MAX_TEXTURE_UNITS 0x84E2
		#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3
		#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4
		#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5
		#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6
		#define GL_MULTISAMPLE 0x809D
		#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
		#define GL_SAMPLE_ALPHA_TO_ONE 0x809F
		#define GL_SAMPLE_COVERAGE 0x80A0
		#define GL_SAMPLE_BUFFERS 0x80A8
		#define GL_SAMPLES 0x80A9
		#define GL_SAMPLE_COVERAGE_VALUE 0x80AA
		#define GL_SAMPLE_COVERAGE_INVERT 0x80AB
		#define GL_MULTISAMPLE_BIT 0x20000000
		#define GL_NORMAL_MAP 0x8511
		#define GL_REFLECTION_MAP 0x8512
		#define GL_TEXTURE_CUBE_MAP 0x8513
		#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
		#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
		#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
		#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
		#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
		#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
		#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
		#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B
		#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
		#define GL_COMPRESSED_ALPHA 0x84E9
		#define GL_COMPRESSED_LUMINANCE 0x84EA
		#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB
		#define GL_COMPRESSED_INTENSITY 0x84EC
		#define GL_COMPRESSED_RGB 0x84ED
		#define GL_COMPRESSED_RGBA 0x84EE
		#define GL_TEXTURE_COMPRESSION_HINT 0x84EF
		#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0
		#define GL_TEXTURE_COMPRESSED 0x86A1
		#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
		#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
		#define GL_CLAMP_TO_BORDER 0x812D
		#define GL_COMBINE 0x8570
		#define GL_COMBINE_RGB 0x8571
		#define GL_COMBINE_ALPHA 0x8572
		#define GL_SOURCE0_RGB 0x8580
		#define GL_SOURCE1_RGB 0x8581
		#define GL_SOURCE2_RGB 0x8582
		#define GL_SOURCE0_ALPHA 0x8588
		#define GL_SOURCE1_ALPHA 0x8589
		#define GL_SOURCE2_ALPHA 0x858A
		#define GL_OPERAND0_RGB 0x8590
		#define GL_OPERAND1_RGB 0x8591
		#define GL_OPERAND2_RGB 0x8592
		#define GL_OPERAND0_ALPHA 0x8598
		#define GL_OPERAND1_ALPHA 0x8599
		#define GL_OPERAND2_ALPHA 0x859A
		#define GL_RGB_SCALE 0x8573
		#define GL_ADD_SIGNED 0x8574
		#define GL_INTERPOLATE 0x8575
		#define GL_SUBTRACT 0x84E7
		#define GL_CONSTANT 0x8576
		#define GL_PRIMARY_COLOR 0x8577
		#define GL_PREVIOUS 0x8578
		#define GL_DOT3_RGB 0x86AE
		#define GL_DOT3_RGBA 0x86AF
		#endif

		#ifndef GL_VERSION_1_4
		#define GL_BLEND_DST_RGB 0x80C8
		#define GL_BLEND_SRC_RGB 0x80C9
		#define GL_BLEND_DST_ALPHA 0x80CA
		#define GL_BLEND_SRC_ALPHA 0x80CB
		#define GL_POINT_SIZE_MIN 0x8126
		#define GL_POINT_SIZE_MAX 0x8127
		#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128
		#define GL_POINT_DISTANCE_ATTENUATION 0x8129
		#define GL_GENERATE_MIPMAP 0x8191
		#define GL_GENERATE_MIPMAP_HINT 0x8192
		#define GL_DEPTH_COMPONENT16 0x81A5
		#define GL_DEPTH_COMPONENT24 0x81A6
		#define GL_DEPTH_COMPONENT32 0x81A7
		#define GL_MIRRORED_REPEAT 0x8370
		#define GL_FOG_COORDINATE_SOURCE 0x8450
		#define GL_FOG_COORDINATE 0x8451
		#define GL_FRAGMENT_DEPTH 0x8452
		#define GL_CURRENT_FOG_COORDINATE 0x8453
		#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454
		#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455
		#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456
		#define GL_FOG_COORDINATE_ARRAY 0x8457
		#define GL_COLOR_SUM 0x8458
		#define GL_CURRENT_SECONDARY_COLOR 0x8459
		#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A
		#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B
		#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C
		#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D
		#define GL_SECONDARY_COLOR_ARRAY 0x845E
		#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
		#define GL_TEXTURE_FILTER_CONTROL 0x8500
		#define GL_TEXTURE_LOD_BIAS 0x8501
		#define GL_INCR_WRAP 0x8507
		#define GL_DECR_WRAP 0x8508
		#define GL_TEXTURE_DEPTH_SIZE 0x884A
		#define GL_DEPTH_TEXTURE_MODE 0x884B
		#define GL_TEXTURE_COMPARE_MODE 0x884C
		#define GL_TEXTURE_COMPARE_FUNC 0x884D
		#define GL_COMPARE_R_TO_TEXTURE 0x884E
		#endif

		#ifndef GL_VERSION_1_5
		#define GL_BUFFER_SIZE 0x8764
		#define GL_BUFFER_USAGE 0x8765
		#define GL_QUERY_COUNTER_BITS 0x8864
		#define GL_CURRENT_QUERY 0x8865
		#define GL_QUERY_RESULT 0x8866
		#define GL_QUERY_RESULT_AVAILABLE 0x8867
		#define GL_ARRAY_BUFFER 0x8892
		#define GL_ELEMENT_ARRAY_BUFFER 0x8893
		#define GL_ARRAY_BUFFER_BINDING 0x8894
		#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
		#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896
		#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897
		#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898
		#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899
		#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A
		#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B
		#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C
		#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D
		#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E
		#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
		#define GL_READ_ONLY 0x88B8
		#define GL_WRITE_ONLY 0x88B9
		#define GL_READ_WRITE 0x88BA
		#define GL_BUFFER_ACCESS 0x88BB
		#define GL_BUFFER_MAPPED 0x88BC
		#define GL_BUFFER_MAP_POINTER 0x88BD
		#define GL_STREAM_DRAW 0x88E0
		#define GL_STREAM_READ 0x88E1
		#define GL_STREAM_COPY 0x88E2
		#define GL_STATIC_DRAW 0x88E4
		#define GL_STATIC_READ 0x88E5
		#define GL_STATIC_COPY 0x88E6
		#define GL_DYNAMIC_DRAW 0x88E8
		#define GL_DYNAMIC_READ 0x88E9
		#define GL_DYNAMIC_COPY 0x88EA
		#define GL_SAMPLES_PASSED 0x8914
		#define GL_FOG_COORD_SRC GL_FOG_COORDINATE_SOURCE
		#define GL_FOG_COORD GL_FOG_COORDINATE
		#define GL_CURRENT_FOG_COORD GL_CURRENT_FOG_COORDINATE
		#define GL_FOG_COORD_ARRAY_TYPE GL_FOG_COORDINATE_ARRAY_TYPE
		#define GL_FOG_COORD_ARRAY_STRIDE GL_FOG_COORDINATE_ARRAY_STRIDE
		#define GL_FOG_COORD_ARRAY_POINTER GL_FOG_COORDINATE_ARRAY_POINTER
		#define GL_FOG_COORD_ARRAY GL_FOG_COORDINATE_ARRAY
		#define GL_FOG_COORD_ARRAY_BUFFER_BINDING GL_FOG_COORDINATE_ARRAY_BUFFER_BI
		NDING
		#define GL_SRC0_RGB GL_SOURCE0_RGB
		#define GL_SRC1_RGB GL_SOURCE1_RGB
		#define GL_SRC2_RGB GL_SOURCE2_RGB
		#define GL_SRC0_ALPHA GL_SOURCE0_ALPHA
		#define GL_SRC1_ALPHA GL_SOURCE1_ALPHA
		#define GL_SRC2_ALPHA GL_SOURCE2_ALPHA
		#endif

		#ifndef GL_VERSION_2_0
		#define GL_BLEND_EQUATION_RGB GL_BLEND_EQUATION
		#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
		#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
		#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
		#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
		#define GL_CURRENT_VERTEX_ATTRIB 0x8626
		#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
		#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643
		#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
		#define GL_STENCIL_BACK_FUNC 0x8800
		#define GL_STENCIL_BACK_FAIL 0x8801
		#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
		#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
		#define GL_MAX_DRAW_BUFFERS 0x8824
		#define GL_DRAW_BUFFER0 0x8825
		#define GL_DRAW_BUFFER1 0x8826
		#define GL_DRAW_BUFFER2 0x8827
		#define GL_DRAW_BUFFER3 0x8828
		#define GL_DRAW_BUFFER4 0x8829
		#define GL_DRAW_BUFFER5 0x882A
		#define GL_DRAW_BUFFER6 0x882B
		#define GL_DRAW_BUFFER7 0x882C
		#define GL_DRAW_BUFFER8 0x882D
		#define GL_DRAW_BUFFER9 0x882E
		#define GL_DRAW_BUFFER10 0x882F
		#define GL_DRAW_BUFFER11 0x8830
		#define GL_DRAW_BUFFER12 0x8831
		#define GL_DRAW_BUFFER13 0x8832
		#define GL_DRAW_BUFFER14 0x8833
		#define GL_DRAW_BUFFER15 0x8834
		#define GL_BLEND_EQUATION_ALPHA 0x883D
		#define GL_POINT_SPRITE 0x8861
		#define GL_COORD_REPLACE 0x8862
		#define GL_MAX_VERTEX_ATTRIBS 0x8869
		#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
		#define GL_MAX_TEXTURE_COORDS 0x8871
		#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
		#define GL_FRAGMENT_SHADER 0x8B30
		#define GL_VERTEX_SHADER 0x8B31
		#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
		#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
		#define GL_MAX_VARYING_FLOATS 0x8B4B
		#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
		#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
		#define GL_SHADER_TYPE 0x8B4F
		#define GL_FLOAT_VEC2 0x8B50
		#define GL_FLOAT_VEC3 0x8B51
		#define GL_FLOAT_VEC4 0x8B52
		#define GL_INT_VEC2 0x8B53
		#define GL_INT_VEC3 0x8B54
		#define GL_INT_VEC4 0x8B55
		#define GL_BOOL 0x8B56
		#define GL_BOOL_VEC2 0x8B57
		#define GL_BOOL_VEC3 0x8B58
		#define GL_BOOL_VEC4 0x8B59
		#define GL_FLOAT_MAT2 0x8B5A
		#define GL_FLOAT_MAT3 0x8B5B
		#define GL_FLOAT_MAT4 0x8B5C
		#define GL_SAMPLER_1D 0x8B5D
		#define GL_SAMPLER_2D 0x8B5E
		#define GL_SAMPLER_3D 0x8B5F
		#define GL_SAMPLER_CUBE 0x8B60
		#define GL_SAMPLER_1D_SHADOW 0x8B61
		#define GL_SAMPLER_2D_SHADOW 0x8B62
		#define GL_DELETE_STATUS 0x8B80
		#define GL_COMPILE_STATUS 0x8B81
		#define GL_LINK_STATUS 0x8B82
		#define GL_VALIDATE_STATUS 0x8B83
		#define GL_INFO_LOG_LENGTH 0x8B84
		#define GL_ATTACHED_SHADERS 0x8B85
		#define GL_ACTIVE_UNIFORMS 0x8B86
		#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
		#define GL_SHADER_SOURCE_LENGTH 0x8B88
		#define GL_ACTIVE_ATTRIBUTES 0x8B89
		#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
		#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
		#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
		#define GL_CURRENT_PROGRAM 0x8B8D
		#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0
		#define GL_LOWER_LEFT 0x8CA1
		#define GL_UPPER_LEFT 0x8CA2
		#define GL_STENCIL_BACK_REF 0x8CA3
		#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
		#define GL_STENCIL_BACK_WRITEMASK 0x8CA5
		#endif

		#ifndef GL_VERSION_2_1
		#define GL_PIXEL_PACK_BUFFER 0x88EB
		#define GL_PIXEL_UNPACK_BUFFER 0x88EC
		#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
		#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
		#define GL_SRGB 0x8C40
		#define GL_SRGB8 0x8C41
		#define GL_SRGB_ALPHA 0x8C42
		#define GL_SRGB8_ALPHA8 0x8C43
		#define GL_SLUMINANCE_ALPHA 0x8C44
		#define GL_SLUMINANCE8_ALPHA8 0x8C45
		#define GL_SLUMINANCE 0x8C46
		#define GL_SLUMINANCE8 0x8C47
		#define GL_COMPRESSED_SRGB 0x8C48
		#define GL_COMPRESSED_SRGB_ALPHA 0x8C49
		#define GL_COMPRESSED_SLUMINANCE 0x8C4A
		#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B
		#define GL_FLOAT_MAT2x3 0x8B65
		#define GL_FLOAT_MAT2x4 0x8B66
		#define GL_FLOAT_MAT3x2 0x8B67
		#define GL_FLOAT_MAT3x4 0x8B68
		#define GL_FLOAT_MAT4x2 0x8B69
		#define GL_FLOAT_MAT4x3 0x8B6A
		#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F
	#endif	#endif

	#ifndef GL_ARB_multitexture	#ifndef GL_ARB_multitexture
	#define GL_TEXTURE0_ARB 0x84C0	#define GL_TEXTURE0_ARB 0x84C0
	#define GL_TEXTURE1_ARB 0x84C1	#define GL_TEXTURE1_ARB 0x84C1
	#define GL_TEXTURE2_ARB 0x84C2	#define GL_TEXTURE2_ARB 0x84C2
	#define GL_TEXTURE3_ARB 0x84C3	#define GL_TEXTURE3_ARB 0x84C3
	#define GL_TEXTURE4_ARB 0x84C4	#define GL_TEXTURE4_ARB 0x84C4
	#define GL_TEXTURE5_ARB 0x84C5	#define GL_TEXTURE5_ARB 0x84C5
	#define GL_TEXTURE6_ARB 0x84C6	#define GL_TEXTURE6_ARB 0x84C6

	skipping to change at line 209	skipping to change at line 567
	#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB 0x809E	#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB 0x809E
	#define GL_SAMPLE_ALPHA_TO_ONE_ARB 0x809F	#define GL_SAMPLE_ALPHA_TO_ONE_ARB 0x809F
	#define GL_SAMPLE_COVERAGE_ARB 0x80A0	#define GL_SAMPLE_COVERAGE_ARB 0x80A0
	#define GL_SAMPLE_BUFFERS_ARB 0x80A8	#define GL_SAMPLE_BUFFERS_ARB 0x80A8
	#define GL_SAMPLES_ARB 0x80A9	#define GL_SAMPLES_ARB 0x80A9
	#define GL_SAMPLE_COVERAGE_VALUE_ARB 0x80AA	#define GL_SAMPLE_COVERAGE_VALUE_ARB 0x80AA
	#define GL_SAMPLE_COVERAGE_INVERT_ARB 0x80AB	#define GL_SAMPLE_COVERAGE_INVERT_ARB 0x80AB
	#define GL_MULTISAMPLE_BIT_ARB 0x20000000	#define GL_MULTISAMPLE_BIT_ARB 0x20000000
	#endif	#endif


		#ifndef GL_ARB_texture_env_add
		#endif

	#ifndef GL_ARB_texture_cube_map	#ifndef GL_ARB_texture_cube_map
	#define GL_NORMAL_MAP_ARB 0x8511	#define GL_NORMAL_MAP_ARB 0x8511
	#define GL_REFLECTION_MAP_ARB 0x8512	#define GL_REFLECTION_MAP_ARB 0x8512
	#define GL_TEXTURE_CUBE_MAP_ARB 0x8513	#define GL_TEXTURE_CUBE_MAP_ARB 0x8513
	#define GL_TEXTURE_BINDING_CUBE_MAP_ARB 0x8514	#define GL_TEXTURE_BINDING_CUBE_MAP_ARB 0x8514
	#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515	#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515
	#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516	#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516
	#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517	#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517
	#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518	#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518
	#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519	#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519

	skipping to change at line 232	skipping to change at line 593
	#endif	#endif

	#ifndef GL_ARB_texture_compression	#ifndef GL_ARB_texture_compression
	#define GL_COMPRESSED_ALPHA_ARB 0x84E9	#define GL_COMPRESSED_ALPHA_ARB 0x84E9
	#define GL_COMPRESSED_LUMINANCE_ARB 0x84EA	#define GL_COMPRESSED_LUMINANCE_ARB 0x84EA
	#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB	#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB
	#define GL_COMPRESSED_INTENSITY_ARB 0x84EC	#define GL_COMPRESSED_INTENSITY_ARB 0x84EC
	#define GL_COMPRESSED_RGB_ARB 0x84ED	#define GL_COMPRESSED_RGB_ARB 0x84ED
	#define GL_COMPRESSED_RGBA_ARB 0x84EE	#define GL_COMPRESSED_RGBA_ARB 0x84EE
	#define GL_TEXTURE_COMPRESSION_HINT_ARB 0x84EF	#define GL_TEXTURE_COMPRESSION_HINT_ARB 0x84EF

	#define GL_TEXTURE_IMAGE_SIZE_ARB 0x86A0	#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0
	#define GL_TEXTURE_COMPRESSED_ARB 0x86A1	#define GL_TEXTURE_COMPRESSED_ARB 0x86A1
	#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2	#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2
	#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3	#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3
	#endif	#endif


		#ifndef GL_ARB_texture_border_clamp
		#define GL_CLAMP_TO_BORDER_ARB 0x812D
		#endif

		#ifndef GL_ARB_point_parameters
		#define GL_POINT_SIZE_MIN_ARB 0x8126
		#define GL_POINT_SIZE_MAX_ARB 0x8127
		#define GL_POINT_FADE_THRESHOLD_SIZE_ARB 0x8128
		#define GL_POINT_DISTANCE_ATTENUATION_ARB 0x8129
		#endif

		#ifndef GL_ARB_vertex_blend
		#define GL_MAX_VERTEX_UNITS_ARB 0x86A4
		#define GL_ACTIVE_VERTEX_UNITS_ARB 0x86A5
		#define GL_WEIGHT_SUM_UNITY_ARB 0x86A6
		#define GL_VERTEX_BLEND_ARB 0x86A7
		#define GL_CURRENT_WEIGHT_ARB 0x86A8
		#define GL_WEIGHT_ARRAY_TYPE_ARB 0x86A9
		#define GL_WEIGHT_ARRAY_STRIDE_ARB 0x86AA
		#define GL_WEIGHT_ARRAY_SIZE_ARB 0x86AB
		#define GL_WEIGHT_ARRAY_POINTER_ARB 0x86AC
		#define GL_WEIGHT_ARRAY_ARB 0x86AD
		#define GL_MODELVIEW0_ARB 0x1700
		#define GL_MODELVIEW1_ARB 0x850A
		#define GL_MODELVIEW2_ARB 0x8722
		#define GL_MODELVIEW3_ARB 0x8723
		#define GL_MODELVIEW4_ARB 0x8724
		#define GL_MODELVIEW5_ARB 0x8725
		#define GL_MODELVIEW6_ARB 0x8726
		#define GL_MODELVIEW7_ARB 0x8727
		#define GL_MODELVIEW8_ARB 0x8728
		#define GL_MODELVIEW9_ARB 0x8729
		#define GL_MODELVIEW10_ARB 0x872A
		#define GL_MODELVIEW11_ARB 0x872B
		#define GL_MODELVIEW12_ARB 0x872C
		#define GL_MODELVIEW13_ARB 0x872D
		#define GL_MODELVIEW14_ARB 0x872E
		#define GL_MODELVIEW15_ARB 0x872F
		#define GL_MODELVIEW16_ARB 0x8730
		#define GL_MODELVIEW17_ARB 0x8731
		#define GL_MODELVIEW18_ARB 0x8732
		#define GL_MODELVIEW19_ARB 0x8733
		#define GL_MODELVIEW20_ARB 0x8734
		#define GL_MODELVIEW21_ARB 0x8735
		#define GL_MODELVIEW22_ARB 0x8736
		#define GL_MODELVIEW23_ARB 0x8737
		#define GL_MODELVIEW24_ARB 0x8738
		#define GL_MODELVIEW25_ARB 0x8739
		#define GL_MODELVIEW26_ARB 0x873A
		#define GL_MODELVIEW27_ARB 0x873B
		#define GL_MODELVIEW28_ARB 0x873C
		#define GL_MODELVIEW29_ARB 0x873D
		#define GL_MODELVIEW30_ARB 0x873E
		#define GL_MODELVIEW31_ARB 0x873F
		#endif

		#ifndef GL_ARB_matrix_palette
		#define GL_MATRIX_PALETTE_ARB 0x8840
		#define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB 0x8841
		#define GL_MAX_PALETTE_MATRICES_ARB 0x8842
		#define GL_CURRENT_PALETTE_MATRIX_ARB 0x8843
		#define GL_MATRIX_INDEX_ARRAY_ARB 0x8844
		#define GL_CURRENT_MATRIX_INDEX_ARB 0x8845
		#define GL_MATRIX_INDEX_ARRAY_SIZE_ARB 0x8846
		#define GL_MATRIX_INDEX_ARRAY_TYPE_ARB 0x8847
		#define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB 0x8848
		#define GL_MATRIX_INDEX_ARRAY_POINTER_ARB 0x8849
		#endif

		#ifndef GL_ARB_texture_env_combine
		#define GL_COMBINE_ARB 0x8570
		#define GL_COMBINE_RGB_ARB 0x8571
		#define GL_COMBINE_ALPHA_ARB 0x8572
		#define GL_SOURCE0_RGB_ARB 0x8580
		#define GL_SOURCE1_RGB_ARB 0x8581
		#define GL_SOURCE2_RGB_ARB 0x8582
		#define GL_SOURCE0_ALPHA_ARB 0x8588
		#define GL_SOURCE1_ALPHA_ARB 0x8589
		#define GL_SOURCE2_ALPHA_ARB 0x858A
		#define GL_OPERAND0_RGB_ARB 0x8590
		#define GL_OPERAND1_RGB_ARB 0x8591
		#define GL_OPERAND2_RGB_ARB 0x8592
		#define GL_OPERAND0_ALPHA_ARB 0x8598
		#define GL_OPERAND1_ALPHA_ARB 0x8599
		#define GL_OPERAND2_ALPHA_ARB 0x859A
		#define GL_RGB_SCALE_ARB 0x8573
		#define GL_ADD_SIGNED_ARB 0x8574
		#define GL_INTERPOLATE_ARB 0x8575
		#define GL_SUBTRACT_ARB 0x84E7
		#define GL_CONSTANT_ARB 0x8576
		#define GL_PRIMARY_COLOR_ARB 0x8577
		#define GL_PREVIOUS_ARB 0x8578
		#endif

		#ifndef GL_ARB_texture_env_crossbar
		#endif

		#ifndef GL_ARB_texture_env_dot3
		#define GL_DOT3_RGB_ARB 0x86AE
		#define GL_DOT3_RGBA_ARB 0x86AF
		#endif

		#ifndef GL_ARB_texture_mirrored_repeat
		#define GL_MIRRORED_REPEAT_ARB 0x8370
		#endif

		#ifndef GL_ARB_depth_texture
		#define GL_DEPTH_COMPONENT16_ARB 0x81A5
		#define GL_DEPTH_COMPONENT24_ARB 0x81A6
		#define GL_DEPTH_COMPONENT32_ARB 0x81A7
		#define GL_TEXTURE_DEPTH_SIZE_ARB 0x884A
		#define GL_DEPTH_TEXTURE_MODE_ARB 0x884B
		#endif

		#ifndef GL_ARB_shadow
		#define GL_TEXTURE_COMPARE_MODE_ARB 0x884C
		#define GL_TEXTURE_COMPARE_FUNC_ARB 0x884D
		#define GL_COMPARE_R_TO_TEXTURE_ARB 0x884E
		#endif

		#ifndef GL_ARB_shadow_ambient
		#define GL_TEXTURE_COMPARE_FAIL_VALUE_ARB 0x80BF
		#endif

		#ifndef GL_ARB_window_pos
		#endif

		#ifndef GL_ARB_vertex_program
		#define GL_COLOR_SUM_ARB 0x8458
		#define GL_VERTEX_PROGRAM_ARB 0x8620
		#define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622
		#define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623
		#define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624
		#define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625
		#define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626
		#define GL_PROGRAM_LENGTH_ARB 0x8627
		#define GL_PROGRAM_STRING_ARB 0x8628
		#define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E
		#define GL_MAX_PROGRAM_MATRICES_ARB 0x862F
		#define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640
		#define GL_CURRENT_MATRIX_ARB 0x8641
		#define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642
		#define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643
		#define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645
		#define GL_PROGRAM_ERROR_POSITION_ARB 0x864B
		#define GL_PROGRAM_BINDING_ARB 0x8677
		#define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869
		#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A
		#define GL_PROGRAM_ERROR_STRING_ARB 0x8874
		#define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875
		#define GL_PROGRAM_FORMAT_ARB 0x8876
		#define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0
		#define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1
		#define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2
		#define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3
		#define GL_PROGRAM_TEMPORARIES_ARB 0x88A4
		#define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5
		#define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6
		#define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7
		#define GL_PROGRAM_PARAMETERS_ARB 0x88A8
		#define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9
		#define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA
		#define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB
		#define GL_PROGRAM_ATTRIBS_ARB 0x88AC
		#define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD
		#define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE
		#define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF
		#define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0
		#define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1
		#define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2
		#define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3
		#define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4
		#define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5
		#define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6
		#define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7
		#define GL_MATRIX0_ARB 0x88C0
		#define GL_MATRIX1_ARB 0x88C1
		#define GL_MATRIX2_ARB 0x88C2
		#define GL_MATRIX3_ARB 0x88C3
		#define GL_MATRIX4_ARB 0x88C4
		#define GL_MATRIX5_ARB 0x88C5
		#define GL_MATRIX6_ARB 0x88C6
		#define GL_MATRIX7_ARB 0x88C7
		#define GL_MATRIX8_ARB 0x88C8
		#define GL_MATRIX9_ARB 0x88C9
		#define GL_MATRIX10_ARB 0x88CA
		#define GL_MATRIX11_ARB 0x88CB
		#define GL_MATRIX12_ARB 0x88CC
		#define GL_MATRIX13_ARB 0x88CD
		#define GL_MATRIX14_ARB 0x88CE
		#define GL_MATRIX15_ARB 0x88CF
		#define GL_MATRIX16_ARB 0x88D0
		#define GL_MATRIX17_ARB 0x88D1
		#define GL_MATRIX18_ARB 0x88D2
		#define GL_MATRIX19_ARB 0x88D3
		#define GL_MATRIX20_ARB 0x88D4
		#define GL_MATRIX21_ARB 0x88D5
		#define GL_MATRIX22_ARB 0x88D6
		#define GL_MATRIX23_ARB 0x88D7
		#define GL_MATRIX24_ARB 0x88D8
		#define GL_MATRIX25_ARB 0x88D9
		#define GL_MATRIX26_ARB 0x88DA
		#define GL_MATRIX27_ARB 0x88DB
		#define GL_MATRIX28_ARB 0x88DC
		#define GL_MATRIX29_ARB 0x88DD
		#define GL_MATRIX30_ARB 0x88DE
		#define GL_MATRIX31_ARB 0x88DF
		#endif

		#ifndef GL_ARB_fragment_program
		#define GL_FRAGMENT_PROGRAM_ARB 0x8804
		#define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805
		#define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806
		#define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807
		#define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808
		#define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809
		#define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A
		#define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B
		#define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C
		#define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D
		#define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E
		#define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F
		#define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810
		#define GL_MAX_TEXTURE_COORDS_ARB 0x8871
		#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872
		#endif

		#ifndef GL_ARB_vertex_buffer_object
		#define GL_BUFFER_SIZE_ARB 0x8764
		#define GL_BUFFER_USAGE_ARB 0x8765
		#define GL_ARRAY_BUFFER_ARB 0x8892
		#define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893
		#define GL_ARRAY_BUFFER_BINDING_ARB 0x8894
		#define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895
		#define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896
		#define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897
		#define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898
		#define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899
		#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A
		#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B
		#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C
		#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D
		#define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E
		#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F
		#define GL_READ_ONLY_ARB 0x88B8
		#define GL_WRITE_ONLY_ARB 0x88B9
		#define GL_READ_WRITE_ARB 0x88BA
		#define GL_BUFFER_ACCESS_ARB 0x88BB
		#define GL_BUFFER_MAPPED_ARB 0x88BC
		#define GL_BUFFER_MAP_POINTER_ARB 0x88BD
		#define GL_STREAM_DRAW_ARB 0x88E0
		#define GL_STREAM_READ_ARB 0x88E1
		#define GL_STREAM_COPY_ARB 0x88E2
		#define GL_STATIC_DRAW_ARB 0x88E4
		#define GL_STATIC_READ_ARB 0x88E5
		#define GL_STATIC_COPY_ARB 0x88E6
		#define GL_DYNAMIC_DRAW_ARB 0x88E8
		#define GL_DYNAMIC_READ_ARB 0x88E9
		#define GL_DYNAMIC_COPY_ARB 0x88EA
		#endif

		#ifndef GL_ARB_occlusion_query
		#define GL_QUERY_COUNTER_BITS_ARB 0x8864
		#define GL_CURRENT_QUERY_ARB 0x8865
		#define GL_QUERY_RESULT_ARB 0x8866
		#define GL_QUERY_RESULT_AVAILABLE_ARB 0x8867
		#define GL_SAMPLES_PASSED_ARB 0x8914
		#endif

		#ifndef GL_ARB_shader_objects
		#define GL_PROGRAM_OBJECT_ARB 0x8B40
		#define GL_SHADER_OBJECT_ARB 0x8B48
		#define GL_OBJECT_TYPE_ARB 0x8B4E
		#define GL_OBJECT_SUBTYPE_ARB 0x8B4F
		#define GL_FLOAT_VEC2_ARB 0x8B50
		#define GL_FLOAT_VEC3_ARB 0x8B51
		#define GL_FLOAT_VEC4_ARB 0x8B52
		#define GL_INT_VEC2_ARB 0x8B53
		#define GL_INT_VEC3_ARB 0x8B54
		#define GL_INT_VEC4_ARB 0x8B55
		#define GL_BOOL_ARB 0x8B56
		#define GL_BOOL_VEC2_ARB 0x8B57
		#define GL_BOOL_VEC3_ARB 0x8B58
		#define GL_BOOL_VEC4_ARB 0x8B59
		#define GL_FLOAT_MAT2_ARB 0x8B5A
		#define GL_FLOAT_MAT3_ARB 0x8B5B
		#define GL_FLOAT_MAT4_ARB 0x8B5C
		#define GL_SAMPLER_1D_ARB 0x8B5D
		#define GL_SAMPLER_2D_ARB 0x8B5E
		#define GL_SAMPLER_3D_ARB 0x8B5F
		#define GL_SAMPLER_CUBE_ARB 0x8B60
		#define GL_SAMPLER_1D_SHADOW_ARB 0x8B61
		#define GL_SAMPLER_2D_SHADOW_ARB 0x8B62
		#define GL_SAMPLER_2D_RECT_ARB 0x8B63
		#define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64
		#define GL_OBJECT_DELETE_STATUS_ARB 0x8B80
		#define GL_OBJECT_COMPILE_STATUS_ARB 0x8B81
		#define GL_OBJECT_LINK_STATUS_ARB 0x8B82
		#define GL_OBJECT_VALIDATE_STATUS_ARB 0x8B83
		#define GL_OBJECT_INFO_LOG_LENGTH_ARB 0x8B84
		#define GL_OBJECT_ATTACHED_OBJECTS_ARB 0x8B85
		#define GL_OBJECT_ACTIVE_UNIFORMS_ARB 0x8B86
		#define GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB 0x8B87
		#define GL_OBJECT_SHADER_SOURCE_LENGTH_ARB 0x8B88
		#endif

		#ifndef GL_ARB_vertex_shader
		#define GL_VERTEX_SHADER_ARB 0x8B31
		#define GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB 0x8B4A
		#define GL_MAX_VARYING_FLOATS_ARB 0x8B4B
		#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C
		#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB 0x8B4D
		#define GL_OBJECT_ACTIVE_ATTRIBUTES_ARB 0x8B89
		#define GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB 0x8B8A
		#endif

		#ifndef GL_ARB_fragment_shader
		#define GL_FRAGMENT_SHADER_ARB 0x8B30
		#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB 0x8B49
		#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB 0x8B8B
		#endif

		#ifndef GL_ARB_shading_language_100
		#define GL_SHADING_LANGUAGE_VERSION_ARB 0x8B8C
		#endif

		#ifndef GL_ARB_texture_non_power_of_two
		#endif

		#ifndef GL_ARB_point_sprite
		#define GL_POINT_SPRITE_ARB 0x8861
		#define GL_COORD_REPLACE_ARB 0x8862
		#endif

		#ifndef GL_ARB_fragment_program_shadow
		#endif

		#ifndef GL_ARB_draw_buffers
		#define GL_MAX_DRAW_BUFFERS_ARB 0x8824
		#define GL_DRAW_BUFFER0_ARB 0x8825
		#define GL_DRAW_BUFFER1_ARB 0x8826
		#define GL_DRAW_BUFFER2_ARB 0x8827
		#define GL_DRAW_BUFFER3_ARB 0x8828
		#define GL_DRAW_BUFFER4_ARB 0x8829
		#define GL_DRAW_BUFFER5_ARB 0x882A
		#define GL_DRAW_BUFFER6_ARB 0x882B
		#define GL_DRAW_BUFFER7_ARB 0x882C
		#define GL_DRAW_BUFFER8_ARB 0x882D
		#define GL_DRAW_BUFFER9_ARB 0x882E
		#define GL_DRAW_BUFFER10_ARB 0x882F
		#define GL_DRAW_BUFFER11_ARB 0x8830
		#define GL_DRAW_BUFFER12_ARB 0x8831
		#define GL_DRAW_BUFFER13_ARB 0x8832
		#define GL_DRAW_BUFFER14_ARB 0x8833
		#define GL_DRAW_BUFFER15_ARB 0x8834
		#endif

		#ifndef GL_ARB_texture_rectangle
		#define GL_TEXTURE_RECTANGLE_ARB 0x84F5
		#define GL_TEXTURE_BINDING_RECTANGLE_ARB 0x84F6
		#define GL_PROXY_TEXTURE_RECTANGLE_ARB 0x84F7
		#define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB 0x84F8
		#endif

		#ifndef GL_ARB_color_buffer_float
		#define GL_RGBA_FLOAT_MODE_ARB 0x8820
		#define GL_CLAMP_VERTEX_COLOR_ARB 0x891A
		#define GL_CLAMP_FRAGMENT_COLOR_ARB 0x891B
		#define GL_CLAMP_READ_COLOR_ARB 0x891C
		#define GL_FIXED_ONLY_ARB 0x891D
		#endif

		#ifndef GL_ARB_half_float_pixel
		#define GL_HALF_FLOAT_ARB 0x140B
		#endif

		#ifndef GL_ARB_texture_float
		#define GL_TEXTURE_RED_TYPE_ARB 0x8C10
		#define GL_TEXTURE_GREEN_TYPE_ARB 0x8C11
		#define GL_TEXTURE_BLUE_TYPE_ARB 0x8C12
		#define GL_TEXTURE_ALPHA_TYPE_ARB 0x8C13
		#define GL_TEXTURE_LUMINANCE_TYPE_ARB 0x8C14
		#define GL_TEXTURE_INTENSITY_TYPE_ARB 0x8C15
		#define GL_TEXTURE_DEPTH_TYPE_ARB 0x8C16
		#define GL_UNSIGNED_NORMALIZED_ARB 0x8C17
		#define GL_RGBA32F_ARB 0x8814
		#define GL_RGB32F_ARB 0x8815
		#define GL_ALPHA32F_ARB 0x8816
		#define GL_INTENSITY32F_ARB 0x8817
		#define GL_LUMINANCE32F_ARB 0x8818
		#define GL_LUMINANCE_ALPHA32F_ARB 0x8819
		#define GL_RGBA16F_ARB 0x881A
		#define GL_RGB16F_ARB 0x881B
		#define GL_ALPHA16F_ARB 0x881C
		#define GL_INTENSITY16F_ARB 0x881D
		#define GL_LUMINANCE16F_ARB 0x881E
		#define GL_LUMINANCE_ALPHA16F_ARB 0x881F
		#endif

		#ifndef GL_ARB_pixel_buffer_object
		#define GL_PIXEL_PACK_BUFFER_ARB 0x88EB
		#define GL_PIXEL_UNPACK_BUFFER_ARB 0x88EC
		#define GL_PIXEL_PACK_BUFFER_BINDING_ARB 0x88ED
		#define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB 0x88EF
		#endif

	#ifndef GL_EXT_abgr	#ifndef GL_EXT_abgr
	#define GL_ABGR_EXT 0x8000	#define GL_ABGR_EXT 0x8000
	#endif	#endif

	#ifndef GL_EXT_blend_color	#ifndef GL_EXT_blend_color
	#define GL_CONSTANT_COLOR_EXT 0x8001	#define GL_CONSTANT_COLOR_EXT 0x8001
	#define GL_ONE_MINUS_CONSTANT_COLOR_EXT 0x8002	#define GL_ONE_MINUS_CONSTANT_COLOR_EXT 0x8002
	#define GL_CONSTANT_ALPHA_EXT 0x8003	#define GL_CONSTANT_ALPHA_EXT 0x8003
	#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT 0x8004	#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT 0x8004
	#define GL_BLEND_COLOR_EXT 0x8005	#define GL_BLEND_COLOR_EXT 0x8005

	skipping to change at line 303	skipping to change at line 1070
	#define GL_TEXTURE_ALPHA_SIZE_EXT 0x805F	#define GL_TEXTURE_ALPHA_SIZE_EXT 0x805F
	#define GL_TEXTURE_LUMINANCE_SIZE_EXT 0x8060	#define GL_TEXTURE_LUMINANCE_SIZE_EXT 0x8060
	#define GL_TEXTURE_INTENSITY_SIZE_EXT 0x8061	#define GL_TEXTURE_INTENSITY_SIZE_EXT 0x8061
	#define GL_REPLACE_EXT 0x8062	#define GL_REPLACE_EXT 0x8062
	#define GL_PROXY_TEXTURE_1D_EXT 0x8063	#define GL_PROXY_TEXTURE_1D_EXT 0x8063
	#define GL_PROXY_TEXTURE_2D_EXT 0x8064	#define GL_PROXY_TEXTURE_2D_EXT 0x8064
	#define GL_TEXTURE_TOO_LARGE_EXT 0x8065	#define GL_TEXTURE_TOO_LARGE_EXT 0x8065
	#endif	#endif

	#ifndef GL_EXT_texture3D	#ifndef GL_EXT_texture3D

	#define GL_PACK_SKIP_IMAGES 0x806B
	#define GL_PACK_SKIP_IMAGES_EXT 0x806B	#define GL_PACK_SKIP_IMAGES_EXT 0x806B

	#define GL_PACK_IMAGE_HEIGHT 0x806C
	#define GL_PACK_IMAGE_HEIGHT_EXT 0x806C	#define GL_PACK_IMAGE_HEIGHT_EXT 0x806C

	#define GL_UNPACK_SKIP_IMAGES 0x806D
	#define GL_UNPACK_SKIP_IMAGES_EXT 0x806D	#define GL_UNPACK_SKIP_IMAGES_EXT 0x806D

	#define GL_UNPACK_IMAGE_HEIGHT 0x806E
	#define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E	#define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E

	#define GL_TEXTURE_3D 0x806F
	#define GL_TEXTURE_3D_EXT 0x806F	#define GL_TEXTURE_3D_EXT 0x806F

	#define GL_PROXY_TEXTURE_3D 0x8070
	#define GL_PROXY_TEXTURE_3D_EXT 0x8070	#define GL_PROXY_TEXTURE_3D_EXT 0x8070

	#define GL_TEXTURE_DEPTH 0x8071
	#define GL_TEXTURE_DEPTH_EXT 0x8071	#define GL_TEXTURE_DEPTH_EXT 0x8071

	#define GL_TEXTURE_WRAP_R 0x8072
	#define GL_TEXTURE_WRAP_R_EXT 0x8072	#define GL_TEXTURE_WRAP_R_EXT 0x8072

	#define GL_MAX_3D_TEXTURE_SIZE 0x8073
	#define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073	#define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073
	#endif	#endif

	#ifndef GL_SGIS_texture_filter4	#ifndef GL_SGIS_texture_filter4
	#define GL_FILTER4_SGIS 0x8146	#define GL_FILTER4_SGIS 0x8146
	#define GL_TEXTURE_FILTER4_SIZE_SGIS 0x8147	#define GL_TEXTURE_FILTER4_SIZE_SGIS 0x8147
	#endif	#endif

	#ifndef GL_EXT_subtexture	#ifndef GL_EXT_subtexture
	#endif	#endif

	skipping to change at line 415	skipping to change at line 1173
	#endif	#endif

	#ifndef GL_SGIS_pixel_texture	#ifndef GL_SGIS_pixel_texture
	#define GL_PIXEL_TEXTURE_SGIS 0x8353	#define GL_PIXEL_TEXTURE_SGIS 0x8353
	#define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS 0x8354	#define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS 0x8354
	#define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS 0x8355	#define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS 0x8355
	#define GL_PIXEL_GROUP_COLOR_SGIS 0x8356	#define GL_PIXEL_GROUP_COLOR_SGIS 0x8356
	#endif	#endif

	#ifndef GL_SGIX_pixel_texture	#ifndef GL_SGIX_pixel_texture

	#define GL_PIXEL_TEX_BUM_SGIX 0x8139	#define GL_PIXEL_TEX_GEN_SGIX 0x8139
	#define GL_PIXEL_TEX_BUM_MODE_SGIX 0x832B	#define GL_PIXEL_TEX_GEN_MODE_SGIX 0x832B
	#endif	#endif

	#ifndef GL_SGIS_texture4D	#ifndef GL_SGIS_texture4D
	#define GL_PACK_SKIP_VOLUMES_SGIS 0x8130	#define GL_PACK_SKIP_VOLUMES_SGIS 0x8130
	#define GL_PACK_IMAGE_DEPTH_SGIS 0x8131	#define GL_PACK_IMAGE_DEPTH_SGIS 0x8131
	#define GL_UNPACK_SKIP_VOLUMES_SGIS 0x8132	#define GL_UNPACK_SKIP_VOLUMES_SGIS 0x8132
	#define GL_UNPACK_IMAGE_DEPTH_SGIS 0x8133	#define GL_UNPACK_IMAGE_DEPTH_SGIS 0x8133
	#define GL_TEXTURE_4D_SGIS 0x8134	#define GL_TEXTURE_4D_SGIS 0x8134
	#define GL_PROXY_TEXTURE_4D_SGIS 0x8135	#define GL_PROXY_TEXTURE_4D_SGIS 0x8135
	#define GL_TEXTURE_4DSIZE_SGIS 0x8136	#define GL_TEXTURE_4DSIZE_SGIS 0x8136

	skipping to change at line 650	skipping to change at line 1408
	#define GL_SPRITE_TRANSLATION_SGIX 0x814B	#define GL_SPRITE_TRANSLATION_SGIX 0x814B
	#define GL_SPRITE_AXIAL_SGIX 0x814C	#define GL_SPRITE_AXIAL_SGIX 0x814C
	#define GL_SPRITE_OBJECT_ALIGNED_SGIX 0x814D	#define GL_SPRITE_OBJECT_ALIGNED_SGIX 0x814D
	#define GL_SPRITE_EYE_ALIGNED_SGIX 0x814E	#define GL_SPRITE_EYE_ALIGNED_SGIX 0x814E
	#endif	#endif

	#ifndef GL_SGIX_texture_multi_buffer	#ifndef GL_SGIX_texture_multi_buffer
	#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E	#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E
	#endif	#endif


	#ifndef GL_SGIS_point_parameters	#ifndef GL_EXT_point_parameters
	#define GL_POINT_SIZE_MIN_EXT 0x8126	#define GL_POINT_SIZE_MIN_EXT 0x8126

	#define GL_POINT_SIZE_MIN_SGIS 0x8126
	#define GL_POINT_SIZE_MAX_EXT 0x8127	#define GL_POINT_SIZE_MAX_EXT 0x8127

	#define GL_POINT_SIZE_MAX_SGIS 0x8127
	#define GL_POINT_FADE_THRESHOLD_SIZE_EXT 0x8128	#define GL_POINT_FADE_THRESHOLD_SIZE_EXT 0x8128

	#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128
	#define GL_DISTANCE_ATTENUATION_EXT 0x8129	#define GL_DISTANCE_ATTENUATION_EXT 0x8129

		#endif

		#ifndef GL_SGIS_point_parameters
		#define GL_POINT_SIZE_MIN_SGIS 0x8126
		#define GL_POINT_SIZE_MAX_SGIS 0x8127
		#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128
	#define GL_DISTANCE_ATTENUATION_SGIS 0x8129	#define GL_DISTANCE_ATTENUATION_SGIS 0x8129
	#endif	#endif

	#ifndef GL_SGIX_instruments	#ifndef GL_SGIX_instruments
	#define GL_INSTRUMENT_BUFFER_POINTER_SGIX 0x8180	#define GL_INSTRUMENT_BUFFER_POINTER_SGIX 0x8180
	#define GL_INSTRUMENT_MEASUREMENTS_SGIX 0x8181	#define GL_INSTRUMENT_MEASUREMENTS_SGIX 0x8181
	#endif	#endif

	#ifndef GL_SGIX_texture_scale_bias	#ifndef GL_SGIX_texture_scale_bias
	#define GL_POST_TEXTURE_FILTER_BIAS_SGIX 0x8179	#define GL_POST_TEXTURE_FILTER_BIAS_SGIX 0x8179

	skipping to change at line 682	skipping to change at line 1443

	#ifndef GL_SGIX_framezoom	#ifndef GL_SGIX_framezoom
	#define GL_FRAMEZOOM_SGIX 0x818B	#define GL_FRAMEZOOM_SGIX 0x818B
	#define GL_FRAMEZOOM_FACTOR_SGIX 0x818C	#define GL_FRAMEZOOM_FACTOR_SGIX 0x818C
	#define GL_MAX_FRAMEZOOM_FACTOR_SGIX 0x818D	#define GL_MAX_FRAMEZOOM_FACTOR_SGIX 0x818D
	#endif	#endif

	#ifndef GL_SGIX_tag_sample_buffer	#ifndef GL_SGIX_tag_sample_buffer
	#endif	#endif


		#ifndef GL_FfdMaskSGIX
		#define GL_TEXTURE_DEFORMATION_BIT_SGIX 0x00000001
		#define GL_GEOMETRY_DEFORMATION_BIT_SGIX 0x00000002
		#endif

		#ifndef GL_SGIX_polynomial_ffd
		#define GL_GEOMETRY_DEFORMATION_SGIX 0x8194
		#define GL_TEXTURE_DEFORMATION_SGIX 0x8195
		#define GL_DEFORMATIONS_MASK_SGIX 0x8196
		#define GL_MAX_DEFORMATION_ORDER_SGIX 0x8197
		#endif

	#ifndef GL_SGIX_reference_plane	#ifndef GL_SGIX_reference_plane
	#define GL_REFERENCE_PLANE_SGIX 0x817D	#define GL_REFERENCE_PLANE_SGIX 0x817D
	#define GL_REFERENCE_PLANE_EQUATION_SGIX 0x817E	#define GL_REFERENCE_PLANE_EQUATION_SGIX 0x817E
	#endif	#endif

	#ifndef GL_SGIX_flush_raster	#ifndef GL_SGIX_flush_raster
	#endif	#endif

	#ifndef GL_SGIX_depth_texture	#ifndef GL_SGIX_depth_texture
	#define GL_DEPTH_COMPONENT16_SGIX 0x81A5	#define GL_DEPTH_COMPONENT16_SGIX 0x81A5

	skipping to change at line 933	skipping to change at line 1706
	#define GL_TEXTURE_MATERIAL_FACE_EXT 0x8351	#define GL_TEXTURE_MATERIAL_FACE_EXT 0x8351
	#define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352	#define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352
	/* reuse GL_FRAGMENT_DEPTH_EXT */	/* reuse GL_FRAGMENT_DEPTH_EXT */
	#endif	#endif

	#ifndef GL_SGIX_blend_alpha_minmax	#ifndef GL_SGIX_blend_alpha_minmax
	#define GL_ALPHA_MIN_SGIX 0x8320	#define GL_ALPHA_MIN_SGIX 0x8320
	#define GL_ALPHA_MAX_SGIX 0x8321	#define GL_ALPHA_MAX_SGIX 0x8321
	#endif	#endif


		#ifndef GL_SGIX_impact_pixel_texture
		#define GL_PIXEL_TEX_GEN_Q_CEILING_SGIX 0x8184
		#define GL_PIXEL_TEX_GEN_Q_ROUND_SGIX 0x8185
		#define GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX 0x8186
		#define GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX 0x8187
		#define GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX 0x8188
		#define GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX 0x8189
		#define GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX 0x818A
		#endif

	#ifndef GL_EXT_bgra	#ifndef GL_EXT_bgra
	#define GL_BGR_EXT 0x80E0	#define GL_BGR_EXT 0x80E0
	#define GL_BGRA_EXT 0x80E1	#define GL_BGRA_EXT 0x80E1
	#endif	#endif


		#ifndef GL_SGIX_async
		#define GL_ASYNC_MARKER_SGIX 0x8329
		#endif

		#ifndef GL_SGIX_async_pixel
		#define GL_ASYNC_TEX_IMAGE_SGIX 0x835C
		#define GL_ASYNC_DRAW_PIXELS_SGIX 0x835D
		#define GL_ASYNC_READ_PIXELS_SGIX 0x835E
		#define GL_MAX_ASYNC_TEX_IMAGE_SGIX 0x835F
		#define GL_MAX_ASYNC_DRAW_PIXELS_SGIX 0x8360
		#define GL_MAX_ASYNC_READ_PIXELS_SGIX 0x8361
		#endif

		#ifndef GL_SGIX_async_histogram
		#define GL_ASYNC_HISTOGRAM_SGIX 0x832C
		#define GL_MAX_ASYNC_HISTOGRAM_SGIX 0x832D
		#endif

	#ifndef GL_INTEL_texture_scissor	#ifndef GL_INTEL_texture_scissor
	#endif	#endif

	#ifndef GL_INTEL_parallel_arrays	#ifndef GL_INTEL_parallel_arrays
	#define GL_PARALLEL_ARRAYS_INTEL 0x83F4	#define GL_PARALLEL_ARRAYS_INTEL 0x83F4
	#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5	#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5
	#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6	#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6
	#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7	#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7
	#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8	#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8
	#endif	#endif

	skipping to change at line 1043	skipping to change at line 1844
	#define GL_COMBINE_ALPHA_EXT 0x8572	#define GL_COMBINE_ALPHA_EXT 0x8572
	#define GL_RGB_SCALE_EXT 0x8573	#define GL_RGB_SCALE_EXT 0x8573
	#define GL_ADD_SIGNED_EXT 0x8574	#define GL_ADD_SIGNED_EXT 0x8574
	#define GL_INTERPOLATE_EXT 0x8575	#define GL_INTERPOLATE_EXT 0x8575
	#define GL_CONSTANT_EXT 0x8576	#define GL_CONSTANT_EXT 0x8576
	#define GL_PRIMARY_COLOR_EXT 0x8577	#define GL_PRIMARY_COLOR_EXT 0x8577
	#define GL_PREVIOUS_EXT 0x8578	#define GL_PREVIOUS_EXT 0x8578
	#define GL_SOURCE0_RGB_EXT 0x8580	#define GL_SOURCE0_RGB_EXT 0x8580
	#define GL_SOURCE1_RGB_EXT 0x8581	#define GL_SOURCE1_RGB_EXT 0x8581
	#define GL_SOURCE2_RGB_EXT 0x8582	#define GL_SOURCE2_RGB_EXT 0x8582

	#define GL_SOURCE3_RGB_EXT 0x8583
	#define GL_SOURCE4_RGB_EXT 0x8584
	#define GL_SOURCE5_RGB_EXT 0x8585
	#define GL_SOURCE6_RGB_EXT 0x8586
	#define GL_SOURCE7_RGB_EXT 0x8587
	#define GL_SOURCE0_ALPHA_EXT 0x8588	#define GL_SOURCE0_ALPHA_EXT 0x8588
	#define GL_SOURCE1_ALPHA_EXT 0x8589	#define GL_SOURCE1_ALPHA_EXT 0x8589
	#define GL_SOURCE2_ALPHA_EXT 0x858A	#define GL_SOURCE2_ALPHA_EXT 0x858A

	#define GL_SOURCE3_ALPHA_EXT 0x858B
	#define GL_SOURCE4_ALPHA_EXT 0x858C
	#define GL_SOURCE5_ALPHA_EXT 0x858D
	#define GL_SOURCE6_ALPHA_EXT 0x858E
	#define GL_SOURCE7_ALPHA_EXT 0x858F
	#define GL_OPERAND0_RGB_EXT 0x8590	#define GL_OPERAND0_RGB_EXT 0x8590
	#define GL_OPERAND1_RGB_EXT 0x8591	#define GL_OPERAND1_RGB_EXT 0x8591
	#define GL_OPERAND2_RGB_EXT 0x8592	#define GL_OPERAND2_RGB_EXT 0x8592

	#define GL_OPERAND3_RGB_EXT 0x8593
	#define GL_OPERAND4_RGB_EXT 0x8594
	#define GL_OPERAND5_RGB_EXT 0x8595
	#define GL_OPERAND6_RGB_EXT 0x8596
	#define GL_OPERAND7_RGB_EXT 0x8597
	#define GL_OPERAND0_ALPHA_EXT 0x8598	#define GL_OPERAND0_ALPHA_EXT 0x8598
	#define GL_OPERAND1_ALPHA_EXT 0x8599	#define GL_OPERAND1_ALPHA_EXT 0x8599
	#define GL_OPERAND2_ALPHA_EXT 0x859A	#define GL_OPERAND2_ALPHA_EXT 0x859A

	#define GL_OPERAND3_ALPHA_EXT 0x859B
	#define GL_OPERAND4_ALPHA_EXT 0x859C
	#define GL_OPERAND5_ALPHA_EXT 0x859D
	#define GL_OPERAND6_ALPHA_EXT 0x859E
	#define GL_OPERAND7_ALPHA_EXT 0x859F
	#endif	#endif

	#ifndef GL_APPLE_specular_vector	#ifndef GL_APPLE_specular_vector
	#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0	#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0
	#endif	#endif

	#ifndef GL_APPLE_transform_hint	#ifndef GL_APPLE_transform_hint
	#define GL_TRANSFORM_HINT_APPLE 0x85B1	#define GL_TRANSFORM_HINT_APPLE 0x85B1
	#endif	#endif


	skipping to change at line 1098	skipping to change at line 1879
	#define GL_UNPACK_CONSTANT_DATA_SUNX 0x81D5	#define GL_UNPACK_CONSTANT_DATA_SUNX 0x81D5
	#define GL_TEXTURE_CONSTANT_DATA_SUNX 0x81D6	#define GL_TEXTURE_CONSTANT_DATA_SUNX 0x81D6
	#endif	#endif

	#ifndef GL_SUN_global_alpha	#ifndef GL_SUN_global_alpha
	#define GL_GLOBAL_ALPHA_SUN 0x81D9	#define GL_GLOBAL_ALPHA_SUN 0x81D9
	#define GL_GLOBAL_ALPHA_FACTOR_SUN 0x81DA	#define GL_GLOBAL_ALPHA_FACTOR_SUN 0x81DA
	#endif	#endif

	#ifndef GL_SUN_triangle_list	#ifndef GL_SUN_triangle_list

	#define GL_RESTART_SUN 0x01	#define GL_RESTART_SUN 0x0001
	#define GL_REPLACE_MIDDLE_SUN 0x02	#define GL_REPLACE_MIDDLE_SUN 0x0002
	#define GL_REPLACE_OLDEST_SUN 0x03	#define GL_REPLACE_OLDEST_SUN 0x0003
	#define GL_TRIANGLE_LIST_SUN 0x81D7	#define GL_TRIANGLE_LIST_SUN 0x81D7
	#define GL_REPLACEMENT_CODE_SUN 0x81D8	#define GL_REPLACEMENT_CODE_SUN 0x81D8
	#define GL_REPLACEMENT_CODE_ARRAY_SUN 0x85C0	#define GL_REPLACEMENT_CODE_ARRAY_SUN 0x85C0
	#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1	#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1
	#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2	#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2
	#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3	#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3
	#define GL_R1UI_V3F_SUN 0x85C4	#define GL_R1UI_V3F_SUN 0x85C4
	#define GL_R1UI_C4UB_V3F_SUN 0x85C5	#define GL_R1UI_C4UB_V3F_SUN 0x85C5
	#define GL_R1UI_C3F_V3F_SUN 0x85C6	#define GL_R1UI_C3F_V3F_SUN 0x85C6
	#define GL_R1UI_N3F_V3F_SUN 0x85C7	#define GL_R1UI_N3F_V3F_SUN 0x85C7

	skipping to change at line 1196	skipping to change at line 1977

	#ifndef GL_EXT_texture_filter_anisotropic	#ifndef GL_EXT_texture_filter_anisotropic
	#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE	#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
	#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF	#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
	#endif	#endif

	#ifndef GL_EXT_vertex_weighting	#ifndef GL_EXT_vertex_weighting
	#define GL_MODELVIEW0_STACK_DEPTH_EXT GL_MODELVIEW_STACK_DEPTH	#define GL_MODELVIEW0_STACK_DEPTH_EXT GL_MODELVIEW_STACK_DEPTH
	#define GL_MODELVIEW1_STACK_DEPTH_EXT 0x8502	#define GL_MODELVIEW1_STACK_DEPTH_EXT 0x8502
	#define GL_MODELVIEW0_MATRIX_EXT GL_MODELVIEW_MATRIX	#define GL_MODELVIEW0_MATRIX_EXT GL_MODELVIEW_MATRIX

	#define GL_MODELVIEW_MATRIX1_EXT 0x8506	#define GL_MODELVIEW1_MATRIX_EXT 0x8506
	#define GL_VERTEX_WEIGHTING_EXT 0x8509	#define GL_VERTEX_WEIGHTING_EXT 0x8509
	#define GL_MODELVIEW0_EXT GL_MODELVIEW	#define GL_MODELVIEW0_EXT GL_MODELVIEW
	#define GL_MODELVIEW1_EXT 0x850A	#define GL_MODELVIEW1_EXT 0x850A
	#define GL_CURRENT_VERTEX_WEIGHT_EXT 0x850B	#define GL_CURRENT_VERTEX_WEIGHT_EXT 0x850B
	#define GL_VERTEX_WEIGHT_ARRAY_EXT 0x850C	#define GL_VERTEX_WEIGHT_ARRAY_EXT 0x850C
	#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT 0x850D	#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT 0x850D
	#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT 0x850E	#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT 0x850E
	#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F	#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F
	#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510	#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510
	#endif	#endif

	skipping to change at line 1221	skipping to change at line 2002
	#endif	#endif

	#ifndef GL_NV_vertex_array_range	#ifndef GL_NV_vertex_array_range
	#define GL_VERTEX_ARRAY_RANGE_NV 0x851D	#define GL_VERTEX_ARRAY_RANGE_NV 0x851D
	#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV 0x851E	#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV 0x851E
	#define GL_VERTEX_ARRAY_RANGE_VALID_NV 0x851F	#define GL_VERTEX_ARRAY_RANGE_VALID_NV 0x851F
	#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520	#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520
	#define GL_VERTEX_ARRAY_RANGE_POINTER_NV 0x8521	#define GL_VERTEX_ARRAY_RANGE_POINTER_NV 0x8521
	#endif	#endif


	#ifndef GL_NV_vertex_array_range2
	#define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV 0x8533
	#endif

	#ifndef GL_NV_register_combiners	#ifndef GL_NV_register_combiners
	#define GL_REGISTER_COMBINERS_NV 0x8522	#define GL_REGISTER_COMBINERS_NV 0x8522
	#define GL_VARIABLE_A_NV 0x8523	#define GL_VARIABLE_A_NV 0x8523
	#define GL_VARIABLE_B_NV 0x8524	#define GL_VARIABLE_B_NV 0x8524
	#define GL_VARIABLE_C_NV 0x8525	#define GL_VARIABLE_C_NV 0x8525
	#define GL_VARIABLE_D_NV 0x8526	#define GL_VARIABLE_D_NV 0x8526
	#define GL_VARIABLE_E_NV 0x8527	#define GL_VARIABLE_E_NV 0x8527
	#define GL_VARIABLE_F_NV 0x8528	#define GL_VARIABLE_F_NV 0x8528
	#define GL_VARIABLE_G_NV 0x8529	#define GL_VARIABLE_G_NV 0x8529
	#define GL_CONSTANT_COLOR0_NV 0x852A	#define GL_CONSTANT_COLOR0_NV 0x852A

	skipping to change at line 1401	skipping to change at line 2178
	#define GL_2PASS_1_EXT 0x80A3	#define GL_2PASS_1_EXT 0x80A3
	#define GL_4PASS_0_EXT 0x80A4	#define GL_4PASS_0_EXT 0x80A4
	#define GL_4PASS_1_EXT 0x80A5	#define GL_4PASS_1_EXT 0x80A5
	#define GL_4PASS_2_EXT 0x80A6	#define GL_4PASS_2_EXT 0x80A6
	#define GL_4PASS_3_EXT 0x80A7	#define GL_4PASS_3_EXT 0x80A7
	#define GL_SAMPLE_BUFFERS_EXT 0x80A8	#define GL_SAMPLE_BUFFERS_EXT 0x80A8
	#define GL_SAMPLES_EXT 0x80A9	#define GL_SAMPLES_EXT 0x80A9
	#define GL_SAMPLE_MASK_VALUE_EXT 0x80AA	#define GL_SAMPLE_MASK_VALUE_EXT 0x80AA
	#define GL_SAMPLE_MASK_INVERT_EXT 0x80AB	#define GL_SAMPLE_MASK_INVERT_EXT 0x80AB
	#define GL_SAMPLE_PATTERN_EXT 0x80AC	#define GL_SAMPLE_PATTERN_EXT 0x80AC

		#define GL_MULTISAMPLE_BIT_EXT 0x20000000
	#endif	#endif

	#ifndef GL_SGIX_vertex_preclip	#ifndef GL_SGIX_vertex_preclip
	#define GL_VERTEX_PRECLIP_SGIX 0x83EE	#define GL_VERTEX_PRECLIP_SGIX 0x83EE
	#define GL_VERTEX_PRECLIP_HINT_SGIX 0x83EF	#define GL_VERTEX_PRECLIP_HINT_SGIX 0x83EF
	#endif	#endif

	#ifndef GL_SGIX_convolution_accuracy	#ifndef GL_SGIX_convolution_accuracy
	#define GL_CONVOLUTION_HINT_SGIX 0x8316	#define GL_CONVOLUTION_HINT_SGIX 0x8316
	#endif	#endif

	skipping to change at line 1435	skipping to change at line 2213
	#define GL_EYE_POINT_SGIS 0x81F4	#define GL_EYE_POINT_SGIS 0x81F4
	#define GL_OBJECT_POINT_SGIS 0x81F5	#define GL_OBJECT_POINT_SGIS 0x81F5
	#define GL_EYE_LINE_SGIS 0x81F6	#define GL_EYE_LINE_SGIS 0x81F6
	#define GL_OBJECT_LINE_SGIS 0x81F7	#define GL_OBJECT_LINE_SGIS 0x81F7
	#endif	#endif

	#ifndef GL_SGIS_texture_color_mask	#ifndef GL_SGIS_texture_color_mask
	#define GL_TEXTURE_COLOR_WRITEMASK_SGIS 0x81EF	#define GL_TEXTURE_COLOR_WRITEMASK_SGIS 0x81EF
	#endif	#endif


		#ifndef GL_EXT_texture_env_dot3
		#define GL_DOT3_RGB_EXT 0x8740
		#define GL_DOT3_RGBA_EXT 0x8741
		#endif

		#ifndef GL_ATI_texture_mirror_once
		#define GL_MIRROR_CLAMP_ATI 0x8742
		#define GL_MIRROR_CLAMP_TO_EDGE_ATI 0x8743
		#endif

		#ifndef GL_NV_fence
		#define GL_ALL_COMPLETED_NV 0x84F2
		#define GL_FENCE_STATUS_NV 0x84F3
		#define GL_FENCE_CONDITION_NV 0x84F4
		#endif

		#ifndef GL_IBM_texture_mirrored_repeat
		#define GL_MIRRORED_REPEAT_IBM 0x8370
		#endif

		#ifndef GL_NV_evaluators
		#define GL_EVAL_2D_NV 0x86C0
		#define GL_EVAL_TRIANGULAR_2D_NV 0x86C1
		#define GL_MAP_TESSELLATION_NV 0x86C2
		#define GL_MAP_ATTRIB_U_ORDER_NV 0x86C3
		#define GL_MAP_ATTRIB_V_ORDER_NV 0x86C4
		#define GL_EVAL_FRACTIONAL_TESSELLATION_NV 0x86C5
		#define GL_EVAL_VERTEX_ATTRIB0_NV 0x86C6
		#define GL_EVAL_VERTEX_ATTRIB1_NV 0x86C7
		#define GL_EVAL_VERTEX_ATTRIB2_NV 0x86C8
		#define GL_EVAL_VERTEX_ATTRIB3_NV 0x86C9
		#define GL_EVAL_VERTEX_ATTRIB4_NV 0x86CA
		#define GL_EVAL_VERTEX_ATTRIB5_NV 0x86CB
		#define GL_EVAL_VERTEX_ATTRIB6_NV 0x86CC
		#define GL_EVAL_VERTEX_ATTRIB7_NV 0x86CD
		#define GL_EVAL_VERTEX_ATTRIB8_NV 0x86CE
		#define GL_EVAL_VERTEX_ATTRIB9_NV 0x86CF
		#define GL_EVAL_VERTEX_ATTRIB10_NV 0x86D0
		#define GL_EVAL_VERTEX_ATTRIB11_NV 0x86D1
		#define GL_EVAL_VERTEX_ATTRIB12_NV 0x86D2
		#define GL_EVAL_VERTEX_ATTRIB13_NV 0x86D3
		#define GL_EVAL_VERTEX_ATTRIB14_NV 0x86D4
		#define GL_EVAL_VERTEX_ATTRIB15_NV 0x86D5
		#define GL_MAX_MAP_TESSELLATION_NV 0x86D6
		#define GL_MAX_RATIONAL_EVAL_ORDER_NV 0x86D7
		#endif

		#ifndef GL_NV_packed_depth_stencil
		#define GL_DEPTH_STENCIL_NV 0x84F9
		#define GL_UNSIGNED_INT_24_8_NV 0x84FA
		#endif

		#ifndef GL_NV_register_combiners2
		#define GL_PER_STAGE_CONSTANTS_NV 0x8535
		#endif

		#ifndef GL_NV_texture_compression_vtc
		#endif

		#ifndef GL_NV_texture_rectangle
		#define GL_TEXTURE_RECTANGLE_NV 0x84F5
		#define GL_TEXTURE_BINDING_RECTANGLE_NV 0x84F6
		#define GL_PROXY_TEXTURE_RECTANGLE_NV 0x84F7
		#define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV 0x84F8
		#endif

		#ifndef GL_NV_texture_shader
		#define GL_OFFSET_TEXTURE_RECTANGLE_NV 0x864C
		#define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV 0x864D
		#define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV 0x864E
		#define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV 0x86D9
		#define GL_UNSIGNED_INT_S8_S8_8_8_NV 0x86DA
		#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB
		#define GL_DSDT_MAG_INTENSITY_NV 0x86DC
		#define GL_SHADER_CONSISTENT_NV 0x86DD
		#define GL_TEXTURE_SHADER_NV 0x86DE
		#define GL_SHADER_OPERATION_NV 0x86DF
		#define GL_CULL_MODES_NV 0x86E0
		#define GL_OFFSET_TEXTURE_MATRIX_NV 0x86E1
		#define GL_OFFSET_TEXTURE_SCALE_NV 0x86E2
		#define GL_OFFSET_TEXTURE_BIAS_NV 0x86E3
		#define GL_OFFSET_TEXTURE_2D_MATRIX_NV GL_OFFSET_TEXTURE_MATRIX_NV
		#define GL_OFFSET_TEXTURE_2D_SCALE_NV GL_OFFSET_TEXTURE_SCALE_NV
		#define GL_OFFSET_TEXTURE_2D_BIAS_NV GL_OFFSET_TEXTURE_BIAS_NV
		#define GL_PREVIOUS_TEXTURE_INPUT_NV 0x86E4
		#define GL_CONST_EYE_NV 0x86E5
		#define GL_PASS_THROUGH_NV 0x86E6
		#define GL_CULL_FRAGMENT_NV 0x86E7
		#define GL_OFFSET_TEXTURE_2D_NV 0x86E8
		#define GL_DEPENDENT_AR_TEXTURE_2D_NV 0x86E9
		#define GL_DEPENDENT_GB_TEXTURE_2D_NV 0x86EA
		#define GL_DOT_PRODUCT_NV 0x86EC
		#define GL_DOT_PRODUCT_DEPTH_REPLACE_NV 0x86ED
		#define GL_DOT_PRODUCT_TEXTURE_2D_NV 0x86EE
		#define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV 0x86F0
		#define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV 0x86F1
		#define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV 0x86F2
		#define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV 0x86F3
		#define GL_HILO_NV 0x86F4
		#define GL_DSDT_NV 0x86F5
		#define GL_DSDT_MAG_NV 0x86F6
		#define GL_DSDT_MAG_VIB_NV 0x86F7
		#define GL_HILO16_NV 0x86F8
		#define GL_SIGNED_HILO_NV 0x86F9
		#define GL_SIGNED_HILO16_NV 0x86FA
		#define GL_SIGNED_RGBA_NV 0x86FB
		#define GL_SIGNED_RGBA8_NV 0x86FC
		#define GL_SIGNED_RGB_NV 0x86FE
		#define GL_SIGNED_RGB8_NV 0x86FF
		#define GL_SIGNED_LUMINANCE_NV 0x8701
		#define GL_SIGNED_LUMINANCE8_NV 0x8702
		#define GL_SIGNED_LUMINANCE_ALPHA_NV 0x8703
		#define GL_SIGNED_LUMINANCE8_ALPHA8_NV 0x8704
		#define GL_SIGNED_ALPHA_NV 0x8705
		#define GL_SIGNED_ALPHA8_NV 0x8706
		#define GL_SIGNED_INTENSITY_NV 0x8707
		#define GL_SIGNED_INTENSITY8_NV 0x8708
		#define GL_DSDT8_NV 0x8709
		#define GL_DSDT8_MAG8_NV 0x870A
		#define GL_DSDT8_MAG8_INTENSITY8_NV 0x870B
		#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C
		#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D
		#define GL_HI_SCALE_NV 0x870E
		#define GL_LO_SCALE_NV 0x870F
		#define GL_DS_SCALE_NV 0x8710
		#define GL_DT_SCALE_NV 0x8711
		#define GL_MAGNITUDE_SCALE_NV 0x8712
		#define GL_VIBRANCE_SCALE_NV 0x8713
		#define GL_HI_BIAS_NV 0x8714
		#define GL_LO_BIAS_NV 0x8715
		#define GL_DS_BIAS_NV 0x8716
		#define GL_DT_BIAS_NV 0x8717
		#define GL_MAGNITUDE_BIAS_NV 0x8718
		#define GL_VIBRANCE_BIAS_NV 0x8719
		#define GL_TEXTURE_BORDER_VALUES_NV 0x871A
		#define GL_TEXTURE_HI_SIZE_NV 0x871B
		#define GL_TEXTURE_LO_SIZE_NV 0x871C
		#define GL_TEXTURE_DS_SIZE_NV 0x871D
		#define GL_TEXTURE_DT_SIZE_NV 0x871E
		#define GL_TEXTURE_MAG_SIZE_NV 0x871F
		#endif

		#ifndef GL_NV_texture_shader2
		#define GL_DOT_PRODUCT_TEXTURE_3D_NV 0x86EF
		#endif

		#ifndef GL_NV_vertex_array_range2
		#define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV 0x8533
		#endif

		#ifndef GL_NV_vertex_program
		#define GL_VERTEX_PROGRAM_NV 0x8620
		#define GL_VERTEX_STATE_PROGRAM_NV 0x8621
		#define GL_ATTRIB_ARRAY_SIZE_NV 0x8623
		#define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624
		#define GL_ATTRIB_ARRAY_TYPE_NV 0x8625
		#define GL_CURRENT_ATTRIB_NV 0x8626
		#define GL_PROGRAM_LENGTH_NV 0x8627
		#define GL_PROGRAM_STRING_NV 0x8628
		#define GL_MODELVIEW_PROJECTION_NV 0x8629
		#define GL_IDENTITY_NV 0x862A
		#define GL_INVERSE_NV 0x862B
		#define GL_TRANSPOSE_NV 0x862C
		#define GL_INVERSE_TRANSPOSE_NV 0x862D
		#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E
		#define GL_MAX_TRACK_MATRICES_NV 0x862F
		#define GL_MATRIX0_NV 0x8630
		#define GL_MATRIX1_NV 0x8631
		#define GL_MATRIX2_NV 0x8632
		#define GL_MATRIX3_NV 0x8633
		#define GL_MATRIX4_NV 0x8634
		#define GL_MATRIX5_NV 0x8635
		#define GL_MATRIX6_NV 0x8636
		#define GL_MATRIX7_NV 0x8637
		#define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640
		#define GL_CURRENT_MATRIX_NV 0x8641
		#define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642
		#define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643
		#define GL_PROGRAM_PARAMETER_NV 0x8644
		#define GL_ATTRIB_ARRAY_POINTER_NV 0x8645
		#define GL_PROGRAM_TARGET_NV 0x8646
		#define GL_PROGRAM_RESIDENT_NV 0x8647
		#define GL_TRACK_MATRIX_NV 0x8648
		#define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649
		#define GL_VERTEX_PROGRAM_BINDING_NV 0x864A
		#define GL_PROGRAM_ERROR_POSITION_NV 0x864B
		#define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650
		#define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651
		#define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652
		#define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653
		#define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654
		#define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655
		#define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656
		#define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657
		#define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658
		#define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659
		#define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A
		#define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B
		#define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C
		#define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D
		#define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E
		#define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F
		#define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660
		#define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661
		#define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662
		#define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663
		#define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664
		#define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665
		#define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666
		#define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667
		#define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668
		#define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669
		#define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A
		#define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B
		#define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C
		#define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D
		#define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E
		#define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F
		#define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670
		#define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671
		#define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672
		#define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673
		#define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674
		#define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675
		#define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676
		#define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677
		#define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678
		#define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679
		#define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A
		#define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B
		#define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C
		#define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D
		#define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E
		#define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F
		#endif

		#ifndef GL_SGIX_texture_coordinate_clamp
		#define GL_TEXTURE_MAX_CLAMP_S_SGIX 0x8369
		#define GL_TEXTURE_MAX_CLAMP_T_SGIX 0x836A
		#define GL_TEXTURE_MAX_CLAMP_R_SGIX 0x836B
		#endif

		#ifndef GL_SGIX_scalebias_hint
		#define GL_SCALEBIAS_HINT_SGIX 0x8322
		#endif

		#ifndef GL_OML_interlace
		#define GL_INTERLACE_OML 0x8980
		#define GL_INTERLACE_READ_OML 0x8981
		#endif

		#ifndef GL_OML_subsample
		#define GL_FORMAT_SUBSAMPLE_24_24_OML 0x8982
		#define GL_FORMAT_SUBSAMPLE_244_244_OML 0x8983
		#endif

		#ifndef GL_OML_resample
		#define GL_PACK_RESAMPLE_OML 0x8984
		#define GL_UNPACK_RESAMPLE_OML 0x8985
		#define GL_RESAMPLE_REPLICATE_OML 0x8986
		#define GL_RESAMPLE_ZERO_FILL_OML 0x8987
		#define GL_RESAMPLE_AVERAGE_OML 0x8988
		#define GL_RESAMPLE_DECIMATE_OML 0x8989
		#endif

		#ifndef GL_NV_copy_depth_to_color
		#define GL_DEPTH_STENCIL_TO_RGBA_NV 0x886E
		#define GL_DEPTH_STENCIL_TO_BGRA_NV 0x886F
		#endif

		#ifndef GL_ATI_envmap_bumpmap
		#define GL_BUMP_ROT_MATRIX_ATI 0x8775
		#define GL_BUMP_ROT_MATRIX_SIZE_ATI 0x8776
		#define GL_BUMP_NUM_TEX_UNITS_ATI 0x8777
		#define GL_BUMP_TEX_UNITS_ATI 0x8778
		#define GL_DUDV_ATI 0x8779
		#define GL_DU8DV8_ATI 0x877A
		#define GL_BUMP_ENVMAP_ATI 0x877B
		#define GL_BUMP_TARGET_ATI 0x877C
		#endif

		#ifndef GL_ATI_fragment_shader
		#define GL_FRAGMENT_SHADER_ATI 0x8920
		#define GL_REG_0_ATI 0x8921
		#define GL_REG_1_ATI 0x8922
		#define GL_REG_2_ATI 0x8923
		#define GL_REG_3_ATI 0x8924
		#define GL_REG_4_ATI 0x8925
		#define GL_REG_5_ATI 0x8926
		#define GL_REG_6_ATI 0x8927
		#define GL_REG_7_ATI 0x8928
		#define GL_REG_8_ATI 0x8929
		#define GL_REG_9_ATI 0x892A
		#define GL_REG_10_ATI 0x892B
		#define GL_REG_11_ATI 0x892C
		#define GL_REG_12_ATI 0x892D
		#define GL_REG_13_ATI 0x892E
		#define GL_REG_14_ATI 0x892F
		#define GL_REG_15_ATI 0x8930
		#define GL_REG_16_ATI 0x8931
		#define GL_REG_17_ATI 0x8932
		#define GL_REG_18_ATI 0x8933
		#define GL_REG_19_ATI 0x8934
		#define GL_REG_20_ATI 0x8935
		#define GL_REG_21_ATI 0x8936
		#define GL_REG_22_ATI 0x8937
		#define GL_REG_23_ATI 0x8938
		#define GL_REG_24_ATI 0x8939
		#define GL_REG_25_ATI 0x893A
		#define GL_REG_26_ATI 0x893B
		#define GL_REG_27_ATI 0x893C
		#define GL_REG_28_ATI 0x893D
		#define GL_REG_29_ATI 0x893E
		#define GL_REG_30_ATI 0x893F
		#define GL_REG_31_ATI 0x8940
		#define GL_CON_0_ATI 0x8941
		#define GL_CON_1_ATI 0x8942
		#define GL_CON_2_ATI 0x8943
		#define GL_CON_3_ATI 0x8944
		#define GL_CON_4_ATI 0x8945
		#define GL_CON_5_ATI 0x8946
		#define GL_CON_6_ATI 0x8947
		#define GL_CON_7_ATI 0x8948
		#define GL_CON_8_ATI 0x8949
		#define GL_CON_9_ATI 0x894A
		#define GL_CON_10_ATI 0x894B
		#define GL_CON_11_ATI 0x894C
		#define GL_CON_12_ATI 0x894D
		#define GL_CON_13_ATI 0x894E
		#define GL_CON_14_ATI 0x894F
		#define GL_CON_15_ATI 0x8950
		#define GL_CON_16_ATI 0x8951
		#define GL_CON_17_ATI 0x8952
		#define GL_CON_18_ATI 0x8953
		#define GL_CON_19_ATI 0x8954
		#define GL_CON_20_ATI 0x8955
		#define GL_CON_21_ATI 0x8956
		#define GL_CON_22_ATI 0x8957
		#define GL_CON_23_ATI 0x8958
		#define GL_CON_24_ATI 0x8959
		#define GL_CON_25_ATI 0x895A
		#define GL_CON_26_ATI 0x895B
		#define GL_CON_27_ATI 0x895C
		#define GL_CON_28_ATI 0x895D
		#define GL_CON_29_ATI 0x895E
		#define GL_CON_30_ATI 0x895F
		#define GL_CON_31_ATI 0x8960
		#define GL_MOV_ATI 0x8961
		#define GL_ADD_ATI 0x8963
		#define GL_MUL_ATI 0x8964
		#define GL_SUB_ATI 0x8965
		#define GL_DOT3_ATI 0x8966
		#define GL_DOT4_ATI 0x8967
		#define GL_MAD_ATI 0x8968
		#define GL_LERP_ATI 0x8969
		#define GL_CND_ATI 0x896A
		#define GL_CND0_ATI 0x896B
		#define GL_DOT2_ADD_ATI 0x896C
		#define GL_SECONDARY_INTERPOLATOR_ATI 0x896D
		#define GL_NUM_FRAGMENT_REGISTERS_ATI 0x896E
		#define GL_NUM_FRAGMENT_CONSTANTS_ATI 0x896F
		#define GL_NUM_PASSES_ATI 0x8970
		#define GL_NUM_INSTRUCTIONS_PER_PASS_ATI 0x8971
		#define GL_NUM_INSTRUCTIONS_TOTAL_ATI 0x8972
		#define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI 0x8973
		#define GL_NUM_LOOPBACK_COMPONENTS_ATI 0x8974
		#define GL_COLOR_ALPHA_PAIRING_ATI 0x8975
		#define GL_SWIZZLE_STR_ATI 0x8976
		#define GL_SWIZZLE_STQ_ATI 0x8977
		#define GL_SWIZZLE_STR_DR_ATI 0x8978
		#define GL_SWIZZLE_STQ_DQ_ATI 0x8979
		#define GL_SWIZZLE_STRQ_ATI 0x897A
		#define GL_SWIZZLE_STRQ_DQ_ATI 0x897B
		#define GL_RED_BIT_ATI 0x00000001
		#define GL_GREEN_BIT_ATI 0x00000002
		#define GL_BLUE_BIT_ATI 0x00000004
		#define GL_2X_BIT_ATI 0x00000001
		#define GL_4X_BIT_ATI 0x00000002
		#define GL_8X_BIT_ATI 0x00000004
		#define GL_HALF_BIT_ATI 0x00000008
		#define GL_QUARTER_BIT_ATI 0x00000010
		#define GL_EIGHTH_BIT_ATI 0x00000020
		#define GL_SATURATE_BIT_ATI 0x00000040
		#define GL_COMP_BIT_ATI 0x00000002
		#define GL_NEGATE_BIT_ATI 0x00000004
		#define GL_BIAS_BIT_ATI 0x00000008
		#endif

		#ifndef GL_ATI_pn_triangles
		#define GL_PN_TRIANGLES_ATI 0x87F0
		#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F1
		#define GL_PN_TRIANGLES_POINT_MODE_ATI 0x87F2
		#define GL_PN_TRIANGLES_NORMAL_MODE_ATI 0x87F3
		#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F4
		#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI 0x87F5
		#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI 0x87F6
		#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI 0x87F7
		#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI 0x87F8
		#endif

		#ifndef GL_ATI_vertex_array_object
		#define GL_STATIC_ATI 0x8760
		#define GL_DYNAMIC_ATI 0x8761
		#define GL_PRESERVE_ATI 0x8762
		#define GL_DISCARD_ATI 0x8763
		#define GL_OBJECT_BUFFER_SIZE_ATI 0x8764
		#define GL_OBJECT_BUFFER_USAGE_ATI 0x8765
		#define GL_ARRAY_OBJECT_BUFFER_ATI 0x8766
		#define GL_ARRAY_OBJECT_OFFSET_ATI 0x8767
		#endif

		#ifndef GL_EXT_vertex_shader
		#define GL_VERTEX_SHADER_EXT 0x8780
		#define GL_VERTEX_SHADER_BINDING_EXT 0x8781
		#define GL_OP_INDEX_EXT 0x8782
		#define GL_OP_NEGATE_EXT 0x8783
		#define GL_OP_DOT3_EXT 0x8784
		#define GL_OP_DOT4_EXT 0x8785
		#define GL_OP_MUL_EXT 0x8786
		#define GL_OP_ADD_EXT 0x8787
		#define GL_OP_MADD_EXT 0x8788
		#define GL_OP_FRAC_EXT 0x8789
		#define GL_OP_MAX_EXT 0x878A
		#define GL_OP_MIN_EXT 0x878B
		#define GL_OP_SET_GE_EXT 0x878C
		#define GL_OP_SET_LT_EXT 0x878D
		#define GL_OP_CLAMP_EXT 0x878E
		#define GL_OP_FLOOR_EXT 0x878F
		#define GL_OP_ROUND_EXT 0x8790
		#define GL_OP_EXP_BASE_2_EXT 0x8791
		#define GL_OP_LOG_BASE_2_EXT 0x8792
		#define GL_OP_POWER_EXT 0x8793
		#define GL_OP_RECIP_EXT 0x8794
		#define GL_OP_RECIP_SQRT_EXT 0x8795
		#define GL_OP_SUB_EXT 0x8796
		#define GL_OP_CROSS_PRODUCT_EXT 0x8797
		#define GL_OP_MULTIPLY_MATRIX_EXT 0x8798
		#define GL_OP_MOV_EXT 0x8799
		#define GL_OUTPUT_VERTEX_EXT 0x879A
		#define GL_OUTPUT_COLOR0_EXT 0x879B
		#define GL_OUTPUT_COLOR1_EXT 0x879C
		#define GL_OUTPUT_TEXTURE_COORD0_EXT 0x879D
		#define GL_OUTPUT_TEXTURE_COORD1_EXT 0x879E
		#define GL_OUTPUT_TEXTURE_COORD2_EXT 0x879F
		#define GL_OUTPUT_TEXTURE_COORD3_EXT 0x87A0
		#define GL_OUTPUT_TEXTURE_COORD4_EXT 0x87A1
		#define GL_OUTPUT_TEXTURE_COORD5_EXT 0x87A2
		#define GL_OUTPUT_TEXTURE_COORD6_EXT 0x87A3
		#define GL_OUTPUT_TEXTURE_COORD7_EXT 0x87A4
		#define GL_OUTPUT_TEXTURE_COORD8_EXT 0x87A5
		#define GL_OUTPUT_TEXTURE_COORD9_EXT 0x87A6
		#define GL_OUTPUT_TEXTURE_COORD10_EXT 0x87A7
		#define GL_OUTPUT_TEXTURE_COORD11_EXT 0x87A8
		#define GL_OUTPUT_TEXTURE_COORD12_EXT 0x87A9
		#define GL_OUTPUT_TEXTURE_COORD13_EXT 0x87AA
		#define GL_OUTPUT_TEXTURE_COORD14_EXT 0x87AB
		#define GL_OUTPUT_TEXTURE_COORD15_EXT 0x87AC
		#define GL_OUTPUT_TEXTURE_COORD16_EXT 0x87AD
		#define GL_OUTPUT_TEXTURE_COORD17_EXT 0x87AE
		#define GL_OUTPUT_TEXTURE_COORD18_EXT 0x87AF
		#define GL_OUTPUT_TEXTURE_COORD19_EXT 0x87B0
		#define GL_OUTPUT_TEXTURE_COORD20_EXT 0x87B1
		#define GL_OUTPUT_TEXTURE_COORD21_EXT 0x87B2
		#define GL_OUTPUT_TEXTURE_COORD22_EXT 0x87B3
		#define GL_OUTPUT_TEXTURE_COORD23_EXT 0x87B4
		#define GL_OUTPUT_TEXTURE_COORD24_EXT 0x87B5
		#define GL_OUTPUT_TEXTURE_COORD25_EXT 0x87B6
		#define GL_OUTPUT_TEXTURE_COORD26_EXT 0x87B7
		#define GL_OUTPUT_TEXTURE_COORD27_EXT 0x87B8
		#define GL_OUTPUT_TEXTURE_COORD28_EXT 0x87B9
		#define GL_OUTPUT_TEXTURE_COORD29_EXT 0x87BA
		#define GL_OUTPUT_TEXTURE_COORD30_EXT 0x87BB
		#define GL_OUTPUT_TEXTURE_COORD31_EXT 0x87BC
		#define GL_OUTPUT_FOG_EXT 0x87BD
		#define GL_SCALAR_EXT 0x87BE
		#define GL_VECTOR_EXT 0x87BF
		#define GL_MATRIX_EXT 0x87C0
		#define GL_VARIANT_EXT 0x87C1
		#define GL_INVARIANT_EXT 0x87C2
		#define GL_LOCAL_CONSTANT_EXT 0x87C3
		#define GL_LOCAL_EXT 0x87C4
		#define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87C5
		#define GL_MAX_VERTEX_SHADER_VARIANTS_EXT 0x87C6
		#define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT 0x87C7
		#define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87C8
		#define GL_MAX_VERTEX_SHADER_LOCALS_EXT 0x87C9
		#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CA
		#define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT 0x87CB
		#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87CC
		#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT 0x87CD
		#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT 0x87CE
		#define GL_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CF
		#define GL_VERTEX_SHADER_VARIANTS_EXT 0x87D0
		#define GL_VERTEX_SHADER_INVARIANTS_EXT 0x87D1
		#define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87D2
		#define GL_VERTEX_SHADER_LOCALS_EXT 0x87D3
		#define GL_VERTEX_SHADER_OPTIMIZED_EXT 0x87D4
		#define GL_X_EXT 0x87D5
		#define GL_Y_EXT 0x87D6
		#define GL_Z_EXT 0x87D7
		#define GL_W_EXT 0x87D8
		#define GL_NEGATIVE_X_EXT 0x87D9
		#define GL_NEGATIVE_Y_EXT 0x87DA
		#define GL_NEGATIVE_Z_EXT 0x87DB
		#define GL_NEGATIVE_W_EXT 0x87DC
		#define GL_ZERO_EXT 0x87DD
		#define GL_ONE_EXT 0x87DE
		#define GL_NEGATIVE_ONE_EXT 0x87DF
		#define GL_NORMALIZED_RANGE_EXT 0x87E0
		#define GL_FULL_RANGE_EXT 0x87E1
		#define GL_CURRENT_VERTEX_EXT 0x87E2
		#define GL_MVP_MATRIX_EXT 0x87E3
		#define GL_VARIANT_VALUE_EXT 0x87E4
		#define GL_VARIANT_DATATYPE_EXT 0x87E5
		#define GL_VARIANT_ARRAY_STRIDE_EXT 0x87E6
		#define GL_VARIANT_ARRAY_TYPE_EXT 0x87E7
		#define GL_VARIANT_ARRAY_EXT 0x87E8
		#define GL_VARIANT_ARRAY_POINTER_EXT 0x87E9
		#define GL_INVARIANT_VALUE_EXT 0x87EA
		#define GL_INVARIANT_DATATYPE_EXT 0x87EB
		#define GL_LOCAL_CONSTANT_VALUE_EXT 0x87EC
		#define GL_LOCAL_CONSTANT_DATATYPE_EXT 0x87ED
		#endif

		#ifndef GL_ATI_vertex_streams
		#define GL_MAX_VERTEX_STREAMS_ATI 0x876B
		#define GL_VERTEX_STREAM0_ATI 0x876C
		#define GL_VERTEX_STREAM1_ATI 0x876D
		#define GL_VERTEX_STREAM2_ATI 0x876E
		#define GL_VERTEX_STREAM3_ATI 0x876F
		#define GL_VERTEX_STREAM4_ATI 0x8770
		#define GL_VERTEX_STREAM5_ATI 0x8771
		#define GL_VERTEX_STREAM6_ATI 0x8772
		#define GL_VERTEX_STREAM7_ATI 0x8773
		#define GL_VERTEX_SOURCE_ATI 0x8774
		#endif

		#ifndef GL_ATI_element_array
		#define GL_ELEMENT_ARRAY_ATI 0x8768
		#define GL_ELEMENT_ARRAY_TYPE_ATI 0x8769
		#define GL_ELEMENT_ARRAY_POINTER_ATI 0x876A
		#endif

		#ifndef GL_SUN_mesh_array
		#define GL_QUAD_MESH_SUN 0x8614
		#define GL_TRIANGLE_MESH_SUN 0x8615
		#endif

		#ifndef GL_SUN_slice_accum
		#define GL_SLICE_ACCUM_SUN 0x85CC
		#endif

		#ifndef GL_NV_multisample_filter_hint
		#define GL_MULTISAMPLE_FILTER_HINT_NV 0x8534
		#endif

		#ifndef GL_NV_depth_clamp
		#define GL_DEPTH_CLAMP_NV 0x864F
		#endif

		#ifndef GL_NV_occlusion_query
		#define GL_PIXEL_COUNTER_BITS_NV 0x8864
		#define GL_CURRENT_OCCLUSION_QUERY_ID_NV 0x8865
		#define GL_PIXEL_COUNT_NV 0x8866
		#define GL_PIXEL_COUNT_AVAILABLE_NV 0x8867
		#endif

		#ifndef GL_NV_point_sprite
		#define GL_POINT_SPRITE_NV 0x8861
		#define GL_COORD_REPLACE_NV 0x8862
		#define GL_POINT_SPRITE_R_MODE_NV 0x8863
		#endif

		#ifndef GL_NV_texture_shader3
		#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV 0x8850
		#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV 0x8851
		#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8852
		#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV 0x8853
		#define GL_OFFSET_HILO_TEXTURE_2D_NV 0x8854
		#define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV 0x8855
		#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV 0x8856
		#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8857
		#define GL_DEPENDENT_HILO_TEXTURE_2D_NV 0x8858
		#define GL_DEPENDENT_RGB_TEXTURE_3D_NV 0x8859
		#define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV 0x885A
		#define GL_DOT_PRODUCT_PASS_THROUGH_NV 0x885B
		#define GL_DOT_PRODUCT_TEXTURE_1D_NV 0x885C
		#define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV 0x885D
		#define GL_HILO8_NV 0x885E
		#define GL_SIGNED_HILO8_NV 0x885F
		#define GL_FORCE_BLUE_TO_ONE_NV 0x8860
		#endif

		#ifndef GL_NV_vertex_program1_1
		#endif

		#ifndef GL_EXT_shadow_funcs
		#endif

		#ifndef GL_EXT_stencil_two_side
		#define GL_STENCIL_TEST_TWO_SIDE_EXT 0x8910
		#define GL_ACTIVE_STENCIL_FACE_EXT 0x8911
		#endif

		#ifndef GL_ATI_text_fragment_shader
		#define GL_TEXT_FRAGMENT_SHADER_ATI 0x8200
		#endif

		#ifndef GL_APPLE_client_storage
		#define GL_UNPACK_CLIENT_STORAGE_APPLE 0x85B2
		#endif

		#ifndef GL_APPLE_element_array
		#define GL_ELEMENT_ARRAY_APPLE 0x8768
		#define GL_ELEMENT_ARRAY_TYPE_APPLE 0x8769
		#define GL_ELEMENT_ARRAY_POINTER_APPLE 0x876A
		#endif

		#ifndef GL_APPLE_fence
		#define GL_DRAW_PIXELS_APPLE 0x8A0A
		#define GL_FENCE_APPLE 0x8A0B
		#endif

		#ifndef GL_APPLE_vertex_array_object
		#define GL_VERTEX_ARRAY_BINDING_APPLE 0x85B5
		#endif

		#ifndef GL_APPLE_vertex_array_range
		#define GL_VERTEX_ARRAY_RANGE_APPLE 0x851D
		#define GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE 0x851E
		#define GL_VERTEX_ARRAY_STORAGE_HINT_APPLE 0x851F
		#define GL_VERTEX_ARRAY_RANGE_POINTER_APPLE 0x8521
		#define GL_STORAGE_CACHED_APPLE 0x85BE
		#define GL_STORAGE_SHARED_APPLE 0x85BF
		#endif

		#ifndef GL_APPLE_ycbcr_422
		#define GL_YCBCR_422_APPLE 0x85B9
		#define GL_UNSIGNED_SHORT_8_8_APPLE 0x85BA
		#define GL_UNSIGNED_SHORT_8_8_REV_APPLE 0x85BB
		#endif

		#ifndef GL_S3_s3tc
		#define GL_RGB_S3TC 0x83A0
		#define GL_RGB4_S3TC 0x83A1
		#define GL_RGBA_S3TC 0x83A2
		#define GL_RGBA4_S3TC 0x83A3
		#endif

		#ifndef GL_ATI_draw_buffers
		#define GL_MAX_DRAW_BUFFERS_ATI 0x8824
		#define GL_DRAW_BUFFER0_ATI 0x8825
		#define GL_DRAW_BUFFER1_ATI 0x8826
		#define GL_DRAW_BUFFER2_ATI 0x8827
		#define GL_DRAW_BUFFER3_ATI 0x8828
		#define GL_DRAW_BUFFER4_ATI 0x8829
		#define GL_DRAW_BUFFER5_ATI 0x882A
		#define GL_DRAW_BUFFER6_ATI 0x882B
		#define GL_DRAW_BUFFER7_ATI 0x882C
		#define GL_DRAW_BUFFER8_ATI 0x882D
		#define GL_DRAW_BUFFER9_ATI 0x882E
		#define GL_DRAW_BUFFER10_ATI 0x882F
		#define GL_DRAW_BUFFER11_ATI 0x8830
		#define GL_DRAW_BUFFER12_ATI 0x8831
		#define GL_DRAW_BUFFER13_ATI 0x8832
		#define GL_DRAW_BUFFER14_ATI 0x8833
		#define GL_DRAW_BUFFER15_ATI 0x8834
		#endif

		#ifndef GL_ATI_pixel_format_float
		#define GL_TYPE_RGBA_FLOAT_ATI 0x8820
		#define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835
		#endif

		#ifndef GL_ATI_texture_env_combine3
		#define GL_MODULATE_ADD_ATI 0x8744
		#define GL_MODULATE_SIGNED_ADD_ATI 0x8745
		#define GL_MODULATE_SUBTRACT_ATI 0x8746
		#endif

		#ifndef GL_ATI_texture_float
		#define GL_RGBA_FLOAT32_ATI 0x8814
		#define GL_RGB_FLOAT32_ATI 0x8815
		#define GL_ALPHA_FLOAT32_ATI 0x8816
		#define GL_INTENSITY_FLOAT32_ATI 0x8817
		#define GL_LUMINANCE_FLOAT32_ATI 0x8818
		#define GL_LUMINANCE_ALPHA_FLOAT32_ATI 0x8819
		#define GL_RGBA_FLOAT16_ATI 0x881A
		#define GL_RGB_FLOAT16_ATI 0x881B
		#define GL_ALPHA_FLOAT16_ATI 0x881C
		#define GL_INTENSITY_FLOAT16_ATI 0x881D
		#define GL_LUMINANCE_FLOAT16_ATI 0x881E
		#define GL_LUMINANCE_ALPHA_FLOAT16_ATI 0x881F
		#endif

		#ifndef GL_NV_float_buffer
		#define GL_FLOAT_R_NV 0x8880
		#define GL_FLOAT_RG_NV 0x8881
		#define GL_FLOAT_RGB_NV 0x8882
		#define GL_FLOAT_RGBA_NV 0x8883
		#define GL_FLOAT_R16_NV 0x8884
		#define GL_FLOAT_R32_NV 0x8885
		#define GL_FLOAT_RG16_NV 0x8886
		#define GL_FLOAT_RG32_NV 0x8887
		#define GL_FLOAT_RGB16_NV 0x8888
		#define GL_FLOAT_RGB32_NV 0x8889
		#define GL_FLOAT_RGBA16_NV 0x888A
		#define GL_FLOAT_RGBA32_NV 0x888B
		#define GL_TEXTURE_FLOAT_COMPONENTS_NV 0x888C
		#define GL_FLOAT_CLEAR_COLOR_VALUE_NV 0x888D
		#define GL_FLOAT_RGBA_MODE_NV 0x888E
		#endif

		#ifndef GL_NV_fragment_program
		#define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868
		#define GL_FRAGMENT_PROGRAM_NV 0x8870
		#define GL_MAX_TEXTURE_COORDS_NV 0x8871
		#define GL_MAX_TEXTURE_IMAGE_UNITS_NV 0x8872
		#define GL_FRAGMENT_PROGRAM_BINDING_NV 0x8873
		#define GL_PROGRAM_ERROR_STRING_NV 0x8874
		#endif

		#ifndef GL_NV_half_float
		#define GL_HALF_FLOAT_NV 0x140B
		#endif

		#ifndef GL_NV_pixel_data_range
		#define GL_WRITE_PIXEL_DATA_RANGE_NV 0x8878
		#define GL_READ_PIXEL_DATA_RANGE_NV 0x8879
		#define GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV 0x887A
		#define GL_READ_PIXEL_DATA_RANGE_LENGTH_NV 0x887B
		#define GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV 0x887C
		#define GL_READ_PIXEL_DATA_RANGE_POINTER_NV 0x887D
		#endif

		#ifndef GL_NV_primitive_restart
		#define GL_PRIMITIVE_RESTART_NV 0x8558
		#define GL_PRIMITIVE_RESTART_INDEX_NV 0x8559
		#endif

		#ifndef GL_NV_texture_expand_normal
		#define GL_TEXTURE_UNSIGNED_REMAP_MODE_NV 0x888F
		#endif

		#ifndef GL_NV_vertex_program2
		#endif

		#ifndef GL_ATI_map_object_buffer
		#endif

		#ifndef GL_ATI_separate_stencil
		#define GL_STENCIL_BACK_FUNC_ATI 0x8800
		#define GL_STENCIL_BACK_FAIL_ATI 0x8801
		#define GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI 0x8802
		#define GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI 0x8803
		#endif

		#ifndef GL_ATI_vertex_attrib_array_object
		#endif

		#ifndef GL_OES_read_format
		#define GL_IMPLEMENTATION_COLOR_READ_TYPE_OES 0x8B9A
		#define GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES 0x8B9B
		#endif

		#ifndef GL_EXT_depth_bounds_test
		#define GL_DEPTH_BOUNDS_TEST_EXT 0x8890
		#define GL_DEPTH_BOUNDS_EXT 0x8891
		#endif

		#ifndef GL_EXT_texture_mirror_clamp
		#define GL_MIRROR_CLAMP_EXT 0x8742
		#define GL_MIRROR_CLAMP_TO_EDGE_EXT 0x8743
		#define GL_MIRROR_CLAMP_TO_BORDER_EXT 0x8912
		#endif

		#ifndef GL_EXT_blend_equation_separate
		#define GL_BLEND_EQUATION_RGB_EXT GL_BLEND_EQUATION
		#define GL_BLEND_EQUATION_ALPHA_EXT 0x883D
		#endif

		#ifndef GL_MESA_pack_invert
		#define GL_PACK_INVERT_MESA 0x8758
		#endif

		#ifndef GL_MESA_ycbcr_texture
		#define GL_UNSIGNED_SHORT_8_8_MESA 0x85BA
		#define GL_UNSIGNED_SHORT_8_8_REV_MESA 0x85BB
		#define GL_YCBCR_MESA 0x8757
		#endif

		#ifndef GL_EXT_pixel_buffer_object
		#define GL_PIXEL_PACK_BUFFER_EXT 0x88EB
		#define GL_PIXEL_UNPACK_BUFFER_EXT 0x88EC
		#define GL_PIXEL_PACK_BUFFER_BINDING_EXT 0x88ED
		#define GL_PIXEL_UNPACK_BUFFER_BINDING_EXT 0x88EF
		#endif

		#ifndef GL_NV_fragment_program_option
		#endif

		#ifndef GL_NV_fragment_program2
		#define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV 0x88F4
		#define GL_MAX_PROGRAM_CALL_DEPTH_NV 0x88F5
		#define GL_MAX_PROGRAM_IF_DEPTH_NV 0x88F6
		#define GL_MAX_PROGRAM_LOOP_DEPTH_NV 0x88F7
		#define GL_MAX_PROGRAM_LOOP_COUNT_NV 0x88F8
		#endif

		#ifndef GL_NV_vertex_program2_option
		/* reuse GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
		/* reuse GL_MAX_PROGRAM_CALL_DEPTH_NV */
		#endif

		#ifndef GL_NV_vertex_program3
		/* reuse GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
		#endif

		#ifndef GL_EXT_framebuffer_object
		#define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506
		#define GL_MAX_RENDERBUFFER_SIZE_EXT 0x84E8
		#define GL_FRAMEBUFFER_BINDING_EXT 0x8CA6
		#define GL_RENDERBUFFER_BINDING_EXT 0x8CA7
		#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT 0x8CD0
		#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT 0x8CD1
		#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT 0x8CD2
		#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3
		#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT 0x8CD4
		#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5
		#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT 0x8CD6
		#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT 0x8CD7
		#define GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT 0x8CD8
		#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9
		#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT 0x8CDA
		#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT 0x8CDB
		#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT 0x8CDC
		#define GL_FRAMEBUFFER_UNSUPPORTED_EXT 0x8CDD
		#define GL_MAX_COLOR_ATTACHMENTS_EXT 0x8CDF
		#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0
		#define GL_COLOR_ATTACHMENT1_EXT 0x8CE1
		#define GL_COLOR_ATTACHMENT2_EXT 0x8CE2
		#define GL_COLOR_ATTACHMENT3_EXT 0x8CE3
		#define GL_COLOR_ATTACHMENT4_EXT 0x8CE4
		#define GL_COLOR_ATTACHMENT5_EXT 0x8CE5
		#define GL_COLOR_ATTACHMENT6_EXT 0x8CE6
		#define GL_COLOR_ATTACHMENT7_EXT 0x8CE7
		#define GL_COLOR_ATTACHMENT8_EXT 0x8CE8
		#define GL_COLOR_ATTACHMENT9_EXT 0x8CE9
		#define GL_COLOR_ATTACHMENT10_EXT 0x8CEA
		#define GL_COLOR_ATTACHMENT11_EXT 0x8CEB
		#define GL_COLOR_ATTACHMENT12_EXT 0x8CEC
		#define GL_COLOR_ATTACHMENT13_EXT 0x8CED
		#define GL_COLOR_ATTACHMENT14_EXT 0x8CEE
		#define GL_COLOR_ATTACHMENT15_EXT 0x8CEF
		#define GL_DEPTH_ATTACHMENT_EXT 0x8D00
		#define GL_STENCIL_ATTACHMENT_EXT 0x8D20
		#define GL_FRAMEBUFFER_EXT 0x8D40
		#define GL_RENDERBUFFER_EXT 0x8D41
		#define GL_RENDERBUFFER_WIDTH_EXT 0x8D42
		#define GL_RENDERBUFFER_HEIGHT_EXT 0x8D43
		#define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44
		#define GL_STENCIL_INDEX_EXT 0x8D45
		#define GL_STENCIL_INDEX1_EXT 0x8D46
		#define GL_STENCIL_INDEX4_EXT 0x8D47
		#define GL_STENCIL_INDEX8_EXT 0x8D48
		#define GL_STENCIL_INDEX16_EXT 0x8D49
		#define GL_RENDERBUFFER_RED_SIZE_EXT 0x8D50
		#define GL_RENDERBUFFER_GREEN_SIZE_EXT 0x8D51
		#define GL_RENDERBUFFER_BLUE_SIZE_EXT 0x8D52
		#define GL_RENDERBUFFER_ALPHA_SIZE_EXT 0x8D53
		#define GL_RENDERBUFFER_DEPTH_SIZE_EXT 0x8D54
		#define GL_RENDERBUFFER_STENCIL_SIZE_EXT 0x8D55
		#endif

		#ifndef GL_GREMEDY_string_marker
		#endif

		#ifndef GL_EXT_Cg_shader
		#define GL_CG_VERTEX_SHADER_EXT 0x890E
		#define GL_CG_FRAGMENT_SHADER_EXT 0x890F
		#endif

		#ifndef GL_EXT_timer_query
		#define GL_TIME_ELAPSED_EXT 0x88BF
		#endif

		#ifndef GL_EXT_texture_buffer_object
		#define GL_TEXTURE_BUFFER_EXT 0x8C2A
		#define GL_MAX_TEXTURE_BUFFER_SIZE_EXT 0x8C2B
		#define GL_TEXTURE_BINDING_BUFFER_EXT 0x8C2C
		#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT 0x8C2D
		#define GL_TEXTURE_BUFFER_FORMAT_EXT 0x8C2E
		#endif

		#ifndef GL_EXT_gpu_shader4
		#define GL_SAMPLER_1D_ARRAY_EXT 0x8DC0
		#define GL_SAMPLER_2D_ARRAY_EXT 0x8DC1
		#define GL_SAMPLER_BUFFER_EXT 0x8DC2
		#define GL_SAMPLER_1D_ARRAY_SHADOW_EXT 0x8DC3
		#define GL_SAMPLER_2D_ARRAY_SHADOW_EXT 0x8DC4
		#define GL_SAMPLER_CUBE_SHADOW_EXT 0x8DC5
		#define GL_UNSIGNED_INT_VEC2_EXT 0x8DC6
		#define GL_UNSIGNED_INT_VEC3_EXT 0x8DC7
		#define GL_UNSIGNED_INT_VEC4_EXT 0x8DC8
		#define GL_INT_SAMPLER_1D_EXT 0x8DC9
		#define GL_INT_SAMPLER_2D_EXT 0x8DCA
		#define GL_INT_SAMPLER_3D_EXT 0x8DCB
		#define GL_INT_SAMPLER_CUBE_EXT 0x8DCC
		#define GL_INT_SAMPLER_2D_RECT_EXT 0x8DCD
		#define GL_INT_SAMPLER_1D_ARRAY_EXT 0x8DCE
		#define GL_INT_SAMPLER_2D_ARRAY_EXT 0x8DCF
		#define GL_INT_SAMPLER_BUFFER_EXT 0x8DD0
		#define GL_UNSIGNED_INT_SAMPLER_1D_EXT 0x8DD1
		#define GL_UNSIGNED_INT_SAMPLER_2D_EXT 0x8DD2
		#define GL_UNSIGNED_INT_SAMPLER_3D_EXT 0x8DD3
		#define GL_UNSIGNED_INT_SAMPLER_CUBE_EXT 0x8DD4
		#define GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT 0x8DD5
		#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT 0x8DD6
		#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT 0x8DD7
		#define GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT 0x8DD8
		#define GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT 0x88FD
		#endif

		#ifndef GL_EXT_geometry_shader4
		#define GL_GEOMETRY_SHADER_EXT 0x8DD9
		#define GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT 0x8DDD
		#define GL_MAX_VERTEX_VARYING_COMPONENTS_EXT 0x8DDE
		#define GL_MAX_VARYING_COMPONENTS_EXT 0x8B4B
		#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT 0x8DDF
		#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT 0x8DE0
		#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT 0x8DE1
		#define GL_GEOMETRY_VERTICES_OUT_EXT 0x8DDA
		#define GL_GEOMETRY_INPUT_TYPE_EXT 0x8DDB
		#define GL_GEOMETRY_OUTPUT_TYPE_EXT 0x8DDC
		#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT 0x8C29
		#define GL_LINES_ADJACENCY_EXT 0xA
		#define GL_LINE_STRIP_ADJACENCY_EXT 0xB
		#define GL_TRIANGLES_ADJACENCY_EXT 0xC
		#define GL_TRIANGLE_STRIP_ADJACENCY_EXT 0xD
		#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT 0x8DA7
		#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT 0x8DA8
		#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT 0x8DA9
		#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT 0x8CD4
		#define GL_PROGRAM_POINT_SIZE_EXT 0x8642
		#endif

		#ifndef GL_EXT_bindable_uniform
		#define GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT 0x8DE2
		#define GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT 0x8DE3
		#define GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT 0x8DE4
		#define GL_MAX_BINDABLE_UNIFORM_SIZE_EXT 0x8DED
		#define GL_UNIFORM_BUFFER_EXT 0x8DEE
		#define GL_UNIFORM_BUFFER_BINDING_EXT 0x8DEF
		#endif

		#ifndef GL_EXT_framebuffer_sRGB
		#define GL_FRAMEBUFFER_SRGB_EXT 0x8DB9
		#define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x8DBA
		#endif

		#ifndef GL_EXT_texture_shared_exponent
		#define GL_RGB9_E5_EXT 0x8C3D
		#define GL_UNSIGNED_INT_5_9_9_9_REV_EXT 0x8C3E
		#define GL_TEXTURE_SHARED_SIZE_EXT 0x8C3F
		#endif

		#ifndef GL_EXT_packed_float
		#define GL_R11F_G11F_B10F_EXT 0x8C3A
		#define GL_UNSIGNED_INT_10F_11F_11F_REV_EXT 0x8C3B
		#define GL_RGBA_SIGNED_COMPONENTS_EXT 0x8C3C
		#endif

		#ifndef GL_EXT_texture_array
		#define GL_TEXTURE_1D_ARRAY_EXT 0x8C18
		#define GL_PROXY_TEXTURE_1D_ARRAY_EXT 0x8C19
		#define GL_TEXTURE_2D_ARRAY_EXT 0x8C1A
		#define GL_PROXY_TEXTURE_2D_ARRAY_EXT 0x8C1B
		#define GL_TEXTURE_BINDING_1D_ARRAY_EXT 0x8C1C
		#define GL_TEXTURE_BINDING_2D_ARRAY_EXT 0x8C1D
		#define GL_MAX_ARRAY_TEXTURE_LAYERS_EXT 0x88FF
		#define GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT 0x884E
		/* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
		#endif

		#ifndef GL_EXT_texture_integer
		#define GL_RGBA32UI_EXT 0x8D70
		#define GL_RGB32UI_EXT 0x8D71
		#define GL_ALPHA32UI_EXT 0x8D72
		#define GL_INTENSITY32UI_EXT 0x8D73
		#define GL_LUMINANCE32UI_EXT 0x8D74
		#define GL_LUMINANCE_ALPHA32UI_EXT 0x8D75
		#define GL_RGBA16UI_EXT 0x8D76
		#define GL_RGB16UI_EXT 0x8D77
		#define GL_ALPHA16UI_EXT 0x8D78
		#define GL_INTENSITY16UI_EXT 0x8D79
		#define GL_LUMINANCE16UI_EXT 0x8D7A
		#define GL_LUMINANCE_ALPHA16UI_EXT 0x8D7B
		#define GL_RGBA8UI_EXT 0x8D7C
		#define GL_RGB8UI_EXT 0x8D7D
		#define GL_ALPHA8UI_EXT 0x8D7E
		#define GL_INTENSITY8UI_EXT 0x8D7F
		#define GL_LUMINANCE8UI_EXT 0x8D80
		#define GL_LUMINANCE_ALPHA8UI_EXT 0x8D81
		#define GL_RGBA32I_EXT 0x8D82
		#define GL_RGB32I_EXT 0x8D83
		#define GL_ALPHA32I_EXT 0x8D84
		#define GL_INTENSITY32I_EXT 0x8D85
		#define GL_LUMINANCE32I_EXT 0x8D86
		#define GL_LUMINANCE_ALPHA32I_EXT 0x8D87
		#define GL_RGBA16I_EXT 0x8D88
		#define GL_RGB16I_EXT 0x8D89
		#define GL_ALPHA16I_EXT 0x8D8A
		#define GL_INTENSITY16I_EXT 0x8D8B
		#define GL_LUMINANCE16I_EXT 0x8D8C
		#define GL_LUMINANCE_ALPHA16I_EXT 0x8D8D
		#define GL_RGBA8I_EXT 0x8D8E
		#define GL_RGB8I_EXT 0x8D8F
		#define GL_ALPHA8I_EXT 0x8D90
		#define GL_INTENSITY8I_EXT 0x8D91
		#define GL_LUMINANCE8I_EXT 0x8D92
		#define GL_LUMINANCE_ALPHA8I_EXT 0x8D93
		#define GL_RED_INTEGER_EXT 0x8D94
		#define GL_GREEN_INTEGER_EXT 0x8D95
		#define GL_BLUE_INTEGER_EXT 0x8D96
		#define GL_ALPHA_INTEGER_EXT 0x8D97
		#define GL_RGB_INTEGER_EXT 0x8D98
		#define GL_RGBA_INTEGER_EXT 0x8D99
		#define GL_BGR_INTEGER_EXT 0x8D9A
		#define GL_BGRA_INTEGER_EXT 0x8D9B
		#define GL_LUMINANCE_INTEGER_EXT 0x8D9C
		#define GL_LUMINANCE_ALPHA_INTEGER_EXT 0x8D9D
		#define GL_RGBA_INTEGER_MODE_EXT 0x8D9E
		#endif

		#ifndef GL_NV_depth_buffer_float
		#define GL_DEPTH_COMPONENT32F_NV 0x8DAB
		#define GL_DEPTH32F_STENCIL8_NV 0x8DAC
		#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV 0x8DAD
		#define GL_DEPTH_BUFFER_FLOAT_MODE_NV 0x8DAF
		#endif

		#ifndef GL_EXT_texture_compression_latc
		#define GL_COMPRESSED_LUMINANCE_LATC1_EXT 0x8C70
		#define GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT 0x8C71
		#define GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT 0x8C72
		#define GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT 0x8C73
		#endif

		#ifndef GL_NV_transform_feedback
		#define GL_BACK_PRIMARY_COLOR_NV 0x8C77
		#define GL_BACK_SECONDARY_COLOR_NV 0x8C78
		#define GL_TEXTURE_COORD_NV 0x8C79
		#define GL_CLIP_DISTANCE_NV 0x8C7A
		#define GL_VERTEX_ID_NV 0x8C7B
		#define GL_PRIMITIVE_ID_NV 0x8C7C
		#define GL_GENERIC_ATTRIB_NV 0x8C7D
		#define GL_TRANSFORM_FEEDBACK_ATTRIBS_NV 0x8C7E
		#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV 0x8C7F
		#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV 0x8C80
		#define GL_ACTIVE_VARYINGS_NV 0x8C81
		#define GL_ACTIVE_VARYING_MAX_LENGTH_NV 0x8C82
		#define GL_TRANSFORM_FEEDBACK_VARYINGS_NV 0x8C83
		#define GL_TRANSFORM_FEEDBACK_BUFFER_START_NV 0x8C84
		#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV 0x8C85
		#define GL_TRANSFORM_FEEDBACK_RECORD_NV 0x8C86
		#define GL_PRIMITIVES_GENERATED_NV 0x8C87
		#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV 0x8C88
		#define GL_RASTERIZER_DISCARD_NV 0x8C89
		#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV 0x8C8A
		#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV 0x8C8B
		#define GL_INTERLEAVED_ATTRIBS_NV 0x8C8C
		#define GL_SEPARATE_ATTRIBS_NV 0x8C8D
		#define GL_TRANSFORM_FEEDBACK_BUFFER_NV 0x8C8E
		#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV 0x8C8F
		#endif

		#ifndef GL_NV_geometry_program4
		#define GL_GEOMETRY_PROGRAM_NV 0x8C26
		#define GL_MAX_PROGRAM_OUTPUT_VERTICES_NV 0x8C27
		#define GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV 0x8C28
		#endif

		#ifndef GL_NV_gpu_program4
		#define GL_MIN_PROGRAM_TEXEL_OFFSET_NV 0x8904
		#define GL_MAX_PROGRAM_TEXEL_OFFSET_NV 0x8905
		#define GL_PROGRAM_ATTRIB_COMPONENTS_NV 0x8906
		#define GL_PROGRAM_RESULT_COMPONENTS_NV 0x8907
		#define GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV 0x8908
		#define GL_MAX_PROGRAM_RESULT_COMPONENTS_NV 0x8909
		#define GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV 0x8DA5
		#define GL_MAX_PROGRAM_GENERIC_RESULTS_NV 0x8DA6
		#endif

		#ifndef GL_NV_framebuffer_multisample_coverage
		#define GL_RENDERBUFFER_COVERAGE_SAMPLES_NV 0x8CAB
		#define GL_RENDERBUFFER_COLOR_SAMPLES_NV 0x8E10
		#define GL_MAX_RENDERBUFFER_COVERAGE_SAMPLES_NV 0x8D57
		#define GL_MAX_RENDERBUFFER_COLOR_SAMPLES_NV 0x8E11
		#define GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV 0x8E12
		#define GL_MULTISAMPLE_COVERAGE_MODES_NV 0x8E13
		#endif

		#ifndef GL_EXT_framebuffer_multisample
		#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT 0x8D56
		#define GL_MAX_SAMPLES_EXT 0x8D57
		#define GL_RENDERBUFFER_SAMPLES_EXT 0x8CAB
		#endif

		#ifndef GL_EXT_framebuffer_blit
		#define GL_READ_FRAMEBUFFER_EXT 0x8CA8
		#define GL_DRAW_FRAMEBUFFER_EXT 0x8CA9
		#define GL_DRAW_FRAMEBUFFER_BINDING_EXT 0x8CA6
		#define GL_READ_FRAMEBUFFER_BINDING_EXT 0x8CAA
		#endif

		#ifndef GL_EXT_texture_compression_rgtc
		#define GL_COMPRESSED_RED_RGTC1_EXT 0x8DBB
		#define GL_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC
		#define GL_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD
		#define GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE
		#endif

	/*************************************************************/	/*************************************************************/


		#include <stddef.h>
		#ifndef GL_VERSION_2_0
		/* GL type for program/shader text */
		typedef char GLchar; /* native character */
		#endif

		#ifndef GL_VERSION_1_5
		/* GL types for handling large vertex buffer objects */
		typedef ptrdiff_t GLintptr;
		typedef ptrdiff_t GLsizeiptr;
		#endif

		#ifndef GL_ARB_vertex_buffer_object
		/* GL types for handling large vertex buffer objects */
		typedef ptrdiff_t GLintptrARB;
		typedef ptrdiff_t GLsizeiptrARB;
		#endif

		#ifndef GL_ARB_shader_objects
		/* GL types for handling shader object handles and program/shader text */
		typedef char GLcharARB; /* native character */
		typedef unsigned int GLhandleARB; /* shader object handle */
		#endif

		/* GL types for "half" precision (s10e5) float data in host memory */
		#ifndef GL_ARB_half_float_pixel
		typedef unsigned short GLhalfARB;
		#endif

		#ifndef GL_NV_half_float
		typedef unsigned short GLhalfNV;
		#endif

		#ifndef GL_EXT_timer_query
		#ifndef GL_COMPILER_LACKS_64BIT_INT
		#if defined(__GNUC__) \|\| defined(__arm) \|\| defined(__IAR_SYSTEMS_ICC__) \|\|
		defined(__ghs__) \|\| defined(_WIN64)
		typedef signed long long GLint64EXT;
		typedef unsigned long long GLuint64EXT;
		#else
		typedef signed __int64 GLint64EXT;
		typedef unsigned __int64 GLuint64EXT;
		#endif
		#endif
		#endif

	#ifndef GL_VERSION_1_2	#ifndef GL_VERSION_1_2
	#define GL_VERSION_1_2 1	#define GL_VERSION_1_2 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glBlendColor (GLclampf, GLclampf, GLclampf, GLclampf);	GLAPI void GLAPIENTRY glBlendColor (GLclampf, GLclampf, GLclampf, GLclampf)
	extern void APIENTRY glBlendEquation (GLenum);	;
	extern void APIENTRY glDrawRangeElements (GLenum, GLuint, GLuint, GLsizei,	GLAPI void GLAPIENTRY glBlendEquation (GLenum);
	GLenum, const GLvoid *);	GLAPI void GLAPIENTRY glDrawRangeElements (GLenum, GLuint, GLuint, GLsizei,
	extern void APIENTRY glColorTable (GLenum, GLenum, GLsizei, GLenum, GLenum,	GLenum, const GLvoid *);
	const GLvoid *);	GLAPI void GLAPIENTRY glColorTable (GLenum, GLenum, GLsizei, GLenum, GLenum
	extern void APIENTRY glColorTableParameterfv (GLenum, GLenum, const GLfloat	, const GLvoid *);
	*);	GLAPI void GLAPIENTRY glColorTableParameterfv (GLenum, GLenum, const GLfloa
	extern void APIENTRY glColorTableParameteriv (GLenum, GLenum, const GLint *	t *);
	);	GLAPI void GLAPIENTRY glColorTableParameteriv (GLenum, GLenum, const GLint
	extern void APIENTRY glCopyColorTable (GLenum, GLenum, GLint, GLint, GLsize	*);
	i);	GLAPI void GLAPIENTRY glCopyColorTable (GLenum, GLenum, GLint, GLint, GLsiz
	extern void APIENTRY glGetColorTable (GLenum, GLenum, GLenum, GLvoid *);	ei);
	extern void APIENTRY glGetColorTableParameterfv (GLenum, GLenum, GLfloat *)	GLAPI void GLAPIENTRY glGetColorTable (GLenum, GLenum, GLenum, GLvoid *);
	;	GLAPI void GLAPIENTRY glGetColorTableParameterfv (GLenum, GLenum, GLfloat *
	extern void APIENTRY glGetColorTableParameteriv (GLenum, GLenum, GLint *);	);
	extern void APIENTRY glColorSubTable (GLenum, GLsizei, GLsizei, GLenum, GLe	GLAPI void GLAPIENTRY glGetColorTableParameteriv (GLenum, GLenum, GLint *);
	num, const GLvoid *);	GLAPI void GLAPIENTRY glColorSubTable (GLenum, GLsizei, GLsizei, GLenum, GL
	extern void APIENTRY glCopyColorSubTable (GLenum, GLsizei, GLint, GLint, GL	enum, const GLvoid *);
	sizei);	GLAPI void GLAPIENTRY glCopyColorSubTable (GLenum, GLsizei, GLint, GLint, G
	extern void APIENTRY glConvolutionFilter1D (GLenum, GLenum, GLsizei, GLenum	Lsizei);
	, GLenum, const GLvoid *);	GLAPI void GLAPIENTRY glConvolutionFilter1D (GLenum, GLenum, GLsizei, GLenu
	extern void APIENTRY glConvolutionFilter2D (GLenum, GLenum, GLsizei, GLsize	m, GLenum, const GLvoid *);
	i, GLenum, GLenum, const GLvoid *);	GLAPI void GLAPIENTRY glConvolutionFilter2D (GLenum, GLenum, GLsizei, GLsiz
	extern void APIENTRY glConvolutionParameterf (GLenum, GLenum, GLfloat);	ei, GLenum, GLenum, const GLvoid *);
	extern void APIENTRY glConvolutionParameterfv (GLenum, GLenum, const GLfloa	GLAPI void GLAPIENTRY glConvolutionParameterf (GLenum, GLenum, GLfloat);
	t *);	GLAPI void GLAPIENTRY glConvolutionParameterfv (GLenum, GLenum, const GLflo
	extern void APIENTRY glConvolutionParameteri (GLenum, GLenum, GLint);	at *);
	extern void APIENTRY glConvolutionParameteriv (GLenum, GLenum, const GLint	GLAPI void GLAPIENTRY glConvolutionParameteri (GLenum, GLenum, GLint);
	*);	GLAPI void GLAPIENTRY glConvolutionParameteriv (GLenum, GLenum, const GLint
	extern void APIENTRY glCopyConvolutionFilter1D (GLenum, GLenum, GLint, GLin	*);
	t, GLsizei);	GLAPI void GLAPIENTRY glCopyConvolutionFilter1D (GLenum, GLenum, GLint, GLi
	extern void APIENTRY glCopyConvolutionFilter2D (GLenum, GLenum, GLint, GLin	nt, GLsizei);
	t, GLsizei, GLsizei);	GLAPI void GLAPIENTRY glCopyConvolutionFilter2D (GLenum, GLenum, GLint, GLi
	extern void APIENTRY glGetConvolutionFilter (GLenum, GLenum, GLenum, GLvoid	nt, GLsizei, GLsizei);
	*);	GLAPI void GLAPIENTRY glGetConvolutionFilter (GLenum, GLenum, GLenum, GLvoi
	extern void APIENTRY glGetConvolutionParameterfv (GLenum, GLenum, GLfloat *	d *);
	);	GLAPI void GLAPIENTRY glGetConvolutionParameterfv (GLenum, GLenum, GLfloat
	extern void APIENTRY glGetConvolutionParameteriv (GLenum, GLenum, GLint *);	*);
	extern void APIENTRY glGetSeparableFilter (GLenum, GLenum, GLenum, GLvoid *	GLAPI void GLAPIENTRY glGetConvolutionParameteriv (GLenum, GLenum, GLint *)
	, GLvoid , GLvoid );	;
	extern void APIENTRY glSeparableFilter2D (GLenum, GLenum, GLsizei, GLsizei,	GLAPI void GLAPIENTRY glGetSeparableFilter (GLenum, GLenum, GLenum, GLvoid
	GLenum, GLenum, const GLvoid , const GLvoid );	, GLvoid , GLvoid *);
	extern void APIENTRY glGetHistogram (GLenum, GLboolean, GLenum, GLenum, GLv	GLAPI void GLAPIENTRY glSeparableFilter2D (GLenum, GLenum, GLsizei, GLsizei
	oid *);	, GLenum, GLenum, const GLvoid , const GLvoid );
	extern void APIENTRY glGetHistogramParameterfv (GLenum, GLenum, GLfloat *);	GLAPI void GLAPIENTRY glGetHistogram (GLenum, GLboolean, GLenum, GLenum, GL
	extern void APIENTRY glGetHistogramParameteriv (GLenum, GLenum, GLint *);	void *);
	extern void APIENTRY glGetMinmax (GLenum, GLboolean, GLenum, GLenum, GLvoid	GLAPI void GLAPIENTRY glGetHistogramParameterfv (GLenum, GLenum, GLfloat *)
	*);	;
	extern void APIENTRY glGetMinmaxParameterfv (GLenum, GLenum, GLfloat *);	GLAPI void GLAPIENTRY glGetHistogramParameteriv (GLenum, GLenum, GLint *);
	extern void APIENTRY glGetMinmaxParameteriv (GLenum, GLenum, GLint *);	GLAPI void GLAPIENTRY glGetMinmax (GLenum, GLboolean, GLenum, GLenum, GLvoi
	extern void APIENTRY glHistogram (GLenum, GLsizei, GLenum, GLboolean);	d *);
	extern void APIENTRY glMinmax (GLenum, GLenum, GLboolean);	GLAPI void GLAPIENTRY glGetMinmaxParameterfv (GLenum, GLenum, GLfloat *);
	extern void APIENTRY glResetHistogram (GLenum);	GLAPI void GLAPIENTRY glGetMinmaxParameteriv (GLenum, GLenum, GLint *);
	extern void APIENTRY glResetMinmax (GLenum);	GLAPI void GLAPIENTRY glHistogram (GLenum, GLsizei, GLenum, GLboolean);
	extern void APIENTRY glTexImage3D (GLenum, GLint, GLint, GLsizei, GLsizei,	GLAPI void GLAPIENTRY glMinmax (GLenum, GLenum, GLboolean);
	GLsizei, GLint, GLenum, GLenum, const GLvoid *);	GLAPI void GLAPIENTRY glResetHistogram (GLenum);
	extern void APIENTRY glTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, G	GLAPI void GLAPIENTRY glResetMinmax (GLenum);
	Lsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);	GLAPI void GLAPIENTRY glTexImage3D (GLenum, GLint, GLint, GLsizei, GLsizei,
	extern void APIENTRY glCopyTexSubImage3D (GLenum, GLint, GLint, GLint, GLin	GLsizei, GLint, GLenum, GLenum, const GLvoid *);
	t, GLint, GLint, GLsizei, GLsizei);	GLAPI void GLAPIENTRY glTexSubImage3D (GLenum, GLint, GLint, GLint, GLint,
		GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
		GLAPI void GLAPIENTRY glCopyTexSubImage3D (GLenum, GLint, GLint, GLint, GLi
		nt, GLint, GLint, GLsizei, GLsizei);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green	typedef void (GLAPIENTRYP PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf gree
	, GLclampf blue, GLclampf alpha);	n, GLclampf blue, GLclampf alpha);
	typedef void (APIENTRY * PFNGLBLENDEQUATIONPROC) (GLenum mode);	typedef void (GLAPIENTRYP PFNGLBLENDEQUATIONPROC) (GLenum mode);
	typedef void (APIENTRY * PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint s	typedef void (GLAPIENTRYP PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint
	tart, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);	start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
	typedef void (APIENTRY * PFNGLCOLORTABLEPROC) (GLenum target, GLenum intern	typedef void (GLAPIENTRYP PFNGLCOLORTABLEPROC) (GLenum target, GLenum inter
	alformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);	nalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
	typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GL	typedef void (GLAPIENTRYP PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, G
	enum pname, const GLfloat *params);	Lenum pname, const GLfloat *params);
	typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GL	typedef void (GLAPIENTRYP PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, G
	enum pname, const GLint *params);	Lenum pname, const GLint *params);
	typedef void (APIENTRY * PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum in	typedef void (GLAPIENTRYP PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum i
	ternalformat, GLint x, GLint y, GLsizei width);	nternalformat, GLint x, GLint y, GLsizei width);
	typedef void (APIENTRY * PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum for	typedef void (GLAPIENTRYP PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum fo
	mat, GLenum type, GLvoid *table);	rmat, GLenum type, GLvoid *table);
	typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target
	GLenum pname, GLfloat *params);	, GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target
	GLenum pname, GLint *params);	, GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei st	typedef void (GLAPIENTRYP PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei s
	art, GLsizei count, GLenum format, GLenum type, const GLvoid *data);	tart, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
	typedef void (APIENTRY * PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsize	typedef void (GLAPIENTRYP PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsiz
	i start, GLint x, GLint y, GLsizei width);	ei start, GLint x, GLint y, GLsizei width);
	typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLen	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLe
	um internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid	num internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid
	*image);	*image);
	typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLen	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLe
	um internalformat, GLsizei width, GLsizei height, GLenum format, GLenum typ	num internalformat, GLsizei width, GLsizei height, GLenum format, GLenum ty
	e, const GLvoid *image);	pe, const GLvoid *image);
	typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GL	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, G
	enum pname, GLfloat params);	Lenum pname, GLfloat params);
	typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, G	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target,
	Lenum pname, const GLfloat *params);	GLenum pname, const GLfloat *params);
	typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GL	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, G
	enum pname, GLint params);	Lenum pname, GLint params);
	typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, G	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target,
	Lenum pname, const GLint *params);	GLenum pname, const GLint *params);
	typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target,
	GLenum internalformat, GLint x, GLint y, GLsizei width);	GLenum internalformat, GLint x, GLint y, GLsizei width);
	typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target,
	GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);	GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
	typedef void (APIENTRY * PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLe	typedef void (GLAPIENTRYP PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GL
	num format, GLenum type, GLvoid *image);	enum format, GLenum type, GLvoid *image);
	typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target	typedef void (GLAPIENTRYP PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum targe
	, GLenum pname, GLfloat *params);	t, GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target	typedef void (GLAPIENTRYP PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum targe
	, GLenum pname, GLint *params);	t, GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenu	typedef void (GLAPIENTRYP PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLen
	m format, GLenum type, GLvoid row, GLvoid column, GLvoid *span);	um format, GLenum type, GLvoid row, GLvoid column, GLvoid *span);
	typedef void (APIENTRY * PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum	typedef void (GLAPIENTRYP PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenu
	internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type,	m internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type
	const GLvoid row, const GLvoid column);	, const GLvoid row, const GLvoid column);
	typedef void (APIENTRY * PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean r	typedef void (GLAPIENTRYP PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean
	eset, GLenum format, GLenum type, GLvoid *values);	reset, GLenum format, GLenum type, GLvoid *values);
	typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target,
	GLenum pname, GLfloat *params);	GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target,
	GLenum pname, GLint *params);	GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLGETMINMAXPROC) (GLenum target, GLboolean rese	typedef void (GLAPIENTRYP PFNGLGETMINMAXPROC) (GLenum target, GLboolean res
	t, GLenum format, GLenum type, GLvoid *values);	et, GLenum format, GLenum type, GLvoid *values);
	typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLe	typedef void (GLAPIENTRYP PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GL
	num pname, GLfloat *params);	enum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLe	typedef void (GLAPIENTRYP PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GL
	num pname, GLint *params);	enum pname, GLint *params);
	typedef void (APIENTRY * PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width,	typedef void (GLAPIENTRYP PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width
	GLenum internalformat, GLboolean sink);	, GLenum internalformat, GLboolean sink);
	typedef void (APIENTRY * PFNGLMINMAXPROC) (GLenum target, GLenum internalfo	typedef void (GLAPIENTRYP PFNGLMINMAXPROC) (GLenum target, GLenum internalf
	rmat, GLboolean sink);	ormat, GLboolean sink);
	typedef void (APIENTRY * PFNGLRESETHISTOGRAMPROC) (GLenum target);	typedef void (GLAPIENTRYP PFNGLRESETHISTOGRAMPROC) (GLenum target);
	typedef void (APIENTRY * PFNGLRESETMINMAXPROC) (GLenum target);	typedef void (GLAPIENTRYP PFNGLRESETMINMAXPROC) (GLenum target);
	typedef void (APIENTRY * PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level,	typedef void (GLAPIENTRYP PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level,
	GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint b	GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint
	order, GLenum format, GLenum type, const GLvoid *pixels);	border, GLenum format, GLenum type, const GLvoid *pixels);
	typedef void (APIENTRY * PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint leve	typedef void (GLAPIENTRYP PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint lev
	l, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei heig	el, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei hei
	ht, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);	ght, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
	typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint	typedef void (GLAPIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint
	level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsiz	level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsi
	ei width, GLsizei height);	zei width, GLsizei height);
		#endif

		#ifndef GL_VERSION_1_3
		#define GL_VERSION_1_3 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glActiveTexture (GLenum);
		GLAPI void GLAPIENTRY glClientActiveTexture (GLenum);
		GLAPI void GLAPIENTRY glMultiTexCoord1d (GLenum, GLdouble);
		GLAPI void GLAPIENTRY glMultiTexCoord1dv (GLenum, const GLdouble *);
		GLAPI void GLAPIENTRY glMultiTexCoord1f (GLenum, GLfloat);
		GLAPI void GLAPIENTRY glMultiTexCoord1fv (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glMultiTexCoord1i (GLenum, GLint);
		GLAPI void GLAPIENTRY glMultiTexCoord1iv (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glMultiTexCoord1s (GLenum, GLshort);
		GLAPI void GLAPIENTRY glMultiTexCoord1sv (GLenum, const GLshort *);
		GLAPI void GLAPIENTRY glMultiTexCoord2d (GLenum, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glMultiTexCoord2dv (GLenum, const GLdouble *);
		GLAPI void GLAPIENTRY glMultiTexCoord2f (GLenum, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glMultiTexCoord2fv (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glMultiTexCoord2i (GLenum, GLint, GLint);
		GLAPI void GLAPIENTRY glMultiTexCoord2iv (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glMultiTexCoord2s (GLenum, GLshort, GLshort);
		GLAPI void GLAPIENTRY glMultiTexCoord2sv (GLenum, const GLshort *);
		GLAPI void GLAPIENTRY glMultiTexCoord3d (GLenum, GLdouble, GLdouble, GLdoub
		le);
		GLAPI void GLAPIENTRY glMultiTexCoord3dv (GLenum, const GLdouble *);
		GLAPI void GLAPIENTRY glMultiTexCoord3f (GLenum, GLfloat, GLfloat, GLfloat)
		;
		GLAPI void GLAPIENTRY glMultiTexCoord3fv (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glMultiTexCoord3i (GLenum, GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glMultiTexCoord3iv (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glMultiTexCoord3s (GLenum, GLshort, GLshort, GLshort)
		;
		GLAPI void GLAPIENTRY glMultiTexCoord3sv (GLenum, const GLshort *);
		GLAPI void GLAPIENTRY glMultiTexCoord4d (GLenum, GLdouble, GLdouble, GLdoub
		le, GLdouble);
		GLAPI void GLAPIENTRY glMultiTexCoord4dv (GLenum, const GLdouble *);
		GLAPI void GLAPIENTRY glMultiTexCoord4f (GLenum, GLfloat, GLfloat, GLfloat,
		GLfloat);
		GLAPI void GLAPIENTRY glMultiTexCoord4fv (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glMultiTexCoord4i (GLenum, GLint, GLint, GLint, GLint
		);
		GLAPI void GLAPIENTRY glMultiTexCoord4iv (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glMultiTexCoord4s (GLenum, GLshort, GLshort, GLshort,
		GLshort);
		GLAPI void GLAPIENTRY glMultiTexCoord4sv (GLenum, const GLshort *);
		GLAPI void GLAPIENTRY glLoadTransposeMatrixf (const GLfloat *);
		GLAPI void GLAPIENTRY glLoadTransposeMatrixd (const GLdouble *);
		GLAPI void GLAPIENTRY glMultTransposeMatrixf (const GLfloat *);
		GLAPI void GLAPIENTRY glMultTransposeMatrixd (const GLdouble *);
		GLAPI void GLAPIENTRY glSampleCoverage (GLclampf, GLboolean);
		GLAPI void GLAPIENTRY glCompressedTexImage3D (GLenum, GLint, GLenum, GLsize
		i, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
		GLAPI void GLAPIENTRY glCompressedTexImage2D (GLenum, GLint, GLenum, GLsize
		i, GLsizei, GLint, GLsizei, const GLvoid *);
		GLAPI void GLAPIENTRY glCompressedTexImage1D (GLenum, GLint, GLenum, GLsize
		i, GLint, GLsizei, const GLvoid *);
		GLAPI void GLAPIENTRY glCompressedTexSubImage3D (GLenum, GLint, GLint, GLin
		t, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
		GLAPI void GLAPIENTRY glCompressedTexSubImage2D (GLenum, GLint, GLint, GLin
		t, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
		GLAPI void GLAPIENTRY glCompressedTexSubImage1D (GLenum, GLint, GLint, GLsi
		zei, GLenum, GLsizei, const GLvoid *);
		GLAPI void GLAPIENTRY glGetCompressedTexImage (GLenum, GLint, GLvoid *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
		typedef void (GLAPIENTRYP PFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdoubl
		e s);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1DVPROC) (GLenum target, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat
		s);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1FVPROC) (GLenum target, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s
		);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1IVPROC) (GLenum target, const
		GLint *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort
		s);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1SVPROC) (GLenum target, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdoubl
		e s, GLdouble t);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2DVPROC) (GLenum target, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat
		s, GLfloat t);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2FVPROC) (GLenum target, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s
		, GLint t);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2IVPROC) (GLenum target, const
		GLint *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort
		s, GLshort t);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2SVPROC) (GLenum target, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdoubl
		e s, GLdouble t, GLdouble r);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3DVPROC) (GLenum target, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat
		s, GLfloat t, GLfloat r);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3FVPROC) (GLenum target, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s
		, GLint t, GLint r);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3IVPROC) (GLenum target, const
		GLint *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort
		s, GLshort t, GLshort r);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3SVPROC) (GLenum target, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdoubl
		e s, GLdouble t, GLdouble r, GLdouble q);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4DVPROC) (GLenum target, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat
		s, GLfloat t, GLfloat r, GLfloat q);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4FVPROC) (GLenum target, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s
		, GLint t, GLint r, GLint q);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4IVPROC) (GLenum target, const
		GLint *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort
		s, GLshort t, GLshort r, GLshort q);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4SVPROC) (GLenum target, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat *m)
		;
		typedef void (GLAPIENTRYP PFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble *m
		);
		typedef void (GLAPIENTRYP PFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat *m)
		;
		typedef void (GLAPIENTRYP PFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble *m
		);
		typedef void (GLAPIENTRYP PFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboole
		an invert);
		typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GL
		int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei de
		pth, GLint border, GLsizei imageSize, const GLvoid *data);
		typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GL
		int level, GLenum internalformat, GLsizei width, GLsizei height, GLint bord
		er, GLsizei imageSize, const GLvoid *data);
		typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GL
		int level, GLenum internalformat, GLsizei width, GLint border, GLsizei imag
		eSize, const GLvoid *data);
		typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target,
		GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, G
		Lsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoi
		d *data);
		typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target,
		GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
		GLenum format, GLsizei imageSize, const GLvoid *data);
		typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target,
		GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSiz
		e, const GLvoid *data);
		typedef void (GLAPIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, G
		Lint level, GLvoid *img);
		#endif

		#ifndef GL_VERSION_1_4
		#define GL_VERSION_1_4 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glBlendFuncSeparate (GLenum, GLenum, GLenum, GLenum);
		GLAPI void GLAPIENTRY glFogCoordf (GLfloat);
		GLAPI void GLAPIENTRY glFogCoordfv (const GLfloat *);
		GLAPI void GLAPIENTRY glFogCoordd (GLdouble);
		GLAPI void GLAPIENTRY glFogCoorddv (const GLdouble *);
		GLAPI void GLAPIENTRY glFogCoordPointer (GLenum, GLsizei, const GLvoid *);
		GLAPI void GLAPIENTRY glMultiDrawArrays (GLenum, GLint , GLsizei , GLsize
		i);
		GLAPI void GLAPIENTRY glMultiDrawElements (GLenum, const GLsizei *, GLenum,
		const GLvoid* *, GLsizei);
		GLAPI void GLAPIENTRY glPointParameterf (GLenum, GLfloat);
		GLAPI void GLAPIENTRY glPointParameterfv (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glPointParameteri (GLenum, GLint);
		GLAPI void GLAPIENTRY glPointParameteriv (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glSecondaryColor3b (GLbyte, GLbyte, GLbyte);
		GLAPI void GLAPIENTRY glSecondaryColor3bv (const GLbyte *);
		GLAPI void GLAPIENTRY glSecondaryColor3d (GLdouble, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glSecondaryColor3dv (const GLdouble *);
		GLAPI void GLAPIENTRY glSecondaryColor3f (GLfloat, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glSecondaryColor3fv (const GLfloat *);
		GLAPI void GLAPIENTRY glSecondaryColor3i (GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glSecondaryColor3iv (const GLint *);
		GLAPI void GLAPIENTRY glSecondaryColor3s (GLshort, GLshort, GLshort);
		GLAPI void GLAPIENTRY glSecondaryColor3sv (const GLshort *);
		GLAPI void GLAPIENTRY glSecondaryColor3ub (GLubyte, GLubyte, GLubyte);
		GLAPI void GLAPIENTRY glSecondaryColor3ubv (const GLubyte *);
		GLAPI void GLAPIENTRY glSecondaryColor3ui (GLuint, GLuint, GLuint);
		GLAPI void GLAPIENTRY glSecondaryColor3uiv (const GLuint *);
		GLAPI void GLAPIENTRY glSecondaryColor3us (GLushort, GLushort, GLushort);
		GLAPI void GLAPIENTRY glSecondaryColor3usv (const GLushort *);
		GLAPI void GLAPIENTRY glSecondaryColorPointer (GLint, GLenum, GLsizei, cons
		t GLvoid *);
		GLAPI void GLAPIENTRY glWindowPos2d (GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glWindowPos2dv (const GLdouble *);
		GLAPI void GLAPIENTRY glWindowPos2f (GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glWindowPos2fv (const GLfloat *);
		GLAPI void GLAPIENTRY glWindowPos2i (GLint, GLint);
		GLAPI void GLAPIENTRY glWindowPos2iv (const GLint *);
		GLAPI void GLAPIENTRY glWindowPos2s (GLshort, GLshort);
		GLAPI void GLAPIENTRY glWindowPos2sv (const GLshort *);
		GLAPI void GLAPIENTRY glWindowPos3d (GLdouble, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glWindowPos3dv (const GLdouble *);
		GLAPI void GLAPIENTRY glWindowPos3f (GLfloat, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glWindowPos3fv (const GLfloat *);
		GLAPI void GLAPIENTRY glWindowPos3i (GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glWindowPos3iv (const GLint *);
		GLAPI void GLAPIENTRY glWindowPos3s (GLshort, GLshort, GLshort);
		GLAPI void GLAPIENTRY glWindowPos3sv (const GLshort *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, G
		Lenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
		typedef void (GLAPIENTRYP PFNGLFOGCOORDFPROC) (GLfloat coord);
		typedef void (GLAPIENTRYP PFNGLFOGCOORDFVPROC) (const GLfloat *coord);
		typedef void (GLAPIENTRYP PFNGLFOGCOORDDPROC) (GLdouble coord);
		typedef void (GLAPIENTRYP PFNGLFOGCOORDDVPROC) (const GLdouble *coord);
		typedef void (GLAPIENTRYP PFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei s
		tride, const GLvoid *pointer);
		typedef void (GLAPIENTRYP PFNGLMULTIDRAWARRAYSPROC) (GLenum mode, GLint *fi
		rst, GLsizei *count, GLsizei primcount);
		typedef void (GLAPIENTRYP PFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, const G
		Lsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
		typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat
		param);
		typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERFVPROC) (GLenum pname, const G
		Lfloat *params);
		typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint pa
		ram);
		typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERIVPROC) (GLenum pname, const G
		Lint *params);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte gr
		een, GLbyte blue);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdoubl
		e green, GLdouble blue);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3DVPROC) (const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat
		green, GLfloat blue);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3FVPROC) (const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint gree
		n, GLint blue);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3IVPROC) (const GLint *v);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort
		green, GLshort blue);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3SVPROC) (const GLshort *v);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte
		green, GLubyte blue);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3UBVPROC) (const GLubyte *v);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint g
		reen, GLuint blue);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3UIVPROC) (const GLuint *v);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLusho
		rt green, GLushort blue);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3USVPROC) (const GLushort *v);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLen
		um type, GLsizei stride, const GLvoid *pointer);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2DVPROC) (const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2FVPROC) (const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2IPROC) (GLint x, GLint y);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2IVPROC) (const GLint *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2SVPROC) (const GLshort *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GL
		double z);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3DVPROC) (const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfl
		oat z);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3FVPROC) (const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z)
		;
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3IVPROC) (const GLint *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLsh
		ort z);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3SVPROC) (const GLshort *v);
		#endif

		#ifndef GL_VERSION_1_5
		#define GL_VERSION_1_5 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glGenQueries (GLsizei, GLuint *);
		GLAPI void GLAPIENTRY glDeleteQueries (GLsizei, const GLuint *);
		GLAPI GLboolean GLAPIENTRY glIsQuery (GLuint);
		GLAPI void GLAPIENTRY glBeginQuery (GLenum, GLuint);
		GLAPI void GLAPIENTRY glEndQuery (GLenum);
		GLAPI void GLAPIENTRY glGetQueryiv (GLenum, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetQueryObjectiv (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetQueryObjectuiv (GLuint, GLenum, GLuint *);
		GLAPI void GLAPIENTRY glBindBuffer (GLenum, GLuint);
		GLAPI void GLAPIENTRY glDeleteBuffers (GLsizei, const GLuint *);
		GLAPI void GLAPIENTRY glGenBuffers (GLsizei, GLuint *);
		GLAPI GLboolean GLAPIENTRY glIsBuffer (GLuint);
		GLAPI void GLAPIENTRY glBufferData (GLenum, GLsizeiptr, const GLvoid *, GLe
		num);
		GLAPI void GLAPIENTRY glBufferSubData (GLenum, GLintptr, GLsizeiptr, const
		GLvoid *);
		GLAPI void GLAPIENTRY glGetBufferSubData (GLenum, GLintptr, GLsizeiptr, GLv
		oid *);
		GLAPI GLvoid* GLAPIENTRY glMapBuffer (GLenum, GLenum);
		GLAPI GLboolean GLAPIENTRY glUnmapBuffer (GLenum);
		GLAPI void GLAPIENTRY glGetBufferParameteriv (GLenum, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetBufferPointerv (GLenum, GLenum, GLvoid* *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLGENQUERIESPROC) (GLsizei n, GLuint *ids);
		typedef void (GLAPIENTRYP PFNGLDELETEQUERIESPROC) (GLsizei n, const GLuint
		*ids);
		typedef GLboolean (GLAPIENTRYP PFNGLISQUERYPROC) (GLuint id);
		typedef void (GLAPIENTRYP PFNGLBEGINQUERYPROC) (GLenum target, GLuint id);
		typedef void (GLAPIENTRYP PFNGLENDQUERYPROC) (GLenum target);
		typedef void (GLAPIENTRYP PFNGLGETQUERYIVPROC) (GLenum target, GLenum pname
		, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETQUERYOBJECTIVPROC) (GLuint id, GLenum pna
		me, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETQUERYOBJECTUIVPROC) (GLuint id, GLenum pn
		ame, GLuint *params);
		typedef void (GLAPIENTRYP PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffe
		r);
		typedef void (GLAPIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint
		*buffers);
		typedef void (GLAPIENTRYP PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers)
		;
		typedef GLboolean (GLAPIENTRYP PFNGLISBUFFERPROC) (GLuint buffer);
		typedef void (GLAPIENTRYP PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr s
		ize, const GLvoid *data, GLenum usage);
		typedef void (GLAPIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr
		offset, GLsizeiptr size, const GLvoid *data);
		typedef void (GLAPIENTRYP PFNGLGETBUFFERSUBDATAPROC) (GLenum target, GLintp
		tr offset, GLsizeiptr size, GLvoid *data);
		typedef GLvoid* (GLAPIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum acc
		ess);
		typedef GLboolean (GLAPIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target);
		typedef void (GLAPIENTRYP PFNGLGETBUFFERPARAMETERIVPROC) (GLenum target, GL
		enum pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETBUFFERPOINTERVPROC) (GLenum target, GLenu
		m pname, GLvoid* *params);
		#endif

		#ifndef GL_VERSION_2_0
		#define GL_VERSION_2_0 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glBlendEquationSeparate (GLenum, GLenum);
		GLAPI void GLAPIENTRY glDrawBuffers (GLsizei, const GLenum *);
		GLAPI void GLAPIENTRY glStencilOpSeparate (GLenum, GLenum, GLenum, GLenum);
		GLAPI void GLAPIENTRY glStencilFuncSeparate (GLenum, GLenum, GLint, GLuint)
		;
		GLAPI void GLAPIENTRY glStencilMaskSeparate (GLenum, GLuint);
		GLAPI void GLAPIENTRY glAttachShader (GLuint, GLuint);
		GLAPI void GLAPIENTRY glBindAttribLocation (GLuint, GLuint, const GLchar *)
		;
		GLAPI void GLAPIENTRY glCompileShader (GLuint);
		GLAPI GLuint GLAPIENTRY glCreateProgram (void);
		GLAPI GLuint GLAPIENTRY glCreateShader (GLenum);
		GLAPI void GLAPIENTRY glDeleteProgram (GLuint);
		GLAPI void GLAPIENTRY glDeleteShader (GLuint);
		GLAPI void GLAPIENTRY glDetachShader (GLuint, GLuint);
		GLAPI void GLAPIENTRY glDisableVertexAttribArray (GLuint);
		GLAPI void GLAPIENTRY glEnableVertexAttribArray (GLuint);
		GLAPI void GLAPIENTRY glGetActiveAttrib (GLuint, GLuint, GLsizei, GLsizei *
		, GLint , GLenum , GLchar *);
		GLAPI void GLAPIENTRY glGetActiveUniform (GLuint, GLuint, GLsizei, GLsizei
		, GLint , GLenum , GLchar );
		GLAPI void GLAPIENTRY glGetAttachedShaders (GLuint, GLsizei, GLsizei *, GLu
		int *);
		GLAPI GLint GLAPIENTRY glGetAttribLocation (GLuint, const GLchar *);
		GLAPI void GLAPIENTRY glGetProgramiv (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetProgramInfoLog (GLuint, GLsizei, GLsizei *, GLch
		ar *);
		GLAPI void GLAPIENTRY glGetShaderiv (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetShaderInfoLog (GLuint, GLsizei, GLsizei *, GLcha
		r *);
		GLAPI void GLAPIENTRY glGetShaderSource (GLuint, GLsizei, GLsizei *, GLchar
		*);
		GLAPI GLint GLAPIENTRY glGetUniformLocation (GLuint, const GLchar *);
		GLAPI void GLAPIENTRY glGetUniformfv (GLuint, GLint, GLfloat *);
		GLAPI void GLAPIENTRY glGetUniformiv (GLuint, GLint, GLint *);
		GLAPI void GLAPIENTRY glGetVertexAttribdv (GLuint, GLenum, GLdouble *);
		GLAPI void GLAPIENTRY glGetVertexAttribfv (GLuint, GLenum, GLfloat *);
		GLAPI void GLAPIENTRY glGetVertexAttribiv (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetVertexAttribPointerv (GLuint, GLenum, GLvoid* *)
		;
		GLAPI GLboolean GLAPIENTRY glIsProgram (GLuint);
		GLAPI GLboolean GLAPIENTRY glIsShader (GLuint);
		GLAPI void GLAPIENTRY glLinkProgram (GLuint);
		GLAPI void GLAPIENTRY glShaderSource (GLuint, GLsizei, const GLchar* *, con
		st GLint *);
		GLAPI void GLAPIENTRY glUseProgram (GLuint);
		GLAPI void GLAPIENTRY glUniform1f (GLint, GLfloat);
		GLAPI void GLAPIENTRY glUniform2f (GLint, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glUniform3f (GLint, GLfloat, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glUniform4f (GLint, GLfloat, GLfloat, GLfloat, GLfloa
		t);
		GLAPI void GLAPIENTRY glUniform1i (GLint, GLint);
		GLAPI void GLAPIENTRY glUniform2i (GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glUniform3i (GLint, GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glUniform4i (GLint, GLint, GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glUniform1fv (GLint, GLsizei, const GLfloat *);
		GLAPI void GLAPIENTRY glUniform2fv (GLint, GLsizei, const GLfloat *);
		GLAPI void GLAPIENTRY glUniform3fv (GLint, GLsizei, const GLfloat *);
		GLAPI void GLAPIENTRY glUniform4fv (GLint, GLsizei, const GLfloat *);
		GLAPI void GLAPIENTRY glUniform1iv (GLint, GLsizei, const GLint *);
		GLAPI void GLAPIENTRY glUniform2iv (GLint, GLsizei, const GLint *);
		GLAPI void GLAPIENTRY glUniform3iv (GLint, GLsizei, const GLint *);
		GLAPI void GLAPIENTRY glUniform4iv (GLint, GLsizei, const GLint *);
		GLAPI void GLAPIENTRY glUniformMatrix2fv (GLint, GLsizei, GLboolean, const
		GLfloat *);
		GLAPI void GLAPIENTRY glUniformMatrix3fv (GLint, GLsizei, GLboolean, const
		GLfloat *);
		GLAPI void GLAPIENTRY glUniformMatrix4fv (GLint, GLsizei, GLboolean, const
		GLfloat *);
		GLAPI void GLAPIENTRY glValidateProgram (GLuint);
		GLAPI void GLAPIENTRY glVertexAttrib1d (GLuint, GLdouble);
		GLAPI void GLAPIENTRY glVertexAttrib1dv (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib1f (GLuint, GLfloat);
		GLAPI void GLAPIENTRY glVertexAttrib1fv (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib1s (GLuint, GLshort);
		GLAPI void GLAPIENTRY glVertexAttrib1sv (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib2d (GLuint, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glVertexAttrib2dv (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib2f (GLuint, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glVertexAttrib2fv (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib2s (GLuint, GLshort, GLshort);
		GLAPI void GLAPIENTRY glVertexAttrib2sv (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib3d (GLuint, GLdouble, GLdouble, GLdoubl
		e);
		GLAPI void GLAPIENTRY glVertexAttrib3dv (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib3f (GLuint, GLfloat, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glVertexAttrib3fv (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib3s (GLuint, GLshort, GLshort, GLshort);
		GLAPI void GLAPIENTRY glVertexAttrib3sv (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib4Nbv (GLuint, const GLbyte *);
		GLAPI void GLAPIENTRY glVertexAttrib4Niv (GLuint, const GLint *);
		GLAPI void GLAPIENTRY glVertexAttrib4Nsv (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib4Nub (GLuint, GLubyte, GLubyte, GLubyte
		, GLubyte);
		GLAPI void GLAPIENTRY glVertexAttrib4Nubv (GLuint, const GLubyte *);
		GLAPI void GLAPIENTRY glVertexAttrib4Nuiv (GLuint, const GLuint *);
		GLAPI void GLAPIENTRY glVertexAttrib4Nusv (GLuint, const GLushort *);
		GLAPI void GLAPIENTRY glVertexAttrib4bv (GLuint, const GLbyte *);
		GLAPI void GLAPIENTRY glVertexAttrib4d (GLuint, GLdouble, GLdouble, GLdoubl
		e, GLdouble);
		GLAPI void GLAPIENTRY glVertexAttrib4dv (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib4f (GLuint, GLfloat, GLfloat, GLfloat,
		GLfloat);
		GLAPI void GLAPIENTRY glVertexAttrib4fv (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib4iv (GLuint, const GLint *);
		GLAPI void GLAPIENTRY glVertexAttrib4s (GLuint, GLshort, GLshort, GLshort,
		GLshort);
		GLAPI void GLAPIENTRY glVertexAttrib4sv (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib4ubv (GLuint, const GLubyte *);
		GLAPI void GLAPIENTRY glVertexAttrib4uiv (GLuint, const GLuint *);
		GLAPI void GLAPIENTRY glVertexAttrib4usv (GLuint, const GLushort *);
		GLAPI void GLAPIENTRY glVertexAttribPointer (GLuint, GLint, GLenum, GLboole
		an, GLsizei, const GLvoid *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum modeRGB,
		GLenum modeAlpha);
		typedef void (GLAPIENTRYP PFNGLDRAWBUFFERSPROC) (GLsizei n, const GLenum *b
		ufs);
		typedef void (GLAPIENTRYP PFNGLSTENCILOPSEPARATEPROC) (GLenum face, GLenum
		sfail, GLenum dpfail, GLenum dppass);
		typedef void (GLAPIENTRYP PFNGLSTENCILFUNCSEPARATEPROC) (GLenum frontfunc,
		GLenum backfunc, GLint ref, GLuint mask);
		typedef void (GLAPIENTRYP PFNGLSTENCILMASKSEPARATEPROC) (GLenum face, GLuin
		t mask);
		typedef void (GLAPIENTRYP PFNGLATTACHSHADERPROC) (GLuint program, GLuint sh
		ader);
		typedef void (GLAPIENTRYP PFNGLBINDATTRIBLOCATIONPROC) (GLuint program, GLu
		int index, const GLchar *name);
		typedef void (GLAPIENTRYP PFNGLCOMPILESHADERPROC) (GLuint shader);
		typedef GLuint (GLAPIENTRYP PFNGLCREATEPROGRAMPROC) (void);
		typedef GLuint (GLAPIENTRYP PFNGLCREATESHADERPROC) (GLenum type);
		typedef void (GLAPIENTRYP PFNGLDELETEPROGRAMPROC) (GLuint program);
		typedef void (GLAPIENTRYP PFNGLDELETESHADERPROC) (GLuint shader);
		typedef void (GLAPIENTRYP PFNGLDETACHSHADERPROC) (GLuint program, GLuint sh
		ader);
		typedef void (GLAPIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint index)
		;
		typedef void (GLAPIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index);
		typedef void (GLAPIENTRYP PFNGLGETACTIVEATTRIBPROC) (GLuint program, GLuint
		index, GLsizei bufSize, GLsizei length, GLint size, GLenum *type, GLchar
		*name);
		typedef void (GLAPIENTRYP PFNGLGETACTIVEUNIFORMPROC) (GLuint program, GLuin
		t index, GLsizei bufSize, GLsizei length, GLint size, GLenum *type, GLcha
		r *name);
		typedef void (GLAPIENTRYP PFNGLGETATTACHEDSHADERSPROC) (GLuint program, GLs
		izei maxCount, GLsizei count, GLuint obj);
		typedef GLint (GLAPIENTRYP PFNGLGETATTRIBLOCATIONPROC) (GLuint program, con
		st GLchar *name);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pn
		ame, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsi
		zei bufSize, GLsizei length, GLchar infoLog);
		typedef void (GLAPIENTRYP PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pnam
		e, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsize
		i bufSize, GLsizei length, GLchar infoLog);
		typedef void (GLAPIENTRYP PFNGLGETSHADERSOURCEPROC) (GLuint shader, GLsizei
		bufSize, GLsizei length, GLchar source);
		typedef GLint (GLAPIENTRYP PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, co
		nst GLchar *name);
		typedef void (GLAPIENTRYP PFNGLGETUNIFORMFVPROC) (GLuint program, GLint loc
		ation, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETUNIFORMIVPROC) (GLuint program, GLint loc
		ation, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBDVPROC) (GLuint index, GLenum
		pname, GLdouble *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBFVPROC) (GLuint index, GLenum
		pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBIVPROC) (GLuint index, GLenum
		pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint index,
		GLenum pname, GLvoid* *pointer);
		typedef GLboolean (GLAPIENTRYP PFNGLISPROGRAMPROC) (GLuint program);
		typedef GLboolean (GLAPIENTRYP PFNGLISSHADERPROC) (GLuint shader);
		typedef void (GLAPIENTRYP PFNGLLINKPROGRAMPROC) (GLuint program);
		typedef void (GLAPIENTRYP PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei co
		unt, const GLchar* string, const GLint length);
		typedef void (GLAPIENTRYP PFNGLUSEPROGRAMPROC) (GLuint program);
		typedef void (GLAPIENTRYP PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0);
		typedef void (GLAPIENTRYP PFNGLUNIFORM2FPROC) (GLint location, GLfloat v0,
		GLfloat v1);
		typedef void (GLAPIENTRYP PFNGLUNIFORM3FPROC) (GLint location, GLfloat v0,
		GLfloat v1, GLfloat v2);
		typedef void (GLAPIENTRYP PFNGLUNIFORM4FPROC) (GLint location, GLfloat v0,
		GLfloat v1, GLfloat v2, GLfloat v3);
		typedef void (GLAPIENTRYP PFNGLUNIFORM1IPROC) (GLint location, GLint v0);
		typedef void (GLAPIENTRYP PFNGLUNIFORM2IPROC) (GLint location, GLint v0, GL
		int v1);
		typedef void (GLAPIENTRYP PFNGLUNIFORM3IPROC) (GLint location, GLint v0, GL
		int v1, GLint v2);
		typedef void (GLAPIENTRYP PFNGLUNIFORM4IPROC) (GLint location, GLint v0, GL
		int v1, GLint v2, GLint v3);
		typedef void (GLAPIENTRYP PFNGLUNIFORM1FVPROC) (GLint location, GLsizei cou
		nt, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM2FVPROC) (GLint location, GLsizei cou
		nt, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM3FVPROC) (GLint location, GLsizei cou
		nt, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM4FVPROC) (GLint location, GLsizei cou
		nt, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM1IVPROC) (GLint location, GLsizei cou
		nt, const GLint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM2IVPROC) (GLint location, GLsizei cou
		nt, const GLint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM3IVPROC) (GLint location, GLsizei cou
		nt, const GLint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM4IVPROC) (GLint location, GLsizei cou
		nt, const GLint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX2FVPROC) (GLint location, GLsiz
		ei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsiz
		ei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsiz
		ei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLVALIDATEPROGRAMPROC) (GLuint program);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1DPROC) (GLuint index, GLdouble
		x);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1DVPROC) (GLuint index, const GL
		double *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1FPROC) (GLuint index, GLfloat x
		);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1FVPROC) (GLuint index, const GL
		float *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1SPROC) (GLuint index, GLshort x
		);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1SVPROC) (GLuint index, const GL
		short *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2DPROC) (GLuint index, GLdouble
		x, GLdouble y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2DVPROC) (GLuint index, const GL
		double *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2FPROC) (GLuint index, GLfloat x
		, GLfloat y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2FVPROC) (GLuint index, const GL
		float *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2SPROC) (GLuint index, GLshort x
		, GLshort y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2SVPROC) (GLuint index, const GL
		short *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3DPROC) (GLuint index, GLdouble
		x, GLdouble y, GLdouble z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3DVPROC) (GLuint index, const GL
		double *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3FPROC) (GLuint index, GLfloat x
		, GLfloat y, GLfloat z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3FVPROC) (GLuint index, const GL
		float *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3SPROC) (GLuint index, GLshort x
		, GLshort y, GLshort z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3SVPROC) (GLuint index, const GL
		short *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NBVPROC) (GLuint index, const G
		Lbyte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NIVPROC) (GLuint index, const G
		Lint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NSVPROC) (GLuint index, const G
		Lshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NUBPROC) (GLuint index, GLubyte
		x, GLubyte y, GLubyte z, GLubyte w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NUBVPROC) (GLuint index, const
		GLubyte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NUIVPROC) (GLuint index, const
		GLuint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NUSVPROC) (GLuint index, const
		GLushort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4BVPROC) (GLuint index, const GL
		byte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4DPROC) (GLuint index, GLdouble
		x, GLdouble y, GLdouble z, GLdouble w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4DVPROC) (GLuint index, const GL
		double *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4FPROC) (GLuint index, GLfloat x
		, GLfloat y, GLfloat z, GLfloat w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4FVPROC) (GLuint index, const GL
		float *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4IVPROC) (GLuint index, const GL
		int *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4SPROC) (GLuint index, GLshort x
		, GLshort y, GLshort z, GLshort w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4SVPROC) (GLuint index, const GL
		short *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4UBVPROC) (GLuint index, const G
		Lubyte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4UIVPROC) (GLuint index, const G
		Luint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4USVPROC) (GLuint index, const G
		Lushort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLin
		t size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *po
		inter);
		#endif

		#ifndef GL_VERSION_2_1
		#define GL_VERSION_2_1 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glUniformMatrix2x3fv (GLint location, GLsizei count,
		GLboolean transpose, const GLfloat *value);
		GLAPI void GLAPIENTRY glUniformMatrix3x2fv (GLint location, GLsizei count,
		GLboolean transpose, const GLfloat *value);
		GLAPI void GLAPIENTRY glUniformMatrix2x4fv (GLint location, GLsizei count,
		GLboolean transpose, const GLfloat *value);
		GLAPI void GLAPIENTRY glUniformMatrix4x2fv (GLint location, GLsizei count,
		GLboolean transpose, const GLfloat *value);
		GLAPI void GLAPIENTRY glUniformMatrix3x4fv (GLint location, GLsizei count,
		GLboolean transpose, const GLfloat *value);
		GLAPI void GLAPIENTRY glUniformMatrix4x3fv (GLint location, GLsizei count,
		GLboolean transpose, const GLfloat *value);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC) (GLint location, GLs
		izei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC) (GLint location, GLs
		izei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC) (GLint location, GLs
		izei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC) (GLint location, GLs
		izei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC) (GLint location, GLs
		izei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC) (GLint location, GLs
		izei count, GLboolean transpose, const GLfloat *value);
	#endif	#endif

	#ifndef GL_ARB_multitexture	#ifndef GL_ARB_multitexture
	#define GL_ARB_multitexture 1	#define GL_ARB_multitexture 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glActiveTextureARB (GLenum);	GLAPI void GLAPIENTRY glActiveTextureARB (GLenum);
	extern void APIENTRY glClientActiveTextureARB (GLenum);	GLAPI void GLAPIENTRY glClientActiveTextureARB (GLenum);
	extern void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);	GLAPI void GLAPIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);
	extern void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);	GLAPI void GLAPIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);
	extern void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);	GLAPI void GLAPIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);
	extern void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);	GLAPI void GLAPIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);
	extern void APIENTRY glMultiTexCoord1iARB (GLenum, GLint);	GLAPI void GLAPIENTRY glMultiTexCoord1iARB (GLenum, GLint);
	extern void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);	GLAPI void GLAPIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);
	extern void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort);	GLAPI void GLAPIENTRY glMultiTexCoord1sARB (GLenum, GLshort);
	extern void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);	GLAPI void GLAPIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);
	extern void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);	GLAPI void GLAPIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
	extern void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);	GLAPI void GLAPIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);
	extern void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);	GLAPI void GLAPIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
	extern void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);	GLAPI void GLAPIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);
	extern void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);	GLAPI void GLAPIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);
	extern void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);	GLAPI void GLAPIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);
	extern void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);	GLAPI void GLAPIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
	extern void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);	GLAPI void GLAPIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);
	extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdo	GLAPI void GLAPIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLd
	uble);	ouble);
	extern void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);	GLAPI void GLAPIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);
	extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloa	GLAPI void GLAPIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLflo
	t);	at);
	extern void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);	GLAPI void GLAPIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);
	extern void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);	GLAPI void GLAPIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
	extern void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);	GLAPI void GLAPIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);
	extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshor	GLAPI void GLAPIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLsho
	t);	rt);
	extern void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);	GLAPI void GLAPIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);
	extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdo	GLAPI void GLAPIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLd
	uble, GLdouble);	ouble, GLdouble);
	extern void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);	GLAPI void GLAPIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);
	extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloa	GLAPI void GLAPIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLflo
	t, GLfloat);	at, GLfloat);
	extern void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);	GLAPI void GLAPIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);
	extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLi	GLAPI void GLAPIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GL
	nt);	int);
	extern void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);	GLAPI void GLAPIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);
	extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshor	GLAPI void GLAPIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLsho
	t, GLshort);	rt, GLshort);
	extern void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);	GLAPI void GLAPIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture);	typedef void (GLAPIENTRYP PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
	typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);	typedef void (GLAPIENTRYP PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture)
	typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdou	;
	ble s);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdo
	typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, cons	uble s);
	t GLdouble *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLflo	st GLdouble *v);
	at s);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfl
	typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, cons	oat s);
	t GLfloat *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint	st GLfloat *v);
	s);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLin
	typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, cons	t s);
	t GLint *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLsho	st GLint *v);
	rt s);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLsh
	typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, cons	ort s);
	t GLshort *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdou	st GLshort *v);
	ble s, GLdouble t);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdo
	typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, cons	uble s, GLdouble t);
	t GLdouble *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLflo	st GLdouble *v);
	at s, GLfloat t);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfl
	typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, cons	oat s, GLfloat t);
	t GLfloat *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint	st GLfloat *v);
	s, GLint t);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLin
	typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, cons	t s, GLint t);
	t GLint *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLsho	st GLint *v);
	rt s, GLshort t);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLsh
	typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, cons	ort s, GLshort t);
	t GLshort *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdou	st GLshort *v);
	ble s, GLdouble t, GLdouble r);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdo
	typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, cons	uble s, GLdouble t, GLdouble r);
	t GLdouble *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLflo	st GLdouble *v);
	at s, GLfloat t, GLfloat r);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfl
	typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, cons	oat s, GLfloat t, GLfloat r);
	t GLfloat *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint	st GLfloat *v);
	s, GLint t, GLint r);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLin
	typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, cons	t s, GLint t, GLint r);
	t GLint *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLsho	st GLint *v);
	rt s, GLshort t, GLshort r);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLsh
	typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, cons	ort s, GLshort t, GLshort r);
	t GLshort *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdou	st GLshort *v);
	ble s, GLdouble t, GLdouble r, GLdouble q);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdo
	typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, cons	uble s, GLdouble t, GLdouble r, GLdouble q);
	t GLdouble *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLflo	st GLdouble *v);
	at s, GLfloat t, GLfloat r, GLfloat q);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfl
	typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, cons	oat s, GLfloat t, GLfloat r, GLfloat q);
	t GLfloat *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint	st GLfloat *v);
	s, GLint t, GLint r, GLint q);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLin
	typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, cons	t s, GLint t, GLint r, GLint q);
	t GLint *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, con
	typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLsho	st GLint *v);
	rt s, GLshort t, GLshort r, GLshort q);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLsh
	typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, cons	ort s, GLshort t, GLshort r, GLshort q);
	t GLshort *v);	typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, con
		st GLshort *v);
	#endif	#endif

	#ifndef GL_ARB_transpose_matrix	#ifndef GL_ARB_transpose_matrix
	#define GL_ARB_transpose_matrix 1	#define GL_ARB_transpose_matrix 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glLoadTransposeMatrixfARB (const GLfloat *);	GLAPI void GLAPIENTRY glLoadTransposeMatrixfARB (const GLfloat *);
	extern void APIENTRY glLoadTransposeMatrixdARB (const GLdouble *);	GLAPI void GLAPIENTRY glLoadTransposeMatrixdARB (const GLdouble *);
	extern void APIENTRY glMultTransposeMatrixfARB (const GLfloat *);	GLAPI void GLAPIENTRY glMultTransposeMatrixfARB (const GLfloat *);
	extern void APIENTRY glMultTransposeMatrixdARB (const GLdouble *);	GLAPI void GLAPIENTRY glMultTransposeMatrixdARB (const GLdouble *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLLOADTRANSPOSEMATRIXFARBPROC) (const GLfloat *	typedef void (GLAPIENTRYP PFNGLLOADTRANSPOSEMATRIXFARBPROC) (const GLfloat
	m);	*m);
	typedef void (APIENTRY * PFNGLLOADTRANSPOSEMATRIXDARBPROC) (const GLdouble	typedef void (GLAPIENTRYP PFNGLLOADTRANSPOSEMATRIXDARBPROC) (const GLdouble
	*m);	*m);
	typedef void (APIENTRY * PFNGLMULTTRANSPOSEMATRIXFARBPROC) (const GLfloat *	typedef void (GLAPIENTRYP PFNGLMULTTRANSPOSEMATRIXFARBPROC) (const GLfloat
	m);	*m);
	typedef void (APIENTRY * PFNGLMULTTRANSPOSEMATRIXDARBPROC) (const GLdouble	typedef void (GLAPIENTRYP PFNGLMULTTRANSPOSEMATRIXDARBPROC) (const GLdouble
	*m);	*m);
	#endif	#endif

	#ifndef GL_ARB_multisample	#ifndef GL_ARB_multisample
	#define GL_ARB_multisample 1	#define GL_ARB_multisample 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glSampleCoverageARB (GLclampf, GLboolean);	GLAPI void GLAPIENTRY glSampleCoverageARB (GLclampf, GLboolean);
	extern void APIENTRY glSamplePassARB (GLenum);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLboo	typedef void (GLAPIENTRYP PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLbo
	lean invert);	olean invert);
	typedef void (APIENTRY * PFNGLSAMPLEPASSARBPROC) (GLenum pass);
	#endif	#endif

	#ifndef GL_ARB_texture_env_add	#ifndef GL_ARB_texture_env_add
	#define GL_ARB_texture_env_add 1	#define GL_ARB_texture_env_add 1
	#endif	#endif

	#ifndef GL_ARB_texture_cube_map	#ifndef GL_ARB_texture_cube_map
	#define GL_ARB_texture_cube_map 1	#define GL_ARB_texture_cube_map 1
	#endif	#endif

	#ifndef GL_ARB_texture_compression	#ifndef GL_ARB_texture_compression
	#define GL_ARB_texture_compression 1	#define GL_ARB_texture_compression 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLsi	GLAPI void GLAPIENTRY glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLs
	zei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);	izei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
	extern void APIENTRY glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLsi	GLAPI void GLAPIENTRY glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLs
	zei, GLsizei, GLint, GLsizei, const GLvoid *);	izei, GLsizei, GLint, GLsizei, const GLvoid *);
	extern void APIENTRY glCompressedTexImage1DARB (GLenum, GLint, GLenum, GLsi	GLAPI void GLAPIENTRY glCompressedTexImage1DARB (GLenum, GLint, GLenum, GLs
	zei, GLint, GLsizei, const GLvoid *);	izei, GLint, GLsizei, const GLvoid *);
	extern void APIENTRY glCompressedTexSubImage3DARB (GLenum, GLint, GLint, GL	GLAPI void GLAPIENTRY glCompressedTexSubImage3DARB (GLenum, GLint, GLint, G
	int, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);	Lint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
	extern void APIENTRY glCompressedTexSubImage2DARB (GLenum, GLint, GLint, GL	GLAPI void GLAPIENTRY glCompressedTexSubImage2DARB (GLenum, GLint, GLint, G
	int, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);	Lint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
	extern void APIENTRY glCompressedTexSubImage1DARB (GLenum, GLint, GLint, GL	GLAPI void GLAPIENTRY glCompressedTexSubImage1DARB (GLenum, GLint, GLint, G
	sizei, GLenum, GLsizei, const GLvoid *);	Lsizei, GLenum, GLsizei, const GLvoid *);
	extern void APIENTRY glGetCompressedTexImageARB (GLenum, GLint, void *);	GLAPI void GLAPIENTRY glGetCompressedTexImageARB (GLenum, GLint, GLvoid *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target,
	GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei	GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei
	depth, GLint border, GLsizei imageSize, const GLvoid *data);	depth, GLint border, GLsizei imageSize, const GLvoid *data);
	typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target,
	GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint bo	GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint b
	rder, GLsizei imageSize, const GLvoid *data);	order, GLsizei imageSize, const GLvoid *data);
	typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target,
	GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei im	GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei i
	ageSize, const GLvoid *data);	mageSize, const GLvoid *data);
	typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum targe	typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum targ
	t, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width,	et, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width
	GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLv	, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GL
	oid *data);	void *data);
	typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum targe	typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum targ
	t, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height	et, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei heigh
	, GLenum format, GLsizei imageSize, const GLvoid *data);	t, GLenum format, GLsizei imageSize, const GLvoid *data);
	typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum targe	typedef void (GLAPIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum targ
	t, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageS	et, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei image
	ize, const GLvoid *data);	Size, const GLvoid *data);
	typedef void (APIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target
	GLint level, void *img);	, GLint level, GLvoid *img);
		#endif

		#ifndef GL_ARB_texture_border_clamp
		#define GL_ARB_texture_border_clamp 1
		#endif

		#ifndef GL_ARB_point_parameters
		#define GL_ARB_point_parameters 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glPointParameterfARB (GLenum, GLfloat);
		GLAPI void GLAPIENTRY glPointParameterfvARB (GLenum, const GLfloat *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERFARBPROC) (GLenum pname, GLflo
		at param);
		typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, cons
		t GLfloat *params);
		#endif

		#ifndef GL_ARB_vertex_blend
		#define GL_ARB_vertex_blend 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glWeightbvARB (GLint, const GLbyte *);
		GLAPI void GLAPIENTRY glWeightsvARB (GLint, const GLshort *);
		GLAPI void GLAPIENTRY glWeightivARB (GLint, const GLint *);
		GLAPI void GLAPIENTRY glWeightfvARB (GLint, const GLfloat *);
		GLAPI void GLAPIENTRY glWeightdvARB (GLint, const GLdouble *);
		GLAPI void GLAPIENTRY glWeightubvARB (GLint, const GLubyte *);
		GLAPI void GLAPIENTRY glWeightusvARB (GLint, const GLushort *);
		GLAPI void GLAPIENTRY glWeightuivARB (GLint, const GLuint *);
		GLAPI void GLAPIENTRY glWeightPointerARB (GLint, GLenum, GLsizei, const GLv
		oid *);
		GLAPI void GLAPIENTRY glVertexBlendARB (GLint);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLWEIGHTBVARBPROC) (GLint size, const GLbyte *
		weights);
		typedef void (GLAPIENTRYP PFNGLWEIGHTSVARBPROC) (GLint size, const GLshort
		*weights);
		typedef void (GLAPIENTRYP PFNGLWEIGHTIVARBPROC) (GLint size, const GLint *w
		eights);
		typedef void (GLAPIENTRYP PFNGLWEIGHTFVARBPROC) (GLint size, const GLfloat
		*weights);
		typedef void (GLAPIENTRYP PFNGLWEIGHTDVARBPROC) (GLint size, const GLdouble
		*weights);
		typedef void (GLAPIENTRYP PFNGLWEIGHTUBVARBPROC) (GLint size, const GLubyte
		*weights);
		typedef void (GLAPIENTRYP PFNGLWEIGHTUSVARBPROC) (GLint size, const GLushor
		t *weights);
		typedef void (GLAPIENTRYP PFNGLWEIGHTUIVARBPROC) (GLint size, const GLuint
		*weights);
		typedef void (GLAPIENTRYP PFNGLWEIGHTPOINTERARBPROC) (GLint size, GLenum ty
		pe, GLsizei stride, const GLvoid *pointer);
		typedef void (GLAPIENTRYP PFNGLVERTEXBLENDARBPROC) (GLint count);
		#endif

		#ifndef GL_ARB_matrix_palette
		#define GL_ARB_matrix_palette 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glCurrentPaletteMatrixARB (GLint);
		GLAPI void GLAPIENTRY glMatrixIndexubvARB (GLint, const GLubyte *);
		GLAPI void GLAPIENTRY glMatrixIndexusvARB (GLint, const GLushort *);
		GLAPI void GLAPIENTRY glMatrixIndexuivARB (GLint, const GLuint *);
		GLAPI void GLAPIENTRY glMatrixIndexPointerARB (GLint, GLenum, GLsizei, cons
		t GLvoid *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLCURRENTPALETTEMATRIXARBPROC) (GLint index);
		typedef void (GLAPIENTRYP PFNGLMATRIXINDEXUBVARBPROC) (GLint size, const GL
		ubyte *indices);
		typedef void (GLAPIENTRYP PFNGLMATRIXINDEXUSVARBPROC) (GLint size, const GL
		ushort *indices);
		typedef void (GLAPIENTRYP PFNGLMATRIXINDEXUIVARBPROC) (GLint size, const GL
		uint *indices);
		typedef void (GLAPIENTRYP PFNGLMATRIXINDEXPOINTERARBPROC) (GLint size, GLen
		um type, GLsizei stride, const GLvoid *pointer);
		#endif

		#ifndef GL_ARB_texture_env_combine
		#define GL_ARB_texture_env_combine 1
		#endif

		#ifndef GL_ARB_texture_env_crossbar
		#define GL_ARB_texture_env_crossbar 1
		#endif

		#ifndef GL_ARB_texture_env_dot3
		#define GL_ARB_texture_env_dot3 1
		#endif

		#ifndef GL_ARB_texture_mirrored_repeat
		#define GL_ARB_texture_mirrored_repeat 1
		#endif

		#ifndef GL_ARB_depth_texture
		#define GL_ARB_depth_texture 1
		#endif

		#ifndef GL_ARB_shadow
		#define GL_ARB_shadow 1
		#endif

		#ifndef GL_ARB_shadow_ambient
		#define GL_ARB_shadow_ambient 1
		#endif

		#ifndef GL_ARB_window_pos
		#define GL_ARB_window_pos 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glWindowPos2dARB (GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glWindowPos2dvARB (const GLdouble *);
		GLAPI void GLAPIENTRY glWindowPos2fARB (GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glWindowPos2fvARB (const GLfloat *);
		GLAPI void GLAPIENTRY glWindowPos2iARB (GLint, GLint);
		GLAPI void GLAPIENTRY glWindowPos2ivARB (const GLint *);
		GLAPI void GLAPIENTRY glWindowPos2sARB (GLshort, GLshort);
		GLAPI void GLAPIENTRY glWindowPos2svARB (const GLshort *);
		GLAPI void GLAPIENTRY glWindowPos3dARB (GLdouble, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glWindowPos3dvARB (const GLdouble *);
		GLAPI void GLAPIENTRY glWindowPos3fARB (GLfloat, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glWindowPos3fvARB (const GLfloat *);
		GLAPI void GLAPIENTRY glWindowPos3iARB (GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glWindowPos3ivARB (const GLint *);
		GLAPI void GLAPIENTRY glWindowPos3sARB (GLshort, GLshort, GLshort);
		GLAPI void GLAPIENTRY glWindowPos3svARB (const GLshort *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2DARBPROC) (GLdouble x, GLdouble y)
		;
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2DVARBPROC) (const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2FARBPROC) (GLfloat x, GLfloat y);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2FVARBPROC) (const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2IARBPROC) (GLint x, GLint y);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2IVARBPROC) (const GLint *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2SARBPROC) (GLshort x, GLshort y);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS2SVARBPROC) (const GLshort *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3DARBPROC) (GLdouble x, GLdouble y,
		GLdouble z);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3DVARBPROC) (const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3FARBPROC) (GLfloat x, GLfloat y, G
		Lfloat z);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3FVARBPROC) (const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3IARBPROC) (GLint x, GLint y, GLint
		z);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3IVARBPROC) (const GLint *v);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3SARBPROC) (GLshort x, GLshort y, G
		Lshort z);
		typedef void (GLAPIENTRYP PFNGLWINDOWPOS3SVARBPROC) (const GLshort *v);
		#endif

		#ifndef GL_ARB_vertex_program
		#define GL_ARB_vertex_program 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glVertexAttrib1dARB (GLuint, GLdouble);
		GLAPI void GLAPIENTRY glVertexAttrib1dvARB (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib1fARB (GLuint, GLfloat);
		GLAPI void GLAPIENTRY glVertexAttrib1fvARB (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib1sARB (GLuint, GLshort);
		GLAPI void GLAPIENTRY glVertexAttrib1svARB (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib2dARB (GLuint, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glVertexAttrib2dvARB (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib2fARB (GLuint, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glVertexAttrib2fvARB (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib2sARB (GLuint, GLshort, GLshort);
		GLAPI void GLAPIENTRY glVertexAttrib2svARB (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib3dARB (GLuint, GLdouble, GLdouble, GLdo
		uble);
		GLAPI void GLAPIENTRY glVertexAttrib3dvARB (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib3fARB (GLuint, GLfloat, GLfloat, GLfloa
		t);
		GLAPI void GLAPIENTRY glVertexAttrib3fvARB (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib3sARB (GLuint, GLshort, GLshort, GLshor
		t);
		GLAPI void GLAPIENTRY glVertexAttrib3svARB (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib4NbvARB (GLuint, const GLbyte *);
		GLAPI void GLAPIENTRY glVertexAttrib4NivARB (GLuint, const GLint *);
		GLAPI void GLAPIENTRY glVertexAttrib4NsvARB (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib4NubARB (GLuint, GLubyte, GLubyte, GLub
		yte, GLubyte);
		GLAPI void GLAPIENTRY glVertexAttrib4NubvARB (GLuint, const GLubyte *);
		GLAPI void GLAPIENTRY glVertexAttrib4NuivARB (GLuint, const GLuint *);
		GLAPI void GLAPIENTRY glVertexAttrib4NusvARB (GLuint, const GLushort *);
		GLAPI void GLAPIENTRY glVertexAttrib4bvARB (GLuint, const GLbyte *);
		GLAPI void GLAPIENTRY glVertexAttrib4dARB (GLuint, GLdouble, GLdouble, GLdo
		uble, GLdouble);
		GLAPI void GLAPIENTRY glVertexAttrib4dvARB (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib4fARB (GLuint, GLfloat, GLfloat, GLfloa
		t, GLfloat);
		GLAPI void GLAPIENTRY glVertexAttrib4fvARB (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib4ivARB (GLuint, const GLint *);
		GLAPI void GLAPIENTRY glVertexAttrib4sARB (GLuint, GLshort, GLshort, GLshor
		t, GLshort);
		GLAPI void GLAPIENTRY glVertexAttrib4svARB (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib4ubvARB (GLuint, const GLubyte *);
		GLAPI void GLAPIENTRY glVertexAttrib4uivARB (GLuint, const GLuint *);
		GLAPI void GLAPIENTRY glVertexAttrib4usvARB (GLuint, const GLushort *);
		GLAPI void GLAPIENTRY glVertexAttribPointerARB (GLuint, GLint, GLenum, GLbo
		olean, GLsizei, const GLvoid *);
		GLAPI void GLAPIENTRY glEnableVertexAttribArrayARB (GLuint);
		GLAPI void GLAPIENTRY glDisableVertexAttribArrayARB (GLuint);
		GLAPI void GLAPIENTRY glProgramStringARB (GLenum, GLenum, GLsizei, const GL
		void *);
		GLAPI void GLAPIENTRY glBindProgramARB (GLenum, GLuint);
		GLAPI void GLAPIENTRY glDeleteProgramsARB (GLsizei, const GLuint *);
		GLAPI void GLAPIENTRY glGenProgramsARB (GLsizei, GLuint *);
		GLAPI void GLAPIENTRY glProgramEnvParameter4dARB (GLenum, GLuint, GLdouble,
		GLdouble, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glProgramEnvParameter4dvARB (GLenum, GLuint, const GL
		double *);
		GLAPI void GLAPIENTRY glProgramEnvParameter4fARB (GLenum, GLuint, GLfloat,
		GLfloat, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glProgramEnvParameter4fvARB (GLenum, GLuint, const GL
		float *);
		GLAPI void GLAPIENTRY glProgramLocalParameter4dARB (GLenum, GLuint, GLdoubl
		e, GLdouble, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glProgramLocalParameter4dvARB (GLenum, GLuint, const
		GLdouble *);
		GLAPI void GLAPIENTRY glProgramLocalParameter4fARB (GLenum, GLuint, GLfloat
		, GLfloat, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glProgramLocalParameter4fvARB (GLenum, GLuint, const
		GLfloat *);
		GLAPI void GLAPIENTRY glGetProgramEnvParameterdvARB (GLenum, GLuint, GLdoub
		le *);
		GLAPI void GLAPIENTRY glGetProgramEnvParameterfvARB (GLenum, GLuint, GLfloa
		t *);
		GLAPI void GLAPIENTRY glGetProgramLocalParameterdvARB (GLenum, GLuint, GLdo
		uble *);
		GLAPI void GLAPIENTRY glGetProgramLocalParameterfvARB (GLenum, GLuint, GLfl
		oat *);
		GLAPI void GLAPIENTRY glGetProgramivARB (GLenum, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetProgramStringARB (GLenum, GLenum, GLvoid *);
		GLAPI void GLAPIENTRY glGetVertexAttribdvARB (GLuint, GLenum, GLdouble *);
		GLAPI void GLAPIENTRY glGetVertexAttribfvARB (GLuint, GLenum, GLfloat *);
		GLAPI void GLAPIENTRY glGetVertexAttribivARB (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetVertexAttribPointervARB (GLuint, GLenum, GLvoid*
		*);
		GLAPI GLboolean GLAPIENTRY glIsProgramARB (GLuint);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdoub
		le x);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloa
		t x);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshor
		t x);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdoub
		le x, GLdouble y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloa
		t x, GLfloat y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshor
		t x, GLshort y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdoub
		le x, GLdouble y, GLdouble z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloa
		t x, GLfloat y, GLfloat z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshor
		t x, GLshort y, GLshort z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, cons
		t GLbyte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, cons
		t GLint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, cons
		t GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLub
		yte x, GLubyte y, GLubyte z, GLubyte w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, con
		st GLubyte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, con
		st GLuint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, con
		st GLushort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, const
		GLbyte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdoub
		le x, GLdouble y, GLdouble z, GLdouble w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloa
		t x, GLfloat y, GLfloat z, GLfloat w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, const
		GLint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshor
		t x, GLshort y, GLshort z, GLshort w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, cons
		t GLubyte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, cons
		t GLuint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, cons
		t GLushort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBPOINTERARBPROC) (GLuint index, G
		Lint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid
		*pointer);
		typedef void (GLAPIENTRYP PFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint inde
		x);
		typedef void (GLAPIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint ind
		ex);
		typedef void (GLAPIENTRYP PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum
		format, GLsizei len, const GLvoid *string);
		typedef void (GLAPIENTRYP PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint p
		rogram);
		typedef void (GLAPIENTRYP PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLu
		int *programs);
		typedef void (GLAPIENTRYP PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint *prog
		rams);
		typedef void (GLAPIENTRYP PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target
		, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum targe
		t, GLuint index, const GLdouble *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target
		, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum targe
		t, GLuint index, const GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum targ
		et, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum tar
		get, GLuint index, const GLdouble *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum targ
		et, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum tar
		get, GLuint index, const GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum tar
		get, GLuint index, GLdouble *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum tar
		get, GLuint index, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum t
		arget, GLuint index, GLdouble *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum t
		arget, GLuint index, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum
		pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLe
		num pname, GLvoid *string);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLe
		num pname, GLdouble *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLe
		num pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLe
		num pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint inde
		x, GLenum pname, GLvoid* *pointer);
		typedef GLboolean (GLAPIENTRYP PFNGLISPROGRAMARBPROC) (GLuint program);
		#endif

		#ifndef GL_ARB_fragment_program
		#define GL_ARB_fragment_program 1
		/* All ARB_fragment_program entry points are shared with ARB_vertex_program
		. */
		#endif

		#ifndef GL_ARB_vertex_buffer_object
		#define GL_ARB_vertex_buffer_object 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glBindBufferARB (GLenum, GLuint);
		GLAPI void GLAPIENTRY glDeleteBuffersARB (GLsizei, const GLuint *);
		GLAPI void GLAPIENTRY glGenBuffersARB (GLsizei, GLuint *);
		GLAPI GLboolean GLAPIENTRY glIsBufferARB (GLuint);
		GLAPI void GLAPIENTRY glBufferDataARB (GLenum, GLsizeiptrARB, const GLvoid
		*, GLenum);
		GLAPI void GLAPIENTRY glBufferSubDataARB (GLenum, GLintptrARB, GLsizeiptrAR
		B, const GLvoid *);
		GLAPI void GLAPIENTRY glGetBufferSubDataARB (GLenum, GLintptrARB, GLsizeipt
		rARB, GLvoid *);
		GLAPI GLvoid* GLAPIENTRY glMapBufferARB (GLenum, GLenum);
		GLAPI GLboolean GLAPIENTRY glUnmapBufferARB (GLenum);
		GLAPI void GLAPIENTRY glGetBufferParameterivARB (GLenum, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetBufferPointervARB (GLenum, GLenum, GLvoid* *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint bu
		ffer);
		typedef void (GLAPIENTRYP PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLui
		nt *buffers);
		typedef void (GLAPIENTRYP PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffe
		rs);
		typedef GLboolean (GLAPIENTRYP PFNGLISBUFFERARBPROC) (GLuint buffer);
		typedef void (GLAPIENTRYP PFNGLBUFFERDATAARBPROC) (GLenum target, GLsizeipt
		rARB size, const GLvoid *data, GLenum usage);
		typedef void (GLAPIENTRYP PFNGLBUFFERSUBDATAARBPROC) (GLenum target, GLintp
		trARB offset, GLsizeiptrARB size, const GLvoid *data);
		typedef void (GLAPIENTRYP PFNGLGETBUFFERSUBDATAARBPROC) (GLenum target, GLi
		ntptrARB offset, GLsizeiptrARB size, GLvoid *data);
		typedef GLvoid* (GLAPIENTRYP PFNGLMAPBUFFERARBPROC) (GLenum target, GLenum
		access);
		typedef GLboolean (GLAPIENTRYP PFNGLUNMAPBUFFERARBPROC) (GLenum target);
		typedef void (GLAPIENTRYP PFNGLGETBUFFERPARAMETERIVARBPROC) (GLenum target,
		GLenum pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETBUFFERPOINTERVARBPROC) (GLenum target, GL
		enum pname, GLvoid* *params);
		#endif

		#ifndef GL_ARB_occlusion_query
		#define GL_ARB_occlusion_query 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glGenQueriesARB (GLsizei, GLuint *);
		GLAPI void GLAPIENTRY glDeleteQueriesARB (GLsizei, const GLuint *);
		GLAPI GLboolean GLAPIENTRY glIsQueryARB (GLuint);
		GLAPI void GLAPIENTRY glBeginQueryARB (GLenum, GLuint);
		GLAPI void GLAPIENTRY glEndQueryARB (GLenum);
		GLAPI void GLAPIENTRY glGetQueryivARB (GLenum, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetQueryObjectivARB (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetQueryObjectuivARB (GLuint, GLenum, GLuint *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLGENQUERIESARBPROC) (GLsizei n, GLuint *ids);
		typedef void (GLAPIENTRYP PFNGLDELETEQUERIESARBPROC) (GLsizei n, const GLui
		nt *ids);
		typedef GLboolean (GLAPIENTRYP PFNGLISQUERYARBPROC) (GLuint id);
		typedef void (GLAPIENTRYP PFNGLBEGINQUERYARBPROC) (GLenum target, GLuint id
		);
		typedef void (GLAPIENTRYP PFNGLENDQUERYARBPROC) (GLenum target);
		typedef void (GLAPIENTRYP PFNGLGETQUERYIVARBPROC) (GLenum target, GLenum pn
		ame, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETQUERYOBJECTIVARBPROC) (GLuint id, GLenum
		pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETQUERYOBJECTUIVARBPROC) (GLuint id, GLenum
		pname, GLuint *params);
		#endif

		#ifndef GL_ARB_shader_objects
		#define GL_ARB_shader_objects 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glDeleteObjectARB (GLhandleARB);
		GLAPI GLhandleARB GLAPIENTRY glGetHandleARB (GLenum);
		GLAPI void GLAPIENTRY glDetachObjectARB (GLhandleARB, GLhandleARB);
		GLAPI GLhandleARB GLAPIENTRY glCreateShaderObjectARB (GLenum);
		GLAPI void GLAPIENTRY glShaderSourceARB (GLhandleARB, GLsizei, const GLchar
		ARB* , const GLint );
		GLAPI void GLAPIENTRY glCompileShaderARB (GLhandleARB);
		GLAPI GLhandleARB GLAPIENTRY glCreateProgramObjectARB (void);
		GLAPI void GLAPIENTRY glAttachObjectARB (GLhandleARB, GLhandleARB);
		GLAPI void GLAPIENTRY glLinkProgramARB (GLhandleARB);
		GLAPI void GLAPIENTRY glUseProgramObjectARB (GLhandleARB);
		GLAPI void GLAPIENTRY glValidateProgramARB (GLhandleARB);
		GLAPI void GLAPIENTRY glUniform1fARB (GLint, GLfloat);
		GLAPI void GLAPIENTRY glUniform2fARB (GLint, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glUniform3fARB (GLint, GLfloat, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glUniform4fARB (GLint, GLfloat, GLfloat, GLfloat, GLf
		loat);
		GLAPI void GLAPIENTRY glUniform1iARB (GLint, GLint);
		GLAPI void GLAPIENTRY glUniform2iARB (GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glUniform3iARB (GLint, GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glUniform4iARB (GLint, GLint, GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glUniform1fvARB (GLint, GLsizei, const GLfloat *);
		GLAPI void GLAPIENTRY glUniform2fvARB (GLint, GLsizei, const GLfloat *);
		GLAPI void GLAPIENTRY glUniform3fvARB (GLint, GLsizei, const GLfloat *);
		GLAPI void GLAPIENTRY glUniform4fvARB (GLint, GLsizei, const GLfloat *);
		GLAPI void GLAPIENTRY glUniform1ivARB (GLint, GLsizei, const GLint *);
		GLAPI void GLAPIENTRY glUniform2ivARB (GLint, GLsizei, const GLint *);
		GLAPI void GLAPIENTRY glUniform3ivARB (GLint, GLsizei, const GLint *);
		GLAPI void GLAPIENTRY glUniform4ivARB (GLint, GLsizei, const GLint *);
		GLAPI void GLAPIENTRY glUniformMatrix2fvARB (GLint, GLsizei, GLboolean, con
		st GLfloat *);
		GLAPI void GLAPIENTRY glUniformMatrix3fvARB (GLint, GLsizei, GLboolean, con
		st GLfloat *);
		GLAPI void GLAPIENTRY glUniformMatrix4fvARB (GLint, GLsizei, GLboolean, con
		st GLfloat *);
		GLAPI void GLAPIENTRY glGetObjectParameterfvARB (GLhandleARB, GLenum, GLflo
		at *);
		GLAPI void GLAPIENTRY glGetObjectParameterivARB (GLhandleARB, GLenum, GLint
		*);
		GLAPI void GLAPIENTRY glGetInfoLogARB (GLhandleARB, GLsizei, GLsizei *, GLc
		harARB *);
		GLAPI void GLAPIENTRY glGetAttachedObjectsARB (GLhandleARB, GLsizei, GLsize
		i , GLhandleARB );
		GLAPI GLint GLAPIENTRY glGetUniformLocationARB (GLhandleARB, const GLcharAR
		B *);
		GLAPI void GLAPIENTRY glGetActiveUniformARB (GLhandleARB, GLuint, GLsizei,
		GLsizei , GLint , GLenum , GLcharARB );
		GLAPI void GLAPIENTRY glGetUniformfvARB (GLhandleARB, GLint, GLfloat *);
		GLAPI void GLAPIENTRY glGetUniformivARB (GLhandleARB, GLint, GLint *);
		GLAPI void GLAPIENTRY glGetShaderSourceARB (GLhandleARB, GLsizei, GLsizei *
		, GLcharARB *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj);
		typedef GLhandleARB (GLAPIENTRYP PFNGLGETHANDLEARBPROC) (GLenum pname);
		typedef void (GLAPIENTRYP PFNGLDETACHOBJECTARBPROC) (GLhandleARB containerO
		bj, GLhandleARB attachedObj);
		typedef GLhandleARB (GLAPIENTRYP PFNGLCREATESHADEROBJECTARBPROC) (GLenum sh
		aderType);
		typedef void (GLAPIENTRYP PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj,
		GLsizei count, const GLcharARB* string, const GLint length);
		typedef void (GLAPIENTRYP PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj
		);
		typedef GLhandleARB (GLAPIENTRYP PFNGLCREATEPROGRAMOBJECTARBPROC) (void);
		typedef void (GLAPIENTRYP PFNGLATTACHOBJECTARBPROC) (GLhandleARB containerO
		bj, GLhandleARB obj);
		typedef void (GLAPIENTRYP PFNGLLINKPROGRAMARBPROC) (GLhandleARB programObj)
		;
		typedef void (GLAPIENTRYP PFNGLUSEPROGRAMOBJECTARBPROC) (GLhandleARB progra
		mObj);
		typedef void (GLAPIENTRYP PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB program
		Obj);
		typedef void (GLAPIENTRYP PFNGLUNIFORM1FARBPROC) (GLint location, GLfloat v
		0);
		typedef void (GLAPIENTRYP PFNGLUNIFORM2FARBPROC) (GLint location, GLfloat v
		0, GLfloat v1);
		typedef void (GLAPIENTRYP PFNGLUNIFORM3FARBPROC) (GLint location, GLfloat v
		0, GLfloat v1, GLfloat v2);
		typedef void (GLAPIENTRYP PFNGLUNIFORM4FARBPROC) (GLint location, GLfloat v
		0, GLfloat v1, GLfloat v2, GLfloat v3);
		typedef void (GLAPIENTRYP PFNGLUNIFORM1IARBPROC) (GLint location, GLint v0)
		;
		typedef void (GLAPIENTRYP PFNGLUNIFORM2IARBPROC) (GLint location, GLint v0,
		GLint v1);
		typedef void (GLAPIENTRYP PFNGLUNIFORM3IARBPROC) (GLint location, GLint v0,
		GLint v1, GLint v2);
		typedef void (GLAPIENTRYP PFNGLUNIFORM4IARBPROC) (GLint location, GLint v0,
		GLint v1, GLint v2, GLint v3);
		typedef void (GLAPIENTRYP PFNGLUNIFORM1FVARBPROC) (GLint location, GLsizei
		count, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM2FVARBPROC) (GLint location, GLsizei
		count, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM3FVARBPROC) (GLint location, GLsizei
		count, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM4FVARBPROC) (GLint location, GLsizei
		count, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM1IVARBPROC) (GLint location, GLsizei
		count, const GLint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM2IVARBPROC) (GLint location, GLsizei
		count, const GLint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM3IVARBPROC) (GLint location, GLsizei
		count, const GLint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM4IVARBPROC) (GLint location, GLsizei
		count, const GLint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX2FVARBPROC) (GLint location, GL
		sizei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX3FVARBPROC) (GLint location, GL
		sizei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORMMATRIX4FVARBPROC) (GLint location, GL
		sizei count, GLboolean transpose, const GLfloat *value);
		typedef void (GLAPIENTRYP PFNGLGETOBJECTPARAMETERFVARBPROC) (GLhandleARB ob
		j, GLenum pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB ob
		j, GLenum pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei
		maxLength, GLsizei length, GLcharARB infoLog);
		typedef void (GLAPIENTRYP PFNGLGETATTACHEDOBJECTSARBPROC) (GLhandleARB cont
		ainerObj, GLsizei maxCount, GLsizei count, GLhandleARB obj);
		typedef GLint (GLAPIENTRYP PFNGLGETUNIFORMLOCATIONARBPROC) (GLhandleARB pro
		gramObj, const GLcharARB *name);
		typedef void (GLAPIENTRYP PFNGLGETACTIVEUNIFORMARBPROC) (GLhandleARB progra
		mObj, GLuint index, GLsizei maxLength, GLsizei length, GLint size, GLenum
		type, GLcharARB name);
		typedef void (GLAPIENTRYP PFNGLGETUNIFORMFVARBPROC) (GLhandleARB programObj
		, GLint location, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETUNIFORMIVARBPROC) (GLhandleARB programObj
		, GLint location, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETSHADERSOURCEARBPROC) (GLhandleARB obj, GL
		sizei maxLength, GLsizei length, GLcharARB source);
		#endif

		#ifndef GL_ARB_vertex_shader
		#define GL_ARB_vertex_shader 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glBindAttribLocationARB (GLhandleARB, GLuint, const G
		LcharARB *);
		GLAPI void GLAPIENTRY glGetActiveAttribARB (GLhandleARB, GLuint, GLsizei, G
		Lsizei , GLint , GLenum , GLcharARB );
		GLAPI GLint GLAPIENTRY glGetAttribLocationARB (GLhandleARB, const GLcharARB
		*);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLBINDATTRIBLOCATIONARBPROC) (GLhandleARB prog
		ramObj, GLuint index, const GLcharARB *name);
		typedef void (GLAPIENTRYP PFNGLGETACTIVEATTRIBARBPROC) (GLhandleARB program
		Obj, GLuint index, GLsizei maxLength, GLsizei length, GLint size, GLenum
		type, GLcharARB name);
		typedef GLint (GLAPIENTRYP PFNGLGETATTRIBLOCATIONARBPROC) (GLhandleARB prog
		ramObj, const GLcharARB *name);
		#endif

		#ifndef GL_ARB_fragment_shader
		#define GL_ARB_fragment_shader 1
		#endif

		#ifndef GL_ARB_shading_language_100
		#define GL_ARB_shading_language_100 1
		#endif

		#ifndef GL_ARB_texture_non_power_of_two
		#define GL_ARB_texture_non_power_of_two 1
		#endif

		#ifndef GL_ARB_point_sprite
		#define GL_ARB_point_sprite 1
		#endif

		#ifndef GL_ARB_fragment_program_shadow
		#define GL_ARB_fragment_program_shadow 1
		#endif

		#ifndef GL_ARB_draw_buffers
		#define GL_ARB_draw_buffers 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glDrawBuffersARB (GLsizei, const GLenum *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLDRAWBUFFERSARBPROC) (GLsizei n, const GLenum
		*bufs);
		#endif

		#ifndef GL_ARB_texture_rectangle
		#define GL_ARB_texture_rectangle 1
		#endif

		#ifndef GL_ARB_color_buffer_float
		#define GL_ARB_color_buffer_float 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glClampColorARB (GLenum, GLenum);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLCLAMPCOLORARBPROC) (GLenum target, GLenum cl
		amp);
		#endif

		#ifndef GL_ARB_half_float_pixel
		#define GL_ARB_half_float_pixel 1
		#endif

		#ifndef GL_ARB_texture_float
		#define GL_ARB_texture_float 1
		#endif

		#ifndef GL_ARB_pixel_buffer_object
		#define GL_ARB_pixel_buffer_object 1
	#endif	#endif

	#ifndef GL_EXT_abgr	#ifndef GL_EXT_abgr
	#define GL_EXT_abgr 1	#define GL_EXT_abgr 1
	#endif	#endif

	#ifndef GL_EXT_blend_color	#ifndef GL_EXT_blend_color
	#define GL_EXT_blend_color 1	#define GL_EXT_blend_color 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glBlendColorEXT (GLclampf, GLclampf, GLclampf, GLclamp f);	GLAPI void GLAPIENTRY glBlendColorEXT (GLclampf, GLclampf, GLclampf, GLclam pf);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf gr een, GLclampf blue, GLclampf alpha);	typedef void (GLAPIENTRYP PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf g reen, GLclampf blue, GLclampf alpha);
	#endif	#endif

	#ifndef GL_EXT_polygon_offset	#ifndef GL_EXT_polygon_offset
	#define GL_EXT_polygon_offset 1	#define GL_EXT_polygon_offset 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glPolygonOffsetEXT (GLfloat, GLfloat);	GLAPI void GLAPIENTRY glPolygonOffsetEXT (GLfloat, GLfloat);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloa t bias);	typedef void (GLAPIENTRYP PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLflo at bias);
	#endif	#endif

	#ifndef GL_EXT_texture	#ifndef GL_EXT_texture
	#define GL_EXT_texture 1	#define GL_EXT_texture 1
	#endif	#endif

	#ifndef GL_EXT_texture3D	#ifndef GL_EXT_texture3D
	#define GL_EXT_texture3D 1	#define GL_EXT_texture3D 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glTexImage3DEXT (GLenum, GLint, GLenum, GLsizei, GLsiz	GLAPI void GLAPIENTRY glTexImage3DEXT (GLenum, GLint, GLenum, GLsizei, GLsi
	ei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);	zei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
	extern void APIENTRY glTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint	GLAPI void GLAPIENTRY glTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLin
	, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);	t, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint leve	typedef void (GLAPIENTRYP PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint lev
	l, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLi	el, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GL
	nt border, GLenum format, GLenum type, const GLvoid *pixels);	int border, GLenum format, GLenum type, const GLvoid *pixels);
	typedef void (APIENTRY * PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint l	typedef void (GLAPIENTRYP PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint
	evel, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei h	level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei
	eight, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);	height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
	#endif	#endif

	#ifndef GL_SGIS_texture_filter4	#ifndef GL_SGIS_texture_filter4
	#define GL_SGIS_texture_filter4 1	#define GL_SGIS_texture_filter4 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glGetTexFilterFuncSGIS (GLenum, GLenum, GLfloat *);	GLAPI void GLAPIENTRY glGetTexFilterFuncSGIS (GLenum, GLenum, GLfloat *);
	extern void APIENTRY glTexFilterFuncSGIS (GLenum, GLenum, GLsizei, const GL	GLAPI void GLAPIENTRY glTexFilterFuncSGIS (GLenum, GLenum, GLsizei, const G
	float *);	Lfloat *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GLe	typedef void (GLAPIENTRYP PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GL
	num filter, GLfloat *weights);	enum filter, GLfloat *weights);
	typedef void (APIENTRY * PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenum	typedef void (GLAPIENTRYP PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenu
	filter, GLsizei n, const GLfloat *weights);	m filter, GLsizei n, const GLfloat *weights);
	#endif	#endif

	#ifndef GL_EXT_subtexture	#ifndef GL_EXT_subtexture
	#define GL_EXT_subtexture 1	#define GL_EXT_subtexture 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glTexSubImage1DEXT (GLenum, GLint, GLint, GLsizei, GLe	GLAPI void GLAPIENTRY glTexSubImage1DEXT (GLenum, GLint, GLint, GLsizei, GL
	num, GLenum, const GLvoid *);	enum, GLenum, const GLvoid *);
	extern void APIENTRY glTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLsiz	GLAPI void GLAPIENTRY glTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLsi
	ei, GLsizei, GLenum, GLenum, const GLvoid *);	zei, GLsizei, GLenum, GLenum, const GLvoid *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint l	typedef void (GLAPIENTRYP PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint
	evel, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoi	level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvo
	d *pixels);	id *pixels);
	typedef void (APIENTRY * PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint l	typedef void (GLAPIENTRYP PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint
	evel, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum f	level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum
	ormat, GLenum type, const GLvoid *pixels);	format, GLenum type, const GLvoid *pixels);
	#endif	#endif

	#ifndef GL_EXT_copy_texture	#ifndef GL_EXT_copy_texture
	#define GL_EXT_copy_texture 1	#define GL_EXT_copy_texture 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glCopyTexImage1DEXT (GLenum, GLint, GLenum, GLint, GLi	GLAPI void GLAPIENTRY glCopyTexImage1DEXT (GLenum, GLint, GLenum, GLint, GL
	nt, GLsizei, GLint);	int, GLsizei, GLint);
	extern void APIENTRY glCopyTexImage2DEXT (GLenum, GLint, GLenum, GLint, GLi	GLAPI void GLAPIENTRY glCopyTexImage2DEXT (GLenum, GLint, GLenum, GLint, GL
	nt, GLsizei, GLsizei, GLint);	int, GLsizei, GLsizei, GLint);
	extern void APIENTRY glCopyTexSubImage1DEXT (GLenum, GLint, GLint, GLint, G	GLAPI void GLAPIENTRY glCopyTexSubImage1DEXT (GLenum, GLint, GLint, GLint,
	Lint, GLsizei);	GLint, GLsizei);
	extern void APIENTRY glCopyTexSubImage2DEXT (GLenum, GLint, GLint, GLint, G	GLAPI void GLAPIENTRY glCopyTexSubImage2DEXT (GLenum, GLint, GLint, GLint,
	Lint, GLint, GLsizei, GLsizei);	GLint, GLint, GLsizei, GLsizei);
	extern void APIENTRY glCopyTexSubImage3DEXT (GLenum, GLint, GLint, GLint, G	GLAPI void GLAPIENTRY glCopyTexSubImage3DEXT (GLenum, GLint, GLint, GLint,
	Lint, GLint, GLint, GLsizei, GLsizei);	GLint, GLint, GLint, GLsizei, GLsizei);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint	typedef void (GLAPIENTRYP PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint
	level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border	level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint borde
	);	r);
	typedef void (APIENTRY * PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint	typedef void (GLAPIENTRYP PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint
	level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei heig	level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei hei
	ht, GLint border);	ght, GLint border);
	typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE1DEXTPROC) (GLenum target, GLi	typedef void (GLAPIENTRYP PFNGLCOPYTEXSUBIMAGE1DEXTPROC) (GLenum target, GL
	nt level, GLint xoffset, GLint x, GLint y, GLsizei width);	int level, GLint xoffset, GLint x, GLint y, GLsizei width);
	typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE2DEXTPROC) (GLenum target, GLi	typedef void (GLAPIENTRYP PFNGLCOPYTEXSUBIMAGE2DEXTPROC) (GLenum target, GL
	nt level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GL	int level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, G
	sizei height);	Lsizei height);
	typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLi	typedef void (GLAPIENTRYP PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GL
	nt level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GL	int level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, G
	sizei width, GLsizei height);	Lsizei width, GLsizei height);
	#endif	#endif

	#ifndef GL_EXT_histogram	#ifndef GL_EXT_histogram
	#define GL_EXT_histogram 1	#define GL_EXT_histogram 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glGetHistogramEXT (GLenum, GLboolean, GLenum, GLenum,	GLAPI void GLAPIENTRY glGetHistogramEXT (GLenum, GLboolean, GLenum, GLenum,
	GLvoid *);	GLvoid *);
	extern void APIENTRY glGetHistogramParameterfvEXT (GLenum, GLenum, GLfloat	GLAPI void GLAPIENTRY glGetHistogramParameterfvEXT (GLenum, GLenum, GLfloat
	*);	*);
	extern void APIENTRY glGetHistogramParameterivEXT (GLenum, GLenum, GLint *)	GLAPI void GLAPIENTRY glGetHistogramParameterivEXT (GLenum, GLenum, GLint *
	;	);
	extern void APIENTRY glGetMinmaxEXT (GLenum, GLboolean, GLenum, GLenum, GLv	GLAPI void GLAPIENTRY glGetMinmaxEXT (GLenum, GLboolean, GLenum, GLenum, GL
	oid *);	void *);
	extern void APIENTRY glGetMinmaxParameterfvEXT (GLenum, GLenum, GLfloat *);	GLAPI void GLAPIENTRY glGetMinmaxParameterfvEXT (GLenum, GLenum, GLfloat *)
	extern void APIENTRY glGetMinmaxParameterivEXT (GLenum, GLenum, GLint *);	;
	extern void APIENTRY glHistogramEXT (GLenum, GLsizei, GLenum, GLboolean);	GLAPI void GLAPIENTRY glGetMinmaxParameterivEXT (GLenum, GLenum, GLint *);
	extern void APIENTRY glMinmaxEXT (GLenum, GLenum, GLboolean);	GLAPI void GLAPIENTRY glHistogramEXT (GLenum, GLsizei, GLenum, GLboolean);
	extern void APIENTRY glResetHistogramEXT (GLenum);	GLAPI void GLAPIENTRY glMinmaxEXT (GLenum, GLenum, GLboolean);
	extern void APIENTRY glResetMinmaxEXT (GLenum);	GLAPI void GLAPIENTRY glResetHistogramEXT (GLenum);
		GLAPI void GLAPIENTRY glResetMinmaxEXT (GLenum);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboolea	typedef void (GLAPIENTRYP PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboole
	n reset, GLenum format, GLenum type, GLvoid *values);	an reset, GLenum format, GLenum type, GLvoid *values);
	typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum targe	typedef void (GLAPIENTRYP PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum targ
	t, GLenum pname, GLfloat *params);	et, GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) (GLenum targe	typedef void (GLAPIENTRYP PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) (GLenum targ
	t, GLenum pname, GLint *params);	et, GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLGETMINMAXEXTPROC) (GLenum target, GLboolean r	typedef void (GLAPIENTRYP PFNGLGETMINMAXEXTPROC) (GLenum target, GLboolean
	eset, GLenum format, GLenum type, GLvoid *values);	reset, GLenum format, GLenum type, GLvoid *values);
	typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERFVEXTPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLGETMINMAXPARAMETERFVEXTPROC) (GLenum target,
	GLenum pname, GLfloat *params);	GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERIVEXTPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLGETMINMAXPARAMETERIVEXTPROC) (GLenum target,
	GLenum pname, GLint *params);	GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLHISTOGRAMEXTPROC) (GLenum target, GLsizei wid	typedef void (GLAPIENTRYP PFNGLHISTOGRAMEXTPROC) (GLenum target, GLsizei wi
	th, GLenum internalformat, GLboolean sink);	dth, GLenum internalformat, GLboolean sink);
	typedef void (APIENTRY * PFNGLMINMAXEXTPROC) (GLenum target, GLenum interna	typedef void (GLAPIENTRYP PFNGLMINMAXEXTPROC) (GLenum target, GLenum intern
	lformat, GLboolean sink);	alformat, GLboolean sink);
	typedef void (APIENTRY * PFNGLRESETHISTOGRAMEXTPROC) (GLenum target);	typedef void (GLAPIENTRYP PFNGLRESETHISTOGRAMEXTPROC) (GLenum target);
	typedef void (APIENTRY * PFNGLRESETMINMAXEXTPROC) (GLenum target);	typedef void (GLAPIENTRYP PFNGLRESETMINMAXEXTPROC) (GLenum target);
	#endif	#endif

	#ifndef GL_EXT_convolution	#ifndef GL_EXT_convolution
	#define GL_EXT_convolution 1	#define GL_EXT_convolution 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glConvolutionFilter1DEXT (GLenum, GLenum, GLsizei, GLe	GLAPI void GLAPIENTRY glConvolutionFilter1DEXT (GLenum, GLenum, GLsizei, GL
	num, GLenum, const GLvoid *);	enum, GLenum, const GLvoid *);
	extern void APIENTRY glConvolutionFilter2DEXT (GLenum, GLenum, GLsizei, GLs	GLAPI void GLAPIENTRY glConvolutionFilter2DEXT (GLenum, GLenum, GLsizei, GL
	izei, GLenum, GLenum, const GLvoid *);	sizei, GLenum, GLenum, const GLvoid *);
	extern void APIENTRY glConvolutionParameterfEXT (GLenum, GLenum, GLfloat);	GLAPI void GLAPIENTRY glConvolutionParameterfEXT (GLenum, GLenum, GLfloat);
	extern void APIENTRY glConvolutionParameterfvEXT (GLenum, GLenum, const GLf	GLAPI void GLAPIENTRY glConvolutionParameterfvEXT (GLenum, GLenum, const GL
	loat *);	float *);
	extern void APIENTRY glConvolutionParameteriEXT (GLenum, GLenum, GLint);	GLAPI void GLAPIENTRY glConvolutionParameteriEXT (GLenum, GLenum, GLint);
	extern void APIENTRY glConvolutionParameterivEXT (GLenum, GLenum, const GLi	GLAPI void GLAPIENTRY glConvolutionParameterivEXT (GLenum, GLenum, const GL
	nt *);	int *);
	extern void APIENTRY glCopyConvolutionFilter1DEXT (GLenum, GLenum, GLint, G	GLAPI void GLAPIENTRY glCopyConvolutionFilter1DEXT (GLenum, GLenum, GLint,
	Lint, GLsizei);	GLint, GLsizei);
	extern void APIENTRY glCopyConvolutionFilter2DEXT (GLenum, GLenum, GLint, G	GLAPI void GLAPIENTRY glCopyConvolutionFilter2DEXT (GLenum, GLenum, GLint,
	Lint, GLsizei, GLsizei);	GLint, GLsizei, GLsizei);
	extern void APIENTRY glGetConvolutionFilterEXT (GLenum, GLenum, GLenum, GLv	GLAPI void GLAPIENTRY glGetConvolutionFilterEXT (GLenum, GLenum, GLenum, GL
	oid *);	void *);
	extern void APIENTRY glGetConvolutionParameterfvEXT (GLenum, GLenum, GLfloa	GLAPI void GLAPIENTRY glGetConvolutionParameterfvEXT (GLenum, GLenum, GLflo
	t *);	at *);
	extern void APIENTRY glGetConvolutionParameterivEXT (GLenum, GLenum, GLint	GLAPI void GLAPIENTRY glGetConvolutionParameterivEXT (GLenum, GLenum, GLint
	*);	*);
	extern void APIENTRY glGetSeparableFilterEXT (GLenum, GLenum, GLenum, GLvoi	GLAPI void GLAPIENTRY glGetSeparableFilterEXT (GLenum, GLenum, GLenum, GLvo
	d , GLvoid , GLvoid *);	id , GLvoid , GLvoid *);
	extern void APIENTRY glSeparableFilter2DEXT (GLenum, GLenum, GLsizei, GLsiz	GLAPI void GLAPIENTRY glSeparableFilter2DEXT (GLenum, GLenum, GLsizei, GLsi
	ei, GLenum, GLenum, const GLvoid , const GLvoid );	zei, GLenum, GLenum, const GLvoid , const GLvoid );
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target, G	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target,
	Lenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvo	GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLv
	id *image);	oid *image);
	typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target, G	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target,
	Lenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum	GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum
	type, const GLvoid *image);	type, const GLvoid *image);
	typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFEXTPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONPARAMETERFEXTPROC) (GLenum target
	GLenum pname, GLfloat params);	, GLenum pname, GLfloat params);
	typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONPARAMETERFVEXTPROC) (GLenum targe
	, GLenum pname, const GLfloat *params);	t, GLenum pname, const GLfloat *params);
	typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIEXTPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONPARAMETERIEXTPROC) (GLenum target
	GLenum pname, GLint params);	, GLenum pname, GLint params);
	typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target	typedef void (GLAPIENTRYP PFNGLCONVOLUTIONPARAMETERIVEXTPROC) (GLenum targe
	, GLenum pname, const GLint *params);	t, GLenum pname, const GLint *params);
	typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) (GLenum targe	typedef void (GLAPIENTRYP PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) (GLenum targ
	t, GLenum internalformat, GLint x, GLint y, GLsizei width);	et, GLenum internalformat, GLint x, GLint y, GLsizei width);
	typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) (GLenum targe	typedef void (GLAPIENTRYP PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) (GLenum targ
	t, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);	et, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
	typedef void (APIENTRY * PFNGLGETCONVOLUTIONFILTEREXTPROC) (GLenum target,	;
	GLenum format, GLenum type, GLvoid *image);	typedef void (GLAPIENTRYP PFNGLGETCONVOLUTIONFILTEREXTPROC) (GLenum target,
	typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) (GLenum tar	GLenum format, GLenum type, GLvoid *image);
	get, GLenum pname, GLfloat *params);	typedef void (GLAPIENTRYP PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) (GLenum ta
	typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) (GLenum tar	rget, GLenum pname, GLfloat *params);
	get, GLenum pname, GLint *params);	typedef void (GLAPIENTRYP PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) (GLenum ta
	typedef void (APIENTRY * PFNGLGETSEPARABLEFILTEREXTPROC) (GLenum target, GL	rget, GLenum pname, GLint *params);
	enum format, GLenum type, GLvoid row, GLvoid column, GLvoid *span);	typedef void (GLAPIENTRYP PFNGLGETSEPARABLEFILTEREXTPROC) (GLenum target, G
	typedef void (APIENTRY * PFNGLSEPARABLEFILTER2DEXTPROC) (GLenum target, GLe	Lenum format, GLenum type, GLvoid row, GLvoid column, GLvoid *span);
	num internalformat, GLsizei width, GLsizei height, GLenum format, GLenum ty	typedef void (GLAPIENTRYP PFNGLSEPARABLEFILTER2DEXTPROC) (GLenum target, GL
	pe, const GLvoid row, const GLvoid column);	enum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum t
		ype, const GLvoid row, const GLvoid column);
	#endif	#endif

	#ifndef GL_EXT_color_matrix	#ifndef GL_EXT_color_matrix
	#define GL_EXT_color_matrix 1	#define GL_EXT_color_matrix 1
	#endif	#endif

	#ifndef GL_SGI_color_table	#ifndef GL_SGI_color_table
	#define GL_SGI_color_table 1	#define GL_SGI_color_table 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glColorTableSGI (GLenum, GLenum, GLsizei, GLenum, GLen	GLAPI void GLAPIENTRY glColorTableSGI (GLenum, GLenum, GLsizei, GLenum, GLe
	um, const GLvoid *);	num, const GLvoid *);
	extern void APIENTRY glColorTableParameterfvSGI (GLenum, GLenum, const GLfl	GLAPI void GLAPIENTRY glColorTableParameterfvSGI (GLenum, GLenum, const GLf
	oat *);	loat *);
	extern void APIENTRY glColorTableParameterivSGI (GLenum, GLenum, const GLin	GLAPI void GLAPIENTRY glColorTableParameterivSGI (GLenum, GLenum, const GLi
	t *);	nt *);
	extern void APIENTRY glCopyColorTableSGI (GLenum, GLenum, GLint, GLint, GLs	GLAPI void GLAPIENTRY glCopyColorTableSGI (GLenum, GLenum, GLint, GLint, GL
	izei);	sizei);
	extern void APIENTRY glGetColorTableSGI (GLenum, GLenum, GLenum, GLvoid *);	GLAPI void GLAPIENTRY glGetColorTableSGI (GLenum, GLenum, GLenum, GLvoid *)
	extern void APIENTRY glGetColorTableParameterfvSGI (GLenum, GLenum, GLfloat	;
	*);	GLAPI void GLAPIENTRY glGetColorTableParameterfvSGI (GLenum, GLenum, GLfloa
	extern void APIENTRY glGetColorTableParameterivSGI (GLenum, GLenum, GLint *	t *);
	);	GLAPI void GLAPIENTRY glGetColorTableParameterivSGI (GLenum, GLenum, GLint
		*);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum int	typedef void (GLAPIENTRYP PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum in
	ernalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table	ternalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *tabl
	);	e);
	typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target
	GLenum pname, const GLfloat *params);	, GLenum pname, const GLfloat *params);
	typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target,	typedef void (GLAPIENTRYP PFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target
	GLenum pname, const GLint *params);	, GLenum pname, const GLint *params);
	typedef void (APIENTRY * PFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum	typedef void (GLAPIENTRYP PFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenu
	internalformat, GLint x, GLint y, GLsizei width);	m internalformat, GLint x, GLint y, GLsizei width);
	typedef void (APIENTRY * PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum	typedef void (GLAPIENTRYP PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum
	format, GLenum type, GLvoid *table);	format, GLenum type, GLvoid *table);
	typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum targ	typedef void (GLAPIENTRYP PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum tar
	et, GLenum pname, GLfloat *params);	get, GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum targ	typedef void (GLAPIENTRYP PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum tar
	et, GLenum pname, GLint *params);	get, GLenum pname, GLint *params);
	#endif	#endif

	#ifndef GL_SGIX_pixel_texture	#ifndef GL_SGIX_pixel_texture
	#define GL_SGIX_pixel_texture 1	#define GL_SGIX_pixel_texture 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glPixelTexGenSGIX (GLenum);	GLAPI void GLAPIENTRY glPixelTexGenSGIX (GLenum);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLPIXELTEXGENSGIXPROC) (GLenum mode);	typedef void (GLAPIENTRYP PFNGLPIXELTEXGENSGIXPROC) (GLenum mode);
	#endif	#endif

	#ifndef GL_SGIS_pixel_texture	#ifndef GL_SGIS_pixel_texture
	#define GL_SGIS_pixel_texture 1	#define GL_SGIS_pixel_texture 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glPixelTexGenParameteriSGIS (GLenum, GLint);	GLAPI void GLAPIENTRY glPixelTexGenParameteriSGIS (GLenum, GLint);
	extern void APIENTRY glPixelTexGenParameterivSGIS (GLenum, const GLint *);	GLAPI void GLAPIENTRY glPixelTexGenParameterivSGIS (GLenum, const GLint *);
	extern void APIENTRY glPixelTexGenParameterfSGIS (GLenum, GLfloat);	GLAPI void GLAPIENTRY glPixelTexGenParameterfSGIS (GLenum, GLfloat);
	extern void APIENTRY glPixelTexGenParameterfvSGIS (GLenum, const GLfloat *)	GLAPI void GLAPIENTRY glPixelTexGenParameterfvSGIS (GLenum, const GLfloat *
	;	);
	extern void APIENTRY glGetPixelTexGenParameterivSGIS (GLenum, GLint *);	GLAPI void GLAPIENTRY glGetPixelTexGenParameterivSGIS (GLenum, GLint *);
	extern void APIENTRY glGetPixelTexGenParameterfvSGIS (GLenum, GLfloat *);	GLAPI void GLAPIENTRY glGetPixelTexGenParameterfvSGIS (GLenum, GLfloat *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERISGISPROC) (GLenum pname,	typedef void (GLAPIENTRYP PFNGLPIXELTEXGENPARAMETERISGISPROC) (GLenum pname
	GLint param);	, GLint param);
	typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname	typedef void (GLAPIENTRYP PFNGLPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pnam
	, const GLint *params);	e, const GLint *params);
	typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERFSGISPROC) (GLenum pname,	typedef void (GLAPIENTRYP PFNGLPIXELTEXGENPARAMETERFSGISPROC) (GLenum pname
	GLfloat param);	, GLfloat param);
	typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname	typedef void (GLAPIENTRYP PFNGLPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pnam
	, const GLfloat *params);	e, const GLfloat *params);
	typedef void (APIENTRY * PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pn	typedef void (GLAPIENTRYP PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC) (GLenum p
	ame, GLint *params);	name, GLint *params);
	typedef void (APIENTRY * PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pn	typedef void (GLAPIENTRYP PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC) (GLenum p
	ame, GLfloat *params);	name, GLfloat *params);
	#endif	#endif

	#ifndef GL_SGIS_texture4D	#ifndef GL_SGIS_texture4D
	#define GL_SGIS_texture4D 1	#define GL_SGIS_texture4D 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glTexImage4DSGIS (GLenum, GLint, GLenum, GLsizei, GLsi	GLAPI void GLAPIENTRY glTexImage4DSGIS (GLenum, GLint, GLenum, GLsizei, GLs
	zei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);	izei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
	extern void APIENTRY glTexSubImage4DSGIS (GLenum, GLint, GLint, GLint, GLin	GLAPI void GLAPIENTRY glTexSubImage4DSGIS (GLenum, GLint, GLint, GLint, GLi
	t, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid	nt, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid
	*);	*);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint lev	typedef void (GLAPIENTRYP PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint le
	el, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GL	vel, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, G
	sizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixel	Lsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixe
	s);	ls);
	typedef void (APIENTRY * PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint	typedef void (GLAPIENTRYP PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint
	level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei	level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei
	width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum	width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenu
	type, const GLvoid *pixels);	m type, const GLvoid *pixels);
	#endif	#endif

	#ifndef GL_SGI_texture_color_table	#ifndef GL_SGI_texture_color_table
	#define GL_SGI_texture_color_table 1	#define GL_SGI_texture_color_table 1
	#endif	#endif

	#ifndef GL_EXT_cmyka	#ifndef GL_EXT_cmyka
	#define GL_EXT_cmyka 1	#define GL_EXT_cmyka 1
	#endif	#endif

	#ifndef GL_EXT_texture_object	#ifndef GL_EXT_texture_object
	#define GL_EXT_texture_object 1	#define GL_EXT_texture_object 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern GLboolean APIENTRY glAreTexturesResidentEXT (GLsizei, const GLuint *	GLAPI GLboolean GLAPIENTRY glAreTexturesResidentEXT (GLsizei, const GLuint
	, GLboolean *);	, GLboolean );
	extern void APIENTRY glBindTextureEXT (GLenum, GLuint);	GLAPI void GLAPIENTRY glBindTextureEXT (GLenum, GLuint);
	extern void APIENTRY glDeleteTexturesEXT (GLsizei, const GLuint *);	GLAPI void GLAPIENTRY glDeleteTexturesEXT (GLsizei, const GLuint *);
	extern void APIENTRY glGenTexturesEXT (GLsizei, GLuint *);	GLAPI void GLAPIENTRY glGenTexturesEXT (GLsizei, GLuint *);
	extern GLboolean APIENTRY glIsTextureEXT (GLuint);	GLAPI GLboolean GLAPIENTRY glIsTextureEXT (GLuint);
	extern void APIENTRY glPrioritizeTexturesEXT (GLsizei, const GLuint *, cons	GLAPI void GLAPIENTRY glPrioritizeTexturesEXT (GLsizei, const GLuint *, con
	t GLclampf *);	st GLclampf *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef GLboolean (APIENTRY * PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n,	typedef GLboolean (GLAPIENTRYP PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n,
	const GLuint textures, GLboolean residences);	const GLuint textures, GLboolean residences);
	typedef void (APIENTRY * PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint te	typedef void (GLAPIENTRYP PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint t
	xture);	exture);
	typedef void (APIENTRY * PFNGLDELETETEXTURESEXTPROC) (GLsizei n, const GLui	typedef void (GLAPIENTRYP PFNGLDELETETEXTURESEXTPROC) (GLsizei n, const GLu
	nt *textures);	int *textures);
	typedef void (APIENTRY * PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint *textu	typedef void (GLAPIENTRYP PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint *text
	res);	ures);
	typedef GLboolean (APIENTRY * PFNGLISTEXTUREEXTPROC) (GLuint texture);	typedef GLboolean (GLAPIENTRYP PFNGLISTEXTUREEXTPROC) (GLuint texture);
	typedef void (APIENTRY * PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, const	typedef void (GLAPIENTRYP PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, const
	GLuint textures, const GLclampf priorities);	GLuint textures, const GLclampf priorities);
	#endif	#endif

	#ifndef GL_SGIS_detail_texture	#ifndef GL_SGIS_detail_texture
	#define GL_SGIS_detail_texture 1	#define GL_SGIS_detail_texture 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glDetailTexFuncSGIS (GLenum, GLsizei, const GLfloat *)	GLAPI void GLAPIENTRY glDetailTexFuncSGIS (GLenum, GLsizei, const GLfloat *
	;	);
	extern void APIENTRY glGetDetailTexFuncSGIS (GLenum, GLfloat *);	GLAPI void GLAPIENTRY glGetDetailTexFuncSGIS (GLenum, GLfloat *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsize	typedef void (GLAPIENTRYP PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsiz
	i n, const GLfloat *points);	ei n, const GLfloat *points);
	typedef void (APIENTRY * PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GLf	typedef void (GLAPIENTRYP PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GL
	loat *points);	float *points);
	#endif	#endif

	#ifndef GL_SGIS_sharpen_texture	#ifndef GL_SGIS_sharpen_texture
	#define GL_SGIS_sharpen_texture 1	#define GL_SGIS_sharpen_texture 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glSharpenTexFuncSGIS (GLenum, GLsizei, const GLfloat *	GLAPI void GLAPIENTRY glSharpenTexFuncSGIS (GLenum, GLsizei, const GLfloat
	);	*);
	extern void APIENTRY glGetSharpenTexFuncSGIS (GLenum, GLfloat *);	GLAPI void GLAPIENTRY glGetSharpenTexFuncSGIS (GLenum, GLfloat *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsiz	typedef void (GLAPIENTRYP PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsi
	ei n, const GLfloat *points);	zei n, const GLfloat *points);
	typedef void (APIENTRY * PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, GL	typedef void (GLAPIENTRYP PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, G
	float *points);	Lfloat *points);
	#endif	#endif

	#ifndef GL_EXT_packed_pixels	#ifndef GL_EXT_packed_pixels
	#define GL_EXT_packed_pixels 1	#define GL_EXT_packed_pixels 1
	#endif	#endif

	#ifndef GL_SGIS_texture_lod	#ifndef GL_SGIS_texture_lod
	#define GL_SGIS_texture_lod 1	#define GL_SGIS_texture_lod 1
	#endif	#endif

	#ifndef GL_SGIS_multisample	#ifndef GL_SGIS_multisample
	#define GL_SGIS_multisample 1	#define GL_SGIS_multisample 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glSampleMaskSGIS (GLclampf, GLboolean);	GLAPI void GLAPIENTRY glSampleMaskSGIS (GLclampf, GLboolean);
	extern void APIENTRY glSamplePatternSGIS (GLenum);	GLAPI void GLAPIENTRY glSamplePatternSGIS (GLenum);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboolea	typedef void (GLAPIENTRYP PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboole
	n invert);	an invert);
	typedef void (APIENTRY * PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern);	typedef void (GLAPIENTRYP PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern);
	#endif	#endif

	#ifndef GL_EXT_rescale_normal	#ifndef GL_EXT_rescale_normal
	#define GL_EXT_rescale_normal 1	#define GL_EXT_rescale_normal 1
	#endif	#endif

	#ifndef GL_EXT_vertex_array	#ifndef GL_EXT_vertex_array
	#define GL_EXT_vertex_array 1	#define GL_EXT_vertex_array 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glArrayElementEXT (GLint);	GLAPI void GLAPIENTRY glArrayElementEXT (GLint);
	extern void APIENTRY glColorPointerEXT (GLint, GLenum, GLsizei, GLsizei, co	GLAPI void GLAPIENTRY glColorPointerEXT (GLint, GLenum, GLsizei, GLsizei, c
	nst GLvoid *);	onst GLvoid *);
	extern void APIENTRY glDrawArraysEXT (GLenum, GLint, GLsizei);	GLAPI void GLAPIENTRY glDrawArraysEXT (GLenum, GLint, GLsizei);
	extern void APIENTRY glEdgeFlagPointerEXT (GLsizei, GLsizei, const GLboolea	GLAPI void GLAPIENTRY glEdgeFlagPointerEXT (GLsizei, GLsizei, const GLboole
	n *);	an *);
	extern void APIENTRY glGetPointervEXT (GLenum, GLvoid* *);	GLAPI void GLAPIENTRY glGetPointervEXT (GLenum, GLvoid* *);
	extern void APIENTRY glIndexPointerEXT (GLenum, GLsizei, GLsizei, const GLv	GLAPI void GLAPIENTRY glIndexPointerEXT (GLenum, GLsizei, GLsizei, const GL
	oid *);	void *);
	extern void APIENTRY glNormalPointerEXT (GLenum, GLsizei, GLsizei, const GL	GLAPI void GLAPIENTRY glNormalPointerEXT (GLenum, GLsizei, GLsizei, const G
	void *);	Lvoid *);
	extern void APIENTRY glTexCoordPointerEXT (GLint, GLenum, GLsizei, GLsizei,	GLAPI void GLAPIENTRY glTexCoordPointerEXT (GLint, GLenum, GLsizei, GLsizei
	const GLvoid *);	, const GLvoid *);
	extern void APIENTRY glVertexPointerEXT (GLint, GLenum, GLsizei, GLsizei, c	GLAPI void GLAPIENTRY glVertexPointerEXT (GLint, GLenum, GLsizei, GLsizei,
	onst GLvoid *);	const GLvoid *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLARRAYELEMENTEXTPROC) (GLint i);	typedef void (GLAPIENTRYP PFNGLARRAYELEMENTEXTPROC) (GLint i);
	typedef void (APIENTRY * PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type	typedef void (GLAPIENTRYP PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum typ
	, GLsizei stride, GLsizei count, const GLvoid *pointer);	e, GLsizei stride, GLsizei count, const GLvoid *pointer);
	typedef void (APIENTRY * PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first,	typedef void (GLAPIENTRYP PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first
	GLsizei count);	, GLsizei count);
	typedef void (APIENTRY * PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsi	typedef void (GLAPIENTRYP PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLs
	zei count, const GLboolean *pointer);	izei count, const GLboolean *pointer);
	typedef void (APIENTRY * PFNGLGETPOINTERVEXTPROC) (GLenum pname, GLvoid* *p	typedef void (GLAPIENTRYP PFNGLGETPOINTERVEXTPROC) (GLenum pname, GLvoid* *
	arams);	params);
	typedef void (APIENTRY * PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei st	typedef void (GLAPIENTRYP PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei s
	ride, GLsizei count, const GLvoid *pointer);	tride, GLsizei count, const GLvoid *pointer);
	typedef void (APIENTRY * PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei s	typedef void (GLAPIENTRYP PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei
	tride, GLsizei count, const GLvoid *pointer);	stride, GLsizei count, const GLvoid *pointer);
	typedef void (APIENTRY * PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum t	typedef void (GLAPIENTRYP PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum
	ype, GLsizei stride, GLsizei count, const GLvoid *pointer);	type, GLsizei stride, GLsizei count, const GLvoid *pointer);
	typedef void (APIENTRY * PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum typ	typedef void (GLAPIENTRYP PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum ty
	e, GLsizei stride, GLsizei count, const GLvoid *pointer);	pe, GLsizei stride, GLsizei count, const GLvoid *pointer);
	#endif	#endif

	#ifndef GL_EXT_misc_attribute	#ifndef GL_EXT_misc_attribute
	#define GL_EXT_misc_attribute 1	#define GL_EXT_misc_attribute 1
	#endif	#endif

	#ifndef GL_SGIS_generate_mipmap	#ifndef GL_SGIS_generate_mipmap
	#define GL_SGIS_generate_mipmap 1	#define GL_SGIS_generate_mipmap 1
	#endif	#endif


	skipping to change at line 1952	skipping to change at line 4798
	#define GL_SGIS_texture_edge_clamp 1	#define GL_SGIS_texture_edge_clamp 1
	#endif	#endif

	#ifndef GL_SGIS_texture_border_clamp	#ifndef GL_SGIS_texture_border_clamp
	#define GL_SGIS_texture_border_clamp 1	#define GL_SGIS_texture_border_clamp 1
	#endif	#endif

	#ifndef GL_EXT_blend_minmax	#ifndef GL_EXT_blend_minmax
	#define GL_EXT_blend_minmax 1	#define GL_EXT_blend_minmax 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glBlendEquationEXT (GLenum);	GLAPI void GLAPIENTRY glBlendEquationEXT (GLenum);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode);	typedef void (GLAPIENTRYP PFNGLBLENDEQUATIONEXTPROC) (GLenum mode);
	#endif	#endif

	#ifndef GL_EXT_blend_subtract	#ifndef GL_EXT_blend_subtract
	#define GL_EXT_blend_subtract 1	#define GL_EXT_blend_subtract 1
	#endif	#endif

	#ifndef GL_EXT_blend_logic_op	#ifndef GL_EXT_blend_logic_op
	#define GL_EXT_blend_logic_op 1	#define GL_EXT_blend_logic_op 1
	#endif	#endif


	skipping to change at line 1980	skipping to change at line 4826
	#define GL_SGIX_pixel_tiles 1	#define GL_SGIX_pixel_tiles 1
	#endif	#endif

	#ifndef GL_SGIX_texture_select	#ifndef GL_SGIX_texture_select
	#define GL_SGIX_texture_select 1	#define GL_SGIX_texture_select 1
	#endif	#endif

	#ifndef GL_SGIX_sprite	#ifndef GL_SGIX_sprite
	#define GL_SGIX_sprite 1	#define GL_SGIX_sprite 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glSpriteParameterfSGIX (GLenum, GLfloat);	GLAPI void GLAPIENTRY glSpriteParameterfSGIX (GLenum, GLfloat);
	extern void APIENTRY glSpriteParameterfvSGIX (GLenum, const GLfloat *);	GLAPI void GLAPIENTRY glSpriteParameterfvSGIX (GLenum, const GLfloat *);
	extern void APIENTRY glSpriteParameteriSGIX (GLenum, GLint);	GLAPI void GLAPIENTRY glSpriteParameteriSGIX (GLenum, GLint);
	extern void APIENTRY glSpriteParameterivSGIX (GLenum, const GLint *);	GLAPI void GLAPIENTRY glSpriteParameterivSGIX (GLenum, const GLint *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLfl	typedef void (GLAPIENTRYP PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLf
	oat param);	loat param);
	typedef void (APIENTRY * PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, con	typedef void (GLAPIENTRYP PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, co
	st GLfloat *params);	nst GLfloat *params);
	typedef void (APIENTRY * PFNGLSPRITEPARAMETERISGIXPROC) (GLenum pname, GLin	typedef void (GLAPIENTRYP PFNGLSPRITEPARAMETERISGIXPROC) (GLenum pname, GLi
	t param);	nt param);
	typedef void (APIENTRY * PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, con	typedef void (GLAPIENTRYP PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, co
	st GLint *params);	nst GLint *params);
	#endif	#endif

	#ifndef GL_SGIX_texture_multi_buffer	#ifndef GL_SGIX_texture_multi_buffer
	#define GL_SGIX_texture_multi_buffer 1	#define GL_SGIX_texture_multi_buffer 1
	#endif	#endif

	#ifndef GL_EXT_point_parameters	#ifndef GL_EXT_point_parameters
	#define GL_EXT_point_parameters 1	#define GL_EXT_point_parameters 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glPointParameterfEXT (GLenum, GLfloat);	GLAPI void GLAPIENTRY glPointParameterfEXT (GLenum, GLfloat);
	extern void APIENTRY glPointParameterfvEXT (GLenum, const GLfloat *);	GLAPI void GLAPIENTRY glPointParameterfvEXT (GLenum, const GLfloat *);
	extern void APIENTRY glPointParameterfSGIS (GLenum, GLfloat);
	extern void APIENTRY glPointParameterfvSGIS (GLenum, const GLfloat *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloa	typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLflo
	t param);	at param);
	typedef void (APIENTRY * PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, const	typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, cons
	GLfloat *params);	t GLfloat *params);
	typedef void (APIENTRY * PFNGLPOINTPARAMETERFSGISPROC) (GLenum pname, GLflo	#endif
	at param);
	typedef void (APIENTRY * PFNGLPOINTPARAMETERFVSGISPROC) (GLenum pname, cons	#ifndef GL_SGIS_point_parameters
	t GLfloat *params);	#define GL_SGIS_point_parameters 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glPointParameterfSGIS (GLenum, GLfloat);
		GLAPI void GLAPIENTRY glPointParameterfvSGIS (GLenum, const GLfloat *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERFSGISPROC) (GLenum pname, GLfl
		oat param);
		typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERFVSGISPROC) (GLenum pname, con
		st GLfloat *params);
	#endif	#endif

	#ifndef GL_SGIX_instruments	#ifndef GL_SGIX_instruments
	#define GL_SGIX_instruments 1	#define GL_SGIX_instruments 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern GLint APIENTRY glGetInstrumentsSGIX (void);	GLAPI GLint GLAPIENTRY glGetInstrumentsSGIX (void);
	extern void APIENTRY glInstrumentsBufferSGIX (GLsizei, GLint *);	GLAPI void GLAPIENTRY glInstrumentsBufferSGIX (GLsizei, GLint *);
	extern GLint APIENTRY glPollInstrumentsSGIX (GLint *);	GLAPI GLint GLAPIENTRY glPollInstrumentsSGIX (GLint *);
	extern void APIENTRY glReadInstrumentsSGIX (GLint);	GLAPI void GLAPIENTRY glReadInstrumentsSGIX (GLint);
	extern void APIENTRY glStartInstrumentsSGIX (void);	GLAPI void GLAPIENTRY glStartInstrumentsSGIX (void);
	extern void APIENTRY glStopInstrumentsSGIX (GLint);	GLAPI void GLAPIENTRY glStopInstrumentsSGIX (GLint);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef GLint (APIENTRY * PFNGLGETINSTRUMENTSSGIXPROC) (void);	typedef GLint (GLAPIENTRYP PFNGLGETINSTRUMENTSSGIXPROC) (void);
	typedef void (APIENTRY * PFNGLINSTRUMENTSBUFFERSGIXPROC) (GLsizei size, GLi	typedef void (GLAPIENTRYP PFNGLINSTRUMENTSBUFFERSGIXPROC) (GLsizei size, GL
	nt *buffer);	int *buffer);
	typedef GLint (APIENTRY * PFNGLPOLLINSTRUMENTSSGIXPROC) (GLint *marker_p);	typedef GLint (GLAPIENTRYP PFNGLPOLLINSTRUMENTSSGIXPROC) (GLint *marker_p);
	typedef void (APIENTRY * PFNGLREADINSTRUMENTSSGIXPROC) (GLint marker);	typedef void (GLAPIENTRYP PFNGLREADINSTRUMENTSSGIXPROC) (GLint marker);
	typedef void (APIENTRY * PFNGLSTARTINSTRUMENTSSGIXPROC) (void);	typedef void (GLAPIENTRYP PFNGLSTARTINSTRUMENTSSGIXPROC) (void);
	typedef void (APIENTRY * PFNGLSTOPINSTRUMENTSSGIXPROC) (GLint marker);	typedef void (GLAPIENTRYP PFNGLSTOPINSTRUMENTSSGIXPROC) (GLint marker);
	#endif	#endif

	#ifndef GL_SGIX_texture_scale_bias	#ifndef GL_SGIX_texture_scale_bias
	#define GL_SGIX_texture_scale_bias 1	#define GL_SGIX_texture_scale_bias 1
	#endif	#endif

	#ifndef GL_SGIX_framezoom	#ifndef GL_SGIX_framezoom
	#define GL_SGIX_framezoom 1	#define GL_SGIX_framezoom 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glFrameZoomSGIX (GLint);	GLAPI void GLAPIENTRY glFrameZoomSGIX (GLint);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLFRAMEZOOMSGIXPROC) (GLint factor);	typedef void (GLAPIENTRYP PFNGLFRAMEZOOMSGIXPROC) (GLint factor);
	#endif	#endif

	#ifndef GL_SGIX_tag_sample_buffer	#ifndef GL_SGIX_tag_sample_buffer
	#define GL_SGIX_tag_sample_buffer 1	#define GL_SGIX_tag_sample_buffer 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glTagSampleBufferSGIX (void);	GLAPI void GLAPIENTRY glTagSampleBufferSGIX (void);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void);	typedef void (GLAPIENTRYP PFNGLTAGSAMPLEBUFFERSGIXPROC) (void);
		#endif

		#ifndef GL_SGIX_polynomial_ffd
		#define GL_SGIX_polynomial_ffd 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glDeformationMap3dSGIX (GLenum, GLdouble, GLdouble, G
		Lint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, G
		Lint, const GLdouble *);
		GLAPI void GLAPIENTRY glDeformationMap3fSGIX (GLenum, GLfloat, GLfloat, GLi
		nt, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint,
		const GLfloat *);
		GLAPI void GLAPIENTRY glDeformSGIX (GLbitfield);
		GLAPI void GLAPIENTRY glLoadIdentityDeformationMapSGIX (GLbitfield);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLDEFORMATIONMAP3DSGIXPROC) (GLenum target, GL
		double u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble
		v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, G
		Lint worder, const GLdouble *points);
		typedef void (GLAPIENTRYP PFNGLDEFORMATIONMAP3FSGIXPROC) (GLenum target, GL
		float u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2,
		GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint w
		order, const GLfloat *points);
		typedef void (GLAPIENTRYP PFNGLDEFORMSGIXPROC) (GLbitfield mask);
		typedef void (GLAPIENTRYP PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC) (GLbitfi
		eld mask);
	#endif	#endif

	#ifndef GL_SGIX_reference_plane	#ifndef GL_SGIX_reference_plane
	#define GL_SGIX_reference_plane 1	#define GL_SGIX_reference_plane 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glReferencePlaneSGIX (const GLdouble *);	GLAPI void GLAPIENTRY glReferencePlaneSGIX (const GLdouble *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLREFERENCEPLANESGIXPROC) (const GLdouble *equa tion);	typedef void (GLAPIENTRYP PFNGLREFERENCEPLANESGIXPROC) (const GLdouble *equ ation);
	#endif	#endif

	#ifndef GL_SGIX_flush_raster	#ifndef GL_SGIX_flush_raster
	#define GL_SGIX_flush_raster 1	#define GL_SGIX_flush_raster 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glFlushRasterSGIX (void);	GLAPI void GLAPIENTRY glFlushRasterSGIX (void);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLFLUSHRASTERSGIXPROC) (void);	typedef void (GLAPIENTRYP PFNGLFLUSHRASTERSGIXPROC) (void);
	#endif	#endif

	#ifndef GL_SGIX_depth_texture	#ifndef GL_SGIX_depth_texture
	#define GL_SGIX_depth_texture 1	#define GL_SGIX_depth_texture 1
	#endif	#endif

	#ifndef GL_SGIS_fog_function	#ifndef GL_SGIS_fog_function
	#define GL_SGIS_fog_function 1	#define GL_SGIS_fog_function 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glFogFuncSGIS (GLsizei, const GLfloat *);	GLAPI void GLAPIENTRY glFogFuncSGIS (GLsizei, const GLfloat *);
	extern void APIENTRY glGetFogFuncSGIS (const GLfloat *);	GLAPI void GLAPIENTRY glGetFogFuncSGIS (GLfloat *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat *p	typedef void (GLAPIENTRYP PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat *
	oints);	points);
	typedef void (APIENTRY * PFNGLGETFOGFUNCSGISPROC) (const GLfloat *points);	typedef void (GLAPIENTRYP PFNGLGETFOGFUNCSGISPROC) (GLfloat *points);
	#endif	#endif

	#ifndef GL_SGIX_fog_offset	#ifndef GL_SGIX_fog_offset
	#define GL_SGIX_fog_offset 1	#define GL_SGIX_fog_offset 1
	#endif	#endif

	#ifndef GL_HP_image_transform	#ifndef GL_HP_image_transform
	#define GL_HP_image_transform 1	#define GL_HP_image_transform 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glImageTransformParameteriHP (GLenum, GLenum, GLint);	GLAPI void GLAPIENTRY glImageTransformParameteriHP (GLenum, GLenum, GLint);
	extern void APIENTRY glImageTransformParameterfHP (GLenum, GLenum, GLfloat)	GLAPI void GLAPIENTRY glImageTransformParameterfHP (GLenum, GLenum, GLfloat
	;	);
	extern void APIENTRY glImageTransformParameterivHP (GLenum, GLenum, const G	GLAPI void GLAPIENTRY glImageTransformParameterivHP (GLenum, GLenum, const
	Lint *);	GLint *);
	extern void APIENTRY glImageTransformParameterfvHP (GLenum, GLenum, const G	GLAPI void GLAPIENTRY glImageTransformParameterfvHP (GLenum, GLenum, const
	Lfloat *);	GLfloat *);
	extern void APIENTRY glGetImageTransformParameterivHP (GLenum, GLenum, GLin	GLAPI void GLAPIENTRY glGetImageTransformParameterivHP (GLenum, GLenum, GLi
	t *);	nt *);
	extern void APIENTRY glGetImageTransformParameterfvHP (GLenum, GLenum, GLfl	GLAPI void GLAPIENTRY glGetImageTransformParameterfvHP (GLenum, GLenum, GLf
	oat *);	loat *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum targe	typedef void (GLAPIENTRYP PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum targ
	t, GLenum pname, GLint param);	et, GLenum pname, GLint param);
	typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum targe	typedef void (GLAPIENTRYP PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum targ
	t, GLenum pname, GLfloat param);	et, GLenum pname, GLfloat param);
	typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum targ	typedef void (GLAPIENTRYP PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum tar
	et, GLenum pname, const GLint *params);	get, GLenum pname, const GLint *params);
	typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum targ	typedef void (GLAPIENTRYP PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum tar
	et, GLenum pname, const GLfloat *params);	get, GLenum pname, const GLfloat *params);
	typedef void (APIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum t	typedef void (GLAPIENTRYP PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum
	arget, GLenum pname, GLint *params);	target, GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum t	typedef void (GLAPIENTRYP PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum
	arget, GLenum pname, GLfloat *params);	target, GLenum pname, GLfloat *params);
	#endif	#endif

	#ifndef GL_HP_convolution_border_modes	#ifndef GL_HP_convolution_border_modes
	#define GL_HP_convolution_border_modes 1	#define GL_HP_convolution_border_modes 1
	#endif	#endif

	#ifndef GL_SGIX_texture_add_env	#ifndef GL_SGIX_texture_add_env
	#define GL_SGIX_texture_add_env 1	#define GL_SGIX_texture_add_env 1
	#endif	#endif

	#ifndef GL_EXT_color_subtable	#ifndef GL_EXT_color_subtable
	#define GL_EXT_color_subtable 1	#define GL_EXT_color_subtable 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum,	GLAPI void GLAPIENTRY glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum,
	GLenum, const GLvoid *);	GLenum, const GLvoid *);
	extern void APIENTRY glCopyColorSubTableEXT (GLenum, GLsizei, GLint, GLint,	GLAPI void GLAPIENTRY glCopyColorSubTableEXT (GLenum, GLsizei, GLint, GLint
	GLsizei);	, GLsizei);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei	typedef void (GLAPIENTRYP PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsize
	start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);	i start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
	typedef void (APIENTRY * PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GLs	typedef void (GLAPIENTRYP PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GL
	izei start, GLint x, GLint y, GLsizei width);	sizei start, GLint x, GLint y, GLsizei width);
	#endif	#endif

	#ifndef GL_PGI_vertex_hints	#ifndef GL_PGI_vertex_hints
	#define GL_PGI_vertex_hints 1	#define GL_PGI_vertex_hints 1
	#endif	#endif

	#ifndef GL_PGI_misc_hints	#ifndef GL_PGI_misc_hints
	#define GL_PGI_misc_hints 1	#define GL_PGI_misc_hints 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glHintPGI (GLenum, GLint);	GLAPI void GLAPIENTRY glHintPGI (GLenum, GLint);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLHINTPGIPROC) (GLenum target, GLint mode);	typedef void (GLAPIENTRYP PFNGLHINTPGIPROC) (GLenum target, GLint mode);
	#endif	#endif

	#ifndef GL_EXT_paletted_texture	#ifndef GL_EXT_paletted_texture
	#define GL_EXT_paletted_texture 1	#define GL_EXT_paletted_texture 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLen	GLAPI void GLAPIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLe
	um, const GLvoid *);	num, const GLvoid *);
	extern void APIENTRY glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *);	GLAPI void GLAPIENTRY glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *)
	extern void APIENTRY glGetColorTableParameterivEXT (GLenum, GLenum, GLint *	;
	);	GLAPI void GLAPIENTRY glGetColorTableParameterivEXT (GLenum, GLenum, GLint
	extern void APIENTRY glGetColorTableParameterfvEXT (GLenum, GLenum, GLfloat	*);
	*);	GLAPI void GLAPIENTRY glGetColorTableParameterfvEXT (GLenum, GLenum, GLfloa
		t *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum int	typedef void (GLAPIENTRYP PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum in
	ernalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table	ternalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *tabl
	);	e);
	typedef void (APIENTRY * PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum	typedef void (GLAPIENTRYP PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum
	format, GLenum type, GLvoid *data);	format, GLenum type, GLvoid *data);
	typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum targ	typedef void (GLAPIENTRYP PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum tar
	et, GLenum pname, GLint *params);	get, GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum targ	typedef void (GLAPIENTRYP PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum tar
	et, GLenum pname, GLfloat *params);	get, GLenum pname, GLfloat *params);
	#endif	#endif

	#ifndef GL_EXT_clip_volume_hint	#ifndef GL_EXT_clip_volume_hint
	#define GL_EXT_clip_volume_hint 1	#define GL_EXT_clip_volume_hint 1
	#endif	#endif

	#ifndef GL_SGIX_list_priority	#ifndef GL_SGIX_list_priority
	#define GL_SGIX_list_priority 1	#define GL_SGIX_list_priority 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glGetListParameterfvSGIX (GLuint, GLenum, GLfloat *);	GLAPI void GLAPIENTRY glGetListParameterfvSGIX (GLuint, GLenum, GLfloat *);
	extern void APIENTRY glGetListParameterivSGIX (GLuint, GLenum, GLint *);	GLAPI void GLAPIENTRY glGetListParameterivSGIX (GLuint, GLenum, GLint *);
	extern void APIENTRY glListParameterfSGIX (GLuint, GLenum, GLfloat);	GLAPI void GLAPIENTRY glListParameterfSGIX (GLuint, GLenum, GLfloat);
	extern void APIENTRY glListParameterfvSGIX (GLuint, GLenum, const GLfloat *	GLAPI void GLAPIENTRY glListParameterfvSGIX (GLuint, GLenum, const GLfloat
	);	*);
	extern void APIENTRY glListParameteriSGIX (GLuint, GLenum, GLint);	GLAPI void GLAPIENTRY glListParameteriSGIX (GLuint, GLenum, GLint);
	extern void APIENTRY glListParameterivSGIX (GLuint, GLenum, const GLint *);	GLAPI void GLAPIENTRY glListParameterivSGIX (GLuint, GLenum, const GLint *)
		;
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLGETLISTPARAMETERFVSGIXPROC) (GLuint list, GLe	typedef void (GLAPIENTRYP PFNGLGETLISTPARAMETERFVSGIXPROC) (GLuint list, GL
	num pname, GLfloat *params);	enum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETLISTPARAMETERIVSGIXPROC) (GLuint list, GLe	typedef void (GLAPIENTRYP PFNGLGETLISTPARAMETERIVSGIXPROC) (GLuint list, GL
	num pname, GLint *params);	enum pname, GLint *params);
	typedef void (APIENTRY * PFNGLLISTPARAMETERFSGIXPROC) (GLuint list, GLenum	typedef void (GLAPIENTRYP PFNGLLISTPARAMETERFSGIXPROC) (GLuint list, GLenum
	pname, GLfloat param);	pname, GLfloat param);
	typedef void (APIENTRY * PFNGLLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum	typedef void (GLAPIENTRYP PFNGLLISTPARAMETERFVSGIXPROC) (GLuint list, GLenu
	pname, const GLfloat *params);	m pname, const GLfloat *params);
	typedef void (APIENTRY * PFNGLLISTPARAMETERISGIXPROC) (GLuint list, GLenum	typedef void (GLAPIENTRYP PFNGLLISTPARAMETERISGIXPROC) (GLuint list, GLenum
	pname, GLint param);	pname, GLint param);
	typedef void (APIENTRY * PFNGLLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum	typedef void (GLAPIENTRYP PFNGLLISTPARAMETERIVSGIXPROC) (GLuint list, GLenu
	pname, const GLint *params);	m pname, const GLint *params);
	#endif	#endif

	#ifndef GL_SGIX_ir_instrument1	#ifndef GL_SGIX_ir_instrument1
	#define GL_SGIX_ir_instrument1 1	#define GL_SGIX_ir_instrument1 1
	#endif	#endif

	#ifndef GL_SGIX_calligraphic_fragment	#ifndef GL_SGIX_calligraphic_fragment
	#define GL_SGIX_calligraphic_fragment 1	#define GL_SGIX_calligraphic_fragment 1
	#endif	#endif


	skipping to change at line 2188	skipping to change at line 5054
	#define GL_SGIX_shadow_ambient 1	#define GL_SGIX_shadow_ambient 1
	#endif	#endif

	#ifndef GL_EXT_index_texture	#ifndef GL_EXT_index_texture
	#define GL_EXT_index_texture 1	#define GL_EXT_index_texture 1
	#endif	#endif

	#ifndef GL_EXT_index_material	#ifndef GL_EXT_index_material
	#define GL_EXT_index_material 1	#define GL_EXT_index_material 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glIndexMaterialEXT (GLenum, GLenum);	GLAPI void GLAPIENTRY glIndexMaterialEXT (GLenum, GLenum);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mo de);	typedef void (GLAPIENTRYP PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum m ode);
	#endif	#endif

	#ifndef GL_EXT_index_func	#ifndef GL_EXT_index_func
	#define GL_EXT_index_func 1	#define GL_EXT_index_func 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glIndexFuncEXT (GLenum, GLclampf);	GLAPI void GLAPIENTRY glIndexFuncEXT (GLenum, GLclampf);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLINDEXFUNCEXTPROC) (GLenum func, GLclampf ref) ;	typedef void (GLAPIENTRYP PFNGLINDEXFUNCEXTPROC) (GLenum func, GLclampf ref );
	#endif	#endif

	#ifndef GL_EXT_index_array_formats	#ifndef GL_EXT_index_array_formats
	#define GL_EXT_index_array_formats 1	#define GL_EXT_index_array_formats 1
	#endif	#endif

	#ifndef GL_EXT_compiled_vertex_array	#ifndef GL_EXT_compiled_vertex_array
	#define GL_EXT_compiled_vertex_array 1	#define GL_EXT_compiled_vertex_array 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glLockArraysEXT (GLint, GLsizei);	GLAPI void GLAPIENTRY glLockArraysEXT (GLint, GLsizei);
	extern void APIENTRY glUnlockArraysEXT (void);	GLAPI void GLAPIENTRY glUnlockArraysEXT (void);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei coun	typedef void (GLAPIENTRYP PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei cou
	t);	nt);
	typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);	typedef void (GLAPIENTRYP PFNGLUNLOCKARRAYSEXTPROC) (void);
	#endif	#endif

	#ifndef GL_EXT_cull_vertex	#ifndef GL_EXT_cull_vertex
	#define GL_EXT_cull_vertex 1	#define GL_EXT_cull_vertex 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glCullParameterdvEXT (GLenum, GLdouble *);	GLAPI void GLAPIENTRY glCullParameterdvEXT (GLenum, GLdouble *);
	extern void APIENTRY glCullParameterfvEXT (GLenum, GLfloat *);	GLAPI void GLAPIENTRY glCullParameterfvEXT (GLenum, GLfloat *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdoub	typedef void (GLAPIENTRYP PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdou
	le *params);	ble *params);
	typedef void (APIENTRY * PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloa	typedef void (GLAPIENTRYP PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLflo
	t *params);	at *params);
	#endif	#endif

	#ifndef GL_SGIX_ycrcb	#ifndef GL_SGIX_ycrcb
	#define GL_SGIX_ycrcb 1	#define GL_SGIX_ycrcb 1
	#endif	#endif

	#ifndef GL_SGIX_fragment_lighting	#ifndef GL_SGIX_fragment_lighting
	#define GL_SGIX_fragment_lighting 1	#define GL_SGIX_fragment_lighting 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glFragmentColorMaterialSGIX (GLenum, GLenum);	GLAPI void GLAPIENTRY glFragmentColorMaterialSGIX (GLenum, GLenum);
	extern void APIENTRY glFragmentLightfSGIX (GLenum, GLenum, GLfloat);	GLAPI void GLAPIENTRY glFragmentLightfSGIX (GLenum, GLenum, GLfloat);
	extern void APIENTRY glFragmentLightfvSGIX (GLenum, GLenum, const GLfloat *	GLAPI void GLAPIENTRY glFragmentLightfvSGIX (GLenum, GLenum, const GLfloat
	);	*);
	extern void APIENTRY glFragmentLightiSGIX (GLenum, GLenum, GLint);	GLAPI void GLAPIENTRY glFragmentLightiSGIX (GLenum, GLenum, GLint);
	extern void APIENTRY glFragmentLightivSGIX (GLenum, GLenum, const GLint *);	GLAPI void GLAPIENTRY glFragmentLightivSGIX (GLenum, GLenum, const GLint *)
	extern void APIENTRY glFragmentLightModelfSGIX (GLenum, GLfloat);	;
	extern void APIENTRY glFragmentLightModelfvSGIX (GLenum, const GLfloat *);	GLAPI void GLAPIENTRY glFragmentLightModelfSGIX (GLenum, GLfloat);
	extern void APIENTRY glFragmentLightModeliSGIX (GLenum, GLint);	GLAPI void GLAPIENTRY glFragmentLightModelfvSGIX (GLenum, const GLfloat *);
	extern void APIENTRY glFragmentLightModelivSGIX (GLenum, const GLint *);	GLAPI void GLAPIENTRY glFragmentLightModeliSGIX (GLenum, GLint);
	extern void APIENTRY glFragmentMaterialfSGIX (GLenum, GLenum, GLfloat);	GLAPI void GLAPIENTRY glFragmentLightModelivSGIX (GLenum, const GLint *);
	extern void APIENTRY glFragmentMaterialfvSGIX (GLenum, GLenum, const GLfloa	GLAPI void GLAPIENTRY glFragmentMaterialfSGIX (GLenum, GLenum, GLfloat);
	t *);	GLAPI void GLAPIENTRY glFragmentMaterialfvSGIX (GLenum, GLenum, const GLflo
	extern void APIENTRY glFragmentMaterialiSGIX (GLenum, GLenum, GLint);	at *);
	extern void APIENTRY glFragmentMaterialivSGIX (GLenum, GLenum, const GLint	GLAPI void GLAPIENTRY glFragmentMaterialiSGIX (GLenum, GLenum, GLint);
	*);	GLAPI void GLAPIENTRY glFragmentMaterialivSGIX (GLenum, GLenum, const GLint
	extern void APIENTRY glGetFragmentLightfvSGIX (GLenum, GLenum, GLfloat *);	*);
	extern void APIENTRY glGetFragmentLightivSGIX (GLenum, GLenum, GLint *);	GLAPI void GLAPIENTRY glGetFragmentLightfvSGIX (GLenum, GLenum, GLfloat *);
	extern void APIENTRY glGetFragmentMaterialfvSGIX (GLenum, GLenum, GLfloat *	GLAPI void GLAPIENTRY glGetFragmentLightivSGIX (GLenum, GLenum, GLint *);
	);	GLAPI void GLAPIENTRY glGetFragmentMaterialfvSGIX (GLenum, GLenum, GLfloat
	extern void APIENTRY glGetFragmentMaterialivSGIX (GLenum, GLenum, GLint *);	*);
	extern void APIENTRY glLightEnviSGIX (GLenum, GLint);	GLAPI void GLAPIENTRY glGetFragmentMaterialivSGIX (GLenum, GLenum, GLint *)
		;
		GLAPI void GLAPIENTRY glLightEnviSGIX (GLenum, GLint);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face,	typedef void (GLAPIENTRYP PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face,
	GLenum mode);	GLenum mode);
	typedef void (APIENTRY * PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenum	typedef void (GLAPIENTRYP PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenu
	pname, GLfloat param);	m pname, GLfloat param);
	typedef void (APIENTRY * PFNGLFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenu	typedef void (GLAPIENTRYP PFNGLFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLen
	m pname, const GLfloat *params);	um pname, const GLfloat *params);
	typedef void (APIENTRY * PFNGLFRAGMENTLIGHTISGIXPROC) (GLenum light, GLenum	typedef void (GLAPIENTRYP PFNGLFRAGMENTLIGHTISGIXPROC) (GLenum light, GLenu
	pname, GLint param);	m pname, GLint param);
	typedef void (APIENTRY * PFNGLFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenu	typedef void (GLAPIENTRYP PFNGLFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLen
	m pname, const GLint *params);	um pname, const GLint *params);
	typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELFSGIXPROC) (GLenum pname, G	typedef void (GLAPIENTRYP PFNGLFRAGMENTLIGHTMODELFSGIXPROC) (GLenum pname,
	Lfloat param);	GLfloat param);
	typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) (GLenum pname,	typedef void (GLAPIENTRYP PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) (GLenum pname,
	const GLfloat *params);	const GLfloat *params);
	typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELISGIXPROC) (GLenum pname, G	typedef void (GLAPIENTRYP PFNGLFRAGMENTLIGHTMODELISGIXPROC) (GLenum pname,
	Lint param);	GLint param);
	typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) (GLenum pname,	typedef void (GLAPIENTRYP PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) (GLenum pname,
	const GLint *params);	const GLint *params);
	typedef void (APIENTRY * PFNGLFRAGMENTMATERIALFSGIXPROC) (GLenum face, GLen	typedef void (GLAPIENTRYP PFNGLFRAGMENTMATERIALFSGIXPROC) (GLenum face, GLe
	um pname, GLfloat param);	num pname, GLfloat param);
	typedef void (APIENTRY * PFNGLFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLe	typedef void (GLAPIENTRYP PFNGLFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GL
	num pname, const GLfloat *params);	enum pname, const GLfloat *params);
	typedef void (APIENTRY * PFNGLFRAGMENTMATERIALISGIXPROC) (GLenum face, GLen	typedef void (GLAPIENTRYP PFNGLFRAGMENTMATERIALISGIXPROC) (GLenum face, GLe
	um pname, GLint param);	num pname, GLint param);
	typedef void (APIENTRY * PFNGLFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLe	typedef void (GLAPIENTRYP PFNGLFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GL
	num pname, const GLint *params);	enum pname, const GLint *params);
	typedef void (APIENTRY * PFNGLGETFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GL	typedef void (GLAPIENTRYP PFNGLGETFRAGMENTLIGHTFVSGIXPROC) (GLenum light, G
	enum pname, GLfloat *params);	Lenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GL	typedef void (GLAPIENTRYP PFNGLGETFRAGMENTLIGHTIVSGIXPROC) (GLenum light, G
	enum pname, GLint *params);	Lenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLGETFRAGMENTMATERIALFVSGIXPROC) (GLenum face,	typedef void (GLAPIENTRYP PFNGLGETFRAGMENTMATERIALFVSGIXPROC) (GLenum face,
	GLenum pname, GLfloat *params);	GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face,	typedef void (GLAPIENTRYP PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face,
	GLenum pname, GLint *params);	GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLLIGHTENVISGIXPROC) (GLenum pname, GLint param	typedef void (GLAPIENTRYP PFNGLLIGHTENVISGIXPROC) (GLenum pname, GLint para
	);	m);
	#endif	#endif

	#ifndef GL_IBM_rasterpos_clip	#ifndef GL_IBM_rasterpos_clip
	#define GL_IBM_rasterpos_clip 1	#define GL_IBM_rasterpos_clip 1
	#endif	#endif

	#ifndef GL_HP_texture_lighting	#ifndef GL_HP_texture_lighting
	#define GL_HP_texture_lighting 1	#define GL_HP_texture_lighting 1
	#endif	#endif

	#ifndef GL_EXT_draw_range_elements	#ifndef GL_EXT_draw_range_elements
	#define GL_EXT_draw_range_elements 1	#define GL_EXT_draw_range_elements 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glDrawRangeElementsEXT (GLenum, GLuint, GLuint, GLsize i, GLenum, const GLvoid *);	GLAPI void GLAPIENTRY glDrawRangeElementsEXT (GLenum, GLuint, GLuint, GLsiz ei, GLenum, const GLvoid *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuin t start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);	typedef void (GLAPIENTRYP PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLui nt start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
	#endif	#endif

	#ifndef GL_WIN_phong_shading	#ifndef GL_WIN_phong_shading
	#define GL_WIN_phong_shading 1	#define GL_WIN_phong_shading 1
	#endif	#endif

	#ifndef GL_WIN_specular_fog	#ifndef GL_WIN_specular_fog
	#define GL_WIN_specular_fog 1	#define GL_WIN_specular_fog 1
	#endif	#endif

	#ifndef GL_EXT_light_texture	#ifndef GL_EXT_light_texture
	#define GL_EXT_light_texture 1	#define GL_EXT_light_texture 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glApplyTextureEXT (GLenum);	GLAPI void GLAPIENTRY glApplyTextureEXT (GLenum);
	extern void APIENTRY glTextureLightEXT (GLenum);	GLAPI void GLAPIENTRY glTextureLightEXT (GLenum);
	extern void APIENTRY glTextureMaterialEXT (GLenum, GLenum);	GLAPI void GLAPIENTRY glTextureMaterialEXT (GLenum, GLenum);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode);	typedef void (GLAPIENTRYP PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode);
	typedef void (APIENTRY * PFNGLTEXTURELIGHTEXTPROC) (GLenum pname);	typedef void (GLAPIENTRYP PFNGLTEXTURELIGHTEXTPROC) (GLenum pname);
	typedef void (APIENTRY * PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum	typedef void (GLAPIENTRYP PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum
	mode);	mode);
	#endif	#endif

	#ifndef GL_SGIX_blend_alpha_minmax	#ifndef GL_SGIX_blend_alpha_minmax
	#define GL_SGIX_blend_alpha_minmax 1	#define GL_SGIX_blend_alpha_minmax 1
	#endif	#endif

	#ifndef GL_EXT_bgra	#ifndef GL_EXT_bgra
	#define GL_EXT_bgra 1	#define GL_EXT_bgra 1
	#endif	#endif


		#ifndef GL_SGIX_async
		#define GL_SGIX_async 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glAsyncMarkerSGIX (GLuint);
		GLAPI GLint GLAPIENTRY glFinishAsyncSGIX (GLuint *);
		GLAPI GLint GLAPIENTRY glPollAsyncSGIX (GLuint *);
		GLAPI GLuint GLAPIENTRY glGenAsyncMarkersSGIX (GLsizei);
		GLAPI void GLAPIENTRY glDeleteAsyncMarkersSGIX (GLuint, GLsizei);
		GLAPI GLboolean GLAPIENTRY glIsAsyncMarkerSGIX (GLuint);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLASYNCMARKERSGIXPROC) (GLuint marker);
		typedef GLint (GLAPIENTRYP PFNGLFINISHASYNCSGIXPROC) (GLuint *markerp);
		typedef GLint (GLAPIENTRYP PFNGLPOLLASYNCSGIXPROC) (GLuint *markerp);
		typedef GLuint (GLAPIENTRYP PFNGLGENASYNCMARKERSSGIXPROC) (GLsizei range);
		typedef void (GLAPIENTRYP PFNGLDELETEASYNCMARKERSSGIXPROC) (GLuint marker,
		GLsizei range);
		typedef GLboolean (GLAPIENTRYP PFNGLISASYNCMARKERSGIXPROC) (GLuint marker);
		#endif

		#ifndef GL_SGIX_async_pixel
		#define GL_SGIX_async_pixel 1
		#endif

		#ifndef GL_SGIX_async_histogram
		#define GL_SGIX_async_histogram 1
		#endif

	#ifndef GL_INTEL_parallel_arrays	#ifndef GL_INTEL_parallel_arrays
	#define GL_INTEL_parallel_arrays 1	#define GL_INTEL_parallel_arrays 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glVertexPointervINTEL (GLint, GLenum, const GLvoid* *)	GLAPI void GLAPIENTRY glVertexPointervINTEL (GLint, GLenum, const GLvoid* *
	;	);
	extern void APIENTRY glNormalPointervINTEL (GLenum, const GLvoid* *);	GLAPI void GLAPIENTRY glNormalPointervINTEL (GLenum, const GLvoid* *);
	extern void APIENTRY glColorPointervINTEL (GLint, GLenum, const GLvoid* *);	GLAPI void GLAPIENTRY glColorPointervINTEL (GLint, GLenum, const GLvoid* *)
	extern void APIENTRY glTexCoordPointervINTEL (GLint, GLenum, const GLvoid*	;
	*);	GLAPI void GLAPIENTRY glTexCoordPointervINTEL (GLint, GLenum, const GLvoid*
		*);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum	typedef void (GLAPIENTRYP PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum
	type, const GLvoid* *pointer);	type, const GLvoid* *pointer);
	typedef void (APIENTRY * PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const	typedef void (GLAPIENTRYP PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const
	GLvoid* *pointer);	GLvoid* *pointer);
	typedef void (APIENTRY * PFNGLCOLORPOINTERVINTELPROC) (GLint size, GLenum t	typedef void (GLAPIENTRYP PFNGLCOLORPOINTERVINTELPROC) (GLint size, GLenum
	ype, const GLvoid* *pointer);	type, const GLvoid* *pointer);
	typedef void (APIENTRY * PFNGLTEXCOORDPOINTERVINTELPROC) (GLint size, GLenu	typedef void (GLAPIENTRYP PFNGLTEXCOORDPOINTERVINTELPROC) (GLint size, GLen
	m type, const GLvoid* *pointer);	um type, const GLvoid* *pointer);
	#endif	#endif

	#ifndef GL_HP_occlusion_test	#ifndef GL_HP_occlusion_test
	#define GL_HP_occlusion_test 1	#define GL_HP_occlusion_test 1
	#endif	#endif

	#ifndef GL_EXT_pixel_transform	#ifndef GL_EXT_pixel_transform
	#define GL_EXT_pixel_transform 1	#define GL_EXT_pixel_transform 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glPixelTransformParameteriEXT (GLenum, GLenum, GLint);	GLAPI void GLAPIENTRY glPixelTransformParameteriEXT (GLenum, GLenum, GLint)
	extern void APIENTRY glPixelTransformParameterfEXT (GLenum, GLenum, GLfloat	;
	);	GLAPI void GLAPIENTRY glPixelTransformParameterfEXT (GLenum, GLenum, GLfloa
	extern void APIENTRY glPixelTransformParameterivEXT (GLenum, GLenum, const	t);
	GLint *);	GLAPI void GLAPIENTRY glPixelTransformParameterivEXT (GLenum, GLenum, const
	extern void APIENTRY glPixelTransformParameterfvEXT (GLenum, GLenum, const	GLint *);
	GLfloat *);	GLAPI void GLAPIENTRY glPixelTransformParameterfvEXT (GLenum, GLenum, const
		GLfloat *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum targ	typedef void (GLAPIENTRYP PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum tar
	et, GLenum pname, GLint param);	get, GLenum pname, GLint param);
	typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum targ	typedef void (GLAPIENTRYP PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum tar
	et, GLenum pname, GLfloat param);	get, GLenum pname, GLfloat param);
	typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum tar	typedef void (GLAPIENTRYP PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum ta
	get, GLenum pname, const GLint *params);	rget, GLenum pname, const GLint *params);
	typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum tar	typedef void (GLAPIENTRYP PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum ta
	get, GLenum pname, const GLfloat *params);	rget, GLenum pname, const GLfloat *params);
	#endif	#endif

	#ifndef GL_EXT_pixel_transform_color_table	#ifndef GL_EXT_pixel_transform_color_table
	#define GL_EXT_pixel_transform_color_table 1	#define GL_EXT_pixel_transform_color_table 1
	#endif	#endif

	#ifndef GL_EXT_shared_texture_palette	#ifndef GL_EXT_shared_texture_palette
	#define GL_EXT_shared_texture_palette 1	#define GL_EXT_shared_texture_palette 1
	#endif	#endif

	#ifndef GL_EXT_separate_specular_color	#ifndef GL_EXT_separate_specular_color
	#define GL_EXT_separate_specular_color 1	#define GL_EXT_separate_specular_color 1
	#endif	#endif

	#ifndef GL_EXT_secondary_color	#ifndef GL_EXT_secondary_color
	#define GL_EXT_secondary_color 1	#define GL_EXT_secondary_color 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glSecondaryColor3bEXT (GLbyte, GLbyte, GLbyte);	GLAPI void GLAPIENTRY glSecondaryColor3bEXT (GLbyte, GLbyte, GLbyte);
	extern void APIENTRY glSecondaryColor3bvEXT (const GLbyte *);	GLAPI void GLAPIENTRY glSecondaryColor3bvEXT (const GLbyte *);
	extern void APIENTRY glSecondaryColor3dEXT (GLdouble, GLdouble, GLdouble);	GLAPI void GLAPIENTRY glSecondaryColor3dEXT (GLdouble, GLdouble, GLdouble);
	extern void APIENTRY glSecondaryColor3dvEXT (const GLdouble *);	GLAPI void GLAPIENTRY glSecondaryColor3dvEXT (const GLdouble *);
	extern void APIENTRY glSecondaryColor3fEXT (GLfloat, GLfloat, GLfloat);	GLAPI void GLAPIENTRY glSecondaryColor3fEXT (GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glSecondaryColor3fvEXT (const GLfloat *);	GLAPI void GLAPIENTRY glSecondaryColor3fvEXT (const GLfloat *);
	extern void APIENTRY glSecondaryColor3iEXT (GLint, GLint, GLint);	GLAPI void GLAPIENTRY glSecondaryColor3iEXT (GLint, GLint, GLint);
	extern void APIENTRY glSecondaryColor3ivEXT (const GLint *);	GLAPI void GLAPIENTRY glSecondaryColor3ivEXT (const GLint *);
	extern void APIENTRY glSecondaryColor3sEXT (GLshort, GLshort, GLshort);	GLAPI void GLAPIENTRY glSecondaryColor3sEXT (GLshort, GLshort, GLshort);
	extern void APIENTRY glSecondaryColor3svEXT (const GLshort *);	GLAPI void GLAPIENTRY glSecondaryColor3svEXT (const GLshort *);
	extern void APIENTRY glSecondaryColor3ubEXT (GLubyte, GLubyte, GLubyte);	GLAPI void GLAPIENTRY glSecondaryColor3ubEXT (GLubyte, GLubyte, GLubyte);
	extern void APIENTRY glSecondaryColor3ubvEXT (const GLubyte *);	GLAPI void GLAPIENTRY glSecondaryColor3ubvEXT (const GLubyte *);
	extern void APIENTRY glSecondaryColor3uiEXT (GLuint, GLuint, GLuint);	GLAPI void GLAPIENTRY glSecondaryColor3uiEXT (GLuint, GLuint, GLuint);
	extern void APIENTRY glSecondaryColor3uivEXT (const GLuint *);	GLAPI void GLAPIENTRY glSecondaryColor3uivEXT (const GLuint *);
	extern void APIENTRY glSecondaryColor3usEXT (GLushort, GLushort, GLushort);	GLAPI void GLAPIENTRY glSecondaryColor3usEXT (GLushort, GLushort, GLushort)
	extern void APIENTRY glSecondaryColor3usvEXT (const GLushort *);	;
	extern void APIENTRY glSecondaryColorPointerEXT (GLint, GLenum, GLsizei, GL	GLAPI void GLAPIENTRY glSecondaryColor3usvEXT (const GLushort *);
	void *);	GLAPI void GLAPIENTRY glSecondaryColorPointerEXT (GLint, GLenum, GLsizei, c
		onst GLvoid *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte
	green, GLbyte blue);	green, GLbyte blue);
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v);	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v);
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdou	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdo
	ble green, GLdouble blue);	uble green, GLdouble blue);
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v)	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v
	;	);
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloa	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLflo
	t green, GLfloat blue);	at green, GLfloat blue);
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v);	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v)
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint gr	;
	een, GLint blue);	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint g
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v);	reen, GLint blue);
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshor	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v);
	t green, GLshort blue);	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLsho
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v);	rt green, GLshort blue);
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLuby	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v)
	te green, GLubyte blue);	;
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v)	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLub
	;	yte green, GLubyte blue);
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v
	green, GLuint blue);	);
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v);	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuin
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLus	t green, GLuint blue);
	hort green, GLushort blue);	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v)
	typedef void (APIENTRY * PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v	;
	);	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLu
	typedef void (APIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GL	short green, GLushort blue);
	enum type, GLsizei stride, GLvoid *pointer);	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *
		v);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, G
		Lenum type, GLsizei stride, const GLvoid *pointer);
	#endif	#endif

	#ifndef GL_EXT_texture_perturb_normal	#ifndef GL_EXT_texture_perturb_normal
	#define GL_EXT_texture_perturb_normal 1	#define GL_EXT_texture_perturb_normal 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glTextureNormalEXT (GLenum);	GLAPI void GLAPIENTRY glTextureNormalEXT (GLenum);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode);	typedef void (GLAPIENTRYP PFNGLTEXTURENORMALEXTPROC) (GLenum mode);
	#endif	#endif

	#ifndef GL_EXT_multi_draw_arrays	#ifndef GL_EXT_multi_draw_arrays
	#define GL_EXT_multi_draw_arrays 1	#define GL_EXT_multi_draw_arrays 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glMultiDrawArraysEXT (GLenum, GLint , GLsizei , GLsi	GLAPI void GLAPIENTRY glMultiDrawArraysEXT (GLenum, GLint , GLsizei , GLs
	zei);	izei);
	extern void APIENTRY glMultiDrawElementsEXT (GLenum, const GLsizei *, GLenu	GLAPI void GLAPIENTRY glMultiDrawElementsEXT (GLenum, const GLsizei *, GLen
	m, const GLvoid* *, GLsizei);	um, const GLvoid* *, GLsizei);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, GLint *	typedef void (GLAPIENTRYP PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, GLint
	first, GLsizei *count, GLsizei primcount);	first, GLsizei count, GLsizei primcount);
	typedef void (APIENTRY * PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, const	typedef void (GLAPIENTRYP PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, cons
	GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);	t GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
	#endif	#endif

	#ifndef GL_EXT_fog_coord	#ifndef GL_EXT_fog_coord
	#define GL_EXT_fog_coord 1	#define GL_EXT_fog_coord 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glFogCoordfEXT (GLfloat);	GLAPI void GLAPIENTRY glFogCoordfEXT (GLfloat);
	extern void APIENTRY glFogCoordfvEXT (const GLfloat *);	GLAPI void GLAPIENTRY glFogCoordfvEXT (const GLfloat *);
	extern void APIENTRY glFogCoorddEXT (GLdouble);	GLAPI void GLAPIENTRY glFogCoorddEXT (GLdouble);
	extern void APIENTRY glFogCoorddvEXT (const GLdouble *);	GLAPI void GLAPIENTRY glFogCoorddvEXT (const GLdouble *);
	extern void APIENTRY glFogCoordPointerEXT (GLenum, GLsizei, const GLvoid *)	GLAPI void GLAPIENTRY glFogCoordPointerEXT (GLenum, GLsizei, const GLvoid *
	;	);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLFOGCOORDFEXTPROC) (GLfloat coord);	typedef void (GLAPIENTRYP PFNGLFOGCOORDFEXTPROC) (GLfloat coord);
	typedef void (APIENTRY * PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord);	typedef void (GLAPIENTRYP PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord);
	typedef void (APIENTRY * PFNGLFOGCOORDDEXTPROC) (GLdouble coord);	typedef void (GLAPIENTRYP PFNGLFOGCOORDDEXTPROC) (GLdouble coord);
	typedef void (APIENTRY * PFNGLFOGCOORDDVEXTPROC) (const GLdouble *coord);	typedef void (GLAPIENTRYP PFNGLFOGCOORDDVEXTPROC) (const GLdouble *coord);
	typedef void (APIENTRY * PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsizei	typedef void (GLAPIENTRYP PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsize
	stride, const GLvoid *pointer);	i stride, const GLvoid *pointer);
	#endif	#endif

	#ifndef GL_REND_screen_coordinates	#ifndef GL_REND_screen_coordinates
	#define GL_REND_screen_coordinates 1	#define GL_REND_screen_coordinates 1
	#endif	#endif

	#ifndef GL_EXT_coordinate_frame	#ifndef GL_EXT_coordinate_frame
	#define GL_EXT_coordinate_frame 1	#define GL_EXT_coordinate_frame 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glTangent3bEXT (GLbyte, GLbyte, GLbyte);	GLAPI void GLAPIENTRY glTangent3bEXT (GLbyte, GLbyte, GLbyte);
	extern void APIENTRY glTangent3bvEXT (const GLbyte *);	GLAPI void GLAPIENTRY glTangent3bvEXT (const GLbyte *);
	extern void APIENTRY glTangent3dEXT (GLdouble, GLdouble, GLdouble);	GLAPI void GLAPIENTRY glTangent3dEXT (GLdouble, GLdouble, GLdouble);
	extern void APIENTRY glTangent3dvEXT (const GLdouble *);	GLAPI void GLAPIENTRY glTangent3dvEXT (const GLdouble *);
	extern void APIENTRY glTangent3fEXT (GLfloat, GLfloat, GLfloat);	GLAPI void GLAPIENTRY glTangent3fEXT (GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glTangent3fvEXT (const GLfloat *);	GLAPI void GLAPIENTRY glTangent3fvEXT (const GLfloat *);
	extern void APIENTRY glTangent3iEXT (GLint, GLint, GLint);	GLAPI void GLAPIENTRY glTangent3iEXT (GLint, GLint, GLint);
	extern void APIENTRY glTangent3ivEXT (const GLint *);	GLAPI void GLAPIENTRY glTangent3ivEXT (const GLint *);
	extern void APIENTRY glTangent3sEXT (GLshort, GLshort, GLshort);	GLAPI void GLAPIENTRY glTangent3sEXT (GLshort, GLshort, GLshort);
	extern void APIENTRY glTangent3svEXT (const GLshort *);	GLAPI void GLAPIENTRY glTangent3svEXT (const GLshort *);
	extern void APIENTRY glBinormal3bEXT (GLbyte, GLbyte, GLbyte);	GLAPI void GLAPIENTRY glBinormal3bEXT (GLbyte, GLbyte, GLbyte);
	extern void APIENTRY glBinormal3bvEXT (const GLbyte *);	GLAPI void GLAPIENTRY glBinormal3bvEXT (const GLbyte *);
	extern void APIENTRY glBinormal3dEXT (GLdouble, GLdouble, GLdouble);	GLAPI void GLAPIENTRY glBinormal3dEXT (GLdouble, GLdouble, GLdouble);
	extern void APIENTRY glBinormal3dvEXT (const GLdouble *);	GLAPI void GLAPIENTRY glBinormal3dvEXT (const GLdouble *);
	extern void APIENTRY glBinormal3fEXT (GLfloat, GLfloat, GLfloat);	GLAPI void GLAPIENTRY glBinormal3fEXT (GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glBinormal3fvEXT (const GLfloat *);	GLAPI void GLAPIENTRY glBinormal3fvEXT (const GLfloat *);
	extern void APIENTRY glBinormal3iEXT (GLint, GLint, GLint);	GLAPI void GLAPIENTRY glBinormal3iEXT (GLint, GLint, GLint);
	extern void APIENTRY glBinormal3ivEXT (const GLint *);	GLAPI void GLAPIENTRY glBinormal3ivEXT (const GLint *);
	extern void APIENTRY glBinormal3sEXT (GLshort, GLshort, GLshort);	GLAPI void GLAPIENTRY glBinormal3sEXT (GLshort, GLshort, GLshort);
	extern void APIENTRY glBinormal3svEXT (const GLshort *);	GLAPI void GLAPIENTRY glBinormal3svEXT (const GLshort *);
	extern void APIENTRY glTangentPointerEXT (GLenum, GLsizei, const GLvoid *);	GLAPI void GLAPIENTRY glTangentPointerEXT (GLenum, GLsizei, const GLvoid *)
	extern void APIENTRY glBinormalPointerEXT (GLenum, GLsizei, const GLvoid *)	;
	;	GLAPI void GLAPIENTRY glBinormalPointerEXT (GLenum, GLsizei, const GLvoid *
		);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLTANGENT3BEXTPROC) (GLbyte tx, GLbyte ty, GLby	typedef void (GLAPIENTRYP PFNGLTANGENT3BEXTPROC) (GLbyte tx, GLbyte ty, GLb
	te tz);	yte tz);
	typedef void (APIENTRY * PFNGLTANGENT3BVEXTPROC) (const GLbyte *v);	typedef void (GLAPIENTRYP PFNGLTANGENT3BVEXTPROC) (const GLbyte *v);
	typedef void (APIENTRY * PFNGLTANGENT3DEXTPROC) (GLdouble tx, GLdouble ty,	typedef void (GLAPIENTRYP PFNGLTANGENT3DEXTPROC) (GLdouble tx, GLdouble ty,
	GLdouble tz);	GLdouble tz);
	typedef void (APIENTRY * PFNGLTANGENT3DVEXTPROC) (const GLdouble *v);	typedef void (GLAPIENTRYP PFNGLTANGENT3DVEXTPROC) (const GLdouble *v);
	typedef void (APIENTRY * PFNGLTANGENT3FEXTPROC) (GLfloat tx, GLfloat ty, GL	typedef void (GLAPIENTRYP PFNGLTANGENT3FEXTPROC) (GLfloat tx, GLfloat ty, G
	float tz);	Lfloat tz);
	typedef void (APIENTRY * PFNGLTANGENT3FVEXTPROC) (const GLfloat *v);	typedef void (GLAPIENTRYP PFNGLTANGENT3FVEXTPROC) (const GLfloat *v);
	typedef void (APIENTRY * PFNGLTANGENT3IEXTPROC) (GLint tx, GLint ty, GLint	typedef void (GLAPIENTRYP PFNGLTANGENT3IEXTPROC) (GLint tx, GLint ty, GLint
	tz);	tz);
	typedef void (APIENTRY * PFNGLTANGENT3IVEXTPROC) (const GLint *v);	typedef void (GLAPIENTRYP PFNGLTANGENT3IVEXTPROC) (const GLint *v);
	typedef void (APIENTRY * PFNGLTANGENT3SEXTPROC) (GLshort tx, GLshort ty, GL	typedef void (GLAPIENTRYP PFNGLTANGENT3SEXTPROC) (GLshort tx, GLshort ty, G
	short tz);	Lshort tz);
	typedef void (APIENTRY * PFNGLTANGENT3SVEXTPROC) (const GLshort *v);	typedef void (GLAPIENTRYP PFNGLTANGENT3SVEXTPROC) (const GLshort *v);
	typedef void (APIENTRY * PFNGLBINORMAL3BEXTPROC) (GLbyte bx, GLbyte by, GLb	typedef void (GLAPIENTRYP PFNGLBINORMAL3BEXTPROC) (GLbyte bx, GLbyte by, GL
	yte bz);	byte bz);
	typedef void (APIENTRY * PFNGLBINORMAL3BVEXTPROC) (const GLbyte *v);	typedef void (GLAPIENTRYP PFNGLBINORMAL3BVEXTPROC) (const GLbyte *v);
	typedef void (APIENTRY * PFNGLBINORMAL3DEXTPROC) (GLdouble bx, GLdouble by,	typedef void (GLAPIENTRYP PFNGLBINORMAL3DEXTPROC) (GLdouble bx, GLdouble by
	GLdouble bz);	, GLdouble bz);
	typedef void (APIENTRY * PFNGLBINORMAL3DVEXTPROC) (const GLdouble *v);	typedef void (GLAPIENTRYP PFNGLBINORMAL3DVEXTPROC) (const GLdouble *v);
	typedef void (APIENTRY * PFNGLBINORMAL3FEXTPROC) (GLfloat bx, GLfloat by, G	typedef void (GLAPIENTRYP PFNGLBINORMAL3FEXTPROC) (GLfloat bx, GLfloat by,
	Lfloat bz);	GLfloat bz);
	typedef void (APIENTRY * PFNGLBINORMAL3FVEXTPROC) (const GLfloat *v);	typedef void (GLAPIENTRYP PFNGLBINORMAL3FVEXTPROC) (const GLfloat *v);
	typedef void (APIENTRY * PFNGLBINORMAL3IEXTPROC) (GLint bx, GLint by, GLint	typedef void (GLAPIENTRYP PFNGLBINORMAL3IEXTPROC) (GLint bx, GLint by, GLin
	bz);	t bz);
	typedef void (APIENTRY * PFNGLBINORMAL3IVEXTPROC) (const GLint *v);	typedef void (GLAPIENTRYP PFNGLBINORMAL3IVEXTPROC) (const GLint *v);
	typedef void (APIENTRY * PFNGLBINORMAL3SEXTPROC) (GLshort bx, GLshort by, G	typedef void (GLAPIENTRYP PFNGLBINORMAL3SEXTPROC) (GLshort bx, GLshort by,
	Lshort bz);	GLshort bz);
	typedef void (APIENTRY * PFNGLBINORMAL3SVEXTPROC) (const GLshort *v);	typedef void (GLAPIENTRYP PFNGLBINORMAL3SVEXTPROC) (const GLshort *v);
	typedef void (APIENTRY * PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei	typedef void (GLAPIENTRYP PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei
	stride, const GLvoid *pointer);	stride, const GLvoid *pointer);
	typedef void (APIENTRY * PFNGLBINORMALPOINTEREXTPROC) (GLenum type, GLsizei	typedef void (GLAPIENTRYP PFNGLBINORMALPOINTEREXTPROC) (GLenum type, GLsize
	stride, const GLvoid *pointer);	i stride, const GLvoid *pointer);
	#endif	#endif

	#ifndef GL_EXT_texture_env_combine	#ifndef GL_EXT_texture_env_combine
	#define GL_EXT_texture_env_combine 1	#define GL_EXT_texture_env_combine 1
	#endif	#endif

	#ifndef GL_APPLE_specular_vector	#ifndef GL_APPLE_specular_vector
	#define GL_APPLE_specular_vector 1	#define GL_APPLE_specular_vector 1
	#endif	#endif


	skipping to change at line 2506	skipping to change at line 5398
	#define GL_APPLE_transform_hint 1	#define GL_APPLE_transform_hint 1
	#endif	#endif

	#ifndef GL_SGIX_fog_scale	#ifndef GL_SGIX_fog_scale
	#define GL_SGIX_fog_scale 1	#define GL_SGIX_fog_scale 1
	#endif	#endif

	#ifndef GL_SUNX_constant_data	#ifndef GL_SUNX_constant_data
	#define GL_SUNX_constant_data 1	#define GL_SUNX_constant_data 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glFinishTextureSUNX (void);	GLAPI void GLAPIENTRY glFinishTextureSUNX (void);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLFINISHTEXTURESUNXPROC) (void);	typedef void (GLAPIENTRYP PFNGLFINISHTEXTURESUNXPROC) (void);
	#endif	#endif

	#ifndef GL_SUN_global_alpha	#ifndef GL_SUN_global_alpha
	#define GL_SUN_global_alpha 1	#define GL_SUN_global_alpha 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glGlobalAlphaFactorbSUN (GLbyte);	GLAPI void GLAPIENTRY glGlobalAlphaFactorbSUN (GLbyte);
	extern void APIENTRY glGlobalAlphaFactorsSUN (GLshort);	GLAPI void GLAPIENTRY glGlobalAlphaFactorsSUN (GLshort);
	extern void APIENTRY glGlobalAlphaFactoriSUN (GLint);	GLAPI void GLAPIENTRY glGlobalAlphaFactoriSUN (GLint);
	extern void APIENTRY glGlobalAlphaFactorfSUN (GLfloat);	GLAPI void GLAPIENTRY glGlobalAlphaFactorfSUN (GLfloat);
	extern void APIENTRY glGlobalAlphaFactordSUN (GLdouble);	GLAPI void GLAPIENTRY glGlobalAlphaFactordSUN (GLdouble);
	extern void APIENTRY glGlobalAlphaFactorubSUN (GLubyte);	GLAPI void GLAPIENTRY glGlobalAlphaFactorubSUN (GLubyte);
	extern void APIENTRY glGlobalAlphaFactorusSUN (GLushort);	GLAPI void GLAPIENTRY glGlobalAlphaFactorusSUN (GLushort);
	extern void APIENTRY glGlobalAlphaFactoruiSUN (GLuint);	GLAPI void GLAPIENTRY glGlobalAlphaFactoruiSUN (GLuint);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor);	typedef void (GLAPIENTRYP PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor);
	typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor);	typedef void (GLAPIENTRYP PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor);
	typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORISUNPROC) (GLint factor);	typedef void (GLAPIENTRYP PFNGLGLOBALALPHAFACTORISUNPROC) (GLint factor);
	typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORFSUNPROC) (GLfloat factor);	typedef void (GLAPIENTRYP PFNGLGLOBALALPHAFACTORFSUNPROC) (GLfloat factor);
	typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORDSUNPROC) (GLdouble factor);	typedef void (GLAPIENTRYP PFNGLGLOBALALPHAFACTORDSUNPROC) (GLdouble factor)
	typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORUBSUNPROC) (GLubyte factor);	;
	typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORUSSUNPROC) (GLushort factor)	typedef void (GLAPIENTRYP PFNGLGLOBALALPHAFACTORUBSUNPROC) (GLubyte factor)
	;	;
	typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORUISUNPROC) (GLuint factor);	typedef void (GLAPIENTRYP PFNGLGLOBALALPHAFACTORUSSUNPROC) (GLushort factor
		);
		typedef void (GLAPIENTRYP PFNGLGLOBALALPHAFACTORUISUNPROC) (GLuint factor);
	#endif	#endif

	#ifndef GL_SUN_triangle_list	#ifndef GL_SUN_triangle_list
	#define GL_SUN_triangle_list 1	#define GL_SUN_triangle_list 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glReplacementCodeuiSUN (GLuint);	GLAPI void GLAPIENTRY glReplacementCodeuiSUN (GLuint);
	extern void APIENTRY glReplacementCodeusSUN (GLushort);	GLAPI void GLAPIENTRY glReplacementCodeusSUN (GLushort);
	extern void APIENTRY glReplacementCodeubSUN (GLubyte);	GLAPI void GLAPIENTRY glReplacementCodeubSUN (GLubyte);
	extern void APIENTRY glReplacementCodeuivSUN (const GLuint *);	GLAPI void GLAPIENTRY glReplacementCodeuivSUN (const GLuint *);
	extern void APIENTRY glReplacementCodeusvSUN (const GLushort *);	GLAPI void GLAPIENTRY glReplacementCodeusvSUN (const GLushort *);
	extern void APIENTRY glReplacementCodeubvSUN (const GLubyte *);	GLAPI void GLAPIENTRY glReplacementCodeubvSUN (const GLubyte *);
	extern void APIENTRY glReplacementCodePointerSUN (GLenum, GLsizei, const GL	GLAPI void GLAPIENTRY glReplacementCodePointerSUN (GLenum, GLsizei, const G
	void* *);	Lvoid* *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code);	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code);	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUBSUNPROC) (GLubyte code);	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUBSUNPROC) (GLubyte code);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVSUNPROC) (const GLuint *cod	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUIVSUNPROC) (const GLuint *co
	e);	de);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUSVSUNPROC) (const GLushort *c	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUSVSUNPROC) (const GLushort *
	ode);	code);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUBVSUNPROC) (const GLubyte *co	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUBVSUNPROC) (const GLubyte *c
	de);	ode);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEPOINTERSUNPROC) (GLenum type,	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEPOINTERSUNPROC) (GLenum type,
	GLsizei stride, const GLvoid* *pointer);	GLsizei stride, const GLvoid* *pointer);
	#endif	#endif

	#ifndef GL_SUN_vertex	#ifndef GL_SUN_vertex
	#define GL_SUN_vertex 1	#define GL_SUN_vertex 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glColor4ubVertex2fSUN (GLubyte, GLubyte, GLubyte, GLub	GLAPI void GLAPIENTRY glColor4ubVertex2fSUN (GLubyte, GLubyte, GLubyte, GLu
	yte, GLfloat, GLfloat);	byte, GLfloat, GLfloat);
	extern void APIENTRY glColor4ubVertex2fvSUN (const GLubyte *, const GLfloat	GLAPI void GLAPIENTRY glColor4ubVertex2fvSUN (const GLubyte *, const GLfloa
	*);	t *);
	extern void APIENTRY glColor4ubVertex3fSUN (GLubyte, GLubyte, GLubyte, GLub	GLAPI void GLAPIENTRY glColor4ubVertex3fSUN (GLubyte, GLubyte, GLubyte, GLu
	yte, GLfloat, GLfloat, GLfloat);	byte, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glColor4ubVertex3fvSUN (const GLubyte *, const GLfloat	GLAPI void GLAPIENTRY glColor4ubVertex3fvSUN (const GLubyte *, const GLfloa
	*);	t *);
	extern void APIENTRY glColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLflo	GLAPI void GLAPIENTRY glColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfl
	at, GLfloat, GLfloat);	oat, GLfloat, GLfloat);
	extern void APIENTRY glColor3fVertex3fvSUN (const GLfloat *, const GLfloat	GLAPI void GLAPIENTRY glColor3fVertex3fvSUN (const GLfloat *, const GLfloat
	*);	*);
	extern void APIENTRY glNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfl	GLAPI void GLAPIENTRY glNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLf
	oat, GLfloat, GLfloat);	loat, GLfloat, GLfloat);
	extern void APIENTRY glNormal3fVertex3fvSUN (const GLfloat *, const GLfloat	GLAPI void GLAPIENTRY glNormal3fVertex3fvSUN (const GLfloat *, const GLfloa
	*);	t *);
	extern void APIENTRY glColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloa	GLAPI void GLAPIENTRY glColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLflo
	t, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);	at, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glColor4fNormal3fVertex3fvSUN (const GLfloat *, const	GLAPI void GLAPIENTRY glColor4fNormal3fVertex3fvSUN (const GLfloat *, const
	GLfloat , const GLfloat );	GLfloat , const GLfloat );
	extern void APIENTRY glTexCoord2fVertex3fSUN (GLfloat, GLfloat, GLfloat, GL	GLAPI void GLAPIENTRY glTexCoord2fVertex3fSUN (GLfloat, GLfloat, GLfloat, G
	float, GLfloat);	Lfloat, GLfloat);
	extern void APIENTRY glTexCoord2fVertex3fvSUN (const GLfloat *, const GLflo	GLAPI void GLAPIENTRY glTexCoord2fVertex3fvSUN (const GLfloat *, const GLfl
	at *);	oat *);
	extern void APIENTRY glTexCoord4fVertex4fSUN (GLfloat, GLfloat, GLfloat, GL	GLAPI void GLAPIENTRY glTexCoord4fVertex4fSUN (GLfloat, GLfloat, GLfloat, G
	float, GLfloat, GLfloat, GLfloat, GLfloat);	Lfloat, GLfloat, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glTexCoord4fVertex4fvSUN (const GLfloat *, const GLflo	GLAPI void GLAPIENTRY glTexCoord4fVertex4fvSUN (const GLfloat *, const GLfl
	at *);	oat *);
	extern void APIENTRY glTexCoord2fColor4ubVertex3fSUN (GLfloat, GLfloat, GLu	GLAPI void GLAPIENTRY glTexCoord2fColor4ubVertex3fSUN (GLfloat, GLfloat, GL
	byte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);	ubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *, con	GLAPI void GLAPIENTRY glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *, co
	st GLubyte , const GLfloat );	nst GLubyte , const GLfloat );
	extern void APIENTRY glTexCoord2fColor3fVertex3fSUN (GLfloat, GLfloat, GLfl	GLAPI void GLAPIENTRY glTexCoord2fColor3fVertex3fSUN (GLfloat, GLfloat, GLf
	oat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);	loat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glTexCoord2fColor3fVertex3fvSUN (const GLfloat *, cons	GLAPI void GLAPIENTRY glTexCoord2fColor3fVertex3fvSUN (const GLfloat *, con
	t GLfloat , const GLfloat );	st GLfloat , const GLfloat );
	extern void APIENTRY glTexCoord2fNormal3fVertex3fSUN (GLfloat, GLfloat, GLf	GLAPI void GLAPIENTRY glTexCoord2fNormal3fVertex3fSUN (GLfloat, GLfloat, GL
	loat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);	float, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *, con	GLAPI void GLAPIENTRY glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *, co
	st GLfloat , const GLfloat );	nst GLfloat , const GLfloat );
	extern void APIENTRY glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat, GLflo	GLAPI void GLAPIENTRY glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat, GLfl
	at, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat,	oat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat
	GLfloat, GLfloat);	, GLfloat, GLfloat);
	extern void APIENTRY glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat	GLAPI void GLAPIENTRY glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloa
	, const GLfloat , const GLfloat , const GLfloat );	t , const GLfloat , const GLfloat , const GLfloat );
	extern void APIENTRY glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat, GLflo	GLAPI void GLAPIENTRY glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat, GLfl
	at, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat,	oat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat
	GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);	, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat	GLAPI void GLAPIENTRY glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloa
	, const GLfloat , const GLfloat , const GLfloat );	t , const GLfloat , const GLfloat , const GLfloat );
	extern void APIENTRY glReplacementCodeuiVertex3fSUN (GLenum, GLfloat, GLflo	GLAPI void GLAPIENTRY glReplacementCodeuiVertex3fSUN (GLuint, GLfloat, GLfl
	at, GLfloat);	oat, GLfloat);
	extern void APIENTRY glReplacementCodeuiVertex3fvSUN (const GLenum *, const	GLAPI void GLAPIENTRY glReplacementCodeuiVertex3fvSUN (const GLuint *, cons
	GLfloat *);	t GLfloat *);
	extern void APIENTRY glReplacementCodeuiColor4ubVertex3fSUN (GLenum, GLubyt	GLAPI void GLAPIENTRY glReplacementCodeuiColor4ubVertex3fSUN (GLuint, GLuby
	e, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);	te, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glReplacementCodeuiColor4ubVertex3fvSUN (const GLenum	GLAPI void GLAPIENTRY glReplacementCodeuiColor4ubVertex3fvSUN (const GLuint
	, const GLubyte , const GLfloat *);	, const GLubyte , const GLfloat *);
	extern void APIENTRY glReplacementCodeuiColor3fVertex3fSUN (GLenum, GLfloat	GLAPI void GLAPIENTRY glReplacementCodeuiColor3fVertex3fSUN (GLuint, GLfloa
	, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);	t, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glReplacementCodeuiColor3fVertex3fvSUN (const GLenum *	GLAPI void GLAPIENTRY glReplacementCodeuiColor3fVertex3fvSUN (const GLuint
	, const GLfloat , const GLfloat );	, const GLfloat , const GLfloat *);
	extern void APIENTRY glReplacementCodeuiNormal3fVertex3fSUN (GLenum, GLfloa	GLAPI void GLAPIENTRY glReplacementCodeuiNormal3fVertex3fSUN (GLuint, GLflo
	t, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);	at, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glReplacementCodeuiNormal3fVertex3fvSUN (const GLenum	GLAPI void GLAPIENTRY glReplacementCodeuiNormal3fVertex3fvSUN (const GLuint
	, const GLfloat , const GLfloat *);	, const GLfloat , const GLfloat *);
	extern void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLenum,	GLAPI void GLAPIENTRY glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLuint
	GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GL	, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, G
	float, GLfloat);	Lfloat, GLfloat);
	extern void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const	GLAPI void GLAPIENTRY glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const
	GLenum , const GLfloat , const GLfloat , const GLfloat );	GLuint , const GLfloat , const GLfloat , const GLfloat );
	extern void APIENTRY glReplacementCodeuiTexCoord2fVertex3fSUN (GLenum, GLfl	GLAPI void GLAPIENTRY glReplacementCodeuiTexCoord2fVertex3fSUN (GLuint, GLf
	oat, GLfloat, GLfloat, GLfloat, GLfloat);	loat, GLfloat, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLenu	GLAPI void GLAPIENTRY glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLui
	m , const GLfloat , const GLfloat *);	nt , const GLfloat , const GLfloat *);
	extern void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLen	GLAPI void GLAPIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLu
	um, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat)	int, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat
	;	);
	extern void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (con	GLAPI void GLAPIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (co
	st GLenum , const GLfloat , const GLfloat , const GLfloat );	nst GLuint , const GLfloat , const GLfloat , const GLfloat );
	extern void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSU	GLAPI void GLAPIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fS
	N (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, G	UN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat,
	Lfloat, GLfloat, GLfloat, GLfloat, GLfloat);	GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvS	GLAPI void GLAPIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv
	UN (const GLenum , const GLfloat , const GLfloat , const GLfloat , cons	SUN (const GLuint , const GLfloat , const GLfloat , const GLfloat , con
	t GLfloat *);	st GLfloat *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte	typedef void (GLAPIENTRYP PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte
	g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);	g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);
	typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte *c,	typedef void (GLAPIENTRYP PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte *c,
	const GLfloat *v);	const GLfloat *v);
	typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX3FSUNPROC) (GLubyte r, GLubyte	typedef void (GLAPIENTRYP PFNGLCOLOR4UBVERTEX3FSUNPROC) (GLubyte r, GLubyte
	g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);	g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX3FVSUNPROC) (const GLubyte *c,	typedef void (GLAPIENTRYP PFNGLCOLOR4UBVERTEX3FVSUNPROC) (const GLubyte *c,
	const GLfloat *v);	const GLfloat *v);
	typedef void (APIENTRY * PFNGLCOLOR3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g	typedef void (GLAPIENTRYP PFNGLCOLOR3FVERTEX3FSUNPROC) (GLfloat r, GLfloat
	, GLfloat b, GLfloat x, GLfloat y, GLfloat z);	g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *c, c	typedef void (GLAPIENTRYP PFNGLCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *c,
	onst GLfloat *v);	const GLfloat *v);
	typedef void (APIENTRY * PFNGLNORMAL3FVERTEX3FSUNPROC) (GLfloat nx, GLfloat	typedef void (GLAPIENTRYP PFNGLNORMAL3FVERTEX3FSUNPROC) (GLfloat nx, GLfloa
	ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);	t ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *n,	typedef void (GLAPIENTRYP PFNGLNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *n,
	const GLfloat *v);	const GLfloat *v);
	typedef void (APIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat r, G	typedef void (GLAPIENTRYP PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat r,
	Lfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat	GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloa
	x, GLfloat y, GLfloat z);	t x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLflo	typedef void (GLAPIENTRYP PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfl
	at c, const GLfloat n, const GLfloat *v);	oat c, const GLfloat n, const GLfloat *v);
	typedef void (APIENTRY * PFNGLTEXCOORD2FVERTEX3FSUNPROC) (GLfloat s, GLfloa	typedef void (GLAPIENTRYP PFNGLTEXCOORD2FVERTEX3FSUNPROC) (GLfloat s, GLflo
	t t, GLfloat x, GLfloat y, GLfloat z);	at t, GLfloat x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLTEXCOORD2FVERTEX3FVSUNPROC) (const GLfloat *t	typedef void (GLAPIENTRYP PFNGLTEXCOORD2FVERTEX3FVSUNPROC) (const GLfloat *
	c, const GLfloat *v);	tc, const GLfloat *v);
	typedef void (APIENTRY * PFNGLTEXCOORD4FVERTEX4FSUNPROC) (GLfloat s, GLfloa	typedef void (GLAPIENTRYP PFNGLTEXCOORD4FVERTEX4FSUNPROC) (GLfloat s, GLflo
	t t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w);	at t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
	typedef void (APIENTRY * PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat *t	typedef void (GLAPIENTRYP PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat *
	c, const GLfloat *v);	tc, const GLfloat *v);
	typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) (GLfloat s	typedef void (GLAPIENTRYP PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) (GLfloat
	, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat	s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloa
	y, GLfloat z);	t y, GLfloat z);
	typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) (const GL	typedef void (GLAPIENTRYP PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) (const G
	float tc, const GLubyte c, const GLfloat *v);	Lfloat tc, const GLubyte c, const GLfloat *v);
	typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) (GLfloat s,	typedef void (GLAPIENTRYP PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) (GLfloat s
	GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat	, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat
	z);	z);
	typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) (const GLf	typedef void (GLAPIENTRYP PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) (const GL
	loat tc, const GLfloat c, const GLfloat *v);	float tc, const GLfloat c, const GLfloat *v);
	typedef void (APIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLfloat s	typedef void (GLAPIENTRYP PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLfloat
	, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfl	s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLf
	oat z);	loat z);
	typedef void (APIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GL	typedef void (GLAPIENTRYP PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const G
	float tc, const GLfloat n, const GLfloat *v);	Lfloat tc, const GLfloat n, const GLfloat *v);
	typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GL	typedef void (GLAPIENTRYP PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (G
	float s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx,	Lfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx
	GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);	, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (c	typedef void (GLAPIENTRYP PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (
	onst GLfloat tc, const GLfloat c, const GLfloat n, const GLfloat v);	const GLfloat tc, const GLfloat c, const GLfloat n, const GLfloat v);
	typedef void (APIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (GL	typedef void (GLAPIENTRYP PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (G
	float s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b,	Lfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b,
	GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloa	GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLflo
	t z, GLfloat w);	at z, GLfloat w);
	typedef void (APIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (c	typedef void (GLAPIENTRYP PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (
	onst GLfloat tc, const GLfloat c, const GLfloat n, const GLfloat v);	const GLfloat tc, const GLfloat c, const GLfloat n, const GLfloat v);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLenum rc,	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLuint rc
	GLfloat x, GLfloat y, GLfloat z);	, GLfloat x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLe	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GL
	num rc, const GLfloat v);	uint rc, const GLfloat v);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GL	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (G
	enum rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y,	Luint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y,
	GLfloat z);	GLfloat z);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (c	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (
	onst GLenum rc, const GLubyte c, const GLfloat *v);	const GLuint rc, const GLubyte c, const GLfloat *v);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLe	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GL
	num rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);	uint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (co	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (c
	nst GLenum rc, const GLfloat c, const GLfloat *v);	onst GLuint rc, const GLfloat c, const GLfloat *v);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GL	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (G
	enum rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat	Luint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat
	z);	z);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (c	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (
	onst GLenum rc, const GLfloat n, const GLfloat *v);	const GLuint rc, const GLfloat n, const GLfloat *v);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPR	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNP
	OC) (GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLf	ROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GL
	loat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);	float ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNP	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUN
	ROC) (const GLenum rc, const GLfloat c, const GLfloat n, const GLfloat	PROC) (const GLuint rc, const GLfloat c, const GLfloat *n, const GLfloat
	v);	*v);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)
	GLenum rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);	(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)
	(const GLenum rc, const GLfloat tc, const GLfloat *v);	(const GLuint rc, const GLfloat tc, const GLfloat *v);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSU	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FS
	NPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz	UNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat n
	, GLfloat x, GLfloat y, GLfloat z);	z, GLfloat x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVS	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FV
	UNPROC) (const GLenum rc, const GLfloat tc, const GLfloat *n, const GLflo	SUNPROC) (const GLuint rc, const GLfloat tc, const GLfloat *n, const GLfl
	at *v);	oat *v);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVER	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVE
	TEX3FSUNPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLflo	RTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfl
	at b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y,	oat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y,
	GLfloat z);	GLfloat z);
	typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVER	typedef void (GLAPIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVE
	TEX3FVSUNPROC) (const GLenum rc, const GLfloat tc, const GLfloat *c, cons	RTEX3FVSUNPROC) (const GLuint rc, const GLfloat tc, const GLfloat *c, con
	t GLfloat n, const GLfloat v);	st GLfloat n, const GLfloat v);
	#endif	#endif

	#ifndef GL_EXT_blend_func_separate	#ifndef GL_EXT_blend_func_separate
	#define GL_EXT_blend_func_separate 1	#define GL_EXT_blend_func_separate 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glBlendFuncSeparateEXT (GLenum, GLenum, GLenum, GLenum );	GLAPI void GLAPIENTRY glBlendFuncSeparateEXT (GLenum, GLenum, GLenum, GLenu m);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB,	typedef void (GLAPIENTRYP PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB
	GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);	, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
		#endif

		#ifndef GL_INGR_blend_func_separate
		#define GL_INGR_blend_func_separate 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glBlendFuncSeparateINGR (GLenum, GLenum, GLenum, GLen
		um);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLBLENDFUNCSEPARATEINGRPROC) (GLenum sfactorRG
		B, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
	#endif	#endif

	#ifndef GL_INGR_color_clamp	#ifndef GL_INGR_color_clamp
	#define GL_INGR_color_clamp 1	#define GL_INGR_color_clamp 1
	#endif	#endif

	#ifndef GL_INGR_interlace_read	#ifndef GL_INGR_interlace_read
	#define GL_INGR_interlace_read 1	#define GL_INGR_interlace_read 1
	#endif	#endif


	skipping to change at line 2686	skipping to change at line 5586
	#define GL_EXT_texture_lod_bias 1	#define GL_EXT_texture_lod_bias 1
	#endif	#endif

	#ifndef GL_EXT_texture_filter_anisotropic	#ifndef GL_EXT_texture_filter_anisotropic
	#define GL_EXT_texture_filter_anisotropic 1	#define GL_EXT_texture_filter_anisotropic 1
	#endif	#endif

	#ifndef GL_EXT_vertex_weighting	#ifndef GL_EXT_vertex_weighting
	#define GL_EXT_vertex_weighting 1	#define GL_EXT_vertex_weighting 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glVertexWeightfEXT (GLfloat);	GLAPI void GLAPIENTRY glVertexWeightfEXT (GLfloat);
	extern void APIENTRY glVertexWeightfvEXT (const GLfloat *);	GLAPI void GLAPIENTRY glVertexWeightfvEXT (const GLfloat *);
	extern void APIENTRY glVertexWeightPointerEXT (GLsizei, GLenum, GLsizei, co	GLAPI void GLAPIENTRY glVertexWeightPointerEXT (GLsizei, GLenum, GLsizei, c
	nst GLvoid *);	onst GLvoid *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight);	typedef void (GLAPIENTRYP PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight);
	typedef void (APIENTRY * PFNGLVERTEXWEIGHTFVEXTPROC) (const GLfloat *weight	typedef void (GLAPIENTRYP PFNGLVERTEXWEIGHTFVEXTPROC) (const GLfloat *weigh
	);	t);
	typedef void (APIENTRY * PFNGLVERTEXWEIGHTPOINTEREXTPROC) (GLsizei size, GL	typedef void (GLAPIENTRYP PFNGLVERTEXWEIGHTPOINTEREXTPROC) (GLsizei size, G
	enum type, GLsizei stride, const GLvoid *pointer);	Lenum type, GLsizei stride, const GLvoid *pointer);
	#endif	#endif

	#ifndef GL_NV_light_max_exponent	#ifndef GL_NV_light_max_exponent
	#define GL_NV_light_max_exponent 1	#define GL_NV_light_max_exponent 1
	#endif	#endif

	#ifndef GL_NV_vertex_array_range	#ifndef GL_NV_vertex_array_range
	#define GL_NV_vertex_array_range 1	#define GL_NV_vertex_array_range 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glFlushVertexArrayRangeNV (void);	GLAPI void GLAPIENTRY glFlushVertexArrayRangeNV (void);
	extern void APIENTRY glVertexArrayRangeNV (GLsizei, const GLvoid *);	GLAPI void GLAPIENTRY glVertexArrayRangeNV (GLsizei, const GLvoid *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void);	typedef void (GLAPIENTRYP PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void);
	typedef void (APIENTRY * PFNGLVERTEXARRAYRANGENVPROC) (GLsizei size, const	typedef void (GLAPIENTRYP PFNGLVERTEXARRAYRANGENVPROC) (GLsizei length, con
	GLvoid *pointer);	st GLvoid *pointer);
	#endif

	#ifndef GL_NV_vertex_array_range2
	#define GL_NV_vertex_array_range2 1
	#endif	#endif

	#ifndef GL_NV_register_combiners	#ifndef GL_NV_register_combiners
	#define GL_NV_register_combiners 1	#define GL_NV_register_combiners 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glCombinerParameterfvNV (GLenum, const GLfloat *);	GLAPI void GLAPIENTRY glCombinerParameterfvNV (GLenum, const GLfloat *);
	extern void APIENTRY glCombinerParameterfNV (GLenum, GLfloat);	GLAPI void GLAPIENTRY glCombinerParameterfNV (GLenum, GLfloat);
	extern void APIENTRY glCombinerParameterivNV (GLenum, const GLint *);	GLAPI void GLAPIENTRY glCombinerParameterivNV (GLenum, const GLint *);
	extern void APIENTRY glCombinerParameteriNV (GLenum, GLint);	GLAPI void GLAPIENTRY glCombinerParameteriNV (GLenum, GLint);
	extern void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLe	GLAPI void GLAPIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GL
	num, GLenum);	enum, GLenum);
	extern void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GL	GLAPI void GLAPIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, G
	enum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);	Lenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
	extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum	GLAPI void GLAPIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenu
	);	m);
	extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenu	GLAPI void GLAPIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLen
	m, GLenum, GLfloat *);	um, GLenum, GLfloat *);
	extern void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLenu	GLAPI void GLAPIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLen
	m, GLenum, GLint *);	um, GLenum, GLint *);
	extern void APIENTRY glGetCombinerOutputParameterfvNV (GLenum, GLenum, GLen	GLAPI void GLAPIENTRY glGetCombinerOutputParameterfvNV (GLenum, GLenum, GLe
	um, GLfloat *);	num, GLfloat *);
	extern void APIENTRY glGetCombinerOutputParameterivNV (GLenum, GLenum, GLen	GLAPI void GLAPIENTRY glGetCombinerOutputParameterivNV (GLenum, GLenum, GLe
	um, GLint *);	num, GLint *);
	extern void APIENTRY glGetFinalCombinerInputParameterfvNV (GLenum, GLenum,	GLAPI void GLAPIENTRY glGetFinalCombinerInputParameterfvNV (GLenum, GLenum,
	GLfloat *);	GLfloat *);
	extern void APIENTRY glGetFinalCombinerInputParameterivNV (GLenum, GLenum,	GLAPI void GLAPIENTRY glGetFinalCombinerInputParameterivNV (GLenum, GLenum,
	GLint *);	GLint *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, con	typedef void (GLAPIENTRYP PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, co
	st GLfloat *params);	nst GLfloat *params);
	typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfl	typedef void (GLAPIENTRYP PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLf
	oat param);	loat param);
	typedef void (APIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, con	typedef void (GLAPIENTRYP PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, co
	st GLint *params);	nst GLint *params);
	typedef void (APIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLin	typedef void (GLAPIENTRYP PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLi
	t param);	nt param);
	typedef void (APIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum po	typedef void (GLAPIENTRYP PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum p
	rtion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage	ortion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsag
	);	e);
	typedef void (APIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum p	typedef void (GLAPIENTRYP PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum
	ortion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, G	portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale,
	Lenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSu	GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxS
	m);	um);
	typedef void (APIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, G	typedef void (GLAPIENTRYP PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable,
	Lenum input, GLenum mapping, GLenum componentUsage);	GLenum input, GLenum mapping, GLenum componentUsage);
	typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum st	typedef void (GLAPIENTRYP PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum s
	age, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);	tage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum st	typedef void (GLAPIENTRYP PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum s
	age, GLenum portion, GLenum variable, GLenum pname, GLint *params);	tage, GLenum portion, GLenum variable, GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum s	typedef void (GLAPIENTRYP PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum
	tage, GLenum portion, GLenum pname, GLfloat *params);	stage, GLenum portion, GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum s	typedef void (GLAPIENTRYP PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum
	tage, GLenum portion, GLenum pname, GLint *params);	stage, GLenum portion, GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLen	typedef void (GLAPIENTRYP PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLe
	um variable, GLenum pname, GLfloat *params);	num variable, GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLen	typedef void (GLAPIENTRYP PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLe
	um variable, GLenum pname, GLint *params);	num variable, GLenum pname, GLint *params);
	#endif	#endif

	#ifndef GL_NV_fog_distance	#ifndef GL_NV_fog_distance
	#define GL_NV_fog_distance 1	#define GL_NV_fog_distance 1
	#endif	#endif

	#ifndef GL_NV_texgen_emboss	#ifndef GL_NV_texgen_emboss
	#define GL_NV_texgen_emboss 1	#define GL_NV_texgen_emboss 1
	#endif	#endif


	skipping to change at line 2764	skipping to change at line 5660
	#define GL_NV_blend_square 1	#define GL_NV_blend_square 1
	#endif	#endif

	#ifndef GL_NV_texture_env_combine4	#ifndef GL_NV_texture_env_combine4
	#define GL_NV_texture_env_combine4 1	#define GL_NV_texture_env_combine4 1
	#endif	#endif

	#ifndef GL_MESA_resize_buffers	#ifndef GL_MESA_resize_buffers
	#define GL_MESA_resize_buffers 1	#define GL_MESA_resize_buffers 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glResizeBuffersMESA (void);	GLAPI void GLAPIENTRY glResizeBuffersMESA (void);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLRESIZEBUFFERSMESAPROC) (void);	typedef void (GLAPIENTRYP PFNGLRESIZEBUFFERSMESAPROC) (void);
	#endif	#endif

	#ifndef GL_MESA_window_pos	#ifndef GL_MESA_window_pos
	#define GL_MESA_window_pos 1	#define GL_MESA_window_pos 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glWindowPos2dMESA (GLdouble, GLdouble);	GLAPI void GLAPIENTRY glWindowPos2dMESA (GLdouble, GLdouble);
	extern void APIENTRY glWindowPos2dvMESA (const GLdouble *);	GLAPI void GLAPIENTRY glWindowPos2dvMESA (const GLdouble *);
	extern void APIENTRY glWindowPos2fMESA (GLfloat, GLfloat);	GLAPI void GLAPIENTRY glWindowPos2fMESA (GLfloat, GLfloat);
	extern void APIENTRY glWindowPos2fvMESA (const GLfloat *);	GLAPI void GLAPIENTRY glWindowPos2fvMESA (const GLfloat *);
	extern void APIENTRY glWindowPos2iMESA (GLint, GLint);	GLAPI void GLAPIENTRY glWindowPos2iMESA (GLint, GLint);
	extern void APIENTRY glWindowPos2ivMESA (const GLint *);	GLAPI void GLAPIENTRY glWindowPos2ivMESA (const GLint *);
	extern void APIENTRY glWindowPos2sMESA (GLshort, GLshort);	GLAPI void GLAPIENTRY glWindowPos2sMESA (GLshort, GLshort);
	extern void APIENTRY glWindowPos2svMESA (const GLshort *);	GLAPI void GLAPIENTRY glWindowPos2svMESA (const GLshort *);
	extern void APIENTRY glWindowPos3dMESA (GLdouble, GLdouble, GLdouble);	GLAPI void GLAPIENTRY glWindowPos3dMESA (GLdouble, GLdouble, GLdouble);
	extern void APIENTRY glWindowPos3dvMESA (const GLdouble *);	GLAPI void GLAPIENTRY glWindowPos3dvMESA (const GLdouble *);
	extern void APIENTRY glWindowPos3fMESA (GLfloat, GLfloat, GLfloat);	GLAPI void GLAPIENTRY glWindowPos3fMESA (GLfloat, GLfloat, GLfloat);
	extern void APIENTRY glWindowPos3fvMESA (const GLfloat *);	GLAPI void GLAPIENTRY glWindowPos3fvMESA (const GLfloat *);
	extern void APIENTRY glWindowPos3iMESA (GLint, GLint, GLint);	GLAPI void GLAPIENTRY glWindowPos3iMESA (GLint, GLint, GLint);
	extern void APIENTRY glWindowPos3ivMESA (const GLint *);	GLAPI void GLAPIENTRY glWindowPos3ivMESA (const GLint *);
	extern void APIENTRY glWindowPos3sMESA (GLshort, GLshort, GLshort);	GLAPI void GLAPIENTRY glWindowPos3sMESA (GLshort, GLshort, GLshort);
	extern void APIENTRY glWindowPos3svMESA (const GLshort *);	GLAPI void GLAPIENTRY glWindowPos3svMESA (const GLshort *);
	extern void APIENTRY glWindowPos4dMESA (GLdouble, GLdouble, GLdouble, GLdou	GLAPI void GLAPIENTRY glWindowPos4dMESA (GLdouble, GLdouble, GLdouble, GLdo
	ble);	uble);
	extern void APIENTRY glWindowPos4dvMESA (const GLdouble *);	GLAPI void GLAPIENTRY glWindowPos4dvMESA (const GLdouble *);
	extern void APIENTRY glWindowPos4fMESA (GLfloat, GLfloat, GLfloat, GLfloat)	GLAPI void GLAPIENTRY glWindowPos4fMESA (GLfloat, GLfloat, GLfloat, GLfloat
	;	);
	extern void APIENTRY glWindowPos4fvMESA (const GLfloat *);	GLAPI void GLAPIENTRY glWindowPos4fvMESA (const GLfloat *);
	extern void APIENTRY glWindowPos4iMESA (GLint, GLint, GLint, GLint);	GLAPI void GLAPIENTRY glWindowPos4iMESA (GLint, GLint, GLint, GLint);
	extern void APIENTRY glWindowPos4ivMESA (const GLint *);	GLAPI void GLAPIENTRY glWindowPos4ivMESA (const GLint *);
	extern void APIENTRY glWindowPos4sMESA (GLshort, GLshort, GLshort, GLshort)	GLAPI void GLAPIENTRY glWindowPos4sMESA (GLshort, GLshort, GLshort, GLshort
	;	);
	extern void APIENTRY glWindowPos4svMESA (const GLshort *);	GLAPI void GLAPIENTRY glWindowPos4svMESA (const GLshort *);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y)	typedef void (GLAPIENTRYP PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y
	;	);
	typedef void (APIENTRY * PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS2FMESAPROC) (GLfloat x, GLfloat y);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS2FMESAPROC) (GLfloat x, GLfloat y);
	typedef void (APIENTRY * PFNGLWINDOWPOS2FVMESAPROC) (const GLfloat *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS2FVMESAPROC) (const GLfloat *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS2IMESAPROC) (GLint x, GLint y);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS2IMESAPROC) (GLint x, GLint y);
	typedef void (APIENTRY * PFNGLWINDOWPOS2IVMESAPROC) (const GLint *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS2IVMESAPROC) (const GLint *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS2SMESAPROC) (GLshort x, GLshort y);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS2SMESAPROC) (GLshort x, GLshort y);
	typedef void (APIENTRY * PFNGLWINDOWPOS2SVMESAPROC) (const GLshort *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS2SVMESAPROC) (const GLshort *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS3DMESAPROC) (GLdouble x, GLdouble y,	typedef void (GLAPIENTRYP PFNGLWINDOWPOS3DMESAPROC) (GLdouble x, GLdouble y
	GLdouble z);	, GLdouble z);
	typedef void (APIENTRY * PFNGLWINDOWPOS3DVMESAPROC) (const GLdouble *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS3DVMESAPROC) (const GLdouble *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS3FMESAPROC) (GLfloat x, GLfloat y, G	typedef void (GLAPIENTRYP PFNGLWINDOWPOS3FMESAPROC) (GLfloat x, GLfloat y,
	Lfloat z);	GLfloat z);
	typedef void (APIENTRY * PFNGLWINDOWPOS3FVMESAPROC) (const GLfloat *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS3FVMESAPROC) (const GLfloat *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS3IMESAPROC) (GLint x, GLint y, GLint	typedef void (GLAPIENTRYP PFNGLWINDOWPOS3IMESAPROC) (GLint x, GLint y, GLin
	z);	t z);
	typedef void (APIENTRY * PFNGLWINDOWPOS3IVMESAPROC) (const GLint *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS3IVMESAPROC) (const GLint *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS3SMESAPROC) (GLshort x, GLshort y, G	typedef void (GLAPIENTRYP PFNGLWINDOWPOS3SMESAPROC) (GLshort x, GLshort y,
	Lshort z);	GLshort z);
	typedef void (APIENTRY * PFNGLWINDOWPOS3SVMESAPROC) (const GLshort *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS3SVMESAPROC) (const GLshort *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS4DMESAPROC) (GLdouble x, GLdouble y,	typedef void (GLAPIENTRYP PFNGLWINDOWPOS4DMESAPROC) (GLdouble x, GLdouble y
	GLdouble z, GLdouble w);	, GLdouble z, GLdouble w);
	typedef void (APIENTRY * PFNGLWINDOWPOS4DVMESAPROC) (const GLdouble *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS4DVMESAPROC) (const GLdouble *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS4FMESAPROC) (GLfloat x, GLfloat y, G	typedef void (GLAPIENTRYP PFNGLWINDOWPOS4FMESAPROC) (GLfloat x, GLfloat y,
	Lfloat z, GLfloat w);	GLfloat z, GLfloat w);
	typedef void (APIENTRY * PFNGLWINDOWPOS4FVMESAPROC) (const GLfloat *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS4FVMESAPROC) (const GLfloat *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS4IMESAPROC) (GLint x, GLint y, GLint	typedef void (GLAPIENTRYP PFNGLWINDOWPOS4IMESAPROC) (GLint x, GLint y, GLin
	z, GLint w);	t z, GLint w);
	typedef void (APIENTRY * PFNGLWINDOWPOS4IVMESAPROC) (const GLint *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS4IVMESAPROC) (const GLint *v);
	typedef void (APIENTRY * PFNGLWINDOWPOS4SMESAPROC) (GLshort x, GLshort y, G	typedef void (GLAPIENTRYP PFNGLWINDOWPOS4SMESAPROC) (GLshort x, GLshort y,
	Lshort z, GLshort w);	GLshort z, GLshort w);
	typedef void (APIENTRY * PFNGLWINDOWPOS4SVMESAPROC) (const GLshort *v);	typedef void (GLAPIENTRYP PFNGLWINDOWPOS4SVMESAPROC) (const GLshort *v);
		#endif

		#ifndef GL_EXT_texture_compression_s3tc
		#define GL_EXT_texture_compression_s3tc 1
	#endif	#endif

	#ifndef GL_IBM_cull_vertex	#ifndef GL_IBM_cull_vertex
	#define GL_IBM_cull_vertex 1	#define GL_IBM_cull_vertex 1
	#endif	#endif

	#ifndef GL_IBM_multimode_draw_arrays	#ifndef GL_IBM_multimode_draw_arrays
	#define GL_IBM_multimode_draw_arrays 1	#define GL_IBM_multimode_draw_arrays 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glMultiModeDrawArraysIBM (GLenum, const GLint *, const	GLAPI void GLAPIENTRY glMultiModeDrawArraysIBM (const GLenum *, const GLint
	GLsizei *, GLsizei, GLint);	, const GLsizei , GLsizei, GLint);
	extern void APIENTRY glMultiModeDrawElementsIBM (const GLenum *, const GLsi	GLAPI void GLAPIENTRY glMultiModeDrawElementsIBM (const GLenum *, const GLs
	zei , GLenum, const GLvoid *, GLsizei, GLint);	izei , GLenum, const GLvoid const *, GLsizei, GLint);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLMULTIMODEDRAWARRAYSIBMPROC) (GLenum mode, con	typedef void (GLAPIENTRYP PFNGLMULTIMODEDRAWARRAYSIBMPROC) (const GLenum *m
	st GLint first, const GLsizei count, GLsizei primcount, GLint modestride)	ode, const GLint first, const GLsizei count, GLsizei primcount, GLint mod
	;	estride);
	typedef void (APIENTRY * PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum *	typedef void (GLAPIENTRYP PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum
	mode, const GLsizei count, GLenum type, const GLvoid *indices, GLsizei pr	mode, const GLsizei count, GLenum type, const GLvoid* const *indices, GLs
	imcount, GLint modestride);	izei primcount, GLint modestride);
	#endif	#endif

	#ifndef GL_IBM_vertex_array_lists	#ifndef GL_IBM_vertex_array_lists
	#define GL_IBM_vertex_array_lists 1	#define GL_IBM_vertex_array_lists 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glColorPointerListIBM (GLint, GLenum, GLint, const GLv	GLAPI void GLAPIENTRY glColorPointerListIBM (GLint, GLenum, GLint, const GL
	oid* *, GLint);	void* *, GLint);
	extern void APIENTRY glSecondaryColorPointerListIBM (GLint, GLenum, GLint,	GLAPI void GLAPIENTRY glSecondaryColorPointerListIBM (GLint, GLenum, GLint,
	const GLvoid* *, GLint);	const GLvoid* *, GLint);
	extern void APIENTRY glEdgeFlagPointerListIBM (GLint, const GLboolean* *, G	GLAPI void GLAPIENTRY glEdgeFlagPointerListIBM (GLint, const GLboolean* *,
	Lint);	GLint);
	extern void APIENTRY glFogCoordPointerListIBM (GLenum, GLint, const GLvoid*	GLAPI void GLAPIENTRY glFogCoordPointerListIBM (GLenum, GLint, const GLvoid
	*, GLint);	* *, GLint);
	extern void APIENTRY glIndexPointerListIBM (GLenum, GLint, const GLvoid* *,	GLAPI void GLAPIENTRY glIndexPointerListIBM (GLenum, GLint, const GLvoid* *
	GLint);	, GLint);
	extern void APIENTRY glNormalPointerListIBM (GLenum, GLint, const GLvoid* *	GLAPI void GLAPIENTRY glNormalPointerListIBM (GLenum, GLint, const GLvoid*
	, GLint);	*, GLint);
	extern void APIENTRY glTexCoordPointerListIBM (GLint, GLenum, GLint, const	GLAPI void GLAPIENTRY glTexCoordPointerListIBM (GLint, GLenum, GLint, const
	GLvoid* *, GLint);	GLvoid* *, GLint);
	extern void APIENTRY glVertexPointerListIBM (GLint, GLenum, GLint, const GL	GLAPI void GLAPIENTRY glVertexPointerListIBM (GLint, GLenum, GLint, const G
	void* *, GLint);	Lvoid* *, GLint);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum	typedef void (GLAPIENTRYP PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum
	type, GLint stride, const GLvoid* *pointer, GLint ptrstride);	type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
	typedef void (APIENTRY * PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint size	typedef void (GLAPIENTRYP PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint siz
	, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);	e, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
	typedef void (APIENTRY * PFNGLEDGEFLAGPOINTERLISTIBMPROC) (GLint stride, co	typedef void (GLAPIENTRYP PFNGLEDGEFLAGPOINTERLISTIBMPROC) (GLint stride, c
	nst GLboolean* *pointer, GLint ptrstride);	onst GLboolean* *pointer, GLint ptrstride);
	typedef void (APIENTRY * PFNGLFOGCOORDPOINTERLISTIBMPROC) (GLenum type, GLi	typedef void (GLAPIENTRYP PFNGLFOGCOORDPOINTERLISTIBMPROC) (GLenum type, GL
	nt stride, const GLvoid* *pointer, GLint ptrstride);	int stride, const GLvoid* *pointer, GLint ptrstride);
	typedef void (APIENTRY * PFNGLINDEXPOINTERLISTIBMPROC) (GLenum type, GLint	typedef void (GLAPIENTRYP PFNGLINDEXPOINTERLISTIBMPROC) (GLenum type, GLint
	stride, const GLvoid* *pointer, GLint ptrstride);	stride, const GLvoid* *pointer, GLint ptrstride);
	typedef void (APIENTRY * PFNGLNORMALPOINTERLISTIBMPROC) (GLenum type, GLint	typedef void (GLAPIENTRYP PFNGLNORMALPOINTERLISTIBMPROC) (GLenum type, GLin
	stride, const GLvoid* *pointer, GLint ptrstride);	t stride, const GLvoid* *pointer, GLint ptrstride);
	typedef void (APIENTRY * PFNGLTEXCOORDPOINTERLISTIBMPROC) (GLint size, GLen	typedef void (GLAPIENTRYP PFNGLTEXCOORDPOINTERLISTIBMPROC) (GLint size, GLe
	um type, GLint stride, const GLvoid* *pointer, GLint ptrstride);	num type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
	typedef void (APIENTRY * PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum	typedef void (GLAPIENTRYP PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenu
	type, GLint stride, const GLvoid* *pointer, GLint ptrstride);	m type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
	#endif	#endif

	#ifndef GL_SGIX_subsample	#ifndef GL_SGIX_subsample
	#define GL_SGIX_subsample 1	#define GL_SGIX_subsample 1
	#endif	#endif

	#ifndef GL_SGIX_ycrcba	#ifndef GL_SGIX_ycrcba
	#define GL_SGIX_ycrcba 1	#define GL_SGIX_ycrcba 1
	#endif	#endif


	skipping to change at line 2886	skipping to change at line 5786
	#define GL_3DFX_texture_compression_FXT1 1	#define GL_3DFX_texture_compression_FXT1 1
	#endif	#endif

	#ifndef GL_3DFX_multisample	#ifndef GL_3DFX_multisample
	#define GL_3DFX_multisample 1	#define GL_3DFX_multisample 1
	#endif	#endif

	#ifndef GL_3DFX_tbuffer	#ifndef GL_3DFX_tbuffer
	#define GL_3DFX_tbuffer 1	#define GL_3DFX_tbuffer 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glTbufferMask3DFX (GLuint);	GLAPI void GLAPIENTRY glTbufferMask3DFX (GLuint);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLTBUFFERMASK3DFXPROC) (GLuint mask);	typedef void (GLAPIENTRYP PFNGLTBUFFERMASK3DFXPROC) (GLuint mask);
	#endif	#endif

	#ifndef GL_EXT_multisample	#ifndef GL_EXT_multisample
	#define GL_EXT_multisample 1	#define GL_EXT_multisample 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glSampleMaskEXT (GLclampf, GLboolean);	GLAPI void GLAPIENTRY glSampleMaskEXT (GLclampf, GLboolean);
	extern void APIENTRY glSamplePatternEXT (GLenum);	GLAPI void GLAPIENTRY glSamplePatternEXT (GLenum);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolean	typedef void (GLAPIENTRYP PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolea
	invert);	n invert);
	typedef void (APIENTRY * PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern);	typedef void (GLAPIENTRYP PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern);
	#endif	#endif


	#ifndef GL_SGI_vertex_preclip	#ifndef GL_SGIX_vertex_preclip
	#define GL_SGI_vertex_preclip 1	#define GL_SGIX_vertex_preclip 1
	#endif	#endif

	#ifndef GL_SGIX_convolution_accuracy	#ifndef GL_SGIX_convolution_accuracy
	#define GL_SGIX_convolution_accuracy 1	#define GL_SGIX_convolution_accuracy 1
	#endif	#endif

	#ifndef GL_SGIX_resample	#ifndef GL_SGIX_resample
	#define GL_SGIX_resample 1	#define GL_SGIX_resample 1
	#endif	#endif

	#ifndef GL_SGIS_point_line_texgen	#ifndef GL_SGIS_point_line_texgen
	#define GL_SGIS_point_line_texgen 1	#define GL_SGIS_point_line_texgen 1
	#endif	#endif

	#ifndef GL_SGIS_texture_color_mask	#ifndef GL_SGIS_texture_color_mask
	#define GL_SGIS_texture_color_mask 1	#define GL_SGIS_texture_color_mask 1
	#ifdef GL_GLEXT_PROTOTYPES	#ifdef GL_GLEXT_PROTOTYPES

	extern void APIENTRY glTextureColorMaskSGIS (GLboolean, GLboolean, GLboolea n, GLboolean);	GLAPI void GLAPIENTRY glTextureColorMaskSGIS (GLboolean, GLboolean, GLboole an, GLboolean);
	#endif /* GL_GLEXT_PROTOTYPES */	#endif /* GL_GLEXT_PROTOTYPES */

	typedef void (APIENTRY * PFNGLTEXTURECOLORMASKSGISPROC) (GLboolean red, GLb oolean green, GLboolean blue, GLboolean alpha);	typedef void (GLAPIENTRYP PFNGLTEXTURECOLORMASKSGISPROC) (GLboolean red, GL boolean green, GLboolean blue, GLboolean alpha);
	#endif	#endif


	/* added by Cass -- this part will be auto-generated in the future*/	#ifndef GL_SGIX_igloo_interface
		#define GL_SGIX_igloo_interface 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glIglooInterfaceSGIX (GLenum, const GLvoid *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLIGLOOINTERFACESGIXPROC) (GLenum pname, const
		GLvoid *params);
		#endif


	#ifndef GL_EXT_texture_compression_s3tc	#ifndef GL_EXT_texture_env_dot3
	#define GL_EXT_texture_compression_s3tc 1	#define GL_EXT_texture_env_dot3 1
	#endif	#endif


	/* Extensions */	#ifndef GL_ATI_texture_mirror_once
	#define GL_ARB_texture_border_clamp 1	#define GL_ATI_texture_mirror_once 1
	#define GL_ARB_texture_env_combine 1	#endif
	#define GL_ARB_texture_env_dot3 1
	#define GL_EXT_texture_env_dot3 1
	#define GL_IBM_texture_mirrored_repeat 1
	#define GL_NV_evaluators 1
	#define GL_NV_fence 1
	#define GL_NV_multisample_filter_hint 1
	#define GL_NV_packed_depth_stencil 1
	#define GL_NV_register_combiners2 1
	#define GL_NV_texture_compression_vtc 1
	#define GL_NV_texture_rectangle 1
	#define GL_NV_texture_shader 1
	#define GL_NV_texture_shader2 1
	#define GL_NV_vertex_program 1
	#define GL_NV_point_sprite 1
	#define GL_NV_occlusion_query 1


	/* ARB_texture_border_clamp */	#ifndef GL_NV_fence
	#define GL_CLAMP_TO_BORDER_ARB 0x812D	#define GL_NV_fence 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glDeleteFencesNV (GLsizei, const GLuint *);
		GLAPI void GLAPIENTRY glGenFencesNV (GLsizei, GLuint *);
		GLAPI GLboolean GLAPIENTRY glIsFenceNV (GLuint);
		GLAPI GLboolean GLAPIENTRY glTestFenceNV (GLuint);
		GLAPI void GLAPIENTRY glGetFenceivNV (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glFinishFenceNV (GLuint);
		GLAPI void GLAPIENTRY glSetFenceNV (GLuint, GLenum);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLDELETEFENCESNVPROC) (GLsizei n, const GLuint
		*fences);
		typedef void (GLAPIENTRYP PFNGLGENFENCESNVPROC) (GLsizei n, GLuint *fences)
		;
		typedef GLboolean (GLAPIENTRYP PFNGLISFENCENVPROC) (GLuint fence);
		typedef GLboolean (GLAPIENTRYP PFNGLTESTFENCENVPROC) (GLuint fence);
		typedef void (GLAPIENTRYP PFNGLGETFENCEIVNVPROC) (GLuint fence, GLenum pnam
		e, GLint *params);
		typedef void (GLAPIENTRYP PFNGLFINISHFENCENVPROC) (GLuint fence);
		typedef void (GLAPIENTRYP PFNGLSETFENCENVPROC) (GLuint fence, GLenum condit
		ion);
		#endif


	/* ARB_texture_env_combine */	#ifndef GL_NV_evaluators
	#define GL_COMBINE_ARB 0x8570	#define GL_NV_evaluators 1
	#define GL_COMBINE_RGB_ARB 0x8571	#ifdef GL_GLEXT_PROTOTYPES
	#define GL_COMBINE_ALPHA_ARB 0x8572	GLAPI void GLAPIENTRY glMapControlPointsNV (GLenum, GLuint, GLenum, GLsizei
	#define GL_RGB_SCALE_ARB 0x8573	, GLsizei, GLint, GLint, GLboolean, const GLvoid *);
	#define GL_ADD_SIGNED_ARB 0x8574	GLAPI void GLAPIENTRY glMapParameterivNV (GLenum, GLenum, const GLint *);
	#define GL_INTERPOLATE_ARB 0x8575	GLAPI void GLAPIENTRY glMapParameterfvNV (GLenum, GLenum, const GLfloat *);
	#define GL_CONSTANT_ARB 0x8576	GLAPI void GLAPIENTRY glGetMapControlPointsNV (GLenum, GLuint, GLenum, GLsi
	#define GL_PRIMARY_COLOR_ARB 0x8577	zei, GLsizei, GLboolean, GLvoid *);
	#define GL_PREVIOUS_ARB 0x8578	GLAPI void GLAPIENTRY glGetMapParameterivNV (GLenum, GLenum, GLint *);
	#define GL_SOURCE0_RGB_ARB 0x8580	GLAPI void GLAPIENTRY glGetMapParameterfvNV (GLenum, GLenum, GLfloat *);
	#define GL_SOURCE1_RGB_ARB 0x8581	GLAPI void GLAPIENTRY glGetMapAttribParameterivNV (GLenum, GLuint, GLenum,
	#define GL_SOURCE2_RGB_ARB 0x8582	GLint *);
	#define GL_SOURCE0_ALPHA_ARB 0x8588	GLAPI void GLAPIENTRY glGetMapAttribParameterfvNV (GLenum, GLuint, GLenum,
	#define GL_SOURCE1_ALPHA_ARB 0x8589	GLfloat *);
	#define GL_SOURCE2_ALPHA_ARB 0x858A	GLAPI void GLAPIENTRY glEvalMapsNV (GLenum, GLenum);
	#define GL_OPERAND0_RGB_ARB 0x8590	#endif /* GL_GLEXT_PROTOTYPES */
	#define GL_OPERAND1_RGB_ARB 0x8591	typedef void (GLAPIENTRYP PFNGLMAPCONTROLPOINTSNVPROC) (GLenum target, GLui
	#define GL_OPERAND2_RGB_ARB 0x8592	nt index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLin
	#define GL_OPERAND0_ALPHA_ARB 0x8598	t vorder, GLboolean packed, const GLvoid *points);
	#define GL_OPERAND1_ALPHA_ARB 0x8599	typedef void (GLAPIENTRYP PFNGLMAPPARAMETERIVNVPROC) (GLenum target, GLenum
	#define GL_OPERAND2_ALPHA_ARB 0x859A	pname, const GLint *params);
	#define GL_SUBTRACT_ARB 0x84E7	typedef void (GLAPIENTRYP PFNGLMAPPARAMETERFVNVPROC) (GLenum target, GLenum
		pname, const GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETMAPCONTROLPOINTSNVPROC) (GLenum target, G
		Luint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packe
		d, GLvoid *points);
		typedef void (GLAPIENTRYP PFNGLGETMAPPARAMETERIVNVPROC) (GLenum target, GLe
		num pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETMAPPARAMETERFVNVPROC) (GLenum target, GLe
		num pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETMAPATTRIBPARAMETERIVNVPROC) (GLenum targe
		t, GLuint index, GLenum pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETMAPATTRIBPARAMETERFVNVPROC) (GLenum targe
		t, GLuint index, GLenum pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLEVALMAPSNVPROC) (GLenum target, GLenum mode)
		;
		#endif


	/* ARB_texture_env_dot3 */	#ifndef GL_NV_packed_depth_stencil
	#define GL_DOT3_RGB_ARB 0x86AE	#define GL_NV_packed_depth_stencil 1
	#define GL_DOT3_RGBA_ARB 0x86AF	#endif


	/* EXT_texture_env_dot3 */	#ifndef GL_NV_register_combiners2
	#define GL_DOT3_RGB_EXT 0x8740	#define GL_NV_register_combiners2 1
	#define GL_DOT3_RGBA_EXT 0x8741	#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glCombinerStageParameterfvNV (GLenum, GLenum, const G
		Lfloat *);
		GLAPI void GLAPIENTRY glGetCombinerStageParameterfvNV (GLenum, GLenum, GLfl
		oat *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stag
		e, GLenum pname, const GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum s
		tage, GLenum pname, GLfloat *params);
		#endif


	/* IBM_texture_mirrored_repeat */	#ifndef GL_NV_texture_compression_vtc
	#define GL_MIRRORED_REPEAT_IBM 0x8370	#define GL_NV_texture_compression_vtc 1
		#endif


	/* NV_vertex_program */	#ifndef GL_NV_texture_rectangle
	#define GL_VERTEX_PROGRAM_NV 0x8620	#define GL_NV_texture_rectangle 1
	#define GL_VERTEX_STATE_PROGRAM_NV 0x8621	#endif
	#define GL_ATTRIB_ARRAY_SIZE_NV 0x8623
	#define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624
	#define GL_ATTRIB_ARRAY_TYPE_NV 0x8625
	#define GL_CURRENT_ATTRIB_NV 0x8626
	#define GL_PROGRAM_LENGTH_NV 0x8627
	#define GL_PROGRAM_STRING_NV 0x8628
	#define GL_MODELVIEW_PROJECTION_NV 0x8629
	#define GL_IDENTITY_NV 0x862A
	#define GL_INVERSE_NV 0x862B
	#define GL_TRANSPOSE_NV 0x862C
	#define GL_INVERSE_TRANSPOSE_NV 0x862D
	#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E
	#define GL_MAX_TRACK_MATRICES_NV 0x862F
	#define GL_MATRIX0_NV 0x8630
	#define GL_MATRIX1_NV 0x8631
	#define GL_MATRIX2_NV 0x8632
	#define GL_MATRIX3_NV 0x8633
	#define GL_MATRIX4_NV 0x8634
	#define GL_MATRIX5_NV 0x8635
	#define GL_MATRIX6_NV 0x8636
	#define GL_MATRIX7_NV 0x8637
	#define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640
	#define GL_CURRENT_MATRIX_NV 0x8641
	#define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642
	#define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643
	#define GL_PROGRAM_PARAMETER_NV 0x8644
	#define GL_ATTRIB_ARRAY_POINTER_NV 0x8645
	#define GL_PROGRAM_TARGET_NV 0x8646
	#define GL_PROGRAM_RESIDENT_NV 0x8647
	#define GL_TRACK_MATRIX_NV 0x8648
	#define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649
	#define GL_VERTEX_PROGRAM_BINDING_NV 0x864A
	#define GL_PROGRAM_ERROR_POSITION_NV 0x864B
	#define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650
	#define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651
	#define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652
	#define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653
	#define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654
	#define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655
	#define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656
	#define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657
	#define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658
	#define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659
	#define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A
	#define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B
	#define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C
	#define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D
	#define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E
	#define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F
	#define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660
	#define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661
	#define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662
	#define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663
	#define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664
	#define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665
	#define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666
	#define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667
	#define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668
	#define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669
	#define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A
	#define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B
	#define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C
	#define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D
	#define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E
	#define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F
	#define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670
	#define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671
	#define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672
	#define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673
	#define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674
	#define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675
	#define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676
	#define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677
	#define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678
	#define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679
	#define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A
	#define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B
	#define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C
	#define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D
	#define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E
	#define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F


	/* NV_evaluators */	#ifndef GL_NV_texture_shader
	#define GL_EVAL_2D_NV 0x86C0	#define GL_NV_texture_shader 1
	#define GL_EVAL_TRIANGULAR_2D_NV 0x86C1	#endif
	#define GL_MAP_TESSELLATION_NV 0x86C2
	#define GL_MAP_ATTRIB_U_ORDER_NV 0x86C3
	#define GL_MAP_ATTRIB_V_ORDER_NV 0x86C4
	#define GL_EVAL_FRACTIONAL_TESSELLATION_NV 0x86C5
	#define GL_EVAL_VERTEX_ATTRIB0_NV 0x86C6
	#define GL_EVAL_VERTEX_ATTRIB1_NV 0x86C7
	#define GL_EVAL_VERTEX_ATTRIB2_NV 0x86C8
	#define GL_EVAL_VERTEX_ATTRIB3_NV 0x86C9
	#define GL_EVAL_VERTEX_ATTRIB4_NV 0x86CA
	#define GL_EVAL_VERTEX_ATTRIB5_NV 0x86CB
	#define GL_EVAL_VERTEX_ATTRIB6_NV 0x86CC
	#define GL_EVAL_VERTEX_ATTRIB7_NV 0x86CD
	#define GL_EVAL_VERTEX_ATTRIB8_NV 0x86CE
	#define GL_EVAL_VERTEX_ATTRIB9_NV 0x86CF
	#define GL_EVAL_VERTEX_ATTRIB10_NV 0x86D0
	#define GL_EVAL_VERTEX_ATTRIB11_NV 0x86D1
	#define GL_EVAL_VERTEX_ATTRIB12_NV 0x86D2
	#define GL_EVAL_VERTEX_ATTRIB13_NV 0x86D3
	#define GL_EVAL_VERTEX_ATTRIB14_NV 0x86D4
	#define GL_EVAL_VERTEX_ATTRIB15_NV 0x86D5
	#define GL_MAX_MAP_TESSELLATION_NV 0x86D6
	#define GL_MAX_RATIONAL_EVAL_ORDER_NV 0x86D7


	/* NV_fence */	#ifndef GL_NV_texture_shader2
	#define GL_ALL_COMPLETED_NV 0x84F2	#define GL_NV_texture_shader2 1
	#define GL_FENCE_STATUS_NV 0x84F3	#endif
	#define GL_FENCE_CONDITION_NV 0x84F4


	/* NV_occlusion_query */	#ifndef GL_NV_vertex_array_range2
	#define GL_PIXEL_COUNTER_BITS_NV 0x8864	#define GL_NV_vertex_array_range2 1
	#define GL_CURRENT_OCCLUSION_QUERY_ID_NV 0x8865	#endif
	#define GL_PIXEL_COUNT_NV 0x8866
	#define GL_PIXEL_COUNT_AVAILABLE_NV 0x8867


	/* NV_point_sprite */	#ifndef GL_NV_vertex_program
	#define GL_POINT_SPRITE_NV 0x8861	#define GL_NV_vertex_program 1
	#define GL_COORD_REPLACE_NV 0x8862	#ifdef GL_GLEXT_PROTOTYPES
	#define GL_POINT_SPRITE_R_MODE_NV 0x8863	GLAPI GLboolean GLAPIENTRY glAreProgramsResidentNV (GLsizei, const GLuint *
		, GLboolean *);
		GLAPI void GLAPIENTRY glBindProgramNV (GLenum, GLuint);
		GLAPI void GLAPIENTRY glDeleteProgramsNV (GLsizei, const GLuint *);
		GLAPI void GLAPIENTRY glExecuteProgramNV (GLenum, GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glGenProgramsNV (GLsizei, GLuint *);
		GLAPI void GLAPIENTRY glGetProgramParameterdvNV (GLenum, GLuint, GLenum, GL
		double *);
		GLAPI void GLAPIENTRY glGetProgramParameterfvNV (GLenum, GLuint, GLenum, GL
		float *);
		GLAPI void GLAPIENTRY glGetProgramivNV (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetProgramStringNV (GLuint, GLenum, GLubyte *);
		GLAPI void GLAPIENTRY glGetTrackMatrixivNV (GLenum, GLuint, GLenum, GLint *
		);
		GLAPI void GLAPIENTRY glGetVertexAttribdvNV (GLuint, GLenum, GLdouble *);
		GLAPI void GLAPIENTRY glGetVertexAttribfvNV (GLuint, GLenum, GLfloat *);
		GLAPI void GLAPIENTRY glGetVertexAttribivNV (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetVertexAttribPointervNV (GLuint, GLenum, GLvoid*
		*);
		GLAPI GLboolean GLAPIENTRY glIsProgramNV (GLuint);
		GLAPI void GLAPIENTRY glLoadProgramNV (GLenum, GLuint, GLsizei, const GLuby
		te *);
		GLAPI void GLAPIENTRY glProgramParameter4dNV (GLenum, GLuint, GLdouble, GLd
		ouble, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glProgramParameter4dvNV (GLenum, GLuint, const GLdoub
		le *);
		GLAPI void GLAPIENTRY glProgramParameter4fNV (GLenum, GLuint, GLfloat, GLfl
		oat, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glProgramParameter4fvNV (GLenum, GLuint, const GLfloa
		t *);
		GLAPI void GLAPIENTRY glProgramParameters4dvNV (GLenum, GLuint, GLuint, con
		st GLdouble *);
		GLAPI void GLAPIENTRY glProgramParameters4fvNV (GLenum, GLuint, GLuint, con
		st GLfloat *);
		GLAPI void GLAPIENTRY glRequestResidentProgramsNV (GLsizei, const GLuint *)
		;
		GLAPI void GLAPIENTRY glTrackMatrixNV (GLenum, GLuint, GLenum, GLenum);
		GLAPI void GLAPIENTRY glVertexAttribPointerNV (GLuint, GLint, GLenum, GLsiz
		ei, const GLvoid *);
		GLAPI void GLAPIENTRY glVertexAttrib1dNV (GLuint, GLdouble);
		GLAPI void GLAPIENTRY glVertexAttrib1dvNV (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib1fNV (GLuint, GLfloat);
		GLAPI void GLAPIENTRY glVertexAttrib1fvNV (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib1sNV (GLuint, GLshort);
		GLAPI void GLAPIENTRY glVertexAttrib1svNV (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib2dNV (GLuint, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glVertexAttrib2dvNV (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib2fNV (GLuint, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glVertexAttrib2fvNV (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib2sNV (GLuint, GLshort, GLshort);
		GLAPI void GLAPIENTRY glVertexAttrib2svNV (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib3dNV (GLuint, GLdouble, GLdouble, GLdou
		ble);
		GLAPI void GLAPIENTRY glVertexAttrib3dvNV (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib3fNV (GLuint, GLfloat, GLfloat, GLfloat
		);
		GLAPI void GLAPIENTRY glVertexAttrib3fvNV (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib3sNV (GLuint, GLshort, GLshort, GLshort
		);
		GLAPI void GLAPIENTRY glVertexAttrib3svNV (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib4dNV (GLuint, GLdouble, GLdouble, GLdou
		ble, GLdouble);
		GLAPI void GLAPIENTRY glVertexAttrib4dvNV (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexAttrib4fNV (GLuint, GLfloat, GLfloat, GLfloat
		, GLfloat);
		GLAPI void GLAPIENTRY glVertexAttrib4fvNV (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexAttrib4sNV (GLuint, GLshort, GLshort, GLshort
		, GLshort);
		GLAPI void GLAPIENTRY glVertexAttrib4svNV (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVertexAttrib4ubNV (GLuint, GLubyte, GLubyte, GLubyt
		e, GLubyte);
		GLAPI void GLAPIENTRY glVertexAttrib4ubvNV (GLuint, const GLubyte *);
		GLAPI void GLAPIENTRY glVertexAttribs1dvNV (GLuint, GLsizei, const GLdouble
		*);
		GLAPI void GLAPIENTRY glVertexAttribs1fvNV (GLuint, GLsizei, const GLfloat
		*);
		GLAPI void GLAPIENTRY glVertexAttribs1svNV (GLuint, GLsizei, const GLshort
		*);
		GLAPI void GLAPIENTRY glVertexAttribs2dvNV (GLuint, GLsizei, const GLdouble
		*);
		GLAPI void GLAPIENTRY glVertexAttribs2fvNV (GLuint, GLsizei, const GLfloat
		*);
		GLAPI void GLAPIENTRY glVertexAttribs2svNV (GLuint, GLsizei, const GLshort
		*);
		GLAPI void GLAPIENTRY glVertexAttribs3dvNV (GLuint, GLsizei, const GLdouble
		*);
		GLAPI void GLAPIENTRY glVertexAttribs3fvNV (GLuint, GLsizei, const GLfloat
		*);
		GLAPI void GLAPIENTRY glVertexAttribs3svNV (GLuint, GLsizei, const GLshort
		*);
		GLAPI void GLAPIENTRY glVertexAttribs4dvNV (GLuint, GLsizei, const GLdouble
		*);
		GLAPI void GLAPIENTRY glVertexAttribs4fvNV (GLuint, GLsizei, const GLfloat
		*);
		GLAPI void GLAPIENTRY glVertexAttribs4svNV (GLuint, GLsizei, const GLshort
		*);
		GLAPI void GLAPIENTRY glVertexAttribs4ubvNV (GLuint, GLsizei, const GLubyte
		*);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef GLboolean (GLAPIENTRYP PFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n,
		const GLuint programs, GLboolean residences);
		typedef void (GLAPIENTRYP PFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id
		);
		typedef void (GLAPIENTRYP PFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLui
		nt *programs);
		typedef void (GLAPIENTRYP PFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint
		id, const GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint *progr
		ams);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target,
		GLuint index, GLenum pname, GLdouble *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target,
		GLuint index, GLenum pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname
		, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum p
		name, GLubyte *program);
		typedef void (GLAPIENTRYP PFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLui
		nt address, GLenum pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLen
		um pname, GLdouble *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLen
		um pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLen
		um pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index
		, GLenum pname, GLvoid* *pointer);
		typedef GLboolean (GLAPIENTRYP PFNGLISPROGRAMNVPROC) (GLuint id);
		typedef void (GLAPIENTRYP PFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id
		, GLsizei len, const GLubyte *program);
		typedef void (GLAPIENTRYP PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GL
		uint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, G
		Luint index, const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GL
		uint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, G
		Luint index, const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target,
		GLuint index, GLuint count, const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target,
		GLuint index, GLuint count, const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, c
		onst GLuint *programs);
		typedef void (GLAPIENTRYP PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint ad
		dress, GLenum matrix, GLenum transform);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GL
		int fsize, GLenum type, GLsizei stride, const GLvoid *pointer);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdoubl
		e x);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat
		x);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort
		x);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdoubl
		e x, GLdouble y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat
		x, GLfloat y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort
		x, GLshort y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdoubl
		e x, GLdouble y, GLdouble z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat
		x, GLfloat y, GLfloat z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort
		x, GLshort y, GLshort z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdoubl
		e x, GLdouble y, GLdouble z, GLdouble w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const
		GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat
		x, GLfloat y, GLfloat z, GLfloat w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const
		GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort
		x, GLshort y, GLshort z, GLshort w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const
		GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyt
		e x, GLubyte y, GLubyte z, GLubyte w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const
		GLubyte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsiz
		ei count, const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsiz
		ei count, const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsiz
		ei count, const GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsiz
		ei count, const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsiz
		ei count, const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsiz
		ei count, const GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsiz
		ei count, const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsiz
		ei count, const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsiz
		ei count, const GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsiz
		ei count, const GLdouble *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsiz
		ei count, const GLfloat *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsiz
		ei count, const GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsi
		zei count, const GLubyte *v);
		#endif


	/* NV_texture_rectangle */	#ifndef GL_SGIX_texture_coordinate_clamp
	#define GL_TEXTURE_RECTANGLE_NV 0x84F5	#define GL_SGIX_texture_coordinate_clamp 1
	#define GL_TEXTURE_BINDING_RECTANGLE_NV 0x84F6	#endif
	#define GL_PROXY_TEXTURE_RECTANGLE_NV 0x84F7
	#define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV 0x84F8


	/* NV_texture_shader */	#ifndef GL_SGIX_scalebias_hint
	#define GL_OFFSET_TEXTURE_RECTANGLE_NV 0x864C	#define GL_SGIX_scalebias_hint 1
	#define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV 0x864D	#endif
	#define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV 0x864E
	#define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV 0x86D9
	#define GL_UNSIGNED_INT_S8_S8_8_8_NV 0x86DA
	#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB
	#define GL_DSDT_MAG_INTENSITY_NV 0x86DC
	#define GL_SHADER_CONSISTENT_NV 0x86DD
	#define GL_TEXTURE_SHADER_NV 0x86DE
	#define GL_SHADER_OPERATION_NV 0x86DF
	#define GL_CULL_MODES_NV 0x86E0
	#define GL_OFFSET_TEXTURE_MATRIX_NV 0x86E1
	#define GL_OFFSET_TEXTURE_SCALE_NV 0x86E2
	#define GL_OFFSET_TEXTURE_BIAS_NV 0x86E3
	#define GL_OFFSET_TEXTURE_2D_MATRIX_NV GL_OFFSET_TEXTURE_MATRIX_NV
	#define GL_OFFSET_TEXTURE_2D_SCALE_NV GL_OFFSET_TEXTURE_SCALE_NV
	#define GL_OFFSET_TEXTURE_2D_BIAS_NV GL_OFFSET_TEXTURE_BIAS_NV
	#define GL_PREVIOUS_TEXTURE_INPUT_NV 0x86E4
	#define GL_CONST_EYE_NV 0x86E5
	#define GL_PASS_THROUGH_NV 0x86E6
	#define GL_CULL_FRAGMENT_NV 0x86E7
	#define GL_OFFSET_TEXTURE_2D_NV 0x86E8
	#define GL_DEPENDENT_AR_TEXTURE_2D_NV 0x86E9
	#define GL_DEPENDENT_GB_TEXTURE_2D_NV 0x86EA
	#define GL_ISOTROPIC_BRDF_NV 0x86EB
	#define GL_DOT_PRODUCT_NV 0x86EC
	#define GL_DOT_PRODUCT_DEPTH_REPLACE_NV 0x86ED
	#define GL_DOT_PRODUCT_TEXTURE_2D_NV 0x86EE
	#define GL_DOT_PRODUCT_TEXTURE_3D_NV 0x86EF
	#define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV 0x86F0
	#define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV 0x86F1
	#define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV 0x86F2
	#define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV 0x86F3
	#define GL_HILO_NV 0x86F4
	#define GL_DSDT_NV 0x86F5
	#define GL_DSDT_MAG_NV 0x86F6
	#define GL_DSDT_MAG_VIB_NV 0x86F7
	#define GL_HILO16_NV 0x86F8
	#define GL_SIGNED_HILO_NV 0x86F9
	#define GL_SIGNED_HILO16_NV 0x86FA
	#define GL_SIGNED_RGBA_NV 0x86FB
	#define GL_SIGNED_RGBA8_NV 0x86FC
	#define GL_SIGNED_RGB_NV 0x86FE
	#define GL_SIGNED_RGB8_NV 0x86FF
	#define GL_SIGNED_LUMINANCE_NV 0x8701
	#define GL_SIGNED_LUMINANCE8_NV 0x8702
	#define GL_SIGNED_LUMINANCE_ALPHA_NV 0x8703
	#define GL_SIGNED_LUMINANCE8_ALPHA8_NV 0x8704
	#define GL_SIGNED_ALPHA_NV 0x8705
	#define GL_SIGNED_ALPHA8_NV 0x8706
	#define GL_SIGNED_INTENSITY_NV 0x8707
	#define GL_SIGNED_INTENSITY8_NV 0x8708
	#define GL_DSDT8_NV 0x8709
	#define GL_DSDT8_MAG8_NV 0x870A
	#define GL_DSDT8_MAG8_INTENSITY8_NV 0x870B
	#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C
	#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D
	#define GL_HI_SCALE_NV 0x870E
	#define GL_LO_SCALE_NV 0x870F
	#define GL_DS_SCALE_NV 0x8710
	#define GL_DT_SCALE_NV 0x8711
	#define GL_MAGNITUDE_SCALE_NV 0x8712
	#define GL_VIBRANCE_SCALE_NV 0x8713
	#define GL_HI_BIAS_NV 0x8714
	#define GL_LO_BIAS_NV 0x8715
	#define GL_DS_BIAS_NV 0x8716
	#define GL_DT_BIAS_NV 0x8717
	#define GL_MAGNITUDE_BIAS_NV 0x8718
	#define GL_VIBRANCE_BIAS_NV 0x8719
	#define GL_TEXTURE_BORDER_VALUES_NV 0x871A
	#define GL_TEXTURE_HI_SIZE_NV 0x871B
	#define GL_TEXTURE_LO_SIZE_NV 0x871C
	#define GL_TEXTURE_DS_SIZE_NV 0x871D
	#define GL_TEXTURE_DT_SIZE_NV 0x871E
	#define GL_TEXTURE_MAG_SIZE_NV 0x871F


	/* NV_texture_shader2 */	#ifndef GL_OML_interlace
	#define GL_DOT_PRODUCT_TEXTURE_3D_NV 0x86EF	#define GL_OML_interlace 1
		#endif


	/* NV_register_combiners2 */	#ifndef GL_OML_subsample
	#define GL_PER_STAGE_CONSTANTS_NV 0x8535	#define GL_OML_subsample 1
		#endif


	/* NV_packed_depth_stencil */	#ifndef GL_OML_resample
	#define GL_DEPTH_STENCIL_NV 0x84F9	#define GL_OML_resample 1
	#define GL_UNSIGNED_INT_24_8_NV 0x84FA	#endif


	/* NV_multisample_filter_hint */	#ifndef GL_NV_copy_depth_to_color
	#define GL_MULTISAMPLE_FILTER_HINT_NV 0x8534	#define GL_NV_copy_depth_to_color 1
		#endif


	/* NV_texture_compression_vtc */	#ifndef GL_ATI_envmap_bumpmap
		#define GL_ATI_envmap_bumpmap 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glTexBumpParameterivATI (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glTexBumpParameterfvATI (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glGetTexBumpParameterivATI (GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetTexBumpParameterfvATI (GLenum, GLfloat *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLTEXBUMPPARAMETERIVATIPROC) (GLenum pname, co
		nst GLint *param);
		typedef void (GLAPIENTRYP PFNGLTEXBUMPPARAMETERFVATIPROC) (GLenum pname, co
		nst GLfloat *param);
		typedef void (GLAPIENTRYP PFNGLGETTEXBUMPPARAMETERIVATIPROC) (GLenum pname,
		GLint *param);
		typedef void (GLAPIENTRYP PFNGLGETTEXBUMPPARAMETERFVATIPROC) (GLenum pname,
		GLfloat *param);
		#endif


	/* NV_vertex_program */	#ifndef GL_ATI_fragment_shader
	typedef GLboolean (APIENTRY * PFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, c	#define GL_ATI_fragment_shader 1
	onst GLuint programs, GLboolean residences);	#ifdef GL_GLEXT_PROTOTYPES
	typedef void (APIENTRY * PFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id)	GLAPI GLuint GLAPIENTRY glGenFragmentShadersATI (GLuint);
	;	GLAPI void GLAPIENTRY glBindFragmentShaderATI (GLuint);
	typedef void (APIENTRY * PFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLuin	GLAPI void GLAPIENTRY glDeleteFragmentShaderATI (GLuint);
	t *programs);	GLAPI void GLAPIENTRY glBeginFragmentShaderATI (void);
	typedef void (APIENTRY * PFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint	GLAPI void GLAPIENTRY glEndFragmentShaderATI (void);
	id, const GLfloat *params);	GLAPI void GLAPIENTRY glPassTexCoordATI (GLuint, GLuint, GLenum);
	typedef void (APIENTRY * PFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint *progra	GLAPI void GLAPIENTRY glSampleMapATI (GLuint, GLuint, GLenum);
	ms);	GLAPI void GLAPIENTRY glColorFragmentOp1ATI (GLenum, GLuint, GLuint, GLuint
	typedef void (APIENTRY * PFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target,	, GLuint, GLuint, GLuint);
	GLuint index, GLenum pname, GLdouble *params);	GLAPI void GLAPIENTRY glColorFragmentOp2ATI (GLenum, GLuint, GLuint, GLuint
	typedef void (APIENTRY * PFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target,	, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint);
	GLuint index, GLenum pname, GLfloat *params);	GLAPI void GLAPIENTRY glColorFragmentOp3ATI (GLenum, GLuint, GLuint, GLuint
	typedef void (APIENTRY * PFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname,	, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint);
	GLint *params);	GLAPI void GLAPIENTRY glAlphaFragmentOp1ATI (GLenum, GLuint, GLuint, GLuint
	typedef void (APIENTRY * PFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pn	, GLuint, GLuint);
	ame, GLubyte *program);	GLAPI void GLAPIENTRY glAlphaFragmentOp2ATI (GLenum, GLuint, GLuint, GLuint
	typedef void (APIENTRY * PFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuin	, GLuint, GLuint, GLuint, GLuint, GLuint);
	t address, GLenum pname, GLint *params);	GLAPI void GLAPIENTRY glAlphaFragmentOp3ATI (GLenum, GLuint, GLuint, GLuint
	typedef void (APIENTRY * PFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenu	, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint);
	m pname, GLdouble *params);	GLAPI void GLAPIENTRY glSetFragmentShaderConstantATI (GLuint, const GLfloat
	typedef void (APIENTRY * PFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenu	*);
	m pname, GLfloat *params);	#endif /* GL_GLEXT_PROTOTYPES */
	typedef void (APIENTRY * PFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenu	typedef GLuint (GLAPIENTRYP PFNGLGENFRAGMENTSHADERSATIPROC) (GLuint range);
	m pname, GLint *params);	typedef void (GLAPIENTRYP PFNGLBINDFRAGMENTSHADERATIPROC) (GLuint id);
	typedef void (APIENTRY * PFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index,	typedef void (GLAPIENTRYP PFNGLDELETEFRAGMENTSHADERATIPROC) (GLuint id);
	GLenum pname, GLvoid* *pointer);	typedef void (GLAPIENTRYP PFNGLBEGINFRAGMENTSHADERATIPROC) (void);
	typedef GLboolean (APIENTRY * PFNGLISPROGRAMNVPROC) (GLuint id);	typedef void (GLAPIENTRYP PFNGLENDFRAGMENTSHADERATIPROC) (void);
	typedef void (APIENTRY * PFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id,	typedef void (GLAPIENTRYP PFNGLPASSTEXCOORDATIPROC) (GLuint dst, GLuint coo
	GLsizei len, const GLubyte *program);	rd, GLenum swizzle);
	typedef void (APIENTRY * PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLu	typedef void (GLAPIENTRYP PFNGLSAMPLEMAPATIPROC) (GLuint dst, GLuint interp
	int index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);	, GLenum swizzle);
	typedef void (APIENTRY * PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GL	typedef void (GLAPIENTRYP PFNGLCOLORFRAGMENTOP1ATIPROC) (GLenum op, GLuint
	uint index, const GLdouble *v);	dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg
	typedef void (APIENTRY * PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLu	1Mod);
	int index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);	typedef void (GLAPIENTRYP PFNGLCOLORFRAGMENTOP2ATIPROC) (GLenum op, GLuint
	typedef void (APIENTRY * PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GL	dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg
	uint index, const GLfloat *v);	1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
	typedef void (APIENTRY * PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, G	typedef void (GLAPIENTRYP PFNGLCOLORFRAGMENTOP3ATIPROC) (GLenum op, GLuint
	Luint index, GLsizei count, const GLdouble *v);	dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg
	typedef void (APIENTRY * PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, G	1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3
	Luint index, GLsizei count, const GLfloat *v);	Rep, GLuint arg3Mod);
	typedef void (APIENTRY * PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, co	typedef void (GLAPIENTRYP PFNGLALPHAFRAGMENTOP1ATIPROC) (GLenum op, GLuint
	nst GLuint *programs);	dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
	typedef void (APIENTRY * PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint add	typedef void (GLAPIENTRYP PFNGLALPHAFRAGMENTOP2ATIPROC) (GLenum op, GLuint
	ress, GLenum matrix, GLenum transform);	dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg
	typedef void (APIENTRY * PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLi	2, GLuint arg2Rep, GLuint arg2Mod);
	nt fsize, GLenum type, GLsizei stride, const GLvoid *pointer);	typedef void (GLAPIENTRYP PFNGLALPHAFRAGMENTOP3ATIPROC) (GLenum op, GLuint
	typedef void (APIENTRY * PFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble	dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg
	x);	2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3
	typedef void (APIENTRY * PFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const G	Mod);
	Ldouble *v);	typedef void (GLAPIENTRYP PFNGLSETFRAGMENTSHADERCONSTANTATIPROC) (GLuint ds
	typedef void (APIENTRY * PFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat	t, const GLfloat *value);
	x);	#endif
	typedef void (APIENTRY * PFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const G
	Lfloat *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort
	x);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const G
	Lshort *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble
	x, GLdouble y);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const G
	Ldouble *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat
	x, GLfloat y);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const G
	Lfloat *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort
	x, GLshort y);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const G
	Lshort *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble
	x, GLdouble y, GLdouble z);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const G
	Ldouble *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat
	x, GLfloat y, GLfloat z);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const G
	Lfloat *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort
	x, GLshort y, GLshort z);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const G
	Lshort *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble
	x, GLdouble y, GLdouble z, GLdouble w);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const G
	Ldouble *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat
	x, GLfloat y, GLfloat z, GLfloat w);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const G
	Lfloat *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort
	x, GLshort y, GLshort z, GLshort w);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const G
	Lshort *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte
	x, GLubyte y, GLubyte z, GLubyte w);
	typedef void (APIENTRY * PFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const
	GLubyte *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsize
	i count, const GLdouble *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsize
	i count, const GLfloat *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsize
	i count, const GLshort *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsize
	i count, const GLdouble *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsize
	i count, const GLfloat *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsize
	i count, const GLshort *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsize
	i count, const GLdouble *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsize
	i count, const GLfloat *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsize
	i count, const GLshort *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsize
	i count, const GLdouble *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsize
	i count, const GLfloat *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsize
	i count, const GLshort *v);
	typedef void (APIENTRY * PFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsiz
	ei count, const GLubyte *v);


	/* NV_evaluators */	#ifndef GL_ATI_pn_triangles
	typedef void (APIENTRY * PFNGLMAPCONTROLPOINTSNVPROC) (GLenum target, GLuin	#define GL_ATI_pn_triangles 1
	t index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint	#ifdef GL_GLEXT_PROTOTYPES
	vorder, GLboolean packed, const GLvoid *points);	GLAPI void GLAPIENTRY glPNTrianglesiATI (GLenum, GLint);
	typedef void (APIENTRY * PFNGLMAPPARAMETERIVNVPROC) (GLenum target, GLenum	GLAPI void GLAPIENTRY glPNTrianglesfATI (GLenum, GLfloat);
	pname, const GLint *params);	#endif /* GL_GLEXT_PROTOTYPES */
	typedef void (APIENTRY * PFNGLMAPPARAMETERFVNVPROC) (GLenum target, GLenum	typedef void (GLAPIENTRYP PFNGLPNTRIANGLESIATIPROC) (GLenum pname, GLint pa
	pname, const GLfloat *params);	ram);
	typedef void (APIENTRY * PFNGLGETMAPCONTROLPOINTSNVPROC) (GLenum target, GL	typedef void (GLAPIENTRYP PFNGLPNTRIANGLESFATIPROC) (GLenum pname, GLfloat
	uint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed	param);
	, GLvoid *points);	#endif
	typedef void (APIENTRY * PFNGLGETMAPPARAMETERIVNVPROC) (GLenum target, GLen
	um pname, GLint *params);
	typedef void (APIENTRY * PFNGLGETMAPPARAMETERFVNVPROC) (GLenum target, GLen
	um pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLGETMAPATTRIBPARAMETERIVNVPROC) (GLenum target
	, GLuint index, GLenum pname, GLint *params);
	typedef void (APIENTRY * PFNGLGETMAPATTRIBPARAMETERFVNVPROC) (GLenum target
	, GLuint index, GLenum pname, GLfloat *params);
	typedef void (APIENTRY * PFNGLEVALMAPSNVPROC) (GLenum target, GLenum mode);


	/* NV_fence */	#ifndef GL_ATI_vertex_array_object
	typedef void (APIENTRY * PFNGLDELETEFENCESNVPROC) (GLsizei n, const GLuint	#define GL_ATI_vertex_array_object 1
	*fences);	#ifdef GL_GLEXT_PROTOTYPES
	typedef void (APIENTRY * PFNGLGENFENCESNVPROC) (GLsizei n, GLuint *fences);	GLAPI GLuint GLAPIENTRY glNewObjectBufferATI (GLsizei, const GLvoid *, GLen
	typedef GLboolean (APIENTRY * PFNGLISFENCENVPROC) (GLuint fence);	um);
	typedef GLboolean (APIENTRY * PFNGLTESTFENCENVPROC) (GLuint fence);	GLAPI GLboolean GLAPIENTRY glIsObjectBufferATI (GLuint);
	typedef void (APIENTRY * PFNGLGETFENCEIVNVPROC) (GLuint fence, GLenum pname	GLAPI void GLAPIENTRY glUpdateObjectBufferATI (GLuint, GLuint, GLsizei, con
	, GLint *params);	st GLvoid *, GLenum);
	typedef void (APIENTRY * PFNGLFINISHFENCENVPROC) (GLuint fence);	GLAPI void GLAPIENTRY glGetObjectBufferfvATI (GLuint, GLenum, GLfloat *);
	typedef void (APIENTRY * PFNGLSETFENCENVPROC) (GLuint fence, GLenum conditi	GLAPI void GLAPIENTRY glGetObjectBufferivATI (GLuint, GLenum, GLint *);
	on);	GLAPI void GLAPIENTRY glFreeObjectBufferATI (GLuint);
		GLAPI void GLAPIENTRY glArrayObjectATI (GLenum, GLint, GLenum, GLsizei, GLu
		int, GLuint);
		GLAPI void GLAPIENTRY glGetArrayObjectfvATI (GLenum, GLenum, GLfloat *);
		GLAPI void GLAPIENTRY glGetArrayObjectivATI (GLenum, GLenum, GLint *);
		GLAPI void GLAPIENTRY glVariantArrayObjectATI (GLuint, GLenum, GLsizei, GLu
		int, GLuint);
		GLAPI void GLAPIENTRY glGetVariantArrayObjectfvATI (GLuint, GLenum, GLfloat
		*);
		GLAPI void GLAPIENTRY glGetVariantArrayObjectivATI (GLuint, GLenum, GLint *
		);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef GLuint (GLAPIENTRYP PFNGLNEWOBJECTBUFFERATIPROC) (GLsizei size, con
		st GLvoid *pointer, GLenum usage);
		typedef GLboolean (GLAPIENTRYP PFNGLISOBJECTBUFFERATIPROC) (GLuint buffer);
		typedef void (GLAPIENTRYP PFNGLUPDATEOBJECTBUFFERATIPROC) (GLuint buffer, G
		Luint offset, GLsizei size, const GLvoid *pointer, GLenum preserve);
		typedef void (GLAPIENTRYP PFNGLGETOBJECTBUFFERFVATIPROC) (GLuint buffer, GL
		enum pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETOBJECTBUFFERIVATIPROC) (GLuint buffer, GL
		enum pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLFREEOBJECTBUFFERATIPROC) (GLuint buffer);
		typedef void (GLAPIENTRYP PFNGLARRAYOBJECTATIPROC) (GLenum array, GLint siz
		e, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
		typedef void (GLAPIENTRYP PFNGLGETARRAYOBJECTFVATIPROC) (GLenum array, GLen
		um pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETARRAYOBJECTIVATIPROC) (GLenum array, GLen
		um pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLVARIANTARRAYOBJECTATIPROC) (GLuint id, GLenu
		m type, GLsizei stride, GLuint buffer, GLuint offset);
		typedef void (GLAPIENTRYP PFNGLGETVARIANTARRAYOBJECTFVATIPROC) (GLuint id,
		GLenum pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETVARIANTARRAYOBJECTIVATIPROC) (GLuint id,
		GLenum pname, GLint *params);
		#endif


	/* NV_occlusion_query */	#ifndef GL_EXT_vertex_shader
	typedef void (APIENTRY * PFNGLGENOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuint	#define GL_EXT_vertex_shader 1
	*ids);	#ifdef GL_GLEXT_PROTOTYPES
	typedef void (APIENTRY * PFNGLDELETEOCCLUSIONQUERIESNVPROC) (GLsizei n, con	GLAPI void GLAPIENTRY glBeginVertexShaderEXT (void);
	st GLuint *ids);	GLAPI void GLAPIENTRY glEndVertexShaderEXT (void);
	typedef void (APIENTRY * PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id);	GLAPI void GLAPIENTRY glBindVertexShaderEXT (GLuint);
	typedef void (APIENTRY * PFNGLBEGINOCCLUSIONQUERYNVPROC) (GLuint id);	GLAPI GLuint GLAPIENTRY glGenVertexShadersEXT (GLuint);
	typedef void (APIENTRY * PFNGLENDOCCLUSIONQUERYNVPROC) (GLvoid);	GLAPI void GLAPIENTRY glDeleteVertexShaderEXT (GLuint);
	typedef void (APIENTRY * PFNGLGETOCCLUSIONQUERYIVNVPROC) (GLuint id, GLenum	GLAPI void GLAPIENTRY glShaderOp1EXT (GLenum, GLuint, GLuint);
	pname, GLint *params);	GLAPI void GLAPIENTRY glShaderOp2EXT (GLenum, GLuint, GLuint, GLuint);
	typedef void (APIENTRY * PFNGLGETOCCLUSIONQUERYUIVNVPROC) (GLuint id, GLenu	GLAPI void GLAPIENTRY glShaderOp3EXT (GLenum, GLuint, GLuint, GLuint, GLuin
	m pname, GLuint *params);	t);
		GLAPI void GLAPIENTRY glSwizzleEXT (GLuint, GLuint, GLenum, GLenum, GLenum,
		GLenum);
		GLAPI void GLAPIENTRY glWriteMaskEXT (GLuint, GLuint, GLenum, GLenum, GLenu
		m, GLenum);
		GLAPI void GLAPIENTRY glInsertComponentEXT (GLuint, GLuint, GLuint);
		GLAPI void GLAPIENTRY glExtractComponentEXT (GLuint, GLuint, GLuint);
		GLAPI GLuint GLAPIENTRY glGenSymbolsEXT (GLenum, GLenum, GLenum, GLuint);
		GLAPI void GLAPIENTRY glSetInvariantEXT (GLuint, GLenum, const GLvoid *);
		GLAPI void GLAPIENTRY glSetLocalConstantEXT (GLuint, GLenum, const GLvoid *
		);
		GLAPI void GLAPIENTRY glVariantbvEXT (GLuint, const GLbyte *);
		GLAPI void GLAPIENTRY glVariantsvEXT (GLuint, const GLshort *);
		GLAPI void GLAPIENTRY glVariantivEXT (GLuint, const GLint *);
		GLAPI void GLAPIENTRY glVariantfvEXT (GLuint, const GLfloat *);
		GLAPI void GLAPIENTRY glVariantdvEXT (GLuint, const GLdouble *);
		GLAPI void GLAPIENTRY glVariantubvEXT (GLuint, const GLubyte *);
		GLAPI void GLAPIENTRY glVariantusvEXT (GLuint, const GLushort *);
		GLAPI void GLAPIENTRY glVariantuivEXT (GLuint, const GLuint *);
		GLAPI void GLAPIENTRY glVariantPointerEXT (GLuint, GLenum, GLuint, const GL
		void *);
		GLAPI void GLAPIENTRY glEnableVariantClientStateEXT (GLuint);
		GLAPI void GLAPIENTRY glDisableVariantClientStateEXT (GLuint);
		GLAPI GLuint GLAPIENTRY glBindLightParameterEXT (GLenum, GLenum);
		GLAPI GLuint GLAPIENTRY glBindMaterialParameterEXT (GLenum, GLenum);
		GLAPI GLuint GLAPIENTRY glBindTexGenParameterEXT (GLenum, GLenum, GLenum);
		GLAPI GLuint GLAPIENTRY glBindTextureUnitParameterEXT (GLenum, GLenum);
		GLAPI GLuint GLAPIENTRY glBindParameterEXT (GLenum);
		GLAPI GLboolean GLAPIENTRY glIsVariantEnabledEXT (GLuint, GLenum);
		GLAPI void GLAPIENTRY glGetVariantBooleanvEXT (GLuint, GLenum, GLboolean *)
		;
		GLAPI void GLAPIENTRY glGetVariantIntegervEXT (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetVariantFloatvEXT (GLuint, GLenum, GLfloat *);
		GLAPI void GLAPIENTRY glGetVariantPointervEXT (GLuint, GLenum, GLvoid* *);
		GLAPI void GLAPIENTRY glGetInvariantBooleanvEXT (GLuint, GLenum, GLboolean
		*);
		GLAPI void GLAPIENTRY glGetInvariantIntegervEXT (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetInvariantFloatvEXT (GLuint, GLenum, GLfloat *);
		GLAPI void GLAPIENTRY glGetLocalConstantBooleanvEXT (GLuint, GLenum, GLbool
		ean *);
		GLAPI void GLAPIENTRY glGetLocalConstantIntegervEXT (GLuint, GLenum, GLint
		*);
		GLAPI void GLAPIENTRY glGetLocalConstantFloatvEXT (GLuint, GLenum, GLfloat
		*);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLBEGINVERTEXSHADEREXTPROC) (void);
		typedef void (GLAPIENTRYP PFNGLENDVERTEXSHADEREXTPROC) (void);
		typedef void (GLAPIENTRYP PFNGLBINDVERTEXSHADEREXTPROC) (GLuint id);
		typedef GLuint (GLAPIENTRYP PFNGLGENVERTEXSHADERSEXTPROC) (GLuint range);
		typedef void (GLAPIENTRYP PFNGLDELETEVERTEXSHADEREXTPROC) (GLuint id);
		typedef void (GLAPIENTRYP PFNGLSHADEROP1EXTPROC) (GLenum op, GLuint res, GL
		uint arg1);
		typedef void (GLAPIENTRYP PFNGLSHADEROP2EXTPROC) (GLenum op, GLuint res, GL
		uint arg1, GLuint arg2);
		typedef void (GLAPIENTRYP PFNGLSHADEROP3EXTPROC) (GLenum op, GLuint res, GL
		uint arg1, GLuint arg2, GLuint arg3);
		typedef void (GLAPIENTRYP PFNGLSWIZZLEEXTPROC) (GLuint res, GLuint in, GLen
		um outX, GLenum outY, GLenum outZ, GLenum outW);
		typedef void (GLAPIENTRYP PFNGLWRITEMASKEXTPROC) (GLuint res, GLuint in, GL
		enum outX, GLenum outY, GLenum outZ, GLenum outW);
		typedef void (GLAPIENTRYP PFNGLINSERTCOMPONENTEXTPROC) (GLuint res, GLuint
		src, GLuint num);
		typedef void (GLAPIENTRYP PFNGLEXTRACTCOMPONENTEXTPROC) (GLuint res, GLuint
		src, GLuint num);
		typedef GLuint (GLAPIENTRYP PFNGLGENSYMBOLSEXTPROC) (GLenum datatype, GLenu
		m storagetype, GLenum range, GLuint components);
		typedef void (GLAPIENTRYP PFNGLSETINVARIANTEXTPROC) (GLuint id, GLenum type
		, const GLvoid *addr);
		typedef void (GLAPIENTRYP PFNGLSETLOCALCONSTANTEXTPROC) (GLuint id, GLenum
		type, const GLvoid *addr);
		typedef void (GLAPIENTRYP PFNGLVARIANTBVEXTPROC) (GLuint id, const GLbyte *
		addr);
		typedef void (GLAPIENTRYP PFNGLVARIANTSVEXTPROC) (GLuint id, const GLshort
		*addr);
		typedef void (GLAPIENTRYP PFNGLVARIANTIVEXTPROC) (GLuint id, const GLint *a
		ddr);
		typedef void (GLAPIENTRYP PFNGLVARIANTFVEXTPROC) (GLuint id, const GLfloat
		*addr);
		typedef void (GLAPIENTRYP PFNGLVARIANTDVEXTPROC) (GLuint id, const GLdouble
		*addr);
		typedef void (GLAPIENTRYP PFNGLVARIANTUBVEXTPROC) (GLuint id, const GLubyte
		*addr);
		typedef void (GLAPIENTRYP PFNGLVARIANTUSVEXTPROC) (GLuint id, const GLushor
		t *addr);
		typedef void (GLAPIENTRYP PFNGLVARIANTUIVEXTPROC) (GLuint id, const GLuint
		*addr);
		typedef void (GLAPIENTRYP PFNGLVARIANTPOINTEREXTPROC) (GLuint id, GLenum ty
		pe, GLuint stride, const GLvoid *addr);
		typedef void (GLAPIENTRYP PFNGLENABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id)
		;
		typedef void (GLAPIENTRYP PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id
		);
		typedef GLuint (GLAPIENTRYP PFNGLBINDLIGHTPARAMETEREXTPROC) (GLenum light,
		GLenum value);
		typedef GLuint (GLAPIENTRYP PFNGLBINDMATERIALPARAMETEREXTPROC) (GLenum face
		, GLenum value);
		typedef GLuint (GLAPIENTRYP PFNGLBINDTEXGENPARAMETEREXTPROC) (GLenum unit,
		GLenum coord, GLenum value);
		typedef GLuint (GLAPIENTRYP PFNGLBINDTEXTUREUNITPARAMETEREXTPROC) (GLenum u
		nit, GLenum value);
		typedef GLuint (GLAPIENTRYP PFNGLBINDPARAMETEREXTPROC) (GLenum value);
		typedef GLboolean (GLAPIENTRYP PFNGLISVARIANTENABLEDEXTPROC) (GLuint id, GL
		enum cap);
		typedef void (GLAPIENTRYP PFNGLGETVARIANTBOOLEANVEXTPROC) (GLuint id, GLenu
		m value, GLboolean *data);
		typedef void (GLAPIENTRYP PFNGLGETVARIANTINTEGERVEXTPROC) (GLuint id, GLenu
		m value, GLint *data);
		typedef void (GLAPIENTRYP PFNGLGETVARIANTFLOATVEXTPROC) (GLuint id, GLenum
		value, GLfloat *data);
		typedef void (GLAPIENTRYP PFNGLGETVARIANTPOINTERVEXTPROC) (GLuint id, GLenu
		m value, GLvoid* *data);
		typedef void (GLAPIENTRYP PFNGLGETINVARIANTBOOLEANVEXTPROC) (GLuint id, GLe
		num value, GLboolean *data);
		typedef void (GLAPIENTRYP PFNGLGETINVARIANTINTEGERVEXTPROC) (GLuint id, GLe
		num value, GLint *data);
		typedef void (GLAPIENTRYP PFNGLGETINVARIANTFLOATVEXTPROC) (GLuint id, GLenu
		m value, GLfloat *data);
		typedef void (GLAPIENTRYP PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC) (GLuint id,
		GLenum value, GLboolean *data);
		typedef void (GLAPIENTRYP PFNGLGETLOCALCONSTANTINTEGERVEXTPROC) (GLuint id,
		GLenum value, GLint *data);
		typedef void (GLAPIENTRYP PFNGLGETLOCALCONSTANTFLOATVEXTPROC) (GLuint id, G
		Lenum value, GLfloat *data);
		#endif


	/* NV_point_sprite */	#ifndef GL_ATI_vertex_streams
	typedef void (APIENTRY * PFNGLPOINTPARAMETERINVPROC) (GLenum pname, int pa	#define GL_ATI_vertex_streams 1
	ram);	#ifdef GL_GLEXT_PROTOTYPES
	typedef void (APIENTRY * PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, const	GLAPI void GLAPIENTRY glVertexStream1sATI (GLenum, GLshort);
	int *params);	GLAPI void GLAPIENTRY glVertexStream1svATI (GLenum, const GLshort *);
		GLAPI void GLAPIENTRY glVertexStream1iATI (GLenum, GLint);
		GLAPI void GLAPIENTRY glVertexStream1ivATI (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glVertexStream1fATI (GLenum, GLfloat);
		GLAPI void GLAPIENTRY glVertexStream1fvATI (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexStream1dATI (GLenum, GLdouble);
		GLAPI void GLAPIENTRY glVertexStream1dvATI (GLenum, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexStream2sATI (GLenum, GLshort, GLshort);
		GLAPI void GLAPIENTRY glVertexStream2svATI (GLenum, const GLshort *);
		GLAPI void GLAPIENTRY glVertexStream2iATI (GLenum, GLint, GLint);
		GLAPI void GLAPIENTRY glVertexStream2ivATI (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glVertexStream2fATI (GLenum, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glVertexStream2fvATI (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexStream2dATI (GLenum, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glVertexStream2dvATI (GLenum, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexStream3sATI (GLenum, GLshort, GLshort, GLshor
		t);
		GLAPI void GLAPIENTRY glVertexStream3svATI (GLenum, const GLshort *);
		GLAPI void GLAPIENTRY glVertexStream3iATI (GLenum, GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glVertexStream3ivATI (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glVertexStream3fATI (GLenum, GLfloat, GLfloat, GLfloa
		t);
		GLAPI void GLAPIENTRY glVertexStream3fvATI (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexStream3dATI (GLenum, GLdouble, GLdouble, GLdo
		uble);
		GLAPI void GLAPIENTRY glVertexStream3dvATI (GLenum, const GLdouble *);
		GLAPI void GLAPIENTRY glVertexStream4sATI (GLenum, GLshort, GLshort, GLshor
		t, GLshort);
		GLAPI void GLAPIENTRY glVertexStream4svATI (GLenum, const GLshort *);
		GLAPI void GLAPIENTRY glVertexStream4iATI (GLenum, GLint, GLint, GLint, GLi
		nt);
		GLAPI void GLAPIENTRY glVertexStream4ivATI (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glVertexStream4fATI (GLenum, GLfloat, GLfloat, GLfloa
		t, GLfloat);
		GLAPI void GLAPIENTRY glVertexStream4fvATI (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glVertexStream4dATI (GLenum, GLdouble, GLdouble, GLdo
		uble, GLdouble);
		GLAPI void GLAPIENTRY glVertexStream4dvATI (GLenum, const GLdouble *);
		GLAPI void GLAPIENTRY glNormalStream3bATI (GLenum, GLbyte, GLbyte, GLbyte);
		GLAPI void GLAPIENTRY glNormalStream3bvATI (GLenum, const GLbyte *);
		GLAPI void GLAPIENTRY glNormalStream3sATI (GLenum, GLshort, GLshort, GLshor
		t);
		GLAPI void GLAPIENTRY glNormalStream3svATI (GLenum, const GLshort *);
		GLAPI void GLAPIENTRY glNormalStream3iATI (GLenum, GLint, GLint, GLint);
		GLAPI void GLAPIENTRY glNormalStream3ivATI (GLenum, const GLint *);
		GLAPI void GLAPIENTRY glNormalStream3fATI (GLenum, GLfloat, GLfloat, GLfloa
		t);
		GLAPI void GLAPIENTRY glNormalStream3fvATI (GLenum, const GLfloat *);
		GLAPI void GLAPIENTRY glNormalStream3dATI (GLenum, GLdouble, GLdouble, GLdo
		uble);
		GLAPI void GLAPIENTRY glNormalStream3dvATI (GLenum, const GLdouble *);
		GLAPI void GLAPIENTRY glClientActiveVertexStreamATI (GLenum);
		GLAPI void GLAPIENTRY glVertexBlendEnviATI (GLenum, GLint);
		GLAPI void GLAPIENTRY glVertexBlendEnvfATI (GLenum, GLfloat);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM1SATIPROC) (GLenum stream, GLsho
		rt x);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM1SVATIPROC) (GLenum stream, cons
		t GLshort *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM1IATIPROC) (GLenum stream, GLint
		x);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM1IVATIPROC) (GLenum stream, cons
		t GLint *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM1FATIPROC) (GLenum stream, GLflo
		at x);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM1FVATIPROC) (GLenum stream, cons
		t GLfloat *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM1DATIPROC) (GLenum stream, GLdou
		ble x);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM1DVATIPROC) (GLenum stream, cons
		t GLdouble *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM2SATIPROC) (GLenum stream, GLsho
		rt x, GLshort y);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM2SVATIPROC) (GLenum stream, cons
		t GLshort *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM2IATIPROC) (GLenum stream, GLint
		x, GLint y);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM2IVATIPROC) (GLenum stream, cons
		t GLint *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM2FATIPROC) (GLenum stream, GLflo
		at x, GLfloat y);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM2FVATIPROC) (GLenum stream, cons
		t GLfloat *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM2DATIPROC) (GLenum stream, GLdou
		ble x, GLdouble y);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM2DVATIPROC) (GLenum stream, cons
		t GLdouble *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM3SATIPROC) (GLenum stream, GLsho
		rt x, GLshort y, GLshort z);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM3SVATIPROC) (GLenum stream, cons
		t GLshort *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM3IATIPROC) (GLenum stream, GLint
		x, GLint y, GLint z);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM3IVATIPROC) (GLenum stream, cons
		t GLint *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM3FATIPROC) (GLenum stream, GLflo
		at x, GLfloat y, GLfloat z);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM3FVATIPROC) (GLenum stream, cons
		t GLfloat *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM3DATIPROC) (GLenum stream, GLdou
		ble x, GLdouble y, GLdouble z);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM3DVATIPROC) (GLenum stream, cons
		t GLdouble *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM4SATIPROC) (GLenum stream, GLsho
		rt x, GLshort y, GLshort z, GLshort w);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, cons
		t GLshort *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM4IATIPROC) (GLenum stream, GLint
		x, GLint y, GLint z, GLint w);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM4IVATIPROC) (GLenum stream, cons
		t GLint *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM4FATIPROC) (GLenum stream, GLflo
		at x, GLfloat y, GLfloat z, GLfloat w);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM4FVATIPROC) (GLenum stream, cons
		t GLfloat *coords);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM4DATIPROC) (GLenum stream, GLdou
		ble x, GLdouble y, GLdouble z, GLdouble w);
		typedef void (GLAPIENTRYP PFNGLVERTEXSTREAM4DVATIPROC) (GLenum stream, cons
		t GLdouble *coords);
		typedef void (GLAPIENTRYP PFNGLNORMALSTREAM3BATIPROC) (GLenum stream, GLbyt
		e nx, GLbyte ny, GLbyte nz);
		typedef void (GLAPIENTRYP PFNGLNORMALSTREAM3BVATIPROC) (GLenum stream, cons
		t GLbyte *coords);
		typedef void (GLAPIENTRYP PFNGLNORMALSTREAM3SATIPROC) (GLenum stream, GLsho
		rt nx, GLshort ny, GLshort nz);
		typedef void (GLAPIENTRYP PFNGLNORMALSTREAM3SVATIPROC) (GLenum stream, cons
		t GLshort *coords);
		typedef void (GLAPIENTRYP PFNGLNORMALSTREAM3IATIPROC) (GLenum stream, GLint
		nx, GLint ny, GLint nz);
		typedef void (GLAPIENTRYP PFNGLNORMALSTREAM3IVATIPROC) (GLenum stream, cons
		t GLint *coords);
		typedef void (GLAPIENTRYP PFNGLNORMALSTREAM3FATIPROC) (GLenum stream, GLflo
		at nx, GLfloat ny, GLfloat nz);
		typedef void (GLAPIENTRYP PFNGLNORMALSTREAM3FVATIPROC) (GLenum stream, cons
		t GLfloat *coords);
		typedef void (GLAPIENTRYP PFNGLNORMALSTREAM3DATIPROC) (GLenum stream, GLdou
		ble nx, GLdouble ny, GLdouble nz);
		typedef void (GLAPIENTRYP PFNGLNORMALSTREAM3DVATIPROC) (GLenum stream, cons
		t GLdouble *coords);
		typedef void (GLAPIENTRYP PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC) (GLenum str
		eam);
		typedef void (GLAPIENTRYP PFNGLVERTEXBLENDENVIATIPROC) (GLenum pname, GLint
		param);
		typedef void (GLAPIENTRYP PFNGLVERTEXBLENDENVFATIPROC) (GLenum pname, GLflo
		at param);
		#endif


	/* NV_register_combiners2 */	#ifndef GL_ATI_element_array
	typedef void (APIENTRY * PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage	#define GL_ATI_element_array 1
	, GLenum pname, const GLfloat *params);	#ifdef GL_GLEXT_PROTOTYPES
	typedef void (APIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum st	GLAPI void GLAPIENTRY glElementPointerATI (GLenum, const GLvoid *);
	age, GLenum pname, GLfloat *params);	GLAPI void GLAPIENTRY glDrawElementArrayATI (GLenum, GLsizei);
		GLAPI void GLAPIENTRY glDrawRangeElementArrayATI (GLenum, GLuint, GLuint, G
		Lsizei);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLELEMENTPOINTERATIPROC) (GLenum type, const G
		Lvoid *pointer);
		typedef void (GLAPIENTRYP PFNGLDRAWELEMENTARRAYATIPROC) (GLenum mode, GLsiz
		ei count);
		typedef void (GLAPIENTRYP PFNGLDRAWRANGEELEMENTARRAYATIPROC) (GLenum mode,
		GLuint start, GLuint end, GLsizei count);
		#endif

		#ifndef GL_SUN_mesh_array
		#define GL_SUN_mesh_array 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glDrawMeshArraysSUN (GLenum, GLint, GLsizei, GLsizei)
		;
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLDRAWMESHARRAYSSUNPROC) (GLenum mode, GLint f
		irst, GLsizei count, GLsizei width);
		#endif

		#ifndef GL_SUN_slice_accum
		#define GL_SUN_slice_accum 1
		#endif

		#ifndef GL_NV_multisample_filter_hint
		#define GL_NV_multisample_filter_hint 1
		#endif

		#ifndef GL_NV_depth_clamp
		#define GL_NV_depth_clamp 1
		#endif

		#ifndef GL_NV_occlusion_query
		#define GL_NV_occlusion_query 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glGenOcclusionQueriesNV (GLsizei, GLuint *);
		GLAPI void GLAPIENTRY glDeleteOcclusionQueriesNV (GLsizei, const GLuint *);
		GLAPI GLboolean GLAPIENTRY glIsOcclusionQueryNV (GLuint);
		GLAPI void GLAPIENTRY glBeginOcclusionQueryNV (GLuint);
		GLAPI void GLAPIENTRY glEndOcclusionQueryNV (void);
		GLAPI void GLAPIENTRY glGetOcclusionQueryivNV (GLuint, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGetOcclusionQueryuivNV (GLuint, GLenum, GLuint *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLGENOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuin
		t *ids);
		typedef void (GLAPIENTRYP PFNGLDELETEOCCLUSIONQUERIESNVPROC) (GLsizei n, co
		nst GLuint *ids);
		typedef GLboolean (GLAPIENTRYP PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id);
		typedef void (GLAPIENTRYP PFNGLBEGINOCCLUSIONQUERYNVPROC) (GLuint id);
		typedef void (GLAPIENTRYP PFNGLENDOCCLUSIONQUERYNVPROC) (void);
		typedef void (GLAPIENTRYP PFNGLGETOCCLUSIONQUERYIVNVPROC) (GLuint id, GLenu
		m pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETOCCLUSIONQUERYUIVNVPROC) (GLuint id, GLen
		um pname, GLuint *params);
		#endif

		#ifndef GL_NV_point_sprite
		#define GL_NV_point_sprite 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glPointParameteriNV (GLenum, GLint);
		GLAPI void GLAPIENTRY glPointParameterivNV (GLenum, const GLint *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERINVPROC) (GLenum pname, GLint
		param);
		typedef void (GLAPIENTRYP PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, const
		GLint *params);
		#endif

		#ifndef GL_NV_texture_shader3
		#define GL_NV_texture_shader3 1
		#endif

		#ifndef GL_NV_vertex_program1_1
		#define GL_NV_vertex_program1_1 1
		#endif

		#ifndef GL_EXT_shadow_funcs
		#define GL_EXT_shadow_funcs 1
		#endif

		#ifndef GL_EXT_stencil_two_side
		#define GL_EXT_stencil_two_side 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glActiveStencilFaceEXT (GLenum);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLACTIVESTENCILFACEEXTPROC) (GLenum face);
		#endif

		#ifndef GL_ATI_text_fragment_shader
		#define GL_ATI_text_fragment_shader 1
		#endif

		#ifndef GL_APPLE_client_storage
		#define GL_APPLE_client_storage 1
		#endif

		#ifndef GL_APPLE_element_array
		#define GL_APPLE_element_array 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glElementPointerAPPLE (GLenum, const GLvoid *);
		GLAPI void GLAPIENTRY glDrawElementArrayAPPLE (GLenum, GLint, GLsizei);
		GLAPI void GLAPIENTRY glDrawRangeElementArrayAPPLE (GLenum, GLuint, GLuint,
		GLint, GLsizei);
		GLAPI void GLAPIENTRY glMultiDrawElementArrayAPPLE (GLenum, const GLint *,
		const GLsizei *, GLsizei);
		GLAPI void GLAPIENTRY glMultiDrawRangeElementArrayAPPLE (GLenum, GLuint, GL
		uint, const GLint , const GLsizei , GLsizei);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLELEMENTPOINTERAPPLEPROC) (GLenum type, const
		GLvoid *pointer);
		typedef void (GLAPIENTRYP PFNGLDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, GLi
		nt first, GLsizei count);
		typedef void (GLAPIENTRYP PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode
		, GLuint start, GLuint end, GLint first, GLsizei count);
		typedef void (GLAPIENTRYP PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC) (GLenum mode
		, const GLint first, const GLsizei count, GLsizei primcount);
		typedef void (GLAPIENTRYP PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum
		mode, GLuint start, GLuint end, const GLint first, const GLsizei count,
		GLsizei primcount);
		#endif

		#ifndef GL_APPLE_fence
		#define GL_APPLE_fence 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glGenFencesAPPLE (GLsizei, GLuint *);
		GLAPI void GLAPIENTRY glDeleteFencesAPPLE (GLsizei, const GLuint *);
		GLAPI void GLAPIENTRY glSetFenceAPPLE (GLuint);
		GLAPI GLboolean GLAPIENTRY glIsFenceAPPLE (GLuint);
		GLAPI GLboolean GLAPIENTRY glTestFenceAPPLE (GLuint);
		GLAPI void GLAPIENTRY glFinishFenceAPPLE (GLuint);
		GLAPI GLboolean GLAPIENTRY glTestObjectAPPLE (GLenum, GLuint);
		GLAPI void GLAPIENTRY glFinishObjectAPPLE (GLenum, GLint);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLGENFENCESAPPLEPROC) (GLsizei n, GLuint *fenc
		es);
		typedef void (GLAPIENTRYP PFNGLDELETEFENCESAPPLEPROC) (GLsizei n, const GLu
		int *fences);
		typedef void (GLAPIENTRYP PFNGLSETFENCEAPPLEPROC) (GLuint fence);
		typedef GLboolean (GLAPIENTRYP PFNGLISFENCEAPPLEPROC) (GLuint fence);
		typedef GLboolean (GLAPIENTRYP PFNGLTESTFENCEAPPLEPROC) (GLuint fence);
		typedef void (GLAPIENTRYP PFNGLFINISHFENCEAPPLEPROC) (GLuint fence);
		typedef GLboolean (GLAPIENTRYP PFNGLTESTOBJECTAPPLEPROC) (GLenum object, GL
		uint name);
		typedef void (GLAPIENTRYP PFNGLFINISHOBJECTAPPLEPROC) (GLenum object, GLint
		name);
		#endif

		#ifndef GL_APPLE_vertex_array_object
		#define GL_APPLE_vertex_array_object 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glBindVertexArrayAPPLE (GLuint);
		GLAPI void GLAPIENTRY glDeleteVertexArraysAPPLE (GLsizei, const GLuint *);
		GLAPI void GLAPIENTRY glGenVertexArraysAPPLE (GLsizei, const GLuint *);
		GLAPI GLboolean GLAPIENTRY glIsVertexArrayAPPLE (GLuint);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLBINDVERTEXARRAYAPPLEPROC) (GLuint array);
		typedef void (GLAPIENTRYP PFNGLDELETEVERTEXARRAYSAPPLEPROC) (GLsizei n, con
		st GLuint *arrays);
		typedef void (GLAPIENTRYP PFNGLGENVERTEXARRAYSAPPLEPROC) (GLsizei n, const
		GLuint *arrays);
		typedef GLboolean (GLAPIENTRYP PFNGLISVERTEXARRAYAPPLEPROC) (GLuint array);
		#endif

		#ifndef GL_APPLE_vertex_array_range
		#define GL_APPLE_vertex_array_range 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glVertexArrayRangeAPPLE (GLsizei, GLvoid *);
		GLAPI void GLAPIENTRY glFlushVertexArrayRangeAPPLE (GLsizei, GLvoid *);
		GLAPI void GLAPIENTRY glVertexArrayParameteriAPPLE (GLenum, GLint);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLVERTEXARRAYRANGEAPPLEPROC) (GLsizei length,
		GLvoid *pointer);
		typedef void (GLAPIENTRYP PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC) (GLsizei len
		gth, GLvoid *pointer);
		typedef void (GLAPIENTRYP PFNGLVERTEXARRAYPARAMETERIAPPLEPROC) (GLenum pnam
		e, GLint param);
		#endif

		#ifndef GL_APPLE_ycbcr_422
		#define GL_APPLE_ycbcr_422 1
		#endif

		#ifndef GL_S3_s3tc
		#define GL_S3_s3tc 1
		#endif

		#ifndef GL_ATI_draw_buffers
		#define GL_ATI_draw_buffers 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glDrawBuffersATI (GLsizei, const GLenum *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLDRAWBUFFERSATIPROC) (GLsizei n, const GLenum
		*bufs);
		#endif

		#ifndef GL_ATI_pixel_format_float
		#define GL_ATI_pixel_format_float 1
		/* This is really a WGL extension, but defines some associated GL enums.
		* ATI does not export "GL_ATI_pixel_format_float" in the GL_EXTENSIONS str
		ing.
		*/
		#endif

		#ifndef GL_ATI_texture_env_combine3
		#define GL_ATI_texture_env_combine3 1
		#endif

		#ifndef GL_ATI_texture_float
		#define GL_ATI_texture_float 1
		#endif

		#ifndef GL_NV_float_buffer
		#define GL_NV_float_buffer 1
		#endif

		#ifndef GL_NV_fragment_program
		#define GL_NV_fragment_program 1
		/* Some NV_fragment_program entry points are shared with ARB_vertex_program
		. */
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glProgramNamedParameter4fNV (GLuint, GLsizei, const G
		Lubyte *, GLfloat, GLfloat, GLfloat, GLfloat);
		GLAPI void GLAPIENTRY glProgramNamedParameter4dNV (GLuint, GLsizei, const G
		Lubyte *, GLdouble, GLdouble, GLdouble, GLdouble);
		GLAPI void GLAPIENTRY glProgramNamedParameter4fvNV (GLuint, GLsizei, const
		GLubyte , const GLfloat );
		GLAPI void GLAPIENTRY glProgramNamedParameter4dvNV (GLuint, GLsizei, const
		GLubyte , const GLdouble );
		GLAPI void GLAPIENTRY glGetProgramNamedParameterfvNV (GLuint, GLsizei, cons
		t GLubyte , GLfloat );
		GLAPI void GLAPIENTRY glGetProgramNamedParameterdvNV (GLuint, GLsizei, cons
		t GLubyte , GLdouble );
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLPROGRAMNAMEDPARAMETER4FNVPROC) (GLuint id, G
		Lsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w
		);
		typedef void (GLAPIENTRYP PFNGLPROGRAMNAMEDPARAMETER4DNVPROC) (GLuint id, G
		Lsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdoub
		le w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id,
		GLsizei len, const GLubyte name, const GLfloat v);
		typedef void (GLAPIENTRYP PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) (GLuint id,
		GLsizei len, const GLubyte name, const GLdouble v);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) (GLuint id
		, GLsizei len, const GLubyte name, GLfloat params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) (GLuint id
		, GLsizei len, const GLubyte name, GLdouble params);
		#endif

		#ifndef GL_NV_half_float
		#define GL_NV_half_float 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glVertex2hNV (GLhalfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glVertex2hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glVertex3hNV (GLhalfNV, GLhalfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glVertex3hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glVertex4hNV (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV)
		;
		GLAPI void GLAPIENTRY glVertex4hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glNormal3hNV (GLhalfNV, GLhalfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glNormal3hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glColor3hNV (GLhalfNV, GLhalfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glColor3hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glColor4hNV (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glColor4hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glTexCoord1hNV (GLhalfNV);
		GLAPI void GLAPIENTRY glTexCoord1hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glTexCoord2hNV (GLhalfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glTexCoord2hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glTexCoord3hNV (GLhalfNV, GLhalfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glTexCoord3hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glTexCoord4hNV (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfN
		V);
		GLAPI void GLAPIENTRY glTexCoord4hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glMultiTexCoord1hNV (GLenum, GLhalfNV);
		GLAPI void GLAPIENTRY glMultiTexCoord1hvNV (GLenum, const GLhalfNV *);
		GLAPI void GLAPIENTRY glMultiTexCoord2hNV (GLenum, GLhalfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glMultiTexCoord2hvNV (GLenum, const GLhalfNV *);
		GLAPI void GLAPIENTRY glMultiTexCoord3hNV (GLenum, GLhalfNV, GLhalfNV, GLha
		lfNV);
		GLAPI void GLAPIENTRY glMultiTexCoord3hvNV (GLenum, const GLhalfNV *);
		GLAPI void GLAPIENTRY glMultiTexCoord4hNV (GLenum, GLhalfNV, GLhalfNV, GLha
		lfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glMultiTexCoord4hvNV (GLenum, const GLhalfNV *);
		GLAPI void GLAPIENTRY glFogCoordhNV (GLhalfNV);
		GLAPI void GLAPIENTRY glFogCoordhvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glSecondaryColor3hNV (GLhalfNV, GLhalfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glSecondaryColor3hvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glVertexWeighthNV (GLhalfNV);
		GLAPI void GLAPIENTRY glVertexWeighthvNV (const GLhalfNV *);
		GLAPI void GLAPIENTRY glVertexAttrib1hNV (GLuint, GLhalfNV);
		GLAPI void GLAPIENTRY glVertexAttrib1hvNV (GLuint, const GLhalfNV *);
		GLAPI void GLAPIENTRY glVertexAttrib2hNV (GLuint, GLhalfNV, GLhalfNV);
		GLAPI void GLAPIENTRY glVertexAttrib2hvNV (GLuint, const GLhalfNV *);
		GLAPI void GLAPIENTRY glVertexAttrib3hNV (GLuint, GLhalfNV, GLhalfNV, GLhal
		fNV);
		GLAPI void GLAPIENTRY glVertexAttrib3hvNV (GLuint, const GLhalfNV *);
		GLAPI void GLAPIENTRY glVertexAttrib4hNV (GLuint, GLhalfNV, GLhalfNV, GLhal
		fNV, GLhalfNV);
		GLAPI void GLAPIENTRY glVertexAttrib4hvNV (GLuint, const GLhalfNV *);
		GLAPI void GLAPIENTRY glVertexAttribs1hvNV (GLuint, GLsizei, const GLhalfNV
		*);
		GLAPI void GLAPIENTRY glVertexAttribs2hvNV (GLuint, GLsizei, const GLhalfNV
		*);
		GLAPI void GLAPIENTRY glVertexAttribs3hvNV (GLuint, GLsizei, const GLhalfNV
		*);
		GLAPI void GLAPIENTRY glVertexAttribs4hvNV (GLuint, GLsizei, const GLhalfNV
		*);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLVERTEX2HNVPROC) (GLhalfNV x, GLhalfNV y);
		typedef void (GLAPIENTRYP PFNGLVERTEX2HVNVPROC) (const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLVERTEX3HNVPROC) (GLhalfNV x, GLhalfNV y, GLh
		alfNV z);
		typedef void (GLAPIENTRYP PFNGLVERTEX3HVNVPROC) (const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLVERTEX4HNVPROC) (GLhalfNV x, GLhalfNV y, GLh
		alfNV z, GLhalfNV w);
		typedef void (GLAPIENTRYP PFNGLVERTEX4HVNVPROC) (const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLNORMAL3HNVPROC) (GLhalfNV nx, GLhalfNV ny, G
		LhalfNV nz);
		typedef void (GLAPIENTRYP PFNGLNORMAL3HVNVPROC) (const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green
		, GLhalfNV blue);
		typedef void (GLAPIENTRYP PFNGLCOLOR3HVNVPROC) (const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLCOLOR4HNVPROC) (GLhalfNV red, GLhalfNV green
		, GLhalfNV blue, GLhalfNV alpha);
		typedef void (GLAPIENTRYP PFNGLCOLOR4HVNVPROC) (const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLTEXCOORD1HNVPROC) (GLhalfNV s);
		typedef void (GLAPIENTRYP PFNGLTEXCOORD1HVNVPROC) (const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLTEXCOORD2HNVPROC) (GLhalfNV s, GLhalfNV t);
		typedef void (GLAPIENTRYP PFNGLTEXCOORD2HVNVPROC) (const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLTEXCOORD3HNVPROC) (GLhalfNV s, GLhalfNV t, G
		LhalfNV r);
		typedef void (GLAPIENTRYP PFNGLTEXCOORD3HVNVPROC) (const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLTEXCOORD4HNVPROC) (GLhalfNV s, GLhalfNV t, G
		LhalfNV r, GLhalfNV q);
		typedef void (GLAPIENTRYP PFNGLTEXCOORD4HVNVPROC) (const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1HNVPROC) (GLenum target, GLhal
		fNV s);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD1HVNVPROC) (GLenum target, cons
		t GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2HNVPROC) (GLenum target, GLhal
		fNV s, GLhalfNV t);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD2HVNVPROC) (GLenum target, cons
		t GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3HNVPROC) (GLenum target, GLhal
		fNV s, GLhalfNV t, GLhalfNV r);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD3HVNVPROC) (GLenum target, cons
		t GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4HNVPROC) (GLenum target, GLhal
		fNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
		typedef void (GLAPIENTRYP PFNGLMULTITEXCOORD4HVNVPROC) (GLenum target, cons
		t GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLFOGCOORDHNVPROC) (GLhalfNV fog);
		typedef void (GLAPIENTRYP PFNGLFOGCOORDHVNVPROC) (const GLhalfNV *fog);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3HNVPROC) (GLhalfNV red, GLhal
		fNV green, GLhalfNV blue);
		typedef void (GLAPIENTRYP PFNGLSECONDARYCOLOR3HVNVPROC) (const GLhalfNV *v)
		;
		typedef void (GLAPIENTRYP PFNGLVERTEXWEIGHTHNVPROC) (GLhalfNV weight);
		typedef void (GLAPIENTRYP PFNGLVERTEXWEIGHTHVNVPROC) (const GLhalfNV *weigh
		t);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1HNVPROC) (GLuint index, GLhalfN
		V x);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB1HVNVPROC) (GLuint index, const
		GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2HNVPROC) (GLuint index, GLhalfN
		V x, GLhalfNV y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB2HVNVPROC) (GLuint index, const
		GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3HNVPROC) (GLuint index, GLhalfN
		V x, GLhalfNV y, GLhalfNV z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB3HVNVPROC) (GLuint index, const
		GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4HNVPROC) (GLuint index, GLhalfN
		V x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIB4HVNVPROC) (GLuint index, const
		GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS1HVNVPROC) (GLuint index, GLsiz
		ei n, const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS2HVNVPROC) (GLuint index, GLsiz
		ei n, const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS3HVNVPROC) (GLuint index, GLsiz
		ei n, const GLhalfNV *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBS4HVNVPROC) (GLuint index, GLsiz
		ei n, const GLhalfNV *v);
		#endif

		#ifndef GL_NV_pixel_data_range
		#define GL_NV_pixel_data_range 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glPixelDataRangeNV (GLenum, GLsizei, GLvoid *);
		GLAPI void GLAPIENTRY glFlushPixelDataRangeNV (GLenum);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLPIXELDATARANGENVPROC) (GLenum target, GLsize
		i length, GLvoid *pointer);
		typedef void (GLAPIENTRYP PFNGLFLUSHPIXELDATARANGENVPROC) (GLenum target);
		#endif

		#ifndef GL_NV_primitive_restart
		#define GL_NV_primitive_restart 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glPrimitiveRestartNV (void);
		GLAPI void GLAPIENTRY glPrimitiveRestartIndexNV (GLuint);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLPRIMITIVERESTARTNVPROC) (void);
		typedef void (GLAPIENTRYP PFNGLPRIMITIVERESTARTINDEXNVPROC) (GLuint index);
		#endif

		#ifndef GL_NV_texture_expand_normal
		#define GL_NV_texture_expand_normal 1
		#endif

		#ifndef GL_NV_vertex_program2
		#define GL_NV_vertex_program2 1
		#endif

		#ifndef GL_ATI_map_object_buffer
		#define GL_ATI_map_object_buffer 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI GLvoid* GLAPIENTRY glMapObjectBufferATI (GLuint);
		GLAPI void GLAPIENTRY glUnmapObjectBufferATI (GLuint);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef GLvoid* (GLAPIENTRYP PFNGLMAPOBJECTBUFFERATIPROC) (GLuint buffer);
		typedef void (GLAPIENTRYP PFNGLUNMAPOBJECTBUFFERATIPROC) (GLuint buffer);
		#endif

		#ifndef GL_ATI_separate_stencil
		#define GL_ATI_separate_stencil 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glStencilOpSeparateATI (GLenum, GLenum, GLenum, GLenu
		m);
		GLAPI void GLAPIENTRY glStencilFuncSeparateATI (GLenum, GLenum, GLint, GLui
		nt);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLSTENCILOPSEPARATEATIPROC) (GLenum face, GLen
		um sfail, GLenum dpfail, GLenum dppass);
		typedef void (GLAPIENTRYP PFNGLSTENCILFUNCSEPARATEATIPROC) (GLenum frontfun
		c, GLenum backfunc, GLint ref, GLuint mask);
		#endif

		#ifndef GL_ATI_vertex_attrib_array_object
		#define GL_ATI_vertex_attrib_array_object 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glVertexAttribArrayObjectATI (GLuint, GLint, GLenum,
		GLboolean, GLsizei, GLuint, GLuint);
		GLAPI void GLAPIENTRY glGetVertexAttribArrayObjectfvATI (GLuint, GLenum, GL
		float *);
		GLAPI void GLAPIENTRY glGetVertexAttribArrayObjectivATI (GLuint, GLenum, GL
		int *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBARRAYOBJECTATIPROC) (GLuint inde
		x, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint bu
		ffer, GLuint offset);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC) (GLuint
		index, GLenum pname, GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC) (GLuint
		index, GLenum pname, GLint *params);
		#endif

		#ifndef GL_OES_read_format
		#define GL_OES_read_format 1
		#endif

		#ifndef GL_EXT_depth_bounds_test
		#define GL_EXT_depth_bounds_test 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glDepthBoundsEXT (GLclampd, GLclampd);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLDEPTHBOUNDSEXTPROC) (GLclampd zmin, GLclampd
		zmax);
		#endif

		#ifndef GL_EXT_texture_mirror_clamp
		#define GL_EXT_texture_mirror_clamp 1
		#endif

		#ifndef GL_EXT_blend_equation_separate
		#define GL_EXT_blend_equation_separate 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glBlendEquationSeparateEXT (GLenum, GLenum);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLBLENDEQUATIONSEPARATEEXTPROC) (GLenum modeRG
		B, GLenum modeAlpha);
		#endif

		#ifndef GL_MESA_pack_invert
		#define GL_MESA_pack_invert 1
		#endif

		#ifndef GL_MESA_ycbcr_texture
		#define GL_MESA_ycbcr_texture 1
		#endif

		#ifndef GL_EXT_pixel_buffer_object
		#define GL_EXT_pixel_buffer_object 1
		#endif

		#ifndef GL_NV_fragment_program_option
		#define GL_NV_fragment_program_option 1
		#endif

		#ifndef GL_NV_fragment_program2
		#define GL_NV_fragment_program2 1
		#endif

		#ifndef GL_NV_vertex_program2_option
		#define GL_NV_vertex_program2_option 1
		#endif

		#ifndef GL_NV_vertex_program3
		#define GL_NV_vertex_program3 1
		#endif

		#ifndef GL_EXT_framebuffer_object
		#define GL_EXT_framebuffer_object 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI GLboolean GLAPIENTRY glIsRenderbufferEXT (GLuint);
		GLAPI void GLAPIENTRY glBindRenderbufferEXT (GLenum, GLuint);
		GLAPI void GLAPIENTRY glDeleteRenderbuffersEXT (GLsizei, const GLuint *);
		GLAPI void GLAPIENTRY glGenRenderbuffersEXT (GLsizei, GLuint *);
		GLAPI void GLAPIENTRY glRenderbufferStorageEXT (GLenum, GLenum, GLsizei, GL
		sizei);
		GLAPI void GLAPIENTRY glGetRenderbufferParameterivEXT (GLenum, GLenum, GLin
		t *);
		GLAPI GLboolean GLAPIENTRY glIsFramebufferEXT (GLuint);
		GLAPI void GLAPIENTRY glBindFramebufferEXT (GLenum, GLuint);
		GLAPI void GLAPIENTRY glDeleteFramebuffersEXT (GLsizei, const GLuint *);
		GLAPI void GLAPIENTRY glGenFramebuffersEXT (GLsizei, GLuint *);
		GLAPI GLenum GLAPIENTRY glCheckFramebufferStatusEXT (GLenum);
		GLAPI void GLAPIENTRY glFramebufferTexture1DEXT (GLenum, GLenum, GLenum, GL
		uint, GLint);
		GLAPI void GLAPIENTRY glFramebufferTexture2DEXT (GLenum, GLenum, GLenum, GL
		uint, GLint);
		GLAPI void GLAPIENTRY glFramebufferTexture3DEXT (GLenum, GLenum, GLenum, GL
		uint, GLint, GLint);
		GLAPI void GLAPIENTRY glFramebufferRenderbufferEXT (GLenum, GLenum, GLenum,
		GLuint);
		GLAPI void GLAPIENTRY glGetFramebufferAttachmentParameterivEXT (GLenum, GLe
		num, GLenum, GLint *);
		GLAPI void GLAPIENTRY glGenerateMipmapEXT (GLenum);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef GLboolean (GLAPIENTRYP PFNGLISRENDERBUFFEREXTPROC) (GLuint renderbu
		ffer);
		typedef void (GLAPIENTRYP PFNGLBINDRENDERBUFFEREXTPROC) (GLenum target, GLu
		int renderbuffer);
		typedef void (GLAPIENTRYP PFNGLDELETERENDERBUFFERSEXTPROC) (GLsizei n, cons
		t GLuint *renderbuffers);
		typedef void (GLAPIENTRYP PFNGLGENRENDERBUFFERSEXTPROC) (GLsizei n, GLuint
		*renderbuffers);
		typedef void (GLAPIENTRYP PFNGLRENDERBUFFERSTORAGEEXTPROC) (GLenum target,
		GLenum internalformat, GLsizei width, GLsizei height);
		typedef void (GLAPIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) (GLenum t
		arget, GLenum pname, GLint *params);
		typedef GLboolean (GLAPIENTRYP PFNGLISFRAMEBUFFEREXTPROC) (GLuint framebuff
		er);
		typedef void (GLAPIENTRYP PFNGLBINDFRAMEBUFFEREXTPROC) (GLenum target, GLui
		nt framebuffer);
		typedef void (GLAPIENTRYP PFNGLDELETEFRAMEBUFFERSEXTPROC) (GLsizei n, const
		GLuint *framebuffers);
		typedef void (GLAPIENTRYP PFNGLGENFRAMEBUFFERSEXTPROC) (GLsizei n, GLuint *
		framebuffers);
		typedef GLenum (GLAPIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) (GLenum tar
		get);
		typedef void (GLAPIENTRYP PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) (GLenum target,
		GLenum attachment, GLenum textarget, GLuint texture, GLint level);
		typedef void (GLAPIENTRYP PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) (GLenum target,
		GLenum attachment, GLenum textarget, GLuint texture, GLint level);
		typedef void (GLAPIENTRYP PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) (GLenum target,
		GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zo
		ffset);
		typedef void (GLAPIENTRYP PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) (GLenum targ
		et, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
		typedef void (GLAPIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)
		(GLenum target, GLenum attachment, GLenum pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGENERATEMIPMAPEXTPROC) (GLenum target);
		#endif

		#ifndef GL_GREMEDY_string_marker
		#define GL_GREMEDY_string_marker 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glStringMarkerGREMEDY (GLsizei, const GLvoid *);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLSTRINGMARKERGREMEDYPROC) (GLsizei len, const
		GLvoid *string);
		#endif

		#ifndef GL_EXT_Cg_shader
		#define GL_EXT_Cg_shader 1
		#endif

		#ifndef GL_EXT_timer_query
		#ifndef GL_COMPILER_LACKS_64BIT_INT
		#define GL_EXT_timer_query 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glGetQueryObjecti64vEXT (GLuint id, GLenum pname, GLi
		nt64EXT *params);
		GLAPI void GLAPIENTRY glGetQueryObjectui64vEXT (GLuint id, GLenum pname, GL
		uint64EXT *params);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLGETQUERYOBJECTI64VEXTPROC) (GLuint id, GLenu
		m pname, GLint64EXT *params);
		typedef void (GLAPIENTRYP PFNGLGETQUERYOBJECTUI64VEXTPROC) (GLuint id, GLen
		um pname, GLuint64EXT *params);
		#endif
		#endif

		#ifndef GL_EXT_texture_buffer_object
		#define GL_EXT_texture_buffer_object 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glTexBufferEXT (GLenum target, GLenum internalformat,
		GLuint buffer);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum int
		ernalformat, GLuint buffer);
		#endif

		#ifndef GL_NV_transform_feedback
		#define GL_NV_transform_feedback 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glBeginTransformFeedbackNV (GLenum primitiveMode);
		GLAPI void GLAPIENTRY glEndTransformFeedbackNV (void);
		GLAPI void GLAPIENTRY glTransformFeedbackAttribsNV (GLuint count, const GLi
		nt *attribs, GLenum bufferMode);
		GLAPI void GLAPIENTRY glBindBufferRangeNV (GLenum target, GLuint index, GLu
		int buffer, GLintptr offset, GLsizeiptr size);
		GLAPI void GLAPIENTRY glBindBufferOffsetNV (GLenum target, GLuint index, GL
		uint buffer, GLintptr offset);
		GLAPI void GLAPIENTRY glBindBufferBaseNV (GLenum target, GLuint index, GLui
		nt buffer);
		GLAPI void GLAPIENTRY glTransformFeedbackVaryingsNV (GLuint program, GLsize
		i count, const GLint *locations, GLenum bufferMode);
		GLAPI void GLAPIENTRY glActiveVaryingNV (GLuint program, const GLchar *name
		);
		GLAPI GLint GLAPIENTRY glGetVaryingLocationNV (GLuint program, const GLchar
		*name);
		GLAPI void GLAPIENTRY glGetActiveVaryingNV (GLuint program, GLuint index, G
		Lsizei bufSize, GLsizei length, GLsizei size, GLenum type, GLchar name)
		;
		GLAPI void GLAPIENTRY glGetTransformFeedbackVaryingNV (GLuint program, GLui
		nt index, GLint *location);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLBEGINTRANSFORMFEEDBACKNVPROC) (GLenum primit
		iveMode);
		typedef void (GLAPIENTRYP PFNGLENDTRANSFORMFEEDBACKNVPROC) (void);
		typedef void (GLAPIENTRYP PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC) (GLuint coun
		t, const GLint *attribs, GLenum bufferMode);
		typedef void (GLAPIENTRYP PFNGLBINDBUFFERRANGENVPROC) (GLenum target, GLuin
		t index, GLuint buffer, GLintptr offset, GLsizeiptr size);
		typedef void (GLAPIENTRYP PFNGLBINDBUFFEROFFSETNVPROC) (GLenum target, GLui
		nt index, GLuint buffer, GLintptr offset);
		typedef void (GLAPIENTRYP PFNGLBINDBUFFERBASENVPROC) (GLenum target, GLuint
		index, GLuint buffer);
		typedef void (GLAPIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC) (GLuint pro
		gram, GLsizei count, const GLint *locations, GLenum bufferMode);
		typedef void (GLAPIENTRYP PFNGLACTIVEVARYINGNVPROC) (GLuint program, const
		GLchar *name);
		typedef GLint (GLAPIENTRYP PFNGLGETVARYINGLOCATIONNVPROC) (GLuint program,
		const GLchar *name);
		typedef void (GLAPIENTRYP PFNGLGETACTIVEVARYINGNVPROC) (GLuint program, GLu
		int index, GLsizei bufSize, GLsizei length, GLsizei size, GLenum *type, G
		Lchar *name);
		typedef void (GLAPIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC) (GLuint p
		rogram, GLuint index, GLint *location);
		#endif

		#ifndef GL_NV_depth_buffer_float
		#define GL_NV_depth_buffer_float 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glDepthRangedNV (GLdouble zNear, GLdouble zFar);
		GLAPI void GLAPIENTRY glClearDepthdNV (GLdouble depth);
		GLAPI void GLAPIENTRY glDepthBoundsdNV (GLdouble zmin, GLdouble zmax);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLDEPTHRANGEDNVPROC) (GLdouble zNear, GLdouble
		zFar);
		typedef void (GLAPIENTRYP PFNGLCLEARDEPTHDNVPROC) (GLdouble depth);
		typedef void (GLAPIENTRYP PFNGLDEPTHBOUNDSDNVPROC) (GLdouble zmin, GLdouble
		zmax);
		#endif

		#ifndef GL_EXT_texture_compression_latc
		#define GL_EXT_texture_compression_latc 1
		#endif

		#ifndef GL_EXT_framebuffer_sRGB
		#define GL_EXT_framebuffer_sRGB 1
		#endif

		#ifndef GL_EXT_texture_shared_exponent
		#define GL_EXT_texture_shared_exponent 1
		#endif

		#ifndef GL_EXT_packed_float
		#define GL_EXT_packed_float 1
		#endif

		#ifndef GL_EXT_texture_array
		#define GL_EXT_texture_array 1
		#endif

		#ifndef GL_EXT_draw_buffers2
		#define GL_EXT_draw_buffers2 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glColorMaskIndexedEXT (GLuint index, GLboolean r, GLb
		oolean g, GLboolean b, GLboolean a);
		GLAPI void GLAPIENTRY glGetBooleanIndexedvEXT (GLenum target, GLuint index,
		GLboolean *data);
		GLAPI void GLAPIENTRY glGetIntegerIndexedvEXT (GLenum target, GLuint index,
		GLint *data);
		GLAPI void GLAPIENTRY glEnableIndexedEXT (GLenum target, GLuint index);
		GLAPI void GLAPIENTRY glDisableIndexedEXT (GLenum target, GLuint index);
		GLAPI GLboolean GLAPIENTRY glIsEnabledIndexedEXT (GLenum target, GLuint ind
		ex);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLCOLORMASKINDEXEDEXTPROC) (GLuint index, GLbo
		olean r, GLboolean g, GLboolean b, GLboolean a);
		typedef void (GLAPIENTRYP PFNGLGETBOOLEANINDEXEDVEXTPROC) (GLenum target, G
		Luint index, GLboolean *data);
		typedef void (GLAPIENTRYP PFNGLGETINTEGERINDEXEDVEXTPROC) (GLenum target, G
		Luint index, GLint *data);
		typedef void (GLAPIENTRYP PFNGLENABLEINDEXEDEXTPROC) (GLenum target, GLuint
		index);
		typedef void (GLAPIENTRYP PFNGLDISABLEINDEXEDEXTPROC) (GLenum target, GLuin
		t index);
		typedef GLboolean (GLAPIENTRYP PFNGLISENABLEDINDEXEDEXTPROC) (GLenum target
		, GLuint index);
		#endif

		#ifndef GL_EXT_texture_integer
		#define GL_EXT_texture_integer 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glTexParameterIivEXT (GLenum target, GLenum pname, co
		nst GLint *params);
		GLAPI void GLAPIENTRY glTexParameterIuivEXT (GLenum target, GLenum pname, c
		onst GLuint *params);
		GLAPI void GLAPIENTRY glGetTexParameterIivEXT (GLenum target, GLenum pname,
		GLint *params);
		GLAPI void GLAPIENTRY glGetTexParameterIuivEXT (GLenum target, GLenum pname
		, GLuint *params);
		GLAPI void GLAPIENTRY glClearColorIiEXT (GLint red, GLint green, GLint blue
		, GLint alpha);
		GLAPI void GLAPIENTRY glClearColorIuiEXT (GLuint red, GLuint green, GLuint
		blue, GLuint alpha);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLTEXPARAMETERIIVEXTPROC) (GLenum target, GLen
		um pname, const GLint *params);
		typedef void (GLAPIENTRYP PFNGLTEXPARAMETERIUIVEXTPROC) (GLenum target, GLe
		num pname, const GLuint *params);
		typedef void (GLAPIENTRYP PFNGLGETTEXPARAMETERIIVEXTPROC) (GLenum target, G
		Lenum pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETTEXPARAMETERIUIVEXTPROC) (GLenum target,
		GLenum pname, GLuint *params);
		typedef void (GLAPIENTRYP PFNGLCLEARCOLORIIEXTPROC) (GLint red, GLint green
		, GLint blue, GLint alpha);
		typedef void (GLAPIENTRYP PFNGLCLEARCOLORIUIEXTPROC) (GLuint red, GLuint gr
		een, GLuint blue, GLuint alpha);
		#endif

		#ifndef GL_EXT_bindable_uniform
		#define GL_EXT_bindable_uniform 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glUniformBufferEXT (GLuint program, GLint location, G
		Luint buffer);
		GLAPI GLint GLAPIENTRY glGetUniformBufferSizeEXT (GLuint program, GLint loc
		ation);
		GLAPI GLintptr GLAPIENTRY glGetUniformOffsetEXT (GLuint program, GLint loca
		tion);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLUNIFORMBUFFEREXTPROC) (GLuint program, GLint
		location, GLuint buffer);
		typedef GLint (GLAPIENTRYP PFNGLGETUNIFORMBUFFERSIZEEXTPROC) (GLuint progra
		m, GLint location);
		typedef GLintptr (GLAPIENTRYP PFNGLGETUNIFORMOFFSETEXTPROC) (GLuint program
		, GLint location);
		#endif

		#ifndef GL_EXT_gpu_shader4
		#define GL_EXT_gpu_shader4 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glGetUniformuivEXT (GLuint program, GLint location, G
		Luint *params);
		GLAPI void GLAPIENTRY glBindFragDataLocationEXT (GLuint program, GLuint col
		or, const GLchar *name);
		GLAPI GLint GLAPIENTRY glGetFragDataLocationEXT (GLuint program, const GLch
		ar *name);
		GLAPI void GLAPIENTRY glUniform1uiEXT (GLint location, GLuint v0);
		GLAPI void GLAPIENTRY glUniform2uiEXT (GLint location, GLuint v0, GLuint v1
		);
		GLAPI void GLAPIENTRY glUniform3uiEXT (GLint location, GLuint v0, GLuint v1
		, GLuint v2);
		GLAPI void GLAPIENTRY glUniform4uiEXT (GLint location, GLuint v0, GLuint v1
		, GLuint v2, GLuint v3);
		GLAPI void GLAPIENTRY glUniform1uivEXT (GLint location, GLsizei count, cons
		t GLuint *value);
		GLAPI void GLAPIENTRY glUniform2uivEXT (GLint location, GLsizei count, cons
		t GLuint *value);
		GLAPI void GLAPIENTRY glUniform3uivEXT (GLint location, GLsizei count, cons
		t GLuint *value);
		GLAPI void GLAPIENTRY glUniform4uivEXT (GLint location, GLsizei count, cons
		t GLuint *value);
		GLAPI void GLAPIENTRY glVertexAttribI1iEXT (GLuint index, GLint x);
		GLAPI void GLAPIENTRY glVertexAttribI2iEXT (GLuint index, GLint x, GLint y)
		;
		GLAPI void GLAPIENTRY glVertexAttribI3iEXT (GLuint index, GLint x, GLint y,
		GLint z);
		GLAPI void GLAPIENTRY glVertexAttribI4iEXT (GLuint index, GLint x, GLint y,
		GLint z, GLint w);
		GLAPI void GLAPIENTRY glVertexAttribI1uiEXT (GLuint index, GLuint x);
		GLAPI void GLAPIENTRY glVertexAttribI2uiEXT (GLuint index, GLuint x, GLuint
		y);
		GLAPI void GLAPIENTRY glVertexAttribI3uiEXT (GLuint index, GLuint x, GLuint
		y, GLuint z);
		GLAPI void GLAPIENTRY glVertexAttribI4uiEXT (GLuint index, GLuint x, GLuint
		y, GLuint z, GLuint w);
		GLAPI void GLAPIENTRY glVertexAttribI1ivEXT (GLuint index, const GLint *v);
		GLAPI void GLAPIENTRY glVertexAttribI2ivEXT (GLuint index, const GLint *v);
		GLAPI void GLAPIENTRY glVertexAttribI3ivEXT (GLuint index, const GLint *v);
		GLAPI void GLAPIENTRY glVertexAttribI4ivEXT (GLuint index, const GLint *v);
		GLAPI void GLAPIENTRY glVertexAttribI1uivEXT (GLuint index, const GLuint *v
		);
		GLAPI void GLAPIENTRY glVertexAttribI2uivEXT (GLuint index, const GLuint *v
		);
		GLAPI void GLAPIENTRY glVertexAttribI3uivEXT (GLuint index, const GLuint *v
		);
		GLAPI void GLAPIENTRY glVertexAttribI4uivEXT (GLuint index, const GLuint *v
		);
		GLAPI void GLAPIENTRY glVertexAttribI4bvEXT (GLuint index, const GLbyte *v)
		;
		GLAPI void GLAPIENTRY glVertexAttribI4svEXT (GLuint index, const GLshort *v
		);
		GLAPI void GLAPIENTRY glVertexAttribI4ubvEXT (GLuint index, const GLubyte *
		v);
		GLAPI void GLAPIENTRY glVertexAttribI4usvEXT (GLuint index, const GLushort
		*v);
		GLAPI void GLAPIENTRY glVertexAttribIPointerEXT (GLuint index, GLint size,
		GLenum type, GLsizei stride, const GLvoid *pointer);
		GLAPI void GLAPIENTRY glGetVertexAttribIivEXT (GLuint index, GLenum pname,
		GLint *params);
		GLAPI void GLAPIENTRY glGetVertexAttribIuivEXT (GLuint index, GLenum pname,
		GLuint *params);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLGETUNIFORMUIVEXTPROC) (GLuint program, GLint
		location, GLuint *params);
		typedef void (GLAPIENTRYP PFNGLBINDFRAGDATALOCATIONEXTPROC) (GLuint program
		, GLuint color, const GLchar *name);
		typedef GLint (GLAPIENTRYP PFNGLGETFRAGDATALOCATIONEXTPROC) (GLuint program
		, const GLchar *name);
		typedef void (GLAPIENTRYP PFNGLUNIFORM1UIEXTPROC) (GLint location, GLuint v
		0);
		typedef void (GLAPIENTRYP PFNGLUNIFORM2UIEXTPROC) (GLint location, GLuint v
		0, GLuint v1);
		typedef void (GLAPIENTRYP PFNGLUNIFORM3UIEXTPROC) (GLint location, GLuint v
		0, GLuint v1, GLuint v2);
		typedef void (GLAPIENTRYP PFNGLUNIFORM4UIEXTPROC) (GLint location, GLuint v
		0, GLuint v1, GLuint v2, GLuint v3);
		typedef void (GLAPIENTRYP PFNGLUNIFORM1UIVEXTPROC) (GLint location, GLsizei
		count, const GLuint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM2UIVEXTPROC) (GLint location, GLsizei
		count, const GLuint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM3UIVEXTPROC) (GLint location, GLsizei
		count, const GLuint *value);
		typedef void (GLAPIENTRYP PFNGLUNIFORM4UIVEXTPROC) (GLint location, GLsizei
		count, const GLuint *value);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI1IEXTPROC) (GLuint index, GLint
		x);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI2IEXTPROC) (GLuint index, GLint
		x, GLint y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI3IEXTPROC) (GLuint index, GLint
		x, GLint y, GLint z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI4IEXTPROC) (GLuint index, GLint
		x, GLint y, GLint z, GLint w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI1UIEXTPROC) (GLuint index, GLui
		nt x);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI2UIEXTPROC) (GLuint index, GLui
		nt x, GLuint y);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI3UIEXTPROC) (GLuint index, GLui
		nt x, GLuint y, GLuint z);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI4UIEXTPROC) (GLuint index, GLui
		nt x, GLuint y, GLuint z, GLuint w);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI1IVEXTPROC) (GLuint index, cons
		t GLint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI2IVEXTPROC) (GLuint index, cons
		t GLint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI3IVEXTPROC) (GLuint index, cons
		t GLint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI4IVEXTPROC) (GLuint index, cons
		t GLint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI1UIVEXTPROC) (GLuint index, con
		st GLuint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI2UIVEXTPROC) (GLuint index, con
		st GLuint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI3UIVEXTPROC) (GLuint index, con
		st GLuint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI4UIVEXTPROC) (GLuint index, con
		st GLuint *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI4BVEXTPROC) (GLuint index, cons
		t GLbyte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI4SVEXTPROC) (GLuint index, cons
		t GLshort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI4UBVEXTPROC) (GLuint index, con
		st GLubyte *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBI4USVEXTPROC) (GLuint index, con
		st GLushort *v);
		typedef void (GLAPIENTRYP PFNGLVERTEXATTRIBIPOINTEREXTPROC) (GLuint index,
		GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBIIVEXTPROC) (GLuint index, GL
		enum pname, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETVERTEXATTRIBIUIVEXTPROC) (GLuint index, G
		Lenum pname, GLuint *params);
		#endif

		#ifndef GL_EXT_geometry_shader4
		#define GL_EXT_geometry_shader4 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glProgramParameteriEXT (GLuint program, GLenum pname,
		GLint value);
		GLAPI void GLAPIENTRY glFramebufferTextureEXT (GLenum target, GLenum attach
		ment, GLuint texture, GLint level);
		GLAPI void GLAPIENTRY glFramebufferTextureLayerEXT (GLenum target, GLenum a
		ttachment, GLuint texture, GLint level, GLint layer);
		GLAPI void GLAPIENTRY glFramebufferTextureFaceEXT (GLenum target, GLenum at
		tachment, GLuint texture, GLint level, GLenum face);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLPROGRAMPARAMETERIEXTPROC) (GLuint program, G
		Lenum pname, GLint value);
		typedef void (GLAPIENTRYP PFNGLFRAMEBUFFERTEXTUREEXTPROC) (GLenum target, G
		Lenum attachment, GLuint texture, GLint level);
		typedef void (GLAPIENTRYP PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) (GLenum targ
		et, GLenum attachment, GLuint texture, GLint level, GLint layer);
		typedef void (GLAPIENTRYP PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC) (GLenum targe
		t, GLenum attachment, GLuint texture, GLint level, GLenum face);
		#endif

		#ifndef GL_NV_geometry_program4
		#define GL_NV_geometry_program4 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glProgramVertexLimitNV (GLenum target, GLint limit);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLPROGRAMVERTEXLIMITNVPROC) (GLenum target, GL
		int limit);
		#endif

		#ifndef GL_NV_gpu_program4
		#define GL_NV_gpu_program4 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glProgramLocalParameterI4iNV (GLenum target, GLuint i
		ndex, GLint x, GLint y, GLint z, GLint w);
		GLAPI void GLAPIENTRY glProgramLocalParameterI4ivNV (GLenum target, GLuint
		index, const GLint *params);
		GLAPI void GLAPIENTRY glProgramLocalParametersI4ivNV (GLenum target, GLuint
		index, GLsizei count, const GLint *params);
		GLAPI void GLAPIENTRY glProgramLocalParameterI4uiNV (GLenum target, GLuint
		index, GLuint x, GLuint y, GLuint z, GLuint w);
		GLAPI void GLAPIENTRY glProgramLocalParameterI4uivNV (GLenum target, GLuint
		index, const GLuint *params);
		GLAPI void GLAPIENTRY glProgramLocalParametersI4uivNV (GLenum target, GLuin
		t index, GLsizei count, const GLuint *params);
		GLAPI void GLAPIENTRY glProgramEnvParameterI4iNV (GLenum target, GLuint ind
		ex, GLint x, GLint y, GLint z, GLint w);
		GLAPI void GLAPIENTRY glProgramEnvParameterI4ivNV (GLenum target, GLuint in
		dex, const GLint *params);
		GLAPI void GLAPIENTRY glProgramEnvParametersI4ivNV (GLenum target, GLuint i
		ndex, GLsizei count, const GLint *params);
		GLAPI void GLAPIENTRY glProgramEnvParameterI4uiNV (GLenum target, GLuint in
		dex, GLuint x, GLuint y, GLuint z, GLuint w);
		GLAPI void GLAPIENTRY glProgramEnvParameterI4uivNV (GLenum target, GLuint i
		ndex, const GLuint *params);
		GLAPI void GLAPIENTRY glProgramEnvParametersI4uivNV (GLenum target, GLuint
		index, GLsizei count, const GLuint *params);
		GLAPI void GLAPIENTRY glGetProgramLocalParameterIivNV (GLenum target, GLuin
		t index, GLint *params);
		GLAPI void GLAPIENTRY glGetProgramLocalParameterIuivNV (GLenum target, GLui
		nt index, GLuint *params);
		GLAPI void GLAPIENTRY glGetProgramEnvParameterIivNV (GLenum target, GLuint
		index, GLint *params);
		GLAPI void GLAPIENTRY glGetProgramEnvParameterIuivNV (GLenum target, GLuint
		index, GLuint *params);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLPROGRAMLOCALPARAMETERI4INVPROC) (GLenum targ
		et, GLuint index, GLint x, GLint y, GLint z, GLint w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC) (GLenum tar
		get, GLuint index, const GLint *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC) (GLenum ta
		rget, GLuint index, GLsizei count, const GLint *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMLOCALPARAMETERI4UINVPROC) (GLenum tar
		get, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC) (GLenum ta
		rget, GLuint index, const GLuint *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC) (GLenum t
		arget, GLuint index, GLsizei count, const GLuint *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMENVPARAMETERI4INVPROC) (GLenum target
		, GLuint index, GLint x, GLint y, GLint z, GLint w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMENVPARAMETERI4IVNVPROC) (GLenum targe
		t, GLuint index, const GLint *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMENVPARAMETERSI4IVNVPROC) (GLenum targ
		et, GLuint index, GLsizei count, const GLint *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMENVPARAMETERI4UINVPROC) (GLenum targe
		t, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
		typedef void (GLAPIENTRYP PFNGLPROGRAMENVPARAMETERI4UIVNVPROC) (GLenum targ
		et, GLuint index, const GLuint *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC) (GLenum tar
		get, GLuint index, GLsizei count, const GLuint *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC) (GLenum t
		arget, GLuint index, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC) (GLenum
		target, GLuint index, GLuint *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMENVPARAMETERIIVNVPROC) (GLenum tar
		get, GLuint index, GLint *params);
		typedef void (GLAPIENTRYP PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC) (GLenum ta
		rget, GLuint index, GLuint *params);
		#endif

		#ifndef GL_NV_parameter_buffer_object
		#define GL_NV_parameter_buffer_object 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glProgramBufferParametersfvNV (GLenum target, GLuint
		buffer, GLuint index, GLsizei count, const GLfloat *params);
		GLAPI void GLAPIENTRY glProgramBufferParametersIivNV (GLenum target, GLuint
		buffer, GLuint index, GLsizei count, const GLint *params);
		GLAPI void GLAPIENTRY glProgramBufferParametersIuivNV (GLenum target, GLuin
		t buffer, GLuint index, GLsizei count, const GLuint *params);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC) (GLenum tar
		get, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC) (GLenum ta
		rget, GLuint buffer, GLuint index, GLsizei count, const GLint *params);
		typedef void (GLAPIENTRYP PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC) (GLenum t
		arget, GLuint buffer, GLuint index, GLsizei count, const GLuint *params);
		#endif

		#ifndef GL_EXT_framebuffer_multisample
		#define GL_EXT_framebuffer_multisample 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glRenderbufferStorageMultisampleEXT (GLenum target, G
		Lsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLen
		um target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei h
		eight);
		#endif

		#ifndef GL_NV_framebuffer_multisample_coverage
		#define GL_NV_framebuffer_multisample_coverage 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glRenderbufferStorageMultisampleCoverageNV (GLenum ta
		rget, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat,
		GLsizei width, GLsizei height);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC
		) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum int
		ernalformat, GLsizei width, GLsizei height);
		#endif

		#ifndef GL_EXT_framebuffer_blit
		#define GL_EXT_framebuffer_blit 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint
		srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GL
		bitfield mask, GLenum filter);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLBLITFRAMEBUFFEREXTPROC) (GLint srcX0, GLint
		srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLi
		nt dstY1, GLbitfield mask, GLenum filter);
		#endif

		#ifndef GL_EXT_draw_instanced
		#define GL_EXT_draw_instanced 1
		#ifdef GL_GLEXT_PROTOTYPES
		GLAPI void GLAPIENTRY glDrawArraysInstancedEXT (GLenum mode, GLint start, G
		Lsizei count, GLsizei primcount);
		GLAPI void GLAPIENTRY glDrawElementsInstancedEXT (GLenum mode, GLsizei coun
		t, GLenum type, const GLvoid *indices, GLsizei primcount);
		#endif /* GL_GLEXT_PROTOTYPES */
		typedef void (GLAPIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GL
		int start, GLsizei count, GLsizei primcount);
		typedef void (GLAPIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode,
		GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
		#endif

		#ifndef GL_EXT_texture_compression_rgtc
		#define GL_EXT_texture_compression_rgtc 1
		#endif

	#ifdef __cplusplus	#ifdef __cplusplus
	}	}
	#endif	#endif

	#endif	#endif

End of changes. 198 change blocks.
	1859 lines changed or deleted	6610 lines changed or added

	nail_constraint.h	nail_constraint.h

	skipping to change at line 45	skipping to change at line 45
	class nail_constraint_t: public constraint_t	class nail_constraint_t: public constraint_t
	{	{
	public:	public:
	//typedefs	//typedefs
	typedef shared_ptr<nail_constraint_t> pointer;	typedef shared_ptr<nail_constraint_t> pointer;

	//	//
	rigid_body_t::pointer rigid_body() { return m_rigid_body; }	rigid_body_t::pointer rigid_body() { return m_rigid_body; }

	//	//

	void set_pivot(vec3f const& p)	void set_pivotA(vec3f const& p) {
	{
	nail_constraint_impl_t* nail_impl = dynamic_cast<nail_constraint_im pl_t*>(impl());	nail_constraint_impl_t* nail_impl = dynamic_cast<nail_constraint_im pl_t*>(impl());

	nail_impl->set_pivot(p);	nail_impl->set_pivotA(p);
	}	}

	//local space pivot	//local space pivot

	void get_pivot(vec3f& p) const {	void get_pivotA(vec3f& p) const {
	nail_constraint_impl_t const* nail_impl = dynamic_cast<nail_constra int_impl_t const*>(impl());	nail_constraint_impl_t const* nail_impl = dynamic_cast<nail_constra int_impl_t const*>(impl());

	nail_impl->get_pivot(p);	nail_impl->get_pivotA(p);
	}	}

	//	//

	void get_world_pivot(vec3f& p) const {	void set_world(vec3f const& p) {
		nail_constraint_impl_t* nail_impl = dynamic_cast<nail_constraint_im
		pl_t*>(impl());
		nail_impl->set_world(p);
		}

		//
		void get_world(vec3f& p) const {
	nail_constraint_impl_t const* nail_impl = dynamic_cast<nail_constra int_impl_t const*>(impl());	nail_constraint_impl_t const* nail_impl = dynamic_cast<nail_constra int_impl_t const*>(impl());

	nail_impl->get_world_pivot(p);	nail_impl->get_world(p);
	}	}

	//	//
	void set_damping(float d) {	void set_damping(float d) {
	nail_constraint_impl_t* nail_impl = dynamic_cast<nail_constraint_im pl_t*>(impl());	nail_constraint_impl_t* nail_impl = dynamic_cast<nail_constraint_im pl_t*>(impl());
	nail_impl->set_damping(d);	nail_impl->set_damping(d);
	}	}

	float damping() const {	float damping() const {
	nail_constraint_impl_t const* nail_impl = dynamic_cast<nail_constra int_impl_t const*>(impl());	nail_constraint_impl_t const* nail_impl = dynamic_cast<nail_constra int_impl_t const*>(impl());

End of changes. 6 change blocks.
	7 lines changed or deleted	13 lines changed or added

	nail_constraint_impl.h	nail_constraint_impl.h

	skipping to change at line 34	skipping to change at line 34

	#ifndef DYN_NAIL_CONSTRAINT_IMPL_H	#ifndef DYN_NAIL_CONSTRAINT_IMPL_H
	#define DYN_NAIL_CONSTRAINT_IMPL_H	#define DYN_NAIL_CONSTRAINT_IMPL_H

	#include "constraint_impl.h"	#include "constraint_impl.h"

	class nail_constraint_impl_t: public constraint_impl_t	class nail_constraint_impl_t: public constraint_impl_t
	{	{
	public:	public:
	//	//

	virtual void set_pivot(vec3f const& p) = 0;	virtual void set_pivotA(vec3f const& p) = 0;
	virtual void get_pivot(vec3f& p) const = 0;	virtual void get_pivotA(vec3f& p) const = 0;
	virtual void get_world_pivot(vec3f& p) const = 0;	virtual void set_world(vec3f const& p) = 0;
		virtual void get_world(vec3f& p) const = 0;

	//	//
	virtual void set_damping(float d) = 0;	virtual void set_damping(float d) = 0;
	virtual float damping() const = 0;	virtual float damping() const = 0;

	public:	public:
	virtual ~nail_constraint_impl_t() {};	virtual ~nail_constraint_impl_t() {};
	};	};

	#endif	#endif

End of changes. 1 change blocks.
	3 lines changed or deleted	4 lines changed or added

	readblend.h	readblend.h

	skipping to change at line 40	skipping to change at line 40
	#include <math.h>	#include <math.h>
	#include <stdlib.h>//size_t for MSVC 6.0	#include <stdlib.h>//size_t for MSVC 6.0

	//#include <cfloat>	//#include <cfloat>
	#include <float.h>	#include <float.h>

	#include "abs-file.h"	#include "abs-file.h"

	/* TODO: Doxygen me. */	/* TODO: Doxygen me. */


	/* don't worry yourself about this. */	#include "blendtype.h"
	#ifndef BlendFile
	#define BlendFile void	#ifdef __cplusplus
		extern "C" {
	#endif	#endif

	/**************************************/	/**************************************/
	/* .blend handle load/free functions */	/* .blend handle load/free functions */
	/*************************************/	/*************************************/

	/* Pass in an already-opened file handle; this function will then	/* Pass in an already-opened file handle; this function will then
	examine the file to check that it is a Blender file and scan the	examine the file to check that it is a Blender file and scan the
	entire file to extract all vital information (quite expensive)	entire file to extract all vital information (quite expensive)
	before any query operations can be performed. The resulting	before any query operations can be performed. The resulting

	skipping to change at line 304	skipping to change at line 305
	float weight;	float weight;
	} bDeformWeight;	} bDeformWeight;

	typedef struct {	typedef struct {
	float xyz[3];	float xyz[3];
	float cnormal[3]; /* cosmetic normal */	float cnormal[3]; /* cosmetic normal */
	int mat;	int mat;
	bDeformWeight* deform_weights;	bDeformWeight* deform_weights;
	int deform_weights_count;	int deform_weights_count;
	} bVert;	} bVert;


	#define BVERT_HAS_CNORMAL(BV) ((BV)->cnormal[0] != 0.0f \|\| \	#define BVERT_HAS_CNORMAL(BV) ((BV)->cnormal[0] != 0.0f \|\| \
	(BV)->cnormal[1] != 0.0f \|\| \	(BV)->cnormal[1] != 0.0f \|\| \
	(BV)->cnormal[2] != 0.0f)	(BV)->cnormal[2] != 0.0f)

	#define BFACE_FLAG_SMOOTH 0x01	#define BFACE_FLAG_SMOOTH 0x01


		typedef struct _bImage {

		void* m_packedImagePtr;
		int m_sizePackedImage;
		char m_imagePathName [128];

		int m_ok;

		int m_xrep;
		int m_yrep;

		} bImage;

	typedef struct {	typedef struct {
	int v[4];	int v[4];
	float rgba[4][4]; /* vertex colours */	float rgba[4][4]; /* vertex colours */
	float rgba2[4][4]; /* texture face colours (errrr...?) */	float rgba2[4][4]; /* texture face colours (errrr...?) */
	float uv[4][2];	float uv[4][2];

	BlendBlockPointer image_id;	bImage* m_image;
	int mat;	int mat;
	unsigned char flags;	unsigned char flags;

		int m_flag;
		int m_mode;
		BlendBlockPointer image_id;
	} bFace;	} bFace;


	#define BFACE_HAS_TEXTURE(BF) ((BF)->image_id != NULL)	#define BFACE_HAS_TEXTURE(BF) ((BF)->image_id != NULL)
	#define BFACE_IS_QUAD(BF) ((BF)->v[3] != 0)	#define BFACE_IS_QUAD(BF) ((BF)->v[3] != 0)
	#define BFACE_IS_TRI(BF) ((BF)->v[2] != 0 && (BF)->v[3] == 0)	#define BFACE_IS_TRI(BF) ((BF)->v[2] != 0 && (BF)->v[3] == 0)
	#define BFACE_IS_LINE(BF) ((BF)->v[1] != 0 && (BF)->v[2] == 0)	#define BFACE_IS_LINE(BF) ((BF)->v[1] != 0 && (BF)->v[2] == 0)

	typedef enum {	typedef enum {
	BTEX_AFFECT_COLOUR = 0x01,	BTEX_AFFECT_COLOUR = 0x01,
	BTEX_AFFECT_ALPHA = 0x02,	BTEX_AFFECT_ALPHA = 0x02,
	BTEX_AFFECT_EMIT = 0x04,	BTEX_AFFECT_EMIT = 0x04,
	BTEX_AFFECT_NORMAL = 0x08,	BTEX_AFFECT_NORMAL = 0x08,

	skipping to change at line 381	skipping to change at line 401
	#define BLENDER_MAX_TEX_LAYERS 8	#define BLENDER_MAX_TEX_LAYERS 8
	typedef struct {	typedef struct {
	bTexLayer *tex_layer[BLENDER_MAX_TEX_LAYERS];	bTexLayer *tex_layer[BLENDER_MAX_TEX_LAYERS];
	bMatFeatureMask feature_mask;	bMatFeatureMask feature_mask;
	float colour_rgba[4]; /* main material colour */	float colour_rgba[4]; /* main material colour */
	float emit; /* emissive strength, 0..1 */	float emit; /* emissive strength, 0..1 */
	} bMaterial;	} bMaterial;

	typedef float bMatrix[4][4];	typedef float bMatrix[4][4];


	typedef struct {	typedef struct _bMesh{
	bVert *vert;	bVert *vert;
	int vert_count;	int vert_count;
	bFace *face;	bFace *face;
	int face_count;	int face_count;
	bMaterial material; / or NULL if none */	bMaterial material; / or NULL if none */
	} bMesh;	} bMesh;

	typedef enum {	typedef enum {
	BOBJ_TYPE_UNKNOWN,	BOBJ_TYPE_UNKNOWN,
	BOBJ_TYPE_NULL, /* indicates object has no data associated with it! */	BOBJ_TYPE_NULL, /* indicates object has no data associated with it! */

	BOBJ_TYPE_MESH	BOBJ_TYPE_MESH,
		BOBJ_TYPE_INVALID_MESH,
		BOBJ_TYPE_CAMERA,
		BOBJ_TYPE_LAMP
	} bObjType;	} bObjType;

	typedef enum {	typedef enum {
	BAQ_INCLUDE_CHILDREN = 0x0001	BAQ_INCLUDE_CHILDREN = 0x0001
	} bAcquireFlags;	} bAcquireFlags;


	typedef struct {	typedef struct _bObj{
	bObjType type;	bObjType type;
	char *name;	char *name;

	bMatrix transform; /* local transformation matrix */	bMatrix transform; /* local transformation matrix */
	bMatrix parentimat; /* parent's inverse transform matrix */	bMatrix parentimat; /* parent's inverse transform matrix */
	float scaling[3]; /* scaling component of transform */	float scaling[3]; /* scaling component of transform */
	float rotphr[3]; /* pitch/head/roll rotation component of transform (use for normals) */	float rotphr[3]; /* pitch/head/roll rotation component of transform (use for normals) */
	float location[3]; /* location component of transform */	float location[3]; /* location component of transform */
	unsigned char transflags; /* NOT DECODED YET, RAW BYTE */	unsigned char transflags; /* NOT DECODED YET, RAW BYTE */

		float mass;//used for rigid body dynamics
		int gameflag; //used to detect object type (static, ghost, dynamic, rigid
		body, soft body)
		int boundtype; //used to detect collision shape type

	union {	union {
	void *dummy;	void *dummy;
	bMesh *mesh;	bMesh *mesh;
	} data;	} data;


	} bObj;	} bObj;

	bObj *blend_alloc_obj(void);	bObj *blend_alloc_obj(void);
	void blend_init_obj(bObj *obj);	void blend_init_obj(bObj *obj);
	void blend_free_obj(bObj *obj);	void blend_free_obj(bObj *obj);
	void blend_free_obj_inner(bObj *obj);	void blend_free_obj_inner(bObj *obj);
	void blend_acquire_obj_from_obj(BlendFile bf, BlendObject objobj,	void blend_acquire_obj_from_obj(BlendFile bf, BlendObject objobj,
	bObj *outobj,	bObj *outobj,
	/* malloc'd BlendObject will be written her e if pointer if non-NULL: / BlendObject *outblendobject);	/* malloc'd BlendObject will be written her e if pointer if non-NULL: / BlendObject *outblendobject);


	skipping to change at line 447	skipping to change at line 474
	void blend_free_material(bMaterial *mat);	void blend_free_material(bMaterial *mat);
	void blend_acquire_material_from_obj(BlendFile bf, BlendObject meobj,	void blend_acquire_material_from_obj(BlendFile bf, BlendObject meobj,
	bMaterial *mat);	bMaterial *mat);

	bTexLayer *blend_alloc_texlayer(void);	bTexLayer *blend_alloc_texlayer(void);
	void blend_init_texlayer(bTexLayer *tl);	void blend_init_texlayer(bTexLayer *tl);
	void blend_free_texlayer(bTexLayer *tl);	void blend_free_texlayer(bTexLayer *tl);
	void blend_acquire_texlayer_from_obj(BlendFile bf, BlendObject tlobj,	void blend_acquire_texlayer_from_obj(BlendFile bf, BlendObject tlobj,
	bTexLayer *tl);	bTexLayer *tl);


		#ifdef __cplusplus
		}
		#endif

	#endif	#endif

End of changes. 12 change blocks.
	7 lines changed or deleted	39 lines changed or added

	rigid_body.h	rigid_body.h

	skipping to change at line 70	skipping to change at line 70
	void get_linear_velocity(vec3f& v) const { m _impl->get_linear_velocity(v); }	void get_linear_velocity(vec3f& v) const { m _impl->get_linear_velocity(v); }

	void set_angular_velocity(vec3f const& v) { m _impl->set_angular_velocity(v); }	void set_angular_velocity(vec3f const& v) { m _impl->set_angular_velocity(v); }
	void get_angular_velocity(vec3f& v) const { m _impl->get_angular_velocity(v); }	void get_angular_velocity(vec3f& v) const { m _impl->get_angular_velocity(v); }

	//	//
	void clear_forces() { m _impl->clear_forces(); }	void clear_forces() { m _impl->clear_forces(); }
	void apply_central_force(vec3f const& f) { m _impl->apply_central_force(f); }	void apply_central_force(vec3f const& f) { m _impl->apply_central_force(f); }
	void apply_torque(vec3f const& t) { m _impl->apply_torque(t); }	void apply_torque(vec3f const& t) { m _impl->apply_torque(t); }


		void update_constraint()
		{ m_impl->update_constraint();
		}
		void add_constraint(bt_constraint_t* constraint)
		{ m_impl->add_constraint(constraint); }
		void remove_constraint(bt_constraint_t* constraint)
		{ m_impl->remove_constraint(constraint); }

	public:	public:
	virtual ~rigid_body_t() {};	virtual ~rigid_body_t() {};

	protected:	protected:
	friend class solver_t;	friend class solver_t;
	rigid_body_t(rigid_body_impl_t* impl, collision_shape_t::pointer& shape ): m_impl(impl), m_collision_shape(shape)	rigid_body_t(rigid_body_impl_t* impl, collision_shape_t::pointer& shape ): m_impl(impl), m_collision_shape(shape)
	{	{
	}	}

	rigid_body_impl_t* impl() { return m_impl.get(); }	rigid_body_impl_t* impl() { return m_impl.get(); }

End of changes. 1 change blocks.
	0 lines changed or deleted	8 lines changed or added

	rigid_body_impl.h	rigid_body_impl.h

	skipping to change at line 29	skipping to change at line 29

	Written by: Nicola Candussi <nicola@fluidinteractive.com>	Written by: Nicola Candussi <nicola@fluidinteractive.com>
	*/	*/

	//rigid_body_impl.h	//rigid_body_impl.h

	#ifndef DYN_RIGID_BODY_IMPL_H	#ifndef DYN_RIGID_BODY_IMPL_H
	#define DYN_RIGID_BODY_IMPL_H	#define DYN_RIGID_BODY_IMPL_H

	#include "mathUtils.h"	#include "mathUtils.h"

		#include "constraint/bt_constraint.h"

	class rigid_body_impl_t	class rigid_body_impl_t
	{	{
	public:	public:
	virtual void set_kinematic(bool kinematic) = 0;	virtual void set_kinematic(bool kinematic) = 0;

	//	//
	virtual void set_mass(float mass) = 0;	virtual void set_mass(float mass) = 0;
	virtual void set_inertia(vec3f const& I) = 0;	virtual void set_inertia(vec3f const& I) = 0;
	virtual void set_restitution(float r) = 0;	virtual void set_restitution(float r) = 0;

	skipping to change at line 57	skipping to change at line 58
	virtual void set_linear_velocity(vec3f const& v) = 0;	virtual void set_linear_velocity(vec3f const& v) = 0;
	virtual void get_linear_velocity(vec3f& v) const = 0;	virtual void get_linear_velocity(vec3f& v) const = 0;

	virtual void set_angular_velocity(vec3f const& v) = 0;	virtual void set_angular_velocity(vec3f const& v) = 0;
	virtual void get_angular_velocity(vec3f& v) const = 0;	virtual void get_angular_velocity(vec3f& v) const = 0;

	virtual void clear_forces() = 0;	virtual void clear_forces() = 0;
	virtual void apply_central_force(vec3f const& f) = 0;	virtual void apply_central_force(vec3f const& f) = 0;
	virtual void apply_torque(vec3f const& t) = 0;	virtual void apply_torque(vec3f const& t) = 0;


		virtual void update_constraint() = 0;
		virtual void add_constraint(bt_constraint_t* constraint) = 0;
		virtual void remove_constraint(bt_constraint_t* constraint) = 0;

	public:	public:
	virtual ~rigid_body_impl_t() {};	virtual ~rigid_body_impl_t() {};
	};	};

	#endif	#endif

End of changes. 2 change blocks.
	0 lines changed or deleted	5 lines changed or added

	solver.h	solver.h

	skipping to change at line 41	skipping to change at line 41

	#include "mathUtils.h"	#include "mathUtils.h"
	#include "shared_ptr.h"	#include "shared_ptr.h"

	#include "rigid_body.h"	#include "rigid_body.h"
	#include "sphere_shape.h"	#include "sphere_shape.h"
	#include "plane_shape.h"	#include "plane_shape.h"
	#include "box_shape.h"	#include "box_shape.h"
	#include "convex_hull_shape.h"	#include "convex_hull_shape.h"
	#include "mesh_shape.h"	#include "mesh_shape.h"

	#include "nail_constraint.h"	#include "constraint/nail_constraint.h"
	#include "solver_impl.h"	#include "solver_impl.h"


		#include "constraint/hinge_constraint.h"
		#include "constraint/slider_constraint.h"
		#include "constraint/sixdof_constraint.h"

	class solver_t	class solver_t
	{	{
	public:	public:
	static void initialize();	static void initialize();
	static void cleanup();	static void cleanup();

	//creation methods	//creation methods
	static sphere_shape_t::pointer create_sphere_shape(float radius = 1.0);	static sphere_shape_t::pointer create_sphere_shape(float radius = 1.0);

	static plane_shape_t::pointer create_plane_shape(vec3f const& normal = vec3f(0, 1, 0), float d = 0);	static plane_shape_t::pointer create_plane_shape(vec3f const& normal = vec3f(0, 1, 0), float d = 0);

	skipping to change at line 68	skipping to change at line 72
	vec3f cons t* normals,	vec3f cons t* normals,
	unsigned i nt const *indices, size_t num_indices);	unsigned i nt const *indices, size_t num_indices);

	static mesh_shape_t::pointer create_mesh_shape(vec3f const* vertices, s ize_t num_vertices,	static mesh_shape_t::pointer create_mesh_shape(vec3f const* vertices, s ize_t num_vertices,
	vec3f const* normals,	vec3f const* normals,
	unsigned int const *indi ces, size_t num_indices);	unsigned int const *indi ces, size_t num_indices);

	static rigid_body_t::pointer create_rigid_body(collision_shape_t::point er& cs);	static rigid_body_t::pointer create_rigid_body(collision_shape_t::point er& cs);

	static nail_constraint_t::pointer create_nail_constraint(rigid_body_t:: pointer& rb, vec3f const& pivot = vec3f(0, 0, 0));	static nail_constraint_t::pointer create_nail_constraint(rigid_body_t:: pointer& rb, vec3f const& pivot = vec3f(0, 0, 0));

		static hinge_constraint_t::pointer create_hinge_constraint(rigid_body_t
		::pointer& rb, vec3f const& pivot = vec3f(0, 0, 0));
		static slider_constraint_t::pointer create_slider_constraint(rigid_body
		_t::pointer& rbA, vec3f const& pivotA, rigid_body_t::pointer& rbB, vec3f co
		nst& pivotB = vec3f(0, 0, 0));
		static sixdof_constraint_t::pointer create_sixdof_constraint(rigid_body
		_t::pointer& rbA, vec3f const& pivotA, rigid_body_t::pointer& rbB, vec3f co
		nst& pivotB = vec3f(0, 0, 0));

	//add/remove from world	//add/remove from world
	static void add_rigid_body(rigid_body_t::pointer& rb);	static void add_rigid_body(rigid_body_t::pointer& rb);
	static void remove_rigid_body(rigid_body_t::pointer& rb);	static void remove_rigid_body(rigid_body_t::pointer& rb);
	static void remove_all_rigid_bodies();	static void remove_all_rigid_bodies();

	//add/remove from world	//add/remove from world
	static void add_constraint(constraint_t::pointer& c);	static void add_constraint(constraint_t::pointer& c);
	static void remove_constraint(constraint_t::pointer& c);	static void remove_constraint(constraint_t::pointer& c);
	static void remove_all_constraints();	static void remove_all_constraints();

End of changes. 3 change blocks.
	1 lines changed or deleted	13 lines changed or added

	solver_impl.h	solver_impl.h

	skipping to change at line 29	skipping to change at line 29

	Written by: Nicola Candussi <nicola@fluidinteractive.com>	Written by: Nicola Candussi <nicola@fluidinteractive.com>
	*/	*/

	//solver_impl.h	//solver_impl.h

	#ifndef DYN_SOLVER_IMPL_H	#ifndef DYN_SOLVER_IMPL_H
	#define DYN_SOLVER_IMPL_H	#define DYN_SOLVER_IMPL_H

	#include "rigid_body_impl.h"	#include "rigid_body_impl.h"

	#include "nail_constraint_impl.h"	#include "constraint/nail_constraint_impl.h"
	#include "collision_shape_impl.h"	#include "collision_shape_impl.h"


		#include "constraint/hinge_constraint_impl.h"
		#include "constraint/slider_constraint_impl.h"
		#include "constraint/sixdof_constraint_impl.h"

	class solver_impl_t	class solver_impl_t
	{	{
	public:	public:
	virtual collision_shape_impl_t* create_sphere_shape(float radius) = 0;	virtual collision_shape_impl_t* create_sphere_shape(float radius) = 0;

	virtual collision_shape_impl_t* create_plane_shape(vec3f const& normal, float d) = 0;	virtual collision_shape_impl_t* create_plane_shape(vec3f const& normal, float d) = 0;

	virtual collision_shape_impl_t* create_box_shape(vec3f const& halfExten ts) = 0;	virtual collision_shape_impl_t* create_box_shape(vec3f const& halfExten ts) = 0;

	virtual collision_shape_impl_t* create_convex_hull_shape(vec3f const* v ertices, size_t num_vertices,	virtual collision_shape_impl_t* create_convex_hull_shape(vec3f const* v ertices, size_t num_vertices,
	vec3f const* n ormals,	vec3f const* n ormals,
	unsigned int c onst *indices, size_t num_indices) = 0;	unsigned int c onst *indices, size_t num_indices) = 0;

	virtual collision_shape_impl_t* create_mesh_shape(vec3f const* vertices , size_t num_vertices,	virtual collision_shape_impl_t* create_mesh_shape(vec3f const* vertices , size_t num_vertices,
	vec3f const* n ormals,	vec3f const* n ormals,
	unsigned int c onst *indices, size_t num_indices) = 0;	unsigned int c onst *indices, size_t num_indices) = 0;

	virtual rigid_body_impl_t* create_rigid_body(collision_shape_impl_t* cs ) = 0;	virtual rigid_body_impl_t* create_rigid_body(collision_shape_impl_t* cs ) = 0;

	virtual nail_constraint_impl_t* create_nail_constraint(rigid_body_impl_ t* rb, vec3f const& pivot) = 0;	virtual nail_constraint_impl_t* create_nail_constraint(rigid_body_impl_ t* rb, vec3f const& pivot) = 0;

		virtual hinge_constraint_impl_t* create_hinge_constraint(rigid_body_imp
		l_t* rb, vec3f const& pivot) = 0;
		virtual slider_constraint_impl_t* create_slider_constraint(rigid_body_i
		mpl_t* rbA, vec3f const& pivotA, rigid_body_impl_t* rbB, vec3f const& pivot
		B) = 0;
		virtual sixdof_constraint_impl_t* create_sixdof_constraint(rigid_body_i
		mpl_t* rbA, vec3f const& pivotA, rigid_body_impl_t* rbB, vec3f const& pivot
		B) = 0;

	virtual void add_rigid_body(rigid_body_impl_t* rb) = 0;	virtual void add_rigid_body(rigid_body_impl_t* rb) = 0;

	virtual void remove_rigid_body(rigid_body_impl_t* rb) = 0;	virtual void remove_rigid_body(rigid_body_impl_t* rb) = 0;

	virtual void add_constraint(constraint_impl_t* rb) = 0;	virtual void add_constraint(constraint_impl_t* rb) = 0;

	virtual void remove_constraint(constraint_impl_t* rb) = 0;	virtual void remove_constraint(constraint_impl_t* rb) = 0;

	virtual void set_gravity(vec3f const& g) = 0;	virtual void set_gravity(vec3f const& g) = 0;

End of changes. 3 change blocks.
	1 lines changed or deleted	13 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	SpuCollisionShapes.h	SpuCollisionShapes.h

	skipping to change at line 37	skipping to change at line 37

	#include "BulletCollision/CollisionShapes/btCapsuleShape.h"	#include "BulletCollision/CollisionShapes/btCapsuleShape.h"

	#include "BulletCollision/CollisionShapes/btConvexShape.h"	#include "BulletCollision/CollisionShapes/btConvexShape.h"
	#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"	#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
	#include "BulletCollision/CollisionShapes/btConvexHullShape.h"	#include "BulletCollision/CollisionShapes/btConvexHullShape.h"
	#include "BulletCollision/CollisionShapes/btCompoundShape.h"	#include "BulletCollision/CollisionShapes/btCompoundShape.h"

	#define MAX_NUM_SPU_CONVEX_POINTS 128	#define MAX_NUM_SPU_CONVEX_POINTS 128


	struct SpuConvexPolyhedronVertexData	ATTRIBUTE_ALIGNED16(struct) SpuConvexPolyhedronVertexData
	{	{
	void* gSpuConvexShapePtr;	void* gSpuConvexShapePtr;
	btVector3* gConvexPoints;	btVector3* gConvexPoints;
	int gNumConvexPoints;	int gNumConvexPoints;

		int unused;
	ATTRIBUTE_ALIGNED16(btVector3 g_convexPointBuffer[MAX_NUM_SPU_CONVEX _POINTS]);	ATTRIBUTE_ALIGNED16(btVector3 g_convexPointBuffer[MAX_NUM_SPU_CONVEX _POINTS]);
	};	};

	#define MAX_SHAPE_SIZE 256	#define MAX_SHAPE_SIZE 256


	struct CollisionShape_LocalStoreMemory	ATTRIBUTE_ALIGNED16(struct) CollisionShape_LocalStoreMemory
	{	{
	ATTRIBUTE_ALIGNED16(char collisionShape[MAX_SHAPE_SIZE]);	ATTRIBUTE_ALIGNED16(char collisionShape[MAX_SHAPE_SIZE]);
	};	};


	struct CompoundShape_LocalStoreMemory	ATTRIBUTE_ALIGNED16(struct) CompoundShape_LocalStoreMemory
	{	{
	// Compound data	// Compound data
	#define MAX_SPU_COMPOUND_SUBSHAPES 16	#define MAX_SPU_COMPOUND_SUBSHAPES 16
	ATTRIBUTE_ALIGNED16(btCompoundShapeChild gSubshapes[MAX_SPU_COMPOUND _SUBSHAPES]);	ATTRIBUTE_ALIGNED16(btCompoundShapeChild gSubshapes[MAX_SPU_COMPOUND _SUBSHAPES]);
	ATTRIBUTE_ALIGNED16(char gSubshapeShape[MAX_SPU_COMPOUND_SUBSHAPES][ MAX_SHAPE_SIZE]);	ATTRIBUTE_ALIGNED16(char gSubshapeShape[MAX_SPU_COMPOUND_SUBSHAPES][ MAX_SHAPE_SIZE]);
	};	};


	struct bvhMeshShape_LocalStoreMemory	ATTRIBUTE_ALIGNED16(struct) bvhMeshShape_LocalStoreMemory
	{	{
	//ATTRIBUTE_ALIGNED16(btOptimizedBvh gOptimizedBvh);	//ATTRIBUTE_ALIGNED16(btOptimizedBvh gOptimizedBvh);
	ATTRIBUTE_ALIGNED16(char gOptimizedBvh[sizeof(btOptimizedBvh)+16]);	ATTRIBUTE_ALIGNED16(char gOptimizedBvh[sizeof(btOptimizedBvh)+16]);
	btOptimizedBvh* getOptimizedBvh()	btOptimizedBvh* getOptimizedBvh()
	{	{
	return (btOptimizedBvh*) gOptimizedBvh;	return (btOptimizedBvh*) gOptimizedBvh;
	}	}

	ATTRIBUTE_ALIGNED16(btTriangleIndexVertexArray gTriangleMeshInterfa ceStorage);	ATTRIBUTE_ALIGNED16(btTriangleIndexVertexArray gTriangleMeshInterfa ceStorage);
	btTriangleIndexVertexArray* gTriangleMeshInterfacePtr;	btTriangleIndexVertexArray* gTriangleMeshInterfacePtr;
	///only a single mesh part for now, we can add support for multiple parts, but quantized trees don't support this at the moment	///only a single mesh part for now, we can add support for multiple parts, but quantized trees don't support this at the moment
	ATTRIBUTE_ALIGNED16(btIndexedMesh gIndexMesh);	ATTRIBUTE_ALIGNED16(btIndexedMesh gIndexMesh);
	#define MAX_SPU_SUBTREE_HEADERS 32	#define MAX_SPU_SUBTREE_HEADERS 32
	//1024	//1024
	ATTRIBUTE_ALIGNED16(btBvhSubtreeInfo gSubtreeHeaders[MAX_SPU_SUBT REE_HEADERS]);	ATTRIBUTE_ALIGNED16(btBvhSubtreeInfo gSubtreeHeaders[MAX_SPU_SUBT REE_HEADERS]);
	ATTRIBUTE_ALIGNED16(btQuantizedBvhNode gSubtreeNodes[MAX_SUBTREE_SI ZE_IN_BYTES/sizeof(btQuantizedBvhNode)]);	ATTRIBUTE_ALIGNED16(btQuantizedBvhNode gSubtreeNodes[MAX_SUBTREE_SI ZE_IN_BYTES/sizeof(btQuantizedBvhNode)]);
	};	};


	btVector3 localGetSupportingVertexWithoutMargin(int shapeType, void* shape, const btVector3& localDir,struct SpuConvexPolyhedronVertexData* convexVe rtexData);//, int *featureIndex)
	void computeAabb (btVector3& aabbMin, btVector3& aabbMax, btConvexInternalS hape* convexShape, ppu_address_t convexShapePtr, int shapeType, const btTra nsform& xform);	void computeAabb (btVector3& aabbMin, btVector3& aabbMax, btConvexInternalS hape* convexShape, ppu_address_t convexShapePtr, int shapeType, const btTra nsform& xform);
	void dmaBvhShapeData (bvhMeshShape_LocalStoreMemory* bvhMeshShape, btBvhTri angleMeshShape* triMeshShape);	void dmaBvhShapeData (bvhMeshShape_LocalStoreMemory* bvhMeshShape, btBvhTri angleMeshShape* triMeshShape);
	void dmaBvhIndexedMesh (btIndexedMesh* IndexMesh, IndexedMeshArray& indexAr ray, int index, uint32_t dmaTag);	void dmaBvhIndexedMesh (btIndexedMesh* IndexMesh, IndexedMeshArray& indexAr ray, int index, uint32_t dmaTag);
	void dmaBvhSubTreeHeaders (btBvhSubtreeInfo* subTreeHeaders, ppu_address_t subTreePtr, int batchSize, uint32_t dmaTag);	void dmaBvhSubTreeHeaders (btBvhSubtreeInfo* subTreeHeaders, ppu_address_t subTreePtr, int batchSize, uint32_t dmaTag);
	void dmaBvhSubTreeNodes (btQuantizedBvhNode* nodes, const btBvhSubtreeInfo& subtree, QuantizedNodeArray& nodeArray, int dmaTag);	void dmaBvhSubTreeNodes (btQuantizedBvhNode* nodes, const btBvhSubtreeInfo& subtree, QuantizedNodeArray& nodeArray, int dmaTag);

	int getShapeTypeSize(int shapeType);	int getShapeTypeSize(int shapeType);
	void dmaConvexVertexData (SpuConvexPolyhedronVertexData* convexVertexData, btConvexHullShape* convexShapeSPU);	void dmaConvexVertexData (SpuConvexPolyhedronVertexData* convexVertexData, btConvexHullShape* convexShapeSPU);
	void dmaCollisionShape (void* collisionShapeLocation, ppu_address_t collisi onShapePtr, uint32_t dmaTag, int shapeType);	void dmaCollisionShape (void* collisionShapeLocation, ppu_address_t collisi onShapePtr, uint32_t dmaTag, int shapeType);
	void dmaCompoundShapeInfo (CompoundShape_LocalStoreMemory* compoundShapeLoc ation, btCompoundShape* spuCompoundShape, uint32_t dmaTag);	void dmaCompoundShapeInfo (CompoundShape_LocalStoreMemory* compoundShapeLoc ation, btCompoundShape* spuCompoundShape, uint32_t dmaTag);

End of changes. 6 change blocks.
	5 lines changed or deleted	5 lines changed or added

	SpuConvexPenetrationDepthSolver.h	SpuConvexPenetrationDepthSolver.h

	skipping to change at line 17	skipping to change at line 17
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/


	#ifndef CONVEX_PENETRATION_DEPTH_H	#ifndef SPU_CONVEX_PENETRATION_DEPTH_H
	#define CONVEX_PENETRATION_DEPTH_H	#define SPU_CONVEX_PENETRATION_DEPTH_H

	class btStackAlloc;	class btStackAlloc;
	class btIDebugDraw;	class btIDebugDraw;

	class SpuVoronoiSimplexSolver;	#include "BulletCollision/NarrowphaseCollision/btConvexPenetrationDepthSolv er.h"

	#include <LinearMath/btTransform.h>	#include <LinearMath/btTransform.h>

	///ConvexPenetrationDepthSolver provides an interface for penetration depth calculation.	///ConvexPenetrationDepthSolver provides an interface for penetration depth calculation.

	class SpuConvexPenetrationDepthSolver	class SpuConvexPenetrationDepthSolver : public btConvexPenetrationDepthSolv er
	{	{
	public:	public:

	virtual ~SpuConvexPenetrationDepthSolver() {};	virtual ~SpuConvexPenetrationDepthSolver() {};
	virtual bool calcPenDepth( SpuVoronoiSimplexSolver& simplexSolver,	virtual bool calcPenDepth( SpuVoronoiSimplexSolver& simplexSolver,
	void* convexA,void* convexB,int shapeTypeA, int shapeTypeB, float marginA, float marginB,	void* convexA,void* convexB,int shapeTypeA, int shapeTypeB, float marginA, float marginB,
	btTransform& transA,const btTransform& transB,	btTransform& transA,const btTransform& transB,
	btVector3& v, btVector3& pa, btVector3& pb,	btVector3& v, btVector3& pa, btVector3& pb,
	class btIDebugDraw* debugDraw,btStackAlloc* stackAll oc,	class btIDebugDraw* debugDraw,btStackAlloc* stackAll oc,
	struct SpuConvexPolyhedronVertexData* convexVertexDa taA,	struct SpuConvexPolyhedronVertexData* convexVertexDa taA,
	struct SpuConvexPolyhedronVertexData* convexVertexDa taB	struct SpuConvexPolyhedronVertexData* convexVertexDa taB
	) const = 0;	) const = 0;

	};	};


	#endif //CONVEX_PENETRATION_DEPTH_H	#endif //SPU_CONVEX_PENETRATION_DEPTH_H

End of changes. 4 change blocks.
	4 lines changed or deleted	4 lines changed or added

	btBulletDynamicsCommon.h	btBulletDynamicsCommon.h

	skipping to change at line 33	skipping to change at line 33
	#include "BulletDynamics/Dynamics/btContinuousDynamicsWorld.h"	#include "BulletDynamics/Dynamics/btContinuousDynamicsWorld.h"

	#include "BulletDynamics/Dynamics/btSimpleDynamicsWorld.h"	#include "BulletDynamics/Dynamics/btSimpleDynamicsWorld.h"
	#include "BulletDynamics/Dynamics/btRigidBody.h"	#include "BulletDynamics/Dynamics/btRigidBody.h"

	#include "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h"	#include "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h"
	#include "BulletDynamics/ConstraintSolver/btHingeConstraint.h"	#include "BulletDynamics/ConstraintSolver/btHingeConstraint.h"
	#include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h"	#include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h"
	#include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h"	#include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h"
	#include "BulletDynamics/ConstraintSolver/btSliderConstraint.h"	#include "BulletDynamics/ConstraintSolver/btSliderConstraint.h"

		#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h"
		#include "BulletDynamics/ConstraintSolver/btUniversalConstraint.h"
		#include "BulletDynamics/ConstraintSolver/btHinge2Constraint.h"

	#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolv er.h"	#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolv er.h"

	///Vehicle simulation, with wheel contact simulated by raycasts	///Vehicle simulation, with wheel contact simulated by raycasts
	#include "BulletDynamics/Vehicle/btRaycastVehicle.h"	#include "BulletDynamics/Vehicle/btRaycastVehicle.h"

	#endif //BULLET_DYNAMICS_COMMON_H	#endif //BULLET_DYNAMICS_COMMON_H

End of changes. 1 change blocks.
	0 lines changed or deleted	3 lines changed or added

	btConvexConvexAlgorithm.h	btConvexConvexAlgorithm.h

	skipping to change at line 34	skipping to change at line 34
	#include "btCollisionCreateFunc.h"	#include "btCollisionCreateFunc.h"
	#include "btCollisionDispatcher.h"	#include "btCollisionDispatcher.h"
	#include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUti l	#include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUti l

	class btConvexPenetrationDepthSolver;	class btConvexPenetrationDepthSolver;

	///Enabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computati on. However, when using large size ratios GJK can be imprecise	///Enabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computati on. However, when using large size ratios GJK can be imprecise
	///so the distance is not conservative. In that case, enabling this USE_SEP DISTANCE_UTIL2 would result in failing/missing collisions.	///so the distance is not conservative. In that case, enabling this USE_SEP DISTANCE_UTIL2 would result in failing/missing collisions.
	///Either improve GJK for large size ratios (testing a 100 units versus a 0 .1 unit object) or only enable the util	///Either improve GJK for large size ratios (testing a 100 units versus a 0 .1 unit object) or only enable the util
	///for certain pairs that have a small size ratio	///for certain pairs that have a small size ratio

	///#define USE_SEPDISTANCE_UTIL2 1
		#define USE_SEPDISTANCE_UTIL2 1

	///The convexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations between two conve x objects.	///The convexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations between two conve x objects.
	///Multiple contact points are calculated by perturbing the orientation of the smallest object orthogonal to the separating normal.	///Multiple contact points are calculated by perturbing the orientation of the smallest object orthogonal to the separating normal.
	///This idea was described by Gino van den Bergen in this forum topic http: //www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=4&t=288&p=888#p888	///This idea was described by Gino van den Bergen in this forum topic http: //www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=4&t=288&p=888#p888
	class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm	class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm
	{	{
	#ifdef USE_SEPDISTANCE_UTIL2	#ifdef USE_SEPDISTANCE_UTIL2
	btConvexSeparatingDistanceUtil m_sepDistance;	btConvexSeparatingDistanceUtil m_sepDistance;
	#endif	#endif
	btSimplexSolverInterface* m_simplexSolver;	btSimplexSolverInterface* m_simplexSolver;

End of changes. 1 change blocks.
	1 lines changed or deleted	2 lines changed or added

	btDbvtBroadphase.h	btDbvtBroadphase.h
	/*	/*
	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2007 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.

	skipping to change at line 118	skipping to change at line 119
	virtual void rayTest(const btVector3& rayFrom,const btVector3& ra yTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin=btVecto r3(0,0,0), const btVector3& aabbMax = btVector3(0,0,0));	virtual void rayTest(const btVector3& rayFrom,const btVector3& ra yTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin=btVecto r3(0,0,0), const btVector3& aabbMax = btVector3(0,0,0));

	virtual void getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const;	virtual void getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const;
	void calculateOve rlappingPairs(btDispatcher* dispatcher);	void calculateOve rlappingPairs(btDispatcher* dispatcher);
	btOverlappingPairCache* getOverlappingPairCache();	btOverlappingPairCache* getOverlappingPairCache();
	const btOverlappingPairCache* getOverlappingPairCache() const;	const btOverlappingPairCache* getOverlappingPairCache() const;
	void getBroadphas eAabb(btVector3& aabbMin,btVector3& aabbMax) const;	void getBroadphas eAabb(btVector3& aabbMin,btVector3& aabbMax) const;
	void printStats() ;	void printStats() ;
	static void benchmark(bt BroadphaseInterface*);	static void benchmark(bt BroadphaseInterface*);


		void setVelocityPrediction(btScalar prediction)
		{
		m_prediction = prediction;
		}
		btScalar getVelocityPrediction() const
		{
		return m_prediction;
		}

	void performDeferredRemoval(btDispatcher* dispatcher);	void performDeferredRemoval(btDispatcher* dispatcher);

	///reset broadphase internal structures, to ensure determinism/repro ducability	///reset broadphase internal structures, to ensure determinism/repro ducability
	virtual void resetPool(btDispatcher* dispatcher);	virtual void resetPool(btDispatcher* dispatcher);

	};	};

	#endif	#endif

End of changes. 2 change blocks.
	1 lines changed or deleted	10 lines changed or added

	btGImpactBvh.h	btGImpactBvh.h

	skipping to change at line 221	skipping to change at line 221
	//! Prototype Base class for primitive classification	//! Prototype Base class for primitive classification
	/*!	/*!
	This class is a wrapper for primitive collections.	This class is a wrapper for primitive collections.
	This tells relevant info for the Bounding Box set classes, which take care of space classification.	This tells relevant info for the Bounding Box set classes, which take care of space classification.
	This class can manage Compound shapes and trimeshes, and if it is managing trimesh then the Hierarchy Bounding Box classes will take advantage of pri mitive Vs Box overlapping tests for getting optimal results and less Per Bo x compairisons.	This class can manage Compound shapes and trimeshes, and if it is managing trimesh then the Hierarchy Bounding Box classes will take advantage of pri mitive Vs Box overlapping tests for getting optimal results and less Per Bo x compairisons.
	*/	*/
	class btPrimitiveManagerBase	class btPrimitiveManagerBase
	{	{
	public:	public:


		virtual ~btPrimitiveManagerBase() {}

	//! determines if this manager consist on only triangles, which spec ial case will be optimized	//! determines if this manager consist on only triangles, which spec ial case will be optimized
	virtual bool is_trimesh() const = 0;	virtual bool is_trimesh() const = 0;
	virtual int get_primitive_count() const = 0;	virtual int get_primitive_count() const = 0;
	virtual void get_primitive_box(int prim_index ,btAABB & primbox) con st = 0;	virtual void get_primitive_box(int prim_index ,btAABB & primbox) con st = 0;
	//! retrieves only the points of the triangle, and the collision mar gin	//! retrieves only the points of the triangle, and the collision mar gin
	virtual void get_primitive_triangle(int prim_index,btPrimitiveTriang le & triangle) const= 0;	virtual void get_primitive_triangle(int prim_index,btPrimitiveTriang le & triangle) const= 0;
	};	};

	//! Structure for containing Boxes	//! Structure for containing Boxes
	/*!	/*!

End of changes. 1 change blocks.
	0 lines changed or deleted	2 lines changed or added

	btGjkEpaPenetrationDepthSolver.h	btGjkEpaPenetrationDepthSolver.h

	skipping to change at line 28	skipping to change at line 28
	#define BT_GJP_EPA_PENETRATION_DEPTH_H	#define BT_GJP_EPA_PENETRATION_DEPTH_H

	#include "btConvexPenetrationDepthSolver.h"	#include "btConvexPenetrationDepthSolver.h"

	///EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to	///EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to
	///calculate the penetration depth between two convex shapes.	///calculate the penetration depth between two convex shapes.
	class btGjkEpaPenetrationDepthSolver : public btConvexPenetrationDepthSolve r	class btGjkEpaPenetrationDepthSolver : public btConvexPenetrationDepthSolve r
	{	{
	public :	public :


		btGjkEpaPenetrationDepthSolver()
		{
		}

	bool calcPenDepth( btSimplexSolverInterfa ce& simplexSolver,	bool calcPenDepth( btSimplexSolverInterfa ce& simplexSolver,
	co nst btConvexShape* pConvexA, const btConvexShape* pConvexB,	co nst btConvexShape* pConvexA, const btConvexShape* pConvexB,
	co nst btTransform& transformA, const btTransform& transformB,	co nst btTransform& transformA, const btTransform& transformB,
	bt Vector3& v, btVector3& wWitnessOnA, btVector3& wWitnessOnB,	bt Vector3& v, btVector3& wWitnessOnA, btVector3& wWitnessOnB,
	cl ass btIDebugDraw* debugDraw,btStackAlloc* stackAlloc );	cl ass btIDebugDraw* debugDraw,btStackAlloc* stackAlloc );

	private :	private :

	};	};


End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	btShapeHull.h	btShapeHull.h
	/*	/*

	btShapeHull implemented by John McCutchan.

	Bullet Continuous Collision Detection and Physics Library	Bullet Continuous Collision Detection and Physics Library

	Copyright (c) 2003-2008 Erwin Coumans http://continuousphysics.com/Bullet/	Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org

	This software is provided 'as-is', without any express or implied warranty.	This software is provided 'as-is', without any express or implied warranty.
	In no event will the authors be held liable for any damages arising from th e use of this software.	In no event will the authors be held liable for any damages arising from th e use of this software.
	Permission is granted to anyone to use this software for any purpose,	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it free ly,	including commercial applications, and to alter it and redistribute it free ly,
	subject to the following restrictions:	subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.	1. The origin of this software must not be misrepresented; you must not cla im that you wrote the original software. If you use this software in a prod uct, an acknowledgment in the product documentation would be appreciated bu t is not required.
	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.	2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.	3. This notice may not be removed or altered from any source distribution.
	*/	*/


		///btShapeHull implemented by John McCutchan.

	#ifndef _SHAPE_HULL_H	#ifndef _SHAPE_HULL_H
	#define _SHAPE_HULL_H	#define _SHAPE_HULL_H

	#include "LinearMath/btAlignedObjectArray.h"	#include "LinearMath/btAlignedObjectArray.h"
	#include "BulletCollision/CollisionShapes/btConvexShape.h"	#include "BulletCollision/CollisionShapes/btConvexShape.h"

	///The btShapeHull class takes a btConvexShape, builds a simplified convex hull using btConvexHull and provides triangle indices and vertices.	///The btShapeHull class takes a btConvexShape, builds a simplified convex hull using btConvexHull and provides triangle indices and vertices.
	///It can be useful for to simplify a complex convex object and for visuali zation of a non-polyhedral convex object.	///It can be useful for to simplify a complex convex object and for visuali zation of a non-polyhedral convex object.
	///It approximates the convex hull using the supporting vertex of 42 direct ions.	///It approximates the convex hull using the supporting vertex of 42 direct ions.
	class btShapeHull	class btShapeHull

End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	glui.h	glui.h

	skipping to change at line 787	skipping to change at line 787
	/** Draw a 3D-look pushed-out box around this rectangle */	/** Draw a 3D-look pushed-out box around this rectangle */
	void draw_raised_box( int x, int y, int w, int h );	void draw_raised_box( int x, int y, int w, int h );
	/** Draw a 3D-look pushed-in box around this rectangle */	/** Draw a 3D-look pushed-in box around this rectangle */
	void draw_lowered_box( int x, int y, int w, int h );	void draw_lowered_box( int x, int y, int w, int h );

	/** Return true if this control should redraw itself immediately (front buffer);	/** Return true if this control should redraw itself immediately (front buffer);
	Or queue up a redraw and return false if it shouldn't (back buffer).	Or queue up a redraw and return false if it shouldn't (back buffer).
	*/	*/
	bool should_redraw_now(GLUI_Control *ctl);	bool should_redraw_now(GLUI_Control *ctl);


		int getMainWindowId()
		{
		return main_gfx_window_id;
		}
	/** Switch to the appropriate draw buffer now. Returns the old draw bu ffer.	/** Switch to the appropriate draw buffer now. Returns the old draw bu ffer.
	This routine should probably only be called from inside the GLUI_Dra wingSentinal,	This routine should probably only be called from inside the GLUI_Dra wingSentinal,
	in glui_internal_control.h	in glui_internal_control.h
	*/	*/
	int set_current_draw_buffer();	int set_current_draw_buffer();
	/** Go back to using this draw buffer. Undoes set_current_draw_buffer. */	/** Go back to using this draw buffer. Undoes set_current_draw_buffer. */
	void restore_draw_buffer( int buffer_state );	void restore_draw_buffer( int buffer_state );

	/** Pack, resize the window, and redraw all the controls. */	/** Pack, resize the window, and redraw all the controls. */
	void refresh();	void refresh();

End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	vectormath2bullet.h	vectormath2bullet.h

	skipping to change at line 34	skipping to change at line 34
	INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE
	POSSIBILITY OF SUCH DAMAGE.	POSSIBILITY OF SUCH DAMAGE.
	*/	*/

	#ifndef AOS_VECTORMATH_BULLET_CONVERT_H	#ifndef AOS_VECTORMATH_BULLET_CONVERT_H
	#define AOS_VECTORMATH_BULLET_CONVERT_H	#define AOS_VECTORMATH_BULLET_CONVERT_H

	#include <vectormath_aos.h>	#include <vectormath_aos.h>

		//#include "BulletMultiThreaded/vectormath/scalar/cpp/vectormath_aos.h"

	#include "LinearMath/btVector3.h"	#include "LinearMath/btVector3.h"
	#include "LinearMath/btQuaternion.h"	#include "LinearMath/btQuaternion.h"
	#include "LinearMath/btMatrix3x3.h"	#include "LinearMath/btMatrix3x3.h"

	inline Vectormath::Aos::Vector3 getVmVector3(const btVector3& bullet Vec)	inline Vectormath::Aos::Vector3 getVmVector3(const btVector3& bullet Vec)
	{	{
	return Vectormath::Aos::Vector3(bulletVec.getX(),bulletVec.getY(),bu lletVec.getZ());	return Vectormath::Aos::Vector3(bulletVec.getX(),bulletVec.getY(),bu lletVec.getZ());
	}	}

	inline btVector3 getBtVector3(const Vectormath::Aos::Vector3& vmVec)	inline btVector3 getBtVector3(const Vectormath::Aos::Vector3& vmVec)

End of changes. 1 change blocks.
	0 lines changed or deleted	2 lines changed or added