Add the old Bullet 2.x obsolete demos, and CMake buildsystem files, and gradually move them to newer Bullet 3.x structure

Use statically linked freeglut, instead of dynamic glut for the obsolete Bullet 2.x demos
Add the 'reset' method to b3GpuDynamicsWorld, and use it in the BasicGpuDemo (pretty slow in debug mode, use release mode)
Don't crash in btCollisionWorld, if there is no collision dispatcher

ObsoleteDemos/BspDemo/BspConverter.cpp

@@ -0,0 +1,207 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+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 the 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 freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but 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.
+*/
+
+#include "BspConverter.h"
+#include "BspLoader.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btGeometryUtil.h"
+#include <stdio.h>
+#include <string.h>
+
+
+void BspConverter::convertBsp(BspLoader& bspLoader,float scaling)
+{
+	{
+		
+		float	playstartf[3] = {0,0,100};
+
+		if (bspLoader.findVectorByName(&playstartf[0],"info_player_start"))
+		{
+			printf("found playerstart\n");
+		} 
+		else
+		{
+			if (bspLoader.findVectorByName(&playstartf[0],"info_player_deathmatch"))
+			{
+				printf("found deatchmatch start\n");
+			}
+		}
+
+		btVector3 playerStart (playstartf[0],playstartf[1],playstartf[2]);
+
+
+		playerStart[2] += 20.f; //start a bit higher
+
+		playerStart *= scaling;
+
+		
+
+		//progressBegin("Loading bsp");
+
+		for (int i=0;i<bspLoader.m_numleafs;i++)
+		{
+			printf("Reading bspLeaf %i from total %i (%f procent)\n",i, bspLoader.m_numleafs,(100.f*(float)i/float(bspLoader.m_numleafs)) );
+			
+			bool isValidBrush = false;
+			
+			BSPLeaf&	leaf = bspLoader.m_dleafs[i];
+	
+			for (int b=0;b<leaf.numLeafBrushes;b++)
+			{
+				btAlignedObjectArray<btVector3> planeEquations;
+				
+				int brushid = bspLoader.m_dleafbrushes[leaf.firstLeafBrush+b];
+
+				BSPBrush& brush = bspLoader.m_dbrushes[brushid];
+				if (brush.shaderNum!=-1)
+				{
+					if (bspLoader.m_dshaders[ brush.shaderNum ].contentFlags & BSPCONTENTS_SOLID)
+					{
+						brush.shaderNum = -1;
+
+						for (int p=0;p<brush.numSides;p++)
+						{
+							int sideid = brush.firstSide+p;
+							BSPBrushSide& brushside = bspLoader.m_dbrushsides[sideid];
+							int planeid = brushside.planeNum;
+							BSPPlane& plane = bspLoader.m_dplanes[planeid];
+							btVector3 planeEq;
+							planeEq.setValue(
+								plane.normal[0],
+								plane.normal[1],
+								plane.normal[2]);
+							planeEq[3] = scaling*-plane.dist;
+
+							planeEquations.push_back(planeEq);
+							isValidBrush=true;
+						}
+						if (isValidBrush)
+						{
+
+							btAlignedObjectArray<btVector3>	vertices;
+							btGeometryUtil::getVerticesFromPlaneEquations(planeEquations,vertices);
+						
+							bool isEntity = false;
+							btVector3 entityTarget(0.f,0.f,0.f);
+							addConvexVerticesCollider(vertices,isEntity,entityTarget);
+						
+						}
+					}
+				} 
+			}
+		}
+
+#define USE_ENTITIES
+#ifdef USE_ENTITIES
+
+		
+		{
+			int i;
+			for (i=0;i<bspLoader.m_num_entities;i++)
+				{
+					const BSPEntity& entity = bspLoader.m_entities[i];
+					const char* cl = bspLoader.getValueForKey(&entity,"classname");
+					if ( !strcmp( cl, "trigger_push" ) ) {
+						btVector3 targetLocation(0.f,0.f,0.f);
+
+						cl = bspLoader.getValueForKey(&entity,"target");
+						if ( strcmp( cl, "" ) ) {
+							//its not empty so ...
+
+							/*
+							//lookup the target position for the jumppad:
+							const BSPEntity* targetentity = bspLoader.getEntityByValue( "targetname" , cl );
+							if (targetentity)
+							{
+								if (bspLoader.getVectorForKey( targetentity , "origin",&targetLocation[0]))
+								{
+																	
+								}
+							}
+							*/
+
+
+							cl = bspLoader.getValueForKey(&entity,"model");
+							if ( strcmp( cl, "" ) ) {
+								// add the model as a brush
+								if (cl[0] == '*')
+								{
+									int modelnr = atoi(&cl[1]);
+									if ((modelnr >=0) && (modelnr < bspLoader.m_nummodels))
+									{
+										const BSPModel& model = bspLoader.m_dmodels[modelnr];
+										for (int n=0;n<model.numBrushes;n++)
+										{
+											btAlignedObjectArray<btVector3> planeEquations;
+											bool	isValidBrush = false;
+
+											//convert brush
+											const BSPBrush& brush = bspLoader.m_dbrushes[model.firstBrush+n];
+											{
+												for (int p=0;p<brush.numSides;p++)
+												{
+													int sideid = brush.firstSide+p;
+													BSPBrushSide& brushside = bspLoader.m_dbrushsides[sideid];
+													int planeid = brushside.planeNum;
+													BSPPlane& plane = bspLoader.m_dplanes[planeid];
+													btVector3 planeEq;
+													planeEq.setValue(
+														plane.normal[0],
+														plane.normal[1],
+														plane.normal[2]);
+													planeEq[3] = scaling*-plane.dist;
+													planeEquations.push_back(planeEq);
+													isValidBrush=true;
+												}
+												if (isValidBrush)
+												{
+													
+													btAlignedObjectArray<btVector3>	vertices;
+													btGeometryUtil::getVerticesFromPlaneEquations(planeEquations,vertices);
+
+													bool isEntity=true;
+													addConvexVerticesCollider(vertices,isEntity,targetLocation);
+													
+												}
+											}
+
+										}
+									}
+								} 
+								else
+								{
+									printf("unsupported trigger_push model, md3 ?\n");
+								}
+							}
+						
+						}
+					}
+				}
+			}
+					
+#endif //USE_ENTITIES
+
+		
+
+		//progressEnd();
+		}
+	
+	}
+
+
+
+
+
+

