CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/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/>.

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/plAvCallbackAction.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);
			}
		}
	}
}