OU/CWE-ou-minkata
1
0
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-18 19:29:09 +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

80
Sources/Plasma/PubUtilLib/plInterp/hsKeys.cpp
View File

@ -48,13 +48,13 @@ const int hsKeyFrame::kMaxFrameNumber = 65535;
void hsPoint3Key::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fFrame = stream->ReadLE16();
fValue.Read(stream);
}
void hsPoint3Key::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteLE16(fFrame);
fValue.Write(stream);
}
@ -67,7 +67,7 @@ hsBool hsPoint3Key::CompareValue(hsPoint3Key *key)
void hsBezPoint3Key::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fFrame = stream->ReadLE16();
fInTan.Read(stream);
fOutTan.Read(stream);
fValue.Read(stream);
@ -75,7 +75,7 @@ void hsBezPoint3Key::Read(hsStream *stream)
void hsBezPoint3Key::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteLE16(fFrame);
fInTan.Write(stream);
fOutTan.Write(stream);
fValue.Write(stream);
@ -92,14 +92,14 @@ hsBool hsBezPoint3Key::CompareValue(hsBezPoint3Key *key)
void hsScalarKey::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fValue = stream->ReadSwapScalar();
fFrame = stream->ReadLE16();
fValue = stream->ReadLEScalar();
}
void hsScalarKey::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteSwapScalar(fValue);
stream->WriteLE16(fFrame);
stream->WriteLEScalar(fValue);
}
hsBool hsScalarKey::CompareValue(hsScalarKey *key)
@ -109,18 +109,18 @@ hsBool hsScalarKey::CompareValue(hsScalarKey *key)
void hsBezScalarKey::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fInTan = stream->ReadSwapScalar();
fOutTan = stream->ReadSwapScalar();
fValue = stream->ReadSwapScalar();
fFrame = stream->ReadLE16();
fInTan = stream->ReadLEScalar();
fOutTan = stream->ReadLEScalar();
fValue = stream->ReadLEScalar();
}
void hsBezScalarKey::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteSwapScalar(fInTan);
stream->WriteSwapScalar(fOutTan);
stream->WriteSwapScalar(fValue);
stream->WriteLE16(fFrame);
stream->WriteLEScalar(fInTan);
stream->WriteLEScalar(fOutTan);
stream->WriteLEScalar(fValue);
}
hsBool hsBezScalarKey::CompareValue(hsBezScalarKey *key)
@ -132,13 +132,13 @@ hsBool hsBezScalarKey::CompareValue(hsBezScalarKey *key)
void hsQuatKey::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fFrame = stream->ReadLE16();
fValue.Read(stream);
}
void hsQuatKey::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteLE16(fFrame);
fValue.Write(stream);
}
@ -154,14 +154,14 @@ const hsScalar hsCompressedQuatKey32::k10BitScaleRange = 1023 / (2 * kOneOverRoo
void hsCompressedQuatKey32::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fData = stream->ReadSwap32();
fFrame = stream->ReadLE16();
fData = stream->ReadLE32();
}
void hsCompressedQuatKey32::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteSwap32(fData);
stream->WriteLE16(fFrame);
stream->WriteLE32(fData);
}
hsBool hsCompressedQuatKey32::CompareValue(hsCompressedQuatKey32 *key)
@ -295,16 +295,16 @@ const hsScalar hsCompressedQuatKey64::k21BitScaleRange = 2097151 / (2 * kOneOver
void hsCompressedQuatKey64::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fData[0] = stream->ReadSwap32();
fData[1] = stream->ReadSwap32();
fFrame = stream->ReadLE16();
fData[0] = stream->ReadLE32();
fData[1] = stream->ReadLE32();
}
void hsCompressedQuatKey64::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteSwap32(fData[0]);
stream->WriteSwap32(fData[1]);
stream->WriteLE16(fFrame);
stream->WriteLE32(fData[0]);
stream->WriteLE32(fData[1]);
}
hsBool hsCompressedQuatKey64::CompareValue(hsCompressedQuatKey64 *key)
@ -456,13 +456,13 @@ void hsScaleValue::Write(hsStream *stream)
/////////////////////////////////////////
void hsScaleKey::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fFrame = stream->ReadLE16();
fValue.Read(stream);
}
void hsScaleKey::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteLE16(fFrame);
fValue.Write(stream);
}
@ -473,7 +473,7 @@ hsBool hsScaleKey::CompareValue(hsScaleKey *key)
void hsBezScaleKey::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fFrame = stream->ReadLE16();
fInTan.Read(stream);
fOutTan.Read(stream);
fValue.Read(stream);
@ -481,7 +481,7 @@ void hsBezScaleKey::Read(hsStream *stream)
void hsBezScaleKey::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteLE16(fFrame);
fInTan.Write(stream);
fOutTan.Write(stream);
fValue.Write(stream);
@ -510,13 +510,13 @@ void hsG3DSMaxKeyFrame::Set(const hsAffineParts &parts, UInt16 frame)
void hsG3DSMaxKeyFrame::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fFrame = stream->ReadLE16();
fParts.Read(stream);
}
void hsG3DSMaxKeyFrame::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteLE16(fFrame);
fParts.Write(stream);
}
@ -529,20 +529,20 @@ hsBool hsG3DSMaxKeyFrame::CompareValue(hsG3DSMaxKeyFrame *key)
void hsMatrix33Key::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fFrame = stream->ReadLE16();
Int32 i,j;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
fValue.fMap[j][i] = stream->ReadSwapScalar();
fValue.fMap[j][i] = stream->ReadLEScalar();
}
void hsMatrix33Key::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteLE16(fFrame);
Int32 i,j;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
stream->WriteSwapScalar(fValue.fMap[j][i]);
stream->WriteLEScalar(fValue.fMap[j][i]);
}
hsBool hsMatrix33Key::CompareValue(hsMatrix33Key *key)
@ -554,13 +554,13 @@ hsBool hsMatrix33Key::CompareValue(hsMatrix33Key *key)
void hsMatrix44Key::Read(hsStream *stream)
{
fFrame = stream->ReadSwap16();
fFrame = stream->ReadLE16();
fValue.Read(stream);
}
void hsMatrix44Key::Write(hsStream *stream)
{
stream->WriteSwap16(fFrame);
stream->WriteLE16(fFrame);
fValue.Write(stream);
}

