mirror of
https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
synced 2025-07-17 10:52:46 +00:00
Convert custom HeadSpin integer types to standard types from stdint.h
This commit is contained in:
@ -522,7 +522,7 @@ bool plATCAnim::GetLoop(const char *name, float &start, float &end) const
|
||||
|
||||
// GetLoop --------------------------------------------------------
|
||||
// --------
|
||||
bool plATCAnim::GetLoop(UInt32 num, float &start, float &end) const
|
||||
bool plATCAnim::GetLoop(uint32_t num, float &start, float &end) const
|
||||
{
|
||||
if (num >= fLoops.size())
|
||||
return false;
|
||||
@ -542,7 +542,7 @@ bool plATCAnim::GetLoop(UInt32 num, float &start, float &end) const
|
||||
|
||||
// GetNumLoops ----------------------
|
||||
// ------------
|
||||
UInt32 plATCAnim::GetNumLoops() const
|
||||
uint32_t plATCAnim::GetNumLoops() const
|
||||
{
|
||||
return fLoops.size();
|
||||
}
|
||||
@ -585,14 +585,14 @@ void plATCAnim::AddStopPoint(hsScalar time)
|
||||
|
||||
// NumStopPoints ----------------
|
||||
// --------------
|
||||
UInt32 plATCAnim::NumStopPoints()
|
||||
uint32_t plATCAnim::NumStopPoints()
|
||||
{
|
||||
return fStopPoints.size();
|
||||
}
|
||||
|
||||
// GetStopPoint --------------------------
|
||||
// -------------
|
||||
hsScalar plATCAnim::GetStopPoint(UInt32 i)
|
||||
hsScalar plATCAnim::GetStopPoint(uint32_t i)
|
||||
{
|
||||
hsAssert(i < fStopPoints.size(), "Invalid index for GetStopPoint");
|
||||
return fStopPoints[i];
|
||||
@ -642,7 +642,7 @@ void plEmoteAnim::Write(hsStream *stream, hsResMgr *mgr)
|
||||
plATCAnim::Write(stream, mgr);
|
||||
stream->WriteLEScalar(fFadeIn);
|
||||
stream->WriteLEScalar(fFadeOut);
|
||||
stream->WriteByte(static_cast<UInt8>(fBodyUsage));
|
||||
stream->WriteByte(static_cast<uint8_t>(fBodyUsage));
|
||||
}
|
||||
|
||||
// GetBodyUsage ----------------------------------------
|
||||
|
||||
@ -264,8 +264,8 @@ public:
|
||||
to make an animation slow down gradually when you stop it.
|
||||
The types are defined in plAnimEaseTypes.h
|
||||
*/
|
||||
virtual UInt8 GetEaseInType() const { return fEaseInType; }
|
||||
void SetEaseInType(UInt8 type) { fEaseInType = type; }
|
||||
virtual uint8_t GetEaseInType() const { return fEaseInType; }
|
||||
void SetEaseInType(uint8_t type) { fEaseInType = type; }
|
||||
|
||||
/** Set the length of time the ease-in should take. */
|
||||
virtual hsScalar GetEaseInLength() const { return fEaseInLength; }
|
||||
@ -283,9 +283,9 @@ public:
|
||||
void SetEaseInMax(hsScalar length) { fEaseInMax = length; }
|
||||
|
||||
/** The curve type for the ease out. */
|
||||
virtual UInt8 GetEaseOutType() const { return fEaseOutType; }
|
||||
virtual uint8_t GetEaseOutType() const { return fEaseOutType; }
|
||||
/** The curve type for the ease out. */
|
||||
void SetEaseOutType(UInt8 type) { fEaseOutType = type; }
|
||||
void SetEaseOutType(uint8_t type) { fEaseOutType = type; }
|
||||
|
||||
/** The length of time for the ease out. */
|
||||
virtual hsScalar GetEaseOutLength() const { return fEaseOutLength; }
|
||||
@ -311,9 +311,9 @@ public:
|
||||
\param end will hold the end time of the loop */
|
||||
bool GetLoop(const char *name, float &start, float &end) const;
|
||||
/** Lets you get a loop by index instead of name. */
|
||||
bool GetLoop(UInt32 num, float &start, float &end) const;
|
||||
bool GetLoop(uint32_t num, float &start, float &end) const;
|
||||
/** Returns the number of loops defined on this anim. */
|
||||
UInt32 GetNumLoops() const;
|
||||
uint32_t GetNumLoops() const;
|
||||
|
||||
/** Add a marker to the animation. Markers can be used
|
||||
for callbacks or for goto comands. A marker is a simple
|
||||
@ -329,10 +329,10 @@ public:
|
||||
at the defined time. */
|
||||
void AddStopPoint(hsScalar time);
|
||||
/** Return the number of stop points defined for this animation. */
|
||||
UInt32 NumStopPoints();
|
||||
uint32_t NumStopPoints();
|
||||
/** Get the time corresponding to the given stop point. Stop points
|
||||
are numbered in the order they were added. */
|
||||
hsScalar GetStopPoint(UInt32 i);
|
||||
hsScalar GetStopPoint(uint32_t i);
|
||||
/** Function to check for a zero-length loop, and set it to
|
||||
the anim's start/end instead */
|
||||
void CheckLoop();
|
||||
@ -353,8 +353,8 @@ protected:
|
||||
hsScalar fLoopEnd; /// when you reach this point, loop back
|
||||
bool fLoop; /// do we loop?
|
||||
|
||||
UInt8 fEaseInType; /// the type (none/linear/spline) of our ease-in curve, if any
|
||||
UInt8 fEaseOutType; /// the type (none/linear/spline) of our ease-out curve, if any
|
||||
uint8_t fEaseInType; /// the type (none/linear/spline) of our ease-in curve, if any
|
||||
uint8_t fEaseOutType; /// the type (none/linear/spline) of our ease-out curve, if any
|
||||
hsScalar fEaseInLength; /// the length of time our ease-in curve takes
|
||||
hsScalar fEaseInMin; /// minimum (initial) value of our ease-in
|
||||
hsScalar fEaseInMax; /// maximum (final) value of our ease-in
|
||||
|
||||
@ -91,7 +91,7 @@ extern const char *gGlobalChannelName = nil;
|
||||
// ctor -------------------------------------------------------------------
|
||||
// -----
|
||||
plAGAnimInstance::plAGAnimInstance(plAGAnim * anim, plAGMasterMod * master,
|
||||
hsScalar blend, UInt16 blendPriority, hsBool cache,
|
||||
hsScalar blend, uint16_t blendPriority, hsBool cache,
|
||||
bool useAmplitude)
|
||||
: fAnimation(anim),
|
||||
fMaster(master),
|
||||
@ -480,14 +480,14 @@ void plAGAnimInstance::FadeAndDetach(hsScalar goal, hsScalar rate)
|
||||
|
||||
// Fade --------------------------------------------------------------------------------
|
||||
// -----
|
||||
void plAGAnimInstance::Fade(hsScalar goal, hsScalar rate, UInt8 type /* = kFadeBlend */)
|
||||
void plAGAnimInstance::Fade(hsScalar goal, hsScalar rate, uint8_t type /* = kFadeBlend */)
|
||||
{
|
||||
ISetupFade(goal, rate, false, type);
|
||||
}
|
||||
|
||||
// ISetupFade --------------------------------------------------------------------------
|
||||
// -----------
|
||||
void plAGAnimInstance::ISetupFade(hsScalar goal, hsScalar rate, bool detach, UInt8 type)
|
||||
void plAGAnimInstance::ISetupFade(hsScalar goal, hsScalar rate, bool detach, uint8_t type)
|
||||
{
|
||||
if (rate == 0)
|
||||
{
|
||||
@ -542,7 +542,7 @@ void plAGAnimInstance::ISetupFade(hsScalar goal, hsScalar rate, bool detach, UIn
|
||||
class agAlloc
|
||||
{
|
||||
public:
|
||||
agAlloc(plAGChannel *object, const char *chanName, const char *animName, UInt16 classIndex)
|
||||
agAlloc(plAGChannel *object, const char *chanName, const char *animName, uint16_t classIndex)
|
||||
: fObject(object),
|
||||
fClassIndex(classIndex)
|
||||
{
|
||||
@ -559,13 +559,13 @@ public:
|
||||
plAGChannel *fObject;
|
||||
char *fChannelName;
|
||||
char *fAnimName;
|
||||
UInt16 fClassIndex;
|
||||
uint16_t fClassIndex;
|
||||
};
|
||||
|
||||
typedef std::map<plAGChannel *, agAlloc *> agAllocMap;
|
||||
static agAllocMap gAGAllocs;
|
||||
|
||||
void RegisterAGAlloc(plAGChannel *object, const char *chanName, const char *animName, UInt16 classIndex)
|
||||
void RegisterAGAlloc(plAGChannel *object, const char *chanName, const char *animName, uint16_t classIndex)
|
||||
{
|
||||
gAGAllocs[object] = TRACKED_NEW agAlloc(object, chanName, animName, classIndex);
|
||||
}
|
||||
@ -581,7 +581,7 @@ void DumpAGAllocs()
|
||||
{
|
||||
agAlloc * al = (*i).second;
|
||||
|
||||
UInt16 realClassIndex = al->fObject->ClassIndex();
|
||||
uint16_t realClassIndex = al->fObject->ClassIndex();
|
||||
|
||||
hsStatusMessageF("agAlloc: an: %s ch: %s, cl: %s", al->fAnimName, al->fChannelName, plFactory::GetNameOfClass(realClassIndex));
|
||||
|
||||
|
||||
@ -98,7 +98,7 @@ public:
|
||||
This attaches the animation channels to the channels of
|
||||
the master modifier and creates all the bookkeeping structures
|
||||
necessary to undo it later. */
|
||||
plAGAnimInstance(plAGAnim * anim, plAGMasterMod * master, hsScalar blend, UInt16 blendPriority, hsBool cache, bool useAmplitude);
|
||||
plAGAnimInstance(plAGAnim * anim, plAGMasterMod * master, hsScalar blend, uint16_t blendPriority, hsBool cache, bool useAmplitude);
|
||||
|
||||
/** Destructor. Removes the animation from the scene objects it's attached to. */
|
||||
virtual ~plAGAnimInstance();
|
||||
@ -172,7 +172,7 @@ public:
|
||||
\param goal is the desired blend strength
|
||||
\param rate is in blend units per second
|
||||
\type is either kFadeBlend or kFadeAmp */
|
||||
void Fade(hsScalar goal, hsScalar rate, UInt8 type = kFadeBlend);
|
||||
void Fade(hsScalar goal, hsScalar rate, uint8_t type = kFadeBlend);
|
||||
|
||||
/** Fade the animation and detach it after the fade is complete.
|
||||
Extremely useful for situations where the controlling logic
|
||||
@ -222,7 +222,7 @@ public:
|
||||
void SearchForGlobals(); // Util function to setup SDL channels
|
||||
protected:
|
||||
/** Set up bookkeeping for a fade. */
|
||||
void ISetupFade(hsScalar goal, hsScalar rate, bool detach, UInt8 type);
|
||||
void ISetupFade(hsScalar goal, hsScalar rate, bool detach, uint8_t type);
|
||||
|
||||
void IRegisterDetach(const char *channelName, plAGChannel *channel);
|
||||
|
||||
@ -264,7 +264,7 @@ protected:
|
||||
extern const char *gGlobalAnimName;
|
||||
extern const char *gGlobalChannelName;
|
||||
|
||||
void RegisterAGAlloc(plAGChannel *object, const char *chanName, const char *animName, UInt16 classIndex);
|
||||
void RegisterAGAlloc(plAGChannel *object, const char *chanName, const char *animName, uint16_t classIndex);
|
||||
void UnRegisterAGAlloc(plAGChannel *object);
|
||||
void DumpAGAllocs();
|
||||
|
||||
|
||||
@ -117,8 +117,8 @@ plAGApplicator *plAGApplicator::CloneWithChannel(plAGChannel *channel)
|
||||
|
||||
hsBool plAGApplicator::CanBlend(plAGApplicator *app)
|
||||
{
|
||||
UInt16 ourClass = ClassIndex();
|
||||
UInt16 theirClass = app->ClassIndex();
|
||||
uint16_t ourClass = ClassIndex();
|
||||
uint16_t theirClass = app->ClassIndex();
|
||||
|
||||
return(ourClass == theirClass);
|
||||
|
||||
@ -175,7 +175,7 @@ plSimulationInterface * plAGApplicator::IGetSI(const plAGModifier * modifier) co
|
||||
return modifier->LeakSI();
|
||||
}
|
||||
|
||||
plObjInterface * plAGApplicator::IGetGI(const plAGModifier * modifier, UInt16 classIdx) const
|
||||
plObjInterface * plAGApplicator::IGetGI(const plAGModifier * modifier, uint16_t classIdx) const
|
||||
{
|
||||
return modifier->LeakGI(classIdx);
|
||||
}
|
||||
|
||||
@ -159,7 +159,7 @@ protected:
|
||||
plCoordinateInterface * IGetCI(const plAGModifier *modifier) const;
|
||||
plDrawInterface * IGetDI(const plAGModifier *modifier) const;
|
||||
plSimulationInterface * IGetSI(const plAGModifier *modifier) const;
|
||||
plObjInterface * IGetGI(const plAGModifier *modifier, UInt16 classIdx) const;
|
||||
plObjInterface * IGetGI(const plAGModifier *modifier, uint16_t classIdx) const;
|
||||
|
||||
// Allow plAGModifier to declare IGet?? as friends
|
||||
friend class plAGModifier;
|
||||
|
||||
@ -218,7 +218,7 @@ plProfile_CreateTimer("AnimatingPhysicals", "Animation", AnimatingPhysicals);
|
||||
plProfile_CreateTimer("StoppedAnimPhysicals", "Animation", StoppedAnimPhysicals);
|
||||
|
||||
// IEVAL
|
||||
hsBool plAGMasterMod::IEval(double secs, hsScalar del, UInt32 dirty)
|
||||
hsBool plAGMasterMod::IEval(double secs, hsScalar del, uint32_t dirty)
|
||||
{
|
||||
if (fFirstEval)
|
||||
{
|
||||
@ -388,7 +388,7 @@ plAGModifier * plAGMasterMod::IFindChannelMod(const plSceneObject *SO, const cha
|
||||
// ATTACHANIMATIONBLENDED(anim, blend)
|
||||
plAGAnimInstance * plAGMasterMod::AttachAnimationBlended(plAGAnim *anim,
|
||||
hsScalar blendFactor /* = 0 */,
|
||||
UInt16 blendPriority /* plAGMedBlendPriority */,
|
||||
uint16_t blendPriority /* plAGMedBlendPriority */,
|
||||
hsBool cache /* = false */)
|
||||
{
|
||||
plAGAnimInstance *instance = nil;
|
||||
@ -421,7 +421,7 @@ plAGAnimInstance * plAGMasterMod::AttachAnimationBlended(plAGAnim *anim,
|
||||
}
|
||||
|
||||
// ATTACHANIMATIONBLENDED(name, blend)
|
||||
plAGAnimInstance * plAGMasterMod::AttachAnimationBlended(const char *name, hsScalar blendFactor /* = 0 */, UInt16 blendPriority, hsBool cache /* = false */)
|
||||
plAGAnimInstance * plAGMasterMod::AttachAnimationBlended(const char *name, hsScalar blendFactor /* = 0 */, uint16_t blendPriority, hsBool cache /* = false */)
|
||||
{
|
||||
plAGAnimInstance *instance = nil;
|
||||
plAGAnim *anim = plAGAnim::FindAnim(name);
|
||||
@ -442,7 +442,7 @@ void plAGMasterMod::PlaySimpleAnim(const char *name)
|
||||
if (FindAnimInstance(name))
|
||||
return;
|
||||
|
||||
instance = AttachAnimationBlended(anim, 1.f, (UInt16)kAGMaxBlendPriority, false);
|
||||
instance = AttachAnimationBlended(anim, 1.f, (uint16_t)kAGMaxBlendPriority, false);
|
||||
}
|
||||
|
||||
if (instance)
|
||||
@ -798,7 +798,7 @@ hsBool plAGMasterMod::HasRunningAnims()
|
||||
//
|
||||
// Send SDL sendState msg to object's plAGMasterSDLModifier
|
||||
//
|
||||
hsBool plAGMasterMod::DirtySynchState(const char* SDLStateName, UInt32 synchFlags)
|
||||
hsBool plAGMasterMod::DirtySynchState(const char* SDLStateName, uint32_t synchFlags)
|
||||
{
|
||||
if(GetNumTargets() > 0 && (!fIsGrouped || fIsGroupMaster))
|
||||
{
|
||||
|
||||
@ -107,13 +107,13 @@ public:
|
||||
If there's no animation already attached to blend with, the
|
||||
animation will be attached at full strength. */
|
||||
plAGAnimInstance *AttachAnimationBlended(plAGAnim *anim, hsScalar blendFactor = 0,
|
||||
UInt16 blendPriority = kAGMedBlendPriority,
|
||||
uint16_t blendPriority = kAGMedBlendPriority,
|
||||
hsBool cache = false);
|
||||
|
||||
/** Look up the given animation by name and attach it
|
||||
with the given blend factor. */
|
||||
plAGAnimInstance *AttachAnimationBlended(const char *name, hsScalar blendFactor = 0,
|
||||
UInt16 blendPriority = kAGMedBlendPriority,
|
||||
uint16_t blendPriority = kAGMedBlendPriority,
|
||||
hsBool cache = false);
|
||||
|
||||
/** Play a simple anim (one that doesn't affect root) once and auto detach.
|
||||
@ -210,7 +210,7 @@ public:
|
||||
virtual void Read(hsStream * stream, hsResMgr *mgr);
|
||||
|
||||
hsBool HasRunningAnims();
|
||||
hsBool DirtySynchState(const char* SDLStateName, UInt32 synchFlags);
|
||||
hsBool DirtySynchState(const char* SDLStateName, uint32_t synchFlags);
|
||||
|
||||
CLASSNAME_REGISTER( plAGMasterMod );
|
||||
GETINTERFACE_ANY( plAGMasterMod, plModifier );
|
||||
@ -220,7 +220,7 @@ protected:
|
||||
plAGModifier * ICacheChannelMod(plAGModifier *mod) const;
|
||||
plAGModifier * IFindChannelMod(const plSceneObject *obj, const char *name) const;
|
||||
|
||||
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty);
|
||||
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty);
|
||||
|
||||
virtual void IApplyDynamic() {}; // dummy function required by base class
|
||||
|
||||
|
||||
@ -54,7 +54,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
||||
char plAGMasterSDLModifier::AGMasterVarNames::kStrAtcs[]="atcs";
|
||||
char plAGMasterSDLModifier::AGMasterVarNames::kStrBlends[]="blends";
|
||||
|
||||
UInt32 plAGMasterSDLModifier::IApplyModFlags(UInt32 sendFlags)
|
||||
uint32_t plAGMasterSDLModifier::IApplyModFlags(uint32_t sendFlags)
|
||||
{
|
||||
// ugly hack so bug light animation state isn't stored on the server
|
||||
if (stricmp(GetTarget()->GetKeyName(), "RTOmni-BugLightTest") == 0)
|
||||
@ -80,7 +80,7 @@ void plAGMasterSDLModifier::IPutBlends(plStateDataRecord* state, plAGMasterMod*
|
||||
int i;
|
||||
for(i=0;i<numBlends; i++)
|
||||
{
|
||||
blendsVar->Set((UInt8)(agMaster->GetAnimInstance(i)->GetBlend() * 255), i);
|
||||
blendsVar->Set((uint8_t)(agMaster->GetAnimInstance(i)->GetBlend() * 255), i);
|
||||
}
|
||||
}
|
||||
|
||||
@ -149,7 +149,7 @@ void plAGMasterSDLModifier::ISetCurrentBlends(const plStateDataRecord* state, pl
|
||||
|
||||
for (i=0;i<blendsVar->GetCount();i++)
|
||||
{
|
||||
UInt8 blend;
|
||||
uint8_t blend;
|
||||
blendsVar->Get(&blend, i);
|
||||
objAGMaster->GetAnimInstance(i)->SetBlend(blend / 255.f);
|
||||
}
|
||||
|
||||
@ -70,7 +70,7 @@ protected:
|
||||
void IPutCurrentStateIn(plStateDataRecord* dstState);
|
||||
void ISetCurrentStateFrom(const plStateDataRecord* srcState);
|
||||
|
||||
UInt32 IApplyModFlags(UInt32 sendFlags);
|
||||
uint32_t IApplyModFlags(uint32_t sendFlags);
|
||||
|
||||
public:
|
||||
CLASSNAME_REGISTER( plAGMasterSDLModifier);
|
||||
|
||||
@ -133,7 +133,7 @@ void plAGModifier::Apply(double time) const
|
||||
|
||||
// IEVAL
|
||||
// Apply our channels to our scene object
|
||||
hsBool plAGModifier::IEval(double time, hsScalar delta, UInt32 dirty)
|
||||
hsBool plAGModifier::IEval(double time, hsScalar delta, uint32_t dirty)
|
||||
{
|
||||
if(fAutoApply) {
|
||||
// Apply(time, delta);
|
||||
|
||||
@ -144,7 +144,7 @@ protected:
|
||||
hsBool fEnabled; // if not enabled, we don't eval any of our anims
|
||||
|
||||
// APPLYING THE ANIMATION
|
||||
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty);
|
||||
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty);
|
||||
|
||||
virtual hsBool IHandleCmd(plAnimCmdMsg* modMsg) { return false; } // only plAGMasterMod should handle these
|
||||
virtual void IApplyDynamic() {}; // dummy function required by base class
|
||||
@ -154,13 +154,13 @@ protected:
|
||||
plCoordinateInterface * LeakCI() const { return IGetTargetCoordinateInterface(0); };
|
||||
plDrawInterface * LeakDI() const { return IGetTargetDrawInterface(0); };
|
||||
plSimulationInterface * LeakSI() const { return IGetTargetSimulationInterface(0); };
|
||||
plObjInterface * LeakGI(UInt32 classIdx) const { return IGetTargetGenericInterface(0, classIdx); }
|
||||
plObjInterface * LeakGI(uint32_t classIdx) const { return IGetTargetGenericInterface(0, classIdx); }
|
||||
|
||||
friend plAudioInterface * plAGApplicator::IGetAI(const plAGModifier * modifier) const;
|
||||
friend plCoordinateInterface * plAGApplicator::IGetCI(const plAGModifier * modifier) const;
|
||||
friend plDrawInterface * plAGApplicator::IGetDI(const plAGModifier * modifier) const;
|
||||
friend plSimulationInterface * plAGApplicator::IGetSI(const plAGModifier * modifier) const;
|
||||
friend plObjInterface * plAGApplicator::IGetGI(const plAGModifier * modifier, UInt16 classIdx) const;
|
||||
friend plObjInterface * plAGApplicator::IGetGI(const plAGModifier * modifier, uint16_t classIdx) const;
|
||||
|
||||
};
|
||||
const plModifier * FindModifierByClass(const plSceneObject *obj, int classID);
|
||||
|
||||
@ -103,7 +103,7 @@ plAnimStage::plAnimStage()
|
||||
{
|
||||
}
|
||||
|
||||
plAnimStage::plAnimStage(const char *animName, UInt8 notify)
|
||||
plAnimStage::plAnimStage(const char *animName, uint8_t notify)
|
||||
: fNotify(notify),
|
||||
fArmature(nil),
|
||||
fBrain(nil),
|
||||
@ -132,7 +132,7 @@ plAnimStage::plAnimStage(const char *animName, UInt8 notify)
|
||||
|
||||
// PLANIMSTAGE canonical ctor
|
||||
plAnimStage::plAnimStage(const char *animName,
|
||||
UInt8 notify,
|
||||
uint8_t notify,
|
||||
ForwardType forward,
|
||||
BackType back,
|
||||
AdvanceType advance,
|
||||
@ -164,7 +164,7 @@ plAnimStage::plAnimStage(const char *animName,
|
||||
}
|
||||
|
||||
plAnimStage::plAnimStage(const char *animName,
|
||||
UInt8 notify,
|
||||
uint8_t notify,
|
||||
ForwardType forward,
|
||||
BackType back,
|
||||
AdvanceType advance,
|
||||
@ -288,7 +288,7 @@ plAGAnimInstance * plAnimStage::Attach(plArmatureMod *armature, plArmatureBrain
|
||||
}
|
||||
|
||||
// SENDNOTIFY
|
||||
hsBool plAnimStage::ISendNotify(UInt32 notifyMask, UInt32 notifyType, plArmatureMod *armature, plArmatureBrain *brain)
|
||||
hsBool plAnimStage::ISendNotify(uint32_t notifyMask, uint32_t notifyType, plArmatureMod *armature, plArmatureBrain *brain)
|
||||
{
|
||||
// make sure the user has requested this type of notify
|
||||
if(fNotify & notifyMask)
|
||||
@ -626,15 +626,15 @@ void plAnimStage::SetRegresstype(RegressType t)
|
||||
}
|
||||
|
||||
// GETNOTIFYFLAGS
|
||||
UInt32 plAnimStage::GetNotifyFlags()
|
||||
uint32_t plAnimStage::GetNotifyFlags()
|
||||
{
|
||||
return fNotify;
|
||||
}
|
||||
|
||||
// SETNOTIFYFLAGS
|
||||
void plAnimStage::SetNotifyFlags(UInt32 newFlags)
|
||||
void plAnimStage::SetNotifyFlags(uint32_t newFlags)
|
||||
{
|
||||
fNotify = (UInt8)newFlags;
|
||||
fNotify = (uint8_t)newFlags;
|
||||
}
|
||||
|
||||
// GETNUMLOOPS
|
||||
|
||||
@ -159,7 +159,7 @@ public:
|
||||
channel attached to the avatar's handle.
|
||||
*/
|
||||
plAnimStage(const char *animName,
|
||||
UInt8 notify,
|
||||
uint8_t notify,
|
||||
ForwardType forward,
|
||||
BackType backward,
|
||||
AdvanceType advance,
|
||||
@ -173,7 +173,7 @@ public:
|
||||
moving.
|
||||
*/
|
||||
plAnimStage(const char *animName,
|
||||
UInt8 notify,
|
||||
uint8_t notify,
|
||||
ForwardType forward,
|
||||
BackType back,
|
||||
AdvanceType advance,
|
||||
@ -189,7 +189,7 @@ public:
|
||||
\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);
|
||||
plAnimStage(const char *animName, uint8_t notify);
|
||||
virtual ~plAnimStage();
|
||||
const plAnimStage& operator=(const plAnimStage& src);
|
||||
|
||||
@ -210,8 +210,8 @@ public:
|
||||
void SetAdvanceType(AdvanceType t);
|
||||
RegressType GetRegressType();
|
||||
void SetRegresstype(RegressType t);
|
||||
UInt32 GetNotifyFlags();
|
||||
void SetNotifyFlags(UInt32 newFlags);
|
||||
uint32_t GetNotifyFlags();
|
||||
void SetNotifyFlags(uint32_t newFlags);
|
||||
int GetNumLoops();
|
||||
void SetNumLoops(int loops);
|
||||
int GetLoopValue();
|
||||
@ -252,16 +252,16 @@ protected:
|
||||
bool ITryAdvance(plArmatureMod *avMod);
|
||||
bool ITryRegress(plArmatureMod *avMod);
|
||||
|
||||
hsBool ISendNotify(UInt32 notifyMask, UInt32 notifyType, plArmatureMod *armature, plArmatureBrain *brain);
|
||||
hsBool ISendNotify(uint32_t notifyMask, uint32_t notifyType, plArmatureMod *armature, plArmatureBrain *brain);
|
||||
|
||||
char *fAnimName; // the name of our animation
|
||||
UInt8 fNotify; // flags for which events will cause notification events
|
||||
uint8_t 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
|
||||
uint32_t 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
|
||||
uint32_t fRegressTo; // the stage to regress true, provided fDoRegressTo is true
|
||||
|
||||
// --- these are derived & kept for bookkeeping
|
||||
plAGAnimInstance *fAnimInstance;
|
||||
@ -273,7 +273,7 @@ protected:
|
||||
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?
|
||||
uint8_t 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
|
||||
|
||||
@ -157,12 +157,12 @@ hsBool plArmatureEffectsMgr::MsgReceive(plMessage* msg)
|
||||
return hsKeyedObject::MsgReceive(msg);
|
||||
}
|
||||
|
||||
UInt32 plArmatureEffectsMgr::GetNumEffects()
|
||||
uint32_t plArmatureEffectsMgr::GetNumEffects()
|
||||
{
|
||||
return fEffects.GetCount();
|
||||
}
|
||||
|
||||
plArmatureEffect *plArmatureEffectsMgr::GetEffect(UInt32 num)
|
||||
plArmatureEffect *plArmatureEffectsMgr::GetEffect(uint32_t num)
|
||||
{
|
||||
return fEffects[num];
|
||||
}
|
||||
@ -214,9 +214,9 @@ void plArmatureEffectFootSound::Read(hsStream* s, hsResMgr* mgr)
|
||||
}
|
||||
}
|
||||
|
||||
UInt32 plArmatureEffectFootSound::IFindSurfaceByTrigger(plKey trigger)
|
||||
uint32_t plArmatureEffectFootSound::IFindSurfaceByTrigger(plKey trigger)
|
||||
{
|
||||
UInt32 i;
|
||||
uint32_t i;
|
||||
|
||||
// Skip index 0. It's the special "NoSurface" that should always be at the stack bottom
|
||||
for (i = 1; i < fSurfaces.GetCount(); i++)
|
||||
@ -265,7 +265,7 @@ hsBool plArmatureEffectFootSound::HandleTrigger(plMessage* msg)
|
||||
plArmatureEffectMsg *eMsg = plArmatureEffectMsg::ConvertNoRef(msg);
|
||||
if (eMsg)
|
||||
{
|
||||
UInt32 curSurfaceIndex = fSurfaces[fSurfaces.GetCount() - 1]->fID;
|
||||
uint32_t curSurfaceIndex = fSurfaces[fSurfaces.GetCount() - 1]->fID;
|
||||
|
||||
if (curSurfaceIndex < plArmatureEffectsMgr::kMaxSurface && fMods[curSurfaceIndex] != nil)
|
||||
{
|
||||
@ -302,7 +302,7 @@ hsBool plArmatureEffectFootSound::HandleTrigger(plMessage* msg)
|
||||
}
|
||||
else
|
||||
{
|
||||
UInt32 index = IFindSurfaceByTrigger(sMsg->GetSender());
|
||||
uint32_t index = IFindSurfaceByTrigger(sMsg->GetSender());
|
||||
if (index != -1)
|
||||
{
|
||||
if (index == fSurfaces.GetCount() - 1) // It's the top on the stack
|
||||
@ -324,7 +324,7 @@ void plArmatureEffectFootSound::Reset()
|
||||
delete fSurfaces.Pop();
|
||||
}
|
||||
|
||||
void plArmatureEffectFootSound::SetFootType(UInt8 type)
|
||||
void plArmatureEffectFootSound::SetFootType(uint8_t type)
|
||||
{
|
||||
if (type == kFootTypeBare)
|
||||
{
|
||||
|
||||
@ -77,8 +77,8 @@ public:
|
||||
|
||||
virtual hsBool MsgReceive(plMessage* msg);
|
||||
|
||||
UInt32 GetNumEffects();
|
||||
plArmatureEffect *GetEffect(UInt32 num);
|
||||
uint32_t GetNumEffects();
|
||||
plArmatureEffect *GetEffect(uint32_t num);
|
||||
void ResetEffects();
|
||||
|
||||
plArmatureMod *fArmature;
|
||||
@ -126,7 +126,7 @@ public:
|
||||
class plArmatureEffectFootSurface
|
||||
{
|
||||
public:
|
||||
UInt8 fID;
|
||||
uint8_t fID;
|
||||
plKey fTrigger;
|
||||
};
|
||||
|
||||
@ -137,7 +137,7 @@ protected:
|
||||
hsBitVector fActiveSurfaces;
|
||||
plRandomSoundMod *fMods[plArmatureEffectsMgr::kMaxSurface];
|
||||
|
||||
UInt32 IFindSurfaceByTrigger(plKey trigger);
|
||||
uint32_t IFindSurfaceByTrigger(plKey trigger);
|
||||
|
||||
public:
|
||||
plArmatureEffectFootSound();
|
||||
@ -152,7 +152,7 @@ public:
|
||||
virtual hsBool MsgReceive(plMessage* msg);
|
||||
virtual hsBool HandleTrigger(plMessage* msg);
|
||||
virtual void Reset();
|
||||
void SetFootType(UInt8);
|
||||
void SetFootType(uint8_t);
|
||||
|
||||
enum
|
||||
{
|
||||
|
||||
@ -184,7 +184,7 @@ void plArmatureModBase::RemoveTarget(plSceneObject* so)
|
||||
plAGMasterMod::RemoveTarget(so);
|
||||
}
|
||||
|
||||
hsBool plArmatureModBase::IEval(double time, hsScalar elapsed, UInt32 dirty)
|
||||
hsBool plArmatureModBase::IEval(double time, hsScalar elapsed, uint32_t dirty)
|
||||
{
|
||||
if (IsFinal())
|
||||
{
|
||||
@ -507,12 +507,12 @@ int plArmatureModBase::AppendBoneVec(plKeyVector *boneVec)
|
||||
return fUnusedBones.size() - 1;
|
||||
}
|
||||
|
||||
UInt8 plArmatureModBase::GetNumLOD() const
|
||||
uint8_t plArmatureModBase::GetNumLOD() const
|
||||
{
|
||||
return fMeshKeys.size();
|
||||
}
|
||||
|
||||
void plArmatureModBase::EnablePhysics(hsBool status, UInt16 reason /* = kDisableReasonUnknown */)
|
||||
void plArmatureModBase::EnablePhysics(hsBool status, uint16_t reason /* = kDisableReasonUnknown */)
|
||||
{
|
||||
if (status)
|
||||
fDisabledPhysics &= ~reason;
|
||||
@ -538,7 +538,7 @@ void plArmatureModBase::EnablePhysicsKinematic(hsBool status)
|
||||
fController->Kinematic(status);
|
||||
}
|
||||
|
||||
void plArmatureModBase::EnableDrawing(hsBool status, UInt16 reason /* = kDisableReasonUnknown */)
|
||||
void plArmatureModBase::EnableDrawing(hsBool status, uint16_t reason /* = kDisableReasonUnknown */)
|
||||
{
|
||||
hsBool oldStatus = !fDisabledDraw;
|
||||
if (status)
|
||||
@ -758,7 +758,7 @@ const plSceneObject *plArmatureMod::FindBone(const char * name) const
|
||||
return result;
|
||||
}
|
||||
|
||||
const plSceneObject *plArmatureMod::FindBone(UInt32 id) const
|
||||
const plSceneObject *plArmatureMod::FindBone(uint32_t id) const
|
||||
{
|
||||
if(fBoneMap)
|
||||
return fBoneMap->FindBone(id);
|
||||
@ -766,7 +766,7 @@ const plSceneObject *plArmatureMod::FindBone(UInt32 id) const
|
||||
return nil;
|
||||
}
|
||||
|
||||
void plArmatureMod::AddBoneMapping(UInt32 id, const plSceneObject *bone)
|
||||
void plArmatureMod::AddBoneMapping(uint32_t id, const plSceneObject *bone)
|
||||
{
|
||||
if(!fBoneMap)
|
||||
fBoneMap = TRACKED_NEW plAvBoneMap();
|
||||
@ -932,7 +932,7 @@ void plArmatureMod::UnRegisterForBehaviorNotify(plKey key)
|
||||
fNotifyKeys.RemoveItem(key);
|
||||
}
|
||||
|
||||
void plArmatureMod::IFireBehaviorNotify(UInt32 type, hsBool behaviorStart)
|
||||
void plArmatureMod::IFireBehaviorNotify(uint32_t type, hsBool behaviorStart)
|
||||
{
|
||||
if (fNotifyKeys.GetCount() > 0)
|
||||
{
|
||||
@ -1495,7 +1495,7 @@ hsBool plArmatureMod::IHandleControlMsg(plControlEventMsg* pMsg)
|
||||
void plArmatureMod::IHandleInputStateMsg(plAvatarInputStateMsg *msg)
|
||||
{
|
||||
int i;
|
||||
UInt32 curBit;
|
||||
uint32_t curBit;
|
||||
for (i = 0, curBit = 0x1; i < plAvatarInputStateMsg::fMapSize; i++, curBit <<= 1)
|
||||
{
|
||||
SetInputFlag(msg->fCodeMap[i], msg->fState & curBit);
|
||||
@ -1503,14 +1503,14 @@ void plArmatureMod::IHandleInputStateMsg(plAvatarInputStateMsg *msg)
|
||||
|
||||
}
|
||||
|
||||
void plArmatureMod::SynchInputState(UInt32 rcvID /* = kInvalidPlayerID */)
|
||||
void plArmatureMod::SynchInputState(uint32_t rcvID /* = kInvalidPlayerID */)
|
||||
{
|
||||
if (plAvatarMgr::GetInstance()->GetLocalAvatar() != this)
|
||||
return;
|
||||
|
||||
plAvatarInputStateMsg *msg = TRACKED_NEW plAvatarInputStateMsg();
|
||||
int i;
|
||||
UInt32 curBit;
|
||||
uint32_t curBit;
|
||||
for (i = 0, curBit = 0x1; i < plAvatarInputStateMsg::fMapSize; i++, curBit <<= 1)
|
||||
{
|
||||
if (GetInputFlag(msg->fCodeMap[i]))
|
||||
@ -1548,7 +1548,7 @@ void plArmatureMod::ILinkToPersonalAge()
|
||||
pMsg->Send();
|
||||
}
|
||||
|
||||
hsBool plArmatureMod::IEval(double time, hsScalar elapsed, UInt32 dirty)
|
||||
hsBool plArmatureMod::IEval(double time, hsScalar elapsed, uint32_t dirty)
|
||||
{
|
||||
if (IsFinal())
|
||||
{
|
||||
@ -1843,7 +1843,7 @@ void plArmatureMod::Read(hsStream * stream, hsResMgr *mgr)
|
||||
plgDispatch::Dispatch()->RegisterForExactType(plAvatarStealthModeMsg::Index(), GetKey());
|
||||
}
|
||||
|
||||
hsBool plArmatureMod::DirtySynchState(const char* SDLStateName, UInt32 synchFlags)
|
||||
hsBool plArmatureMod::DirtySynchState(const char* SDLStateName, uint32_t synchFlags)
|
||||
{
|
||||
// skip requests to synch non-avatar state
|
||||
if (SDLStateName && stricmp(SDLStateName, kSDLAvatar))
|
||||
@ -1862,7 +1862,7 @@ hsBool plArmatureMod::DirtySynchState(const char* SDLStateName, UInt32 synchFlag
|
||||
return false;
|
||||
}
|
||||
|
||||
hsBool plArmatureMod::DirtyPhysicalSynchState(UInt32 synchFlags)
|
||||
hsBool plArmatureMod::DirtyPhysicalSynchState(uint32_t synchFlags)
|
||||
{
|
||||
synchFlags |= plSynchedObject::kForceFullSend; // TEMP
|
||||
synchFlags |= plSynchedObject::kBCastToClients;
|
||||
@ -1931,7 +1931,7 @@ void plArmatureMod::ICustomizeApplicator()
|
||||
}
|
||||
}
|
||||
|
||||
const plSceneObject *plArmatureMod::GetClothingSO(UInt8 lod) const
|
||||
const plSceneObject *plArmatureMod::GetClothingSO(uint8_t lod) const
|
||||
{
|
||||
if (fClothToSOMap.GetCount() <= lod)
|
||||
return nil;
|
||||
@ -1947,7 +1947,7 @@ void plArmatureMod::NetworkSynch(double timeNow, int force)
|
||||
{
|
||||
// make sure state change gets sent out over the network
|
||||
// avatar state should use relevance region filtering
|
||||
UInt32 flags = kBCastToClients | kUseRelevanceRegions;
|
||||
uint32_t flags = kBCastToClients | kUseRelevanceRegions;
|
||||
if (force)
|
||||
flags |= kForceFullSend;
|
||||
DirtyPhysicalSynchState(flags);
|
||||
@ -2094,7 +2094,7 @@ int plArmatureMod::GetBrainCount()
|
||||
return fBrains.size();
|
||||
}
|
||||
|
||||
plArmatureBrain * plArmatureMod::FindBrainByClass(UInt32 classID) const
|
||||
plArmatureBrain * plArmatureMod::FindBrainByClass(uint32_t classID) const
|
||||
{
|
||||
int n = fBrains.size();
|
||||
|
||||
@ -2474,10 +2474,10 @@ const char *plArmatureMod::GetAnimRootName(const char *name)
|
||||
return name + fAnimationPrefix.length();
|
||||
}
|
||||
|
||||
Int8 plArmatureMod::AnimNameToIndex(const char *name)
|
||||
int8_t plArmatureMod::AnimNameToIndex(const char *name)
|
||||
{
|
||||
const char *rootName = GetAnimRootName(name);
|
||||
Int8 result = -1;
|
||||
int8_t result = -1;
|
||||
|
||||
if (!strcmp(rootName, "Walk") || !strcmp(rootName, "WalkBack") ||
|
||||
!strcmp(rootName, "LadderDown") || !strcmp(rootName, "LadderDownOn") ||
|
||||
@ -2655,7 +2655,7 @@ int plArmatureMod::RefreshDebugDisplay()
|
||||
plDebugText &debugTxt = plDebugText::Instance();
|
||||
char strBuf[ 2048 ];
|
||||
int lineHeight = debugTxt.GetFontSize() + 4;
|
||||
UInt32 scrnWidth, scrnHeight;
|
||||
uint32_t scrnWidth, scrnHeight;
|
||||
|
||||
debugTxt.GetScreenSize( &scrnWidth, &scrnHeight );
|
||||
int y = 10;
|
||||
@ -2784,7 +2784,7 @@ void plArmatureMod::DumpToDebugDisplay(int &x, int &y, int lineHeight, char *str
|
||||
class plAvBoneMap::BoneMapImp
|
||||
{
|
||||
public:
|
||||
typedef std::map<UInt32, const plSceneObject *> id2SceneObjectMap;
|
||||
typedef std::map<uint32_t, const plSceneObject *> id2SceneObjectMap;
|
||||
id2SceneObjectMap fMap;
|
||||
};
|
||||
|
||||
@ -2798,7 +2798,7 @@ plAvBoneMap::~plAvBoneMap()
|
||||
delete fImp;
|
||||
}
|
||||
|
||||
const plSceneObject * plAvBoneMap::FindBone(UInt32 boneID)
|
||||
const plSceneObject * plAvBoneMap::FindBone(uint32_t boneID)
|
||||
{
|
||||
BoneMapImp::id2SceneObjectMap::iterator i = fImp->fMap.find(boneID);
|
||||
const plSceneObject *result = nil;
|
||||
@ -2810,7 +2810,7 @@ const plSceneObject * plAvBoneMap::FindBone(UInt32 boneID)
|
||||
return result;
|
||||
}
|
||||
|
||||
void plAvBoneMap::AddBoneMapping(UInt32 boneID, const plSceneObject *SO)
|
||||
void plAvBoneMap::AddBoneMapping(uint32_t boneID, const plSceneObject *SO)
|
||||
{
|
||||
(fImp->fMap)[boneID] = SO;
|
||||
}
|
||||
|
||||
@ -112,7 +112,7 @@ public:
|
||||
virtual hsBool MsgReceive(plMessage* msg);
|
||||
virtual void AddTarget(plSceneObject* so);
|
||||
virtual void RemoveTarget(plSceneObject* so);
|
||||
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty);
|
||||
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty);
|
||||
virtual void Read(hsStream *stream, hsResMgr *mgr);
|
||||
virtual void Write(hsStream *stream, hsResMgr *mgr);
|
||||
|
||||
@ -134,7 +134,7 @@ public:
|
||||
void RefreshTree(); // Resend an LOD update to all our nodes (for when geometry changes)
|
||||
int AppendMeshKey(plKey meshKey);
|
||||
int AppendBoneVec(plKeyVector *boneVec);
|
||||
UInt8 GetNumLOD() const;
|
||||
uint8_t GetNumLOD() const;
|
||||
|
||||
// A collection of reasons (flags) that things might be disabled. When all flags are gone
|
||||
// The object is re-enabled.
|
||||
@ -147,9 +147,9 @@ public:
|
||||
kDisableReasonVehicle = 0x0010,
|
||||
kDisableReasonGenericBrain = 0x0020,
|
||||
};
|
||||
void EnablePhysics(hsBool status, UInt16 reason = kDisableReasonUnknown);
|
||||
void EnablePhysics(hsBool status, uint16_t reason = kDisableReasonUnknown);
|
||||
void EnablePhysicsKinematic(hsBool status);
|
||||
void EnableDrawing(hsBool status, UInt16 reason = kDisableReasonUnknown);
|
||||
void EnableDrawing(hsBool status, uint16_t reason = kDisableReasonUnknown);
|
||||
hsBool IsPhysicsEnabled() { return fDisabledPhysics == 0; }
|
||||
hsBool IsDrawEnabled() { return fDisabledDraw == 0; }
|
||||
|
||||
@ -177,7 +177,7 @@ protected:
|
||||
kNeedApplicator = 0x20,
|
||||
kNeedBrainActivation = 0x40,
|
||||
};
|
||||
UInt16 fWaitFlags;
|
||||
uint16_t fWaitFlags;
|
||||
|
||||
int fCurLOD;
|
||||
plPhysicalControllerCore* fController;
|
||||
@ -185,8 +185,8 @@ protected:
|
||||
plBrainStack fBrains;
|
||||
plMatrixDifferenceApp *fRootAnimator;
|
||||
std::vector<plKeyVector*> fUnusedBones;
|
||||
UInt16 fDisabledPhysics;
|
||||
UInt16 fDisabledDraw;
|
||||
uint16_t fDisabledPhysics;
|
||||
uint16_t fDisabledDraw;
|
||||
};
|
||||
|
||||
class plArmatureMod : public plArmatureModBase
|
||||
@ -207,7 +207,7 @@ public:
|
||||
virtual hsBool MsgReceive(plMessage* msg);
|
||||
virtual void AddTarget(plSceneObject* so);
|
||||
virtual void RemoveTarget(plSceneObject* so);
|
||||
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty);
|
||||
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty);
|
||||
virtual void Read(hsStream *stream, hsResMgr *mgr);
|
||||
virtual void Write(hsStream *stream, hsResMgr *mgr);
|
||||
|
||||
@ -222,8 +222,8 @@ public:
|
||||
hsBool IsLocalAvatar();
|
||||
hsBool IsLocalAI();
|
||||
virtual const plSceneObject *FindBone(const char * name) const;
|
||||
virtual const plSceneObject *FindBone(UInt32 id) const; // use an id from an appropriate taxonomy, such as plAvBrainHuman::BoneID
|
||||
virtual void AddBoneMapping(UInt32 id, const plSceneObject *bone);
|
||||
virtual const plSceneObject *FindBone(uint32_t id) const; // use an id from an appropriate taxonomy, such as plAvBrainHuman::BoneID
|
||||
virtual void AddBoneMapping(uint32_t id, const plSceneObject *bone);
|
||||
plAGModifier *GetRootAGMod();
|
||||
plAGAnim *FindCustomAnim(const char *baseName) const;
|
||||
|
||||
@ -239,13 +239,13 @@ public:
|
||||
int GetBrainCount();
|
||||
plArmatureBrain *GetNextBrain(plArmatureBrain *brain);
|
||||
plArmatureBrain *GetBrain(int index) { if(index <= fBrains.size()) return fBrains.at(index); else return nil; }
|
||||
plArmatureBrain *FindBrainByClass(UInt32 classID) const;
|
||||
plArmatureBrain *FindBrainByClass(uint32_t classID) const;
|
||||
|
||||
void TurnToPoint(hsPoint3 &point);
|
||||
void SuspendInput();
|
||||
void ResumeInput();
|
||||
|
||||
UInt8 IsInputSuspended() { return fSuspendInputCount; }
|
||||
uint8_t IsInputSuspended() { return fSuspendInputCount; }
|
||||
void IProcessQueuedInput();
|
||||
void PreserveInputState();
|
||||
void RestoreInputState();
|
||||
@ -281,12 +281,12 @@ public:
|
||||
void GetMoveKeyString(char *buff);
|
||||
|
||||
void SynchIfLocal(double timeNow, int force); // Just physical state
|
||||
void SynchInputState(UInt32 rcvID = kInvalidPlayerID);
|
||||
hsBool DirtySynchState(const char* SDLStateName, UInt32 synchFlags );
|
||||
hsBool DirtyPhysicalSynchState(UInt32 synchFlags);
|
||||
void SynchInputState(uint32_t rcvID = kInvalidPlayerID);
|
||||
hsBool DirtySynchState(const char* SDLStateName, uint32_t synchFlags );
|
||||
hsBool DirtyPhysicalSynchState(uint32_t synchFlags);
|
||||
plClothingOutfit *GetClothingOutfit() const { return fClothingOutfit; }
|
||||
plClothingSDLModifier *GetClothingSDLMod() const { return fClothingSDLMod; }
|
||||
const plSceneObject *GetClothingSO(UInt8 lod) const;
|
||||
const plSceneObject *GetClothingSO(uint8_t lod) const;
|
||||
plArmatureEffectsMgr *GetArmatureEffects() const { return fEffects; }
|
||||
|
||||
enum
|
||||
@ -299,7 +299,7 @@ public:
|
||||
};
|
||||
|
||||
const char *GetAnimRootName(const char *name);
|
||||
Int8 AnimNameToIndex(const char *name);
|
||||
int8_t AnimNameToIndex(const char *name);
|
||||
void SetBodyType(int type) { fBodyType = type; }
|
||||
int GetBodyType(int type) { return fBodyType; }
|
||||
int GetCurrentGenericType();
|
||||
@ -321,7 +321,7 @@ public:
|
||||
bool IsMidLink();
|
||||
hsBool ConsumeJump(); // returns true if the jump keypress was available to consume
|
||||
|
||||
void SendBehaviorNotify(UInt32 type, hsBool start = true) { IFireBehaviorNotify(type,start); }
|
||||
void SendBehaviorNotify(uint32_t type, hsBool start = true) { IFireBehaviorNotify(type,start); }
|
||||
// Discovered a bug which makes these values horribly out of scale. So we do the rescale
|
||||
// in the Get/Set functions for backwards compatability.
|
||||
static void SetMouseTurnSensitivity(hsScalar val) { fMouseTurnSensitivity = val / 150.f; }
|
||||
@ -381,7 +381,7 @@ protected:
|
||||
|
||||
void NetworkSynch(double timeNow, int force = 0);
|
||||
hsBool IHandleControlMsg(plControlEventMsg* pMsg);
|
||||
void IFireBehaviorNotify(UInt32 type, hsBool behaviorStart = true);
|
||||
void IFireBehaviorNotify(uint32_t type, hsBool behaviorStart = true);
|
||||
void IHandleInputStateMsg(plAvatarInputStateMsg *msg);
|
||||
void ILinkToPersonalAge();
|
||||
int IFindSpawnOverride(void);
|
||||
@ -400,7 +400,7 @@ protected:
|
||||
static hsScalar fMouseTurnSensitivity;
|
||||
plArmatureUpdateMsg *fUpdateMsg;
|
||||
|
||||
// Trying to be a good lad here and align all our bools and UInt8s...
|
||||
// Trying to be a good lad here and align all our bools and bytes...
|
||||
bool fMidLink; // We're in between a LeaveAge and an EnterAge
|
||||
bool fAlreadyPanicLinking; // Cleared when you enter an age. Prevents spamming the server with panic link requests.
|
||||
bool fUnconsumedJump; // We've pressed the jump key, but haven't jumped yet
|
||||
@ -408,8 +408,8 @@ protected:
|
||||
bool fPendingSynch;
|
||||
bool fDebugOn;
|
||||
bool fOpaque;
|
||||
UInt8 fSuspendInputCount;
|
||||
UInt8 fStealthMode;
|
||||
uint8_t fSuspendInputCount;
|
||||
uint8_t fStealthMode;
|
||||
int fStealthLevel; // you are invisible to other players/CCRs of lower stealthLevel
|
||||
|
||||
double fLastInputSynch;
|
||||
@ -473,8 +473,8 @@ public:
|
||||
plAvBoneMap();
|
||||
virtual ~plAvBoneMap();
|
||||
|
||||
const plSceneObject * FindBone(UInt32 boneID); // you probably want to use plAvBrainHuman::BoneID;
|
||||
void AddBoneMapping(UInt32 boneID, const plSceneObject *SO);
|
||||
const plSceneObject * FindBone(uint32_t boneID); // you probably want to use plAvBrainHuman::BoneID;
|
||||
void AddBoneMapping(uint32_t boneID, const plSceneObject *SO);
|
||||
|
||||
protected:
|
||||
class BoneMapImp; // forward declaration to keep the header clean: see .cpp for implementation
|
||||
|
||||
@ -47,7 +47,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
||||
|
||||
#include "plPipeline/plDebugText.h"
|
||||
|
||||
plArmatureBehavior::plArmatureBehavior() : fAnim(nil), fArmature(nil), fBrain(nil), fIndex((UInt8)-1), fFlags(0) {}
|
||||
plArmatureBehavior::plArmatureBehavior() : fAnim(nil), fArmature(nil), fBrain(nil), fIndex((uint8_t)-1), fFlags(0) {}
|
||||
|
||||
plArmatureBehavior::~plArmatureBehavior()
|
||||
{
|
||||
@ -55,7 +55,7 @@ plArmatureBehavior::~plArmatureBehavior()
|
||||
fAnim->Detach();
|
||||
}
|
||||
|
||||
void plArmatureBehavior::Init(plAGAnim *anim, hsBool loop, plArmatureBrain *brain, plArmatureModBase *armature, UInt8 index)
|
||||
void plArmatureBehavior::Init(plAGAnim *anim, hsBool loop, plArmatureBrain *brain, plArmatureModBase *armature, uint8_t index)
|
||||
{
|
||||
fArmature = armature;
|
||||
fBrain = brain;
|
||||
|
||||
@ -60,7 +60,7 @@ public:
|
||||
plArmatureBehavior();
|
||||
virtual ~plArmatureBehavior();
|
||||
|
||||
void Init(plAGAnim *anim, hsBool loop, plArmatureBrain *brain, plArmatureModBase *armature, UInt8 index);
|
||||
void Init(plAGAnim *anim, hsBool loop, plArmatureBrain *brain, plArmatureModBase *armature, uint8_t index);
|
||||
virtual void Process(double time, float elapsed);
|
||||
virtual void SetStrength(hsScalar val, hsScalar rate = 0.f); // default instant change
|
||||
virtual hsScalar GetStrength();
|
||||
@ -71,14 +71,14 @@ public:
|
||||
{
|
||||
kBehaviorFlagNotifyOnStop = 0x01,
|
||||
};
|
||||
UInt32 fFlags;
|
||||
uint32_t fFlags;
|
||||
|
||||
protected:
|
||||
plAGAnimInstance *fAnim;
|
||||
plArmatureModBase *fArmature;
|
||||
plArmatureBrain *fBrain;
|
||||
plTimedValue<hsScalar> fStrength;
|
||||
UInt8 fIndex;
|
||||
uint8_t fIndex;
|
||||
|
||||
virtual void IStart();
|
||||
virtual void IStop();
|
||||
|
||||
@ -77,7 +77,7 @@ public:
|
||||
virtual void Suspend() {}
|
||||
virtual void Resume() {}
|
||||
virtual void Spawn(double timeNow) {}
|
||||
virtual void OnBehaviorStop(UInt8 index) {}
|
||||
virtual void OnBehaviorStop(uint8_t index) {}
|
||||
virtual hsBool LeaveAge();
|
||||
virtual hsBool IsRunningTask() const;
|
||||
virtual void QueueTask(plAvTask *task);
|
||||
|
||||
@ -680,20 +680,20 @@ void plAvBrainClimb::IProbeEnvironment()
|
||||
|
||||
// *** would be cool if we could hint that these should be batched for spatial coherence optimization
|
||||
plLOSRequestMsg *upReq = TRACKED_NEW plLOSRequestMsg(ourKey, start, up, plSimDefs::kLOSDBCustom, plLOSRequestMsg::kTestAny, plLOSRequestMsg::kReportHit);
|
||||
upReq->SetRequestID(static_cast<UInt32>(plClimbMsg::kUp));
|
||||
upReq->SetRequestID(static_cast<uint32_t>(plClimbMsg::kUp));
|
||||
upReq->Send();
|
||||
|
||||
plLOSRequestMsg *downReq = TRACKED_NEW plLOSRequestMsg(ourKey, start, down, plSimDefs::kLOSDBCustom, plLOSRequestMsg::kTestAny, plLOSRequestMsg::kReportHit);
|
||||
downReq->SetRequestID(static_cast<UInt32>(plClimbMsg::kDown));
|
||||
downReq->SetRequestID(static_cast<uint32_t>(plClimbMsg::kDown));
|
||||
downReq->Send();
|
||||
|
||||
plLOSRequestMsg *leftReq = TRACKED_NEW plLOSRequestMsg(ourKey, start, left, plSimDefs::kLOSDBCustom, plLOSRequestMsg::kTestAny, plLOSRequestMsg::kReportHit);
|
||||
leftReq->SetRequestID(static_cast<UInt32>(plClimbMsg::kLeft));
|
||||
leftReq->SetRequestID(static_cast<uint32_t>(plClimbMsg::kLeft));
|
||||
leftReq->SetRequestType(plSimDefs::kLOSDBCustom);
|
||||
leftReq->Send();
|
||||
|
||||
plLOSRequestMsg *rightReq = TRACKED_NEW plLOSRequestMsg(ourKey, start, right, plSimDefs::kLOSDBCustom, plLOSRequestMsg::kTestAny, plLOSRequestMsg::kReportHit);
|
||||
rightReq->SetRequestID(static_cast<UInt32>(plClimbMsg::kRight));
|
||||
rightReq->SetRequestID(static_cast<uint32_t>(plClimbMsg::kRight));
|
||||
rightReq->Send();
|
||||
|
||||
fOldPhysicallyBlockedDirections = fPhysicallyBlockedDirections;
|
||||
|
||||
@ -187,10 +187,10 @@ private:
|
||||
Mode fNextMode;
|
||||
plClimbMsg::Direction fDesiredDirection; // up / down / left / right
|
||||
float fControlDir; // 1.0 = move current stage forward -1.0 = move current stage back
|
||||
UInt32 fAllowedDirections;
|
||||
UInt32 fPhysicallyBlockedDirections;
|
||||
UInt32 fOldPhysicallyBlockedDirections; // for debug display convenience
|
||||
UInt32 fAllowedDismounts;
|
||||
uint32_t fAllowedDirections;
|
||||
uint32_t fPhysicallyBlockedDirections;
|
||||
uint32_t fOldPhysicallyBlockedDirections; // for debug display convenience
|
||||
uint32_t fAllowedDismounts;
|
||||
|
||||
float fVerticalProbeLength;
|
||||
float fHorizontalProbeLength;
|
||||
|
||||
@ -91,12 +91,12 @@ plAvBrainCoop::plAvBrainCoop()
|
||||
|
||||
// plAvBrainCoop ----------------------------------------------------------
|
||||
// --------------
|
||||
plAvBrainCoop::plAvBrainCoop(UInt32 exitFlags, float fadeIn, float fadeOut,
|
||||
plAvBrainCoop::plAvBrainCoop(uint32_t exitFlags, float fadeIn, float fadeOut,
|
||||
MoveMode moveMode, plKey guestKey)
|
||||
: plAvBrainGeneric(exitFlags, fadeIn, fadeOut, moveMode),
|
||||
fGuestKey(guestKey)
|
||||
{
|
||||
static UInt16 coopSerial = 0;
|
||||
static uint16_t coopSerial = 0;
|
||||
|
||||
// this particular constructor is only called by the initiator...
|
||||
fInitiatorID = plNetClientApp::GetInstance()->GetPlayerID();
|
||||
@ -105,8 +105,8 @@ plAvBrainCoop::plAvBrainCoop(UInt32 exitFlags, float fadeIn, float fadeOut,
|
||||
|
||||
// plAvBrainCoop ----------------------------------------------------------
|
||||
// --------------
|
||||
plAvBrainCoop::plAvBrainCoop(UInt32 exitFlags, float fadeIn, float fadeOut,
|
||||
MoveMode moveMode, UInt32 initiatorID, UInt16 initiatorSerial,
|
||||
plAvBrainCoop::plAvBrainCoop(uint32_t exitFlags, float fadeIn, float fadeOut,
|
||||
MoveMode moveMode, uint32_t initiatorID, uint16_t initiatorSerial,
|
||||
plKey hostKey)
|
||||
: plAvBrainGeneric(exitFlags, fadeIn, fadeOut, moveMode),
|
||||
fInitiatorID(initiatorID), fInitiatorSerial(initiatorSerial),
|
||||
@ -181,14 +181,14 @@ void plAvBrainCoop::EnableGuestClick()
|
||||
|
||||
// GetInitiatorID --------------------
|
||||
// ---------------
|
||||
UInt32 plAvBrainCoop::GetInitiatorID()
|
||||
uint32_t plAvBrainCoop::GetInitiatorID()
|
||||
{
|
||||
return fInitiatorID;
|
||||
}
|
||||
|
||||
// GetInitiatorSerial --------------------
|
||||
// -------------------
|
||||
UInt16 plAvBrainCoop::GetInitiatorSerial()
|
||||
uint16_t plAvBrainCoop::GetInitiatorSerial()
|
||||
{
|
||||
return fInitiatorSerial;
|
||||
}
|
||||
|
||||
@ -57,11 +57,11 @@ public:
|
||||
plAvBrainCoop();
|
||||
|
||||
// use this constructor for a host brain; it sets up the unique ID
|
||||
plAvBrainCoop(UInt32 exitFlags, float fadeIn, float fadeOut, MoveMode moveMode, plKey guestKey);
|
||||
plAvBrainCoop(uint32_t exitFlags, float fadeIn, float fadeOut, MoveMode moveMode, plKey guestKey);
|
||||
|
||||
// use this constructor for the guest brain, when you already have the unique ID
|
||||
plAvBrainCoop(UInt32 exitFlags, float fadeIn, float fadeOut, MoveMode moveMode,
|
||||
UInt32 initiatorID, UInt16 initiatorSerial, plKey hostKey);
|
||||
plAvBrainCoop(uint32_t exitFlags, float fadeIn, float fadeOut, MoveMode moveMode,
|
||||
uint32_t initiatorID, uint16_t initiatorSerial, plKey hostKey);
|
||||
|
||||
hsBool MsgReceive(plMessage *msg);
|
||||
virtual bool RelayNotifyMsg(plNotifyMsg *msg);
|
||||
@ -76,15 +76,15 @@ public:
|
||||
virtual void Write(hsStream *stream, hsResMgr *mgr);
|
||||
|
||||
// stuff
|
||||
UInt32 GetInitiatorID();
|
||||
UInt16 GetInitiatorSerial();
|
||||
uint32_t GetInitiatorID();
|
||||
uint16_t GetInitiatorSerial();
|
||||
|
||||
virtual plKey GetRecipient();
|
||||
virtual void SetRecipient(plKey &recipient);
|
||||
|
||||
private:
|
||||
UInt32 fInitiatorID;
|
||||
UInt16 fInitiatorSerial;
|
||||
uint32_t fInitiatorID;
|
||||
uint16_t fInitiatorSerial;
|
||||
|
||||
plKey fGuestKey; // only filled out if we are the host
|
||||
plKey fHostKey; // only filled out if we are the guest
|
||||
|
||||
@ -83,7 +83,7 @@ public:
|
||||
fAvMod(nil), fCritterBrain(nil), fName(name), fRandomStartPoint(randomStart), fFadeInLength(fadeInLength), fFadeOutLength(fadeOutLength) {}
|
||||
virtual ~CritterBehavior() {}
|
||||
|
||||
void Init(plAGAnim* anim, hsBool loop, plAvBrainCritter* brain, plArmatureMod* body, UInt8 index)
|
||||
void Init(plAGAnim* anim, hsBool loop, plAvBrainCritter* brain, plArmatureMod* body, uint8_t index)
|
||||
{
|
||||
plArmatureBehavior::Init(anim, loop, brain, body, index);
|
||||
fAvMod = body;
|
||||
|
||||
@ -105,7 +105,7 @@ plAvBrainGeneric::plAvBrainGeneric(plAnimStageVec *stages,
|
||||
plMessage *startMessage,
|
||||
plMessage *endMessage,
|
||||
plKey recipient,
|
||||
UInt32 exitFlags,
|
||||
uint32_t exitFlags,
|
||||
float fadeIn,
|
||||
float fadeOut,
|
||||
MoveMode moveMode)
|
||||
@ -128,7 +128,7 @@ plAvBrainGeneric::plAvBrainGeneric(plAnimStageVec *stages,
|
||||
}
|
||||
|
||||
// plAvBrainGeneric
|
||||
plAvBrainGeneric::plAvBrainGeneric(UInt32 exitFlags, float fadeIn, float fadeOut, MoveMode moveMode)
|
||||
plAvBrainGeneric::plAvBrainGeneric(uint32_t exitFlags, float fadeIn, float fadeOut, MoveMode moveMode)
|
||||
: fRecipient(nil),
|
||||
fStages(nil),
|
||||
fCurStage(0),
|
||||
|
||||
@ -133,14 +133,14 @@ public:
|
||||
\param recipient Callbacks from the brain *and* the stages is sent to this key.
|
||||
\param exitFlags A combination of exit conditions from the ExitFlag enum */
|
||||
plAvBrainGeneric(plAnimStageVec *stages, plMessage *enterMessage, plMessage *exitMessage,
|
||||
plKey recipient, UInt32 exitFlags, float fadeIn, float fadeOut, MoveMode moveMode);
|
||||
plKey recipient, uint32_t exitFlags, float fadeIn, float fadeOut, MoveMode moveMode);
|
||||
|
||||
/** Simplified constructor
|
||||
\param exitFlags Indicates which conditions will cause the brain to exit.
|
||||
\param fadeIn Rate (in blend units per second) of initial animation fade in.
|
||||
\param fadeOut Rate (in blend units per second) of final animation fade out.
|
||||
*/
|
||||
plAvBrainGeneric(UInt32 exitFlags, float fadeIn, float fadeOut, MoveMode moveMode);
|
||||
plAvBrainGeneric(uint32_t exitFlags, float fadeIn, float fadeOut, MoveMode moveMode);
|
||||
|
||||
/** Virtual destructor */
|
||||
virtual ~plAvBrainGeneric();
|
||||
@ -239,7 +239,7 @@ public:
|
||||
|
||||
/** Returns the bitvector holding our exit conditions.
|
||||
/sa plAvBrainGeneric::ExitFlags */
|
||||
UInt32 GetExitFlags() const { return fExitFlags; }
|
||||
uint32_t GetExitFlags() const { return fExitFlags; }
|
||||
|
||||
plAGAnim::BodyUsage GetBodyUsage();
|
||||
void SetBodyUsage(plAGAnim::BodyUsage bodyUsage);
|
||||
@ -299,7 +299,7 @@ protected:
|
||||
plAnimStageVec *fStages; // all the stages in our animation
|
||||
int fCurStage; // which stage are we playing? (zero-based)
|
||||
BrainType fType; // what type of brain are we?
|
||||
UInt32 fExitFlags; // what will cause us to exit?
|
||||
uint32_t fExitFlags; // what will cause us to exit?
|
||||
plHorizontalFreezeAction *fCallbackAction;
|
||||
|
||||
bool fForward; // are we currently moving forward or backward through the stages?
|
||||
|
||||
@ -966,7 +966,7 @@ plHBehavior::~plHBehavior()
|
||||
|
||||
void plHBehavior::Init(plAGAnim *anim, hsBool loop, plAvBrainHuman *brain,
|
||||
plArmatureMod *body, float fadeIn, float fadeOut,
|
||||
UInt8 index, UInt32 type /* = 0 */)
|
||||
uint8_t index, uint32_t type /* = 0 */)
|
||||
{
|
||||
plArmatureBehavior::Init(anim, loop, brain, body, index);
|
||||
fAvMod = body;
|
||||
|
||||
@ -180,7 +180,7 @@ protected:
|
||||
|
||||
plAGModifier *fHandleAGMod; // the ag modifier that's attached to our top object
|
||||
double fStartedTurning; // when did we start turning?
|
||||
UInt32 fPreconditions;
|
||||
uint32_t fPreconditions;
|
||||
bool fIsActor; // are we an actor with special privileges?
|
||||
static float fWalkTimeToMaxTurn;
|
||||
static float fRunTimeToMaxTurn;
|
||||
@ -237,9 +237,9 @@ public:
|
||||
~plHBehavior();
|
||||
|
||||
void Init(plAGAnim *anim, hsBool loop, plAvBrainHuman *brain, plArmatureMod *body,
|
||||
float fadeIn, float fadeOut, UInt8 index, UInt32 type = 0);
|
||||
float fadeIn, float fadeOut, uint8_t index, uint32_t type = 0);
|
||||
virtual hsBool PreCondition(double time, float elapsed) { return true; }
|
||||
UInt32 GetType() const { return fType; }
|
||||
uint32_t GetType() const { return fType; }
|
||||
|
||||
protected:
|
||||
virtual void IStart();
|
||||
@ -250,7 +250,7 @@ protected:
|
||||
float fFadeIn; // speed at which the animation fades in, in blend units per second
|
||||
float fFadeOut; // speed at which the animation fades out, in blend units per second
|
||||
float fMaxBlend; // the maximum blend the animation should reach
|
||||
UInt32 fType; // (see the behaviorType enum)
|
||||
uint32_t fType; // (see the behaviorType enum)
|
||||
|
||||
bool fStartMsgSent; // flags to prevent multiple start and stop messages from being sent
|
||||
bool fStopMsgSent;
|
||||
|
||||
@ -91,7 +91,7 @@ public:
|
||||
plSwimBehavior() : fAvMod(nil), fSwimBrain(nil) {}
|
||||
virtual ~plSwimBehavior() {}
|
||||
|
||||
void Init(plAGAnim *anim, hsBool loop, plAvBrainSwim *brain, plArmatureMod *body, UInt8 index)
|
||||
void Init(plAGAnim *anim, hsBool loop, plAvBrainSwim *brain, plArmatureMod *body, uint8_t index)
|
||||
{
|
||||
plArmatureBehavior::Init(anim, loop, brain, body, index);
|
||||
fAvMod = body;
|
||||
|
||||
@ -310,7 +310,7 @@ void plAvLadderMod::EmitCommand(const plKey receiver)
|
||||
plNotifyMsg* enterNotify = TRACKED_NEW plNotifyMsg(GetKey(), GetKey());
|
||||
enterNotify->fID = kNotifyAvatarOnLadder;
|
||||
|
||||
UInt32 exitFlags = plAvBrainGeneric::kExitNormal;
|
||||
uint32_t exitFlags = plAvBrainGeneric::kExitNormal;
|
||||
|
||||
plAvBrainGeneric *ladBrain = TRACKED_NEW plAvBrainGeneric(v, enterNotify, nil, nil, exitFlags, plAvBrainGeneric::kDefaultFadeIn,
|
||||
plAvBrainGeneric::kDefaultFadeOut, plAvBrainGeneric::kMoveRelative);
|
||||
|
||||
@ -78,7 +78,7 @@ public:
|
||||
void SetEnabled(bool enabled) { fEnabled = enabled; }
|
||||
|
||||
protected:
|
||||
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) {return true;}
|
||||
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) {return true;}
|
||||
bool IIsReadyToClimb();
|
||||
void ITriggerSelf(plKey avKey);
|
||||
|
||||
|
||||
@ -62,7 +62,7 @@ public:
|
||||
kSeekRunNormal,
|
||||
kSeekAbort,
|
||||
};
|
||||
UInt8 fState;
|
||||
uint8_t fState;
|
||||
|
||||
enum
|
||||
{
|
||||
@ -183,7 +183,7 @@ protected:
|
||||
hsScalar fMaxBackAngle; // in fwd . goal
|
||||
|
||||
double fStartTime;
|
||||
UInt8 fFlags;
|
||||
uint8_t fFlags;
|
||||
plKey fNotifyFinishedKey; // Send a message to this key when we're done.
|
||||
};
|
||||
|
||||
|
||||
@ -232,7 +232,7 @@ void plClothingItem::Write(hsStream *s, hsResMgr *mgr)
|
||||
if (fThumbnail != nil)
|
||||
mgr->WriteKey(s, fThumbnail->GetKey());
|
||||
|
||||
UInt32 texSkip = 0;
|
||||
uint32_t texSkip = 0;
|
||||
for (i = 0; i < fTextures.GetCount(); i++)
|
||||
if (fTextures[i] == nil)
|
||||
texSkip++;
|
||||
@ -504,7 +504,7 @@ void plClothingOutfit::RemoveItem(plClothingItem *item, hsBool update /* = true
|
||||
|
||||
void plClothingOutfit::TintItem(plClothingItem *item, hsScalar red, hsScalar green, hsScalar blue,
|
||||
hsBool update /* = true */, hsBool broadcast /* = true */, hsBool netForce /* = false */,
|
||||
hsBool retry /* = true */, UInt8 layer /* = kLayerTint1 */)
|
||||
hsBool retry /* = true */, uint8_t layer /* = kLayerTint1 */)
|
||||
{
|
||||
plClothingMsg *msg = TRACKED_NEW plClothingMsg();
|
||||
msg->AddReceiver(GetKey());
|
||||
@ -541,7 +541,7 @@ void plClothingOutfit::TintSkin(hsScalar red, hsScalar green, hsScalar blue,
|
||||
plgDispatch::MsgSend(msg);
|
||||
}
|
||||
|
||||
void plClothingOutfit::MorphItem(plClothingItem *item, UInt8 layer, UInt8 delta, hsScalar weight,
|
||||
void plClothingOutfit::MorphItem(plClothingItem *item, uint8_t layer, uint8_t delta, hsScalar weight,
|
||||
hsBool retry /* = true */)
|
||||
{
|
||||
plClothingMsg *msg = TRACKED_NEW plClothingMsg();
|
||||
@ -561,7 +561,7 @@ void plClothingOutfit::SetAge(hsScalar age, hsBool update /* = true */, hsBool b
|
||||
SetSkinBlend(age, plClothingElement::kLayerSkinBlend1, update, broadcast);
|
||||
}
|
||||
|
||||
void plClothingOutfit::SetSkinBlend(hsScalar blend, UInt8 layer, hsBool update /* = true */, hsBool broadcast /* = true */)
|
||||
void plClothingOutfit::SetSkinBlend(hsScalar blend, uint8_t layer, hsBool update /* = true */, hsBool broadcast /* = true */)
|
||||
{
|
||||
plClothingMsg *msg = TRACKED_NEW plClothingMsg();
|
||||
msg->AddReceiver(GetKey());
|
||||
@ -576,7 +576,7 @@ void plClothingOutfit::SetSkinBlend(hsScalar blend, UInt8 layer, hsBool update /
|
||||
plgDispatch::MsgSend(msg);
|
||||
}
|
||||
|
||||
hsScalar plClothingOutfit::GetSkinBlend(UInt8 layer)
|
||||
hsScalar plClothingOutfit::GetSkinBlend(uint8_t layer)
|
||||
{
|
||||
if (layer >= plClothingElement::kLayerSkinBlend1 && layer <= plClothingElement::kLayerSkinLast)
|
||||
return fSkinBlends[layer - plClothingElement::kLayerSkinBlend1];
|
||||
@ -651,7 +651,7 @@ void plClothingOutfit::IAddItem(plClothingItem *item)
|
||||
void plClothingOutfit::IRemoveItem(plClothingItem *item)
|
||||
{
|
||||
// We may just be removing the ref...
|
||||
UInt32 index = fItems.Find(item);
|
||||
uint32_t index = fItems.Find(item);
|
||||
if (index != fItems.kMissingIndex)
|
||||
{
|
||||
fItems.Remove(index);
|
||||
@ -662,9 +662,9 @@ void plClothingOutfit::IRemoveItem(plClothingItem *item)
|
||||
}
|
||||
}
|
||||
|
||||
hsBool plClothingOutfit::ITintItem(plClothingItem *item, hsColorRGBA color, UInt8 layer)
|
||||
hsBool plClothingOutfit::ITintItem(plClothingItem *item, hsColorRGBA color, uint8_t layer)
|
||||
{
|
||||
UInt32 index = fItems.Find(item);
|
||||
uint32_t index = fItems.Find(item);
|
||||
if (index != fItems.kMissingIndex)
|
||||
{
|
||||
if (layer == plClothingElement::kLayerTint1)
|
||||
@ -676,7 +676,7 @@ hsBool plClothingOutfit::ITintItem(plClothingItem *item, hsColorRGBA color, UInt
|
||||
if (fItems[index]->fAccessory)
|
||||
{
|
||||
plClothingItem *acc = fItems[index]->fAccessory;
|
||||
UInt32 accIndex = fItems.Find(acc);
|
||||
uint32_t accIndex = fItems.Find(acc);
|
||||
if (accIndex != fItems.kMissingIndex)
|
||||
{
|
||||
if (layer == plClothingElement::kLayerTint1)
|
||||
@ -692,13 +692,13 @@ hsBool plClothingOutfit::ITintItem(plClothingItem *item, hsColorRGBA color, UInt
|
||||
return false;
|
||||
}
|
||||
|
||||
hsColorRGBA plClothingOutfit::GetItemTint(plClothingItem *item, UInt8 layer /* = kLayerTint1 */) const
|
||||
hsColorRGBA plClothingOutfit::GetItemTint(plClothingItem *item, uint8_t layer /* = kLayerTint1 */) const
|
||||
{
|
||||
if (layer >= plClothingElement::kLayerSkinFirst &&
|
||||
layer <= plClothingElement::kLayerSkinLast)
|
||||
return fSkinTint;
|
||||
|
||||
UInt32 index = fItems.Find(item);
|
||||
uint32_t index = fItems.Find(item);
|
||||
if (index != fItems.kMissingIndex)
|
||||
{
|
||||
if (layer == plClothingElement::kLayerTint1)
|
||||
@ -712,9 +712,9 @@ hsColorRGBA plClothingOutfit::GetItemTint(plClothingItem *item, UInt8 layer /* =
|
||||
return color;
|
||||
}
|
||||
|
||||
hsBool plClothingOutfit::IMorphItem(plClothingItem *item, UInt8 layer, UInt8 delta, hsScalar weight)
|
||||
hsBool plClothingOutfit::IMorphItem(plClothingItem *item, uint8_t layer, uint8_t delta, hsScalar weight)
|
||||
{
|
||||
UInt32 index = fItems.Find(item);
|
||||
uint32_t index = fItems.Find(item);
|
||||
if (index != fItems.kMissingIndex)
|
||||
{
|
||||
int i;
|
||||
@ -790,7 +790,7 @@ void plClothingOutfit::IHandleMorphSDR(plStateDataRecord *sdr)
|
||||
if (!lodVar)
|
||||
return;
|
||||
|
||||
UInt8 lod;
|
||||
uint8_t lod;
|
||||
lodVar->Get(&lod);
|
||||
|
||||
const plSceneObject *so = fAvatar->GetClothingSO(lod);
|
||||
@ -1012,7 +1012,7 @@ void plClothingOutfit::WearDefaultClothing()
|
||||
cMgr->GetItemsByGroup(fGroup, items);
|
||||
|
||||
// Wear one thing of each type
|
||||
UInt32 i, j;
|
||||
uint32_t i, j;
|
||||
for (i = 0; i < plClothingMgr::kMaxType; i++)
|
||||
{
|
||||
if (i == plClothingMgr::kTypeAccessory)
|
||||
@ -1043,13 +1043,13 @@ void plClothingOutfit::WearDefaultClothing()
|
||||
}
|
||||
}
|
||||
|
||||
void plClothingOutfit::WearDefaultClothingType(UInt32 clothingType)
|
||||
void plClothingOutfit::WearDefaultClothingType(uint32_t clothingType)
|
||||
{
|
||||
plClothingMgr *cMgr = plClothingMgr::GetClothingMgr();
|
||||
hsTArray<plClothingItem *> items;
|
||||
cMgr->GetItemsByGroup(fGroup, items);
|
||||
|
||||
UInt32 i;
|
||||
uint32_t i;
|
||||
for (i=0; i<items.GetCount(); i++)
|
||||
{
|
||||
if (items[i]->fType == clothingType)
|
||||
@ -1149,15 +1149,15 @@ void plClothingOutfit::WearRandomOutfit()
|
||||
hsTArray<plClothingItem *>items;
|
||||
|
||||
// Wear one thing of each type
|
||||
UInt32 i, j;
|
||||
uint32_t i, j;
|
||||
for (i = 0; i < plClothingMgr::kMaxType; i++)
|
||||
{
|
||||
if (i == plClothingMgr::kTypeAccessory)
|
||||
continue;
|
||||
|
||||
items.Reset();
|
||||
cMgr->GetItemsByGroupAndType(fGroup, (UInt8)i, items);
|
||||
j = (UInt32)(sRandom.RandZeroToOne() * items.GetCount());
|
||||
cMgr->GetItemsByGroupAndType(fGroup, (uint8_t)i, items);
|
||||
j = (uint32_t)(sRandom.RandZeroToOne() * items.GetCount());
|
||||
|
||||
hsScalar r1 = sRandom.RandZeroToOne();
|
||||
hsScalar g1 = sRandom.RandZeroToOne();
|
||||
@ -1184,7 +1184,7 @@ void plClothingOutfit::WearRandomOutfit()
|
||||
hsBool plClothingOutfit::ReadItems(hsStream* s, hsResMgr* mgr, hsBool broadcast /* = true */)
|
||||
{
|
||||
hsBool result = true;
|
||||
UInt32 numItems = s->ReadLE32();
|
||||
uint32_t numItems = s->ReadLE32();
|
||||
int i;
|
||||
for (i = 0; i < numItems; i++)
|
||||
{
|
||||
@ -1410,7 +1410,7 @@ hsBool plClothingOutfit::MsgReceive(plMessage* msg)
|
||||
// TESTING SDL
|
||||
// Send clothing sendState msg to object's plClothingSDLModifier
|
||||
//
|
||||
hsBool plClothingOutfit::DirtySynchState(const char* SDLStateName, UInt32 synchFlags)
|
||||
hsBool plClothingOutfit::DirtySynchState(const char* SDLStateName, uint32_t synchFlags)
|
||||
{
|
||||
plSynchEnabler ps(true); // make sure synching is enabled, since this happens during load
|
||||
synchFlags |= plSynchedObject::kForceFullSend; // TEMP
|
||||
@ -1421,7 +1421,7 @@ hsBool plClothingOutfit::DirtySynchState(const char* SDLStateName, UInt32 synchF
|
||||
return fAvatar->GetTarget(0)->DirtySynchState(SDLStateName, synchFlags);
|
||||
}
|
||||
|
||||
// Note: Currently the word "instance" is a lie. We just copy. In the future
|
||||
// Note: Currently the uint16_t "instance" is a lie. We just copy. In the future
|
||||
// we'll be good about this, but I wanted to get it working first.
|
||||
void plClothingOutfit::IInstanceSharedMeshes(plClothingItem *item)
|
||||
{
|
||||
@ -1670,7 +1670,7 @@ plClothingItem *plClothingMgr::FindItemByName(const char *name)
|
||||
return nil;
|
||||
}
|
||||
|
||||
void plClothingMgr::GetItemsByGroup(UInt8 group, hsTArray<plClothingItem*> &out)
|
||||
void plClothingMgr::GetItemsByGroup(uint8_t group, hsTArray<plClothingItem*> &out)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < fItems.GetCount(); i++)
|
||||
@ -1680,7 +1680,7 @@ void plClothingMgr::GetItemsByGroup(UInt8 group, hsTArray<plClothingItem*> &out)
|
||||
}
|
||||
}
|
||||
|
||||
void plClothingMgr::GetItemsByGroupAndType(UInt8 group, UInt8 type, hsTArray<plClothingItem*> &out)
|
||||
void plClothingMgr::GetItemsByGroupAndType(uint8_t group, uint8_t type, hsTArray<plClothingItem*> &out)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < fItems.GetCount(); i++)
|
||||
|
||||
@ -90,16 +90,16 @@ public:
|
||||
hsTArray<plMipmap **> fTextures;
|
||||
hsTArray<char *> fElementNames;
|
||||
hsTArray<plClothingElement *> fElements;
|
||||
UInt8 fGroup; // Each avatar can wear one of the available groups
|
||||
UInt8 fType; // Each group has multiple types of clothes (shirt/pants/etc)
|
||||
UInt8 fTileset;
|
||||
UInt8 fSortOrder;
|
||||
uint8_t fGroup; // Each avatar can wear one of the available groups
|
||||
uint8_t fType; // Each group has multiple types of clothes (shirt/pants/etc)
|
||||
uint8_t fTileset;
|
||||
uint8_t fSortOrder;
|
||||
char *fDescription;
|
||||
char *fCustomText;
|
||||
plMipmap *fThumbnail;
|
||||
plClothingItem *fAccessory; // Forced accessory to always wear with this item.
|
||||
UInt8 fDefaultTint1[3];
|
||||
UInt8 fDefaultTint2[3];
|
||||
uint8_t fDefaultTint1[3];
|
||||
uint8_t fDefaultTint2[3];
|
||||
|
||||
char *fAccessoryName; // Export only
|
||||
|
||||
@ -167,7 +167,7 @@ public:
|
||||
hsTArray<plClothingItem*> fItems;
|
||||
hsTArray<plClothingItemOptions*> fOptions;
|
||||
plClothingBase *fBase;
|
||||
UInt8 fGroup;
|
||||
uint8_t fGroup;
|
||||
bool fSynchClients; // set true if the next synch should be bcast
|
||||
hsColorRGBA fSkinTint;
|
||||
hsScalar fSkinBlends[plClothingElement::kLayerSkinLast - plClothingElement::kLayerSkinFirst]; // Controls the opacity between skin textures.
|
||||
@ -182,25 +182,25 @@ public:
|
||||
void AddItem(plClothingItem *item, hsBool update = true, hsBool broadcast = true, hsBool netForce=false);
|
||||
void RemoveItem(plClothingItem *item, hsBool update = true, hsBool netForce=false);
|
||||
void TintItem(plClothingItem *item, hsScalar red, hsScalar green, hsScalar blue, hsBool update = true, hsBool broadcast = true,
|
||||
hsBool netForce = false, hsBool retry = true, UInt8 fLayer = plClothingElement::kLayerTint1);
|
||||
hsBool netForce = false, hsBool retry = true, uint8_t fLayer = plClothingElement::kLayerTint1);
|
||||
void TintSkin(hsScalar red, hsScalar green, hsScalar blue,
|
||||
hsBool update = true, hsBool broadcast = true);
|
||||
void MorphItem(plClothingItem *item, UInt8 layer, UInt8 delta, hsScalar weight, hsBool retry = true);
|
||||
void MorphItem(plClothingItem *item, uint8_t layer, uint8_t delta, hsScalar weight, hsBool retry = true);
|
||||
void SetAge(hsScalar age, hsBool update = true, hsBool broadcast = true);
|
||||
void SetSkinBlend(hsScalar blend, UInt8 layer, hsBool update = true, hsBool broadcast = true);
|
||||
hsScalar GetSkinBlend(UInt8 layer);
|
||||
hsColorRGBA GetItemTint(plClothingItem *item, UInt8 layer = 2) const;
|
||||
void SetSkinBlend(hsScalar blend, uint8_t layer, hsBool update = true, hsBool broadcast = true);
|
||||
hsScalar GetSkinBlend(uint8_t layer);
|
||||
hsColorRGBA GetItemTint(plClothingItem *item, uint8_t layer = 2) const;
|
||||
hsScalar GetAge() const { return fSkinBlends[0]; }
|
||||
hsTArray<plClothingItem*> &GetItemList() { return fItems; }
|
||||
hsTArray<plClothingItemOptions*> &GetOptionList() { return fOptions; }
|
||||
|
||||
virtual void Read(hsStream* s, hsResMgr* mgr);
|
||||
virtual void Write(hsStream* s, hsResMgr* mgr);
|
||||
hsBool DirtySynchState(const char* SDLStateName, UInt32 synchFlags);
|
||||
hsBool DirtySynchState(const char* SDLStateName, uint32_t synchFlags);
|
||||
|
||||
void StripAccessories();
|
||||
void WearDefaultClothing();
|
||||
void WearDefaultClothingType(UInt32 clothingType);
|
||||
void WearDefaultClothingType(uint32_t clothingType);
|
||||
void WearMaintainerOutfit();
|
||||
void WearRandomOutfit();
|
||||
void RemoveMaintainerOutfit();
|
||||
@ -231,8 +231,8 @@ protected:
|
||||
|
||||
void IAddItem(plClothingItem *item);
|
||||
void IRemoveItem(plClothingItem *item);
|
||||
hsBool ITintItem(plClothingItem *item, hsColorRGBA color, UInt8 layer);
|
||||
hsBool IMorphItem(plClothingItem *item, UInt8 layer, UInt8 delta, hsScalar weight);
|
||||
hsBool ITintItem(plClothingItem *item, hsColorRGBA color, uint8_t layer);
|
||||
hsBool IMorphItem(plClothingItem *item, uint8_t layer, uint8_t delta, hsScalar weight);
|
||||
void IHandleMorphSDR(plStateDataRecord *sdr);
|
||||
|
||||
void IUpdate();
|
||||
@ -269,8 +269,8 @@ public:
|
||||
// Functions that relate to all existing clothing
|
||||
plClothingItem *FindItemByName(const char *name);
|
||||
hsTArray<plClothingItem*>& GetItemList() { return fItems; }
|
||||
void GetItemsByGroup(UInt8 group, hsTArray<plClothingItem*> &out);
|
||||
void GetItemsByGroupAndType(UInt8 group, UInt8 type, hsTArray<plClothingItem*> &out);
|
||||
void GetItemsByGroup(uint8_t group, hsTArray<plClothingItem*> &out);
|
||||
void GetItemsByGroupAndType(uint8_t group, uint8_t type, hsTArray<plClothingItem*> &out);
|
||||
void GetAllWithSameMesh(plClothingItem *item, hsTArray<plClothingItem*> &out);
|
||||
|
||||
// Give an array of items (from one of the above functions, for example)
|
||||
|
||||
@ -372,8 +372,8 @@ hsBool plAvatarMgr::HandleCoopMsg(plAvCoopMsg *msg)
|
||||
{
|
||||
plAvCoopMsg::Command cmd = msg->fCommand;
|
||||
|
||||
UInt32 id = msg->fInitiatorID;
|
||||
UInt16 serial = msg->fInitiatorSerial;
|
||||
uint32_t id = msg->fInitiatorID;
|
||||
uint16_t serial = msg->fInitiatorSerial;
|
||||
|
||||
if(cmd == plAvCoopMsg::kStartNew)
|
||||
{
|
||||
@ -407,14 +407,14 @@ hsBool plAvatarMgr::HandleNotifyMsg(plNotifyMsg *msg)
|
||||
proCoopEventData *ed = static_cast<proCoopEventData *>(msg->FindEventRecord(proEventData::kCoop));
|
||||
if(ed)
|
||||
{
|
||||
UInt32 id = ed->fID;
|
||||
UInt16 serial = ed->fSerial;
|
||||
uint32_t id = ed->fID;
|
||||
uint16_t serial = ed->fSerial;
|
||||
return IPassMessageToActiveCoop(msg, id, serial);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
hsBool plAvatarMgr::IPassMessageToActiveCoop(plMessage *msg, UInt32 id, UInt16 serial)
|
||||
hsBool plAvatarMgr::IPassMessageToActiveCoop(plMessage *msg, uint32_t id, uint16_t serial)
|
||||
{
|
||||
plCoopMap::iterator i = fActiveCoops.find(id);
|
||||
while(i != fActiveCoops.end() && (*i).first == id)
|
||||
@ -738,7 +738,7 @@ plArmatureMod* plAvatarMgr::FindAvatar(plKey& avatarKey)
|
||||
return nil;
|
||||
}
|
||||
|
||||
plArmatureMod* plAvatarMgr::FindAvatarByPlayerID(UInt32 pid)
|
||||
plArmatureMod* plAvatarMgr::FindAvatarByPlayerID(uint32_t pid)
|
||||
{
|
||||
plAvatarVec::iterator it;
|
||||
for (it = fAvatars.begin(); it != fAvatars.end(); ++it)
|
||||
@ -815,7 +815,7 @@ int plAvatarMgr::FindSpawnPoint( const char *name ) const
|
||||
return -1;
|
||||
}
|
||||
|
||||
int plAvatarMgr::WarpPlayerToAnother(hsBool iMove, UInt32 remoteID)
|
||||
int plAvatarMgr::WarpPlayerToAnother(hsBool iMove, uint32_t remoteID)
|
||||
{
|
||||
plNetTransport &mgr = plNetClientMgr::GetInstance()->TransportMgr();
|
||||
plNetTransportMember *mbr = mgr.GetMember(mgr.FindMember(remoteID));
|
||||
@ -1020,13 +1020,13 @@ void plAvatarMgr::OfferLinkingBook(plKey hostKey, plKey guestKey, plMessage *lin
|
||||
brainH->AddStage(hostIdle);
|
||||
brainH->AddStage(hostFinish);
|
||||
|
||||
UInt32 hostID = brainH->GetInitiatorID();
|
||||
UInt32 hostSerial = brainH->GetInitiatorSerial();
|
||||
uint32_t hostID = brainH->GetInitiatorID();
|
||||
uint32_t hostSerial = brainH->GetInitiatorSerial();
|
||||
|
||||
|
||||
// make the guest brain
|
||||
plAvBrainCoop * brainG = TRACKED_NEW plAvBrainCoop(plAvBrainGeneric::kExitNormal, 3.0, 3.0, plAvBrainGeneric::kMoveRelative,
|
||||
hostID, (UInt16)hostSerial, hostKey);
|
||||
hostID, (uint16_t)hostSerial, hostKey);
|
||||
|
||||
plAnimStage *guestAccept = TRACKED_NEW plAnimStage("BookAccept", plAnimStage::kNotifyAdvance);
|
||||
plAnimStage *guestAcceptIdle = TRACKED_NEW plAnimStage("BookAcceptIdle", plAnimStage::kNotifyEnter, plAnimStage::kForwardAuto, plAnimStage::kBackNone,
|
||||
|
||||
@ -132,7 +132,7 @@ public:
|
||||
plArmatureMod *GetLocalAvatar();
|
||||
plKey GetLocalAvatarKey();
|
||||
static plArmatureMod *FindAvatar(plKey& avatarKey); // Key of the sceneObject
|
||||
plArmatureMod *FindAvatarByPlayerID(UInt32 pid);
|
||||
plArmatureMod *FindAvatarByPlayerID(uint32_t pid);
|
||||
plArmatureMod *FindAvatarByModelName(char *name); // Probably only useful for custom NPCs. All players are
|
||||
// either "Male" or "Female".
|
||||
void FindAllAvatarsByModelName(const char* name, plArmatureModPtrVec& outVec);
|
||||
@ -149,7 +149,7 @@ public:
|
||||
int NumSpawnPoints() { return fSpawnPoints.size(); }
|
||||
int FindSpawnPoint( const char *name ) const;
|
||||
// \}
|
||||
static int WarpPlayerToAnother(hsBool iMove, UInt32 remoteID);
|
||||
static int WarpPlayerToAnother(hsBool iMove, uint32_t remoteID);
|
||||
static int WarpPlayerToXYZ(hsScalar x, hsScalar y, hsScalar z);
|
||||
static int WarpPlayerToXYZ(int pid, hsScalar x, hsScalar y, hsScalar z);
|
||||
|
||||
@ -160,7 +160,7 @@ public:
|
||||
hsBool MsgReceive(plMessage *msg);
|
||||
hsBool HandleCoopMsg(plAvCoopMsg *msg);
|
||||
hsBool HandleNotifyMsg(plNotifyMsg *msg);
|
||||
hsBool IPassMessageToActiveCoop(plMessage *msg, UInt32 id, UInt16 serial);
|
||||
hsBool IPassMessageToActiveCoop(plMessage *msg, uint32_t id, uint16_t serial);
|
||||
|
||||
// similar to a spawn point, maintainers markers are used
|
||||
// to generate your position in Dni coordinates
|
||||
@ -224,7 +224,7 @@ protected:
|
||||
// ID. By using a multimap, however, we can still handle a few different coops
|
||||
// for the same user by just iterating from the first match forward until
|
||||
// we run out of matches.
|
||||
typedef std::multimap<UInt32, plCoopCoordinator *> plCoopMap;
|
||||
typedef std::multimap<uint32_t, plCoopCoordinator *> plCoopMap;
|
||||
plCoopMap fActiveCoops;
|
||||
|
||||
hsTArray<plLoadCloneMsg*> fCloneMsgQueue;
|
||||
|
||||
@ -437,7 +437,7 @@ bool plAvatarSDLModifier::ISetGenericBrainFrom(plArmatureMod *avMod, const plSta
|
||||
// IGetStageFrom ----------------------------------------------------------------------------------------
|
||||
plAnimStage * plAvatarSDLModifier::IGetStageFrom(plArmatureMod *avMod, const plStateDataRecord* srcState)
|
||||
{
|
||||
UInt32 notifyFlags=0;
|
||||
uint32_t notifyFlags=0;
|
||||
|
||||
bool notifyEnter, notifyLoop, notifyAdv, notifyRegress;
|
||||
if (srcState->FindVar(StandardStageVarNames::kStrNotifyEnter)->Get(¬ifyEnter))
|
||||
@ -500,7 +500,7 @@ plAnimStage * plAvatarSDLModifier::IGetStageFrom(plArmatureMod *avMod, const plS
|
||||
// ***!!! need to capture "advanceTo" and "regressTo" values!!!
|
||||
bool hackAdvanceToWrong = false, hackRegressToWrong = false;
|
||||
plAnimStage *newStage = TRACKED_NEW plAnimStage(name,
|
||||
(UInt8)notifyFlags,
|
||||
(uint8_t)notifyFlags,
|
||||
static_cast<plAnimStage::ForwardType>(fwd),
|
||||
static_cast<plAnimStage::BackType>(bwd),
|
||||
static_cast<plAnimStage::AdvanceType>(adv),
|
||||
@ -526,7 +526,7 @@ bool plAvatarSDLModifier::IPutStageIn(plArmatureMod *avMod, plAnimStage *stage,
|
||||
dstState->FindVar(StandardStageVarNames::kStrStageAdvance)->Set((int)stage->GetAdvanceType());
|
||||
dstState->FindVar(StandardStageVarNames::kStrStageRegress)->Set((int)stage->GetRegressType());
|
||||
|
||||
UInt32 notifies = stage->GetNotifyFlags();
|
||||
uint32_t notifies = stage->GetNotifyFlags();
|
||||
dstState->FindVar(StandardStageVarNames::kStrNotifyEnter)->Set((notifies & plAnimStage::kNotifyEnter) ? true : false);
|
||||
dstState->FindVar(StandardStageVarNames::kStrNotifyLoop)->Set((notifies & plAnimStage::kNotifyLoop) ? true : false);
|
||||
dstState->FindVar(StandardStageVarNames::kStrNotifyStageAdvance)->Set((notifies & plAnimStage::kNotifyAdvance) ? true : false);
|
||||
|
||||
@ -68,7 +68,7 @@ protected:
|
||||
void ISetCurrentStateFrom(const plStateDataRecord* srcState);
|
||||
void IPutCurrentStateIn(plStateDataRecord* dstState);
|
||||
|
||||
UInt32 IApplyModFlags(UInt32 sendFlags) { return (sendFlags | plSynchedObject::kDontPersistOnServer | plSynchedObject::kIsAvatarState); }
|
||||
uint32_t IApplyModFlags(uint32_t sendFlags) { return (sendFlags | plSynchedObject::kDontPersistOnServer | plSynchedObject::kIsAvatarState); }
|
||||
|
||||
public:
|
||||
CLASSNAME_REGISTER( plAvatarPhysicalSDLModifier );
|
||||
@ -150,7 +150,7 @@ protected:
|
||||
void IPutDriveBrainIn(plArmatureMod *avMod, plAvBrainDrive *brain, plStateDataRecord* dstState);
|
||||
bool IPutStageIn(plArmatureMod *avMod, plAnimStage *stage, plStateDataRecord* dstState);
|
||||
|
||||
UInt32 IApplyModFlags(UInt32 sendFlags) { return (sendFlags | plSynchedObject::kDontPersistOnServer | plSynchedObject::kIsAvatarState); }
|
||||
uint32_t IApplyModFlags(uint32_t sendFlags) { return (sendFlags | plSynchedObject::kDontPersistOnServer | plSynchedObject::kIsAvatarState); }
|
||||
|
||||
public:
|
||||
CLASSNAME_REGISTER( plAvatarSDLModifier );
|
||||
|
||||
@ -72,12 +72,12 @@ public:
|
||||
};
|
||||
|
||||
char *fName;
|
||||
UInt32 fXPos;
|
||||
UInt32 fYPos;
|
||||
UInt32 fWidth;
|
||||
UInt32 fHeight;
|
||||
uint32_t fXPos;
|
||||
uint32_t fYPos;
|
||||
uint32_t fWidth;
|
||||
uint32_t fHeight;
|
||||
|
||||
plClothingElement(const char *name, UInt32 xPos, UInt32 yPos, UInt32 width, UInt32 height)
|
||||
plClothingElement(const char *name, uint32_t xPos, uint32_t yPos, uint32_t width, uint32_t height)
|
||||
{
|
||||
fName = hsStrcpy(name);
|
||||
fXPos = xPos;
|
||||
@ -127,11 +127,11 @@ public:
|
||||
class plClothingLayout
|
||||
{
|
||||
public:
|
||||
plClothingLayout(char *name, UInt32 origWidth) { fName = hsStrcpy(name); fOrigWidth = origWidth; }
|
||||
plClothingLayout(char *name, uint32_t origWidth) { fName = hsStrcpy(name); fOrigWidth = origWidth; }
|
||||
~plClothingLayout() { delete [] fName; }
|
||||
|
||||
char *fName;
|
||||
UInt32 fOrigWidth;
|
||||
uint32_t fOrigWidth;
|
||||
hsTArray<plClothingElement*> fElements;
|
||||
/*
|
||||
enum
|
||||
|
||||
@ -135,10 +135,10 @@ void plClothingSDLModifier::IPutCurrentStateIn(plStateDataRecord* dstState)
|
||||
|
||||
// skin tint
|
||||
plSDStateVariable* appearanceStateDesc = dstState->FindSDVar(kStrAppearance); // for skin tint
|
||||
UInt8 skinTint[3];
|
||||
skinTint[0] = (UInt8)(clothing->fSkinTint.r * 255);
|
||||
skinTint[1] = (UInt8)(clothing->fSkinTint.g * 255);
|
||||
skinTint[2] = (UInt8)(clothing->fSkinTint.b * 255);
|
||||
uint8_t skinTint[3];
|
||||
skinTint[0] = (uint8_t)(clothing->fSkinTint.r * 255);
|
||||
skinTint[1] = (uint8_t)(clothing->fSkinTint.g * 255);
|
||||
skinTint[2] = (uint8_t)(clothing->fSkinTint.b * 255);
|
||||
appearanceStateDesc->GetStateDataRecord(0)->FindVar(kStrSkinTint)->Set(skinTint);
|
||||
|
||||
plSimpleStateVariable* faceBlends = appearanceStateDesc->GetStateDataRecord(0)->FindVar(kStrFaceBlends);
|
||||
@ -146,7 +146,7 @@ void plClothingSDLModifier::IPutCurrentStateIn(plStateDataRecord* dstState)
|
||||
if (faceBlends->GetCount() != numBlends)
|
||||
faceBlends->Alloc(numBlends);
|
||||
for(i = 0; i < numBlends; i++)
|
||||
faceBlends->Set((UInt8)(clothing->fSkinBlends[i] * 255), i);
|
||||
faceBlends->Set((uint8_t)(clothing->fSkinBlends[i] * 255), i);
|
||||
|
||||
SDRs.Append(appearanceStateDesc->GetStateDataRecord(0));
|
||||
|
||||
@ -165,14 +165,14 @@ void plClothingSDLModifier::PutSingleItemIntoSDR(plClosetItem *item, plStateData
|
||||
|
||||
//hsColorRGBA c = item->fOptions.fTint1;
|
||||
//hsColorRGBA c2 = item->fOptions.fTint2;
|
||||
UInt8 c[3];
|
||||
UInt8 c2[3];
|
||||
c[0] = (UInt8)(item->fOptions.fTint1.r * 255);
|
||||
c[1] = (UInt8)(item->fOptions.fTint1.g * 255);
|
||||
c[2] = (UInt8)(item->fOptions.fTint1.b * 255);
|
||||
c2[0] = (UInt8)(item->fOptions.fTint2.r * 255);
|
||||
c2[1] = (UInt8)(item->fOptions.fTint2.g * 255);
|
||||
c2[2] = (UInt8)(item->fOptions.fTint2.b * 255);
|
||||
uint8_t c[3];
|
||||
uint8_t c2[3];
|
||||
c[0] = (uint8_t)(item->fOptions.fTint1.r * 255);
|
||||
c[1] = (uint8_t)(item->fOptions.fTint1.g * 255);
|
||||
c[2] = (uint8_t)(item->fOptions.fTint1.b * 255);
|
||||
c2[0] = (uint8_t)(item->fOptions.fTint2.r * 255);
|
||||
c2[1] = (uint8_t)(item->fOptions.fTint2.g * 255);
|
||||
c2[2] = (uint8_t)(item->fOptions.fTint2.b * 255);
|
||||
|
||||
sdr->FindVar(kStrTint)->Set(c);
|
||||
sdr->FindVar(kStrTint2)->Set(c2);
|
||||
@ -229,7 +229,7 @@ void plClothingSDLModifier::HandleSingleSDR(const plStateDataRecord *sdr, plClot
|
||||
return;
|
||||
|
||||
int i;
|
||||
UInt8 tint[3];
|
||||
uint8_t tint[3];
|
||||
hsScalar tintScalar[3];
|
||||
if (!strcmp(sdr->GetDescriptor()->GetName(), kStrClothingDescName))
|
||||
{
|
||||
@ -300,7 +300,7 @@ void plClothingSDLModifier::HandleSingleSDR(const plStateDataRecord *sdr, plClot
|
||||
int numBlends = plClothingElement::kLayerSkinLast - plClothingElement::kLayerSkinFirst;
|
||||
for(i = 0; i < numBlends && i < faceBlends->GetCount(); i++)
|
||||
{
|
||||
UInt8 blend;
|
||||
uint8_t blend;
|
||||
faceBlends->Get(&blend, i);
|
||||
clothing->fSkinBlends[i] = (hsScalar)blend / 255;
|
||||
}
|
||||
|
||||
@ -66,7 +66,7 @@ protected:
|
||||
void IPutCurrentStateIn(plStateDataRecord* dstState);
|
||||
void ISetCurrentStateFrom(const plStateDataRecord* srcState);
|
||||
|
||||
UInt32 IApplyModFlags(UInt32 sendFlags) { return (sendFlags | plSynchedObject::kDontPersistOnServer | plSynchedObject::kIsAvatarState); }
|
||||
uint32_t IApplyModFlags(uint32_t sendFlags) { return (sendFlags | plSynchedObject::kDontPersistOnServer | plSynchedObject::kIsAvatarState); }
|
||||
|
||||
public:
|
||||
// var labels
|
||||
|
||||
@ -95,7 +95,7 @@ plCoopCoordinator::plCoopCoordinator()
|
||||
plCoopCoordinator::plCoopCoordinator(plKey host, plKey guest,
|
||||
plAvBrainCoop *hostBrain, plAvBrainCoop *guestBrain,
|
||||
const char *synchBone,
|
||||
UInt32 hostOfferStage, UInt32 guestAcceptStage,
|
||||
uint32_t hostOfferStage, uint32_t guestAcceptStage,
|
||||
plMessage *guestAcceptMsg,
|
||||
bool autoStartGuest)
|
||||
: fHostKey(host),
|
||||
@ -168,7 +168,7 @@ hsBool plCoopCoordinator::MsgReceive(plMessage *msg)
|
||||
if(mtevt)
|
||||
{
|
||||
int stageNum = mtevt->fStage;
|
||||
UInt32 stageState = mtevt->fEvent;
|
||||
uint32_t stageState = mtevt->fEvent;
|
||||
|
||||
plKey noteSender = notify->GetSender();
|
||||
bool isFromHost = (noteSender == fHostKey);
|
||||
@ -253,7 +253,7 @@ hsBool plCoopCoordinator::MsgReceive(plMessage *msg)
|
||||
DebugMsg("COOP: Received avatar seek finished msg: aborted = %d", seekDone->fAborted ? 1 : 0);
|
||||
if ( seekDone->fAborted )
|
||||
{
|
||||
plAvCoopMsg *coopM = TRACKED_NEW plAvCoopMsg(plAvCoopMsg::kGuestSeekAbort,fInitiatorID,(UInt16)fInitiatorSerial);
|
||||
plAvCoopMsg *coopM = TRACKED_NEW plAvCoopMsg(plAvCoopMsg::kGuestSeekAbort,fInitiatorID,(uint16_t)fInitiatorSerial);
|
||||
coopM->SetBCastFlag(plMessage::kNetPropagate);
|
||||
coopM->SetBCastFlag(plMessage::kNetForce);
|
||||
coopM->AddReceiver(GetKey());
|
||||
@ -262,7 +262,7 @@ hsBool plCoopCoordinator::MsgReceive(plMessage *msg)
|
||||
}
|
||||
else
|
||||
{
|
||||
plAvCoopMsg *coopM = TRACKED_NEW plAvCoopMsg(plAvCoopMsg::kGuestSeeked,fInitiatorID,(UInt16)fInitiatorSerial);
|
||||
plAvCoopMsg *coopM = TRACKED_NEW plAvCoopMsg(plAvCoopMsg::kGuestSeeked,fInitiatorID,(uint16_t)fInitiatorSerial);
|
||||
coopM->SetBCastFlag(plMessage::kNetPropagate);
|
||||
coopM->SetBCastFlag(plMessage::kNetForce);
|
||||
coopM->AddReceiver(GetKey());
|
||||
@ -293,15 +293,15 @@ bool plCoopCoordinator::IsActiveForReal()
|
||||
|
||||
// GetInitiatorID ------------------------
|
||||
// ---------------
|
||||
UInt32 plCoopCoordinator::GetInitiatorID()
|
||||
uint32_t plCoopCoordinator::GetInitiatorID()
|
||||
{
|
||||
return fInitiatorID;
|
||||
}
|
||||
|
||||
// GetInitiatorSerial ------------------------
|
||||
UInt16 plCoopCoordinator::GetInitiatorSerial()
|
||||
uint16_t plCoopCoordinator::GetInitiatorSerial()
|
||||
{
|
||||
return (UInt16)fInitiatorSerial;
|
||||
return (uint16_t)fInitiatorSerial;
|
||||
}
|
||||
|
||||
// IStartHost ----------------------
|
||||
@ -430,8 +430,8 @@ void plCoopCoordinator::Write(hsStream *stream, hsResMgr *mgr)
|
||||
mgr->WriteCreatable(stream, fHostBrain);
|
||||
mgr->WriteCreatable(stream, fGuestBrain);
|
||||
|
||||
stream->WriteByte((UInt8)fHostOfferStage);
|
||||
stream->WriteByte((UInt8)fGuestAcceptStage);
|
||||
stream->WriteByte((uint8_t)fHostOfferStage);
|
||||
stream->WriteByte((uint8_t)fGuestAcceptStage);
|
||||
|
||||
stream->Writebool(fGuestAcceptMsg != nil);
|
||||
if(fGuestAcceptMsg)
|
||||
|
||||
@ -79,7 +79,7 @@ public:
|
||||
plCoopCoordinator();
|
||||
plCoopCoordinator(plKey host, plKey guest,
|
||||
plAvBrainCoop *hostBrain, plAvBrainCoop *guestBrain,
|
||||
const char *synchBone, UInt32 hostOfferStage, UInt32 guestAcceptStage,
|
||||
const char *synchBone, uint32_t hostOfferStage, uint32_t guestAcceptStage,
|
||||
plMessage *guestAcceptMsg,
|
||||
bool autoStartGuest);
|
||||
~plCoopCoordinator();
|
||||
@ -88,8 +88,8 @@ public:
|
||||
|
||||
void Run();
|
||||
|
||||
UInt32 GetInitiatorID();
|
||||
UInt16 GetInitiatorSerial();
|
||||
uint32_t GetInitiatorID();
|
||||
uint16_t GetInitiatorSerial();
|
||||
|
||||
bool IsActiveForReal();
|
||||
|
||||
@ -116,11 +116,11 @@ protected:
|
||||
plAvBrainCoop *fHostBrain;
|
||||
plAvBrainCoop *fGuestBrain;
|
||||
|
||||
UInt32 fInitiatorID;
|
||||
UInt32 fInitiatorSerial;
|
||||
uint32_t fInitiatorID;
|
||||
uint32_t fInitiatorSerial;
|
||||
|
||||
UInt32 fHostOfferStage; // when we enter this stage, the offer is ready
|
||||
UInt32 fGuestAcceptStage; // when we enter this stage, the offer is accepted
|
||||
uint32_t fHostOfferStage; // when we enter this stage, the offer is ready
|
||||
uint32_t fGuestAcceptStage; // when we enter this stage, the offer is accepted
|
||||
|
||||
plMessage *fGuestAcceptMsg; // send this when the guest accepts
|
||||
|
||||
|
||||
@ -370,7 +370,7 @@ plAGChannel * plMatrixBlend::MakeBlend(plAGChannel *newChannel,
|
||||
return result;
|
||||
}
|
||||
|
||||
UInt16 plMatrixBlend::GetPriority() {
|
||||
uint16_t plMatrixBlend::GetPriority() {
|
||||
return fPriority;
|
||||
}
|
||||
|
||||
|
||||
@ -173,7 +173,7 @@ public:
|
||||
virtual plAGChannel * MakeBlend(plAGChannel *newChannel, plScalarChannel *channelBias, int blendPriority);
|
||||
|
||||
// you cannot blend on top of a channel that has higher priority than you do.
|
||||
virtual UInt16 GetPriority();
|
||||
virtual uint16_t GetPriority();
|
||||
|
||||
// SPECIFICS
|
||||
const plMatrixChannel * GetChannelA() const { return fChannelA; }
|
||||
|
||||
@ -169,7 +169,7 @@ hsBool plMultistageBehMod::MsgReceive(plMessage* msg)
|
||||
|
||||
// these (currently unused) callbacks are for the brain itself, not any of the stages
|
||||
plMessage *exitCallback = nil, *enterCallback = nil;
|
||||
UInt32 exitFlags = plAvBrainGeneric::kExitNormal;
|
||||
uint32_t exitFlags = plAvBrainGeneric::kExitNormal;
|
||||
|
||||
plAvBrainGeneric *brain = TRACKED_NEW plAvBrainGeneric(stages, exitCallback, enterCallback, sender, exitFlags,
|
||||
plAvBrainGeneric::kDefaultFadeIn, plAvBrainGeneric::kDefaultFadeOut,
|
||||
|
||||
@ -61,7 +61,7 @@ protected:
|
||||
std::vector<plKey> fReceivers;
|
||||
|
||||
void IDeleteStageVec();
|
||||
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return true; }
|
||||
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) { return true; }
|
||||
|
||||
public:
|
||||
plMultistageBehMod();
|
||||
|
||||
@ -175,7 +175,7 @@ void plNPCSpawnMod::Write(hsStream *stream, hsResMgr *mgr)
|
||||
|
||||
// IEVAL
|
||||
// attack of the bogons
|
||||
hsBool plNPCSpawnMod::IEval(double secs, hsScalar del, UInt32 dirty)
|
||||
hsBool plNPCSpawnMod::IEval(double secs, hsScalar del, uint32_t dirty)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -65,7 +65,7 @@ public:
|
||||
virtual void Write(hsStream *stream, hsResMgr *mgr);
|
||||
|
||||
protected:
|
||||
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty);
|
||||
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty);
|
||||
void ISendNotify(plKey &avatarKey); // send our notification message
|
||||
|
||||
private:
|
||||
|
||||
@ -55,7 +55,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
||||
class plOneShotMod : public plMultiModifier
|
||||
{
|
||||
protected:
|
||||
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) {return true;}
|
||||
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) {return true;}
|
||||
char * fAnimName; // the name of the animation associated with this one-shot
|
||||
hsBool fDrivable; // whether the user can control the position of the animation
|
||||
hsBool fReversable; // whether the user can back up the animation (fDrivable must be true as well)
|
||||
|
||||
@ -239,7 +239,7 @@ void plWalkingStrategy::Apply(hsScalar delSecs)
|
||||
{
|
||||
//Apply Should Only be Called from a PhysicalControllerCore
|
||||
hsAssert(fCore,"No Core shouldn't be Applying");
|
||||
UInt32 collideFlags =
|
||||
uint32_t collideFlags =
|
||||
1<<plSimDefs::kGroupStatic |
|
||||
1<<plSimDefs::kGroupAvatarBlocker |
|
||||
1<<plSimDefs::kGroupDynamic;
|
||||
@ -400,7 +400,7 @@ void plWalkingStrategy::Apply(hsScalar delSecs)
|
||||
//Did you hit your head on a dynamic?
|
||||
//with Physx's wonderful controller hit report vs flags issues we need to actually sweep to see
|
||||
std::multiset< plControllerSweepRecord > HitsDynamic;
|
||||
UInt32 testFlag=1<<plSimDefs::kGroupDynamic;
|
||||
uint32_t testFlag=1<<plSimDefs::kGroupDynamic;
|
||||
hsPoint3 startPos;
|
||||
hsPoint3 endPos;
|
||||
fCore->GetPositionSim(startPos);
|
||||
@ -613,7 +613,7 @@ void plSwimStrategy::IAdjustBuoyancy()
|
||||
void plSwimStrategy::Apply(hsScalar delSecs)
|
||||
{
|
||||
hsAssert(fCore,"PlSwimStrategy::Apply No Core shouldn't be Applying");
|
||||
UInt32 collideFlags =
|
||||
uint32_t collideFlags =
|
||||
1<<plSimDefs::kGroupStatic |
|
||||
1<<plSimDefs::kGroupAvatarBlocker |
|
||||
1<<plSimDefs::kGroupDynamic;
|
||||
@ -772,7 +772,7 @@ void plRidingAnimatedPhysicalStrategy::Apply(hsScalar delSecs)
|
||||
plSceneObject* so = plSceneObject::ConvertNoRef(fOwner->ObjectIsLoaded());
|
||||
hsPoint3 startPos, desiredDestination, endPos;
|
||||
fCore->GetPositionSim(startPos);
|
||||
UInt32 collideFlags =
|
||||
uint32_t collideFlags =
|
||||
1<<plSimDefs::kGroupStatic |
|
||||
1<<plSimDefs::kGroupAvatarBlocker |
|
||||
1<<plSimDefs::kGroupDynamic;
|
||||
@ -884,7 +884,7 @@ bool plRidingAnimatedPhysicalStrategy::ICheckMove(const hsPoint3& startPos, cons
|
||||
//returns false if it believes the end result can't be obtained by pure application of velocity (collides into somthing that it can't climb up)
|
||||
//used as a way to check if it needs to hack getting there like in jumping
|
||||
|
||||
UInt32 collideFlags =
|
||||
uint32_t collideFlags =
|
||||
1<<plSimDefs::kGroupStatic |
|
||||
1<<plSimDefs::kGroupAvatarBlocker |
|
||||
1<<plSimDefs::kGroupDynamic;
|
||||
|
||||
@ -188,7 +188,7 @@ public:
|
||||
{
|
||||
fAchievedLinearVelocity.Set(0.f,0.f,0.f);
|
||||
}
|
||||
virtual int SweepControllerPath(const hsPoint3& startPos,const hsPoint3& endPos, hsBool vsDynamics, hsBool vsStatics, UInt32& vsSimGroups, std::multiset< plControllerSweepRecord >& WhatWasHitOut)=0;
|
||||
virtual int SweepControllerPath(const hsPoint3& startPos,const hsPoint3& endPos, hsBool vsDynamics, hsBool vsStatics, uint32_t& vsSimGroups, std::multiset< plControllerSweepRecord >& WhatWasHitOut)=0;
|
||||
//this should only be used to force a move it could place your head into a wall and that would be good
|
||||
virtual hsScalar GetHeight() {return fHeight;}
|
||||
virtual hsScalar GetRadius() {return fRadius;}
|
||||
|
||||
@ -52,7 +52,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
||||
class plSeekPointMod : public plMultiModifier
|
||||
{
|
||||
protected:
|
||||
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) {return true;}
|
||||
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) {return true;}
|
||||
char * fName; // public because you can't change it
|
||||
|
||||
public:
|
||||
|
||||
@ -198,7 +198,7 @@ hsBool plSittingModifier::MsgReceive(plMessage *msg)
|
||||
plSceneObject * obj = plSceneObject::ConvertNoRef(avatarKey->ObjectIsLoaded());
|
||||
plArmatureMod * avMod = (plArmatureMod*)obj->GetModifierByType(plArmatureMod::Index());
|
||||
|
||||
UInt32 flags = kBCastToClients | kUseRelevanceRegions | kForceFullSend;
|
||||
uint32_t flags = kBCastToClients | kUseRelevanceRegions | kForceFullSend;
|
||||
avMod->DirtyPhysicalSynchState(flags);
|
||||
}
|
||||
}
|
||||
@ -308,7 +308,7 @@ plAvBrainGeneric *plSittingModifier::IBuildSitBrain(plKey avModKey, plKey seekKe
|
||||
hsMatrix44 sitGoal = seekObj->GetLocalToWorld();
|
||||
hsMatrix44 candidateGoal;
|
||||
hsScalar closestDist = 0.0f;
|
||||
UInt8 closestApproach = 0;
|
||||
uint8_t closestApproach = 0;
|
||||
hsPoint3 curPosition = avatar->GetTarget(0)->GetLocalToWorld().GetTranslate();
|
||||
char * sitAnimName = nil;
|
||||
char * standAnimName = "StandUpFront"; // always prefer to stand facing front
|
||||
@ -341,7 +341,7 @@ plAvBrainGeneric *plSittingModifier::IBuildSitBrain(plKey avModKey, plKey seekKe
|
||||
|
||||
if(sitAnimName)
|
||||
{
|
||||
UInt32 exitFlags = plAvBrainGeneric::kExitNormal; // SOME stages can be interrupted, but not the brain itself
|
||||
uint32_t exitFlags = plAvBrainGeneric::kExitNormal; // SOME stages can be interrupted, but not the brain itself
|
||||
brain = TRACKED_NEW plAvBrainGeneric(nil, enterNotify, exitNotify, nil, exitFlags, plAvBrainGeneric::kDefaultFadeIn,
|
||||
plAvBrainGeneric::kDefaultFadeOut, plAvBrainGeneric::kMoveRelative);
|
||||
|
||||
|
||||
@ -80,7 +80,7 @@ public:
|
||||
kDisableForward = 0x10,
|
||||
};
|
||||
|
||||
UInt8 fMiscFlags;
|
||||
uint8_t fMiscFlags;
|
||||
|
||||
plSittingModifier();
|
||||
plSittingModifier(bool hasFront, bool hasLeft, bool hasRight);
|
||||
@ -113,7 +113,7 @@ protected:
|
||||
plAvBrainGeneric * IBuildSitBrain(plKey avModKey, plKey seekKey,char **pAnimName, plNotifyMsg *enterNotify, plNotifyMsg *exitNotify);
|
||||
|
||||
/** Unused. */
|
||||
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return true; }
|
||||
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) { return true; }
|
||||
|
||||
/** An array of keys to objects that are interested in receiving our sit messages. */
|
||||
hsTArray<plKey> fNotifyKeys;
|
||||
|
||||
@ -62,7 +62,7 @@ public:
|
||||
kNumProps // last
|
||||
};
|
||||
|
||||
virtual Int32 GetNumProperties() const { return kNumProps; }
|
||||
virtual int32_t GetNumProperties() const { return kNumProps; }
|
||||
virtual void SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l) {}
|
||||
virtual void Read(hsStream* stream, hsResMgr* mgr);
|
||||
virtual void Write(hsStream* stream, hsResMgr* mgr);
|
||||
|
||||
Reference in New Issue
Block a user