Fix line endings and tabs

CMakeLists.txt

@@ -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)
 
 if(PLASMA_EXTERNAL_RELEASE)
-	add_definitions(-DPLASMA_EXTERNAL_RELEASE)
+    add_definitions(-DPLASMA_EXTERNAL_RELEASE)
 endif(PLASMA_EXTERNAL_RELEASE)
 
 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
              "Dev" "QA" "Test" "Beta" "Live")
 
 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")
-	add_definitions(-DBUILD_TYPE=BUILD_TYPE_QA)
+    add_definitions(-DBUILD_TYPE=BUILD_TYPE_QA)
 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")
-	add_definitions(-DBUILD_TYPE=BUILD_TYPE_BETA)
+    add_definitions(-DBUILD_TYPE=BUILD_TYPE_BETA)
 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")
 
 set(PLASMA_TARGETS "Client"
@@ -46,24 +46,24 @@ set_property(CACHE PLASMA_TARGETS PROPERTY STRINGS
              "Client" "Server" "Patcher" "Ethereal" "NoAvMsgs")
 
 if(PLASMA_TARGETS STREQUAL "Patcher")
-	add_definitions(-DPATCHER)
+    add_definitions(-DPATCHER)
 endif(PLASMA_TARGETS STREQUAL "Patcher")
 
 if(PLASMA_TARGETS STREQUAL "Server")
-	add_definitions(-DSERVER)
+    add_definitions(-DSERVER)
 endif(PLASMA_TARGETS STREQUAL "Server")
 
 if(PLASMA_TARGETS STREQUAL "NoAvMsgs")
-	add_definitions(-DNO_AV_MSGS)
+    add_definitions(-DNO_AV_MSGS)
 endif(PLASMA_TARGETS STREQUAL "NoAvMsgs")
 
 if(PLASMA_TARGETS STREQUAL "Ethereal")
-	add_definitions(-DSTREAM_LOGGER)
+    add_definitions(-DSTREAM_LOGGER)
 endif(PLASMA_TARGETS STREQUAL "Ethereal")
 
 if(MSVC)
-	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-	add_definitions(-D_SCL_SECURE_NO_WARNINGS)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    add_definitions(-D_SCL_SECURE_NO_WARNINGS)
 endif(MSVC)
 
 add_subdirectory(Sources/Plasma)

Sources/Plasma/Apps/plClient/CMakeLists.txt

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

Sources/Plasma/Apps/plClient/plClient.h

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

Sources/Plasma/Apps/plClient/plClientUpdateFormat.h

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

Sources/Plasma/Apps/plClientKey/DllMain.cpp

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

Sources/Plasma/Apps/plClientKey/plClientKey.cpp

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

Sources/Plasma/Apps/plClientKey/plClientKey.def

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

Sources/Plasma/Apps/plClientKey/plClientKey.h

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

Sources/Plasma/Apps/plClientPatcher/CMakeLists.txt

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

Sources/Plasma/Apps/plClientPatcher/plLauncherCallback.h

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

Sources/Plasma/Apps/plFileEncrypt/main.cpp

@@ -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 print_version(){
-	wchar productString[256];
-	ProductString(productString, arrsize(productString));
-	printf("%S\n\n", productString);
+    wchar productString[256];
+    ProductString(productString, arrsize(productString));
+    printf("%S\n\n", productString);
 }
 
 void print_help() {
-	printf("plFileEncrypt - Encrypts and Decrypts Uru Files.\n\n");
-	print_version();
-	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("\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-v|--version\t - Prints build version information\n");
+    printf("plFileEncrypt - Encrypts and Decrypts Uru Files.\n\n");
+    print_version();
+    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("\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-v|--version\t - Prints build version information\n");
 }
 
 
 int main(int argc, char *argv[])
 {
-	bool encrypt = true;
-	const char* dir = ".";
+    bool encrypt = true;
+    const char* dir = ".";
 
-	if (argc > 1)
-	{
-		if (hsStrEQ(argv[1], "encrypt") || hsStrEQ(argv[1], "-e") )
-		{
-			if (argc > 2)
-				dir = argv[2];
-			encrypt = true;
-		}
-		else if (hsStrEQ(argv[1], "decrypt") || hsStrEQ(argv[1], "-d"))
-		{
-			if (argc > 2)
-				dir = argv[2];
-			encrypt = false;
-		}
-		else if(hsStrEQ(argv[1], "--help") || hsStrEQ(argv[1], "-h") || hsStrEQ(argv[1], "-?")  || hsStrEQ(argv[1], "/?"))
-		{
-			print_help();
-			return 0;
-		} 
-		else if (hsStrEQ(argv[1], "-v") || hsStrEQ(argv[1], "--version"))
-		{
-			print_version();			
-			return 0;
-		}
-	}
+    if (argc > 1)
+    {
+        if (hsStrEQ(argv[1], "encrypt") || hsStrEQ(argv[1], "-e") )
+        {
+            if (argc > 2)
+                dir = argv[2];
+            encrypt = true;
+        }
+        else if (hsStrEQ(argv[1], "decrypt") || hsStrEQ(argv[1], "-d"))
+        {
+            if (argc > 2)
+                dir = argv[2];
+            encrypt = false;
+        }
+        else if(hsStrEQ(argv[1], "--help") || hsStrEQ(argv[1], "-h") || hsStrEQ(argv[1], "-?")  || hsStrEQ(argv[1], "/?"))
+        {
+            print_help();
+            return 0;
+        } 
+        else if (hsStrEQ(argv[1], "-v") || hsStrEQ(argv[1], "--version"))
+        {
+            print_version();            
+            return 0;
+        }
+    }
 
-	EncryptFiles(dir, ".age", encrypt);
-	EncryptFiles(dir, ".fni", encrypt);
-	EncryptFiles(dir, ".ini", encrypt);
-	EncryptFiles(dir, ".sdl", encrypt);
-	EncryptFiles(dir, ".csv", encrypt);
-	return 0;
+    EncryptFiles(dir, ".age", encrypt);
+    EncryptFiles(dir, ".fni", encrypt);
+    EncryptFiles(dir, ".ini", encrypt);
+    EncryptFiles(dir, ".sdl", encrypt);
+    EncryptFiles(dir, ".csv", encrypt);
+    return 0;
 }
 
 void EncryptFiles(const char* dir, const char* ext, bool encrypt)
 {
-	char filePath[256];
+    char filePath[256];
 
-	hsFolderIterator folder(dir);
-	while (folder.NextFileSuffix(ext))
-	{
-		folder.GetPathAndName(filePath);
-		if (encrypt)
-		{
-			printf("encrypting: %s\n", folder.GetFileName());
-			plEncryptedStream::FileEncrypt(filePath);
-		}
-		else
-		{ 
-			printf("decrypting: %s\n", folder.GetFileName());
-			plEncryptedStream::FileDecrypt(filePath);
-		}
-	}
+    hsFolderIterator folder(dir);
+    while (folder.NextFileSuffix(ext))
+    {
+        folder.GetPathAndName(filePath);
+        if (encrypt)
+        {
+            printf("encrypting: %s\n", folder.GetFileName());
+            plEncryptedStream::FileEncrypt(filePath);
+        }
+        else
+        { 
+            printf("decrypting: %s\n", folder.GetFileName());
+            plEncryptedStream::FileDecrypt(filePath);
+        }
+    }
 }

Sources/Plasma/Apps/plFileSecure/main.cpp

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

Sources/Plasma/Apps/plLogDecrypt/plLogDecrypt.cpp

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

Sources/Plasma/Apps/plMD5/Main.cpp

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

Sources/Plasma/Apps/plPageInfo/plPageInfo.cpp

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

Sources/Plasma/Apps/plPageOptimizer/main.cpp

@@ -34,72 +34,72 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 int main(int argc, char* argv[])
 {
-	if (argc != 2)
-	{
-		printf("plPageOptimizer: wrong number of arguments");
-		return 1;
-	}
+    if (argc != 2)
+    {
+        printf("plPageOptimizer: wrong number of arguments");
+        return 1;
+    }
 
-	printf("Optimizing %s...", plFileUtils::GetFileName(argv[1]));
+    printf("Optimizing %s...", plFileUtils::GetFileName(argv[1]));
 
-	plFontCache* fontCache;
+    plFontCache* fontCache;
 #ifndef _DEBUG
-	try
-	{
+    try
+    {
 #endif
-		plResManager* resMgr = TRACKED_NEW plResManager;
-		hsgResMgr::Init(resMgr);
+        plResManager* resMgr = TRACKED_NEW plResManager;
+        hsgResMgr::Init(resMgr);
 
-		// Setup all the crap that needs to be around to load
-		plSimulationMgr::Init();
-		fontCache = TRACKED_NEW plFontCache;
-		plPythonFileMod::SetAtConvertTime();
+        // Setup all the crap that needs to be around to load
+        plSimulationMgr::Init();
+        fontCache = TRACKED_NEW plFontCache;
+        plPythonFileMod::SetAtConvertTime();
 #ifndef _DEBUG
-	} catch (...)
-	{
-		printf(" ***crashed on init");
-		return 2;
-	}
+    } catch (...)
+    {
+        printf(" ***crashed on init");
+        return 2;
+    }
 #endif
 
 #ifndef _DEBUG
-	try
+    try
 #endif
-	{
-		plPageOptimizer optimizer(argv[1]);
-		optimizer.Optimize();
-	}
+    {
+        plPageOptimizer optimizer(argv[1]);
+        optimizer.Optimize();
+    }
 #ifndef _DEBUG
-	catch (...)
-	{
-		printf(" ***crashed on optimizing");
-		return 2;
-	}
+    catch (...)
+    {
+        printf(" ***crashed on optimizing");
+        return 2;
+    }
 #endif
 
 #ifndef _DEBUG
-	try
-	{
+    try
+    {
 #endif
-		// Deinit the crap
-		fontCache->UnRegisterAs(kFontCache_KEY);
-		fontCache = nil;
-		plSimulationMgr::Shutdown();
+        // Deinit the crap
+        fontCache->UnRegisterAs(kFontCache_KEY);
+        fontCache = nil;
+        plSimulationMgr::Shutdown();
 
-		// 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
-		// ResMgr goes away.
-		std::vector<plSynchedObject::StateDefn> carryOvers;
-		plSynchedObject::ClearDirtyState(carryOvers);
+        // 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
+        // ResMgr goes away.
+        std::vector<plSynchedObject::StateDefn> carryOvers;
+        plSynchedObject::ClearDirtyState(carryOvers);
 
-		hsgResMgr::Shutdown();
+        hsgResMgr::Shutdown();
 #ifndef _DEBUG
-	} catch (...)
-	{
-		printf(" ***crashed on shutdown");
-		return 2;
-	}
+    } catch (...)
+    {
+        printf(" ***crashed on shutdown");
+        return 2;
+    }
 #endif
 
-	return 0;
+    return 0;
 }

Sources/Plasma/Apps/plPageOptimizer/plPageOptimizer.cpp

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

Sources/Plasma/Apps/plPageOptimizer/plPageOptimizer.h

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

Sources/Plasma/Apps/plPlasmaInstaller/main.cpp

@@ -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)
 {
-	jvCoreUtil::SetHInstance(hInstance);
-	plPlasmaInstaller installer;
-	installer.Create();
+    jvCoreUtil::SetHInstance(hInstance);
+    plPlasmaInstaller installer;
+    installer.Create();
 
-	MSG msg;
-	while (GetMessage(&msg, NULL, 0, 0))
-	{
-		if (!IsDialogMessage(installer.GetHWnd(), &msg))
-		{
-			TranslateMessage(&msg);
-			DispatchMessage(&msg);
-		}
-	}
+    MSG msg;
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        if (!IsDialogMessage(installer.GetHWnd(), &msg))
+        {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+    }
 
-	return msg.wParam;
+    return msg.wParam;
 }

