CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/pySceneObject.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/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

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 "hsTypes.h" // TEMP, for STL warnings
#include "pySceneObject.h"

#include "../pnKeyedObject/plKey.h"
#include "cyAvatar.h"
#include "../plAvatar/plAvBrainHuman.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "../plResMgr/plResManager.h"
#include "../pnMessage/plCameraMsg.h"
#include "../pfCamera/plCameraModifier.h"
#include "../plAvatar/plArmatureMod.h"
#include "plPhysical.h"
#include "../plModifier/plResponderModifier.h"
#include "../plModifier/plLogicModifier.h"
#include "../pfPython/plPythonFileMod.h"

#include "pyMatrix44.h"
#include "pyKey.h"
#include "plgDispatch.h"

void pySceneObject::IAddObjKeyToAll(plKey key)
{
	// set the sender and the receiver to the same thing
	cyDraw::ConvertFrom(fDraw)->AddRecvr(key);
	cyPhysics::ConvertFrom(fPhysics)->AddRecvr(key);
	cyAvatar::ConvertFrom(fAvatar)->AddRecvr(key);
	cyParticleSys::ConvertFrom(fParticle)->AddRecvr(key);
}

void pySceneObject::ISetAllSenderKeys()
{
	// set the sender and the receiver to the same thing
	cyDraw::ConvertFrom(fDraw)->SetSender(fSenderKey);
	cyPhysics::ConvertFrom(fPhysics)->SetSender(fSenderKey);
	cyAvatar::ConvertFrom(fAvatar)->SetSender(fSenderKey);
	cyParticleSys::ConvertFrom(fParticle)->SetSender(fSenderKey);
}

pySceneObject::pySceneObject()
{
	// make sure these are created
	fDraw = cyDraw::New();
	fPhysics = cyPhysics::New();
	fAvatar = cyAvatar::New();
	fParticle = cyParticleSys::New();
	fNetForce = false;
}

pySceneObject::pySceneObject(pyKey& objkey, pyKey& selfkey)
{
	// make sure these are created
	fDraw = cyDraw::New();
	fPhysics = cyPhysics::New();
	fAvatar = cyAvatar::New();
	fParticle = cyParticleSys::New();

	addObjKey(objkey.getKey());
	setSenderKey(selfkey.getKey());
	setPyMod(selfkey);
	fNetForce = false;
}

pySceneObject::pySceneObject(plKey objkey,pyKey& selfkey)
{
	// make sure these are created
	fDraw = cyDraw::New();
	fPhysics = cyPhysics::New();
	fAvatar = cyAvatar::New();
	fParticle = cyParticleSys::New();

	addObjKey(objkey);
	setSenderKey(selfkey.getKey());
	setPyMod(selfkey);
	fNetForce = false;
}


pySceneObject::pySceneObject(plKey objkey)
{
	// make sure these are created
	fDraw = cyDraw::New();
	fPhysics = cyPhysics::New();
	fAvatar = cyAvatar::New();
	fParticle = cyParticleSys::New();

	addObjKey(objkey);
	setSenderKey(objkey);
	fNetForce = false;
}


hsBool pySceneObject::operator==(const pySceneObject &sobj) const
{
	plKey ours = ((pySceneObject*)this)->getObjKey();
	plKey theirs = ((pySceneObject&)sobj).getObjKey();
	if ( ours == nil && theirs == nil )
		return true;
	else if ( ours != nil && theirs != nil )
		return (ours->GetUoid()==theirs->GetUoid());
	else
		return false;
}

// getter and setters
void pySceneObject::addObjKey(plKey key)
{
	if ( key != nil )
	{
		fSceneObjects.Append(key);
		IAddObjKeyToAll(key);
	}
}

void pySceneObject::addObjPyKey(pyKey& objkey)
{
	if ( objkey.getKey() != nil )
	{
		fSceneObjects.Append(objkey.getKey());
		IAddObjKeyToAll(objkey.getKey());
	}
}

plKey pySceneObject::getObjKey()
{
	if ( fSceneObjects.Count() > 0 )
		return fSceneObjects[0];
	else
		return nil;
}