ObsoleteDemos/BspDemo/BspConverter.h

@@ -0,0 +1,39 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+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 the 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 freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but 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 BSP_CONVERTER_H
+#define BSP_CONVERTER_H
+
+class BspLoader;
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+///BspConverter turns a loaded bsp level into convex parts (vertices)
+class BspConverter
+{
+	public:
+
+		void convertBsp(BspLoader& bspLoader,float scaling);
+		virtual ~BspConverter()
+		{
+		}
+
+		///this callback is called for each brush that succesfully converted into vertices
+		virtual void	addConvexVerticesCollider(btAlignedObjectArray<btVector3>& vertices, bool isEntity, const btVector3& entityTargetLocation) = 0;
+
+};
+
+#endif //BSP_CONVERTER_H
+

ObsoleteDemos/BspDemo/BspDemo.cpp

@@ -0,0 +1,321 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+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 the 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 freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but 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.
+*/
+
+#include "btBulletDynamicsCommon.h"
+
+#include "LinearMath/btQuickprof.h"
+#include "LinearMath/btIDebugDraw.h"
+
+#include "GLDebugDrawer.h"
+
+
+#define QUAKE_BSP_IMPORTING 1
+
+#ifdef QUAKE_BSP_IMPORTING
+#include "BspLoader.h"
+#include "BspConverter.h"
+#endif //QUAKE_BSP_IMPORTING
+
+
+#include <stdio.h> //printf debugging
+
+
+#include "BspDemo.h"
+#include "GL_ShapeDrawer.h"
+#include "GlutStuff.h"
+
+
+
+
+#define CUBE_HALF_EXTENTS 1
+#define EXTRA_HEIGHT -20.f
+
+
+
+///BspToBulletConverter  extends the BspConverter to convert to Bullet datastructures
+class BspToBulletConverter : public BspConverter
+{
+	BspDemo* m_demoApp;
+
+public:
+
+	BspToBulletConverter(BspDemo*	demoApp)
+		:m_demoApp(demoApp)
+	{
+	}
+
+		virtual void	addConvexVerticesCollider(btAlignedObjectArray<btVector3>& vertices, bool isEntity, const btVector3& entityTargetLocation)
+		{
+			///perhaps we can do something special with entities (isEntity)
+			///like adding a collision Triggering (as example)
+			
+			if (vertices.size() > 0)
+			{
+				float mass = 0.f;
+				btTransform startTransform;
+				//can use a shift
+				startTransform.setIdentity();
+				startTransform.setOrigin(btVector3(0,0,-10.f));
+				//this create an internal copy of the vertices
+				
+				btCollisionShape* shape = new btConvexHullShape(&(vertices[0].getX()),vertices.size());
+				m_demoApp->m_collisionShapes.push_back(shape);
+
+				//btRigidBody* body = m_demoApp->localCreateRigidBody(mass, startTransform,shape);
+				m_demoApp->localCreateRigidBody(mass, startTransform,shape);
+			}
+		}
+};
+
+
+
+
+
+////////////////////////////////////
+
+
+
+
+
+
+
+BspDemo::~BspDemo()
+{
+		//cleanup in the reverse order of creation/initialization
+
+	//remove the rigidbodies from the dynamics world and delete them
+	int i;
+	for (i=m_dynamicsWorld->getNumCollisionObjects()-1; i>=0 ;i--)
+	{
+		btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+		btRigidBody* body = btRigidBody::upcast(obj);
+		if (body && body->getMotionState())
+		{
+			delete body->getMotionState();
+		}
+		m_dynamicsWorld->removeCollisionObject( obj );
+		delete obj;
+	}
+
+	//delete collision shapes
+	for (int j=0;j<m_collisionShapes.size();j++)
+	{
+		btCollisionShape* shape = m_collisionShapes[j];
+		delete shape;
+	}
+
+	//delete dynamics world
+	delete m_dynamicsWorld;
+
+	//delete solver
+	delete m_solver;
+
+	//delete broadphase
+	delete m_broadphase;
+
+	//delete dispatcher
+	delete m_dispatcher;
+
+	delete m_collisionConfiguration;
+}
+
+void	BspDemo::initPhysics()
+{
+	const char* bspfilename = "BspDemo.bsp";
+	
+	initPhysics(bspfilename);
+}
+
+
+
+void	BspDemo::initPhysics(const char* bspfilename)
+{
+	setTexturing(true);
+	setShadows(false);
+	
+	m_cameraUp = btVector3(0,0,1);
+	m_forwardAxis = 1;
+
+	setCameraDistance(22.f);
+
+	///Setup a Physics Simulation Environment
+
+	m_collisionConfiguration = new btDefaultCollisionConfiguration();
+//	btCollisionShape* groundShape = new btBoxShape(btVector3(50,3,50));
+	m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
+	btVector3 worldMin(-1000,-1000,-1000);
+	btVector3 worldMax(1000,1000,1000);
+	m_broadphase = new btDbvtBroadphase();
+	//m_broadphase = new btAxisSweep3(worldMin,worldMax);
+	//btOverlappingPairCache* broadphase = new btSimpleBroadphase();
+	m_solver = new btSequentialImpulseConstraintSolver();
+	//ConstraintSolver* solver = new OdeConstraintSolver;
+	m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration);
+
+	m_dynamicsWorld->setGravity(-m_cameraUp * 10);
+
+
+#ifdef QUAKE_BSP_IMPORTING
+
+	void* memoryBuffer = 0;
+	
+	FILE* file = fopen(bspfilename,"r");
+	if (!file)
+	{
+		//try again other path, 
+		//sight... visual studio leaves the current working directory in the projectfiles folder
+		//instead of executable folder. who wants this default behaviour?!?
+		bspfilename = "../../BspDemo.bsp";
+		file = fopen(bspfilename,"r");
+	}
+	if (!file)
+	{
+
+		//try again other path, cmake needs 4 levels deep back...
+		bspfilename = "../../../../BspDemo.bsp";
+		file = fopen(bspfilename,"r");
+	}
+	if (!file)
+	{
+		//try again other path, 
+		//sight... visual studio leaves the current working directory in the projectfiles folder
+		//instead of executable folder. who wants this default behaviour?!?
+		bspfilename = "BspDemo.bsp";
+		file = fopen(bspfilename,"r");
+	}
+
+	if (file)
+	{
+		BspLoader bspLoader;
+		int size=0;
+		if (fseek(file, 0, SEEK_END) || (size = ftell(file)) == EOF || fseek(file, 0, SEEK_SET)) {        /* File operations denied? ok, just close and return failure */
+			printf("Error: cannot get filesize from %s\n", bspfilename);
+		} else
+		{
+			//how to detect file size?
+			memoryBuffer = malloc(size+1);
+			fread(memoryBuffer,1,size,file);
+			bspLoader.loadBSPFile( memoryBuffer);
+
+			BspToBulletConverter bsp2bullet(this);
+			float bspScaling = 0.1f;
+			bsp2bullet.convertBsp(bspLoader,bspScaling);
+
+		}
+		fclose(file);
+	}
+
+#endif
+
+
+
+
+	clientResetScene();
+
+}
+
+
+void BspDemo::clientMoveAndDisplay()
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
+	float dt = getDeltaTimeMicroseconds() * 0.000001f;
+	
+	m_dynamicsWorld->stepSimulation(dt);
+
+	//optional but useful: debug drawing
+	m_dynamicsWorld->debugDrawWorld();
+
+	renderme();
+
+	glFlush();
+	glutSwapBuffers();
+
+}
+
+
+
+void BspDemo::displayCallback(void) {
+
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
+
+
+	renderme();
+
+	//optional but useful: debug drawing
+	if (m_dynamicsWorld)
+		m_dynamicsWorld->debugDrawWorld();
+
+	glFlush();
+	glutSwapBuffers();
+}
+
+
+
+
+
+
+//some code that de-mangles the windows filename passed in as argument
+char cleaned_filename[512];
+char* getLastFileName()
+{
+	return cleaned_filename;
+}
+char* makeExeToBspFilename(const char* lpCmdLine)
+{
+
+
+	// We might get a windows-style path on the command line, this can mess up the DOM which expects
+	// all paths to be URI's.  This block of code does some conversion to try and make the input
+	// compliant without breaking the ability to accept a properly formatted URI.  Right now this only
+	// displays the first filename
+	const char *in = lpCmdLine;
+	char* out = cleaned_filename;
+	*out = '\0';
+	// If the first character is a ", skip it (filenames with spaces in them are quoted)
+	if(*in == '\"')
+	{
+		in++;
+	}
+	int i;
+	for(i =0; i<512; i++)
+	{
+		//if we get '.' we stop as well, unless it's the first character. Then we add .bsp as extension
+		// If we hit a null or a quote, stop copying.  This will get just the first filename.
+		if(i && (in[0] == '.') && (in[1] == 'e') && (in[2] == 'x') && (in[3] == 'e'))
+			break;
+			
+		// If we hit a null or a quote, stop copying.  This will get just the first filename.
+		if(*in == '\0' || *in == '\"')
+			break;
+		// Copy while swapping backslashes for forward ones
+		if(*in == '\\')
+		{
+			*out = '/';
+		}
+		else
+		{
+			*out = *in;
+		}
+		in++;
+		out++;
+	}
+	*(out++) = '.';
+	*(out++) = 'b';
+	*(out++) = 's';
+	*(out++) = 'p';
+	*(out++) = 0;
+	
+	return cleaned_filename;
+}