Sources/Plasma/Apps/plPlasmaInstaller/plInstallerReg.cpp

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

Sources/Plasma/Apps/plPlasmaInstaller/plInstallerReg.h

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

Sources/Plasma/Apps/plPlasmaInstaller/plPlasmaInstaller.cpp

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

Sources/Plasma/Apps/plPlasmaInstaller/plPlasmaInstaller.h

@@ -28,30 +28,30 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 class plPlasmaInstaller : public jvBaseDlg
 {
 protected:
-	char fDailyDir[MAX_PATH];
-	bool fDidGet;
+    char fDailyDir[MAX_PATH];
+    bool fDidGet;
 
-	HWND fStatusList;
+    HWND fStatusList;
 
-	enum { kBuildMain, kBuildBranch, kBuildActive };
-	enum { kNightly, kAfternoon, kEvening };
+    enum { kBuildMain, kBuildBranch, kBuildActive };
+    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();
-	void IGetFolder(bool client);
+    bool IGetDailyDir();
+    void IGetFolder(bool client);
 
-	void IGet();
+    void IGet();
 
-	void IInit();
-	void IExtractZip(const char* filename, const char* dest);
+    void IInit();
+    void IExtractZip(const char* filename, const char* dest);
 
-	void IAddStatusLine(const char* format, ...);
+    void IAddStatusLine(const char* format, ...);
 
 public:
-	plPlasmaInstaller();
+    plPlasmaInstaller();
 
-	void Create();
+    void Create();
 
-	HWND GetHWnd() { return fDlg; }
+    HWND GetHWnd() { return fDlg; }
 };

