blender/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp

286 lines
8.2 KiB
C++
Raw Normal View History

/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
2011-02-25 13:35:59 +00:00
/** \file gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp
* \ingroup ketsji
*
* Add an object when this actuator is triggered
2011-02-25 13:35:59 +00:00
*/
2002-10-12 11:37:38 +00:00
/* Previously existed as:
* \source\gameengine\GameLogic\SCA_AddObjectActuator.cpp
* Please look here for revision history. */
2002-10-12 11:37:38 +00:00
#include "KX_SCA_AddObjectActuator.h"
#include "SCA_IScene.h"
#include "KX_GameObject.h"
#include "KX_IPhysicsController.h"
#include "PyObjectPlus.h"
2002-10-12 11:37:38 +00:00
/* ------------------------------------------------------------------------- */
/* Native functions */
/* ------------------------------------------------------------------------- */
KX_SCA_AddObjectActuator::KX_SCA_AddObjectActuator(SCA_IObject *gameobj,
SCA_IObject *original,
2002-10-12 11:37:38 +00:00
int time,
SCA_IScene* scene,
const float *linvel,
bool linv_local,
const float *angvel,
bool angv_local)
2002-10-12 11:37:38 +00:00
:
SCA_IActuator(gameobj, KX_ACT_ADD_OBJECT),
2002-10-12 11:37:38 +00:00
m_OriginalObject(original),
m_scene(scene),
m_localLinvFlag(linv_local),
m_localAngvFlag(angv_local)
2002-10-12 11:37:38 +00:00
{
m_linear_velocity[0] = linvel[0];
m_linear_velocity[1] = linvel[1];
m_linear_velocity[2] = linvel[2];
m_angular_velocity[0] = angvel[0];
m_angular_velocity[1] = angvel[1];
m_angular_velocity[2] = angvel[2];
if (m_OriginalObject)
m_OriginalObject->RegisterActuator(this);
2002-10-12 11:37:38 +00:00
m_lastCreatedObject = NULL;
m_timeProp = time;
}
KX_SCA_AddObjectActuator::~KX_SCA_AddObjectActuator()
{
if (m_OriginalObject)
m_OriginalObject->UnregisterActuator(this);
2002-10-12 11:37:38 +00:00
if (m_lastCreatedObject)
m_lastCreatedObject->UnregisterActuator(this);
2002-10-12 11:37:38 +00:00
}
bool KX_SCA_AddObjectActuator::Update()
2002-10-12 11:37:38 +00:00
{
//bool result = false; /*unused*/
2002-10-12 11:37:38 +00:00
bool bNegativeEvent = IsNegativeEvent();
RemoveAllEvents();
if (bNegativeEvent) return false; // do nothing on negative events
InstantAddObject();
2002-10-12 11:37:38 +00:00
2002-10-12 11:37:38 +00:00
return false;
}
2002-10-12 11:37:38 +00:00
SCA_IObject* KX_SCA_AddObjectActuator::GetLastCreatedObject() const
{
return m_lastCreatedObject;
}
CValue* KX_SCA_AddObjectActuator::GetReplica()
{
KX_SCA_AddObjectActuator* replica = new KX_SCA_AddObjectActuator(*this);
if (replica == NULL)
return NULL;
// this will copy properties and so on...
replica->ProcessReplica();
return replica;
}
void KX_SCA_AddObjectActuator::ProcessReplica()
{
if (m_OriginalObject)
m_OriginalObject->RegisterActuator(this);
m_lastCreatedObject=NULL;
SCA_IActuator::ProcessReplica();
}
bool KX_SCA_AddObjectActuator::UnlinkObject(SCA_IObject* clientobj)
{
if (clientobj == m_OriginalObject)
{
// this object is being deleted, we cannot continue to track it.
m_OriginalObject = NULL;
return true;
}
if (clientobj == m_lastCreatedObject)
{
// this object is being deleted, we cannot continue to track it.
m_lastCreatedObject = NULL;
return true;
}
return false;
}
2002-10-12 11:37:38 +00:00
void KX_SCA_AddObjectActuator::Relink(CTR_Map<CTR_HashedPtr, void*> *obj_map)
{
void **h_obj = (*obj_map)[m_OriginalObject];
if (h_obj) {
if (m_OriginalObject)
m_OriginalObject->UnregisterActuator(this);
m_OriginalObject = (SCA_IObject*)(*h_obj);
m_OriginalObject->RegisterActuator(this);
}
}
#ifdef WITH_PYTHON
2002-10-12 11:37:38 +00:00
/* ------------------------------------------------------------------------- */
/* Python functions */
/* ------------------------------------------------------------------------- */
/* Integration hooks ------------------------------------------------------- */
PyTypeObject KX_SCA_AddObjectActuator::Type = {
PyVarObject_HEAD_INIT(NULL, 0)
2002-10-12 11:37:38 +00:00
"KX_SCA_AddObjectActuator",
sizeof(PyObjectPlus_Proxy),
2002-10-12 11:37:38 +00:00
0,
py_base_dealloc,
2002-10-12 11:37:38 +00:00
0,
0,
0,
0,
py_base_repr,
0,0,0,0,0,0,0,0,0,
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
0,0,0,0,0,0,0,
Methods,
0,
0,
&SCA_IActuator::Type,
0,0,0,0,0,0,
py_base_new
2002-10-12 11:37:38 +00:00
};
PyMethodDef KX_SCA_AddObjectActuator::Methods[] = {
{"instantAddObject", (PyCFunction) KX_SCA_AddObjectActuator::sPyInstantAddObject, METH_NOARGS, NULL},
{NULL,NULL} //Sentinel
2002-10-12 11:37:38 +00:00
};
PyAttributeDef KX_SCA_AddObjectActuator::Attributes[] = {
KX_PYATTRIBUTE_RW_FUNCTION("object",KX_SCA_AddObjectActuator,pyattr_get_object,pyattr_set_object),
KX_PYATTRIBUTE_RO_FUNCTION("objectLastCreated",KX_SCA_AddObjectActuator,pyattr_get_objectLastCreated),
KX_PYATTRIBUTE_INT_RW("time",0,2000,true,KX_SCA_AddObjectActuator,m_timeProp),
KX_PYATTRIBUTE_FLOAT_ARRAY_RW("linearVelocity",-FLT_MAX,FLT_MAX,KX_SCA_AddObjectActuator,m_linear_velocity,3),
KX_PYATTRIBUTE_FLOAT_ARRAY_RW("angularVelocity",-FLT_MAX,FLT_MAX,KX_SCA_AddObjectActuator,m_angular_velocity,3),
{ NULL } //Sentinel
};
2002-10-12 11:37:38 +00:00
2012-09-16 04:58:18 +00:00
PyObject *KX_SCA_AddObjectActuator::pyattr_get_object(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
2002-10-12 11:37:38 +00:00
{
KX_SCA_AddObjectActuator* actuator = static_cast<KX_SCA_AddObjectActuator*>(self);
2012-09-16 04:58:18 +00:00
if (!actuator->m_OriginalObject)
Py_RETURN_NONE;
else
return actuator->m_OriginalObject->GetProxy();
2002-10-12 11:37:38 +00:00
}
int KX_SCA_AddObjectActuator::pyattr_set_object(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
{
KX_SCA_AddObjectActuator* actuator = static_cast<KX_SCA_AddObjectActuator*>(self);
KX_GameObject *gameobj;
if (!ConvertPythonToGameObject(value, &gameobj, true, "actuator.object = value: KX_SCA_AddObjectActuator"))
return PY_SET_ATTR_FAIL; // ConvertPythonToGameObject sets the error
if (actuator->m_OriginalObject != NULL)
2012-09-16 04:58:18 +00:00
actuator->m_OriginalObject->UnregisterActuator(actuator);
actuator->m_OriginalObject = (SCA_IObject*)gameobj;
if (actuator->m_OriginalObject)
actuator->m_OriginalObject->RegisterActuator(actuator);
return PY_SET_ATTR_SUCCESS;
}
2012-09-16 04:58:18 +00:00
PyObject *KX_SCA_AddObjectActuator::pyattr_get_objectLastCreated(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
{
KX_SCA_AddObjectActuator* actuator = static_cast<KX_SCA_AddObjectActuator*>(self);
if (!actuator->m_lastCreatedObject)
Py_RETURN_NONE;
else
return actuator->m_lastCreatedObject->GetProxy();
}
2012-09-16 04:58:18 +00:00
PyObject *KX_SCA_AddObjectActuator::PyInstantAddObject()
{
InstantAddObject();
Py_RETURN_NONE;
}
#endif // WITH_PYTHON
2002-10-12 11:37:38 +00:00
void KX_SCA_AddObjectActuator::InstantAddObject()
{
if (m_OriginalObject)
{
2012-09-16 04:58:18 +00:00
// Add an identical object, with properties inherited from the original object
// Now it needs to be added to the current scene.
SCA_IObject* replica = m_scene->AddReplicaObject(m_OriginalObject,GetParent(),m_timeProp );
KX_GameObject * game_obj = static_cast<KX_GameObject *>(replica);
game_obj->setLinearVelocity(m_linear_velocity, m_localLinvFlag);
game_obj->setAngularVelocity(m_angular_velocity,m_localAngvFlag);
game_obj->ResolveCombinedVelocities(m_linear_velocity, m_angular_velocity, m_localLinvFlag, m_localAngvFlag);
// keep a copy of the last object, to allow python scripters to change it
if (m_lastCreatedObject)
{
//Let's not keep a reference to the object: it's bad, if the object is deleted
//this will force to keep a "zombie" in the game for no good reason.
//m_scene->DelayedReleaseObject(m_lastCreatedObject);
//m_lastCreatedObject->Release();
//Instead we use the registration mechanism
m_lastCreatedObject->UnregisterActuator(this);
m_lastCreatedObject = NULL;
}
m_lastCreatedObject = replica;
// no reference
//m_lastCreatedObject->AddRef();
// but registration
m_lastCreatedObject->RegisterActuator(this);
// finished using replica? then release it
replica->Release();
}
}