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

4
Sources/Plasma/NucleusLib/pnMessage/plAudioSysMsg.h
View File

@ -94,14 +94,14 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
stream->WriteSwap(fAudFlag);
stream->WriteLE(fAudFlag);
mgr->WriteKey(stream, pObj);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->ReadSwap(&fAudFlag);
stream->ReadLE(&fAudFlag);
pObj = mgr->ReadKey(stream);
}
};

48
Sources/Plasma/NucleusLib/pnMessage/plCameraMsg.cpp
View File

@ -81,7 +81,7 @@ void plCameraMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
fCmd.Read(stream);
fTransTime = stream->ReadSwapDouble();
fTransTime = stream->ReadLEDouble();
fActivated = stream->ReadBool();
fNewCam = mgr->ReadKey(stream);
fTriggerer = mgr->ReadKey(stream);
@ -92,7 +92,7 @@ void plCameraMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
fCmd.Write(stream);
stream->WriteSwapDouble(fTransTime);
stream->WriteLEDouble(fTransTime);
stream->WriteBool(fActivated);
mgr->WriteKey(stream, fNewCam);
mgr->WriteKey(stream, fTriggerer);
@ -101,33 +101,33 @@ void plCameraMsg::Write(hsStream* stream, hsResMgr* mgr)
void plCameraConfig::Read(hsStream* stream)
{
fAccel = stream->ReadSwapFloat();
fDecel = stream->ReadSwapFloat();
fVel = stream->ReadSwapFloat();
fFPAccel = stream->ReadSwapFloat();
fFPDecel = stream->ReadSwapFloat();
fFPVel = stream->ReadSwapFloat();
fFOVw = stream->ReadSwapFloat();
fFOVh = stream->ReadSwapFloat();
fOffset.fX = stream->ReadSwapFloat();
fOffset.fY = stream->ReadSwapFloat();
fOffset.fZ = stream->ReadSwapFloat();
fAccel = stream->ReadLEFloat();
fDecel = stream->ReadLEFloat();
fVel = stream->ReadLEFloat();
fFPAccel = stream->ReadLEFloat();
fFPDecel = stream->ReadLEFloat();
fFPVel = stream->ReadLEFloat();
fFOVw = stream->ReadLEFloat();
fFOVh = stream->ReadLEFloat();
fOffset.fX = stream->ReadLEFloat();
fOffset.fY = stream->ReadLEFloat();
fOffset.fZ = stream->ReadLEFloat();
fWorldspace = stream->ReadBool();
}
void plCameraConfig::Write(hsStream* stream)
{
stream->WriteSwapFloat(fAccel);
stream->WriteSwapFloat(fDecel);
stream->WriteSwapFloat(fVel);
stream->WriteSwapFloat(fFPAccel);
stream->WriteSwapFloat(fFPDecel);
stream->WriteSwapFloat(fFPVel);
stream->WriteSwapFloat(fFOVw);
stream->WriteSwapFloat(fFOVh);
stream->WriteSwapFloat(fOffset.fX);
stream->WriteSwapFloat(fOffset.fY);
stream->WriteSwapFloat(fOffset.fZ);
stream->WriteLEFloat(fAccel);
stream->WriteLEFloat(fDecel);
stream->WriteLEFloat(fVel);
stream->WriteLEFloat(fFPAccel);
stream->WriteLEFloat(fFPDecel);
stream->WriteLEFloat(fFPVel);
stream->WriteLEFloat(fFOVw);
stream->WriteLEFloat(fFOVh);
stream->WriteLEFloat(fOffset.fX);
stream->WriteLEFloat(fOffset.fY);
stream->WriteLEFloat(fOffset.fZ);
stream->WriteBool(fWorldspace);
}

8
Sources/Plasma/NucleusLib/pnMessage/plClientMsg.h
View File

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

8
Sources/Plasma/NucleusLib/pnMessage/plCursorChangeMsg.h
View File

@ -91,15 +91,15 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
fType = stream->ReadSwap32();
fPriority = stream->ReadSwap32();
fType = stream->ReadLE32();
fPriority = stream->ReadLE32();
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap32(fType);
stream->WriteSwap32(fPriority);
stream->WriteLE32(fType);
stream->WriteLE32(fPriority);
}
};

20
Sources/Plasma/NucleusLib/pnMessage/plEventCallbackMsg.h
View File

