OU/CWE-ou-minkata
1
0
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-17 10:52:46 +00:00
Code Releases Activity

Fix Endian functions names in hsTypes and hsStream.

Browse Source 
Function and macro names for endianness were previously vague,
and on big-endian systems entirely misleading.  The names are
now properly descriptive of what they actually do.
This commit is contained in:
Joseph Davies
2011-10-23 14:01:54 -07:00
committed by Darryl Pogue
parent ab37a4a486
commit e462ef04b3
255 changed files with 2676 additions and 2676 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
Sources/Plasma/PubUtilLib/plMessage/plAccountUpdateMsg.cpp
View File

@ -55,17 +55,17 @@ plAccountUpdateMsg::plAccountUpdateMsg(unsigned updateType)
void plAccountUpdateMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
fUpdateType = stream->ReadSwap32();
fResult = stream->ReadSwap32();
fPlayerInt = stream->ReadSwap32();
fUpdateType = stream->ReadLE32();
fResult = stream->ReadLE32();
fPlayerInt = stream->ReadLE32();
}
void plAccountUpdateMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap32(fUpdateType);
stream->WriteSwap32(fResult);
stream->WriteSwap32(fPlayerInt);
stream->WriteLE32(fUpdateType);
stream->WriteLE32(fResult);
stream->WriteLE32(fPlayerInt);
}
unsigned plAccountUpdateMsg::GetUpdateType()

4
Sources/Plasma/PubUtilLib/plMessage/plActivatorMsg.h
View File

@ -68,14 +68,14 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
fTriggerType = stream->ReadSwap32();
fTriggerType = stream->ReadLE32();
fHitPoint.Read(stream);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap32( fTriggerType );
stream->WriteLE32( fTriggerType );
fHitPoint.Write(stream);
}

44
Sources/Plasma/PubUtilLib/plMessage/plAnimCmdMsg.cpp
View File

@ -102,13 +102,13 @@ void plAnimCmdMsg::Read(hsStream* stream, hsResMgr* mgr)
plMessageWithCallbacks::Read(stream, mgr);
fCmd.Read(stream);
stream->ReadSwap(&fBegin);
stream->ReadSwap(&fEnd);
stream->ReadSwap(&fLoopEnd);
stream->ReadSwap(&fLoopBegin);
stream->ReadSwap(&fSpeed);
stream->ReadSwap(&fSpeedChangeRate);
stream->ReadSwap(&fTime);
stream->ReadLE(&fBegin);
stream->ReadLE(&fEnd);
stream->ReadLE(&fLoopEnd);
stream->ReadLE(&fLoopBegin);
stream->ReadLE(&fSpeed);
stream->ReadLE(&fSpeedChangeRate);
stream->ReadLE(&fTime);
fAnimName = stream->ReadSafeString();
fLoopName = stream->ReadSafeString();
@ -119,13 +119,13 @@ void plAnimCmdMsg::Write(hsStream* stream, hsResMgr* mgr)
plMessageWithCallbacks::Write(stream, mgr);
fCmd.Write(stream);
stream->WriteSwap(fBegin);
stream->WriteSwap(fEnd);
stream->WriteSwap(fLoopEnd);
stream->WriteSwap(fLoopBegin);
stream->WriteSwap(fSpeed);
stream->WriteSwap(fSpeedChangeRate);
stream->WriteSwap(fTime);
stream->WriteLE(fBegin);
stream->WriteLE(fEnd);
stream->WriteLE(fLoopEnd);
stream->WriteLE(fLoopBegin);
stream->WriteLE(fSpeed);
stream->WriteLE(fSpeedChangeRate);
stream->WriteLE(fTime);
stream->WriteSafeString(fAnimName);
stream->WriteSafeString(fLoopName);
@ -155,10 +155,10 @@ void plAGCmdMsg::Read(hsStream* stream, hsResMgr* mgr)
plMessage::IMsgRead(stream, mgr);
fCmd.Read(stream);
stream->ReadSwap(&fBlend);
stream->ReadSwap(&fBlendRate);
stream->ReadSwap(&fAmp);
stream->ReadSwap(&fAmpRate);
stream->ReadLE(&fBlend);
stream->ReadLE(&fBlendRate);
stream->ReadLE(&fAmp);
stream->ReadLE(&fAmpRate);
fAnimName = stream->ReadSafeString();
}
@ -168,10 +168,10 @@ void plAGCmdMsg::Write(hsStream* stream, hsResMgr* mgr)
plMessage::IMsgWrite(stream, mgr);
fCmd.Write(stream);
stream->WriteSwap(fBlend);
stream->WriteSwap(fBlendRate);
stream->WriteSwap(fAmp);
stream->WriteSwap(fAmpRate);
stream->WriteLE(fBlend);
stream->WriteLE(fBlendRate);
stream->WriteLE(fAmp);
stream->WriteLE(fAmpRate);
stream->WriteSafeString(fAnimName);
}

12
Sources/Plasma/PubUtilLib/plMessage/plAvCoopMsg.cpp
View File

@ -102,10 +102,10 @@ void plAvCoopMsg::Read(hsStream *stream, hsResMgr *mgr)
if(stream->Readbool())
fCoordinator = reinterpret_cast<plCoopCoordinator *>(mgr->ReadCreatable(stream));
fInitiatorID = stream->ReadSwap32();
fInitiatorSerial = stream->ReadSwap16();
fInitiatorID = stream->ReadLE32();
fInitiatorSerial = stream->ReadLE16();
fCommand = static_cast<Command>(stream->ReadSwap16());
fCommand = static_cast<Command>(stream->ReadLE16());
}
// Write -----------------------------------------------
@ -118,10 +118,10 @@ void plAvCoopMsg::Write(hsStream *stream, hsResMgr *mgr)
if(fCoordinator)
mgr->WriteCreatable(stream, fCoordinator);
stream->WriteSwap32(fInitiatorID);
stream->WriteSwap16(fInitiatorSerial);
stream->WriteLE32(fInitiatorID);
stream->WriteLE16(fInitiatorSerial);
stream->WriteSwap16(fCommand);
stream->WriteLE16(fCommand);
}
#endif // ndef NO_AV_MSGS

40
Sources/Plasma/PubUtilLib/plMessage/plAvatarMsg.cpp
View File

