GameObjectModel Class Reference

#include "GameObjectModel.h"

Public Member Functions
const G3D::AABox &	GetBounds () const
	~GameObjectModel ()
const G3D::Vector3 &	GetPosition () const
void	disable ()
void	enable (uint32 ph_mask)
bool	isEnabled () const
bool	IsMapObject () const
bool	intersectRay (const G3D::Ray &Ray, float &MaxDist, bool StopAtFirstHit, uint32 ph_mask, VMAP::ModelIgnoreFlags ignoreFlags) const
void	IntersectPoint (G3D::Vector3 const &point, VMAP::AreaInfo &info, uint32 ph_mask) const
bool	GetLocationInfo (G3D::Vector3 const &point, VMAP::LocationInfo &info, uint32 ph_mask) const
bool	GetLiquidLevel (G3D::Vector3 const &point, VMAP::LocationInfo &info, float &liqHeight) const
bool	UpdatePosition ()

Static Public Member Functions
static GameObjectModel *	Create (std::unique_ptr< GameObjectModelOwnerBase > modelOwner, std::string const &dataPath)

Public Attributes
std::string	name

Private Member Functions
	GameObjectModel ()=default
bool	initialize (std::unique_ptr< GameObjectModelOwnerBase > modelOwner, std::string const &dataPath)

Private Attributes
uint32	phasemask {0}
G3D::AABox	iBound
G3D::Matrix3	iInvRot
G3D::Vector3	iPos
float	iInvScale {0}
float	iScale {0}
VMAP::WorldModel *	iModel {nullptr}
std::unique_ptr< GameObjectModelOwnerBase >	owner
bool	isWmo {false}

Detailed Description

Constructor & Destructor Documentation

GameObjectModel()

GameObjectModel::GameObjectModel ( )

privatedefault

Referenced by Create().

~GameObjectModel()

GameObjectModel::~GameObjectModel

(

)

{
    if (iModel)
    {
        VMAP::VMapFactory::createOrGetVMapMgr()->releaseModelInstance(name);
    }
}

References VMAP::VMapFactory::createOrGetVMapMgr(), iModel, name, and VMAP::VMapMgr2::releaseModelInstance().

Member Function Documentation

Create()

GameObjectModel * GameObjectModel::Create ( std::unique_ptr< GameObjectModelOwnerBase >  modelOwner, std::string const &  dataPath  )

static

{
    GameObjectModel* mdl = new GameObjectModel();
    if (!mdl->initialize(std::move(modelOwner), dataPath))
    {
        delete mdl;
        return nullptr;
    }
 
    return mdl;
}

References GameObjectModel(), and initialize().

Referenced by GameObject::CreateModel().

disable()

void GameObjectModel::disable ( )

inline

Enables\disables collision.

{ phasemask = 0; }

References phasemask.

enable()

void GameObjectModel::enable ( uint32  ph_mask )

inline

{ phasemask = ph_mask; }

References phasemask.

Referenced by GameObject::EnableCollision().

GetBounds()

const G3D::AABox & GameObjectModel::GetBounds ( ) const

inline

{ return iBound; }

References iBound.

Referenced by BoundsTrait< GameObjectModel >::GetBounds(), and BoundsTrait< GameObjectModel >::GetBounds2().

GetLiquidLevel()

bool GameObjectModel::GetLiquidLevel	(	G3D::Vector3 const &	point,
		VMAP::LocationInfo &	info,
		float &	liqHeight
	)		const