ObsoleteDemos/BspDemo/BspDemo.h

@@ -0,0 +1,71 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+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 the 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 freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but 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 BSP_DEMO_H
+#define BSP_DEMO_H
+
+#include "GlutDemoApplication.h"
+#include "LinearMath/btAlignedObjectArray.h"
+
+class btBroadphaseInterface;
+class btCollisionShape;
+class btOverlappingPairCache;
+class btCollisionDispatcher;
+class btConstraintSolver;
+struct btCollisionAlgorithmCreateFunc;
+class btDefaultCollisionConfiguration;
+
+
+///BspDemo shows the convex collision detection, by converting a Quake BSP file into convex objects and allowing interaction with boxes.
+class BspDemo : public GlutDemoApplication
+{
+	public:
+
+	//keep the collision shapes, for deletion/cleanup
+	btAlignedObjectArray<btCollisionShape*>	m_collisionShapes;
+
+	btBroadphaseInterface*	m_broadphase;
+
+	btCollisionDispatcher*	m_dispatcher;
+
+	btConstraintSolver*	m_solver;
+
+	btDefaultCollisionConfiguration* m_collisionConfiguration;
+
+
+	
+
+	virtual ~BspDemo();
+
+	virtual void	initPhysics();
+
+	void	initPhysics(const char* bspfilename);
+
+	virtual void clientMoveAndDisplay();
+
+	virtual void displayCallback();
+	
+	static DemoApplication* Create()
+	{
+		BspDemo* demo = new BspDemo;
+		demo->myinit();
+		demo->initPhysics("BspDemo.bsp");
+		return demo;
+	}
+
+};
+
+#endif //BSP_DEMO_H
+
+

ObsoleteDemos/BspDemo/BspLoader.cpp