@ -297,10 +297,10 @@ void plAvSeekMsg::Read(hsStream *stream, hsResMgr *mgr)
fTargetLookAt.Read(stream);
}
fDuration = stream->ReadSwapScalar();
fDuration = stream->ReadLEScalar();
fSmartSeek = stream->ReadBool();
fAnimName = stream->ReadSafeString();
fAlignType = static_cast<plAvAlignment>(stream->ReadSwap16());
fAlignType = static_cast<plAvAlignment>(stream->ReadLE16());
fNoSeek = stream->ReadBool();
fFlags = stream->ReadByte();
fFinishKey = mgr->ReadKey(stream);
@ -318,10 +318,10 @@ void plAvSeekMsg::Write(hsStream *stream, hsResMgr *mgr)
fTargetLookAt.Write(stream);
}
stream->WriteSwapScalar(fDuration);
stream->WriteLEScalar(fDuration);
stream->WriteBool(fSmartSeek);
stream->WriteSafeString(fAnimName);
stream->WriteSwap16(static_cast<UInt16>(fAlignType));
stream->WriteLE16(static_cast<UInt16>(fAlignType));
stream->WriteBool(fNoSeek);
stream->WriteByte(fFlags);
mgr->WriteKey(stream, fFinishKey);
@ -461,25 +461,25 @@ plAvBrainGenericMsg::plAvBrainGenericMsg(plKey sender, plKey receiver,
void plAvBrainGenericMsg::Write(hsStream *stream, hsResMgr *mgr)
{
plAvatarMsg::Write(stream, mgr);
stream->WriteSwap32(fType);
stream->WriteSwap32(fWhichStage);
stream->WriteLE32(fType);
stream->WriteLE32(fWhichStage);
stream->WriteBool(fSetTime);
stream->WriteSwapScalar(fNewTime);
stream->WriteLEScalar(fNewTime);
stream->WriteBool(fSetDirection);
stream->WriteBool(fNewDirection);
stream->WriteSwapScalar(fTransitionTime);
stream->WriteLEScalar(fTransitionTime);
}
void plAvBrainGenericMsg::Read(hsStream *stream, hsResMgr *mgr)
{
plAvatarMsg::Read(stream, mgr);
fType = static_cast<plAvBrainGenericMsg::Type>(stream->ReadSwap32());
fWhichStage = stream->ReadSwap32();
fType = static_cast<plAvBrainGenericMsg::Type>(stream->ReadLE32());
fWhichStage = stream->ReadLE32();
fSetTime = stream->ReadBool();
fNewTime = stream->ReadSwapScalar();
fNewTime = stream->ReadLEScalar();
fSetDirection = stream->ReadBool();
fNewDirection = stream->ReadBool();
fTransitionTime = stream->ReadSwapScalar();
fTransitionTime = stream->ReadLEScalar();
}
enum AvBrainGenericFlags
@ -508,19 +508,19 @@ void plAvBrainGenericMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kAvBrainGenericType
s->WriteSwap32(fType);
s->WriteLE32(fType);
// kAvBrainGenericWhich
s->WriteSwap32(fWhichStage);
s->WriteLE32(fWhichStage);
// kAvBrainGenericSetTime
s->WriteBool(fSetTime);
// kAvBrainGenericNewTime
s->WriteSwapScalar(fNewTime);
s->WriteLEScalar(fNewTime);
// kAvBrainGenericSetDir
s->WriteBool(fSetDirection);
// kAvBrainGenericNewDir
s->WriteBool(fNewDirection);
// kAvBrainGenericTransTime
s->WriteSwapScalar(fTransitionTime);
s->WriteLEScalar(fTransitionTime);
}
void plAvBrainGenericMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
@ -531,19 +531,19 @@ void plAvBrainGenericMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kAvBrainGenericType))
fType = static_cast<plAvBrainGenericMsg::Type>(s->ReadSwap32());
fType = static_cast<plAvBrainGenericMsg::Type>(s->ReadLE32());
if (contentFlags.IsBitSet(kAvBrainGenericWhich))
fWhichStage = s->ReadSwap32();
fWhichStage = s->ReadLE32();
if (contentFlags.IsBitSet(kAvBrainGenericSetTime))
fSetTime = s->ReadBool();
if (contentFlags.IsBitSet(kAvBrainGenericNewTime))
fNewTime = s->ReadSwapScalar();
fNewTime = s->ReadLEScalar();
if (contentFlags.IsBitSet(kAvBrainGenericSetDir))
fSetDirection = s->ReadBool();
if (contentFlags.IsBitSet(kAvBrainGenericNewDir))
fNewDirection = s->ReadBool();
if (contentFlags.IsBitSet(kAvBrainGenericTransTime))
fTransitionTime = s->ReadSwapScalar();
fTransitionTime = s->ReadLEScalar();
}
///////////////////

12
Sources/Plasma/PubUtilLib/plMessage/plBulletMsg.cpp
View File

@ -55,9 +55,9 @@ void plBulletMsg::Read(hsStream* stream, hsResMgr* mgr)
fFrom.Read(stream);
fDir.Read(stream);
fRange = stream->ReadSwapScalar();
fRadius = stream->ReadSwapScalar();
fPartyTime = stream->ReadSwapScalar();
fRange = stream->ReadLEScalar();
fRadius = stream->ReadLEScalar();
fPartyTime = stream->ReadLEScalar();
}
void plBulletMsg::Write(hsStream* stream, hsResMgr* mgr)
@ -68,9 +68,9 @@ void plBulletMsg::Write(hsStream* stream, hsResMgr* mgr)
fFrom.Write(stream);
fDir.Write(stream);
stream->WriteSwapScalar(fRange);
stream->WriteSwapScalar(fRadius);
stream->WriteSwapScalar(fPartyTime);
stream->WriteLEScalar(fRange);
stream->WriteLEScalar(fRadius);
stream->WriteLEScalar(fPartyTime);
}
void plBulletMsg::FireShot(const hsPoint3& from, const hsVector3& dir, hsScalar radius, hsScalar range, hsScalar psecs)

12
Sources/Plasma/PubUtilLib/plMessage/plCCRMsg.cpp
View File

@ -52,7 +52,7 @@ void plCCRPetitionMsg::Read(hsStream* stream, hsResMgr* mgr)
plMsgStdStringHelper::Peek(fNote, stream);
plMsgStdStringHelper::Peek(fTitle, stream);
stream->ReadSwap(&fPetitionType);
stream->ReadLE(&fPetitionType);
}
void plCCRPetitionMsg::Write(hsStream* stream, hsResMgr* mgr)
@ -61,7 +61,7 @@ void plCCRPetitionMsg::Write(hsStream* stream, hsResMgr* mgr)
plMsgStdStringHelper::Poke(fNote, stream);
plMsgStdStringHelper::Poke(fTitle, stream);
stream->WriteSwap(fPetitionType);
stream->WriteLE(fPetitionType);
}
///////////////////////////////////////////////////////////
@ -99,8 +99,8 @@ void plCCRCommunicationMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
plMsgStdStringHelper::Peek(fString, stream);
fType = (Type)stream->ReadSwap32();
stream->ReadSwap(&fCCRPlayerID);
fType = (Type)stream->ReadLE32();
stream->ReadLE(&fCCRPlayerID);
}
void plCCRCommunicationMsg::Write(hsStream* stream, hsResMgr* mgr)
@ -108,8 +108,8 @@ void plCCRCommunicationMsg::Write(hsStream* stream, hsResMgr* mgr)
plMessage::IMsgWrite(stream, mgr);
plMsgStdStringHelper::Poke(fString, stream);
stream->WriteSwap32((int)fType);
stream->WriteSwap(fCCRPlayerID);
stream->WriteLE32((int)fType);
stream->WriteLE(fCCRPlayerID);
}
///////////////////////////////////////////////////////////