@ -91,20 +91,20 @@ public:
virtual void Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
fEventTime = stream->ReadSwapFloat();
fEvent = (CallbackEvent)stream->ReadSwap16();
fIndex = stream->ReadSwap16();
fRepeats = stream->ReadSwap16();
fUser = stream->ReadSwap16();
fEventTime = stream->ReadLEFloat();
fEvent = (CallbackEvent)stream->ReadLE16();
fIndex = stream->ReadLE16();
fRepeats = stream->ReadLE16();
fUser = stream->ReadLE16();
}
virtual void Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwapFloat(fEventTime);
stream->WriteSwap16((Int16)fEvent);
stream->WriteSwap16(fIndex);
stream->WriteSwap16(fRepeats);
stream->WriteSwap16(fUser);
stream->WriteLEFloat(fEventTime);
stream->WriteLE16((Int16)fEvent);
stream->WriteLE16(fIndex);
stream->WriteLE16(fRepeats);
stream->WriteLE16(fUser);
}
};

12
Sources/Plasma/NucleusLib/pnMessage/plIntRefMsg.h
View File

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

44
Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp
View File

@ -119,14 +119,14 @@ void plMessage::IMsgRead(hsStream* s, hsResMgr* mgr)
fSender = mgr->ReadKey(s);
int n;
s->LogReadSwap(&n,"NumberOfReceivers");
s->LogReadLE(&n,"NumberOfReceivers");
fReceivers.SetCount(n);
int i;
for( i = 0; i < fReceivers.GetCount(); i++ )
fReceivers[i] = mgr->ReadKey(s);
s->LogReadSwap(&fTimeStamp,"TimeStamp"); // read as double
s->LogReadSwap(&fBCastFlags, "BCastFlags");
s->LogReadLE(&fTimeStamp,"TimeStamp"); // read as double
s->LogReadLE(&fBCastFlags, "BCastFlags");
}
void plMessage::IMsgWrite(hsStream* s, hsResMgr* mgr)
@ -134,13 +134,13 @@ void plMessage::IMsgWrite(hsStream* s, hsResMgr* mgr)
plCreatable::Write(s, mgr);
mgr->WriteKey(s,fSender);
s->WriteSwap32(fReceivers.GetCount());
s->WriteLE32(fReceivers.GetCount());
int i;
for( i = 0; i < fReceivers.GetCount(); i++ )
mgr->WriteKey(s,fReceivers[i]);
s->WriteSwap(fTimeStamp); // write as double
s->WriteSwap32(fBCastFlags);
s->WriteLE(fTimeStamp); // write as double
s->WriteLE32(fBCastFlags);
}
enum MsgFlags
@ -161,7 +161,7 @@ void plMessage::IMsgReadVersion(hsStream* s, hsResMgr* mgr)
if (contentFlags.IsBitSet(kMsgReceivers))
{
int n = s->ReadSwap32();
int n = s->ReadLE32();
fReceivers.SetCount(n);
int i;
for( i = 0; i < fReceivers.GetCount(); i++ )
@ -169,10 +169,10 @@ void plMessage::IMsgReadVersion(hsStream* s, hsResMgr* mgr)
}
if (contentFlags.IsBitSet(kMsgTimeStamp))
s->ReadSwap(&fTimeStamp); // read as double
s->ReadLE(&fTimeStamp); // read as double
if (contentFlags.IsBitSet(kMsgBCastFlags))
fBCastFlags = s->ReadSwap32();
fBCastFlags = s->ReadLE32();
}
void plMessage::IMsgWriteVersion(hsStream* s, hsResMgr* mgr)
@ -188,16 +188,16 @@ void plMessage::IMsgWriteVersion(hsStream* s, hsResMgr* mgr)
mgr->WriteKey(s,fSender);
// kMsgReceivers
s->WriteSwap32(fReceivers.GetCount());
s->WriteLE32(fReceivers.GetCount());
int i;
for( i = 0; i < fReceivers.GetCount(); i++ )
mgr->WriteKey(s,fReceivers[i]);
// kMsgTimeStamp
s->WriteSwap(fTimeStamp); // write as double
s->WriteLE(fTimeStamp); // write as double
// kMsgBCastFlags
s->WriteSwap32(fBCastFlags);
s->WriteLE32(fBCastFlags);
}
void plMessage::AddNetReceiver( UInt32 plrID )
@ -222,7 +222,7 @@ int plMsgStdStringHelper::Poke(const std::string & stringref, hsStream* stream,
plMessage::plStrLen strlen;
hsAssert( stringref.length()<0xFFFF, "buf too big for plMsgStdStringHelper" );
strlen = stringref.length();
stream->WriteSwap(strlen);
stream->WriteLE(strlen);
if (strlen)
stream->Write(strlen,stringref.data());
return stream->GetPosition();
@ -231,7 +231,7 @@ int plMsgStdStringHelper::Poke(const std::string & stringref, hsStream* stream,
int plMsgStdStringHelper::PokeBig(const std::string & stringref, hsStream* stream, const UInt32 peekOptions)
{
UInt32 strlen = stringref.length();
stream->WriteSwap(strlen);
stream->WriteLE(strlen);
if (strlen)
stream->Write(strlen,stringref.data());
return stream->GetPosition();
@ -242,7 +242,7 @@ int plMsgStdStringHelper::Poke(const char * buf, UInt32 bufsz, hsStream* stream,
plMessage::plStrLen strlen;
hsAssert( bufsz<0xFFFF, "buf too big for plMsgStdStringHelper" );
strlen = (plMessage::plStrLen)bufsz;
stream->WriteSwap(strlen);
stream->WriteLE(strlen);
if (strlen)
stream->Write(strlen,buf);
return stream->GetPosition();
@ -250,7 +250,7 @@ int plMsgStdStringHelper::Poke(const char * buf, UInt32 bufsz, hsStream* stream,
int plMsgStdStringHelper::PokeBig(const char * buf, UInt32 bufsz, hsStream* stream, const UInt32 peekOptions)
{
stream->WriteSwap(bufsz);
stream->WriteLE(bufsz);
if (bufsz)
stream->Write(bufsz,buf);
return stream->GetPosition();
@ -261,7 +261,7 @@ int plMsgStdStringHelper::Peek(std::string & stringref, hsStream* stream, const
{
plMessage::plStrLen strlen;
stream->LogSubStreamStart("push this");
stream->LogReadSwap(&strlen,"StrLen");
stream->LogReadLE(&strlen,"StrLen");
stringref.erase();
if (strlen <= stream->GetSizeLeft())
{
@ -283,7 +283,7 @@ int plMsgStdStringHelper::PeekBig(std::string & stringref, hsStream* stream, co
{
UInt32 bufsz;
stream->LogSubStreamStart("push this");
stream->LogReadSwap(&bufsz,"Bufsz");
stream->LogReadLE(&bufsz,"Bufsz");
stringref.erase();
if (bufsz <= stream->GetSizeLeft())
{
@ -308,7 +308,7 @@ int plMsgXtlStringHelper::Poke(const xtl::istring & stringref, hsStream* stream,
{
plMessage::plStrLen strlen;
strlen = stringref.length();
stream->WriteSwap(strlen);
stream->WriteLE(strlen);
if (strlen)
stream->Write(strlen,stringref.data());
return stream->GetPosition();
@ -319,7 +319,7 @@ int plMsgXtlStringHelper::Peek(xtl::istring & stringref, hsStream* stream, const
{
plMessage::plStrLen strlen;
stream->LogSubStreamStart("push me");
stream->LogReadSwap(&strlen,"StrLen");
stream->LogReadLE(&strlen,"StrLen");
stringref.erase();
if (strlen <= stream->GetSizeLeft())
{
@ -341,7 +341,7 @@ int plMsgCStringHelper::Poke(const char * str, hsStream* stream, const UInt32 pe
{
plMessage::plStrLen strlen;
strlen = (str)?hsStrlen(str):0;
stream->WriteSwap(strlen);
stream->WriteLE(strlen);
if (strlen)
stream->Write(strlen,str);
return stream->GetPosition();
@ -352,7 +352,7 @@ int plMsgCStringHelper::Peek(char *& str, hsStream* stream, const UInt32 peekOpt
{
plMessage::plStrLen strlen;
stream->LogSubStreamStart("push me");
stream->LogReadSwap(&strlen,"StrLen");
stream->LogReadLE(&strlen,"StrLen");
delete [] str;
str = nil;
if (strlen <= stream->GetSizeLeft())

8
Sources/Plasma/NucleusLib/pnMessage/plMessageWithCallbacks.cpp
View File

@ -68,7 +68,7 @@ void plMessageWithCallbacks::Read(hsStream* stream, hsResMgr* mgr)
Clear();
// read count
int n = stream->ReadSwap32();
int n = stream->ReadLE32();
fCallbacks.SetCount(n);
// read callbacks
@ -85,7 +85,7 @@ void plMessageWithCallbacks::Write(hsStream* stream, hsResMgr* mgr)
// write count
int n=fCallbacks.GetCount();
stream->WriteSwap32(n);
stream->WriteLE32(n);
// write callbacks
int i;
@ -110,7 +110,7 @@ void plMessageWithCallbacks::ReadVersion(hsStream* s, hsResMgr* mgr)
if (contentFlags.IsBitSet(kMsgWithCBsCallbacks))
{
// read count
int n = s->ReadSwap32();
int n = s->ReadLE32();
fCallbacks.SetCount(n);
for (int i = 0; i < n; i++)
@ -128,7 +128,7 @@ void plMessageWithCallbacks::WriteVersion(hsStream* s, hsResMgr* mgr)
// write count
int n = fCallbacks.GetCount();
s->WriteSwap32(n);
s->WriteLE32(n);
// write callbacks
for (int i = 0; i < n; i++)

152
Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.cpp
View File

@ -840,11 +840,11 @@ void plNotifyMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
// read in the static data
fType = stream->ReadSwap32();
stream->ReadSwap(&fState);
fID = stream->ReadSwap32();
fType = stream->ReadLE32();
stream->ReadLE(&fState);
fID = stream->ReadLE32();
// read in the variable part of the message
Int32 numberEDs = stream->ReadSwap32();
Int32 numberEDs = stream->ReadLE32();
fEvents.SetCountAndZero(numberEDs);
if ( numberEDs > 0 )
{
@ -869,12 +869,12 @@ void plNotifyMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
// write static data
stream->WriteSwap32(fType);
stream->WriteSwap(fState);
stream->WriteSwap32(fID);
stream->WriteLE32(fType);
stream->WriteLE(fState);
stream->WriteLE32(fID);
// then write the variable data
Int32 numberEDs = fEvents.Count();
stream->WriteSwap32(numberEDs);
stream->WriteLE32(numberEDs);
if ( numberEDs > 0 )
{
// write out each record
@ -903,18 +903,18 @@ void plNotifyMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kNotifyMsgType))
fType = s->ReadSwap32();
fType = s->ReadLE32();
if (contentFlags.IsBitSet(kNotifyMsgState))
s->ReadSwap(&fState);
s->ReadLE(&fState);
if (contentFlags.IsBitSet(kNotifyMsgID))
fID = s->ReadSwap32();
fID = s->ReadLE32();
if (contentFlags.IsBitSet(kNotifyMsgEDs))
{
// read in the variable part of the message
Int32 numberEDs = s->ReadSwap32();
Int32 numberEDs = s->ReadLE32();
fEvents.SetCountAndZero(numberEDs);
if (numberEDs > 0)
{
@ -946,17 +946,17 @@ void plNotifyMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kNotifyMsgType
s->WriteSwap32(fType);
s->WriteLE32(fType);
// kNotifyMsgState
s->WriteSwap(fState);
s->WriteLE(fState);
// kNotifyMsgID
s->WriteSwap32(fID);
s->WriteLE32(fID);
// kNotifyMsgEDs
Int32 numberEDs = fEvents.Count();
s->WriteSwap32(numberEDs);
s->WriteLE32(numberEDs);
if (numberEDs > 0)
{
// write out each record
@ -1028,7 +1028,7 @@ proEventData* proEventData::ICreateEventDataType(Int32 type)
proEventData* proEventData::Read( hsStream *stream, hsResMgr *mgr )
{
Int32 evtType = stream->ReadSwap32();
Int32 evtType = stream->ReadLE32();
proEventData* data = ICreateEventDataType(evtType);
@ -1040,7 +1040,7 @@ proEventData* proEventData::Read( hsStream *stream, hsResMgr *mgr )
void proEventData::Write(hsStream *stream, hsResMgr *mgr)
{
stream->WriteSwap32(fEventType);
stream->WriteLE32(fEventType);
IWrite(stream, mgr);
}
@ -1056,7 +1056,7 @@ proEventData* proEventData::ReadVersion(hsStream* s, hsResMgr* mgr)
if (contentFlags.IsBitSet(kProEventDataType))
{
Int32 evtType = s->ReadSwap32();
Int32 evtType = s->ReadLE32();
proEventData* data = ICreateEventDataType(evtType);
@ -1076,7 +1076,7 @@ void proEventData::WriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kProEventDataType
s->WriteSwap32(fEventType);
s->WriteLE32(fEventType);
IWriteVersion(s, mgr);
}
@ -1233,12 +1233,12 @@ void proSpawnedEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
void proControlKeyEventData::IRead(hsStream* stream, hsResMgr* mgr)
{
fControlKey = stream->ReadSwap32();
fControlKey = stream->ReadLE32();
fDown = stream->ReadBool();
}
void proControlKeyEventData::IWrite(hsStream* stream, hsResMgr* mgr)
{
stream->WriteSwap32(fControlKey);
stream->WriteLE32(fControlKey);
stream->WriteBool(fDown);
}
@ -1254,7 +1254,7 @@ void proControlKeyEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kProControlKey))
fControlKey = s->ReadSwap32();
fControlKey = s->ReadLE32();
if (contentFlags.IsBitSet(kProControlDown))
fDown = s->ReadBool();
}
@ -1266,7 +1266,7 @@ void proControlKeyEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kProControlKey
s->WriteSwap32(fControlKey);
s->WriteLE32(fControlKey);
// kProControlDown
s->WriteBool(fDown);
}
@ -1286,16 +1286,16 @@ void proVariableEventData::IDestruct()
void proVariableEventData::IRead(hsStream* stream, hsResMgr* mgr)
{
fName = stream->ReadSafeString();
fDataType = stream->ReadSwap32();
fNumber = stream->ReadSwapScalar();
fDataType = stream->ReadLE32();
fNumber = stream->ReadLEScalar();
fKey = mgr->ReadKey(stream);
}
void proVariableEventData::IWrite(hsStream* stream, hsResMgr* mgr)
{
stream->WriteSafeString(fName);
stream->WriteSwap32(fDataType);
stream->WriteSwapScalar(fNumber);
stream->WriteLE32(fDataType);
stream->WriteLEScalar(fNumber);
mgr->WriteKey(stream, fKey);
}
@ -1315,9 +1315,9 @@ void proVariableEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
if (contentFlags.IsBitSet(kProVariableName))
fName = s->ReadSafeString();
if (contentFlags.IsBitSet(kProVariableDataType))
fDataType = s->ReadSwap32();
fDataType = s->ReadLE32();
if (contentFlags.IsBitSet(kProVariableNumber))
fNumber = s->ReadSwapScalar();
fNumber = s->ReadLEScalar();
if (contentFlags.IsBitSet(kProVariableKey))
fKey = mgr->ReadKey(s);
}
@ -1334,9 +1334,9 @@ void proVariableEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
// kProVariableName
s->WriteSafeString(fName);
// kProVariableDataType
s->WriteSwap32(fDataType);
s->WriteLE32(fDataType);
// kProVariableNumber
s->WriteSwapScalar(fNumber);
s->WriteLEScalar(fNumber);
// kProVariableKey
mgr->WriteKey(s, fKey);
}
@ -1345,7 +1345,7 @@ void proFacingEventData::IRead(hsStream* stream, hsResMgr* mgr)
{
fFacer = mgr->ReadKey(stream);
fFacee = mgr->ReadKey(stream);
dot = stream->ReadSwapScalar();
dot = stream->ReadLEScalar();
enabled = stream->ReadBool();
}
@ -1353,7 +1353,7 @@ void proFacingEventData::IWrite(hsStream* stream, hsResMgr* mgr)
{
mgr->WriteKey(stream, fFacer);
mgr->WriteKey(stream, fFacee);
stream->WriteSwapScalar(dot);
stream->WriteLEScalar(dot);
stream->WriteBool(enabled);
}
@ -1375,7 +1375,7 @@ void proFacingEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
if (contentFlags.IsBitSet(kProFacingFacee))
fFacee = mgr->ReadKey(s);
if (contentFlags.IsBitSet(kProFacingDot))
dot = s->ReadSwapScalar();
dot = s->ReadLEScalar();
if (contentFlags.IsBitSet(kProFacingEnabled))
enabled = s->ReadBool();
}
@ -1394,7 +1394,7 @@ void proFacingEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
// kProFacingFacee
mgr->WriteKey(s, fFacee);
// kProFacingDot
s->WriteSwapScalar(dot);
s->WriteLEScalar(dot);
// kProFacingEnabled
s->WriteBool(enabled);
}
@ -1493,12 +1493,12 @@ void proActivateEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
void proCallbackEventData::IRead(hsStream* stream, hsResMgr* mgr)
{
fEventType = stream->ReadSwap32();
fEventType = stream->ReadLE32();
}
void proCallbackEventData::IWrite(hsStream* stream, hsResMgr* mgr)
{
stream->WriteSwap32(fEventType);
stream->WriteLE32(fEventType);
}
enum ProCallbackFlags
@ -1512,7 +1512,7 @@ void proCallbackEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kProCallbackEventType))
fEventType = s->ReadSwap32();
fEventType = s->ReadLE32();
}
void proCallbackEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
@ -1522,17 +1522,17 @@ void proCallbackEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kProCallbackEventType
s->WriteSwap32(fEventType);
s->WriteLE32(fEventType);
}
void proResponderStateEventData::IRead(hsStream* stream, hsResMgr* mgr)
{
fState = stream->ReadSwap32();
fState = stream->ReadLE32();
}
void proResponderStateEventData::IWrite(hsStream* stream, hsResMgr* mgr)
{
stream->WriteSwap32(fState);
stream->WriteLE32(fState);
}
enum ProResponderFlags
@ -1546,7 +1546,7 @@ void proResponderStateEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kProResponderState))
fState = s->ReadSwap32();
fState = s->ReadLE32();
}
void proResponderStateEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
@ -1556,20 +1556,20 @@ void proResponderStateEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kProResponderState
s->WriteSwap32(fState);
s->WriteLE32(fState);
}
void proMultiStageEventData::IRead(hsStream* stream, hsResMgr* mgr)
{
fStage = stream->ReadSwap32();
fEvent = stream->ReadSwap32();
fStage = stream->ReadLE32();
fEvent = stream->ReadLE32();
fAvatar = mgr->ReadKey(stream);
}
void proMultiStageEventData::IWrite(hsStream* stream, hsResMgr* mgr)
{
stream->WriteSwap32(fStage);
stream->WriteSwap32(fEvent);
stream->WriteLE32(fStage);
stream->WriteLE32(fEvent);
mgr->WriteKey(stream, fAvatar);
}
@ -1586,9 +1586,9 @@ void proMultiStageEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kProMultiStageStage))
fStage = s->ReadSwap32();
fStage = s->ReadLE32();
if (contentFlags.IsBitSet(kProMultiStageEvent))
fEvent = s->ReadSwap32();
fEvent = s->ReadLE32();
if (contentFlags.IsBitSet(kProMultiStageAvatar))
fAvatar = mgr->ReadKey(s);
}
@ -1602,23 +1602,23 @@ void proMultiStageEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kProMultiStageStage
s->WriteSwap32(fStage);
s->WriteLE32(fStage);
// kProMultiStageEvent
s->WriteSwap32(fEvent);
s->WriteLE32(fEvent);
// kProMultiStageAvatar
mgr->WriteKey(s, fAvatar);
}
void proCoopEventData::IRead(hsStream* stream, hsResMgr* mgr)
{
fID = stream->ReadSwap32();
fSerial = stream->ReadSwap16();
fID = stream->ReadLE32();
fSerial = stream->ReadLE16();
}
void proCoopEventData::IWrite(hsStream* stream, hsResMgr* mgr)
{
stream->WriteSwap32(fID);
stream->WriteSwap16(fSerial);
stream->WriteLE32(fID);
stream->WriteLE16(fSerial);
}
enum ProCoopFlags
@ -1633,9 +1633,9 @@ void proCoopEventData::IReadVersion(hsStream* stream, hsResMgr* mgr)
contentFlags.Read(stream);
if(contentFlags.IsBitSet(kProCoopID))
fID = stream->ReadSwap32();
fID = stream->ReadLE32();
if(contentFlags.IsBitSet(kProCoopSerial))
fSerial = stream->ReadSwap16();
fSerial = stream->ReadLE16();
}
void proCoopEventData::IWriteVersion(hsStream* stream, hsResMgr* mgr)
@ -1645,23 +1645,23 @@ void proCoopEventData::IWriteVersion(hsStream* stream, hsResMgr* mgr)
contentFlags.SetBit(kProCoopSerial);
contentFlags.Write(stream);
stream->WriteSwap32(fID);
stream->WriteSwap16(fSerial);
stream->WriteLE32(fID);
stream->WriteLE16(fSerial);
}
void proOfferLinkingBookEventData::IWrite(hsStream* stream, hsResMgr* mgr)
{
mgr->WriteKey(stream, offerer);
stream->WriteSwap32(targetAge);
stream->WriteSwap32(offeree);
stream->WriteLE32(targetAge);
stream->WriteLE32(offeree);
}
void proOfferLinkingBookEventData::IRead(hsStream* stream, hsResMgr* mgr)
{
offerer = mgr->ReadKey(stream);
targetAge = stream->ReadSwap32();
offeree = stream->ReadSwap32();
targetAge = stream->ReadLE32();
offeree = stream->ReadLE32();
}
enum ProOfferFlags
@ -1680,8 +1680,8 @@ void proOfferLinkingBookEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
mgr->WriteKey(s, offerer);
s->WriteSwap32(targetAge);
s->WriteSwap32(offeree);
s->WriteLE32(targetAge);
s->WriteLE32(offeree);
}
void proOfferLinkingBookEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
@ -1692,21 +1692,21 @@ void proOfferLinkingBookEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
if(contentFlags.IsBitSet(kProOfferOfferer))
offerer = mgr->ReadKey(s);
if(contentFlags.IsBitSet(kProOfferTargetAge))
targetAge = s->ReadSwap32();
targetAge = s->ReadLE32();
if(contentFlags.IsBitSet(kProOfferOfferee))
offeree = s->ReadSwap32();
offeree = s->ReadLE32();
}
void proBookEventData::IWrite(hsStream* stream, hsResMgr* mgr)
{
stream->WriteSwap32(fEvent);
stream->WriteSwap32(fLinkID);
stream->WriteLE32(fEvent);
stream->WriteLE32(fLinkID);
}
void proBookEventData::IRead(hsStream* stream, hsResMgr* mgr)
{
fEvent = stream->ReadSwap32();
fLinkID = stream->ReadSwap32();
fEvent = stream->ReadLE32();
fLinkID = stream->ReadLE32();
}
enum ProBookFlags
@ -1722,8 +1722,8 @@ void proBookEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.SetBit(kProBookLinkID);
contentFlags.Write(s);
s->WriteSwap32( fEvent );
s->WriteSwap32( fLinkID );
s->WriteLE32( fEvent );
s->WriteLE32( fLinkID );
}
void proBookEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
@ -1732,9 +1732,9 @@ void proBookEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if(contentFlags.IsBitSet(kProBookEvent))
fEvent = s->ReadSwap32();
fEvent = s->ReadLE32();
if(contentFlags.IsBitSet(kProBookLinkID))
fLinkID = s->ReadSwap32();
fLinkID = s->ReadLE32();
}