PyObject* pySceneObject::getObjPyKey()
{
	PyObject* pyobj;	// Python will manage this... it only knows when everyone is done with it
	if ( fSceneObjects.Count() > 0 )
		pyobj = pyKey::New(fSceneObjects[0]);
	else
	{
		Py_INCREF(Py_None);
		pyobj = Py_None;
	}
	return pyobj;
}

void pySceneObject::setSenderKey(plKey key)
{ 
	fSenderKey=key;
	ISetAllSenderKeys();
}

void pySceneObject::setPyMod(pyKey& pymod)
{
	fPyMod = pymod.getKey();
}

void pySceneObject::setPyMod(plKey& key)
{
	fPyMod = key;
}

void pySceneObject::SetNetForce(hsBool state)
{
	// set our flag
	fNetForce = state;
	// then set the netForce flag in the subs
	cyDraw::ConvertFrom(fDraw)->SetNetForce(state);
	cyPhysics::ConvertFrom(fPhysics)->SetNetForce(state);
	cyAvatar::ConvertFrom(fAvatar)->SetNetForce(state);
	cyParticleSys::ConvertFrom(fParticle)->SetNetForce(state);
}


const char* pySceneObject::GetName()
{
	if ( fSceneObjects.Count() > 0 )
		return fSceneObjects[0]->GetName();
	return "";
}

PyObject* pySceneObject::findObj(const char* name)
{
	PyObject* pSobj = nil;
	// search through the plKeys that we have looking for this name
	int i;
	for ( i=0; i<fSceneObjects.Count(); i++ )
	{
		if ( hsStrEQ(name,fSceneObjects[i]->GetName()) )
		{
			pSobj = pySceneObject::New(fSceneObjects[i],fPyMod);
			break;
		}
	}

	// did we find one? if not make an object with nil object
	if ( pSobj == nil )
	{
		// throw a Python error, so the coder knows it didn't work
		PyErr_SetString(PyExc_KeyError, name);
	}

	return pSobj;
}


//
// deteremine if this object (or the first object in the list)
// ...is locally owned
hsBool pySceneObject::IsLocallyOwned()
{
	// make sure that there are sceneobjects
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSynchedObject* obj = plSynchedObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj && obj->IsLocallyOwned() == plSynchedObject::kYes )
			return true;
		else
			// both No and Maybe answers will be assumed to be "not locally ownded"
			return false;
	}
	else
		// if we couldn't find any sceneobject, then there is no way that it could be local... heh
		return false;
}


//
// get the local to world matrix
PyObject* pySceneObject::GetLocalToWorld()
{
	// make sure that there are sceneobjects
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{
			const plCoordinateInterface* ci = obj->GetCoordinateInterface();
			if ( ci )
				return pyMatrix44::New((hsMatrix44)ci->GetLocalToWorld());
			else
			{
				char errmsg[256];
				sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
				PyErr_SetString(PyExc_RuntimeError, errmsg);
				return nil; // return nil to tell python we errored
			}
		}
	}
	// if we couldn't find any sceneobject or a coordinate interface
	return pyMatrix44::New();
}

//
// get the local to world matrix
PyObject* pySceneObject::GetWorldToLocal()
{
	// make sure that there are sceneobjects
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{
			const plCoordinateInterface* ci = obj->GetCoordinateInterface();
			if ( ci )
				return pyMatrix44::New((hsMatrix44)ci->GetWorldToLocal());
			else
			{
				char errmsg[256];
				sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
				PyErr_SetString(PyExc_RuntimeError, errmsg);
				return nil; // return nil to tell python we errored
			}
		}
	}
	// if we couldn't find any sceneobject or a coordinate interface
	return pyMatrix44::New();
}

//
// get the local to world matrix
PyObject* pySceneObject::GetLocalToParent()
{
	// make sure that there are sceneobjects
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{
			const plCoordinateInterface* ci = obj->GetCoordinateInterface();
			if ( ci )
				return pyMatrix44::New((hsMatrix44)ci->GetLocalToParent());
			else
			{
				char errmsg[256];
				sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
				PyErr_SetString(PyExc_RuntimeError, errmsg);
				return nil; // return nil to tell python we errored
			}
		}
	}
	// if we couldn't find any sceneobject or a coordinate interface
	return pyMatrix44::New();
}