@@ -0,0 +1,730 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+
+This file is part of Quake III Arena source code.
+
+Quake III Arena source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU bteral Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+Quake III Arena source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU bteral Public License for more details.
+
+You should have received a copy of the GNU bteral Public License
+along with Foobar; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+
+#include "BspLoader.h"
+#include <stdio.h>
+#include <string.h>
+
+typedef struct
+{
+	char	filename[1024];
+	char    *buffer,*script_p,*end_p;
+	int     line;
+} BSPScript;
+
+#define	MAX_INCLUDES	8
+BSPScript	scriptstack[MAX_INCLUDES];
+BSPScript	*script;
+int			scriptline;
+
+char    token[BSPMAXTOKEN];
+bool endofscript;
+bool tokenready;                     // only true if UnGetToken was just called
+
+//
+//loadBSPFile
+//
+
+int extrasize = 100;
+
+BspLoader::BspLoader()
+	:m_num_entities(0)
+{
+	m_Endianness = getMachineEndianness();
+	if (m_Endianness == BSP_BIG_ENDIAN)
+	{
+		printf("Machine is BIG_ENDIAN\n");
+	} else
+	{
+		printf("Machine is Little Endian\n");
+	}
+}
+
+
+bool	BspLoader::loadBSPFile( void* memoryBuffer) {
+	
+	BSPHeader	*header = (BSPHeader*) memoryBuffer;
+
+	// load the file header
+	if (header)
+	{
+		// swap the header
+		swapBlock( (int *)header, sizeof(*header) );
+		
+		int length = (header->lumps[BSPLUMP_SHADERS].filelen) / sizeof(BSPShader);
+		m_dshaders.resize(length+extrasize);
+		m_numShaders = copyLump( header, BSPLUMP_SHADERS, &m_dshaders[0], sizeof(BSPShader) );
+
+		length = (header->lumps[LUMP_MODELS].filelen) / sizeof(BSPModel);
+		m_dmodels.resize(length+extrasize);
+		m_nummodels = copyLump( header, LUMP_MODELS, &m_dmodels[0], sizeof(BSPModel) );
+
+		length = (header->lumps[BSPLUMP_PLANES].filelen) / sizeof(BSPPlane);
+		m_dplanes.resize(length+extrasize);
+		m_numplanes = copyLump( header, BSPLUMP_PLANES, &m_dplanes[0], sizeof(BSPPlane) );
+
+		length = (header->lumps[BSPLUMP_LEAFS].filelen) / sizeof(BSPLeaf);
+		m_dleafs.resize(length+extrasize);
+		m_numleafs = copyLump( header, BSPLUMP_LEAFS, &m_dleafs[0], sizeof(BSPLeaf) );
+
+		length = (header->lumps[BSPLUMP_NODES].filelen) / sizeof(BSPNode);
+		m_dnodes.resize(length+extrasize);
+		m_numnodes = copyLump( header, BSPLUMP_NODES, &m_dnodes[0], sizeof(BSPNode) );
+
+		length = (header->lumps[BSPLUMP_LEAFSURFACES].filelen) / sizeof(m_dleafsurfaces[0]);
+		m_dleafsurfaces.resize(length+extrasize);
+		m_numleafsurfaces = copyLump( header, BSPLUMP_LEAFSURFACES, &m_dleafsurfaces[0], sizeof(m_dleafsurfaces[0]) );
+
+		length = (header->lumps[BSPLUMP_LEAFBRUSHES].filelen) / sizeof(m_dleafbrushes[0]) ;
+		m_dleafbrushes.resize(length+extrasize);
+		m_numleafbrushes = copyLump( header, BSPLUMP_LEAFBRUSHES, &m_dleafbrushes[0], sizeof(m_dleafbrushes[0]) );
+
+		length = (header->lumps[LUMP_BRUSHES].filelen) / sizeof(BSPBrush);
+		m_dbrushes.resize(length+extrasize);
+		m_numbrushes = copyLump( header, LUMP_BRUSHES, &m_dbrushes[0], sizeof(BSPBrush) );
+
+
+		length = (header->lumps[LUMP_BRUSHSIDES].filelen) / sizeof(BSPBrushSide);
+		m_dbrushsides.resize(length+extrasize);
+		m_numbrushsides = copyLump( header, LUMP_BRUSHSIDES, &m_dbrushsides[0], sizeof(BSPBrushSide) );
+
+		
+		length = (header->lumps[LUMP_SURFACES].filelen) / sizeof(BSPSurface);
+		m_drawSurfaces.resize(length+extrasize);
+		m_numDrawSurfaces = copyLump( header, LUMP_SURFACES, &m_drawSurfaces[0], sizeof(BSPSurface) );
+
+
+		length = (header->lumps[LUMP_DRAWINDEXES].filelen) / sizeof(m_drawIndexes[0]);
+		m_drawIndexes.resize(length+extrasize);
+		m_numDrawIndexes = copyLump( header, LUMP_DRAWINDEXES, &m_drawIndexes[0], sizeof(m_drawIndexes[0]) );
+
+		length = (header->lumps[LUMP_VISIBILITY].filelen) / 1;
+		m_visBytes.resize(length+extrasize);
+		m_numVisBytes = copyLump( header, LUMP_VISIBILITY, &m_visBytes[0], 1 );
+
+		length = (header->lumps[LUMP_LIGHTMAPS].filelen) / 1;
+		m_lightBytes.resize(length+extrasize);
+		m_numLightBytes = copyLump( header, LUMP_LIGHTMAPS, &m_lightBytes[0], 1 );
+
+		length = (header->lumps[BSPLUMP_ENTITIES].filelen) / 1;
+		m_dentdata.resize(length+extrasize);
+		m_entdatasize = copyLump( header, BSPLUMP_ENTITIES, &m_dentdata[0], 1);
+
+		length = (header->lumps[LUMP_LIGHTGRID].filelen) / 1;
+		m_gridData.resize(length+extrasize);
+		m_numGridPoints = copyLump( header, LUMP_LIGHTGRID, &m_gridData[0], 8 );
+
+		// swap everything
+		swapBSPFile();
+
+		return true;
+
+	}
+	return false;
+}
+
+
+
+const char* BspLoader::getValueForKey( const  BSPEntity* ent, const char* key ) const {
+
+	const BSPKeyValuePair* ep;
+	
+	for (ep=ent->epairs ; ep ; ep=ep->next) {
+		if (!strcmp(ep->key, key) ) {
+			return ep->value;
+		}
+	}
+	return "";
+}
+
+float	BspLoader::getFloatForKey( const BSPEntity *ent, const char *key ) {
+	const char	*k;
+	
+	k = getValueForKey( ent, key );
+	return float(atof(k));
+}
+
+bool 	BspLoader::getVectorForKey( const BSPEntity *ent, const char *key, BSPVector3 vec ) {
+
+	const char	*k;
+	k = getValueForKey (ent, key);
+	if (strcmp(k, ""))
+	{
+		sscanf (k, "%f %f %f", &vec[0], &vec[1], &vec[2]);
+		return true;
+	}
+	return false;
+}
+
+
+
+
+/*
+==============
+parseFromMemory
+==============
+*/
+void BspLoader::parseFromMemory (char *buffer, int size)
+{
+	script = scriptstack;
+	script++;
+	if (script == &scriptstack[MAX_INCLUDES])
+	{
+		//printf("script file exceeded MAX_INCLUDES");
+	}
+	strcpy (script->filename, "memory buffer" );
+
+	script->buffer = buffer;
+	script->line = 1;
+	script->script_p = script->buffer;
+	script->end_p = script->buffer + size;
+
+	endofscript = false;
+	tokenready = false;
+}
+
+
+bool BspLoader::isEndOfScript (bool crossline)
+{
+	if (!crossline)
+		//printf("Line %i is incomplete\n",scriptline);
+
+	if (!strcmp (script->filename, "memory buffer"))
+	{
+		endofscript = true;
+		return false;
+	}
+
+	//free (script->buffer);
+	if (script == scriptstack+1)
+	{
+		endofscript = true;
+		return false;
+	}
+	script--;
+	scriptline = script->line;
+	//printf ("returning to %s\n", script->filename);
+	return getToken (crossline);
+}
+
+/*
+
+==============
+getToken
+==============
+*/
+bool BspLoader::getToken (bool crossline)
+{
+	char    *token_p;
+
+	if (tokenready)                         // is a token allready waiting?
+	{
+		tokenready = false;
+		return true;
+	}
+
+	if (script->script_p >= script->end_p)
+		return isEndOfScript (crossline);
+
+//
+// skip space
+//
+skipspace:
+	while (*script->script_p <= 32)
+	{
+		if (script->script_p >= script->end_p)
+			return isEndOfScript (crossline);
+		if (*script->script_p++ == '\n')
+		{
+			if (!crossline)
+			{
+				//printf("Line %i is incomplete\n",scriptline);
+			}
+			scriptline = script->line++;
+		}
+	}
+
+	if (script->script_p >= script->end_p)
+		return isEndOfScript (crossline);
+
+	// ; # // comments
+	if (*script->script_p == ';' || *script->script_p == '#'
+		|| ( script->script_p[0] == '/' && script->script_p[1] == '/') )
+	{
+		if (!crossline)
+		{
+			//printf("Line %i is incomplete\n",scriptline);
+		}
+		while (*script->script_p++ != '\n')
+			if (script->script_p >= script->end_p)
+				return isEndOfScript (crossline);
+		scriptline = script->line++;
+		goto skipspace;
+	}
+
+	// /* */ comments
+	if (script->script_p[0] == '/' && script->script_p[1] == '*')
+	{
+		if (!crossline)
+		{
+			//printf("Line %i is incomplete\n",scriptline);
+		}
+		script->script_p+=2;
+		while (script->script_p[0] != '*' && script->script_p[1] != '/')
+		{
+			if ( *script->script_p == '\n' ) {
+				scriptline = script->line++;
+			}
+			script->script_p++;
+			if (script->script_p >= script->end_p)
+				return isEndOfScript (crossline);
+		}
+		script->script_p += 2;
+		goto skipspace;
+	}
+
+//
+// copy token
+//
+	token_p = token;
+
+	if (*script->script_p == '"')
+	{
+		// quoted token
+		script->script_p++;
+		while (*script->script_p != '"')
+		{
+			*token_p++ = *script->script_p++;
+			if (script->script_p == script->end_p)
+				break;
+			if (token_p == &token[BSPMAXTOKEN])
+			{
+				//printf ("Token too large on line %i\n",scriptline);
+			}
+		}
+		script->script_p++;
+	}
+	else	// regular token
+	while ( *script->script_p > 32 && *script->script_p != ';')
+	{
+		*token_p++ = *script->script_p++;
+		if (script->script_p == script->end_p)
+			break;
+		if (token_p == &token[BSPMAXTOKEN])
+		{
+			//printf ("Token too large on line %i\n",scriptline);
+		}
+	}
+
+	*token_p = 0;
+
+	if (!strcmp (token, "$include"))
+	{
+		//getToken (false);
+		//AddScriptToStack (token);
+		return false;//getToken (crossline);
+	}
+
+	return true;
+}
+
+char *BspLoader::copystring(const char *s)
+{
+	char	*b;
+	b = (char*) malloc( strlen(s)+1);
+	strcpy (b, s);
+	return b;
+}
+
+void BspLoader::stripTrailing( char *e ) {
+	char	*s;
+
+	s = e + strlen(e)-1;
+	while (s >= e && *s <= 32)
+	{
+		*s = 0;
+		s--;
+	}
+}
+/*
+=================
+parseEpair
+=================
+*/
+BSPKeyValuePair *BspLoader::parseEpair( void ) {
+	BSPKeyValuePair	*e;
+
+	e = (struct BSPPair*) malloc( sizeof(BSPKeyValuePair));
+	memset( e, 0, sizeof(BSPKeyValuePair) );
+	
+	if ( strlen(token) >= BSPMAX_KEY-1 ) {
+		//printf ("ParseEpar: token too long");
+	}
+	e->key = copystring( token );
+	getToken( false );
+	if ( strlen(token) >= BSPMAX_VALUE-1 ) {
+
+		//printf ("ParseEpar: token too long");
+	}
+	e->value = copystring( token );
+
+	// strip trailing spaces that sometimes get accidentally
+	// added in the editor
+	stripTrailing( e->key );
+	stripTrailing( e->value );
+
+	return e;
+}
+
+
+/*
+================
+parseEntity
+================
+*/
+bool	BspLoader::parseEntity( void ) {
+	BSPKeyValuePair		*e;
+	BSPEntity	*mapent;
+
+	if ( !getToken (true) ) {
+		return false;
+	}
+
+	if ( strcmp (token, "{") ) {
+
+		//printf ("parseEntity: { not found");
+	}
+
+	BSPEntity bla;
+	bla.brushes = 0;
+	bla.epairs = 0;
+	bla.firstDrawSurf = 0;
+	bla.origin[0] = 0.f;
+	bla.origin[1] = 0.f;
+	bla.origin[2] = 0.f;
+	bla.patches = 0;
+
+	m_entities.push_back(bla);
+	mapent = &m_entities[m_entities.size()-1];
+	m_num_entities++;
+
+	do {
+		if ( !getToken (true) ) {
+			//printf("parseEntity: EOF without closing brace");
+		}
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+		e = (struct BSPPair*)parseEpair ();
+		e->next = mapent->epairs;
+		mapent->epairs = e;
+	} while (1);
+	
+	return true;
+}
+
+/*
+================
+parseEntities
+
+Parses the dentdata string into entities
+================
+*/
+void BspLoader::parseEntities( void ) {
+	m_num_entities = 0;
+	m_entities.clear();
+
+	parseFromMemory( &m_dentdata[0], m_entdatasize );
+
+	while ( parseEntity () ) {
+	}	
+}
+
+
+
+int BspLoader::getMachineEndianness()
+{
+   long int i = 1;
+   const char *p = (const char *) &i;
+   if (p[0] == 1)  // Lowest address contains the least significant byte
+	   return BSP_LITTLE_ENDIAN;
+   else
+	   return BSP_BIG_ENDIAN;
+}
+
+short   BspLoader::isLittleShort (short l)
+{
+	if (machineEndianness() == BSP_BIG_ENDIAN)
+	{
+		unsigned char    b1,b2;
+
+		b1 = l&255;
+		b2 = (l>>8)&255;
+
+		return (b1<<8) + b2;
+	}
+	//little endian
+	return l;
+}
+
+short   BspLoader::isBigShort (short l)
+{
+	if (machineEndianness() == BSP_BIG_ENDIAN)
+	{
+		return l;
+	}
+
+	unsigned char   b1,b2;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+
+	return (b1<<8) + b2;
+
+
+
+}
+
+
+int    BspLoader::isLittleLong (int l)
+{
+	if (machineEndianness() == BSP_BIG_ENDIAN)
+	{
+		unsigned char    b1,b2,b3,b4;
+
+		b1 = l&255;
+		b2 = (l>>8)&255;
+		b3 = (l>>16)&255;
+		b4 = (l>>24)&255;
+
+		return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
+	}
+
+	//little endian
+	return l;
+
+}
+
+int    BspLoader::isBigLong (int l)
+{
+	if (machineEndianness() == BSP_BIG_ENDIAN)
+	{
+		return l;
+	}
+
+
+	unsigned char    b1,b2,b3,b4;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+	b3 = (l>>16)&255;
+	b4 = (l>>24)&255;
+
+	return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
+
+}
+
+
+float	BspLoader::isLittleFloat (float l)
+{
+	if (machineEndianness() == BSP_BIG_ENDIAN)
+	{
+		union {unsigned char b[4]; float f;} in, out;
+		
+		in.f = l;
+		out.b[0] = in.b[3];
+		out.b[1] = in.b[2];
+		out.b[2] = in.b[1];
+		out.b[3] = in.b[0];
+		
+		return out.f;
+	}
+
+	//little endian
+	return l;
+}
+
+float	BspLoader::isBigFloat (float l)
+{
+	if (machineEndianness() == BSP_BIG_ENDIAN)
+	{
+		return l;
+	}
+	//little endian
+	union {unsigned char b[4]; float f;} in, out;
+	
+	in.f = l;
+	out.b[0] = in.b[3];
+	out.b[1] = in.b[2];
+	out.b[2] = in.b[1];
+	out.b[3] = in.b[0];
+	
+	return out.f;
+}
+
+
+
+
+
+
+//
+// swapBlock
+// If all values are 32 bits, this can be used to swap everything
+//
+
+void BspLoader::swapBlock( int *block, int sizeOfBlock ) {
+	int		i;
+
+	sizeOfBlock >>= 2;
+	for ( i = 0 ; i < sizeOfBlock ; i++ ) {
+		block[i] = isLittleLong( block[i] );
+	}
+}
+
+//
+// copyLump
+//
+
+int BspLoader::copyLump( BSPHeader	*header, int lump, void *dest, int size ) {
+	int		length, ofs;
+
+	length = header->lumps[lump].filelen;
+	ofs = header->lumps[lump].fileofs;
+	
+	//if ( length % size ) {
+	//	printf ("loadBSPFile: odd lump size");
+	//}
+
+	memcpy( dest, (unsigned char *)header + ofs, length );
+
+	return length / size;
+}
+
+
+
+
+//
+// swapBSPFile
+//
+
+void BspLoader::swapBSPFile( void ) {
+	int				i;
+	
+	// models	
+	swapBlock( (int *) &m_dmodels[0], m_nummodels * sizeof( m_dmodels[0] ) );
+
+	// shaders (don't swap the name)
+	for ( i = 0 ; i < m_numShaders ; i++ ) {
+		m_dshaders[i].contentFlags = isLittleLong( m_dshaders[i].contentFlags );
+		m_dshaders[i].surfaceFlags = isLittleLong( m_dshaders[i].surfaceFlags );
+	}
+
+	// planes
+	swapBlock( (int *)&m_dplanes[0], m_numplanes * sizeof( m_dplanes[0] ) );
+	
+	// nodes
+	swapBlock( (int *)&m_dnodes[0], m_numnodes * sizeof( m_dnodes[0] ) );
+
+	// leafs
+	swapBlock( (int *)&m_dleafs[0], m_numleafs * sizeof( m_dleafs[0] ) );
+
+	// leaffaces
+	swapBlock( (int *)&m_dleafsurfaces[0], m_numleafsurfaces * sizeof( m_dleafsurfaces[0] ) );
+
+	// leafbrushes
+	swapBlock( (int *)&m_dleafbrushes[0], m_numleafbrushes * sizeof( m_dleafbrushes[0] ) );
+
+	// brushes
+	swapBlock( (int *)&m_dbrushes[0], m_numbrushes * sizeof( m_dbrushes[0] ) );
+
+	// brushsides
+	swapBlock( (int *)&m_dbrushsides[0], m_numbrushsides * sizeof( m_dbrushsides[0] ) );
+
+	// vis
+	((int *)&m_visBytes)[0] = isLittleLong( ((int *)&m_visBytes)[0] );
+	((int *)&m_visBytes)[1] = isLittleLong( ((int *)&m_visBytes)[1] );
+
+
+	// drawindexes
+	swapBlock( (int *)&m_drawIndexes[0], m_numDrawIndexes * sizeof( m_drawIndexes[0] ) );
+
+	// drawsurfs
+	swapBlock( (int *)&m_drawSurfaces[0], m_numDrawSurfaces * sizeof( m_drawSurfaces[0] ) );
+
+}
+
+
+
+
+
+bool BspLoader::findVectorByName(float* outvec,const char* name)
+{
+	const char *cl;
+	BSPVector3 origin;
+	
+	bool found = false;
+
+	parseEntities();
+
+	for ( int i = 1; i < m_num_entities; i++ ) {
+		cl = getValueForKey (&m_entities[i], "classname");
+		if ( !strcmp( cl, "info_player_start" ) ) {
+				getVectorForKey( &m_entities[i], "origin", origin );
+				found = true;
+				break;
+			}
+		if ( !strcmp( cl, "info_player_deathmatch" ) ) {
+				getVectorForKey( &m_entities[i], "origin", origin );
+				found = true;
+				break;
+			}
+	}
+
+	if (found)
+	{
+		outvec[0] = origin[0];
+		outvec[1] = origin[1];
+		outvec[2] = origin[2];
+	}
+	return found;
+}
+  
+
+
+const BSPEntity * BspLoader::getEntityByValue( const char* name, const char* value)
+{
+	const BSPEntity* entity = NULL;
+
+	for ( int i = 1; i < m_num_entities; i++ ) {
+
+		const BSPEntity& ent = m_entities[i];
+
+		const char* cl = getValueForKey (&m_entities[i], name);
+		if ( !strcmp( cl, value ) ) {
+			entity = &ent;
+			break;
+		}
+	}
+	return entity;
+}
+

