D:/Zythum/DinoKod/Bsp/BspLoader.h

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : BspLoader.h
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 07/09/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#ifndef __BSPLOADER_H__
#define __BSPLOADER_H__

#include "Bsp/BspDll.h"
#include "Common/File.h"
#include "Common/Table.h"
#include "Render/Shader.h"

class KBspEntity;
class KRender;

//-------------------------------------------------------------------
#define BSP_OK                                          0
#define BSP_ERROR_OPENFILE                      1
#define BSP_ERROR_BADVERSION            2
#define BSP_ERROR_LIGHTMAPS                     4
#define BSP_ERROR_ENTITY                        5
#define BSP_ERROR_TEXTURENOTFOUND       6
#define BSP_ERROR_LOADSHADERS           7

//---------------------------------------------------------------------------------------------------------------------
typedef enum EBspLump
{
        LUMP_ENTITIES           = 0,
        LUMP_SHADERS            = 1,
        LUMP_PLANES                     = 2,
        LUMP_NODES                      = 3,
        LUMP_LEAVES                     = 4,
        LUMP_FACELIST           = 5,
        LUMP_BRUSHLIST          = 6,
        LUMP_MODELS                     = 7,
        LUMP_BRUSHES            = 8,
        LUMP_BRUSHSIDES         = 9,
        LUMP_VERTICES           = 10,
        LUMP_MESHVERTS          = 11,
        LUMP_EFFECTS            = 12,
        LUMP_FACES                      = 13,
        LUMP_LIGHTMAPS          = 14,
        LUMP_LIGHTVOLS          = 15,
        LUMP_VISILIST           = 16,
        LUMP_COUNT
};

//---------------------------------------------------------------------------------------------------------------------
#pragma pack( push, 1 )