8
Sources/Plasma/NucleusLib/pnMessage/plObjRefMsg.h
View File

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

4
Sources/Plasma/NucleusLib/pnMessage/plPlayerPageMsg.h
View File

@ -77,7 +77,7 @@ public:
fLocallyOriginated = stream->ReadBool();
fLastOut = stream->ReadBool();
fUnload = stream->ReadBool();
fClientID = stream->ReadSwap32();
fClientID = stream->ReadLE32();
}
void Write(hsStream* stream, hsResMgr* mgr)
{
@ -86,7 +86,7 @@ public:
stream->WriteBool(fLocallyOriginated);
stream->WriteBool(fLastOut);
stream->WriteBool(fUnload);
stream->WriteSwap32(fClientID);
stream->WriteLE32(fClientID);
}
};

4
Sources/Plasma/NucleusLib/pnMessage/plProxyDrawMsg.cpp
View File

@ -71,11 +71,11 @@ plProxyDrawMsg::~plProxyDrawMsg()
void plProxyDrawMsg::Read(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgRead(s, mgr);
fProxyFlags = s->ReadSwap16();
fProxyFlags = s->ReadLE16();
}
void plProxyDrawMsg::Write(hsStream* s, hsResMgr* mgr)
{
plMessage::IMsgWrite(s, mgr);
s->WriteSwap16(fProxyFlags);
s->WriteLE16(fProxyFlags);
}

