OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
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.
104 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: 745d8c675f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '745d8c675f'
${ noResults }
CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/cyPhysics.cpp

787 lines
24 KiB
Raw Blame History

/*==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 "cyPhysics.h"
#include "plgDispatch.h"
#include "pnMessage/plEnableMsg.h"
#include "pnMessage/plWarpMsg.h"
#include "plMessage/plSimInfluenceMsg.h"
#include "plMessage/plSimStateMsg.h"
#include "plMessage/plLinearVelocityMsg.h"
#include "plMessage/plAngularVelocityMsg.h"
#include "pyGeometry3.h"
#include "pyMatrix44.h"
#include "pyKey.h"
#include "hsQuat.h"
#include "pnSceneObject/plSceneObject.h"
#include "pnSceneObject/plCoordinateInterface.h"
#include "pnKeyedObject/plKey.h"
cyPhysics::cyPhysics(plKey sender, plKey recvr)
{
SetSender(sender);
AddRecvr(recvr);
fNetForce = false;
}
// setters
void cyPhysics::SetSender(plKey &sender)
{
fSender = sender;
}
void cyPhysics::AddRecvr(plKey &recvr)
{
if ( recvr != nil )
fRecvr.Append(recvr);
}
void cyPhysics::SetNetForce(hsBool state)
{
// set our flag
fNetForce = state;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Enable
// PARAMETERS :
//
// PURPOSE : Enable physics (must already be there)
//
void cyPhysics::EnableT(hsBool state)
{
// must have a receiver!
if ( fRecvr.Count() > 0 )
{
// create message
plEnableMsg* pMsg = TRACKED_NEW plEnableMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
// jump back to frame 0
pMsg->SetCmd(plEnableMsg::kPhysical);
// which way are we doin' it?
if ( state )
pMsg->SetCmd(plEnableMsg::kEnable);
else
pMsg->SetCmd(plEnableMsg::kDisable);
// make sure to propagate this to the modifiers to tell things like the clickables to disable.
pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
}
void cyPhysics::Enable()
{
EnableT(true);
}
void cyPhysics::Disable()
{
EnableT(false);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Enable / Disable Collision
//
// PURPOSE : Enable / Disable collision for terrain and proxy terrain objects
// because using cyPhysics::Enable() does not work for these physical types
//
//
void cyPhysics::EnableCollision()
{
hsAssert(0, "Who uses this?");
/*
// must have a receiver!
if ( fRecvr.Count() > 0 )
{
plEventGroupEnableMsg* pMsg = TRACKED_NEW plEventGroupEnableMsg;
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->SetFlags(plEventGroupEnableMsg::kCollideOn);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
*/
}
void cyPhysics::DisableCollision()
{
hsAssert(0, "Who uses this?");
/*
// must have a receiver!
if ( fRecvr.Count() > 0 )
{
plEventGroupEnableMsg* pMsg = TRACKED_NEW plEventGroupEnableMsg;
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->SetFlags(plEventGroupEnableMsg::kCollideOff);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
*/
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Warp
// PARAMETERS : pos - the point to translate to
//
// PURPOSE : Suggest to physics engine where you want to place something
//
//
void cyPhysics::Warp(pyPoint3& pos)
{
// create message
PyObject* matObj = pyMatrix44::New();
pyMatrix44* mat = pyMatrix44::ConvertFrom(matObj);
mat->fMatrix.IdentityMatrix();
mat->fMatrix.SetTranslate(&pos.fPoint);
WarpMat(*mat);
Py_DECREF(matObj);
}
// warp v2 - for warping to the matching transform of an object (like a reference point)
void cyPhysics::WarpObj(pyKey& obj)
{
plKey obKey = obj.getKey();
plSceneObject* pObj = plSceneObject::ConvertNoRef(obKey->GetObjectPtr());
if (pObj && pObj->GetCoordinateInterface())
{
// create message
PyObject* matObj = pyMatrix44::New();
pyMatrix44* mat = pyMatrix44::ConvertFrom(matObj);
mat->fMatrix = pObj->GetCoordinateInterface()->GetLocalToWorld();
WarpMat(*mat);
Py_DECREF(matObj);
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : WarpMat
// PARAMETERS : mat - the matrix to translate to
//
// PURPOSE : Suggest to physics engine where you want to place something
//
//
void cyPhysics::WarpMat(pyMatrix44& mat)
{
// must have a receiver!
if ( fRecvr.Count() > 0 )
{
// create message
plWarpMsg* pMsg = TRACKED_NEW plWarpMsg(mat.fMatrix);
pMsg->SetWarpFlags(plWarpMsg::kFlushTransform);
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Move
// PARAMETERS : direction - vector of direction to move towards
// : distance - how far to move in that direction
//
// PURPOSE : Move the object in a direction and distance
// : if the object is physical then warp it
// : otherwise just use the coordinate interface and set the transform
//
void cyPhysics::Move(pyVector3& direction, hsScalar distance)
{
//move each receiver (object) separately
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
// 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(fRecvr[i]->GetObjectPtr());
if ( obj )
{
const plCoordinateInterface* ci = obj->GetCoordinateInterface();
if ( ci )
{
hsVector3 offset = direction.fVector * distance;
hsMatrix44 trans;
trans.MakeTranslateMat(&offset);
hsMatrix44 target_matrix = ci->GetWorldToLocal();
target_matrix = target_matrix * trans;
// see if this has a physical interface, if so, then its physical, therefore use warp
const plSimulationInterface* si = obj->GetSimulationInterface();
if ( si )
{
// create message for each receiver
plWarpMsg* pMsg = TRACKED_NEW plWarpMsg(target_matrix);
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// must have a receiver!
pMsg->AddReceiver(fRecvr[i]);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
else
{
// else just use the coordinate interface
hsMatrix44 w2l;
target_matrix.GetInverse(&w2l);
obj->SetTransform(target_matrix,w2l);
}
}
else
{
char errmsg[256];
sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
PyErr_SetString(PyExc_RuntimeError, errmsg);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Rotate
// PARAMETERS : rad - radians to rotate
// : axis - axis to rotate around
//
// PURPOSE : Rotate the object
// : if the object is physical then warp it
// : otherwise just use the coordinate interface and set the transform
//
void cyPhysics::Rotate(hsScalar rad, pyVector3& axis)
{
// rotate each receiver (object) separately
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
// 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(fRecvr[i]->GetObjectPtr());
if ( obj )
{
const plCoordinateInterface* ci = obj->GetCoordinateInterface();
if ( ci )
{
hsQuat q(rad, &axis.fVector);
q.Normalize();
hsMatrix44 rot;
q.MakeMatrix(&rot);
hsMatrix44 target_matrix = ci->GetWorldToLocal();
target_matrix = target_matrix * rot;
// see if this has a physical interface, then its physical, therefore use warp
const plSimulationInterface* si = obj->GetSimulationInterface();
if ( si )
{
// create message for each receiver
plWarpMsg* pMsg = TRACKED_NEW plWarpMsg(target_matrix);
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// must have a receiver!
pMsg->AddReceiver(fRecvr[i]);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
else
{
// else just use the coordinate interface
hsMatrix44 w2l;
target_matrix.GetInverse(&w2l);
obj->SetTransform(target_matrix,w2l);
}
}
else
{
char errmsg[256];
sprintf(errmsg,"Sceneobject %s does not have a coordinate interface.",obj->GetKeyName());
PyErr_SetString(PyExc_RuntimeError, errmsg);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Force
// PARAMETERS :
//
// PURPOSE : apply a force to the center of mass of the receiver
//
//
void cyPhysics::Force(pyVector3& force)
{
hsAssert(0, "Who uses this?");
// must have a receiver!
/* if ( fRecvr.Count() > 0 )
{
// create message
plForceMsg* pMsg = TRACKED_NEW plForceMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->SetForce(force.fVector);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
*/
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : ForceWithOffset
// PARAMETERS :
//
// PURPOSE : apply a force to the receiver as though it were being impacted at the
// : given point in global space
//
//
void cyPhysics::ForceWithOffset(pyVector3& force, pyPoint3& offset)
{
hsAssert(0, "Who uses this?");
// must have a receiver!
/* if ( fRecvr.Count() > 0 )
{
// create message
plOffsetForceMsg* pMsg = TRACKED_NEW plOffsetForceMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->SetForce(force.fVector);
pMsg->SetPoint(offset.fPoint);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
*/
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Torque
// PARAMETERS :
//
// PURPOSE : Apply the given torque force to the body
// : The vector indicates the axes, and the magnitude indicates the strength
//
//
void cyPhysics::Torque(pyVector3& torque)
{
hsAssert(0, "Who uses this?");
// must have a receiver!
/* if ( fRecvr.Count() > 0 )
{
// create message
plTorqueMsg* pMsg = TRACKED_NEW plTorqueMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->SetTorque(torque.fVector);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
*/
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Impulse
// PARAMETERS :
//
// PURPOSE : Add the given vector to the objects velocity
//
//
void cyPhysics::Impulse(pyVector3& impulse)
{
hsAssert(0, "Who uses this?");
// must have a receiver!
/* if ( fRecvr.Count() > 0 )
{
// create message
plImpulseMsg* pMsg = TRACKED_NEW plImpulseMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->SetImpulse(impulse.fVector);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
*/
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : ImpulseWithOffset
// PARAMETERS :
//
// PURPOSE : Apply the given impulse to the object at the given point in global space
// : Will impart torque if not applied to center of mass
//
//
void cyPhysics::ImpulseWithOffset(pyVector3& impulse, pyPoint3& offset)
{
hsAssert(0, "Who uses this?");
// must have a receiver!
/* if ( fRecvr.Count() > 0 )
{
// create message
plOffsetImpulseMsg* pMsg = TRACKED_NEW plOffsetImpulseMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->SetImpulse(impulse.fVector);
pMsg->SetPoint(offset.fPoint);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
*/
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : AngularImpulse
// PARAMETERS :
//
// PURPOSE : Add the given vector (representing a rotation axis and magnitude)
//
//
void cyPhysics::AngularImpulse(pyVector3& impulse)
{
hsAssert(0, "Who uses this?");
// must have a receiver!
/* if ( fRecvr.Count() > 0 )
{
// create message
plAngularImpulseMsg* pMsg = TRACKED_NEW plAngularImpulseMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->SetImpulse(impulse.fVector);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
*/
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Damp
// PARAMETERS :
//
// PURPOSE : Decrease all velocities on the given object.
// : A damp factor of 0 nulls them all entirely;
// : A damp factor of 1 leaves them alone.
//
//
void cyPhysics::Damp(hsScalar damp)
{
hsAssert(0, "Who uses this?");
// must have a receiver!
/* if ( fRecvr.Count() > 0 )
{
// create message
plDampMsg* pMsg = TRACKED_NEW plDampMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->SetDamp(damp);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
*/
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : ShiftMass
// PARAMETERS :
//
// PURPOSE : Shift the center of mass of the given object by the given
// : amount in the given direction.
//
//
void cyPhysics::ShiftMass(pyVector3& offset)
{
hsAssert(0, "Who uses this?");
// must have a receiver!
/* if ( fRecvr.Count() > 0 )
{
// create message
plShiftMassMsg* pMsg = TRACKED_NEW plShiftMassMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->SetOffset(offset.fVector);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
*/
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Suppress
// PARAMETERS : doSuppress: if true, remove the physical (see below)
// if false, add it back
//
// PURPOSE : Completely remove the physical, but keep it around so it
// can be added back later.
//
//
void cyPhysics::Suppress(bool doSuppress)
{
EnableT(!doSuppress);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : SetLinearVelocity
// PARAMETERS : velocity
//
// PURPOSE : Change the objects linear velocity to this
//
//
void cyPhysics::SetLinearVelocity(pyVector3& velocity)
{
if ( fRecvr.Count() > 0 )
{
// create message
plLinearVelocityMsg* pMsg = TRACKED_NEW plLinearVelocityMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->Velocity(velocity.fVector);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
}
void cyPhysics::SetAngularVelocity(pyVector3& angVel)
{
if ( fRecvr.Count() > 0 )
{
// create message
plAngularVelocityMsg* pMsg = TRACKED_NEW plAngularVelocityMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
if ( fSender )
pMsg->SetSender(fSender);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
pMsg->AngularVelocity(angVel.fVector);
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
}