irrlicht/source/Irrlicht/CQ3LevelMesh.h

459 lines
14 KiB
C++

// Copyright (C) 2002-2009 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __C_Q3_LEVEL_MESH_H_INCLUDED__
#define __C_Q3_LEVEL_MESH_H_INCLUDED__
#include "IQ3LevelMesh.h"
#include "IReadFile.h"
#include "IFileSystem.h"
#include "SMesh.h"
#include "SMeshBufferLightMap.h"
#include "IVideoDriver.h"
#include "irrString.h"
#include "ISceneManager.h"
#include "os.h"
namespace irr
{
namespace scene
{
class CQ3LevelMesh : public IQ3LevelMesh
{
public:
//! constructor
CQ3LevelMesh( io::IFileSystem* fs,
scene::ISceneManager* smgr,
const quake3::Q3LevelLoadParameter &loadParam
);
//! destructor
virtual ~CQ3LevelMesh();
//! loads a level from a .bsp-File. Also tries to load all
//! needed textures. Returns true if successful.
bool loadFile(io::IReadFile* file);
//! returns the amount of frames in milliseconds. If the amount
//! is 1, it is a static (=non animated) mesh.
virtual u32 getFrameCount() const;
//! returns the animated mesh based on a detail level. 0 is the
//! lowest, 255 the highest detail. Note, that some Meshes will
//! ignore the detail level.
virtual IMesh* getMesh(s32 frameInMs, s32 detailLevel=255,
s32 startFrameLoop=-1, s32 endFrameLoop=-1);
//! Returns an axis aligned bounding box of the mesh.
//! \return A bounding box of this mesh is returned.
virtual const core::aabbox3d<f32>& getBoundingBox() const;
virtual void setBoundingBox( const core::aabbox3df& box);
//! Returns the type of the animated mesh.
virtual E_ANIMATED_MESH_TYPE getMeshType() const;
//! loads the shader definition
virtual const quake3::IShader * getShader( const c8 * filename, bool fileNameIsValid=true );
//! returns a already loaded Shader
virtual const quake3::IShader * getShader( u32 index ) const;
//! get's an interface to the entities
virtual quake3::tQ3EntityList & getEntityList( const c8 * fileName );
//Link to held meshes? ...
//! returns amount of mesh buffers.
virtual u32 getMeshBufferCount() const
{
return 0;
}
//! returns pointer to a mesh buffer
virtual IMeshBuffer* getMeshBuffer(u32 nr) const
{
return 0;
}
//! Returns pointer to a mesh buffer which fits a material
/** \param material: material to search for
\return Pointer to the mesh buffer or 0 if there is no such mesh buffer. */
virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const
{
return 0;
}
virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue)
{
return;
}
//! set the hardware mapping hint, for driver
virtual void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX)
{
return;
}
//! flags the meshbuffer as changed, reloads hardware buffers
virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX)
{
return;
}
private:
void constructMesh();
void solveTJunction();
void loadTextures();
struct STexShader
{
video::ITexture* Texture;
s32 ShaderID;
};
core::array< STexShader > Tex;
core::array<video::ITexture*> Lightmap;
enum eLumps
{
kEntities = 0, // Stores player/object positions, etc...
kShaders = 1, // Stores texture information
kPlanes = 2, // Stores the splitting planes
kNodes = 3, // Stores the BSP nodes
kLeafs = 4, // Stores the leafs of the nodes
kLeafFaces = 5, // Stores the leaf's indices into the faces
kLeafBrushes = 6, // Stores the leaf's indices into the brushes
kModels = 7, // Stores the info of world models
kBrushes = 8, // Stores the brushes info (for collision)
kBrushSides = 9, // Stores the brush surfaces info
kVertices = 10, // Stores the level vertices
kMeshVerts = 11, // Stores the model vertices offsets
kFogs = 12, // Stores the shader files (blending, anims..)
kFaces = 13, // Stores the faces for the level
kLightmaps = 14, // Stores the lightmaps for the level
kLightGrid = 15, // Stores extra world lighting information
kVisData = 16, // Stores PVS and cluster info (visibility)
kLightArray = 17, // RBSP
kMaxLumps // A constant to store the number of lumps
};
enum eBspSurfaceType
{
BSP_MST_BAD,
BSP_MST_PLANAR,
BSP_MST_PATCH,
BSP_MST_TRIANGLE_SOUP,
BSP_MST_FLARE,
BSP_MST_FOLIAGE
};
struct tBSPHeader
{
s32 strID; // This should always be 'IBSP'
s32 version; // This should be 0x2e for Quake 3 files
};
tBSPHeader header;
struct tBSPLump
{
s32 offset;
s32 length;
};
struct tBSPVertex
{
f32 vPosition[3]; // (x, y, z) position.
f32 vTextureCoord[2]; // (u, v) texture coordinate
f32 vLightmapCoord[2]; // (u, v) lightmap coordinate
f32 vNormal[3]; // (x, y, z) normal vector
u8 color[4]; // RGBA color for the vertex
};
struct tBSPFace
{
s32 textureID; // The index into the texture array
s32 fogNum; // The index for the effects (or -1 = n/a)
s32 type; // 1=polygon, 2=patch, 3=mesh, 4=billboard
s32 vertexIndex; // The index into this face's first vertex
s32 numOfVerts; // The number of vertices for this face
s32 meshVertIndex; // The index into the first meshvertex
s32 numMeshVerts; // The number of mesh vertices
s32 lightmapID; // The texture index for the lightmap
s32 lMapCorner[2]; // The face's lightmap corner in the image
s32 lMapSize[2]; // The size of the lightmap section
f32 lMapPos[3]; // The 3D origin of lightmap.
f32 lMapBitsets[2][3]; // The 3D space for s and t unit vectors.
f32 vNormal[3]; // The face normal.
s32 size[2]; // The bezier patch dimensions.
};
struct tBSPTexture
{
c8 strName[64]; // The name of the texture w/o the extension
u32 flags; // The surface flags (unknown)
u32 contents; // The content flags (unknown)
};
struct tBSPLightmap
{
u8 imageBits[128][128][3]; // The RGB data in a 128x128 image
};
struct tBSPNode
{
s32 plane; // The index into the planes array
s32 front; // The child index for the front node
s32 back; // The child index for the back node
s32 mins[3]; // The bounding box min position.
s32 maxs[3]; // The bounding box max position.
};
struct tBSPLeaf
{
s32 cluster; // The visibility cluster
s32 area; // The area portal
s32 mins[3]; // The bounding box min position
s32 maxs[3]; // The bounding box max position
s32 leafface; // The first index into the face array
s32 numOfLeafFaces; // The number of faces for this leaf
s32 leafBrush; // The first index for into the brushes
s32 numOfLeafBrushes; // The number of brushes for this leaf
};
struct tBSPPlane
{
f32 vNormal[3]; // Plane normal.
f32 d; // The plane distance from origin
};
struct tBSPVisData
{
s32 numOfClusters; // The number of clusters
s32 bytesPerCluster; // Bytes (8 bits) in the cluster's bitset
c8 *pBitsets; // Array of bytes holding the cluster vis.
};
struct tBSPBrush
{
s32 brushSide; // The starting brush side for the brush
s32 numOfBrushSides; // Number of brush sides for the brush
s32 textureID; // The texture index for the brush
};
struct tBSPBrushSide
{
s32 plane; // The plane index
s32 textureID; // The texture index
};
struct tBSPModel
{
f32 min[3]; // The min position for the bounding box
f32 max[3]; // The max position for the bounding box.
s32 faceIndex; // The first face index in the model
s32 numOfFaces; // The number of faces in the model
s32 brushIndex; // The first brush index in the model
s32 numOfBrushes; // The number brushes for the model
};
struct tBSPFog
{
c8 shader[64]; // The name of the shader file
s32 brushIndex; // The brush index for this shader
s32 visibleSide; // the brush side that ray tests need to clip against (-1 == none
};
core::array < STexShader > FogMap;
struct tBSPLights
{
u8 ambient[3]; // This is the ambient color in RGB
u8 directional[3]; // This is the directional color in RGB
u8 direction[2]; // The direction of the light: [phi,theta]
};
void loadTextures (tBSPLump* l, io::IReadFile* file); // Load the textures
void loadLightmaps (tBSPLump* l, io::IReadFile* file); // Load the lightmaps
void loadVerts (tBSPLump* l, io::IReadFile* file); // Load the vertices
void loadFaces (tBSPLump* l, io::IReadFile* file); // Load the faces
void loadPlanes (tBSPLump* l, io::IReadFile* file); // Load the Planes of the BSP
void loadNodes (tBSPLump* l, io::IReadFile* file); // load the Nodes of the BSP
void loadLeafs (tBSPLump* l, io::IReadFile* file); // load the Leafs of the BSP
void loadLeafFaces (tBSPLump* l, io::IReadFile* file); // load the Faces of the Leafs of the BSP
void loadVisData (tBSPLump* l, io::IReadFile* file); // load the visibility data of the clusters
void loadEntities (tBSPLump* l, io::IReadFile* file); // load the entities
void loadModels (tBSPLump* l, io::IReadFile* file); // load the models
void loadMeshVerts (tBSPLump* l, io::IReadFile* file); // load the mesh vertices
void loadBrushes (tBSPLump* l, io::IReadFile* file); // load the brushes of the BSP
void loadBrushSides (tBSPLump* l, io::IReadFile* file); // load the brushsides of the BSP
void loadLeafBrushes(tBSPLump* l, io::IReadFile* file); // load the brushes of the leaf
void loadFogs (tBSPLump* l, io::IReadFile* file); // load the shaders
//bi-quadratic bezier patches
void createCurvedSurface_bezier(SMeshBufferLightMap* meshBuffer,
s32 faceIndex, s32 patchTesselation, s32 storevertexcolor);
void createCurvedSurface_nosubdivision(SMeshBufferLightMap* meshBuffer,
s32 faceIndex, s32 patchTesselation, s32 storevertexcolor);
struct S3DVertex2TCoords_64
{
core::vector3d<f64> Pos;
core::vector3d<f64> Normal;
video::SColorf Color;
core::vector2d<f64> TCoords;
core::vector2d<f64> TCoords2;
void copy( video::S3DVertex2TCoords &dest ) const;
S3DVertex2TCoords_64() {}
S3DVertex2TCoords_64(const core::vector3d<f64>& pos, const core::vector3d<f64>& normal, const video::SColorf& color,
const core::vector2d<f64>& tcoords, const core::vector2d<f64>& tcoords2)
: Pos(pos), Normal(normal), Color(color), TCoords(tcoords), TCoords2(tcoords2) {}
S3DVertex2TCoords_64 getInterpolated_quadratic(const S3DVertex2TCoords_64& v2,
const S3DVertex2TCoords_64& v3, const f64 d) const
{
return S3DVertex2TCoords_64 (
Pos.getInterpolated_quadratic ( v2.Pos, v3.Pos, d ),
Normal.getInterpolated_quadratic ( v2.Normal, v3.Normal, d ),
Color.getInterpolated_quadratic ( v2.Color, v3.Color, (f32) d ),
TCoords.getInterpolated_quadratic ( v2.TCoords, v3.TCoords, d ),
TCoords2.getInterpolated_quadratic ( v2.TCoords2, v3.TCoords2, d ));
}
};
inline void copy( video::S3DVertex2TCoords * dest, const tBSPVertex * source,
s32 vertexcolor ) const;
void copy( S3DVertex2TCoords_64 * dest, const tBSPVertex * source, s32 vertexcolor ) const;
struct SBezier
{
SMeshBufferLightMap *Patch;
S3DVertex2TCoords_64 control[9];
void tesselate(s32 level);
private:
s32 Level;
core::array<S3DVertex2TCoords_64> column[3];
};
SBezier Bezier;
quake3::Q3LevelLoadParameter LoadParam;
tBSPLump Lumps[kMaxLumps];
tBSPTexture* Textures;
s32 NumTextures;
tBSPLightmap* LightMaps;
s32 NumLightMaps;
tBSPVertex* Vertices;
s32 NumVertices;
tBSPFace* Faces;
s32 NumFaces;
tBSPPlane* Planes;
s32 NumPlanes;
tBSPNode* Nodes;
s32 NumNodes;
tBSPLeaf* Leafs;
s32 NumLeafs;
s32 *LeafFaces;
s32 NumLeafFaces;
s32 *MeshVerts; // The vertex offsets for a mesh
s32 NumMeshVerts;
tBSPBrush* Brushes;
s32 NumBrushes;
scene::SMesh* Mesh[quake3::E_Q3_MESH_SIZE];
video::IVideoDriver* Driver;
core::stringc LevelName;
io::IFileSystem* FileSystem; // needs because there are no file extenstions stored in .bsp files.
// Additional content
scene::ISceneManager* SceneManager;
enum eToken
{
Q3_TOKEN_UNRESOLVED = 0,
Q3_TOKEN_EOF = 1,
Q3_TOKEN_START_LIST,
Q3_TOKEN_END_LIST,
Q3_TOKEN_ENTITY,
Q3_TOKEN_TOKEN,
Q3_TOKEN_EOL,
Q3_TOKEN_COMMENT,
Q3_TOKEN_MATH_DIVIDE,
Q3_TOKEN_MATH_ADD,
Q3_TOKEN_MATH_MULTIPY
};
struct SQ3Parser
{
const c8 *source;
u32 sourcesize;
u32 index;
core::stringc token;
u32 tokenresult;
};
SQ3Parser Parser;
typedef void( CQ3LevelMesh::*tParserCallback ) ( quake3::SVarGroupList *& groupList );
void parser_parse( const void * data, u32 size, tParserCallback callback );
void parser_nextToken();
void dumpVarGroup( const quake3::SVarGroup * group, s32 stack ) const;
void scriptcallback_entity( quake3::SVarGroupList *& grouplist );
core::array < quake3::IShader > Entity; //quake3::tQ3EntityList Entity;
void scriptcallback_shader( quake3::SVarGroupList *& grouplist );
core::array < quake3::IShader > Shader;
quake3::tStringList ShaderFile;
void InitShader();
void ReleaseShader();
void ReleaseEntity();
s32 setShaderMaterial( video::SMaterial & material, const tBSPFace * face ) const;
s32 setShaderFogMaterial( video::SMaterial &material, const tBSPFace * face ) const;
struct SToBuffer
{
s32 takeVertexColor;
u32 index;
};
void cleanMeshes();
void cleanLoader ();
void calcBoundingBoxes();
c8 buf[128];
};
} // end namespace scene
} // end namespace irr
#endif