8
Sources/Plasma/PubUtilLib/plMessage/plClimbMsg.cpp
View File

@ -68,8 +68,8 @@ void plClimbMsg::Read(hsStream *stream, hsResMgr *mgr)
{
plMessage::IMsgRead(stream, mgr);
fCommand = static_cast<Command>(stream->ReadSwap32());
fDirection = static_cast<Direction>(stream->ReadSwap32());
fCommand = static_cast<Command>(stream->ReadLE32());
fDirection = static_cast<Direction>(stream->ReadLE32());
fStatus = stream->ReadBool();
fTarget = mgr->ReadKey(stream);
}
@ -77,8 +77,8 @@ void plClimbMsg::Read(hsStream *stream, hsResMgr *mgr)
void plClimbMsg::Write(hsStream *stream, hsResMgr *mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap32(static_cast<UInt32>(fCommand));
stream->WriteSwap32(static_cast<UInt32>(fDirection));
stream->WriteLE32(static_cast<UInt32>(fCommand));
stream->WriteLE32(static_cast<UInt32>(fDirection));
stream->WriteBool(fStatus);
mgr->WriteKey(stream, fTarget);
}

4
Sources/Plasma/PubUtilLib/plMessage/plCondRefMsg.h
View File

@ -66,13 +66,13 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plRefMsg::Read(stream, mgr);
stream->ReadSwap(&fWhich);
stream->ReadLE(&fWhich);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plRefMsg::Write(stream, mgr);
stream->WriteSwap(fWhich);
stream->WriteLE(fWhich);
}
};

4
Sources/Plasma/PubUtilLib/plMessage/plConsoleMsg.h
View File

@ -84,7 +84,7 @@ public:
virtual void Read(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgRead(s, mgr);
s->ReadSwap(&fCmd);
s->ReadLE(&fCmd);
// read string
plMsgCStringHelper::Peek(fString, s);
}
@ -92,7 +92,7 @@ public:
virtual void Write(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgWrite(s, mgr);
s->WriteSwap(fCmd);
s->WriteLE(fCmd);
// write cmd/string
plMsgCStringHelper::Poke(fString, s);
}

12
Sources/Plasma/PubUtilLib/plMessage/plDynaDecalEnableMsg.cpp
View File

@ -79,11 +79,11 @@ void plDynaDecalEnableMsg::Read(hsStream* stream, hsResMgr* mgr)
fKey = mgr->ReadKey(stream);
fConTime = stream->ReadSwapDouble();
fConTime = stream->ReadLEDouble();
fFlags = stream->ReadSwap32();
fFlags = stream->ReadLE32();
fID = stream->ReadSwap32();
fID = stream->ReadLE32();
}
void plDynaDecalEnableMsg::Write(hsStream* stream, hsResMgr* mgr)
@ -92,10 +92,10 @@ void plDynaDecalEnableMsg::Write(hsStream* stream, hsResMgr* mgr)
mgr->WriteKey(stream, fKey);
stream->WriteSwapDouble(fConTime);
stream->WriteLEDouble(fConTime);
stream->WriteSwap32(fFlags);
stream->WriteLE32(fFlags);
stream->WriteSwap32(fID);
stream->WriteLE32(fID);
}

20
Sources/Plasma/PubUtilLib/plMessage/plDynamicEnvMapMsg.cpp
View File

@ -48,26 +48,26 @@ void plDynamicEnvMapMsg::Read(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgRead(s, mgr);
fCmd = s->ReadSwap32();
fCmd = s->ReadLE32();
fPos.Read(s);
fHither = s->ReadSwapScalar();
fYon = s->ReadSwapScalar();
fFogStart = s->ReadSwapScalar();
fHither = s->ReadLEScalar();
fYon = s->ReadLEScalar();
fFogStart = s->ReadLEScalar();
fColor.Read(s);
fRefresh = s->ReadSwapScalar();
fRefresh = s->ReadLEScalar();
}
void plDynamicEnvMapMsg::Write(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgWrite(s, mgr);
s->WriteSwap32(fCmd);
s->WriteLE32(fCmd);
fPos.Write(s);
s->WriteSwapScalar(fHither);
s->WriteSwapScalar(fYon);
s->WriteSwapScalar(fFogStart);
s->WriteLEScalar(fHither);
s->WriteLEScalar(fYon);
s->WriteLEScalar(fFogStart);
fColor.Write(s);
s->WriteSwapScalar(fRefresh);
s->WriteLEScalar(fRefresh);
}

80
Sources/Plasma/PubUtilLib/plMessage/plDynamicTextMsg.cpp
View File