ObsoleteDemos/BspDemo/BspLoader.h

@@ -0,0 +1,295 @@
+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+
+This file is part of Quake III Arena source code.
+
+Quake III Arena source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU bteral Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+Quake III Arena source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU bteral Public License for more details.
+
+You should have received a copy of the GNU bteral Public License
+along with Foobar; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+
+
+#ifndef BSP_LOADER_H
+#define BSP_LOADER_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+
+#define	BSPMAXTOKEN	1024
+#define	BSPMAX_KEY				32
+#define	BSPMAX_VALUE			1024
+#define	BSPCONTENTS_SOLID			1
+#define	BSPCONTENTS_AREAPORTAL		0x8000
+#define	BSPLUMP_ENTITIES		0
+#define	BSPLUMP_SHADERS		1
+#define	BSPLUMP_PLANES			2
+#define	BSPLUMP_NODES			3
+#define	BSPLUMP_LEAFS			4
+#define	BSPLUMP_LEAFSURFACES	5
+#define	BSPLUMP_LEAFBRUSHES	6
+#define	LUMP_MODELS			7
+#define	LUMP_BRUSHES		8
+#define	LUMP_BRUSHSIDES		9
+#define	LUMP_DRAWVERTS		10
+#define	LUMP_DRAWINDEXES	11
+#define	LUMP_SURFACES		13
+#define	LUMP_LIGHTMAPS		14
+#define	LUMP_LIGHTGRID		15
+#define	LUMP_VISIBILITY		16
+#define	HEADER_LUMPS		17
+#define	MAX_QPATH		64
+
+
+
+typedef struct {
+	int		fileofs, filelen;
+} BSPLump;
+
+typedef float BSPVector3[3];
+
+typedef struct {
+	int			ident;
+	int			version;
+	
+	BSPLump		lumps[HEADER_LUMPS];
+} BSPHeader;
+
+
+typedef struct {
+	float		mins[3], maxs[3];
+	int			firstSurface, numSurfaces;
+	int			firstBrush, numBrushes;
+} BSPModel;
+
+typedef struct {
+	char		shader[MAX_QPATH];
+	int			surfaceFlags;
+	int			contentFlags;
+} BSPShader;
+
+typedef struct {
+	float		normal[3];
+	float		dist;
+} BSPPlane;
+
+typedef struct {
+	int			planeNum;
+	int			children[2];
+	int			mins[3];
+	int			maxs[3];
+} BSPNode;
+
+typedef struct {
+	int			cluster;	
+	int			area;
+	
+	int			mins[3];	
+	int			maxs[3];
+	
+	int			firstLeafSurface;
+	int			numLeafSurfaces;
+	
+	int			firstLeafBrush;
+	int			numLeafBrushes;
+} BSPLeaf;
+
+typedef struct {
+	int			planeNum;	
+	int			shaderNum;
+} BSPBrushSide;
+
+typedef struct {
+	int			firstSide;
+	int			numSides;
+	int			shaderNum;	
+} BSPBrush;
+
+
+
+
+typedef struct BSPPair {
+	struct BSPPair	*next;
+	char	*key;
+	char	*value;
+} BSPKeyValuePair;
+
+typedef struct {
+	BSPVector3		origin;
+	struct bspbrush_s	*brushes;
+	struct parseMesh_s	*patches;
+	int			firstDrawSurf;
+	BSPKeyValuePair		*epairs;
+} BSPEntity;
+
+typedef enum {
+	MST_BAD,
+		MST_PLANAR,
+		MST_PATCH,
+		MST_TRIANGLE_SOUP,
+		MST_FLARE
+} BSPMapSurface;
+
+typedef struct {
+	int			shaderNum;
+	int			fogNum;
+	int			surfaceType;
+	
+	int			firstVert;
+	int			numVerts;
+	
+	int			firstIndex;
+	int			numIndexes;
+	
+	int			lightmapNum;
+	int			lightmapX, lightmapY;
+	int			lightmapWidth, lightmapHeight;
+	
+	BSPVector3		lightmapOrigin;
+	BSPVector3		lightmapVecs[3];
+	
+	int			patchWidth;
+	int			patchHeight;
+} BSPSurface;
+
+
+
+///GPL code from IdSofware to parse a Quake 3 BSP file
+///check that your platform define __BIG_ENDIAN__ correctly (in BspLoader.cpp)
+class BspLoader
+{
+	int m_Endianness;
+
+	public:
+
+		BspLoader();
+
+		bool	loadBSPFile( void* memoryBuffer);
+
+		const char* getValueForKey( const BSPEntity *ent, const char *key ) const;
+
+		bool	getVectorForKey( const BSPEntity *ent, const char *key, BSPVector3 vec );
+		
+		float	getFloatForKey( const BSPEntity *ent, const char *key );
+
+		void parseEntities( void );
+
+		bool findVectorByName(float* outvec,const char* name);
+
+		const BSPEntity * getEntityByValue( const char* name, const char* value);
+
+
+	protected:
+
+		void parseFromMemory (char *buffer, int size);
+		
+
+
+		bool isEndOfScript (bool crossline);
+
+		bool getToken (bool crossline);
+
+		char *copystring(const char *s);
+	
+		void stripTrailing( char *e );
+
+		BSPKeyValuePair * parseEpair( void );
+
+		bool	parseEntity( void );
+
+		short   isLittleShort (short l);
+		int    isLittleLong (int l);
+		float	isLittleFloat (float l);
+
+		int    isBigLong (int l);
+		short   isBigShort (short l);
+		float	isBigFloat (float l);
+
+		void swapBlock( int *block, int sizeOfBlock );
+
+		int copyLump( BSPHeader	*header, int lump, void *dest, int size );
+
+		void swapBSPFile( void );
+		
+	
+
+	
+	public: //easier for conversion
+		int			m_num_entities;
+		btAlignedObjectArray<BSPEntity>	m_entities;
+		
+		int			m_nummodels;
+		btAlignedObjectArray<BSPModel>	m_dmodels;
+
+		int			m_numShaders;
+		btAlignedObjectArray<BSPShader>	m_dshaders;
+
+		int			m_entdatasize;
+		btAlignedObjectArray<char>		m_dentdata;
+
+		int			m_numleafs;
+		btAlignedObjectArray<BSPLeaf>		m_dleafs;
+
+		int			m_numplanes;
+		btAlignedObjectArray<BSPPlane>	m_dplanes;
+
+		int			m_numnodes;
+		btAlignedObjectArray<BSPNode>		m_dnodes;
+
+		int			m_numleafsurfaces;
+		btAlignedObjectArray<int>			m_dleafsurfaces;
+
+		int			m_numleafbrushes;
+		btAlignedObjectArray<int>			m_dleafbrushes;
+
+		int			m_numbrushes;
+		btAlignedObjectArray<BSPBrush>	m_dbrushes;
+
+		int			m_numbrushsides;
+		btAlignedObjectArray<BSPBrushSide>	m_dbrushsides;
+
+		int			m_numLightBytes;
+		btAlignedObjectArray<unsigned char>		m_lightBytes;
+
+		int			m_numGridPoints;
+		btAlignedObjectArray<unsigned char>		m_gridData;
+
+		int			m_numVisBytes;
+		btAlignedObjectArray<unsigned char>		m_visBytes;
+
+		
+		int			m_numDrawIndexes;
+		btAlignedObjectArray<int>			m_drawIndexes;
+
+		int			m_numDrawSurfaces;
+		btAlignedObjectArray<BSPSurface>	m_drawSurfaces;
+
+		enum
+		{
+			BSP_LITTLE_ENDIAN  = 0,
+			BSP_BIG_ENDIAN    =  1
+		};
+
+		//returns machines big endian / little endian
+		//
+		int getMachineEndianness();
+
+		inline int	machineEndianness()
+		{
+			return m_Endianness;
+		}
+
+};
+
+#endif //BSP_LOADER_H

