Differential D625 Diff 2018 source/gameengine/GameLogic/SCA_SteeringActuator.cpp

Changeset View

Standalone View

source/gameengine/GameLogic/SCA_SteeringActuator.cpp

This file was moved from source/gameengine/Ketsji/KX_SteeringActuator.cpp.

Show All 22 Lines
*		*
* The Original Code is: all of this file.		* The Original Code is: all of this file.
*		*
* Contributor(s): none yet.		* Contributor(s): none yet.
*		*
* *** END GPL LICENSE BLOCK ***		* *** END GPL LICENSE BLOCK ***
*/		*/

		/** \file gameengine/GameLogic/SCA_SteeringActuator.cpp
		* \ingroup gamelogic
		*/

#include "BLI_math.h"		#include "BLI_math.h"
#include "KX_SteeringActuator.h"		#include "SCA_SteeringActuator.h"
#include "KX_GameObject.h"		#include "KX_GameObject.h"
#include "KX_NavMeshObject.h"		#include "KX_NavMeshObject.h"
#include "KX_ObstacleSimulation.h"		#include "KX_ObstacleSimulation.h"
#include "KX_PythonInit.h"		#include "KX_PythonInit.h"
#include "KX_PyMath.h"		#include "KX_PyMath.h"
#include "Recast.h"		#include "Recast.h"

/* ------------------------------------------------------------------------- */		/* ------------------------------------------------------------------------- */
/* Native functions */		/* Native functions */
/* ------------------------------------------------------------------------- */		/* ------------------------------------------------------------------------- */

KX_SteeringActuator::KX_SteeringActuator(SCA_IObject *gameobj,		SCA_SteeringActuator::SCA_SteeringActuator(SCA_IObject *gameobj,
int mode,		int mode,
KX_GameObject *target,		KX_GameObject *target,
KX_GameObject *navmesh,		KX_GameObject *navmesh,
float distance,		float distance,
float velocity,		float velocity,
float acceleration,		float acceleration,
float turnspeed,		float turnspeed,
bool isSelfTerminated,		bool isSelfTerminated,
int pathUpdatePeriod,		int pathUpdatePeriod,
KX_ObstacleSimulation* simulation,		KX_ObstacleSimulation* simulation,
short facingmode,		short facingmode,
bool normalup,		bool normalup,
bool enableVisualization)		bool enableVisualization)
: SCA_IActuator(gameobj, KX_ACT_STEERING),		: SCA_IActuator(gameobj, SCA_ACT_STEERING),
m_target(target),		m_target(target),
m_mode(mode),		m_mode(mode),
m_distance(distance),		m_distance(distance),
m_velocity(velocity),		m_velocity(velocity),
m_acceleration(acceleration),		m_acceleration(acceleration),
m_turnspeed(turnspeed),		m_turnspeed(turnspeed),
m_simulation(simulation),		m_simulation(simulation),
m_updateTime(0),		m_updateTime(0),
Show All 20 Lines	SCA_SteeringActuator::SCA_SteeringActuator(SCA_IObject *gameobj,
if (m_facingMode>0 && parent)		if (m_facingMode>0 && parent)
{		{
m_parentlocalmat = parent->GetSGNode()->GetLocalOrientation();		m_parentlocalmat = parent->GetSGNode()->GetLocalOrientation();
}		}
else		else
m_parentlocalmat.setIdentity();		m_parentlocalmat.setIdentity();
}		}

KX_SteeringActuator::~KX_SteeringActuator()		SCA_SteeringActuator::~SCA_SteeringActuator()
{		{
if (m_navmesh)		if (m_navmesh)
m_navmesh->UnregisterActuator(this);		m_navmesh->UnregisterActuator(this);
if (m_target)		if (m_target)
m_target->UnregisterActuator(this);		m_target->UnregisterActuator(this);
}		}

CValue* KX_SteeringActuator::GetReplica()		CValue* SCA_SteeringActuator::GetReplica()
{		{
KX_SteeringActuator* replica = new KX_SteeringActuator(*this);		SCA_SteeringActuator* replica = new SCA_SteeringActuator(*this);
// replication just copy the m_base pointer => common random generator		// replication just copy the m_base pointer => common random generator
replica->ProcessReplica();		replica->ProcessReplica();
return replica;		return replica;
}		}

