C:/Projects/ngn/include/bsp.h

/***************************************************************************
 *            bsp.h
 *
 *  Sun Feb  1 12:12:39 2004
 *  Copyright  2004  thierry schartz
 *  thierry.schartz@bluebottle.com
 ****************************************************************************/
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef _BSP_H
#define _BSP_H

#ifdef WIN32
#include <windows.h>
#endif


#include <vector>
#include <string>
#include "GLee.h"
#include "q3types.h"
#include "q3entities.h"
#include "texture.h"
#include "bitset.h"
#include "world.h"
#include "errors.h"
#include "patch.h"
#include "shader.h"
#include "collision.h"



namespace ngn {
class Skybox;
class Camera;
    namespace core {
        
        
        
       
        class Bsp : public World
        {
            
        public:
            Bsp();
                virtual ~Bsp();
                // load bsp
                virtual bool load( const char* filename );
                        // render bsp
                virtual void render( const Camera& cam );
                        // clear loaded bsp
                        void clear();
                // set image gamma factor
                void setGammaFactor( float gamma );
                        // get image gamma factor
                float getGammaFactor() const;
                        // get a spawn position in the map
                        const Vector3df& getEntryPoint( unsigned int index ) const;
                        // get a random entry point into the map
                        const Vector3df& getRandomEntryPoint() const;
                
                protected:
                        // finds & adds .jpg or .tga to texture file name
                        bool addTextureExtension( char* filename );
                        // create textures
                        void createTextures( tBSPTexture *pTex );
                        // create lightmap textures
                        void createLightmap( unsigned int &texture, unsigned char* pImageBits, int width, int height);
                        // set gamma factor
                        void setGamma( float gamma );
                        // get gamma factor
                        float getGamma() const;
                        // prepare rendering
                        void enableVertexArray() const;
                        // post rendering operations
                        void disableVertexArray() const;
                        // render starting at root node of the bsp tree
                        void renderTree( int node, bool frustumcheck, const Camera& cam );
                        // render a leaf
                        void renderLeaf( int leaf, bool frustumcheck, const Camera& cam )const;
                        // render a face knowing its index
                        void renderFace( int faceindex );
                        // render a patch face
                        void renderPatch( int index ) const;
                        // render the environment map
                        void renderSkybox( const Camera& cam ) const;
                        // finds if a cluster is visible from another one
                        int isClusterVisible( int current, int test );
                        // find the leaf we are in
                        int findLeaf( const Vector3df& pos );
                        // create bezier patches from face data
                        void createPatches();

                        // load vertices data
                        void loadVertices();
                        // load faces data
                        void loadFaces();
                        // load textures data
                        void loadTextures();
                        // load lightmaps
                        void loadLightmaps();
                        // load nodes
                        void loadNodes();
                        // load leafs
                        void loadLeafs();
                        // load leaf faces
                        void loadLeafFaces();
                        // load planes
                        void loadPlanes();
                        // load visibility data
                        void loadVisData();
                        // load entities string
                        void loadEntities();
                        // load models data
                        void loadModels();
                        // load meshes data
                        void loadMeshVertices();
                        // load light volumes
                        void loadLights();
                        // load the environment map
                        void loadSkybox();
                        // load brushes data
                        void loadBrushes();
                        // load brush side data
                        void loadBrushSides();
                        // load leaf brushes data
                        void loadLeafBrushes();
                        // load vertex indices
                        void loadIndices();


                private:

                        // adjust gamma factor for lightmaps
                        void adjustGamma( unsigned char *pImage, int size, float factor );
                        
                        int m_nVerts;           // number of vertices     
                        int m_nFaces;           // number of faces                 
                        int m_nTextures;        // number of textures 
                        int m_nLightmaps;       // number of lightmaps 
                        int m_nNodes;           // number of nodes
                        int m_nLeafs;           // number of leafs
                        int m_nLeafFaces;       // number of leaf faces
                        int m_nPlanes;          // number of planes
                        int m_nModels;          // number of models
                        int m_nMeshVertices;// number of mesh vertices
                        int m_nPatchFaces;      // number of bezier patches
                        int m_nLights;          // number of lights
                        int m_nBrushes;         // number of brushes 
                        int m_nBrushSides;      // number of brush sides 
                        int m_nLeafBrushes;     // number of leaf brushes
                        int m_nIndices;         // number of indices
        
                        tBSPLump m_lumps[ kMaxLumps ];  // lumps info

                        tBSPVertex *m_pVerts;           // pointer to vertices data
                        tBSPFace *m_pFaces;                     // pointer to faces data
                        tBSPTexture *m_pTextures;       // pointer to textures data
                        tBSPNode *m_pNodes;                     // pointer to nodes data
                        tBSPLeaf *m_pLeafs;                     // pointer to leafs data
                        tBSPPlane *m_pPlanes;           // pointer to planes data
                        int *m_pLeafFaces;                      // pointer to leaf faces data
                        tBSPVisData m_clusters;         // visibility clusters
                        char *m_entities;                       // pointer to entities description string
                        tBSPModel *m_pModels;           // pointer to models data
                        int *m_pMeshVertices;           // pointer to mesh vertices data
                        bsp::tBSPPatchFace *m_pPatchFaces;      // pointer to bezier patches
                        tBSPLights *m_pLights;          // pointer to lights data
                        tBSPBrush *m_pBrushes;          // pointer to brushes data
                        tBSPBrushSide *m_pBrushSides;   // pointer to brush sides data
                        int *m_pLeafBrushes;            // pointer to leaf brushes data
                        int *m_pIndices;


                                                        
                        GLuint m_texArray[ MAX_TEXTURES ];              // array of textures id
                        GLuint m_lightmapArray[ MAX_TEXTURES ]; // array of lightmaps id
                        Texture *m_pTex;                                                // textures
                Bitset m_bitset;                                                // keep track of rendered faces
                        FILE *m_file;                                                   // file handler
                        float m_gamma;                                                  // lightmap gamma factor
                        std::vector<bsp::entry_point> m_entry_points;   // map entry points vector
                        Skybox *m_skybox;                                               // environment map renderer
                        std::string m_map_file;                                 // holds bsp file path
                        gl::ShaderProgram *m_shader;                    // GLSL liquid fx
                                                                        
                        friend class bsp::BSPCollision;
                                                                
        };
        
                                
        
    }//core
}//ngn        
#endif /* _BSP_H */

---