OU/CWE-ou-minkata
1
0
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-18 03:09:13 +00:00
Code Releases Activity

Convert custom HeadSpin integer types to standard types from stdint.h

Browse Source
This commit is contained in:
Adam Johnson
2012-01-19 21:19:26 -05:00
parent a0d54e2644
commit 5027b5a4ac
1301 changed files with 14497 additions and 14532 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Sources/Plasma/PubUtilLib/plModifier/plAnimEventModifier.h
View File

@ -54,7 +54,7 @@ protected:
hsTArray<plKey> fReceivers;// Keys to notify when the anim event happens
plMessage* fCallback; // The callback setup message we send when the anim loads
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return false; }
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) { return false; }
void ISendNotify(bool triggered);
hsBool fDisabled;

6
Sources/Plasma/PubUtilLib/plModifier/plAxisAnimModifier.cpp
View File

@ -79,7 +79,7 @@ class plAxisInputInterface : public plInputInterface
plAxisInputInterface( plAxisAnimModifier *owner ) { fOwner = owner; SetEnabled( true ); }
virtual UInt32 GetPriorityLevel( void ) const { return kSceneInteractionPriority + 10; }
virtual uint32_t GetPriorityLevel( void ) const { return kSceneInteractionPriority + 10; }
virtual hsBool InterpretInputEvent( plInputEventMsg *pMsg )
{
plMouseEventMsg* pMMsg = plMouseEventMsg::ConvertNoRef( pMsg );
@ -99,7 +99,7 @@ class plAxisInputInterface : public plInputInterface
return false;
}
virtual UInt32 GetCurrentCursorID( void ) const { return kCursorGrab; }
virtual uint32_t GetCurrentCursorID( void ) const { return kCursorGrab; }
virtual hsBool HasInterestingCursorID( void ) const { return true; }
};
@ -122,7 +122,7 @@ plAxisAnimModifier::~plAxisAnimModifier()
}
hsBool plAxisAnimModifier::IEval(double secs, hsScalar del, UInt32 dirty)
hsBool plAxisAnimModifier::IEval(double secs, hsScalar del, uint32_t dirty)
{
if (!fActive)
return true;

2
Sources/Plasma/PubUtilLib/plModifier/plAxisAnimModifier.h
View File

@ -78,7 +78,7 @@ protected:
plAxisInputInterface *fInputIface;
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty);
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty);
public:
plAxisAnimModifier();

2
Sources/Plasma/PubUtilLib/plModifier/plCloneSpawnModifier.h
View File

@ -50,7 +50,7 @@ protected:
char* fTemplateName;
bool fExportTime;
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return true; }
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) { return true; }
public:
plCloneSpawnModifier();

4
Sources/Plasma/PubUtilLib/plModifier/plDecalEnableMod.h
View File

@ -55,7 +55,7 @@ protected:
hsScalar fWetLength;
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return false; }
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) { return false; }
public:
plDecalEnableMod();
@ -73,7 +73,7 @@ public:
hsScalar GetWetLength() const { return fWetLength; }
void AddDecalKey(const plKey& k) { fDecalMgrs.Append(k); }
UInt32 GetNumDecalKeys() const { return fDecalMgrs.GetCount(); }
uint32_t GetNumDecalKeys() const { return fDecalMgrs.GetCount(); }
const plKey& GetDecalKey(int i) const { return fDecalMgrs[i]; }
};

2
Sources/Plasma/PubUtilLib/plModifier/plExcludeRegionModifier.h
View File

@ -64,7 +64,7 @@ protected:
plExcludeRegionSDLModifier *fSDLModifier;
hsBool fSeek; // use smart seek or teleport?
hsScalar fSeekTime; // how long to seek for
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return true; }
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) { return true; }
void ISetPhysicalState(bool cleared);

8
Sources/Plasma/PubUtilLib/plModifier/plGameMarkerModifier.h
View File