void KX_SteeringActuator::ProcessReplica()		void SCA_SteeringActuator::ProcessReplica()
{		{
if (m_target)		if (m_target)
m_target->RegisterActuator(this);		m_target->RegisterActuator(this);
if (m_navmesh)		if (m_navmesh)
m_navmesh->RegisterActuator(this);		m_navmesh->RegisterActuator(this);
SCA_IActuator::ProcessReplica();		SCA_IActuator::ProcessReplica();
}		}

void KX_SteeringActuator::ReParent(SCA_IObject* parent)		void SCA_SteeringActuator::ReParent(SCA_IObject* parent)
{		{
SCA_IActuator::ReParent(parent);		SCA_IActuator::ReParent(parent);
if (m_simulation)		if (m_simulation)
m_obstacle = m_simulation->GetObstacle((KX_GameObject*)m_gameobj);		m_obstacle = m_simulation->GetObstacle((KX_GameObject*)m_gameobj);
}		}

bool KX_SteeringActuator::UnlinkObject(SCA_IObject* clientobj)		bool SCA_SteeringActuator::UnlinkObject(SCA_IObject* clientobj)
{		{
if (clientobj == m_target)		if (clientobj == m_target)
{		{
m_target = NULL;		m_target = NULL;
return true;		return true;
}		}
else if (clientobj == m_navmesh)		else if (clientobj == m_navmesh)
{		{
m_navmesh = NULL;		m_navmesh = NULL;
return true;		return true;
}		}
return false;		return false;
}		}

void KX_SteeringActuator::Relink(CTR_Map<CTR_HashedPtr, void> obj_map)		void SCA_SteeringActuator::Relink(CTR_Map<CTR_HashedPtr, void> obj_map)
{		{
void *h_obj = (obj_map)[m_target];		void *h_obj = (obj_map)[m_target];
if (h_obj) {		if (h_obj) {
if (m_target)		if (m_target)
m_target->UnregisterActuator(this);		m_target->UnregisterActuator(this);
m_target = (KX_GameObject)(h_obj);		m_target = (KX_GameObject)(h_obj);
m_target->RegisterActuator(this);		m_target->RegisterActuator(this);
}		}

h_obj = (*obj_map)[m_navmesh];		h_obj = (*obj_map)[m_navmesh];
if (h_obj) {		if (h_obj) {
if (m_navmesh)		if (m_navmesh)
m_navmesh->UnregisterActuator(this);		m_navmesh->UnregisterActuator(this);
m_navmesh = (KX_NavMeshObject)(h_obj);		m_navmesh = (KX_NavMeshObject)(h_obj);
m_navmesh->RegisterActuator(this);		m_navmesh->RegisterActuator(this);
}		}
}		}

bool KX_SteeringActuator::Update(double curtime, bool frame)		bool SCA_SteeringActuator::Update(double curtime, bool frame)
{		{
if (frame)		if (frame)
{		{
double delta = curtime - m_updateTime;		double delta = curtime - m_updateTime;
m_updateTime = curtime;		m_updateTime = curtime;

if (m_posevent && !m_isActive)		if (m_posevent && !m_isActive)
{		{
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Lines	if (frame)

if (terminate && m_isSelfTerminated)		if (terminate && m_isSelfTerminated)
return false;		return false;
}		}

return true;		return true;
}		}

const MT_Vector3& KX_SteeringActuator::GetSteeringVec()		const MT_Vector3& SCA_SteeringActuator::GetSteeringVec()
{		{
static MT_Vector3 ZERO_VECTOR(0, 0, 0);		static MT_Vector3 ZERO_VECTOR(0, 0, 0);
if (m_isActive)		if (m_isActive)
return m_steerVec;		return m_steerVec;
else		else
return ZERO_VECTOR;		return ZERO_VECTOR;
}		}

▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines	if (idxMin>=0)
b = tri[2]-tri[0];		b = tri[2]-tri[0];
normal = b.cross(a).safe_normalized();		normal = b.cross(a).safe_normalized();
return true;		return true;
}		}

