VMAP::GroupModel Class Reference

#include "WorldModel.h"

Public Member Functions
	GroupModel ()
	GroupModel (const GroupModel &other)
	GroupModel (uint32 mogpFlags, uint32 groupWMOID, const G3D::AABox &bound)
	~GroupModel ()
void	setMeshData (std::vector< G3D::Vector3 > &vert, std::vector< MeshTriangle > &tri)
	pass mesh data to object and create BIH. Passed vectors get get swapped with old geometry! More...
void	setLiquidData (WmoLiquid *&liquid)
bool	IntersectRay (const G3D::Ray &ray, float &distance, bool stopAtFirstHit) const
bool	IsInsideObject (const G3D::Vector3 &pos, const G3D::Vector3 &down, float &z_dist) const
bool	GetLiquidLevel (const G3D::Vector3 &pos, float &liqHeight) const
uint32	GetLiquidType () const
bool	writeToFile (FILE *wf)
bool	readFromFile (FILE *rf)
const G3D::AABox &	GetBound () const
uint32	GetMogpFlags () const
uint32	GetWmoID () const
void	GetMeshData (std::vector< G3D::Vector3 > &outVertices, std::vector< MeshTriangle > &outTriangles, WmoLiquid *&liquid)

Protected Attributes
G3D::AABox	iBound
uint32	iMogpFlags {0}
uint32	iGroupWMOID {0}
std::vector< G3D::Vector3 >	vertices
std::vector< MeshTriangle >	triangles
BIH	meshTree
WmoLiquid *	iLiquid {nullptr}

Detailed Description

holding additional info for WMO group files

Constructor & Destructor Documentation

GroupModel() [1/3]

VMAP::GroupModel::GroupModel ( )

inline

{ }

GroupModel() [2/3]

VMAP::GroupModel::GroupModel

(

const GroupModel &

other

)

                                                 :
        iBound(other.iBound), iMogpFlags(other.iMogpFlags), iGroupWMOID(other.iGroupWMOID),
        vertices(other.vertices), triangles(other.triangles), meshTree(other.meshTree), iLiquid(0)
    {
        if (other.iLiquid)
        {
            iLiquid = new WmoLiquid(*other.iLiquid);
        }
    }

References iLiquid.

GroupModel() [3/3]

VMAP::GroupModel::GroupModel ( uint32  mogpFlags, uint32  groupWMOID, const G3D::AABox &  bound  )

inline

                                                                              :
            iBound(bound), iMogpFlags(mogpFlags), iGroupWMOID(groupWMOID), iLiquid(nullptr) { }

~GroupModel()

VMAP::GroupModel::~GroupModel ( )

inline

{ delete iLiquid; }

References iLiquid.

Member Function Documentation

GetBound()

const G3D::AABox & VMAP::GroupModel::GetBound ( ) const

inline

{ return iBound; }

References iBound.

Referenced by BoundsTrait< VMAP::GroupModel >::GetBounds(), and VMAP::WModelAreaCallback::operator()().

GetLiquidLevel()

bool VMAP::GroupModel::GetLiquidLevel	(	const G3D::Vector3 &	pos,
		float &	liqHeight
	)		const

    {
        if (iLiquid)
        {
            return iLiquid->GetLiquidHeight(pos, liqHeight);
        }
        return false;
    }

References VMAP::WmoLiquid::GetLiquidHeight(), and iLiquid.

Referenced by VMAP::ModelInstance::GetLiquidLevel(), and GameObjectModel::GetLiquidLevel().

GetLiquidType()

uint32 VMAP::GroupModel::GetLiquidType

(

)

const

    {
        if (iLiquid)
        {
            return iLiquid->GetType();
        }
        return 0;
    }

References VMAP::WmoLiquid::GetType(), and iLiquid.

Referenced by DynamicMapTree::GetAreaAndLiquidData(), VMAP::VMapMgr2::GetAreaAndLiquidData(), and VMAP::VMapMgr2::GetLiquidLevel().

GetMeshData()

void VMAP::GroupModel::GetMeshData	(	std::vector< G3D::Vector3 > &	outVertices,
		std::vector< MeshTriangle > &	outTriangles,
		WmoLiquid *&	liquid
	)

    {
        outVertices = vertices;
        outTriangles = triangles;
        liquid = iLiquid;
    }

References iLiquid, triangles, and vertices.

GetMogpFlags()

uint32 VMAP::GroupModel::GetMogpFlags ( ) const

inline

