OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
Browse Source

Remove unused platform code (MacOS9, PS2, XBox).

Joseph Davies 13 years ago
parent
7dd9b30452
commit
29de5fbc07
32 changed files with 96 additions and 910 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      Sources/Plasma/CoreLib/CMakeLists.txt
  2. 16
      Sources/Plasma/CoreLib/HeadSpin.cpp
  3. 4
      Sources/Plasma/CoreLib/hsBounds.cpp
  4. 6
      Sources/Plasma/CoreLib/hsConfig.h
  5. 24
      Sources/Plasma/CoreLib/hsFixedTypes.h
  6. 8
      Sources/Plasma/CoreLib/hsGeometry3.h
  7. 40
      Sources/Plasma/CoreLib/hsMatrix44.cpp
  8. 22
      Sources/Plasma/CoreLib/hsMemory.cpp
  9. 4
      Sources/Plasma/CoreLib/hsMemory.h
  10. 6
      Sources/Plasma/CoreLib/hsPoint2.h
  11. 193
      Sources/Plasma/CoreLib/hsStream.cpp
  12. 11
      Sources/Plasma/CoreLib/hsStream.h
  13. 31
      Sources/Plasma/CoreLib/hsThread.h
  14. 161
      Sources/Plasma/CoreLib/hsUtils.cpp
  15. 13
      Sources/Plasma/CoreLib/hsUtils.h
  16. 10
      Sources/Plasma/CoreLib/hsWindowHndl.h
  17. 34
      Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.cpp
  18. 4
      Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizedString.cpp
  19. 5
      Sources/Plasma/FeatureLib/pfPython/pyEnum.cpp
  20. 68
      Sources/Plasma/NucleusLib/pnTimer/hsTimer.cpp
  21. 2
      Sources/Plasma/PubUtilLib/plContainer/hsStringTable.cpp
  22. 4
      Sources/Plasma/PubUtilLib/plFile/CMakeLists.txt
  23. 6
      Sources/Plasma/PubUtilLib/plFile/hsFiles.cpp
  24. 55
      Sources/Plasma/PubUtilLib/plFile/hsFiles.h
  25. 221
      Sources/Plasma/PubUtilLib/plGImage/hsDXTSoftwareCodec.cpp
  26. 5
      Sources/Plasma/PubUtilLib/plGImage/hsDXTSoftwareCodec.h
  27. 20
      Sources/Plasma/PubUtilLib/plGImage/hsRect.h
  28. 4
      Sources/Plasma/PubUtilLib/plPipeline/hsWinRef.h
  29. 12
      Sources/Plasma/PubUtilLib/plPipeline/plDXEnumerate.cpp
  30. 2
      Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.cpp
  31. 4
      Sources/Plasma/PubUtilLib/plPipeline/plDXTextFont.cpp
  32. 3
      Sources/Plasma/PubUtilLib/plTransform/mat_decomp.cpp

8
Sources/Plasma/CoreLib/CMakeLists.txt
Unescape View File

@ -40,14 +40,6 @@ if(UNIX)
) )
endif(UNIX) endif(UNIX)
# for now we use the Unix file on mac... I think this is Carbon code, which
# we don't want to use. I don't think it's worth support OS9 anymore
#if(APPLE)
# set(CoreLib_SOURCES ${CoreLib_SOURCES}
# hsThread_Mac.cpp
# )
#endif(APPLE)
set(CoreLib_HEADERS set(CoreLib_HEADERS
HeadSpin.h HeadSpin.h

16
Sources/Plasma/CoreLib/HeadSpin.cpp
Unescape View File

@ -46,12 +46,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsExceptions.h" #include "hsExceptions.h"
#if HS_BUILD_FOR_MAC
#include <Events.h>
#include <ToolUtils.h>
#include <Windows.h>
#endif
#if HS_BUILD_FOR_WIN32 #if HS_BUILD_FOR_WIN32
#ifdef _MSC_VER #ifdef _MSC_VER
# include <crtdbg.h> /* for _RPT_BASE */ # include <crtdbg.h> /* for _RPT_BASE */
@ -108,9 +102,7 @@ void hsDebugMessage (const char message[], long val)
if (gHSDebugProc) if (gHSDebugProc)
gHSDebugProc(&s[1]); gHSDebugProc(&s[1]);
else else
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
DebugStr((unsigned char*)s);
#elif HS_BUILD_FOR_WIN32
{ OutputDebugString(&s[1]); { OutputDebugString(&s[1]);
OutputDebugString("\n"); OutputDebugString("\n");
} }
@ -118,8 +110,6 @@ void hsDebugMessage (const char message[], long val)
{ fprintf(stderr, "%s\n", &s[1]); { fprintf(stderr, "%s\n", &s[1]);
// hsThrow(&s[1]); // hsThrow(&s[1]);
} }
#elif HS_BUILD_FOR_PS2
fprintf(stderr, "%s\n", &s[1]);
#else #else
hsThrow(&s[1]); hsThrow(&s[1]);
#endif #endif
@ -160,7 +150,7 @@ void hsStatusMessage(const char message[])
if (gHSStatusProc) { if (gHSStatusProc) {
gHSStatusProc(message); gHSStatusProc(message);
} else { } else {
#if HS_BUILD_FOR_PS2 || HS_BUILD_FOR_UNIX #if HS_BUILD_FOR_UNIX
printf("%s",message); printf("%s",message);
int len = strlen(message); int len = strlen(message);
if (len>0 && message[len-1]!='\n') if (len>0 && message[len-1]!='\n')
@ -170,7 +160,7 @@ void hsStatusMessage(const char message[])
int len = strlen(message); int len = strlen(message);
if (len>0 && message[len-1]!='\n') if (len>0 && message[len-1]!='\n')
OutputDebugString("\n"); OutputDebugString("\n");
#endif // MAC ?????? TODO #endif
} }
} }

4
Sources/Plasma/CoreLib/hsBounds.cpp
Unescape View File

@ -46,10 +46,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsFastMath.h" #include "hsFastMath.h"
#if defined(__MWERKS__) && !defined(HS_DEBUGGING)
#pragma optimization_level 2
#endif
const hsScalar hsBounds::kRealSmall = 1.0e-5f; const hsScalar hsBounds::kRealSmall = 1.0e-5f;
/////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////

6
Sources/Plasma/CoreLib/hsConfig.h
Unescape View File

@ -62,11 +62,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
//////////////////// Specific Compiler Stuff This Section is computed //////////// //////////////////// Specific Compiler Stuff This Section is computed ////////////
#if defined(macintosh) && defined(__POWERPC__) #if defined(_WIN32)
#define HS_BUILD_FOR_MACPPC 1
#elif defined(macintosh)
#define HS_BUILD_FOR_MAC68K 1
#elif defined(_WIN32)
#define HS_BUILD_FOR_WIN32 1 #define HS_BUILD_FOR_WIN32 1
#elif defined(__unix__) #elif defined(__unix__)
#define HS_BUILD_FOR_UNIX 1 #define HS_BUILD_FOR_UNIX 1

24
Sources/Plasma/CoreLib/hsFixedTypes.h
Unescape View File

