text: /*
  ===========================================================================
  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
  