@ -51,10 +51,10 @@ protected:
plKey fRedAnimKey;
plKey fOpenAnimKey;
plKey fBounceAnimKey;
UInt16 fPlaceSndIdx;
UInt16 fHitSndIdx;
uint16_t fPlaceSndIdx;
uint16_t fHitSndIdx;
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return true; }
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) { return true; }
plKey IFindCloneKey(plKey baseKey);
@ -68,7 +68,7 @@ public:
GETINTERFACE_ANY(plGameMarkerModifier, plSingleModifier);
void ExportInit(plKey greenKey, plKey redKey, plKey openKey, plKey bounceAnimKey,
UInt16 placeSndIdx, UInt16 hitSndIdx)
uint16_t placeSndIdx, uint16_t hitSndIdx)
{
fGreenAnimKey = greenKey;
fRedAnimKey = redKey;

4
Sources/Plasma/PubUtilLib/plModifier/plImageLibMod.cpp
View File

@ -85,7 +85,7 @@ void plImageLibMod::Read(hsStream* stream, hsResMgr* mgr)
{
plSingleModifier::Read(stream, mgr);
UInt32 i, count = stream->ReadLE32();
uint32_t i, count = stream->ReadLE32();
fImages.SetCountAndZero( count );
for( i = 0; i < count; i++ )
mgr->ReadKeyNotifyMe( stream, TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, i, kRefImage ), plRefFlags::kActiveRef );
@ -96,7 +96,7 @@ void plImageLibMod::Write(hsStream* stream, hsResMgr* mgr)
plSingleModifier::Write(stream, mgr);
stream->WriteLE32( fImages.GetCount() );
UInt32 i;
uint32_t i;
for( i = 0; i < fImages.GetCount(); i++ )
mgr->WriteKey( stream, fImages[ i ]->GetKey() );
}

4
Sources/Plasma/PubUtilLib/plModifier/plImageLibMod.h
View File

@ -54,7 +54,7 @@ protected:
hsTArray<plBitmap *> fImages;
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return false; }
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) { return false; }
public:
plImageLibMod();
@ -73,7 +73,7 @@ public:
kRefImage = 0
};
UInt32 GetNumImages( void ) const { return fImages.GetCount(); }
uint32_t GetNumImages( void ) const { return fImages.GetCount(); }
};
#endif // plImageLibMod_inc

2
Sources/Plasma/PubUtilLib/plModifier/plInterfaceInfoModifier.h
View File

@ -52,7 +52,7 @@ class plInterfaceInfoModifier : public plSingleModifier
protected:
hsTArray<plKey> fKeyList;
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty){ return true; }
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty){ return true; }
public:
plInterfaceInfoModifier();

22
Sources/Plasma/PubUtilLib/plModifier/plLayerSDLModifier.cpp
View File

@ -112,24 +112,24 @@ void plLayerSDLModifier::IPutCurrentStateIn(plStateDataRecord* dstState)
int channelIdx = 0;
if (layer->fPreshadeColor && (layer->fOwnedChannels & plLayerInterface::kPreshadeColor))
{
channelVar->Set((UInt8)(layer->fPreshadeColor->r * 255), channelIdx++);
channelVar->Set((UInt8)(layer->fPreshadeColor->g * 255), channelIdx++);
channelVar->Set((UInt8)(layer->fPreshadeColor->b * 255), channelIdx++);
channelVar->Set((uint8_t)(layer->fPreshadeColor->r * 255), channelIdx++);
channelVar->Set((uint8_t)(layer->fPreshadeColor->g * 255), channelIdx++);
channelVar->Set((uint8_t)(layer->fPreshadeColor->b * 255), channelIdx++);
}
if (layer->fRuntimeColor && (layer->fOwnedChannels & plLayerInterface::kRuntimeColor))
{
channelVar->Set((UInt8)(layer->fRuntimeColor->r * 255), channelIdx++);
channelVar->Set((UInt8)(layer->fRuntimeColor->g * 255), channelIdx++);
channelVar->Set((UInt8)(layer->fRuntimeColor->b * 255), channelIdx++);
channelVar->Set((uint8_t)(layer->fRuntimeColor->r * 255), channelIdx++);
channelVar->Set((uint8_t)(layer->fRuntimeColor->g * 255), channelIdx++);
channelVar->Set((uint8_t)(layer->fRuntimeColor->b * 255), channelIdx++);
}
if (layer->fAmbientColor && (layer->fOwnedChannels & plLayerInterface::kAmbientColor))
{
channelVar->Set((UInt8)(layer->fAmbientColor->r * 255), channelIdx++);
channelVar->Set((UInt8)(layer->fAmbientColor->g * 255), channelIdx++);
channelVar->Set((UInt8)(layer->fAmbientColor->b * 255), channelIdx++);
channelVar->Set((uint8_t)(layer->fAmbientColor->r * 255), channelIdx++);
channelVar->Set((uint8_t)(layer->fAmbientColor->g * 255), channelIdx++);
channelVar->Set((uint8_t)(layer->fAmbientColor->b * 255), channelIdx++);
}
if (layer->fOpacity && (layer->fOwnedChannels & plLayerInterface::kOpacity))
channelVar->Set((UInt8)(*layer->fOpacity * 255), channelIdx++);
channelVar->Set((uint8_t)(*layer->fOpacity * 255), channelIdx++);
}
//
@ -166,7 +166,7 @@ void plLayerSDLModifier::ISetCurrentStateFrom(const plStateDataRecord* srcState)
plSimpleStateVariable *channelVar = srcState->FindVar(kStrChannelData);
int channelIdx = 0;
UInt8 val;
uint8_t val;
if (layer->fPreshadeColor && (layer->fOwnedChannels & plLayerInterface::kPreshadeColor))
{
channelVar->Get(&val, channelIdx++);

2
Sources/Plasma/PubUtilLib/plModifier/plMaintainersMarkerModifier.h
View File

@ -57,7 +57,7 @@ public:
kCalibrated,
};
protected:
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) {return true;}
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) {return true;}
int fCalibrated;
public:

52
Sources/Plasma/PubUtilLib/plModifier/plResponderModifier.cpp
View File

@ -168,14 +168,14 @@ hsBool plResponderModifier::MsgReceive(plMessage* msg)
plTimerCallbackMsg *timerMsg = plTimerCallbackMsg::ConvertNoRef(msg);
if (pEventMsg || timerMsg)
{
UInt32 waitID = pEventMsg ? pEventMsg->fUser : timerMsg->fID;
uint32_t waitID = pEventMsg ? pEventMsg->fUser : timerMsg->fID;
if (waitID != -1)
{
// Flag that this callback completed and try sending in case any commands were waiting on this
fCompletedEvents.SetBit(waitID);
ResponderLog(ILog(plStatusLog::kWhite, "Got callback from command %d(id:%d)", ICmdFromWait((Int8)waitID)+1, waitID));
ResponderLog(ILog(plStatusLog::kWhite, "Got callback from command %d(id:%d)", ICmdFromWait((int8_t)waitID)+1, waitID));
IContinueSending();
DirtySynchState(kSDLResponder, 0);
@ -203,7 +203,7 @@ void plResponderModifier::AddCommand(plMessage* pMsg, int state)
fStates[state].fCmds.Append(plResponderCmd(pMsg, -1));
}
void plResponderModifier::AddCallback(Int8 state, Int8 cmd, Int8 callback)
void plResponderModifier::AddCallback(int8_t state, int8_t cmd, int8_t callback)
{
fStates[state].fWaitToCmd[callback] = cmd;
}
@ -227,7 +227,7 @@ bool plResponderModifier::IIsLocalOnlyCmd(plMessage* cmd)
return false;
}
void plResponderModifier::ISetResponderState(Int8 state)
void plResponderModifier::ISetResponderState(int8_t state)
{
// make sure that it is a valid state to switch to
if (state >= 0 && state < fStates.Count())
@ -245,7 +245,7 @@ void plResponderModifier::ISetResponderStateFromNotify(plNotifyMsg* msg)
// set the state of the responder IF they want it to be
proResponderStateEventData* event = (proResponderStateEventData*)msg->FindEventRecord(proEventData::kResponderState);
if (event != nil)
ISetResponderState((Int8)(event->fState));
ISetResponderState((int8_t)(event->fState));
}
void plResponderModifier::Trigger(plNotifyMsg *msg)
@ -259,7 +259,7 @@ void plResponderModifier::Trigger(plNotifyMsg *msg)
#endif
// If we're not in the middle of sending, reset and start sending commands
if (fCurCommand == Int8(-1) && fEnabled)
if (fCurCommand == int8_t(-1) && fEnabled)
{
ResponderLog(ILog(plStatusLog::kGreen, "Trigger"));
@ -288,7 +288,7 @@ void plResponderModifier::Trigger(plNotifyMsg *msg)
bool plResponderModifier::IContinueSending()
{
// If we haven't been started, exit
if (fCurCommand == Int8(-1))
if (fCurCommand == int8_t(-1))
return false;
plResponderState& state = fStates[fCurState];
@ -299,17 +299,17 @@ bool plResponderModifier::IContinueSending()
if (msg)
{
// If this command needs to wait, and it's condition hasn't been met yet, exit
Int8 wait = state.fCmds[fCurCommand].fWaitOn;
int8_t wait = state.fCmds[fCurCommand].fWaitOn;
if (wait != -1 && !fCompletedEvents.IsBitSet(wait))
{
ResponderLog(ILog(plStatusLog::kWhite, "Command %d is waiting for command %d(id:%d)", Int8(fCurCommand)+1, ICmdFromWait(wait)+1, wait));
ResponderLog(ILog(plStatusLog::kWhite, "Command %d is waiting for command %d(id:%d)", int8_t(fCurCommand)+1, ICmdFromWait(wait)+1, wait));
return false;
}
if (!(fNotifyMsgFlags & plMessage::kNetNonLocal)|| !IIsLocalOnlyCmd(msg))
{
// make sure outgoing msgs inherit net flags as part of cascade
UInt32 msgFlags = msg->GetAllBCastFlags();
uint32_t msgFlags = msg->GetAllBCastFlags();
plNetClientApp::InheritNetMsgFlags(fNotifyMsgFlags, &msgFlags, true);
msg->SetAllBCastFlags(msgFlags);
@ -414,7 +414,7 @@ bool plResponderModifier::IContinueSending()
return true;
}
Int8 plResponderModifier::ICmdFromWait(Int8 waitIdx)
int8_t plResponderModifier::ICmdFromWait(int8_t waitIdx)
{
WaitToCmd& waitToCmd = fStates[fCurState].fWaitToCmd;
if (waitToCmd.find(waitIdx) != waitToCmd.end())
@ -640,17 +640,17 @@ void plResponderModifier::Read(hsStream* stream, hsResMgr* mgr)
{
plSingleModifier::Read(stream, mgr);
Int8 numStates = stream->ReadByte();
int8_t numStates = stream->ReadByte();
fStates.SetCount(numStates);
for (Int8 i = 0; i < numStates; i++)
for (int8_t i = 0; i < numStates; i++)
{
plResponderState& state = fStates[i];
state.fNumCallbacks = stream->ReadByte();
state.fSwitchToState = stream->ReadByte();
Int8 j;
int8_t j;
Int8 numCmds = stream->ReadByte();
int8_t numCmds = stream->ReadByte();
state.fCmds.SetCount(numCmds);
for (j = 0; j < numCmds; j++)
{
@ -662,11 +662,11 @@ void plResponderModifier::Read(hsStream* stream, hsResMgr* mgr)
}
state.fWaitToCmd.clear();
Int8 mapSize = stream->ReadByte();
int8_t mapSize = stream->ReadByte();
for (j = 0; j < mapSize; j++)
{
Int8 wait = stream->ReadByte();
Int8 cmd = stream->ReadByte();
int8_t wait = stream->ReadByte();
int8_t cmd = stream->ReadByte();
state.fWaitToCmd[wait] = cmd;
}
}
@ -685,7 +685,7 @@ void plResponderModifier::Write(hsStream* stream, hsResMgr* mgr)
{
plSingleModifier::Write(stream, mgr);
Int8 numStates = fStates.GetCount();
int8_t numStates = fStates.GetCount();
stream->WriteByte(numStates);
for (int i = 0; i < numStates; i++)
{
@ -693,7 +693,7 @@ void plResponderModifier::Write(hsStream* stream, hsResMgr* mgr)
stream->WriteByte(state.fNumCallbacks);
stream->WriteByte(state.fSwitchToState);
Int8 numCmds = state.fCmds.GetCount();
int8_t numCmds = state.fCmds.GetCount();
stream->WriteByte(numCmds);
for (int j = 0; j < numCmds; j++)
{
@ -703,7 +703,7 @@ void plResponderModifier::Write(hsStream* stream, hsResMgr* mgr)
stream->WriteByte(cmd.fWaitOn);
}
Int8 mapSize = state.fWaitToCmd.size();
int8_t mapSize = state.fWaitToCmd.size();
stream->WriteByte(mapSize);
for (WaitToCmd::iterator it = state.fWaitToCmd.begin(); it != state.fWaitToCmd.end(); it++)
{
@ -724,17 +724,17 @@ void plResponderModifier::IDebugAnimBox(bool start)
{
plDebugText &debugTxt = plDebugText::Instance();
UInt32 scrnWidth, scrnHeight;
uint32_t scrnWidth, scrnHeight;
debugTxt.GetScreenSize(&scrnWidth, &scrnHeight);
// Box size is 1/8 screen size
UInt32 boxSize = scrnHeight / 8;
uint32_t boxSize = scrnHeight / 8;
// Draw box in lower left corner
if (start)
debugTxt.DrawRect(0, (UInt16)(scrnHeight-boxSize), (UInt16)boxSize, (UInt16)scrnHeight, 0, 255, 0);
debugTxt.DrawRect(0, (uint16_t)(scrnHeight-boxSize), (uint16_t)boxSize, (uint16_t)scrnHeight, 0, 255, 0);
else
debugTxt.DrawRect((UInt16)boxSize, (UInt16)(scrnHeight-boxSize), (UInt16)(boxSize*2), (UInt16)scrnHeight, 255, 0, 0);
debugTxt.DrawRect((uint16_t)boxSize, (uint16_t)(scrnHeight-boxSize), (uint16_t)(boxSize*2), (uint16_t)scrnHeight, 255, 0, 0);
}
void plResponderModifier::IDebugPlayMsg(plAnimCmdMsg* msg)
@ -766,7 +766,7 @@ void plResponderModifier::NoLogString(const char* str)
#endif // STATUS_LOG
}
void plResponderModifier::ILog(UInt32 color, const char* format, ...)
void plResponderModifier::ILog(uint32_t color, const char* format, ...)
{
#ifdef STATUS_LOG
if (!gLog)

30
Sources/Plasma/PubUtilLib/plModifier/plResponderModifier.h
View File

@ -54,30 +54,30 @@ class plResponderModifier : public plSingleModifier
{
friend class plResponderSDLModifier;
protected:
typedef std::map<Int8,Int8> WaitToCmd;
typedef std::map<int8_t,int8_t> WaitToCmd;
class plResponderCmd
{
public:
plResponderCmd() : fMsg(nil), fWaitOn(-1) {}
plResponderCmd(plMessage *msg, Int8 waitOn) : fMsg(msg), fWaitOn(waitOn) {}
plResponderCmd(plMessage *msg, int8_t waitOn) : fMsg(msg), fWaitOn(waitOn) {}
plMessage *fMsg;
Int8 fWaitOn; // Index into fCompletedEvents of who we're waiting on
int8_t fWaitOn; // Index into fCompletedEvents of who we're waiting on
};
class plResponderState
{
public:
hsTArray<plResponderCmd> fCmds;
Int8 fNumCallbacks; // So we know how far to search into the bitvector to find out when we're done
Int8 fSwitchToState; // State to switch to when all commands complete
int8_t fNumCallbacks; // So we know how far to search into the bitvector to find out when we're done
int8_t fSwitchToState; // State to switch to when all commands complete
WaitToCmd fWaitToCmd;
};
hsTArray<plResponderState> fStates;
Int8 fCurState; // The current state (first index for fCommandList)
Int8 fCurCommand; // The command we are currently waiting to send (or -1 if we're not sending)
int8_t fCurState; // The current state (first index for fCommandList)
int8_t fCurCommand; // The command we are currently waiting to send (or -1 if we're not sending)
bool fNetRequest; // Was the last trigger a net request
hsBitVector fCompletedEvents; // Which events that commands are waiting on have completed
bool fEnabled;
@ -94,16 +94,16 @@ protected:
kDetectUnTrigger = 0x2,
kSkipFFSound = 0x4
};
UInt8 fFlags;
UInt32 fNotifyMsgFlags; // store the msg flags of the notify which triggered us
uint8_t fFlags;
uint32_t fNotifyMsgFlags; // store the msg flags of the notify which triggered us
void Trigger(plNotifyMsg *msg);
bool IIsLocalOnlyCmd(plMessage* cmd);
bool IContinueSending();
Int8 ICmdFromWait(Int8 waitIdx);
int8_t ICmdFromWait(int8_t waitIdx);
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty) { return true; }
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty) { return true; }
static bool fDebugAnimBox; // Draws a box on screen when an animation is started
static void IDebugAnimBox(bool start);
@ -116,9 +116,9 @@ protected:
plMessage* IGetFastForwardMsg(plMessage* msg, bool python);
void ISetResponderStateFromNotify(plNotifyMsg* msg);
void ISetResponderState(Int8 state);
void ISetResponderState(int8_t state);
void ILog(UInt32 color, const char* format, ...);
void ILog(uint32_t color, const char* format, ...);
friend class plResponderComponent;
friend class plResponderWait;
@ -143,12 +143,12 @@ public:
// Restore callback state after load
void Restore();
const Int8 GetState() const { return fCurState; }
const int8_t GetState() const { return fCurState; }
//
// Export time only
//
void AddCommand(plMessage* pMsg, int state=0);
void AddCallback(Int8 state, Int8 cmd, Int8 callback);
void AddCallback(int8_t state, int8_t cmd, int8_t callback);
};
// Message for changing the enable state in a responder modifier

8
Sources/Plasma/PubUtilLib/plModifier/plSDLModifier.cpp
View File

@ -73,7 +73,7 @@ void plSDLModifier::AddTarget(plSceneObject* so)
fStateCache = TRACKED_NEW plStateDataRecord(GetSDLName());
}
UInt32 plSDLModifier::IApplyModFlags(UInt32 sendFlags)
uint32_t plSDLModifier::IApplyModFlags(uint32_t sendFlags)
{
return sendFlags;
}
@ -81,7 +81,7 @@ UInt32 plSDLModifier::IApplyModFlags(UInt32 sendFlags)
//
// write to net msg and send to server
//
void plSDLModifier::ISendNetMsg(plStateDataRecord*& state, plKey senderKey, UInt32 sendFlags)
void plSDLModifier::ISendNetMsg(plStateDataRecord*& state, plKey senderKey, uint32_t sendFlags)
{
hsAssert(senderKey, "nil senderKey?");
@ -112,7 +112,7 @@ hsBool plSDLModifier::MsgReceive(plMessage* msg)
plSDLModifierMsg* sdlMsg = plSDLModifierMsg::ConvertNoRef(msg);
if (sdlMsg && !stricmp(sdlMsg->GetSDLName(),GetSDLName()))
{
UInt32 sendFlags = IApplyModFlags(sdlMsg->GetFlags());
uint32_t sendFlags = IApplyModFlags(sdlMsg->GetFlags());
if (!fSentOrRecvdState)
sendFlags |= plSynchedObject::kNewState;
@ -150,7 +150,7 @@ hsBool plSDLModifier::MsgReceive(plMessage* msg)
// send a state update
//
bool gMooseDump=false;
void plSDLModifier::SendState(UInt32 sendFlags)
void plSDLModifier::SendState(uint32_t sendFlags)
{
hsAssert(fStateCache, "nil stateCache");

8
Sources/Plasma/PubUtilLib/plModifier/plSDLModifier.h
View File

@ -56,13 +56,13 @@ protected:
plStateDataRecord* fStateCache;
bool fSentOrRecvdState;
void ISendNetMsg(plStateDataRecord*& state, plKey senderKey, UInt32 sendFlags); // transmit net msg
void ISendNetMsg(plStateDataRecord*& state, plKey senderKey, uint32_t sendFlags); // transmit net msg
virtual void IPutCurrentStateIn(plStateDataRecord* dstState) = 0;
virtual void ISetCurrentStateFrom(const plStateDataRecord* srcState) = 0;
virtual void ISentState(const plStateDataRecord* sentState) {}
hsBool IEval(double secs, hsScalar del, UInt32 dirty) {return false;}
hsBool IEval(double secs, hsScalar del, uint32_t dirty) {return false;}
virtual UInt32 IApplyModFlags(UInt32 sendFlags);
virtual uint32_t IApplyModFlags(uint32_t sendFlags);
public:
CLASSNAME_REGISTER( plSDLModifier );
@ -72,7 +72,7 @@ public:
virtual ~plSDLModifier();
hsBool MsgReceive(plMessage* msg);
void SendState(UInt32 sendFlags); // send a state update
void SendState(uint32_t sendFlags); // send a state update
void ReceiveState(const plStateDataRecord* srcState); // recv a state update
virtual const char* GetSDLName() const = 0; // return the string name of the type of state descriptor you handle
virtual plKey GetStateOwnerKey() const;

2
Sources/Plasma/PubUtilLib/plModifier/plSimpleModifier.cpp
View File

@ -114,7 +114,7 @@ void plSimpleModifier::IEnd()
}
}
hsBool plSimpleModifier::IEval(double secs, hsScalar del, UInt32 dirty)
hsBool plSimpleModifier::IEval(double secs, hsScalar del, uint32_t dirty)
{
return IHandleTime(secs, del);
}

2
Sources/Plasma/PubUtilLib/plModifier/plSimpleModifier.h
View File

@ -83,7 +83,7 @@ protected:
virtual void IBegin();
virtual void IEnd();
virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty);
virtual hsBool IEval(double secs, hsScalar del, uint32_t dirty);
public:
plSimpleModifier();

2
Sources/Plasma/PubUtilLib/plModifier/plSpawnModifier.h
View File

@ -49,7 +49,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
class plSpawnModifier : 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;}
public:
plSpawnModifier(){;}