CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfPython/pySceneObjectGlue.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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 3 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, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "pySceneObject.h"
#include "pyMatrix44.h"
#include "pyGeometry3.h"

#include <python.h>

// glue functions
PYTHON_CLASS_DEFINITION(ptSceneobject, pySceneObject);

PYTHON_DEFAULT_NEW_DEFINITION(ptSceneobject, pySceneObject)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptSceneobject)

PYTHON_INIT_DEFINITION(ptSceneobject, args, keywords)
{
	PyObject *objKeyObject = NULL;
	PyObject *selfKeyObject = NULL;
	if (!PyArg_ParseTuple(args, "OO", &objKeyObject, &selfKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "init expects two ptKey objects");
		PYTHON_RETURN_INIT_ERROR;
	}
	if ((!pyKey::Check(objKeyObject))||(!pyKey::Check(selfKeyObject)))
	{
		PyErr_SetString(PyExc_TypeError, "init expects two ptKey objects");
		PYTHON_RETURN_INIT_ERROR;
	}

	pyKey *objKey = pyKey::ConvertFrom(objKeyObject);
	pyKey *selfKey = pyKey::ConvertFrom(selfKeyObject);
	self->fThis->addObjKey(objKey->getKey());
	self->fThis->setSenderKey(selfKey->getKey());
	self->fThis->setPyMod(*selfKey);

	PYTHON_RETURN_INIT_OK;
}