@ -210,14 +210,14 @@ void plDynamicTextMsg::Read( hsStream *s, hsResMgr *mgr )
{
plMessage::IMsgRead( s, mgr );
s->ReadSwap( &fCmd );
s->ReadSwap( &fX );
s->ReadSwap( &fY );
s->ReadLE( &fCmd );
s->ReadLE( &fX );
s->ReadLE( &fY );
s->ReadSwap( &fLeft );
s->ReadSwap( &fTop );
s->ReadSwap( &fRight );
s->ReadSwap( &fBottom );
s->ReadLE( &fLeft );
s->ReadLE( &fTop );
s->ReadLE( &fRight );
s->ReadLE( &fBottom );
fClearColor.Read( s );
fColor.Read( s );
@ -225,10 +225,10 @@ void plDynamicTextMsg::Read( hsStream *s, hsResMgr *mgr )
fString = s->ReadSafeWString();
fImageKey = mgr->ReadKey( s );
s->ReadSwap( &fFlags );
s->ReadLE( &fFlags );
s->ReadSwap( &fBlockRGB );
s->ReadSwap( &fLineSpacing );
s->ReadLE( &fBlockRGB );
s->ReadLE( &fLineSpacing );
}
void plDynamicTextMsg::Write( hsStream *s, hsResMgr *mgr )
{
@ -241,14 +241,14 @@ void plDynamicTextMsg::Write( hsStream *s, hsResMgr *mgr )
}
#endif
s->WriteSwap( fCmd );
s->WriteSwap( fX );
s->WriteSwap( fY );
s->WriteLE( fCmd );
s->WriteLE( fX );
s->WriteLE( fY );
s->WriteSwap( fLeft );
s->WriteSwap( fTop );
s->WriteSwap( fRight );
s->WriteSwap( fBottom );
s->WriteLE( fLeft );
s->WriteLE( fTop );
s->WriteLE( fRight );
s->WriteLE( fBottom );
fClearColor.Write( s );
fColor.Write( s );
@ -256,10 +256,10 @@ void plDynamicTextMsg::Write( hsStream *s, hsResMgr *mgr )
s->WriteSafeWString( fString );
mgr->WriteKey( s, fImageKey );
s->WriteSwap( fFlags );
s->WriteLE( fFlags );
s->WriteSwap( fBlockRGB );
s->WriteSwap( fLineSpacing );
s->WriteLE( fBlockRGB );
s->WriteLE( fLineSpacing );
}
enum DynamicTextMsgFlags
@ -288,19 +288,19 @@ void plDynamicTextMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kDynTextMsgCmd))
s->ReadSwap( &fCmd );
s->ReadLE( &fCmd );
if (contentFlags.IsBitSet(kDynTextMsgX))
s->ReadSwap( &fX );
s->ReadLE( &fX );
if (contentFlags.IsBitSet(kDynTextMsgY))
s->ReadSwap( &fY );
s->ReadLE( &fY );
if (contentFlags.IsBitSet(kDynTextMsgLeft))
s->ReadSwap( &fLeft );
s->ReadLE( &fLeft );
if (contentFlags.IsBitSet(kDynTextMsgTop))
s->ReadSwap( &fTop );
s->ReadLE( &fTop );
if (contentFlags.IsBitSet(kDynTextMsgRight))
s->ReadSwap( &fRight );
s->ReadLE( &fRight );
if (contentFlags.IsBitSet(kDynTextMsgBottom))
s->ReadSwap( &fBottom );
s->ReadLE( &fBottom );
if (contentFlags.IsBitSet(kDynTextMsgClearColor))
fClearColor.Read( s );
if (contentFlags.IsBitSet(kDynTextMsgColor))
@ -310,11 +310,11 @@ void plDynamicTextMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
if (contentFlags.IsBitSet(kDynTextMsgImageKey))
fImageKey = mgr->ReadKey( s );
if (contentFlags.IsBitSet(kDynTextMsgFlags))
s->ReadSwap( &fFlags );
s->ReadLE( &fFlags );
if (contentFlags.IsBitSet(kDynTextMsgBlockRGB))
s->ReadSwap( &fBlockRGB );
s->ReadLE( &fBlockRGB );
if (contentFlags.IsBitSet(kDynTextMsgLineSpacing))
s->ReadSwap( &fLineSpacing );
s->ReadLE( &fLineSpacing );
}
void plDynamicTextMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
@ -339,20 +339,20 @@ void plDynamicTextMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kDynTextMsgCmd
s->WriteSwap( fCmd );
s->WriteLE( fCmd );
// kDynTextMsgX
s->WriteSwap( fX );
s->WriteLE( fX );
// kDynTextMsgY
s->WriteSwap( fY );
s->WriteLE( fY );
// kDynTextMsgLeft
s->WriteSwap( fLeft );
s->WriteLE( fLeft );
// kDynTextMsgTop
s->WriteSwap( fTop );
s->WriteLE( fTop );
// kDynTextMsgRight
s->WriteSwap( fRight );
s->WriteLE( fRight );
// kDynTextMsgBottom
s->WriteSwap( fBottom );
s->WriteLE( fBottom );
// kDynTextMsgClearColor
fClearColor.Write( s );
@ -365,12 +365,12 @@ void plDynamicTextMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
mgr->WriteKey( s, fImageKey );
// kDynTextMsgFlags
s->WriteSwap( fFlags );
s->WriteLE( fFlags );
// kDynTextMsgBlockRGB
s->WriteSwap( fBlockRGB );
s->WriteLE( fBlockRGB );
// kDynTextMsgLineSpacing
s->WriteSwap( fLineSpacing );
s->WriteLE( fLineSpacing );
}

4
Sources/Plasma/PubUtilLib/plMessage/plExcludeRegionMsg.h
View File

@ -77,14 +77,14 @@ public:
{
plMessage::IMsgRead(stream, mgr);
fCmd = stream->ReadByte();
fSynchFlags = stream->ReadSwap32();
fSynchFlags = stream->ReadLE32();
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteByte(fCmd);
stream->WriteSwap32(fSynchFlags);
stream->WriteLE32(fSynchFlags);
}
};

40
Sources/Plasma/PubUtilLib/plMessage/plInputEventMsg.cpp
View File

@ -68,14 +68,14 @@ void plInputEventMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
stream->ReadSwap(&fEvent);
stream->ReadLE(&fEvent);
}
void plInputEventMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap(fEvent);
stream->WriteLE(fEvent);
}
enum InputEventMsgFlags
@ -91,7 +91,7 @@ void plInputEventMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kInputEventMsgEvent))
s->ReadSwap(&fEvent);
s->ReadLE(&fEvent);
}
void plInputEventMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
@ -103,7 +103,7 @@ void plInputEventMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kInputEventMsgEvent
s->WriteSwap(fEvent);
s->WriteLE(fEvent);
}
plControlEventMsg::plControlEventMsg() :
@ -134,9 +134,9 @@ plControlEventMsg::~plControlEventMsg()
void plControlEventMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Read(stream, mgr);
stream->ReadSwap((Int32*)&fControlCode);
stream->ReadSwap(&fControlActivated);
stream->ReadSwap(&fControlPct);
stream->ReadLE((Int32*)&fControlCode);
stream->ReadLE(&fControlActivated);
stream->ReadLE(&fControlPct);
fTurnToPt.Read(stream);
// read cmd/string
@ -146,9 +146,9 @@ void plControlEventMsg::Read(hsStream* stream, hsResMgr* mgr)
void plControlEventMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Write(stream, mgr);
stream->WriteSwap((Int32)fControlCode);
stream->WriteSwap(fControlActivated);
stream->WriteSwap(fControlPct);
stream->WriteLE((Int32)fControlCode);
stream->WriteLE(fControlActivated);
stream->WriteLE(fControlPct);
fTurnToPt.Write(stream);
// write cmd/string
@ -172,13 +172,13 @@ void plControlEventMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kControlEventMsgCode))
s->ReadSwap((Int32*)&fControlCode);
s->ReadLE((Int32*)&fControlCode);
if (contentFlags.IsBitSet(kControlEventMsgActivated))
s->ReadSwap(&fControlActivated);
s->ReadLE(&fControlActivated);
if (contentFlags.IsBitSet(kControlEventMsgPct))
s->ReadSwap(&fControlPct);
s->ReadLE(&fControlPct);
if (contentFlags.IsBitSet(kControlEventMsgTurnToPt))
fTurnToPt.Read(s);
@ -201,13 +201,13 @@ void plControlEventMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kControlEventMsgCode,
s->WriteSwap((Int32)fControlCode);
s->WriteLE((Int32)fControlCode);
// kControlEventMsgActivated,
s->WriteSwap(fControlActivated);
s->WriteLE(fControlActivated);
// kControlEventMsgPct,
s->WriteSwap(fControlPct);
s->WriteLE(fControlPct);
// kControlEventMsgTurnToPt,
fTurnToPt.Write(s);
@ -283,13 +283,13 @@ const UInt8 plAvatarInputStateMsg::fMapSize = 12;
void plAvatarInputStateMsg::Read(hsStream *s, hsResMgr *mgr)
{
plMessage::IMsgRead(s, mgr);
fState = s->ReadSwap16();
fState = s->ReadLE16();
}
void plAvatarInputStateMsg::Write(hsStream *s, hsResMgr *mgr)
{
plMessage::IMsgWrite(s, mgr);
s->WriteSwap16(fState);
s->WriteLE16(fState);
}
enum AvatarInputStateMsgFlags
@ -305,7 +305,7 @@ void plAvatarInputStateMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kAvatarInputStateMsgState))
fState = s->ReadSwap16();
fState = s->ReadLE16();
}
void plAvatarInputStateMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
@ -316,7 +316,7 @@ void plAvatarInputStateMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.SetBit(kAvatarInputStateMsgState);
contentFlags.Write(s);
s->WriteSwap16(fState);
s->WriteLE16(fState);
}
hsBool plAvatarInputStateMsg::IsCodeInMap(ControlEventCode code)