ObsoleteDemos/BspDemo/CMakeLists.txt

@@ -0,0 +1,44 @@
+# This is basically the overall name of the project in Visual Studio this is the name of the Solution File
+
+
+# For every executable you have with a main method you should have an add_executable line below.
+# For every add executable line you should list every .cpp and .h file you have associated with that executable.  
+
+
+# You shouldn't have to modify anything below this line 
+########################################################
+
+
+INCLUDE_DIRECTORIES(
+${BULLET_PHYSICS_SOURCE_DIR}/src 
+../OpenGL
+)
+
+LINK_LIBRARIES(
+ OpenGLSupport  BulletDynamics  BulletCollision LinearMath    ${GLUT_glut_LIBRARY} ${OPENGL_gl_LIBRARY} ${OPENGL_glu_LIBRARY}
+)
+
+ADD_EXECUTABLE(AppBspPhysicsDemo
+	main.cpp
+	BspDemo.cpp
+	BspLoader.cpp
+	BspConverter.cpp	
+)
+
+
+
+
+
+IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+	ADD_CUSTOM_COMMAND(
+		TARGET AppBspPhysicsDemo
+		POST_BUILD
+		COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${BULLET_PHYSICS_SOURCE_DIR}/ObsoleteDemos/BspDemo/BspDemo.bsp ${CMAKE_CURRENT_BINARY_DIR}
+	)
+ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+
+IF (INTERNAL_ADD_POSTFIX_EXECUTABLE_NAMES)
+			SET_TARGET_PROPERTIES(AppBspPhysicsDemo PROPERTIES  DEBUG_POSTFIX "_Debug")
+			SET_TARGET_PROPERTIES(AppBspPhysicsDemo PROPERTIES  MINSIZEREL_POSTFIX "_MinsizeRel")
+			SET_TARGET_PROPERTIES(AppBspPhysicsDemo PROPERTIES  RELWITHDEBINFO_POSTFIX "_RelWithDebugInfo")
+ENDIF(INTERNAL_ADD_POSTFIX_EXECUTABLE_NAMES)