12
Sources/Plasma/NucleusLib/pnMessage/plRefMsg.cpp
View File

@ -81,7 +81,7 @@ plRefMsg& plRefMsg::SetOldRef(hsKeyedObject* oldRef)
void plRefMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
stream->ReadSwap(&fContext);
stream->ReadLE(&fContext);
plKey key;
key = mgr->ReadKey(stream);
@ -93,7 +93,7 @@ void plRefMsg::Read(hsStream* stream, hsResMgr* mgr)
void plRefMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap(fContext);
stream->WriteLE(fContext);
mgr->WriteKey(stream, (fRef ? fRef->GetKey() : nil));
mgr->WriteKey(stream, (fOldRef ? fOldRef->GetKey() : nil));
@ -103,13 +103,13 @@ void plRefMsg::Write(hsStream* stream, hsResMgr* mgr)
void plGenRefMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plRefMsg::Read(stream, mgr);
stream->ReadSwap(&fType);
fWhich = stream->ReadSwap32();
stream->ReadLE(&fType);
fWhich = stream->ReadLE32();
}
void plGenRefMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plRefMsg::Write(stream, mgr);
stream->WriteSwap(fType);
stream->WriteSwap32(fWhich);
stream->WriteLE(fType);
stream->WriteLE32(fWhich);
}