@ -44,11 +44,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsTypes.h" #include "hsTypes.h"
#if HS_BUILD_FOR_MAC
#include <ToolUtils.h>
#include <FixMath.h>
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
@ -86,21 +81,12 @@ extern "C" {
#define hsFloatToFract(x) hsFract((x) * hsFract1) #define hsFloatToFract(x) hsFract((x) * hsFract1)
#endif #endif
#if HS_BUILD_FOR_MAC68K && !(HS_PIN_MATH_OVERFLOW)
#define hsFixMul(a, b) FixMul(a, b)
#else
hsFixed hsFixMul(hsFixed a, hsFixed b);
#endif
#if HS_BUILD_FOR_MAC && !(HS_PIN_MATH_OVERFLOW) && !(HS_MP_SAFE) hsFixed hsFixMul(hsFixed a, hsFixed b);
#define hsFixDiv(a, b) FixDiv(a, b)
#define hsFracMul(a, b) FracMul(a, b) hsFract hsFixDiv(hsFixed a, hsFixed b);
#define hsFracDiv(a, b) FracDiv(a, b) hsFract hsFracMul(hsFract a, hsFract b);
#else hsFract hsFracDiv(hsFract a, hsFract b);
hsFract hsFixDiv(hsFixed a, hsFixed b);
hsFract hsFracMul(hsFract a, hsFract b);
hsFract hsFracDiv(hsFract a, hsFract b);
#endif
hsFract hsFracSqrt(hsFract value); hsFract hsFracSqrt(hsFract value);
#define hsFixSqrt(value) (hsFracSqrt(value) >> 7) #define hsFixSqrt(value) (hsFracSqrt(value) >> 7)

8
Sources/Plasma/CoreLib/hsGeometry3.h
Unescape View File

@ -196,13 +196,6 @@ struct hsVector3 : public hsScalarTriple {
void Normalize() void Normalize()
{ {
#if HS_BUILD_FOR_PS2
hsScalar length = this->Magnitude();
hsIfDebugMessage(length == 0, "Err: Normalizing hsVector3 of length 0", 0);
if (length == 0)
return;
NormalizeVU0(length, (MATRIX4)this);
#else
hsScalar length = this->Magnitude(); hsScalar length = this->Magnitude();
// hsIfDebugMessage(length == 0, "Err: Normalizing hsVector3 of length 0", 0); // hsIfDebugMessage(length == 0, "Err: Normalizing hsVector3 of length 0", 0);
if (length == 0) if (length == 0)
@ -212,7 +205,6 @@ struct hsVector3 : public hsScalarTriple {
fX = hsScalarMul(fX, invMag); fX = hsScalarMul(fX, invMag);
fY = hsScalarMul(fY, invMag); fY = hsScalarMul(fY, invMag);
fZ = hsScalarMul(fZ, invMag); fZ = hsScalarMul(fZ, invMag);
#endif
} }
inline void Renormalize() // if the vector is already close to unit length inline void Renormalize() // if the vector is already close to unit length
{ {

40
Sources/Plasma/CoreLib/hsMatrix44.cpp
Unescape View File

@ -123,9 +123,6 @@ hsMatrix44 operator*(const hsMatrix44& a, const hsMatrix44& b)
if( b.fFlags & hsMatrix44::kIsIdent ) if( b.fFlags & hsMatrix44::kIsIdent )
return a; return a;
#if HS_BUILD_FOR_PS2
MulMatrixVU0(a.fMap, b.fMap, c.fMap);
#else
c.fMap[0][0] = hsScalarMul(a.fMap[0][0], b.fMap[0][0]) + hsScalarMul(a.fMap[0][1], b.fMap[1][0]) + hsScalarMul(a.fMap[0][2], b.fMap[2][0]) + hsScalarMul(a.fMap[0][3], b.fMap[3][0]); c.fMap[0][0] = hsScalarMul(a.fMap[0][0], b.fMap[0][0]) + hsScalarMul(a.fMap[0][1], b.fMap[1][0]) + hsScalarMul(a.fMap[0][2], b.fMap[2][0]) + hsScalarMul(a.fMap[0][3], b.fMap[3][0]);
c.fMap[0][1] = hsScalarMul(a.fMap[0][0], b.fMap[0][1]) + hsScalarMul(a.fMap[0][1], b.fMap[1][1]) + hsScalarMul(a.fMap[0][2], b.fMap[2][1]) + hsScalarMul(a.fMap[0][3], b.fMap[3][1]); c.fMap[0][1] = hsScalarMul(a.fMap[0][0], b.fMap[0][1]) + hsScalarMul(a.fMap[0][1], b.fMap[1][1]) + hsScalarMul(a.fMap[0][2], b.fMap[2][1]) + hsScalarMul(a.fMap[0][3], b.fMap[3][1]);
c.fMap[0][2] = hsScalarMul(a.fMap[0][0], b.fMap[0][2]) + hsScalarMul(a.fMap[0][1], b.fMap[1][2]) + hsScalarMul(a.fMap[0][2], b.fMap[2][2]) + hsScalarMul(a.fMap[0][3], b.fMap[3][2]); c.fMap[0][2] = hsScalarMul(a.fMap[0][0], b.fMap[0][2]) + hsScalarMul(a.fMap[0][1], b.fMap[1][2]) + hsScalarMul(a.fMap[0][2], b.fMap[2][2]) + hsScalarMul(a.fMap[0][3], b.fMap[3][2]);
@ -145,7 +142,6 @@ hsMatrix44 operator*(const hsMatrix44& a, const hsMatrix44& b)
c.fMap[3][1] = hsScalarMul(a.fMap[3][0], b.fMap[0][1]) + hsScalarMul(a.fMap[3][1], b.fMap[1][1]) + hsScalarMul(a.fMap[3][2], b.fMap[2][1]) + hsScalarMul(a.fMap[3][3], b.fMap[3][1]); c.fMap[3][1] = hsScalarMul(a.fMap[3][0], b.fMap[0][1]) + hsScalarMul(a.fMap[3][1], b.fMap[1][1]) + hsScalarMul(a.fMap[3][2], b.fMap[2][1]) + hsScalarMul(a.fMap[3][3], b.fMap[3][1]);
c.fMap[3][2] = hsScalarMul(a.fMap[3][0], b.fMap[0][2]) + hsScalarMul(a.fMap[3][1], b.fMap[1][2]) + hsScalarMul(a.fMap[3][2], b.fMap[2][2]) + hsScalarMul(a.fMap[3][3], b.fMap[3][2]); c.fMap[3][2] = hsScalarMul(a.fMap[3][0], b.fMap[0][2]) + hsScalarMul(a.fMap[3][1], b.fMap[1][2]) + hsScalarMul(a.fMap[3][2], b.fMap[2][2]) + hsScalarMul(a.fMap[3][3], b.fMap[3][2]);
c.fMap[3][3] = hsScalarMul(a.fMap[3][0], b.fMap[0][3]) + hsScalarMul(a.fMap[3][1], b.fMap[1][3]) + hsScalarMul(a.fMap[3][2], b.fMap[2][3]) + hsScalarMul(a.fMap[3][3], b.fMap[3][3]); c.fMap[3][3] = hsScalarMul(a.fMap[3][0], b.fMap[0][3]) + hsScalarMul(a.fMap[3][1], b.fMap[1][3]) + hsScalarMul(a.fMap[3][2], b.fMap[2][3]) + hsScalarMul(a.fMap[3][3], b.fMap[3][3]);
#endif
return c; return c;
} }
@ -157,13 +153,9 @@ hsVector3 operator*(const hsMatrix44& m, const hsVector3& p)
hsVector3 rVal; hsVector3 rVal;
#if HS_BUILD_FOR_PS2
MulVectorVU0(m.fMap, (MATRIX4) &p, (MATRIX4) &rVal);
#else
rVal.fX = hsScalarMul(p.fX, m.fMap[0][0]) + hsScalarMul(p.fY, m.fMap[0][1]) + hsScalarMul(p.fZ, m.fMap[0][2]); rVal.fX = hsScalarMul(p.fX, m.fMap[0][0]) + hsScalarMul(p.fY, m.fMap[0][1]) + hsScalarMul(p.fZ, m.fMap[0][2]);
rVal.fY = hsScalarMul(p.fX, m.fMap[1][0]) + hsScalarMul(p.fY, m.fMap[1][1]) + hsScalarMul(p.fZ, m.fMap[1][2]); rVal.fY = hsScalarMul(p.fX, m.fMap[1][0]) + hsScalarMul(p.fY, m.fMap[1][1]) + hsScalarMul(p.fZ, m.fMap[1][2]);
rVal.fZ = hsScalarMul(p.fX, m.fMap[2][0]) + hsScalarMul(p.fY, m.fMap[2][1]) + hsScalarMul(p.fZ, m.fMap[2][2]); rVal.fZ = hsScalarMul(p.fX, m.fMap[2][0]) + hsScalarMul(p.fY, m.fMap[2][1]) + hsScalarMul(p.fZ, m.fMap[2][2]);
#endif
return rVal; return rVal;
} }
@ -183,9 +175,6 @@ hsMatrix44 hsMatrix44::operator*(const hsMatrix44& b) const
if( b.fFlags & hsMatrix44::kIsIdent ) if( b.fFlags & hsMatrix44::kIsIdent )
return *this; return *this;
#if HS_BUILD_FOR_PS2
MulMatrixVU0(fMap, b.fMap, c.fMap);
#else
c.fMap[0][0] = hsScalarMul(fMap[0][0], b.fMap[0][0]) + hsScalarMul(fMap[0][1], b.fMap[1][0]) + hsScalarMul(fMap[0][2], b.fMap[2][0]) + hsScalarMul(fMap[0][3], b.fMap[3][0]); c.fMap[0][0] = hsScalarMul(fMap[0][0], b.fMap[0][0]) + hsScalarMul(fMap[0][1], b.fMap[1][0]) + hsScalarMul(fMap[0][2], b.fMap[2][0]) + hsScalarMul(fMap[0][3], b.fMap[3][0]);
c.fMap[0][1] = hsScalarMul(fMap[0][0], b.fMap[0][1]) + hsScalarMul(fMap[0][1], b.fMap[1][1]) + hsScalarMul(fMap[0][2], b.fMap[2][1]) + hsScalarMul(fMap[0][3], b.fMap[3][1]); c.fMap[0][1] = hsScalarMul(fMap[0][0], b.fMap[0][1]) + hsScalarMul(fMap[0][1], b.fMap[1][1]) + hsScalarMul(fMap[0][2], b.fMap[2][1]) + hsScalarMul(fMap[0][3], b.fMap[3][1]);
c.fMap[0][2] = hsScalarMul(fMap[0][0], b.fMap[0][2]) + hsScalarMul(fMap[0][1], b.fMap[1][2]) + hsScalarMul(fMap[0][2], b.fMap[2][2]) + hsScalarMul(fMap[0][3], b.fMap[3][2]); c.fMap[0][2] = hsScalarMul(fMap[0][0], b.fMap[0][2]) + hsScalarMul(fMap[0][1], b.fMap[1][2]) + hsScalarMul(fMap[0][2], b.fMap[2][2]) + hsScalarMul(fMap[0][3], b.fMap[3][2]);
@ -205,7 +194,6 @@ hsMatrix44 hsMatrix44::operator*(const hsMatrix44& b) const
c.fMap[3][1] = hsScalarMul(fMap[3][0], b.fMap[0][1]) + hsScalarMul(fMap[3][1], b.fMap[1][1]) + hsScalarMul(fMap[3][2], b.fMap[2][1]) + hsScalarMul(fMap[3][3], b.fMap[3][1]); c.fMap[3][1] = hsScalarMul(fMap[3][0], b.fMap[0][1]) + hsScalarMul(fMap[3][1], b.fMap[1][1]) + hsScalarMul(fMap[3][2], b.fMap[2][1]) + hsScalarMul(fMap[3][3], b.fMap[3][1]);
c.fMap[3][2] = hsScalarMul(fMap[3][0], b.fMap[0][2]) + hsScalarMul(fMap[3][1], b.fMap[1][2]) + hsScalarMul(fMap[3][2], b.fMap[2][2]) + hsScalarMul(fMap[3][3], b.fMap[3][2]); c.fMap[3][2] = hsScalarMul(fMap[3][0], b.fMap[0][2]) + hsScalarMul(fMap[3][1], b.fMap[1][2]) + hsScalarMul(fMap[3][2], b.fMap[2][2]) + hsScalarMul(fMap[3][3], b.fMap[3][2]);
c.fMap[3][3] = hsScalarMul(fMap[3][0], b.fMap[0][3]) + hsScalarMul(fMap[3][1], b.fMap[1][3]) + hsScalarMul(fMap[3][2], b.fMap[2][3]) + hsScalarMul(fMap[3][3], b.fMap[3][3]); c.fMap[3][3] = hsScalarMul(fMap[3][0], b.fMap[0][3]) + hsScalarMul(fMap[3][1], b.fMap[1][3]) + hsScalarMul(fMap[3][2], b.fMap[2][3]) + hsScalarMul(fMap[3][3], b.fMap[3][3]);
#endif
return c; return c;
} }
@ -217,13 +205,9 @@ hsVector3 hsMatrix44::operator*(const hsVector3& p) const
hsVector3 rVal; hsVector3 rVal;
#if HS_BUILD_FOR_PS2
MulVectorVU0(fMap, (MATRIX4) &p, (MATRIX4) &rVal);
#else
rVal.fX = hsScalarMul(p.fX, fMap[0][0]) + hsScalarMul(p.fY, fMap[0][1]) + hsScalarMul(p.fZ, fMap[0][2]); rVal.fX = hsScalarMul(p.fX, fMap[0][0]) + hsScalarMul(p.fY, fMap[0][1]) + hsScalarMul(p.fZ, fMap[0][2]);
rVal.fY = hsScalarMul(p.fX, fMap[1][0]) + hsScalarMul(p.fY, fMap[1][1]) + hsScalarMul(p.fZ, fMap[1][2]); rVal.fY = hsScalarMul(p.fX, fMap[1][0]) + hsScalarMul(p.fY, fMap[1][1]) + hsScalarMul(p.fZ, fMap[1][2]);
rVal.fZ = hsScalarMul(p.fX, fMap[2][0]) + hsScalarMul(p.fY, fMap[2][1]) + hsScalarMul(p.fZ, fMap[2][2]); rVal.fZ = hsScalarMul(p.fX, fMap[2][0]) + hsScalarMul(p.fY, fMap[2][1]) + hsScalarMul(p.fZ, fMap[2][2]);
#endif
return rVal; return rVal;
} }
@ -271,9 +255,6 @@ int hsMatrix44::operator==(const hsMatrix44& ss) const
hsMatrix44& hsMatrix44::Scale(const hsVector3* scale) hsMatrix44& hsMatrix44::Scale(const hsVector3* scale)
{ {
#if HS_BUILD_FOR_PS2
MulScaleVU0(fMap, (MATRIX4 *) scale);
#else
fMap[0][0] *= scale->fX; fMap[0][0] *= scale->fX;
fMap[0][1] *= scale->fX; fMap[0][1] *= scale->fX;
fMap[0][2] *= scale->fX; fMap[0][2] *= scale->fX;
@ -288,7 +269,7 @@ hsMatrix44& hsMatrix44::Scale(const hsVector3* scale)
fMap[2][1] *= scale->fZ; fMap[2][1] *= scale->fZ;
fMap[2][2] *= scale->fZ; fMap[2][2] *= scale->fZ;
fMap[2][3] *= scale->fZ; fMap[2][3] *= scale->fZ;
#endif
NotIdentity(); NotIdentity();
return *this; return *this;
} }
@ -318,14 +299,10 @@ hsVector3 hsMatrix44::RemoveScale()
hsMatrix44& hsMatrix44::Translate(const hsVector3* pt) hsMatrix44& hsMatrix44::Translate(const hsVector3* pt)
{ {
#if HS_BUILD_FOR_PS2
TranslateVU0(fMap, (MATRIX4 *) pt); /* SUNSOFT */
#else
for (int i =0; i < 3; i++) for (int i =0; i < 3; i++)
{ {
fMap[i][3] += (*pt)[i]; fMap[i][3] += (*pt)[i];
} }
#endif
NotIdentity(); NotIdentity();
return *this; return *this;
} }
@ -686,9 +663,6 @@ static inline hsScalar Determinant3(hsScalar a, hsScalar b, hsScalar c,
hsScalar hsMatrix44::GetDeterminant() const hsScalar hsMatrix44::GetDeterminant() const
{ {
#if HS_BUILD_FOR_PS2
return (GetDeterminantVU0(fMap));
#else
return (fMap[0][0]*Determinant3(fMap[1][1], fMap[2][1], fMap[3][1], return (fMap[0][0]*Determinant3(fMap[1][1], fMap[2][1], fMap[3][1],
fMap[1][2], fMap[2][2], fMap[3][2], fMap[1][2], fMap[2][2], fMap[3][2],
fMap[1][3], fMap[2][3], fMap[3][3]) - fMap[1][3], fMap[2][3], fMap[3][3]) -
@ -701,15 +675,11 @@ hsScalar hsMatrix44::GetDeterminant() const
fMap[3][0]*Determinant3(fMap[0][1], fMap[1][1], fMap[2][1], fMap[3][0]*Determinant3(fMap[0][1], fMap[1][1], fMap[2][1],
fMap[0][2], fMap[1][2], fMap[2][2], fMap[0][2], fMap[1][2], fMap[2][2],
fMap[0][3], fMap[1][3], fMap[2][3])); fMap[0][3], fMap[1][3], fMap[2][3]));
#endif
} }
hsMatrix44 *hsMatrix44::GetAdjoint(hsMatrix44 *adj) const hsMatrix44 *hsMatrix44::GetAdjoint(hsMatrix44 *adj) const
{ {
#if HS_BUILD_FOR_PS2
GetAdjointVU0(fMap, adj->fMap);
#else
float a1, a2, a3, a4, b1, b2, b3, b4; float a1, a2, a3, a4, b1, b2, b3, b4;
float c1, c2, c3, c4, d1, d2, d3, d4; float c1, c2, c3, c4, d1, d2, d3, d4;
/* /*
@ -774,7 +744,7 @@ hsMatrix44 *hsMatrix44::GetAdjoint(hsMatrix44 *adj) const
adj->fMap[1][3] = Determinant3(a1, a2, a3, c1, c2, c3, d1, d2, d3); adj->fMap[1][3] = Determinant3(a1, a2, a3, c1, c2, c3, d1, d2, d3);
adj->fMap[2][3] = -Determinant3(a1, a2, a3, b1, b2, b3, d1, d2, d3); adj->fMap[2][3] = -Determinant3(a1, a2, a3, b1, b2, b3, d1, d2, d3);
adj->fMap[3][3] = Determinant3(a1, a2, a3, b1, b2, b3, c1, c2, c3); adj->fMap[3][3] = Determinant3(a1, a2, a3, b1, b2, b3, c1, c2, c3);
#endif
adj->NotIdentity(); adj->NotIdentity();
return adj; return adj;
} }
@ -792,13 +762,11 @@ hsMatrix44* hsMatrix44::GetInverse(hsMatrix44* inverse) const
det = hsScalarInvert(det); det = hsScalarInvert(det);
GetAdjoint(inverse); GetAdjoint(inverse);
#if HS_BUILD_FOR_PS2
MatMulVU0(inverse->fMap, det);
#else
for (i=0; i<4; i++) for (i=0; i<4; i++)
for (j=0; j<4; j++) for (j=0; j<4; j++)
inverse->fMap[i][j] *= det; inverse->fMap[i][j] *= det;
#endif
return inverse; return inverse;
} }

22
Sources/Plasma/CoreLib/hsMemory.cpp
Unescape View File

@ -39,11 +39,8 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
Mead, WA 99021 Mead, WA 99021
*==LICENSE==*/ *==LICENSE==*/
#if HS_BUILD_FOR_MAC
#include <Memory.h> #include <string.h>
#else
#include <string.h>
#endif
#include "hsMemory.h" #include "hsMemory.h"
#include "hsExceptions.h" #include "hsExceptions.h"
@ -52,17 +49,10 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
#if HS_BUILD_FOR_MAC void HSMemory::BlockMove(const void* src, void* dst, UInt32 length)
void HSMemory::BlockMove(const void* src, void* dst, UInt32 length) {
{ memmove(dst, src, length);
::BlockMoveData(src, dst, length); }
}
#else
void HSMemory::BlockMove(const void* src, void* dst, UInt32 length)
{
memmove(dst, src, length);
}
#endif
hsBool HSMemory::EqualBlocks(const void* block1, const void* block2, UInt32 length) hsBool HSMemory::EqualBlocks(const void* block1, const void* block2, UInt32 length)
{ {

4
Sources/Plasma/CoreLib/hsMemory.h
Unescape View File

@ -48,11 +48,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
class HSMemory { class HSMemory {
public: public:
#if HS_BUILD_FOR_MAC
static void BlockMove(const void* src, void* dst, UInt32 length); static void BlockMove(const void* src, void* dst, UInt32 length);
#else
static void BlockMove(const void* src, void* dst, UInt32 length);
#endif
static void Clear(void *m, UInt32 byteLen); static void Clear(void *m, UInt32 byteLen);
static void ClearMemory(void *m, UInt32 byteLen) { HSMemory::Clear(m, byteLen); } static void ClearMemory(void *m, UInt32 byteLen) { HSMemory::Clear(m, byteLen); }

6
Sources/Plasma/CoreLib/hsPoint2.h
Unescape View File

@ -44,12 +44,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsScalar.h" #include "hsScalar.h"
#if __MWERKS__
// This guy disables MetroWerks' desire to only include a file once, which obviously gets
// in the way of our little HS_POINT2.inc trick
#pragma once off
#endif
#define HS_POINT2_NAME hsIntPoint2 #define HS_POINT2_NAME hsIntPoint2
#define HS_POINT2_TYPE Int32 #define HS_POINT2_TYPE Int32
#include "HS_POINT2.inc" #include "HS_POINT2.inc"

193
Sources/Plasma/CoreLib/hsStream.cpp
Unescape View File

@ -51,17 +51,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include <unistd.h> #include <unistd.h>
#endif #endif
#if HS_BUILD_FOR_MAC
#include <Files.h>
#include <stdio.h>
#include <unistd.h>
#endif
#if HS_BUILD_FOR_PS2
#include <eekernel.h>
#include <sifdev.h>
#endif
#include "hsWindows.h" #include "hsWindows.h"
#if HS_BUILD_FOR_WIN32 #if HS_BUILD_FOR_WIN32
#include <io.h> #include <io.h>
@ -696,26 +685,8 @@ UInt32 hsStream::ReadLEAtom(UInt32* sizePtr)
hsBool hsFileStream::Open(const char *name, const char *mode) hsBool hsFileStream::Open(const char *name, const char *mode)
{ {
#ifdef HS_BUILD_FOR_PS2
hsAssert(fRef == kFileStream_Uninitialized, "hsFileStream:Open Stream already opened");
Int32 ref = hsPS2Open(name, mode);
if (ref == -1)
return false;
fRef = (UInt32) ref;
fFileSize = sceLseek(fRef, 0, SCE_SEEK_END);
sceLseek(fRef, 0, SCE_SEEK_SET);
fBufferIsEmpty = true;
fWriteBufferUsed = false;
fVirtualFilePointer = 0;
fBufferBase = 0;
return true;
#else
hsAssert(0, "hsFileStream::Open NotImplemented"); hsAssert(0, "hsFileStream::Open NotImplemented");
return false; return false;
#endif
} }
hsBool hsFileStream::Open(const wchar *name, const wchar *mode) hsBool hsFileStream::Open(const wchar *name, const wchar *mode)
@ -726,17 +697,8 @@ hsBool hsFileStream::Open(const wchar *name, const wchar *mode)
hsBool hsFileStream::Close () hsBool hsFileStream::Close ()
{ {
#ifdef HS_BUILD_FOR_PS2
if (fRef != kFileStream_Uninitialized)
{
hsPS2Close(fRef);
fRef = kFileStream_Uninitialized;
}
return true;
#else
hsAssert(0, "hsFileStream::Close NotImplemented"); hsAssert(0, "hsFileStream::Close NotImplemented");
return false; return false;
#endif
} }
UInt32 hsFileStream::GetFileRef() UInt32 hsFileStream::GetFileRef()
@ -748,23 +710,11 @@ void hsFileStream::SetFileRef(UInt32 ref)
{ {
hsAssert(ref != kFileStream_Uninitialized, "bad ref"); hsAssert(ref != kFileStream_Uninitialized, "bad ref");
fRef = ref; fRef = ref;
#if HS_BUILD_FOR_PS2
fFileSize = sceLseek(fRef, 0, SCE_SEEK_END);
sceLseek(fRef, 0, SCE_SEEK_SET);
fBufferIsEmpty= true;
fWriteBufferUsed= false;
fVirtualFilePointer= 0;
fBufferBase= 0;
#endif
} }
hsFileStream::hsFileStream() hsFileStream::hsFileStream()
{ {
fRef = kFileStream_Uninitialized; fRef = kFileStream_Uninitialized;
#if HS_BUILD_FOR_PS2
fBufferIsEmpty= true;
fWriteBufferUsed= false;
#endif
} }
hsFileStream::~hsFileStream() hsFileStream::~hsFileStream()
@ -778,54 +728,7 @@ UInt32 hsFileStream::Read(UInt32 bytes, void* buffer)
fBytesRead += bytes; fBytesRead += bytes;
fPosition += bytes; fPosition += bytes;
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
Int16 err;
err = FSRead(fRef, (long*)&bytes, buffer);
if (err == noErr)
return bytes;
else
return 0;
#elif HS_BUILD_FOR_PS2
Int32 ret;
Int32 nReadBytes= 0;
while(bytes){
if( !fBufferIsEmpty ){ // read at already chatched.
Int32 DataBytesInBuffer= fBufferBase + kBufferSize - fVirtualFilePointer;
Int32 ChatchedReadSize= DataBytesInBuffer < bytes ? DataBytesInBuffer : bytes;
memcpy( buffer, &fBuffer[fVirtualFilePointer-fBufferBase], ChatchedReadSize );
nReadBytes += ChatchedReadSize;
buffer= (void *)(((char*)buffer) + ChatchedReadSize);
fVirtualFilePointer += ChatchedReadSize;
bytes -= ChatchedReadSize;
fBufferIsEmpty= (fBufferBase + kBufferSize <= fVirtualFilePointer);
}
if( kBufferSize <= bytes ){ // read directry, for Large block read.
hsAssert( fBufferIsEmpty, "read buffer was not used.");
Int32 DirectReadSize= bytes - bytes % kBufferSize;
ret= sceRead(fRef, buffer, DirectReadSize);
if( ret == -1 ){
return 0;
}
hsAssert( ret == DirectReadSize, "require read size != return size");
nReadBytes += DirectReadSize;
buffer= (void *)(((char*)buffer) + DirectReadSize);
fVirtualFilePointer += DirectReadSize;
bytes -= DirectReadSize;
}
if( 0 < bytes && fBufferIsEmpty ){ // fill buffer
hsAssert( fVirtualFilePointer % kBufferSize == 0 , "read buffer is not alignment.");
ret= sceRead(fRef, fBuffer, kBufferSize );
if( ret == -1 ){
return 0;
}
fBufferBase= fVirtualFilePointer;
fBufferIsEmpty= false;
}
}
return nReadBytes;
#elif HS_BUILD_FOR_WIN32
UInt32 rBytes; UInt32 rBytes;
ReadFile((HANDLE)fRef, buffer, bytes, (LPDWORD)&rBytes, nil); ReadFile((HANDLE)fRef, buffer, bytes, (LPDWORD)&rBytes, nil);
if(bytes == rBytes) if(bytes == rBytes)
@ -844,28 +747,7 @@ UInt32 hsFileStream::Write(UInt32 bytes, const void* buffer)
fBytesRead += bytes; fBytesRead += bytes;
fPosition += bytes; fPosition += bytes;
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
Int16 err;
err = FSWrite(fRef, (long*)&bytes, buffer);
if (err == noErr)
return bytes;
else
{
hsDebugMessage("hsFileStream::Write failed", err);
return 0;
}
#elif HS_BUILD_FOR_PS2
Int32 ret;
fWriteBufferUsed =true; // buffered write was not implement, not yet.
ret = sceWrite(fRef, (void*)buffer ,bytes);
if(ret != -1)
return ret;
else
return 0;
#elif HS_BUILD_FOR_WIN32
UInt32 wBytes; UInt32 wBytes;
WriteFile((HANDLE)fRef, buffer, bytes, (LPDWORD)&wBytes, nil); WriteFile((HANDLE)fRef, buffer, bytes, (LPDWORD)&wBytes, nil);
if(bytes == wBytes) if(bytes == wBytes)
@ -885,24 +767,7 @@ UInt32 hsFileStream::Write(UInt32 bytes, const void* buffer)
hsBool hsFileStream::AtEnd() hsBool hsFileStream::AtEnd()
{ {
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
Int32 eof;
Int32 pos;
::GetEOF(fRef, &eof);
::GetFPos(fRef, &pos);
return pos >= eof;
#elif HS_BUILD_FOR_PS2
Int32 rVal = 0;
if( fWriteBufferUsed || fVirtualFilePointer == 0 ){
// bufferd write was not implement, yiet.
rVal = sceLseek(fRef, 0, SCE_SEEK_CUR);
return rVal >= fFileSize;
}
else{ // bufferd read
return fVirtualFilePointer >= fFileSize;
}
#elif HS_BUILD_FOR_WIN32
UInt32 bytes; UInt32 bytes;
PeekNamedPipe((void*)fRef, nil, 0, nil, (LPDWORD)&bytes, nil); PeekNamedPipe((void*)fRef, nil, 0, nil, (LPDWORD)&bytes, nil);
return bytes>0; return bytes>0;
@ -917,41 +782,7 @@ void hsFileStream::Skip(UInt32 delta)
fBytesRead += delta; fBytesRead += delta;
fPosition += delta; fPosition += delta;
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
short err = SetFPos(fRef, fsFromMark, delta);
hsAssert(err == noErr, "SetFPos failed");
#elif HS_BUILD_FOR_PS2
const Int32 NewPointer= fVirtualFilePointer+delta;
if( fWriteBufferUsed || fVirtualFilePointer == 0 ){
// bufferd write was not implement, yiet.
sceLseek(fRef, delta, SCE_SEEK_CUR);
}
else{ // bufferd read.
if( !fBufferIsEmpty ){
Int32 CurBlock= fVirtualFilePointer / kBufferSize;
Int32 NewBlock= NewPointer / kBufferSize;
if( CurBlock == NewBlock ){
fVirtualFilePointer += delta;
return;
}
fBufferIsEmpty= false;
}
Int32 NewBaseMod= NewPointer % kBufferSize;
Int32 NewBase= NewPointer - NewBaseMod;
if( NewBaseMod ){
sceLseek( fRef, NewBase, SCE_SEEK_SET );
sceRead( fRef, fBuffer, kBufferSize );
fVirtualFilePointer= NewPointer;
fBufferBase= NewBase;
fBufferIsEmpty= false;
}
else{
// just block border.
fVirtualFilePointer= NewPointer;
fBufferBase= NewBase;
}
}
#elif HS_BUILD_FOR_WIN32
hsDebugMessage("hsFileStream::Skip unimplemented", 0); hsDebugMessage("hsFileStream::Skip unimplemented", 0);
#endif #endif
} }
@ -961,21 +792,7 @@ void hsFileStream::Rewind()
fBytesRead = 0; fBytesRead = 0;
fPosition = 0; fPosition = 0;
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
short err = SetFPos(fRef, fsFromStart, 0);
hsAssert(err == noErr, "SetFPos failed");
#elif HS_BUILD_FOR_PS2
if( fWriteBufferUsed || fVirtualFilePointer == 0 ){
// bufferd write was not implement, yiet.
sceLseek(fRef,0,SCE_SEEK_SET);
}
else{ // bufferd read.
sceLseek(fRef, 0, SCE_SEEK_SET);
fBufferIsEmpty= true;
fVirtualFilePointer= 0;
fBufferBase= 0;
}
#elif HS_BUILD_FOR_WIN32
hsDebugMessage("hsFileStream::Rewind unimplemented", 0); hsDebugMessage("hsFileStream::Rewind unimplemented", 0);
#endif #endif
} }

11
Sources/Plasma/CoreLib/hsStream.h
Unescape View File

@ -320,17 +320,6 @@ public:
class hsFileStream: public hsStream class hsFileStream: public hsStream
{ {
UInt32 fRef; UInt32 fRef;
#if HS_BUILD_FOR_PS2
enum {
kBufferSize = 2*1024
};
UInt32 fFileSize;
char fBuffer[kBufferSize];
Int32 fVirtualFilePointer;
Int32 fBufferBase; // offset to top of fBuffer
hsBool fBufferIsEmpty;
hsBool fWriteBufferUsed; // In write mode. fBuffer must be flush, when file was closed.
#endif
public: public:
hsFileStream(); hsFileStream();

31
Sources/Plasma/CoreLib/hsThread.h
Unescape View File

@ -47,9 +47,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
typedef UInt32 hsMilliseconds; typedef UInt32 hsMilliseconds;
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
#include <Multiprocessing.h>
#elif HS_BUILD_FOR_WIN32
#include "hsWindows.h" #include "hsWindows.h"
#elif HS_BUILD_FOR_UNIX #elif HS_BUILD_FOR_UNIX
#include <pthread.h> #include <pthread.h>
@ -66,9 +64,7 @@ typedef UInt32 hsMilliseconds;
class hsThread class hsThread
{ {
public: public:
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
typedef MPTaskId ThreadId;
#elif HS_BUILD_FOR_WIN32
typedef DWORD ThreadId; typedef DWORD ThreadId;
#elif HS_BUILD_FOR_UNIX #elif HS_BUILD_FOR_UNIX
typedef pthread_t ThreadId; typedef pthread_t ThreadId;
@ -76,10 +72,7 @@ public:
private: private:
hsBool fQuit; hsBool fQuit;
UInt32 fStackSize; UInt32 fStackSize;
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
ThreadId fTaskId;
MPQueueId fNotifyQ;
#elif HS_BUILD_FOR_WIN32
ThreadId fThreadId; ThreadId fThreadId;
HANDLE fThreadH; HANDLE fThreadH;
HANDLE fQuitSemaH; HANDLE fQuitSemaH;
@ -94,10 +87,7 @@ protected:
public: public:
hsThread(UInt32 stackSize = 0); hsThread(UInt32 stackSize = 0);
virtual ~hsThread(); // calls Stop() virtual ~hsThread(); // calls Stop()
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
ThreadId GetThreadId() { return fTaskId; }
#error "Mac is Depricated"
#elif HS_BUILD_FOR_WIN32
ThreadId GetThreadId() { return fThreadId; } ThreadId GetThreadId() { return fThreadId; }
static ThreadId GetMyThreadId() { return GetCurrentThreadId(); } static ThreadId GetMyThreadId() { return GetCurrentThreadId(); }
#elif HS_BUILD_FOR_UNIX #elif HS_BUILD_FOR_UNIX
@ -123,9 +113,7 @@ public:
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
class hsMutex { class hsMutex {
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
MPCriticalRegionId fCriticalRegion;
#elif HS_BUILD_FOR_WIN32
HANDLE fMutexH; HANDLE fMutexH;
#elif HS_BUILD_FOR_UNIX #elif HS_BUILD_FOR_UNIX
pthread_mutex_t fPMutex; pthread_mutex_t fPMutex;
@ -159,9 +147,7 @@ public:
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
class hsSemaphore { class hsSemaphore {
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
MPSemaphoreId fSemaId;
#elif HS_BUILD_FOR_WIN32
HANDLE fSemaH; HANDLE fSemaH;
#elif HS_BUILD_FOR_UNIX #elif HS_BUILD_FOR_UNIX
#ifdef USE_SEMA #ifdef USE_SEMA
@ -185,7 +171,6 @@ public:
}; };
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#if !HS_BUILD_FOR_MAC
class hsEvent class hsEvent
{ {
#if HS_BUILD_FOR_UNIX #if HS_BUILD_FOR_UNIX
@ -209,10 +194,8 @@ public:
hsBool Wait(hsMilliseconds timeToWait = kPosInfinity32); hsBool Wait(hsMilliseconds timeToWait = kPosInfinity32);
void Signal(); void Signal();
}; };
#endif // HS_BUILD_FOR_MAC
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#if !HS_BUILD_FOR_MAC
class hsSleep class hsSleep
{ {
public: public:
@ -224,8 +207,6 @@ public:
#endif #endif
}; };
#endif // HS_BUILD_FOR_MAC
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// Allows multiple readers, locks out readers for writing. // Allows multiple readers, locks out readers for writing.

161
Sources/Plasma/CoreLib/hsUtils.cpp
Unescape View File

@ -40,9 +40,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
*==LICENSE==*/ *==LICENSE==*/
#include "hsUtils.h" #include "hsUtils.h"
#if HS_BUILD_FOR_MAC
#include <Gestalt.h>
#endif
#if HS_BUILD_FOR_WIN32 #if HS_BUILD_FOR_WIN32
extern "C" { extern "C" {
#endif #endif
@ -51,14 +48,6 @@ extern "C" {
#if HS_BUILD_FOR_WIN32 #if HS_BUILD_FOR_WIN32
}; };
#endif #endif
#if __MWERKS__
#include <ctype.h>
#endif
#if HS_BUILD_FOR_PS2
#include <ctype.h>
#include "eekernel.h"
#include "sifdev.h"
#endif
#if HS_BUILD_FOR_WIN32 #if HS_BUILD_FOR_WIN32
#include <winsock2.h> #include <winsock2.h>
@ -153,12 +142,6 @@ int hsMessageBoxWithOwner(void * owner, const char message[], const char caption
} }
#endif #endif
#if HS_BUILD_FOR_MACPPC
DebugStr(message);
#endif
#if HS_BUILD_FOR_PS2
printf("Cap:%s Message:%s\n",caption, message);
#endif
} }
int hsMessageBoxWithOwner(void * owner, const wchar_t message[], const wchar_t caption[], int kind, int icon) int hsMessageBoxWithOwner(void * owner, const wchar_t message[], const wchar_t caption[], int kind, int icon)
@ -213,12 +196,6 @@ int hsMessageBoxWithOwner(void * owner, const wchar_t message[], const wchar_t c
} }
#endif #endif
#if HS_BUILD_FOR_MACPPC
DebugStr(message);
#endif
#if HS_BUILD_FOR_PS2
printf("Cap:%s Message:%s\n",caption, message);
#endif
} }
int hsMessageBox(const char message[], const char caption[], int kind, int icon) int hsMessageBox(const char message[], const char caption[], int kind, int icon)
@ -442,16 +419,6 @@ void hsCPathToMacPath(char* dst, char* fname)
int hsRemove(const char * fname) int hsRemove(const char * fname)
{ {
#if HS_BUILD_FOR_MACPPC
char buf[500];
hsStrcpy(buf,":");
hsStrcat(buf,fname);
int i;
for(i =0; i < hsStrlen(buf); i++)
if(buf[i] == '\\')
buf[i] = ':';
return remove(buf);
#endif
return remove(fname); return remove(fname);
} }
@ -464,12 +431,6 @@ UInt32 hsPhysicalMemory()
MEMORYSTATUS ms; MEMORYSTATUS ms;
GlobalMemoryStatus(&ms); GlobalMemoryStatus(&ms);
return (ms.dwTotalPhys / HS_ONE_MEGABYTE); return (ms.dwTotalPhys / HS_ONE_MEGABYTE);
#elif HS_BUILD_FOR_MAC
// Silver, figure out the physical memory here (in MB)
OSErr err;
SInt32 TotPhysicalRAM;
err = Gestalt(gestaltPhysicalRAMSize, &TotPhysicalRAM);
return (TotPhysicalRAM / HS_ONE_MEGABYTE);
#endif #endif
} }
@ -488,128 +449,6 @@ MemSpec hsMemorySpec()
return kOptimal; return kOptimal;
} }
#if HS_BUILD_FOR_MAC
FILE *hsFopen(const char *fname, const char *mode)
{
char buf[500];
#if 0
FILE *f;
hsStrcpy(buf,":");
hsStrcat(buf,fname);
int i;
for(i =0; i < hsStrlen(buf); i++)
if(buf[i] == '\\')
buf[i] = ':';
#endif
hsCPathToMacPath(buf, (char*)fname);
return fopen(buf,mode);
}
#endif
#if HS_BUILD_FOR_PS2
int hsPS2Open(const char name[], const char mode[])
{
char buf[500];
int newMode;
int i;
hsStrcpy(buf,"sim:");
//hsStrcpy(buf,"");
hsStrcat(buf,name);
for(i =0; i < hsStrlen(buf); i++)
if(buf[i] == '\\')
buf[i] = '/';
printf("Opening File %s\n",buf);
if(mode[0] == 'r')
newMode = SCE_RDONLY;
else if(mode[0] == 'w')
newMode = SCE_WRONLY|SCE_CREAT;
else
hsAssert(0,"Bad mode in hsPS2Open\n");
printf("Opening File %s mode =%d\n",buf,newMode);
return sceOpen(buf,newMode);
}
void hsPS2Close( int file )
{
if( file != -1 )
sceClose( file );
}
//FILE *hsFopen(const char *fname, const char *mode)
//{
// FILE *f;
// char buf[500];
// char newMode[10];
// hsStrcpy(buf,"sim:");
// //hsStrcpy(buf,"");
// hsStrcat(buf,fname);
// int i;
// for(i =0; i < hsStrlen(buf); i++)
// if(buf[i] == '\\')
// buf[i] = '/';
// printf("Opening File %s\n",buf);
// if(!strcmp("rt",mode))
// {
// strcpy(newMode, "r");
// }
// else
// strcpy(newMode, mode);
//
// printf("Opening File %s mode =%s\n",buf,newMode);
// f= fopen(buf,newMode);
// if(f)
// return f;
// else
// return nil;
//}
#endif
// Compare lexigraphically two strings
#if !(HS_BUILD_FOR_WIN32 || HS_BUILD_FOR_UNIX)
int hsStrcasecmp(const char *s1, const char *s2)
{
if (s1 && s2)
{
char c1, c2;
while (1)
{
c1 = tolower(*s1++);
c2 = tolower(*s2++);
if (c1 < c2) return -1;
if (c1 > c2) return 1;
if (c1 == '\0') return 0;
}
}
return !s1 ? -1 : 1;
}
// Compare lexigraphically two strings up to a max length
int hsStrncasecmp(const char *s1, const char *s2, int n)
{
if (s1 && s2)
{
int i;
char c1, c2;
for (i=0; i<n; i++)
{
c1 = tolower(*s1++);
c2 = tolower(*s2++);
if (c1 < c2) return -1;
if (c1 > c2) return 1;
if (!c1) return 0;
}
return 0;
}
return !s1 ? -1 : 1;
}
#endif
// //
// Microsoft SAMPLE CODE // Microsoft SAMPLE CODE
// returns array of allocated version info strings or nil // returns array of allocated version info strings or nil

13
Sources/Plasma/CoreLib/hsUtils.h
Unescape View File

@ -185,21 +185,8 @@ inline float hsRandNorm() { return 1.f / 32767.f; } // multiply by hsRand to get
int hsRand(void); int hsRand(void);
void hsRandSeed(int seed); void hsRandSeed(int seed);
#if HS_BUILD_FOR_MAC
FILE* hsFopen(const char name[], const char mode[]); // handles path names with /s
#elif HS_BUILD_FOR_PS2 // HS_BUILD_FOR_MAC
int hsPS2Open(const char name[], const char mode[]);
void hsPS2Close( int file );
#else // HS_BUILD_FOR_MAC
#define hsFopen(name, mode) fopen(name, mode) #define hsFopen(name, mode) fopen(name, mode)
#endif // HS_BUILD_FOR_MAC
char** DisplaySystemVersion(); char** DisplaySystemVersion();
#endif // hsUtils_Defined #endif // hsUtils_Defined

10
Sources/Plasma/CoreLib/hsWindowHndl.h
Unescape View File

@ -45,17 +45,9 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "HeadSpin.h" #include "HeadSpin.h"
// decide what hsWindowHndl is // decide what hsWindowHndl is
#if HS_BUILD_FOR_MAC
#include <QuickDraw.h>
#ifdef HS_MAC_CARBON
typedef WindowPtr hsWindowHndl;
#else
typedef GrafPtr hsWindowHndl;
#endif
#endif
#if HS_BUILD_FOR_WIN32 #if HS_BUILD_FOR_WIN32
typedef struct HWND__ * hsWindowHndl; typedef struct HWND__ * hsWindowHndl;
#elif HS_BUILD_FOR_PS2 || HS_BUILD_FOR_UNIX #elif HS_BUILD_FOR_UNIX
typedef int* hsWindowHndl; typedef int* hsWindowHndl;
#endif #endif

34
Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.cpp
Unescape View File

@ -62,10 +62,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include <stack> #include <stack>
#if HS_BUILD_FOR_MAC
#include <bxwchar.h>
#endif
// MinGW sucks // MinGW sucks
#if defined(_WIN32) && !defined(_MSC_VER) #if defined(_WIN32) && !defined(_MSC_VER)
# define swprintf _snwprintf # define swprintf _snwprintf
@ -183,28 +179,12 @@ XML_Memory_Handling_Suite gHeapAllocator = {
//metmet remove static //metmet remove static
void XMLCALL LocalizationXMLFile::StartTag(void *userData, const XML_Char *element, const XML_Char **attributes) void XMLCALL LocalizationXMLFile::StartTag(void *userData, const XML_Char *element, const XML_Char **attributes)
{ {
#if !HS_BUILD_FOR_MAC
std::wstring wElement = element; std::wstring wElement = element;
#else
// jfim
wchar_t buf[2048], buf2[2048];
BX_Char16ToWchar(element, buf);
std::wstring wElement = buf; // jfim: element;
#endif
LocalizationXMLFile *file = (LocalizationXMLFile*)userData; LocalizationXMLFile *file = (LocalizationXMLFile*)userData;
std::map<std::wstring, std::wstring> wAttributes; std::map<std::wstring, std::wstring> wAttributes;
for (int i = 0; attributes[i]; i += 2) for (int i = 0; attributes[i]; i += 2)
#if !HS_BUILD_FOR_MAC
wAttributes[attributes[i]] = attributes[i+1]; wAttributes[attributes[i]] = attributes[i+1];
#else
{
// jfim
BX_Char16ToWchar(attributes[i], buf);
BX_Char16ToWchar(attributes[i+1], buf2);
wAttributes[buf] = buf2;
}
#endif
LocalizationXMLFile::tagInfo parentTag; LocalizationXMLFile::tagInfo parentTag;
if (!file->fTagStack.empty()) if (!file->fTagStack.empty())
@ -236,14 +216,7 @@ void XMLCALL LocalizationXMLFile::StartTag(void *userData, const XML_Char *eleme
//metmet remove static and include the function inside LocalizationXMLFile //metmet remove static and include the function inside LocalizationXMLFile
void XMLCALL LocalizationXMLFile::EndTag(void *userData, const XML_Char *element) void XMLCALL LocalizationXMLFile::EndTag(void *userData, const XML_Char *element)
{ {
#if !HS_BUILD_FOR_MAC
std::wstring wElement = element; std::wstring wElement = element;
#else
// jfim
wchar_t buf[2048], buf2[2048];
BX_Char16ToWchar(element, buf);
std::wstring wElement = buf; // jfim: element;
#endif
LocalizationXMLFile *file = (LocalizationXMLFile*)userData; LocalizationXMLFile *file = (LocalizationXMLFile*)userData;
if (file->fSkipDepth != -1) // we're currently skipping if (file->fSkipDepth != -1) // we're currently skipping
@ -447,14 +420,7 @@ bool LocalizationXMLFile::Parse(const std::string & fileName)
fLastError += L"ERROR: Parse error at line "; fLastError += L"ERROR: Parse error at line ";
fLastError += lineNumber; fLastError += lineNumber;
fLastError += L": "; fLastError += L": ";
#if !HS_BUILD_FOR_MAC
fLastError += XML_ErrorString(XML_GetErrorCode(fParser)); fLastError += XML_ErrorString(XML_GetErrorCode(fParser));
#else
// jfim
wchar_t buf[2048];
BX_Utf8ToWchar(XML_ErrorString(XML_GetErrorCode(fParser)), buf);
fLastError += buf;
#endif
fLastError += L"\n"; fLastError += L"\n";
XML_ParserFree(fParser); XML_ParserFree(fParser);
fParser = nil; fParser = nil;

4
Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizedString.cpp
Unescape View File

@ -52,10 +52,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "pfLocalizedString.h" #include "pfLocalizedString.h"
#if HS_BUILD_FOR_MAC
#include <bxwchar.h>
#endif
// MinGW sucks // MinGW sucks
#if defined(_WIN32) && !defined(_MSC_VER) #if defined(_WIN32) && !defined(_MSC_VER)
# define swprintf _snwprintf # define swprintf _snwprintf

5
Sources/Plasma/FeatureLib/pfPython/pyEnum.cpp
Unescape View File

@ -53,11 +53,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "structmember.h" #include "structmember.h"
#include "pyGlueHelpers.h" #include "pyGlueHelpers.h"
#if HS_BUILD_FOR_MAC
#include <stdio.h>
#include <bxString.h>
#endif
struct EnumValue { struct EnumValue {
PyObject_HEAD PyObject_HEAD
long value; long value;

68
Sources/Plasma/NucleusLib/pnTimer/hsTimer.cpp
Unescape View File

@ -42,10 +42,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsTimer.h" #include "hsTimer.h"
#include "hsUtils.h" #include "hsUtils.h"
#if HS_BUILD_FOR_MAC
#include <Timer.h>
#endif
#include "plTweak.h" #include "plTweak.h"
// //
@ -241,34 +237,6 @@ hsWide hsTimer::IInitRawBase()
return base; return base;
} }
#elif HS_BUILD_FOR_MAC
#include <Events.h>
#include <DriverServices.h>
//#define HS_USE_TICKCOUNT
hsWide* plTimerShare::GetRawTicks(hsWide* ticks)
{
#ifndef HS_USE_TICKCOUNT
UnsignedWide ns = AbsoluteToNanoseconds(UpTime());
ticks->Set(ns.hi, ns.lo);
#else
ticks->Set(0, TickCount());
#endif
return FactorInTimeZero(ticks);
}
hsWide plTimerShare::IInitRawBase()
{
hsWide base;
#ifndef HS_USE_TICKCOUNT
base.Set(0, 1000000000L);
#else
base.Set(0, 60);
#endif
return base;
}
#elif HS_BUILD_FOR_UNIX #elif HS_BUILD_FOR_UNIX
#include <sys/time.h> #include <sys/time.h>
@ -295,29 +263,6 @@ hsWide hsTimer::IInitRawBase()
return base; return base;
} }
#elif HS_BUILD_FOR_PS2
extern unsigned long psTimerGetCount();
//#define kTickMul (150000000) // kTickMul/kTickDiv :: 4577.636719
#define kTickMul (100000000) // kTickMul/kTickDiv :: 3051.757813 // for debugger
#define kTickDiv (256*128)
hsWide* plTimerShare::GetRawTicks(hsWide* ticks)
{
unsigned long t= psTimerGetCount();
ticks->Set( (Int32)(t>>32), (Int32)(t&((1ul<<32)-1)));
return ticks;
}
hsWide plTimerShare::IInitRawBase()
{
hsWide base;
base.Set(0, kTickMul/kTickDiv );
return base;
}
#endif #endif
// //
@ -351,12 +296,6 @@ double hsTimer::GetPrecTicksPerSec()
} }
return ((double) freq.LowPart); return ((double) freq.LowPart);
#endif #endif
#if HS_BUILD_FOR_MAC
return 1000.f;
#endif
#if HS_BUILD_FOR_PS2
return 1000.f;
#endif
return 1; return 1;
} }
@ -370,13 +309,6 @@ UInt32 hsTimer::GetPrecTickCount()
return ti.LowPart; return ti.LowPart;
#endif #endif
#if HS_BUILD_FOR_MACPPC
return hsTimer::GetMSeconds();
#endif
#if HS_BUILD_FOR_PS2
return hsTimer::GetMSeconds();
#endif
} }
UInt32 hsTimer::PrecSecsToTicks(hsScalar secs) UInt32 hsTimer::PrecSecsToTicks(hsScalar secs)
{ {

2
Sources/Plasma/PubUtilLib/plContainer/hsStringTable.cpp
Unescape View File

@ -41,7 +41,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
*==LICENSE==*/ *==LICENSE==*/
#include "hsStringTable.h" #include "hsStringTable.h"
#include <stdlib.h> #include <stdlib.h>
#if HS_BUILD_FOR_PS2 || __MWERKS__ || HS_BUILD_FOR_UNIX #if HS_BUILD_FOR_UNIX
#include <ctype.h> #include <ctype.h>
#endif #endif
// //

4
Sources/Plasma/PubUtilLib/plFile/CMakeLists.txt
Unescape View File

@ -16,10 +16,6 @@ set(plFile_SOURCES
if(WIN32) if(WIN32)
set(plFile_SOURCES ${plFile_SOURCES} hsFiles_Win.cpp) set(plFile_SOURCES ${plFile_SOURCES} hsFiles_Win.cpp)
elseif(APPLE)
set(plFile_SOURCES ${plFile_SOURCES} hsFiles_Mac.cpp)
#elseif(PS2)
# set(plFile_SOURCES ${plFile_SOURCES} hsFiles_PS2.cpp)
else(WIN32) else(WIN32)
set(plFile_SOURCES ${plFile_SOURCES} hsFiles_Unix.cpp) set(plFile_SOURCES ${plFile_SOURCES} hsFiles_Unix.cpp)
endif(WIN32) endif(WIN32)

6
Sources/Plasma/PubUtilLib/plFile/hsFiles.cpp
Unescape View File

@ -45,9 +45,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsExceptions.h" #include "hsExceptions.h"
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
#define kDirChar ':'
#elif HS_BUILD_FOR_WIN32
#define kDirChar '\\' #define kDirChar '\\'
#else #else
#define kDirChar '/' #define kDirChar '/'
@ -64,7 +62,6 @@ static const char* FindNameInPath(const char path[])
} }
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
#if !HS_BUILD_FOR_PS2
hsFile::hsFile() : fPathAndName(nil), fFILE(nil) hsFile::hsFile() : fPathAndName(nil), fFILE(nil)
{ {
@ -141,7 +138,6 @@ void hsFile::Close()
fFILE = nil; fFILE = nil;
} }
} }
#endif
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////

