OU/CWE-ou-minkata
2
3
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-14 02:27:40 -04:00
Code Releases Activity

Fix line endings and tabs

Browse Source
This commit is contained in:
Branan Purvine-Riley
2011-04-11 16:27:55 -07:00
parent d4250e19b5
commit 908aaeb6f6
2738 changed files with 702562 additions and 702562 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
CMakeLists.txt
View File

@ -20,24 +20,24 @@ find_package(Bink) #TODO: Find Bink, but don't require it if plPipeli
option(PLASMA_EXTERNAL_RELEASE "Is this release intended for the general public?" OFF) option(PLASMA_EXTERNAL_RELEASE "Is this release intended for the general public?" OFF)
if(PLASMA_EXTERNAL_RELEASE) if(PLASMA_EXTERNAL_RELEASE)
add_definitions(-DPLASMA_EXTERNAL_RELEASE) add_definitions(-DPLASMA_EXTERNAL_RELEASE)
endif(PLASMA_EXTERNAL_RELEASE) endif(PLASMA_EXTERNAL_RELEASE)
set(PLASMA_BUILD_TYPE "Live" set(PLASMA_BUILD_TYPE "Live"
CACHE STRING "Which type of client to build") CACHE STRING "Which type of client to build")
set_property(CACHE PLASMA_BUILD_TYPE PROPERTY STRINGS set_property(CACHE PLASMA_BUILD_TYPE PROPERTY STRINGS
"Dev" "QA" "Test" "Beta" "Live") "Dev" "QA" "Test" "Beta" "Live")
if(PLASMA_BUILD_TYPE STREQUAL "Dev") if(PLASMA_BUILD_TYPE STREQUAL "Dev")
add_definitions(-DBUILD_TYPE=BUILD_TYPE_DEV) add_definitions(-DBUILD_TYPE=BUILD_TYPE_DEV)
elseif(PLASMA_BUILD_TYPE STREQUAL "QA") elseif(PLASMA_BUILD_TYPE STREQUAL "QA")
add_definitions(-DBUILD_TYPE=BUILD_TYPE_QA) add_definitions(-DBUILD_TYPE=BUILD_TYPE_QA)
elseif(PLASMA_BUILD_TYPE STREQUAL "Test") elseif(PLASMA_BUILD_TYPE STREQUAL "Test")
add_definitions(-DBUILD_TYPE=BUILD_TYPE_TEST) add_definitions(-DBUILD_TYPE=BUILD_TYPE_TEST)
elseif(PLASMA_BUILD_TYPE STREQUAL "Beta") elseif(PLASMA_BUILD_TYPE STREQUAL "Beta")
add_definitions(-DBUILD_TYPE=BUILD_TYPE_BETA) add_definitions(-DBUILD_TYPE=BUILD_TYPE_BETA)
elseif(PLASMA_BUILD_TYPE STREQUAL "Live") elseif(PLASMA_BUILD_TYPE STREQUAL "Live")
add_definitions(-DBUILD_TYPE=BUILD_TYPE_LIVE) add_definitions(-DBUILD_TYPE=BUILD_TYPE_LIVE)
endif(PLASMA_BUILD_TYPE STREQUAL "Dev") endif(PLASMA_BUILD_TYPE STREQUAL "Dev")
set(PLASMA_TARGETS "Client" set(PLASMA_TARGETS "Client"
@ -46,24 +46,24 @@ set_property(CACHE PLASMA_TARGETS PROPERTY STRINGS
"Client" "Server" "Patcher" "Ethereal" "NoAvMsgs") "Client" "Server" "Patcher" "Ethereal" "NoAvMsgs")
if(PLASMA_TARGETS STREQUAL "Patcher") if(PLASMA_TARGETS STREQUAL "Patcher")
add_definitions(-DPATCHER) add_definitions(-DPATCHER)
endif(PLASMA_TARGETS STREQUAL "Patcher") endif(PLASMA_TARGETS STREQUAL "Patcher")
if(PLASMA_TARGETS STREQUAL "Server") if(PLASMA_TARGETS STREQUAL "Server")
add_definitions(-DSERVER) add_definitions(-DSERVER)
endif(PLASMA_TARGETS STREQUAL "Server") endif(PLASMA_TARGETS STREQUAL "Server")
if(PLASMA_TARGETS STREQUAL "NoAvMsgs") if(PLASMA_TARGETS STREQUAL "NoAvMsgs")
add_definitions(-DNO_AV_MSGS) add_definitions(-DNO_AV_MSGS)
endif(PLASMA_TARGETS STREQUAL "NoAvMsgs") endif(PLASMA_TARGETS STREQUAL "NoAvMsgs")
if(PLASMA_TARGETS STREQUAL "Ethereal") if(PLASMA_TARGETS STREQUAL "Ethereal")
add_definitions(-DSTREAM_LOGGER) add_definitions(-DSTREAM_LOGGER)
endif(PLASMA_TARGETS STREQUAL "Ethereal") endif(PLASMA_TARGETS STREQUAL "Ethereal")
if(MSVC) if(MSVC)
add_definitions(-D_CRT_SECURE_NO_WARNINGS) add_definitions(-D_CRT_SECURE_NO_WARNINGS)
add_definitions(-D_SCL_SECURE_NO_WARNINGS) add_definitions(-D_SCL_SECURE_NO_WARNINGS)
endif(MSVC) endif(MSVC)
add_subdirectory(Sources/Plasma) add_subdirectory(Sources/Plasma)

142
Sources/Plasma/Apps/plClient/CMakeLists.txt
View File

@ -8,86 +8,86 @@ include_directories("../../PubUtilLib/inc")
include_directories("../../PubUtilLib") include_directories("../../PubUtilLib")
if(Bink_SDK_AVAILABLE) if(Bink_SDK_AVAILABLE)
include_directories(${Bink_INCLUDE_DIR}) include_directories(${Bink_INCLUDE_DIR})
endif() endif()
include_directories(${OPENAL_INCLUDE_DIR}) include_directories(${OPENAL_INCLUDE_DIR})
include_directories(${OPENSSL_INCLUDE_DIR}) include_directories(${OPENSSL_INCLUDE_DIR})
include_directories(${PYTHON_INCLUDE_DIR}) include_directories(${PYTHON_INCLUDE_DIR})
set(plClient_HEADERS set(plClient_HEADERS
plClient.h plClient.h
plClientCreatable.h plClientCreatable.h
#plClientKey.h #plClientKey.h
plClientUpdateFormat.h plClientUpdateFormat.h
#plPluginClient.h #plPluginClient.h
) )
set(plClient_SOURCES set(plClient_SOURCES
pfAllCreatables.cpp pfAllCreatables.cpp
plAllCreatables.cpp plAllCreatables.cpp
plClient.cpp plClient.cpp
#plClientKey.cpp #plClientKey.cpp
#plPluginClient.cpp #plPluginClient.cpp
pnAllCreatables.cpp pnAllCreatables.cpp
winmain.cpp winmain.cpp
) )
set(plClient_TEXT set(plClient_TEXT
../../../../Docs/ReleaseNotes/ReleaseNotes.txt ../../../../Docs/ReleaseNotes/ReleaseNotes.txt
) )
set(plClient_RESOURCES set(plClient_RESOURCES
res/plClient.rc res/plClient.rc
res/resource.h res/resource.h
res/banner.bmp res/banner.bmp
res/bitmap1.bmp res/bitmap1.bmp
res/bitmap2.bmp res/bitmap2.bmp
res/bitmap3.bmp res/bitmap3.bmp
res/bmp00001.bmp res/bmp00001.bmp
res/bmp00002.bmp res/bmp00002.bmp
res/bmp00003.bmp res/bmp00003.bmp
res/bmp00004.bmp res/bmp00004.bmp
res/bmp00005.bmp res/bmp00005.bmp
res/book.bmp res/book.bmp
res/book_cli.bmp res/book_cli.bmp
res/book_hig.bmp res/book_hig.bmp
res/cnsl1.bin res/cnsl1.bin
res/cursor_clicked.bmp res/cursor_clicked.bmp
res/cursor_disabled.bmp res/cursor_disabled.bmp
res/cursor_down.bmp res/cursor_down.bmp
res/cursor_grab.bmp res/cursor_grab.bmp
res/cursor_left.bmp res/cursor_left.bmp
res/cursor_open.bmp res/cursor_open.bmp
res/cursor_poised.bmp res/cursor_poised.bmp
res/cursor_right.bmp res/cursor_right.bmp
res/cursor_u.bmp res/cursor_u.bmp
res/cursor_up.bmp res/cursor_up.bmp
res/cursor_upward.bmp res/cursor_upward.bmp
res/Dirt.ICO res/Dirt.ICO
res/headspin.ico res/headspin.ico
res/Microphone.bmp res/Microphone.bmp
res/Speaker.bmp res/Speaker.bmp
res/xLoading_Linking.01.jpg res/xLoading_Linking.01.jpg
res/xLoading_Linking.02.jpg res/xLoading_Linking.02.jpg
res/xLoading_Linking.03.jpg res/xLoading_Linking.03.jpg
res/xLoading_Linking.04.jpg res/xLoading_Linking.04.jpg
res/xLoading_Linking.05.jpg res/xLoading_Linking.05.jpg
res/xLoading_Linking.06.jpg res/xLoading_Linking.06.jpg
res/xLoading_Linking.07.jpg res/xLoading_Linking.07.jpg
res/xLoading_Linking.08.jpg res/xLoading_Linking.08.jpg
res/xLoading_Linking.09.jpg res/xLoading_Linking.09.jpg
res/xLoading_Linking.10.jpg res/xLoading_Linking.10.jpg
res/xLoading_Linking.11.jpg res/xLoading_Linking.11.jpg
res/xLoading_Linking.12.jpg res/xLoading_Linking.12.jpg
res/xLoading_Linking.13.jpg res/xLoading_Linking.13.jpg
res/xLoading_Linking.14.jpg res/xLoading_Linking.14.jpg
res/xLoading_Linking.15.jpg res/xLoading_Linking.15.jpg
res/xLoading_Linking.16.jpg res/xLoading_Linking.16.jpg
res/xLoading_Linking.17.jpg res/xLoading_Linking.17.jpg
res/xLoading_Linking.18.jpg res/xLoading_Linking.18.jpg
res/xLoading_Linking_Text.jpg res/xLoading_Linking_Text.jpg
res/xLoading_Updating_Text.jpg res/xLoading_Updating_Text.jpg
) )
add_executable(plClient WIN32 ${plClient_SOURCES} ${plClient_HEADERS} add_executable(plClient WIN32 ${plClient_SOURCES} ${plClient_HEADERS}
@ -195,16 +195,16 @@ target_link_libraries(plClient ${Vorbis_LIBRARIES})
target_link_libraries(plClient ${DirectX_LIBRARIES}) target_link_libraries(plClient ${DirectX_LIBRARIES})
if(Bink_SDK_AVAILABLE) if(Bink_SDK_AVAILABLE)
target_link_libraries(plClient ${Bink_LIBRARIES}) target_link_libraries(plClient ${Bink_LIBRARIES})
endif() endif()
if (WIN32) if (WIN32)
target_link_libraries(plClient Rpcrt4) target_link_libraries(plClient Rpcrt4)
target_link_libraries(plClient Winhttp) target_link_libraries(plClient Winhttp)
target_link_libraries(plClient Version) target_link_libraries(plClient Version)
target_link_libraries(plClient Vfw32) target_link_libraries(plClient Vfw32)
target_link_libraries(plClient Ws2_32) target_link_libraries(plClient Ws2_32)
target_link_libraries(plClient strmiids) target_link_libraries(plClient strmiids)
endif(WIN32) endif(WIN32)
source_group("Source Files" FILES ${plClient_SOURCES}) source_group("Source Files" FILES ${plClient_SOURCES})

3492
Sources/Plasma/Apps/plClient/plClient.cpp
View File

File diff suppressed because it is too large Load Diff

304
Sources/Plasma/Apps/plClient/plClient.h
View File

@ -74,221 +74,221 @@ class plClient : public hsKeyedObject
{ {
protected: protected:
class plRoomRec class plRoomRec
{ {
public: public:
plSceneNode *fNode; plSceneNode *fNode;
UInt32 fFlags; UInt32 fFlags;
plRoomRec() { fNode = nil; fFlags = 0; } plRoomRec() { fNode = nil; fFlags = 0; }
plRoomRec( plSceneNode *n, UInt32 f ) : fNode( n ), fFlags( f ) {} plRoomRec( plSceneNode *n, UInt32 f ) : fNode( n ), fFlags( f ) {}
enum Flags enum Flags
{ {
kHeld = 0x00000001 kHeld = 0x00000001
}; };
}; };
hsBitVector fFlags; hsBitVector fFlags;
plInputManager* fInputManager; plInputManager* fInputManager;
plPageTreeMgr* fPageMgr; plPageTreeMgr* fPageMgr;
hsTArray<plRoomRec> fRooms; hsTArray<plRoomRec> fRooms;
plSceneNode* fCurrentNode; plSceneNode* fCurrentNode;
plPipeline* fPipeline; plPipeline* fPipeline;
hsColorRGBA fClearColor; hsColorRGBA fClearColor;
plTransitionMgr *fTransitionMgr; plTransitionMgr *fTransitionMgr;
plLinkEffectsMgr *fLinkEffectsMgr; plLinkEffectsMgr *fLinkEffectsMgr;
plFontCache *fFontCache; plFontCache *fFontCache;
pfConsoleEngine* fConsoleEngine; pfConsoleEngine* fConsoleEngine;
pfConsole* fConsole; pfConsole* fConsole;
pfKI *fKIGUIGlue; pfKI *fKIGUIGlue;
hsBool fDone; hsBool fDone;
hsBool fWindowActive; hsBool fWindowActive;
hsWindowHndl fWindowHndl; hsWindowHndl fWindowHndl;
double fLastProgressUpdate; double fLastProgressUpdate;
plOperationProgress *fProgressBar; plOperationProgress *fProgressBar;
pfGameGUIMgr *fGameGUIMgr; pfGameGUIMgr *fGameGUIMgr;
virtual hsG3DDeviceModeRecord ILoadDevMode(const char* devModeFile); virtual hsG3DDeviceModeRecord ILoadDevMode(const char* devModeFile);
hsBool IUpdate(); hsBool IUpdate();
hsBool IDraw(); hsBool IDraw();
hsBool IDrawProgress(); hsBool IDrawProgress();
plVirtualCam1* fNewCamera; plVirtualCam1* fNewCamera;
static plClient* fInstance; static plClient* fInstance;
char * fpAuxInitDir; char * fpAuxInitDir;
static hsBool fDelayMS; static hsBool fDelayMS;
int fClampCap; int fClampCap;
int fQuality; int fQuality;
hsBool fQuitIntro; hsBool fQuitIntro;
hsTArray<plBinkPlayer*> fMovies; hsTArray<plBinkPlayer*> fMovies;
hsBool fPatchGlobalAges; hsBool fPatchGlobalAges;
plMessagePumpProc fMessagePumpProc; plMessagePumpProc fMessagePumpProc;
#ifndef PLASMA_EXTERNAL_RELEASE #ifndef PLASMA_EXTERNAL_RELEASE
bool bPythonDebugConnected; bool bPythonDebugConnected;
#endif #endif
hsTArray<plRenderRequest*> fPreRenderRequests; hsTArray<plRenderRequest*> fPreRenderRequests;
hsTArray<plRenderRequest*> fPostRenderRequests; hsTArray<plRenderRequest*> fPostRenderRequests;
bool fHoldLoadRequests; bool fHoldLoadRequests;
class LoadRequest class LoadRequest
{ {
public: public:
LoadRequest(const plLocation& loc, bool hold) { this->loc = loc; this->hold = hold; } LoadRequest(const plLocation& loc, bool hold) { this->loc = loc; this->hold = hold; }
plLocation loc; plLocation loc;
bool hold; bool hold;
}; };
typedef std::list<LoadRequest*> LoadList; typedef std::list<LoadRequest*> LoadList;
LoadList fLoadRooms; LoadList fLoadRooms;
int fNumLoadingRooms; // Number of rooms we're waiting for load callbacks on int fNumLoadingRooms; // Number of rooms we're waiting for load callbacks on
std::vector<plLocation> fRoomsLoading; // the locations we are currently in the middle of loading std::vector<plLocation> fRoomsLoading; // the locations we are currently in the middle of loading
int fNumPostLoadMsgs; int fNumPostLoadMsgs;
float fPostLoadMsgInc; float fPostLoadMsgInc;
void ICompleteInit (); void ICompleteInit ();
void IOnAsyncInitComplete (); void IOnAsyncInitComplete ();
void IHandlePreloaderMsg (plPreloaderMsg * msg); void IHandlePreloaderMsg (plPreloaderMsg * msg);
void IHandleNetCommAuthMsg (plNetCommAuthMsg * msg); void IHandleNetCommAuthMsg (plNetCommAuthMsg * msg);
bool IHandleAgeLoaded2Msg (plAgeLoaded2Msg * msg); bool IHandleAgeLoaded2Msg (plAgeLoaded2Msg * msg);
hsBool IFlushRenderRequests(); hsBool IFlushRenderRequests();
void IProcessPreRenderRequests(); void IProcessPreRenderRequests();
void IProcessPostRenderRequests(); void IProcessPostRenderRequests();
void IProcessRenderRequests(hsTArray<plRenderRequest*>& reqs); void IProcessRenderRequests(hsTArray<plRenderRequest*>& reqs);
void IAddRenderRequest(plRenderRequest* req); void IAddRenderRequest(plRenderRequest* req);
hsBool IPlayIntroBink(const char* movieName, hsScalar endDelay, hsScalar posX, hsScalar posY, hsScalar scaleX, hsScalar scaleY, hsScalar volume = 1.0); hsBool IPlayIntroBink(const char* movieName, hsScalar endDelay, hsScalar posX, hsScalar posY, hsScalar scaleX, hsScalar scaleY, hsScalar volume = 1.0);
hsBool IHandleMovieMsg(plMovieMsg* mov); hsBool IHandleMovieMsg(plMovieMsg* mov);
void IKillMovies(); void IKillMovies();
void IServiceMovies(); void IServiceMovies();
void IStartProgress( const char *title, hsScalar len ); void IStartProgress( const char *title, hsScalar len );
void IIncProgress( hsScalar byHowMuch, const char *text ); void IIncProgress( hsScalar byHowMuch, const char *text );
void IStopProgress( void ); void IStopProgress( void );
static void IDispatchMsgReceiveCallback(); static void IDispatchMsgReceiveCallback();
static void IReadKeyedObjCallback(plKey key); static void IReadKeyedObjCallback(plKey key);
static void IProgressMgrCallbackProc( plOperationProgress *progress ); static void IProgressMgrCallbackProc( plOperationProgress *progress );
void IPatchGlobalAgeFiles( void ); void IPatchGlobalAgeFiles( void );
int IFindRoomByLoc(const plLocation& loc); int IFindRoomByLoc(const plLocation& loc);
bool IIsRoomLoading(const plLocation& loc); bool IIsRoomLoading(const plLocation& loc);
void IQueueRoomLoad(const std::vector<plLocation>& locs, bool hold); void IQueueRoomLoad(const std::vector<plLocation>& locs, bool hold);
void ILoadNextRoom(); void ILoadNextRoom();
void IUnloadRooms(const std::vector<plLocation>& locs); void IUnloadRooms(const std::vector<plLocation>& locs);
void IRoomLoaded(plSceneNode* node, bool hold); void IRoomLoaded(plSceneNode* node, bool hold);
void IRoomUnloaded(plSceneNode* node); void IRoomUnloaded(plSceneNode* node);
void ISetGraphicsDefaults(); void ISetGraphicsDefaults();
public: public:
plClient(); plClient();
virtual ~plClient(); virtual ~plClient();
CLASSNAME_REGISTER( plClient ); CLASSNAME_REGISTER( plClient );
GETINTERFACE_ANY( plClient, hsKeyedObject ); GETINTERFACE_ANY( plClient, hsKeyedObject );
static plClient* GetInstance() { return fInstance; } static plClient* GetInstance() { return fInstance; }
static void SetInstance(plClient* v) { fInstance=v; } static void SetInstance(plClient* v) { fInstance=v; }
virtual hsBool MsgReceive(plMessage* msg); virtual hsBool MsgReceive(plMessage* msg);
hsBool InitPipeline(); hsBool InitPipeline();
void InitInputs(); void InitInputs();
void InitDLLs(); void InitDLLs();
void ShutdownDLLs(); void ShutdownDLLs();
void InitAuxInits(); void InitAuxInits();
virtual hsBool StartInit(); virtual hsBool StartInit();
virtual hsBool Shutdown(); virtual hsBool Shutdown();
virtual hsBool MainLoop(); virtual hsBool MainLoop();
plClient& SetDone(hsBool done) { fDone = done; return *this; } plClient& SetDone(hsBool done) { fDone = done; return *this; }
hsBool GetDone() { return fDone; } hsBool GetDone() { return fDone; }
// Set this to true to queue any room load requests that come in. Set it to false to process them. // Set this to true to queue any room load requests that come in. Set it to false to process them.
void SetHoldLoadRequests(bool hold); void SetHoldLoadRequests(bool hold);
enum enum
{ {
kFlagIniting, kFlagIniting,
kFlagDBGDisableRender, kFlagDBGDisableRender,
kFlagDBGDisableRRequests, kFlagDBGDisableRRequests,
kFlagAsyncInitComplete, kFlagAsyncInitComplete,
kFlagGlobalDataLoaded, kFlagGlobalDataLoaded,
}; };
hsBool HasFlag(int f) const { return fFlags.IsBitSet(f); } hsBool HasFlag(int f) const { return fFlags.IsBitSet(f); }
void SetFlag(int f, hsBool on=true) { fFlags.SetBit(f, on); } void SetFlag(int f, hsBool on=true) { fFlags.SetBit(f, on); }
virtual plClient& SetWindowHandle(hsWindowHndl hndl) { fWindowHndl=hndl; return *this; } virtual plClient& SetWindowHandle(hsWindowHndl hndl) { fWindowHndl=hndl; return *this; }
hsWindowHndl GetWindowHandle() { return fWindowHndl; } hsWindowHndl GetWindowHandle() { return fWindowHndl; }
plInputManager* GetInputManager() { return fInputManager; } plInputManager* GetInputManager() { return fInputManager; }
plPipeline* GetPipeline() { return fPipeline; } plPipeline* GetPipeline() { return fPipeline; }
plSceneNode* GetCurrentScene() { return fCurrentNode; } plSceneNode* GetCurrentScene() { return fCurrentNode; }
pfConsoleEngine *GetConsoleEngine() { return fConsoleEngine; } pfConsoleEngine *GetConsoleEngine() { return fConsoleEngine; }
void SetAuxInitDir(const char *p) { delete [] fpAuxInitDir; fpAuxInitDir = hsStrcpy(p); } void SetAuxInitDir(const char *p) { delete [] fpAuxInitDir; fpAuxInitDir = hsStrcpy(p); }
static void EnableClientDelay() { plClient::fDelayMS = true; } static void EnableClientDelay() { plClient::fDelayMS = true; }
// These are a hack to let the console fake a lesser capabile board and test out quality settings. // These are a hack to let the console fake a lesser capabile board and test out quality settings.
// They should go away once we have this built into ClientSetup et.al. // They should go away once we have this built into ClientSetup et.al.
void SetClampCap(int c) { fClampCap = c; } void SetClampCap(int c) { fClampCap = c; }
int GetClampCap() const { return fClampCap; } int GetClampCap() const { return fClampCap; }
void SetQuality(int q) { fQuality = q; } void SetQuality(int q) { fQuality = q; }
int GetQuality() const { return fQuality; } int GetQuality() const { return fQuality; }
hsBool GetQuitIntro() const { return fQuitIntro; } hsBool GetQuitIntro() const { return fQuitIntro; }
void SetQuitIntro(hsBool on) { fQuitIntro = on; } void SetQuitIntro(hsBool on) { fQuitIntro = on; }
void SetClearColor( hsColorRGBA &color ); void SetClearColor( hsColorRGBA &color );
hsColorRGBA GetClearColor() const { return fClearColor; } hsColorRGBA GetClearColor() const { return fClearColor; }
// The client window has focus (true) or lost it (false) // The client window has focus (true) or lost it (false)
virtual void WindowActivate(bool active); virtual void WindowActivate(bool active);
virtual hsBool WindowActive() const { return fWindowActive; } virtual hsBool WindowActive() const { return fWindowActive; }
void SetMessagePumpProc( plMessagePumpProc proc ) { fMessagePumpProc = proc; } void SetMessagePumpProc( plMessagePumpProc proc ) { fMessagePumpProc = proc; }
void ResetDisplayDevice(int Width, int Height, int ColorDepth, hsBool Windowed, int NumAASamples, int MaxAnisotropicSamples, hsBool VSync = false, hsBool windowOnly = false); void ResetDisplayDevice(int Width, int Height, int ColorDepth, hsBool Windowed, int NumAASamples, int MaxAnisotropicSamples, hsBool VSync = false, hsBool windowOnly = false);
void IDetectAudioVideoSettings(); void IDetectAudioVideoSettings();
void IWriteDefaultGraphicsSettings(const wchar* destFile); void IWriteDefaultGraphicsSettings(const wchar* destFile);
plAnimDebugList *fAnimDebugList; plAnimDebugList *fAnimDebugList;
#if 0 #if 0
std::string fUsername; std::string fUsername;
std::string fPasswordDigest; std::string fPasswordDigest;
std::string fServer; std::string fServer;
int fPlayerID; int fPlayerID;
bool fRecreatePlayer; bool fRecreatePlayer;
bool fAuthPassed; bool fAuthPassed;
#endif #endif
}; };

10
Sources/Plasma/Apps/plClient/plClientUpdateFormat.h
View File

@ -28,11 +28,11 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
namespace ClientUpdate namespace ClientUpdate
{ {
enum enum
{ {
kUpdate, kUpdate,
kShutdown, kShutdown,
}; };
} }
// //

BIN
Sources/Plasma/Apps/plClient/res/Dirt.ICO
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.2 KiB

After

Width:  |  Height:  |  Size: 2.2 KiB

BIN
Sources/Plasma/Apps/plClient/res/Microphone.bmp
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 630 B

After

Width:  |  Height:  |  Size: 646 B

BIN
Sources/Plasma/Apps/plClient/res/Speaker.bmp
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 630 B

After

Width:  |  Height:  |  Size: 631 B

BIN
Sources/Plasma/Apps/plClient/res/banner.bmp
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 70 KiB

After

Width:  |  Height:  |  Size: 70 KiB

BIN
Sources/Plasma/Apps/plClient/res/bmp00004.bmp
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.1 KiB

After

Width:  |  Height:  |  Size: 2.1 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.01.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.4 KiB

After

Width:  |  Height:  |  Size: 6.4 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.02.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.3 KiB

After

Width:  |  Height:  |  Size: 6.4 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.03.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.3 KiB

After

Width:  |  Height:  |  Size: 6.3 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.04.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.4 KiB

After

Width:  |  Height:  |  Size: 6.4 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.05.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.3 KiB

After

Width:  |  Height:  |  Size: 6.3 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.06.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.4 KiB

After

Width:  |  Height:  |  Size: 6.4 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.07.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.3 KiB

After

Width:  |  Height:  |  Size: 6.3 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.08.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.4 KiB

After

Width:  |  Height:  |  Size: 6.4 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.09.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.3 KiB

After

Width:  |  Height:  |  Size: 6.3 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.10.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.3 KiB

After

Width:  |  Height:  |  Size: 6.4 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.11.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.3 KiB

After

Width:  |  Height:  |  Size: 6.3 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.12.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.4 KiB

After

Width:  |  Height:  |  Size: 6.4 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.13.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.2 KiB

After

Width:  |  Height:  |  Size: 6.3 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.14.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.4 KiB

After

Width:  |  Height:  |  Size: 6.4 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.15.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.3 KiB

After

Width:  |  Height:  |  Size: 6.3 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.16.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.3 KiB

After

Width:  |  Height:  |  Size: 6.4 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.17.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.3 KiB

After

Width:  |  Height:  |  Size: 6.3 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking.18.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.4 KiB

After

Width:  |  Height:  |  Size: 6.4 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Linking_Text.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 29 KiB

After

Width:  |  Height:  |  Size: 30 KiB

BIN
Sources/Plasma/Apps/plClient/res/xLoading_Updating_Text.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 29 KiB

After

Width:  |  Height:  |  Size: 30 KiB

2854
Sources/Plasma/Apps/plClient/winmain.cpp
View File

File diff suppressed because it is too large Load Diff

8
Sources/Plasma/Apps/plClientKey/DllMain.cpp
View File

@ -27,9 +27,9 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
__declspec(dllexport) const unsigned long* GetKey() __declspec(dllexport) const unsigned long* GetKey()
{ {
// So the crackers know who the tard is // So the crackers know who the tard is
static const char* tauntText = "My copy protection is uncrackable! -Brice"; static const char* tauntText = "My copy protection is uncrackable! -Brice";
static const unsigned long kDefaultKey[4] = { 0x6c0a5452, 0x3827d0f, 0x3a170b92, 0x16db7fc2 }; static const unsigned long kDefaultKey[4] = { 0x6c0a5452, 0x3827d0f, 0x3a170b92, 0x16db7fc2 };
return kDefaultKey; return kDefaultKey;
} }

26
Sources/Plasma/Apps/plClientKey/plClientKey.cpp
View File

@ -30,19 +30,19 @@ typedef const UInt32* (*GETKEY)();
const UInt32* plClientKey::GetKey() const UInt32* plClientKey::GetKey()
{ {
HMODULE hDll = LoadLibrary("sp.dll"); HMODULE hDll = LoadLibrary("sp.dll");
if (hDll) if (hDll)
{ {
GETKEY getKey = (GETKEY)GetProcAddress(hDll, "GetKey"); GETKEY getKey = (GETKEY)GetProcAddress(hDll, "GetKey");
if (getKey) if (getKey)
{ {
static UInt32 key[4]; static UInt32 key[4];
memcpy(key, getKey(), sizeof(key)); memcpy(key, getKey(), sizeof(key));
FreeLibrary(hDll); FreeLibrary(hDll);
return key; return key;
} }
} }
return nil; return nil;
} }

4
Sources/Plasma/Apps/plClientKey/plClientKey.def
View File

@ -1,5 +1,5 @@
LIBRARY LIBRARY
EXPORTS EXPORTS
GetKey @1 GetKey @1
SECTIONS SECTIONS
.data READ WRITE .data READ WRITE

2
Sources/Plasma/Apps/plClientKey/plClientKey.h
View File

@ -37,7 +37,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
// //
namespace plClientKey namespace plClientKey
{ {
const UInt32* GetKey(); const UInt32* GetKey();
} }
#endif // plClientKey_h_inc #endif // plClientKey_h_inc

8
Sources/Plasma/Apps/plClientPatcher/CMakeLists.txt
View File

@ -8,13 +8,13 @@ include_directories("../../PubUtilLib")
include_directories(${OPENSSL_INCLUDE_DIR}) include_directories(${OPENSSL_INCLUDE_DIR})
set(plClientPatcher_HEADERS set(plClientPatcher_HEADERS
Intern.h Intern.h
Pch.h Pch.h
UruPlayer.h UruPlayer.h
) )
set(plClientPatcher_SOURCES set(plClientPatcher_SOURCES
UruPlayer.cpp UruPlayer.cpp
) )
add_library(plClientPatcher STATIC ${plClientPatcher_HEADERS} ${plClientPatcher_SOURCES}) add_library(plClientPatcher STATIC ${plClientPatcher_HEADERS} ${plClientPatcher_SOURCES})

1366
Sources/Plasma/Apps/plClientPatcher/UruPlayer.cpp
View File

File diff suppressed because it is too large Load Diff

12
Sources/Plasma/Apps/plClientPatcher/plLauncherCallback.h
View File

@ -35,15 +35,15 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#define PLASMA20_SOURCES_PLASMA_APPS_PLURULAUNCHER_PLLAUNCHERCALLBACK_H #define PLASMA20_SOURCES_PLASMA_APPS_PLURULAUNCHER_PLLAUNCHERCALLBACK_H
enum EStatus { enum EStatus {
kStatusOk, kStatusOk,
}; };
typedef void (*launcherCallback)(int status, void *param); typedef void (*launcherCallback)(int status, void *param);
struct plLauncherCallback { struct plLauncherCallback {
launcherCallback prepCallback; launcherCallback prepCallback;
launcherCallback initCallback; launcherCallback initCallback;
launcherCallback startCallback; launcherCallback startCallback;
launcherCallback stopCallback; launcherCallback stopCallback;
launcherCallback terminateCallback; launcherCallback terminateCallback;
}; };

118
Sources/Plasma/Apps/plFileEncrypt/main.cpp
View File

@ -32,78 +32,78 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
void EncryptFiles(const char* dir, const char* ext, bool encrypt); void EncryptFiles(const char* dir, const char* ext, bool encrypt);
void print_version(){ void print_version(){
wchar productString[256]; wchar productString[256];
ProductString(productString, arrsize(productString)); ProductString(productString, arrsize(productString));
printf("%S\n\n", productString); printf("%S\n\n", productString);
} }
void print_help() { void print_help() {
printf("plFileEncrypt - Encrypts and Decrypts Uru Files.\n\n"); printf("plFileEncrypt - Encrypts and Decrypts Uru Files.\n\n");
print_version(); print_version();
printf("Usage: plFileEncrypt \t[(encrypt|-e)|(decrypt|-d|)|(--help|-h|-?|/h)|(-v)]\n"); printf("Usage: plFileEncrypt \t[(encrypt|-e)|(decrypt|-d|)|(--help|-h|-?|/h)|(-v)]\n");
printf("\tencrypt|-e\t - Encrypts All .age, .fni, .ini, .csv, and .sdl files in the current folder.\n"); printf("\tencrypt|-e\t - Encrypts All .age, .fni, .ini, .csv, and .sdl files in the current folder.\n");
printf("\tdecrypt|-d\t - Decrypts All .age, .fni, .ini, .csv, and .sdl files in the current folder.\n"); printf("\tdecrypt|-d\t - Decrypts All .age, .fni, .ini, .csv, and .sdl files in the current folder.\n");
printf("\t--help|-h|-?|/h\t - Prints Help. This Screen.\n"); printf("\t--help|-h|-?|/h\t - Prints Help. This Screen.\n");
printf("\t-v|--version\t - Prints build version information\n"); printf("\t-v|--version\t - Prints build version information\n");
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
bool encrypt = true; bool encrypt = true;
const char* dir = "."; const char* dir = ".";
if (argc > 1) if (argc > 1)
{ {
if (hsStrEQ(argv[1], "encrypt") || hsStrEQ(argv[1], "-e") ) if (hsStrEQ(argv[1], "encrypt") || hsStrEQ(argv[1], "-e") )
{ {
if (argc > 2) if (argc > 2)
dir = argv[2]; dir = argv[2];
encrypt = true; encrypt = true;
} }
else if (hsStrEQ(argv[1], "decrypt") || hsStrEQ(argv[1], "-d")) else if (hsStrEQ(argv[1], "decrypt") || hsStrEQ(argv[1], "-d"))
{ {
if (argc > 2) if (argc > 2)
dir = argv[2]; dir = argv[2];
encrypt = false; encrypt = false;
} }
else if(hsStrEQ(argv[1], "--help") || hsStrEQ(argv[1], "-h") || hsStrEQ(argv[1], "-?") || hsStrEQ(argv[1], "/?")) else if(hsStrEQ(argv[1], "--help") || hsStrEQ(argv[1], "-h") || hsStrEQ(argv[1], "-?") || hsStrEQ(argv[1], "/?"))
{ {
print_help(); print_help();
return 0; return 0;
} }
else if (hsStrEQ(argv[1], "-v") || hsStrEQ(argv[1], "--version")) else if (hsStrEQ(argv[1], "-v") || hsStrEQ(argv[1], "--version"))
{ {
print_version(); print_version();
return 0; return 0;
} }
} }
EncryptFiles(dir, ".age", encrypt); EncryptFiles(dir, ".age", encrypt);
EncryptFiles(dir, ".fni", encrypt); EncryptFiles(dir, ".fni", encrypt);
EncryptFiles(dir, ".ini", encrypt); EncryptFiles(dir, ".ini", encrypt);
EncryptFiles(dir, ".sdl", encrypt); EncryptFiles(dir, ".sdl", encrypt);
EncryptFiles(dir, ".csv", encrypt); EncryptFiles(dir, ".csv", encrypt);
return 0; return 0;
} }
void EncryptFiles(const char* dir, const char* ext, bool encrypt) void EncryptFiles(const char* dir, const char* ext, bool encrypt)
{ {
char filePath[256]; char filePath[256];
hsFolderIterator folder(dir); hsFolderIterator folder(dir);
while (folder.NextFileSuffix(ext)) while (folder.NextFileSuffix(ext))
{ {
folder.GetPathAndName(filePath); folder.GetPathAndName(filePath);
if (encrypt) if (encrypt)
{ {
printf("encrypting: %s\n", folder.GetFileName()); printf("encrypting: %s\n", folder.GetFileName());
plEncryptedStream::FileEncrypt(filePath); plEncryptedStream::FileEncrypt(filePath);
} }
else else
{ {
printf("decrypting: %s\n", folder.GetFileName()); printf("decrypting: %s\n", folder.GetFileName());
plEncryptedStream::FileDecrypt(filePath); plEncryptedStream::FileDecrypt(filePath);
} }
} }
} }

268
Sources/Plasma/Apps/plFileSecure/main.cpp
View File

@ -34,163 +34,163 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include <string> #include <string>
void print_version() { void print_version() {
wchar productString[256]; wchar productString[256];
ProductString(productString, arrsize(productString)); ProductString(productString, arrsize(productString));
printf("%S\n\n", productString); printf("%S\n\n", productString);
} }
void print_help() { void print_help() {
printf("plFileSecure - Secures Uru files and generates encryption.key files.\n\n"); printf("plFileSecure - Secures Uru files and generates encryption.key files.\n\n");
print_version(); print_version();
printf("Usage:\n"); printf("Usage:\n");
printf("\tplFileSecure (<directory> <ext>)|[/generate /default]\n"); printf("\tplFileSecure (<directory> <ext>)|[/generate /default]\n");
printf("\n"); printf("\n");
printf("<directory> <ext> : The directory and extension of files to secure. Cannot\n"); printf("<directory> <ext> : The directory and extension of files to secure. Cannot\n");
printf(" be used with /generate. Uses the %s file in\n", plFileUtils::kKeyFilename); printf(" be used with /generate. Uses the %s file in\n", plFileUtils::kKeyFilename);
printf(" the current directory (or default key if no file exists)\n"); printf(" the current directory (or default key if no file exists)\n");
printf("/generate : Generates a random key and writes it to a %s\n", plFileUtils::kKeyFilename); printf("/generate : Generates a random key and writes it to a %s\n", plFileUtils::kKeyFilename);
printf(" file in the current directory. Cannot be used with\n"); printf(" file in the current directory. Cannot be used with\n");
printf(" <directory> <ext>\n"); printf(" <directory> <ext>\n");
printf("/default : If used with /generate, creates a %s file\n", plFileUtils::kKeyFilename); printf("/default : If used with /generate, creates a %s file\n", plFileUtils::kKeyFilename);
printf(" with the default key. If used with <directory> <ext>, it\n"); printf(" with the default key. If used with <directory> <ext>, it\n");
printf(" secures with the default key instead of the\n"); printf(" secures with the default key instead of the\n");
printf(" %s file's key\n", plFileUtils::kKeyFilename); printf(" %s file's key\n", plFileUtils::kKeyFilename);
printf("\n"); printf("\n");
} }
void GenerateKey(bool useDefault) void GenerateKey(bool useDefault)
{ {
UInt32 key[4]; UInt32 key[4];
if (useDefault) if (useDefault)
{ {
unsigned memSize = min(arrsize(key), arrsize(plSecureStream::kDefaultKey)); unsigned memSize = min(arrsize(key), arrsize(plSecureStream::kDefaultKey));
memSize *= sizeof(UInt32); memSize *= sizeof(UInt32);
memcpy(key, plSecureStream::kDefaultKey, memSize); memcpy(key, plSecureStream::kDefaultKey, memSize);
} }
else else
{ {
srand((unsigned)time(nil)); srand((unsigned)time(nil));
double randNum = (double)rand() / (double)RAND_MAX; // converts to 0..1 double randNum = (double)rand() / (double)RAND_MAX; // converts to 0..1
UInt32 keyNum = (UInt32)(randNum * (double)0xFFFFFFFF); // multiply it by the max unsigned 32-bit int UInt32 keyNum = (UInt32)(randNum * (double)0xFFFFFFFF); // multiply it by the max unsigned 32-bit int
key[0] = keyNum; key[0] = keyNum;
randNum = (double)rand() / (double)RAND_MAX; randNum = (double)rand() / (double)RAND_MAX;
keyNum = (UInt32)(randNum * (double)0xFFFFFFFF); keyNum = (UInt32)(randNum * (double)0xFFFFFFFF);
key[1] = keyNum; key[1] = keyNum;
randNum = (double)rand() / (double)RAND_MAX; randNum = (double)rand() / (double)RAND_MAX;
keyNum = (UInt32)(randNum * (double)0xFFFFFFFF); keyNum = (UInt32)(randNum * (double)0xFFFFFFFF);
key[2] = keyNum; key[2] = keyNum;
randNum = (double)rand() / (double)RAND_MAX; randNum = (double)rand() / (double)RAND_MAX;
keyNum = (UInt32)(randNum * (double)0xFFFFFFFF); keyNum = (UInt32)(randNum * (double)0xFFFFFFFF);
key[3] = keyNum; key[3] = keyNum;
} }
hsUNIXStream out; hsUNIXStream out;
out.Open(plFileUtils::kKeyFilename, "wb"); out.Open(plFileUtils::kKeyFilename, "wb");
out.Write(sizeof(UInt32) * arrsize(key), (void*)key); out.Write(sizeof(UInt32) * arrsize(key), (void*)key);
out.Close(); out.Close();
} }
void SecureFiles(std::string dir, std::string ext, UInt32* key) void SecureFiles(std::string dir, std::string ext, UInt32* key)
{ {
char filePath[256]; char filePath[256];
hsFolderIterator folder(dir.c_str()); hsFolderIterator folder(dir.c_str());
while (folder.NextFileSuffix(ext.c_str())) while (folder.NextFileSuffix(ext.c_str()))
{ {
folder.GetPathAndName(filePath); folder.GetPathAndName(filePath);
printf("securing: %s\n", folder.GetFileName()); printf("securing: %s\n", folder.GetFileName());
plSecureStream::FileEncrypt(filePath, key); plSecureStream::FileEncrypt(filePath, key);
} }
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
bool generatingKey = false; bool generatingKey = false;
bool useDefault = false; bool useDefault = false;
std::string directory; std::string directory;
std::string ext; std::string ext;
if (argc > 1) if (argc > 1)
{ {
for (int i = 1; i < argc; i++) for (int i = 1; i < argc; i++)
{ {
std::string arg = argv[i]; std::string arg = argv[i];
if ((arg[0] == '-')||(arg[0] == '/')) if ((arg[0] == '-')||(arg[0] == '/'))
{ {
// this arg is a flag of some kind // this arg is a flag of some kind
arg = arg.substr(1, arg.length()); // trim the dash or slash arg = arg.substr(1, arg.length()); // trim the dash or slash
if ((stricmp(arg.c_str(), "g") == 0) || (stricmp(arg.c_str(), "generate") == 0)) if ((stricmp(arg.c_str(), "g") == 0) || (stricmp(arg.c_str(), "generate") == 0))
{ {
if (!generatingKey) if (!generatingKey)
generatingKey = true; generatingKey = true;
else else
{ {
print_help(); print_help();
return 0; return 0;
} }
} }
else if ((stricmp(arg.c_str(), "d") == 0) || (stricmp(arg.c_str(), "default") == 0)) else if ((stricmp(arg.c_str(), "d") == 0) || (stricmp(arg.c_str(), "default") == 0))
{ {
if (!useDefault) if (!useDefault)
useDefault = true; useDefault = true;
else else
{ {
print_help(); print_help();
return 0; return 0;
} }
} }
else else
{ {
print_help(); print_help();
return 0; return 0;
} }
} }
else else
{ {
// else it is a directory or extension // else it is a directory or extension
if (directory == "") if (directory == "")
directory = argv[i]; directory = argv[i];
else if (ext == "") else if (ext == "")
ext = argv[i]; ext = argv[i];
else else
{ {
print_help(); print_help();
return 0; return 0;
} }
} }
} }
if (generatingKey && ((directory != "") || (ext != ""))) if (generatingKey && ((directory != "") || (ext != "")))
{ {
print_help(); print_help();
return 0; return 0;
} }
} }
else else
{ {
print_help(); print_help();
return 0; return 0;
} }
if (generatingKey) if (generatingKey)
{ {
GenerateKey(useDefault); GenerateKey(useDefault);
return 0; return 0;
} }
if (ext[0] != '.') if (ext[0] != '.')
ext = "." + ext; // tack on the dot if necessary ext = "." + ext; // tack on the dot if necessary
if (useDefault) if (useDefault)
SecureFiles(directory, ext, nil); SecureFiles(directory, ext, nil);
else else
{ {
UInt32 key[4]; UInt32 key[4];
plFileUtils::GetSecureEncryptionKey(plFileUtils::kKeyFilename, key, arrsize(key)); plFileUtils::GetSecureEncryptionKey(plFileUtils::kKeyFilename, key, arrsize(key));
SecureFiles(directory, ext, key); SecureFiles(directory, ext, key);
} }
return 0; return 0;
} }

118
Sources/Plasma/Apps/plLogDecrypt/plLogDecrypt.cpp
View File

@ -35,76 +35,76 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
void IProcessFile(const char *path) void IProcessFile(const char *path)
{ {
char out_path[512]; char out_path[512];
strcpy(out_path, path); strcpy(out_path, path);
strcat(out_path, ".decrypt"); strcat(out_path, ".decrypt");
FILE * fpIn = fopen(path, "rb"); FILE * fpIn = fopen(path, "rb");
FILE * fpOut = fopen(out_path, "w"); FILE * fpOut = fopen(out_path, "w");
if( fpIn != nil && fpOut != nil) if( fpIn != nil && fpOut != nil)
{ {
UInt8 line[ 2048 ]; UInt8 line[ 2048 ];
while( !feof( fpIn ) ) while( !feof( fpIn ) )
{ {
// Read next string // Read next string
long pos = ftell(fpIn); long pos = ftell(fpIn);
if( pos == -1L ) if( pos == -1L )
break; break;
UInt8 hint = (UInt8)pos; UInt8 hint = (UInt8)pos;
UInt16 sizeHint = (UInt16)pos; UInt16 sizeHint = (UInt16)pos;
UInt16 size; UInt16 size;
if( stricmp( path + strlen( path ) - 4, ".log" ) == 0 ) if( stricmp( path + strlen( path ) - 4, ".log" ) == 0 )
{ {
int i; int i;
for( i = 0; i < 511; i++ ) for( i = 0; i < 511; i++ )
{ {
int c = fgetc( fpIn ); int c = fgetc( fpIn );
if( c == EOF || c == hint ) if( c == EOF || c == hint )
break; break;
line[ i ] = (UInt8)c; line[ i ] = (UInt8)c;
} }
line[ i ] = 0; line[ i ] = 0;
size = i; size = i;
} }
else else
{ {
// UInt16 line length is encoded first // UInt16 line length is encoded first
int c = fgetc( fpIn ); int c = fgetc( fpIn );
if( c == EOF ) if( c == EOF )
break; break;
size = ( c & 0xff ) | ( fgetc( fpIn ) << 8 ); size = ( c & 0xff ) | ( fgetc( fpIn ) << 8 );
size = size ^ sizeHint; size = size ^ sizeHint;
if( size > sizeof( line ) ) if( size > sizeof( line ) )
{ {
hsAssert( size <= sizeof( line ) - 1, "Invalid line size" ); hsAssert( size <= sizeof( line ) - 1, "Invalid line size" );
break; break;
} }
fread( line, 1, size, fpIn ); fread( line, 1, size, fpIn );
line[ size ] = 0; line[ size ] = 0;
} }
plStatusEncrypt::Decrypt( line, size, hint ); plStatusEncrypt::Decrypt( line, size, hint );
fprintf(fpOut, "%s\n", (const char *)line); fprintf(fpOut, "%s\n", (const char *)line);
} }
} }
if (fpIn) if (fpIn)
fclose(fpIn); fclose(fpIn);
if (fpOut) if (fpOut)
fclose(fpOut); fclose(fpOut);
} }
int main(int argc, const char * argv[]) int main(int argc, const char * argv[])
{ {
if (argc == 2) if (argc == 2)
{ {
IProcessFile(argv[1]); IProcessFile(argv[1]);
} }
return 0; return 0;
} }

22
Sources/Plasma/Apps/plMD5/Main.cpp
View File

@ -42,17 +42,17 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
//============================================================================ //============================================================================
int __cdecl main (int argc, char ** argv) { int __cdecl main (int argc, char ** argv) {
if (argc < 2) { if (argc < 2) {
fprintf(stderr, "ERROR: Please specify filename.\n"); fprintf(stderr, "ERROR: Please specify filename.\n");
return 1; return 1;
} }
plMD5Checksum md5(argv[1]); plMD5Checksum md5(argv[1]);
if (!md5.IsValid()) { if (!md5.IsValid()) {
fprintf(stderr, "ERROR: MD5 failed.\n"); fprintf(stderr, "ERROR: MD5 failed.\n");
return 1; return 1;
} }
fprintf(stdout, "%s\n", md5.GetAsHexString()); fprintf(stdout, "%s\n", md5.GetAsHexString());
return 0; return 0;
} }

268
Sources/Plasma/Apps/plPageInfo/plPageInfo.cpp
View File

@ -52,150 +52,150 @@ bool DumpSounds();
//// PrintVersion /////////////////////////////////////////////////////////////// //// PrintVersion ///////////////////////////////////////////////////////////////
void PrintVersion() void PrintVersion()
{ {
wchar productString[256]; wchar productString[256];
ProductString(productString, arrsize(productString)); ProductString(productString, arrsize(productString));
_putws(productString); _putws(productString);
} }
//// PrintHelp /////////////////////////////////////////////////////////////// //// PrintHelp ///////////////////////////////////////////////////////////////
int PrintHelp( void ) int PrintHelp( void )
{ {
puts(""); puts("");
PrintVersion(); PrintVersion();
puts(""); puts("");
puts("Usage: plPageInfo [-s -i] pageFile"); puts("Usage: plPageInfo [-s -i] pageFile");
puts(" plPageInfo -v"); puts(" plPageInfo -v");
puts("Where:" ); puts("Where:" );
puts(" -v print version and exit."); puts(" -v print version and exit.");
puts(" -s dump sounds in page to the console"); puts(" -s dump sounds in page to the console");
puts(" -i dump object size info to .csv files"); puts(" -i dump object size info to .csv files");
puts(" pageFile is the path to the .prp file"); puts(" pageFile is the path to the .prp file");
puts(""); puts("");
return -1; return -1;
} }
//// main //////////////////////////////////////////////////////////////////// //// main ////////////////////////////////////////////////////////////////////
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
if (argc >= 1 && hsStrEQ(argv[1], "-v")) if (argc >= 1 && hsStrEQ(argv[1], "-v"))
{ {
PrintVersion(); PrintVersion();
return 0; return 0;
} }
if (argc < 3) if (argc < 3)
return PrintHelp(); return PrintHelp();
bool sounds = false; bool sounds = false;
bool stats = false; bool stats = false;
int arg = 1; int arg = 1;
for (arg = 1; arg < argc; arg++) for (arg = 1; arg < argc; arg++)
{ {
if (hsStrEQ(argv[arg], "-s")) if (hsStrEQ(argv[arg], "-s"))
sounds = true; sounds = true;
else if (hsStrEQ(argv[arg], "-i")) else if (hsStrEQ(argv[arg], "-i"))
stats = true; stats = true;
else else
break; break;
} }
// Make sure we have 1 arg left after getting the options // Make sure we have 1 arg left after getting the options
char* pageFile = nil; char* pageFile = nil;
if (arg < argc) if (arg < argc)
pageFile = argv[arg]; pageFile = argv[arg];
else else
return PrintHelp(); return PrintHelp();
// Init our special resMgr // Init our special resMgr
plResMgrSettings::Get().SetFilterNewerPageVersions(false); plResMgrSettings::Get().SetFilterNewerPageVersions(false);
plResMgrSettings::Get().SetFilterOlderPageVersions(false); plResMgrSettings::Get().SetFilterOlderPageVersions(false);
plResMgrSettings::Get().SetLoadPagesOnInit(false); plResMgrSettings::Get().SetLoadPagesOnInit(false);
gResMgr = TRACKED_NEW plResManager; gResMgr = TRACKED_NEW plResManager;
hsgResMgr::Init(gResMgr); hsgResMgr::Init(gResMgr);
gResMgr->AddSinglePage(pageFile); gResMgr->AddSinglePage(pageFile);
if (sounds) if (sounds)
DumpSounds(); DumpSounds();
if (stats) if (stats)
{ {
char path[256]; char path[256];
strcpy(path, pageFile); strcpy(path, pageFile);
plFileUtils::StripFile(path); plFileUtils::StripFile(path);
DumpStats(path); DumpStats(path);
} }
hsgResMgr::Shutdown(); hsgResMgr::Shutdown();
return 0; return 0;
} }
//// plSoundBufferCollector ////////////////////////////////////////////////// //// plSoundBufferCollector //////////////////////////////////////////////////
// Page iterator that collects all the plSoundBuffers in all of our pages // Page iterator that collects all the plSoundBuffers in all of our pages
class plSoundBufferCollector : public plRegistryPageIterator, public plKeyCollector class plSoundBufferCollector : public plRegistryPageIterator, public plKeyCollector
{ {
public: public:
plSoundBufferCollector(hsTArray<plKey>& keyArray) plSoundBufferCollector(hsTArray<plKey>& keyArray)
: plKeyCollector(keyArray) {} : plKeyCollector(keyArray) {}
hsBool EatPage(plRegistryPageNode* page) hsBool EatPage(plRegistryPageNode* page)
{ {
page->LoadKeys(); page->LoadKeys();
return page->IterateKeys(this, plSoundBuffer::Index()); return page->IterateKeys(this, plSoundBuffer::Index());
return true; return true;
} }
}; };
bool DumpSounds() bool DumpSounds()
{ {
hsTArray<plKey> soundKeys; hsTArray<plKey> soundKeys;
plSoundBufferCollector soundCollector(soundKeys); plSoundBufferCollector soundCollector(soundKeys);
gResMgr->IterateAllPages(&soundCollector); gResMgr->IterateAllPages(&soundCollector);
for (int i = 0; i < soundKeys.GetCount(); i++) for (int i = 0; i < soundKeys.GetCount(); i++)
{ {
plSoundBuffer* buffer = plSoundBuffer::ConvertNoRef(soundKeys[i]->VerifyLoaded()); plSoundBuffer* buffer = plSoundBuffer::ConvertNoRef(soundKeys[i]->VerifyLoaded());
if (buffer) if (buffer)
{ {
// Ref it... // Ref it...
buffer->GetKey()->RefObject(); buffer->GetKey()->RefObject();
// Get the filename from it and add that file if necessary // Get the filename from it and add that file if necessary
const char* filename = buffer->GetFileName(); const char* filename = buffer->GetFileName();
if (filename) if (filename)
{ {
UInt32 flags = 0; UInt32 flags = 0;
if (stricmp(plFileUtils::GetFileExt(filename), "wav") != 0) if (stricmp(plFileUtils::GetFileExt(filename), "wav") != 0)
{ {
if (buffer->HasFlag(plSoundBuffer::kOnlyLeftChannel) || if (buffer->HasFlag(plSoundBuffer::kOnlyLeftChannel) ||
buffer->HasFlag(plSoundBuffer::kOnlyRightChannel)) buffer->HasFlag(plSoundBuffer::kOnlyRightChannel))
hsSetBits(flags, plManifestFile::kSndFlagCacheSplit); hsSetBits(flags, plManifestFile::kSndFlagCacheSplit);
else if (buffer->HasFlag(plSoundBuffer::kStreamCompressed)) else if (buffer->HasFlag(plSoundBuffer::kStreamCompressed))
hsSetBits(flags, plManifestFile::kSndFlagStreamCompressed); hsSetBits(flags, plManifestFile::kSndFlagStreamCompressed);
else else
hsSetBits(flags, plManifestFile::kSndFlagCacheStereo); hsSetBits(flags, plManifestFile::kSndFlagCacheStereo);
} }
printf("%s,%u\n", filename, flags); printf("%s,%u\n", filename, flags);
} }
// Unref the object so it goes away // Unref the object so it goes away
buffer->GetKey()->UnRefObject(); buffer->GetKey()->UnRefObject();
} }
} }
soundKeys.Reset(); soundKeys.Reset();
plIndirectUnloadIterator iter; plIndirectUnloadIterator iter;
gResMgr->IterateAllPages(&iter); gResMgr->IterateAllPages(&iter);
return true; return true;
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -205,50 +205,50 @@ bool DumpSounds()
class plStatDumpIterator : public plRegistryPageIterator, public plRegistryKeyIterator class plStatDumpIterator : public plRegistryPageIterator, public plRegistryKeyIterator
{ {
protected: protected:
const char* fOutputDir; const char* fOutputDir;
hsUNIXStream fStream; hsUNIXStream fStream;
public: public:
plStatDumpIterator(const char* outputDir) : fOutputDir(outputDir) {} plStatDumpIterator(const char* outputDir) : fOutputDir(outputDir) {}
hsBool EatKey(const plKey& key) hsBool EatKey(const plKey& key)
{ {
plKeyImp* imp = (plKey)key; plKeyImp* imp = (plKey)key;
fStream.WriteString(imp->GetName()); fStream.WriteString(imp->GetName());
fStream.WriteString(","); fStream.WriteString(",");
fStream.WriteString(plFactory::GetNameOfClass(imp->GetUoid().GetClassType())); fStream.WriteString(plFactory::GetNameOfClass(imp->GetUoid().GetClassType()));
fStream.WriteString(","); fStream.WriteString(",");
char buf[30]; char buf[30];
sprintf(buf, "%u", imp->GetDataLen()); sprintf(buf, "%u", imp->GetDataLen());
fStream.WriteString(buf); fStream.WriteString(buf);
fStream.WriteString("\n"); fStream.WriteString("\n");
return true; return true;
} }
hsBool EatPage(plRegistryPageNode* page) hsBool EatPage(plRegistryPageNode* page)
{ {
const plPageInfo& info = page->GetPageInfo(); const plPageInfo& info = page->GetPageInfo();
char fileName[256]; char fileName[256];
sprintf(fileName, "%s%s_%s.csv", fOutputDir, info.GetAge(), info.GetPage()); sprintf(fileName, "%s%s_%s.csv", fOutputDir, info.GetAge(), info.GetPage());
fStream.Open(fileName, "wt"); fStream.Open(fileName, "wt");
page->LoadKeys(); page->LoadKeys();
page->IterateKeys(this); page->IterateKeys(this);
fStream.Close(); fStream.Close();
return true; return true;
} }
}; };
bool DumpStats(const char* patchDir) bool DumpStats(const char* patchDir)
{ {
plStatDumpIterator statDump(patchDir); plStatDumpIterator statDump(patchDir);
gResMgr->IterateAllPages(&statDump); gResMgr->IterateAllPages(&statDump);
return true; return true;
} }

96
Sources/Plasma/Apps/plPageOptimizer/main.cpp
View File

@ -34,72 +34,72 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
if (argc != 2) if (argc != 2)
{ {
printf("plPageOptimizer: wrong number of arguments"); printf("plPageOptimizer: wrong number of arguments");
return 1; return 1;
} }
printf("Optimizing %s...", plFileUtils::GetFileName(argv[1])); printf("Optimizing %s...", plFileUtils::GetFileName(argv[1]));
plFontCache* fontCache; plFontCache* fontCache;
#ifndef _DEBUG #ifndef _DEBUG
try try
{ {
#endif #endif
plResManager* resMgr = TRACKED_NEW plResManager; plResManager* resMgr = TRACKED_NEW plResManager;
hsgResMgr::Init(resMgr); hsgResMgr::Init(resMgr);
// Setup all the crap that needs to be around to load // Setup all the crap that needs to be around to load
plSimulationMgr::Init(); plSimulationMgr::Init();
fontCache = TRACKED_NEW plFontCache; fontCache = TRACKED_NEW plFontCache;
plPythonFileMod::SetAtConvertTime(); plPythonFileMod::SetAtConvertTime();
#ifndef _DEBUG #ifndef _DEBUG
} catch (...) } catch (...)
{ {
printf(" ***crashed on init"); printf(" ***crashed on init");
return 2; return 2;
} }
#endif #endif
#ifndef _DEBUG #ifndef _DEBUG
try try
#endif #endif
{ {
plPageOptimizer optimizer(argv[1]); plPageOptimizer optimizer(argv[1]);
optimizer.Optimize(); optimizer.Optimize();
} }
#ifndef _DEBUG #ifndef _DEBUG
catch (...) catch (...)
{ {
printf(" ***crashed on optimizing"); printf(" ***crashed on optimizing");
return 2; return 2;
} }
#endif #endif
#ifndef _DEBUG #ifndef _DEBUG
try try
{ {
#endif #endif
// Deinit the crap // Deinit the crap
fontCache->UnRegisterAs(kFontCache_KEY); fontCache->UnRegisterAs(kFontCache_KEY);
fontCache = nil; fontCache = nil;
plSimulationMgr::Shutdown(); plSimulationMgr::Shutdown();
// Reading in objects may have generated dirty state which we're obviously // Reading in objects may have generated dirty state which we're obviously
// not sending out. Clear it so that we don't have leaked keys before the // not sending out. Clear it so that we don't have leaked keys before the
// ResMgr goes away. // ResMgr goes away.
std::vector<plSynchedObject::StateDefn> carryOvers; std::vector<plSynchedObject::StateDefn> carryOvers;
plSynchedObject::ClearDirtyState(carryOvers); plSynchedObject::ClearDirtyState(carryOvers);
hsgResMgr::Shutdown(); hsgResMgr::Shutdown();
#ifndef _DEBUG #ifndef _DEBUG
} catch (...) } catch (...)
{ {
printf(" ***crashed on shutdown"); printf(" ***crashed on shutdown");
return 2; return 2;
} }
#endif #endif
return 0; return 0;
} }

334
Sources/Plasma/Apps/plPageOptimizer/plPageOptimizer.cpp
View File

@ -40,230 +40,230 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
plPageOptimizer* plPageOptimizer::fInstance = nil; plPageOptimizer* plPageOptimizer::fInstance = nil;
plPageOptimizer::plPageOptimizer(const char* pagePath) : plPageOptimizer::plPageOptimizer(const char* pagePath) :
fOptimized(true), fOptimized(true),
fPageNode(nil), fPageNode(nil),
fPagePath(pagePath) fPagePath(pagePath)
{ {
fInstance = this; fInstance = this;
strcpy(fTempPagePath, fPagePath); strcpy(fTempPagePath, fPagePath);
plFileUtils::StripExt(fTempPagePath); plFileUtils::StripExt(fTempPagePath);
strcat(fTempPagePath, "_opt.prp"); strcat(fTempPagePath, "_opt.prp");
fResMgr = (plResManager*)hsgResMgr::ResMgr(); fResMgr = (plResManager*)hsgResMgr::ResMgr();
} }
void plPageOptimizer::IFindLoc() void plPageOptimizer::IFindLoc()
{ {
class plPageIt : public plRegistryPageIterator class plPageIt : public plRegistryPageIterator
{ {
public: public:
plLocation fLoc; plLocation fLoc;
virtual hsBool EatPage(plRegistryPageNode* keyNode) virtual hsBool EatPage(plRegistryPageNode* keyNode)
{ {
fLoc = keyNode->GetPageInfo().GetLocation(); fLoc = keyNode->GetPageInfo().GetLocation();
return true; return true;
} }
}; };
plPageIt it; plPageIt it;
fResMgr->IterateAllPages(&it); fResMgr->IterateAllPages(&it);
fLoc = it.fLoc; fLoc = it.fLoc;
} }
void plPageOptimizer::Optimize() void plPageOptimizer::Optimize()
{ {
fResMgr->AddSinglePage(fPagePath); fResMgr->AddSinglePage(fPagePath);
// Get the location of the page we're optimizing // Get the location of the page we're optimizing
IFindLoc(); IFindLoc();
hsBool loaded = true; hsBool loaded = true;
// Get the key for the scene node, we'll load it to force a load on all the objects // Get the key for the scene node, we'll load it to force a load on all the objects
plKey snKey = plKeyFinder::Instance().FindSceneNodeKey(fLoc); plKey snKey = plKeyFinder::Instance().FindSceneNodeKey(fLoc);
if (snKey) if (snKey)
{ {
// Load all the keys // Load all the keys
fPageNode = fResMgr->FindPage(fLoc); fPageNode = fResMgr->FindPage(fLoc);
fResMgr->LoadPageKeys(fPageNode); fResMgr->LoadPageKeys(fPageNode);
// Put all the keys in a vector, so they won't get unreffed // Put all the keys in a vector, so they won't get unreffed
class plVecKeyCollector : public plRegistryKeyIterator class plVecKeyCollector : public plRegistryKeyIterator
{ {
public: public:
KeyVec& fKeys; KeyVec& fKeys;
plVecKeyCollector(KeyVec& keys) : fKeys(keys) {} plVecKeyCollector(KeyVec& keys) : fKeys(keys) {}
virtual hsBool EatKey(const plKey& key) { fKeys.push_back(key); return true; } virtual hsBool EatKey(const plKey& key) { fKeys.push_back(key); return true; }
}; };
plVecKeyCollector keyIt(fAllKeys); plVecKeyCollector keyIt(fAllKeys);
fResMgr->IterateKeys(&keyIt); fResMgr->IterateKeys(&keyIt);
// Set our load proc, which will track the order that objects are loaded // Set our load proc, which will track the order that objects are loaded
fResMgr->SetProgressBarProc(KeyedObjectProc); fResMgr->SetProgressBarProc(KeyedObjectProc);
// Load the page // Load the page
snKey->VerifyLoaded(); snKey->VerifyLoaded();
// Unload everything // Unload everything
snKey->RefObject(); snKey->RefObject();
snKey->UnRefObject(); snKey->UnRefObject();
snKey = nil; snKey = nil;
} }
else else
{ {
loaded = false; loaded = false;
} }
if (loaded) if (loaded)
IRewritePage(); IRewritePage();
UInt32 oldSize = plFileUtils::GetFileSize(fPagePath); UInt32 oldSize = plFileUtils::GetFileSize(fPagePath);
UInt32 newSize = plFileUtils::GetFileSize(fTempPagePath); UInt32 newSize = plFileUtils::GetFileSize(fTempPagePath);
if (!loaded) if (!loaded)
{ {
printf("no scene node.\n"); printf("no scene node.\n");
} }
else if (fOptimized) else if (fOptimized)
{ {
plFileUtils::RemoveFile(fTempPagePath); plFileUtils::RemoveFile(fTempPagePath);
printf("already optimized.\n"); printf("already optimized.\n");
} }
else if (oldSize == newSize) else if (oldSize == newSize)
{ {
plFileUtils::RemoveFile(fPagePath, true); plFileUtils::RemoveFile(fPagePath, true);
plFileUtils::FileMove(fTempPagePath, fPagePath); plFileUtils::FileMove(fTempPagePath, fPagePath);
printf("complete\n"); printf("complete\n");
} }
else else
{ {
plFileUtils::RemoveFile(fTempPagePath); plFileUtils::RemoveFile(fTempPagePath);
printf("failed. File sizes different\n"); printf("failed. File sizes different\n");
} }
} }
void plPageOptimizer::KeyedObjectProc(plKey key) void plPageOptimizer::KeyedObjectProc(plKey key)
{ {
const char* keyName = key->GetName(); const char* keyName = key->GetName();
const char* className = plFactory::GetNameOfClass(key->GetUoid().GetClassType()); const char* className = plFactory::GetNameOfClass(key->GetUoid().GetClassType());
// For now, ignore any key that isn't in the location we're looking at. That means stuff like textures. // For now, ignore any key that isn't in the location we're looking at. That means stuff like textures.
if (fInstance->fLoc != key->GetUoid().GetLocation()) if (fInstance->fLoc != key->GetUoid().GetLocation())
return; return;
KeySet& loadedKeys = fInstance->fLoadedKeys; KeySet& loadedKeys = fInstance->fLoadedKeys;
KeyVec& loadOrder = fInstance->fKeyLoadOrder; KeyVec& loadOrder = fInstance->fKeyLoadOrder;
KeySet::iterator it = loadedKeys.lower_bound(key); KeySet::iterator it = loadedKeys.lower_bound(key);
if (it != loadedKeys.end() && *it == key) if (it != loadedKeys.end() && *it == key)
{ {
printf("Keyed object %s(%s) loaded more than once\n", keyName, className); printf("Keyed object %s(%s) loaded more than once\n", keyName, className);
} }
else else
{ {
loadedKeys.insert(it, key); loadedKeys.insert(it, key);
loadOrder.push_back(key); loadOrder.push_back(key);
} }
} }
void plPageOptimizer::IWriteKeyData(hsStream* oldPage, hsStream* newPage, plKey key) void plPageOptimizer::IWriteKeyData(hsStream* oldPage, hsStream* newPage, plKey key)
{ {
class plUpdateKeyImp : public plKeyImp class plUpdateKeyImp : public plKeyImp
{ {
public: public:
void SetStartPos(UInt32 startPos) { fStartPos = startPos; } void SetStartPos(UInt32 startPos) { fStartPos = startPos; }
}; };
plUpdateKeyImp* keyImp = (plUpdateKeyImp*)(plKeyImp*)key; plUpdateKeyImp* keyImp = (plUpdateKeyImp*)(plKeyImp*)key;
UInt32 startPos = keyImp->GetStartPos(); UInt32 startPos = keyImp->GetStartPos();
UInt32 len = keyImp->GetDataLen(); UInt32 len = keyImp->GetDataLen();
oldPage->SetPosition(startPos); oldPage->SetPosition(startPos);
if (len > fBuf.size()) if (len > fBuf.size())
fBuf.resize(len); fBuf.resize(len);
oldPage->Read(len, &fBuf[0]); oldPage->Read(len, &fBuf[0]);
UInt32 newStartPos = newPage->GetPosition(); UInt32 newStartPos = newPage->GetPosition();
// If we move any buffers, this page wasn't optimized already // If we move any buffers, this page wasn't optimized already
if (newStartPos != startPos) if (newStartPos != startPos)
fOptimized = false; fOptimized = false;
keyImp->SetStartPos(newStartPos); keyImp->SetStartPos(newStartPos);
newPage->Write(len, &fBuf[0]); newPage->Write(len, &fBuf[0]);
} }
void plPageOptimizer::IRewritePage() void plPageOptimizer::IRewritePage()
{ {
hsUNIXStream newPage; hsUNIXStream newPage;
if (newPage.Open(fTempPagePath, "wb")) if (newPage.Open(fTempPagePath, "wb"))
{ {
hsUNIXStream oldPage; hsUNIXStream oldPage;
oldPage.Open(fPagePath); oldPage.Open(fPagePath);
const plPageInfo& pageInfo = fPageNode->GetPageInfo(); const plPageInfo& pageInfo = fPageNode->GetPageInfo();
UInt32 dataStart = pageInfo.GetDataStart(); UInt32 dataStart = pageInfo.GetDataStart();
fBuf.resize(dataStart); fBuf.resize(dataStart);
oldPage.Read(dataStart, &fBuf[0]); oldPage.Read(dataStart, &fBuf[0]);
newPage.Write(dataStart, &fBuf[0]); newPage.Write(dataStart, &fBuf[0]);
int size = (int)fKeyLoadOrder.size(); int size = (int)fKeyLoadOrder.size();
for (int i = 0; i < size; i++) for (int i = 0; i < size; i++)
IWriteKeyData(&oldPage, &newPage, fKeyLoadOrder[i]); IWriteKeyData(&oldPage, &newPage, fKeyLoadOrder[i]);
// If there are any objects that we didn't write (because they didn't load for // If there are any objects that we didn't write (because they didn't load for
// some reason), put them at the end // some reason), put them at the end
for (int i = 0; i < fAllKeys.size(); i++) for (int i = 0; i < fAllKeys.size(); i++)
{ {
hsBool found = (fLoadedKeys.find(fAllKeys[i]) != fLoadedKeys.end()); hsBool found = (fLoadedKeys.find(fAllKeys[i]) != fLoadedKeys.end());
if (!found) if (!found)
IWriteKeyData(&oldPage, &newPage, fAllKeys[i]); IWriteKeyData(&oldPage, &newPage, fAllKeys[i]);
} }
UInt32 newKeyStart = newPage.GetPosition(); UInt32 newKeyStart = newPage.GetPosition();
UInt32 oldKeyStart = pageInfo.GetIndexStart(); UInt32 oldKeyStart = pageInfo.GetIndexStart();
oldPage.SetPosition(oldKeyStart); oldPage.SetPosition(oldKeyStart);
UInt32 numTypes = oldPage.ReadSwap32(); UInt32 numTypes = oldPage.ReadSwap32();
newPage.WriteSwap32(numTypes); newPage.WriteSwap32(numTypes);
for (UInt32 i = 0; i < numTypes; i++) for (UInt32 i = 0; i < numTypes; i++)
{ {
UInt16 classType = oldPage.ReadSwap16(); UInt16 classType = oldPage.ReadSwap16();
UInt32 len = oldPage.ReadSwap32(); UInt32 len = oldPage.ReadSwap32();
UInt8 flags = oldPage.ReadByte(); UInt8 flags = oldPage.ReadByte();
UInt32 numKeys = oldPage.ReadSwap32(); UInt32 numKeys = oldPage.ReadSwap32();
newPage.WriteSwap16(classType); newPage.WriteSwap16(classType);
newPage.WriteSwap32(len); newPage.WriteSwap32(len);
newPage.WriteByte(flags); newPage.WriteByte(flags);
newPage.WriteSwap32(numKeys); newPage.WriteSwap32(numKeys);
for (UInt32 j = 0; j < numKeys; j++) for (UInt32 j = 0; j < numKeys; j++)
{ {
plUoid uoid; plUoid uoid;
uoid.Read(&oldPage); uoid.Read(&oldPage);
UInt32 startPos = oldPage.ReadSwap32(); UInt32 startPos = oldPage.ReadSwap32();
UInt32 dataLen = oldPage.ReadSwap32(); UInt32 dataLen = oldPage.ReadSwap32();
// Get the new start pos // Get the new start pos
plKeyImp* key = (plKeyImp*)fResMgr->FindKey(uoid); plKeyImp* key = (plKeyImp*)fResMgr->FindKey(uoid);
startPos = key->GetStartPos(); startPos = key->GetStartPos();
uoid.Write(&newPage); uoid.Write(&newPage);
newPage.WriteSwap32(startPos); newPage.WriteSwap32(startPos);
newPage.WriteSwap32(dataLen); newPage.WriteSwap32(dataLen);
} }
} }
newPage.Close(); newPage.Close();
oldPage.Close(); oldPage.Close();
} }
} }

38
Sources/Plasma/Apps/plPageOptimizer/plPageOptimizer.h
View File

@ -37,34 +37,34 @@ class plResManager;
class plPageOptimizer class plPageOptimizer
{ {
protected: protected:
typedef std::vector<plKey> KeyVec; typedef std::vector<plKey> KeyVec;
typedef std::set<plKey> KeySet; typedef std::set<plKey> KeySet;
KeyVec fKeyLoadOrder; // The order objects were loaded in KeyVec fKeyLoadOrder; // The order objects were loaded in
KeySet fLoadedKeys; // Keys we've loaded objects for, for quick lookup KeySet fLoadedKeys; // Keys we've loaded objects for, for quick lookup
KeyVec fAllKeys; // All the keys in the page KeyVec fAllKeys; // All the keys in the page
std::vector<UInt8> fBuf; std::vector<UInt8> fBuf;
bool fOptimized; // True after optimization if the page was already optimized bool fOptimized; // True after optimization if the page was already optimized
const char* fPagePath; // Path to our page const char* fPagePath; // Path to our page
char fTempPagePath[512]; // Path to the temp output page char fTempPagePath[512]; // Path to the temp output page
plLocation fLoc; // Location of our page plLocation fLoc; // Location of our page
plRegistryPageNode* fPageNode; // PageNode for our page plRegistryPageNode* fPageNode; // PageNode for our page
plResManager* fResMgr; plResManager* fResMgr;
static plPageOptimizer* fInstance; static plPageOptimizer* fInstance;
static void KeyedObjectProc(plKey key); static void KeyedObjectProc(plKey key);
void IWriteKeyData(hsStream* oldPage, hsStream* newPage, plKey key); void IWriteKeyData(hsStream* oldPage, hsStream* newPage, plKey key);
void IFindLoc(); void IFindLoc();
void IRewritePage(); void IRewritePage();
public: public:
plPageOptimizer(const char* pagePath); plPageOptimizer(const char* pagePath);
void Optimize(); void Optimize();
}; };
#endif // plPageOptimizer_h_inc #endif // plPageOptimizer_h_inc

BIN
Sources/Plasma/Apps/plPlasmaInstaller/Dirt.ICO
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.5 KiB

After

Width:  |  Height:  |  Size: 2.5 KiB

26
Sources/Plasma/Apps/plPlasmaInstaller/main.cpp
View File

@ -29,19 +29,19 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{ {
jvCoreUtil::SetHInstance(hInstance); jvCoreUtil::SetHInstance(hInstance);
plPlasmaInstaller installer; plPlasmaInstaller installer;
installer.Create(); installer.Create();
MSG msg; MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) while (GetMessage(&msg, NULL, 0, 0))
{ {
if (!IsDialogMessage(installer.GetHWnd(), &msg)) if (!IsDialogMessage(installer.GetHWnd(), &msg))
{ {
TranslateMessage(&msg); TranslateMessage(&msg);
DispatchMessage(&msg); DispatchMessage(&msg);
} }
} }
return msg.wParam; return msg.wParam;
} }

76
Sources/Plasma/Apps/plPlasmaInstaller/plInstallerReg.cpp
View File

@ -29,69 +29,69 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
static HKEY GetInstallerKey() static HKEY GetInstallerKey()
{ {
HKEY hSoftKey = NULL; HKEY hSoftKey = NULL;
HKEY hCompanyKey = NULL; HKEY hCompanyKey = NULL;
HKEY hAppKey = NULL; HKEY hAppKey = NULL;
if(RegOpenKeyEx(HKEY_CURRENT_USER, "software", 0, KEY_WRITE|KEY_READ, if(RegOpenKeyEx(HKEY_CURRENT_USER, "software", 0, KEY_WRITE|KEY_READ,
&hSoftKey) == ERROR_SUCCESS) &hSoftKey) == ERROR_SUCCESS)
{ {
DWORD dw; DWORD dw;
if(RegCreateKeyEx(hSoftKey, "Cyan", 0, REG_NONE, if(RegCreateKeyEx(hSoftKey, "Cyan", 0, REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL,
&hCompanyKey, &dw) == ERROR_SUCCESS) &hCompanyKey, &dw) == ERROR_SUCCESS)
{ {
RegCreateKeyEx(hCompanyKey, "PlasmaInstaller", 0, REG_NONE, RegCreateKeyEx(hCompanyKey, "PlasmaInstaller", 0, REG_NONE,
REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL,
&hAppKey, &dw); &hAppKey, &dw);
} }
} }
if (hSoftKey != NULL) if (hSoftKey != NULL)
RegCloseKey(hSoftKey); RegCloseKey(hSoftKey);
if (hCompanyKey != NULL) if (hCompanyKey != NULL)
RegCloseKey(hCompanyKey); RegCloseKey(hCompanyKey);
return hAppKey; return hAppKey;
} }
static void WriteRegString(const char* valueName, const char* value) static void WriteRegString(const char* valueName, const char* value)
{ {
HKEY installKey = GetInstallerKey(); HKEY installKey = GetInstallerKey();
RegSetValueEx(installKey, valueName, 0, REG_SZ, (const BYTE*)value, strlen(value)+1); RegSetValueEx(installKey, valueName, 0, REG_SZ, (const BYTE*)value, strlen(value)+1);
RegCloseKey(installKey); RegCloseKey(installKey);
} }
static bool ReadRegString(const char* valueName, char* value, DWORD size) static bool ReadRegString(const char* valueName, char* value, DWORD size)
{ {
HKEY installKey = GetInstallerKey(); HKEY installKey = GetInstallerKey();
bool ret = (RegQueryValueEx(installKey, valueName, NULL, NULL, (LPBYTE)value, &size) == ERROR_SUCCESS); bool ret = (RegQueryValueEx(installKey, valueName, NULL, NULL, (LPBYTE)value, &size) == ERROR_SUCCESS);
RegCloseKey(installKey); RegCloseKey(installKey);
return ret; return ret;
} }
void plInstallerReg::SetClientDir(const char* dir) void plInstallerReg::SetClientDir(const char* dir)
{ {
WriteRegString("Client", dir); WriteRegString("Client", dir);
} }
void plInstallerReg::SetMaxDir(const char* dir) void plInstallerReg::SetMaxDir(const char* dir)
{ {
WriteRegString("3dsmax", dir); WriteRegString("3dsmax", dir);
} }
const char* plInstallerReg::GetClientDir() const char* plInstallerReg::GetClientDir()
{ {
static char dir[MAX_PATH]; static char dir[MAX_PATH];
if (!ReadRegString("Client", dir, sizeof(dir))) if (!ReadRegString("Client", dir, sizeof(dir)))
strcpy(dir, "C:\\PlasmaClient"); strcpy(dir, "C:\\PlasmaClient");
return dir; return dir;
} }
const char* plInstallerReg::GetMaxDir() const char* plInstallerReg::GetMaxDir()
{ {
static char dir[MAX_PATH]; static char dir[MAX_PATH];
dir[0] = '\0'; dir[0] = '\0';
ReadRegString("3dsmax", dir, sizeof(dir)); ReadRegString("3dsmax", dir, sizeof(dir));
return dir; return dir;
} }

8
Sources/Plasma/Apps/plPlasmaInstaller/plInstallerReg.h
View File

@ -26,9 +26,9 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
namespace plInstallerReg namespace plInstallerReg
{ {
void SetClientDir(const char* dir); void SetClientDir(const char* dir);
void SetMaxDir(const char* dir); void SetMaxDir(const char* dir);
const char* GetClientDir(); const char* GetClientDir();
const char* GetMaxDir(); const char* GetMaxDir();
} }

518
Sources/Plasma/Apps/plPlasmaInstaller/plPlasmaInstaller.cpp
View File

@ -37,19 +37,19 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
plPlasmaInstaller::plPlasmaInstaller() plPlasmaInstaller::plPlasmaInstaller()
{ {
fDailyDir[0] = '\0'; fDailyDir[0] = '\0';
fDidGet = false; fDidGet = false;
fStatusList = nil; fStatusList = nil;
INITCOMMONCONTROLSEX icc = {0}; INITCOMMONCONTROLSEX icc = {0};
icc.dwSize = sizeof(INITCOMMONCONTROLSEX); icc.dwSize = sizeof(INITCOMMONCONTROLSEX);
icc.dwICC = ICC_DATE_CLASSES; icc.dwICC = ICC_DATE_CLASSES;
InitCommonControlsEx(&icc); InitCommonControlsEx(&icc);
} }
void plPlasmaInstaller::Create() void plPlasmaInstaller::Create()
{ {
ICreateDialog(IDD_INSTALLER, NULL); ICreateDialog(IDD_INSTALLER, NULL);
} }
static const char* kAllClientExes = "AllClientExes.zip"; static const char* kAllClientExes = "AllClientExes.zip";
@ -59,334 +59,334 @@ static const char* kTools = "AllToolsRelease.zip";
bool FileExists(const char* path, const char* filename) bool FileExists(const char* path, const char* filename)
{ {
char fullpath[MAX_PATH]; char fullpath[MAX_PATH];
sprintf(fullpath, "%s%s", path, filename); sprintf(fullpath, "%s%s", path, filename);
HANDLE hFile = CreateFile(fullpath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); HANDLE hFile = CreateFile(fullpath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (hFile != INVALID_HANDLE_VALUE) if (hFile != INVALID_HANDLE_VALUE)
{ {
CloseHandle(hFile); CloseHandle(hFile);
return true; return true;
} }
return false; return false;
} }
bool plPlasmaInstaller::IGetDailyDir() bool plPlasmaInstaller::IGetDailyDir()
{ {
// Get the branch // Get the branch
HWND hBuild = GetDlgItem(fDlg, IDC_BUILD_COMBO); HWND hBuild = GetDlgItem(fDlg, IDC_BUILD_COMBO);
int idx = ComboBox_GetCurSel(hBuild); int idx = ComboBox_GetCurSel(hBuild);
int buildServer = ComboBox_GetItemData(hBuild, idx); int buildServer = ComboBox_GetItemData(hBuild, idx);
HWND hTime = GetDlgItem(fDlg, IDC_TIME_COMBO); HWND hTime = GetDlgItem(fDlg, IDC_TIME_COMBO);
idx = ComboBox_GetCurSel(hTime); idx = ComboBox_GetCurSel(hTime);
int time = ComboBox_GetItemData(hTime, idx); int time = ComboBox_GetItemData(hTime, idx);
// Get the build date // Get the build date
SYSTEMTIME date; SYSTEMTIME date;
DateTime_GetSystemtime(GetDlgItem(fDlg, IDC_BRANCH_DATE), &date); DateTime_GetSystemtime(GetDlgItem(fDlg, IDC_BRANCH_DATE), &date);
char dateStr[] = "xx-xx-xxxx"; char dateStr[] = "xx-xx-xxxx";
sprintf(dateStr, "%02d-%02d-%04d", date.wMonth, date.wDay, date.wYear); sprintf(dateStr, "%02d-%02d-%04d", date.wMonth, date.wDay, date.wYear);
fDailyDir[0] = '\0'; fDailyDir[0] = '\0';
IAddStatusLine("Searching for %s build...", dateStr); IAddStatusLine("Searching for %s build...", dateStr);
char buildDir[MAX_PATH]; char buildDir[MAX_PATH];
static const char* kMainBuild = "\\\\Plasmabuild\\Output\\"; static const char* kMainBuild = "\\\\Plasmabuild\\Output\\";
static const char* kBranchBuild = "\\\\Branchbuild\\Output\\"; static const char* kBranchBuild = "\\\\Branchbuild\\Output\\";
static const char* kActiveBuild = "\\\\Activebuild\\Output\\"; static const char* kActiveBuild = "\\\\Activebuild\\Output\\";
static const char* kInternalMain = "Main-Internal\\"; static const char* kInternalMain = "Main-Internal\\";
static const char* kInternalBranch = "Branch-Internal\\"; static const char* kInternalBranch = "Branch-Internal\\";
static const char* kInternalActive = "Active-Internal\\"; static const char* kInternalActive = "Active-Internal\\";
switch (buildServer) switch (buildServer)
{ {
case kBuildMain: strcpy(buildDir, kMainBuild); break; case kBuildMain: strcpy(buildDir, kMainBuild); break;
case kBuildBranch: strcpy(buildDir, kBranchBuild); break; case kBuildBranch: strcpy(buildDir, kBranchBuild); break;
case kBuildActive: strcpy(buildDir, kActiveBuild); break; case kBuildActive: strcpy(buildDir, kActiveBuild); break;
} }
switch (time) switch (time)
{ {
case kNightly: case kNightly:
strcat(buildDir, "Nightly\\"); strcat(buildDir, "Nightly\\");
break; break;
case kAfternoon: case kAfternoon:
strcat(buildDir, "Afternoon\\"); strcat(buildDir, "Afternoon\\");
break; break;
case kEvening: case kEvening:
strcat(buildDir, "Evening\\"); strcat(buildDir, "Evening\\");
break; break;
} }
strcat(buildDir, dateStr); strcat(buildDir, dateStr);
strcat(buildDir, "\\"); strcat(buildDir, "\\");
switch (buildServer) switch (buildServer)
{ {
case kBuildMain: strcat(buildDir, kInternalMain); break; case kBuildMain: strcat(buildDir, kInternalMain); break;
case kBuildBranch: strcat(buildDir, kInternalBranch); break; case kBuildBranch: strcat(buildDir, kInternalBranch); break;
case kBuildActive: strcat(buildDir, kInternalActive); break; case kBuildActive: strcat(buildDir, kInternalActive); break;
} }
if (FileExists(buildDir, kAllClientExes) && FileExists(buildDir, kAllDllsRelease) && FileExists(buildDir, kScripts)) if (FileExists(buildDir, kAllClientExes) && FileExists(buildDir, kAllDllsRelease) && FileExists(buildDir, kScripts))
{ {
strcpy(fDailyDir, buildDir); strcpy(fDailyDir, buildDir);
const char* serverName = nil; const char* serverName = nil;
switch (buildServer) switch (buildServer)
{ {
case kBuildMain: serverName = "Main"; break; case kBuildMain: serverName = "Main"; break;
case kBuildBranch: serverName = "Branch"; break; case kBuildBranch: serverName = "Branch"; break;
case kBuildActive: serverName = "Active"; break; case kBuildActive: serverName = "Active"; break;
} }
IAddStatusLine("Found %s at %s", serverName, fDailyDir); IAddStatusLine("Found %s at %s", serverName, fDailyDir);
EnableWindow(GetDlgItem(fDlg, IDC_GET_BUTTON), TRUE); EnableWindow(GetDlgItem(fDlg, IDC_GET_BUTTON), TRUE);
return true; return true;
} }
IAddStatusLine("Couldn't find build"); IAddStatusLine("Couldn't find build");
EnableWindow(GetDlgItem(fDlg, IDC_GET_BUTTON), FALSE); EnableWindow(GetDlgItem(fDlg, IDC_GET_BUTTON), FALSE);
return false; return false;
} }
void plPlasmaInstaller::IInit() void plPlasmaInstaller::IInit()
{ {
const char* clientDir = plInstallerReg::GetClientDir(); const char* clientDir = plInstallerReg::GetClientDir();
SetDlgItemText(fDlg, IDC_CLIENT_EDIT, clientDir); SetDlgItemText(fDlg, IDC_CLIENT_EDIT, clientDir);
const char* maxDir = plInstallerReg::GetMaxDir(); const char* maxDir = plInstallerReg::GetMaxDir();
SetDlgItemText(fDlg, IDC_3DSMAX_EDIT, maxDir); SetDlgItemText(fDlg, IDC_3DSMAX_EDIT, maxDir);
fStatusList = GetDlgItem(fDlg, IDC_STATUS_LIST); fStatusList = GetDlgItem(fDlg, IDC_STATUS_LIST);
HWND hCombo = GetDlgItem(fDlg, IDC_BUILD_COMBO); HWND hCombo = GetDlgItem(fDlg, IDC_BUILD_COMBO);
int idx = ComboBox_AddString(hCombo, "Main"); int idx = ComboBox_AddString(hCombo, "Main");
ComboBox_SetItemData(hCombo, idx, kBuildMain); ComboBox_SetItemData(hCombo, idx, kBuildMain);
ComboBox_SetCurSel(hCombo, idx); ComboBox_SetCurSel(hCombo, idx);
idx = ComboBox_AddString(hCombo, "Branch"); idx = ComboBox_AddString(hCombo, "Branch");
ComboBox_SetItemData(hCombo, idx, kBuildBranch); ComboBox_SetItemData(hCombo, idx, kBuildBranch);
idx = ComboBox_AddString(hCombo, "Active"); idx = ComboBox_AddString(hCombo, "Active");
ComboBox_SetItemData(hCombo, idx, kBuildActive); ComboBox_SetItemData(hCombo, idx, kBuildActive);
HWND hTime = GetDlgItem(fDlg, IDC_TIME_COMBO); HWND hTime = GetDlgItem(fDlg, IDC_TIME_COMBO);
idx = ComboBox_AddString(hTime, "Nightly"); idx = ComboBox_AddString(hTime, "Nightly");
ComboBox_SetItemData(hTime, idx, kNightly); ComboBox_SetItemData(hTime, idx, kNightly);
ComboBox_SetCurSel(hTime, idx); ComboBox_SetCurSel(hTime, idx);
idx = ComboBox_AddString(hTime, "Afternoon"); idx = ComboBox_AddString(hTime, "Afternoon");
ComboBox_SetItemData(hTime, idx, kAfternoon); ComboBox_SetItemData(hTime, idx, kAfternoon);
idx = ComboBox_AddString(hTime, "Evening"); idx = ComboBox_AddString(hTime, "Evening");
ComboBox_SetItemData(hTime, idx, kEvening); ComboBox_SetItemData(hTime, idx, kEvening);
CheckDlgButton(fDlg, IDC_CLIENT_CHECK, BST_CHECKED); CheckDlgButton(fDlg, IDC_CLIENT_CHECK, BST_CHECKED);
CheckDlgButton(fDlg, IDC_SCRIPTS_CHECK, BST_CHECKED); CheckDlgButton(fDlg, IDC_SCRIPTS_CHECK, BST_CHECKED);
CheckDlgButton(fDlg, IDC_PLUGINS_CHECK, BST_CHECKED); CheckDlgButton(fDlg, IDC_PLUGINS_CHECK, BST_CHECKED);
ShowWindow(fDlg, SW_SHOW); ShowWindow(fDlg, SW_SHOW);
IGetDailyDir(); IGetDailyDir();
} }
BOOL plPlasmaInstaller::IDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) BOOL plPlasmaInstaller::IDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{ {
switch (msg) switch (msg)
{ {
case WM_INITDIALOG: case WM_INITDIALOG:
IInit(); IInit();
SetFocus(GetDlgItem(fDlg, IDC_GET_BUTTON)); SetFocus(GetDlgItem(fDlg, IDC_GET_BUTTON));
return FALSE; return FALSE;
case WM_CLOSE: case WM_CLOSE:
DestroyWindow(hDlg); DestroyWindow(hDlg);
return TRUE; return TRUE;
case WM_DESTROY: case WM_DESTROY:
PostQuitMessage(0); PostQuitMessage(0);
return TRUE; return TRUE;
case WM_COMMAND: case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED) if (HIWORD(wParam) == BN_CLICKED)
{ {
switch (LOWORD(wParam)) switch (LOWORD(wParam))
{ {
case IDCANCEL: case IDCANCEL:
PostMessage(hDlg, WM_CLOSE, 0, 0); PostMessage(hDlg, WM_CLOSE, 0, 0);
return TRUE; return TRUE;
case IDC_BROWSE_3DSMAX: case IDC_BROWSE_3DSMAX:
case IDC_BROWSE_CLIENT: case IDC_BROWSE_CLIENT:
IGetFolder(LOWORD(wParam) == IDC_BROWSE_CLIENT); IGetFolder(LOWORD(wParam) == IDC_BROWSE_CLIENT);
return TRUE; return TRUE;
case IDC_GET_BUTTON: case IDC_GET_BUTTON:
if (fDidGet) if (fDidGet)
PostMessage(hDlg, WM_CLOSE, 0, 0); PostMessage(hDlg, WM_CLOSE, 0, 0);
else else
IGet(); IGet();
return TRUE; return TRUE;
} }
} }
else if (HIWORD(wParam) == CBN_SELCHANGE && (LOWORD(wParam) == IDC_TIME_COMBO || LOWORD(wParam) == IDC_BUILD_COMBO)) else if (HIWORD(wParam) == CBN_SELCHANGE && (LOWORD(wParam) == IDC_TIME_COMBO || LOWORD(wParam) == IDC_BUILD_COMBO))
{ {
IGetDailyDir(); IGetDailyDir();
return TRUE; return TRUE;
} }
break; break;
case WM_NOTIFY: case WM_NOTIFY:
{ {
NMHDR* nmhdr = (NMHDR*)lParam; NMHDR* nmhdr = (NMHDR*)lParam;
if (nmhdr->idFrom == IDC_BRANCH_DATE && nmhdr->code == DTN_CLOSEUP/*DTN_DATETIMECHANGE*/) if (nmhdr->idFrom == IDC_BRANCH_DATE && nmhdr->code == DTN_CLOSEUP/*DTN_DATETIMECHANGE*/)
{ {
IGetDailyDir(); IGetDailyDir();
return TRUE; return TRUE;
} }
} }
break; break;
} }
return FALSE; return FALSE;
} }
void plPlasmaInstaller::IExtractZip(const char* filename, const char* dest) void plPlasmaInstaller::IExtractZip(const char* filename, const char* dest)
{ {
plUnzip unzip; plUnzip unzip;
if (unzip.Open(filename)) if (unzip.Open(filename))
{ {
IAddStatusLine("Extracting %s...", filename); IAddStatusLine("Extracting %s...", filename);
char buf[MAX_PATH]; char buf[MAX_PATH];
while (unzip.ExtractNext(dest, buf)) while (unzip.ExtractNext(dest, buf))
IAddStatusLine(" %s", buf); IAddStatusLine(" %s", buf);
IAddStatusLine(" %s", buf); IAddStatusLine(" %s", buf);
unzip.Close(); unzip.Close();
} }
} }
void plPlasmaInstaller::IGet() void plPlasmaInstaller::IGet()
{ {
bool getClient = (IsDlgButtonChecked(fDlg, IDC_CLIENT_CHECK) == BST_CHECKED); bool getClient = (IsDlgButtonChecked(fDlg, IDC_CLIENT_CHECK) == BST_CHECKED);
bool getScripts = (IsDlgButtonChecked(fDlg, IDC_SCRIPTS_CHECK) == BST_CHECKED); bool getScripts = (IsDlgButtonChecked(fDlg, IDC_SCRIPTS_CHECK) == BST_CHECKED);
bool getPlugins = (IsDlgButtonChecked(fDlg, IDC_PLUGINS_CHECK) == BST_CHECKED); bool getPlugins = (IsDlgButtonChecked(fDlg, IDC_PLUGINS_CHECK) == BST_CHECKED);
bool getTools = (IsDlgButtonChecked(fDlg, IDC_TOOLS_CHECK) == BST_CHECKED); bool getTools = (IsDlgButtonChecked(fDlg, IDC_TOOLS_CHECK) == BST_CHECKED);
const char* clientDir = plInstallerReg::GetClientDir(); const char* clientDir = plInstallerReg::GetClientDir();
if (*clientDir == '\0' && (getClient || getScripts)) if (*clientDir == '\0' && (getClient || getScripts))
{ {
MessageBox(fDlg, "You need to set your client directory", "Plasma Installer", MB_OK | MB_ICONASTERISK); MessageBox(fDlg, "You need to set your client directory", "Plasma Installer", MB_OK | MB_ICONASTERISK);
return; return;
} }
const char* maxDir = plInstallerReg::GetMaxDir(); const char* maxDir = plInstallerReg::GetMaxDir();
if (*maxDir == '\0' && getPlugins) if (*maxDir == '\0' && getPlugins)
{ {
MessageBox(fDlg, "You need to set your 3dsmax directory", "Plasma Installer", MB_OK | MB_ICONASTERISK); MessageBox(fDlg, "You need to set your 3dsmax directory", "Plasma Installer", MB_OK | MB_ICONASTERISK);
return; return;
} }
HWND hGetButton = GetDlgItem(fDlg, IDC_GET_BUTTON); HWND hGetButton = GetDlgItem(fDlg, IDC_GET_BUTTON);
EnableWindow(hGetButton, FALSE); EnableWindow(hGetButton, FALSE);
HCURSOR hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT)); HCURSOR hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
char buf[MAX_PATH]; char buf[MAX_PATH];
if (getScripts) if (getScripts)
{ {
sprintf(buf, "%s%s", fDailyDir, kScripts); sprintf(buf, "%s%s", fDailyDir, kScripts);
IExtractZip(buf, clientDir); IExtractZip(buf, clientDir);
} }
if (getClient) if (getClient)
{ {
sprintf(buf, "%s%s", fDailyDir, kAllClientExes); sprintf(buf, "%s%s", fDailyDir, kAllClientExes);
IExtractZip(buf, clientDir); IExtractZip(buf, clientDir);
} }
if (getPlugins) if (getPlugins)
{ {
sprintf(buf, "%s%s", fDailyDir, kAllDllsRelease); sprintf(buf, "%s%s", fDailyDir, kAllDllsRelease);
char pluginDir[MAX_PATH]; char pluginDir[MAX_PATH];
sprintf(pluginDir, "%s\\plugins", maxDir); sprintf(pluginDir, "%s\\plugins", maxDir);
IExtractZip(buf, pluginDir); IExtractZip(buf, pluginDir);
IAddStatusLine("Updating PlasmaMAX2.ini..."); IAddStatusLine("Updating PlasmaMAX2.ini...");
sprintf(buf, "%s\\plugcfg\\PlasmaMAX2.ini", maxDir); sprintf(buf, "%s\\plugcfg\\PlasmaMAX2.ini", maxDir);
WritePrivateProfileString("SceneViewer", "Directory", clientDir, buf); WritePrivateProfileString("SceneViewer", "Directory", clientDir, buf);
} }
if (getTools) if (getTools)
{ {
sprintf(buf, "%s%s", fDailyDir, kTools); sprintf(buf, "%s%s", fDailyDir, kTools);
char toolBuf[MAX_PATH]; char toolBuf[MAX_PATH];
sprintf(toolBuf, "%s\\Tools", clientDir); sprintf(toolBuf, "%s\\Tools", clientDir);
IExtractZip(buf, toolBuf); IExtractZip(buf, toolBuf);
} }
IAddStatusLine("Updating path..."); IAddStatusLine("Updating path...");
SetPlasmaPath(clientDir); SetPlasmaPath(clientDir);
IAddStatusLine("Done"); IAddStatusLine("Done");
SetCursor(hOldCursor); SetCursor(hOldCursor);
fDidGet = true; fDidGet = true;
SetWindowText(hGetButton, "Close"); SetWindowText(hGetButton, "Close");
EnableWindow(hGetButton, TRUE); EnableWindow(hGetButton, TRUE);
} }
void plPlasmaInstaller::IGetFolder(bool client) void plPlasmaInstaller::IGetFolder(bool client)
{ {
char path[MAX_PATH]; char path[MAX_PATH];
if (client) if (client)
strcpy(path, plInstallerReg::GetClientDir()); strcpy(path, plInstallerReg::GetClientDir());
else else
strcpy(path, plInstallerReg::GetMaxDir()); strcpy(path, plInstallerReg::GetMaxDir());
if (plBrowseFolder::GetFolder(path, path)) if (plBrowseFolder::GetFolder(path, path))
{ {
if (client) if (client)
{ {
SetDlgItemText(fDlg, IDC_CLIENT_EDIT, path); SetDlgItemText(fDlg, IDC_CLIENT_EDIT, path);
plInstallerReg::SetClientDir(path); plInstallerReg::SetClientDir(path);
} }
else else
{ {
SetDlgItemText(fDlg, IDC_3DSMAX_EDIT, path); SetDlgItemText(fDlg, IDC_3DSMAX_EDIT, path);
plInstallerReg::SetMaxDir(path); plInstallerReg::SetMaxDir(path);
} }
} }
} }
void plPlasmaInstaller::IAddStatusLine(const char* format, ...) void plPlasmaInstaller::IAddStatusLine(const char* format, ...)
{ {
if (!format || *format == '\0') if (!format || *format == '\0')
return; return;
va_list args; va_list args;
va_start(args, format); va_start(args, format);
char buf[2048]; char buf[2048];
int numWritten = _vsnprintf(buf, sizeof(buf), format, args); int numWritten = _vsnprintf(buf, sizeof(buf), format, args);
hsAssert(numWritten > 0, "Buffer too small"); hsAssert(numWritten > 0, "Buffer too small");
va_end(args); va_end(args);
int idx = ListBox_AddString(fStatusList, buf); int idx = ListBox_AddString(fStatusList, buf);
ListBox_SetCurSel(fStatusList, idx); ListBox_SetCurSel(fStatusList, idx);
// Pump the message queue // Pump the message queue
MSG msg; MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{ {
if (!IsDialogMessage(&msg)) if (!IsDialogMessage(&msg))
{ {
TranslateMessage(&msg); TranslateMessage(&msg);
DispatchMessage(&msg); DispatchMessage(&msg);
} }
} }
} }

30
Sources/Plasma/Apps/plPlasmaInstaller/plPlasmaInstaller.h
View File

@ -28,30 +28,30 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
class plPlasmaInstaller : public jvBaseDlg class plPlasmaInstaller : public jvBaseDlg
{ {
protected: protected:
char fDailyDir[MAX_PATH]; char fDailyDir[MAX_PATH];
bool fDidGet; bool fDidGet;
HWND fStatusList; HWND fStatusList;
enum { kBuildMain, kBuildBranch, kBuildActive }; enum { kBuildMain, kBuildBranch, kBuildActive };
enum { kNightly, kAfternoon, kEvening }; enum { kNightly, kAfternoon, kEvening };
virtual BOOL IDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam); virtual BOOL IDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam);
bool IGetDailyDir(); bool IGetDailyDir();
void IGetFolder(bool client); void IGetFolder(bool client);
void IGet(); void IGet();
void IInit(); void IInit();
void IExtractZip(const char* filename, const char* dest); void IExtractZip(const char* filename, const char* dest);
void IAddStatusLine(const char* format, ...); void IAddStatusLine(const char* format, ...);
public: public:
plPlasmaInstaller(); plPlasmaInstaller();
void Create(); void Create();
HWND GetHWnd() { return fDlg; } HWND GetHWnd() { return fDlg; }
}; };

116
Sources/Plasma/Apps/plPlasmaInstaller/plSetPlasmaPath.cpp
View File

@ -28,77 +28,77 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
static HKEY GetEnvironKey() static HKEY GetEnvironKey()
{ {
HKEY hSystemKey = NULL; HKEY hSystemKey = NULL;
HKEY hControlSetKey = NULL; HKEY hControlSetKey = NULL;
HKEY hControlKey = NULL; HKEY hControlKey = NULL;
HKEY hSessionKey = NULL; HKEY hSessionKey = NULL;
HKEY hEnvironKey = NULL; HKEY hEnvironKey = NULL;
if ((RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM", 0, KEY_READ, &hSystemKey) == ERROR_SUCCESS) && if ((RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM", 0, KEY_READ, &hSystemKey) == ERROR_SUCCESS) &&
(RegOpenKeyEx(hSystemKey, "CurrentControlSet", 0, KEY_READ, &hControlSetKey) == ERROR_SUCCESS) && (RegOpenKeyEx(hSystemKey, "CurrentControlSet", 0, KEY_READ, &hControlSetKey) == ERROR_SUCCESS) &&
(RegOpenKeyEx(hControlSetKey, "Control", 0, KEY_READ, &hControlKey) == ERROR_SUCCESS) && (RegOpenKeyEx(hControlSetKey, "Control", 0, KEY_READ, &hControlKey) == ERROR_SUCCESS) &&
(RegOpenKeyEx(hControlKey, "Session Manager", 0, KEY_READ, &hSessionKey) == ERROR_SUCCESS)) (RegOpenKeyEx(hControlKey, "Session Manager", 0, KEY_READ, &hSessionKey) == ERROR_SUCCESS))
{ {
RegOpenKeyEx(hSessionKey, "Environment", 0, KEY_READ | KEY_WRITE, &hEnvironKey); RegOpenKeyEx(hSessionKey, "Environment", 0, KEY_READ | KEY_WRITE, &hEnvironKey);
} }
if (hSystemKey != NULL) if (hSystemKey != NULL)
RegCloseKey(hSystemKey); RegCloseKey(hSystemKey);
if (hControlSetKey != NULL) if (hControlSetKey != NULL)
RegCloseKey(hControlSetKey); RegCloseKey(hControlSetKey);
if (hControlKey != NULL) if (hControlKey != NULL)
RegCloseKey(hControlKey); RegCloseKey(hControlKey);
if (hSessionKey != NULL) if (hSessionKey != NULL)
RegCloseKey(hSessionKey); RegCloseKey(hSessionKey);
return hEnvironKey; return hEnvironKey;
} }
void SetPlasmaPath(const char* plasmaPath) void SetPlasmaPath(const char* plasmaPath)
{ {
bool pathSet = false; bool pathSet = false;
HKEY hEnvironKey = GetEnvironKey(); HKEY hEnvironKey = GetEnvironKey();
if (hEnvironKey) if (hEnvironKey)
{ {
// Make sure the PlasmaGameDir var is in the path // Make sure the PlasmaGameDir var is in the path
DWORD size = 0; DWORD size = 0;
if (ERROR_SUCCESS == RegQueryValueEx(hEnvironKey, "Path", NULL, NULL, NULL, &size)) if (ERROR_SUCCESS == RegQueryValueEx(hEnvironKey, "Path", NULL, NULL, NULL, &size))
{ {
char* oldPath = new char[size]; char* oldPath = new char[size];
static const char* kPlasmaVar = "%PlasmaGameDir%"; static const char* kPlasmaVar = "%PlasmaGameDir%";
if (ERROR_SUCCESS == RegQueryValueEx(hEnvironKey, "Path", NULL, NULL, (BYTE*)oldPath, &size)) if (ERROR_SUCCESS == RegQueryValueEx(hEnvironKey, "Path", NULL, NULL, (BYTE*)oldPath, &size))
{ {
pathSet = (strstr(oldPath, kPlasmaVar) != NULL); pathSet = (strstr(oldPath, kPlasmaVar) != NULL);
if (!pathSet) if (!pathSet)
{ {
char* newPath = new char[size+strlen(kPlasmaVar)+1]; char* newPath = new char[size+strlen(kPlasmaVar)+1];
strcpy(newPath, oldPath); strcpy(newPath, oldPath);
strcat(newPath, ";"); strcat(newPath, ";");
strcat(newPath, kPlasmaVar); strcat(newPath, kPlasmaVar);
RegSetValueEx(hEnvironKey, "Path", 0, REG_EXPAND_SZ, (BYTE*)newPath, strlen(newPath)+1); RegSetValueEx(hEnvironKey, "Path", 0, REG_EXPAND_SZ, (BYTE*)newPath, strlen(newPath)+1);
delete [] newPath; delete [] newPath;
} }
} }
delete [] oldPath; delete [] oldPath;
} }
// Set the PlasmaGameDir var // Set the PlasmaGameDir var
RegSetValueEx(hEnvironKey, "PlasmaGameDir", 0, REG_SZ, (BYTE*)plasmaPath, strlen(plasmaPath)+1); RegSetValueEx(hEnvironKey, "PlasmaGameDir", 0, REG_SZ, (BYTE*)plasmaPath, strlen(plasmaPath)+1);
// Notify command prompts and stuff that environ changed // Notify command prompts and stuff that environ changed
DWORD ret; DWORD ret;
SendMessageTimeout(HWND_BROADCAST, SendMessageTimeout(HWND_BROADCAST,
WM_SETTINGCHANGE, WM_SETTINGCHANGE,
0, 0,
(LPARAM)"Environment", (LPARAM)"Environment",
SMTO_ABORTIFHUNG, SMTO_ABORTIFHUNG,
5000, 5000,
&ret); &ret);
} }
} }

158
Sources/Plasma/Apps/plPlasmaInstaller/plUnzip.cpp
View File

@ -35,119 +35,119 @@ plUnzip::plUnzip() : fFile(nil)
bool plUnzip::Open(const char* filename) bool plUnzip::Open(const char* filename)
{ {
fFile = unzOpen(filename); fFile = unzOpen(filename);
return (fFile != nil); return (fFile != nil);
} }
bool plUnzip::Close() bool plUnzip::Close()
{ {
bool ret = false; bool ret = false;
if (fFile != nil) if (fFile != nil)
{ {
ret = (UNZ_OK == unzClose(fFile)); ret = (UNZ_OK == unzClose(fFile));
fFile = nil; fFile = nil;
} }
return ret; return ret;
} }
void plUnzip::IGetFullPath(const char* destDir, const char* filename, char* outFilename) void plUnzip::IGetFullPath(const char* destDir, const char* filename, char* outFilename)
{ {
// Make sure the dest ends with a slash // Make sure the dest ends with a slash
strcpy(outFilename, destDir); strcpy(outFilename, destDir);
char lastChar = outFilename[strlen(outFilename)-1]; char lastChar = outFilename[strlen(outFilename)-1];
if (lastChar != '\\' && lastChar != '/') if (lastChar != '\\' && lastChar != '/')
strcat(outFilename, "\\"); strcat(outFilename, "\\");
// Check if the output filename has any directories in it // Check if the output filename has any directories in it
const char* forward = strrchr(filename, '/'); const char* forward = strrchr(filename, '/');
const char* backward = strrchr(filename, '\\'); const char* backward = strrchr(filename, '\\');
if (!forward && !backward) if (!forward && !backward)
{ {
CreateDirectory(outFilename, NULL); CreateDirectory(outFilename, NULL);
strcat(outFilename, filename); strcat(outFilename, filename);
} }
else else
{ {
const char* fileOnly = (forward > backward) ? forward+1 : backward+1; const char* fileOnly = (forward > backward) ? forward+1 : backward+1;
strncat(outFilename, filename, fileOnly-filename); strncat(outFilename, filename, fileOnly-filename);
CreateDirectory(outFilename, NULL); CreateDirectory(outFilename, NULL);
strcat(outFilename, fileOnly); strcat(outFilename, fileOnly);
} }
} }
void plUnzip::IExtractCurrent(const char* destDir, char* fileName) void plUnzip::IExtractCurrent(const char* destDir, char* fileName)
{ {
char filename[MAX_PATH]; char filename[MAX_PATH];
if (unzGetCurrentFileInfo(fFile, nil, filename, sizeof(filename), nil, 0, nil, 0) == UNZ_OK) if (unzGetCurrentFileInfo(fFile, nil, filename, sizeof(filename), nil, 0, nil, 0) == UNZ_OK)
{ {
strcpy(fileName, filename); strcpy(fileName, filename);
if (unzOpenCurrentFile(fFile) == UNZ_OK) if (unzOpenCurrentFile(fFile) == UNZ_OK)
{ {
char outFilename[MAX_PATH]; char outFilename[MAX_PATH];
IGetFullPath(destDir, filename, outFilename); IGetFullPath(destDir, filename, outFilename);
// Make sure to take off the read-only flag if the file exists, and is RO // Make sure to take off the read-only flag if the file exists, and is RO
DWORD attrs = GetFileAttributes(outFilename); DWORD attrs = GetFileAttributes(outFilename);
if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_READONLY)) if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_READONLY))
SetFileAttributes(outFilename, attrs & ~FILE_ATTRIBUTE_READONLY); SetFileAttributes(outFilename, attrs & ~FILE_ATTRIBUTE_READONLY);
hsUNIXStream outFile; hsUNIXStream outFile;
if (outFile.Open(outFilename, "wb")) if (outFile.Open(outFilename, "wb"))
{ {
char buf[2048]; char buf[2048];
int numRead; int numRead;
while ((numRead = unzReadCurrentFile(fFile, buf, sizeof(buf))) > 0) while ((numRead = unzReadCurrentFile(fFile, buf, sizeof(buf))) > 0)
{ {
outFile.Write(numRead, buf); outFile.Write(numRead, buf);
} }
outFile.Close(); outFile.Close();
unz_file_info_s info; unz_file_info_s info;
unzGetCurrentFileInfo(fFile, &info, NULL, 0, NULL, 0, NULL, 0); unzGetCurrentFileInfo(fFile, &info, NULL, 0, NULL, 0, NULL, 0);
SYSTEMTIME sysTime = {0}; SYSTEMTIME sysTime = {0};
sysTime.wDay = info.tmu_date.tm_mday; sysTime.wDay = info.tmu_date.tm_mday;
sysTime.wMonth = info.tmu_date.tm_mon+1; sysTime.wMonth = info.tmu_date.tm_mon+1;
sysTime.wYear = info.tmu_date.tm_year; sysTime.wYear = info.tmu_date.tm_year;
sysTime.wHour = info.tmu_date.tm_hour; sysTime.wHour = info.tmu_date.tm_hour;
sysTime.wMinute = info.tmu_date.tm_min; sysTime.wMinute = info.tmu_date.tm_min;
sysTime.wSecond = info.tmu_date.tm_sec; sysTime.wSecond = info.tmu_date.tm_sec;
FILETIME localFileTime, utcFileTime; FILETIME localFileTime, utcFileTime;
SystemTimeToFileTime(&sysTime, &localFileTime); SystemTimeToFileTime(&sysTime, &localFileTime);
LocalFileTimeToFileTime(&localFileTime, &utcFileTime); LocalFileTimeToFileTime(&localFileTime, &utcFileTime);
HANDLE hFile = CreateFile(outFilename, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); HANDLE hFile = CreateFile(outFilename, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
SetFileTime(hFile, NULL, NULL, &utcFileTime); SetFileTime(hFile, NULL, NULL, &utcFileTime);
CloseHandle(hFile); CloseHandle(hFile);
} }
unzCloseCurrentFile(fFile); unzCloseCurrentFile(fFile);
} }
} }
} }
void plUnzip::ExtractAll(const char* destDir) void plUnzip::ExtractAll(const char* destDir)
{ {
if (unzGoToFirstFile(fFile) != UNZ_OK) if (unzGoToFirstFile(fFile) != UNZ_OK)
return; return;
do do
{ {
IExtractCurrent(destDir); IExtractCurrent(destDir);
} }
while (unzGoToNextFile(fFile) == UNZ_OK); while (unzGoToNextFile(fFile) == UNZ_OK);
} }
bool plUnzip::ExtractNext(const char* destDir, char* fileName) bool plUnzip::ExtractNext(const char* destDir, char* fileName)
{ {
IExtractCurrent(destDir, fileName); IExtractCurrent(destDir, fileName);
return (unzGoToNextFile(fFile) == UNZ_OK); return (unzGoToNextFile(fFile) == UNZ_OK);
} }

16
Sources/Plasma/Apps/plPlasmaInstaller/plUnzip.h
View File

@ -32,19 +32,19 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
class plUnzip class plUnzip
{ {
protected: protected:
unzFile fFile; unzFile fFile;
void IGetFullPath(const char* destDir, const char* filename, char* outFilename); void IGetFullPath(const char* destDir, const char* filename, char* outFilename);
void IExtractCurrent(const char* destDir, char* fileName=nil); void IExtractCurrent(const char* destDir, char* fileName=nil);
public: public:
plUnzip(); plUnzip();
bool Open(const char* filename); bool Open(const char* filename);
bool Close(); bool Close();
void ExtractAll(const char* destDir); void ExtractAll(const char* destDir);
bool ExtractNext(const char* destDir, char* fileName); bool ExtractNext(const char* destDir, char* fileName);
}; };
#endif // plUnzip_h_inc #endif // plUnzip_h_inc

BIN
Sources/Plasma/Apps/plPlasmaUpdate/Dirt.ICO
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.5 KiB

After

Width:  |  Height:  |  Size: 2.5 KiB

32
Sources/Plasma/Apps/plPlasmaUpdate/main.cpp
View File

@ -30,23 +30,23 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{ {
jvCoreUtil::SetHInstance(hInstance); jvCoreUtil::SetHInstance(hInstance);
plPlasmaUpdate installer; plPlasmaUpdate installer;
if (!installer.Create()) if (!installer.Create())
return 0; return 0;
if (!stricmp(lpCmdLine, "AutoDownload")) if (!stricmp(lpCmdLine, "AutoDownload"))
installer.SetAutoDownload(); installer.SetAutoDownload();
MSG msg; MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) while (GetMessage(&msg, NULL, 0, 0))
{ {
if (!jvBaseDlg::IsDialogMessage(&msg)) if (!jvBaseDlg::IsDialogMessage(&msg))
{ {
TranslateMessage(&msg); TranslateMessage(&msg);
DispatchMessage(&msg); DispatchMessage(&msg);
} }
} }
return 0; return 0;
} }

162
Sources/Plasma/Apps/plPlasmaUpdate/plFileGrabber.cpp
View File

@ -28,72 +28,72 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
/* Not needed currently - if we want it again we'll have to reimplement HTTP comm /* Not needed currently - if we want it again we'll have to reimplement HTTP comm
plHttpFileGrabber::plHttpFileGrabber() plHttpFileGrabber::plHttpFileGrabber()
{ {
fRequestMgr.SetHostname(""); fRequestMgr.SetHostname("");
} }
bool plHttpFileGrabber::FileToStream(const char* path, hsStream* stream) bool plHttpFileGrabber::FileToStream(const char* path, hsStream* stream)
{ {
std::string pathStr(path); std::string pathStr(path);
bool retVal = fRequestMgr.GetFileToStream(path, stream); bool retVal = fRequestMgr.GetFileToStream(path, stream);
stream->SetPosition(0); stream->SetPosition(0);
return retVal; return retVal;
} }
void plHttpFileGrabber::SetServer(const char* server) void plHttpFileGrabber::SetServer(const char* server)
{ {
std::string serverPath(server); std::string serverPath(server);
fRequestMgr.SetHostname(serverPath); fRequestMgr.SetHostname(serverPath);
} }
void plHttpFileGrabber::MakeProperPath(char* path) void plHttpFileGrabber::MakeProperPath(char* path)
{ {
char* slash = NULL; char* slash = NULL;
do { do {
slash = strchr(path, '\\'); slash = strchr(path, '\\');
if (slash) if (slash)
*slash = '/'; *slash = '/';
} while(slash != NULL); } while(slash != NULL);
} }
void plHttpFileGrabber::SetUsernamePassword(const std::string& username, const std::string& password) void plHttpFileGrabber::SetUsernamePassword(const std::string& username, const std::string& password)
{ {
fRequestMgr.SetUsername(username); fRequestMgr.SetUsername(username);
fRequestMgr.SetPassword(password); fRequestMgr.SetPassword(password);
} }
bool plHttpFileGrabber::IsServerAvailable(const char* serverName) bool plHttpFileGrabber::IsServerAvailable(const char* serverName)
{ {
bool retVal = false; bool retVal = false;
HINTERNET hInternet = InternetOpen("Parable Patcher",INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,0); HINTERNET hInternet = InternetOpen("Parable Patcher",INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,0);
if (hInternet) if (hInternet)
{ {
HINTERNET hHttp = InternetConnect(hInternet,serverName,8080,fUserName.c_str(),fPassword.c_str(),INTERNET_SERVICE_HTTP,0,0); HINTERNET hHttp = InternetConnect(hInternet,serverName,8080,fUserName.c_str(),fPassword.c_str(),INTERNET_SERVICE_HTTP,0,0);
if (hHttp) if (hHttp)
{ {
HINTERNET hRequest = HttpOpenRequest(hHttp, "GET", "/Current/Current.txt", NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_KEEP_CONNECTION, 0); HINTERNET hRequest = HttpOpenRequest(hHttp, "GET", "/Current/Current.txt", NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_KEEP_CONNECTION, 0);
if (hRequest) if (hRequest)
{ {
DWORD dwCode; DWORD dwCode;
DWORD dwSize = sizeof(dwCode); DWORD dwSize = sizeof(dwCode);
HttpSendRequest(hRequest, NULL, 0, NULL, 0); HttpSendRequest(hRequest, NULL, 0, NULL, 0);
HttpQueryInfo(hRequest, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &dwCode, &dwSize, NULL); HttpQueryInfo(hRequest, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &dwCode, &dwSize, NULL);
if (dwCode >= 200 && dwCode < 300) if (dwCode >= 200 && dwCode < 300)
{ {
retVal = true; retVal = true;
} }
InternetCloseHandle(hRequest); InternetCloseHandle(hRequest);
} }
InternetCloseHandle(hHttp); InternetCloseHandle(hHttp);
} }
InternetCloseHandle(hInternet); InternetCloseHandle(hInternet);
} }
return retVal; return retVal;
} }
*/ */
@ -104,67 +104,67 @@ plNetShareFileGrabber::plNetShareFileGrabber()
#define BUFFER_SIZE 1024*1024 #define BUFFER_SIZE 1024*1024
bool plNetShareFileGrabber::FileToStream(const char* path, hsStream* stream) bool plNetShareFileGrabber::FileToStream(const char* path, hsStream* stream)
{ {
hsUNIXStream fileStream; hsUNIXStream fileStream;
std::string filePath = fServerName + path; std::string filePath = fServerName + path;
if (fileStream.Open(filePath.c_str())) if (fileStream.Open(filePath.c_str()))
{ {
char* buffer = new char[BUFFER_SIZE]; char* buffer = new char[BUFFER_SIZE];
UInt32 streamSize = fileStream.GetSizeLeft(); UInt32 streamSize = fileStream.GetSizeLeft();
while (streamSize > (BUFFER_SIZE)) while (streamSize > (BUFFER_SIZE))
{ {
fileStream.Read(BUFFER_SIZE, buffer); fileStream.Read(BUFFER_SIZE, buffer);
stream->Write(BUFFER_SIZE, buffer); stream->Write(BUFFER_SIZE, buffer);
streamSize = fileStream.GetSizeLeft(); streamSize = fileStream.GetSizeLeft();
} }
if (streamSize > 0) if (streamSize > 0)
{ {
fileStream.Read(streamSize, buffer); fileStream.Read(streamSize, buffer);
stream->Write(streamSize, buffer); stream->Write(streamSize, buffer);
} }
stream->Rewind(); stream->Rewind();
fileStream.Close(); fileStream.Close();
delete [] buffer; delete [] buffer;
return true; return true;
} }
return false; return false;
} }
void plNetShareFileGrabber::SetServer(const char* server) void plNetShareFileGrabber::SetServer(const char* server)
{ {
fServerName = "\\\\"; fServerName = "\\\\";
fServerName += server; fServerName += server;
} }
void plNetShareFileGrabber::MakeProperPath(char* path) void plNetShareFileGrabber::MakeProperPath(char* path)
{ {
char* slash = NULL; char* slash = NULL;
do { do {
slash = strchr(path, '/'); slash = strchr(path, '/');
if (slash) if (slash)
*slash = '\\'; *slash = '\\';
} while(slash != NULL); } while(slash != NULL);
} }
bool plNetShareFileGrabber::IsServerAvailable(const char* serverName, const char* currentDir) bool plNetShareFileGrabber::IsServerAvailable(const char* serverName, const char* currentDir)
{ {
bool retVal = false; bool retVal = false;
char serverPath[MAX_PATH]; char serverPath[MAX_PATH];
sprintf(serverPath, "\\\\%s\\%s\\Current.txt", serverName, currentDir); sprintf(serverPath, "\\\\%s\\%s\\Current.txt", serverName, currentDir);
hsUNIXStream si; hsUNIXStream si;
if (si.Open(serverPath, "rb")) if (si.Open(serverPath, "rb"))
{ {
retVal = true; retVal = true;
si.Close(); si.Close();
} }
return retVal; return retVal;
} }

40
Sources/Plasma/Apps/plPlasmaUpdate/plFileGrabber.h
View File

@ -32,42 +32,42 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
class plFileGrabber class plFileGrabber
{ {
public: public:
virtual bool IsServerAvailable(const char* serverName, const char* currentDir) = 0; virtual bool IsServerAvailable(const char* serverName, const char* currentDir) = 0;
virtual bool FileToStream(const char* path, hsStream* stream) = 0; virtual bool FileToStream(const char* path, hsStream* stream) = 0;
virtual void SetServer(const char* server) = 0; virtual void SetServer(const char* server) = 0;
virtual void MakeProperPath(char* path) = 0; virtual void MakeProperPath(char* path) = 0;
virtual bool NeedsAuth() { return false; } virtual bool NeedsAuth() { return false; }
virtual void SetUsernamePassword(const std::string& username, const std::string& password) {} virtual void SetUsernamePassword(const std::string& username, const std::string& password) {}
}; };
/* Not needed currently - if we want it again we'll have to reimplement HTTP comm /* Not needed currently - if we want it again we'll have to reimplement HTTP comm
class plHttpFileGrabber : public plFileGrabber class plHttpFileGrabber : public plFileGrabber
{ {
private: private:
plHttpDiverseRequestMgr fRequestMgr; plHttpDiverseRequestMgr fRequestMgr;
public: public:
plHttpFileGrabber(); plHttpFileGrabber();
virtual bool IsServerAvailable(const char* serverName); virtual bool IsServerAvailable(const char* serverName);
virtual bool FileToStream(const char* path, hsStream* stream); virtual bool FileToStream(const char* path, hsStream* stream);
virtual void SetServer(const char* server); virtual void SetServer(const char* server);
virtual void MakeProperPath(char* path); virtual void MakeProperPath(char* path);
virtual bool NeedsAuth() { return true; } virtual bool NeedsAuth() { return true; }
virtual void SetUsernamePassword(const std::string& username, const std::string& password); virtual void SetUsernamePassword(const std::string& username, const std::string& password);
}; };
*/ */
class plNetShareFileGrabber : public plFileGrabber class plNetShareFileGrabber : public plFileGrabber
{ {
private: private:
std::string fServerName; std::string fServerName;
public: public:
plNetShareFileGrabber(); plNetShareFileGrabber();
virtual bool IsServerAvailable(const char* serverName, const char* currentDir); virtual bool IsServerAvailable(const char* serverName, const char* currentDir);
virtual bool FileToStream(const char* path, hsStream* stream); virtual bool FileToStream(const char* path, hsStream* stream);
virtual void SetServer(const char* server); virtual void SetServer(const char* server);
virtual void MakeProperPath(char* path); virtual void MakeProperPath(char* path);
}; };
#endif #endif

418
Sources/Plasma/Apps/plPlasmaUpdate/plManifest.cpp
View File

@ -36,282 +36,282 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
class plManifestFile class plManifestFile
{ {
public: public:
char* fFilename; char* fFilename;
plMD5Checksum fSum; plMD5Checksum fSum;
plMD5Checksum fLocalSum; plMD5Checksum fLocalSum;
UInt32 fSize; UInt32 fSize;
UInt32 fCompressedSize; UInt32 fCompressedSize;
UInt32 fFlags; UInt32 fFlags;
}; };
plManifest::plManifest(LogFunc log) : plManifest::plManifest(LogFunc log) :
fDownloadFiles(0), fDownloadFiles(0),
fDownloadBytes(0), fDownloadBytes(0),
fDirtySums(false), fDirtySums(false),
fLog(log) fLog(log)
{ {
} }
plManifest::~plManifest() plManifest::~plManifest()
{ {
if (fDirtySums) if (fDirtySums)
IWriteCache(); IWriteCache();
delete [] fManifestName; delete [] fManifestName;
for (int i = 0; i < fFiles.size(); i++) for (int i = 0; i < fFiles.size(); i++)
{ {
delete [] fFiles[i]->fFilename; delete [] fFiles[i]->fFilename;
delete fFiles[i]; delete fFiles[i];
} }
} }
bool plManifest::Read(hsStream* mfsStream, const char* basePath, const char* mfsName) bool plManifest::Read(hsStream* mfsStream, const char* basePath, const char* mfsName)
{ {
fBasePath = basePath; fBasePath = basePath;
fManifestName = hsStrcpy(mfsName); fManifestName = hsStrcpy(mfsName);
fLog("--- Reading manifest for %s", fManifestName); fLog("--- Reading manifest for %s", fManifestName);
char buf[256]; char buf[256];
while (mfsStream->ReadLn(buf, sizeof(buf))) while (mfsStream->ReadLn(buf, sizeof(buf)))
{ {
plManifestFile* file = new plManifestFile; plManifestFile* file = new plManifestFile;
char* tok = strtok(buf, "\t"); char* tok = strtok(buf, "\t");
file->fFilename = hsStrcpy(tok); file->fFilename = hsStrcpy(tok);
tok = strtok(nil, "\t"); tok = strtok(nil, "\t");
file->fSum.SetFromHexString(tok); file->fSum.SetFromHexString(tok);
tok = strtok(nil, "\t"); tok = strtok(nil, "\t");
file->fSize = atoi(tok); file->fSize = atoi(tok);
tok = strtok(nil, "\t"); tok = strtok(nil, "\t");
file->fCompressedSize = atoi(tok); file->fCompressedSize = atoi(tok);
tok = strtok(nil, "\t"); tok = strtok(nil, "\t");
file->fFlags = atoi(tok); file->fFlags = atoi(tok);
fFiles.push_back(file); fFiles.push_back(file);
} }
return true; return true;
} }
void plManifest::ValidateFiles(ProgressFunc progress) void plManifest::ValidateFiles(ProgressFunc progress)
{ {
if (fFiles.empty()) if (fFiles.empty())
return; return;
fLog("--- Validating files for %s", fManifestName); fLog("--- Validating files for %s", fManifestName);
IReadCache(progress); IReadCache(progress);
fDownloadFiles = 0; fDownloadFiles = 0;
fDownloadBytes = 0; fDownloadBytes = 0;
for (int i = 0; i < fFiles.size(); i++) for (int i = 0; i < fFiles.size(); i++)
{ {
plManifestFile* file = fFiles[i]; plManifestFile* file = fFiles[i];
// If the local checksum is invalid, this file wasn't in our cache. // If the local checksum is invalid, this file wasn't in our cache.
// Get the sum, and update the progress bar. // Get the sum, and update the progress bar.
if (!file->fLocalSum.IsValid()) if (!file->fLocalSum.IsValid())
{ {
fLog(" No sum for %s, calculating", file->fFilename); fLog(" No sum for %s, calculating", file->fFilename);
file->fLocalSum.CalcFromFile(file->fFilename); file->fLocalSum.CalcFromFile(file->fFilename);
fDirtySums = true; fDirtySums = true;
progress(file->fFilename, 1); progress(file->fFilename, 1);
} }
if (file->fLocalSum != file->fSum) if (file->fLocalSum != file->fSum)
{ {
fLog(" Incorrect sum for %s", file->fFilename); fLog(" Incorrect sum for %s", file->fFilename);
fDownloadFiles++; fDownloadFiles++;
fDownloadBytes += file->fCompressedSize; fDownloadBytes += file->fCompressedSize;
} }
} }
fLog("--- Need to download %d files, %.1f MB", fDownloadFiles, float(fDownloadBytes) / (1024.f*1024.f)); fLog("--- Need to download %d files, %.1f MB", fDownloadFiles, float(fDownloadBytes) / (1024.f*1024.f));
} }
void plManifest::DownloadUpdates(ProgressFunc progress, plFileGrabber* grabber) void plManifest::DownloadUpdates(ProgressFunc progress, plFileGrabber* grabber)
{ {
for (int i = 0; i < fFiles.size(); i++) for (int i = 0; i < fFiles.size(); i++)
{ {
plManifestFile* file = fFiles[i]; plManifestFile* file = fFiles[i];
if (file->fLocalSum != file->fSum) if (file->fLocalSum != file->fSum)
{ {
char serverPath[MAX_PATH]; char serverPath[MAX_PATH];
sprintf(serverPath, "%s%s.gz", fBasePath.c_str(), file->fFilename); sprintf(serverPath, "%s%s.gz", fBasePath.c_str(), file->fFilename);
grabber->MakeProperPath(serverPath); grabber->MakeProperPath(serverPath);
hsRAMStream serverStream; hsRAMStream serverStream;
if (grabber->FileToStream(serverPath, &serverStream)) if (grabber->FileToStream(serverPath, &serverStream))
{ {
plFileUtils::EnsureFilePathExists(file->fFilename); plFileUtils::EnsureFilePathExists(file->fFilename);
plFileUtils::RemoveFile(file->fFilename, true); plFileUtils::RemoveFile(file->fFilename, true);
plZlibStream localStream; plZlibStream localStream;
if (localStream.Open(file->fFilename, "wb")) if (localStream.Open(file->fFilename, "wb"))
{ {
char dataBuf[1024]; char dataBuf[1024];
UInt32 sizeLeft = serverStream.GetSizeLeft(); UInt32 sizeLeft = serverStream.GetSizeLeft();
while (UInt32 amtRead = serverStream.Read( (sizeof(dataBuf) > sizeLeft) ? sizeLeft : sizeof(dataBuf), dataBuf)) while (UInt32 amtRead = serverStream.Read( (sizeof(dataBuf) > sizeLeft) ? sizeLeft : sizeof(dataBuf), dataBuf))
{ {
progress(file->fFilename, amtRead); progress(file->fFilename, amtRead);
localStream.Write(amtRead, dataBuf); localStream.Write(amtRead, dataBuf);
sizeLeft = serverStream.GetSizeLeft(); sizeLeft = serverStream.GetSizeLeft();
} }
localStream.Close(); localStream.Close();
// FIXME - Should we recalc this? // FIXME - Should we recalc this?
file->fLocalSum = file->fSum; file->fLocalSum = file->fSum;
fDirtySums = true; fDirtySums = true;
if (file->fFlags != 0) if (file->fFlags != 0)
IDecompressSound(file); IDecompressSound(file);
} }
} }
} }
} }
} }
plManifestFile* plManifest::IFindFile(const char* name) plManifestFile* plManifest::IFindFile(const char* name)
{ {
// FIXME // FIXME
for (int i = 0; i < fFiles.size(); i++) for (int i = 0; i < fFiles.size(); i++)
{ {
if (hsStrEQ(fFiles[i]->fFilename, name)) if (hsStrEQ(fFiles[i]->fFilename, name))
return fFiles[i]; return fFiles[i];
} }
return nil; return nil;
} }
// KLUDGE - Put age checksums in the dat dir, for backwards compatability // KLUDGE - Put age checksums in the dat dir, for backwards compatability
const char* plManifest::IGetCacheDir() const char* plManifest::IGetCacheDir()
{ {
const char* prefix = ""; const char* prefix = "";
if (strncmp(fFiles[0]->fFilename, "dat\\", strlen("dat\\")) == 0) if (strncmp(fFiles[0]->fFilename, "dat\\", strlen("dat\\")) == 0)
return "dat\\"; return "dat\\";
else else
return ""; return "";
} }
#define kCacheFileVersion 1 #define kCacheFileVersion 1
void plManifest::IWriteCache() void plManifest::IWriteCache()
{ {
plEncryptedStream s; plEncryptedStream s;
bool openedFile = false; bool openedFile = false;
UInt32 numFiles = 0; UInt32 numFiles = 0;
for (int i = 0; i < fFiles.size(); i++) for (int i = 0; i < fFiles.size(); i++)
{ {
plManifestFile* file = fFiles[i]; plManifestFile* file = fFiles[i];
plUnifiedTime modifiedTime; plUnifiedTime modifiedTime;
if (file->fLocalSum.IsValid() && if (file->fLocalSum.IsValid() &&
plFileUtils::GetFileTimes(file->fFilename, nil, &modifiedTime)) plFileUtils::GetFileTimes(file->fFilename, nil, &modifiedTime))
{ {
if (!openedFile) if (!openedFile)
{ {
openedFile = true; openedFile = true;
char buf[256]; char buf[256];
sprintf(buf, "%s%s.sum", IGetCacheDir(), fManifestName); sprintf(buf, "%s%s.sum", IGetCacheDir(), fManifestName);
s.Open(buf, "wb"); s.Open(buf, "wb");
s.WriteSwap32(0); s.WriteSwap32(0);
s.WriteSwap32(kCacheFileVersion); s.WriteSwap32(kCacheFileVersion);
} }
s.WriteSafeString(file->fFilename); s.WriteSafeString(file->fFilename);
plMD5Checksum& checksum = file->fLocalSum; plMD5Checksum& checksum = file->fLocalSum;
s.Write(checksum.GetSize(), checksum.GetValue()); s.Write(checksum.GetSize(), checksum.GetValue());
modifiedTime.Write(&s); modifiedTime.Write(&s);
numFiles++; numFiles++;
} }
} }
if (openedFile) if (openedFile)
{ {
s.Rewind(); s.Rewind();
s.WriteSwap32(numFiles); s.WriteSwap32(numFiles);
s.Close(); s.Close();
} }
} }
void plManifest::IReadCache(ProgressFunc progress) void plManifest::IReadCache(ProgressFunc progress)
{ {
// //
// Load valid cached checksums // Load valid cached checksums
// //
char buf[256]; char buf[256];
sprintf(buf, "%s%s.sum", IGetCacheDir(), fManifestName); sprintf(buf, "%s%s.sum", IGetCacheDir(), fManifestName);
hsStream* s = plEncryptedStream::OpenEncryptedFile(buf); hsStream* s = plEncryptedStream::OpenEncryptedFile(buf);
if (s) if (s)
{ {
UInt32 numCached = s->ReadSwap32(); UInt32 numCached = s->ReadSwap32();
UInt32 cacheFileVersion = s->ReadSwap32(); UInt32 cacheFileVersion = s->ReadSwap32();
if (cacheFileVersion != kCacheFileVersion) if (cacheFileVersion != kCacheFileVersion)
{ {
s->Close(); s->Close();
delete s; delete s;
return; return;
} }
fLog(" Reading cache...found %d cached sums", numCached); fLog(" Reading cache...found %d cached sums", numCached);
for (int i = 0; i < numCached; i++) for (int i = 0; i < numCached; i++)
{ {
char* name = s->ReadSafeString(); char* name = s->ReadSafeString();
UInt8 checksumBuf[MD5_DIGEST_LENGTH]; UInt8 checksumBuf[MD5_DIGEST_LENGTH];
s->Read(sizeof(checksumBuf), checksumBuf); s->Read(sizeof(checksumBuf), checksumBuf);
plMD5Checksum checksum; plMD5Checksum checksum;
checksum.SetValue(checksumBuf); checksum.SetValue(checksumBuf);
plUnifiedTime modifiedTime; plUnifiedTime modifiedTime;
modifiedTime.Read(s); modifiedTime.Read(s);
plManifestFile* file = IFindFile(name); plManifestFile* file = IFindFile(name);
if (file) if (file)
{ {
plUnifiedTime curModifiedTime; plUnifiedTime curModifiedTime;
if (plFileUtils::GetFileTimes(file->fFilename, nil, &curModifiedTime)) if (plFileUtils::GetFileTimes(file->fFilename, nil, &curModifiedTime))
{ {
if (curModifiedTime == modifiedTime) if (curModifiedTime == modifiedTime)
file->fLocalSum = checksum; file->fLocalSum = checksum;
else else
fLog(" Invalid modified time for %s", name); fLog(" Invalid modified time for %s", name);
} }
else else
fLog(" Couldn't get modified time for %s", name); fLog(" Couldn't get modified time for %s", name);
progress(file->fFilename, 1); progress(file->fFilename, 1);
} }
else else
fLog(" Couldn't find cached file '%s' in manifest, discarding", name); fLog(" Couldn't find cached file '%s' in manifest, discarding", name);
delete [] name; delete [] name;
} }
s->Close(); s->Close();
delete s; delete s;
} }
} }
#include "../plAudioCore/plAudioFileReader.h" #include "../plAudioCore/plAudioFileReader.h"
@ -321,26 +321,26 @@ void plManifest::IReadCache(ProgressFunc progress)
bool plManifest::IDecompressSound(plManifestFile* file) bool plManifest::IDecompressSound(plManifestFile* file)
{ {
enum enum
{ {
kSndFlagCacheSplit = 1<<0, kSndFlagCacheSplit = 1<<0,
kSndFlagCacheStereo = 1<<2, kSndFlagCacheStereo = 1<<2,
}; };
if (hsCheckBits(file->fFlags, kSndFlagCacheSplit) || if (hsCheckBits(file->fFlags, kSndFlagCacheSplit) ||
hsCheckBits(file->fFlags, kSndFlagCacheStereo)) hsCheckBits(file->fFlags, kSndFlagCacheStereo))
{ {
plAudioFileReader* reader = plAudioFileReader::CreateReader(file->fFilename, plAudioCore::kAll, plAudioFileReader::kStreamNative); plAudioFileReader* reader = plAudioFileReader::CreateReader(file->fFilename, plAudioCore::kAll, plAudioFileReader::kStreamNative);
if (!reader) if (!reader)
return false; return false;
UInt32 size = reader->GetDataSize(); UInt32 size = reader->GetDataSize();
delete reader; delete reader;
if (hsCheckBits(file->fFlags, kSndFlagCacheSplit)) if (hsCheckBits(file->fFlags, kSndFlagCacheSplit))
plAudioFileReader::CacheFile(file->fFilename, true); plAudioFileReader::CacheFile(file->fFilename, true);
if (hsCheckBits(file->fFlags, kSndFlagCacheStereo)) if (hsCheckBits(file->fFlags, kSndFlagCacheStereo))
plAudioFileReader::CacheFile(file->fFilename, false); plAudioFileReader::CacheFile(file->fFilename, false);
} }
return true; return true;
} }

42
Sources/Plasma/Apps/plPlasmaUpdate/plManifest.h
View File

@ -39,39 +39,39 @@ typedef void (*LogFunc)(const char* format, ...);
class plManifest class plManifest
{ {
protected: protected:
std::string fBasePath; std::string fBasePath;
char* fManifestName; char* fManifestName;
typedef std::vector<plManifestFile*> FileVec; typedef std::vector<plManifestFile*> FileVec;
FileVec fFiles; FileVec fFiles;
UInt32 fDownloadFiles; UInt32 fDownloadFiles;
UInt32 fDownloadBytes; UInt32 fDownloadBytes;
bool fDirtySums; bool fDirtySums;
LogFunc fLog; LogFunc fLog;
bool IDecompressSound(plManifestFile* file); bool IDecompressSound(plManifestFile* file);
plManifestFile* IFindFile(const char* name); plManifestFile* IFindFile(const char* name);
const char* IGetCacheDir(); const char* IGetCacheDir();
void IReadCache(ProgressFunc progress); void IReadCache(ProgressFunc progress);
void IWriteCache(); void IWriteCache();
public: public:
plManifest(LogFunc log); plManifest(LogFunc log);
~plManifest(); ~plManifest();
bool Read(hsStream* mfsStream, const char* basePath, const char* mfsName); bool Read(hsStream* mfsStream, const char* basePath, const char* mfsName);
void ValidateFiles(ProgressFunc progress); void ValidateFiles(ProgressFunc progress);
void DownloadUpdates(ProgressFunc progress, plFileGrabber* grabber); void DownloadUpdates(ProgressFunc progress, plFileGrabber* grabber);
int NumFiles() { return fFiles.size(); } int NumFiles() { return fFiles.size(); }
UInt32 NumDownloadFiles() { return fDownloadFiles; } UInt32 NumDownloadFiles() { return fDownloadFiles; }
UInt32 DownloadSize() { return fDownloadBytes; } UInt32 DownloadSize() { return fDownloadBytes; }
}; };
#endif // plManifest_h_inc #endif // plManifest_h_inc

80
Sources/Plasma/Apps/plPlasmaUpdate/plPlasmaServers.cpp
View File

@ -29,51 +29,51 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
bool plPlasmaServers::GetServerInfo() bool plPlasmaServers::GetServerInfo()
{ {
bool ret = true; bool ret = true;
hsUNIXStream si; hsUNIXStream si;
if (si.Open("\\\\dirtcake\\ServerInfo\\ServerInfo.txt", "rb")) if (si.Open("\\\\dirtcake\\ServerInfo\\ServerInfo.txt", "rb"))
{ {
char line[256]; char line[256];
// Make sure we've got the latest version // Make sure we've got the latest version
if (si.ReadLn(line, sizeof(line))) if (si.ReadLn(line, sizeof(line)))
{ {
int version = atoi(line); int version = atoi(line);
si.ReadLn(line, sizeof(line)); si.ReadLn(line, sizeof(line));
if (version != 4) if (version != 4)
{ {
char errorMsg[512]; char errorMsg[512];
sprintf(errorMsg, "This installer is out of date.\nPlease get the latest version from:\n\n%s", line); sprintf(errorMsg, "This installer is out of date.\nPlease get the latest version from:\n\n%s", line);
hsMessageBox(errorMsg, "Error", hsMessageBoxNormal, hsMessageBoxIconError); hsMessageBox(errorMsg, "Error", hsMessageBoxNormal, hsMessageBoxIconError);
ret = false; ret = false;
} }
} }
else else
ret = false; ret = false;
// Read in the servers, one per line // Read in the servers, one per line
while (ret && si.ReadLn(line, sizeof(line))) while (ret && si.ReadLn(line, sizeof(line)))
{ {
ServerInfo info; ServerInfo info;
info.fServerAddress = strtok(line, ","); info.fServerAddress = strtok(line, ",");
info.fServerName = strtok(nil, ","); info.fServerName = strtok(nil, ",");
info.fURLBase = strtok(nil, ","); info.fURLBase = strtok(nil, ",");
info.fOutputDir = strtok(nil, ","); info.fOutputDir = strtok(nil, ",");
info.fCurrentDir = strtok(nil, ","); info.fCurrentDir = strtok(nil, ",");
info.fCodeDir = strtok(nil, ","); info.fCodeDir = strtok(nil, ",");
fServers.push_back(info); fServers.push_back(info);
} }
si.Close(); si.Close();
} }
else else
{ {
hsMessageBox("Couldn't find server info", "Error", hsMessageBoxNormal, hsMessageBoxIconError); hsMessageBox("Couldn't find server info", "Error", hsMessageBoxNormal, hsMessageBoxIconError);
ret = false; ret = false;
} }
return ret; return ret;
} }

38
Sources/Plasma/Apps/plPlasmaUpdate/plPlasmaServers.h
View File

@ -32,28 +32,28 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
class plPlasmaServers class plPlasmaServers
{ {
protected: protected:
class ServerInfo class ServerInfo
{ {
public: public:
std::string fServerAddress; std::string fServerAddress;
std::string fServerName; std::string fServerName;
std::string fURLBase; std::string fURLBase;
std::string fOutputDir; std::string fOutputDir;
std::string fCurrentDir; std::string fCurrentDir;
std::string fCodeDir; std::string fCodeDir;
}; };
std::vector<ServerInfo> fServers; std::vector<ServerInfo> fServers;
public: public:
bool GetServerInfo(); bool GetServerInfo();
int GetNumServers() { return fServers.size(); } int GetNumServers() { return fServers.size(); }
std::string& GetServerAddress(int i) { return fServers[i].fServerAddress; } std::string& GetServerAddress(int i) { return fServers[i].fServerAddress; }
std::string& GetServerName(int i) { return fServers[i].fServerName; } std::string& GetServerName(int i) { return fServers[i].fServerName; }
std::string& GetServerURLBase(int i) { return fServers[i].fURLBase; } std::string& GetServerURLBase(int i) { return fServers[i].fURLBase; }
std::string& GetServerOutputDir(int i) { return fServers[i].fOutputDir; } std::string& GetServerOutputDir(int i) { return fServers[i].fOutputDir; }
std::string& GetServerCurrentDir(int i) { return fServers[i].fCurrentDir; } std::string& GetServerCurrentDir(int i) { return fServers[i].fCurrentDir; }
std::string& GetServerCodeDir(int i) { return fServers[i].fCodeDir; } std::string& GetServerCodeDir(int i) { return fServers[i].fCodeDir; }
}; };
#endif // plPlasmaServers_h_inc #endif // plPlasmaServers_h_inc

642
Sources/Plasma/Apps/plPlasmaUpdate/plPlasmaUpdate.cpp
View File

@ -49,451 +49,451 @@ std::string plPlasmaUpdate::fPassword = "parabledata";
plPlasmaUpdate::plPlasmaUpdate() : fCanExit(true), fProgressType(kValidating), fResizer(nil), fAutoDownload(false) plPlasmaUpdate::plPlasmaUpdate() : fCanExit(true), fProgressType(kValidating), fResizer(nil), fAutoDownload(false)
{ {
INITCOMMONCONTROLSEX icc = {0}; INITCOMMONCONTROLSEX icc = {0};
icc.dwSize = sizeof(INITCOMMONCONTROLSEX); icc.dwSize = sizeof(INITCOMMONCONTROLSEX);
icc.dwICC = ICC_PROGRESS_CLASS; icc.dwICC = ICC_PROGRESS_CLASS;
InitCommonControlsEx(&icc); InitCommonControlsEx(&icc);
gInst = this; gInst = this;
_getcwd(fIniPath, sizeof(fIniPath)); _getcwd(fIniPath, sizeof(fIniPath));
char lastChar = fIniPath[strlen(fIniPath)]; char lastChar = fIniPath[strlen(fIniPath)];
if (lastChar != '\\' && lastChar != '/') if (lastChar != '\\' && lastChar != '/')
strcat(fIniPath, "\\"); strcat(fIniPath, "\\");
strcat(fIniPath, "ParableUpdate.ini"); strcat(fIniPath, "ParableUpdate.ini");
fFileGrabber = new plNetShareFileGrabber; fFileGrabber = new plNetShareFileGrabber;
} }
plPlasmaUpdate::~plPlasmaUpdate() plPlasmaUpdate::~plPlasmaUpdate()
{ {
delete fResizer; delete fResizer;
if (fFileGrabber) if (fFileGrabber)
delete fFileGrabber; delete fFileGrabber;
} }
bool plPlasmaUpdate::Create() bool plPlasmaUpdate::Create()
{ {
if (!fServers.GetServerInfo()) if (!fServers.GetServerInfo())
return false; return false;
ICreateDialog(IDD_UPDATE, NULL); ICreateDialog(IDD_UPDATE, NULL);
return true; return true;
} }
BOOL CALLBACK plPlasmaUpdate::ILoginWinProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) BOOL CALLBACK plPlasmaUpdate::ILoginWinProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{ {
switch( msg ) switch( msg )
{ {
case WM_INITDIALOG: case WM_INITDIALOG:
SetFocus(GetDlgItem(hDlg, IDC_USERNAME)); SetFocus(GetDlgItem(hDlg, IDC_USERNAME));
break; break;
case WM_COMMAND: case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED && (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)) if (HIWORD(wParam) == BN_CLICKED && (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL))
{ {
bool ok = (LOWORD(wParam) == IDOK); bool ok = (LOWORD(wParam) == IDOK);
if (ok) if (ok)
{ {
char username[25]; char username[25];
char password[25]; char password[25];
GetDlgItemText(hDlg, IDC_USERNAME, username, 25); GetDlgItemText(hDlg, IDC_USERNAME, username, 25);
GetDlgItemText(hDlg, IDC_PASSWORD, password, 25); GetDlgItemText(hDlg, IDC_PASSWORD, password, 25);
fUserName = username; fUserName = username;
hsAssert(false, "who uses this program?"); hsAssert(false, "who uses this program?");
// plChallengeResponse::HashPassword(password, fPassword); // plChallengeResponse::HashPassword(password, fPassword);
} }
EndDialog(hDlg, ok); EndDialog(hDlg, ok);
return TRUE; return TRUE;
} }
break; break;
} }
return FALSE; return FALSE;
} }
void plPlasmaUpdate::IInit() void plPlasmaUpdate::IInit()
{ {
char curServerAddress[256]; char curServerAddress[256];
GetPrivateProfileString("PlasmaUpdate", "ServerAddress", "", curServerAddress, sizeof(curServerAddress), fIniPath); GetPrivateProfileString("PlasmaUpdate", "ServerAddress", "", curServerAddress, sizeof(curServerAddress), fIniPath);
bool external = (GetPrivateProfileInt("PlasmaUpdate", "External", 0, fIniPath) != 0); bool external = (GetPrivateProfileInt("PlasmaUpdate", "External", 0, fIniPath) != 0);
HWND hCombo = GetDlgItem(fDlg, IDC_BUILD_COMBO); HWND hCombo = GetDlgItem(fDlg, IDC_BUILD_COMBO);
for (int i = 0; i < fServers.GetNumServers(); i++) for (int i = 0; i < fServers.GetNumServers(); i++)
{ {
std::string& serverAddress = fServers.GetServerAddress(i); std::string& serverAddress = fServers.GetServerAddress(i);
std::string& serverName = fServers.GetServerName(i); std::string& serverName = fServers.GetServerName(i);
std::string& currentDir = fServers.GetServerCurrentDir(i); std::string& currentDir = fServers.GetServerCurrentDir(i);
if (!fFileGrabber->IsServerAvailable(serverAddress.c_str(), currentDir.c_str())) if (!fFileGrabber->IsServerAvailable(serverAddress.c_str(), currentDir.c_str()))
continue; continue;
bool thisServer = (serverAddress == curServerAddress); bool thisServer = (serverAddress == curServerAddress);
int idx = ComboBox_AddString(hCombo, serverName.c_str()); int idx = ComboBox_AddString(hCombo, serverName.c_str());
ComboBox_SetItemData(hCombo, idx, MAKELPARAM(i, 0)); ComboBox_SetItemData(hCombo, idx, MAKELPARAM(i, 0));
if (thisServer && !external) if (thisServer && !external)
ComboBox_SetCurSel(hCombo, idx); ComboBox_SetCurSel(hCombo, idx);
std::string extName = serverName + " (External)"; std::string extName = serverName + " (External)";
idx = ComboBox_AddString(hCombo, extName.c_str()); idx = ComboBox_AddString(hCombo, extName.c_str());
ComboBox_SetItemData(hCombo, idx, MAKELPARAM(i, 1)); ComboBox_SetItemData(hCombo, idx, MAKELPARAM(i, 1));
if (thisServer && external) if (thisServer && external)
ComboBox_SetCurSel(hCombo, idx); ComboBox_SetCurSel(hCombo, idx);
} }
if (ComboBox_GetCurSel(hCombo) == -1) if (ComboBox_GetCurSel(hCombo) == -1)
ComboBox_SetCurSel(hCombo, 0); ComboBox_SetCurSel(hCombo, 0);
SendMessage(fDlg, WM_SETICON, ICON_BIG, (LPARAM)LoadIcon(jvCoreUtil::GetHInstance(), MAKEINTRESOURCE(IDI_ICON))); SendMessage(fDlg, WM_SETICON, ICON_BIG, (LPARAM)LoadIcon(jvCoreUtil::GetHInstance(), MAKEINTRESOURCE(IDI_ICON)));
SendMessage(fDlg, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(jvCoreUtil::GetHInstance(), MAKEINTRESOURCE(IDI_ICON))); SendMessage(fDlg, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(jvCoreUtil::GetHInstance(), MAKEINTRESOURCE(IDI_ICON)));
fResizer = new jvDialogResizer(fDlg); fResizer = new jvDialogResizer(fDlg);
fResizer->AddControl(IDC_BUILD_COMBO, jvDialogResizer::kResizeX); fResizer->AddControl(IDC_BUILD_COMBO, jvDialogResizer::kResizeX);
fResizer->AddControl(IDC_STATUS_LIST, jvDialogResizer::kResizeX | jvDialogResizer::kResizeY); fResizer->AddControl(IDC_STATUS_LIST, jvDialogResizer::kResizeX | jvDialogResizer::kResizeY);
fResizer->AddControl(IDC_PROGRESS, jvDialogResizer::kLockBottom | jvDialogResizer::kResizeX); fResizer->AddControl(IDC_PROGRESS, jvDialogResizer::kLockBottom | jvDialogResizer::kResizeX);
fResizer->AddControl(IDC_DL_TEXT, jvDialogResizer::kLockBottom | jvDialogResizer::kResizeX); fResizer->AddControl(IDC_DL_TEXT, jvDialogResizer::kLockBottom | jvDialogResizer::kResizeX);
fResizer->AddControl(IDC_DL_BUTTON, jvDialogResizer::kLockBottom | jvDialogResizer::kCenterX); fResizer->AddControl(IDC_DL_BUTTON, jvDialogResizer::kLockBottom | jvDialogResizer::kCenterX);
fResizer->SetSize(360, 320); fResizer->SetSize(360, 320);
fResizer->LoadPosAndSize("PlasmaUpdate"); fResizer->LoadPosAndSize("PlasmaUpdate");
bool goTime = true; bool goTime = true;
if (fFileGrabber->NeedsAuth()) if (fFileGrabber->NeedsAuth())
{ {
/* /*
if (!DialogBox(NULL, MAKEINTRESOURCE(IDD_PLASMAUPDATE_LOGIN), fDlg, ILoginWinProc)) if (!DialogBox(NULL, MAKEINTRESOURCE(IDD_PLASMAUPDATE_LOGIN), fDlg, ILoginWinProc))
goTime = false; goTime = false;
else else
*/ */
fFileGrabber->SetUsernamePassword(fUserName, fPassword); fFileGrabber->SetUsernamePassword(fUserName, fPassword);
} }
if (goTime) if (goTime)
{ {
ShowWindow(fDlg, SW_SHOW); ShowWindow(fDlg, SW_SHOW);
PostMessage(fDlg, WM_UPDATE_SERVER, 0, 0); PostMessage(fDlg, WM_UPDATE_SERVER, 0, 0);
} }
else else
PostQuitMessage(0); PostQuitMessage(0);
} }
void plPlasmaUpdate::IShutdown() void plPlasmaUpdate::IShutdown()
{ {
fResizer->SavePosAndSize("PlasmaUpdate"); fResizer->SavePosAndSize("PlasmaUpdate");
delete fResizer; delete fResizer;
fResizer = NULL; fResizer = NULL;
IDeleteManifests(); IDeleteManifests();
} }
void plPlasmaUpdate::IEnableCtrls(bool enable) void plPlasmaUpdate::IEnableCtrls(bool enable)
{ {
fCanExit = enable; fCanExit = enable;
EnableWindow(GetDlgItem(fDlg, IDC_BUILD_COMBO), enable); EnableWindow(GetDlgItem(fDlg, IDC_BUILD_COMBO), enable);
HWND hDlButton = GetDlgItem(fDlg, IDC_DL_BUTTON); HWND hDlButton = GetDlgItem(fDlg, IDC_DL_BUTTON);
if (fManifests.empty()) if (fManifests.empty())
SetWindowText(hDlButton, "Close"); SetWindowText(hDlButton, "Close");
else else
SetWindowText(hDlButton, "Download"); SetWindowText(hDlButton, "Download");
EnableWindow(hDlButton, enable); EnableWindow(hDlButton, enable);
if (enable) if (enable)
SetFocus(hDlButton); SetFocus(hDlButton);
} }
void plPlasmaUpdate::IDeleteManifests() void plPlasmaUpdate::IDeleteManifests()
{ {
for (int i = 0; i < fManifests.size(); i++) for (int i = 0; i < fManifests.size(); i++)
delete fManifests[i]; delete fManifests[i];
fManifests.clear(); fManifests.clear();
} }
bool plPlasmaUpdate::IGetManifests(const char* serverRoot, bool external) bool plPlasmaUpdate::IGetManifests(const char* serverRoot, bool external)
{ {
IDeleteManifests(); IDeleteManifests();
char filePath[MAX_PATH]; char filePath[MAX_PATH];
sprintf(filePath, "%sCurrent.txt", serverRoot); sprintf(filePath, "%sCurrent.txt", serverRoot);
enum Sections enum Sections
{ {
kVersion, kVersion,
kInternal, kInternal,
kExternal, kExternal,
kAll kAll
}; };
int curSection = kVersion; int curSection = kVersion;
hsRAMStream s; hsRAMStream s;
hsRAMStream manifestStream; hsRAMStream manifestStream;
if (fFileGrabber->FileToStream(filePath, &s)) if (fFileGrabber->FileToStream(filePath, &s))
{ {
char buf[256]; char buf[256];
while (s.ReadLn(buf, sizeof(buf))) while (s.ReadLn(buf, sizeof(buf)))
{ {
if (buf[0] == '[') if (buf[0] == '[')
{ {
if (hsStrEQ(buf, "[Version]")) if (hsStrEQ(buf, "[Version]"))
curSection = kVersion; curSection = kVersion;
else if (hsStrEQ(buf, "[Internal]")) else if (hsStrEQ(buf, "[Internal]"))
curSection = kInternal; curSection = kInternal;
else if (hsStrEQ(buf, "[External]")) else if (hsStrEQ(buf, "[External]"))
curSection = kExternal; curSection = kExternal;
else if (hsStrEQ(buf, "[All]")) else if (hsStrEQ(buf, "[All]"))
curSection = kAll; curSection = kAll;
} }
else else
{ {
if (curSection == kVersion) if (curSection == kVersion)
{ {
int version = atoi(buf); int version = atoi(buf);
if (version != 1) if (version != 1)
{ {
hsMessageBox("Your copy of PlasmaUpdate is out of date.\nPlease get the latest version.", "Error", hsMessageBoxNormal, hsMessageBoxIconError); hsMessageBox("Your copy of PlasmaUpdate is out of date.\nPlease get the latest version.", "Error", hsMessageBoxNormal, hsMessageBoxIconError);
return false; return false;
} }
} }
else if ((!external && curSection == kInternal) else if ((!external && curSection == kInternal)
|| (external && curSection == kExternal) || (external && curSection == kExternal)
|| curSection == kAll) || curSection == kAll)
{ {
//if (curSection == kAll && !(!strcmp(buf, "Data\\Movies.mfs") || !strcmp(buf, "Data\\Sounds.mfs"))) //if (curSection == kAll && !(!strcmp(buf, "Data\\Movies.mfs") || !strcmp(buf, "Data\\Sounds.mfs")))
// continue; // continue;
sprintf(filePath, "%s%s", serverRoot, buf); sprintf(filePath, "%s%s", serverRoot, buf);
fFileGrabber->MakeProperPath(filePath); fFileGrabber->MakeProperPath(filePath);
manifestStream.Reset(); manifestStream.Reset();
fFileGrabber->FileToStream(filePath, &manifestStream); fFileGrabber->FileToStream(filePath, &manifestStream);
plFileUtils::StripFile(filePath); plFileUtils::StripFile(filePath);
plManifest* manifest = new plManifest(ILog); plManifest* manifest = new plManifest(ILog);
manifest->Read(&manifestStream, filePath, buf); manifest->Read(&manifestStream, filePath, buf);
fManifests.push_back(manifest); fManifests.push_back(manifest);
} }
} }
} }
return true; return true;
} }
return false; return false;
} }
void plPlasmaUpdate::IUpdateServer() void plPlasmaUpdate::IUpdateServer()
{ {
char buf[256]; char buf[256];
IEnableCtrls(false); IEnableCtrls(false);
SetDlgItemText(fDlg, IDC_DL_TEXT, "Checking for updates..."); SetDlgItemText(fDlg, IDC_DL_TEXT, "Checking for updates...");
// //
// Figure out what server we're checking // Figure out what server we're checking
// //
bool external = false; bool external = false;
char serverRoot[MAX_PATH]; char serverRoot[MAX_PATH];
{ {
HWND hCombo = GetDlgItem(fDlg, IDC_BUILD_COMBO); HWND hCombo = GetDlgItem(fDlg, IDC_BUILD_COMBO);
int idx = ComboBox_GetCurSel(hCombo); int idx = ComboBox_GetCurSel(hCombo);
LPARAM data = ComboBox_GetItemData(hCombo, idx); LPARAM data = ComboBox_GetItemData(hCombo, idx);
int server = LOWORD(data); int server = LOWORD(data);
external = (HIWORD(data) != 0); external = (HIWORD(data) != 0);
sprintf(serverRoot, "/%s/", fServers.GetServerCurrentDir(server).c_str()); sprintf(serverRoot, "/%s/", fServers.GetServerCurrentDir(server).c_str());
const char* serverName = fServers.GetServerAddress(server).c_str(); const char* serverName = fServers.GetServerAddress(server).c_str();
ILog("===== Server set to %s %s =====", serverName, external ? "external" : "internal"); ILog("===== Server set to %s %s =====", serverName, external ? "external" : "internal");
WritePrivateProfileString("PlasmaUpdate", "ServerAddress", serverName, fIniPath); WritePrivateProfileString("PlasmaUpdate", "ServerAddress", serverName, fIniPath);
WritePrivateProfileString("PlasmaUpdate", "External", external ? "1" : "0", fIniPath); WritePrivateProfileString("PlasmaUpdate", "External", external ? "1" : "0", fIniPath);
fFileGrabber->SetServer(serverName); fFileGrabber->SetServer(serverName);
} }
// //
// Get the latest publish notes // Get the latest publish notes
// //
{ {
HWND hList = GetDlgItem(fDlg, IDC_STATUS_LIST); HWND hList = GetDlgItem(fDlg, IDC_STATUS_LIST);
ListBox_ResetContent(hList); ListBox_ResetContent(hList);
char updateFile[MAX_PATH]; char updateFile[MAX_PATH];
if (external) if (external)
sprintf(updateFile, "%sUpdates-External.txt", serverRoot); sprintf(updateFile, "%sUpdates-External.txt", serverRoot);
else else
sprintf(updateFile, "%sUpdates-Internal.txt", serverRoot); sprintf(updateFile, "%sUpdates-Internal.txt", serverRoot);
hsRAMStream updates; hsRAMStream updates;
fFileGrabber->MakeProperPath(updateFile); fFileGrabber->MakeProperPath(updateFile);
if (fFileGrabber->FileToStream(updateFile, &updates)) if (fFileGrabber->FileToStream(updateFile, &updates))
{ {
while (updates.ReadLn(buf, sizeof(buf))) while (updates.ReadLn(buf, sizeof(buf)))
ListBox_InsertString(hList, 0, buf); ListBox_InsertString(hList, 0, buf);
} }
} }
// //
// Get the manifests // Get the manifests
// //
bool gotManifests = IGetManifests(serverRoot, external); bool gotManifests = IGetManifests(serverRoot, external);
UInt32 dlSize = 0; UInt32 dlSize = 0;
fProgressType = kValidating; fProgressType = kValidating;
if (gotManifests) if (gotManifests)
{ {
int i; int i;
UInt32 numFiles = 0; UInt32 numFiles = 0;
for (i = 0; i < fManifests.size(); i++) for (i = 0; i < fManifests.size(); i++)
numFiles += fManifests[i]->NumFiles(); numFiles += fManifests[i]->NumFiles();
HWND hProgress = GetDlgItem(fDlg, IDC_PROGRESS); HWND hProgress = GetDlgItem(fDlg, IDC_PROGRESS);
SendMessage(hProgress, PBM_SETRANGE32, 0, numFiles); SendMessage(hProgress, PBM_SETRANGE32, 0, numFiles);
for (i = 0; i < fManifests.size(); i++) for (i = 0; i < fManifests.size(); i++)
{ {
fManifests[i]->ValidateFiles(ProgressFunc); fManifests[i]->ValidateFiles(ProgressFunc);
dlSize += fManifests[i]->DownloadSize(); dlSize += fManifests[i]->DownloadSize();
} }
SendMessage(hProgress, PBM_SETPOS, 0, 0); SendMessage(hProgress, PBM_SETPOS, 0, 0);
} }
// Print how many megs there are to download // Print how many megs there are to download
if (dlSize == 0) if (dlSize == 0)
{ {
strcpy(buf, "No updates to download"); strcpy(buf, "No updates to download");
IDeleteManifests(); IDeleteManifests();
} }
else else
{ {
float dlMegs = float(dlSize) / (1024.f*1024.f); float dlMegs = float(dlSize) / (1024.f*1024.f);
if (dlMegs < .1) if (dlMegs < .1)
dlMegs = .1; dlMegs = .1;
sprintf(buf, "%.1f MB of updates to download", dlMegs); sprintf(buf, "%.1f MB of updates to download", dlMegs);
} }
SetDlgItemText(fDlg, IDC_DL_TEXT, buf); SetDlgItemText(fDlg, IDC_DL_TEXT, buf);
IEnableCtrls(true); IEnableCtrls(true);
if (fAutoDownload) if (fAutoDownload)
PostMessage(fDlg, WM_COMMAND, MAKEWPARAM(IDC_DL_BUTTON, BN_CLICKED), LPARAM(GetDlgItem(fDlg, IDC_DL_BUTTON))); PostMessage(fDlg, WM_COMMAND, MAKEWPARAM(IDC_DL_BUTTON, BN_CLICKED), LPARAM(GetDlgItem(fDlg, IDC_DL_BUTTON)));
} }
void plPlasmaUpdate::IDownloadUpdates() void plPlasmaUpdate::IDownloadUpdates()
{ {
fProgressType = kDownloading; fProgressType = kDownloading;
IEnableCtrls(false); IEnableCtrls(false);
int i; int i;
UInt32 dlSize = 0; UInt32 dlSize = 0;
for (i = 0; i < fManifests.size(); i++) for (i = 0; i < fManifests.size(); i++)
dlSize += fManifests[i]->DownloadSize(); dlSize += fManifests[i]->DownloadSize();
HWND hProgress = GetDlgItem(fDlg, IDC_PROGRESS); HWND hProgress = GetDlgItem(fDlg, IDC_PROGRESS);
SendMessage(hProgress, PBM_SETRANGE32, 0, dlSize); SendMessage(hProgress, PBM_SETRANGE32, 0, dlSize);
for (i = 0; i < fManifests.size(); i++) for (i = 0; i < fManifests.size(); i++)
fManifests[i]->DownloadUpdates(ProgressFunc, fFileGrabber); fManifests[i]->DownloadUpdates(ProgressFunc, fFileGrabber);
SendMessage(hProgress, PBM_SETPOS, 0, 0); SendMessage(hProgress, PBM_SETPOS, 0, 0);
EnableWindow(GetDlgItem(fDlg, IDC_DL_BUTTON), false); EnableWindow(GetDlgItem(fDlg, IDC_DL_BUTTON), false);
SetDlgItemText(fDlg, IDC_DL_TEXT, "No updates to download"); SetDlgItemText(fDlg, IDC_DL_TEXT, "No updates to download");
IDeleteManifests(); IDeleteManifests();
IEnableCtrls(true); IEnableCtrls(true);
if (fAutoDownload) if (fAutoDownload)
PostMessage(fDlg, WM_COMMAND, MAKEWPARAM(IDC_DL_BUTTON, BN_CLICKED), LPARAM(GetDlgItem(fDlg, IDC_DL_BUTTON))); PostMessage(fDlg, WM_COMMAND, MAKEWPARAM(IDC_DL_BUTTON, BN_CLICKED), LPARAM(GetDlgItem(fDlg, IDC_DL_BUTTON)));
} }
void plPlasmaUpdate::ProgressFunc(const char* name, int delta) void plPlasmaUpdate::ProgressFunc(const char* name, int delta)
{ {
static const char* lastName = nil; static const char* lastName = nil;
if (lastName != name) if (lastName != name)
{ {
lastName = name; lastName = name;
char buf[256]; char buf[256];
if (gInst->fProgressType == kValidating) if (gInst->fProgressType == kValidating)
strcpy(buf, "Checking "); strcpy(buf, "Checking ");
else else
strcpy(buf, "Downloading "); strcpy(buf, "Downloading ");
strcat(buf, name); strcat(buf, name);
SetDlgItemText(gInst->fDlg, IDC_DL_TEXT, buf); SetDlgItemText(gInst->fDlg, IDC_DL_TEXT, buf);
} }
SendDlgItemMessage(gInst->fDlg, IDC_PROGRESS, PBM_DELTAPOS, delta, 0); SendDlgItemMessage(gInst->fDlg, IDC_PROGRESS, PBM_DELTAPOS, delta, 0);
jvBaseDlg::PumpQueue(); jvBaseDlg::PumpQueue();
} }
void plPlasmaUpdate::ILog(const char* format, ...) void plPlasmaUpdate::ILog(const char* format, ...)
{ {
static plStatusLog* log = nil; static plStatusLog* log = nil;
if (!log) if (!log)
log = plStatusLogMgr::GetInstance().CreateStatusLog(0, "PlasmaUpdate.log"); log = plStatusLogMgr::GetInstance().CreateStatusLog(0, "PlasmaUpdate.log");
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log->AddLineV(format, args); log->AddLineV(format, args);
va_end(args); va_end(args);
} }
BOOL plPlasmaUpdate::IDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) BOOL plPlasmaUpdate::IDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{ {
switch (msg) switch (msg)
{ {
case WM_INITDIALOG: case WM_INITDIALOG:
IInit(); IInit();
SetFocus(GetDlgItem(fDlg, IDC_DL_BUTTON)); SetFocus(GetDlgItem(fDlg, IDC_DL_BUTTON));
return FALSE; return FALSE;
case WM_CLOSE: case WM_CLOSE:
if (fCanExit) if (fCanExit)
DestroyWindow(hDlg); DestroyWindow(hDlg);
return TRUE; return TRUE;
case WM_DESTROY: case WM_DESTROY:
IShutdown(); IShutdown();
PostQuitMessage(0); PostQuitMessage(0);
return TRUE; return TRUE;
case WM_COMMAND: case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_DL_BUTTON) if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_DL_BUTTON)
{ {
if (fManifests.empty()) if (fManifests.empty())
SendMessage(fDlg, WM_CLOSE, 0, 0); SendMessage(fDlg, WM_CLOSE, 0, 0);
else else
IDownloadUpdates(); IDownloadUpdates();
return TRUE; return TRUE;
} }
else if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_BUILD_COMBO) else if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_BUILD_COMBO)
{ {
IUpdateServer(); IUpdateServer();
return TRUE; return TRUE;
} }
break; break;
case WM_UPDATE_SERVER: case WM_UPDATE_SERVER:
IUpdateServer(); IUpdateServer();
return TRUE; return TRUE;
} }
return FALSE; return FALSE;
} }

54
Sources/Plasma/Apps/plPlasmaUpdate/plPlasmaUpdate.h
View File

@ -36,43 +36,43 @@ class jvDialogResizer;
class plPlasmaUpdate : public jvBaseDlg class plPlasmaUpdate : public jvBaseDlg
{ {
protected: protected:
static BOOL CALLBACK ILoginWinProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam); static BOOL CALLBACK ILoginWinProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam);
static std::string fUserName; static std::string fUserName;
static std::string fPassword; static std::string fPassword;
std::vector<plManifest*> fManifests; std::vector<plManifest*> fManifests;
char fIniPath[MAX_PATH]; char fIniPath[MAX_PATH];
bool fCanExit; bool fCanExit;
enum ProgressType { kValidating, kDownloading }; enum ProgressType { kValidating, kDownloading };
ProgressType fProgressType; ProgressType fProgressType;
jvDialogResizer* fResizer; jvDialogResizer* fResizer;
plPlasmaServers fServers; plPlasmaServers fServers;
bool fAutoDownload; bool fAutoDownload;
plFileGrabber* fFileGrabber; plFileGrabber* fFileGrabber;
void IInit(); void IInit();
void IShutdown(); void IShutdown();
bool IReadServerInfo(); bool IReadServerInfo();
void IEnableCtrls(bool enable); void IEnableCtrls(bool enable);
BOOL IDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam); BOOL IDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam);
static void ProgressFunc(const char* name, int delta); static void ProgressFunc(const char* name, int delta);
static void ILog(const char* format, ...); static void ILog(const char* format, ...);
void IUpdateServer(); void IUpdateServer();
void IDeleteManifests(); void IDeleteManifests();
bool IGetManifests(const char* serverRoot, bool external); bool IGetManifests(const char* serverRoot, bool external);
void IDownloadUpdates(); void IDownloadUpdates();
public: public:
plPlasmaUpdate(); plPlasmaUpdate();
virtual ~plPlasmaUpdate(); virtual ~plPlasmaUpdate();
bool Create(); bool Create();
void SetAutoDownload() { fAutoDownload = true; } void SetAutoDownload() { fAutoDownload = true; }
}; };

6
Sources/Plasma/Apps/plPythonPack/CMakeLists.txt
View File

@ -4,12 +4,12 @@ include_directories(../../PubUtilLib)
include_directories(${PYTHON_INCLUDE_DIR}) include_directories(${PYTHON_INCLUDE_DIR})
set(plPythonPack_SOURCES set(plPythonPack_SOURCES
main.cpp main.cpp
PythonInterface.cpp PythonInterface.cpp
) )
set(plPythonPack_HEADERS set(plPythonPack_HEADERS
PythonInterface.h PythonInterface.h
) )
add_executable(plPythonPack ${plPythonPack_SOURCES} ${plPythonPack_HEADERS}) add_executable(plPythonPack ${plPythonPack_SOURCES} ${plPythonPack_HEADERS})

306
Sources/Plasma/Apps/plPythonPack/PythonInterface.cpp
View File

@ -31,86 +31,86 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "marshal.h" #include "marshal.h"
#include "cStringIO.h" #include "cStringIO.h"
static PyObject* stdFile; // python object of the stdout and err file static PyObject* stdFile; // python object of the stdout and err file
void PythonInterface::initPython(std::string rootDir) void PythonInterface::initPython(std::string rootDir)
{ {
// if haven't been initialized then do it // if haven't been initialized then do it
if ( Py_IsInitialized() == 0 ) if ( Py_IsInitialized() == 0 )
{ {
// initialize the Python stuff // initialize the Python stuff
// let Python do some intialization... // let Python do some intialization...
Py_SetProgramName("plasma"); Py_SetProgramName("plasma");
Py_Initialize(); Py_Initialize();
// intialize any of our special plasma python modules // intialize any of our special plasma python modules
// initP2PInterface(); // initP2PInterface();
// save object to the Plasma module // save object to the Plasma module
// plasmaMod = PyImport_ImportModule("Plasma"); // plasmaMod = PyImport_ImportModule("Plasma");
// create the StringIO for the stdout and stderr file // create the StringIO for the stdout and stderr file
PycStringIO = (struct PycStringIO_CAPI*)PyCObject_Import("cStringIO", "cStringIO_CAPI"); PycStringIO = (struct PycStringIO_CAPI*)PyCObject_Import("cStringIO", "cStringIO_CAPI");
stdFile = (*PycStringIO->NewOutput)(20000); stdFile = (*PycStringIO->NewOutput)(20000);
// if we need the builtins then find the builtin module // if we need the builtins then find the builtin module
PyObject* sysmod = PyImport_ImportModule("sys"); PyObject* sysmod = PyImport_ImportModule("sys");
// then add the builtin dicitionary to our module's dictionary // then add the builtin dicitionary to our module's dictionary
if (sysmod != NULL ) if (sysmod != NULL )
{ {
// get the sys's dictionary to find the stdout and stderr // get the sys's dictionary to find the stdout and stderr
PyObject* sys_dict = PyModule_GetDict(sysmod); PyObject* sys_dict = PyModule_GetDict(sysmod);
if (stdFile != nil) if (stdFile != nil)
{ {
PyDict_SetItemString(sys_dict,"stdout", stdFile); PyDict_SetItemString(sys_dict,"stdout", stdFile);
PyDict_SetItemString(sys_dict,"stderr", stdFile); PyDict_SetItemString(sys_dict,"stderr", stdFile);
} }
// NOTE: we will reset the path to not include paths // NOTE: we will reset the path to not include paths
// ...that Python may have found in the registery // ...that Python may have found in the registery
PyObject* path_list = PyList_New(0); PyObject* path_list = PyList_New(0);
printf("Setting up include dirs:\n"); printf("Setting up include dirs:\n");
printf("%s\n",rootDir.c_str()); printf("%s\n",rootDir.c_str());
PyObject* more_path = PyString_FromString(rootDir.c_str()); PyObject* more_path = PyString_FromString(rootDir.c_str());
PyList_Append(path_list, more_path); PyList_Append(path_list, more_path);
// make sure that our plasma libraries are gotten before the system ones // make sure that our plasma libraries are gotten before the system ones
std::string temp = rootDir + "plasma"; std::string temp = rootDir + "plasma";
printf("%s\n",temp.c_str()); printf("%s\n",temp.c_str());
PyObject* more_path3 = PyString_FromString(temp.c_str()); PyObject* more_path3 = PyString_FromString(temp.c_str());
PyList_Append(path_list, more_path3); PyList_Append(path_list, more_path3);
temp = rootDir + "system"; temp = rootDir + "system";
printf("%s\n\n",temp.c_str()); printf("%s\n\n",temp.c_str());
PyObject* more_path2 = PyString_FromString("system"); PyObject* more_path2 = PyString_FromString("system");
PyList_Append(path_list, more_path2); PyList_Append(path_list, more_path2);
// set the path to be this one // set the path to be this one
PyDict_SetItemString(sys_dict,"path",path_list); PyDict_SetItemString(sys_dict,"path",path_list);
Py_DECREF(sysmod); Py_DECREF(sysmod);
} }
} }
// initialized++; // initialized++;
} }
void PythonInterface::addPythonPath(std::string path) void PythonInterface::addPythonPath(std::string path)
{ {
PyObject* sysmod = PyImport_ImportModule("sys"); PyObject* sysmod = PyImport_ImportModule("sys");
if (sysmod != NULL) if (sysmod != NULL)
{ {
PyObject* sys_dict = PyModule_GetDict(sysmod); PyObject* sys_dict = PyModule_GetDict(sysmod);
PyObject* path_list = PyDict_GetItemString(sys_dict, "path"); PyObject* path_list = PyDict_GetItemString(sys_dict, "path");
printf("Adding path %s\n", path.c_str()); printf("Adding path %s\n", path.c_str());
PyObject* more_path = PyString_FromString(path.c_str()); PyObject* more_path = PyString_FromString(path.c_str());
PyList_Append(path_list, more_path); PyList_Append(path_list, more_path);
Py_DECREF(sysmod); Py_DECREF(sysmod);
} }
} }
void PythonInterface::finiPython() void PythonInterface::finiPython()
{ {
if (Py_IsInitialized() != 0) if (Py_IsInitialized() != 0)
{ {
Py_Finalize(); Py_Finalize();
} }
} }
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
@ -123,8 +123,8 @@ void PythonInterface::finiPython()
// //
PyObject* PythonInterface::CompileString(char *command, char* filename) PyObject* PythonInterface::CompileString(char *command, char* filename)
{ {
PyObject* pycode = Py_CompileString(command, filename, Py_file_input); PyObject* pycode = Py_CompileString(command, filename, Py_file_input);
return pycode; return pycode;
} }
@ -137,27 +137,27 @@ PyObject* PythonInterface::CompileString(char *command, char* filename)
// //
hsBool PythonInterface::DumpObject(PyObject* pyobj, char** pickle, Int32* size) hsBool PythonInterface::DumpObject(PyObject* pyobj, char** pickle, Int32* size)
{ {
PyObject *s; // the python string object where the marsalled object wil go PyObject *s; // the python string object where the marsalled object wil go
// convert object to a marshalled string python object // convert object to a marshalled string python object
#if (PY_MAJOR_VERSION == 2) && (PY_MINOR_VERSION < 4) #if (PY_MAJOR_VERSION == 2) && (PY_MINOR_VERSION < 4)
s = PyMarshal_WriteObjectToString(pyobj); s = PyMarshal_WriteObjectToString(pyobj);
#else #else
s = PyMarshal_WriteObjectToString(pyobj, 0); s = PyMarshal_WriteObjectToString(pyobj, 0);
#endif #endif
// did it actually do it? // did it actually do it?
if ( s != NULL ) if ( s != NULL )
{ {
// yes, then get the size and the string address // yes, then get the size and the string address
*size = PyString_Size(s); *size = PyString_Size(s);
*pickle = PyString_AsString(s); *pickle = PyString_AsString(s);
return true; return true;
} }
else // otherwise, there was an error else // otherwise, there was an error
{ {
// Yikes! errors! // Yikes! errors!
PyErr_Print(); // FUTURE: we may have to get the string to display in max...later PyErr_Print(); // FUTURE: we may have to get the string to display in max...later
return false; return false;
} }
} }
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
@ -169,30 +169,30 @@ hsBool PythonInterface::DumpObject(PyObject* pyobj, char** pickle, Int32* size)
// //
int PythonInterface::getOutputAndReset(char** line) int PythonInterface::getOutputAndReset(char** line)
{ {
PyObject* pyStr = (*PycStringIO->cgetvalue)(stdFile); PyObject* pyStr = (*PycStringIO->cgetvalue)(stdFile);
char *str = PyString_AsString( pyStr ); char *str = PyString_AsString( pyStr );
int size = PyString_Size( pyStr ); int size = PyString_Size( pyStr );
// reset the file back to zero // reset the file back to zero
PyObject_CallMethod(stdFile,"reset",""); PyObject_CallMethod(stdFile,"reset","");
/* /*
// check to see if the debug python module is loaded // check to see if the debug python module is loaded
if ( dbgOut != nil ) if ( dbgOut != nil )
{ {
// then send it the new text // then send it the new text
if ( PyObject_CallFunction(dbgOut,"s",str) == nil ) if ( PyObject_CallFunction(dbgOut,"s",str) == nil )
{ {
// for some reason this function didn't, remember that and not call it again // for some reason this function didn't, remember that and not call it again
dbgOut = nil; dbgOut = nil;
// if there was an error make sure that the stderr gets flushed so it can be seen // if there was an error make sure that the stderr gets flushed so it can be seen
PyErr_Print(); // make sure the error is printed PyErr_Print(); // make sure the error is printed
PyErr_Clear(); // clear the error PyErr_Clear(); // clear the error
} }
} }
*/ */
if (line) if (line)
*line = str; *line = str;
return size; return size;
} }
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
@ -204,30 +204,30 @@ int PythonInterface::getOutputAndReset(char** line)
// //
PyObject* PythonInterface::CreateModule(char* module) PyObject* PythonInterface::CreateModule(char* module)
{ {
PyObject *m, *d; PyObject *m, *d;
// first we must get rid of any old modules of the same name, we'll replace it // first we must get rid of any old modules of the same name, we'll replace it
PyObject *modules = PyImport_GetModuleDict(); PyObject *modules = PyImport_GetModuleDict();
if ((m = PyDict_GetItemString(modules, module)) != NULL && PyModule_Check(m)) if ((m = PyDict_GetItemString(modules, module)) != NULL && PyModule_Check(m))
// clear it // clear it
_PyModule_Clear(m); _PyModule_Clear(m);
// create the module // create the module
m = PyImport_AddModule(module); m = PyImport_AddModule(module);
if (m == NULL) if (m == NULL)
return nil; return nil;
d = PyModule_GetDict(m); d = PyModule_GetDict(m);
// add in the built-ins // add in the built-ins
// first make sure that we don't already have the builtins // first make sure that we don't already have the builtins
if (PyDict_GetItemString(d, "__builtins__") == NULL) if (PyDict_GetItemString(d, "__builtins__") == NULL)
{ {
// if we need the builtins then find the builtin module // if we need the builtins then find the builtin module
PyObject *bimod = PyImport_ImportModule("__builtin__"); PyObject *bimod = PyImport_ImportModule("__builtin__");
// then add the builtin dicitionary to our module's dictionary // then add the builtin dicitionary to our module's dictionary
if (bimod == NULL || PyDict_SetItemString(d, "__builtins__", bimod) != 0) if (bimod == NULL || PyDict_SetItemString(d, "__builtins__", bimod) != 0)
return nil; return nil;
Py_DECREF(bimod); Py_DECREF(bimod);
} }
return m; return m;
} }
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
@ -240,30 +240,30 @@ PyObject* PythonInterface::CreateModule(char* module)
// //
hsBool PythonInterface::RunPYC(PyObject* code, PyObject* module) hsBool PythonInterface::RunPYC(PyObject* code, PyObject* module)
{ {
PyObject *d, *v; PyObject *d, *v;
// make sure that we're given a good module... or at least one with an address // make sure that we're given a good module... or at least one with an address
if ( !module ) if ( !module )
{ {
// if no module was given then use just use the main module // if no module was given then use just use the main module
module = PyImport_AddModule("__main__"); module = PyImport_AddModule("__main__");
if (module == NULL) if (module == NULL)
return false; return false;
} }
// get the dictionaries for this module // get the dictionaries for this module
d = PyModule_GetDict(module); d = PyModule_GetDict(module);
// run the string // run the string
v = PyEval_EvalCode((PyCodeObject*)code, d, d); v = PyEval_EvalCode((PyCodeObject*)code, d, d);
// check for errors and print them // check for errors and print them
if (v == NULL) if (v == NULL)
{ {
// Yikes! errors! // Yikes! errors!
PyErr_Print(); PyErr_Print();
return false; return false;
} }
Py_DECREF(v); Py_DECREF(v);
if (Py_FlushLine()) if (Py_FlushLine())
PyErr_Clear(); PyErr_Clear();
return true; return true;
} }
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
@ -275,11 +275,11 @@ hsBool PythonInterface::RunPYC(PyObject* code, PyObject* module)
// //
PyObject* PythonInterface::GetModuleItem(char* item, PyObject* module) PyObject* PythonInterface::GetModuleItem(char* item, PyObject* module)
{ {
if ( module ) if ( module )
{ {
PyObject* d = PyModule_GetDict(module); PyObject* d = PyModule_GetDict(module);
return PyDict_GetItemString(d, item); return PyDict_GetItemString(d, item);
} }
return nil; return nil;
} }

20
Sources/Plasma/Apps/plPythonPack/PythonInterface.h
View File

@ -29,15 +29,15 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
namespace PythonInterface namespace PythonInterface
{ {
void initPython(std::string rootDir); void initPython(std::string rootDir);
void finiPython(); void finiPython();
// So the Python packer can add extra paths // So the Python packer can add extra paths
void addPythonPath(std::string dir); void addPythonPath(std::string dir);
PyObject* CompileString(char *command, char* filename); PyObject* CompileString(char *command, char* filename);
hsBool DumpObject(PyObject* pyobj, char** pickle, Int32* size); hsBool DumpObject(PyObject* pyobj, char** pickle, Int32* size);
int getOutputAndReset(char** line=nil); int getOutputAndReset(char** line=nil);
PyObject* CreateModule(char* module); PyObject* CreateModule(char* module);
hsBool RunPYC(PyObject* code, PyObject* module); hsBool RunPYC(PyObject* code, PyObject* module);
PyObject* GetModuleItem(char* item, PyObject* module); PyObject* GetModuleItem(char* item, PyObject* module);
} }

666
Sources/Plasma/Apps/plPythonPack/main.cpp
View File

@ -39,413 +39,413 @@ static char* glueFile = (char*)kGlueFile;
void WritePythonFile(const char *fileName, const char* path, hsStream *s) void WritePythonFile(const char *fileName, const char* path, hsStream *s)
{ {
hsUNIXStream pyStream, glueStream; hsUNIXStream pyStream, glueStream;
char* pathAndFile = new char[strlen(fileName)+strlen(path)+2]; char* pathAndFile = new char[strlen(fileName)+strlen(path)+2];
strcpy(pathAndFile,path); strcpy(pathAndFile,path);
char lastchar = pathAndFile[strlen(pathAndFile)-1]; char lastchar = pathAndFile[strlen(pathAndFile)-1];
if (lastchar != '\\' && lastchar != '/') if (lastchar != '\\' && lastchar != '/')
strcat(pathAndFile, "\\"); strcat(pathAndFile, "\\");
strcat(pathAndFile,fileName); strcat(pathAndFile,fileName);
if (!pyStream.Open(pathAndFile) || !glueStream.Open(glueFile)) if (!pyStream.Open(pathAndFile) || !glueStream.Open(glueFile))
{ {
printf("Unable to open path %s, ",pathAndFile); printf("Unable to open path %s, ",pathAndFile);
return; return;
} }
printf("==Packing %s, ",fileName); printf("==Packing %s, ",fileName);
pyStream.FastFwd(); pyStream.FastFwd();
UInt32 pyFileSize = pyStream.GetPosition(); UInt32 pyFileSize = pyStream.GetPosition();
pyStream.Rewind(); pyStream.Rewind();
glueStream.FastFwd(); glueStream.FastFwd();
UInt32 glueFileSize = glueStream.GetPosition(); UInt32 glueFileSize = glueStream.GetPosition();
glueStream.Rewind(); glueStream.Rewind();
UInt32 totalSize = pyFileSize + glueFileSize + 2; UInt32 totalSize = pyFileSize + glueFileSize + 2;
char *code = new char[totalSize]; char *code = new char[totalSize];
UInt32 amountRead = pyStream.Read(pyFileSize, code); UInt32 amountRead = pyStream.Read(pyFileSize, code);
hsAssert(amountRead == pyFileSize, "Bad read"); hsAssert(amountRead == pyFileSize, "Bad read");
code[pyFileSize] = '\n'; code[pyFileSize] = '\n';
amountRead = glueStream.Read(glueFileSize, code+pyFileSize+1); amountRead = glueStream.Read(glueFileSize, code+pyFileSize+1);
hsAssert(amountRead == glueFileSize, "Bad read"); hsAssert(amountRead == glueFileSize, "Bad read");
code[totalSize-1] = '\0'; code[totalSize-1] = '\0';
// remove the CRs, they seem to give Python heartburn // remove the CRs, they seem to give Python heartburn
int k = 0; int k = 0;
for (int i = 0; i < totalSize; i++) for (int i = 0; i < totalSize; i++)
{ {
if (code[i] != '\r') // is it not a CR? if (code[i] != '\r') // is it not a CR?
code[k++] = code[i]; code[k++] = code[i];
// else // else
// skip the CRs // skip the CRs
} }
PyObject* pythonCode = PythonInterface::CompileString(code, (char*)fileName); PyObject* pythonCode = PythonInterface::CompileString(code, (char*)fileName);
if (pythonCode) if (pythonCode)
{ {
// we need to find out if this is PythonFile module // we need to find out if this is PythonFile module
// create a module name... with the '.' as an X // create a module name... with the '.' as an X
// and create a python file name that is without the ".py" // and create a python file name that is without the ".py"
char* modulename = new char[strlen(fileName)+1]; char* modulename = new char[strlen(fileName)+1];
char* pythonfilename = new char[strlen(fileName)+1]; char* pythonfilename = new char[strlen(fileName)+1];
int j; int j;
for (j=0; j<strlen(fileName); j++) for (j=0; j<strlen(fileName); j++)
{ {
if (fileName[j] == '.') if (fileName[j] == '.')
{ {
modulename[j] = 'X'; modulename[j] = 'X';
pythonfilename[j] = '\0'; pythonfilename[j] = '\0';
} }
else else
{ {
modulename[j] = fileName[j]; modulename[j] = fileName[j];
pythonfilename[j] = fileName[j]; pythonfilename[j] = fileName[j];
} }
} }
modulename[j] = '\0'; modulename[j] = '\0';
PyObject* fModule = PythonInterface::CreateModule(modulename); PyObject* fModule = PythonInterface::CreateModule(modulename);
delete [] modulename; delete [] modulename;
// run the code // run the code
if (PythonInterface::RunPYC(pythonCode, fModule) ) if (PythonInterface::RunPYC(pythonCode, fModule) )
{ {
// set the name of the file (in the global dictionary of the module) // set the name of the file (in the global dictionary of the module)
PyObject* dict = PyModule_GetDict(fModule); PyObject* dict = PyModule_GetDict(fModule);
PyObject* pfilename = PyString_FromString(pythonfilename); PyObject* pfilename = PyString_FromString(pythonfilename);
PyDict_SetItemString(dict, "glue_name", pfilename); PyDict_SetItemString(dict, "glue_name", pfilename);
// next we need to: // next we need to:
// - create instance of class // - create instance of class
PyObject* getID = PythonInterface::GetModuleItem("glue_getBlockID",fModule); PyObject* getID = PythonInterface::GetModuleItem("glue_getBlockID",fModule);
hsBool foundID = false; hsBool foundID = false;
if ( getID!=nil && PyCallable_Check(getID) ) if ( getID!=nil && PyCallable_Check(getID) )
{ {
PyObject* id = PyObject_CallFunction(getID,nil); PyObject* id = PyObject_CallFunction(getID,nil);
if ( id && PyInt_Check(id) ) if ( id && PyInt_Check(id) )
foundID = true; foundID = true;
} }
if ( foundID == false ) // then there was an error or no ID or somethin' if ( foundID == false ) // then there was an error or no ID or somethin'
{ {
// oops, this is not a PythonFile modifier // oops, this is not a PythonFile modifier
// re-read the source and compile it without the glue code this time // re-read the source and compile it without the glue code this time
memset(code,0,totalSize); memset(code,0,totalSize);
pyStream.Rewind(); pyStream.Rewind();
amountRead = pyStream.Read(pyFileSize, code); amountRead = pyStream.Read(pyFileSize, code);
hsAssert(amountRead == pyFileSize, "Bad read"); hsAssert(amountRead == pyFileSize, "Bad read");
strcat(code,"\n"); strcat(code,"\n");
k = 0; k = 0;
for (int i = 0; i < strlen(code)+1; i++) for (int i = 0; i < strlen(code)+1; i++)
{ {
if (code[i] != '\r') // is it not a CR? if (code[i] != '\r') // is it not a CR?
code[k++] = code[i]; code[k++] = code[i];
// else // else
// skip the CRs // skip the CRs
} }
pythonCode = PythonInterface::CompileString(code, (char*)fileName); pythonCode = PythonInterface::CompileString(code, (char*)fileName);
hsAssert(pythonCode,"Not sure why this didn't compile the second time???"); hsAssert(pythonCode,"Not sure why this didn't compile the second time???");
printf("an import file "); printf("an import file ");
} }
else else
printf("a PythonFile modifier(tm) "); printf("a PythonFile modifier(tm) ");
} }
else else
{ {
printf("......blast! Error during run-code!\n"); printf("......blast! Error during run-code!\n");
s->WriteSwap32(0); s->WriteSwap32(0);
char* errmsg; char* errmsg;
int chars_read = PythonInterface::getOutputAndReset(&errmsg); int chars_read = PythonInterface::getOutputAndReset(&errmsg);
if (chars_read > 0) if (chars_read > 0)
{ {
printf(errmsg); printf(errmsg);
printf("\n"); printf("\n");
} }
} }
delete [] pythonfilename; delete [] pythonfilename;
} }
// make sure that we have code to save // make sure that we have code to save
if (pythonCode) if (pythonCode)
{ {
Int32 size; Int32 size;
char* pycode; char* pycode;
PythonInterface::DumpObject(pythonCode,&pycode,&size); PythonInterface::DumpObject(pythonCode,&pycode,&size);
printf("\n"); printf("\n");
// print any message after each module // print any message after each module
char* errmsg; char* errmsg;
int chars_read = PythonInterface::getOutputAndReset(&errmsg); int chars_read = PythonInterface::getOutputAndReset(&errmsg);
if (chars_read > 0) if (chars_read > 0)
{ {
printf(errmsg); printf(errmsg);
printf("\n"); printf("\n");
} }
s->WriteSwap32(size); s->WriteSwap32(size);
s->Write(size, pycode); s->Write(size, pycode);
} }
else else
{ {
printf("......blast! Compile error!\n"); printf("......blast! Compile error!\n");
s->WriteSwap32(0); s->WriteSwap32(0);
PyErr_Print(); PyErr_Print();
PyErr_Clear(); PyErr_Clear();
char* errmsg; char* errmsg;
int chars_read = PythonInterface::getOutputAndReset(&errmsg); int chars_read = PythonInterface::getOutputAndReset(&errmsg);
if (chars_read > 0) if (chars_read > 0)
{ {
printf(errmsg); printf(errmsg);
printf("\n"); printf("\n");
} }
} }
delete [] code; delete [] code;
delete [] pathAndFile; // all done with the path and filename as one delete [] pathAndFile; // all done with the path and filename as one
pyStream.Close(); pyStream.Close();
glueStream.Close(); glueStream.Close();
} }
void FindFiles(std::vector<std::string> &filenames, std::vector<std::string> &pathnames, const char* path) void FindFiles(std::vector<std::string> &filenames, std::vector<std::string> &pathnames, const char* path)
{ {
// Get the names of all the python files // Get the names of all the python files
hsFolderIterator folder; hsFolderIterator folder;
// if there is a path... set it // if there is a path... set it
if ( path ) if ( path )
folder.SetPath(path); folder.SetPath(path);
while (folder.NextFileSuffix(".py")) while (folder.NextFileSuffix(".py"))
{ {
const char *fileName = folder.GetFileName(); const char *fileName = folder.GetFileName();
filenames.push_back(fileName); filenames.push_back(fileName);
if ( path ) if ( path )
pathnames.push_back(path); pathnames.push_back(path);
else else
pathnames.push_back(""); pathnames.push_back("");
} }
} }
std::string ToLowerCase(std::string str) std::string ToLowerCase(std::string str)
{ {
std::string retVal = ""; std::string retVal = "";
for (int i=0; i<str.length(); i++) for (int i=0; i<str.length(); i++)
{ {
if ((str[i]>='A')&&(str[i]<='Z')) if ((str[i]>='A')&&(str[i]<='Z'))
retVal += (char)tolower(str[i]); retVal += (char)tolower(str[i]);
else else
retVal += str[i]; retVal += str[i];
} }
return retVal; return retVal;
} }
void FindSubDirs(std::vector<std::string> &dirnames, std::vector<std::string> &pakNames, char *path) void FindSubDirs(std::vector<std::string> &dirnames, std::vector<std::string> &pakNames, char *path)
{ {
hsFolderIterator folder; hsFolderIterator folder;
if (path) if (path)
folder.SetPath(path); folder.SetPath(path);
while (folder.NextFile()) while (folder.NextFile())
{ {
if (folder.IsDirectory()) if (folder.IsDirectory())
{ {
std::string dirName = folder.GetFileName(); std::string dirName = folder.GetFileName();
if ((dirName != ".")&&(dirName != "..")&&(ToLowerCase(dirName) != "system") && (ToLowerCase(dirName) != "plasma")) if ((dirName != ".")&&(dirName != "..")&&(ToLowerCase(dirName) != "system") && (ToLowerCase(dirName) != "plasma"))
{ {
dirnames.push_back(dirName); dirnames.push_back(dirName);
pakNames.push_back(dirName+".pak"); pakNames.push_back(dirName+".pak");
} }
} }
} }
} }
// adds or removes the ending slash in a path as necessary // adds or removes the ending slash in a path as necessary
std::string AdjustEndingSlash(std::string path, bool endingSlash = false) std::string AdjustEndingSlash(std::string path, bool endingSlash = false)
{ {
std::string retVal = path; std::string retVal = path;
bool endSlashExists = false; bool endSlashExists = false;
char temp = path[path.length()-1]; char temp = path[path.length()-1];
if (temp == '\\') if (temp == '\\')
endSlashExists = true; endSlashExists = true;
if (endingSlash) if (endingSlash)
{ {
if (!endSlashExists) if (!endSlashExists)
retVal += "\\"; retVal += "\\";
} }
else else
{ {
if (endSlashExists) if (endSlashExists)
{ {
std::string temp = ""; std::string temp = "";
for (int i=0; i<retVal.length()-1; i++) for (int i=0; i<retVal.length()-1; i++)
temp += retVal[i]; temp += retVal[i];
retVal = temp; retVal = temp;
} }
} }
return retVal; return retVal;
} }
// appends partialPath onto the end of fullPath, inserting or removing slashes as necesssary // appends partialPath onto the end of fullPath, inserting or removing slashes as necesssary
std::string ConcatDirs(std::string fullPath, std::string partialPath) std::string ConcatDirs(std::string fullPath, std::string partialPath)
{ {
bool fullSlash = false, partialSlash = false; bool fullSlash = false, partialSlash = false;
char temp = fullPath[fullPath.length()-1]; char temp = fullPath[fullPath.length()-1];
if (temp == '\\') if (temp == '\\')
fullSlash = true; fullSlash = true;
temp = partialPath[0]; temp = partialPath[0];
if (temp == '\\') if (temp == '\\')
partialSlash = true; partialSlash = true;
std::string retVal = ""; std::string retVal = "";
if (!fullSlash) if (!fullSlash)
retVal = fullPath + "\\"; retVal = fullPath + "\\";
if (partialSlash) if (partialSlash)
{ {
std::string temp = ""; std::string temp = "";
for (int i=1; i<partialPath.length(); i++) for (int i=1; i<partialPath.length(); i++)
temp += partialPath[i]; temp += partialPath[i];
partialPath = temp; partialPath = temp;
} }
retVal += partialPath; retVal += partialPath;
return retVal; return retVal;
} }
void PackDirectory(std::string dir, std::string rootPath, std::string pakName, std::vector<std::string>& extraDirs, bool packSysAndPlasma = false) void PackDirectory(std::string dir, std::string rootPath, std::string pakName, std::vector<std::string>& extraDirs, bool packSysAndPlasma = false)
{ {
// make sure the dir ends in a slash // make sure the dir ends in a slash
dir = AdjustEndingSlash(dir,true); dir = AdjustEndingSlash(dir,true);
printf("\nCreating %s using the contents of %s\n",pakName.c_str(),dir.c_str()); printf("\nCreating %s using the contents of %s\n",pakName.c_str(),dir.c_str());
printf("Changing working directory to %s\n",rootPath.c_str()); printf("Changing working directory to %s\n",rootPath.c_str());
if (_chdir(rootPath.c_str())) if (_chdir(rootPath.c_str()))
{ {
printf("ERROR: Directory change to %s failed for some reason\n",rootPath.c_str()); printf("ERROR: Directory change to %s failed for some reason\n",rootPath.c_str());
printf("Unable to continue with the packing of this directory, aborting...\n"); printf("Unable to continue with the packing of this directory, aborting...\n");
return; return;
} }
else else
printf("Directory changed to %s\n",rootPath.c_str()); printf("Directory changed to %s\n",rootPath.c_str());
std::vector<std::string> fileNames; std::vector<std::string> fileNames;
std::vector<std::string> pathNames; std::vector<std::string> pathNames;
FindFiles(fileNames,pathNames,dir.c_str()); FindFiles(fileNames,pathNames,dir.c_str());
if (packSysAndPlasma) if (packSysAndPlasma)
{ {
printf("Adding the system and plasma directories to this pack file\n"); printf("Adding the system and plasma directories to this pack file\n");
std::string tempPath; std::string tempPath;
tempPath = dir + "system"; tempPath = dir + "system";
FindFiles(fileNames,pathNames,tempPath.c_str()); FindFiles(fileNames,pathNames,tempPath.c_str());
tempPath = dir + "plasma"; tempPath = dir + "plasma";
FindFiles(fileNames,pathNames,tempPath.c_str()); FindFiles(fileNames,pathNames,tempPath.c_str());
} }
// ok, we know how many files we're gonna pack, so make a fake index (we'll fill in later) // ok, we know how many files we're gonna pack, so make a fake index (we'll fill in later)
hsUNIXStream s; hsUNIXStream s;
if (!s.Open(pakName.c_str(), "wb")) if (!s.Open(pakName.c_str(), "wb"))
return; return;
s.WriteSwap32(fileNames.size()); s.WriteSwap32(fileNames.size());
int i; int i;
for (i = 0; i < fileNames.size(); i++) for (i = 0; i < fileNames.size(); i++)
{ {
s.WriteSafeString(fileNames[i].c_str()); s.WriteSafeString(fileNames[i].c_str());
s.WriteSwap32(0); s.WriteSwap32(0);
} }
PythonInterface::initPython(rootPath); PythonInterface::initPython(rootPath);
for (i = 0; i < extraDirs.size(); i++) for (i = 0; i < extraDirs.size(); i++)
PythonInterface::addPythonPath(rootPath + extraDirs[i]); PythonInterface::addPythonPath(rootPath + extraDirs[i]);
// set to maximum optimization (includes removing __doc__ strings) // set to maximum optimization (includes removing __doc__ strings)
Py_OptimizeFlag = 2; Py_OptimizeFlag = 2;
std::vector<UInt32> filePositions; std::vector<UInt32> filePositions;
filePositions.resize(fileNames.size()); filePositions.resize(fileNames.size());
for (i = 0; i < fileNames.size(); i++) for (i = 0; i < fileNames.size(); i++)
{ {
UInt32 initialPos = s.GetPosition(); UInt32 initialPos = s.GetPosition();
WritePythonFile(fileNames[i].c_str(), pathNames[i].c_str(), &s); WritePythonFile(fileNames[i].c_str(), pathNames[i].c_str(), &s);
UInt32 endPos = s.GetPosition(); UInt32 endPos = s.GetPosition();
filePositions[i] = initialPos; filePositions[i] = initialPos;
} }
s.SetPosition(sizeof(UInt32)); s.SetPosition(sizeof(UInt32));
for (i = 0; i < fileNames.size(); i++) for (i = 0; i < fileNames.size(); i++)
{ {
s.WriteSafeString(fileNames[i].c_str()); s.WriteSafeString(fileNames[i].c_str());
s.WriteSwap32(filePositions[i]); s.WriteSwap32(filePositions[i]);
} }
s.Close(); s.Close();
PythonInterface::finiPython(); PythonInterface::finiPython();
} }
void PrintUsage() void PrintUsage()
{ {
printf("Usage:\n"); printf("Usage:\n");
printf("plPythonPack [directory to pack...]\n"); printf("plPythonPack [directory to pack...]\n");
printf("NOTE: the directory to pack must have full system and plasma dirs and\n"); printf("NOTE: the directory to pack must have full system and plasma dirs and\n");
printf(" must be a relative path to the current working directory\n"); printf(" must be a relative path to the current working directory\n");
} }
void main(int argc, char *argv[]) void main(int argc, char *argv[])
{ {
printf("The Python Pack Utility\n"); printf("The Python Pack Utility\n");
char buffer[_MAX_PATH]; char buffer[_MAX_PATH];
_getcwd(buffer,_MAX_PATH); _getcwd(buffer,_MAX_PATH);
std::string baseWorkingDir = buffer; std::string baseWorkingDir = buffer;
// are they asking for usage? // are they asking for usage?
if (argc == 2) if (argc == 2)
{ {
std::string temp = argv[1]; std::string temp = argv[1];
temp = ToLowerCase(temp); temp = ToLowerCase(temp);
if ((temp == "?") || (temp == "-?") || (temp == "/?") || (temp == "-help") || (temp == "/help") if ((temp == "?") || (temp == "-?") || (temp == "/?") || (temp == "-help") || (temp == "/help")
|| (temp == "-h") || (temp == "/h")) || (temp == "-h") || (temp == "/h"))
{ {
PrintUsage(); PrintUsage();
return; return;
} }
} }
// wrong number of args, print usage // wrong number of args, print usage
if (argc > 2) if (argc > 2)
{ {
PrintUsage(); PrintUsage();
return; return;
} }
std::vector<std::string> dirNames; std::vector<std::string> dirNames;
std::vector<std::string> pakNames; std::vector<std::string> pakNames;
std::string rootPath; std::string rootPath;
if (argc == 1) if (argc == 1)
{ {
FindSubDirs(dirNames,pakNames,nil); FindSubDirs(dirNames,pakNames,nil);
rootPath = AdjustEndingSlash(baseWorkingDir,true); rootPath = AdjustEndingSlash(baseWorkingDir,true);
} }
else else
{ {
std::string path = argv[1]; std::string path = argv[1];
FindSubDirs(dirNames,pakNames,argv[1]); FindSubDirs(dirNames,pakNames,argv[1]);
rootPath = ConcatDirs(baseWorkingDir,path); rootPath = ConcatDirs(baseWorkingDir,path);
rootPath = AdjustEndingSlash(rootPath,true); rootPath = AdjustEndingSlash(rootPath,true);
} }
PackDirectory(rootPath,rootPath,rootPath+kPackFileName,dirNames,true); PackDirectory(rootPath,rootPath,rootPath+kPackFileName,dirNames,true);
for (int i=0; i<dirNames.size(); i++) for (int i=0; i<dirNames.size(); i++)
{ {
PackDirectory(dirNames[i],rootPath,rootPath+pakNames[i],dirNames); PackDirectory(dirNames[i],rootPath,rootPath+pakNames[i],dirNames);
} }
} }

18
Sources/Plasma/Apps/plUruLauncher/CMakeLists.txt
View File

@ -7,22 +7,22 @@ include_directories("../../PubUtilLib")
include_directories(${OPENSSL_INCLUDE_DIR}) include_directories(${OPENSSL_INCLUDE_DIR})
set(plUruLauncher_HEADERS set(plUruLauncher_HEADERS
Intern.h Intern.h
Pch.h Pch.h
plLauncherInfo.h plLauncherInfo.h
) )
set(plUruLauncher_SOURCES set(plUruLauncher_SOURCES
Main.cpp Main.cpp
SelfPatcher.cpp SelfPatcher.cpp
) )
set(plUruLauncher_RESOURCES set(plUruLauncher_RESOURCES
plUruLauncher.rc plUruLauncher.rc
resource.h resource.h
banner.bmp banner.bmp
Dirt.ICO Dirt.ICO
) )
add_executable(plUruLauncher WIN32 ${plUruLauncher_SOURCES} ${plUruLauncher_HEADERS} add_executable(plUruLauncher WIN32 ${plUruLauncher_SOURCES} ${plUruLauncher_HEADERS}

BIN
Sources/Plasma/Apps/plUruLauncher/Dirt.ICO
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.2 KiB

After

Width:  |  Height:  |  Size: 2.2 KiB

1260
Sources/Plasma/Apps/plUruLauncher/Main.cpp
View File

File diff suppressed because it is too large Load Diff

334
Sources/Plasma/Apps/plUruLauncher/SelfPatcher.cpp
View File

@ -40,27 +40,27 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
***/ ***/
#ifndef PLASMA_EXTERNAL_RELEASE #ifndef PLASMA_EXTERNAL_RELEASE
static const wchar s_manifest[] = L"InternalPatcher"; static const wchar s_manifest[] = L"InternalPatcher";
#else #else
static const wchar s_manifest[] = L"ExternalPatcher"; static const wchar s_manifest[] = L"ExternalPatcher";
#endif #endif
class SelfPatcherStream : public plZlibStream { class SelfPatcherStream : public plZlibStream {
public: public:
virtual UInt32 Write(UInt32 byteCount, const void* buffer); virtual UInt32 Write(UInt32 byteCount, const void* buffer);
static plLauncherInfo *info; static plLauncherInfo *info;
static unsigned totalBytes; static unsigned totalBytes;
static unsigned progress; static unsigned progress;
}; };
unsigned SelfPatcherStream::totalBytes = 0; unsigned SelfPatcherStream::totalBytes = 0;
unsigned SelfPatcherStream::progress = 0; unsigned SelfPatcherStream::progress = 0;
static bool s_downloadComplete; static bool s_downloadComplete;
static long s_numFiles; static long s_numFiles;
static ENetError s_patchResult; static ENetError s_patchResult;
static bool s_updated; static bool s_updated;
static wchar s_newPatcherFile[MAX_PATH]; static wchar s_newPatcherFile[MAX_PATH];
/***************************************************************************** /*****************************************************************************
@ -71,202 +71,202 @@ static wchar s_newPatcherFile[MAX_PATH];
//============================================================================ //============================================================================
static void NetErrorHandler (ENetProtocol protocol, ENetError error) { static void NetErrorHandler (ENetProtocol protocol, ENetError error) {
LogMsg(kLogError, L"NetErr: %s", NetErrorToString(error)); LogMsg(kLogError, L"NetErr: %s", NetErrorToString(error));
if (IS_NET_SUCCESS(s_patchResult)) if (IS_NET_SUCCESS(s_patchResult))
s_patchResult = error; s_patchResult = error;
s_downloadComplete = true; s_downloadComplete = true;
switch(error) { switch(error) {
case kNetErrServerBusy: case kNetErrServerBusy:
MessageBox(0, "Due to the high demand, the server is currently busy. Please try again later, or for alternative download options visit: http://www.mystonline.com/play/", "UruLauncher", MB_OK); MessageBox(0, "Due to the high demand, the server is currently busy. Please try again later, or for alternative download options visit: http://www.mystonline.com/play/", "UruLauncher", MB_OK);
s_patchResult = kNetErrServerBusy; s_patchResult = kNetErrServerBusy;
s_downloadComplete = true; s_downloadComplete = true;
break; break;
} }
} }
//============================================================================ //============================================================================
static void DownloadCallback ( static void DownloadCallback (
ENetError result, ENetError result,
void * param, void * param,
const wchar filename[], const wchar filename[],
hsStream * writer hsStream * writer
) { ) {
if(IS_NET_ERROR(result)) { if(IS_NET_ERROR(result)) {
switch (result) { switch (result) {
case kNetErrTimeout: case kNetErrTimeout:
writer->Rewind(); writer->Rewind();
NetCliFileDownloadRequest(filename, writer, DownloadCallback, param); NetCliFileDownloadRequest(filename, writer, DownloadCallback, param);
break; break;
default: default:
LogMsg(kLogError, L"Error getting patcher file: %s", NetErrorToString(result)); LogMsg(kLogError, L"Error getting patcher file: %s", NetErrorToString(result));
if (IS_NET_SUCCESS(s_patchResult)) if (IS_NET_SUCCESS(s_patchResult))
s_patchResult = result; s_patchResult = result;
break; break;
} }
return; return;
} }
writer->Close(); writer->Close();
delete writer; delete writer;
AtomicAdd(&s_numFiles, -1); AtomicAdd(&s_numFiles, -1);
if(!s_numFiles) { if(!s_numFiles) {
s_downloadComplete = true; s_downloadComplete = true;
s_updated = true; s_updated = true;
} }
} }
//============================================================================ //============================================================================
static bool MD5Check (const char filename[], const wchar md5[]) { static bool MD5Check (const char filename[], const wchar md5[]) {
// Do md5 check // Do md5 check
char md5copy[MAX_PATH]; char md5copy[MAX_PATH];
plMD5Checksum existingMD5(filename); plMD5Checksum existingMD5(filename);
plMD5Checksum latestMD5; plMD5Checksum latestMD5;
StrToAnsi(md5copy, md5, arrsize(md5copy)); StrToAnsi(md5copy, md5, arrsize(md5copy));
latestMD5.SetFromHexString(md5copy); latestMD5.SetFromHexString(md5copy);
return (existingMD5 == latestMD5); return (existingMD5 == latestMD5);
} }
//============================================================================ //============================================================================
static void ManifestCallback ( static void ManifestCallback (
ENetError result, ENetError result,
void * param, void * param,
const wchar group[], const wchar group[],
const NetCliFileManifestEntry manifest[], const NetCliFileManifestEntry manifest[],
unsigned entryCount unsigned entryCount
) { ) {
if(IS_NET_ERROR(result)) { if(IS_NET_ERROR(result)) {
switch (result) { switch (result) {
case kNetErrTimeout: case kNetErrTimeout:
NetCliFileManifestRequest(ManifestCallback, nil, s_manifest); NetCliFileManifestRequest(ManifestCallback, nil, s_manifest);
break; break;
default: default:
LogMsg(kLogError, L"Error getting patcher manifest: %s", NetErrorToString(result)); LogMsg(kLogError, L"Error getting patcher manifest: %s", NetErrorToString(result));
if (IS_NET_SUCCESS(s_patchResult)) if (IS_NET_SUCCESS(s_patchResult))
s_patchResult = result; s_patchResult = result;
break; break;
} }
return; return;
} }
char ansi[MAX_PATH]; char ansi[MAX_PATH];
// MD5 check current patcher against value in manifest // MD5 check current patcher against value in manifest
ASSERT(entryCount == 1); ASSERT(entryCount == 1);
wchar curPatcherFile[MAX_PATH]; wchar curPatcherFile[MAX_PATH];
PathGetProgramName(curPatcherFile, arrsize(curPatcherFile)); PathGetProgramName(curPatcherFile, arrsize(curPatcherFile));
StrToAnsi(ansi, curPatcherFile, arrsize(ansi)); StrToAnsi(ansi, curPatcherFile, arrsize(ansi));
if (!MD5Check(ansi, manifest[0].md5)) { if (!MD5Check(ansi, manifest[0].md5)) {
// MessageBox(GetTopWindow(nil), "MD5 failed", "Msg", MB_OK); // MessageBox(GetTopWindow(nil), "MD5 failed", "Msg", MB_OK);
SelfPatcherStream::totalBytes += manifest[0].zipSize; SelfPatcherStream::totalBytes += manifest[0].zipSize;
AtomicAdd(&s_numFiles, 1); AtomicAdd(&s_numFiles, 1);
SetText("Downloading new patcher..."); SetText("Downloading new patcher...");
StrToAnsi(ansi, s_newPatcherFile, arrsize(ansi)); StrToAnsi(ansi, s_newPatcherFile, arrsize(ansi));
SelfPatcherStream * stream = NEWZERO(SelfPatcherStream); SelfPatcherStream * stream = NEWZERO(SelfPatcherStream);
if (!stream->Open(ansi, "wb")) if (!stream->Open(ansi, "wb"))
ErrorFatal(__LINE__, __FILE__, "Failed to create file: %s, errno: %u", ansi, errno); ErrorFatal(__LINE__, __FILE__, "Failed to create file: %s, errno: %u", ansi, errno);
NetCliFileDownloadRequest(manifest[0].downloadName, stream, DownloadCallback, nil); NetCliFileDownloadRequest(manifest[0].downloadName, stream, DownloadCallback, nil);
} }
else { else {
s_downloadComplete = true; s_downloadComplete = true;
} }
} }
//============================================================================ //============================================================================
static void FileSrvIpAddressCallback ( static void FileSrvIpAddressCallback (
ENetError result, ENetError result,
void * param, void * param,
const wchar addr[] const wchar addr[]
) { ) {
NetCliGateKeeperDisconnect(); NetCliGateKeeperDisconnect();
if (IS_NET_ERROR(result)) { if (IS_NET_ERROR(result)) {
LogMsg(kLogDebug, L"FileSrvIpAddressRequest failed: %s", NetErrorToString(result)); LogMsg(kLogDebug, L"FileSrvIpAddressRequest failed: %s", NetErrorToString(result));
s_patchResult = result; s_patchResult = result;
s_downloadComplete = true; s_downloadComplete = true;
} }
// Start connecting to the server // Start connecting to the server
NetCliFileStartConnect(&addr, 1, true); NetCliFileStartConnect(&addr, 1, true);
PathGetProgramDirectory(s_newPatcherFile, arrsize(s_newPatcherFile)); PathGetProgramDirectory(s_newPatcherFile, arrsize(s_newPatcherFile));
GetTempFileNameW(s_newPatcherFile, kPatcherExeFilename, 0, s_newPatcherFile); GetTempFileNameW(s_newPatcherFile, kPatcherExeFilename, 0, s_newPatcherFile);
PathDeleteFile(s_newPatcherFile); PathDeleteFile(s_newPatcherFile);
NetCliFileManifestRequest(ManifestCallback, nil, s_manifest); NetCliFileManifestRequest(ManifestCallback, nil, s_manifest);
} }
//============================================================================ //============================================================================
static bool SelfPatcherProc (bool * abort, plLauncherInfo *info) { static bool SelfPatcherProc (bool * abort, plLauncherInfo *info) {
bool patched = false; bool patched = false;
s_downloadComplete = false; s_downloadComplete = false;
s_patchResult = kNetSuccess; s_patchResult = kNetSuccess;
NetClientInitialize(); NetClientInitialize();
NetClientSetErrorHandler(NetErrorHandler); NetClientSetErrorHandler(NetErrorHandler);
const wchar ** addrs; const wchar ** addrs;
unsigned count; unsigned count;
count = GetGateKeeperSrvHostnames(&addrs); count = GetGateKeeperSrvHostnames(&addrs);
// Start connecting to the server // Start connecting to the server
NetCliGateKeeperStartConnect(addrs, count); NetCliGateKeeperStartConnect(addrs, count);
// request a file server ip address // request a file server ip address
NetCliGateKeeperFileSrvIpAddressRequest(FileSrvIpAddressCallback, nil, true); NetCliGateKeeperFileSrvIpAddressRequest(FileSrvIpAddressCallback, nil, true);
while(!s_downloadComplete && !*abort) { while(!s_downloadComplete && !*abort) {
NetClientUpdate(); NetClientUpdate();
AsyncSleep(10); AsyncSleep(10);
} }
NetCliFileDisconnect(); NetCliFileDisconnect();
NetClientUpdate(); NetClientUpdate();
// Shutdown the client/server networking subsystem // Shutdown the client/server networking subsystem
NetClientDestroy(); NetClientDestroy();
if (s_downloadComplete && !*abort && s_updated && IS_NET_SUCCESS(s_patchResult)) { if (s_downloadComplete && !*abort && s_updated && IS_NET_SUCCESS(s_patchResult)) {
// launch new patcher // launch new patcher
STARTUPINFOW si; STARTUPINFOW si;
PROCESS_INFORMATION pi; PROCESS_INFORMATION pi;
ZERO(si); ZERO(si);
ZERO(pi); ZERO(pi);
si.cb = sizeof(si); si.cb = sizeof(si);
wchar cmdline[MAX_PATH]; wchar cmdline[MAX_PATH];
StrPrintf(cmdline, arrsize(cmdline), L"%s %s", s_newPatcherFile, info->cmdLine); StrPrintf(cmdline, arrsize(cmdline), L"%s %s", s_newPatcherFile, info->cmdLine);
// we have only successfully patched if we actually launch the new version of the patcher // we have only successfully patched if we actually launch the new version of the patcher
patched = CreateProcessW( patched = CreateProcessW(
NULL, NULL,
cmdline, cmdline,
NULL, NULL,
NULL, NULL,
FALSE, FALSE,
DETACHED_PROCESS, DETACHED_PROCESS,
NULL, NULL,
NULL, NULL,
&si, &si,
&pi &pi
); );
SetReturnCode(pi.dwProcessId); SetReturnCode(pi.dwProcessId);
CloseHandle( pi.hThread ); CloseHandle( pi.hThread );
CloseHandle( pi.hProcess ); CloseHandle( pi.hProcess );
ASSERT(patched); ASSERT(patched);
} }
return patched; return patched;
} }
@ -278,10 +278,10 @@ static bool SelfPatcherProc (bool * abort, plLauncherInfo *info) {
//============================================================================ //============================================================================
UInt32 SelfPatcherStream::Write(UInt32 byteCount, const void* buffer) { UInt32 SelfPatcherStream::Write(UInt32 byteCount, const void* buffer) {
progress += byteCount; progress += byteCount;
float p = (float)progress / (float)totalBytes * 100; // progress float p = (float)progress / (float)totalBytes * 100; // progress
SetProgress( (int)p ); SetProgress( (int)p );
return plZlibStream::Write(byteCount, buffer); return plZlibStream::Write(byteCount, buffer);
} }
@ -294,12 +294,12 @@ UInt32 SelfPatcherStream::Write(UInt32 byteCount, const void* buffer) {
//============================================================================ //============================================================================
// if return value is true, there was an update and the patcher should be shutdown, so the new patcher can take over // if return value is true, there was an update and the patcher should be shutdown, so the new patcher can take over
bool SelfPatch (bool noSelfPatch, bool * abort, ENetError * result, plLauncherInfo *info) { bool SelfPatch (bool noSelfPatch, bool * abort, ENetError * result, plLauncherInfo *info) {
bool patched = false; bool patched = false;
if (!noSelfPatch) { if (!noSelfPatch) {
SetText("Checking for patcher update..."); SetText("Checking for patcher update...");
patched = SelfPatcherProc(abort, info); patched = SelfPatcherProc(abort, info);
} }
*result = s_patchResult; *result = s_patchResult;
return patched; return patched;
} }

BIN
Sources/Plasma/Apps/plUruLauncher/banner.bmp
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 70 KiB

After

Width:  |  Height:  |  Size: 70 KiB

46
Sources/Plasma/Apps/plUruLauncher/plLauncherInfo.h
View File

@ -35,15 +35,15 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#define PLASMA20_SOURCES_PLASMA_APPS_PLURULAUNCHER_PLLAUNCHERCALLBACK_H #define PLASMA20_SOURCES_PLASMA_APPS_PLURULAUNCHER_PLLAUNCHERCALLBACK_H
enum EStatus { enum EStatus {
kStatusOk, kStatusOk,
kStatusError, kStatusError,
kStatusPending, kStatusPending,
}; };
struct PatchInfo { struct PatchInfo {
unsigned progress; unsigned progress;
unsigned stage; unsigned stage;
unsigned progressStage; unsigned progressStage;
}; };
typedef void (*launcherCallback)(int status, void *param); typedef void (*launcherCallback)(int status, void *param);
@ -53,24 +53,24 @@ typedef void (*setTimeRemainingCallback)(unsigned seconds);
typedef void (*setBytesRemainingCallback)(unsigned bytes); typedef void (*setBytesRemainingCallback)(unsigned bytes);
struct plLauncherInfo { struct plLauncherInfo {
wchar path[MAX_PATH]; wchar path[MAX_PATH];
wchar cmdLine[512]; wchar cmdLine[512];
unsigned buildId; // buildId override unsigned buildId; // buildId override
launcherCallback prepCallback; launcherCallback prepCallback;
launcherCallback initCallback; launcherCallback initCallback;
launcherCallback startCallback; launcherCallback startCallback;
launcherCallback stopCallback; launcherCallback stopCallback;
launcherCallback terminateCallback; launcherCallback terminateCallback;
launcherCallback progressCallback; launcherCallback progressCallback;
launcherCallback exitCallback; launcherCallback exitCallback;
setTextCallback SetText; setTextCallback SetText;
setStatusTextCallback SetStatusText; setStatusTextCallback SetStatusText;
setTimeRemainingCallback SetTimeRemaining; setTimeRemainingCallback SetTimeRemaining;
setBytesRemainingCallback SetBytesRemaining; setBytesRemainingCallback SetBytesRemaining;
PatchInfo patchInfo; PatchInfo patchInfo;
bool IsTGCider; bool IsTGCider;
DWORD returnCode; // used so we can pass a new process id back to gametap. That way gametap wont think uru has exited when the patcher quits. DWORD returnCode; // used so we can pass a new process id back to gametap. That way gametap wont think uru has exited when the patcher quits.
}; };

152
Sources/Plasma/CoreLib/CMakeLists.txt
View File

@ -1,96 +1,96 @@
add_definitions(-D_LIB) add_definitions(-D_LIB)
set(CoreLib_SOURCES set(CoreLib_SOURCES
HeadSpin.cpp HeadSpin.cpp
hsBitVector.cpp hsBitVector.cpp
hsBounds.cpp hsBounds.cpp
hsCritSect.cpp hsCritSect.cpp
hsExceptionStack.cpp hsExceptionStack.cpp
hsFastMath.cpp hsFastMath.cpp
hsGeometry3.cpp hsGeometry3.cpp
hsMalloc.cpp hsMalloc.cpp
hsMatrix33.cpp hsMatrix33.cpp
hsMatrix44.cpp hsMatrix44.cpp
hsMemory.cpp hsMemory.cpp
hsMMIOStream.cpp hsMMIOStream.cpp
hsQuat.cpp hsQuat.cpp
hsSafeRefCnt.cpp hsSafeRefCnt.cpp
hsSTLStream.cpp hsSTLStream.cpp
hsStlUtils.cpp hsStlUtils.cpp
hsStream.cpp hsStream.cpp
hsStringTokenizer.cpp hsStringTokenizer.cpp
hsTemplates.cpp hsTemplates.cpp
hsThread.cpp hsThread.cpp
hsUtils.cpp hsUtils.cpp
hsWide.cpp hsWide.cpp
pcSmallRect.cpp pcSmallRect.cpp
plGeneric.cpp plGeneric.cpp
plLoadMask.cpp plLoadMask.cpp
plViewTransform.cpp plViewTransform.cpp
) )
if(WIN32 AND NOT CYGWIN) if(WIN32 AND NOT CYGWIN)
set(CoreLib_SOURCES ${CoreLib_SOURCES} set(CoreLib_SOURCES ${CoreLib_SOURCES}
hsThread_Win.cpp hsThread_Win.cpp
) )
endif(WIN32 AND NOT CYGWIN) endif(WIN32 AND NOT CYGWIN)
if(UNIX) if(UNIX)
set(CoreLib_SOURCES ${CoreLib_SOURCES} set(CoreLib_SOURCES ${CoreLib_SOURCES}
hsThread_Unix.cpp hsThread_Unix.cpp
) )
endif(UNIX) endif(UNIX)
# for now we use the Unix file on mac... I think this is Carbon code, which # 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 # we don't want to use. I don't think it's worth support OS9 anymore
#if(APPLE) #if(APPLE)
# set(CoreLib_SOURCES ${CoreLib_SOURCES} # set(CoreLib_SOURCES ${CoreLib_SOURCES}
# hsThread_Mac.cpp # hsThread_Mac.cpp
# ) # )
#endif(APPLE) #endif(APPLE)
set(CoreLib_HEADERS set(CoreLib_HEADERS
HeadSpin.h HeadSpin.h
hsBiExpander.h hsBiExpander.h
hsBitVector.h hsBitVector.h
hsBounds.h hsBounds.h
hsColorRGBA.h hsColorRGBA.h
hsConfig.h hsConfig.h
hsCritSect.h hsCritSect.h
hsExceptions.h hsExceptions.h
hsFastMath.h hsFastMath.h
hsFixedTypes.h hsFixedTypes.h
hsGeometry3.h hsGeometry3.h
hsHashTable.h hsHashTable.h
hsMalloc.h hsMalloc.h
hsMatrix44.h hsMatrix44.h
hsMemory.h hsMemory.h
hsMMIOStream.h hsMMIOStream.h
hsPoint2.h hsPoint2.h
hsQuat.h hsQuat.h
hsQueue.h hsQueue.h
hsRefCnt.h hsRefCnt.h
hsSafeRefCnt.h hsSafeRefCnt.h
hsScalar.h hsScalar.h
hsStlSortUtils.h hsStlSortUtils.h
hsSTLStream.h hsSTLStream.h
hsStream.h hsStream.h
hsStringTokenizer.h hsStringTokenizer.h
hsTemplates.h hsTemplates.h
hsTempPointer.h hsTempPointer.h
hsThread.h hsThread.h
hsTypes.h hsTypes.h
hsUtils.h hsUtils.h
hsWide.h hsWide.h
hsWindowHndl.h hsWindowHndl.h
hsWindows.h hsWindows.h
pcSmallRect.h pcSmallRect.h
plGeneric.h plGeneric.h
plLoadMask.h plLoadMask.h
plQuality.h plQuality.h
plRefCnt.h plRefCnt.h
plTweak.h plTweak.h
plViewTransform.h plViewTransform.h
) )
add_library(CoreLib STATIC ${CoreLib_SOURCES} ${CoreLib_HEADERS}) add_library(CoreLib STATIC ${CoreLib_SOURCES} ${CoreLib_HEADERS})

104
Sources/Plasma/CoreLib/HS_POINT2.inc
View File

@ -1,61 +1,61 @@
struct HS_POINT2_NAME { struct HS_POINT2_NAME {
HS_POINT2_TYPE fX, fY; HS_POINT2_TYPE fX, fY;
HS_POINT2_NAME& Set(HS_POINT2_TYPE x, HS_POINT2_TYPE y) HS_POINT2_NAME& Set(HS_POINT2_TYPE x, HS_POINT2_TYPE y)
{ {
fX = x; fX = x;
fY = y; fY = y;
return *this; return *this;
} }
HS_POINT2_NAME& operator+=(const HS_POINT2_NAME& s) HS_POINT2_NAME& operator+=(const HS_POINT2_NAME& s)
{ {
this->fX += s.fX; this->fX += s.fX;
this->fY += s.fY; this->fY += s.fY;
return *this; return *this;
} }
HS_POINT2_NAME& operator-=(const HS_POINT2_NAME& s) HS_POINT2_NAME& operator-=(const HS_POINT2_NAME& s)
{ {
this->fX -= s.fX; this->fX -= s.fX;
this->fY -= s.fY; this->fY -= s.fY;
return *this; return *this;
} }
#if 0 // Havok reeks #if 0 // Havok reeks
friend int operator==(const HS_POINT2_NAME& s, const HS_POINT2_NAME& t) friend int operator==(const HS_POINT2_NAME& s, const HS_POINT2_NAME& t)
{ {
return (s.fX == t.fX && s.fY == t.fY); return (s.fX == t.fX && s.fY == t.fY);
} }
friend int operator!=(const HS_POINT2_NAME& s, const HS_POINT2_NAME& t) friend int operator!=(const HS_POINT2_NAME& s, const HS_POINT2_NAME& t)
{ {
return !(s == t); return !(s == t);
} }
#else // Havok reeks #else // Havok reeks
int operator==(const HS_POINT2_NAME& ss) const int operator==(const HS_POINT2_NAME& ss) const
{ {
return (ss.fX == fX && ss.fY == fY); return (ss.fX == fX && ss.fY == fY);
} }
int operator!=(const HS_POINT2_NAME& ss) int operator!=(const HS_POINT2_NAME& ss)
{ {
return !(ss == *this); return !(ss == *this);
} }
#endif // Havok reeks #endif // Havok reeks
friend HS_POINT2_NAME operator+(const HS_POINT2_NAME& s, const HS_POINT2_NAME& t) friend HS_POINT2_NAME operator+(const HS_POINT2_NAME& s, const HS_POINT2_NAME& t)
{ {
HS_POINT2_NAME result; HS_POINT2_NAME result;
result.Set(s.fX + t.fX, s.fY + t.fY); result.Set(s.fX + t.fX, s.fY + t.fY);
return result; return result;
} }
friend HS_POINT2_NAME operator-(const HS_POINT2_NAME& s, const HS_POINT2_NAME& t) friend HS_POINT2_NAME operator-(const HS_POINT2_NAME& s, const HS_POINT2_NAME& t)
{ {
HS_POINT2_NAME result; HS_POINT2_NAME result;
result.Set(s.fX - t.fX, s.fY - t.fY); result.Set(s.fX - t.fX, s.fY - t.fY);
return result; return result;
} }
friend HS_POINT2_NAME operator-(const HS_POINT2_NAME& s) friend HS_POINT2_NAME operator-(const HS_POINT2_NAME& s)
{ {
HS_POINT2_NAME result = { -s.fX, -s.fY }; HS_POINT2_NAME result = { -s.fX, -s.fY };
return result; return result;
} }
#undef HS_POINT2_NAME #undef HS_POINT2_NAME
#undef HS_POINT2_TYPE #undef HS_POINT2_TYPE

94
Sources/Plasma/CoreLib/HeadSpin.cpp
View File

@ -31,16 +31,16 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_MAC
#include <Events.h> #include <Events.h>
#include <ToolUtils.h> #include <ToolUtils.h>
#include <Windows.h> #include <Windows.h>
#endif #endif
#if HS_BUILD_FOR_WIN32 #if HS_BUILD_FOR_WIN32
# include <crtdbg.h> /* for _RPT_BASE */ # include <crtdbg.h> /* for _RPT_BASE */
# define WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN
# define WIN32_EXTRA_LEAN # define WIN32_EXTRA_LEAN
# include <windows.h> // For OutputDebugString() # include <windows.h> // For OutputDebugString()
#endif #endif
@ -51,11 +51,11 @@ hsDebugMessageProc gHSStatusProc = nil;
hsDebugMessageProc hsSetStatusMessageProc(hsDebugMessageProc newProc) hsDebugMessageProc hsSetStatusMessageProc(hsDebugMessageProc newProc)
{ {
hsDebugMessageProc oldProc = gHSStatusProc; hsDebugMessageProc oldProc = gHSStatusProc;
gHSStatusProc = newProc; gHSStatusProc = newProc;
return oldProc; return oldProc;
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -64,17 +64,17 @@ hsDebugMessageProc gHSDebugProc = nil;
hsDebugMessageProc hsSetDebugMessageProc(hsDebugMessageProc newProc) hsDebugMessageProc hsSetDebugMessageProc(hsDebugMessageProc newProc)
{ {
hsDebugMessageProc oldProc = gHSDebugProc; hsDebugMessageProc oldProc = gHSDebugProc;
gHSDebugProc = newProc; gHSDebugProc = newProc;
return oldProc; return oldProc;
} }
#ifdef HS_DEBUGGING #ifdef HS_DEBUGGING
void hsDebugMessage (const char message[], long val) void hsDebugMessage (const char message[], long val)
{ {
char s[1024]; char s[1024];
#if HS_BUILD_FOR_WIN32 #if HS_BUILD_FOR_WIN32
#define strfmt _snprintf #define strfmt _snprintf
@ -83,27 +83,27 @@ void hsDebugMessage (const char message[], long val)
#endif #endif
if (val) if (val)
s[0] = strfmt(&s[1], 1022, "%s: %ld", message, val); s[0] = strfmt(&s[1], 1022, "%s: %ld", message, val);
else else
s[0] = strfmt(&s[1], 1022, "%s", message); s[0] = strfmt(&s[1], 1022, "%s", message);
if (gHSDebugProc) if (gHSDebugProc)
gHSDebugProc(&s[1]); gHSDebugProc(&s[1]);
else else
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_MAC
DebugStr((unsigned char*)s); DebugStr((unsigned char*)s);
#elif HS_BUILD_FOR_WIN32 #elif HS_BUILD_FOR_WIN32
{ OutputDebugString(&s[1]); { OutputDebugString(&s[1]);
OutputDebugString("\n"); OutputDebugString("\n");
} }
#elif (HS_BUILD_FOR_BE || HS_BUILD_FOR_UNIX ) #elif (HS_BUILD_FOR_BE || HS_BUILD_FOR_UNIX )
{ fprintf(stderr, "%s\n", &s[1]); { fprintf(stderr, "%s\n", &s[1]);
// hsThrow(&s[1]); // hsThrow(&s[1]);
} }
#elif HS_BUILD_FOR_PS2 #elif HS_BUILD_FOR_PS2
fprintf(stderr, "%s\n", &s[1]); fprintf(stderr, "%s\n", &s[1]);
#else #else
hsThrow(&s[1]); hsThrow(&s[1]);
#endif #endif
} }
#endif #endif
@ -114,22 +114,22 @@ void hsDebugMessage (const char message[], long val)
hsRefCnt::~hsRefCnt() hsRefCnt::~hsRefCnt()
{ {
hsDebugCode(hsThrowIfFalse(fRefCnt == 1);) hsDebugCode(hsThrowIfFalse(fRefCnt == 1);)
} }
void hsRefCnt::Ref() void hsRefCnt::Ref()
{ {
fRefCnt++; fRefCnt++;
} }
void hsRefCnt::UnRef() void hsRefCnt::UnRef()
{ {
hsDebugCode(hsThrowIfFalse(fRefCnt >= 1);) hsDebugCode(hsThrowIfFalse(fRefCnt >= 1);)
if (fRefCnt == 1) // don't decrement if we call delete if (fRefCnt == 1) // don't decrement if we call delete
delete this; delete this;
else else
--fRefCnt; --fRefCnt;
} }
@ -144,31 +144,31 @@ void hsStatusMessage(const char message[])
} else { } else {
#if HS_BUILD_FOR_PS2 || HS_BUILD_FOR_UNIX #if HS_BUILD_FOR_PS2 || 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')
printf("\n"); printf("\n");
#elif HS_BUILD_FOR_WIN32 #elif HS_BUILD_FOR_WIN32
OutputDebugString(message); OutputDebugString(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 // MAC ?????? TODO
} }
} }
void hsStatusMessageV(const char * fmt, va_list args) void hsStatusMessageV(const char * fmt, va_list args)
{ {
char buffer[2000]; char buffer[2000];
vsprintf(buffer, fmt, args); vsprintf(buffer, fmt, args);
hsStatusMessage(buffer); hsStatusMessage(buffer);
} }
void hsStatusMessageF(const char * fmt, ...) void hsStatusMessageF(const char * fmt, ...)
{ {
va_list args; va_list args;
va_start(args,fmt); va_start(args,fmt);
hsStatusMessageV(fmt,args); hsStatusMessageV(fmt,args);
va_end(args); va_end(args);
} }
#endif // not PLASMA_EXTERNAL_RELEASE #endif // not PLASMA_EXTERNAL_RELEASE

468
Sources/Plasma/CoreLib/hsBiExpander.h
View File

@ -35,205 +35,205 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
template <class T> class hsExpander { template <class T> class hsExpander {
private: private:
Int32 fNumPost; Int32 fNumPost;
Int32 fNumPostAlloc; Int32 fNumPostAlloc;
T* fArray; T* fArray;
Int32 fGrowBy; // default = 0, to double Int32 fGrowBy; // default = 0, to double
Int32 fMinSize; // default = 1, min == 1 Int32 fMinSize; // default = 1, min == 1
Int32 fCurrent; Int32 fCurrent;
hsExpander(const hsExpander& x); // make it passed as ref or pointer hsExpander(const hsExpander& x); // make it passed as ref or pointer
void IExpand(int newSize); void IExpand(int newSize);
public: public:
enum { kMissingIndex = -1 }; enum { kMissingIndex = -1 };
hsExpander(Int32 minSize = 1, Int32 growBy = 0); hsExpander(Int32 minSize = 1, Int32 growBy = 0);
virtual ~hsExpander(); virtual ~hsExpander();
hsExpander<T>& operator=(const hsExpander<T>&orig) { return Copy(orig); } hsExpander<T>& operator=(const hsExpander<T>&orig) { return Copy(orig); }
hsExpander<T>& Copy(const hsExpander<T>& orig); hsExpander<T>& Copy(const hsExpander<T>& orig);
void SetCount(int cnt) { if( cnt >= fNumPostAlloc )IExpand(cnt); fNumPost = cnt; } void SetCount(int cnt) { if( cnt >= fNumPostAlloc )IExpand(cnt); fNumPost = cnt; }
Int32 GetCount() const { return fNumPost; } Int32 GetCount() const { return fNumPost; }
hsBool Empty() const { return GetCount() == 0; } hsBool Empty() const { return GetCount() == 0; }
const T& Get(Int32 index) const; const T& Get(Int32 index) const;
Int32 Get(Int32 index, Int32 count, T data[]) const; Int32 Get(Int32 index, Int32 count, T data[]) const;
Int32 Find(const T&) const; // returns kMissingIndex if not found Int32 Find(const T&) const; // returns kMissingIndex if not found
void SetArray(T* a, Int32 cnt); void SetArray(T* a, Int32 cnt);
T* GetArray() { return fArray; } T* GetArray() { return fArray; }
T& operator[]( Int32 index ); T& operator[]( Int32 index );
Int32 Append(const T&); // returns t's index Int32 Append(const T&); // returns t's index
T* Append(); T* Append();
Int32 Push(const T& t) { return Append(t); } Int32 Push(const T& t) { return Append(t); }
T* Push() { return Append(); } T* Push() { return Append(); }
T* Top() { return fNumPost ? fArray + fNumPost-1 : nil; } T* Top() { return fNumPost ? fArray + fNumPost-1 : nil; }
Int32 Pop(T* t); // returns count of remaining Int32 Pop(T* t); // returns count of remaining
Int32 Pop(); Int32 Pop();
void Reset(); // clears out everything void Reset(); // clears out everything
T& Head() { return fArray[0]; } T& Head() { return fArray[0]; }
T& Tail() { return fArray[fNumPost-1]; } T& Tail() { return fArray[fNumPost-1]; }
T& Current() { return fArray[fCurrent]; } T& Current() { return fArray[fCurrent]; }
void First(); void First();
void Last(); void Last();
void Plus() { ++fCurrent; } void Plus() { ++fCurrent; }
hsBool More() { return (fCurrent < fNumPost); } hsBool More() { return (fCurrent < fNumPost); }
}; };
template <class T> template <class T>
hsExpander<T>& hsExpander<T>::Copy(const hsExpander<T>& orig) hsExpander<T>& hsExpander<T>::Copy(const hsExpander<T>& orig)
{ {
SetCount(orig.GetCount()); SetCount(orig.GetCount());
int i; int i;
for( i = 0; i < GetCount(); i++ ) for( i = 0; i < GetCount(); i++ )
fArray[i] = orig.fArray[i]; fArray[i] = orig.fArray[i];
return *this; return *this;
} }
template <class T> template <class T>
void hsExpander<T>::SetArray(T* a, Int32 cnt) void hsExpander<T>::SetArray(T* a, Int32 cnt)
{ {
delete [] fArray; delete [] fArray;
if( a ) if( a )
fArray = a; fArray = a;
fNumPost = fNumPostAlloc = cnt; fNumPost = fNumPostAlloc = cnt;
} }
template <class T> template <class T>
void hsExpander<T>::IExpand(int newSize) void hsExpander<T>::IExpand(int newSize)
{ {
Int32 newPostAlloc = fNumPostAlloc; Int32 newPostAlloc = fNumPostAlloc;
if( !newPostAlloc ) if( !newPostAlloc )
newPostAlloc++; newPostAlloc++;
while( newPostAlloc <= newSize ) while( newPostAlloc <= newSize )
newPostAlloc = fGrowBy ? newPostAlloc + fGrowBy : newPostAlloc << 1; newPostAlloc = fGrowBy ? newPostAlloc + fGrowBy : newPostAlloc << 1;
T* newArray = TRACKED_NEW T[newPostAlloc]; T* newArray = TRACKED_NEW T[newPostAlloc];
int i; int i;
for( i = 0; i < fNumPost; i++ ) for( i = 0; i < fNumPost; i++ )
newArray[i] = fArray[i]; newArray[i] = fArray[i];
delete [] (fArray); delete [] (fArray);
fArray = newArray; fArray = newArray;
fNumPostAlloc = newPostAlloc; fNumPostAlloc = newPostAlloc;
} }
template <class T> template <class T>
hsExpander<T>::hsExpander(Int32 minSize, Int32 growBy) hsExpander<T>::hsExpander(Int32 minSize, Int32 growBy)
{ {
hsThrowIfBadParam(minSize < 0); hsThrowIfBadParam(minSize < 0);
hsThrowIfBadParam(growBy < 0); hsThrowIfBadParam(growBy < 0);
fMinSize = minSize+1; fMinSize = minSize+1;
fGrowBy = growBy; fGrowBy = growBy;
fArray = TRACKED_NEW T[fMinSize]; fArray = TRACKED_NEW T[fMinSize];
fNumPostAlloc = fMinSize; fNumPostAlloc = fMinSize;
fNumPost = 0; fNumPost = 0;
} }
template <class T> template <class T>
hsExpander<T>::~hsExpander() hsExpander<T>::~hsExpander()
{ {
delete [] fArray; delete [] fArray;
} }
template <class T> template <class T>
void hsExpander<T>::First() void hsExpander<T>::First()
{ {
fCurrent = 0; fCurrent = 0;
} }
template <class T> template <class T>
void hsExpander<T>::Last() void hsExpander<T>::Last()
{ {
fCurrent = fNumPost-1; fCurrent = fNumPost-1;
} }
template <class T> template <class T>
T& hsExpander<T>::operator[]( Int32 index ) T& hsExpander<T>::operator[]( Int32 index )
{ {
hsDebugCode(hsThrowIfBadParam((index < 0)||(index >= fNumPost));) hsDebugCode(hsThrowIfBadParam((index < 0)||(index >= fNumPost));)
return fArray[index]; return fArray[index];
} }
template <class T> template <class T>
const T& hsExpander<T>::Get( Int32 index ) const const T& hsExpander<T>::Get( Int32 index ) const
{ {
hsDebugCode(hsThrowIfBadParam((index < 0)||(index >= fNumPost));) hsDebugCode(hsThrowIfBadParam((index < 0)||(index >= fNumPost));)
return fArray[index]; return fArray[index];
} }
template <class T> template <class T>
Int32 hsExpander<T>::Get(Int32 index, Int32 count, T data[]) const Int32 hsExpander<T>::Get(Int32 index, Int32 count, T data[]) const
{ {
if( count > 0 ) if( count > 0 )
{ hsThrowIfNilParam(data); { hsThrowIfNilParam(data);
hsThrowIfBadParam((index < 0)||(index >= fNumPost)); hsThrowIfBadParam((index < 0)||(index >= fNumPost));
if (index + count > fNumPost) if (index + count > fNumPost)
count = fNumPost - index; count = fNumPost - index;
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
data[i] = fArray[i + index]; data[i] = fArray[i + index];
} }
return count; return count;
} }
template <class T> template <class T>
Int32 hsExpander<T>::Find(const T& obj) const Int32 hsExpander<T>::Find(const T& obj) const
{ {
for (int i = 0; i < fNumPost; i++) for (int i = 0; i < fNumPost; i++)
if (fArray[i] == obj) if (fArray[i] == obj)
return i; return i;
return kMissingIndex; return kMissingIndex;
} }
template <class T> template <class T>
Int32 hsExpander<T>::Append(const T& obj) Int32 hsExpander<T>::Append(const T& obj)
{ {
hsAssert(!(fNumPost >= fNumPostAlloc), "Must be less"); hsAssert(!(fNumPost >= fNumPostAlloc), "Must be less");
if( fNumPost == fNumPostAlloc-1 ) if( fNumPost == fNumPostAlloc-1 )
IExpand(fNumPostAlloc); IExpand(fNumPostAlloc);
fArray[fNumPost] = obj; fArray[fNumPost] = obj;
return fNumPost++; return fNumPost++;
} }
template <class T> template <class T>
T* hsExpander<T>::Append() T* hsExpander<T>::Append()
{ {
hsAssert(!(fNumPost >= fNumPostAlloc), "Must be less"); hsAssert(!(fNumPost >= fNumPostAlloc), "Must be less");
if( fNumPost == fNumPostAlloc-1 ) if( fNumPost == fNumPostAlloc-1 )
IExpand(fNumPostAlloc); IExpand(fNumPostAlloc);
return fArray + fNumPost++; return fArray + fNumPost++;
} }
template <class T> template <class T>
Int32 hsExpander<T>::Pop(T*t) Int32 hsExpander<T>::Pop(T*t)
{ {
hsThrowIfBadParam(Empty()); hsThrowIfBadParam(Empty());
--fNumPost; --fNumPost;
if( t ) if( t )
*t = fArray[fNumPost]; *t = fArray[fNumPost];
return GetCount(); return GetCount();
} }
template <class T> template <class T>
Int32 hsExpander<T>::Pop() Int32 hsExpander<T>::Pop()
{ {
hsThrowIfBadParam(Empty()); hsThrowIfBadParam(Empty());
--fNumPost; --fNumPost;
return GetCount(); return GetCount();
} }
template <class T> template <class T>
void hsExpander<T>::Reset() void hsExpander<T>::Reset()
{ {
fNumPost = 0; fNumPost = 0;
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -241,237 +241,237 @@ void hsExpander<T>::Reset()
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
template <class T> class hsBiExpander { template <class T> class hsBiExpander {
private: private:
Int32 fNumPre; Int32 fNumPre;
Int32 fNumPost; Int32 fNumPost;
Int32 fNumPreAlloc; Int32 fNumPreAlloc;
Int32 fNumPostAlloc; Int32 fNumPostAlloc;
T* fArray; T* fArray;
Int32 fGrowBy; // default = 0, to double Int32 fGrowBy; // default = 0, to double
Int32 fMinSize; // default = 1, min == 1 Int32 fMinSize; // default = 1, min == 1
Int32 fCurrent; Int32 fCurrent;
hsBiExpander<T>& operator=(const hsBiExpander<T>&); // don't allow assignment hsBiExpander<T>& operator=(const hsBiExpander<T>&); // don't allow assignment
hsBiExpander(const hsBiExpander<T>&); // make it passed as ref or pointer hsBiExpander(const hsBiExpander<T>&); // make it passed as ref or pointer
void IExpand(int newSize, hsBool towardEnd = true); void IExpand(int newSize, hsBool towardEnd = true);
public: public:
enum { kMissingIndex = -1 }; enum { kMissingIndex = -1 };
hsBiExpander(Int32 minSize = 1, Int32 growBy = 0); hsBiExpander(Int32 minSize = 1, Int32 growBy = 0);
virtual ~hsBiExpander(); virtual ~hsBiExpander();
Int32 GetFirst() const { return -fNumPre; } Int32 GetFirst() const { return -fNumPre; }
Int32 GetCount() const { return fNumPre + fNumPost; } Int32 GetCount() const { return fNumPre + fNumPost; }
hsBool Empty() const { return GetCount() == 0; } hsBool Empty() const { return GetCount() == 0; }
const T& Get(Int32 index) const; const T& Get(Int32 index) const;
Int32 Get(Int32 index, Int32 count, T data[]) const; Int32 Get(Int32 index, Int32 count, T data[]) const;
Int32 Find(const T&) const; // returns kMissingIndex if not found Int32 Find(const T&) const; // returns kMissingIndex if not found
void SetArray(T* a, Int32 cnt, Int32 numPre=0); void SetArray(T* a, Int32 cnt, Int32 numPre=0);
T** GetArray() { return fArray - fNumPre; } T** GetArray() { return fArray - fNumPre; }
T& operator[]( Int32 index ); T& operator[]( Int32 index );
T* Append(); // returns t's index T* Append(); // returns t's index
T* Push(); // returns t's index T* Push(); // returns t's index
Int32 Append(const T&); // returns t's index Int32 Append(const T&); // returns t's index
Int32 Push(const T&); // returns t's index Int32 Push(const T&); // returns t's index
Int32 Pop(T*t = nil) { return PopHead(t); } // returns count of remaining Int32 Pop(T*t = nil) { return PopHead(t); } // returns count of remaining
Int32 PopHead(T*t = nil); // returns count of remaining Int32 PopHead(T*t = nil); // returns count of remaining
Int32 PopTail(T*t = nil); // returns count of remaining Int32 PopTail(T*t = nil); // returns count of remaining
void Reset(); // clears out everything void Reset(); // clears out everything
T& Head() { return fArray[-fNumPre]; } T& Head() { return fArray[-fNumPre]; }
T& Tail() { return fArray[fNumPost-1]; } T& Tail() { return fArray[fNumPost-1]; }
T& Current() { return fArray[fCurrent]; } T& Current() { return fArray[fCurrent]; }
void First(); void First();
void Last(); void Last();
void Plus() { ++fCurrent; } void Plus() { ++fCurrent; }
void Minus() { --fCurrent; } void Minus() { --fCurrent; }
hsBool More() { return (fCurrent < fNumPost)&&(fCurrent >= -fNumPre); } hsBool More() { return (fCurrent < fNumPost)&&(fCurrent >= -fNumPre); }
}; };
template <class T> template <class T>
void hsBiExpander<T>::SetArray(T* a, Int32 cnt, Int32 numPre) void hsBiExpander<T>::SetArray(T* a, Int32 cnt, Int32 numPre)
{ {
if( !numPre ) if( !numPre )
Reset(); Reset();
else else
{ {
fNumPreAlloc = fNumPre = numPre; fNumPreAlloc = fNumPre = numPre;
fNumPostAlloc = fNumPost = cnt - numPre; fNumPostAlloc = fNumPost = cnt - numPre;
fArray = a + numPre; fArray = a + numPre;
} }
} }
template <class T> template <class T>
void hsBiExpander<T>::IExpand(int newSize, hsBool towardEnd) void hsBiExpander<T>::IExpand(int newSize, hsBool towardEnd)
{ {
Int32 newPreAlloc = fNumPreAlloc; Int32 newPreAlloc = fNumPreAlloc;
Int32 newPostAlloc = fNumPostAlloc; Int32 newPostAlloc = fNumPostAlloc;
if( towardEnd ) if( towardEnd )
{ {
if( !newPostAlloc ) if( !newPostAlloc )
newPostAlloc++; newPostAlloc++;
while( newPostAlloc <= newSize ) while( newPostAlloc <= newSize )
newPostAlloc = fGrowBy ? newPostAlloc + fGrowBy : newPostAlloc << 1; newPostAlloc = fGrowBy ? newPostAlloc + fGrowBy : newPostAlloc << 1;
} }
else else
{ {
if( !newPreAlloc ) if( !newPreAlloc )
newPreAlloc++; newPreAlloc++;
while( newPreAlloc <= newSize ) while( newPreAlloc <= newSize )
newPreAlloc = fGrowBy ? newPreAlloc + fGrowBy : newPreAlloc << 1; newPreAlloc = fGrowBy ? newPreAlloc + fGrowBy : newPreAlloc << 1;
} }
T* newArray = TRACKED_NEW T[newPreAlloc + newPostAlloc]; T* newArray = TRACKED_NEW T[newPreAlloc + newPostAlloc];
newArray += newPreAlloc; newArray += newPreAlloc;
int i; int i;
for( i = -fNumPre; i < fNumPost; i++ ) for( i = -fNumPre; i < fNumPost; i++ )
newArray[i] = fArray[i]; newArray[i] = fArray[i];
// HSMemory::BlockMove(fArray-fNumPre, newArray-fNumPre, // HSMemory::BlockMove(fArray-fNumPre, newArray-fNumPre,
// (fNumPre+fNumPost)*sizeof(*fArray)); // (fNumPre+fNumPost)*sizeof(*fArray));
delete [] (fArray-fNumPreAlloc); delete [] (fArray-fNumPreAlloc);
fArray = newArray; fArray = newArray;
fNumPreAlloc = newPreAlloc; fNumPreAlloc = newPreAlloc;
fNumPostAlloc = newPostAlloc; fNumPostAlloc = newPostAlloc;
} }
template <class T> template <class T>
hsBiExpander<T>::hsBiExpander(Int32 minSize, Int32 growBy) hsBiExpander<T>::hsBiExpander(Int32 minSize, Int32 growBy)
{ {
hsThrowIfBadParam(minSize < 0); hsThrowIfBadParam(minSize < 0);
hsThrowIfBadParam(growBy < 0); hsThrowIfBadParam(growBy < 0);
fMinSize = minSize+1; fMinSize = minSize+1;
fGrowBy = growBy; fGrowBy = growBy;
fArray = TRACKED_NEW T[fMinSize << 1]; fArray = TRACKED_NEW T[fMinSize << 1];
fNumPreAlloc = fNumPostAlloc = fMinSize; fNumPreAlloc = fNumPostAlloc = fMinSize;
fArray += fNumPreAlloc; fArray += fNumPreAlloc;
fNumPre = fNumPost = 0; fNumPre = fNumPost = 0;
} }
template <class T> template <class T>
hsBiExpander<T>::~hsBiExpander() hsBiExpander<T>::~hsBiExpander()
{ {
delete [] (fArray - fNumPreAlloc); delete [] (fArray - fNumPreAlloc);
} }
template <class T> template <class T>
void hsBiExpander<T>::First() void hsBiExpander<T>::First()
{ {
fCurrent = -fNumPre; fCurrent = -fNumPre;
} }
template <class T> template <class T>
void hsBiExpander<T>::Last() void hsBiExpander<T>::Last()
{ {
fCurrent = fNumPost-1; fCurrent = fNumPost-1;
} }
template <class T> template <class T>
T& hsBiExpander<T>::operator[]( Int32 index ) T& hsBiExpander<T>::operator[]( Int32 index )
{ {
hsDebugCode(hsThrowIfBadParam((index < -fNumPre)||(index >= fNumPost));) hsDebugCode(hsThrowIfBadParam((index < -fNumPre)||(index >= fNumPost));)
return fArray[index]; return fArray[index];
} }
template <class T> template <class T>
const T& hsBiExpander<T>::Get( Int32 index ) const const T& hsBiExpander<T>::Get( Int32 index ) const
{ {
hsDebugCode(hsThrowIfBadParam((index < -fNumPre)||(index >= fNumPost));) hsDebugCode(hsThrowIfBadParam((index < -fNumPre)||(index >= fNumPost));)
return fArray[index]; return fArray[index];
} }
template <class T> template <class T>
Int32 hsBiExpander<T>::Get(Int32 index, Int32 count, T data[]) const Int32 hsBiExpander<T>::Get(Int32 index, Int32 count, T data[]) const
{ {
if( count > 0 ) if( count > 0 )
{ hsThrowIfNilParam(data); { hsThrowIfNilParam(data);
hsThrowIfBadParam((index < -fNumPre)||(index >= fNumPost)); hsThrowIfBadParam((index < -fNumPre)||(index >= fNumPost));
if (index + count > fNumPost) if (index + count > fNumPost)
count = fNumPost - index; count = fNumPost - index;
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
data[i] = fArray[i + index]; data[i] = fArray[i + index];
} }
return count; return count;
} }
template <class T> template <class T>
Int32 hsBiExpander<T>::Find(const T& obj) const Int32 hsBiExpander<T>::Find(const T& obj) const
{ {
for (int i = -fNumPre; i < fNumPost; i++) for (int i = -fNumPre; i < fNumPost; i++)
if (fArray[i] == obj) if (fArray[i] == obj)
return i; return i;
return kMissingIndex; return kMissingIndex;
} }
template <class T> template <class T>
T* hsBiExpander<T>::Append() T* hsBiExpander<T>::Append()
{ {
hsAssert(!(fNumPost >= fNumPostAlloc), "Must be less"); hsAssert(!(fNumPost >= fNumPostAlloc), "Must be less");
if( fNumPost == fNumPostAlloc-1 ) if( fNumPost == fNumPostAlloc-1 )
IExpand(fNumPostAlloc, true); IExpand(fNumPostAlloc, true);
return fArray + fNumPost++; return fArray + fNumPost++;
} }
template <class T> template <class T>
T* hsBiExpander<T>::Push() T* hsBiExpander<T>::Push()
{ {
hsAssert(!(fNumPre >= fNumPreAlloc), "Must be less"); hsAssert(!(fNumPre >= fNumPreAlloc), "Must be less");
if( ++fNumPre == fNumPreAlloc ) if( ++fNumPre == fNumPreAlloc )
IExpand(fNumPreAlloc, false); IExpand(fNumPreAlloc, false);
return fArray - fNumPre; return fArray - fNumPre;
} }
template <class T> template <class T>
Int32 hsBiExpander<T>::Append(const T& obj) Int32 hsBiExpander<T>::Append(const T& obj)
{ {
hsAssert(!(fNumPost >= fNumPostAlloc), "Must be less"); hsAssert(!(fNumPost >= fNumPostAlloc), "Must be less");
if( fNumPost == fNumPostAlloc-1 ) if( fNumPost == fNumPostAlloc-1 )
IExpand(fNumPostAlloc, true); IExpand(fNumPostAlloc, true);
fArray[fNumPost] = obj; fArray[fNumPost] = obj;
return fNumPost++; return fNumPost++;
} }
template <class T> template <class T>
Int32 hsBiExpander<T>::Push(const T& obj) Int32 hsBiExpander<T>::Push(const T& obj)
{ {
hsAssert(!(fNumPre >= fNumPreAlloc), "Must be less"); hsAssert(!(fNumPre >= fNumPreAlloc), "Must be less");
if( ++fNumPre == fNumPreAlloc ) if( ++fNumPre == fNumPreAlloc )
IExpand(fNumPreAlloc, false); IExpand(fNumPreAlloc, false);
fArray[-fNumPre] = obj; fArray[-fNumPre] = obj;
return -fNumPre; return -fNumPre;
} }
template <class T> template <class T>
Int32 hsBiExpander<T>::PopHead(T*t) Int32 hsBiExpander<T>::PopHead(T*t)
{ {
hsThrowIfBadParam(Empty()); hsThrowIfBadParam(Empty());
if( t ) if( t )
*t = fArray[-fNumPre]; *t = fArray[-fNumPre];
--fNumPre; --fNumPre;
return GetCount(); return GetCount();
} }
template <class T> template <class T>
Int32 hsBiExpander<T>::PopTail(T*t) Int32 hsBiExpander<T>::PopTail(T*t)
{ {
hsThrowIfBadParam(Empty()); hsThrowIfBadParam(Empty());
--fNumPost; --fNumPost;
if( t ) if( t )
*t = fArray[fNumPost]; *t = fArray[fNumPost];
return GetCount(); return GetCount();
} }
template <class T> template <class T>
void hsBiExpander<T>::Reset() void hsBiExpander<T>::Reset()
{ {
fNumPre = fNumPost = 0; fNumPre = fNumPost = 0;
} }
#endif // hsBiExpander_inc #endif // hsBiExpander_inc

216
Sources/Plasma/CoreLib/hsBitVector.cpp
View File

@ -32,174 +32,174 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include <stdarg.h> #include <stdarg.h>
hsBitVector::hsBitVector(int b, ...) hsBitVector::hsBitVector(int b, ...)
: fBitVectors(nil), : fBitVectors(nil),
fNumBitVectors(0) fNumBitVectors(0)
{ {
va_list vl; va_list vl;
va_start( vl, b ); va_start( vl, b );
do { do {
SetBit( b, true ); SetBit( b, true );
} while( (b = va_arg( vl, int )) >= 0 ); } while( (b = va_arg( vl, int )) >= 0 );
va_end( vl ); va_end( vl );
} }
hsBitVector::hsBitVector(const hsTArray<Int16>& src) hsBitVector::hsBitVector(const hsTArray<Int16>& src)
: fBitVectors(nil), : fBitVectors(nil),
fNumBitVectors(0) fNumBitVectors(0)
{ {
FromList(src); FromList(src);
} }
void hsBitVector::IGrow(UInt32 newNumBitVectors) void hsBitVector::IGrow(UInt32 newNumBitVectors)
{ {
hsAssert(newNumBitVectors > fNumBitVectors, "Growing smaller"); hsAssert(newNumBitVectors > fNumBitVectors, "Growing smaller");
UInt32 *old = fBitVectors; UInt32 *old = fBitVectors;
fBitVectors = TRACKED_NEW UInt32[newNumBitVectors]; fBitVectors = TRACKED_NEW UInt32[newNumBitVectors];
int i; int i;
for( i = 0; i < fNumBitVectors; i++ ) for( i = 0; i < fNumBitVectors; i++ )
fBitVectors[i] = old[i]; fBitVectors[i] = old[i];
for( ; i < newNumBitVectors; i++ ) for( ; i < newNumBitVectors; i++ )
fBitVectors[i] = 0; fBitVectors[i] = 0;
delete [] old; delete [] old;
fNumBitVectors = newNumBitVectors; fNumBitVectors = newNumBitVectors;
} }
hsBitVector& hsBitVector::Compact() hsBitVector& hsBitVector::Compact()
{ {
if( !fBitVectors ) if( !fBitVectors )
return *this; return *this;
if( fBitVectors[fNumBitVectors-1] ) if( fBitVectors[fNumBitVectors-1] )
return *this; return *this;
int hiVec = 0; int hiVec = 0;
for( hiVec = fNumBitVectors-1; (hiVec >= 0)&& !fBitVectors[hiVec]; --hiVec ); for( hiVec = fNumBitVectors-1; (hiVec >= 0)&& !fBitVectors[hiVec]; --hiVec );
if( hiVec >= 0 ) if( hiVec >= 0 )
{ {
UInt32 *old = fBitVectors; UInt32 *old = fBitVectors;
fBitVectors = TRACKED_NEW UInt32[++hiVec]; fBitVectors = TRACKED_NEW UInt32[++hiVec];
int i; int i;
for( i = 0; i < hiVec; i++ ) for( i = 0; i < hiVec; i++ )
fBitVectors[i] = old[i]; fBitVectors[i] = old[i];
fNumBitVectors = hiVec; fNumBitVectors = hiVec;
delete [] old; delete [] old;
} }
else else
{ {
Reset(); Reset();
} }
return *this; return *this;
} }
void hsBitVector::Read(hsStream* s) void hsBitVector::Read(hsStream* s)
{ {
Reset(); Reset();
s->LogReadSwap(&fNumBitVectors,"NumBitVectors"); s->LogReadSwap(&fNumBitVectors,"NumBitVectors");
if( fNumBitVectors ) if( fNumBitVectors )
{ {
delete [] fBitVectors; delete [] fBitVectors;
fBitVectors = TRACKED_NEW UInt32[fNumBitVectors]; fBitVectors = TRACKED_NEW UInt32[fNumBitVectors];
int i; int i;
for( i = 0; i < fNumBitVectors; i++ ) for( i = 0; i < fNumBitVectors; i++ )
s->LogReadSwap(&fBitVectors[i],"BitVector"); s->LogReadSwap(&fBitVectors[i],"BitVector");
} }
} }
void hsBitVector::Write(hsStream* s) const void hsBitVector::Write(hsStream* s) const
{ {
s->WriteSwap32(fNumBitVectors); s->WriteSwap32(fNumBitVectors);
int i; int i;
for( i = 0; i < fNumBitVectors; i++ ) for( i = 0; i < fNumBitVectors; i++ )
s->WriteSwap32(fBitVectors[i]); s->WriteSwap32(fBitVectors[i]);
} }
hsTArray<Int16>& hsBitVector::Enumerate(hsTArray<Int16>& dst) const hsTArray<Int16>& hsBitVector::Enumerate(hsTArray<Int16>& dst) const
{ {
dst.SetCount(0); dst.SetCount(0);
hsBitIterator iter(*this); hsBitIterator iter(*this);
int i = iter.Begin(); int i = iter.Begin();
while( i >= 0 ) while( i >= 0 )
{ {
dst.Append(i); dst.Append(i);
i = iter.Advance(); i = iter.Advance();
} }
return dst; return dst;
} }
hsBitVector& hsBitVector::FromList(const hsTArray<Int16>& src) hsBitVector& hsBitVector::FromList(const hsTArray<Int16>& src)
{ {
Clear(); Clear();
int i; int i;
for( i = 0; i < src.GetCount(); i++ ) for( i = 0; i < src.GetCount(); i++ )
SetBit(src[i]); SetBit(src[i]);
return *this; return *this;
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
int hsBitIterator::IAdvanceVec() int hsBitIterator::IAdvanceVec()
{ {
hsAssert((fCurrVec >= 0) && (fCurrVec < fBits.fNumBitVectors), "Invalid state to advance from"); hsAssert((fCurrVec >= 0) && (fCurrVec < fBits.fNumBitVectors), "Invalid state to advance from");
while( (++fCurrVec < fBits.fNumBitVectors) && !fBits.fBitVectors[fCurrVec] ); while( (++fCurrVec < fBits.fNumBitVectors) && !fBits.fBitVectors[fCurrVec] );
return fCurrVec < fBits.fNumBitVectors; return fCurrVec < fBits.fNumBitVectors;
} }
int hsBitIterator::IAdvanceBit() int hsBitIterator::IAdvanceBit()
{ {
do do
{ {
if( ++fCurrBit > 31 ) if( ++fCurrBit > 31 )
{ {
if( !IAdvanceVec() ) if( !IAdvanceVec() )
return false; return false;
fCurrBit = 0; fCurrBit = 0;
} }
} while( !(fBits.fBitVectors[fCurrVec] & (1 << fCurrBit)) ); } while( !(fBits.fBitVectors[fCurrVec] & (1 << fCurrBit)) );
return true; return true;
} }
int hsBitIterator::Advance() int hsBitIterator::Advance()
{ {
if( End() ) if( End() )
return -1; return -1;
if( !IAdvanceBit() ) if( !IAdvanceBit() )
return fCurrVec = -1; return fCurrVec = -1;
return fCurrent = (fCurrVec << 5) + fCurrBit; return fCurrent = (fCurrVec << 5) + fCurrBit;
} }
int hsBitIterator::Begin() int hsBitIterator::Begin()
{ {
fCurrent = -1; fCurrent = -1;
fCurrVec = -1; fCurrVec = -1;
int i; int i;
for( i = 0; i < fBits.fNumBitVectors; i++ ) for( i = 0; i < fBits.fNumBitVectors; i++ )
{ {
if( fBits.fBitVectors[i] ) if( fBits.fBitVectors[i] )
{ {
int j; int j;
for( j = 0; j < 32; j++ ) for( j = 0; j < 32; j++ )
{ {
if( fBits.fBitVectors[i] & (1 << j) ) if( fBits.fBitVectors[i] & (1 << j) )
{ {
fCurrVec = i; fCurrVec = i;
fCurrBit = j; fCurrBit = j;
return fCurrent = (fCurrVec << 5) + fCurrBit; return fCurrent = (fCurrVec << 5) + fCurrBit;
} }
} }
} }
} }
return fCurrent; return fCurrent;
} }

462
Sources/Plasma/CoreLib/hsBitVector.h
View File

@ -35,236 +35,236 @@ class hsStream;
class hsBitVector { class hsBitVector {
protected: protected:
UInt32* fBitVectors; UInt32* fBitVectors;
UInt32 fNumBitVectors; UInt32 fNumBitVectors;
void IGrow(UInt32 newNumBitVectors); void IGrow(UInt32 newNumBitVectors);
friend class hsBitIterator; friend class hsBitIterator;
public: public:
hsBitVector(const hsBitVector& other); hsBitVector(const hsBitVector& other);
hsBitVector(UInt32 which) : fBitVectors(nil), fNumBitVectors(0) { SetBit(which); } hsBitVector(UInt32 which) : fBitVectors(nil), fNumBitVectors(0) { SetBit(which); }
hsBitVector(int b, ...); // list of one or more integer bits to set. -1 (or any negative) terminates the list (e.g. hsBitVector(0,1,4,-1); hsBitVector(int b, ...); // list of one or more integer bits to set. -1 (or any negative) terminates the list (e.g. hsBitVector(0,1,4,-1);
hsBitVector(const hsTArray<Int16>& list); // sets bit for each int in list hsBitVector(const hsTArray<Int16>& list); // sets bit for each int in list
hsBitVector() : fBitVectors(nil), fNumBitVectors(0) {} hsBitVector() : fBitVectors(nil), fNumBitVectors(0) {}
virtual ~hsBitVector() { Reset(); } virtual ~hsBitVector() { Reset(); }
hsBitVector& Reset() { delete [] fBitVectors; fBitVectors = nil; fNumBitVectors = 0; return *this; } hsBitVector& Reset() { delete [] fBitVectors; fBitVectors = nil; fNumBitVectors = 0; return *this; }
hsBitVector& Clear(); // everyone clear, but no dealloc hsBitVector& Clear(); // everyone clear, but no dealloc
hsBitVector& Set(int upToBit=-1); // WARNING - see comments at function hsBitVector& Set(int upToBit=-1); // WARNING - see comments at function
int operator==(const hsBitVector& other) const; // unset (ie uninitialized) bits are clear, int operator==(const hsBitVector& other) const; // unset (ie uninitialized) bits are clear,
int operator!=(const hsBitVector& other) const { return !(*this == other); } int operator!=(const hsBitVector& other) const { return !(*this == other); }
hsBitVector& operator=(const hsBitVector& other); // will wind up identical hsBitVector& operator=(const hsBitVector& other); // will wind up identical
hsBool ClearBit(UInt32 which) { return SetBit(which, 0); } // returns previous state hsBool ClearBit(UInt32 which) { return SetBit(which, 0); } // returns previous state
hsBool SetBit(UInt32 which, hsBool on = true); // returns previous state hsBool SetBit(UInt32 which, hsBool on = true); // returns previous state
hsBool IsBitSet(UInt32 which) const; // returns current state hsBool IsBitSet(UInt32 which) const; // returns current state
hsBool ToggleBit(UInt32 which); // returns previous state hsBool ToggleBit(UInt32 which); // returns previous state
hsBitVector& RemoveBit(UInt32 which); // removes bit, sliding higher bits down to fill the gap. hsBitVector& RemoveBit(UInt32 which); // removes bit, sliding higher bits down to fill the gap.
friend inline int Overlap(const hsBitVector& lhs, const hsBitVector& rhs) { return lhs.Overlap(rhs); } friend inline int Overlap(const hsBitVector& lhs, const hsBitVector& rhs) { return lhs.Overlap(rhs); }
hsBool Overlap(const hsBitVector& other) const; hsBool Overlap(const hsBitVector& other) const;
hsBool Empty() const; hsBool Empty() const;
hsBool operator[](UInt32 which) const { return IsBitSet(which); } hsBool operator[](UInt32 which) const { return IsBitSet(which); }
friend inline hsBitVector operator&(const hsBitVector& lhs, const hsBitVector& rhs); // See Overlap() friend inline hsBitVector operator&(const hsBitVector& lhs, const hsBitVector& rhs); // See Overlap()
friend inline hsBitVector operator|(const hsBitVector& lhs, const hsBitVector& rhs); friend inline hsBitVector operator|(const hsBitVector& lhs, const hsBitVector& rhs);
friend inline hsBitVector operator^(const hsBitVector& lhs, const hsBitVector& rhs); friend inline hsBitVector operator^(const hsBitVector& lhs, const hsBitVector& rhs);
friend inline hsBitVector operator-(const hsBitVector& lhs, const hsBitVector& rhs); // return lhs w/ rhs's bits turned off friend inline hsBitVector operator-(const hsBitVector& lhs, const hsBitVector& rhs); // return lhs w/ rhs's bits turned off
hsBitVector& operator&=(const hsBitVector& other); // See Overlap() hsBitVector& operator&=(const hsBitVector& other); // See Overlap()
hsBitVector& operator|=(const hsBitVector& other); hsBitVector& operator|=(const hsBitVector& other);
hsBitVector& operator^=(const hsBitVector& other); hsBitVector& operator^=(const hsBitVector& other);
hsBitVector& operator-=(const hsBitVector& other); // return me w/ other's bits turned off hsBitVector& operator-=(const hsBitVector& other); // return me w/ other's bits turned off
hsBitVector& Compact(); hsBitVector& Compact();
hsBitVector& SetSize(UInt32 numBits) { ClearBit(numBits+1); return *this; } hsBitVector& SetSize(UInt32 numBits) { ClearBit(numBits+1); return *this; }
UInt32 GetSize() { return fNumBitVectors << 5; } UInt32 GetSize() { return fNumBitVectors << 5; }
// integer level access // integer level access
UInt32 GetNumBitVectors() const { return fNumBitVectors; } UInt32 GetNumBitVectors() const { return fNumBitVectors; }
UInt32 GetBitVector(int i) const { return fBitVectors[i]; } UInt32 GetBitVector(int i) const { return fBitVectors[i]; }
void SetNumBitVectors(UInt32 n) { Reset(); fNumBitVectors=n; fBitVectors = TRACKED_NEW UInt32[n]; } void SetNumBitVectors(UInt32 n) { Reset(); fNumBitVectors=n; fBitVectors = TRACKED_NEW UInt32[n]; }
void SetBitVector(int i, UInt32 val) { fBitVectors[i]=val; } void SetBitVector(int i, UInt32 val) { fBitVectors[i]=val; }
// Do dst.SetCount(0), then add each set bit's index into dst, returning dst. // Do dst.SetCount(0), then add each set bit's index into dst, returning dst.
hsTArray<Int16>& Enumerate(hsTArray<Int16>& dst) const; hsTArray<Int16>& Enumerate(hsTArray<Int16>& dst) const;
// this->Clear(), then set all bits listed in src, returning *this. // this->Clear(), then set all bits listed in src, returning *this.
hsBitVector& FromList(const hsTArray<Int16>& src); hsBitVector& FromList(const hsTArray<Int16>& src);
void Read(hsStream* s); void Read(hsStream* s);
void Write(hsStream* s) const; void Write(hsStream* s) const;
}; };
inline hsBitVector::hsBitVector(const hsBitVector& other) inline hsBitVector::hsBitVector(const hsBitVector& other)
{ {
if( 0 != (fNumBitVectors = other.fNumBitVectors) ) if( 0 != (fNumBitVectors = other.fNumBitVectors) )
{ {
fBitVectors = TRACKED_NEW UInt32[fNumBitVectors]; fBitVectors = TRACKED_NEW UInt32[fNumBitVectors];
int i; int i;
for( i = 0; i < fNumBitVectors; i++ ) for( i = 0; i < fNumBitVectors; i++ )
fBitVectors[i] = other.fBitVectors[i]; fBitVectors[i] = other.fBitVectors[i];
} }
else else
fBitVectors = nil; fBitVectors = nil;
} }
inline hsBool hsBitVector::Empty() const inline hsBool hsBitVector::Empty() const
{ {
int i; int i;
for( i = 0; i < fNumBitVectors; i++ ) for( i = 0; i < fNumBitVectors; i++ )
{ {
if( fBitVectors[i] ) if( fBitVectors[i] )
return false; return false;
} }
return true; return true;
} }
inline hsBool hsBitVector::Overlap(const hsBitVector& other) const inline hsBool hsBitVector::Overlap(const hsBitVector& other) const
{ {
if( fNumBitVectors > other.fNumBitVectors ) if( fNumBitVectors > other.fNumBitVectors )
return other.Overlap(*this); return other.Overlap(*this);
int i; int i;
for( i = 0; i < fNumBitVectors; i++ ) for( i = 0; i < fNumBitVectors; i++ )
{ {
if( fBitVectors[i] & other.fBitVectors[i] ) if( fBitVectors[i] & other.fBitVectors[i] )
return true; return true;
} }
return false; return false;
} }
inline hsBitVector& hsBitVector::operator=(const hsBitVector& other) inline hsBitVector& hsBitVector::operator=(const hsBitVector& other)
{ {
if( this != &other ) if( this != &other )
{ {
if( fNumBitVectors < other.fNumBitVectors ) if( fNumBitVectors < other.fNumBitVectors )
{ {
Reset(); Reset();
fNumBitVectors = other.fNumBitVectors; fNumBitVectors = other.fNumBitVectors;
fBitVectors = TRACKED_NEW UInt32[fNumBitVectors]; fBitVectors = TRACKED_NEW UInt32[fNumBitVectors];
} }
else else
{ {
Clear(); Clear();
} }
int i; int i;
for( i = 0; i < other.fNumBitVectors; i++ ) for( i = 0; i < other.fNumBitVectors; i++ )
fBitVectors[i] = other.fBitVectors[i]; fBitVectors[i] = other.fBitVectors[i];
} }
return *this; return *this;
} }
inline int hsBitVector::operator==(const hsBitVector& other) const inline int hsBitVector::operator==(const hsBitVector& other) const
{ {
if( fNumBitVectors < other.fNumBitVectors ) if( fNumBitVectors < other.fNumBitVectors )
return other.operator==(*this); return other.operator==(*this);
int i; int i;
for( i = 0; i < other.fNumBitVectors; i++ ) for( i = 0; i < other.fNumBitVectors; i++ )
if( fBitVectors[i] ^ other.fBitVectors[i] ) if( fBitVectors[i] ^ other.fBitVectors[i] )
return false; return false;
for( ; i < fNumBitVectors; i++ ) for( ; i < fNumBitVectors; i++ )
if( fBitVectors[i] ) if( fBitVectors[i] )
return false; return false;
return true; return true;
} }
inline hsBitVector& hsBitVector::operator&=(const hsBitVector& other) inline hsBitVector& hsBitVector::operator&=(const hsBitVector& other)
{ {
if( this == &other ) if( this == &other )
return *this; return *this;
if( fNumBitVectors > other.fNumBitVectors ) if( fNumBitVectors > other.fNumBitVectors )
{ {
fNumBitVectors = other.fNumBitVectors; fNumBitVectors = other.fNumBitVectors;
} }
int i; int i;
for( i = 0; i < fNumBitVectors; i++ ) for( i = 0; i < fNumBitVectors; i++ )
fBitVectors[i] &= other.fBitVectors[i]; fBitVectors[i] &= other.fBitVectors[i];
return *this; return *this;
} }
inline hsBitVector& hsBitVector::operator|=(const hsBitVector& other) inline hsBitVector& hsBitVector::operator|=(const hsBitVector& other)
{ {
if( this == &other ) if( this == &other )
return *this; return *this;
if( fNumBitVectors < other.fNumBitVectors ) if( fNumBitVectors < other.fNumBitVectors )
{ {
IGrow(other.fNumBitVectors); IGrow(other.fNumBitVectors);
} }
int i; int i;
for( i = 0; i < other.fNumBitVectors; i++ ) for( i = 0; i < other.fNumBitVectors; i++ )
fBitVectors[i] |= other.fBitVectors[i]; fBitVectors[i] |= other.fBitVectors[i];
return *this; return *this;
} }
inline hsBitVector& hsBitVector::operator^=(const hsBitVector& other) inline hsBitVector& hsBitVector::operator^=(const hsBitVector& other)
{ {
if( this == &other ) if( this == &other )
{ {
Clear(); Clear();
return *this; return *this;
} }
if( fNumBitVectors < other.fNumBitVectors ) if( fNumBitVectors < other.fNumBitVectors )
{ {
IGrow(other.fNumBitVectors); IGrow(other.fNumBitVectors);
} }
int i; int i;
for( i = 0; i < other.fNumBitVectors; i++ ) for( i = 0; i < other.fNumBitVectors; i++ )
fBitVectors[i] ^= other.fBitVectors[i]; fBitVectors[i] ^= other.fBitVectors[i];
return *this; return *this;
} }
inline hsBitVector& hsBitVector::operator-=(const hsBitVector& other) inline hsBitVector& hsBitVector::operator-=(const hsBitVector& other)
{ {
if( this == &other ) if( this == &other )
{ {
Clear(); Clear();
return *this; return *this;
} }
int minNum = fNumBitVectors < other.fNumBitVectors ? fNumBitVectors : other.fNumBitVectors; int minNum = fNumBitVectors < other.fNumBitVectors ? fNumBitVectors : other.fNumBitVectors;
int i; int i;
for( i = 0; i < minNum; i++ ) for( i = 0; i < minNum; i++ )
fBitVectors[i] &= ~other.fBitVectors[i]; fBitVectors[i] &= ~other.fBitVectors[i];
return *this; return *this;
} }
inline hsBitVector operator&(const hsBitVector& rhs, const hsBitVector& lhs) inline hsBitVector operator&(const hsBitVector& rhs, const hsBitVector& lhs)
{ {
hsBitVector ret(rhs); hsBitVector ret(rhs);
return ret &= lhs; return ret &= lhs;
} }
inline hsBitVector operator|(const hsBitVector& rhs, const hsBitVector& lhs) inline hsBitVector operator|(const hsBitVector& rhs, const hsBitVector& lhs)
{ {
hsBitVector ret(rhs); hsBitVector ret(rhs);
return ret |= lhs; return ret |= lhs;
} }
inline hsBitVector operator^(const hsBitVector& rhs, const hsBitVector& lhs) inline hsBitVector operator^(const hsBitVector& rhs, const hsBitVector& lhs)
{ {
hsBitVector ret(rhs); hsBitVector ret(rhs);
return ret ^= lhs; return ret ^= lhs;
} }
inline hsBitVector operator-(const hsBitVector& rhs, const hsBitVector& lhs) inline hsBitVector operator-(const hsBitVector& rhs, const hsBitVector& lhs)
{ {
hsBitVector ret(rhs); hsBitVector ret(rhs);
return ret -= lhs; return ret -= lhs;
} }
inline hsBitVector& hsBitVector::Clear() inline hsBitVector& hsBitVector::Clear()
{ {
int i; int i;
for( i = 0; i < fNumBitVectors; i++ ) for( i = 0; i < fNumBitVectors; i++ )
fBitVectors[i] = 0; fBitVectors[i] = 0;
return *this; return *this;
} }
// WARNING - since the bitvector is conceptually infinitely long, // WARNING - since the bitvector is conceptually infinitely long,
@ -277,117 +277,117 @@ inline hsBitVector& hsBitVector::Clear()
// the bits from 0 to upToBit, but won't clear any higher bits. // the bits from 0 to upToBit, but won't clear any higher bits.
inline hsBitVector& hsBitVector::Set(int upToBit) inline hsBitVector& hsBitVector::Set(int upToBit)
{ {
if( upToBit >= 0 ) if( upToBit >= 0 )
{ {
UInt32 major = upToBit >> 5; UInt32 major = upToBit >> 5;
UInt32 minor = 1 << (upToBit & 0x1f); UInt32 minor = 1 << (upToBit & 0x1f);
if( major >= fNumBitVectors ) if( major >= fNumBitVectors )
IGrow(major+1); IGrow(major+1);
UInt32 i; UInt32 i;
for( i = 0; i < major; i++ ) for( i = 0; i < major; i++ )
fBitVectors[i] = 0xffffffff; fBitVectors[i] = 0xffffffff;
for( i = 1; i <= minor && i > 0; i <<= 1 ) for( i = 1; i <= minor && i > 0; i <<= 1 )
fBitVectors[major] |= i; fBitVectors[major] |= i;
} }
else else
{ {
int i; int i;
for( i = 0; i < fNumBitVectors; i++ ) for( i = 0; i < fNumBitVectors; i++ )
fBitVectors[i] = 0xffffffff; fBitVectors[i] = 0xffffffff;
} }
return *this; return *this;
} }
inline hsBool hsBitVector::IsBitSet(UInt32 which) const inline hsBool hsBitVector::IsBitSet(UInt32 which) const
{ {
UInt32 major = which >> 5; UInt32 major = which >> 5;
return return
(major < fNumBitVectors) (major < fNumBitVectors)
&& (0 != (fBitVectors[major] & 1 << (which & 0x1f))); && (0 != (fBitVectors[major] & 1 << (which & 0x1f)));
} }
inline hsBool hsBitVector::SetBit(UInt32 which, hsBool on) inline hsBool hsBitVector::SetBit(UInt32 which, hsBool on)
{ {
UInt32 major = which >> 5; UInt32 major = which >> 5;
UInt32 minor = 1 << (which & 0x1f); UInt32 minor = 1 << (which & 0x1f);
if( major >= fNumBitVectors ) if( major >= fNumBitVectors )
IGrow(major+1); IGrow(major+1);
hsBool ret = 0 != (fBitVectors[major] & minor); hsBool ret = 0 != (fBitVectors[major] & minor);
if( ret != on ) if( ret != on )
{ {
if( on ) if( on )
fBitVectors[major] |= minor; fBitVectors[major] |= minor;
else else
fBitVectors[major] &= ~minor; fBitVectors[major] &= ~minor;
} }
return ret; return ret;
} }
inline hsBool hsBitVector::ToggleBit(UInt32 which) inline hsBool hsBitVector::ToggleBit(UInt32 which)
{ {
UInt32 major = which >> 5; UInt32 major = which >> 5;
UInt32 minor = 1 << (which & 0x1f); UInt32 minor = 1 << (which & 0x1f);
if( major >= fNumBitVectors ) if( major >= fNumBitVectors )
IGrow(major); IGrow(major);
hsBool ret = 0 != (fBitVectors[major] & minor); hsBool ret = 0 != (fBitVectors[major] & minor);
if( ret ) if( ret )
fBitVectors[major] &= ~minor; fBitVectors[major] &= ~minor;
else else
fBitVectors[major] |= minor; fBitVectors[major] |= minor;
return ret; return ret;
} }
inline hsBitVector& hsBitVector::RemoveBit(UInt32 which) inline hsBitVector& hsBitVector::RemoveBit(UInt32 which)
{ {
UInt32 major = which >> 5; UInt32 major = which >> 5;
if( major >= fNumBitVectors ) if( major >= fNumBitVectors )
return *this; return *this;
UInt32 minor = 1 << (which & 0x1f); UInt32 minor = 1 << (which & 0x1f);
UInt32 lowMask = minor-1; UInt32 lowMask = minor-1;
UInt32 hiMask = ~(lowMask); UInt32 hiMask = ~(lowMask);
fBitVectors[major] = (fBitVectors[major] & lowMask) fBitVectors[major] = (fBitVectors[major] & lowMask)
| ((fBitVectors[major] >> 1) & hiMask); | ((fBitVectors[major] >> 1) & hiMask);
while( major < fNumBitVectors-1 ) while( major < fNumBitVectors-1 )
{ {
if( fBitVectors[major+1] & 0x1 ) if( fBitVectors[major+1] & 0x1 )
fBitVectors[major] |= 0x80000000; fBitVectors[major] |= 0x80000000;
else else
fBitVectors[major] &= ~0x80000000; fBitVectors[major] &= ~0x80000000;
major++; major++;
fBitVectors[major] >>= 1; fBitVectors[major] >>= 1;
} }
fBitVectors[major] &= ~0x80000000; fBitVectors[major] &= ~0x80000000;
return *this; return *this;
} }
class hsBitIterator class hsBitIterator
{ {
protected: protected:
const hsBitVector& fBits; const hsBitVector& fBits;
int fCurrent; int fCurrent;
int fCurrVec; int fCurrVec;
int fCurrBit; int fCurrBit;
int IAdvanceBit(); int IAdvanceBit();
int IAdvanceVec(); int IAdvanceVec();
public: public:
// Must call begin after instanciating. // Must call begin after instanciating.
hsBitIterator(const hsBitVector& bits) : fBits(bits) {} hsBitIterator(const hsBitVector& bits) : fBits(bits) {}
int Begin(); int Begin();
int Current() const { return fCurrent; } int Current() const { return fCurrent; }
int Advance(); int Advance();
int End() const { return fCurrVec < 0; } int End() const { return fCurrVec < 0; }
}; };

4642
Sources/Plasma/CoreLib/hsBounds.cpp
View File

File diff suppressed because it is too large Load Diff

512
Sources/Plasma/CoreLib/hsBounds.h
View File

@ -41,10 +41,10 @@ class hsG3DDevice;
enum hsBoundsType enum hsBoundsType
{ {
kBoundsNormal, kBoundsNormal,
kBoundsFull, kBoundsFull,
kBoundsEmpty, kBoundsEmpty,
kBoundsUninitialized kBoundsUninitialized
}; };
// //
@ -54,25 +54,25 @@ class hsBounds3;
class hsBounds class hsBounds
{ {
protected: protected:
hsBoundsType fType; hsBoundsType fType;
public: public:
static const hsScalar kRealSmall; static const hsScalar kRealSmall;
hsBounds() : fType(kBoundsUninitialized) { }; hsBounds() : fType(kBoundsUninitialized) { };
hsBounds& MakeEmpty() { fType = kBoundsEmpty; return *this; } hsBounds& MakeEmpty() { fType = kBoundsEmpty; return *this; }
hsBounds& MakeFull() { fType = kBoundsFull; return *this; } hsBounds& MakeFull() { fType = kBoundsFull; return *this; }
hsBoundsType GetType() const { return fType; } hsBoundsType GetType() const { return fType; }
// //
// These set type to kBounds Normal // These set type to kBounds Normal
// //
virtual void Reset(const hsBounds3*) = 0; virtual void Reset(const hsBounds3*) = 0;
virtual hsBool IsInside(const hsPoint3* pos) const =0; // Only valid for kBounds Normal virtual hsBool IsInside(const hsPoint3* pos) const =0; // Only valid for kBounds Normal
virtual void Read(hsStream*); virtual void Read(hsStream*);
virtual void Write(hsStream*); virtual void Write(hsStream*);
}; };
// //
@ -83,103 +83,103 @@ struct hsMatrix44;
class hsBounds3 : public hsBounds class hsBounds3 : public hsBounds
{ {
public: public:
enum { enum {
kCenterValid = 0x1, kCenterValid = 0x1,
kIsSphere = 0x2 kIsSphere = 0x2
}; };
protected: protected:
mutable UInt32 fBounds3Flags; mutable UInt32 fBounds3Flags;
hsPoint3 fMins; hsPoint3 fMins;
hsPoint3 fMaxs; hsPoint3 fMaxs;
mutable hsPoint3 fCenter; mutable hsPoint3 fCenter;
void ICalcCenter() const; void ICalcCenter() const;
public: public:
hsBounds3() : fBounds3Flags(0) {} hsBounds3() : fBounds3Flags(0) {}
hsBounds3(const hsBounds3 &pRHS) : fBounds3Flags(0) { Reset(&pRHS); } hsBounds3(const hsBounds3 &pRHS) : fBounds3Flags(0) { Reset(&pRHS); }
hsBounds3 &operator=(const hsBounds3 &pRHS ) hsBounds3 &operator=(const hsBounds3 &pRHS )
{ if (&pRHS != this) Reset(&pRHS); return *this; } { if (&pRHS != this) Reset(&pRHS); return *this; }
// //
// These set type to kBounds Normal // These set type to kBounds Normal
// //
virtual void Reset(const hsBounds3*); virtual void Reset(const hsBounds3*);
virtual void Reset(const hsPoint3 *p); virtual void Reset(const hsPoint3 *p);
virtual void Reset(int n, const hsPoint3 *p); virtual void Reset(int n, const hsPoint3 *p);
virtual void Union(const hsPoint3 *p); virtual void Union(const hsPoint3 *p);
virtual void Union(const hsBounds3 *b); virtual void Union(const hsBounds3 *b);
virtual void Union(const hsVector3 *v); // smears the bounds in given direction virtual void Union(const hsVector3 *v); // smears the bounds in given direction
virtual void MakeSymmetric(const hsPoint3* p); // Expands bounds to be symmetric about p virtual void MakeSymmetric(const hsPoint3* p); // Expands bounds to be symmetric about p
virtual void InscribeSphere(); virtual void InscribeSphere();
virtual void Transform(const hsMatrix44*); virtual void Transform(const hsMatrix44*);
// //
// Only valid for kBounds Normal // Only valid for kBounds Normal
// //
void Draw(hsGView3* v, hsG3DDevice* d, hsScalar r, hsScalar g, hsScalar b, hsScalar a, hsBool spheric=false); void Draw(hsGView3* v, hsG3DDevice* d, hsScalar r, hsScalar g, hsScalar b, hsScalar a, hsBool spheric=false);
virtual void GetCorners(hsPoint3 *b) const; virtual void GetCorners(hsPoint3 *b) const;
const hsPoint3& GetMins() const; const hsPoint3& GetMins() const;
const hsPoint3& GetMaxs() const; const hsPoint3& GetMaxs() const;
hsScalar GetMaxDim() const; // Computes the answer hsScalar GetMaxDim() const; // Computes the answer
const hsPoint3& GetCenter() const; // Computes the answer if not already there const hsPoint3& GetCenter() const; // Computes the answer if not already there
// void MakeTriMesh(hsGTriMesh* tMesh, UInt32 triFlags, hsPoint3* cornersIn=nil) const; // void MakeTriMesh(hsGTriMesh* tMesh, UInt32 triFlags, hsPoint3* cornersIn=nil) const;
// void MakeTriMeshSphere(hsGTriMesh* tMesh, hsPoint3* cornersIn=nil) const; // void MakeTriMeshSphere(hsGTriMesh* tMesh, hsPoint3* cornersIn=nil) const;
virtual hsBool IsInside(const hsPoint3* pos) const; // ok for full/empty virtual hsBool IsInside(const hsPoint3* pos) const; // ok for full/empty
virtual void TestPlane(const hsVector3 &n, hsPoint2 &depth) const; virtual void TestPlane(const hsVector3 &n, hsPoint2 &depth) const;
virtual void TestPlane(const hsPlane3 *p, hsPoint2 &depth) const; virtual void TestPlane(const hsPlane3 *p, hsPoint2 &depth) const;
virtual hsBool ClosestPoint(const hsPoint3& p, hsPoint3& inner, hsPoint3& outer) const; virtual hsBool ClosestPoint(const hsPoint3& p, hsPoint3& inner, hsPoint3& outer) const;
// Test according to my axes only, doesn't check other's axes // Test according to my axes only, doesn't check other's axes
// neg, pos, zero == disjoint, I contain other, overlap // neg, pos, zero == disjoint, I contain other, overlap
virtual Int32 TestBound(const hsBounds3& other) const; virtual Int32 TestBound(const hsBounds3& other) const;
static hsScalar ClosestPointToLine(const hsPoint3 *p, const hsPoint3 *v0, const hsPoint3 *v1, hsPoint3 *out); static hsScalar ClosestPointToLine(const hsPoint3 *p, const hsPoint3 *v0, const hsPoint3 *v1, hsPoint3 *out);
static hsScalar ClosestPointToInfiniteLine(const hsPoint3* p, const hsVector3* v, hsPoint3* out); static hsScalar ClosestPointToInfiniteLine(const hsPoint3* p, const hsVector3* v, hsPoint3* out);
virtual void Read(hsStream*); virtual void Read(hsStream*);
virtual void Write(hsStream*); virtual void Write(hsStream*);
}; };
inline void hsBounds3::ICalcCenter() const inline void hsBounds3::ICalcCenter() const
{ {
hsAssert(kBoundsNormal == fType, "Invalid type for ICalcCenter"); hsAssert(kBoundsNormal == fType, "Invalid type for ICalcCenter");
fCenter = ((fMins + fMaxs) / 2.0); fCenter = ((fMins + fMaxs) / 2.0);
fBounds3Flags |= kCenterValid; fBounds3Flags |= kCenterValid;
} }
inline void hsBounds3::GetCorners(hsPoint3 *b) const inline void hsBounds3::GetCorners(hsPoint3 *b) const
{ {
hsAssert(kBoundsNormal == fType, "Invalid type for GetCorners"); hsAssert(kBoundsNormal == fType, "Invalid type for GetCorners");
for(int i = 0; i < 8; i++) for(int i = 0; i < 8; i++)
{ {
b[i][0] = (i & 0x1) ? fMins[0] : fMaxs[0]; b[i][0] = (i & 0x1) ? fMins[0] : fMaxs[0];
b[i][1] = (i & 0x2) ? fMins[1] : fMaxs[1]; b[i][1] = (i & 0x2) ? fMins[1] : fMaxs[1];
b[i][2] = (i & 0x4) ? fMins[2] : fMaxs[2]; b[i][2] = (i & 0x4) ? fMins[2] : fMaxs[2];
} }
} }
inline const hsPoint3& hsBounds3::GetMins() const inline const hsPoint3& hsBounds3::GetMins() const
{ {
hsAssert(kBoundsNormal == fType, "Invalid type for GetMins"); hsAssert(kBoundsNormal == fType, "Invalid type for GetMins");
return fMins; return fMins;
} }
inline const hsPoint3& hsBounds3::GetMaxs() const inline const hsPoint3& hsBounds3::GetMaxs() const
{ {
hsAssert(kBoundsNormal == fType, "Invalid type for GetMaxs"); hsAssert(kBoundsNormal == fType, "Invalid type for GetMaxs");
return fMaxs; return fMaxs;
} }
inline const hsPoint3& hsBounds3::GetCenter() const inline const hsPoint3& hsBounds3::GetCenter() const
{ {
hsAssert(kBoundsNormal == fType, "Invalid type for GetCenter"); hsAssert(kBoundsNormal == fType, "Invalid type for GetCenter");
if(!(fBounds3Flags & kCenterValid)) if(!(fBounds3Flags & kCenterValid))
ICalcCenter(); ICalcCenter();
return fCenter; return fCenter;
} }
inline hsScalar hsBounds3::GetMaxDim() const inline hsScalar hsBounds3::GetMaxDim() const
{ {
hsAssert(kBoundsNormal == fType, "Invalid type for GetMaxDim"); hsAssert(kBoundsNormal == fType, "Invalid type for GetMaxDim");
return hsMaximum(hsMaximum(fMaxs.fX-fMins.fX, fMaxs.fY-fMins.fY), fMaxs.fZ-fMins.fZ); return hsMaximum(hsMaximum(fMaxs.fX-fMins.fX, fMaxs.fY-fMins.fY), fMaxs.fZ-fMins.fZ);
} }
// //
@ -188,236 +188,236 @@ inline hsScalar hsBounds3::GetMaxDim() const
class hsBoundsOriented : public hsBounds class hsBoundsOriented : public hsBounds
{ {
private: private:
hsBool fCenterValid; hsBool fCenterValid;
hsPoint3 fCenter; hsPoint3 fCenter;
hsPlane3 *fPlanes; hsPlane3 *fPlanes;
UInt32 fNumPlanes; UInt32 fNumPlanes;
public: public:
hsBoundsOriented() : fPlanes(nil),fNumPlanes(0),fCenterValid(false) {} hsBoundsOriented() : fPlanes(nil),fNumPlanes(0),fCenterValid(false) {}
virtual ~hsBoundsOriented() { if (fPlanes) delete [] fPlanes; } virtual ~hsBoundsOriented() { if (fPlanes) delete [] fPlanes; }
// Center is not computed by the class, it must be set by the creator of the class. // Center is not computed by the class, it must be set by the creator of the class.
void SetCenter(const hsPoint3* c) { fCenter=*c; fCenterValid = true; } void SetCenter(const hsPoint3* c) { fCenter=*c; fCenterValid = true; }
void SetCenter(const hsBounds3* b) { hsBounds3 bb=*b; fCenter=bb.GetCenter(); fCenterValid = true; } void SetCenter(const hsBounds3* b) { hsBounds3 bb=*b; fCenter=bb.GetCenter(); fCenterValid = true; }
void SetCenter(const hsBoundsOriented* b) { fCenter=b->GetCenter(); fCenterValid = true; } void SetCenter(const hsBoundsOriented* b) { fCenter=b->GetCenter(); fCenterValid = true; }
hsPoint3 GetCenter() const; hsPoint3 GetCenter() const;
void SetNumberPlanes(UInt32 n); void SetNumberPlanes(UInt32 n);
hsPlane3* GetPlane(int i) { return &fPlanes[i]; } hsPlane3* GetPlane(int i) { return &fPlanes[i]; }
int GetNumPlanes() { return fNumPlanes; } int GetNumPlanes() { return fNumPlanes; }
// //
// These set type to kBounds Normal // These set type to kBounds Normal
// //
virtual void Reset(const hsBounds3*); virtual void Reset(const hsBounds3*);
void Reset(hsGTriMesh *tMesh); void Reset(hsGTriMesh *tMesh);
void SetPlane(UInt32 i, hsPlane3 *p); void SetPlane(UInt32 i, hsPlane3 *p);
// //
// Only valid for kBounds Normal // Only valid for kBounds Normal
// //
virtual hsBool IsInside(const hsPoint3* pos) const; virtual hsBool IsInside(const hsPoint3* pos) const;
virtual void TestPlane(const hsVector3 &n, hsPoint2 &depth) const; // Complain and refuse virtual void TestPlane(const hsVector3 &n, hsPoint2 &depth) const; // Complain and refuse
virtual void Write(hsStream *stream); virtual void Write(hsStream *stream);
virtual void Read(hsStream *stream); virtual void Read(hsStream *stream);
}; };
//class hsBounds3Tri; //class hsBounds3Tri;
class hsHitInfoExt; class hsHitInfoExt;
class hsBounds3Ext : public hsBounds3 { class hsBounds3Ext : public hsBounds3 {
protected: protected:
enum { enum {
kAxisAligned =0x1, kAxisAligned =0x1,
kSphereSet =0x2, kSphereSet =0x2,
kDistsSet =0x4, kDistsSet =0x4,
kAxisZeroZero =(1<<20), kAxisZeroZero =(1<<20),
kAxisOneZero =(1<<21), kAxisOneZero =(1<<21),
kAxisTwoZero =(1<<22) kAxisTwoZero =(1<<22)
}; };
mutable UInt32 fExtFlags; mutable UInt32 fExtFlags;
hsPoint3 fCorner; hsPoint3 fCorner;
hsVector3 fAxes[3]; hsVector3 fAxes[3];
mutable hsPoint2 fDists[3]; mutable hsPoint2 fDists[3];
mutable hsScalar fRadius; mutable hsScalar fRadius;
hsBool IAxisIsZero(UInt32 i) const { return (fExtFlags & (1 << (20+i))) != 0; }; hsBool IAxisIsZero(UInt32 i) const { return (fExtFlags & (1 << (20+i))) != 0; };
void IMakeSphere() const; void IMakeSphere() const;
void IMakeDists() const; void IMakeDists() const;
void IMakeMinsMaxs(); void IMakeMinsMaxs();
public: public:
hsBounds3Ext() : fExtFlags(kAxisAligned) {}; hsBounds3Ext() : fExtFlags(kAxisAligned) {};
hsBounds3Ext(const hsBounds3 &b); hsBounds3Ext(const hsBounds3 &b);
hsBounds3Ext &operator=(const hsBounds3 &b); hsBounds3Ext &operator=(const hsBounds3 &b);
hsBounds3Ext(const hsBounds3Ext &pRHS) { Reset(&pRHS); } hsBounds3Ext(const hsBounds3Ext &pRHS) { Reset(&pRHS); }
hsBounds3Ext &operator=(const hsBounds3Ext &pRHS ) hsBounds3Ext &operator=(const hsBounds3Ext &pRHS )
{ if (&pRHS != this) Reset(&pRHS); return *this; } { if (&pRHS != this) Reset(&pRHS); return *this; }
virtual void Reset(const hsBounds3Ext *b); virtual void Reset(const hsBounds3Ext *b);
virtual void Reset(const hsBounds3 *b); virtual void Reset(const hsBounds3 *b);
virtual void Reset(const hsPoint3 *p); virtual void Reset(const hsPoint3 *p);
virtual void Reset(int n, const hsPoint3 *p); virtual void Reset(int n, const hsPoint3 *p);
virtual void Union(const hsPoint3 *p); virtual void Union(const hsPoint3 *p);
virtual void Union(const hsBounds3 *b); virtual void Union(const hsBounds3 *b);
virtual void Union(const hsVector3 *v); // smears the bounds in given direction virtual void Union(const hsVector3 *v); // smears the bounds in given direction
virtual void MakeSymmetric(const hsPoint3* p); // Expands bounds to be symmetric about p virtual void MakeSymmetric(const hsPoint3* p); // Expands bounds to be symmetric about p
virtual void InscribeSphere(); virtual void InscribeSphere();
virtual void Unalign(); virtual void Unalign();
virtual void Transform(const hsMatrix44 *m); virtual void Transform(const hsMatrix44 *m);
virtual void Translate(const hsVector3 &v); virtual void Translate(const hsVector3 &v);
virtual hsScalar GetRadius() const; virtual hsScalar GetRadius() const;
virtual void GetAxes(hsVector3 *fAxis0, hsVector3 *fAxis1, hsVector3 *fAxis2) const; virtual void GetAxes(hsVector3 *fAxis0, hsVector3 *fAxis1, hsVector3 *fAxis2) const;
virtual hsPoint3 *GetCorner(hsPoint3 *c) const { *c = (fExtFlags & kAxisAligned ? fMins : fCorner); return c; } virtual hsPoint3 *GetCorner(hsPoint3 *c) const { *c = (fExtFlags & kAxisAligned ? fMins : fCorner); return c; }
virtual void GetCorners(hsPoint3 *b) const; virtual void GetCorners(hsPoint3 *b) const;
virtual hsBool ClosestPoint(const hsPoint3& p, hsPoint3& inner, hsPoint3& outer) const; virtual hsBool ClosestPoint(const hsPoint3& p, hsPoint3& inner, hsPoint3& outer) const;
virtual hsBool IsInside(const hsPoint3* pos) const; // ok for full/empty virtual hsBool IsInside(const hsPoint3* pos) const; // ok for full/empty
virtual void TestPlane(const hsVector3 &n, hsPoint2 &depth) const; virtual void TestPlane(const hsVector3 &n, hsPoint2 &depth) const;
virtual Int32 TestPoints(int n, const hsPoint3 *pList) const; // pos,neg,zero == allout, allin, cut virtual Int32 TestPoints(int n, const hsPoint3 *pList) const; // pos,neg,zero == allout, allin, cut
// Test according to my axes only, doesn't check other's axes // Test according to my axes only, doesn't check other's axes
// neg, pos, zero == disjoint, I contain other, overlap // neg, pos, zero == disjoint, I contain other, overlap
virtual Int32 TestBound(const hsBounds3Ext& other) const; virtual Int32 TestBound(const hsBounds3Ext& other) const;
virtual void TestPlane(const hsVector3 &n, const hsVector3 &myVel, hsPoint2 &depth) const; virtual void TestPlane(const hsVector3 &n, const hsVector3 &myVel, hsPoint2 &depth) const;
virtual void TestPlane(const hsPlane3 *p, const hsVector3 &myVel, hsPoint2 &depth) const; virtual void TestPlane(const hsPlane3 *p, const hsVector3 &myVel, hsPoint2 &depth) const;
virtual Int32 TestPoints(int n, const hsPoint3 *pList, const hsVector3 &ptVel) const; // pos,neg,zero == allout, allin, cut virtual Int32 TestPoints(int n, const hsPoint3 *pList, const hsVector3 &ptVel) const; // pos,neg,zero == allout, allin, cut
virtual hsBool ISectBB(const hsBounds3Ext &other, const hsVector3 &myVel) const; virtual hsBool ISectBB(const hsBounds3Ext &other, const hsVector3 &myVel) const;
virtual hsBool ISectBB(const hsBounds3Ext &other, const hsVector3 &myVel, hsHitInfoExt *hit) const; virtual hsBool ISectBB(const hsBounds3Ext &other, const hsVector3 &myVel, hsHitInfoExt *hit) const;
virtual hsBool ISectABB(const hsBounds3Ext &other, const hsVector3 &myVel) const; virtual hsBool ISectABB(const hsBounds3Ext &other, const hsVector3 &myVel) const;
virtual hsBool ISectBS(const hsBounds3Ext &other, const hsVector3 &myVel) const; virtual hsBool ISectBS(const hsBounds3Ext &other, const hsVector3 &myVel) const;
#if 0 // Commenting out this which will be made redundant and/or obsolete by Havok integration #if 0 // Commenting out this which will be made redundant and/or obsolete by Havok integration
virtual hsBool ISectTriABB(hsBounds3Tri &tri, const hsVector3 &myVel) const; virtual hsBool ISectTriABB(hsBounds3Tri &tri, const hsVector3 &myVel) const;
virtual hsBool ISectTriBB(hsBounds3Tri &tri, const hsVector3 &myVel) const; virtual hsBool ISectTriBB(hsBounds3Tri &tri, const hsVector3 &myVel) const;
virtual hsBool ISectTriBB(hsBounds3Tri &tri, const hsVector3 &myVel, hsHitInfoExt *hit) const; virtual hsBool ISectTriBB(hsBounds3Tri &tri, const hsVector3 &myVel, hsHitInfoExt *hit) const;
virtual hsBool TriBSHitInfo(hsBounds3Tri& tri, const hsVector3& myVel, hsHitInfoExt* hit) const; virtual hsBool TriBSHitInfo(hsBounds3Tri& tri, const hsVector3& myVel, hsHitInfoExt* hit) const;
virtual hsBool TriBBHitInfo(hsBounds3Tri& tri, const hsVector3& myVel, hsHitInfoExt* hit) const; virtual hsBool TriBBHitInfo(hsBounds3Tri& tri, const hsVector3& myVel, hsHitInfoExt* hit) const;
#endif // Commenting out this which will be made redundant and/or obsolete by Havok integration #endif // Commenting out this which will be made redundant and/or obsolete by Havok integration
virtual Int32 IClosestISect(const hsBounds3Ext& other, const hsVector3& myVel, virtual Int32 IClosestISect(const hsBounds3Ext& other, const hsVector3& myVel,
hsScalar* tClose, hsScalar* tImpact) const; hsScalar* tClose, hsScalar* tImpact) const;
#if 0 // Commenting out this which will be made redundant and/or obsolete by Havok integration #if 0 // Commenting out this which will be made redundant and/or obsolete by Havok integration
virtual hsBool ISectTriBS(hsBounds3Tri &tri, const hsVector3 &myVel) const; virtual hsBool ISectTriBS(hsBounds3Tri &tri, const hsVector3 &myVel) const;
virtual hsBool ISectTriBS(hsBounds3Tri &tri, const hsVector3 &myVel, hsHitInfoExt *hit) const; virtual hsBool ISectTriBS(hsBounds3Tri &tri, const hsVector3 &myVel, hsHitInfoExt *hit) const;
#endif // Commenting out this which will be made redundant and/or obsolete by Havok integration #endif // Commenting out this which will be made redundant and/or obsolete by Havok integration
virtual hsBool ISectBoxBS(const hsBounds3Ext &other, const hsVector3 &myVel, hsHitInfoExt *hit) const; virtual hsBool ISectBoxBS(const hsBounds3Ext &other, const hsVector3 &myVel, hsHitInfoExt *hit) const;
virtual hsBool ISectBSBox(const hsBounds3Ext &other, const hsVector3 &myVel, hsHitInfoExt *hit) const; virtual hsBool ISectBSBox(const hsBounds3Ext &other, const hsVector3 &myVel, hsHitInfoExt *hit) const;
virtual hsBool ISectBoxBS(const hsBounds3Ext &other, const hsVector3 &myVel) const; virtual hsBool ISectBoxBS(const hsBounds3Ext &other, const hsVector3 &myVel) const;
virtual hsBool ISectBSBS(const hsBounds3Ext &other, const hsVector3 &myVel, hsHitInfoExt *hit) const; virtual hsBool ISectBSBS(const hsBounds3Ext &other, const hsVector3 &myVel, hsHitInfoExt *hit) const;
virtual hsBool ISectLine(const hsPoint3* from, const hsPoint3* to) const; virtual hsBool ISectLine(const hsPoint3* from, const hsPoint3* to) const;
virtual hsBool ISectCone(const hsPoint3* from, const hsPoint3* to, hsScalar radius) const; virtual hsBool ISectCone(const hsPoint3* from, const hsPoint3* to, hsScalar radius) const;
virtual hsBool ISectRayBS(const hsPoint3& from, const hsPoint3& to, hsPoint3& at) const; virtual hsBool ISectRayBS(const hsPoint3& from, const hsPoint3& to, hsPoint3& at) const;
virtual void Read(hsStream *s); virtual void Read(hsStream *s);
virtual void Write(hsStream *s); virtual void Write(hsStream *s);
}; };
inline hsScalar hsBounds3Ext::GetRadius() const inline hsScalar hsBounds3Ext::GetRadius() const
{ {
if( !(fExtFlags & kSphereSet) ) if( !(fExtFlags & kSphereSet) )
IMakeSphere(); IMakeSphere();
return fRadius; return fRadius;
} }
#if 0 // Commenting out this which will be made redundant and/or obsolete by Havok integration #if 0 // Commenting out this which will be made redundant and/or obsolete by Havok integration
class hsBounds3Tri { class hsBounds3Tri {
protected: protected:
enum { enum {
kOnEdge0 = (1 << 0), kOnEdge0 = (1 << 0),
kOnEdge1 = (1 << 1), kOnEdge1 = (1 << 1),
kOnEdge2 = (1 << 2), kOnEdge2 = (1 << 2),
kOnTriPlane = (1 << 3) kOnTriPlane = (1 << 3)
}; };
public: public:
enum { enum {
kAxesSet = 0x1, kAxesSet = 0x1,
kDoubleSide = 0x2 kDoubleSide = 0x2
}; };
hsVector3 fNormal; hsVector3 fNormal;
// hsVector3 fNormal; // hsVector3 fNormal;
hsScalar fDist; hsScalar fDist;
hsPoint3 fVerts[3]; hsPoint3 fVerts[3];
// hsVector3 fPerpAxes[3]; // hsVector3 fPerpAxes[3];
mutable UInt32 fTriFlags; mutable UInt32 fTriFlags;
mutable hsVector3 fPerpAxes[3]; mutable hsVector3 fPerpAxes[3];
mutable hsPoint2 fPerpDists[3]; mutable hsPoint2 fPerpDists[3];
mutable UInt32 fOnIsMax; mutable UInt32 fOnIsMax;
hsTriangle3* fTriangle; hsTriangle3* fTriangle;
void TestPlane(const hsVector3 &n, hsPoint2 &depth) const; void TestPlane(const hsVector3 &n, hsPoint2 &depth) const;
hsBool PointOutsideTriPlane(const hsPoint3 *p) const { return fNormal.InnerProduct(p) > fDist; }; hsBool PointOutsideTriPlane(const hsPoint3 *p) const { return fNormal.InnerProduct(p) > fDist; };
hsBool ClosestTriPoint(const hsPoint3 *p, hsPoint3 *out, const hsVector3 *ax=nil) const; // sets out, true if out = p + t*fNormal hsBool ClosestTriPoint(const hsPoint3 *p, hsPoint3 *out, const hsVector3 *ax=nil) const; // sets out, true if out = p + t*fNormal
hsBool ISectCone(const hsPoint3& from, const hsPoint3& to, hsScalar cosThetaSq, hsBool32 ignoreBackFacing, hsPoint3& at, hsBool32& backSide) const; hsBool ISectCone(const hsPoint3& from, const hsPoint3& to, hsScalar cosThetaSq, hsBool32 ignoreBackFacing, hsPoint3& at, hsBool32& backSide) const;
void SetAxes() const; void SetAxes() const;
hsBounds3Tri* Transform(const hsMatrix44& x); hsBounds3Tri* Transform(const hsMatrix44& x);
hsBounds3Tri* Translate(const hsVector3& v); hsBounds3Tri* Translate(const hsVector3& v);
void Set(const hsPoint3& v0, void Set(const hsPoint3& v0,
const hsPoint3& v1, const hsPoint3& v1,
const hsPoint3& v2, const hsPoint3& v2,
hsTriangle3* t, hsTriangle3* t,
const hsMatrix44& x); const hsMatrix44& x);
hsBounds3Tri(const hsPoint3& v0, hsBounds3Tri(const hsPoint3& v0,
const hsPoint3& v1, const hsPoint3& v1,
const hsPoint3& v2, const hsPoint3& v2,
hsTriangle3* t, hsTriangle3* t,
const hsMatrix44& x); const hsMatrix44& x);
hsBounds3Tri(hsTriangle3* t, hsBounds3Tri(hsTriangle3* t,
const hsMatrix44& x); const hsMatrix44& x);
void Set(hsPoint3 *v0, void Set(hsPoint3 *v0,
hsPoint3 *v1, hsPoint3 *v1,
hsPoint3 *v2, hsPoint3 *v2,
hsVector3 *n, hsVector3 *n,
UInt32 triFlags, UInt32 triFlags,
hsTriangle3 *t=nil); hsTriangle3 *t=nil);
hsBounds3Tri(hsPoint3 *v0, hsBounds3Tri(hsPoint3 *v0,
hsPoint3 *v1, hsPoint3 *v1,
hsPoint3 *v2, hsPoint3 *v2,
hsVector3 *n, hsVector3 *n,
UInt32 triFlags, UInt32 triFlags,
hsTriangle3 *t=nil); hsTriangle3 *t=nil);
hsBounds3Tri(hsTriangle3* t); hsBounds3Tri(hsTriangle3* t);
hsBounds3Tri() {} hsBounds3Tri() {}
~hsBounds3Tri(); ~hsBounds3Tri();
friend class hsBounds3Ext; friend class hsBounds3Ext;
} ATTRIBUTE_FOR_PS2; /* SUNSOFT */ } ATTRIBUTE_FOR_PS2; /* SUNSOFT */
#endif // Commenting out this which will be made redundant and/or obsolete by Havok integration #endif // Commenting out this which will be made redundant and/or obsolete by Havok integration
class hsHitInfoExt { class hsHitInfoExt {
public: public:
hsScalar fDepth; hsScalar fDepth;
hsVector3 fNormal; hsVector3 fNormal;
hsVector3 fDelPos; hsVector3 fDelPos;
#if 0 // Commenting out this which will be made redundant and/or obsolete by Havok integration #if 0 // Commenting out this which will be made redundant and/or obsolete by Havok integration
const hsBounds3Tri* fTriBnd; const hsBounds3Tri* fTriBnd;
#endif // Commenting out this which will be made redundant and/or obsolete by Havok integration #endif // Commenting out this which will be made redundant and/or obsolete by Havok integration
const hsBounds3Ext* fBoxBnd; const hsBounds3Ext* fBoxBnd;
const hsBounds3Ext* fOtherBoxBnd; const hsBounds3Ext* fOtherBoxBnd;
const hsPoint3* fRootCenter; const hsPoint3* fRootCenter;
hsHitInfoExt(const hsPoint3 *ctr, const hsVector3& offset) { fRootCenter=ctr; fDelPos=offset; }; hsHitInfoExt(const hsPoint3 *ctr, const hsVector3& offset) { fRootCenter=ctr; fDelPos=offset; };
#if 0 // Commenting out this which will be made redundant and/or obsolete by Havok integration #if 0 // Commenting out this which will be made redundant and/or obsolete by Havok integration
void Set(const hsBounds3Ext *m, const hsBounds3Tri *t, const hsVector3* n, hsScalar d) void Set(const hsBounds3Ext *m, const hsBounds3Tri *t, const hsVector3* n, hsScalar d)
{ fDepth = d; fTriBnd = t; fBoxBnd = m; fNormal = *n; fOtherBoxBnd = nil; } { fDepth = d; fTriBnd = t; fBoxBnd = m; fNormal = *n; fOtherBoxBnd = nil; }
void Set(const hsBounds3Ext *m, const hsBounds3Ext *o, const hsVector3 &norm, hsScalar d) void Set(const hsBounds3Ext *m, const hsBounds3Ext *o, const hsVector3 &norm, hsScalar d)
{ fDepth = d; fBoxBnd = m, fOtherBoxBnd = o; fNormal = norm; fTriBnd = nil; } { fDepth = d; fBoxBnd = m, fOtherBoxBnd = o; fNormal = norm; fTriBnd = nil; }
#else // Commenting out this which will be made redundant and/or obsolete by Havok integration #else // Commenting out this which will be made redundant and/or obsolete by Havok integration
void Set(const hsBounds3Ext *m, const hsVector3* n, hsScalar d) void Set(const hsBounds3Ext *m, const hsVector3* n, hsScalar d)
{ fDepth = d; fBoxBnd = m; fNormal = *n; fOtherBoxBnd = nil; } { fDepth = d; fBoxBnd = m; fNormal = *n; fOtherBoxBnd = nil; }
void Set(const hsBounds3Ext *m, const hsBounds3Ext *o, const hsVector3 &norm, hsScalar d) void Set(const hsBounds3Ext *m, const hsBounds3Ext *o, const hsVector3 &norm, hsScalar d)
{ fDepth = d; fBoxBnd = m, fOtherBoxBnd = o; fNormal = norm; } { fDepth = d; fBoxBnd = m, fOtherBoxBnd = o; fNormal = norm; }
#endif // Commenting out this which will be made redundant and/or obsolete by Havok integration #endif // Commenting out this which will be made redundant and/or obsolete by Havok integration
}; };
#endif // hsBounds_inc #endif // hsBounds_inc

148
Sources/Plasma/CoreLib/hsColorRGBA.h
View File

@ -31,140 +31,140 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsStream.h" #include "hsStream.h"
struct hsColorRGBA { struct hsColorRGBA {
hsScalar r,g,b,a; hsScalar r,g,b,a;
hsRGBAColor32 ToRGBA32() const; hsRGBAColor32 ToRGBA32() const;
hsColorRGBA& Set(hsScalar red, hsScalar grn, hsScalar blu, hsScalar alp) { r = red; g = grn; b = blu; a = alp; return *this; } hsColorRGBA& Set(hsScalar red, hsScalar grn, hsScalar blu, hsScalar alp) { r = red; g = grn; b = blu; a = alp; return *this; }
hsBool operator==(const hsColorRGBA&c) const { return (r==c.r)&&(g==c.g)&&(b==c.b)&&(a==c.a); } hsBool operator==(const hsColorRGBA&c) const { return (r==c.r)&&(g==c.g)&&(b==c.b)&&(a==c.a); }
hsBool operator!=(const hsColorRGBA&c) const { return !(c == *this); } hsBool operator!=(const hsColorRGBA&c) const { return !(c == *this); }
friend inline hsColorRGBA operator+(const hsColorRGBA& s, const hsColorRGBA& t); friend inline hsColorRGBA operator+(const hsColorRGBA& s, const hsColorRGBA& t);
hsColorRGBA& operator+=(const hsColorRGBA& s); hsColorRGBA& operator+=(const hsColorRGBA& s);
friend inline hsColorRGBA operator*(const hsColorRGBA& s, const hsColorRGBA& t); friend inline hsColorRGBA operator*(const hsColorRGBA& s, const hsColorRGBA& t);
hsColorRGBA& operator*=(const hsColorRGBA& s); hsColorRGBA& operator*=(const hsColorRGBA& s);
friend inline hsColorRGBA operator-(const hsColorRGBA& s, const hsColorRGBA& t); friend inline hsColorRGBA operator-(const hsColorRGBA& s, const hsColorRGBA& t);
hsColorRGBA& operator-=(const hsColorRGBA& s); hsColorRGBA& operator-=(const hsColorRGBA& s);
friend inline hsColorRGBA operator*(const hsColorRGBA& c, const hsScalar s); friend inline hsColorRGBA operator*(const hsColorRGBA& c, const hsScalar s);
friend inline hsColorRGBA operator*(const hsScalar s, const hsColorRGBA& c); friend inline hsColorRGBA operator*(const hsScalar s, const hsColorRGBA& c);
hsColorRGBA& operator*=(const hsScalar s); hsColorRGBA& operator*=(const hsScalar s);
hsColorRGBA& FromARGB32(UInt32 c); hsColorRGBA& FromARGB32(UInt32 c);
UInt32 ToARGB32() const; UInt32 ToARGB32() const;
void Read(hsStream *stream); void Read(hsStream *stream);
void Write(hsStream *stream) const; void Write(hsStream *stream) const;
}; };
inline void hsColorRGBA::Read(hsStream *s) inline void hsColorRGBA::Read(hsStream *s)
{ {
r = s->ReadSwapScalar(); r = s->ReadSwapScalar();
g = s->ReadSwapScalar(); g = s->ReadSwapScalar();
b = s->ReadSwapScalar(); b = s->ReadSwapScalar();
a = s->ReadSwapScalar(); a = s->ReadSwapScalar();
} }
inline void hsColorRGBA::Write(hsStream *s) const inline void hsColorRGBA::Write(hsStream *s) const
{ {
s->WriteSwapScalar(r); s->WriteSwapScalar(r);
s->WriteSwapScalar(g); s->WriteSwapScalar(g);
s->WriteSwapScalar(b); s->WriteSwapScalar(b);
s->WriteSwapScalar(a); s->WriteSwapScalar(a);
} }
inline hsColorRGBA& hsColorRGBA::FromARGB32(UInt32 c) inline hsColorRGBA& hsColorRGBA::FromARGB32(UInt32 c)
{ {
const hsScalar oo255 = 1.f / 255.f; const hsScalar oo255 = 1.f / 255.f;
a = hsScalar((c >> 24) & 0xff) * oo255; a = hsScalar((c >> 24) & 0xff) * oo255;
r = hsScalar((c >> 16) & 0xff) * oo255; r = hsScalar((c >> 16) & 0xff) * oo255;
g = hsScalar((c >> 8) & 0xff) * oo255; g = hsScalar((c >> 8) & 0xff) * oo255;
b = hsScalar((c >> 0) & 0xff) * oo255; b = hsScalar((c >> 0) & 0xff) * oo255;
return *this; return *this;
} }
inline UInt32 hsColorRGBA::ToARGB32() const inline UInt32 hsColorRGBA::ToARGB32() const
{ {
return (UInt32(a * 255.99f) << 24) return (UInt32(a * 255.99f) << 24)
| (UInt32(r * 255.99f) << 16) | (UInt32(r * 255.99f) << 16)
| (UInt32(g * 255.99f) << 8) | (UInt32(g * 255.99f) << 8)
| (UInt32(b * 255.99f) << 0); | (UInt32(b * 255.99f) << 0);
} }
inline hsColorRGBA operator+(const hsColorRGBA& s, const hsColorRGBA& t) inline hsColorRGBA operator+(const hsColorRGBA& s, const hsColorRGBA& t)
{ {
hsColorRGBA res; hsColorRGBA res;
return res.Set(s.r + t.r, s.g + t.g, s.b + t.b, s.a + t.a); return res.Set(s.r + t.r, s.g + t.g, s.b + t.b, s.a + t.a);
} }
inline hsColorRGBA& hsColorRGBA::operator+=(const hsColorRGBA& s) inline hsColorRGBA& hsColorRGBA::operator+=(const hsColorRGBA& s)
{ {
r += s.r; r += s.r;
g += s.g; g += s.g;
b += s.b; b += s.b;
a += s.a; a += s.a;
return *this; return *this;
} }
inline hsColorRGBA operator*(const hsColorRGBA& s, const hsColorRGBA& t) inline hsColorRGBA operator*(const hsColorRGBA& s, const hsColorRGBA& t)
{ {
hsColorRGBA res; hsColorRGBA res;
return res.Set(s.r * t.r, s.g * t.g, s.b * t.b, s.a * t.a); return res.Set(s.r * t.r, s.g * t.g, s.b * t.b, s.a * t.a);
} }
inline hsColorRGBA& hsColorRGBA::operator*=(const hsColorRGBA& s) inline hsColorRGBA& hsColorRGBA::operator*=(const hsColorRGBA& s)
{ {
r *= s.r; r *= s.r;
g *= s.g; g *= s.g;
b *= s.b; b *= s.b;
a *= s.a; a *= s.a;
return *this; return *this;
} }
inline hsColorRGBA operator-(const hsColorRGBA& s, const hsColorRGBA& t) inline hsColorRGBA operator-(const hsColorRGBA& s, const hsColorRGBA& t)
{ {
hsColorRGBA res; hsColorRGBA res;
return res.Set(s.r - t.r, s.g - t.g, s.b - t.b, s.a - t.a); return res.Set(s.r - t.r, s.g - t.g, s.b - t.b, s.a - t.a);
} }
inline hsColorRGBA& hsColorRGBA::operator-=(const hsColorRGBA& s) inline hsColorRGBA& hsColorRGBA::operator-=(const hsColorRGBA& s)
{ {
r -= s.r; r -= s.r;
g -= s.g; g -= s.g;
b -= s.b; b -= s.b;
a -= s.a; a -= s.a;
return *this; return *this;
} }
inline hsColorRGBA operator*(const hsColorRGBA& t, const hsScalar s) inline hsColorRGBA operator*(const hsColorRGBA& t, const hsScalar s)
{ {
hsColorRGBA res; hsColorRGBA res;
return res.Set(s * t.r, s * t.g, s * t.b, s * t.a); return res.Set(s * t.r, s * t.g, s * t.b, s * t.a);
} }
inline hsColorRGBA operator*(const hsScalar s, const hsColorRGBA&t) inline hsColorRGBA operator*(const hsScalar s, const hsColorRGBA&t)
{ {
return t * s; return t * s;
} }
inline hsColorRGBA& hsColorRGBA::operator*=(const hsScalar s) inline hsColorRGBA& hsColorRGBA::operator*=(const hsScalar s)
{ {
r *= s; r *= s;
g *= s; g *= s;
b *= s; b *= s;
a *= s; a *= s;
return *this; return *this;
} }
class hsColorOverride class hsColorOverride
{ {
public: public:
enum { enum {
kNone, kNone,
kModColor, kModColor,
kModAlpha, kModAlpha,
kModShade kModShade
}; };
hsColorRGBA fShade; hsColorRGBA fShade;
hsColorRGBA fColor; hsColorRGBA fColor;
hsBool fFlags; hsBool fFlags;
}; };

74
Sources/Plasma/CoreLib/hsConfig.h
View File

@ -35,22 +35,22 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#ifdef BUILDPS2 #ifdef BUILDPS2
#define HS_BUILD_FOR_PS2 1 #define HS_BUILD_FOR_PS2 1
#define PLASMA_NO_NETWORK 1 #define PLASMA_NO_NETWORK 1
#define PLASMA_NO_KEYBOARD 1 #define PLASMA_NO_KEYBOARD 1
#define PLASMA_NO_GLIDE 1 #define PLASMA_NO_GLIDE 1
#define PLASMA_NO_DDRAW 1 #define PLASMA_NO_DDRAW 1
#define HS_BUILD_PLASMA 1 #define HS_BUILD_PLASMA 1
#define NEXUS_NO_2D 1 #define NEXUS_NO_2D 1
#endif #endif
//////////////////// Change the 1s and 0s ////////////////////// //////////////////// Change the 1s and 0s //////////////////////
#define HS_CAN_USE_FLOAT 1 #define HS_CAN_USE_FLOAT 1
#define HS_SCALAR_IS_FLOAT 1 #define HS_SCALAR_IS_FLOAT 1
#define HS_PIN_MATH_OVERFLOW 0 // This forces hsWide versions of FixMath routines #define HS_PIN_MATH_OVERFLOW 0 // This forces hsWide versions of FixMath routines
#define HS_DEBUG_MATH_OVERFLOW 0 // This calls hsDebugMessage on k[Pos,Neg]Infinity #define HS_DEBUG_MATH_OVERFLOW 0 // This calls hsDebugMessage on k[Pos,Neg]Infinity
@ -62,8 +62,8 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#ifdef HS_BUILD_PLASMA #ifdef HS_BUILD_PLASMA
#define HS_IGNORE_T2K 1 #define HS_IGNORE_T2K 1
#define HS_SUPPORT_NFNT_FONTS 1 #define HS_SUPPORT_NFNT_FONTS 1
#endif // HS_BUILD_PLASMA #endif // HS_BUILD_PLASMA
@ -72,40 +72,40 @@ 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(macintosh) && defined(__POWERPC__)
#define HS_BUILD_FOR_MACPPC 1 #define HS_BUILD_FOR_MACPPC 1
#define HS_CPU_BENDIAN 1 #define HS_CPU_BENDIAN 1
#elif defined(macintosh) #elif defined(macintosh)
#define HS_BUILD_FOR_MAC68K 1 #define HS_BUILD_FOR_MAC68K 1
#elif defined(_M_IX86) && defined(_WIN32) #elif defined(_M_IX86) && defined(_WIN32)
#define HS_BUILD_FOR_WIN32 1 #define HS_BUILD_FOR_WIN32 1
#define HS_CPU_LENDIAN 1 #define HS_CPU_LENDIAN 1
#elif defined(__unix__) #elif defined(__unix__)
#define HS_BUILD_FOR_UNIX 1 #define HS_BUILD_FOR_UNIX 1
#if defined(__intel__) || defined(__i386__) #if defined(__intel__) || defined(__i386__)
#define HS_CPU_LENDIAN 1 #define HS_CPU_LENDIAN 1
#elif defined(__mips__) #elif defined(__mips__)
#define HS_CPU_BENDIAN 1 #define HS_CPU_BENDIAN 1
#endif #endif
#elif !HS_BUILD_FOR_PS2 #elif !HS_BUILD_FOR_PS2
#define HS_BUILD_FOR_REFERENCE 1 #define HS_BUILD_FOR_REFERENCE 1
#endif #endif
#if defined(HS_BUILD_FOR_MAC68K) || defined(HS_BUILD_FOR_MACPPC) #if defined(HS_BUILD_FOR_MAC68K) || defined(HS_BUILD_FOR_MACPPC)
#define HS_BUILD_FOR_MAC 1 #define HS_BUILD_FOR_MAC 1
#endif #endif
#if defined(__INTEL__) && defined(HS_BUILD_FOR_MAC) #if defined(__INTEL__) && defined(HS_BUILD_FOR_MAC)
#error "Can't have HS_BUILD_FOR_MAC defined" #error "Can't have HS_BUILD_FOR_MAC defined"
#endif #endif
#if (defined(GENERATING68K) || defined(GENERATINGPOWERPC)) && defined(HS_BUILD_FOR_WIN32) #if (defined(GENERATING68K) || defined(GENERATINGPOWERPC)) && defined(HS_BUILD_FOR_WIN32)
#define "Can't define HS_BUILD_FOR_WIN32" #define "Can't define HS_BUILD_FOR_WIN32"
#endif #endif
#define HS_SCALAR_IS_FIXED !(HS_SCALAR_IS_FLOAT) #define HS_SCALAR_IS_FIXED !(HS_SCALAR_IS_FLOAT)
#define HS_NEVER_USE_FLOAT !(HS_CAN_USE_FLOAT) #define HS_NEVER_USE_FLOAT !(HS_CAN_USE_FLOAT)
#if HS_DEBUG_MATH_OVERFLOW && !(HS_PIN_MATH_OVERFLOW) #if HS_DEBUG_MATH_OVERFLOW && !(HS_PIN_MATH_OVERFLOW)
#error "Can't debug overflow unless HS_PIN_MATH_OVERFLOW is ON" #error "Can't debug overflow unless HS_PIN_MATH_OVERFLOW is ON"
#endif #endif
@ -144,7 +144,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#if HS_BUILD_FOR_PS2 #if HS_BUILD_FOR_PS2
#define ATTRIBUTE_FOR_PS2 __attribute__((aligned (16))) /* SUNSOFT */ #define ATTRIBUTE_FOR_PS2 __attribute__((aligned (16))) /* SUNSOFT */
#else #else
#define ATTRIBUTE_FOR_PS2 #define ATTRIBUTE_FOR_PS2
#endif #endif
@ -153,11 +153,11 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
/////////////////////Myst3D Defines ///////////////////////////////////// /////////////////////Myst3D Defines /////////////////////////////////////
#ifdef M3DRELEASE #ifdef M3DRELEASE
#define PLASMA_NO_NETWORK 1 #define PLASMA_NO_NETWORK 1
#define NEXUS_NO_2D 1 #define NEXUS_NO_2D 1
#define NO_LOAD_MSG 1 #define NO_LOAD_MSG 1
#define PLASMA_NO_CONSOLE 1 #define PLASMA_NO_CONSOLE 1
#define NEXUS_NO_DEBUG 1 #define NEXUS_NO_DEBUG 1
#endif #endif

4
Sources/Plasma/CoreLib/hsExceptionStack.cpp
View File

@ -30,6 +30,6 @@ hsExceptionStackDestroyer hsExceptionStack::fExceptionStackDestroyer;
void hsExceptionStack::FreeInstance() void hsExceptionStack::FreeInstance()
{ {
delete fExceptionStack; delete fExceptionStack;
fExceptionStack = nil; fExceptionStack = nil;
} }

52
Sources/Plasma/CoreLib/hsExceptionStack.h
View File

@ -38,45 +38,45 @@ class hsExceptionStackDestroyer;
class hsExceptionStack class hsExceptionStack
{ {
friend class hsExceptionStackDestroyer; friend class hsExceptionStackDestroyer;
private: private:
hsExceptionStack() { } hsExceptionStack() { }
public: public:
~hsExceptionStack() { } ~hsExceptionStack() { }
static hsExceptionStack& Instance(); static hsExceptionStack& Instance();
Int32 GetNumEntries() const { return fEntries.Count(); } Int32 GetNumEntries() const { return fEntries.Count(); }
const char* GetEntry(Int32 i) const { return fEntries[i]; } const char* GetEntry(Int32 i) const { return fEntries[i]; }
void Push(const char* str); void Push(const char* str);
// After an exception is caught and stack has been displayed, // After an exception is caught and stack has been displayed,
// call continue to flush stack // call continue to flush stack
void Continue() { fEntries.Reset(); } void Continue() { fEntries.Reset(); }
private: private:
static void FreeInstance(); static void FreeInstance();
hsTArray<const char*> fEntries; hsTArray<const char*> fEntries;
static hsExceptionStack* fExceptionStack; static hsExceptionStack* fExceptionStack;
static hsExceptionStackDestroyer fExceptionStackDestroyer; static hsExceptionStackDestroyer fExceptionStackDestroyer;
}; };
inline hsExceptionStack& hsExceptionStack::Instance() inline hsExceptionStack& hsExceptionStack::Instance()
{ {
if (!fExceptionStack) if (!fExceptionStack)
{ {
fExceptionStack = TRACKED_NEW hsExceptionStack; fExceptionStack = TRACKED_NEW hsExceptionStack;
} }
return *fExceptionStack; return *fExceptionStack;
} }
inline void hsExceptionStack::Push(const char* str) inline void hsExceptionStack::Push(const char* str)
{ {
fEntries.Append(str); fEntries.Append(str);
} }
// //
@ -85,10 +85,10 @@ inline void hsExceptionStack::Push(const char* str)
class hsExceptionStackDestroyer class hsExceptionStackDestroyer
{ {
public: public:
~hsExceptionStackDestroyer() ~hsExceptionStackDestroyer()
{ {
hsExceptionStack::FreeInstance(); hsExceptionStack::FreeInstance();
} }
}; };
#ifdef HS_DEBUGGING #ifdef HS_DEBUGGING
@ -102,8 +102,8 @@ public:
#else // HS_NO_TRY #else // HS_NO_TRY
#define hsGuardBegin(X) { const char* guardToken = X; try { #define hsGuardBegin(X) { const char* guardToken = X; try {
#define hsGuardEnd } catch(...) { hsExceptionStack::Instance().Push(guardToken); throw; } } #define hsGuardEnd } catch(...) { hsExceptionStack::Instance().Push(guardToken); throw; } }
#endif // HS_NO_TRY #endif // HS_NO_TRY

112
Sources/Plasma/CoreLib/hsExceptions.h
View File

@ -34,47 +34,47 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
enum hsErrorEnum { enum hsErrorEnum {
kNo_hsError, kNo_hsError,
kBadAlloc_hsError, kBadAlloc_hsError,
kNilParam_hsError, kNilParam_hsError,
kBadParam_hsError, kBadParam_hsError,
kInternal_hsError, kInternal_hsError,
kOS_hsError kOS_hsError
}; };
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
class hsException { class hsException {
public: public:
hsErrorEnum fError; hsErrorEnum fError;
long fParam; long fParam;
hsException(hsErrorEnum error, long param = 0) : fError(error), fParam(param) {} hsException(hsErrorEnum error, long param = 0) : fError(error), fParam(param) {}
}; };
class hsBadAllocException : public hsException { class hsBadAllocException : public hsException {
public: public:
hsBadAllocException() : hsException(kBadAlloc_hsError) {} hsBadAllocException() : hsException(kBadAlloc_hsError) {}
}; };
class hsNilParamException : public hsException { class hsNilParamException : public hsException {
public: public:
hsNilParamException() : hsException(kNilParam_hsError) {} hsNilParamException() : hsException(kNilParam_hsError) {}
}; };
class hsBadParamException : public hsException { class hsBadParamException : public hsException {
public: public:
hsBadParamException() : hsException(kBadParam_hsError) {} hsBadParamException() : hsException(kBadParam_hsError) {}
}; };
class hsInternalException : public hsException { class hsInternalException : public hsException {
public: public:
hsInternalException() : hsException(kInternal_hsError) {} hsInternalException() : hsException(kInternal_hsError) {}
}; };
class hsOSException : public hsException { class hsOSException : public hsException {
public: public:
hsOSException(long error) : hsException(kOS_hsError, error) {} hsOSException(long error) : hsException(kOS_hsError, error) {}
}; };
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
@ -88,65 +88,65 @@ public:
inline void hsThrowIfNilParam(const void* p) inline void hsThrowIfNilParam(const void* p)
{ {
if (p == nil) if (p == nil)
{ {
hsAssert(0,"hsNilParamException"); hsAssert(0,"hsNilParamException");
throw hsNilParamException(); throw hsNilParamException();
} }
} }
inline void hsThrowIfBadParam(hsBool trueIfBadParam) inline void hsThrowIfBadParam(hsBool trueIfBadParam)
{ {
if (trueIfBadParam) if (trueIfBadParam)
{ {
hsAssert(0,"hsBadParamException"); hsAssert(0,"hsBadParamException");
throw hsBadParamException(); throw hsBadParamException();
} }
} }
inline void hsThrowIfOSErr(long osErr) inline void hsThrowIfOSErr(long osErr)
{ {
if (osErr != 0) if (osErr != 0)
{ {
hsAssert(0,"hsOSException"); hsAssert(0,"hsOSException");
throw hsOSException(osErr); throw hsOSException(osErr);
} }
} }
inline void hsThrowIfTrue(hsBool condition) inline void hsThrowIfTrue(hsBool condition)
{ {
if (condition) if (condition)
{ {
hsAssert(0,"hsThrowIfTrue"); hsAssert(0,"hsThrowIfTrue");
throw hsInternalException(); throw hsInternalException();
} }
} }
inline void hsThrowIfFalse(hsBool condition) inline void hsThrowIfFalse(hsBool condition)
{ {
if (condition == false) if (condition == false)
{ {
hsAssert(0,"hsThrowIfFalse"); hsAssert(0,"hsThrowIfFalse");
throw hsInternalException(); throw hsInternalException();
} }
} }
inline void hsThrowIfTrue(hsBool condition, const char message[]) inline void hsThrowIfTrue(hsBool condition, const char message[])
{ {
if (condition) if (condition)
{ {
hsAssert(0,message); hsAssert(0,message);
throw message; throw message;
} }
} }
inline void hsThrowIfFalse(hsBool condition, const char message[]) inline void hsThrowIfFalse(hsBool condition, const char message[])
{ {
if (condition == false) if (condition == false)
{ {
hsAssert(0,message); hsAssert(0,message);
throw message; throw message;
} }
} }
#else #else
@ -157,37 +157,37 @@ inline void hsThrowIfFalse(hsBool condition, const char message[])
inline void hsThrowIfNilParam(const void* p) inline void hsThrowIfNilParam(const void* p)
{ {
hsAssert(p!=nil,"hsThrowIfNilParam"); hsAssert(p!=nil,"hsThrowIfNilParam");
} }
inline void hsThrowIfBadParam(hsBool trueIfBadParam) inline void hsThrowIfBadParam(hsBool trueIfBadParam)
{ {
hsAssert(!trueIfBadParam,"hsThrowIfBadParam"); hsAssert(!trueIfBadParam,"hsThrowIfBadParam");
} }
inline void hsThrowIfOSErr(long osErr) inline void hsThrowIfOSErr(long osErr)
{ {
hsAssert(osErr==0,"hsThrowIfOSErr"); hsAssert(osErr==0,"hsThrowIfOSErr");
} }
inline void hsThrowIfTrue(hsBool condition) inline void hsThrowIfTrue(hsBool condition)
{ {
hsAssert(!condition,"hsThrowIfTrue"); hsAssert(!condition,"hsThrowIfTrue");
} }
inline void hsThrowIfFalse(hsBool condition) inline void hsThrowIfFalse(hsBool condition)
{ {
hsAssert(condition,"hsThrowIfFalse"); hsAssert(condition,"hsThrowIfFalse");
} }
inline void hsThrowIfTrue(hsBool condition, const char message[]) inline void hsThrowIfTrue(hsBool condition, const char message[])
{ {
hsAssert(!condition,message); hsAssert(!condition,message);
} }
inline void hsThrowIfFalse(hsBool condition, const char message[]) inline void hsThrowIfFalse(hsBool condition, const char message[])
{ {
hsAssert(condition,message); hsAssert(condition,message);
} }

1146
Sources/Plasma/CoreLib/hsFastMath.cpp
View File

File diff suppressed because it is too large Load Diff

246
Sources/Plasma/CoreLib/hsFastMath.h
View File

@ -32,212 +32,212 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
class hsFastMath { class hsFastMath {
protected: protected:
static const hsPoint2* fCosSinTable; static const hsPoint2* fCosSinTable;
public: public:
static const hsScalar kSqrtTwo; static const hsScalar kSqrtTwo;
static const hsScalar kInvSqrtTwo; static const hsScalar kInvSqrtTwo;
static const hsScalar kTwoPI; static const hsScalar kTwoPI;
static hsScalar IATan2OverTwoPi(hsScalar y, hsScalar x); static hsScalar IATan2OverTwoPi(hsScalar y, hsScalar x);
static inline hsScalar InvSqrtAppr(hsScalar x); static inline hsScalar InvSqrtAppr(hsScalar x);
static inline hsScalar InvSqrt(hsScalar x); static inline hsScalar InvSqrt(hsScalar x);
static inline hsVector3& Normalize(hsVector3& v) { return (v *= InvSqrt(v.MagnitudeSquared())); } static inline hsVector3& Normalize(hsVector3& v) { return (v *= InvSqrt(v.MagnitudeSquared())); }
static inline hsVector3& NormalizeAppr(hsVector3& v) { return (v *= InvSqrtAppr(v.MagnitudeSquared())); } static inline hsVector3& NormalizeAppr(hsVector3& v) { return (v *= InvSqrtAppr(v.MagnitudeSquared())); }
static inline void SinCosAppr(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads); static inline void SinCosAppr(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads);
static inline void SinCosInRangeAppr(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads); static inline void SinCosInRangeAppr(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads);
static inline void SinCos(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads); static inline void SinCos(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads);
static inline void SinCosInRange(hsScalar ang, hsScalar& sinRads, hsScalar& cosRads); static inline void SinCosInRange(hsScalar ang, hsScalar& sinRads, hsScalar& cosRads);
static inline hsScalar Sin(hsScalar rads); static inline hsScalar Sin(hsScalar rads);
static inline hsScalar Cos(hsScalar rads); static inline hsScalar Cos(hsScalar rads);
static inline hsScalar SinInRange(hsScalar rads); static inline hsScalar SinInRange(hsScalar rads);
static inline hsScalar CosInRange(hsScalar rads); static inline hsScalar CosInRange(hsScalar rads);
}; };
// One over Square Root - from Graphics Gems // One over Square Root - from Graphics Gems
// Interesting combo's are // Interesting combo's are
// NUM_ITER LOOKUP_BITS err frac us per call // NUM_ITER LOOKUP_BITS err frac us per call
// 0 8 5e-3 0.045 // 0 8 5e-3 0.045
// 1 8 3e-5 0.082 // 1 8 3e-5 0.082
// 0 6 1e-2 0.045 // 0 6 1e-2 0.045
// 1 6 1e-4 0.082 // 1 6 1e-4 0.082
// 2 6 1e-7 0.11 // 2 6 1e-7 0.11
// 1 4 2e-3 0.082 // 1 4 2e-3 0.082
// 2 4 5e-6 0.11 // 2 4 5e-6 0.11
// 2 3 8e-5 0.11 // 2 3 8e-5 0.11
// Tested on 5000 random numbers from [1.e-6..1.e3] over several runs // Tested on 5000 random numbers from [1.e-6..1.e3] over several runs
// These are tight loops, though, so they don't weigh in a bigger // These are tight loops, though, so they don't weigh in a bigger
// table trashing the cache. // table trashing the cache.
#define NUM_ITER 0 #define NUM_ITER 0
#define LOOKUP_BITS 8 #define LOOKUP_BITS 8
#define EXP_POS 23 #define EXP_POS 23
#define EXP_BIAS 127 #define EXP_BIAS 127
#define LOOKUP_POS (EXP_POS - LOOKUP_BITS) #define LOOKUP_POS (EXP_POS - LOOKUP_BITS)
#define SEED_POS (EXP_POS - 8) #define SEED_POS (EXP_POS - 8)
#define TABLE_SIZE (2 << LOOKUP_BITS) #define TABLE_SIZE (2 << LOOKUP_BITS)
#define LOOKUP_MASK (TABLE_SIZE - 1) #define LOOKUP_MASK (TABLE_SIZE - 1)
#define GET_EXP(a) (((a) >> EXP_POS) & 0xff) #define GET_EXP(a) (((a) >> EXP_POS) & 0xff)
#define SET_EXP(a) ((a) << EXP_POS) #define SET_EXP(a) ((a) << EXP_POS)
#define GET_EMANT(a) (((a) >> LOOKUP_POS) & LOOKUP_MASK) #define GET_EMANT(a) (((a) >> LOOKUP_POS) & LOOKUP_MASK)
#define SET_MANTSEED(a) (((unsigned long) (a)) << SEED_POS) #define SET_MANTSEED(a) (((unsigned long) (a)) << SEED_POS)
inline hsScalar hsFastMath::InvSqrtAppr(hsScalar x) inline hsScalar hsFastMath::InvSqrtAppr(hsScalar x)
{ {
register unsigned long a = *(long*)&x; register unsigned long a = *(long*)&x;
register float arg = x; register float arg = x;
union { union {
long i; long i;
float f; float f;
} seed; } seed;
register float r; register float r;
extern unsigned char statSeedTable[]; extern unsigned char statSeedTable[];
seed.i = SET_EXP(((3*EXP_BIAS - 1) - GET_EXP(a)) >> 1) | SET_MANTSEED(statSeedTable[GET_EMANT(a)]); seed.i = SET_EXP(((3*EXP_BIAS - 1) - GET_EXP(a)) >> 1) | SET_MANTSEED(statSeedTable[GET_EMANT(a)]);
r = seed.f; r = seed.f;
#if NUM_ITER > 0 #if NUM_ITER > 0
r = (3.0f - r * r * arg) * r * 0.5f; r = (3.0f - r * r * arg) * r * 0.5f;
#if NUM_ITER > 1 #if NUM_ITER > 1
r = (3.0f - r * r * arg) * r * 0.5f; r = (3.0f - r * r * arg) * r * 0.5f;
#endif #endif
#endif #endif
return r; return r;
} }
inline hsScalar hsFastMath::InvSqrt(hsScalar x) inline hsScalar hsFastMath::InvSqrt(hsScalar x)
{ {
register unsigned long a = *(long*)&x; register unsigned long a = *(long*)&x;
register float arg = x; register float arg = x;
union { union {
long i; long i;
float f; float f;
} seed; } seed;
register float r; register float r;
extern unsigned char statSeedTable[]; extern unsigned char statSeedTable[];
seed.i = SET_EXP(((3*EXP_BIAS - 1) - GET_EXP(a)) >> 1) | SET_MANTSEED(statSeedTable[GET_EMANT(a)]); seed.i = SET_EXP(((3*EXP_BIAS - 1) - GET_EXP(a)) >> 1) | SET_MANTSEED(statSeedTable[GET_EMANT(a)]);
r = seed.f; r = seed.f;
r = (3.0f - r * r * arg) * r * 0.5f; r = (3.0f - r * r * arg) * r * 0.5f;
r = (3.0f - r * r * arg) * r * 0.5f; r = (3.0f - r * r * arg) * r * 0.5f;
return r; return r;
} }
inline void hsFastMath::SinCosAppr(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads) inline void hsFastMath::SinCosAppr(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads)
{ {
rads = fmodf(rads, kTwoPI); rads = fmodf(rads, kTwoPI);
if( rads < 0 ) if( rads < 0 )
rads += kTwoPI; rads += kTwoPI;
SinCosInRangeAppr(rads, sinRads, cosRads); SinCosInRangeAppr(rads, sinRads, cosRads);
} }
inline void hsFastMath::SinCosInRangeAppr(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads) inline void hsFastMath::SinCosInRangeAppr(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads)
{ {
const int kNumSinCosEntries = 8; const int kNumSinCosEntries = 8;
const hsScalar kNumEntriesOverTwoPI = kNumSinCosEntries * 0.5f / hsScalarPI; const hsScalar kNumEntriesOverTwoPI = kNumSinCosEntries * 0.5f / hsScalarPI;
hsScalar t = rads * kNumEntriesOverTwoPI; hsScalar t = rads * kNumEntriesOverTwoPI;
int iLo = (int)t; int iLo = (int)t;
t -= iLo; t -= iLo;
const hsPoint2* p = &fCosSinTable[iLo + 1]; const hsPoint2* p = &fCosSinTable[iLo + 1];
cosRads = p->fX; cosRads = p->fX;
sinRads = p->fY; sinRads = p->fY;
p--; p--;
cosRads -= p->fX; cosRads -= p->fX;
sinRads -= p->fY; sinRads -= p->fY;
cosRads *= t; cosRads *= t;
sinRads *= t; sinRads *= t;
cosRads += p->fX; cosRads += p->fX;
sinRads += p->fY; sinRads += p->fY;
} }
inline hsScalar hsFastMath::Sin(hsScalar rads) inline hsScalar hsFastMath::Sin(hsScalar rads)
{ {
rads = fmodf(rads, kTwoPI); rads = fmodf(rads, kTwoPI);
if( rads < 0 ) if( rads < 0 )
rads += kTwoPI; rads += kTwoPI;
return SinInRange(rads); return SinInRange(rads);
} }
inline hsScalar hsFastMath::Cos(hsScalar rads) inline hsScalar hsFastMath::Cos(hsScalar rads)
{ {
rads = fmodf(rads, kTwoPI); rads = fmodf(rads, kTwoPI);
if( rads < 0 ) if( rads < 0 )
rads += kTwoPI; rads += kTwoPI;
return CosInRange(rads); return CosInRange(rads);
} }
inline hsScalar hsFastMath::SinInRange(hsScalar ang) inline hsScalar hsFastMath::SinInRange(hsScalar ang)
{ {
float sgn = 1.f; float sgn = 1.f;
if(ang >= (0.75f * kTwoPI)) if(ang >= (0.75f * kTwoPI))
ang -= kTwoPI; ang -= kTwoPI;
else if(ang >= (0.25f * kTwoPI)) else if(ang >= (0.25f * kTwoPI))
{ {
ang -= 3.141592654f; ang -= 3.141592654f;
sgn = -1.0f; sgn = -1.0f;
} }
return (ang - (ang*ang*ang) * (1.0f/6.0f) + (ang*ang*ang*ang*ang) / 120.0f) * sgn; return (ang - (ang*ang*ang) * (1.0f/6.0f) + (ang*ang*ang*ang*ang) / 120.0f) * sgn;
} }
inline hsScalar hsFastMath::CosInRange(hsScalar ang) inline hsScalar hsFastMath::CosInRange(hsScalar ang)
{ {
float sgn = 1.f; float sgn = 1.f;
if(ang >= (0.75f * kTwoPI)) if(ang >= (0.75f * kTwoPI))
ang -= kTwoPI; ang -= kTwoPI;
else if(ang >= (0.25f * kTwoPI)) else if(ang >= (0.25f * kTwoPI))
{ {
ang -= 3.141592654f; ang -= 3.141592654f;
sgn = -1.0f; sgn = -1.0f;
} }
return (1.0f - (ang*ang / 2.0f) + (ang*ang*ang*ang) / 24.0f) *sgn; return (1.0f - (ang*ang / 2.0f) + (ang*ang*ang*ang) / 24.0f) *sgn;
} }
inline void hsFastMath::SinCos(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads) inline void hsFastMath::SinCos(hsScalar rads, hsScalar& sinRads, hsScalar& cosRads)
{ {
rads = fmodf(rads, kTwoPI); rads = fmodf(rads, kTwoPI);
if( rads < 0 ) if( rads < 0 )
rads += kTwoPI; rads += kTwoPI;
SinCosInRange(rads, sinRads, cosRads); SinCosInRange(rads, sinRads, cosRads);
} }
inline void hsFastMath::SinCosInRange(hsScalar ang, hsScalar& sinRads, hsScalar& cosRads) inline void hsFastMath::SinCosInRange(hsScalar ang, hsScalar& sinRads, hsScalar& cosRads)
{ {
float sgn = 1.f; float sgn = 1.f;
if(ang >= (0.75f * kTwoPI)) if(ang >= (0.75f * kTwoPI))
ang -= kTwoPI; ang -= kTwoPI;
else if(ang >= (0.25f * kTwoPI)) else if(ang >= (0.25f * kTwoPI))
{ {
ang -= 3.141592654f; ang -= 3.141592654f;
sgn = -1.0f; sgn = -1.0f;
} }
sinRads = (ang - (ang*ang*ang) * (1.0f/6.0f) + (ang*ang*ang*ang*ang) / 120.0f) * sgn; sinRads = (ang - (ang*ang*ang) * (1.0f/6.0f) + (ang*ang*ang*ang*ang) / 120.0f) * sgn;
cosRads = (1.0f - (ang*ang / 2.0f) + (ang*ang*ang*ang) / 24.0f) *sgn; cosRads = (1.0f - (ang*ang / 2.0f) + (ang*ang*ang*ang) / 24.0f) *sgn;
} }
// //
// Here's an interesting one from GDalgorithms, which doesn't need a LUT // Here's an interesting one from GDalgorithms, which doesn't need a LUT

100
Sources/Plasma/CoreLib/hsFixedTypes.h
View File

@ -29,90 +29,90 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsTypes.h" #include "hsTypes.h"
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_MAC
#include <ToolUtils.h> #include <ToolUtils.h>
#include <FixMath.h> #include <FixMath.h>
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define hsIntToFixed(x) ((hsFixed)(x) << 16) #define hsIntToFixed(x) ((hsFixed)(x) << 16)
#define hsFixedToInt(x) ((x) >> 16) #define hsFixedToInt(x) ((x) >> 16)
#define hsFixedRound(x) (((x) + 0x8000) >> 16) #define hsFixedRound(x) (((x) + 0x8000) >> 16)
#define hsFixed1 hsIntToFixed(1) #define hsFixed1 hsIntToFixed(1)
#define hsFixedPI (0x3243F) #define hsFixedPI (0x3243F)
#define hsFixedPiOver2 (0x1921F) #define hsFixedPiOver2 (0x1921F)
#define hsFixedToFract(x) ((hsFract)(x) << 14) #define hsFixedToFract(x) ((hsFract)(x) << 14)
#define hsFractToFixed(x) ((hsFixed)(x) >> 14) #define hsFractToFixed(x) ((hsFixed)(x) >> 14)
#define hsFract1 hsFixedToFract(hsFixed1) #define hsFract1 hsFixedToFract(hsFixed1)
#define hsFractPiOver2 (0x6487ED34) /* needs some work */ #define hsFractPiOver2 (0x6487ED34) /* needs some work */
#define hsFixFloor(x) \ #define hsFixFloor(x) \
(hsFixed)((x) < 0 ? -(hsFixed)((-(x) + 0xFFFF) & 0xFFFF0000) : (x) & 0xFFFF0000) (hsFixed)((x) < 0 ? -(hsFixed)((-(x) + 0xFFFF) & 0xFFFF0000) : (x) & 0xFFFF0000)
#define hsFixedToFloorInt(x) \ #define hsFixedToFloorInt(x) \
(int)((x) < 0 ? -(int)((-(x) + 0xFFFF) >> 16) : ((x) >> 16)) (int)((x) < 0 ? -(int)((-(x) + 0xFFFF) >> 16) : ((x) >> 16))
#define hsFixCeiling(x) \ #define hsFixCeiling(x) \
(hsFixed)((x) < 0 ? -(hsFixed)(-(x) & 0xFFFF0000) : ((x) + 0xFFFF) & 0xFFFF0000) (hsFixed)((x) < 0 ? -(hsFixed)(-(x) & 0xFFFF0000) : ((x) + 0xFFFF) & 0xFFFF0000)
#define hsFixedToCeilingInt(x) \ #define hsFixedToCeilingInt(x) \
(int)((x) < 0 ? -(int)(-(x) >> 16) : (((x) + 0xFFFF) >> 16)) (int)((x) < 0 ? -(int)(-(x) >> 16) : (((x) + 0xFFFF) >> 16))
#if HS_CAN_USE_FLOAT #if HS_CAN_USE_FLOAT
#define hsFixedToFloat(x) ((x) / float(hsFixed1)) #define hsFixedToFloat(x) ((x) / float(hsFixed1))
#define hsFloatToFixed(x) hsFixed((x) * hsFixed1) #define hsFloatToFixed(x) hsFixed((x) * hsFixed1)
#define hsFractToFloat(x) ((x) / float(hsFract1)) #define hsFractToFloat(x) ((x) / float(hsFract1))
#define hsFloatToFract(x) hsFract((x) * hsFract1) #define hsFloatToFract(x) hsFract((x) * hsFract1)
#endif #endif
#if HS_BUILD_FOR_MAC68K && !(HS_PIN_MATH_OVERFLOW) #if HS_BUILD_FOR_MAC68K && !(HS_PIN_MATH_OVERFLOW)
#define hsFixMul(a, b) FixMul(a, b) #define hsFixMul(a, b) FixMul(a, b)
#else #else
hsFixed hsFixMul(hsFixed a, hsFixed b); hsFixed hsFixMul(hsFixed a, hsFixed b);
#endif #endif
#if HS_BUILD_FOR_MAC && !(HS_PIN_MATH_OVERFLOW) && !(HS_MP_SAFE) #if HS_BUILD_FOR_MAC && !(HS_PIN_MATH_OVERFLOW) && !(HS_MP_SAFE)
#define hsFixDiv(a, b) FixDiv(a, b) #define hsFixDiv(a, b) FixDiv(a, b)
#define hsFracMul(a, b) FracMul(a, b) #define hsFracMul(a, b) FracMul(a, b)
#define hsFracDiv(a, b) FracDiv(a, b) #define hsFracDiv(a, b) FracDiv(a, b)
#else #else
hsFract hsFixDiv(hsFixed a, hsFixed b); hsFract hsFixDiv(hsFixed a, hsFixed b);
hsFract hsFracMul(hsFract a, hsFract b); hsFract hsFracMul(hsFract a, hsFract b);
hsFract hsFracDiv(hsFract a, hsFract b); hsFract hsFracDiv(hsFract a, hsFract b);
#endif #endif
hsFract hsFracSqrt(hsFract value); hsFract hsFracSqrt(hsFract value);
#define hsFixSqrt(value) (hsFracSqrt(value) >> 7) #define hsFixSqrt(value) (hsFracSqrt(value) >> 7)
hsFract hsFracCubeRoot(hsFract value); hsFract hsFracCubeRoot(hsFract value);
hsFixed hsFixedSin(hsFixed s); hsFixed hsFixedSin(hsFixed s);
hsFixed hsFixedCos(hsFixed s); hsFixed hsFixedCos(hsFixed s);
hsFixed hsFixedASin(hsFixed s); hsFixed hsFixedASin(hsFixed s);
hsFixed hsFixedACos(hsFixed s); hsFixed hsFixedACos(hsFixed s);
UInt16 hsSqrt32(UInt32 value); UInt16 hsSqrt32(UInt32 value);
UInt16 hsCubeRoot32(UInt32 value); UInt16 hsCubeRoot32(UInt32 value);
Int32 hsMulDiv32(Int32 numer1, Int32 numer2, Int32 denom); Int32 hsMulDiv32(Int32 numer1, Int32 numer2, Int32 denom);
Int32 hsMagnitude32(Int32 x, Int32 y); Int32 hsMagnitude32(Int32 x, Int32 y);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
struct hsFixedPlane { struct hsFixedPlane {
hsFixed fA, fB, fC; hsFixed fA, fB, fC;
void Set(hsFixed a, hsFixed b, hsFixed c) { fA = a; fB = b; fC = c; } void Set(hsFixed a, hsFixed b, hsFixed c) { fA = a; fB = b; fC = c; }
hsFixed FixEval(hsFixed x, hsFixed y) const { return hsFixMul(fA, x) + hsFixMul(fB, y) + fC; } hsFixed FixEval(hsFixed x, hsFixed y) const { return hsFixMul(fA, x) + hsFixMul(fB, y) + fC; }
Int32 IntEval(Int32 x, Int32 y) const { return fA * x + fB * y + fC; } Int32 IntEval(Int32 x, Int32 y) const { return fA * x + fB * y + fC; }
void ShiftDown(UInt32 i) { fA >>= i; fB >>= i; fC >>= i;} void ShiftDown(UInt32 i) { fA >>= i; fB >>= i; fC >>= i;}
}; };
#endif #endif
#endif #endif

78
Sources/Plasma/CoreLib/hsGeometry3.cpp
View File

@ -28,11 +28,11 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
hsVector3 operator%(const hsVector3& t, const hsVector3& s) hsVector3 operator%(const hsVector3& t, const hsVector3& s)
{ {
hsVector3 result; hsVector3 result;
return *result.Set( hsScalarMul(t.fY, s.fZ) - hsScalarMul(s.fY, t.fZ), return *result.Set( hsScalarMul(t.fY, s.fZ) - hsScalarMul(s.fY, t.fZ),
-hsScalarMul(t.fX, s.fZ) + hsScalarMul(s.fX, t.fZ), -hsScalarMul(t.fX, s.fZ) + hsScalarMul(s.fX, t.fZ),
hsScalarMul(t.fX, s.fY) - hsScalarMul(s.fX, t.fY)); hsScalarMul(t.fX, s.fY) - hsScalarMul(s.fX, t.fY));
} }
@ -43,75 +43,75 @@ hsVector3 operator%(const hsVector3& t, const hsVector3& s)
#if HS_SCALAR_IS_FIXED #if HS_SCALAR_IS_FIXED
hsScalar hsScalarTriple::Magnitude() const hsScalar hsScalarTriple::Magnitude() const
{ {
hsWide result, temp; hsWide result, temp;
result.Mul(fCoord[0], fCoord[0]); result.Mul(fCoord[0], fCoord[0]);
temp.Mul(fCoord[1], fCoord[1]); temp.Mul(fCoord[1], fCoord[1]);
result.Add(&temp); result.Add(&temp);
temp.Mul(fCoord[2], fCoord[2]); temp.Mul(fCoord[2], fCoord[2]);
result.Add(&temp); result.Add(&temp);
return result.Sqrt(); return result.Sqrt();
} }
hsScalar hsScalarTriple::MagnitudeSquared() const hsScalar hsScalarTriple::MagnitudeSquared() const
{ {
hsWide result, temp; hsWide result, temp;
result.Mul(fCoord[0], fCoord[0]); result.Mul(fCoord[0], fCoord[0]);
temp.Mul(fCoord[1], fCoord[1]); temp.Mul(fCoord[1], fCoord[1]);
result.Add(&temp); result.Add(&temp);
temp.Mul(fCoord[2], fCoord[2]); temp.Mul(fCoord[2], fCoord[2]);
result.Add(&temp); result.Add(&temp);
return result.AsFixed(); return result.AsFixed();
} }
#endif #endif
void hsScalarTriple::Read(hsStream *stream) void hsScalarTriple::Read(hsStream *stream)
{ {
// DANGER for speed read directly into these variables...ASSUMES fX,fY, and fZ are in contiguous order (PBG) // DANGER for speed read directly into these variables...ASSUMES fX,fY, and fZ are in contiguous order (PBG)
stream->Read12Bytes(&fX); stream->Read12Bytes(&fX);
#if HS_BUILD_FOR_MAC #if HS_BUILD_FOR_MAC
fX = hsSwapEndianFloat(fX); fX = hsSwapEndianFloat(fX);
fY = hsSwapEndianFloat(fY); fY = hsSwapEndianFloat(fY);
fZ = hsSwapEndianFloat(fZ); fZ = hsSwapEndianFloat(fZ);
#endif #endif
} }
void hsScalarTriple::Write(hsStream *stream) const void hsScalarTriple::Write(hsStream *stream) const
{ {
stream->WriteSwapScalar(fX); stream->WriteSwapScalar(fX);
stream->WriteSwapScalar(fY); stream->WriteSwapScalar(fY);
stream->WriteSwapScalar(fZ); stream->WriteSwapScalar(fZ);
} }
hsPlane3::hsPlane3(const hsPoint3* pt1, const hsPoint3* pt2, const hsPoint3* pt3) hsPlane3::hsPlane3(const hsPoint3* pt1, const hsPoint3* pt2, const hsPoint3* pt3)
{ {
// convert into a point with two vectors // convert into a point with two vectors
hsVector3 v1(pt2, pt1); hsVector3 v1(pt2, pt1);
hsVector3 v2(pt3, pt1); hsVector3 v2(pt3, pt1);
// calculate the normal (wedge) // calculate the normal (wedge)
fN.fX = (v1.fY * v2.fZ) - (v2.fY * v1.fZ); fN.fX = (v1.fY * v2.fZ) - (v2.fY * v1.fZ);
fN.fY = (v1.fZ * v2.fX) - (v2.fZ * v1.fX); fN.fY = (v1.fZ * v2.fX) - (v2.fZ * v1.fX);
fN.fZ = (v1.fX * v2.fY) - (v2.fX * v1.fY); fN.fZ = (v1.fX * v2.fY) - (v2.fX * v1.fY);
fN.Normalize(); fN.Normalize();
fD = -pt1->InnerProduct(&fN); fD = -pt1->InnerProduct(&fN);
} }
void hsPlane3::Read(hsStream *stream) void hsPlane3::Read(hsStream *stream)
{ {
fN.Read(stream); fN.Read(stream);
fD=stream->ReadSwapScalar(); fD=stream->ReadSwapScalar();
} }
void hsPlane3::Write(hsStream *stream) const void hsPlane3::Write(hsStream *stream) const
{ {
fN.Write(stream); fN.Write(stream);
stream->WriteSwapScalar(fD); stream->WriteSwapScalar(fD);
} }

468
Sources/Plasma/CoreLib/hsGeometry3.h
View File

@ -45,155 +45,155 @@ class hsStream;
/**** vu0 inline ****/ /**** vu0 inline ****/
#if 1 #if 1
#define inline_asm inline /* inline */ #define inline_asm inline /* inline */
#else #else
#define inline_asm /* not inline */ #define inline_asm /* not inline */
#endif #endif
/******* HeadSpin *******/ /******* HeadSpin *******/
typedef float hsScalar; typedef float hsScalar;
/* -------------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------------- */
/* return(sqrt(x)) */ /* return(sqrt(x)) */
inline_asm hsScalar SqrtVU0(hsScalar x) inline_asm hsScalar SqrtVU0(hsScalar x)
{ {
register hsScalar ret; register hsScalar ret;
asm volatile(" \ asm volatile(" \
mfc1 $8,%1 \ mfc1 $8,%1 \
qmtc2 $8,vf4 \ qmtc2 $8,vf4 \
vsqrt Q,vf4x \ vsqrt Q,vf4x \
vwaitq \ vwaitq \
cfc2 $2,$vi22 \ cfc2 $2,$vi22 \
mtc1 $2,%0 \ mtc1 $2,%0 \
" :"=f" (ret) : "f" (x), "0" (ret) : "$2", "$8", "memory"); " :"=f" (ret) : "f" (x), "0" (ret) : "$2", "$8", "memory");
return ret; return ret;
} }
/* -------------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------------- */
/* return(1 / a) */ /* return(1 / a) */
inline_asm hsScalar ScalarInvertVU0(hsScalar a) inline_asm hsScalar ScalarInvertVU0(hsScalar a)
{ {
register hsScalar ret; register hsScalar ret;
asm volatile(" \ asm volatile(" \
mfc1 $8,%1 \ mfc1 $8,%1 \
qmtc2 $8,vf2 \ qmtc2 $8,vf2 \
vdiv Q,vf0w,vf2x \ vdiv Q,vf0w,vf2x \
vwaitq \ vwaitq \
cfc2 $2,$vi22 \ cfc2 $2,$vi22 \
mtc1 $2,%0 \ mtc1 $2,%0 \
" :"=f" (ret) : "f" (a), "0" (ret) : "$2", "$8", "memory"); " :"=f" (ret) : "f" (a), "0" (ret) : "$2", "$8", "memory");
return ret; return ret;
} }
/* -------------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------------- */
/* return(a * b) */ /* return(a * b) */
inline_asm hsScalar ScalarMulVU0(hsScalar a, hsScalar b) inline_asm hsScalar ScalarMulVU0(hsScalar a, hsScalar b)
{ {
register hsScalar ret; register hsScalar ret;
asm volatile(" \ asm volatile(" \
mfc1 $8,%1 \ mfc1 $8,%1 \
qmtc2 $8,vf2 \ qmtc2 $8,vf2 \
mfc1 $9,%2 \ mfc1 $9,%2 \
qmtc2 $9,vf3 \ qmtc2 $9,vf3 \
vmul.x vf3,vf2,vf3 \ vmul.x vf3,vf2,vf3 \
qmfc2 $2 ,vf3 \ qmfc2 $2 ,vf3 \
mtc1 $2,%0 \ mtc1 $2,%0 \
" :"=f" (ret) : "f" (a), "f" (b), "0" (ret) : "$2", "$8", "$9", "memory"); " :"=f" (ret) : "f" (a), "f" (b), "0" (ret) : "$2", "$8", "$9", "memory");
return ret; return ret;
} }
#endif // PS2 #endif // PS2
/* /*
If value is already close to hsScalar1, then this is a good approx. of 1/sqrt(value) If value is already close to hsScalar1, then this is a good approx. of 1/sqrt(value)
*/ */
static inline hsScalar hsInvSqrt(hsScalar value) static inline hsScalar hsInvSqrt(hsScalar value)
{ {
hsScalar guess; hsScalar guess;
hsScalar threeOverTwo = hsScalar1 + hsScalarHalf; hsScalar threeOverTwo = hsScalar1 + hsScalarHalf;
value = hsScalarDiv2(value); value = hsScalarDiv2(value);
guess = threeOverTwo - value; // with initial guess = 1.0 guess = threeOverTwo - value; // with initial guess = 1.0
// repeat this line for better approx // repeat this line for better approx
guess = hsScalarMul(guess, threeOverTwo - hsScalarMul(hsScalarMul(value, guess), guess)); guess = hsScalarMul(guess, threeOverTwo - hsScalarMul(hsScalarMul(value, guess), guess));
guess = hsScalarMul(guess, threeOverTwo - hsScalarMul(hsScalarMul(value, guess), guess)); guess = hsScalarMul(guess, threeOverTwo - hsScalarMul(hsScalarMul(value, guess), guess));
return guess; return guess;
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
struct hsScalarTriple struct hsScalarTriple
{ {
//protected: //protected:
// hsScalarTriple() : fX(privateData[0]), fY(privateData[1]), fZ(privateData[2]) {} // hsScalarTriple() : fX(privateData[0]), fY(privateData[1]), fZ(privateData[2]) {}
// hsScalarTriple(hsScalar x, hsScalar y, hsScalar z) // hsScalarTriple(hsScalar x, hsScalar y, hsScalar z)
// : fX(privateData[0]), fY(privateData[1]), fZ(privateData[2]) { fX = x, fY = y, fZ = z; } // : fX(privateData[0]), fY(privateData[1]), fZ(privateData[2]) { fX = x, fY = y, fZ = z; }
// //
// union { // union {
// u_long128 privateTemp; // u_long128 privateTemp;
// hsScalar privateData[4]; // hsScalar privateData[4];
// }; // };
//public: //public:
// //
// int operator=(const hsScalarTriple& o) { privateTemp = o.privateTemp; } // int operator=(const hsScalarTriple& o) { privateTemp = o.privateTemp; }
// hsScalarTriple(const hsScalarTriple& o) : fX(privateData[0]), fY(privateData[1]), fZ(privateData[2]) // hsScalarTriple(const hsScalarTriple& o) : fX(privateData[0]), fY(privateData[1]), fZ(privateData[2])
// { *this = o; } // { *this = o; }
// //
// hsScalar& fX; // hsScalar& fX;
// hsScalar& fY; // hsScalar& fY;
// hsScalar& fZ; // hsScalar& fZ;
protected: protected:
hsScalarTriple() {} hsScalarTriple() {}
hsScalarTriple(hsScalar x, hsScalar y, hsScalar z) : fX(x), fY(y), fZ(z) {} hsScalarTriple(hsScalar x, hsScalar y, hsScalar z) : fX(x), fY(y), fZ(z) {}
public: public:
hsScalar fX, fY, fZ; hsScalar fX, fY, fZ;
hsScalarTriple* Set(hsScalar x, hsScalar y, hsScalar z) { fX= x; fY = y; fZ = z; return this;} hsScalarTriple* Set(hsScalar x, hsScalar y, hsScalar z) { fX= x; fY = y; fZ = z; return this;}
hsScalarTriple* Set(const hsScalarTriple *p) { fX = p->fX; fY = p->fY; fZ = p->fZ; return this;} hsScalarTriple* Set(const hsScalarTriple *p) { fX = p->fX; fY = p->fY; fZ = p->fZ; return this;}
hsScalar InnerProduct(const hsScalarTriple &p) const; hsScalar InnerProduct(const hsScalarTriple &p) const;
hsScalar InnerProduct(const hsScalarTriple *p) const; hsScalar InnerProduct(const hsScalarTriple *p) const;
// hsScalarTriple LERP(hsScalarTriple &other, hsScalar t); // hsScalarTriple LERP(hsScalarTriple &other, hsScalar t);
#if HS_SCALAR_IS_FIXED #if HS_SCALAR_IS_FIXED
hsScalar Magnitude() const; hsScalar Magnitude() const;
hsScalar MagnitudeSquared() const; hsScalar MagnitudeSquared() const;
#else #else
#if HS_BUILD_FOR_PS2 #if HS_BUILD_FOR_PS2
hsScalar Magnitude() const; hsScalar Magnitude() const;
#else #else
hsScalar Magnitude() const { return hsSquareRoot(MagnitudeSquared()); } hsScalar Magnitude() const { return hsSquareRoot(MagnitudeSquared()); }
#endif #endif
hsScalar MagnitudeSquared() const { return (fX * fX + fY * fY + fZ * fZ); } hsScalar MagnitudeSquared() const { return (fX * fX + fY * fY + fZ * fZ); }
#endif #endif
hsBool IsEmpty() const { return fX == 0 && fY == 0 && fZ == 0; } hsBool IsEmpty() const { return fX == 0 && fY == 0 && fZ == 0; }
hsScalar operator[](int i) const; hsScalar operator[](int i) const;
hsScalar& operator[](int i); hsScalar& operator[](int i);
void Read(hsStream *stream); void Read(hsStream *stream);
void Write(hsStream *stream) const; void Write(hsStream *stream) const;
} ATTRIBUTE_FOR_PS2; /* SUNSOFT */ } ATTRIBUTE_FOR_PS2; /* SUNSOFT */
#if HS_BUILD_FOR_PS2 #if HS_BUILD_FOR_PS2
inline hsScalar hsScalarTriple::Magnitude() const inline hsScalar hsScalarTriple::Magnitude() const
{ {
MATRIX4 m; MATRIX4 m;
m[0] = fX; m[0] = fX;
m[1] = fY; m[1] = fY;
m[2] = fZ; m[2] = fZ;
return MagnitudeVU0(m); return MagnitudeVU0(m);
} }
#endif #endif
@ -201,264 +201,264 @@ inline hsScalar hsScalarTriple::Magnitude() const
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
inline hsScalar& hsScalarTriple::operator[] (int i) inline hsScalar& hsScalarTriple::operator[] (int i)
{ {
hsAssert(i >=0 && i <3, "Bad index for hsScalarTriple::operator[]"); hsAssert(i >=0 && i <3, "Bad index for hsScalarTriple::operator[]");
return *(&fX + i); return *(&fX + i);
} }
inline hsScalar hsScalarTriple::operator[] (int i) const inline hsScalar hsScalarTriple::operator[] (int i) const
{ {
hsAssert(i >=0 && i <3, "Bad index for hsScalarTriple::operator[]"); hsAssert(i >=0 && i <3, "Bad index for hsScalarTriple::operator[]");
return *(&fX + i); return *(&fX + i);
} }
inline hsScalar hsScalarTriple::InnerProduct(const hsScalarTriple &p) const inline hsScalar hsScalarTriple::InnerProduct(const hsScalarTriple &p) const
{ {
hsScalar tmp = fX*p.fX; hsScalar tmp = fX*p.fX;
tmp += fY*p.fY; tmp += fY*p.fY;
tmp += fZ*p.fZ; tmp += fZ*p.fZ;
return tmp; return tmp;
} }
inline hsScalar hsScalarTriple::InnerProduct(const hsScalarTriple *p) const inline hsScalar hsScalarTriple::InnerProduct(const hsScalarTriple *p) const
{ {
hsScalar tmp = fX*p->fX; hsScalar tmp = fX*p->fX;
tmp += fY*p->fY; tmp += fY*p->fY;
tmp += fZ*p->fZ; tmp += fZ*p->fZ;
return tmp; return tmp;
} }
//inline hsScalarTriple hsScalarTriple::LERP(hsScalarTriple &other, hsScalar t) //inline hsScalarTriple hsScalarTriple::LERP(hsScalarTriple &other, hsScalar t)
//{ //{
// hsScalarTriple p = other - this; // hsScalarTriple p = other - this;
// p = p / t; // p = p / t;
// return this + p; // return this + p;
//} //}
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
struct hsPoint3 : public hsScalarTriple { struct hsPoint3 : public hsScalarTriple {
hsPoint3() {}; hsPoint3() {};
hsPoint3(hsScalar x, hsScalar y, hsScalar z) : hsScalarTriple(x,y,z) {} hsPoint3(hsScalar x, hsScalar y, hsScalar z) : hsScalarTriple(x,y,z) {}
explicit hsPoint3(const hsScalarTriple& p) : hsScalarTriple(p) {} explicit hsPoint3(const hsScalarTriple& p) : hsScalarTriple(p) {}
hsPoint3* Set(hsScalar x, hsScalar y, hsScalar z) { return (hsPoint3*)this->hsScalarTriple::Set(x,y,z);} hsPoint3* Set(hsScalar x, hsScalar y, hsScalar z) { return (hsPoint3*)this->hsScalarTriple::Set(x,y,z);}
hsPoint3* Set(const hsScalarTriple* p) { return (hsPoint3*)this->hsScalarTriple::Set(p) ;} hsPoint3* Set(const hsScalarTriple* p) { return (hsPoint3*)this->hsScalarTriple::Set(p) ;}
friend inline hsPoint3 operator+(const hsPoint3& s, const hsPoint3& t); friend inline hsPoint3 operator+(const hsPoint3& s, const hsPoint3& t);
friend inline hsPoint3 operator+(const hsPoint3& s, const hsVector3& t); friend inline hsPoint3 operator+(const hsPoint3& s, const hsVector3& t);
friend inline hsPoint3 operator-(const hsPoint3& s, const hsPoint3& t); friend inline hsPoint3 operator-(const hsPoint3& s, const hsPoint3& t);
friend inline hsPoint3 operator-(const hsPoint3& s); friend inline hsPoint3 operator-(const hsPoint3& s);
friend inline hsPoint3 operator*(const hsScalar& s, const hsPoint3& t); friend inline hsPoint3 operator*(const hsScalar& s, const hsPoint3& t);
friend inline hsPoint3 operator*(const hsPoint3& t, const hsScalar& s); friend inline hsPoint3 operator*(const hsPoint3& t, const hsScalar& s);
friend inline hsPoint3 operator/(const hsPoint3& t, const hsScalar& s); friend inline hsPoint3 operator/(const hsPoint3& t, const hsScalar& s);
hsBool operator==(const hsPoint3& ss) const hsBool operator==(const hsPoint3& ss) const
{ {
return (ss.fX == fX && ss.fY == fY && ss.fZ == fZ); return (ss.fX == fX && ss.fY == fY && ss.fZ == fZ);
} }
hsBool operator!=(const hsPoint3& ss) const { return !(*this == ss); } hsBool operator!=(const hsPoint3& ss) const { return !(*this == ss); }
hsPoint3 &operator+=(const hsScalarTriple &s) { fX += s.fX; fY += s.fY; fZ += s.fZ; return *this; } hsPoint3 &operator+=(const hsScalarTriple &s) { fX += s.fX; fY += s.fY; fZ += s.fZ; return *this; }
hsPoint3 &operator*=(const hsScalar s) { fX *= s; fY *= s; fZ *= s; return *this; } hsPoint3 &operator*=(const hsScalar s) { fX *= s; fY *= s; fZ *= s; return *this; }
} ATTRIBUTE_FOR_PS2; /* SUNSOFT */ } ATTRIBUTE_FOR_PS2; /* SUNSOFT */
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
struct hsVector3 : public hsScalarTriple { struct hsVector3 : public hsScalarTriple {
hsVector3() {}; hsVector3() {};
hsVector3(hsScalar x, hsScalar y, hsScalar z) : hsScalarTriple(x,y,z) {} hsVector3(hsScalar x, hsScalar y, hsScalar z) : hsScalarTriple(x,y,z) {}
explicit hsVector3(const hsScalarTriple& p) : hsScalarTriple(p) { } explicit hsVector3(const hsScalarTriple& p) : hsScalarTriple(p) { }
hsVector3(const hsPoint3 *p1, const hsPoint3 *p2) { hsVector3(const hsPoint3 *p1, const hsPoint3 *p2) {
fX = p1->fX - p2->fX, fY= p1->fY - p2->fY, fZ = p1->fZ - p2->fZ; } fX = p1->fX - p2->fX, fY= p1->fY - p2->fY, fZ = p1->fZ - p2->fZ; }
hsVector3* Set(hsScalar x, hsScalar y, hsScalar z) { return (hsVector3*)hsScalarTriple::Set(x,y,z); } hsVector3* Set(hsScalar x, hsScalar y, hsScalar z) { return (hsVector3*)hsScalarTriple::Set(x,y,z); }
hsVector3* Set(const hsScalarTriple* p) { return (hsVector3*)hsScalarTriple::Set(p) ;} hsVector3* Set(const hsScalarTriple* p) { return (hsVector3*)hsScalarTriple::Set(p) ;}
hsVector3* Set(const hsScalarTriple* p1, const hsScalarTriple* p2) { return Set(p1->fX-p2->fX,p1->fY-p2->fY,p1->fZ-p2->fZ);} hsVector3* Set(const hsScalarTriple* p1, const hsScalarTriple* p2) { return Set(p1->fX-p2->fX,p1->fY-p2->fY,p1->fZ-p2->fZ);}
void Normalize() void Normalize()
{ {
#if HS_BUILD_FOR_PS2 #if HS_BUILD_FOR_PS2
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)
return; return;
NormalizeVU0(length, (MATRIX4)this); NormalizeVU0(length, (MATRIX4)this);
#else #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)
return; return;
hsScalar invMag = hsScalarInvert(length); hsScalar invMag = hsScalarInvert(length);
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 #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
{ {
hsScalar mag2 = *this * *this; hsScalar mag2 = *this * *this;
hsIfDebugMessage(mag2 == 0, "Err: Renormalizing hsVector3 of length 0", 0); hsIfDebugMessage(mag2 == 0, "Err: Renormalizing hsVector3 of length 0", 0);
if (mag2 == 0) if (mag2 == 0)
return; return;
hsScalar invMag = hsInvSqrt(mag2); hsScalar invMag = hsInvSqrt(mag2);
fX = hsScalarMul(fX, invMag); fX = hsScalarMul(fX, invMag);
fY = hsScalarMul(fY, invMag); fY = hsScalarMul(fY, invMag);
fZ = hsScalarMul(fZ, invMag); fZ = hsScalarMul(fZ, invMag);
} }
// hsVector3 &Sub(const hsPoint3& s, const hsPoint3& t) // hsVector3 &Sub(const hsPoint3& s, const hsPoint3& t)
// { Set(s.fX - t.fX, s.fY - t.fY, s.fZ - t.fZ); // { Set(s.fX - t.fX, s.fY - t.fY, s.fZ - t.fZ);
// return *this; }; // return *this; };
friend inline hsVector3 operator+(const hsVector3& s, const hsVector3& t); friend inline hsVector3 operator+(const hsVector3& s, const hsVector3& t);
friend inline hsVector3 operator-(const hsVector3& s, const hsVector3& t); friend inline hsVector3 operator-(const hsVector3& s, const hsVector3& t);
friend inline hsVector3 operator-(const hsVector3& s); friend inline hsVector3 operator-(const hsVector3& s);
friend inline hsVector3 operator*(const hsScalar& s, const hsVector3& t); friend inline hsVector3 operator*(const hsScalar& s, const hsVector3& t);
friend inline hsVector3 operator*(const hsVector3& t, const hsScalar& s); friend inline hsVector3 operator*(const hsVector3& t, const hsScalar& s);
friend inline hsVector3 operator/(const hsVector3& t, const hsScalar& s); friend inline hsVector3 operator/(const hsVector3& t, const hsScalar& s);
friend inline hsScalar operator*(const hsVector3& t, const hsVector3& s); friend inline hsScalar operator*(const hsVector3& t, const hsVector3& s);
friend hsVector3 operator%(const hsVector3& t, const hsVector3& s); friend hsVector3 operator%(const hsVector3& t, const hsVector3& s);
#if 0 // Havok reeks #if 0 // Havok reeks
friend hsBool32 operator==(const hsVector3& s, const hsVector3& t) friend hsBool32 operator==(const hsVector3& s, const hsVector3& t)
{ {
return (s.fX == t.fX && s.fY == t.fY && s.fZ == t.fZ); return (s.fX == t.fX && s.fY == t.fY && s.fZ == t.fZ);
} }
#else // Havok reeks #else // Havok reeks
hsBool operator==(const hsVector3& ss) const hsBool operator==(const hsVector3& ss) const
{ {
return (ss.fX == fX && ss.fY == fY && ss.fZ == fZ); return (ss.fX == fX && ss.fY == fY && ss.fZ == fZ);
} }
#endif // Havok reeks #endif // Havok reeks
hsVector3 &operator+=(const hsScalarTriple &s) { fX += s.fX; fY += s.fY; fZ += s.fZ; return *this; } hsVector3 &operator+=(const hsScalarTriple &s) { fX += s.fX; fY += s.fY; fZ += s.fZ; return *this; }
hsVector3 &operator-=(const hsScalarTriple &s) { fX -= s.fX; fY -= s.fY; fZ -= s.fZ; return *this; } hsVector3 &operator-=(const hsScalarTriple &s) { fX -= s.fX; fY -= s.fY; fZ -= s.fZ; return *this; }
hsVector3 &operator*=(const hsScalar s) { fX *= s; fY *= s; fZ *= s; return *this; } hsVector3 &operator*=(const hsScalar s) { fX *= s; fY *= s; fZ *= s; return *this; }
hsVector3 &operator/=(const hsScalar s) { fX /= s; fY /= s; fZ /= s; return *this; } hsVector3 &operator/=(const hsScalar s) { fX /= s; fY /= s; fZ /= s; return *this; }
} ATTRIBUTE_FOR_PS2; /* SUNSOFT */ } ATTRIBUTE_FOR_PS2; /* SUNSOFT */
struct hsPoint4 { struct hsPoint4 {
hsScalar fX, fY, fZ, fW; hsScalar fX, fY, fZ, fW;
hsPoint4() {} hsPoint4() {}
hsPoint4(hsScalar x, hsScalar y, hsScalar z, hsScalar w) : fX(x), fY(y), fZ(z), fW(w) {} hsPoint4(hsScalar x, hsScalar y, hsScalar z, hsScalar w) : fX(x), fY(y), fZ(z), fW(w) {}
hsScalar& operator[](int i); hsScalar& operator[](int i);
hsScalar operator[](int i) const; hsScalar operator[](int i) const;
hsPoint4& operator=(const hsPoint3&p) { Set(p.fX, p.fY, p.fZ, hsScalar1); return *this; } hsPoint4& operator=(const hsPoint3&p) { Set(p.fX, p.fY, p.fZ, hsScalar1); return *this; }
hsPoint4* Set(hsScalar x, hsScalar y, hsScalar z, hsScalar w) hsPoint4* Set(hsScalar x, hsScalar y, hsScalar z, hsScalar w)
{ fX = x; fY = y; fZ = z; fW = w; return this; } { fX = x; fY = y; fZ = z; fW = w; return this; }
} ATTRIBUTE_FOR_PS2; /* SUNSOFT */ } ATTRIBUTE_FOR_PS2; /* SUNSOFT */
inline hsVector3 operator+(const hsVector3& s, const hsVector3& t) inline hsVector3 operator+(const hsVector3& s, const hsVector3& t)
{ {
hsVector3 result; hsVector3 result;
return *result.Set(s.fX + t.fX, s.fY + t.fY, s.fZ + t.fZ); return *result.Set(s.fX + t.fX, s.fY + t.fY, s.fZ + t.fZ);
} }
inline hsVector3 operator-(const hsVector3& s, const hsVector3& t) inline hsVector3 operator-(const hsVector3& s, const hsVector3& t)
{ {
hsVector3 result; hsVector3 result;
return *result.Set(s.fX - t.fX, s.fY - t.fY, s.fZ - t.fZ); return *result.Set(s.fX - t.fX, s.fY - t.fY, s.fZ - t.fZ);
} }
// unary minus // unary minus
inline hsVector3 operator-(const hsVector3& s) inline hsVector3 operator-(const hsVector3& s)
{ {
hsVector3 result; hsVector3 result;
return *result.Set(-s.fX, -s.fY, -s.fZ); return *result.Set(-s.fX, -s.fY, -s.fZ);
} }
inline hsVector3 operator*(const hsVector3& s, const hsScalar& t) inline hsVector3 operator*(const hsVector3& s, const hsScalar& t)
{ {
hsVector3 result; hsVector3 result;
return *result.Set(hsScalarMul(s.fX, t), hsScalarMul(s.fY, t), hsScalarMul(s.fZ, t)); return *result.Set(hsScalarMul(s.fX, t), hsScalarMul(s.fY, t), hsScalarMul(s.fZ, t));
} }
inline hsVector3 operator/(const hsVector3& s, const hsScalar& t) inline hsVector3 operator/(const hsVector3& s, const hsScalar& t)
{ {
hsVector3 result; hsVector3 result;
return *result.Set(hsScalarDiv(s.fX, t), hsScalarDiv(s.fY, t), hsScalarDiv(s.fZ, t)); return *result.Set(hsScalarDiv(s.fX, t), hsScalarDiv(s.fY, t), hsScalarDiv(s.fZ, t));
} }
inline hsVector3 operator*(const hsScalar& t, const hsVector3& s) inline hsVector3 operator*(const hsScalar& t, const hsVector3& s)
{ {
hsVector3 result; hsVector3 result;
return *result.Set(hsScalarMul(s.fX, t), hsScalarMul(s.fY, t), hsScalarMul(s.fZ, t)); return *result.Set(hsScalarMul(s.fX, t), hsScalarMul(s.fY, t), hsScalarMul(s.fZ, t));
} }
inline hsScalar operator*(const hsVector3& t, const hsVector3& s) inline hsScalar operator*(const hsVector3& t, const hsVector3& s)
{ {
return hsScalarMul(t.fX, s.fX) + hsScalarMul(t.fY, s.fY) + hsScalarMul(t.fZ, s.fZ); return hsScalarMul(t.fX, s.fX) + hsScalarMul(t.fY, s.fY) + hsScalarMul(t.fZ, s.fZ);
} }
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
inline hsPoint3 operator+(const hsPoint3& s, const hsPoint3& t) inline hsPoint3 operator+(const hsPoint3& s, const hsPoint3& t)
{ {
hsPoint3 result; hsPoint3 result;
return *result.Set(s.fX + t.fX, s.fY + t.fY, s.fZ + t.fZ); return *result.Set(s.fX + t.fX, s.fY + t.fY, s.fZ + t.fZ);
} }
inline hsPoint3 operator+(const hsPoint3& s, const hsVector3& t) inline hsPoint3 operator+(const hsPoint3& s, const hsVector3& t)
{ {
hsPoint3 result; hsPoint3 result;
return *result.Set(s.fX + t.fX, s.fY + t.fY, s.fZ + t.fZ); return *result.Set(s.fX + t.fX, s.fY + t.fY, s.fZ + t.fZ);
} }
inline hsPoint3 operator-(const hsPoint3& s, const hsPoint3& t) inline hsPoint3 operator-(const hsPoint3& s, const hsPoint3& t)
{ {
hsPoint3 result; hsPoint3 result;
return *result.Set(s.fX - t.fX, s.fY - t.fY, s.fZ - t.fZ); return *result.Set(s.fX - t.fX, s.fY - t.fY, s.fZ - t.fZ);
} }
// unary - // unary -
inline hsPoint3 operator-(const hsPoint3& s) inline hsPoint3 operator-(const hsPoint3& s)
{ {
hsPoint3 result; hsPoint3 result;
return *result.Set(-s.fX, -s.fY, -s.fZ); return *result.Set(-s.fX, -s.fY, -s.fZ);
} }
inline hsPoint3 operator-(const hsPoint3& s, const hsVector3& t) inline hsPoint3 operator-(const hsPoint3& s, const hsVector3& t)
{ {
hsPoint3 result; hsPoint3 result;
return *result.Set(s.fX - t.fX, s.fY - t.fY, s.fZ - t.fZ); return *result.Set(s.fX - t.fX, s.fY - t.fY, s.fZ - t.fZ);
} }
inline hsPoint3 operator*(const hsPoint3& s, const hsScalar& t) inline hsPoint3 operator*(const hsPoint3& s, const hsScalar& t)
{ {
hsPoint3 result; hsPoint3 result;
return *result.Set(hsScalarMul(s.fX, t), hsScalarMul(s.fY, t), hsScalarMul(s.fZ, t)); return *result.Set(hsScalarMul(s.fX, t), hsScalarMul(s.fY, t), hsScalarMul(s.fZ, t));
} }
inline hsPoint3 operator/(const hsPoint3& s, const hsScalar& t) inline hsPoint3 operator/(const hsPoint3& s, const hsScalar& t)
{ {
hsPoint3 result; hsPoint3 result;
return *result.Set(hsScalarDiv(s.fX, t), hsScalarDiv(s.fY, t), hsScalarDiv(s.fZ, t)); return *result.Set(hsScalarDiv(s.fX, t), hsScalarDiv(s.fY, t), hsScalarDiv(s.fZ, t));
} }
inline hsPoint3 operator*(const hsScalar& t, const hsPoint3& s) inline hsPoint3 operator*(const hsScalar& t, const hsPoint3& s)
{ {
hsPoint3 result; hsPoint3 result;
return *result.Set(hsScalarMul(s.fX, t), hsScalarMul(s.fY, t), hsScalarMul(s.fZ, t)); return *result.Set(hsScalarMul(s.fX, t), hsScalarMul(s.fY, t), hsScalarMul(s.fZ, t));
} }
inline hsScalar hsPoint4::operator[] (int i) const inline hsScalar hsPoint4::operator[] (int i) const
{ {
hsAssert(i >=0 && i <4, "Bad index for hsPoint4::operator[]"); hsAssert(i >=0 && i <4, "Bad index for hsPoint4::operator[]");
return *(&fX + i); return *(&fX + i);
} }
inline hsScalar& hsPoint4::operator[] (int i) inline hsScalar& hsPoint4::operator[] (int i)
{ {
hsAssert(i >=0 && i <4, "Bad index for hsPoint4::operator[]"); hsAssert(i >=0 && i <4, "Bad index for hsPoint4::operator[]");
return *(&fX + i); return *(&fX + i);
} }
typedef hsPoint3 hsGUv; typedef hsPoint3 hsGUv;
@ -466,31 +466,31 @@ typedef hsPoint3 hsGUv;
struct hsPointNorm { struct hsPointNorm {
hsPoint3 fPos; hsPoint3 fPos;
hsVector3 fNorm; hsVector3 fNorm;
void Read(hsStream* s) { fPos.Read(s); fNorm.Read(s); } void Read(hsStream* s) { fPos.Read(s); fNorm.Read(s); }
void Write(hsStream* s) const { fPos.Write(s); fNorm.Write(s); } void Write(hsStream* s) const { fPos.Write(s); fNorm.Write(s); }
} ATTRIBUTE_FOR_PS2; /* SUNSOFT */ } ATTRIBUTE_FOR_PS2; /* SUNSOFT */
struct hsPlane3 { struct hsPlane3 {
hsVector3 fN; hsVector3 fN;
hsScalar fD; hsScalar fD;
hsPlane3() { } hsPlane3() { }
hsPlane3(const hsVector3* nrml, hsScalar d) hsPlane3(const hsVector3* nrml, hsScalar d)
{ fN = *nrml; fD=d; } { fN = *nrml; fD=d; }
hsPlane3(const hsPoint3* pt, const hsVector3* nrml) hsPlane3(const hsPoint3* pt, const hsVector3* nrml)
{ fN = *nrml; fD = -pt->InnerProduct(nrml); } { fN = *nrml; fD = -pt->InnerProduct(nrml); }
// create plane from a triangle (assumes clockwise winding of vertices) // create plane from a triangle (assumes clockwise winding of vertices)
hsPlane3(const hsPoint3* pt1, const hsPoint3* pt2, const hsPoint3* pt3); hsPlane3(const hsPoint3* pt1, const hsPoint3* pt2, const hsPoint3* pt3);
hsVector3 GetNormal() const { return fN; } hsVector3 GetNormal() const { return fN; }
void Read(hsStream *stream); void Read(hsStream *stream);
void Write(hsStream *stream) const; void Write(hsStream *stream) const;
} ATTRIBUTE_FOR_PS2; } ATTRIBUTE_FOR_PS2;
#endif #endif

162
Sources/Plasma/CoreLib/hsHashTable.h
View File

@ -34,24 +34,24 @@ template <class T>
class hsHashTableIterator class hsHashTableIterator
{ {
public: public:
hsHashTableIterator() : fList(nil), fIndex(-1) { } hsHashTableIterator() : fList(nil), fIndex(-1) { }
explicit hsHashTableIterator(hsTArray<T>* list, UInt32 idx) : fList(list), fIndex(idx) { } explicit hsHashTableIterator(hsTArray<T>* list, UInt32 idx) : fList(list), fIndex(idx) { }
T* operator->() const { return &((*fList)[fIndex]); } T* operator->() const { return &((*fList)[fIndex]); }
T& operator*() const { return (*fList)[fIndex]; } T& operator*() const { return (*fList)[fIndex]; }
hsHashTableIterator<T>& operator++() { fIndex--; return *this; } hsHashTableIterator<T>& operator++() { fIndex--; return *this; }
const hsHashTableIterator<T>& operator++(int) { hsHashTableIterator<T> temp(*this); --(*this); return temp; } const hsHashTableIterator<T>& operator++(int) { hsHashTableIterator<T> temp(*this); --(*this); return temp; }
hsHashTableIterator<T>& operator--() { fIndex++; return *this; } hsHashTableIterator<T>& operator--() { fIndex++; return *this; }
const hsHashTableIterator<T>& operator--(int) { hsHashTableIterator<T> temp(*this); ++(*this); return temp; } const hsHashTableIterator<T>& operator--(int) { hsHashTableIterator<T> temp(*this); ++(*this); return temp; }
hsBool operator==(const hsHashTableIterator<T>& other) const { return fList==other.fList && fIndex==other.fIndex; } hsBool operator==(const hsHashTableIterator<T>& other) const { return fList==other.fList && fIndex==other.fIndex; }
hsBool operator!=(const hsHashTableIterator<T>& other) const { return !(*this == other); } hsBool operator!=(const hsHashTableIterator<T>& other) const { return !(*this == other); }
private: private:
hsTArray<T>* fList; hsTArray<T>* fList;
UInt32 fIndex; UInt32 fIndex;
}; };
@ -59,37 +59,37 @@ template <class T>
class hsHashTable class hsHashTable
{ {
public: public:
hsHashTable(UInt32 size=150001, UInt32 step=1); hsHashTable(UInt32 size=150001, UInt32 step=1);
~hsHashTable(); ~hsHashTable();
typedef hsHashTableIterator<T> iterator; typedef hsHashTableIterator<T> iterator;
iterator begin() { return iterator(&fItemList,fItemList.Count()-1); } iterator begin() { return iterator(&fItemList,fItemList.Count()-1); }
iterator end() { return iterator(&fItemList,0); } iterator end() { return iterator(&fItemList,0); }
void clear(); void clear();
UInt32 count() { return fItemList.Count()-1; } UInt32 count() { return fItemList.Count()-1; }
UInt32 size() { return fSize; } UInt32 size() { return fSize; }
UInt32 CollisionCount() { return fCollisionCount; } UInt32 CollisionCount() { return fCollisionCount; }
inline void insert(T& item); inline void insert(T& item);
inline void erase(T& item); inline void erase(T& item);
inline iterator find(const T& item); inline iterator find(const T& item);
iterator GetItem(UInt32 i); iterator GetItem(UInt32 i);
private: private:
hsTArray<T> fItemList; hsTArray<T> fItemList;
hsTArray<UInt32> fClearList; hsTArray<UInt32> fClearList;
UInt32* fHashTable; UInt32* fHashTable;
UInt32 fSize; UInt32 fSize;
UInt32 fCollisionStep; UInt32 fCollisionStep;
UInt32 fCollisionCount; UInt32 fCollisionCount;
// No copy or assignment // No copy or assignment
hsHashTable(const hsHashTable&); hsHashTable(const hsHashTable&);
hsHashTable &operator=(const hsHashTable&); hsHashTable &operator=(const hsHashTable&);
}; };
@ -99,85 +99,85 @@ fSize(size),
fCollisionStep(step), fCollisionStep(step),
fCollisionCount(0) fCollisionCount(0)
{ {
fItemList.SetCount(1); fItemList.SetCount(1);
fHashTable = TRACKED_NEW UInt32[fSize]; fHashTable = TRACKED_NEW UInt32[fSize];
memset(fHashTable,0,fSize*sizeof(UInt32)); memset(fHashTable,0,fSize*sizeof(UInt32));
} }
template <class T> template <class T>
hsHashTable<T>::~hsHashTable() hsHashTable<T>::~hsHashTable()
{ {
delete [] fHashTable; delete [] fHashTable;
} }
template <class T> template <class T>
void hsHashTable<T>::clear() void hsHashTable<T>::clear()
{ {
fItemList.SetCount(1); fItemList.SetCount(1);
for (Int32 i=0; i<fClearList.Count(); i++) for (Int32 i=0; i<fClearList.Count(); i++)
fHashTable[ fClearList[i] ] = 0; fHashTable[ fClearList[i] ] = 0;
fClearList.Reset(); fClearList.Reset();
} }
template <class T> template <class T>
void hsHashTable<T>::insert(T& item) void hsHashTable<T>::insert(T& item)
{ {
hsAssert(fClearList.Count() < fSize,"Hash table overflow! Increase the table size."); hsAssert(fClearList.Count() < fSize,"Hash table overflow! Increase the table size.");
UInt32 h = item.GetHash(); UInt32 h = item.GetHash();
h %= fSize; h %= fSize;
while (UInt32 it = fHashTable[h]) while (UInt32 it = fHashTable[h])
{ {
if ( fItemList[it] == item) if ( fItemList[it] == item)
{ {
fItemList[it] = item; fItemList[it] = item;
return; return;
} }
h += fCollisionStep; h += fCollisionStep;
h %= fSize; h %= fSize;
fCollisionCount++; fCollisionCount++;
} }
fHashTable[h] = fItemList.Count(); fHashTable[h] = fItemList.Count();
fItemList.Append(item); fItemList.Append(item);
fClearList.Append(h); fClearList.Append(h);
} }
template <class T> template <class T>
void hsHashTable<T>::erase(T& item) void hsHashTable<T>::erase(T& item)
{ {
UInt32 h = item.GetHash(); UInt32 h = item.GetHash();
h %= fSize; h %= fSize;
while (UInt32 it = fHashTable[h]) while (UInt32 it = fHashTable[h])
{ {
if ( fItemList[it] == item ) if ( fItemList[it] == item )
{ {
fHashTable[h] = 0; fHashTable[h] = 0;
return; return;
} }
} }
} }
template <class T> template <class T>
hsHashTableIterator<T> hsHashTable<T>::find(const T& item) hsHashTableIterator<T> hsHashTable<T>::find(const T& item)
{ {
UInt32 h = item.GetHash(); UInt32 h = item.GetHash();
h %= fSize; h %= fSize;
while (UInt32 it = fHashTable[h]) while (UInt32 it = fHashTable[h])
{ {
if ( fItemList[it] == item ) if ( fItemList[it] == item )
{ {
return iterator(&fItemList,it); return iterator(&fItemList,it);
} }
h += fCollisionStep; h += fCollisionStep;
h %= fSize; h %= fSize;
fCollisionCount++; fCollisionCount++;
} }
return end(); return end();
} }
template <class T> template <class T>
hsHashTableIterator<T> hsHashTable<T>::GetItem(UInt32 i) hsHashTableIterator<T> hsHashTable<T>::GetItem(UInt32 i)
{ {
return iterator(&fItemList,i+1); return iterator(&fItemList,i+1);
} }
#endif // _hsHashTable_Included_ #endif // _hsHashTable_Included_

14
Sources/Plasma/CoreLib/hsLOD.h
View File

@ -28,13 +28,13 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
namespace hsLOD namespace hsLOD
{ {
enum enum
{ {
kLODNone = 0x00000000, kLODNone = 0x00000000,
kLODLow = 0x00000001, kLODLow = 0x00000001,
kLODHigh = 0x00000002, kLODHigh = 0x00000002,
kLODAll = kLODLow | kLODHigh kLODAll = kLODLow | kLODHigh
}; };
} }
#endif // hsLOD_inc #endif // hsLOD_inc

48
Sources/Plasma/CoreLib/hsMMIOStream.cpp
View File

@ -33,57 +33,57 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
UInt32 hsMMIOStream::Read(UInt32 bytes, void* buffer) UInt32 hsMMIOStream::Read(UInt32 bytes, void* buffer)
{ {
fBytesRead += bytes; fBytesRead += bytes;
fPosition += bytes; fPosition += bytes;
int numItems = ::mmioRead(fHmfr, (char*)buffer, bytes); int numItems = ::mmioRead(fHmfr, (char*)buffer, bytes);
if ((unsigned)numItems < bytes) if ((unsigned)numItems < bytes)
{ {
if (numItems>=0 && ::mmioSeek(fHmfr,0,SEEK_CUR)==::mmioSeek(fHmfr,0,SEEK_END)) { if (numItems>=0 && ::mmioSeek(fHmfr,0,SEEK_CUR)==::mmioSeek(fHmfr,0,SEEK_END)) {
// EOF ocurred // EOF ocurred
char str[128]; char str[128];
sprintf(str, "Hit EOF on MMIO Read, only read %d out of requested %d bytes\n", numItems, bytes); sprintf(str, "Hit EOF on MMIO Read, only read %d out of requested %d bytes\n", numItems, bytes);
hsDebugMessage(str, 0); hsDebugMessage(str, 0);
} }
else else
{ {
hsDebugMessage("Error on MMIO Read",0); hsDebugMessage("Error on MMIO Read",0);
} }
} }
return numItems; return numItems;
} }
hsBool hsMMIOStream::AtEnd() hsBool hsMMIOStream::AtEnd()
{ {
return (::mmioSeek(fHmfr,0,SEEK_CUR)==::mmioSeek(fHmfr,0,SEEK_END)); return (::mmioSeek(fHmfr,0,SEEK_CUR)==::mmioSeek(fHmfr,0,SEEK_END));
} }
UInt32 hsMMIOStream::Write(UInt32 bytes, const void* buffer) UInt32 hsMMIOStream::Write(UInt32 bytes, const void* buffer)
{ {
fPosition += bytes; fPosition += bytes;
return ::mmioWrite(fHmfr,(const char*)buffer,bytes); return ::mmioWrite(fHmfr,(const char*)buffer,bytes);
} }
void hsMMIOStream::Skip(UInt32 delta) void hsMMIOStream::Skip(UInt32 delta)
{ {
fBytesRead += delta; fBytesRead += delta;
fPosition += delta; fPosition += delta;
(void)::mmioSeek(fHmfr, delta, SEEK_CUR); (void)::mmioSeek(fHmfr, delta, SEEK_CUR);
} }
void hsMMIOStream::Rewind() void hsMMIOStream::Rewind()
{ {
fBytesRead = 0; fBytesRead = 0;
fPosition = 0; fPosition = 0;
(void)::mmioSeek(fHmfr, 0, SEEK_SET); (void)::mmioSeek(fHmfr, 0, SEEK_SET);
} }
void hsMMIOStream::FastFwd() void hsMMIOStream::FastFwd()
{ {
fBytesRead = fPosition = ::mmioSeek(fHmfr, 0, SEEK_END); fBytesRead = fPosition = ::mmioSeek(fHmfr, 0, SEEK_END);
} }
void hsMMIOStream::Truncate() void hsMMIOStream::Truncate()
{ {
hsThrow("Truncate unimplemented by subclass of stream"); hsThrow("Truncate unimplemented by subclass of stream");
} }
#endif #endif

24
Sources/Plasma/CoreLib/hsMMIOStream.h
View File

@ -35,22 +35,22 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
class hsMMIOStream: public hsStream class hsMMIOStream: public hsStream
{ {
HMMIO fHmfr; HMMIO fHmfr;
public: public:
virtual hsBool Open(const char *, const char *) { hsAssert(0, "hsMMIOStream::Open NotImplemented"); return false; } virtual hsBool Open(const char *, const char *) { hsAssert(0, "hsMMIOStream::Open NotImplemented"); return false; }
virtual hsBool Close() { hsAssert(0, "hsMMIOStream::Close NotImplemented"); return false; } virtual hsBool Close() { hsAssert(0, "hsMMIOStream::Close NotImplemented"); return false; }
virtual hsBool AtEnd(); virtual hsBool AtEnd();
virtual UInt32 Read(UInt32 byteCount, void* buffer); virtual UInt32 Read(UInt32 byteCount, void* buffer);
virtual UInt32 Write(UInt32 byteCount, const void* buffer); virtual UInt32 Write(UInt32 byteCount, const void* buffer);
virtual void Skip(UInt32 deltaByteCount); virtual void Skip(UInt32 deltaByteCount);
virtual void Rewind(); virtual void Rewind();
virtual void FastFwd(); virtual void FastFwd();
virtual void Truncate(); virtual void Truncate();
HMMIO GetHandle() { return fHmfr; } HMMIO GetHandle() { return fHmfr; }
void SetHandle(HMMIO handle) { fHmfr = handle; } void SetHandle(HMMIO handle) { fHmfr = handle; }
}; };
#endif // hsMMIOStream_inc #endif // hsMMIOStream_inc

38
Sources/Plasma/CoreLib/hsMalloc.h
View File

@ -44,9 +44,9 @@ extern "C" {
#endif #endif
// MemAlloc flags // MemAlloc flags
extern const unsigned kMemReallocInPlaceOnly; // use _expand when realloc'ing extern const unsigned kMemReallocInPlaceOnly; // use _expand when realloc'ing
extern const unsigned kMemZero; // fill allocated memory with zeros extern const unsigned kMemZero; // fill allocated memory with zeros
extern const unsigned kMemIgnoreBlock; // don't track this allocation extern const unsigned kMemIgnoreBlock; // don't track this allocation
void * MemAlloc (unsigned bytes, unsigned flags, const char file[], int line); void * MemAlloc (unsigned bytes, unsigned flags, const char file[], int line);
@ -123,27 +123,27 @@ inline void __cdecl operator delete (void *, void *) {}
* *
***/ ***/
#define ALLOC(b) MemAlloc(b, 0, __FILE__, __LINE__) #define ALLOC(b) MemAlloc(b, 0, __FILE__, __LINE__)
#define ALLOCZERO(b) MemAlloc(b, kMemZero, __FILE__, __LINE__) #define ALLOCZERO(b) MemAlloc(b, kMemZero, __FILE__, __LINE__)
#define ALLOCFLAGS(b, f) MemAlloc(b, (f), __FILE__, __LINE__) #define ALLOCFLAGS(b, f) MemAlloc(b, (f), __FILE__, __LINE__)
#define FREE(p) MemFree(p, 0) #define FREE(p) MemFree(p, 0)
#define FREEFLAGS(p, f) MemFree(p, (f)) #define FREEFLAGS(p, f) MemFree(p, (f))
#define REALLOC(p, b) MemRealloc(p, b, 0, __FILE__, __LINE__) #define REALLOC(p, b) MemRealloc(p, b, 0, __FILE__, __LINE__)
#define REALLOCFLAGS(p, b, f) MemRealloc(p, b, (f), __FILE__, __LINE__) #define REALLOCFLAGS(p, b, f) MemRealloc(p, b, (f), __FILE__, __LINE__)
#define CALLOC(n, s) MemAlloc((n)*(s), kMemZero, __FILE__, __LINE__) #define CALLOC(n, s) MemAlloc((n)*(s), kMemZero, __FILE__, __LINE__)
#define MEMDUP(s, b) MemDup(s, b, 0, __FILE__, __LINE__) #define MEMDUP(s, b) MemDup(s, b, 0, __FILE__, __LINE__)
#define ZERO(s) MemSet(&s, 0, sizeof(s)) #define ZERO(s) MemSet(&s, 0, sizeof(s))
#define ZEROPTR(p) MemSet(p, 0, sizeof(*p)) #define ZEROPTR(p) MemSet(p, 0, sizeof(*p))
// Client must #include <malloc.h> // Client must #include <malloc.h>
#define ALLOCA(t, n) (t *)_alloca((n) * sizeof(t)) #define ALLOCA(t, n) (t *)_alloca((n) * sizeof(t))
#ifdef __cplusplus #ifdef __cplusplus
#define NEW(t) new(MemAlloc(sizeof(t), 0, __FILE__, __LINE__)) t #define NEW(t) new(MemAlloc(sizeof(t), 0, __FILE__, __LINE__)) t
#define NEWFLAGS(t, f) new(MemAlloc(sizeof(t), (f), __FILE__, __LINE__)) t #define NEWFLAGS(t, f) new(MemAlloc(sizeof(t), (f), __FILE__, __LINE__)) t
#define NEWZERO(t) new(MemAlloc(sizeof(t), kMemZero, __FILE__, __LINE__)) t #define NEWZERO(t) new(MemAlloc(sizeof(t), kMemZero, __FILE__, __LINE__)) t
#define DEL(t) delete (t) #define DEL(t) delete (t)
#endif // __cplusplus #endif // __cplusplus

78
Sources/Plasma/CoreLib/hsMatrix33.cpp
View File

@ -30,68 +30,68 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
hsMatrix33* hsMatrix33::Reset() hsMatrix33* hsMatrix33::Reset()
{ {
static const hsMatrix33 gIdentity = { 1, 0, 0, 0, 1, 0, 0, 0, 1 }; static const hsMatrix33 gIdentity = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
*this = gIdentity; *this = gIdentity;
return this; return this;
} }
hsMatrix33* hsMatrix33::SetConcat(const hsMatrix33* a, const hsMatrix33* b) hsMatrix33* hsMatrix33::SetConcat(const hsMatrix33* a, const hsMatrix33* b)
{ {
hsMatrix33 tmpMatrix; hsMatrix33 tmpMatrix;
hsMatrix33* c; hsMatrix33* c;
c = this; c = this;
if (this == a || this == b) if (this == a || this == b)
c = &tmpMatrix; c = &tmpMatrix;
c->fMap[0][0] = a->fMap[0][0] * b->fMap[0][0] + a->fMap[0][1] * b->fMap[1][0] + a->fMap[0][2] * b->fMap[2][0]; c->fMap[0][0] = a->fMap[0][0] * b->fMap[0][0] + a->fMap[0][1] * b->fMap[1][0] + a->fMap[0][2] * b->fMap[2][0];
c->fMap[0][1] = a->fMap[0][0] * b->fMap[0][1] + a->fMap[0][1] * b->fMap[1][1] + a->fMap[0][2] * b->fMap[2][1]; c->fMap[0][1] = a->fMap[0][0] * b->fMap[0][1] + a->fMap[0][1] * b->fMap[1][1] + a->fMap[0][2] * b->fMap[2][1];
c->fMap[0][2] = a->fMap[0][0] * b->fMap[0][2] + a->fMap[0][1] * b->fMap[1][2] + a->fMap[0][2] * b->fMap[2][2]; c->fMap[0][2] = a->fMap[0][0] * b->fMap[0][2] + a->fMap[0][1] * b->fMap[1][2] + a->fMap[0][2] * b->fMap[2][2];
c->fMap[1][0] = a->fMap[1][0] * b->fMap[0][0] + a->fMap[1][1] * b->fMap[1][0] + a->fMap[1][2] * b->fMap[2][0]; c->fMap[1][0] = a->fMap[1][0] * b->fMap[0][0] + a->fMap[1][1] * b->fMap[1][0] + a->fMap[1][2] * b->fMap[2][0];
c->fMap[1][1] = a->fMap[1][0] * b->fMap[0][1] + a->fMap[1][1] * b->fMap[1][1] + a->fMap[1][2] * b->fMap[2][1]; c->fMap[1][1] = a->fMap[1][0] * b->fMap[0][1] + a->fMap[1][1] * b->fMap[1][1] + a->fMap[1][2] * b->fMap[2][1];
c->fMap[1][2] = a->fMap[1][0] * b->fMap[0][2] + a->fMap[1][1] * b->fMap[1][2] + a->fMap[1][2] * b->fMap[2][2]; c->fMap[1][2] = a->fMap[1][0] * b->fMap[0][2] + a->fMap[1][1] * b->fMap[1][2] + a->fMap[1][2] * b->fMap[2][2];
c->fMap[2][0] = a->fMap[2][0] * b->fMap[0][0] + a->fMap[2][1] * b->fMap[1][0] + a->fMap[2][2] * b->fMap[2][0]; c->fMap[2][0] = a->fMap[2][0] * b->fMap[0][0] + a->fMap[2][1] * b->fMap[1][0] + a->fMap[2][2] * b->fMap[2][0];
c->fMap[2][1] = a->fMap[2][0] * b->fMap[0][1] + a->fMap[2][1] * b->fMap[1][1] + a->fMap[2][2] * b->fMap[2][1]; c->fMap[2][1] = a->fMap[2][0] * b->fMap[0][1] + a->fMap[2][1] * b->fMap[1][1] + a->fMap[2][2] * b->fMap[2][1];
c->fMap[2][2] = a->fMap[2][0] * b->fMap[0][2] + a->fMap[2][1] * b->fMap[1][2] + a->fMap[2][2] * b->fMap[2][2]; c->fMap[2][2] = a->fMap[2][0] * b->fMap[0][2] + a->fMap[2][1] * b->fMap[1][2] + a->fMap[2][2] * b->fMap[2][2];
if (this != c) if (this != c)
*this = *c; *this = *c;
return this; return this;
} }
hsMatrix33 operator*(const hsMatrix33& a, const hsMatrix33& b) hsMatrix33 operator*(const hsMatrix33& a, const hsMatrix33& b)
{ {
hsMatrix33 c; hsMatrix33 c;
(void)c.SetConcat(&a, &b); (void)c.SetConcat(&a, &b);
return c; return c;
} }
void hsMatrix33::Read(hsStream* s) void hsMatrix33::Read(hsStream* s)
{ {
int i, j; int i, j;
for( i = 0; i < 3; i++ ) for( i = 0; i < 3; i++ )
{ {
for( j = 0; j < 3; j++ ) for( j = 0; j < 3; j++ )
{ {
fMap[i][j] = s->ReadSwapScalar(); fMap[i][j] = s->ReadSwapScalar();
} }
} }
} }
void hsMatrix33::Write(hsStream* s) void hsMatrix33::Write(hsStream* s)
{ {
int i, j; int i, j;
for( i = 0; i < 3; i++ ) for( i = 0; i < 3; i++ )
{ {
for( j = 0; j < 3; j++ ) for( j = 0; j < 3; j++ )
{ {
s->WriteSwapScalar(fMap[i][j]); s->WriteSwapScalar(fMap[i][j]);
} }
} }
} }

32
Sources/Plasma/CoreLib/hsMatrix33.h
View File

@ -31,26 +31,26 @@ class hsStream;
struct hsMatrix33 struct hsMatrix33
{ {
hsScalar fMap[3][3]; hsScalar fMap[3][3];
hsMatrix33* Reset(); hsMatrix33* Reset();
int operator==(const hsMatrix33& aa) const int operator==(const hsMatrix33& aa) const
{ {
return aa.fMap[0][0] == fMap[0][0] && aa.fMap[0][1] == fMap[0][1] && aa.fMap[0][2] == fMap[0][2] && return aa.fMap[0][0] == fMap[0][0] && aa.fMap[0][1] == fMap[0][1] && aa.fMap[0][2] == fMap[0][2] &&
aa.fMap[1][0] == fMap[1][0] && aa.fMap[1][1] == fMap[1][1] && aa.fMap[1][2] == fMap[1][2] && aa.fMap[1][0] == fMap[1][0] && aa.fMap[1][1] == fMap[1][1] && aa.fMap[1][2] == fMap[1][2] &&
aa.fMap[2][0] == fMap[2][0] && aa.fMap[2][1] == fMap[2][1] && aa.fMap[2][2] == fMap[2][2]; aa.fMap[2][0] == fMap[2][0] && aa.fMap[2][1] == fMap[2][1] && aa.fMap[2][2] == fMap[2][2];
} }
int operator!=(const hsMatrix33& aa) const int operator!=(const hsMatrix33& aa) const
{ {
return !(aa == *this); return !(aa == *this);
} }
hsMatrix33* SetConcat(const hsMatrix33* a, const hsMatrix33* b); hsMatrix33* SetConcat(const hsMatrix33* a, const hsMatrix33* b);
friend hsMatrix33 operator*(const hsMatrix33& a, const hsMatrix33& b); friend hsMatrix33 operator*(const hsMatrix33& a, const hsMatrix33& b);
void Read(hsStream* s); void Read(hsStream* s);
void Write(hsStream* s); void Write(hsStream* s);
}; };
#endif // hsMatrix33_inc #endif // hsMatrix33_inc

Some files were not shown because too many files have changed in this diff Show More