source: orxonox.OLD/branches/terrain.older/src/lib/graphics/importer/bsp_file.h @ 10606

/*
 orxonox - the future of 3D-vertical-scrollers
 
 Copyright (C) 2006 orx
 
 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, or (at your option)
 any later version.
 
 ### File Specific:
 main-programmer: bottac@ee.ethz.ch
 
  Inspired by:
  Rendering Q3 Maps by Morgan McGuire                  http://graphics.cs.brown.edu/games/quake/quake3.html
  Unofficial Quake 3 Map Specs by Kekoa Proudfoot      http://graphics.stanford.edu/~kekoa/q3/
  Quake 3 Collision Detection by Nathan Ostgard        http://www.devmaster.net/articles/quake3collision/
*/

#include <vector>
#include "filesys/binary_file.h"
class SDL_Surface;
class BspTreeNode;
class Vector;
class Material;
class MoviePlayer;
class VertexArrayModel;


struct bsp_lump {
        int                     offset;
        int                     length;
};

enum bsp_lumps {
        Entities                =      0,
        Textures                =      1,
        Planes                  =      2,
        Nodes                   =      3,
        Leafs                   =      4,
        Leaffaces               =      5,
        Leafbrushes             =      6,
        Models                  =      7,
        Brushes                 =      8,
        Brushsides              =      9,
        Vertices                =     10,
        Meshverts               =     11,
        Effects                 =     12,
        Faces                   =     13,
        Lightmaps               =     14,
        Lightvols               =     15,
        Visdata                 =     16
};

struct bsp_header {
        // The magic number always "IBSP"
        char            magic[4];
        // The version, 0x2e for quake 3 models 
        int                     version;
        bsp_lump        lumps[17];
};

struct plane
{
  float x;     //!< 1st component of the plane's normal
  float y;     //!< 2nd component of the plane's normal
  float z;     //!< 3rd component of the plane's normal
  float d;     //!< distance of the plane to the origin
};


typedef struct
{
  float mins [ 3 ]; //!< Bounding box min coord.
  float maxs [ 3 ]; //!< Bounding box max coord.
  int face;         //!< First face for model.
  int n_faces;      //!< Number of faces for model.
  int brush;        //!< First brush for model.
  int n_brushes;    //!< Number of brushes
}
model;

typedef struct
{
  int plane;        //!< Plane index.
  int left;         //!< 1st Child index. Negative numbers are leaf indices: -(leaf+1).
  int right;        //!< 2nd Child index. Negative numbers are leaf indices: -(leaf+1).
  int mins[ 3 ];    //!< Integer bounding box min coord.
  int maxs[ 3 ];    //!< Integer bounding box max coord.
}
node;

typedef struct
{
  int cluster;            //!< Visdata cluster index.
  int area;               //!< Areaportal area.
  int mins[ 3 ];          //!< Integer bounding box min coord.
  int maxs[ 3 ];          //!< Integer bounding box max coord.
  int leafface;           //!< First leafface for leaf.
  int n_leaffaces;        //!< Number of leaffaces for leaf.
  int leafbrush_first;    //!< leafbrush for leaf.
  int n_leafbrushes;      //!< Number of leafbrushes for leaf.
}
leaf;

struct brush
{
  int brushside;        //!< First brushside for brush.
  int n_brushsides;     //!< Number of brushsides for brush.
  int texture;          //!< Texture index.
};

typedef struct
{
  int plane;    //!< Plane index.
  int texture;  //!< Texture index.
}
brushside;