//
// get the local to world matrix
PyObject* pySceneObject::GetParentToLocal()
{
	// make sure that there are sceneobjects
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{
			const plCoordinateInterface* ci = obj->GetCoordinateInterface();
			if ( ci )
				return pyMatrix44::New((hsMatrix44)ci->GetParentToLocal());
			else
			{
				char errmsg[256];
				sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
				PyErr_SetString(PyExc_RuntimeError, errmsg);
				return nil; // return nil to tell python we errored
			}
		}
	}
	// if we couldn't find any sceneobject or a coordinate interface
	return pyMatrix44::New();
}

//
// get the local to world matrix
void pySceneObject::SetTransform(pyMatrix44& l2w, pyMatrix44& w2l)
{
	// make sure that there are sceneobjects
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
			obj->SetTransform(l2w.fMatrix,w2l.fMatrix);
	}
}

//
// find the position of this object (if there are more than one, just the first one)
PyObject* pySceneObject::GetWorldPosition()
{
	// make sure that there are sceneobjects
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{
			const plCoordinateInterface* ci = obj->GetCoordinateInterface();
			if ( ci )
				return pyPoint3::New((hsPoint3)ci->GetWorldPos());
			else
			{
				char errmsg[256];
				sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
				PyErr_SetString(PyExc_RuntimeError, errmsg);
				return nil; // return nil to tell python we errored
			}
		}
	}
	// if we couldn't find any sceneobject or a coordinate interface
	return pyPoint3::New(hsPoint3(0,0,0));
}

//
// find the view vector for this object (if there are more than one, just the first one)
PyObject* pySceneObject::GetViewVector()
{
	// make sure that there are sceneobjects
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{
			const plCoordinateInterface* ci = obj->GetCoordinateInterface();
			if ( ci )
				return pyVector3::New(ci->GetLocalToWorld().GetAxis(hsMatrix44::kView));
			else
			{
				char errmsg[256];
				sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
				PyErr_SetString(PyExc_RuntimeError, errmsg);
				return nil; // return nil to tell python we errored
			}
		}
	}
	// if we couldn't find any sceneobject or a coordinate interface
	return pyVector3::New(hsVector3(0,0,0));
}

//
// find the up vector for this object (if there are more than one, just the first one)
PyObject* pySceneObject::GetUpVector()
{
	// make sure that there are sceneobjects
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{
			const plCoordinateInterface* ci = obj->GetCoordinateInterface();
			if ( ci )
				return pyVector3::New(ci->GetLocalToWorld().GetAxis(hsMatrix44::kUp));
			else
			{
				char errmsg[256];
				sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
				PyErr_SetString(PyExc_RuntimeError, errmsg);
				return nil; // return nil to tell python we errored
			}
		}
	}
	// if we couldn't find any sceneobject or a coordinate interface
	return pyVector3::New(hsVector3(0,0,0));
}

//
// find the up vector for this object (if there are more than one, just the first one)
PyObject* pySceneObject::GetRightVector()
{
	// make sure that there are sceneobjects
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{
			const plCoordinateInterface* ci = obj->GetCoordinateInterface();
			if ( ci )
				return pyVector3::New(ci->GetLocalToWorld().GetAxis(hsMatrix44::kRight));
			else
			{
				char errmsg[256];
				sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
				PyErr_SetString(PyExc_RuntimeError, errmsg);
				return nil; // return nil to tell python we errored
			}
		}
	}
	// if we couldn't find any sceneobject or a coordinate interface
	return pyVector3::New(hsVector3(0,0,0));
}

//
// deteremine if this object (or any of the object attached)
// ...is an avatar, of any type
hsBool pySceneObject::IsAvatar()
{
	// loop through all the sceneobject... looking for avatar modifiers
	int j;
	for ( j=0 ; j<fSceneObjects.Count() ; j++ )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[j]->ObjectIsLoaded());
		if ( obj )
		{
			// search through its modifiers to see if one of them is an avatar modifier
			int i;
			for ( i=0; i<obj->GetNumModifiers(); i++ )
			{
				const plModifier* mod = obj->GetModifier(i);
				// see if it is an avatar mod base class
				const plArmatureMod* avatar = plArmatureMod::ConvertNoRef(mod);
				if ( avatar )
					return true;
			}
		}
	}
	// if we couldn't find any sceneobject that had an avatar mod then this ain't an avatar
	return false;
}

