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

Changeset View

Standalone View

source/gameengine/GameLogic/SCA_ReplaceMeshActuator.cpp

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

	Show All 19 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/Ketsji/KX_SCA_ReplaceMeshActuator.cpp			/** \file gameengine/GameLogic/SCA_ReplaceMeshActuator.cpp
	* \ingroup ketsji			* \ingroup gamelogic
	*			*
	* Replace the mesh for this actuator's parent			* Replace the mesh for this actuator's parent
	*/			*/

	//			//
	// Previously existed as:			// Previously existed as:

	// \source\gameengine\GameLogic\SCA_ReplaceMeshActuator.cpp			// \source\gameengine\GameLogic\SCA_ReplaceMeshActuator.cpp

	// Please look here for revision history.			// Please look here for revision history.

	#include <stddef.h>			#include <stddef.h>

	#include "KX_SCA_ReplaceMeshActuator.h"			#include "SCA_ReplaceMeshActuator.h"
	#include "KX_MeshProxy.h"			#include "KX_MeshProxy.h"

	#include "PyObjectPlus.h"			#include "PyObjectPlus.h"


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

				SCA_ReplaceMeshActuator::SCA_ReplaceMeshActuator(SCA_IObject *gameobj,
				class RAS_MeshObject *mesh,
				SCA_IScene* scene,
				bool use_gfx,
				bool use_phys) :

				SCA_IActuator(gameobj, SCA_ACT_REPLACE_MESH),
				m_mesh(mesh),
				m_scene(scene),
				m_use_gfx(use_gfx),
				m_use_phys(use_phys)
				{
				} /* End of constructor */



				SCA_ReplaceMeshActuator::~SCA_ReplaceMeshActuator()
				{
				// there's nothing to be done here, really....
				} /* end of destructor */



				bool SCA_ReplaceMeshActuator::Update()
				{
				// bool result = false; /unused/
				bool bNegativeEvent = IsNegativeEvent();
				RemoveAllEvents();

				if (bNegativeEvent)
				return false; // do nothing on negative events

				if (m_mesh \|\| m_use_phys) /* NULL mesh is ok if were updating physics */
				m_scene->ReplaceMesh(GetParent(),m_mesh, m_use_gfx, m_use_phys);

				return false;
				}



				CValue* SCA_ReplaceMeshActuator::GetReplica()
				{
				SCA_ReplaceMeshActuator* replica = new SCA_ReplaceMeshActuator(*this);

				if (replica == NULL)
				return NULL;

				replica->ProcessReplica();

				return replica;
				}

				void SCA_ReplaceMeshActuator::InstantReplaceMesh()
				{
				if (m_mesh) m_scene->ReplaceMesh(GetParent(),m_mesh, m_use_gfx, m_use_phys);
				}


	#ifdef WITH_PYTHON			#ifdef WITH_PYTHON

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

	/* Integration hooks ------------------------------------------------------- */			/* Integration hooks ------------------------------------------------------- */

	PyTypeObject KX_SCA_ReplaceMeshActuator::Type = {			PyTypeObject SCA_ReplaceMeshActuator::Type = {
	PyVarObject_HEAD_INIT(NULL, 0)			PyVarObject_HEAD_INIT(NULL, 0)
	"KX_SCA_ReplaceMeshActuator",			"SCA_ReplaceMeshActuator",
	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_SCA_ReplaceMeshActuator::Methods[] = {			PyMethodDef SCA_ReplaceMeshActuator::Methods[] = {
	KX_PYMETHODTABLE(KX_SCA_ReplaceMeshActuator, instantReplaceMesh),			KX_PYMETHODTABLE(SCA_ReplaceMeshActuator, instantReplaceMesh),
	{NULL,NULL} //Sentinel			{NULL,NULL} //Sentinel
	};			};

	PyAttributeDef KX_SCA_ReplaceMeshActuator::Attributes[] = {			PyAttributeDef SCA_ReplaceMeshActuator::Attributes[] = {
	KX_PYATTRIBUTE_RW_FUNCTION("mesh", KX_SCA_ReplaceMeshActuator, pyattr_get_mesh, pyattr_set_mesh),			KX_PYATTRIBUTE_RW_FUNCTION("mesh", SCA_ReplaceMeshActuator, pyattr_get_mesh, pyattr_set_mesh),
	KX_PYATTRIBUTE_BOOL_RW ("useDisplayMesh", KX_SCA_ReplaceMeshActuator, m_use_gfx),			KX_PYATTRIBUTE_BOOL_RW ("useDisplayMesh", SCA_ReplaceMeshActuator, m_use_gfx),
	KX_PYATTRIBUTE_BOOL_RW ("usePhysicsMesh", KX_SCA_ReplaceMeshActuator, m_use_phys),			KX_PYATTRIBUTE_BOOL_RW ("usePhysicsMesh", SCA_ReplaceMeshActuator, m_use_phys),
	{ NULL } //Sentinel			{ NULL } //Sentinel
	};			};

	PyObject KX_SCA_ReplaceMeshActuator::pyattr_get_mesh(void self, const struct KX_PYATTRIBUTE_DEF *attrdef)			PyObject SCA_ReplaceMeshActuator::pyattr_get_mesh(void self, const struct KX_PYATTRIBUTE_DEF *attrdef)
	{			{
	KX_SCA_ReplaceMeshActuator* actuator = static_cast<KX_SCA_ReplaceMeshActuator*>(self);			SCA_ReplaceMeshActuator* actuator = static_cast<SCA_ReplaceMeshActuator*>(self);
	if (!actuator->m_mesh)			if (!actuator->m_mesh)
	Py_RETURN_NONE;			Py_RETURN_NONE;
	KX_MeshProxy* meshproxy = new KX_MeshProxy(actuator->m_mesh);			KX_MeshProxy* meshproxy = new KX_MeshProxy(actuator->m_mesh);
	return meshproxy->NewProxy(true);			return meshproxy->NewProxy(true);
	}			}

	int KX_SCA_ReplaceMeshActuator::pyattr_set_mesh(void self, const struct KX_PYATTRIBUTE_DEF attrdef, PyObject *value)			int SCA_ReplaceMeshActuator::pyattr_set_mesh(void self, const struct KX_PYATTRIBUTE_DEF attrdef, PyObject *value)
	{			{
	KX_SCA_ReplaceMeshActuator* actuator = static_cast<KX_SCA_ReplaceMeshActuator*>(self);			SCA_ReplaceMeshActuator* actuator = static_cast<SCA_ReplaceMeshActuator*>(self);
	RAS_MeshObject* new_mesh;			RAS_MeshObject* new_mesh;

	if (!ConvertPythonToMesh(value, &new_mesh, true, "actuator.mesh = value: KX_SCA_ReplaceMeshActuator"))			if (!ConvertPythonToMesh(value, &new_mesh, true, "actuator.mesh = value: SCA_ReplaceMeshActuator"))
	return PY_SET_ATTR_FAIL;			return PY_SET_ATTR_FAIL;

	actuator->m_mesh = new_mesh;			actuator->m_mesh = new_mesh;
	return PY_SET_ATTR_SUCCESS;			return PY_SET_ATTR_SUCCESS;
	}			}

	KX_PYMETHODDEF_DOC(KX_SCA_ReplaceMeshActuator, instantReplaceMesh,			KX_PYMETHODDEF_DOC(SCA_ReplaceMeshActuator, instantReplaceMesh,
	"instantReplaceMesh() : immediately replace mesh without delay\n")			"instantReplaceMesh() : immediately replace mesh without delay\n")
	{			{
	InstantReplaceMesh();			InstantReplaceMesh();
	Py_RETURN_NONE;			Py_RETURN_NONE;
	}			}

	#endif // WITH_PYTHON			#endif // WITH_PYTHON

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

	KX_SCA_ReplaceMeshActuator::KX_SCA_ReplaceMeshActuator(SCA_IObject *gameobj,
	class RAS_MeshObject *mesh,
	SCA_IScene* scene,
	bool use_gfx,
	bool use_phys) :

	SCA_IActuator(gameobj, KX_ACT_REPLACE_MESH),
	m_mesh(mesh),
	m_scene(scene),
	m_use_gfx(use_gfx),
	m_use_phys(use_phys)
	{
	} /* End of constructor */



	KX_SCA_ReplaceMeshActuator::~KX_SCA_ReplaceMeshActuator()
	{
	// there's nothing to be done here, really....
	} /* end of destructor */



	bool KX_SCA_ReplaceMeshActuator::Update()
	{
	// bool result = false; /unused/
	bool bNegativeEvent = IsNegativeEvent();
	RemoveAllEvents();

	if (bNegativeEvent)
	return false; // do nothing on negative events

	if (m_mesh \|\| m_use_phys) /* NULL mesh is ok if were updating physics */
	m_scene->ReplaceMesh(GetParent(),m_mesh, m_use_gfx, m_use_phys);

	return false;
	}



	CValue* KX_SCA_ReplaceMeshActuator::GetReplica()
	{
	KX_SCA_ReplaceMeshActuator* replica =
	new KX_SCA_ReplaceMeshActuator(*this);

	if (replica == NULL)
	return NULL;

	replica->ProcessReplica();

	return replica;
	};

	void KX_SCA_ReplaceMeshActuator::InstantReplaceMesh()
	{
	if (m_mesh) m_scene->ReplaceMesh(GetParent(),m_mesh, m_use_gfx, m_use_phys);
	}

	/* eof */			/* eof */