#include "WorldModel.h"

Public Member Functions
	WorldModel ()

void	setGroupModels (std::vector< GroupModel > &models)
	pass group models to WorldModel and create BIH. Passed vector is swapped with old geometry!

void	setRootWmoID (uint32 id)

bool	IntersectRay (const G3D::Ray &ray, float &distance, bool stopAtFirstHit, ModelIgnoreFlags ignoreFlags) const

bool	GetLocationInfo (const G3D::Vector3 &p, const G3D::Vector3 &down, float &dist, GroupLocationInfo &info) const

bool	writeFile (const std::string &filename)

bool	readFile (const std::string &filename)

void	GetGroupModels (std::vector< GroupModel > &outGroupModels)

Public Attributes
uint32	Flags

Protected Attributes
uint32	RootWMOID {0}

std::vector< GroupModel >	groupModels

BIH	groupTree

Detailed Description

Holds a model (converted M2 or WMO) in its original coordinate space

Constructor & Destructor Documentation

◆ WorldModel()

VMAP::WorldModel::WorldModel ( )

inline

109{ }

Member Function Documentation

◆ GetGroupModels()

void VMAP::WorldModel::GetGroupModels ( std::vector< GroupModel > & outGroupModels )

    {
        outGroupModels = groupModels;
    }

References groupModels.

Referenced by MMAP::TerrainBuilder::loadVMap().

◆ GetLocationInfo()

bool VMAP::WorldModel::GetLocationInfo	(	const G3D::Vector3 &	p,
		const G3D::Vector3 &	down,
		float &	dist,
		GroupLocationInfo &	info
	)		const

    {
        if (groupModels.empty())
        {
            return false;
        }
 
        WModelAreaCallback callback(groupModels);
        G3D::Ray r(p - down * 0.1f, down);
        float zDist = groupTree.bound().extent().length();
        groupTree.intersectRay(r, callback, zDist, false);
        if (callback.hit[GroupModel::INSIDE])
        {
            info.rootId = RootWMOID;
            info.hitModel = callback.hit[GroupModel::INSIDE];
            dist = zDist;
            return true;
        }
 
        // some group models don't have any floor to intersect with
        // so we should attempt to intersect with a model part below the group `p` is in (stored in GroupModel::ABOVE)
        // then find back where we originated from (GroupModel::MAYBE_INSIDE)
        if (callback.hit[GroupModel::MAYBE_INSIDE] && callback.hit[GroupModel::ABOVE])
        {
            info.rootId   = RootWMOID;
            info.hitModel = callback.hit[GroupModel::MAYBE_INSIDE];
            dist = zDist;
            return true;
        }
        return false;
    }

References VMAP::GroupModel::ABOVE, BIH::bound(), groupModels, groupTree, VMAP::WModelAreaCallback::hit, VMAP::GroupLocationInfo::hitModel, VMAP::GroupModel::INSIDE, BIH::intersectRay(), VMAP::GroupModel::MAYBE_INSIDE, VMAP::GroupLocationInfo::rootId, and RootWMOID.

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

◆ IntersectRay()

bool VMAP::WorldModel::IntersectRay	(	const G3D::Ray &	ray,
		float &	distance,
		bool	stopAtFirstHit,
		ModelIgnoreFlags	ignoreFlags
	)		const

    {
        // If the caller asked us to ignore certain objects we should check flags
        if ((ignoreFlags & ModelIgnoreFlags::M2) != ModelIgnoreFlags::Nothing)
        {
            // M2 models are not taken into account for LoS calculation if caller requested their ignoring.
            if (Flags & MOD_M2)
            {
                return false;
            }
        }
 
        // small M2 workaround, maybe better make separate class with virtual intersection funcs
        // in any case, there's no need to use a bound tree if we only have one submodel
        if (groupModels.size() == 1)
        {
            return groupModels[0].IntersectRay(ray, distance, stopAtFirstHit);
        }
 
        WModelRayCallBack isc(groupModels);
        groupTree.intersectRay(ray, isc, distance, stopAtFirstHit);
        return isc.hit;
    }