88
Sources/Plasma/PubUtilLib/plMessage/plInputEventMsg.h
View File

@ -165,23 +165,23 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Read(stream, mgr);
stream->ReadSwap((Int32*)&fKeyCode);
stream->ReadSwap(&fKeyDown);
stream->ReadSwap(&fCapsLockKeyDown);
stream->ReadSwap(&fShiftKeyDown);
stream->ReadSwap(&fCtrlKeyDown);
stream->ReadSwap(&fRepeat);
stream->ReadLE((Int32*)&fKeyCode);
stream->ReadLE(&fKeyDown);
stream->ReadLE(&fCapsLockKeyDown);
stream->ReadLE(&fShiftKeyDown);
stream->ReadLE(&fCtrlKeyDown);
stream->ReadLE(&fRepeat);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Write(stream, mgr);
stream->WriteSwap((Int32)fKeyCode);
stream->WriteSwap(fKeyDown);
stream->WriteSwap(fCapsLockKeyDown);
stream->WriteSwap(fShiftKeyDown);
stream->WriteSwap(fCtrlKeyDown);
stream->WriteSwap(fRepeat);
stream->WriteLE((Int32)fKeyCode);
stream->WriteLE(fKeyDown);
stream->WriteLE(fCapsLockKeyDown);
stream->WriteLE(fShiftKeyDown);
stream->WriteLE(fCtrlKeyDown);
stream->WriteLE(fRepeat);
}
};
@ -224,21 +224,21 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Read(stream, mgr);
stream->ReadSwap((Int32*)&fKeyCode);
stream->ReadSwap(&fKeyDown);
stream->ReadSwap(&fCapsLockKeyDown);
stream->ReadSwap(&fShiftKeyDown);
stream->ReadSwap(&fCtrlKeyDown);
stream->ReadLE((Int32*)&fKeyCode);
stream->ReadLE(&fKeyDown);
stream->ReadLE(&fCapsLockKeyDown);
stream->ReadLE(&fShiftKeyDown);
stream->ReadLE(&fCtrlKeyDown);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Write(stream, mgr);
stream->WriteSwap((Int32)fKeyCode);
stream->WriteSwap(fKeyDown);
stream->WriteSwap(fCapsLockKeyDown);
stream->WriteSwap(fShiftKeyDown);
stream->WriteSwap(fCtrlKeyDown);
stream->WriteLE((Int32)fKeyCode);
stream->WriteLE(fKeyDown);
stream->WriteLE(fCapsLockKeyDown);
stream->WriteLE(fShiftKeyDown);
stream->WriteLE(fCtrlKeyDown);
}
};
@ -262,15 +262,15 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Read(stream, mgr);
stream->ReadSwap(&fX);
stream->ReadSwap(&fWx);
stream->ReadLE(&fX);
stream->ReadLE(&fWx);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Write(stream, mgr);
stream->WriteSwap(fX);
stream->WriteSwap(fWx);
stream->WriteLE(fX);
stream->WriteLE(fWx);
}
};
@ -295,15 +295,15 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Read(stream, mgr);
stream->ReadSwap(&fY);
stream->ReadSwap(&fWy);
stream->ReadLE(&fY);
stream->ReadLE(&fWy);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Write(stream, mgr);
stream->WriteSwap(fY);
stream->WriteSwap(fWy);
stream->WriteLE(fY);
stream->WriteLE(fWy);
}
};
@ -326,13 +326,13 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Read(stream, mgr);
stream->ReadSwap(&fButton);
stream->ReadLE(&fButton);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Write(stream, mgr);
stream->WriteSwap(fButton);
stream->WriteLE(fButton);
}
};
@ -379,23 +379,23 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Read(stream, mgr);
stream->ReadSwap(&fXPos);
stream->ReadSwap(&fYPos);
stream->ReadSwap(&fDX);
stream->ReadSwap(&fDY);
stream->ReadSwap(&fButton);
stream->ReadSwap(&fWheelDelta);
stream->ReadLE(&fXPos);
stream->ReadLE(&fYPos);
stream->ReadLE(&fDX);
stream->ReadLE(&fDY);
stream->ReadLE(&fButton);
stream->ReadLE(&fWheelDelta);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plInputEventMsg::Write(stream, mgr);
stream->WriteSwap(fXPos);
stream->WriteSwap(fYPos);
stream->WriteSwap(fDX);
stream->WriteSwap(fDY);
stream->WriteSwap(fButton);
stream->WriteSwap(fWheelDelta);
stream->WriteLE(fXPos);
stream->WriteLE(fYPos);
stream->WriteLE(fDX);
stream->WriteLE(fDY);
stream->WriteLE(fButton);
stream->WriteLE(fWheelDelta);
}
};

8
Sources/Plasma/PubUtilLib/plMessage/plInputIfaceMgrMsg.h
View File