{ return iMogpFlags; }

References iMogpFlags.

Referenced by DynamicMapTree::GetAreaAndLiquidData(), VMAP::VMapMgr2::GetAreaAndLiquidData(), VMAP::VMapMgr2::GetLiquidLevel(), and VMAP::WModelAreaCallback::operator()().

GetWmoID()

uint32 VMAP::GroupModel::GetWmoID ( ) const

inline

{ return iGroupWMOID; }

References iGroupWMOID.

Referenced by DynamicMapTree::GetAreaAndLiquidData(), VMAP::VMapMgr2::GetAreaAndLiquidData(), and VMAP::WModelAreaCallback::operator()().

IntersectRay()

bool VMAP::GroupModel::IntersectRay	(	const G3D::Ray &	ray,
		float &	distance,
		bool	stopAtFirstHit
	)		const

    {
        if (triangles.empty())
        {
            return false;
        }
 
        GModelRayCallback callback(triangles, vertices);
        meshTree.intersectRay(ray, callback, distance, stopAtFirstHit);
        return callback.hit;
    }

References VMAP::GModelRayCallback::hit, BIH::intersectRay(), meshTree, triangles, and vertices.

Referenced by IsInsideObject().

IsInsideObject()

bool VMAP::GroupModel::IsInsideObject	(	const G3D::Vector3 &	pos,
		const G3D::Vector3 &	down,
		float &	z_dist
	)		const

    {
        if (triangles.empty() || !iBound.contains(pos))
        {
            return false;
        }
        Vector3 rPos = pos - 0.1f * down;
        float dist = G3D::inf();
        G3D::Ray ray(rPos, down);
        bool hit = IntersectRay(ray, dist, false);
        if (hit)
        {
            z_dist = dist - 0.1f;
        }
        return hit;
    }

References iBound, IntersectRay(), and triangles.

readFromFile()

bool VMAP::GroupModel::readFromFile

(

FILE *

rf

)

    {
        char chunk[8];
        bool result = true;
        uint32 chunkSize = 0;
        uint32 count = 0;
        triangles.clear();
        vertices.clear();
        delete iLiquid;
        iLiquid = nullptr;
 
        if (fread(&iBound, sizeof(G3D::AABox), 1, rf) != 1) { result = false; }
        if (result && fread(&iMogpFlags, sizeof(uint32), 1, rf) != 1) { result = false; }
        if (result && fread(&iGroupWMOID, sizeof(uint32), 1, rf) != 1) { result = false; }
 
        // read vertices
        if (result && !readChunk(rf, chunk, "VERT", 4)) { result = false; }
        if (result && fread(&chunkSize, sizeof(uint32), 1, rf) != 1) { result = false; }
        if (result && fread(&count, sizeof(uint32), 1, rf) != 1) { result = false; }
        if (!count) // models without (collision) geometry end here, unsure if they are useful
        {
            return result;
        }
        if (result) { vertices.resize(count); }
        if (result && fread(&vertices[0], sizeof(Vector3), count, rf) != count) { result = false; }
 
        // read triangle mesh
        if (result && !readChunk(rf, chunk, "TRIM", 4)) { result = false; }
        if (result && fread(&chunkSize, sizeof(uint32), 1, rf) != 1) { result = false; }
        if (result && fread(&count, sizeof(uint32), 1, rf) != 1) { result = false; }
        if (result) { triangles.resize(count); }
        if (result && fread(&triangles[0], sizeof(MeshTriangle), count, rf) != count) { result = false; }
 
        // read mesh BIH
        if (result && !readChunk(rf, chunk, "MBIH", 4)) { result = false; }
        if (result) { result = meshTree.readFromFile(rf); }
 
        // write liquid data
        if (result && !readChunk(rf, chunk, "LIQU", 4)) { result = false; }
        if (result && fread(&chunkSize, sizeof(uint32), 1, rf) != 1) { result = false; }
        if (result && chunkSize > 0)
        {
            result = WmoLiquid::readFromFile(rf, iLiquid);
        }
        return result;
    }

References iBound, iGroupWMOID, iLiquid, iMogpFlags, meshTree, VMAP::readChunk(), BIH::readFromFile(), VMAP::WmoLiquid::readFromFile(), triangles, and vertices.

setLiquidData()

void VMAP::GroupModel::setLiquidData ( WmoLiquid *&  liquid )

inline

{ iLiquid = liquid; liquid = nullptr; }

References iLiquid.

setMeshData()