#include "../plAvatar/plPhysicalControllerCore.h"

PyObject* pySceneObject::GetAvatarVelocity()
{
	// loop through all the sceneobject... looking for avatar modifiers
	int j;
	for ( j=0 ; j<fSceneObjects.Count() ; j++ )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[j]->ObjectIsLoaded());
		if ( obj )
		{
			// search through its modifiers to see if one of them is an avatar modifier
			int i;
			for ( i=0; i<obj->GetNumModifiers(); i++ )
			{
				const plModifier* mod = obj->GetModifier(i);
				// see if it is an avatar mod base class
				const plArmatureMod* avatar = plArmatureMod::ConvertNoRef(mod);
				if ( avatar && avatar->GetController() )
				{
					hsVector3 vel = avatar->GetController()->GetLinearVelocity();
					return pyVector3::New(vel);
				}
			}
		}
	}

	// if we couldn't find any sceneobject that had an avatar mod then this ain't an avatar
	return pyVector3::New(hsVector3(0,0,0));
}


//
// deteremine if this object (or the first object in the list)
// ...is a human avatar
hsBool pySceneObject::IsHumanAvatar()
{
	// loop through all the sceneobject... looking for avatar modifiers
	int j;
	for ( j=0 ; j<fSceneObjects.Count() ; j++ )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{
			// search through its modifiers to see if one of them is an avatar modifier
			int i;
			for ( i=0; i<obj->GetNumModifiers(); i++ )
			{
				const plModifier* mod = obj->GetModifier(i);
				// see if it is an avatar mod base class
				plArmatureMod* avatar = (plArmatureMod*)plArmatureMod::ConvertNoRef(mod);
				if ( avatar )
				{
					plArmatureBrain* brain = avatar->GetCurrentBrain();
					plAvBrainHuman* human = plAvBrainHuman::ConvertNoRef(brain);
					if ( human )
						return true;
				}
			}
		}
	}
	// if we couldn't find any sceneobject that had an avatar mod then this ain't an avatar
	return false;
}

// switch to / from this object (assuming that it is actually a camera)
void pySceneObject::PushCutsceneCamera(hsBool cut, pyKey& avKey)
{
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{	
			for (int i = 0; i < obj->GetNumModifiers(); i++)
			{
				const plCameraModifier1* pCam = plCameraModifier1::ConvertNoRef(obj->GetModifier(i));
				if (pCam)
				{
					plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
					pMsg->SetSender(pCam->GetKey());
					pMsg->SetBCastFlag(plMessage::kBCastByType);
					// set command to do the transition
					if (cut)
						pMsg->SetCmd(plCameraMsg::kPythonOverridePushCut);
					else
						pMsg->SetCmd(plCameraMsg::kPythonOverridePush);
					// set the new camera
					pMsg->SetNewCam(pCam->GetKey());
					pMsg->SetTriggerer(avKey.getKey());
					plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
					return;
				}
			}
		}
	}
}

void pySceneObject::PopCutsceneCamera(pyKey& avKey)
{
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{	
			for (int i = 0; i < obj->GetNumModifiers(); i++)
			{
				const plCameraModifier1* pCam = plCameraModifier1::ConvertNoRef(obj->GetModifier(i));
				if (pCam)
				{
					plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
					pMsg->SetSender(pCam->GetKey());
					pMsg->SetBCastFlag(plMessage::kBCastByType);
					// set command to do the transition
					pMsg->SetCmd(plCameraMsg::kPythonOverridePop);
					// set the new camera
					pMsg->SetTriggerer(avKey.getKey());
					pMsg->SetNewCam(pCam->GetKey());
					plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
					return;
				}
			}
		}
	}

}