return false;		return false;
}		}

void KX_SteeringActuator::HandleActorFace(MT_Vector3& velocity)		void SCA_SteeringActuator::HandleActorFace(MT_Vector3& velocity)
{		{
if (m_facingMode==0 && (!m_navmesh \|\| !m_normalUp))		if (m_facingMode==0 && (!m_navmesh \|\| !m_normalUp))
return;		return;
KX_GameObject* curobj = (KX_GameObject*) GetParent();		KX_GameObject* curobj = (KX_GameObject*) GetParent();
MT_Vector3 dir = m_facingMode==0 ? curobj->NodeGetLocalOrientation().getColumn(1) : velocity;		MT_Vector3 dir = m_facingMode==0 ? curobj->NodeGetLocalOrientation().getColumn(1) : velocity;
if (dir.fuzzyZero())		if (dir.fuzzyZero())
return;		return;
dir.normalize();		dir.normalize();
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines

#ifdef WITH_PYTHON		#ifdef WITH_PYTHON

/* ------------------------------------------------------------------------- */		/* ------------------------------------------------------------------------- */
/* Python functions */		/* Python functions */
/* ------------------------------------------------------------------------- */		/* ------------------------------------------------------------------------- */

/* Integration hooks ------------------------------------------------------- */		/* Integration hooks ------------------------------------------------------- */
PyTypeObject KX_SteeringActuator::Type = {		PyTypeObject SCA_SteeringActuator::Type = {
PyVarObject_HEAD_INIT(NULL, 0)		PyVarObject_HEAD_INIT(NULL, 0)
"KX_SteeringActuator",		"SCA_SteeringActuator",
sizeof(PyObjectPlus_Proxy),		sizeof(PyObjectPlus_Proxy),
0,		0,
py_base_dealloc,		py_base_dealloc,
0,		0,
0,		0,
0,		0,
0,		0,
py_base_repr,		py_base_repr,
0,0,0,0,0,0,0,0,0,		0,0,0,0,0,0,0,0,0,
Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE,		Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE,
0,0,0,0,0,0,0,		0,0,0,0,0,0,0,
Methods,		Methods,
0,		0,
0,		0,
&SCA_IActuator::Type,		&SCA_IActuator::Type,
0,0,0,0,0,0,		0,0,0,0,0,0,
py_base_new		py_base_new
};		};

PyMethodDef KX_SteeringActuator::Methods[] = {		PyMethodDef SCA_SteeringActuator::Methods[] = {
{NULL,NULL} //Sentinel		{NULL,NULL} //Sentinel
};		};

PyAttributeDef KX_SteeringActuator::Attributes[] = {		PyAttributeDef SCA_SteeringActuator::Attributes[] = {
KX_PYATTRIBUTE_INT_RW("behavior", KX_STEERING_NODEF+1, KX_STEERING_MAX-1, true, KX_SteeringActuator, m_mode),		KX_PYATTRIBUTE_INT_RW("behavior", KX_STEERING_NODEF+1, KX_STEERING_MAX-1, true, SCA_SteeringActuator, m_mode),
KX_PYATTRIBUTE_RW_FUNCTION("target", KX_SteeringActuator, pyattr_get_target, pyattr_set_target),		KX_PYATTRIBUTE_RW_FUNCTION("target", SCA_SteeringActuator, pyattr_get_target, pyattr_set_target),
KX_PYATTRIBUTE_RW_FUNCTION("navmesh", KX_SteeringActuator, pyattr_get_navmesh, pyattr_set_navmesh),		KX_PYATTRIBUTE_RW_FUNCTION("navmesh", SCA_SteeringActuator, pyattr_get_navmesh, pyattr_set_navmesh),
KX_PYATTRIBUTE_FLOAT_RW("distance", 0.0f, 1000.0f, KX_SteeringActuator, m_distance),		KX_PYATTRIBUTE_FLOAT_RW("distance", 0.0f, 1000.0f, SCA_SteeringActuator, m_distance),
KX_PYATTRIBUTE_FLOAT_RW("velocity", 0.0f, 1000.0f, KX_SteeringActuator, m_velocity),		KX_PYATTRIBUTE_FLOAT_RW("velocity", 0.0f, 1000.0f, SCA_SteeringActuator, m_velocity),
KX_PYATTRIBUTE_FLOAT_RW("acceleration", 0.0f, 1000.0f, KX_SteeringActuator, m_acceleration),		KX_PYATTRIBUTE_FLOAT_RW("acceleration", 0.0f, 1000.0f, SCA_SteeringActuator, m_acceleration),
KX_PYATTRIBUTE_FLOAT_RW("turnspeed", 0.0f, 720.0f, KX_SteeringActuator, m_turnspeed),		KX_PYATTRIBUTE_FLOAT_RW("turnspeed", 0.0f, 720.0f, SCA_SteeringActuator, m_turnspeed),
KX_PYATTRIBUTE_BOOL_RW("selfterminated", KX_SteeringActuator, m_isSelfTerminated),		KX_PYATTRIBUTE_BOOL_RW("selfterminated", SCA_SteeringActuator, m_isSelfTerminated),
KX_PYATTRIBUTE_BOOL_RW("enableVisualization", KX_SteeringActuator, m_enableVisualization),		KX_PYATTRIBUTE_BOOL_RW("enableVisualization", SCA_SteeringActuator, m_enableVisualization),
KX_PYATTRIBUTE_RO_FUNCTION("steeringVec", KX_SteeringActuator, pyattr_get_steeringVec),		KX_PYATTRIBUTE_RO_FUNCTION("steeringVec", SCA_SteeringActuator, pyattr_get_steeringVec),
KX_PYATTRIBUTE_SHORT_RW("facingMode", 0, 6, true, KX_SteeringActuator, m_facingMode),		KX_PYATTRIBUTE_SHORT_RW("facingMode", 0, 6, true, SCA_SteeringActuator, m_facingMode),
KX_PYATTRIBUTE_INT_RW("pathUpdatePeriod", -1, 100000, true, KX_SteeringActuator, m_pathUpdatePeriod),		KX_PYATTRIBUTE_INT_RW("pathUpdatePeriod", -1, 100000, true, SCA_SteeringActuator, m_pathUpdatePeriod),
{ NULL } //Sentinel		{ NULL } //Sentinel
};		};

PyObject KX_SteeringActuator::pyattr_get_target(void self, const struct KX_PYATTRIBUTE_DEF *attrdef)		PyObject SCA_SteeringActuator::pyattr_get_target(void self, const struct KX_PYATTRIBUTE_DEF *attrdef)
{		{
KX_SteeringActuator* actuator = static_cast<KX_SteeringActuator*>(self);		SCA_SteeringActuator* actuator = static_cast<SCA_SteeringActuator*>(self);
if (!actuator->m_target)		if (!actuator->m_target)
Py_RETURN_NONE;		Py_RETURN_NONE;
else		else
return actuator->m_target->GetProxy();		return actuator->m_target->GetProxy();
}		}

int KX_SteeringActuator::pyattr_set_target(void self, const struct KX_PYATTRIBUTE_DEF attrdef, PyObject *value)		int SCA_SteeringActuator::pyattr_set_target(void self, const struct KX_PYATTRIBUTE_DEF attrdef, PyObject *value)
{		{
KX_SteeringActuator* actuator = static_cast<KX_SteeringActuator*>(self);		SCA_SteeringActuator* actuator = static_cast<SCA_SteeringActuator*>(self);
KX_GameObject *gameobj;		KX_GameObject *gameobj;

if (!ConvertPythonToGameObject(value, &gameobj, true, "actuator.object = value: KX_SteeringActuator"))		if (!ConvertPythonToGameObject(value, &gameobj, true, "actuator.object = value: SCA_SteeringActuator"))
return PY_SET_ATTR_FAIL; // ConvertPythonToGameObject sets the error		return PY_SET_ATTR_FAIL; // ConvertPythonToGameObject sets the error

if (actuator->m_target != NULL)		if (actuator->m_target != NULL)
actuator->m_target->UnregisterActuator(actuator);		actuator->m_target->UnregisterActuator(actuator);

actuator->m_target = (KX_GameObject*) gameobj;		actuator->m_target = (KX_GameObject*) gameobj;

if (actuator->m_target)		if (actuator->m_target)
actuator->m_target->RegisterActuator(actuator);		actuator->m_target->RegisterActuator(actuator);

return PY_SET_ATTR_SUCCESS;		return PY_SET_ATTR_SUCCESS;
}		}

PyObject KX_SteeringActuator::pyattr_get_navmesh(void self, const struct KX_PYATTRIBUTE_DEF *attrdef)		PyObject SCA_SteeringActuator::pyattr_get_navmesh(void self, const struct KX_PYATTRIBUTE_DEF *attrdef)
{		{
KX_SteeringActuator* actuator = static_cast<KX_SteeringActuator*>(self);		SCA_SteeringActuator* actuator = static_cast<SCA_SteeringActuator*>(self);
if (!actuator->m_navmesh)		if (!actuator->m_navmesh)
Py_RETURN_NONE;		Py_RETURN_NONE;
else		else
return actuator->m_navmesh->GetProxy();		return actuator->m_navmesh->GetProxy();
}		}

int KX_SteeringActuator::pyattr_set_navmesh(void self, const struct KX_PYATTRIBUTE_DEF attrdef, PyObject *value)		int SCA_SteeringActuator::pyattr_set_navmesh(void self, const struct KX_PYATTRIBUTE_DEF attrdef, PyObject *value)
{		{
KX_SteeringActuator* actuator = static_cast<KX_SteeringActuator*>(self);		SCA_SteeringActuator* actuator = static_cast<SCA_SteeringActuator*>(self);
KX_GameObject *gameobj;		KX_GameObject *gameobj;

if (!ConvertPythonToGameObject(value, &gameobj, true, "actuator.object = value: KX_SteeringActuator"))		if (!ConvertPythonToGameObject(value, &gameobj, true, "actuator.object = value: SCA_SteeringActuator"))
return PY_SET_ATTR_FAIL; // ConvertPythonToGameObject sets the error		return PY_SET_ATTR_FAIL; // ConvertPythonToGameObject sets the error

if (!PyObject_TypeCheck(value, &KX_NavMeshObject::Type))		if (!PyObject_TypeCheck(value, &KX_NavMeshObject::Type))
{		{
PyErr_Format(PyExc_TypeError, "KX_NavMeshObject is expected");		PyErr_Format(PyExc_TypeError, "KX_NavMeshObject is expected");
return PY_SET_ATTR_FAIL;		return PY_SET_ATTR_FAIL;
}		}

if (actuator->m_navmesh != NULL)		if (actuator->m_navmesh != NULL)
actuator->m_navmesh->UnregisterActuator(actuator);		actuator->m_navmesh->UnregisterActuator(actuator);

actuator->m_navmesh = static_cast<KX_NavMeshObject*>(gameobj);		actuator->m_navmesh = static_cast<KX_NavMeshObject*>(gameobj);

if (actuator->m_navmesh)		if (actuator->m_navmesh)
actuator->m_navmesh->RegisterActuator(actuator);		actuator->m_navmesh->RegisterActuator(actuator);

return PY_SET_ATTR_SUCCESS;		return PY_SET_ATTR_SUCCESS;
}		}

PyObject KX_SteeringActuator::pyattr_get_steeringVec(void self, const struct KX_PYATTRIBUTE_DEF *attrdef)		PyObject SCA_SteeringActuator::pyattr_get_steeringVec(void self, const struct KX_PYATTRIBUTE_DEF *attrdef)
{		{
KX_SteeringActuator* actuator = static_cast<KX_SteeringActuator*>(self);		SCA_SteeringActuator* actuator = static_cast<SCA_SteeringActuator*>(self);
const MT_Vector3& steeringVec = actuator->GetSteeringVec();		const MT_Vector3& steeringVec = actuator->GetSteeringVec();
return PyObjectFrom(steeringVec);		return PyObjectFrom(steeringVec);
}		}

#endif // WITH_PYTHON		#endif // WITH_PYTHON

/* eof */		/* eof */