@ -100,8 +100,8 @@ class plInputIfaceMgrMsg : public plMessage
virtual void Read(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgRead( s, mgr );
s->ReadSwap( &fCommand );
s->ReadSwap( &fPageID );
s->ReadLE( &fCommand );
s->ReadLE( &fPageID );
ageName = s->ReadSafeString();
ageFileName = s->ReadSafeString();
spawnPoint = s->ReadSafeString();
@ -111,8 +111,8 @@ class plInputIfaceMgrMsg : public plMessage
virtual void Write(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgWrite( s, mgr );
s->WriteSwap( fCommand );
s->WriteSwap( fPageID );
s->WriteLE( fCommand );
s->WriteLE( fPageID );
s->WriteSafeString(ageName);
s->WriteSafeString(ageFileName);
s->WriteSafeString(spawnPoint);

12
Sources/Plasma/PubUtilLib/plMessage/plInterestingPing.h
View File

@ -71,9 +71,9 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
stream->ReadSwap(&fWeight);
stream->ReadSwap(&fRadius);
stream->ReadSwap(&fSize);
stream->ReadLE(&fWeight);
stream->ReadLE(&fRadius);
stream->ReadLE(&fSize);
fPos.Read(stream);
fObj = mgr->ReadKey(stream);
}
@ -81,9 +81,9 @@ public:
void Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap(fWeight);
stream->WriteSwap(fRadius);
stream->WriteSwap(fSize);
stream->WriteLE(fWeight);
stream->WriteLE(fRadius);
stream->WriteLE(fSize);
fPos.Write(stream);
mgr->WriteKey(stream, fObj);
}

8
Sources/Plasma/PubUtilLib/plMessage/plLOSHitMsg.h
View File

@ -79,8 +79,8 @@ public:
fObj = mgr->ReadKey(stream);
fHitPoint.Read(stream);
fNoHit = stream->ReadBool();
stream->ReadSwap(&fRequestID);
stream->ReadSwap(&fHitFlags);
stream->ReadLE(&fRequestID);
stream->ReadLE(&fHitFlags);
}
void Write(hsStream* stream, hsResMgr* mgr)
@ -89,8 +89,8 @@ public:
mgr->WriteKey(stream, fObj);
fHitPoint.Write(stream);
stream->WriteBool(fNoHit);
stream->WriteSwap(fRequestID);
stream->WriteSwap(fHitFlags);
stream->WriteLE(fRequestID);
stream->WriteLE(fHitFlags);
}
};

8
Sources/Plasma/PubUtilLib/plMessage/plLayRefMsg.cpp
View File

@ -47,13 +47,13 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
void plLayRefMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plRefMsg::Read(stream, mgr);
stream->ReadSwap(&fType);
stream->ReadSwap(&fWhich);
stream->ReadLE(&fType);
stream->ReadLE(&fWhich);
}
void plLayRefMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plRefMsg::Write(stream, mgr);
stream->WriteSwap(fType);
stream->WriteSwap(fWhich);
stream->WriteLE(fType);
stream->WriteLE(fWhich);
}

20
Sources/Plasma/PubUtilLib/plMessage/plLinkToAgeMsg.cpp
View File

@ -146,7 +146,7 @@ void plLinkingMgrMsg::Read( hsStream* stream, hsResMgr* mgr )
contentFlags.Read( stream );
if ( contentFlags.IsBitSet( kLinkingMgrCmd ) )
stream->ReadSwap( &fLinkingMgrCmd );
stream->ReadLE( &fLinkingMgrCmd );
if ( contentFlags.IsBitSet( kLinkingMgrArgs ) )
fArgs.Read( stream, mgr );
}
@ -160,7 +160,7 @@ void plLinkingMgrMsg::Write( hsStream* stream, hsResMgr* mgr )
contentFlags.SetBit( kLinkingMgrArgs );
contentFlags.Write( stream );
stream->WriteSwap( fLinkingMgrCmd );
stream->WriteLE( fLinkingMgrCmd );
fArgs.Write( stream, mgr );
}
@ -189,12 +189,12 @@ void plLinkEffectsTriggerMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead( stream, mgr );
fInvisLevel = stream->ReadSwap32();
fInvisLevel = stream->ReadLE32();
fLeavingAge = stream->ReadBool();
fLinkKey = mgr->ReadKey(stream);
// This variable is for internal use only. Still read/written for backwards compatability.
fEffects = stream->ReadSwap32();
fEffects = stream->ReadLE32();
fEffects = 0;
fLinkInAnimKey = mgr->ReadKey(stream);
@ -204,10 +204,10 @@ void plLinkEffectsTriggerMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite( stream, mgr );
stream->WriteSwap32(fInvisLevel);
stream->WriteLE32(fInvisLevel);
stream->WriteBool(fLeavingAge);
mgr->WriteKey(stream, fLinkKey);
stream->WriteSwap32(fEffects);
stream->WriteLE32(fEffects);
mgr->WriteKey(stream, fLinkInAnimKey);
}
@ -231,7 +231,7 @@ void plLinkEffectsTriggerMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
if (contentFlags.IsBitSet(kLinkEffectsLinkKey))
fLinkKey = mgr->ReadKey(s);
if (contentFlags.IsBitSet(kLinkEffectsEffects))
fEffects = s->ReadSwap32();
fEffects = s->ReadLE32();
if (contentFlags.IsBitSet(kLinkEffectsLinkInAnimKey))
fLinkInAnimKey = mgr->ReadKey(s);
@ -258,7 +258,7 @@ void plLinkEffectsTriggerMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
// kLinkEffectsLinkKey
mgr->WriteKey(s, fLinkKey);
// kLinkEffectsEffects
s->WriteSwap32(fEffects);
s->WriteLE32(fEffects);
// kLinkEffectsLinkInAnimKey
mgr->WriteKey(s, fLinkInAnimKey);
}
@ -303,7 +303,7 @@ void plLinkEffectBCMsg::Read(hsStream* stream, hsResMgr* mgr)
plMessage::IMsgRead(stream, mgr);
fLinkKey = mgr->ReadKey(stream);
fLinkFlags = stream->ReadSwap32();
fLinkFlags = stream->ReadLE32();
}
void plLinkEffectBCMsg::Write(hsStream* stream, hsResMgr* mgr)
@ -311,7 +311,7 @@ void plLinkEffectBCMsg::Write(hsStream* stream, hsResMgr* mgr)
plMessage::IMsgWrite(stream, mgr);
mgr->WriteKey(stream, fLinkKey);
stream->WriteSwap32(fLinkFlags);
stream->WriteLE32(fLinkFlags);
}
void plLinkEffectBCMsg::SetLinkFlag(UInt32 flag, hsBool on /* = true */)

