VMAP::ModelInstance Class Reference

#include "ModelInstance.h"

Inheritance diagram for VMAP::ModelInstance:

Public Member Functions
	ModelInstance ()
	ModelInstance (const ModelSpawn &spawn, WorldModel *model)
void	setUnloaded ()
bool	intersectRay (const G3D::Ray &pRay, float &pMaxDist, bool StopAtFirstHit, ModelIgnoreFlags ignoreFlags) const
void	intersectPoint (const G3D::Vector3 &p, AreaInfo &info) const
bool	GetLocationInfo (const G3D::Vector3 &p, LocationInfo &info) const
bool	GetLiquidLevel (const G3D::Vector3 &p, LocationInfo &info, float &liqHeight) const
WorldModel *	getWorldModel ()
Public Member Functions inherited from VMAP::ModelSpawn
bool	operator== (const ModelSpawn &other) const
const G3D::AABox &	GetBounds () const

Protected Attributes
G3D::Matrix3	iInvRot
float	iInvScale {0.0f}
WorldModel *	iModel {nullptr}

Additional Inherited Members
Static Public Member Functions inherited from VMAP::ModelSpawn
static bool	readFromFile (FILE *rf, ModelSpawn &spawn)
static bool	writeToFile (FILE *rw, const ModelSpawn &spawn)
Public Attributes inherited from VMAP::ModelSpawn
uint32	flags
uint16	adtId
uint32	ID
G3D::Vector3	iPos
G3D::Vector3	iRot
float	iScale
G3D::AABox	iBound
std::string	name

Detailed Description

Constructor & Destructor Documentation

ModelInstance() [1/2]

VMAP::ModelInstance::ModelInstance ( )

inline

{ }

ModelInstance() [2/2]

VMAP::ModelInstance::ModelInstance	(	const ModelSpawn &	spawn,
		WorldModel *	model
	)

                                                                          : ModelSpawn(spawn), iModel(model)
    {
        iInvRot = G3D::Matrix3::fromEulerAnglesZYX(G3D::pi() * iRot.y / 180.f, G3D::pi() * iRot.x / 180.f, G3D::pi() * iRot.z / 180.f).inverse();
        iInvScale = 1.f / iScale;
    }

References iInvRot, iInvScale, VMAP::ModelSpawn::iRot, and VMAP::ModelSpawn::iScale.

Member Function Documentation

GetLiquidLevel()

bool VMAP::ModelInstance::GetLiquidLevel	(	const G3D::Vector3 &	p,
		LocationInfo &	info,
		float &	liqHeight
	)		const

    {
        // child bounds are defined in object space:
        Vector3 pModel = iInvRot * (p - iPos) * iInvScale;
        //Vector3 zDirModel = iInvRot * Vector3(0.f, 0.f, -1.f);
        float zDist;
        if (info.hitModel->GetLiquidLevel(pModel, zDist))
        {
            // calculate world height (zDist in model coords):
            // assume WMO not tilted (wouldn't make much sense anyway)
            liqHeight = zDist * iScale + iPos.z;
            return true;
        }
        return false;
    }

References VMAP::GroupModel::GetLiquidLevel(), VMAP::LocationInfo::hitModel, iInvRot, iInvScale, VMAP::ModelSpawn::iPos, and VMAP::ModelSpawn::iScale.

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

GetLocationInfo()

bool VMAP::ModelInstance::GetLocationInfo	(	const G3D::Vector3 &	p,
		LocationInfo &	info
	)		const

    {
        if (!iModel)
        {
#ifdef VMAP_DEBUG
            std::cout << "<object not loaded>\n";
#endif
            return false;
        }
 
        // M2 files don't contain area info, only WMO files
        if (flags & MOD_M2)
        {
            return false;
        }
        if (!iBound.contains(p))
        {
            return false;
        }
        // child bounds are defined in object space:
        Vector3 pModel = iInvRot * (p - iPos) * iInvScale;
        Vector3 zDirModel = iInvRot * Vector3(0.f, 0.f, -1.f);
        float zDist;
        if (iModel->GetLocationInfo(pModel, zDirModel, zDist, info))
        {
            Vector3 modelGround = pModel + zDist * zDirModel;
            // Transform back to world space. Note that:
            // Mat * vec == vec * Mat.transpose()
            // and for rotation matrices: Mat.inverse() == Mat.transpose()
            float world_Z = ((modelGround * iInvRot) * iScale + iPos).z;
            if (info.ground_Z < world_Z) // hm...could it be handled automatically with zDist at intersection?
            {
                info.ground_Z = world_Z;
                info.hitInstance = this;
                return true;
            }
        }
        return false;
    }