ObsoleteDemos/BspDemo/main.cpp

@@ -0,0 +1,59 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2007 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+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 the 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 freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but 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.
+*/
+
+
+#include "BspDemo.h"
+#include "GlutStuff.h"
+#include "GLDebugDrawer.h"
+#include "btBulletDynamicsCommon.h"
+
+char* makeExeToBspFilename(const char* lpCmdLine);
+char* getLastFileName();
+
+
+int main(int argc,char** argv)
+{
+
+	BspDemo* bspDemo = new BspDemo();
+
+	const char* bspfilename = "BspDemo.bsp";
+
+	printf("argc=%i\n",argc);
+	{
+		for (int i=0;i<argc;i++)
+		{
+			printf("argv[%i]=%s\n",i,argv[i]);
+		}
+		
+		bspfilename = makeExeToBspFilename(argv[0]);
+		printf("new name=%s\n",bspfilename);
+	}
+	if (argc>1)
+	{
+		bspfilename = argv[1];
+	}
+
+	GLDebugDrawer	gDebugDrawer;
+
+	// Enrico: TODO: Should change parameter type of initPhysics() to std::string or at least const char *
+	bspDemo->initPhysics((char*)bspfilename);
+	
+	bspDemo->getDynamicsWorld()->setDebugDrawer(&gDebugDrawer);
+
+	
+
+	return glutmain(argc, argv,640,480,"Bullet Quake BSP Physics Viewer http://bulletphysics.org",bspDemo);
+}
+