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	intersectRay (const G3D::Ray &Ray, float &MaxDist, bool StopAtFirstHit, uint32 ph_mask) 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 ()
bool	initialize (std::unique_ptr< GameObjectModelOwnerBase > modelOwner, std::string const &dataPath)

Private Attributes
uint32	phasemask
G3D::AABox	iBound
G3D::Matrix3	iInvRot
G3D::Vector3	iPos
float	iInvScale
float	iScale
VMAP::WorldModel *	iModel
std::unique_ptr < GameObjectModelOwnerBase >	owner

Constructor & Destructor Documentation

GameObjectModel::GameObjectModel ( )

inlineprivate

: phasemask(0), iInvScale(0), iScale(0), iModel(NULL) { }

Here is the caller graph for this function:

GameObjectModel::~GameObjectModel

(

)

{
 if (iModel)
 ((VMAP::VMapManager2*)VMAP::VMapFactory::createOrGetVMapManager())->releaseModelInstance(name);
}

Here is the call graph for this function:

Member Function Documentation

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 NULL;
 }

 return mdl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObjectModel::disable ( )

inline

Enables collision.

{ phasemask = 0;}

void GameObjectModel::enable ( uint32  ph_mask )

inline

{ phasemask = ph_mask;}

Here is the caller graph for this function:

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

inline

{ return iBound; }

Here is the caller graph for this function:

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

inline

{ return iPos;}

Here is the caller graph for this function:

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())
 {
 VMAP_ERROR_LOG("misc", "GameObject model %s has zero bounds, loading skipped", it->second.name.c_str());
 return false;
 }

 iModel = ((VMAP::VMapManager2*)VMAP::VMapFactory::createOrGetVMapManager())->acquireModelInstance(dataPath + "vmaps/", it->second.name);

 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);
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
 if (!(phasemask & ph_mask) || !owner->IsSpawned())
 return false;

 float time = ray.intersectionTime(iBound);
 if (time == G3D::finf())
 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);
 if (hit)
 {
 distance *= iScale;
 MaxDist = distance;
 }
 return hit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool GameObjectModel::isEnabled ( ) const

inline

{return phasemask != 0;}

Here is the caller graph for this function:

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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

G3D::AABox GameObjectModel::iBound

private

G3D::Matrix3 GameObjectModel::iInvRot

private

float GameObjectModel::iInvScale

private

VMAP::WorldModel* GameObjectModel::iModel

private

G3D::Vector3 GameObjectModel::iPos

private

float GameObjectModel::iScale

private

std::string GameObjectModel::name

std::unique_ptr<GameObjectModelOwnerBase> GameObjectModel::owner

private

uint32 GameObjectModel::phasemask

private

---

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

• src/common/Collision/Models/GameObjectModel.h
• src/common/Collision/Models/GameObjectModel.cpp