References VMAP::ModelSpawn::flags, VMAP::WorldModel::GetLocationInfo(), VMAP::LocationInfo::ground_Z, VMAP::LocationInfo::hitInstance, VMAP::ModelSpawn::iBound, iInvRot, iInvScale, iModel, VMAP::ModelSpawn::iPos, VMAP::ModelSpawn::iScale, and VMAP::MOD_M2.

getWorldModel()

WorldModel * VMAP::ModelInstance::getWorldModel ( )

inline

{ return iModel; }

References iModel.

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

intersectPoint()

void VMAP::ModelInstance::intersectPoint	(	const G3D::Vector3 &	p,
		AreaInfo &	info
	)		const

    {
        if (!iModel)
        {
#ifdef VMAP_DEBUG
            std::cout << "<object not loaded>\n";
#endif
            return;
        }
 
        // M2 files don't contain area info, only WMO files
        if (flags & MOD_M2)
        {
            return;
        }
        if (!iBound.contains(p))
        {
            return;
        }
        // child bounds are defined in object space:
        Vector3 pModel = iInvRot * (p - iPos) * iInvScale;
        Vector3 zDirModel = iInvRot * Vector3(0.f, 0.f, -1.f);
        float zDist;
        if (iModel->IntersectPoint(pModel, zDirModel, zDist, info))
        {
            Vector3 modelGround = pModel + zDist * zDirModel;
            // Transform back to world space. Note that:
            // Mat * vec == vec * Mat.transpose()
            // and for rotation matrices: Mat.inverse() == Mat.transpose()
            float world_Z = ((modelGround * iInvRot) * iScale + iPos).z;
            if (info.ground_Z < world_Z)
            {
                info.ground_Z = world_Z;
                info.adtId = adtId;
            }
        }
    }

References VMAP::AreaInfo::adtId, VMAP::ModelSpawn::adtId, VMAP::ModelSpawn::flags, VMAP::AreaInfo::ground_Z, VMAP::ModelSpawn::iBound, iInvRot, iInvScale, iModel, VMAP::WorldModel::IntersectPoint(), VMAP::ModelSpawn::iPos, VMAP::ModelSpawn::iScale, and VMAP::MOD_M2.

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

intersectRay()

bool VMAP::ModelInstance::intersectRay	(	const G3D::Ray &	pRay,
		float &	pMaxDist,
		bool	StopAtFirstHit,
		ModelIgnoreFlags	ignoreFlags
	)		const

    {
        if (!iModel)
        {
            //std::cout << "<object not loaded>\n";
            return false;
        }
        float time = pRay.intersectionTime(iBound);
        if (time == G3D::inf())
        {
            //            std::cout << "Ray does not hit '" << name << "'\n";
 
            return false;
        }
        //        std::cout << "Ray crosses bound of '" << name << "'\n";
        /*        std::cout << "ray from:" << pRay.origin().x << ", " << pRay.origin().y << ", " << pRay.origin().z
                          << " dir:" << pRay.direction().x << ", " << pRay.direction().y << ", " << pRay.direction().z
                          << " t/tmax:" << time << '/' << pMaxDist;
                std::cout << "\nBound lo:" << iBound.low().x << ", " << iBound.low().y << ", " << iBound.low().z << " hi: "
                          << iBound.high().x << ", " << iBound.high().y << ", " << iBound.high().z << std::endl; */
        // child bounds are defined in object space:
        Vector3 p = iInvRot * (pRay.origin() - iPos) * iInvScale;
        Ray modRay(p, iInvRot * pRay.direction());
        float distance = pMaxDist * iInvScale;
        bool hit = iModel->IntersectRay(modRay, distance, StopAtFirstHit, ignoreFlags);
        if (hit)
        {
            distance *= iScale;
            pMaxDist = distance;
        }
        return hit;
    }

References VMAP::ModelSpawn::iBound, iInvRot, iInvScale, iModel, VMAP::WorldModel::IntersectRay(), VMAP::ModelSpawn::iPos, and VMAP::ModelSpawn::iScale.

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

setUnloaded()

void VMAP::ModelInstance::setUnloaded ( )

inline

{ iModel = nullptr; }

References iModel.

Referenced by VMAP::StaticMapTree::UnloadMap(), and VMAP::StaticMapTree::UnloadMapTile().

Member Data Documentation

iInvRot

G3D::Matrix3 VMAP::ModelInstance::iInvRot

protected

Referenced by GetLiquidLevel(), GetLocationInfo(), intersectPoint(), intersectRay(), and ModelInstance().

iInvScale

float VMAP::ModelInstance::iInvScale {0.0f}

protected

Referenced by GetLiquidLevel(), GetLocationInfo(), intersectPoint(), intersectRay(), and ModelInstance().

iModel

WorldModel* VMAP::ModelInstance::iModel {nullptr}

protected

Referenced by GetLocationInfo(), getWorldModel(), intersectPoint(), intersectRay(), and setUnloaded().