References Flags, groupModels, groupTree, VMAP::WModelRayCallBack::hit, BIH::intersectRay(), VMAP::M2, VMAP::MOD_M2, and VMAP::Nothing.

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

◆ readFile()

bool VMAP::WorldModel::readFile ( const std::string & filename )

    {
        FILE* rf = fopen(filename.c_str(), "rb");
        if (!rf)
        {
            return false;
        }
 
        bool result = true;
        uint32 chunkSize = 0;
        uint32 count = 0;
        char chunk[8];                          // Ignore the added magic header
        if (!readChunk(rf, chunk, VMAP_MAGIC, 8)) { result = false; }
 
        if (result && !readChunk(rf, chunk, "WMOD", 4)) { result = false; }
        if (result && fread(&chunkSize, sizeof(uint32), 1, rf) != 1) { result = false; }
        if (result && fread(&RootWMOID, sizeof(uint32), 1, rf) != 1) { result = false; }
 
        // read group models
        if (result && readChunk(rf, chunk, "GMOD", 4))
        {
            //if (fread(&chunkSize, sizeof(uint32), 1, rf) != 1) result = false;
 
            if (fread(&count, sizeof(uint32), 1, rf) != 1) { result = false; }
            if (result) { groupModels.resize(count); }
            //if (result && fread(&groupModels[0], sizeof(GroupModel), count, rf) != count) result = false;
            for (uint32 i = 0; i < count && result; ++i)
            {
                result = groupModels[i].readFromFile(rf);
            }
 
            // read group BIH
            if (result && !readChunk(rf, chunk, "GBIH", 4)) { result = false; }
            if (result) { result = groupTree.readFromFile(rf); }
        }
 
        fclose(rf);
        return result;
    }

References groupModels, groupTree, VMAP::readChunk(), BIH::readFromFile(), RootWMOID, and VMAP::VMAP_MAGIC.

Referenced by VMAP::VMapMgr2::acquireModelInstance().

◆ setGroupModels()

void VMAP::WorldModel::setGroupModels ( std::vector< GroupModel > & models )

pass group models to WorldModel and create BIH. Passed vector is swapped with old geometry!

    {
        groupModels.swap(models);
        groupTree.build(groupModels, BoundsTrait<GroupModel>::GetBounds, 1);
    }

References BIH::build(), groupModels, and groupTree.

Referenced by VMAP::TileAssembler::convertRawFile().

◆ setRootWmoID()

void VMAP::WorldModel::setRootWmoID ( uint32 id )

inline

113{ RootWMOID = id; }

References RootWMOID.

Referenced by VMAP::TileAssembler::convertRawFile().

◆ writeFile()

bool VMAP::WorldModel::writeFile ( const std::string & filename )

    {
        FILE* wf = fopen(filename.c_str(), "wb");
        if (!wf)
        {
            return false;
        }
 
        uint32 chunkSize, count;
        bool result = fwrite(VMAP_MAGIC, 1, 8, wf) == 8;
        if (result && fwrite("WMOD", 1, 4, wf) != 4) { result = false; }
        chunkSize = sizeof(uint32) + sizeof(uint32);
        if (result && fwrite(&chunkSize, sizeof(uint32), 1, wf) != 1) { result = false; }
        if (result && fwrite(&RootWMOID, sizeof(uint32), 1, wf) != 1) { result = false; }
 
        // write group models
        count = groupModels.size();
        if (count)
        {
            if (result && fwrite("GMOD", 1, 4, wf) != 4) { result = false; }
            //chunkSize = sizeof(uint32)+ sizeof(GroupModel)*count;
            //if (result && fwrite(&chunkSize, sizeof(uint32), 1, wf) != 1) result = false;
            if (result && fwrite(&count, sizeof(uint32), 1, wf) != 1) { result = false; }
            for (uint32 i = 0; i < groupModels.size() && result; ++i)
            {
                result = groupModels[i].writeToFile(wf);
            }
 
            // write group BIH
            if (result && fwrite("GBIH", 1, 4, wf) != 4) { result = false; }
            if (result) { result = groupTree.writeToFile(wf); }
        }
 
        fclose(wf);
        return result;
    }