PYTHON_RICH_COMPARE_DEFINITION(ptSceneobject, obj1, obj2, compareType)
{
	if ((obj1 == Py_None) || (obj2 == Py_None) || !pySceneObject::Check(obj1) || !pySceneObject::Check(obj2))
	{
		// if they aren't the same type, they don't match, obviously (we also never equal none)
		if (compareType == Py_EQ)
			PYTHON_RCOMPARE_FALSE;
		else if (compareType == Py_NE)
			PYTHON_RCOMPARE_TRUE;
		else
		{
			PyErr_SetString(PyExc_NotImplementedError, "invalid comparison for a ptSceneobject object");
			PYTHON_RCOMPARE_ERROR;
		}
	}
	pySceneObject *scObj1 = pySceneObject::ConvertFrom(obj1);
	pySceneObject *scObj2 = pySceneObject::ConvertFrom(obj2);
	if (compareType == Py_EQ)
	{
		if ((*scObj1) == (*scObj2))
			PYTHON_RCOMPARE_TRUE;
		PYTHON_RCOMPARE_FALSE;
	}
	else if (compareType == Py_NE)
	{
		if ((*scObj1) != (*scObj2))
			PYTHON_RCOMPARE_TRUE;
		PYTHON_RCOMPARE_FALSE;
	}
	PyErr_SetString(PyExc_NotImplementedError, "invalid comparison for a ptSceneobject object");
	PYTHON_RCOMPARE_ERROR;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, addKey, args)
{
	PyObject *keyObject = NULL;
	if (!PyArg_ParseTuple(args, "O", &keyObject))
	{
		PyErr_SetString(PyExc_TypeError, "addKey expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	if (!pyKey::Check(keyObject))
	{
		PyErr_SetString(PyExc_TypeError, "addKey expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	pyKey *key = pyKey::ConvertFrom(keyObject);
	self->fThis->addObjPyKey(*key);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getKey)
{
	return self->fThis->getObjPyKey();
}

PYTHON_METHOD_DEFINITION(ptSceneobject, netForce, args)
{
	char forceFlag;
	if (!PyArg_ParseTuple(args, "b", &forceFlag))
	{
		PyErr_SetString(PyExc_TypeError, "netForce requires a boolean argument");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->SetNetForce(forceFlag != 0);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, findObject, args)
{
	char *name = NULL;
	if (!PyArg_ParseTuple(args, "s", &name))
	{
		PyErr_SetString(PyExc_TypeError, "findObject expects a string");
		PYTHON_RETURN_ERROR;
	}
	return self->fThis->findObj(name);
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getName)
{
	return PyString_FromString(self->fThis->GetName());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getResponders)
{
	std::vector<PyObject*> vecList = self->fThis->GetResponders();
	PyObject *retVal = PyList_New(vecList.size());
	for (int curKey = 0; curKey < vecList.size(); curKey++)
		PyList_SetItem(retVal, curKey, vecList[curKey]); // steals the vecList ref
	return retVal;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getPythonMods)
{
	std::vector<PyObject*> vecList = self->fThis->GetPythonMods();
	PyObject *retVal = PyList_New(vecList.size());
	for (int curKey = 0; curKey < vecList.size(); curKey++)
		PyList_SetItem(retVal, curKey, vecList[curKey]); // steals the vecList ref
	return retVal;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, isLocallyOwned)
{
	PYTHON_RETURN_BOOL(self->fThis->IsLocallyOwned());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getLocalToWorld)
{
	return self->fThis->GetLocalToWorld();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getWorldToLocal)
{
	return self->fThis->GetWorldToLocal();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getLocalToParent)
{
	return self->fThis->GetLocalToParent();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getParentToLocal)
{
	return self->fThis->GetParentToLocal();
}

PYTHON_METHOD_DEFINITION(ptSceneobject, setTransform, args)
{
	PyObject *local2WorldObj = NULL;
	PyObject *world2LocalObj = NULL;
	if (!PyArg_ParseTuple(args, "OO", &local2WorldObj, &world2LocalObj))
	{
		PyErr_SetString(PyExc_TypeError, "setTransform expects two ptMatrix44 objects");
		PYTHON_RETURN_ERROR;
	}
	if ((!pyMatrix44::Check(local2WorldObj))||(!pyMatrix44::Check(world2LocalObj)))
	{
		PyErr_SetString(PyExc_TypeError, "setTransform expects two ptMatrix44 objects");
		PYTHON_RETURN_ERROR;
	}
	pyMatrix44 *local2World = pyMatrix44::ConvertFrom(local2WorldObj);
	pyMatrix44 *world2Local = pyMatrix44::ConvertFrom(world2LocalObj);
	self->fThis->SetTransform(*local2World, *world2Local);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, position)
{
	return self->fThis->GetWorldPosition();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, view)
{
	return self->fThis->GetViewVector();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, up)
{
	return self->fThis->GetUpVector();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, right)
{
	return self->fThis->GetRightVector();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, isAvatar)
{
	PYTHON_RETURN_BOOL(self->fThis->IsAvatar());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, avatarVelocity)
{
	return self->fThis->GetAvatarVelocity();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, isHuman)
{
	PYTHON_RETURN_BOOL(self->fThis->IsHumanAvatar());
}

PYTHON_METHOD_DEFINITION(ptSceneobject, pushCutsceneCamera, args)
{
	char cutFlag;
	PyObject *avKeyObject = NULL;
	if (!PyArg_ParseTuple(args, "bO", &cutFlag, &avKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "pushCutseneCamera expects a boolean and a ptKey");
		PYTHON_RETURN_ERROR;
	}
	if (!pyKey::Check(avKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "pushCutseneCamera expects a boolean and a ptKey");
		PYTHON_RETURN_ERROR;
	}
	pyKey *avKey = pyKey::ConvertFrom(avKeyObject);
	self->fThis->PushCutsceneCamera((cutFlag != 0), *avKey);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, popCutsceneCamera, args)
{
	PyObject *avKeyObject = NULL;
	if (!PyArg_ParseTuple(args, "O", &avKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "popCutsceneCamera expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	if (!pyKey::Check(avKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "popCutsceneCamera expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	pyKey *avKey = pyKey::ConvertFrom(avKeyObject);
	self->fThis->PopCutsceneCamera(*avKey);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, pushCamera, args)
{
	PyObject *avKeyObject = NULL;
	if (!PyArg_ParseTuple(args, "O", &avKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "pushCamera expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	if (!pyKey::Check(avKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "pushCamera expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	pyKey *avKey = pyKey::ConvertFrom(avKeyObject);
	self->fThis->PushCamera(*avKey);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, pushCameraCut, args)
{
	PyObject *avKeyObject = NULL;
	if (!PyArg_ParseTuple(args, "O", &avKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "pushCameraCut expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	if (!pyKey::Check(avKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "pushCameraCut expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	pyKey *avKey = pyKey::ConvertFrom(avKeyObject);
	self->fThis->PushCameraCut(*avKey);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, popCamera, args)
{
	PyObject *avKeyObject = NULL;
	if (!PyArg_ParseTuple(args, "O", &avKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "popCamera expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	if (!pyKey::Check(avKeyObject))
	{
		PyErr_SetString(PyExc_TypeError, "popCamera expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	pyKey *avKey = pyKey::ConvertFrom(avKeyObject);
	self->fThis->PopCamera(*avKey);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptSceneobject, getResponderState)
{
	return PyInt_FromLong((long)self->fThis->GetResponderState());
}

PYTHON_BASIC_METHOD_DEFINITION(ptSceneobject, animate, Animate)

PYTHON_METHOD_DEFINITION(ptSceneobject, rewindAnimNamed, args)
{
	char *name = NULL;
	if (!PyArg_ParseTuple(args, "s", &name))
	{
		PyErr_SetString(PyExc_TypeError, "rewindAnimNamed expects a string");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->RewindAnim(name);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, playAnimNamed, args)
{
	char *name = NULL;
	if (!PyArg_ParseTuple(args, "s", &name))
	{
		PyErr_SetString(PyExc_TypeError, "playAnimNamed expects a string");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->PlayAnim(name);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, stopAnimNamed, args)
{
	char *name = NULL;
	if (!PyArg_ParseTuple(args, "s", &name))
	{
		PyErr_SetString(PyExc_TypeError, "stopAnimNamed expects a string");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->StopAnim(name);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, runAttachedResponder, args)
{
	int state;
	if (!PyArg_ParseTuple(args, "i", &state))
	{
		PyErr_SetString(PyExc_TypeError, "runAttachedResponder expects an integer");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->RunResponder(state);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, fastForwardAttachedResponder, args)
{
	int state;
	if (!PyArg_ParseTuple(args, "i", &state))
	{
		PyErr_SetString(PyExc_TypeError, "fastForwardAttachedResponder expects an integer");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->FFResponder(state);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, setSoundFilename, args)
{
	int index;
	char *filename = NULL;
	char isCompressed;
	if (!PyArg_ParseTuple(args, "isb", &index, &filename, &isCompressed))
	{
		PyErr_SetString(PyExc_TypeError, "setSoundFilename expects an integer, string and boolean");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->SetSoundFilename(index, filename, (isCompressed != 0));
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptSceneobject, getSoundIndex, args)
{
	char *sndComponentName = NULL;
	if (!PyArg_ParseTuple(args, "s", &sndComponentName))
	{
		PyErr_SetString(PyExc_TypeError, "getSoundIndex expects a string");
		PYTHON_RETURN_ERROR;
	}
	return PyInt_FromLong((long)self->fThis->GetSoundObjectIndex(sndComponentName));
}

PYTHON_METHOD_DEFINITION(ptSceneobject, volumeSensorIgnoreExtraEnters, args)
{
	char ignore;
	if (!PyArg_ParseTuple(args, "b", &ignore))
	{
		PyErr_SetString(PyExc_TypeError, "volumeSensorIgnoreExtraEnters expects a boolean");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->VolumeSensorIgnoreExtraEnters(ignore != 0);
	PYTHON_RETURN_NONE;
}

PYTHON_START_METHODS_TABLE(ptSceneobject)
	PYTHON_METHOD(ptSceneobject, addKey, "Params: key\nMostly used internally.\n"
				"Add another sceneobject ptKey"),
	PYTHON_METHOD_NOARGS(ptSceneobject, getKey, "Get the ptKey of this sceneobject\n"
				"If there are more then one attached, get the first one"),

	PYTHON_METHOD(ptSceneobject, netForce, "Params: forceFlag\nSpecify whether this object needs to use messages that are forced to the network\n"
				"- This is to be used if your Python program is running on only one client\n"
				"Such as a game master, only running on the client that owns a particular object\n"
				"- Setting the netForce flag on a sceneobject will also set the netForce flag on\n"
				"its draw, physics, avatar, particle objects"),
	
	PYTHON_METHOD(ptSceneobject, findObject, "Params: name\nFind a particular object in just the sceneobjects that are attached"),
	PYTHON_METHOD_NOARGS(ptSceneobject, getName, "Returns the name of the sceneobject (Max name)\n"
				"- If there are more than one sceneobject attached, return just the first one"),
	PYTHON_METHOD_NOARGS(ptSceneobject, getResponders, "Returns list of ptKeys of the responders attached to this sceneobject"),
	PYTHON_METHOD_NOARGS(ptSceneobject, getPythonMods, "Returns list of ptKeys of the python modifiers attached to this sceneobject"),
	PYTHON_METHOD_NOARGS(ptSceneobject, isLocallyOwned, "Returns true(1) if this object is locally owned by this client\n"
				"or returns false(0) if it is not or don't know"),

	PYTHON_METHOD_NOARGS(ptSceneobject, getLocalToWorld, "Returns ptMatrix44 of the local to world transform for this sceneobject\n"
				"- If there is more than one sceneobject attached, returns just the first one"),
	PYTHON_METHOD_NOARGS(ptSceneobject, getWorldToLocal, "Returns ptMatrix44 of the world to local transform for this sceneobject\n"
				"- If there is more than one sceneobject attached, returns just the first one"),
	PYTHON_METHOD_NOARGS(ptSceneobject, getLocalToParent, "Returns ptMatrix44 of the local to parent transform for this sceneobject\n"
				"- If there is more than one sceneobject attached, returns just the first one"),
	PYTHON_METHOD_NOARGS(ptSceneobject, getParentToLocal, "Returns ptMatrix44 of the parent to local transform for this sceneobject\n"
				"- If there is more than one sceneobject attached, returns just the first one"),
	PYTHON_METHOD(ptSceneobject, setTransform, "Params: local2world,world2local\nSet our current transforms"),

	PYTHON_METHOD_NOARGS(ptSceneobject, position, "Returns the scene object's current position"),
	PYTHON_METHOD_NOARGS(ptSceneobject, view, "Returns the scene object's current view vector"),
	PYTHON_METHOD_NOARGS(ptSceneobject, up, "Returns the scene object's current up vector"),
	PYTHON_METHOD_NOARGS(ptSceneobject, right, "Returns the scene object's current right vector"),
	PYTHON_METHOD_NOARGS(ptSceneobject, isAvatar, "Returns true if the scene object is an avatar"),
	PYTHON_METHOD_NOARGS(ptSceneobject, avatarVelocity, "Returns the velocity of the first attached avatar scene object"),
	PYTHON_METHOD_NOARGS(ptSceneobject, isHuman, "Returns true if the scene object is a human avatar"),

	PYTHON_METHOD(ptSceneobject, pushCutsceneCamera, "Params: cutFlag,avKey\nSwitch to this object (assuming that it is actually a camera)"),
	PYTHON_METHOD(ptSceneobject, popCutsceneCamera, "Params: avKey\nPop the camera stack and go back to previous camera."),
	PYTHON_METHOD(ptSceneobject, pushCamera, "Params: avKey\nSwitch to this object (if it is a camera)"),
	PYTHON_METHOD(ptSceneobject, pushCameraCut, "Params: avKey\nSwitch to this object, cutting the view (if it is a camera)"),
	PYTHON_METHOD(ptSceneobject, popCamera, "Params: avKey\nPop the camera stack and go back to the previous camera"),

	PYTHON_METHOD_NOARGS(ptSceneobject, getResponderState, "Return the responder state (if we are a responder)"),
	
	PYTHON_BASIC_METHOD(ptSceneobject, animate, "If we can animate, start animating"),
	PYTHON_METHOD(ptSceneobject, rewindAnimNamed, "Params: animName\nRewind the attached named animation"),
	PYTHON_METHOD(ptSceneobject, playAnimNamed, "Params: animName\nPlay the attached named animation"),
	PYTHON_METHOD(ptSceneobject, stopAnimNamed, "Params: animName\nStop the attached named animation"),

	PYTHON_METHOD(ptSceneobject, runAttachedResponder, "Params: state\nRun the attached responder to the specified state"),
	PYTHON_METHOD(ptSceneobject, fastForwardAttachedResponder, "Params: state\nFast forward the attached responder to the specified state"),

	PYTHON_METHOD(ptSceneobject, setSoundFilename, "Params: index, filename, isCompressed\nSets the sound attached to this sceneobject to use the specified sound file."),
	PYTHON_METHOD(ptSceneobject, getSoundIndex, "Params: sndComponentName\nGet the index of the requested sound component"),

	PYTHON_METHOD(ptSceneobject, volumeSensorIgnoreExtraEnters, "Params: ignore\nTells the volume sensor attached to this object to ignore extra enters (default), or not (hack for garrison)."),
PYTHON_END_METHODS_TABLE;

PYTHON_GET_DEFINITION(ptSceneobject, draw)
{
	Py_INCREF(self->fThis->fDraw); // we need to return a new ref
	return self->fThis->fDraw;
}

PYTHON_SET_DEFINITION_READONLY(ptSceneobject, draw)

PYTHON_GET_DEFINITION(ptSceneobject, physics)
{
	Py_INCREF(self->fThis->fPhysics); // we need to return a new ref
	return self->fThis->fPhysics;
}

PYTHON_SET_DEFINITION_READONLY(ptSceneobject, physics)

PYTHON_GET_DEFINITION(ptSceneobject, avatar)
{
	Py_INCREF(self->fThis->fAvatar); // we need to return a new ref
	return self->fThis->fAvatar;
}

PYTHON_SET_DEFINITION_READONLY(ptSceneobject, avatar)

PYTHON_GET_DEFINITION(ptSceneobject, particle)
{
	Py_INCREF(self->fThis->fParticle); // we need to return a new ref
	return self->fThis->fParticle;
}

PYTHON_SET_DEFINITION_READONLY(ptSceneobject, particle)

PYTHON_START_GETSET_TABLE(ptSceneobject)
	PYTHON_GETSET(ptSceneobject, draw, ""),
	PYTHON_GETSET(ptSceneobject, physics, ""),
	PYTHON_GETSET(ptSceneobject, avatar, ""),
	PYTHON_GETSET(ptSceneobject, particle, ""),
PYTHON_END_GETSET_TABLE;

// Type structure definition
#define ptSceneobject_COMPARE			PYTHON_NO_COMPARE
#define ptSceneobject_AS_NUMBER			PYTHON_NO_AS_NUMBER
#define ptSceneobject_AS_SEQUENCE		PYTHON_NO_AS_SEQUENCE
#define ptSceneobject_AS_MAPPING		PYTHON_NO_AS_MAPPING
#define ptSceneobject_STR				PYTHON_NO_STR
#define ptSceneobject_RICH_COMPARE		PYTHON_DEFAULT_RICH_COMPARE(ptSceneobject)
#define ptSceneobject_GETSET			PYTHON_DEFAULT_GETSET(ptSceneobject)
#define ptSceneobject_BASE				PYTHON_NO_BASE
PLASMA_CUSTOM_TYPE(ptSceneobject, "Params: objKey, selfKey\nPlasma Sceneobject class");

// required functions for PyObject interoperability
PyObject *pySceneObject::New(plKey objKey, PyObject *selfKeyObj)
{
	if (!pyKey::Check(selfKeyObj))
		return NULL;
	pyKey *selfKey = pyKey::ConvertFrom(selfKeyObj);

	ptSceneobject *newObj = (ptSceneobject*)ptSceneobject_type.tp_new(&ptSceneobject_type, NULL, NULL);
	newObj->fThis->addObjKey(objKey);
	newObj->fThis->setSenderKey(selfKey->getKey());
	newObj->fThis->setPyMod(*selfKey);
	newObj->fThis->SetNetForce(false);
	return (PyObject*)newObj;
}

PyObject *pySceneObject::New(plKey objKey, pyKey &selfKey)
{
	ptSceneobject *newObj = (ptSceneobject*)ptSceneobject_type.tp_new(&ptSceneobject_type, NULL, NULL);
	newObj->fThis->addObjKey(objKey);
	newObj->fThis->setSenderKey(selfKey.getKey());
	newObj->fThis->setPyMod(selfKey);
	newObj->fThis->SetNetForce(false);
	return (PyObject*)newObj;
}

PyObject *pySceneObject::New(plKey objKey, plKey selfKey)
{
	ptSceneobject *newObj = (ptSceneobject*)ptSceneobject_type.tp_new(&ptSceneobject_type, NULL, NULL);
	newObj->fThis->addObjKey(objKey);
	newObj->fThis->setSenderKey(selfKey);
	newObj->fThis->setPyMod(selfKey);
	newObj->fThis->SetNetForce(false);
	return (PyObject*)newObj;
}

PyObject *pySceneObject::New(plKey objKey)
{
	ptSceneobject *newObj = (ptSceneobject*)ptSceneobject_type.tp_new(&ptSceneobject_type, NULL, NULL);
	newObj->fThis->addObjKey(objKey);
	newObj->fThis->setSenderKey(objKey);
	newObj->fThis->SetNetForce(false);
	return (PyObject*)newObj;
}

PYTHON_CLASS_CHECK_IMPL(ptSceneobject, pySceneObject)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptSceneobject, pySceneObject)

///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pySceneObject::AddPlasmaClasses(PyObject *m)
{
	PYTHON_CLASS_IMPORT_START(m);
	PYTHON_CLASS_IMPORT(m, ptSceneobject);
	PYTHON_CLASS_IMPORT_END(m);
}