VMAP::GroupModel Class Reference

#include "WorldModel.h"

Public Types
enum	InsideResult {   INSIDE = 0 ,   MAYBE_INSIDE = 1 ,   ABOVE = 2 ,   OUT_OF_BOUNDS = -1 }

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!
void	setLiquidData (WmoLiquid *&liquid)
bool	IntersectRay (const G3D::Ray &ray, float &distance, bool stopAtFirstHit) const
InsideResult	IsInsideObject (G3D::Ray const &ray, float &z_dist) const
bool	GetLiquidLevel (const G3D::Vector3 &pos, float &liqHeight) const
uint32	GetLiquidType () const
bool	writeToFile (FILE *wf)
bool	readFromFile (FILE *rf)
G3D::AABox const &	GetBound () const
G3D::AABox const &	GetMeshTreeBound () 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

Member Enumeration Documentation

InsideResult

enum VMAP::GroupModel::InsideResult

Enumerator
INSIDE
MAYBE_INSIDE
ABOVE
OUT_OF_BOUNDS

{ INSIDE = 0, MAYBE_INSIDE = 1, ABOVE = 2, OUT_OF_BOUNDS = -1 };

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()

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

inline

{ return iBound; }

References iBound.

Referenced by BoundsTrait< VMAP::GroupModel >::GetBounds().

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(), and VMAP::VMapMgr2::GetAreaAndLiquidData().

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.

GetMeshTreeBound()

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

inline

{ return meshTree.bound(); }

References BIH::bound(), and meshTree.

GetMogpFlags()

uint32 VMAP::GroupModel::GetMogpFlags ( ) const

inline

{ return iMogpFlags; }

References iMogpFlags.

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

GetWmoID()

uint32 VMAP::GroupModel::GetWmoID ( ) const

inline

{ return iGroupWMOID; }

References iGroupWMOID.

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

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()

GroupModel::InsideResult VMAP::GroupModel::IsInsideObject	(	G3D::Ray const &	ray,
		float &	z_dist
	)		const

    {
        if (triangles.empty() || !IsInsideOrAboveBound(iBound, ray.origin()))
            return OUT_OF_BOUNDS;
 
        if (meshTree.bound().high().z >= ray.origin().z)
        {
            float dist = G3D::finf();
            if (IntersectRay(ray, dist, false))
            {
                z_dist = dist - 0.1f;
                return INSIDE;
            }
            if (meshTree.bound().contains(ray.origin()))
                return MAYBE_INSIDE;
        }
        else
        {
            // some group models don't have any floor to intersect with
            // so we should attempt to intersect with a model part below this group
            // then find back where we originated from (in WorldModel::GetLocationInfo)
            float dist = G3D::finf();
            float delta = ray.origin().z - meshTree.bound().high().z;
            if (IntersectRay(ray.bumpedRay(delta), dist, false))
            {
                z_dist = dist - 0.1f + delta;
                return ABOVE;
            }
        }
 
        return OUT_OF_BOUNDS;
    }

References ABOVE, BIH::bound(), iBound, INSIDE, IntersectRay(), VMAP::IsInsideOrAboveBound(), MAYBE_INSIDE, meshTree, OUT_OF_BOUNDS, 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

{0};

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

iLiquid

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

protected

{nullptr};

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

iMogpFlags

uint32 VMAP::GroupModel::iMogpFlags {0}

protected

{0};// 0x8 outdor; 0x2000 indoor

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

meshTree

BIH VMAP::GroupModel::meshTree

protected

Referenced by GetMeshTreeBound(), IntersectRay(), IsInsideObject(), 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().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/common/Collision/Models/WorldModel.h
• azerothcore-wotlk/src/common/Collision/Models/WorldModel.cpp