VMAP Namespace Reference

Classes
struct	AreaAndLiquidData
struct	AreaInfo
struct	GModelRayCallback
struct	GroupLocationInfo
class	GroupModel
struct	GroupModel_Raw
class	IntersectionCallBack
class	IVMapMgr
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	VMapMgr2
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 class	LoadResult : uint8 {   Success ,   FileNotFound ,   VersionMismatch }
enum	DisableTypes {   VMAP_DISABLE_AREAFLAG = 0x1 ,   VMAP_DISABLE_HEIGHT = 0x2 ,   VMAP_DISABLE_LOS = 0x4 ,   VMAP_DISABLE_LIQUIDSTATUS = 0x8 }
enum class	ModelIgnoreFlags : uint32 {   Nothing = 0x00 ,   M2 = 0x01 }
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)
ModelIgnoreFlags	operator& (ModelIgnoreFlags left, ModelIgnoreFlags right)
bool	IntersectTriangle (const MeshTriangle &tri, std::vector< Vector3 >::const_iterator points, const G3D::Ray &ray, float &distance)
bool	IsInsideOrAboveBound (G3D::AABox const &bounds, const G3D::Point3 &point)

Variables
VMapMgr2 *	gVMapMgr = nullptr
const char	VMAP_MAGIC [] = "VMAP_4.7"
const char	RAW_VMAP_MAGIC [] = "VMAP047"
const char	GAMEOBJECT_MODELS [] = "GameObjectModels.dtree"

Detailed Description

This is the minimum interface to the VMapMamager.

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

InstanceTreeMap

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

MapData

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

ModelFileMap

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

TileMap

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

UniqueEntryMap

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

Enumeration Type Documentation

DisableTypes

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
    };

LoadResult

enum class VMAP::LoadResult : uint8

strong

Enumerator
Success
FileNotFound
VersionMismatch

    {
        Success,
        FileNotFound,
        VersionMismatch
    };

ModelFlags

enum VMAP::ModelFlags

Enumerator
MOD_M2
MOD_WORLDSPAWN
MOD_HAS_BOUND

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

ModelIgnoreFlags

enum class VMAP::ModelIgnoreFlags : uint32

strong

Enumerator
Nothing
M2

    {
        Nothing = 0x00,
        M2      = 0x01
    };

VMAP_LOAD_RESULT

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

IntersectTriangle()

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;
    }

References VMAP::MeshTriangle::idx0, VMAP::MeshTriangle::idx1, and VMAP::MeshTriangle::idx2.

Referenced by VMAP::GModelRayCallback::operator()().

IsInsideOrAboveBound()

bool VMAP::IsInsideOrAboveBound ( G3D::AABox const &  bounds, const G3D::Point3 &  point  )

inline

    {
        return point.x >= bounds.low().x
            && point.y >= bounds.low().y
            && point.z >= bounds.low().z
            && point.x <= bounds.high().x
            && point.y <= bounds.high().y;
    }

Referenced by VMAP::GroupModel::IsInsideObject().

operator&()

ModelIgnoreFlags VMAP::operator& ( ModelIgnoreFlags  left, ModelIgnoreFlags  right  )

inline

    {
        return ModelIgnoreFlags(uint32(left) & uint32(right));
    }

readChunk()

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;
    }

Referenced by VMAP::StaticMapTree::CanLoadMap(), VMAP::StaticMapTree::InitMap(), VMAP::StaticMapTree::LoadMapTile(), VMAP::WorldModel::readFile(), VMAP::GroupModel::readFromFile(), and VMAP::StaticMapTree::UnloadMapTile().

Variable Documentation

GAMEOBJECT_MODELS

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

Referenced by VMAP::TileAssembler::exportGameobjectModels(), and LoadGameObjectModelList().

gVMapMgr

VMapMgr2* VMAP::gVMapMgr = nullptr

Referenced by VMAP::VMapFactory::clear(), and VMAP::VMapFactory::createOrGetVMapMgr().

RAW_VMAP_MAGIC

const char VMAP::RAW_VMAP_MAGIC = "VMAP047"

Referenced by Model::ConvertToVMAPModel(), WMORoot::ConvertToVMAPRootWmo(), VMAP::TileAssembler::exportGameobjectModels(), ExtractGameobjectModels(), and VMAP::WorldModel_Raw::Read().

VMAP_MAGIC

const char VMAP::VMAP_MAGIC = "VMAP_4.7"

Referenced by VMAP::StaticMapTree::CanLoadMap(), VMAP::TileAssembler::convertWorld2(), VMAP::TileAssembler::exportGameobjectModels(), VMAP::StaticMapTree::InitMap(), LoadGameObjectModelList(), VMAP::StaticMapTree::LoadMapTile(), VMAP::WorldModel::readFile(), VMAP::StaticMapTree::UnloadMapTile(), and VMAP::WorldModel::writeFile().