Sources/Plasma/Apps/plPlasmaInstaller/plSetPlasmaPath.cpp

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

Sources/Plasma/Apps/plPlasmaInstaller/plUnzip.cpp

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

Sources/Plasma/Apps/plPlasmaInstaller/plUnzip.h

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

Sources/Plasma/Apps/plPlasmaUpdate/main.cpp

@@ -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)
 {
-	jvCoreUtil::SetHInstance(hInstance);
-	plPlasmaUpdate installer;
-	if (!installer.Create())
-		return 0;
+    jvCoreUtil::SetHInstance(hInstance);
+    plPlasmaUpdate installer;
+    if (!installer.Create())
+        return 0;
 
-	if (!stricmp(lpCmdLine, "AutoDownload"))
-		installer.SetAutoDownload();
+    if (!stricmp(lpCmdLine, "AutoDownload"))
+        installer.SetAutoDownload();
 
-	MSG msg;
-	while (GetMessage(&msg, NULL, 0, 0))
-	{
-		if (!jvBaseDlg::IsDialogMessage(&msg))
-		{
-			TranslateMessage(&msg);
-			DispatchMessage(&msg);
-		}
-	}
+    MSG msg;
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        if (!jvBaseDlg::IsDialogMessage(&msg))
+        {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+    }
 
-	return 0;
+    return 0;
 }