void pySceneObject::PushCamera(pyKey& avKey)
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{	
		for (int i = 0; i < obj->GetNumModifiers(); i++)
		{
			const plCameraModifier1* pCam = plCameraModifier1::ConvertNoRef(obj->GetModifier(i));
			if (pCam)
			{
									
				// create message
				plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
				pMsg->SetSender(pCam->GetKey());
				pMsg->SetBCastFlag(plMessage::kBCastByType);

				// set command to do the transition
				pMsg->SetCmd(plCameraMsg::kResponderTrigger);
				pMsg->SetCmd(plCameraMsg::kRegionPushCamera);
				// set the new camera
				pMsg->SetTriggerer(avKey.getKey());
				pMsg->SetNewCam(pCam->GetKey());

				plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
			}
		}
	}
}

void pySceneObject::PushCameraCut(pyKey& avKey)
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{	
		for (int i = 0; i < obj->GetNumModifiers(); i++)
		{
			const plCameraModifier1* pCam = plCameraModifier1::ConvertNoRef(obj->GetModifier(i));
			if (pCam)
			{
									
				// create message
				plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
				pMsg->SetSender(pCam->GetKey());
				pMsg->SetBCastFlag(plMessage::kBCastByType);

				// set command to do the transition
				pMsg->SetCmd(plCameraMsg::kResponderTrigger);
				pMsg->SetCmd(plCameraMsg::kRegionPushCamera);
				pMsg->SetCmd(plCameraMsg::kCut);
				// set the new camera
				pMsg->SetTriggerer(avKey.getKey());
				pMsg->SetNewCam(pCam->GetKey());

				plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
			}
		}
	}
}


/////////////////////////////////////////////////////////////////////////////
//
//  Function   : Pop
//  PARAMETERS :
//
//  PURPOSE    : Restore the state of the virtual camera with a previously saved setting
//
void pySceneObject::PopCamera(pyKey& avKey)
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{	
		for (int i = 0; i < obj->GetNumModifiers(); i++)
		{
			const plCameraModifier1* pCam = plCameraModifier1::ConvertNoRef(obj->GetModifier(i));
			if (pCam)
			{
									
				// create message
				plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
				pMsg->SetSender(pCam->GetKey());
				pMsg->SetBCastFlag(plMessage::kBCastByType);

				// set command to do the transition
				pMsg->SetCmd(plCameraMsg::kRegionPushCamera);
				// set the new camera
				pMsg->SetTriggerer(avKey.getKey());
				pMsg->SetNewCam(pCam->GetKey());

				plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
			}
		}
	}
}

std::vector<PyObject*> pySceneObject::GetResponders()
{
	std::vector<PyObject*> pyPL;
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{	
			for (int i = 0; i < obj->GetNumModifiers(); i++)
			{
				const plResponderModifier* resp = plResponderModifier::ConvertNoRef(obj->GetModifier(i));
				if (resp)
					pyPL.push_back(pyKey::New(resp->GetKey()));
			}
		}
	}
	return pyPL;
}

std::vector<PyObject*> pySceneObject::GetPythonMods()
{
	std::vector<PyObject*> pyPL;
	if ( fSceneObjects.Count() > 0 )
	{
		// get the object pointer of just the first one in the list
		// (We really can't tell which one the user is thinking of if they are
		// referring to multiple objects, so the first one in the list will do.)
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if ( obj )
		{	
			for (int i = 0; i < obj->GetNumModifiers(); i++)
			{
				const plPythonFileMod* resp = plPythonFileMod::ConvertNoRef(obj->GetModifier(i));
				if (resp)
					pyPL.push_back(pyKey::New(resp->GetKey()));
			}
		}
	}
	return pyPL;
}



#include "../plMessage/plAnimCmdMsg.h"
#include "../pnMessage/plNotifyMsg.h"

void pySceneObject::Animate()
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{
		plAnimCmdMsg* pMsg = TRACKED_NEW plAnimCmdMsg;
		pMsg->AddReceiver(obj->GetKey());
		pMsg->SetCmd(plAnimCmdMsg::kGoToBegin);
		pMsg->SetCmd(plAnimCmdMsg::kContinue);
		pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
		plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
	}
}