void VMAP::GroupModel::setMeshData	(	std::vector< G3D::Vector3 > &	vert,
		std::vector< MeshTriangle > &	tri
	)

pass mesh data to object and create BIH. Passed vectors get get swapped with old geometry!

    {
        vertices.swap(vert);
        triangles.swap(tri);
        TriBoundFunc bFunc(vertices);
        meshTree.build(triangles, bFunc);
    }

References BIH::build(), meshTree, triangles, and vertices.

writeToFile()

bool VMAP::GroupModel::writeToFile

(

FILE *

wf

)

    {
        bool result = true;
        uint32 chunkSize, count;
 
        if (fwrite(&iBound, sizeof(G3D::AABox), 1, wf) != 1) { result = false; }
        if (result && fwrite(&iMogpFlags, sizeof(uint32), 1, wf) != 1) { result = false; }
        if (result && fwrite(&iGroupWMOID, sizeof(uint32), 1, wf) != 1) { result = false; }
 
        // write vertices
        if (result && fwrite("VERT", 1, 4, wf) != 4) { result = false; }
        count = vertices.size();
        chunkSize = sizeof(uint32) + sizeof(Vector3) * count;
        if (result && fwrite(&chunkSize, sizeof(uint32), 1, wf) != 1) { result = false; }
        if (result && fwrite(&count, sizeof(uint32), 1, wf) != 1) { result = false; }
        if (!count) // models without (collision) geometry end here, unsure if they are useful
        {
            return result;
        }
        if (result && fwrite(&vertices[0], sizeof(Vector3), count, wf) != count) { result = false; }
 
        // write triangle mesh
        if (result && fwrite("TRIM", 1, 4, wf) != 4) { result = false; }
        count = triangles.size();
        chunkSize = sizeof(uint32) + sizeof(MeshTriangle) * count;
        if (result && fwrite(&chunkSize, sizeof(uint32), 1, wf) != 1) { result = false; }
        if (result && fwrite(&count, sizeof(uint32), 1, wf) != 1) { result = false; }
        if (result && fwrite(&triangles[0], sizeof(MeshTriangle), count, wf) != count) { result = false; }
 
        // write mesh BIH
        if (result && fwrite("MBIH", 1, 4, wf) != 4) { result = false; }
        if (result) { result = meshTree.writeToFile(wf); }
 
        // write liquid data
        if (result && fwrite("LIQU", 1, 4, wf) != 4) { result = false; }
        if (!iLiquid)
        {
            chunkSize = 0;
            if (result && fwrite(&chunkSize, sizeof(uint32), 1, wf) != 1) { result = false; }
            return result;
        }
        chunkSize = iLiquid->GetFileSize();
        if (result && fwrite(&chunkSize, sizeof(uint32), 1, wf) != 1) { result = false; }
        if (result) { result = iLiquid->writeToFile(wf); }
 
        return result;
    }

References VMAP::WmoLiquid::GetFileSize(), iBound, iGroupWMOID, iLiquid, iMogpFlags, meshTree, triangles, vertices, VMAP::WmoLiquid::writeToFile(), and BIH::writeToFile().

Member Data Documentation

iBound

G3D::AABox VMAP::GroupModel::iBound

protected

Referenced by GetBound(), IsInsideObject(), readFromFile(), and writeToFile().

iGroupWMOID

uint32 VMAP::GroupModel::iGroupWMOID {0}

protected

Referenced by GetWmoID(), readFromFile(), and writeToFile().

iLiquid

WmoLiquid* VMAP::GroupModel::iLiquid {nullptr}

protected

Referenced by GetLiquidLevel(), GetLiquidType(), GetMeshData(), GroupModel(), readFromFile(), setLiquidData(), writeToFile(), and ~GroupModel().

iMogpFlags

uint32 VMAP::GroupModel::iMogpFlags {0}

protected

Referenced by GetMogpFlags(), readFromFile(), and writeToFile().

meshTree

BIH VMAP::GroupModel::meshTree

protected

Referenced by IntersectRay(), readFromFile(), setMeshData(), and writeToFile().

triangles

std::vector<MeshTriangle> VMAP::GroupModel::triangles

protected

Referenced by GetMeshData(), IntersectRay(), IsInsideObject(), readFromFile(), setMeshData(), and writeToFile().

vertices

std::vector<G3D::Vector3> VMAP::GroupModel::vertices

protected

Referenced by GetMeshData(), IntersectRay(), readFromFile(), setMeshData(), and writeToFile().