struct face
{
  int texture;          //!< Texture index.
  int effect;           //!< Index into lump 12 (Effects), or -1.
  int type;             //!< Face type. 1=polygon, 2=patch, 3=mesh, 4=billboard
  int vertex;           //!< Index of first vertex.
  int n_vertexes;       //!< Number of vertices.
  int meshvert;         //!< Index of first meshvert.
  int n_meshverts;      //!< Number of meshverts.
  int lm_index;         //!< Lightmap index.
  int lm_start [ 2 ];   //!< Corner of this face's lightmap image in lightmap.
  int lm_size [ 2 ];     //!< Size of this face's lightmap image in lightmap.
  float lm_origin [ 3 ] ;    //!<  World space origin of lightmap.
  float lm_vecs [ 2 ][ 3 ];  //!< World space lightmap s and t unit vectors.
  float normal[ 3 ];         //!< Surface normal.
  int size [ 2 ] ;           //!< Patch dimensions.
} ;


typedef struct
{
  float position[ 3 ];        //!< Vertex position.
  float texcoord[ 2 ][ 2 ];   //!< Vertex texture coordinates. [0][x]=surface, [1][x]=lightmap.
  float normal[ 3 ];          //!< Vertex normal.
  unsigned char color [ 4 ];  //!< Vertex color. RGBA.
}
BspVertex;

typedef struct
{
  int offset;
}
meshvert;                    //!< Integer offset to mesh vertex

typedef struct
{
  float position [ 3 ];
}
BspVec;

typedef struct
{
  Material* mat;
  MoviePlayer* aviMat;
  bool alpha;
  bool animated;
}
AMat;
typedef struct
{
  unsigned char map [128][128][3];
}
lightmap;

typedef struct
{
  char name[64];
  int flags;
  int contents;
}
BspTexture;


class BspFile
{
  friend class BspManager;

public:
  BspFile();
  ~BspFile();
  int read(const char* name );
  void build_tree();
  void load_textures();
  void tesselate( int iface );
  BspTreeNode* get_root();
  AMat loadMat( char* mat );
  AMat loadAVI(char * mat);
 

private:
        void readEntities();
        void readTextures();
        void readPlanes();
        void readNodes();
        void readLeafs();
        void readLeafFaces();
        void readLeafBrushes();
        void readBrushSides();
        void readModels();
        void readBrushes();
        void readVertices();
        void readMeshVerts();
        void readEffects();
        void readFaces();
        void readLightmaps();
        void readLightvols();
        void readVisdata();
        BinaryFile file;
        BspTreeNode* root;
        bsp_header header;               //!< Buffer for header of BSP-File
        node* nodes;               //!< Buffer to store BSP-Tree-Nodes
        leaf* leaves;              //!< Buffer to store BSP-Tree-Leaves
        plane* planes;             //!< Buffer to store planes separateing the space
        model* bspModels;          //!< Buffer to store BSP-Model-List
        char* leafFaces;           //!< Buffer to store leafFaces
        face* faces;               //!<
        char* leafBrushes;         //!< Buffer to store brush indice
        brush* brushes;            //!< Buffer to store  brushes
        brushside* brushSides;     //!<
        char* vertice;             //!<
        meshvert* meshverts;       //!< Buffer to store meshverice
        char* visData;             //!< Buffer to store visibility data
        char* textures;            //!< Holds all the texture filename strings
        char* patchVertice;        //!<
        char* patchIndexes;
        char* patchTrianglesPerRow;
        lightmap* lightMaps;       //!< Buffer to store lightmap-images


        int** patchRowIndexes;
        VertexArrayModel** VertexArrayModels; 
        int patchOffset;

        int numNodes;
        int numLeafs;
        int numVertex;
        int numPlanes;
        int numBspModels;
        int numLeafFaces;
        int numFaces;
        int numLeafBrushes;
        int numTextures;
        int numPatches;
        int numBrushSides;
        int numLightMaps;

        float  scale;

        BspTreeNode* build_tree_rec( int i );
        unsigned int loadLightMapToGL(lightmap&);
        AMat* Materials;
        unsigned int* glLightMapTextures;
        unsigned int whiteLightMap;
        unsigned char whiteTexture[3];
        void swapAllBspCoordinates();
        void swapCoords(int * array);
        void swapCoords(float * array);
        SDL_Surface* testSurf;


        ::std::vector<MoviePlayer* > MovieMaterials; //!< Movieplayer Materials
};