Int8 pySceneObject::GetResponderState()
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{
		for (int i = 0; i < obj->GetNumModifiers(); i++)
		{
			const plResponderModifier* resp = plResponderModifier::ConvertNoRef(obj->GetModifier(i));
			if (resp)
				return resp->GetState();
		}
	}
	return -1;
}

void pySceneObject::RewindAnim(const char* animName)
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{	
		plAnimCmdMsg* pMsg = TRACKED_NEW plAnimCmdMsg;
		pMsg->AddReceiver(obj->GetKey());
		pMsg->SetAnimName(animName);
		pMsg->SetCmd(plAnimCmdMsg::kGoToBegin);
		pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
		plgDispatch::MsgSend( pMsg );	// whoosh... off it goes	
	}
}

void pySceneObject::PlayAnim(const char* animName)
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{
		plAnimCmdMsg* pMsg = TRACKED_NEW plAnimCmdMsg;
		pMsg->AddReceiver(obj->GetKey());
		pMsg->SetAnimName(animName);
		pMsg->SetCmd(plAnimCmdMsg::kContinue);
		pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
		plgDispatch::MsgSend( pMsg );	// whoosh... off it goes	
	}
}

void pySceneObject::StopAnim(const char* animName)
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{
		plAnimCmdMsg* pMsg = TRACKED_NEW plAnimCmdMsg;
		pMsg->AddReceiver(obj->GetKey());
		pMsg->SetAnimName(animName);
		pMsg->SetCmd(plAnimCmdMsg::kStop);
		pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
		plgDispatch::MsgSend( pMsg );	// whoosh... off it goes	
	}
}

void pySceneObject::RunResponder(int state)
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{
		const plModifier* pMod = obj->GetModifierByType(plResponderModifier::Index());
		if (pMod)
		{
			plNotifyMsg* pMsg = TRACKED_NEW plNotifyMsg;
			pMsg->fType = plNotifyMsg::kResponderChangeState;
			pMsg->AddResponderStateEvent(state);
			pMsg->AddReceiver(pMod->GetKey());
			pMsg->Send();
		
			plNotifyMsg* pMsg0 = TRACKED_NEW plNotifyMsg;
			pMsg0->fState = true;
			pMsg0->AddReceiver(pMod->GetKey());
			pMsg0->Send();
		}
	}
}


void pySceneObject::FFResponder(int state)
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{
		const plModifier* pMod = obj->GetModifierByType(plResponderModifier::Index());
		if (pMod)
		{
			plNotifyMsg* pMsg = TRACKED_NEW plNotifyMsg;
			pMsg->fType = plNotifyMsg::kResponderFF;
			pMsg->AddResponderStateEvent(state);
			pMsg->AddReceiver(pMod->GetKey());
			pMsg->Send();
		}
	}
}

#include "../pnSceneObject/plAudioInterface.h"
#include "../NucleusLib/inc/plAudible.h"

void pySceneObject::SetSoundFilename(int index, const char* filename, bool isCompressed)
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{
		const plAudioInterface* ai = obj->GetAudioInterface();
		if (ai)
		{
			plAudible* au = ai->GetAudible();
			if (au)
			{
				au->SetFilename(index, filename, isCompressed);
			}
		}
	}
}

int pySceneObject::GetSoundObjectIndex(const char* sndObj)
{
	plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
	if ( obj )
	{
		const plAudioInterface* ai = obj->GetAudioInterface();
		if (ai)
		{
			plAudible* au = ai->GetAudible();
			if (au)
			{
				return au->GetSoundIndex(sndObj);
			}
		}
	}

	return -1;
}

void pySceneObject::VolumeSensorIgnoreExtraEnters(bool ignore)
{
	if (fSceneObjects.Count() > 0)
	{
		plSceneObject* obj = plSceneObject::ConvertNoRef(fSceneObjects[0]->ObjectIsLoaded());
		if (obj)
		{
			for (int i = 0; i < obj->GetNumModifiers(); ++i)
			{
				plLogicModifier* logic = const_cast<plLogicModifier*>(plLogicModifier::ConvertNoRef(obj->GetModifier(i)));
				if (logic)
					logic->VolumeIgnoreExtraEnters(ignore);
			}
		}
	}
}