36
Sources/Plasma/PubUtilLib/plInterp/hsTimedValue.h
View File

@ -100,31 +100,31 @@ public:
template <class T>
void hsTimedValue<T>::WriteScalar(hsStream* s, hsScalar currSecs)
{
s->WriteSwap32(fFlags);
s->WriteLE32(fFlags);
s->WriteSwapScalar(fValue);
s->WriteLEScalar(fValue);
if( !(fFlags & kIdle) )
{
s->WriteSwapScalar(fDuration);
s->WriteSwapScalar(currSecs - fStartTime);
s->WriteLEScalar(fDuration);
s->WriteLEScalar(currSecs - fStartTime);
s->WriteSwapScalar(fGoal);
s->WriteSwapScalar(fFrom);
s->WriteLEScalar(fGoal);
s->WriteLEScalar(fFrom);
}
}
template <class T>
void hsTimedValue<T>::Write(hsStream* s, hsScalar currSecs)
{
s->WriteSwap32(fFlags);
s->WriteLE32(fFlags);
fValue.Write(s);
if( !(fFlags & kIdle) )
{
s->WriteSwapScalar(fDuration);
s->WriteSwapScalar(currSecs - fStartTime);
s->WriteLEScalar(fDuration);
s->WriteLEScalar(currSecs - fStartTime);
fGoal.Write(s);
fFrom.Write(s);
@ -134,31 +134,31 @@ void hsTimedValue<T>::Write(hsStream* s, hsScalar currSecs)
template <class T>
void hsTimedValue<T>::ReadScalar(hsStream* s, hsScalar currSecs)
{
fFlags = s->ReadSwap32();
fFlags = s->ReadLE32();
fValue = s->ReadSwapScalar();
fValue = s->ReadLEScalar();
if( !(fFlags & kIdle) )
{
fDuration = s->ReadSwapScalar();
fStartTime = currSecs - s->ReadSwapScalar();
fDuration = s->ReadLEScalar();
fStartTime = currSecs - s->ReadLEScalar();
fGoal = s->ReadSwapScalar();
fFrom = s->ReadSwapScalar();
fGoal = s->ReadLEScalar();
fFrom = s->ReadLEScalar();
}
}
template <class T>
void hsTimedValue<T>::Read(hsStream* s, hsScalar currSecs)
{
fFlags = s->ReadSwap32();
fFlags = s->ReadLE32();
fValue.Read(s);
if( !(fFlags & kIdle) )
{
fDuration = s->ReadSwapScalar();
fStartTime = currSecs - s->ReadSwapScalar();
fDuration = s->ReadLEScalar();
fStartTime = currSecs - s->ReadLEScalar();
fGoal.Read(s);
fFrom.Read(s);

40
Sources/Plasma/PubUtilLib/plInterp/plATCEaseCurves.cpp
View File

@ -119,24 +119,24 @@ void plATCEaseCurve::Read(hsStream *s, hsResMgr *mgr)
{
plCreatable::Read(s, mgr);
fMinLength = s->ReadSwapScalar();
fMaxLength = s->ReadSwapScalar();
fNormLength = fLength = s->ReadSwapScalar();
fStartSpeed = s->ReadSwapScalar();
fSpeed = s->ReadSwapScalar();
fBeginWorldTime = s->ReadSwapDouble();
fMinLength = s->ReadLEScalar();
fMaxLength = s->ReadLEScalar();
fNormLength = fLength = s->ReadLEScalar();
fStartSpeed = s->ReadLEScalar();
fSpeed = s->ReadLEScalar();
fBeginWorldTime = s->ReadLEDouble();
}
void plATCEaseCurve::Write(hsStream *s, hsResMgr *mgr)
{
plCreatable::Write(s, mgr);
s->WriteSwapScalar(fMinLength);
s->WriteSwapScalar(fMaxLength);
s->WriteSwapScalar(fNormLength);
s->WriteSwapScalar(fStartSpeed);
s->WriteSwapScalar(fSpeed);
s->WriteSwapDouble(fBeginWorldTime);
s->WriteLEScalar(fMinLength);
s->WriteLEScalar(fMaxLength);
s->WriteLEScalar(fNormLength);
s->WriteLEScalar(fStartSpeed);
s->WriteLEScalar(fSpeed);
s->WriteLEDouble(fBeginWorldTime);
}
///////////////////////////////////////////////////////////////////////////////////////////////
@ -345,19 +345,19 @@ void plSplineEaseCurve::Read(hsStream *s, hsResMgr *mgr)
{
plATCEaseCurve::Read(s, mgr);
fCoef[0] = s->ReadSwapScalar();
fCoef[1] = s->ReadSwapScalar();
fCoef[2] = s->ReadSwapScalar();
fCoef[3] = s->ReadSwapScalar();
fCoef[0] = s->ReadLEScalar();
fCoef[1] = s->ReadLEScalar();
fCoef[2] = s->ReadLEScalar();
fCoef[3] = s->ReadLEScalar();
}
void plSplineEaseCurve::Write(hsStream *s, hsResMgr *mgr)
{
plATCEaseCurve::Write(s, mgr);
s->WriteSwapScalar(fCoef[0]);
s->WriteSwapScalar(fCoef[1]);
s->WriteSwapScalar(fCoef[2]);
s->WriteSwapScalar(fCoef[3]);
s->WriteLEScalar(fCoef[0]);
s->WriteLEScalar(fCoef[1]);
s->WriteLEScalar(fCoef[2]);
s->WriteLEScalar(fCoef[3]);
}

12
Sources/Plasma/PubUtilLib/plInterp/plAnimPath.cpp
View File

@ -188,7 +188,7 @@ void plAnimPath::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
void plAnimPath::Read(hsStream* stream, hsResMgr* mgr)
{
fAnimPathFlags=stream->ReadSwap32();
fAnimPathFlags=stream->ReadLE32();
delete fController;
fController = plCompoundController::ConvertNoRef(mgr->ReadCreatable(stream));
@ -200,15 +200,15 @@ void plAnimPath::Read(hsStream* stream, hsResMgr* mgr)
fLocalToWorld.Read(stream);
fWorldToLocal.Read(stream);
fLength = stream->ReadSwapScalar();
fMinDistSq = stream->ReadSwapScalar();
fLength = stream->ReadLEScalar();
fMinDistSq = stream->ReadLEScalar();
Reset();
}
void plAnimPath::Write(hsStream* stream, hsResMgr* mgr)
{
stream->WriteSwap32(fAnimPathFlags);
stream->WriteLE32(fAnimPathFlags);
mgr->WriteCreatable(stream, fController);
@ -217,8 +217,8 @@ void plAnimPath::Write(hsStream* stream, hsResMgr* mgr)
fLocalToWorld.Write(stream);
fWorldToLocal.Write(stream);
stream->WriteSwapScalar(fLength);
stream->WriteSwapScalar(fMinDistSq);
stream->WriteLEScalar(fLength);
stream->WriteLEScalar(fMinDistSq);
}
hsBool plAnimPath::OutOfRange(hsPoint3 &worldPt, hsScalar range) const

76
Sources/Plasma/PubUtilLib/plInterp/plAnimTimeConvert.cpp
View File

@ -889,23 +889,23 @@ void plAnimTimeConvert::Read(hsStream* s, hsResMgr* mgr)
{
plCreatable::Read(s, mgr);
fFlags = (UInt16)(s->ReadSwap32());
fFlags = (UInt16)(s->ReadLE32());
fBegin = fInitialBegin = s->ReadSwapScalar();
fEnd = fInitialEnd = s->ReadSwapScalar();
fLoopEnd = s->ReadSwapScalar();
fLoopBegin = s->ReadSwapScalar();
fSpeed = s->ReadSwapScalar();
fBegin = fInitialBegin = s->ReadLEScalar();
fEnd = fInitialEnd = s->ReadLEScalar();
fLoopEnd = s->ReadLEScalar();
fLoopBegin = s->ReadLEScalar();
fSpeed = s->ReadLEScalar();
fEaseInCurve = plATCEaseCurve::ConvertNoRef(mgr->ReadCreatable(s));
fEaseOutCurve = plATCEaseCurve::ConvertNoRef(mgr->ReadCreatable(s));
fSpeedEaseCurve = plATCEaseCurve::ConvertNoRef(mgr->ReadCreatable(s));
fCurrentAnimTime = s->ReadSwapScalar();
fLastEvalWorldTime = s->ReadSwapDouble();
fCurrentAnimTime = s->ReadLEScalar();
fLastEvalWorldTime = s->ReadLEDouble();
// load other non-synched data;
int count = s->ReadSwap32();
int count = s->ReadLE32();
fCallbackMsgs.SetCountAndZero(count);
int i;
@ -915,10 +915,10 @@ void plAnimTimeConvert::Read(hsStream* s, hsResMgr* mgr)
fCallbackMsgs[i] = msg;
}
count = s->ReadSwap32();
count = s->ReadLE32();
for (i = 0; i < count; i++)
{
fStopPoints.Append(s->ReadSwapScalar());
fStopPoints.Append(s->ReadLEScalar());
}
IProcessStateChange(0, fBegin);
}
@ -927,31 +927,31 @@ void plAnimTimeConvert::Write(hsStream* s, hsResMgr* mgr)
{
plCreatable::Write(s, mgr);
s->WriteSwap32(fFlags);
s->WriteLE32(fFlags);
s->WriteSwapScalar(fBegin);
s->WriteSwapScalar(fEnd);
s->WriteSwapScalar(fLoopEnd);
s->WriteSwapScalar(fLoopBegin);
s->WriteSwapScalar(fSpeed);
s->WriteLEScalar(fBegin);
s->WriteLEScalar(fEnd);
s->WriteLEScalar(fLoopEnd);
s->WriteLEScalar(fLoopBegin);
s->WriteLEScalar(fSpeed);
mgr->WriteCreatable(s, fEaseInCurve);
mgr->WriteCreatable(s, fEaseOutCurve);
mgr->WriteCreatable(s, fSpeedEaseCurve);
s->WriteSwapScalar(fCurrentAnimTime);
s->WriteSwapDouble(fLastEvalWorldTime);
s->WriteLEScalar(fCurrentAnimTime);
s->WriteLEDouble(fLastEvalWorldTime);
// save out other non-synched important data
s->WriteSwap32(fCallbackMsgs.Count());
s->WriteLE32(fCallbackMsgs.Count());
int i;
for (i = 0; i < fCallbackMsgs.Count(); i++)
mgr->WriteCreatable(s, fCallbackMsgs[i]);
s->WriteSwap32(fStopPoints.GetCount());
s->WriteLE32(fStopPoints.GetCount());
for (i = 0; i < fStopPoints.GetCount(); i++)
{
s->WriteSwapScalar(fStopPoints.Get(i));
s->WriteLEScalar(fStopPoints.Get(i));
}
}
@ -1347,30 +1347,30 @@ void plAnimTimeConvert::EnableCallbacks(hsBool val)
void plATCState::Read(hsStream *s, hsResMgr *mgr)
{
fStartWorldTime = s->ReadSwapDouble();
fStartAnimTime = s->ReadSwapScalar();
fStartWorldTime = s->ReadLEDouble();
fStartAnimTime = s->ReadLEScalar();
fFlags = (UInt8)(s->ReadSwap32());
fEnd = s->ReadSwapScalar();
fLoopBegin = s->ReadSwapScalar();
fLoopEnd = s->ReadSwapScalar();
fSpeed = s->ReadSwapScalar();
fWrapTime = s->ReadSwapScalar();
fFlags = (UInt8)(s->ReadLE32());
fEnd = s->ReadLEScalar();
fLoopBegin = s->ReadLEScalar();
fLoopEnd = s->ReadLEScalar();
fSpeed = s->ReadLEScalar();
fWrapTime = s->ReadLEScalar();
if (s->ReadBool())
fEaseCurve = plATCEaseCurve::ConvertNoRef(mgr->ReadCreatable(s));
}
void plATCState::Write(hsStream *s, hsResMgr *mgr)
{
s->WriteSwapDouble(fStartWorldTime);
s->WriteSwapScalar(fStartAnimTime);
s->WriteLEDouble(fStartWorldTime);
s->WriteLEScalar(fStartAnimTime);
s->WriteSwap32(fFlags);
s->WriteSwapScalar(fEnd);
s->WriteSwapScalar(fLoopBegin);
s->WriteSwapScalar(fLoopEnd);
s->WriteSwapScalar(fSpeed);
s->WriteSwapScalar(fWrapTime);
s->WriteLE32(fFlags);
s->WriteLEScalar(fEnd);
s->WriteLEScalar(fLoopBegin);
s->WriteLEScalar(fLoopEnd);
s->WriteLEScalar(fSpeed);
s->WriteLEScalar(fWrapTime);
if (fEaseCurve != nil)
{
s->WriteBool(true);

4
Sources/Plasma/PubUtilLib/plInterp/plController.cpp
View File

@ -605,7 +605,7 @@ hsBool plLeafController::PurgeRedundantSubcontrollers()
void plLeafController::Read(hsStream* s, hsResMgr *mgr)
{
UInt8 type = s->ReadByte();
UInt32 numKeys = s->ReadSwap32();
UInt32 numKeys = s->ReadLE32();
AllocKeys(numKeys, type);
int i;
@ -681,7 +681,7 @@ void plLeafController::Read(hsStream* s, hsResMgr *mgr)
void plLeafController::Write(hsStream* s, hsResMgr *mgr)
{
s->WriteByte(fType);
s->WriteSwap32(fNumKeys);
s->WriteLE32(fNumKeys);
int i;
switch (fType)

4
Sources/Plasma/PubUtilLib/plInterp/plModulator.cpp
View File

@ -111,13 +111,13 @@ hsScalar plModulator::Modulation(const hsPoint3& pos) const
void plModulator::Read(hsStream* s, hsResMgr* mgr)
{
fVolume = plVolumeIsect::ConvertNoRef(mgr->ReadCreatable(s));
fSoftDist = s->ReadSwapScalar();
fSoftDist = s->ReadLEScalar();
}
void plModulator::Write(hsStream* s, hsResMgr* mgr)
{
mgr->WriteCreatable(s, fVolume);
s->WriteSwapScalar(fSoftDist);
s->WriteLEScalar(fSoftDist);
}