12
Sources/Plasma/PubUtilLib/plMessage/plLoadAgeMsg.cpp
View File

@ -53,7 +53,7 @@ void plLoadAgeMsg::Read(hsStream* stream, hsResMgr* mgr)
// read agename
UInt8 len;
stream->ReadSwap(&len);
stream->ReadLE(&len);
if (len)
{
fAgeFilename=TRACKED_NEW char[len+1];
@ -61,7 +61,7 @@ void plLoadAgeMsg::Read(hsStream* stream, hsResMgr* mgr)
fAgeFilename[len]=0;
}
fUnload = stream->ReadBool();
stream->ReadSwap(&fPlayerID);
stream->ReadLE(&fPlayerID);
fAgeGuid.Read(stream);
}
@ -71,13 +71,13 @@ void plLoadAgeMsg::Write(hsStream* stream, hsResMgr* mgr)
// write agename
UInt8 len=fAgeFilename?hsStrlen(fAgeFilename):0;
stream->WriteSwap(len);
stream->WriteLE(len);
if (len)
{
stream->Write(len, fAgeFilename);
}
stream->WriteBool(fUnload);
stream->WriteSwap(fPlayerID);
stream->WriteLE(fPlayerID);
fAgeGuid.Write(stream);
}
@ -107,7 +107,7 @@ void plLoadAgeMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
fUnload = s->ReadBool();
if (contentFlags.IsBitSet(kLoadAgePlayerID))
s->ReadSwap(&fPlayerID);
s->ReadLE(&fPlayerID);
if (contentFlags.IsBitSet(kLoadAgeAgeGuid))
fAgeGuid.Read(s);
@ -129,7 +129,7 @@ void plLoadAgeMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
// kLoadAgeUnload
s->WriteBool(fUnload);
// kLoadAgePlayerID
s->WriteSwap(fPlayerID);
s->WriteLE(fPlayerID);
// kLoadAgeAgeGuid
fAgeGuid.Write(s);
}

16
Sources/Plasma/PubUtilLib/plMessage/plLoadCloneMsg.cpp
View File

@ -128,8 +128,8 @@ void plLoadCloneMsg::Read(hsStream* stream, hsResMgr* mgr)
plMessage::IMsgRead(stream, mgr);
fCloneKey = mgr->ReadKey(stream);
fRequestorKey = mgr->ReadKey(stream);
fOriginatingPlayerID = stream->ReadSwap32();
fUserData = stream->ReadSwap32();
fOriginatingPlayerID = stream->ReadLE32();
fUserData = stream->ReadLE32();
fValidMsg = stream->ReadBool();
fIsLoading = stream->ReadBool();
fTriggerMsg = plMessage::ConvertNoRef(mgr->ReadCreatable(stream));
@ -141,8 +141,8 @@ void plLoadCloneMsg::Write(hsStream* stream, hsResMgr* mgr)
plMessage::IMsgWrite(stream,mgr);
mgr->WriteKey(stream, fCloneKey);
mgr->WriteKey(stream, fRequestorKey);
stream->WriteSwap32(fOriginatingPlayerID);
stream->WriteSwap32(fUserData);
stream->WriteLE32(fOriginatingPlayerID);
stream->WriteLE32(fUserData);
stream->WriteBool(fValidMsg);
stream->WriteBool(fIsLoading);
mgr->WriteCreatable(stream, fTriggerMsg);
@ -173,10 +173,10 @@ void plLoadCloneMsg::ReadVersion(hsStream* stream, hsResMgr* mgr)
fRequestorKey = mgr->ReadKey(stream);
if (contentFlags.IsBitSet(kLoadCloneMsgOrigPlayerID))
fOriginatingPlayerID = stream->ReadSwap32();
fOriginatingPlayerID = stream->ReadLE32();
if (contentFlags.IsBitSet(kLoadCloneMsgUserData))
fUserData = stream->ReadSwap32();
fUserData = stream->ReadLE32();
if (contentFlags.IsBitSet(kLoadCloneMsgValidMsg))
fValidMsg = stream->ReadBool();
@ -207,9 +207,9 @@ void plLoadCloneMsg::WriteVersion(hsStream* stream, hsResMgr* mgr)
// kLoadCloneMsgRequestorKey
mgr->WriteKey(stream, fRequestorKey);
// kLoadCloneMsgOrigPlayerID
stream->WriteSwap32(fOriginatingPlayerID);
stream->WriteLE32(fOriginatingPlayerID);
// kLoadCloneMsgUserData
stream->WriteSwap32(fUserData);
stream->WriteLE32(fUserData);
// kLoadCloneMsgValidMsg
stream->WriteBool(fValidMsg);
// kLoadCloneMsgIsLoading

8
Sources/Plasma/PubUtilLib/plMessage/plMeshRefMsg.h
View File

@ -69,15 +69,15 @@ public:
virtual void Read(hsStream* stream, hsResMgr* mgr)
{
plRefMsg::Read(stream, mgr);
stream->ReadSwap(&fType);
stream->ReadSwap(&fWhich);
stream->ReadLE(&fType);
stream->ReadLE(&fWhich);
}
virtual void Write(hsStream* stream, hsResMgr* mgr)
{
plRefMsg::Write(stream, mgr);
stream->WriteSwap(fType);
stream->WriteSwap(fWhich);
stream->WriteLE(fType);
stream->WriteLE(fWhich);
}
};

12
Sources/Plasma/PubUtilLib/plMessage/plNetVoiceListMsg.cpp
View File

@ -50,11 +50,11 @@ void plNetVoiceListMsg::Read(hsStream* stream, hsResMgr* mgr)
plMessage::IMsgRead(stream, mgr);
fRemoved = mgr->ReadKey(stream);
fCmd = stream->ReadSwap32();
int n = stream->ReadSwap32();
fCmd = stream->ReadLE32();
int n = stream->ReadLE32();
fClientIDs.SetCountAndZero(0);
for (int i = 0; i < n; i++)
fClientIDs.Append(stream->ReadSwap32());
fClientIDs.Append(stream->ReadLE32());
}
@ -63,8 +63,8 @@ void plNetVoiceListMsg::Write(hsStream* stream, hsResMgr* mgr)
plMessage::IMsgWrite(stream, mgr);
mgr->WriteKey(stream, fRemoved);
stream->WriteSwap32(fCmd);
stream->WriteSwap32(fClientIDs.Count());
stream->WriteLE32(fCmd);
stream->WriteLE32(fClientIDs.Count());
for (int i = 0; i<fClientIDs.Count(); i++)
stream->WriteSwap32(fClientIDs[i]);
stream->WriteLE32(fClientIDs[i]);
}

8
Sources/Plasma/PubUtilLib/plMessage/plOneShotCallbacks.cpp
View File

