You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

979 lines
33 KiB

/*==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);
}
}
}
}