8
Sources/Plasma/NucleusLib/pnMessage/plServerReplyMsg.cpp
View File

@ -46,13 +46,13 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
void plServerReplyMsg::Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
stream->ReadSwap(&fType);
stream->ReadLE(&fType);
}
void plServerReplyMsg::Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap(fType);
stream->WriteLE(fType);
}
enum ServerReplyFlags
@ -68,7 +68,7 @@ void plServerReplyMsg::ReadVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Read(s);
if (contentFlags.IsBitSet(kServerReplyType))
s->ReadSwap(&fType);
s->ReadLE(&fType);
}
void plServerReplyMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
@ -80,5 +80,5 @@ void plServerReplyMsg::WriteVersion(hsStream* s, hsResMgr* mgr)
contentFlags.Write(s);
// kServerReplyType
s->WriteSwap(fType);
s->WriteLE(fType);
}

32
Sources/Plasma/NucleusLib/pnMessage/plSoundMsg.cpp
View File

@ -62,16 +62,16 @@ void plSoundMsg::Read(hsStream* stream, hsResMgr* mgr)
plMessageWithCallbacks::Read(stream, mgr);
fCmd.Read(stream);
stream->ReadSwap(&fBegin);
stream->ReadSwap(&fEnd);
stream->ReadLE(&fBegin);
stream->ReadLE(&fEnd);
fLoop = stream->ReadBool();
fPlaying = stream->ReadBool();
stream->ReadSwap(&fSpeed);
stream->ReadSwap(&fTime);
stream->ReadSwap(&fIndex);
stream->ReadSwap(&fRepeats);
stream->ReadSwap(&fNameStr);
stream->ReadSwap(&fVolume);
stream->ReadLE(&fSpeed);
stream->ReadLE(&fTime);
stream->ReadLE(&fIndex);
stream->ReadLE(&fRepeats);
stream->ReadLE(&fNameStr);
stream->ReadLE(&fVolume);
fFadeType = (plSoundMsg::FadeType)stream->ReadByte();
}
@ -80,15 +80,15 @@ void plSoundMsg::Write(hsStream* stream, hsResMgr* mgr)
plMessageWithCallbacks::Write(stream, mgr);
fCmd.Write(stream);
stream->WriteSwap(fBegin);
stream->WriteSwap(fEnd);
stream->WriteLE(fBegin);
stream->WriteLE(fEnd);
stream->WriteBool(fLoop);
stream->WriteBool(fPlaying);
stream->WriteSwap(fSpeed);
stream->WriteSwap(fTime);
stream->WriteSwap(fIndex);
stream->WriteSwap(fRepeats);
stream->WriteSwap(fNameStr);
stream->WriteSwap(fVolume);
stream->WriteLE(fSpeed);
stream->WriteLE(fTime);
stream->WriteLE(fIndex);
stream->WriteLE(fRepeats);
stream->WriteLE(fNameStr);
stream->WriteLE(fVolume);
stream->WriteByte( (UInt8)fFadeType );
}

8
Sources/Plasma/NucleusLib/pnMessage/plTimeMsg.h
View File

@ -72,15 +72,15 @@ public:
void Read(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgRead(stream, mgr);
stream->ReadSwap(&fSeconds);
stream->ReadSwap(&fDelSecs);
stream->ReadLE(&fSeconds);
stream->ReadLE(&fDelSecs);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
stream->WriteSwap(fSeconds);
stream->WriteSwap(fDelSecs);
stream->WriteLE(fSeconds);
stream->WriteLE(fDelSecs);
}
};

4
Sources/Plasma/NucleusLib/pnMessage/plWarpMsg.h
View File

@ -86,14 +86,14 @@ public:
{
plMessage::IMsgRead(stream, mgr);
fTransform.Read(stream);
stream->ReadSwap(&fWarpFlags);
stream->ReadLE(&fWarpFlags);
}
void Write(hsStream* stream, hsResMgr* mgr)
{
plMessage::IMsgWrite(stream, mgr);
fTransform.Write(stream);
stream->WriteSwap(fWarpFlags);
stream->WriteLE(fWarpFlags);
}
};