VMAP Namespace Reference

Classes
struct	AreaInfo
class	AreaInfoCallback
struct	GModelRayCallback
class	GroupModel
struct	GroupModel_Raw
class	IntersectionCallBack
class	IVMapManager
struct	LocationInfo
class	LocationInfoCallback
class	ManagedModel
class	MapRayCallback
struct	MapSpawns
class	MeshTriangle
class	ModelInstance
class	ModelPosition
class	ModelSpawn
class	MyCollisionDetection
class	StaticMapTree
class	TileAssembler
class	TriBoundFunc
class	VMapFactory
class	VMapManager2
class	WModelAreaCallback
struct	WModelRayCallBack
class	WmoLiquid
struct	WMOLiquidHeader
class	WorldModel
struct	WorldModel_Raw

Typedefs
typedef std::unordered_map < uint32, StaticMapTree * >	InstanceTreeMap
typedef std::unordered_map < std::string, ManagedModel >	ModelFileMap
typedef std::map< uint32, ModelSpawn >	UniqueEntryMap
typedef std::multimap< uint32, uint32 >	TileMap
typedef std::map< uint32, MapSpawns * >	MapData

Enumerations
enum	VMAP_LOAD_RESULT { VMAP_LOAD_RESULT_ERROR, VMAP_LOAD_RESULT_OK, VMAP_LOAD_RESULT_IGNORED }
enum	DisableTypes { VMAP_DISABLE_AREAFLAG = 0x1, VMAP_DISABLE_HEIGHT = 0x2, VMAP_DISABLE_LOS = 0x4, VMAP_DISABLE_LIQUIDSTATUS = 0x8 }
enum	ModelFlags { MOD_M2 = 1, MOD_WORLDSPAWN = 1<<1, MOD_HAS_BOUND = 1<<2 }

Functions
bool	readChunk (FILE *rf, char *dest, const char *compare, uint32 len)
bool	IntersectTriangle (const MeshTriangle &tri, std::vector< Vector3 >::const_iterator points, const G3D::Ray &ray, float &distance)

Variables
IVMapManager *	gVMapManager = NULL
const char	VMAP_MAGIC [] = "VMAP_4.3"
const char	RAW_VMAP_MAGIC [] = "VMAP043"
const char	GAMEOBJECT_MODELS [] = "GameObjectModels.dtree"

Detailed Description

This is the minimum interface to the VMapMamager.

This is the access point to the VMapManager.

The Class is mainly taken from G3D/AABSPTree.h but modified to be able to use our internal data structure. This is an iterator that helps us analysing the BSP-Trees. The collision detection is modified to return true, if we are inside an object.

Typedef Documentation

typedef std::unordered_map<uint32, StaticMapTree*> VMAP::InstanceTreeMap

typedef std::map<uint32, MapSpawns*> VMAP::MapData

typedef std::unordered_map<std::string, ManagedModel> VMAP::ModelFileMap

typedef std::multimap<uint32, uint32> VMAP::TileMap

typedef std::map<uint32, ModelSpawn> VMAP::UniqueEntryMap

Enumeration Type Documentation

enum VMAP::DisableTypes

Enumerator
VMAP_DISABLE_AREAFLAG
VMAP_DISABLE_HEIGHT
VMAP_DISABLE_LOS
VMAP_DISABLE_LIQUIDSTATUS

 {
 VMAP_DISABLE_AREAFLAG = 0x1,
 VMAP_DISABLE_HEIGHT = 0x2,
 VMAP_DISABLE_LOS = 0x4,
 VMAP_DISABLE_LIQUIDSTATUS = 0x8
 };

enum VMAP::ModelFlags

Enumerator
MOD_M2
MOD_WORLDSPAWN
MOD_HAS_BOUND

 {
 MOD_M2 = 1,
 MOD_WORLDSPAWN = 1<<1,
 MOD_HAS_BOUND = 1<<2
 };

enum VMAP::VMAP_LOAD_RESULT

Enumerator
VMAP_LOAD_RESULT_ERROR
VMAP_LOAD_RESULT_OK
VMAP_LOAD_RESULT_IGNORED

 {
 VMAP_LOAD_RESULT_ERROR,
 VMAP_LOAD_RESULT_OK,
 VMAP_LOAD_RESULT_IGNORED
 };

Function Documentation

bool VMAP::IntersectTriangle	(	const MeshTriangle &	tri,
		std::vector< Vector3 >::const_iterator	points,
		const G3D::Ray &	ray,
		float &	distance
	)

 {
 static const float EPS = 1e-5f;

 // See RTR2 ch. 13.7 for the algorithm.

 const Vector3 e1 = points[tri.idx1] - points[tri.idx0];
 const Vector3 e2 = points[tri.idx2] - points[tri.idx0];
 const Vector3 p(ray.direction().cross(e2));
 const float a = e1.dot(p);

 if (std::fabs(a) < EPS) {
 // Determinant is ill-conditioned; abort early
 return false;
 }

 const float f = 1.0f / a;
 const Vector3 s(ray.origin() - points[tri.idx0]);
 const float u = f * s.dot(p);

 if ((u < 0.0f) || (u > 1.0f)) {
 // We hit the plane of the m_geometry, but outside the m_geometry
 return false;
 }

 const Vector3 q(s.cross(e1));
 const float v = f * ray.direction().dot(q);

 if ((v < 0.0f) || ((u + v) > 1.0f)) {
 // We hit the plane of the triangle, but outside the triangle
 return false;
 }

 const float t = f * e2.dot(q);

 if ((t > 0.0f) && (t < distance))
 {
 // This is a new hit, closer than the previous one
 distance = t;

 /* baryCoord[0] = 1.0 - u - v;
 baryCoord[1] = u;
 baryCoord[2] = v; */

 return true;
 }
 // This hit is after the previous hit, so ignore it
 return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool VMAP::readChunk	(	FILE *	rf,
		char *	dest,
		const char *	compare,
		uint32	len
	)

 {
 if (fread(dest, sizeof(char), len, rf) != len) return false;
 return memcmp(dest, compare, len) == 0;
 }

Here is the caller graph for this function:

Variable Documentation

const char VMAP::GAMEOBJECT_MODELS[] = "GameObjectModels.dtree"

IVMapManager* VMAP::gVMapManager = NULL

const char VMAP::RAW_VMAP_MAGIC[] = "VMAP043"

const char VMAP::VMAP_MAGIC[] = "VMAP_4.3"