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.
 
 
 
 
 

282 lines
8.7 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==*/
// SIMULATION MESSAGES
// Messages that influence the movement of a physically simulated object
#ifndef PLSIMINFLUENCEMSG_H
#define PLSIMINFLUENCEMSG_H
/*
#include "../../NucleusLib/pnMessage/plSimulationMsg.h"
#include "../../CoreLib/hsGeometry3.h"
////////////
//
// INFLUENCE
//
////////////
// PLSIMULATIONINFLUENCEMSG (virtual)
// base for messages that are used to push physical objects around in one way or another
class plSimInfluenceMsg : public plSimulationMsg
{
public:
plSimInfluenceMsg() : plSimulationMsg() {};
plSimInfluenceMsg(const plKey& sender, const plKey &receiver, double *time)
:plSimulationMsg(sender, receiver, time){};
CLASSNAME_REGISTER( plSimInfluenceMsg );
GETINTERFACE_ANY( plSimInfluenceMsg, plSimulationMsg);
virtual void Read(hsStream *stream, hsResMgr *mgr);
virtual void Write(hsStream *stream, hsResMgr *mgr);
};
// FORCES
/////////
// PLFORCEMSG
// apply a force to the center of mass of the receiver
class plForceMsg : public plSimInfluenceMsg
{
public:
plForceMsg() : plSimInfluenceMsg() { };
plForceMsg::plForceMsg(const plKey& sender, const plKey &receiver, hsVector3 &force)
:plSimInfluenceMsg(sender, receiver, nil), fForce(force) {};
plForceMsg::plForceMsg(const plKey& sender, const plKey &receiver, double *time, hsVector3 &force)
:plSimInfluenceMsg(sender, receiver, time), fForce(force) {};
CLASSNAME_REGISTER( plForceMsg );
GETINTERFACE_ANY( plForceMsg, plSimInfluenceMsg);
void Read(hsStream *stream, hsResMgr *mgr);
void Write(hsStream *stream, hsResMgr *mgr);
hsVector3 GetForce() const { return fForce; }
void SetForce(const hsVector3 &the_Force)
{ fForce = the_Force; }
protected:
hsVector3 fForce;
};
// PLOFFSETFORCE
// apply a force to the receiver as though it were being impacted at the
// given point in global space
class plOffsetForceMsg : public plForceMsg
{
public:
plOffsetForceMsg() : plForceMsg() { };
plOffsetForceMsg(const plKey& sender, const plKey &receiver, hsVector3 &force, hsPoint3 &point)
:plForceMsg(sender, receiver, nil, force), fPoint(point) {};
plOffsetForceMsg(const plKey& sender, const plKey &receiver, double *time, hsVector3 &force, hsPoint3 &point)
:plForceMsg(sender, receiver, time, force), fPoint(point) {};
CLASSNAME_REGISTER( plOffsetForceMsg );
GETINTERFACE_ANY( plOffsetForceMsg, plForceMsg);
void Read(hsStream *stream, hsResMgr *mgr);
void Write(hsStream *stream, hsResMgr *mgr);
hsPoint3 GetPoint() const { return fPoint; }
void SetPoint(const hsPoint3 &the_Point)
{ fPoint = the_Point; }
protected:
hsPoint3 fPoint;
};
// PLTORQUEMSG
// Apply the given torque force to the body
// The vector indicates the axes, and the magnitude indicates the strength
class plTorqueMsg : public plSimInfluenceMsg
{
public:
plTorqueMsg() : plSimInfluenceMsg() { };
plTorqueMsg(const plKey& sender, const plKey &receiver, hsVector3 & torque)
:plSimInfluenceMsg(sender, receiver, nil), fTorque(torque) {};
CLASSNAME_REGISTER( plTorqueMsg );
GETINTERFACE_ANY( plTorqueMsg, plSimInfluenceMsg);
void Read(hsStream *stream, hsResMgr *mgr);
void Write(hsStream *stream, hsResMgr *mgr);
hsVector3 GetTorque() const { return fTorque; }
void SetTorque(const hsVector3 &the_Torque) { fTorque = the_Torque; }
protected:
hsVector3 fTorque;
};
// IMPULSES
///////////
// PLIMPULSE
// Add the given vector to the objects velocity
class plImpulseMsg : public plSimInfluenceMsg
{
public:
plImpulseMsg() : plSimInfluenceMsg() { };
plImpulseMsg(const plKey& sender, const plKey &receiver, hsVector3 &impulse)
:plSimInfluenceMsg(sender, receiver, nil), fImpulse(impulse) {};
plImpulseMsg(const plKey& sender, const plKey &receiver, double *time, hsVector3 &impulse)
:plSimInfluenceMsg(sender, receiver, time), fImpulse(impulse) {};
CLASSNAME_REGISTER( plImpulseMsg );
GETINTERFACE_ANY( plImpulseMsg, plSimInfluenceMsg);
void Read(hsStream *stream, hsResMgr *mgr);
void Write(hsStream *stream, hsResMgr *mgr);
hsVector3 GetImpulse() const { return fImpulse; }
void SetImpulse(const hsVector3 &the_Impulse) { fImpulse = the_Impulse; }
protected:
hsVector3 fImpulse;
};
// PLOFFSETIMPULSE
// Apply the given impulse to the object at the given point in global space
// Will impart torque if not applied to center of mass
class plOffsetImpulseMsg : public plImpulseMsg
{
public:
plOffsetImpulseMsg() : plImpulseMsg() { };
plOffsetImpulseMsg(const plKey& sender, const plKey &receiver, hsVector3 & impulse, hsPoint3 &point)
: plImpulseMsg(sender, receiver, impulse), fPoint(point) {};
plOffsetImpulseMsg(const plKey& sender, const plKey &receiver, double *time, hsVector3 & impulse, hsPoint3 &point)
: plImpulseMsg(sender, receiver, time, impulse), fPoint(point) {};
CLASSNAME_REGISTER( plOffsetImpulseMsg );
GETINTERFACE_ANY( plOffsetImpulseMsg, plImpulseMsg);
void Read(hsStream *stream, hsResMgr *mgr);
void Write(hsStream *stream, hsResMgr *mgr);
hsPoint3 GetPoint() const { return fPoint; }
void SetPoint(const hsPoint3 &the_Point) { fPoint = the_Point; }
protected:
hsPoint3 fPoint;
};
// PLANGULARIMPULSE
// Add the given vector (representing a rotation axis and magnitude)
// to the
class plAngularImpulseMsg : public plSimInfluenceMsg
{
public:
plAngularImpulseMsg() : plSimInfluenceMsg() { };
plAngularImpulseMsg(const plKey& sender, const plKey &receiver, hsVector3 &impulse)
: plSimInfluenceMsg(sender, receiver, nil), fImpulse(impulse) {};
plAngularImpulseMsg(const plKey& sender, const plKey &receiver, double *time, hsVector3 &impulse)
: plSimInfluenceMsg(sender, receiver, time), fImpulse(impulse) {};
CLASSNAME_REGISTER( plAngularImpulseMsg );
GETINTERFACE_ANY( plAngularImpulseMsg, plSimInfluenceMsg);
void Read(hsStream *stream, hsResMgr *mgr);
void Write(hsStream *stream, hsResMgr *mgr);
hsVector3 GetImpulse() const { return fImpulse; }
void SetImpulse(const hsVector3 &the_Impulse)
{ fImpulse = the_Impulse; }
protected:
hsVector3 fImpulse;
};
// MISCELLANEOUS INFLUENCES
///////////////////////////
// PLDAMPMSG
// Decrease all velocities on the given object.
// A damp factor of 0 nulls them all entirely;
// A damp factor of 1 leaves them alone.
class plDampMsg : public plSimInfluenceMsg
{
public:
plDampMsg() : plSimInfluenceMsg() { };
plDampMsg(const plKey& sender, const plKey &receiver, float dampFactor)
: plSimInfluenceMsg(sender, receiver, nil), fDamp(dampFactor) {};
plDampMsg(const plKey& sender, const plKey &receiver, double *time, float dampFactor)
: plSimInfluenceMsg(sender, receiver, time), fDamp(dampFactor) {};
CLASSNAME_REGISTER( plDampMsg );
GETINTERFACE_ANY( plDampMsg, plSimInfluenceMsg);
void Read(hsStream *stream, hsResMgr *mgr);
void Write(hsStream *stream, hsResMgr *mgr);
float GetDamp() const { return fDamp; }
void SetDamp( float the_Damp )
{ fDamp = the_Damp; }
protected:
float fDamp;
};
// PLSHIFTCENTERMSG
// Shift the center of mass of the given object by the given
// amount in the given direction.
class plShiftMassMsg : public plSimInfluenceMsg
{
public:
plShiftMassMsg() : plSimInfluenceMsg() { };
plShiftMassMsg(const plKey& sender, const plKey &receiver, hsVector3 &offset)
:plSimInfluenceMsg(sender, receiver, nil), fOffset(offset) {};
plShiftMassMsg(const plKey& sender, const plKey &receiver, double *time, hsVector3 &offset)
:plSimInfluenceMsg(sender, receiver, time), fOffset(offset) {};
CLASSNAME_REGISTER( plShiftMassMsg );
GETINTERFACE_ANY( plShiftMassMsg, plSimInfluenceMsg);
void Read(hsStream *stream, hsResMgr *mgr);
void Write(hsStream *stream, hsResMgr *mgr);
hsVector3 GetOffset() const { return fOffset; }
void SetOffset(const hsVector3 &the_Offset)
{ fOffset = the_Offset; }
protected:
hsVector3 fOffset;
};
*/
#endif // PLSIMINFLUENCEMSG_H