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.
289 lines
11 KiB
289 lines
11 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/>. |
|
|
|
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==*/ |
|
/** \file plAnimStage.h |
|
An intelligent avatar animation for use in a generic brain. |
|
|
|
\ingroup Avatar |
|
*/ |
|
#ifndef PL_ANIM_STAGE_INC |
|
#define PL_ANIM_STAGE_INC |
|
|
|
#include "hsMatrix44.h" |
|
#include "hsStlUtils.h" |
|
#include "../pnFactory/plCreatable.h" |
|
|
|
class plMessage; |
|
class plAGAnimInstance; |
|
class plArmatureMod; |
|
class plArmatureMod; |
|
class hsStream; |
|
class hsResMgr; |
|
class plArmatureBrain; |
|
class plDebugText; |
|
class plMultistageBehMod; |
|
|
|
// PLANIMSTAGE |
|
// In a multi-stage behavior, each stage is specified in one of these classes |
|
/** \class plAnimStage |
|
An animation stage is an intelligent wrapper for an avatar animation. |
|
It provides specific control over: |
|
- how the progress of the animation is controlled |
|
- when the animation optionally sends messages about its progress |
|
- whether the animation naturally progresses to the next animation after finishing |
|
- how many times the animation loops |
|
- whether the animation works in world space or a local space |
|
*/ |
|
class plAnimStage : public plCreatable |
|
{ |
|
public: |
|
// -- forward declarations of types -- |
|
// Points to send notifications at |
|
/** \enum NotifyType |
|
Controls when notification messages are sent by the stage. |
|
These can be used instead of or in combination with |
|
normal animation callback messages. |
|
Where the messages are sent is determined by the controlling |
|
brain. |
|
These are mask bits; you can have any number of them on at a time. |
|
*/ |
|
enum NotifyType |
|
{ |
|
kNotifyEnter = 0x1, /// Send when we enter the stage from |
|
kNotifyLoop = 0x2, /// Sent each time the stage loops |
|
kNotifyAdvance = 0x4, /// Sent when we advance out of the stage |
|
kNotifyRegress = 0x8 /// Sent when we regress out of the stage |
|
}; |
|
|
|
/** \enum ForwardType |
|
What makes the stage progress in a forward direction? |
|
You can only choose one of these, although a stage will always respond |
|
to forward movement messages. */ |
|
enum ForwardType { |
|
kForwardNone, /// move forward only in response to messages |
|
kForwardKey, /// move forward when the user presses the move forward key |
|
kForwardAuto, /// move forward automatically |
|
kForwardMax, |
|
} fForwardType; |
|
|
|
/** \enum BackType |
|
What makes the stage progress in a backward direction? |
|
You can only choose one of these, although a stage will always respond |
|
to backward movement message. */ |
|
enum BackType { |
|
kBackNone, /// move backward only in response to messages |
|
kBackKey, /// move backward when the user presses the move backward key |
|
kBackAuto, /// move backward automatically (only when entered from end) |
|
kBackMax, |
|
} fBackType; |
|
|
|
/** When do we advance to the next stage? |
|
This is typically asked when we're reached the end of the current stage, |
|
but for some advance types, you can interrupt the current stage and |
|
advance automatically on certain events. */ |
|
enum AdvanceType { |
|
kAdvanceNone, /// advance only when told to via a message |
|
kAdvanceOnMove, /// advance whenever the user hits a movement key |
|
kAdvanceAuto, /// advance automatically at the end of the current stage |
|
kAdvanceOnAnyKey, /// advance when any key is pressed |
|
kAdvanceMax, |
|
} fAdvanceType; |
|
|
|
/** When do we regress to the previous stage? |
|
This is typically asked when we've reached the beginning of the current stage |
|
and we still trying to move backwards. |
|
For some regress types, however, you can abort this stage automatically when |
|
certain events occur. */ |
|
enum RegressType { |
|
kRegressNone, // regress only when told to via a message |
|
kRegressOnMove, // regress whenever the user hits a movement key |
|
kRegressAuto, // regress automatically when we reach the beginning of the current |
|
/// stage and we're still moving backwards |
|
kRegressOnAnyKey, // regress when any key is pressed |
|
kRegressMax, |
|
} fRegressType; |
|
|
|
/** Default constructor, used primarily by the class factory. */ |
|
plAnimStage(); |
|
/** Canonical constructor. |
|
\param animName The name of the animation controlled by this stage. |
|
\param notify Flags for when to send notify messages |
|
\param forward How to control forward movement |
|
\param backward How to control backward movement |
|
\param regress When to regress to the previous stage |
|
\param advance When to advance to the next stage |
|
\param loops How many times to loop this stage after its initial playthrough. |
|
i.e. If you only want it to play once, set loops to 0 |
|
To make it play forever, pass in -1 for loops. |
|
\param localize Align the origin of the animation to the avatar's position |
|
when the stage start's playing. Only relevant if the |
|
animation attempts to reposition the avatar by having a |
|
channel attached to the avatar's handle. |
|
*/ |
|
plAnimStage(const char *animName, |
|
UInt8 notify, |
|
ForwardType forward, |
|
BackType backward, |
|
AdvanceType advance, |
|
RegressType regress, |
|
int loops); |
|
|
|
/** Most complete constructor. Specifies every aspect of the stage. Differs from |
|
the next-most-complete constructor by the presence of doAdvanceTo, advanceTo, |
|
doRegressTo, and regressTo. These parameters allow you to specify what stages |
|
will be played after this one, depending on which direction the stage is |
|
moving. |
|
*/ |
|
plAnimStage(const char *animName, |
|
UInt8 notify, |
|
ForwardType forward, |
|
BackType back, |
|
AdvanceType advance, |
|
RegressType regress, |
|
int loops, |
|
bool doAdvanceTo, |
|
int advanceTo, |
|
bool doRegressTo, |
|
int regressTo); |
|
|
|
/** Simple and common constructor: moves forward automatically, advances automatically, |
|
no reverse, no regress. |
|
\param animName The name of the animation controlled by this stage. |
|
\param notify Flags for when to send notify messages |
|
*/ |
|
plAnimStage(const char *animName, UInt8 notify); |
|
virtual ~plAnimStage(); |
|
const plAnimStage& operator=(const plAnimStage& src); |
|
|
|
plAGAnimInstance * Attach(plArmatureMod *armature, plArmatureBrain *brain, float initialBlend, double time); |
|
int Detach(plArmatureMod *armature); |
|
void Reset(double time, plArmatureMod *avMod, bool atStart); |
|
void ResetAtTime(double time, float localTime, plArmatureMod *avMod); |
|
bool MoveRelative(double worldTime, float delta, float &overage, plArmatureMod *avMod); |
|
|
|
/** The name of the animation associated with this stage. */ |
|
const char * GetAnimName(); |
|
|
|
ForwardType GetForwardType(); |
|
void SetForwardType(ForwardType t); |
|
BackType GetBackType(); |
|
void SetBackType(BackType t); |
|
AdvanceType GetAdvanceType(); |
|
void SetAdvanceType(AdvanceType t); |
|
RegressType GetRegressType(); |
|
void SetRegresstype(RegressType t); |
|
UInt32 GetNotifyFlags(); |
|
void SetNotifyFlags(UInt32 newFlags); |
|
int GetNumLoops(); |
|
void SetNumLoops(int loops); |
|
int GetLoopValue(); |
|
void SetLoopValue(int loop); |
|
float GetLocalTime(); |
|
void SetLocalTime(float time, hsBool noCallbacks = false); |
|
float GetLength(); |
|
|
|
void SetMod(plMultistageBehMod* p) { fMod = p; } // for returning ID#'s to python scripts: |
|
plMultistageBehMod* GetMod() { return fMod; } |
|
bool GetIsAttached(); |
|
void SetIsAttached(bool status); |
|
|
|
int GetNextStage(int curStage); |
|
int GetPrevStage(int curStage); |
|
plAGAnimInstance *GetAnimInstance() const { return fAnimInstance; }; |
|
bool GetReverseOnIdle() { return fReverseOnIdle; } |
|
void SetReverseOnIdle(bool onOff) { fReverseOnIdle = onOff; } |
|
void DumpDebug(bool active, int &x, int &y, int lineHeight, char *strBuf, plDebugText &debugTxt); |
|
|
|
// STANDARD PLASMA PROTOCOL |
|
virtual void Read(hsStream *stream, hsResMgr *mgr); |
|
virtual void Write(hsStream *stream, hsResMgr *mgr); |
|
|
|
virtual void SaveAux(hsStream *stream, hsResMgr *mgr); |
|
virtual void LoadAux(hsStream *stream, hsResMgr *mgr, double time); |
|
|
|
CLASSNAME_REGISTER( plAnimStage ); |
|
GETINTERFACE_ANY( plAnimStage, plCreatable); |
|
|
|
protected: |
|
bool IMoveBackward(double worldTime, float delta, float &underrun, plArmatureMod *avMod); |
|
bool IMoveForward(double worldTime, float delta, float &overrun, plArmatureMod *avMod); |
|
|
|
bool INeedFadeIn(); |
|
bool INeedFadeOut(); |
|
|
|
bool ITryAdvance(plArmatureMod *avMod); |
|
bool ITryRegress(plArmatureMod *avMod); |
|
|
|
hsBool ISendNotify(UInt32 notifyMask, UInt32 notifyType, plArmatureMod *armature, plArmatureBrain *brain); |
|
|
|
char *fAnimName; // the name of our animation |
|
UInt8 fNotify; // flags for which events will cause notification events |
|
int fLoops; // how many times will this animation loop (after initial playthrough?) |
|
|
|
bool fDoAdvanceTo; // advance to a specific stage instead of n + 1 |
|
UInt32 fAdvanceTo; // the stage to advance to, provided fDoAdvanceTo is true |
|
bool fDoRegressTo; // regress to a specific stage instaed of n - 1 |
|
UInt32 fRegressTo; // the stage to regress true, provided fDoRegressTo is true |
|
|
|
// --- these are derived & kept for bookkeeping |
|
plAGAnimInstance *fAnimInstance; |
|
plArmatureMod *fArmature; |
|
plArmatureBrain *fBrain; // only valid while attached |
|
plMultistageBehMod *fMod; // where we came from |
|
float fLocalTime; // our time within the animation |
|
float fLength; // the length of our animation? |
|
int fCurLoop; // which loop are we currently in? |
|
bool fAttached; // in the middle of reloading |
|
bool fAnimatedHandle; // this animation moves the handle |
|
UInt8 fSentNotifies; // which notifies have we sent? |
|
bool fReverseOnIdle; // reverse our key interpretation if we stop. this is a special |
|
// case for down ladders, for which the forward button means "keep going down" |
|
// if you hold it down the whole time, but means "go up" if you press it |
|
// again after releasing it. |
|
bool fDone; // We've reached the end of the anim -- may be fading out, or paused. |
|
|
|
}; |
|
|
|
class plAnimStageVec : public std::vector<plAnimStage*> |
|
{ |
|
}; |
|
|
|
#endif // PL_ANIM_STAGE_INC
|
|
|