@ -73,13 +73,13 @@ plOneShotCallbacks::plOneShotCallback& plOneShotCallbacks::GetCallback(int i)
void plOneShotCallbacks::Read(hsStream* stream, hsResMgr* mgr)
{
int size = stream->ReadSwap32();
int size = stream->ReadLE32();
fCallbacks.reserve(size);
for (int i = 0; i < size; i++)
{
char *marker = stream->ReadSafeString();
plKey receiver = mgr->ReadKey(stream);
Int16 user = stream->ReadSwap16();
Int16 user = stream->ReadLE16();
fCallbacks.push_back(plOneShotCallback(marker, receiver, user));
}
@ -88,11 +88,11 @@ void plOneShotCallbacks::Read(hsStream* stream, hsResMgr* mgr)
void plOneShotCallbacks::Write(hsStream* stream, hsResMgr* mgr)
{
int size = fCallbacks.size();
stream->WriteSwap32(size);
stream->WriteLE32(size);
for (int i = 0; i < size; i++)
{
stream->WriteSafeString(fCallbacks[i].fMarker);
mgr->WriteKey(stream, fCallbacks[i].fReceiver);
stream->WriteSwap16(fCallbacks[i].fUser);
stream->WriteLE16(fCallbacks[i].fUser);
}
}

24
Sources/Plasma/PubUtilLib/plMessage/plParticleUpdateMsg.h
View File

@ -96,16 +96,16 @@ public:
{
plMessage::IMsgRead(stream, mgr);
fParamID = stream->ReadSwap32();
stream->ReadSwap(&fParamValue);
fParamID = stream->ReadLE32();
stream->ReadLE(&fParamValue);
}
virtual void Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap32(fParamID);
stream->WriteSwap(fParamValue);
stream->WriteLE32(fParamID);
stream->WriteLE(fParamValue);
}
};
@ -134,7 +134,7 @@ public:
plMessage::IMsgRead(stream, mgr);
fSysSOKey = mgr->ReadKey(stream);
fNumToTransfer = stream->ReadSwap16();
fNumToTransfer = stream->ReadLE16();
}
virtual void Write(hsStream *stream, hsResMgr *mgr)
@ -142,7 +142,7 @@ public:
plMessage::IMsgWrite(stream, mgr);
mgr->WriteKey(stream, fSysSOKey);
stream->WriteSwap16(fNumToTransfer);
stream->WriteLE16(fNumToTransfer);
}
};
@ -177,16 +177,16 @@ public:
virtual void Read(hsStream *stream, hsResMgr *mgr)
{
plMessage::IMsgRead(stream,mgr);
fNumToKill = stream->ReadSwapScalar();
fTimeLeft = stream->ReadSwapScalar();
stream->ReadSwap(&fFlags);
fNumToKill = stream->ReadLEScalar();
fTimeLeft = stream->ReadLEScalar();
stream->ReadLE(&fFlags);
}
virtual void Write(hsStream *stream, hsResMgr *mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwapScalar(fNumToKill);
stream->WriteSwapScalar(fTimeLeft);
stream->WriteSwap(fFlags);
stream->WriteLEScalar(fNumToKill);
stream->WriteLEScalar(fTimeLeft);
stream->WriteLE(fFlags);
}
};

4
Sources/Plasma/PubUtilLib/plMessage/plSimInfluenceMsg.cpp
View File

@ -154,14 +154,14 @@ void plDampMsg::Read(hsStream *stream, hsResMgr *mgr)
{
plSimInfluenceMsg::Read(stream, mgr);
stream->WriteSwapScalar(fDamp);
stream->WriteLEScalar(fDamp);
}
void plDampMsg::Write(hsStream * stream, hsResMgr *mgr)
{
plSimInfluenceMsg::Write(stream, mgr);
fDamp = stream->ReadSwapScalar();
fDamp = stream->ReadLEScalar();
}

8
Sources/Plasma/PubUtilLib/plMessage/plSynchEnableMsg.cpp
View File

@ -50,13 +50,13 @@ plSynchEnableMsg::plSynchEnableMsg(bool push, bool enable) : fPush(push), fEnabl
void plSynchEnableMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead( stream, mgr );
stream->WriteSwap(fEnable);
stream->WriteSwap(fPush);
stream->WriteLE(fEnable);
stream->WriteLE(fPush);
}
void plSynchEnableMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite( stream, mgr );
stream->ReadSwap(&fEnable);
stream->ReadSwap(&fPush);
stream->ReadLE(&fEnable);
stream->ReadLE(&fPush);
}

8
Sources/Plasma/PubUtilLib/plMessage/plTimerCallbackMsg.h
View File

@ -64,15 +64,15 @@ public:
virtual void Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
fID = stream->ReadSwap32();
fTime = stream->ReadSwapScalar();
fID = stream->ReadLE32();
fTime = stream->ReadLEScalar();
}
virtual void Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap32(fID);
stream->WriteSwapScalar(fTime);
stream->WriteLE32(fID);
stream->WriteLEScalar(fTime);
}
};

12
Sources/Plasma/PubUtilLib/plMessage/plTransitionMsg.h
View File

@ -80,17 +80,17 @@ public:
virtual void Read(hsStream* s, hsResMgr* mgr)
{
plMessageWithCallbacks::Read(s, mgr);
s->ReadSwap(&fEffect);
s->ReadSwap(&fLengthInSecs);
s->ReadSwap(&fHoldUntilNext);
s->ReadLE(&fEffect);
s->ReadLE(&fLengthInSecs);
s->ReadLE(&fHoldUntilNext);
}
virtual void Write(hsStream* s, hsResMgr* mgr)
{
plMessageWithCallbacks::Write(s, mgr);
s->WriteSwap(fEffect);
s->WriteSwap(fLengthInSecs);
s->WriteSwap(fHoldUntilNext);
s->WriteLE(fEffect);
s->WriteLE(fLengthInSecs);
s->WriteLE(fHoldUntilNext);
}
};

8
Sources/Plasma/PubUtilLib/plMessage/plVaultNotifyMsg.cpp
View File

@ -56,15 +56,15 @@ plVaultNotifyMsg::~plVaultNotifyMsg()
void plVaultNotifyMsg::Read(hsStream* stream, hsResMgr* mgr)
{
stream->ReadSwap( &fType );
stream->ReadSwap( &fResultCode );
stream->ReadLE( &fType );
stream->ReadLE( &fResultCode );
fArgs.Read( stream, mgr );
}
void plVaultNotifyMsg::Write(hsStream* stream, hsResMgr* mgr)
{
stream->WriteSwap( fType );
stream->WriteSwap( fResultCode );
stream->WriteLE( fType );
stream->WriteLE( fResultCode );
fArgs.Write( stream, mgr );
}