{
    // child bounds are defined in object space:
    Vector3 pModel = iInvRot * (point - 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, iPos, and iScale.

Referenced by DynamicMapTree::GetAreaAndLiquidData().

GetLocationInfo()

bool GameObjectModel::GetLocationInfo	(	G3D::Vector3 const &	point,
		VMAP::LocationInfo &	info,
		uint32	ph_mask
	)		const

{
    if (!(phasemask & ph_mask) || !owner->IsSpawned() || !IsMapObject())
        return false;
 
    if (!iBound.contains(point))
        return false;
 
    // child bounds are defined in object space:
    Vector3 pModel = iInvRot * (point - 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;
        float world_Z = ((modelGround * iInvRot) * iScale + iPos).z;
        if (info.ground_Z < world_Z)
        {
            info.ground_Z = world_Z;
            return true;
        }
    }
 
    return false;
}

References VMAP::WorldModel::GetLocationInfo(), VMAP::LocationInfo::ground_Z, iBound, iInvRot, iInvScale, iModel, iPos, iScale, IsMapObject(), owner, and phasemask.

Referenced by DynamicTreeLocationInfoCallback::operator()().

GetPosition()

const G3D::Vector3 & GameObjectModel::GetPosition ( ) const

inline

{ return iPos; }

References iPos.

Referenced by PositionTrait< GameObjectModel >::GetPosition().

initialize()

bool GameObjectModel::initialize ( std::unique_ptr< GameObjectModelOwnerBase >  modelOwner, std::string const &  dataPath  )

private

{
    ModelList::const_iterator it = model_list.find(modelOwner->GetDisplayId());
    if (it == model_list.end())
    {
        return false;
    }
 
    G3D::AABox mdl_box(it->second.bound);
    // ignore models with no bounds
    if (mdl_box == G3D::AABox::zero())
    {
        LOG_ERROR("maps", "GameObject model {} has zero bounds, loading skipped", it->second.name);
        return false;
    }
 
    iModel = VMAP::VMapFactory::createOrGetVMapMgr()->acquireModelInstance(dataPath + "vmaps/", it->second.name,
        it->second.isWmo ? VMAP::ModelFlags::MOD_WORLDSPAWN : VMAP::ModelFlags::MOD_M2);
 
    if (!iModel)
    {
        return false;
    }
 
    name = it->second.name;
    iPos = modelOwner->GetPosition();
    phasemask = modelOwner->GetPhaseMask();
    iScale = modelOwner->GetScale();
    iInvScale = 1.f / iScale;
 
    G3D::Matrix3 iRotation = G3D::Matrix3::fromEulerAnglesZYX(modelOwner->GetOrientation(), 0, 0);
    iInvRot = iRotation.inverse();
    // transform bounding box:
    mdl_box = AABox(mdl_box.low() * iScale, mdl_box.high() * iScale);
    AABox rotated_bounds;
    for (int i = 0; i < 8; ++i)
    {
        rotated_bounds.merge(iRotation * mdl_box.corner(i));
    }
 
    iBound = rotated_bounds + iPos;
 
#ifdef SPAWN_CORNERS
    // test:
    for (int i = 0; i < 8; ++i)
    {
        Vector3 pos(iBound.corner(i));
        modelOwner->DebugVisualizeCorner(pos);
    }
#endif
 
    owner = std::move(modelOwner);
    isWmo = it->second.isWmo;
    return true;
}

References VMAP::VMapMgr2::acquireModelInstance(), VMAP::VMapFactory::createOrGetVMapMgr(), iBound, iInvRot, iInvScale, iModel, iPos, iScale, isWmo, LOG_ERROR, VMAP::MOD_M2, VMAP::MOD_WORLDSPAWN, model_list, name, owner, and phasemask.

Referenced by Create().

IntersectPoint()

void GameObjectModel::IntersectPoint	(	G3D::Vector3 const &	point,
		VMAP::AreaInfo &	info,
		uint32	ph_mask
	)		const

{
    if (!(phasemask & ph_mask) || !owner->IsSpawned() || !IsMapObject())
        return;
 
    if (!iBound.contains(point))
        return;
 
    // child bounds are defined in object space:
    Vector3 pModel = iInvRot * (point - 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;
        float world_Z = ((modelGround * iInvRot) * iScale + iPos).z;
        if (info.ground_Z < world_Z)
            info.ground_Z = world_Z;
    }
}

References VMAP::AreaInfo::ground_Z, iBound, iInvRot, iInvScale, iModel, VMAP::WorldModel::IntersectPoint(), iPos, iScale, IsMapObject(), owner, and phasemask.

Referenced by DynamicTreeAreaInfoCallback::operator()().

intersectRay()

bool GameObjectModel::intersectRay	(	const G3D::Ray &	Ray,
		float &	MaxDist,
		bool	StopAtFirstHit,
		uint32	ph_mask,
		VMAP::ModelIgnoreFlags	ignoreFlags
	)		const

{
    if (!(phasemask & ph_mask) || !owner->IsSpawned())
    {
        return false;
    }
 
    float time = ray.intersectionTime(iBound);
    if (time == G3D::inf())
    {
        return false;
    }
 
    // child bounds are defined in object space:
    Vector3 p = iInvRot * (ray.origin() - iPos) * iInvScale;
    Ray modRay(p, iInvRot * ray.direction());
    float distance = MaxDist * iInvScale;
    bool hit = iModel->IntersectRay(modRay, distance, StopAtFirstHit, ignoreFlags);
    if (hit)
    {
        distance *= iScale;
        MaxDist = distance;
    }
    return hit;
}

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

Referenced by DynamicTreeIntersectionCallback::operator()().

isEnabled()

bool GameObjectModel::isEnabled ( ) const

inline

{ return phasemask != 0; }

References phasemask.

Referenced by GameObject::SetPhaseMask().

IsMapObject()

bool GameObjectModel::IsMapObject ( ) const

inline

{ return isWmo; }

References isWmo.

Referenced by GetLocationInfo(), and IntersectPoint().

UpdatePosition()

bool GameObjectModel::UpdatePosition

(

)

{
    if (!iModel)
    {
        return false;
    }
 
    ModelList::const_iterator it = model_list.find(owner->GetDisplayId());
    if (it == model_list.end())
    {
        return false;
    }
 
    G3D::AABox mdl_box(it->second.bound);
 
    // ignore models with no bounds
    if (mdl_box == G3D::AABox::zero())
    {
        //VMAP_ERROR_LOG("misc", "GameObject model %s has zero bounds, loading skipped", it->second.name.c_str());
        return false;
    }
 
    iPos = owner->GetPosition();
    G3D::Matrix3 iRotation = G3D::Matrix3::fromEulerAnglesZYX(owner->GetOrientation(), 0, 0);
    iInvRot = iRotation.inverse();
 
    // transform bounding box:
    mdl_box = AABox(mdl_box.low() * iScale, mdl_box.high() * iScale);
    AABox rotated_bounds;
 
    for (int i = 0; i < 8; ++i)
    {
        rotated_bounds.merge(iRotation * mdl_box.corner(i));
    }
 
    iBound = rotated_bounds + iPos;
#ifdef SPAWN_CORNERS
    // test:
    for (int i = 0; i < 8; ++i)
    {
        Vector3 pos(iBound.corner(i));
        owner->DebugVisualizeCorner(pos);
    }
#endif
 
    return true;
}

References iBound, iInvRot, iModel, iPos, iScale, model_list, and owner.

Referenced by GameObject::AddToWorld(), and GameObject::UpdateModelPosition().

Member Data Documentation

iBound

G3D::AABox GameObjectModel::iBound

private

Referenced by GetBounds(), GetLocationInfo(), initialize(), IntersectPoint(), intersectRay(), and UpdatePosition().

iInvRot

G3D::Matrix3 GameObjectModel::iInvRot

private

Referenced by GetLiquidLevel(), GetLocationInfo(), initialize(), IntersectPoint(), intersectRay(), and UpdatePosition().

iInvScale

float GameObjectModel::iInvScale {0}

private

Referenced by GetLiquidLevel(), GetLocationInfo(), initialize(), IntersectPoint(), and intersectRay().

iModel

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

private

Referenced by GetLocationInfo(), initialize(), IntersectPoint(), intersectRay(), UpdatePosition(), and ~GameObjectModel().

iPos

G3D::Vector3 GameObjectModel::iPos

private

Referenced by GetLiquidLevel(), GetLocationInfo(), GetPosition(), initialize(), IntersectPoint(), intersectRay(), and UpdatePosition().

iScale

float GameObjectModel::iScale {0}

private

Referenced by GetLiquidLevel(), GetLocationInfo(), initialize(), IntersectPoint(), intersectRay(), and UpdatePosition().

isWmo

bool GameObjectModel::isWmo {false}

private

Referenced by initialize(), and IsMapObject().

name

std::string GameObjectModel::name

Referenced by initialize(), and ~GameObjectModel().

owner

std::unique_ptr<GameObjectModelOwnerBase> GameObjectModel::owner

private

Referenced by GetLocationInfo(), initialize(), IntersectPoint(), intersectRay(), and UpdatePosition().

phasemask

uint32 GameObjectModel::phasemask {0}

private

Referenced by disable(), enable(), GetLocationInfo(), initialize(), IntersectPoint(), intersectRay(), and isEnabled().