Sources/Plasma/Apps/plPlasmaUpdate/plFileGrabber.cpp

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

Sources/Plasma/Apps/plPlasmaUpdate/plFileGrabber.h

@@ -32,42 +32,42 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 class plFileGrabber
 {
 public:
-	virtual bool IsServerAvailable(const char* serverName, const char* currentDir) = 0;
-	virtual bool FileToStream(const char* path, hsStream* stream) = 0;
-	virtual void SetServer(const char* server) = 0;
-	virtual void MakeProperPath(char* path) = 0;
-	virtual bool NeedsAuth() { return false; }
-	virtual void SetUsernamePassword(const std::string& username, const std::string& password) {}
+    virtual bool IsServerAvailable(const char* serverName, const char* currentDir) = 0;
+    virtual bool FileToStream(const char* path, hsStream* stream) = 0;
+    virtual void SetServer(const char* server) = 0;
+    virtual void MakeProperPath(char* path) = 0;
+    virtual bool NeedsAuth() { return false; }
+    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
 class plHttpFileGrabber : public plFileGrabber
 {
 private:
-	plHttpDiverseRequestMgr fRequestMgr;
+    plHttpDiverseRequestMgr fRequestMgr;
 
 public:
-	plHttpFileGrabber();
-	virtual bool IsServerAvailable(const char* serverName);
-	virtual bool FileToStream(const char* path, hsStream* stream);
-	virtual void SetServer(const char* server);
-	virtual void MakeProperPath(char* path);
-	virtual bool NeedsAuth() { return true; }
-	virtual void SetUsernamePassword(const std::string& username, const std::string& password);
+    plHttpFileGrabber();
+    virtual bool IsServerAvailable(const char* serverName);
+    virtual bool FileToStream(const char* path, hsStream* stream);
+    virtual void SetServer(const char* server);
+    virtual void MakeProperPath(char* path);
+    virtual bool NeedsAuth() { return true; }
+    virtual void SetUsernamePassword(const std::string& username, const std::string& password);
 };
 */
 
 class plNetShareFileGrabber : public plFileGrabber
 {
 private:
-	std::string fServerName;
+    std::string fServerName;
 
 public:
-	plNetShareFileGrabber();
-	virtual bool IsServerAvailable(const char* serverName, const char* currentDir);
-	virtual bool FileToStream(const char* path, hsStream* stream);
-	virtual void SetServer(const char* server);
-	virtual void MakeProperPath(char* path);
+    plNetShareFileGrabber();
+    virtual bool IsServerAvailable(const char* serverName, const char* currentDir);
+    virtual bool FileToStream(const char* path, hsStream* stream);
+    virtual void SetServer(const char* server);
+    virtual void MakeProperPath(char* path);
 };
 
 #endif

Sources/Plasma/Apps/plPlasmaUpdate/plManifest.cpp

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

Sources/Plasma/Apps/plPlasmaUpdate/plManifest.h

@@ -39,39 +39,39 @@ typedef void (*LogFunc)(const char* format, ...);
 class plManifest
 {
 protected:
-	std::string fBasePath;
-	char* fManifestName;
+    std::string fBasePath;
+    char* fManifestName;
 
-	typedef std::vector<plManifestFile*> FileVec;
-	FileVec fFiles;
+    typedef std::vector<plManifestFile*> FileVec;
+    FileVec fFiles;
 
-	UInt32 fDownloadFiles;
-	UInt32 fDownloadBytes;
+    UInt32 fDownloadFiles;
+    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();
-	void IReadCache(ProgressFunc progress);
-	void IWriteCache();
+    const char* IGetCacheDir();
+    void IReadCache(ProgressFunc progress);
+    void IWriteCache();
 
 public:
-	plManifest(LogFunc log);
-	~plManifest();
+    plManifest(LogFunc log);
+    ~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	DownloadUpdates(ProgressFunc progress, plFileGrabber* grabber);
+    void    ValidateFiles(ProgressFunc progress);
+    void    DownloadUpdates(ProgressFunc progress, plFileGrabber* grabber);
 
-	int		NumFiles() { return fFiles.size(); }
-	UInt32	NumDownloadFiles() { return fDownloadFiles; }
-	UInt32	DownloadSize() { return fDownloadBytes; }
+    int     NumFiles() { return fFiles.size(); }
+    UInt32  NumDownloadFiles() { return fDownloadFiles; }
+    UInt32  DownloadSize() { return fDownloadBytes; }
 };
 
 #endif // plManifest_h_inc

Sources/Plasma/Apps/plPlasmaUpdate/plPlasmaServers.cpp

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

Sources/Plasma/Apps/plPlasmaUpdate/plPlasmaServers.h

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

Sources/Plasma/Apps/plPlasmaUpdate/plPlasmaUpdate.cpp

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

Sources/Plasma/Apps/plPlasmaUpdate/plPlasmaUpdate.h

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

Sources/Plasma/Apps/plPythonPack/CMakeLists.txt

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

Sources/Plasma/Apps/plPythonPack/PythonInterface.cpp

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

Sources/Plasma/Apps/plPythonPack/PythonInterface.h

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

Sources/Plasma/Apps/plPythonPack/main.cpp

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

Sources/Plasma/Apps/plUruLauncher/CMakeLists.txt

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

Sources/Plasma/Apps/plUruLauncher/SelfPatcher.cpp

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

Sources/Plasma/Apps/plUruLauncher/plLauncherInfo.h

@@ -35,15 +35,15 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 #define PLASMA20_SOURCES_PLASMA_APPS_PLURULAUNCHER_PLLAUNCHERCALLBACK_H
 
 enum EStatus {
-	kStatusOk,
-	kStatusError,
-	kStatusPending,
+    kStatusOk,
+    kStatusError,
+    kStatusPending,
 };
 
 struct PatchInfo {
-	unsigned progress;
-	unsigned stage;
-	unsigned progressStage;
+    unsigned progress;
+    unsigned stage;
+    unsigned progressStage;
 };
 
 typedef void (*launcherCallback)(int status, void *param);
@@ -53,24 +53,24 @@ typedef void (*setTimeRemainingCallback)(unsigned seconds);
 typedef void (*setBytesRemainingCallback)(unsigned bytes);
 
 struct plLauncherInfo {
-	wchar path[MAX_PATH];
-	wchar cmdLine[512];
-	unsigned buildId;				// buildId override
-	launcherCallback prepCallback;
-	launcherCallback initCallback;
-	launcherCallback startCallback;
-	launcherCallback stopCallback;
-	launcherCallback terminateCallback;
-	launcherCallback progressCallback;
-	launcherCallback exitCallback;
-	setTextCallback				SetText; 
-	setStatusTextCallback		SetStatusText;
-	setTimeRemainingCallback	SetTimeRemaining;
-	setBytesRemainingCallback	SetBytesRemaining;
+    wchar path[MAX_PATH];
+    wchar cmdLine[512];
+    unsigned buildId;               // buildId override
+    launcherCallback prepCallback;
+    launcherCallback initCallback;
+    launcherCallback startCallback;
+    launcherCallback stopCallback;
+    launcherCallback terminateCallback;
+    launcherCallback progressCallback;
+    launcherCallback exitCallback;
+    setTextCallback             SetText; 
+    setStatusTextCallback       SetStatusText;
+    setTimeRemainingCallback    SetTimeRemaining;
+    setBytesRemainingCallback   SetBytesRemaining;
     
-	PatchInfo patchInfo;
-	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.
+    PatchInfo patchInfo;
+    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.
 };
 
 

Sources/Plasma/CoreLib/CMakeLists.txt

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

Sources/Plasma/CoreLib/HS_POINT2.inc

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

Sources/Plasma/CoreLib/HeadSpin.cpp

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

Sources/Plasma/CoreLib/hsBiExpander.h

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

Sources/Plasma/CoreLib/hsBitVector.cpp

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

Sources/Plasma/CoreLib/hsBitVector.h

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

Sources/Plasma/CoreLib/hsBounds.h

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

Sources/Plasma/CoreLib/hsColorRGBA.h

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

Sources/Plasma/CoreLib/hsConfig.h

@@ -35,22 +35,22 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 
 #ifdef BUILDPS2
-#define HS_BUILD_FOR_PS2		1
-#define PLASMA_NO_NETWORK		1 
-#define PLASMA_NO_KEYBOARD		1
-#define PLASMA_NO_GLIDE			1
-#define PLASMA_NO_DDRAW			1
-#define HS_BUILD_PLASMA			1
-#define NEXUS_NO_2D				1
+#define HS_BUILD_FOR_PS2        1
+#define PLASMA_NO_NETWORK       1 
+#define PLASMA_NO_KEYBOARD      1
+#define PLASMA_NO_GLIDE         1
+#define PLASMA_NO_DDRAW         1
+#define HS_BUILD_PLASMA         1
+#define NEXUS_NO_2D             1
 #endif
 
 //////////////////// Change the 1s and 0s //////////////////////
 
-#define HS_CAN_USE_FLOAT			1
-#define HS_SCALAR_IS_FLOAT			1
+#define HS_CAN_USE_FLOAT            1
+#define HS_SCALAR_IS_FLOAT          1
 
-#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_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
 
 
 
@@ -62,8 +62,8 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 #ifdef   HS_BUILD_PLASMA
 
-	#define HS_IGNORE_T2K		  1
-	#define HS_SUPPORT_NFNT_FONTS 1
+    #define HS_IGNORE_T2K         1
+    #define HS_SUPPORT_NFNT_FONTS 1
 
 #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  ////////////
 
 #if defined(macintosh) && defined(__POWERPC__)
-	#define HS_BUILD_FOR_MACPPC			1
-	#define HS_CPU_BENDIAN				1
+    #define HS_BUILD_FOR_MACPPC         1
+    #define HS_CPU_BENDIAN              1
 #elif defined(macintosh)
-	#define HS_BUILD_FOR_MAC68K			1
+    #define HS_BUILD_FOR_MAC68K         1
 #elif defined(_M_IX86) && defined(_WIN32)
-	#define HS_BUILD_FOR_WIN32			1
-	#define HS_CPU_LENDIAN				1
+    #define HS_BUILD_FOR_WIN32          1
+    #define HS_CPU_LENDIAN              1
 #elif defined(__unix__)
-	#define HS_BUILD_FOR_UNIX			1
-	#if defined(__intel__) || defined(__i386__)
-		#define HS_CPU_LENDIAN				1
-	#elif defined(__mips__)
-		#define HS_CPU_BENDIAN				1
-	#endif
+    #define HS_BUILD_FOR_UNIX           1
+    #if defined(__intel__) || defined(__i386__)
+        #define HS_CPU_LENDIAN              1
+    #elif defined(__mips__)
+        #define HS_CPU_BENDIAN              1
+    #endif
 #elif !HS_BUILD_FOR_PS2
-	#define HS_BUILD_FOR_REFERENCE		1
+    #define HS_BUILD_FOR_REFERENCE      1
 #endif
 
 #if defined(HS_BUILD_FOR_MAC68K) || defined(HS_BUILD_FOR_MACPPC) 
-	#define HS_BUILD_FOR_MAC		1
+    #define HS_BUILD_FOR_MAC        1
 #endif
 
 #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
 #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
 
-#define HS_SCALAR_IS_FIXED			!(HS_SCALAR_IS_FLOAT)
-#define HS_NEVER_USE_FLOAT			!(HS_CAN_USE_FLOAT)
+#define HS_SCALAR_IS_FIXED          !(HS_SCALAR_IS_FLOAT)
+#define HS_NEVER_USE_FLOAT          !(HS_CAN_USE_FLOAT)
 
 #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
 
 
@@ -144,7 +144,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 
 
 #if HS_BUILD_FOR_PS2
-#define ATTRIBUTE_FOR_PS2 __attribute__((aligned (16)))		/* SUNSOFT */
+#define ATTRIBUTE_FOR_PS2 __attribute__((aligned (16)))     /* SUNSOFT */
 #else
 #define ATTRIBUTE_FOR_PS2
 #endif
@@ -153,11 +153,11 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
 /////////////////////Myst3D Defines /////////////////////////////////////
 
 #ifdef M3DRELEASE
-#define PLASMA_NO_NETWORK	1
-#define NEXUS_NO_2D			1
-#define NO_LOAD_MSG			1
-#define PLASMA_NO_CONSOLE	1
-#define NEXUS_NO_DEBUG		1
+#define PLASMA_NO_NETWORK   1
+#define NEXUS_NO_2D         1
+#define NO_LOAD_MSG         1
+#define PLASMA_NO_CONSOLE   1
+#define NEXUS_NO_DEBUG      1
 #endif
 
 

Sources/Plasma/CoreLib/hsExceptionStack.cpp

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

Sources/Plasma/CoreLib/hsExceptionStack.h

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

Sources/Plasma/CoreLib/hsExceptions.h

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

Sources/Plasma/CoreLib/hsFastMath.h

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

Sources/Plasma/CoreLib/hsFixedTypes.h

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

Sources/Plasma/CoreLib/hsGeometry3.cpp

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

Sources/Plasma/CoreLib/hsGeometry3.h

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

Sources/Plasma/CoreLib/hsHashTable.h

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

Sources/Plasma/CoreLib/hsLOD.h

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

Sources/Plasma/CoreLib/hsMMIOStream.cpp

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

Sources/Plasma/CoreLib/hsMMIOStream.h

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

Sources/Plasma/CoreLib/hsMalloc.h

@@ -44,9 +44,9 @@ extern "C" {
 #endif
 
 // MemAlloc flags
-extern const unsigned kMemReallocInPlaceOnly;	// use _expand when realloc'ing
-extern const unsigned kMemZero;					// fill allocated memory with zeros
-extern const unsigned kMemIgnoreBlock;			// don't track this allocation
+extern const unsigned kMemReallocInPlaceOnly;   // use _expand when realloc'ing
+extern const unsigned kMemZero;                 // fill allocated memory with zeros
+extern const unsigned kMemIgnoreBlock;          // don't track this allocation
 
 
 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 ALLOCZERO(b)			MemAlloc(b, kMemZero, __FILE__, __LINE__)
-#define ALLOCFLAGS(b, f)		MemAlloc(b, (f), __FILE__, __LINE__)
-#define FREE(p)					MemFree(p, 0)
-#define FREEFLAGS(p, f)			MemFree(p, (f))
-#define REALLOC(p, b)			MemRealloc(p, b, 0, __FILE__, __LINE__)
-#define REALLOCFLAGS(p, b, f)	MemRealloc(p, b, (f), __FILE__, __LINE__)
-#define CALLOC(n, s)			MemAlloc((n)*(s), kMemZero, __FILE__, __LINE__)
-#define MEMDUP(s, b)			MemDup(s, b, 0, __FILE__, __LINE__)
-#define ZERO(s)					MemSet(&s, 0, sizeof(s))
-#define ZEROPTR(p)				MemSet(p, 0, sizeof(*p))
+#define ALLOC(b)                MemAlloc(b, 0, __FILE__, __LINE__)
+#define ALLOCZERO(b)            MemAlloc(b, kMemZero, __FILE__, __LINE__)
+#define ALLOCFLAGS(b, f)        MemAlloc(b, (f), __FILE__, __LINE__)
+#define FREE(p)                 MemFree(p, 0)
+#define FREEFLAGS(p, f)         MemFree(p, (f))
+#define REALLOC(p, b)           MemRealloc(p, b, 0, __FILE__, __LINE__)
+#define REALLOCFLAGS(p, b, f)   MemRealloc(p, b, (f), __FILE__, __LINE__)
+#define CALLOC(n, s)            MemAlloc((n)*(s), kMemZero, __FILE__, __LINE__)
+#define MEMDUP(s, b)            MemDup(s, b, 0, __FILE__, __LINE__)
+#define ZERO(s)                 MemSet(&s, 0, sizeof(s))
+#define ZEROPTR(p)              MemSet(p, 0, sizeof(*p))
 // 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
 
-#define NEW(t)					new(MemAlloc(sizeof(t), 0, __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 DEL(t)					delete (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 NEWZERO(t)              new(MemAlloc(sizeof(t), kMemZero, __FILE__, __LINE__)) t
+#define DEL(t)                  delete (t)
 
 #endif // __cplusplus
 

Sources/Plasma/CoreLib/hsMatrix33.cpp

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

Sources/Plasma/CoreLib/hsMatrix33.h

@@ -31,26 +31,26 @@ class hsStream;
 
 struct hsMatrix33
 {
-	hsScalar 			fMap[3][3];
+    hsScalar            fMap[3][3];
 
-	hsMatrix33* Reset();
+    hsMatrix33* Reset();
 
-	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] &&
-								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];
-					}
-	int			operator!=(const hsMatrix33& aa) const
-					{
-						return !(aa == *this);
-					}
-	hsMatrix33* SetConcat(const hsMatrix33* a, const hsMatrix33* b);
-	friend hsMatrix33 operator*(const hsMatrix33& a, const hsMatrix33& b);
+    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] &&
+                                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];
+                    }
+    int         operator!=(const hsMatrix33& aa) const
+                    {
+                        return !(aa == *this);
+                    }
+    hsMatrix33* SetConcat(const hsMatrix33* a, const hsMatrix33* b);
+    friend hsMatrix33 operator*(const hsMatrix33& a, const hsMatrix33& b);
 
 
-	void Read(hsStream* s);
-	void Write(hsStream* s);
+    void Read(hsStream* s);
+    void Write(hsStream* s);
 };
 
 #endif // hsMatrix33_inc