55
Sources/Plasma/PubUtilLib/plFile/hsFiles.h
Unescape View File

@ -50,15 +50,8 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#define kFolderIterator_MaxPath PATH_MAX #define kFolderIterator_MaxPath PATH_MAX
#include <unistd.h> #include <unistd.h>
#define SetCurrentDirectory chdir #define SetCurrentDirectory chdir
#elif !HS_BUILD_FOR_PS2
#define kFolderIterator_MaxPath _MAX_PATH
#else #else
#define kFolderIterator_MaxPath 255 #define kFolderIterator_MaxPath _MAX_PATH
#endif
#if HS_BUILD_FOR_MAC
#include <Files.h>
#include <Script.h>
#endif #endif
@ -76,7 +69,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
#if !HS_BUILD_FOR_PS2
class hsFile { class hsFile {
hsFile& operator=(const hsFile&); // disallow assignment hsFile& operator=(const hsFile&); // disallow assignment
@ -98,41 +90,8 @@ public:
virtual void Close(); // called automatically in the destructor virtual void Close(); // called automatically in the destructor
}; };
typedef hsFile hsUnixFile; // for compatibility typedef hsFile hsUnixFile; // for compatibility
typedef hsFile hsOSFile;
#if HS_BUILD_FOR_MAC
class hsMacFile : public hsFile {
enum {
kRefNum_Dirty,
kPathName_Dirty
};
FSSpec fSpec;
Int16 fRefNum;
UInt16 fFlags;
void SetSpecFromName();
void SetNameFromSpec();
public:
hsMacFile();
hsMacFile(const FSSpec* spec);
hsMacFile(const char pathAndName[]);
virtual ~hsMacFile();
const FSSpec* GetSpec() const { return &fSpec; }
void SetSpec(const FSSpec* spec);
hsBool Create(OSType creator, OSType fileType, ScriptCode scriptCode = smSystemScript);
hsBool OpenDataFork(SInt8 permission, Int16* refnum);
// Overrides
virtual const char* GetPathAndName();
virtual void SetPathAndName(const char pathAndName[]);
virtual hsStream* OpenStream(const char mode[], hsBool throwIfFailure = false);
virtual void Close();
};
typedef hsMacFile hsOSFile;
#else
typedef hsFile hsOSFile;
#endif
#endif // HS_BUILD_FOR_PS2
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
class hsFolderIterator { class hsFolderIterator {
@ -160,15 +119,7 @@ public:
FILE* OpenFILE(const char mode[]); FILE* OpenFILE(const char mode[]);
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_WIN32
void SetMacFolder(const char path[]);
void SetMacFolder(OSType folderType);
void SetMacFolder(Int16 vRefNum, Int32 dirID);
hsBool NextMacFile(OSType targetFileType, OSType targetCreator);
const struct FSSpec* GetMacSpec() const;
OSType GetMacFileType() const;
OSType GetMacCreator() const;
#elif HS_BUILD_FOR_WIN32
void SetWinSystemDir(const char subdir[]); // e.g. "Fonts" void SetWinSystemDir(const char subdir[]); // e.g. "Fonts"
void SetFileFilterStr(const char filterStr[]); // e.g. "*.*" void SetFileFilterStr(const char filterStr[]); // e.g. "*.*"
#endif #endif

221
Sources/Plasma/PubUtilLib/plGImage/hsDXTSoftwareCodec.cpp
Unescape View File

@ -667,13 +667,8 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT5To16( plMipmap *destBMap, plMip
colors[ 2 ] = IMixTwoThirdsRGB4444( colors[ 0 ], colors[ 1 ] ); colors[ 2 ] = IMixTwoThirdsRGB4444( colors[ 0 ], colors[ 1 ] );
colors[ 3 ] = IMixTwoThirdsRGB4444( colors[ 1 ], colors[ 0 ] ); colors[ 3 ] = IMixTwoThirdsRGB4444( colors[ 1 ], colors[ 0 ] );
cBitSrc1 = srcData[ 2 ]; cBitSrc1 = hsToLE16( srcData[ 2 ] );
cBitSrc2 = srcData[ 3 ]; cBitSrc2 = hsToLE16( srcData[ 3 ] );
#ifdef HS_BUILD_FOR_MAC
cBitSrc1 = ISwapWordOrder( cBitSrc1 );
cBitSrc2 = ISwapWordOrder( cBitSrc2 );
#endif
for( j = 0; j < 8; j++ ) for( j = 0; j < 8; j++ )
{ {
@ -683,10 +678,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT5To16( plMipmap *destBMap, plMip
destBlock[ j + 8 ] = alphas[ aBitSrc2 & 0x07 ] | colors[ cBitSrc2 & 0x03 ]; destBlock[ j + 8 ] = alphas[ aBitSrc2 & 0x07 ] | colors[ cBitSrc2 & 0x03 ];
aBitSrc2 >>= 3; aBitSrc2 >>= 3;
cBitSrc2 >>= 2; cBitSrc2 >>= 2;
#ifdef HS_BUILD_FOR_MAC
destBlock[ j ] = ISwapWordOrder( destBlock[ j ] ); destBlock[ j ] = hsToLE16( destBlock[ j ] );
destBlock[ j + 8 ] = ISwapWordOrder( destBlock[ j + 8 ] ); destBlock[ j + 8 ] = hsToLE16( destBlock[ j + 8 ] );
#endif
} }
/// Now copy the block to the destination bitmap /// Now copy the block to the destination bitmap
@ -828,13 +822,8 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT5To16Weird( plMipmap *destBMap,
colors[ 2 ] = IMixTwoThirdsRGB4444( colors[ 0 ], colors[ 1 ] ); colors[ 2 ] = IMixTwoThirdsRGB4444( colors[ 0 ], colors[ 1 ] );
colors[ 3 ] = IMixTwoThirdsRGB4444( colors[ 1 ], colors[ 0 ] ); colors[ 3 ] = IMixTwoThirdsRGB4444( colors[ 1 ], colors[ 0 ] );
cBitSrc1 = srcData[ 2 ]; cBitSrc1 = hsToLE16( srcData[ 2 ] );
cBitSrc2 = srcData[ 3 ]; cBitSrc2 = hsToLE16( srcData[ 3 ] );
#ifdef HS_BUILD_FOR_MAC
cBitSrc1 = ISwapWordOrder( cBitSrc1 );
cBitSrc2 = ISwapWordOrder( cBitSrc2 );
#endif
for( j = 0; j < 8; j++ ) for( j = 0; j < 8; j++ )
{ {
@ -844,10 +833,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT5To16Weird( plMipmap *destBMap,
destBlock[ j + 8 ] = alphas[ aBitSrc2 & 0x07 ] | colors[ cBitSrc2 & 0x03 ]; destBlock[ j + 8 ] = alphas[ aBitSrc2 & 0x07 ] | colors[ cBitSrc2 & 0x03 ];
aBitSrc2 >>= 3; aBitSrc2 >>= 3;
cBitSrc2 >>= 2; cBitSrc2 >>= 2;
#ifdef HS_BUILD_FOR_MAC
destBlock[ j ] = ISwapWordOrder( destBlock[ j ] ); destBlock[ j ] = hsToLE16( destBlock[ j ] );
destBlock[ j + 8 ] = ISwapWordOrder( destBlock[ j + 8 ] ); destBlock[ j + 8 ] = hsToLE16( destBlock[ j + 8 ] );
#endif
} }
/// Now copy the block to the destination bitmap /// Now copy the block to the destination bitmap
@ -1000,13 +988,8 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT5To32( plMipmap *destBMap, plMip
colors[ 2 ] = IMixTwoThirdsRGB32( colors[ 0 ], colors[ 1 ] ); colors[ 2 ] = IMixTwoThirdsRGB32( colors[ 0 ], colors[ 1 ] );
colors[ 3 ] = IMixTwoThirdsRGB32( colors[ 1 ], colors[ 0 ] ); colors[ 3 ] = IMixTwoThirdsRGB32( colors[ 1 ], colors[ 0 ] );
cBitSrc1 = srcData[ 2 ]; cBitSrc1 = hsToLE16( srcData[ 2 ] );
cBitSrc2 = srcData[ 3 ]; cBitSrc2 = hsToLE16( srcData[ 3 ] );
#ifdef HS_BUILD_FOR_MAC
cBitSrc1 = ( cBitSrc1 >> 8 ) | ( ( cBitSrc1 & 0xff ) << 8 );
cBitSrc2 = ( cBitSrc2 >> 8 ) | ( ( cBitSrc2 & 0xff ) << 8 );
#endif
for( j = 0; j < 8; j++ ) for( j = 0; j < 8; j++ )
{ {
@ -1016,10 +999,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT5To32( plMipmap *destBMap, plMip
destBlock[ j + 8 ] = alphas[ aBitSrc2 & 0x07 ] | colors[ cBitSrc2 & 0x03 ]; destBlock[ j + 8 ] = alphas[ aBitSrc2 & 0x07 ] | colors[ cBitSrc2 & 0x03 ];
aBitSrc2 >>= 3; aBitSrc2 >>= 3;
cBitSrc2 >>= 2; cBitSrc2 >>= 2;
#ifdef HS_BUILD_FOR_MAC
destBlock[ j ] = ISwapDwordOrder( destBlock[ j ] ); destBlock[ j ] = hsToLE32( destBlock[ j ] );
destBlock[ j + 8 ] = ISwapDwordOrder( destBlock[ j + 8 ] ); destBlock[ j + 8 ] = hsToLE32( destBlock[ j + 8 ] );
#endif
} }
/// Now copy the block to the destination bitmap /// Now copy the block to the destination bitmap
@ -1153,13 +1135,8 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT5ToAInten( plMipmap *destBMap, p
colors[ 2 ] = IMixTwoThirdsInten( colors[ 0 ], colors[ 1 ] ); colors[ 2 ] = IMixTwoThirdsInten( colors[ 0 ], colors[ 1 ] );
colors[ 3 ] = IMixTwoThirdsInten( colors[ 1 ], colors[ 0 ] ); colors[ 3 ] = IMixTwoThirdsInten( colors[ 1 ], colors[ 0 ] );
cBitSrc1 = srcData[ 2 ]; cBitSrc1 = hsToLE16( srcData[ 2 ] );
cBitSrc2 = srcData[ 3 ]; cBitSrc2 = hsToLE16( srcData[ 3 ] );
#ifdef HS_BUILD_FOR_MAC
cBitSrc1 = ( cBitSrc1 >> 8 ) | ( ( cBitSrc1 & 0xff ) << 8 );
cBitSrc2 = ( cBitSrc2 >> 8 ) | ( ( cBitSrc2 & 0xff ) << 8 );
#endif
for( j = 0; j < 8; j++ ) for( j = 0; j < 8; j++ )
{ {
@ -1169,10 +1146,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT5ToAInten( plMipmap *destBMap, p
destBlock[ j + 8 ] = alphas[ aBitSrc2 & 0x07 ] | (UInt16)colors[ cBitSrc2 & 0x03 ]; destBlock[ j + 8 ] = alphas[ aBitSrc2 & 0x07 ] | (UInt16)colors[ cBitSrc2 & 0x03 ];
aBitSrc2 >>= 3; aBitSrc2 >>= 3;
cBitSrc2 >>= 2; cBitSrc2 >>= 2;
#ifdef HS_BUILD_FOR_MAC
destBlock[ j ] = ISwapWordOrder( destBlock[ j ] ); destBlock[ j ] = hsToLE16( destBlock[ j ] );
destBlock[ j + 8 ] = ISwapWordOrder( destBlock[ j + 8 ] ); destBlock[ j + 8 ] = hsToLE16( destBlock[ j + 8 ] );
#endif
} }
/// Now copy the block to the destination bitmap /// Now copy the block to the destination bitmap
@ -1246,13 +1222,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1To16( plMipmap *destBMap, plMip
colors[ 0 ] = IRGB565To1555( srcData[ 0 ] ) | 0x8000; // Make sure alpha is set colors[ 0 ] = IRGB565To1555( srcData[ 0 ] ) | 0x8000; // Make sure alpha is set
colors[ 1 ] = IRGB565To1555( srcData[ 1 ] ) | 0x8000; // Make sure alpha is set colors[ 1 ] = IRGB565To1555( srcData[ 1 ] ) | 0x8000; // Make sure alpha is set
#ifdef HS_BUILD_FOR_MAC tempW1 = hsToLE16( srcData[ 0 ] );
tempW1 = ISwapWordOrder( srcData[ 0 ] ); tempW2 = hsToLE16( srcData[ 1 ] );
tempW2 = ISwapWordOrder( srcData[ 1 ] );
#else
tempW1 = srcData[ 0 ];
tempW2 = srcData[ 1 ];
#endif
if( tempW1 > tempW2 ) if( tempW1 > tempW2 )
{ {
/// Four-color block--mix the other two /// Four-color block--mix the other two
@ -1266,13 +1238,8 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1To16( plMipmap *destBMap, plMip
colors[ 3 ] = 0; colors[ 3 ] = 0;
} }
bitSource = srcData[ 2 ]; bitSource = hsToLE16( srcData[ 2 ] );
bitSource2 = srcData[ 3 ]; bitSource2 = hsToLE16( srcData[ 3 ] );
#ifdef HS_BUILD_FOR_MAC
bitSource = ( bitSource >> 8 ) | ( ( bitSource & 0xff ) << 8 );
bitSource2 = ( bitSource2 >> 8 ) | ( ( bitSource2 & 0xff ) << 8 );
#endif
for( j = 0; j < 8; j++ ) for( j = 0; j < 8; j++ )
{ {
@ -1280,10 +1247,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1To16( plMipmap *destBMap, plMip
bitSource >>= 2; bitSource >>= 2;
destBlock[ j + 8 ] = colors[ bitSource2 & 0x03 ]; destBlock[ j + 8 ] = colors[ bitSource2 & 0x03 ];
bitSource2 >>= 2; bitSource2 >>= 2;
#ifdef HS_BUILD_FOR_MAC
destBlock[ j ] = ISwapWordOrder( destBlock[ j ] ); destBlock[ j ] = hsToLE16( destBlock[ j ] );
destBlock[ j + 8 ] = ISwapWordOrder( destBlock[ j + 8 ] ); destBlock[ j + 8 ] = hsToLE16( destBlock[ j + 8 ] );
#endif
} }
/// Now copy the block to the destination bitmap /// Now copy the block to the destination bitmap
@ -1358,13 +1324,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1To16Weird( plMipmap *destBMap,
colors[ 0 ] = IRGB565To5551( srcData[ 0 ] ) | 0x0001; // Make sure alpha is set colors[ 0 ] = IRGB565To5551( srcData[ 0 ] ) | 0x0001; // Make sure alpha is set
colors[ 1 ] = IRGB565To5551( srcData[ 1 ] ) | 0x0001; // Make sure alpha is set colors[ 1 ] = IRGB565To5551( srcData[ 1 ] ) | 0x0001; // Make sure alpha is set
#ifdef HS_BUILD_FOR_MAC tempW1 = hsToLE16( srcData[ 0 ] );
tempW1 = ISwapWordOrder( srcData[ 0 ] ); tempW2 = hsToLE16( srcData[ 1 ] );
tempW2 = ISwapWordOrder( srcData[ 1 ] );
#else
tempW1 = srcData[ 0 ];
tempW2 = srcData[ 1 ];
#endif
if( tempW1 > tempW2 ) if( tempW1 > tempW2 )
{ {
/// Four-color block--mix the other two /// Four-color block--mix the other two
@ -1378,13 +1340,8 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1To16Weird( plMipmap *destBMap,
colors[ 3 ] = 0; colors[ 3 ] = 0;
} }
bitSource = srcData[ 2 ]; bitSource = hsToLE16( srcData[ 2 ] );
bitSource2 = srcData[ 3 ]; bitSource2 = hsToLE16( srcData[ 3 ] );
#ifdef HS_BUILD_FOR_MAC
bitSource = ( bitSource >> 8 ) | ( ( bitSource & 0xff ) << 8 );
bitSource2 = ( bitSource2 >> 8 ) | ( ( bitSource2 & 0xff ) << 8 );
#endif
for( j = 0; j < 8; j++ ) for( j = 0; j < 8; j++ )
{ {
@ -1392,10 +1349,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1To16Weird( plMipmap *destBMap,
bitSource >>= 2; bitSource >>= 2;
destBlock[ j + 8 ] = colors[ bitSource2 & 0x03 ]; destBlock[ j + 8 ] = colors[ bitSource2 & 0x03 ];
bitSource2 >>= 2; bitSource2 >>= 2;
#ifdef HS_BUILD_FOR_MAC
destBlock[ j ] = ISwapWordOrder( destBlock[ j ] ); destBlock[ j ] = hsToLE16( destBlock[ j ] );
destBlock[ j + 8 ] = ISwapWordOrder( destBlock[ j + 8 ] ); destBlock[ j + 8 ] = hsToLE16( destBlock[ j + 8 ] );
#endif
} }
/// Now copy the block to the destination bitmap /// Now copy the block to the destination bitmap
@ -1470,13 +1426,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1To32( plMipmap *destBMap,
colors[ 0 ] = IRGB16To32Bit( srcData[ 0 ] ) | 0xff000000; colors[ 0 ] = IRGB16To32Bit( srcData[ 0 ] ) | 0xff000000;
colors[ 1 ] = IRGB16To32Bit( srcData[ 1 ] ) | 0xff000000; colors[ 1 ] = IRGB16To32Bit( srcData[ 1 ] ) | 0xff000000;
#ifdef HS_BUILD_FOR_MAC tempW1 = hsToLE16( srcData[ 0 ] );
tempW1 = ISwapWordOrder( srcData[ 0 ] ); tempW2 = hsToLE16( srcData[ 1 ] );
tempW2 = ISwapWordOrder( srcData[ 1 ] );
#else
tempW1 = srcData[ 0 ];
tempW2 = srcData[ 1 ];
#endif
if( tempW1 > tempW2 ) if( tempW1 > tempW2 )
{ {
/// Four-color block--mix the other two /// Four-color block--mix the other two
@ -1490,13 +1442,8 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1To32( plMipmap *destBMap,
colors[ 3 ] = 0; colors[ 3 ] = 0;
} }
bitSource = srcData[ 2 ]; bitSource = hsToLE16( srcData[ 2 ] );
bitSource2 = srcData[ 3 ]; bitSource2 = hsToLE16( srcData[ 3 ] );
#ifdef HS_BUILD_FOR_MAC
bitSource = ( bitSource >> 8 ) | ( ( bitSource & 0xff ) << 8 );
bitSource2 = ( bitSource2 >> 8 ) | ( ( bitSource2 & 0xff ) << 8 );
#endif
for( j = 0; j < 8; j++ ) for( j = 0; j < 8; j++ )
{ {
@ -1504,10 +1451,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1To32( plMipmap *destBMap,
bitSource >>= 2; bitSource >>= 2;
destBlock[ j + 8 ] = colors[ bitSource2 & 0x03 ]; destBlock[ j + 8 ] = colors[ bitSource2 & 0x03 ];
bitSource2 >>= 2; bitSource2 >>= 2;
#ifdef HS_BUILD_FOR_MAC
destBlock[ j ] = ISwapDwordOrder( destBlock[ j ] ); destBlock[ j ] = hsToLE32( destBlock[ j ] );
destBlock[ j + 8 ] = ISwapDwordOrder( destBlock[ j + 8 ] ); destBlock[ j + 8 ] = hsToLE32( destBlock[ j + 8 ] );
#endif
} }
/// Now copy the block to the destination bitmap /// Now copy the block to the destination bitmap
@ -1580,13 +1526,9 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1ToInten( plMipmap *destBMap,
colors[ 0 ] = (UInt8)IRGB16To32Bit( srcData[ 0 ] ); colors[ 0 ] = (UInt8)IRGB16To32Bit( srcData[ 0 ] );
colors[ 1 ] = (UInt8)IRGB16To32Bit( srcData[ 1 ] ); colors[ 1 ] = (UInt8)IRGB16To32Bit( srcData[ 1 ] );
#ifdef HS_BUILD_FOR_MAC tempW1 = hsToLE16( srcData[ 0 ] );
tempW1 = ISwapWordOrder( srcData[ 0 ] ); tempW2 = hsToLE16( srcData[ 1 ] );
tempW2 = ISwapWordOrder( srcData[ 1 ] );
#else
tempW1 = srcData[ 0 ];
tempW2 = srcData[ 1 ];
#endif
if( tempW1 > tempW2 ) if( tempW1 > tempW2 )
{ {
/// Four-color block--mix the other two /// Four-color block--mix the other two
@ -1600,13 +1542,8 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1ToInten( plMipmap *destBMap,
colors[ 3 ] = 0; colors[ 3 ] = 0;
} }
bitSource = srcData[ 2 ]; bitSource = hsToLE16( srcData[ 2 ] );
bitSource2 = srcData[ 3 ]; bitSource2 = hsToLE16( srcData[ 3 ] );
#ifdef HS_BUILD_FOR_MAC
bitSource = ( bitSource >> 8 ) | ( ( bitSource & 0xff ) << 8 );
bitSource2 = ( bitSource2 >> 8 ) | ( ( bitSource2 & 0xff ) << 8 );
#endif
for( j = 0; j < 8; j++ ) for( j = 0; j < 8; j++ )
{ {
@ -1650,27 +1587,6 @@ void hsDXTSoftwareCodec::IUncompressMipmapDXT1ToInten( plMipmap *destBMap,
} }
} }
//// ISwapDwordOrder //////////////////////////////////////////////////////////
UInt32 hsDXTSoftwareCodec::ISwapDwordOrder( UInt32 color )
{
UInt8 a, r, g, b;
a = (UInt8)( color >> 24 );
r = (UInt8)( color >> 16 ) & 0xff;
g = (UInt8)( color >> 8 ) & 0xff;
b = (UInt8)( color & 0xff );
return( ( b << 24 ) | ( g << 16 ) | ( r << 8 ) | a );
}
//// ISwapWordOrder ///////////////////////////////////////////////////////////
UInt16 hsDXTSoftwareCodec::ISwapWordOrder( UInt16 color )
{
return( ( color >> 8 ) | ( color << 8 ) );
}
//// IRGB16To32Bit //////////////////////////////////////////////////////////// //// IRGB16To32Bit ////////////////////////////////////////////////////////////
// //
// Converts a RGB565 16-bit color into a RGB888 32-bit color. Alpha (upper 8 // Converts a RGB565 16-bit color into a RGB888 32-bit color. Alpha (upper 8
@ -1681,9 +1597,7 @@ UInt32 hsDXTSoftwareCodec::IRGB16To32Bit( UInt16 color )
{ {
UInt32 r, g, b; UInt32 r, g, b;
#ifdef HS_BUILD_FOR_MAC color = hsToLE16(color);
color = ( ( color >> 8 ) | ( ( color & 0xff ) << 8 ) );
#endif
b = ( color & 31 ) << 3; b = ( color & 31 ) << 3;
color >>= 5; color >>= 5;
@ -1706,9 +1620,7 @@ UInt16 hsDXTSoftwareCodec::IRGB565To4444( UInt16 color )
{ {
UInt16 r, g, b; UInt16 r, g, b;
#ifdef HS_BUILD_FOR_MAC color = hsToLE16( color );
color = ISwapWordOrder( color );
#endif
b = ( color & 31 ) >> 1; b = ( color & 31 ) >> 1;
color >>= 5; color >>= 5;
@ -1733,9 +1645,7 @@ UInt16 hsDXTSoftwareCodec::IRGB565To4444Rev( UInt16 color )
{ {
UInt16 r, g, b; UInt16 r, g, b;
#ifdef HS_BUILD_FOR_MAC color = hsToLE16( color );
color = ISwapWordOrder( color );
#endif
r = ( color & 31 ) >> 1; r = ( color & 31 ) >> 1;
color >>= 5; color >>= 5;
@ -1760,9 +1670,7 @@ UInt16 hsDXTSoftwareCodec::IRGB565To1555( UInt16 color )
{ {
UInt16 r, g, b; UInt16 r, g, b;
#ifdef HS_BUILD_FOR_MAC color = hsToLE16( color );
color = ISwapWordOrder( color );
#endif
b = ( color & 31 ); b = ( color & 31 );
color >>= 5; color >>= 5;
@ -1787,9 +1695,7 @@ UInt16 hsDXTSoftwareCodec::IRGB565To5551( UInt16 color )
{ {
UInt16 rg, b; UInt16 rg, b;
#ifdef HS_BUILD_FOR_MAC color = hsToLE16( color );
color = ISwapWordOrder( color );
#endif
rg = color & 0xffc0; /// Masks off red and green rg = color & 0xffc0; /// Masks off red and green
b = ( color & 31 ); b = ( color & 31 );
@ -2418,13 +2324,8 @@ hsBool hsDXTSoftwareCodec::ColorizeCompMipmap( plMipmap *bMap, const UInt8 *colo
{ {
/// Get the two colors to colorize (our decompression scheme will do the rest... /// Get the two colors to colorize (our decompression scheme will do the rest...
/// handy, eh? :) /// handy, eh? :)
#if HS_BUILD_FOR_MAC color1 = hsToLE16( srcData[ 0 ] );
color1 = ISwapWordOrder( srcData[ 0 ] ); color2 = hsToLE16( srcData[ 1 ] );
color2 = ISwapWordOrder( srcData[ 1 ] );
#else
color1 = srcData[ 0 ];
color2 = srcData[ 1 ];
#endif
/// Now colorize using our age-old formula (see hsGMipmap::ColorLevel for details) /// Now colorize using our age-old formula (see hsGMipmap::ColorLevel for details)
gray = ( ( color1 >> 11 ) & 0x1f ) + ( ( color1 >> 6 ) & 0x1f ) + ( color1 & 0x1f ); gray = ( ( color1 >> 11 ) & 0x1f ) + ( ( color1 >> 6 ) & 0x1f ) + ( color1 & 0x1f );
@ -2484,13 +2385,9 @@ hsBool hsDXTSoftwareCodec::ColorizeCompMipmap( plMipmap *bMap, const UInt8 *colo
} }
/// Write back and go! /// Write back and go!
#if HS_BUILD_FOR_MAC srcData[ 0 ] = hsToLE16( color1 );
srcData[ 0 ] = ISwapWordOrder( color1 ); srcData[ 1 ] = hsToLE16( color2 );
srcData[ 1 ] = ISwapWordOrder( color2 );
#else
srcData[ 0 ] = color1;
srcData[ 1 ] = color2;
#endif
srcData += blockSize; srcData += blockSize;
} }

5
Sources/Plasma/PubUtilLib/plGImage/hsDXTSoftwareCodec.h
Unescape View File

@ -146,11 +146,6 @@ private:
// Converts a color from RGB565 to RGB4444 reversed format, with alpha=0 // Converts a color from RGB565 to RGB4444 reversed format, with alpha=0
UInt16 inline IRGB565To4444Rev( UInt16 color ); UInt16 inline IRGB565To4444Rev( UInt16 color );
// Swaps the bytes in a doubleword
UInt32 inline ISwapDwordOrder( UInt32 color );
// Swaps the bytes in a word
UInt16 inline ISwapWordOrder( UInt16 color );
static hsBool Register(); static hsBool Register();
static hsBool fRegistered; static hsBool fRegistered;
}; };

20
Sources/Plasma/PubUtilLib/plGImage/hsRect.h
Unescape View File

@ -44,32 +44,12 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsPoint2.h" #include "hsPoint2.h"
#if HS_BUILD_FOR_MAC
// This guy disables MetroWerks' desire to only include a file once, which obviously gets
// in the way of our little HS_RECT.inc trick
#pragma once off
#endif
#define HS_RECT_NAME hsIntRect #define HS_RECT_NAME hsIntRect
#define HS_RECT_POINT hsIntPoint2 #define HS_RECT_POINT hsIntPoint2
#define HS_RECT_TYPE Int32 #define HS_RECT_TYPE Int32
#define HS_RECT_EXTEND 1 #define HS_RECT_EXTEND 1
#include "HS_RECT.inc" #include "HS_RECT.inc"
#if HS_BUILD_FOR_MAC
Rect* ToRect(Rect* r) const
{
r->left = (Int16)this->fLeft;
r->top = (Int16)this->fTop;
r->right = (Int16)this->fRight;
r->bottom = (Int16)this->fBottom;
return r;
}
hsIntRect* Set(const Rect* r)
{
return this->Set(r->left, r->top, r->right, r->bottom);
}
#endif
#ifdef _WINDOWS_ #ifdef _WINDOWS_
RECT* ToRECT(RECT* r) const RECT* ToRECT(RECT* r) const
{ {

4
Sources/Plasma/PubUtilLib/plPipeline/hsWinRef.h
Unescape View File

@ -49,10 +49,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsWindows.h" #include "hsWindows.h"
typedef HWND hsWinRef; typedef HWND hsWinRef;
#elif HS_BUILD_FOR_MACPPC
typedef WindowRef hsWinRef;
#else // Whatever #else // Whatever
typedef void* hsWinRef; typedef void* hsWinRef;

12
Sources/Plasma/PubUtilLib/plPipeline/plDXEnumerate.cpp
Unescape View File

@ -217,7 +217,6 @@ HRESULT hsGDirect3DTnLEnumerate::D3DEnum_SelectDefaultDriver( DWORD dwFlags )
} }
else else
{ {
#if !HS_BUILD_FOR_XBOX
if( dwFlags & D3DENUM_CANWINDOW ) if( dwFlags & D3DENUM_CANWINDOW )
{ {
if( (pDriver == &fDrivers[0]) if( (pDriver == &fDrivers[0])
@ -229,7 +228,6 @@ HRESULT hsGDirect3DTnLEnumerate::D3DEnum_SelectDefaultDriver( DWORD dwFlags )
} }
} }
else else
#endif
if( dwFlags & D3DENUM_PRIMARYHAL ) if( dwFlags & D3DENUM_PRIMARYHAL )
{ {
if( pDriver == &fDrivers[0] ) if( pDriver == &fDrivers[0] )
@ -292,7 +290,6 @@ hsGDirect3DTnLEnumerate::hsGDirect3DTnLEnumerate()
/// New DX Enumeration /// New DX Enumeration
// Get a pointer to the creation function // Get a pointer to the creation function
#if !HS_BUILD_FOR_XBOX
if( hsGDDrawDllLoad::GetD3DDll() == nil ) if( hsGDDrawDllLoad::GetD3DDll() == nil )
{ {
strcpy( fEnumeErrorStr, "Cannot load Direct3D driver!" ); strcpy( fEnumeErrorStr, "Cannot load Direct3D driver!" );
@ -308,10 +305,7 @@ hsGDirect3DTnLEnumerate::hsGDirect3DTnLEnumerate()
} }
// Create a D3D object to use // Create a D3D object to use
IDirect3D9 *pD3D = procPtr( D3D_SDK_VERSION ); IDirect3D9 *pD3D = procPtr( D3D_SDK_VERSION );
#else
IDirect3D9 *pD3D = Direct3DCreate9( D3D_SDK_VERSION );
#endif
if( pD3D == nil ) if( pD3D == nil )
{ {
strcpy( fEnumeErrorStr, "Cannot load DirectX!" ); strcpy( fEnumeErrorStr, "Cannot load DirectX!" );
@ -519,12 +513,8 @@ void hsGDirect3DTnLEnumerate::IEnumAdapterDevices( IDirect3D9 *pD3D, UINT iAd
hsBool hsGDirect3DTnLEnumerate::IFindDepthFormats( IDirect3D9 *pD3D, UINT iAdapter, D3DDEVTYPE deviceType, hsBool hsGDirect3DTnLEnumerate::IFindDepthFormats( IDirect3D9 *pD3D, UINT iAdapter, D3DDEVTYPE deviceType,
D3DEnum_ModeInfo *modeInfo ) D3DEnum_ModeInfo *modeInfo )
{ {
#if HS_BUILD_FOR_XBOX
D3DFORMAT formats[] = { D3DFMT_D16, D3DFMT_D24S8, D3DFMT_UNKNOWN };
#else
D3DFORMAT formats[] = { D3DFMT_D16, D3DFMT_D24X8, D3DFMT_D32, D3DFORMAT formats[] = { D3DFMT_D16, D3DFMT_D24X8, D3DFMT_D32,
D3DFMT_D15S1, D3DFMT_D24X4S4, D3DFMT_D24S8, D3DFMT_UNKNOWN }; D3DFMT_D15S1, D3DFMT_D24X4S4, D3DFMT_D24S8, D3DFMT_UNKNOWN };
#endif
/// Try 'em /// Try 'em
for( int i = 0; formats[ i ] != D3DFMT_UNKNOWN; i++ ) for( int i = 0; formats[ i ] != D3DFMT_UNKNOWN; i++ )

2
Sources/Plasma/PubUtilLib/plPipeline/plDXPipeline.cpp
Unescape View File

@ -5367,13 +5367,11 @@ void plDXPipeline::ISetFogParameters(const plSpan* span, const plLayerInterface*
bool forceLoad = false; bool forceLoad = false;
D3DRENDERSTATETYPE d3dFogType = D3DRS_FOGTABLEMODE; // Use VERTEXMODE for vertex fog D3DRENDERSTATETYPE d3dFogType = D3DRS_FOGTABLEMODE; // Use VERTEXMODE for vertex fog
#if !HS_BUILD_FOR_XBOX
if (!(fSettings.fD3DCaps & kCapsPixelFog) || isShader) if (!(fSettings.fD3DCaps & kCapsPixelFog) || isShader)
{ {
d3dFogType = D3DRS_FOGVERTEXMODE; d3dFogType = D3DRS_FOGVERTEXMODE;
isVertex = true; isVertex = true;
} }
#endif
// Quick check // Quick check
if ((fCurrFog.fEnvPtr == fog) && (fCurrFog.fIsVertex == isVertex) && (fCurrFog.fIsShader == isShader)) if ((fCurrFog.fEnvPtr == fog) && (fCurrFog.fIsVertex == isVertex) && (fCurrFog.fIsShader == isShader))

4
Sources/Plasma/PubUtilLib/plPipeline/plDXTextFont.cpp
Unescape View File

@ -57,10 +57,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include <ddraw.h> #include <ddraw.h>
#include <d3dx9mesh.h> #include <d3dx9mesh.h>
#if HS_BUILD_FOR_MAC
#include <QuickDraw.h>
#endif
#include "hsWinRef.h" #include "hsWinRef.h"
#include "hsTypes.h" #include "hsTypes.h"
#include "plDXTextFont.h" #include "plDXTextFont.h"

3
Sources/Plasma/PubUtilLib/plTransform/mat_decomp.cpp
Unescape View File

@ -46,9 +46,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
// //
#include <math.h> #include <math.h>
#include "mat_decomp.h" #include "mat_decomp.h"
#ifdef __MWERKS__
//#pragma optimization_level 0
#endif
/******* Matrix Preliminaries *******/ /******* Matrix Preliminaries *******/

Write Preview
Loading…
Cancel
Save