//---------------------------------------------------------------------------------------------------------------------
typedef enum _KBFACETYPE
{
        KBFT_POLYGON            = 1,
        KBFT_PATCH                      = 2,
        KBFT_MESH                       = 3,
        KBFT_BILLBOARD          = 4
} KBFACETYPE;

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspEntry
{
public:
        s32                     m_Offset;                               // Offset depuis le debut du fichier
        s32                     m_Size;                                 // Taille de l'entrée
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspHeader
{
public:
        char            m_Magic[4];                             // 'IBSP'
        s32                     m_Version;                              // Version
        KBspEntry       m_Entry[LUMP_COUNT];    // Entrées
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspShader
{
public:
        char            m_pName[64];
        s32                     m_Flags;
        s32                     m_Contents;
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspPlane
{
public:
        KVector         m_Normal;                       // Verteur normal normalisé
        float           m_Distance;                     // Offset du plan depuis le repère (0,0,0)
};                                                                      
                                                                        
//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspNode                                          
{       
public:
        s32                     m_PlaneId;
        s32                     m_Front;                        // Si bit15 == 0, index du Front child node
                                                                        // Si bit15 == 1, ~front = index du child leaf
        s32                     m_Back;                         // Si bit15 == 0, index du Back child node
                                                                        // Si bit15 == 1, ~back = index du child leaf   
        s32                     m_BBMins[3];
        s32                     m_BBMaxs[3];            
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspLeafInt
{
public:
        s32                     m_FirstVisListId;
        s32                     m_Area;
        s32                     m_BBMin[3];
        s32                     m_BBMax[3];
        s32                     m_FirstFaceId;
        s32                     m_NumFaces;
        s32                     m_FirstBrushId;
        s32                     m_NumBrushes;
};

class BSP_API KBspLeaf
{
public:
        s32                     m_FirstVisListId;
        s32                     m_Area;
        float           m_BBMin[3];
        float           m_BBMax[3];
        s32                     m_FirstFaceId;
        s32                     m_NumFaces;
        s32                     m_FirstBrushId;
        s32                     m_NumBrushes;
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspFaceList
{
public:
        s32                     m_Face;
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspBrushList
{
public:
        s32                     m_Brush;
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspModel
{
public:
        KVector         m_BBMin;
        KVector         m_BBMax;
        s32                     m_FirstFaceId;
        s32                     m_NumFaces;
        s32                     m_FirstBrushId;
        s32                     m_NumBrushes;
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspBrush
{
public:
        s32                     m_FirstBrushSideId;
        s32                     m_NumBrushSides;
        s32                     m_TextureId;
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspBrushSide
{
public:
        s32                     m_PlaneId;
        s32                     m_TextureId;
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspVertex
{
public:
        KVector         m_Position;
        KFPt            m_UV[2];                        // 0 = surface, 1 = lightmap
        KVector         m_Normal;
        KRgba           m_Color;
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspMeshVert
{
public:
        s32                     m_FirstVertexId;
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspEffect
{
public:
        char            m_ShaderName[64];
        s32                     m_BrushId;
        s32                     m_Unknown;                      // Always 5, except in q3dm8, which has one effect with -1. 
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspFace
{
public:
        s32                     m_ShaderId;
        s32                     m_EffectId;                     // Id ou -1
        s32                     m_Type;                         // Face type. 1=polygon, 2=patch, 3=mesh, 4=billboard  
        s32                     m_FirstVertexId;
        s32                     m_NumVertices;
        s32                     m_FirstMeshVert;
        s32                     m_NumMeshVerts;
        s32                     m_LightMapId;
        KPt                     m_LightMapStart;        //  Corner of this face's lightmap image in lightmap.  
        KPt                     m_LightMapSize;         //  Size of this face's lightmap image in lightmap.  
        KVector         m_LightMapOrigin;       //  World space origin of lightmap.  
        KVector         m_LightMapVecs[2];      //  World space lightmap s and t unit vectors.  
        KVector         m_Normal;
        KPt                     m_Size;                         //  Patch dimensions.  
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspLightMap
{
public:
        KRgb            m_Color[128][128];
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspLightVol
{
public:
        KRgb            m_Ambient;
        KRgb            m_Directional;
        u8                      m_Direction[2];         // 0=phi, 1=theta.  
};

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspVisiList
{
public:
        u32                     m_NumVectors;
        u32                     m_SizeOfVector;
        u8*                     m_VisiList;                     // [m_NumVectors * m_SizeOfVector]

        KBspVisiList()
        {
                m_NumVectors    = 0;
                m_SizeOfVector  = 0;
                m_VisiList              = NULL;         
        }

        ~KBspVisiList()
        {
                if( m_VisiList )
                        Deletev( m_VisiList );
        }
};

#pragma pack( pop )

//---------------------------------------------------------------------------------------------------------------------
class BSP_API KBspLoader : public KFile
{
private:
        KBspHeader                                      m_Header;

protected:
        bool                                            m_bLoaded;

        KTable<KBspEntity*>                     m_EntityList;
        KBspShader*                                     m_pShaders;
        KBspPlane*                                      m_pPlanes;
        KBspNode*                                       m_pNodes;
        KBspLeaf*                                       m_pLeaves;
        KBspFaceList*                           m_pFaceList;
        KBspBrushList*                          m_pBrushList;
        KBspModel*                                      m_pModels;
        KBspBrush*                                      m_pBrushes;
        KBspBrushSide*                          m_pBrushSides;
        KBspVertex*                                     m_pVertices;
        KBspMeshVert*                           m_pMeshVerts;
        KBspEffect*                                     m_pEffects;
        KBspFace*                                       m_pFaces;
        KBspLightMap*                           m_pLightMaps;
        KBspLightVol*                           m_pLightVols;
        KBspVisiList*                           m_pVisiList;

        u32                                                     m_nShaders;
        u32                                                     m_nPlanes;
        u32                                                     m_nNodes;
        u32                                                     m_nLeaves;
        u32                                                     m_nFaceList;
        u32                                                     m_nBrushList;
        u32                                                     m_nModels;
        u32                                                     m_nBrushes;
        u32                                                     m_nBrushSides;
        u32                                                     m_nVertices;
        u32                                                     m_nMeshVerts;
        u32                                                     m_nEffects;
        u32                                                     m_nFaces;
        u32                                                     m_nLightMaps;
        u32                                                     m_nLightVols;
        u32                                                     m_nVisiList;

        float                                           m_fScale;

        s32                                                     LoadVisiList();
        s32                                                     LoadEntities();
        void                                            DestroyVisiList();
        void                                            DestroyEntities();

        u32                                                     ReadLump( EBspLump Lump, u8** pData, u32 Size );
        template <class T> u32          ReadLump( EBspLump Lump, T** pData )
        {
                *pData = new T[m_Header.m_Entry[Lump].m_Size / sizeof( T )];
                return ReadLump( Lump, (u8**)pData, sizeof( T ) );
        }

public:
                                                                KBspLoader();
        virtual                                         ~KBspLoader();
                                                                
        virtual s32                                     LoadBSP( const char* pFileName );
        virtual s32                                     CloseBSP();

        inline KBspPlane*                       GetpPlanes(     u32 PlaneId )                   { KASSERT( PlaneId < m_nPlanes );                                               return &m_pPlanes[PlaneId];                             }
        inline KBspNode*                        GetpNodes( u32 NodeId   )                       { KASSERT( NodeId < m_nNodes );                                                 return &m_pNodes[NodeId];                               }
        inline KBspLeaf*                        GetpLeaves( u32 LeafId )                        { KASSERT( LeafId < m_nLeaves );                                                return &m_pLeaves[LeafId];                              }
        inline KBspFaceList*            GetpFaceList( u32 FaceId )                      { KASSERT( FaceId < m_nFaceList );                                              return &m_pFaceList[FaceId];                    }
        inline KBspFace*                        GetpFaces( u32 FaceId )                         { KASSERT( FaceId < m_nFaces );                                                 return &m_pFaces[FaceId];                               }
        inline u8*                                      GetpVisiList( u32 ClusterId )           { KASSERT( ClusterId <  m_pVisiList->m_NumVectors );    return &m_pVisiList->m_VisiList[ ClusterId * m_pVisiList->m_SizeOfVector ];     }
        inline KBspVertex*                      GetpVertices( u32 VertexId )            { KASSERT( VertexId < m_nVertices )     ;                                       return &m_pVertices[VertexId];                  }
        inline KBspMeshVert*            GetpMeshVerts( u32 VertexId )           { KASSERT( VertexId < m_nMeshVerts );                                   return &m_pMeshVerts[VertexId];                 }
        inline KBspShader*                      GetpShaders( u32 ShaderId )                     { KASSERT( ShaderId < m_nShaders );                                             return &m_pShaders[ShaderId];                   }
        inline KBspModel*                       GetpModels( u32 ModelId )                       { KASSERT( ModelId < m_nModels );                                               return &m_pModels[ModelId];                             }
        inline KBspBrush*                       GetpBrushes( u32 BrushId )                      { KASSERT( BrushId < m_nBrushes );                                              return &m_pBrushes[BrushId];                    }
        inline KBspBrushSide*           GetpBrushSides( u32 BrushSidesId )      { KASSERT( BrushSidesId < m_nBrushSides );                              return &m_pBrushSides[BrushSidesId];    }
        inline u32                                      GetBrushList( u32 BrushId )                     { KASSERT( BrushId < m_nBrushList );                                    return m_pBrushList[BrushId].m_Brush;   }

        inline s32                                      GetnFaces()                                                     { return m_nFaces;                                      }
        inline s32                                      GetnLeaves()                                            { return m_nLeaves;                                     }
        inline s32                                      GetnFaceList()                                          { return m_nFaceList;                           }
        inline s32                                      GetnShaders()                                           { return m_nShaders;                            }
        inline s32                                      GetnModels()                                            { return m_nModels;                                     }
        inline u32                                      GetnEntities()                                          { return m_EntityList.GetSize();        }

        KBspEntity*                                     GetNextEntity( KBspEntity* pCurrentEntity, char* pClassName );
        KBspEntity*                                     GetpEntity( u32 EntityId )              { KASSERT( EntityId < m_EntityList.GetSize() ); return m_EntityList[EntityId];  }

        bool                                            IsLoaded()      { return m_bLoaded;     }

        float                                           GetScale()                                              { return m_fScale;                                      }
};

#endif  __BSPLOADER_H__

---