Merge branch 'master' of git://github.com/GTAmodding/re3

src/Camera.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "Draw.h"
 #include "World.h"
 #include "Vehicle.h"

src/CdStream.cpp

@@ -0,0 +1,529 @@
+#include <Windows.h>
+#include "common.h"
+#include "patcher.h"
+#include "CdStream.h"
+#include "rwcore.h"
+#include "RwHelper.h"
+
+#define CDDEBUG(f, ...)   debug ("%s: " f "\n", "cdvd_stream", __VA_ARGS__)
+#define CDTRACE(f, ...)   printf("%s: " f "\n", "cdvd_stream", __VA_ARGS__)
+
+struct CdReadInfo
+{
+	uint32 nSectorOffset;
+	uint32 nSectorsToRead;
+	void *pBuffer;
+	char field_C;
+	bool bLocked;
+	bool bInUse;
+	char _pad0;
+	int32 nStatus;
+	HANDLE hSemaphore;
+	HANDLE hFile;
+	OVERLAPPED Overlapped;
+};
+VALIDATE_SIZE(CdReadInfo, 0x30);
+
+char gCdImageNames[MAX_CDIMAGES+1][64];
+int32 gNumImages;
+int32 gNumChannels;
+
+HANDLE gImgFiles[MAX_CDIMAGES];
+
+HANDLE _gCdStreamThread;
+HANDLE gCdStreamSema;
+DWORD _gCdStreamThreadId;
+
+CdReadInfo *gpReadInfo;
+Queue gChannelRequestQ;
+
+int32 lastPosnRead;
+
+BOOL _gbCdStreamOverlapped;
+BOOL _gbCdStreamAsync;
+DWORD _gdwCdStreamFlags;
+
+
+void
+CdStreamInitThread(void)
+{
+	SetLastError(0);
+	
+	if ( gNumChannels > 0 )
+	{
+		for ( int32 i = 0; i < gNumChannels; i++ )
+		{
+			gpReadInfo[i].hSemaphore = CreateSemaphore(NULL, 0, 2, NULL);
+			
+			if ( gpReadInfo[i].hSemaphore == NULL )
+			{
+				CDTRACE("failed to create sync semaphore");
+				ASSERT(0);
+				return;
+			}
+		}
+	}
+	
+	gChannelRequestQ.items = (int32 *)LocalAlloc(LMEM_ZEROINIT, sizeof(int32) * (gNumChannels + 1));
+	gChannelRequestQ.head = 0;
+	gChannelRequestQ.tail = 0;
+	gChannelRequestQ.size = gNumChannels + 1;
+	ASSERT(gChannelRequestQ.items != NULL );
+	
+	gCdStreamSema = CreateSemaphore(NULL, 0, 5, "CdStream");
+	
+	if ( gCdStreamSema == NULL )
+	{
+		CDTRACE("failed to create stream semaphore");
+		ASSERT(0);
+		return;
+	}
+	
+	_gCdStreamThread = CreateThread(NULL, 64*1024/*64KB*/, CdStreamThread, NULL, CREATE_SUSPENDED, &_gCdStreamThreadId);
+	
+	if ( _gCdStreamThread == NULL )
+	{
+		CDTRACE("failed to create streaming thread");
+		ASSERT(0);
+		return;
+	}
+
+	SetThreadPriority(_gCdStreamThread, GetThreadPriority(GetCurrentThread()) - 1);
+		
+	ResumeThread(_gCdStreamThread);	
+}
+
+void
+CdStreamInit(int32 numChannels)
+{
+	DWORD SectorsPerCluster;
+	DWORD BytesPerSector;
+	DWORD NumberOfFreeClusters;
+	DWORD TotalNumberOfClusters;
+
+	GetDiskFreeSpace(NULL, &SectorsPerCluster, &BytesPerSector, &NumberOfFreeClusters, &TotalNumberOfClusters);
+	
+	_gdwCdStreamFlags = 0;
+	
+	if ( BytesPerSector <= CDSTREAM_SECTOR_SIZE )
+	{
+		_gdwCdStreamFlags |= FILE_FLAG_NO_BUFFERING;
+		debug("Using no buffered loading for streaming\n");
+	}
+	
+	_gbCdStreamOverlapped = TRUE;
+
+	_gdwCdStreamFlags |= FILE_FLAG_OVERLAPPED;
+	
+	_gbCdStreamAsync = FALSE;
+	
+	void *pBuffer = (void *)RwMallocAlign(CDSTREAM_SECTOR_SIZE, BytesPerSector);
+	ASSERT( pBuffer != NULL );
+	
+	SetLastError(0);
+	
+	gNumImages = 0;
+	
+	gNumChannels = numChannels;
+	
+	gpReadInfo = (CdReadInfo *)LocalAlloc(LMEM_ZEROINIT, sizeof(CdReadInfo) * numChannels);
+	ASSERT( gpReadInfo != NULL );
+	
+	CDDEBUG("read info %p", gpReadInfo);
+	
+	CdStreamAddImage("MODELS\\GTA3.IMG");
+	
+	int32 nStatus = CdStreamRead(0, pBuffer, 0, 1);
+	
+	CdStreamRemoveImages();
+	
+	if ( nStatus == STREAM_SUCCESS )
+	{
+		_gbCdStreamAsync = TRUE;
+		
+		debug("Using async loading for streaming\n");
+	}
+	else
+	{
+		_gdwCdStreamFlags &= ~FILE_FLAG_OVERLAPPED;
+		
+		_gbCdStreamOverlapped = FALSE;
+		
+		_gbCdStreamAsync = TRUE;
+		
+		debug("Using sync loading for streaming\n");
+	}
+	
+	CdStreamInitThread();
+	
+	ASSERT( pBuffer != NULL );
+	RwFreeAlign(pBuffer);
+}
+
+uint32
+GetGTA3ImgSize(void)
+{
+	ASSERT( gImgFiles[0] != NULL );
+	return (uint32)GetFileSize(gImgFiles[0], NULL);
+}
+
+void
+CdStreamShutdown(void)
+{
+	if ( _gbCdStreamAsync )
+	{
+		LocalFree(gChannelRequestQ.items);
+		CloseHandle(gCdStreamSema);
+		CloseHandle(_gCdStreamThread);
+		
+		for ( int32 i = 0; i < gNumChannels; i++ )
+			CloseHandle(gpReadInfo[i].hSemaphore);
+	}
+	
+	LocalFree(gpReadInfo);
+}
+
+
+
+int32
+CdStreamRead(int32 channel, void *buffer, uint32 offset, uint32 size)
+{
+	ASSERT( channel < gNumChannels );
+	ASSERT( buffer != NULL );
+	
+	lastPosnRead = size + offset;
+	
+	ASSERT( _GET_INDEX(offset) < MAX_CDIMAGES );
+	HANDLE hImage = gImgFiles[_GET_INDEX(offset)];
+	ASSERT( hImage != NULL );
+	
+	
+	CdReadInfo *pChannel = &gpReadInfo[channel];
+	ASSERT( pChannel != NULL );
+	
+	pChannel->hFile = hImage;
+	
+	SetLastError(0);
+	
+	if ( _gbCdStreamAsync )
+	{
+		if ( pChannel->nSectorsToRead != 0 || pChannel->bInUse )
+			return STREAM_NONE;
+		
+		pChannel->nStatus = STREAM_NONE;
+		pChannel->nSectorOffset = _GET_OFFSET(offset);
+		pChannel->nSectorsToRead = size;
+		pChannel->pBuffer = buffer;
+		pChannel->bLocked = 0;
+		
+		AddToQueue(&gChannelRequestQ, channel);
+		
+		if ( !ReleaseSemaphore(gCdStreamSema, 1, NULL) )
+			printf("Signal Sema Error\n");
+		
+		return STREAM_SUCCESS;
+	}
+	
+	if ( _gbCdStreamOverlapped )
+	{
+		ASSERT( channel < gNumChannels );
+		CdReadInfo *pChannel = &gpReadInfo[channel];
+		ASSERT( pChannel != NULL );
+		
+		pChannel->Overlapped.Offset = _GET_OFFSET(offset) * CDSTREAM_SECTOR_SIZE;
+		
+		if ( !ReadFile(hImage, buffer, size * CDSTREAM_SECTOR_SIZE, NULL, &pChannel->Overlapped)
+					&& GetLastError() != ERROR_IO_PENDING )
+			return STREAM_NONE;
+		else
+			return STREAM_SUCCESS;
+	}
+	
+	SetFilePointer(hImage, _GET_OFFSET(offset) * CDSTREAM_SECTOR_SIZE, NULL, FILE_BEGIN);
+	
+	DWORD NumberOfBytesRead;
+	
+	if ( !ReadFile(hImage, buffer, size * CDSTREAM_SECTOR_SIZE, &NumberOfBytesRead, NULL) )
+		return STREAM_NONE;
+	else
+		return STREAM_SUCCESS;
+}
+
+int32
+CdStreamGetStatus(int32 channel)
+{
+	ASSERT( channel < gNumChannels );
+	CdReadInfo *pChannel = &gpReadInfo[channel];
+	ASSERT( pChannel != NULL );
+	
+	if ( _gbCdStreamAsync )
+	{
+		if ( pChannel->bInUse )
+			return STREAM_READING;
+		
+		if ( pChannel->nSectorsToRead != 0 )
+			return STREAM_WAITING;
+		
+		if ( pChannel->nStatus != STREAM_NONE )
+		{
+			int32 status = pChannel->nStatus;
+			
+			pChannel->nStatus = STREAM_NONE;
+			
+			return status;
+		}
+		
+		return STREAM_NONE;
+	}
+	
+	if ( _gbCdStreamOverlapped )
+	{
+		ASSERT( pChannel->hFile != NULL );
+		if ( WaitForSingleObjectEx(pChannel->hFile, 0, TRUE) == WAIT_OBJECT_0 )
+			return STREAM_NONE;
+		else
+			return STREAM_READING;
+	}
+	
+	return STREAM_NONE;
+}
+
+int32
+CdStreamGetLastPosn(void)
+{
+	return lastPosnRead;
+}
+
+int32
+CdStreamSync(int32 channel)
+{
+	ASSERT( channel < gNumChannels );
+	CdReadInfo *pChannel = &gpReadInfo[channel];
+	ASSERT( pChannel != NULL );
+	
+	if ( _gbCdStreamAsync )
+	{
+		if ( pChannel->nSectorsToRead != 0 )
+		{
+			pChannel->bLocked = true;
+
+			ASSERT( pChannel->hSemaphore != NULL );
+
+			WaitForSingleObject(pChannel->hSemaphore, INFINITE);
+		}
+
+		pChannel->bInUse = false;
+		
+		return pChannel->nStatus;
+	}
+	
+	DWORD NumberOfBytesTransferred;
+
+	if ( _gbCdStreamOverlapped && pChannel->hFile )
+	{
+		ASSERT(pChannel->hFile != NULL );
+		if ( GetOverlappedResult(pChannel->hFile, &pChannel->Overlapped, &NumberOfBytesTransferred, TRUE) )
+			return STREAM_NONE;
+		else
+			return STREAM_ERROR;
+	}
+	
+	return STREAM_NONE;
+}
+
+void
+AddToQueue(Queue *queue, int32 item)
+{
+	ASSERT( queue != NULL );
+	ASSERT( queue->items != NULL );
+	queue->items[queue->tail] = item;
+	
+	queue->tail = (queue->tail + 1) % queue->size;
+	
+	if ( queue->head == queue->tail )
+		debug("Queue is full\n");
+}
+
+int32 
+GetFirstInQueue(Queue *queue)
+{
+	ASSERT( queue != NULL );
+	if ( queue->head == queue->tail )
+		return -1;
+
+	ASSERT( queue->items != NULL );
+	return queue->items[queue->head];
+}
+
+void
+RemoveFirstInQueue(Queue *queue)
+{	
+	ASSERT( queue != NULL );
+	if ( queue->head == queue->tail )
+	{
+		debug("Queue is empty\n");
+		return;
+	}
+
+	queue->head = (queue->head + 1) % queue->size;
+}
+
+DWORD
+WINAPI CdStreamThread(LPVOID lpThreadParameter)
+{
+	debug("Created cdstream thread\n");
+	
+	while ( true )
+	{
+		WaitForSingleObject(gCdStreamSema, INFINITE);
+		
+		int32 channel = GetFirstInQueue(&gChannelRequestQ);
+		ASSERT( channel < gNumChannels );
+		
+		CdReadInfo *pChannel = &gpReadInfo[channel];
+		ASSERT( pChannel != NULL );
+		
+		pChannel->bInUse = true;
+		
+		if ( pChannel->nStatus == STREAM_NONE )
+		{
+			if ( _gbCdStreamOverlapped )
+			{
+				pChannel->Overlapped.Offset = pChannel->nSectorOffset * CDSTREAM_SECTOR_SIZE;
+				
+				ASSERT(pChannel->hFile != NULL );
+				ASSERT(pChannel->pBuffer != NULL );
+				
+				DWORD NumberOfBytesTransferred;
+				
+				if ( ReadFile(pChannel->hFile,
+						pChannel->pBuffer,
+						pChannel->nSectorsToRead * CDSTREAM_SECTOR_SIZE,
+						NULL,
+						&pChannel->Overlapped) )
+				{
+					pChannel->nStatus = STREAM_NONE;
+				}
+				else if ( GetLastError() == ERROR_IO_PENDING
+						&& GetOverlappedResult(pChannel->hFile, &pChannel->Overlapped, &NumberOfBytesTransferred, TRUE) )
+				{
+					pChannel->nStatus = STREAM_NONE;
+				}
+				else
+				{
+					pChannel->nStatus = STREAM_ERROR;
+				}
+			}
+			else
+			{
+				ASSERT(pChannel->hFile != NULL );
+				ASSERT(pChannel->pBuffer != NULL );
+				
+				SetFilePointer(pChannel->hFile, pChannel->nSectorOffset * CDSTREAM_SECTOR_SIZE, NULL, FILE_BEGIN);
+
+				DWORD NumberOfBytesRead;
+				if ( ReadFile(pChannel->hFile,
+						pChannel->pBuffer,
+						pChannel->nSectorsToRead * CDSTREAM_SECTOR_SIZE,
+						&NumberOfBytesRead,
+						NULL) )
+				{
+					pChannel->nStatus = STREAM_NONE;
+				}
+			}
+		}
+		
+		RemoveFirstInQueue(&gChannelRequestQ);
+		
+		pChannel->nSectorsToRead = 0;
+		
+		if ( pChannel->bLocked )
+		{
+			ASSERT( pChannel->hSemaphore != NULL );
+			ReleaseSemaphore(pChannel->hSemaphore, 1, NULL);
+		}
+		
+		pChannel->bInUse = false;
+	}
+}
+
+bool
+CdStreamAddImage(char const *path)
+{
+	ASSERT(path != NULL);
+	ASSERT(gNumImages < MAX_CDIMAGES);
+	
+	SetLastError(0);
+	
+	gImgFiles[gNumImages] = CreateFile(path,
+	                                   GENERIC_READ,
+	                                   FILE_SHARE_READ,
+	                                   NULL,
+	                                   OPEN_EXISTING,
+	                                   _gdwCdStreamFlags | FILE_FLAG_RANDOM_ACCESS | FILE_ATTRIBUTE_READONLY,
+	                                   NULL);
+	
+	ASSERT( gImgFiles[gNumImages] != NULL );
+	if ( gImgFiles[gNumImages] == NULL )
+		return false;
+	
+	strcpy(gCdImageNames[gNumImages], path);
+	
+	gNumImages++;
+	
+	return true;
+}
+
+char *
+CdStreamGetImageName(int32 cd)
+{
+	ASSERT(cd < MAX_CDIMAGES);
+	if ( gImgFiles[cd] != NULL )
+		return gCdImageNames[cd];
+	
+	return NULL;
+}
+
+void
+CdStreamRemoveImages(void)
+{	
+	for ( int32 i = 0; i < gNumChannels; i++ )
+		CdStreamSync(i);
+	
+	for ( int32 i = 0; i < gNumImages; i++ )
+	{
+		SetLastError(0);
+		
+		CloseHandle(gImgFiles[i]);
+		gImgFiles[i] = NULL;
+	}
+	
+	gNumImages = 0;
+}
+
+int32
+CdStreamGetNumImages(void)
+{	
+	return gNumImages;
+}
+
+
+STARTPATCHES
+	InjectHook(0x405B50, CdStreamInitThread, PATCH_JUMP);
+	InjectHook(0x405C80, CdStreamInit, PATCH_JUMP);
+	//InjectHook(0x405DB0, debug, PATCH_JUMP);
+	InjectHook(0x405DC0, GetGTA3ImgSize, PATCH_JUMP);
+	InjectHook(0x405DD0, CdStreamShutdown, PATCH_JUMP);
+	InjectHook(0x405E40, CdStreamRead, PATCH_JUMP);
+	InjectHook(0x405F90, CdStreamGetStatus, PATCH_JUMP);
+	InjectHook(0x406000, CdStreamGetLastPosn, PATCH_JUMP);
+	InjectHook(0x406010, CdStreamSync, PATCH_JUMP);
+	InjectHook(0x4060B0, AddToQueue, PATCH_JUMP);
+	InjectHook(0x4060F0, GetFirstInQueue, PATCH_JUMP);
+	InjectHook(0x406110, RemoveFirstInQueue, PATCH_JUMP);
+	InjectHook(0x406140, CdStreamThread, PATCH_JUMP);
+	InjectHook(0x406270, CdStreamAddImage, PATCH_JUMP);
+	InjectHook(0x4062E0, CdStreamGetImageName, PATCH_JUMP);
+	InjectHook(0x406300, CdStreamRemoveImages, PATCH_JUMP);
+	InjectHook(0x406370, CdStreamGetNumImages, PATCH_JUMP);
+ENDPATCHES

src/CdStream.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#define MAX_CDIMAGES 8
+#define CDSTREAM_SECTOR_SIZE 2048
+
+#define _GET_INDEX(a) (a >> 24)
+#define _GET_OFFSET(a)  (a & 0xFFFFFF)
+
+enum
+{
+	STREAM_NONE            = uint8( 0),
+	STREAM_SUCCESS         = uint8( 1),
+	STREAM_READING         = uint8(-1), // 0xFF,
+	STREAM_ERROR           = uint8(-2), // 0xFE,
+	STREAM_ERROR_NOCD      = uint8(-3), // 0xFD,
+	STREAM_ERROR_WRONGCD   = uint8(-4), // 0xFC,
+	STREAM_ERROR_OPENCD    = uint8(-5), // 0xFB,
+	STREAM_WAITING         = uint8(-6)  // 0xFA,
+};
+
+struct Queue
+{
+	int32 *items;
+	int32 head;
+	int32 tail;
+	int32 size;
+};
+
+VALIDATE_SIZE(Queue, 0x10);
+
+
+void CdStreamInitThread(void);
+void CdStreamInit(int32 numChannels);
+uint32 GetGTA3ImgSize(void);
+void CdStreamShutdown(void);
+int32 CdStreamRead(int32 channel, void *buffer, uint32 offset, uint32 size);
+int32 CdStreamGetStatus(int32 channel);
+int32 CdStreamGetLastPosn(void);
+int32 CdStreamSync(int32 channel);
+void AddToQueue(Queue *queue, int32 item);
+int32 GetFirstInQueue(Queue *queue);
+void RemoveFirstInQueue(Queue *queue);
+DWORD WINAPI CdStreamThread(LPVOID lpThreadParameter);
+bool CdStreamAddImage(char const *path);
+char *CdStreamGetImageName(int32 cd);
+void CdStreamRemoveImages(void);
+int32 CdStreamGetNumImages(void);

src/FileLoader.h

@@ -0,0 +1,42 @@
+#pragma once
+
+class CFileLoader
+{
+	static char ms_line[256];
+public:
+	static void LoadLevel(const char *filename);
+	static void LoadCollisionFromDatFile(int currlevel);
+	static char *LoadLine(int fd);
+	static RwTexDictionary *LoadTexDictionary(const char *filename);
+	static void LoadCollisionFile(const char *filename);
+	static void LoadCollisionModel(uint8 *buf, CColModel &model, char *name);
+	static void LoadModelFile(const char *filename);
+	static RpAtomic *FindRelatedModelInfoCB(RpAtomic *atomic, void *data);
+	static void LoadClumpFile(const char *filename);
+	static bool LoadClumpFile(RwStream *stream, uint32 id);
+	static bool StartLoadClumpFile(RwStream *stream, uint32 id);
+	static bool FinishLoadClumpFile(RwStream *stream, uint32 id);
+	static bool LoadAtomicFile(RwStream *stream, uint32 id);
+	static RpAtomic *SetRelatedModelInfoCB(RpAtomic *atomic, void *data);
+	static RpClump *LoadAtomicFile2Return(const char *filename);
+	static void AddTexDictionaries(RwTexDictionary *dst, RwTexDictionary *src);
+
+	static void LoadObjectTypes(const char *filename);
+	static void LoadObject(const char *line);
+	static void LoadTimeObject(const char *line);
+	static void LoadClumpObject(const char *line);
+	static void LoadVehicleObject(const char *line);
+	static void LoadPedObject(const char *line);
+	static int LoadPathHeader(const char *line, char *type);
+	static void LoadPedPathNode(const char *line, int id, int node);
+	static void LoadCarPathNode(const char *line, int id, int node);
+	static void Load2dEffect(const char *line);
+
+	static void LoadScene(const char *filename);
+	static void LoadObjectInstance(const char *line);
+	static void LoadZone(const char *line);
+	static void LoadCullZone(const char *line);
+	static void LoadPickup(const char *line);
+
+	static void LoadMapZones(const char *filename);
+};

src/Game.cpp

@@ -9,6 +9,7 @@ bool &CGame::frenchGame = *(bool*)0x95CDCB;
 bool &CGame::germanGame = *(bool*)0x95CD1E;
 bool &CGame::noProstitutes = *(bool*)0x95CDCF;
 bool &CGame::playingIntro = *(bool*)0x95CDC2;
+char *CGame::aDatFile = (char*)0x773A48;
 
 WRAPPER void CGame::Process(void) { EAXJMP(0x48C850); }
 WRAPPER bool CGame::InitialiseOnceBeforeRW(void) { EAXJMP(0x48BB80); }

src/Game.h

@@ -18,6 +18,7 @@ public:
 	static bool &germanGame;
 	static bool &noProstitutes;
 	static bool &playingIntro;
+	static char *aDatFile;	//[32];
 
 	static void Process(void);
 	static bool InitialiseOnceBeforeRW(void);

src/Pad.cpp

@@ -1995,7 +1995,10 @@ STARTPATCHES
 	InjectHook(0x492720, CPad::UpdatePads, PATCH_JUMP);
 	InjectHook(0x492C60, &CPad::ProcessPCSpecificStuff, PATCH_JUMP);
 	InjectHook(0x492C70, &CPad::Update, PATCH_JUMP);
+#pragma warning( push )
+#pragma warning( disable : 4573)
 	InjectHook(0x492F00, (void (*)())CPad::DoCheats, PATCH_JUMP);
+#pragma warning( pop )
 	InjectHook(0x492F20, (void (CPad::*)(int16))&CPad::DoCheats, PATCH_JUMP);
 	InjectHook(0x492F30, CPad::StopPadsShaking, PATCH_JUMP);
 	InjectHook(0x492F50, &CPad::StopShaking, PATCH_JUMP);

src/RwHelper.cpp

@@ -4,6 +4,34 @@
 #include "TimeCycle.h"
 #include "skeleton.h"
 
+void *
+RwMallocAlign(RwUInt32 size, RwUInt32 align)
+{
+	void *mem = (void *)malloc(size + align);
+	
+	ASSERT(mem != NULL);
+	
+	void *addr = (void *)((((RwUInt32)mem) + align) & ~(align - 1));
+	
+	ASSERT(addr != NULL);
+	
+	*(((void **)addr) - 1) = mem;
+	
+	return addr;
+}
+
+void
+RwFreeAlign(void *mem)
+{
+	ASSERT(mem != NULL);
+	
+	void *addr = *(((void **)mem) - 1);
+	
+	ASSERT(addr != NULL);
+	
+	free(addr);
+}
+
 void
 DefinedState(void)
 {

src/RwHelper.h

@@ -1,5 +1,8 @@
 #pragma once
 
+void *RwMallocAlign(RwUInt32 size, RwUInt32 align);
+void RwFreeAlign(void *mem);
+
 void DefinedState(void);
 RwFrame *GetFirstChild(RwFrame *frame);
 RwObject *GetFirstObject(RwFrame *frame);

src/Timecycle.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "Clock.h"
 #include "Weather.h"
 #include "Camera.h"

src/World.cpp

@@ -7,6 +7,8 @@
 #include "TempColModels.h"
 #include "World.h"
 
+WRAPPER void CWorld::Add(CEntity *entity) { EAXJMP(0x4AE930); }
+
 CPtrList *CWorld::ms_bigBuildingsList = (CPtrList*)0x6FAB60;
 CPtrList &CWorld::ms_listMovingEntityPtrs = *(CPtrList*)0x8F433C;
 CSector (*CWorld::ms_aSectors)[NUMSECTORS_X] = (CSector (*)[NUMSECTORS_Y])0x665608;

src/World.h

@@ -55,6 +55,7 @@ public:
 	static bool &bForceProcessControl;
 	static bool &bProcessCutsceneOnly;
 
+	static void Add(CEntity *entity);
 
 	static CSector *GetSector(int x, int y) { return &ms_aSectors[y][x]; }
 	static CPtrList &GetBigBuildingList(eLevelName i) { return ms_bigBuildingsList[i]; }

src/animation/AnimBlendAssocGroup.cpp

@@ -139,7 +139,7 @@ CAnimBlendAssocGroup::CreateAssociations(const char *blockName, RpClump *clump,
 		DestroyAssociations();
 
 	animBlock = CAnimManager::GetAnimationBlock(blockName);
-	assocList = new CAnimBlendAssociation[animBlock->numAnims];
+	assocList = new CAnimBlendAssociation[numAssocs];
 
 	numAssociations = 0;
 	for(i = 0; i < numAssocs; i++){

src/animation/AnimBlendAssociation.cpp

@@ -5,10 +5,7 @@
 #include "RpAnimBlend.h"
 #include "AnimManager.h"
 #include "AnimBlendAssociation.h"
-
-// TODO: implement those
-#define RwFreeAlign RwFree
-#define RwMallocAlign(sz, algn) RwMalloc(sz)
+#include "RwHelper.h"
 
 CAnimBlendAssociation::CAnimBlendAssociation(void)
 {
@@ -57,6 +54,7 @@ CAnimBlendAssociation::AllocateAnimBlendNodeArray(int n)
 void
 CAnimBlendAssociation::FreeAnimBlendNodeArray(void)
 {
+	assert(nodes != nil);
 	RwFreeAlign(nodes);
 }
 

src/animation/AnimBlendClumpData.cpp

@@ -1,10 +1,8 @@
 #include "common.h"
 #include "patcher.h"
 #include "AnimBlendClumpData.h"
+#include "RwHelper.h"
 
-// TODO: implement those
-#define RwFreeAlign RwFree
-#define RwMallocAlign(sz, algn) RwMalloc(sz)
 
 CAnimBlendClumpData::CAnimBlendClumpData(void)
 {

src/common.h

@@ -76,13 +76,6 @@ extern void **rwengine;
 #define HUD_FROM_RIGHT(a) (SCREEN_WIDTH - HUD_STRETCH_X(a))
 #define HUD_FROM_BOTTOM(a) (SCREEN_HEIGHT - HUD_STRETCH_Y(a))
 
-struct GlobalScene
-{
-	RpWorld *world;
-	RwCamera *camera;
-};
-extern GlobalScene &Scene;
-
 #include "math/Vector.h"
 #include "math/Vector2D.h"
 #include "math/Matrix.h"
@@ -136,10 +129,6 @@ inline float sq(float x) { return x*x; }
 int myrand(void);
 void mysrand(unsigned int seed);
 
-extern uint8 work_buff[55000];
-extern char gString[256];
-extern wchar *gUString;
-
 void re3_debug(char *format, ...);
 void re3_trace(const char *filename, unsigned int lineno, const char *func, char *format, ...);
 void re3_assert(const char *expr, const char *filename, unsigned int lineno, const char *func);

src/control/CarCtrl.cpp

@@ -3,3 +3,4 @@
 #include "CarCtrl.h"
 
 WRAPPER void CCarCtrl::SwitchVehicleToRealPhysics(CVehicle*) { EAXJMP(0x41F7F0); }
+WRAPPER void CCarCtrl::AddToCarArray(int id, int vehclass) { EAXJMP(0x4182F0); }

src/control/CarCtrl.h

@@ -6,4 +6,5 @@ class CCarCtrl
 {
 public:
 	static void SwitchVehicleToRealPhysics(CVehicle*);
+	static void AddToCarArray(int id, int vehclass);
 };

src/control/Garages.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "ModelIndices.h"
 #include "Garages.h"
 #include "Timer.h"

src/control/HandlingDataMgr.cpp

@@ -0,0 +1,7 @@
+#include "common.h"
+#include "patcher.h"
+#include "HandlingDatamgr.h"
+
+cHandlingDataMgr &mod_HandlingManager = *(cHandlingDataMgr*)0x728060;
+
+WRAPPER int32 cHandlingDataMgr::GetHandlingId(const char *name){ EAXJMP(0x546B70); }

src/control/HandlingDataMgr.h

@@ -0,0 +1,8 @@
+#pragma once
+
+class cHandlingDataMgr
+{
+public:
+	int32 GetHandlingId(const char *name);
+};
+extern cHandlingDataMgr &mod_HandlingManager;

src/control/ObjectData.cpp

@@ -0,0 +1,5 @@
+#include "common.h"
+#include "patcher.h"
+#include "ObjectData.h"
+
+WRAPPER void CObjectData::Initialise(const char *filename) { EAXJMP(0x4BC0E0); }

src/control/ObjectData.h

@@ -0,0 +1,7 @@
+#pragma once
+
+class CObjectData
+{
+public:
+	static void Initialise(const char *filename);
+};

src/control/PathFind.cpp

@@ -45,6 +45,43 @@ CPathInfoForObject *&InfoForTilePeds  = *(CPathInfoForObject**)0x8F1AE4;
 CTempDetachedNode *&DetachedNodesCars = *(CTempDetachedNode**)0x8E2824;
 CTempDetachedNode *&DetachedNodesPeds = *(CTempDetachedNode**)0x8E28A0;
 
+void
+CPathFind::StoreNodeInfoPed(int16 id, int16 node, int8 type, int8 next, int16 x, int16 y, int16 z, int16 width, bool crossing)
+{
+	int i;
+
+	i = id*12 + node;
+	InfoForTilePeds[i].type = type;
+	InfoForTilePeds[i].next = next;
+	InfoForTilePeds[i].x = x;
+	InfoForTilePeds[i].y = y;
+	InfoForTilePeds[i].z = z;
+	InfoForTilePeds[i].numLeftLanes = 0;
+	InfoForTilePeds[i].numRightLanes = 0;
+	InfoForTilePeds[i].crossing = crossing;
+}
+
+void
+CPathFind::StoreNodeInfoCar(int16 id, int16 node, int8 type, int8 next, int16 x, int16 y, int16 z, int16 width, int8 numLeft, int8 numRight)
+{
+	int i;
+
+	i = id*12 + node;
+	InfoForTileCars[i].type = type;
+	InfoForTileCars[i].next = next;
+	InfoForTileCars[i].x = x;
+	InfoForTileCars[i].y = y;
+	InfoForTileCars[i].z = z;
+	InfoForTileCars[i].numLeftLanes = numLeft;
+	InfoForTileCars[i].numRightLanes = numRight;
+}
+
+void
+CPathFind::RegisterMapObject(CTreadable *mapObject)
+{
+	m_mapObjects[m_numMapObjects++] = mapObject;
+}
+
 void
 CPathFind::PreparePathData(void)
 {
@@ -457,8 +494,8 @@ CPathFind::PreparePathDataForType(uint8 type, CTempNode *tempnodes, CPathInfoFor
 					}
 				}else{
 					// Crosses road
-					if(objectpathinfo[istart + iseg].next == jseg && objectpathinfo[istart + iseg].flag & 1 ||
-					   objectpathinfo[jstart + jseg].next == iseg && objectpathinfo[jstart + jseg].flag & 1)
+					if(objectpathinfo[istart + iseg].next == jseg && objectpathinfo[istart + iseg].crossing ||
+					   objectpathinfo[jstart + jseg].next == iseg && objectpathinfo[jstart + jseg].crossing)
 						m_connectionFlags[m_numConnections] |= ConnectionCrossRoad;
 					else
 						m_connectionFlags[m_numConnections] &= ~ConnectionCrossRoad;

src/control/PathFind.h

@@ -65,8 +65,10 @@ struct CPathInfoForObject
 	int8 next;
 	int8 numLeftLanes;
 	int8 numRightLanes;
-	uint8 flag;
+	uint8 crossing : 1;
 };
+extern CPathInfoForObject *&InfoForTileCars;
+extern CPathInfoForObject *&InfoForTilePeds;
 
 struct CTempNode
 {
@@ -123,6 +125,11 @@ public:
 	void PreparePathDataForType(uint8 type, CTempNode *tempnodes, CPathInfoForObject *objectpathinfo,
 		float unk, CTempDetachedNode *detachednodes, int unused);
 	void CalcNodeCoors(int16 x, int16 y, int16 z, int32 id, CVector *out);
+	void StoreNodeInfoPed(int16 id, int16 node, int8 type, int8 next, int16 x, int16 y, int16 z, int16 width, bool crossing);
+	void StoreNodeInfoCar(int16 id, int16 node, int8 type, int8 next, int16 x, int16 y, int16 z, int16 width, int8 numLeft, int8 numRight);
+	void RegisterMapObject(CTreadable *mapObject);
+
+	bool IsPathObject(int id) { return id < PATHNODESIZE && (InfoForTileCars[id*12].type != 0 || InfoForTilePeds[id*12].type != 0); }
 };
 static_assert(sizeof(CPathFind) == 0x4c8f4, "CPathFind: error");
 

src/control/PedStats.cpp

@@ -0,0 +1,5 @@
+#include "common.h"
+#include "patcher.h"
+#include "PedStats.h"
+
+WRAPPER int32 CPedStats::GetPedStatType(char *type) { EAXJMP(0x4EF780); }

src/control/PedStats.h

@@ -15,3 +15,9 @@ struct PedStat
 	int16 m_flags;
 };
 static_assert(sizeof(PedStat) == 0x34, "PedStat: error");
+
+class CPedStats
+{
+public:
+	static int32 GetPedStatType(char *type);
+};

src/control/PedType.cpp

@@ -0,0 +1,5 @@
+#include "common.h"
+#include "patcher.h"
+#include "PedType.h"
+
+WRAPPER int32 CPedType::FindPedType(char *type) { EAXJMP(0x4EEC10); }

src/control/PedType.h

@@ -0,0 +1,7 @@
+#pragma once
+
+class CPedType
+{
+public:
+	static int32 FindPedType(char *type);
+};

src/entities/Building.h

@@ -6,7 +6,10 @@ class CBuilding : public CEntity
 {
 public:
 	// TODO: ReplaceWithNewModel
-	// TODO: ctor
+	CBuilding(void) {
+		m_type = ENTITY_TYPE_BUILDING;
+		bUsesCollision = true;
+	}
 	static void *operator new(size_t);
 	static void operator delete(void*, size_t);
 

src/entities/CutsceneHead.cpp

@@ -1,6 +1,7 @@
 #include "common.h"
 #include <rpskin.h>
 #include "patcher.h"
+#include "main.h"
 #include "RwHelper.h"
 #include "RpAnimBlend.h"
 #include "AnimBlendClumpData.h"

src/entities/CutsceneObject.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "lights.h"
 #include "PointLights.h"
 #include "RpAnimBlend.h"

src/entities/Dummy.h

@@ -8,6 +8,9 @@ class CDummy : public CEntity
 public:
 	CEntryInfoList m_entryInfoList;
 
+	CDummy(void) { m_type = ENTITY_TYPE_DUMMY; }
+	// TODO: Add, Remove
+
 	static void *operator new(size_t);
 	static void operator delete(void*, size_t);
 };

src/entities/DummyObject.cpp

@@ -0,0 +1,13 @@
+#include "common.h"
+#include "patcher.h"
+#include "DummyObject.h"
+#include "Pools.h"
+
+CDummyObject::CDummyObject(CObject *obj)
+{
+	SetModelIndexNoCreate(obj->GetModelIndex());
+	if(obj->m_rwObject)
+		AttachToRwObject(obj->m_rwObject);
+	obj->DetachFromRwObject();
+	m_level = obj->m_level;
+}

src/entities/DummyObject.h

@@ -2,7 +2,12 @@
 
 #include "Dummy.h"
 
-class CDummyObject : CDummy
+class CObject;
+
+class CDummyObject : public CDummy
 {
+public:
+	CDummyObject(void) {}
+	CDummyObject(CObject *obj);
 };
 static_assert(sizeof(CDummyObject) == 0x68, "CDummyObject: error");

src/entities/Entity.cpp

@@ -48,7 +48,7 @@ CEntity::CEntity(void)
 	bHasHitWall = false;
 	bImBeingRendered = false;
 	m_flagD8 = false;
-	m_flagD10 = false;
+	bIsSubway = false;
 	bDrawLast = false;
 	m_flagD40 = false;
 	m_flagD80 = false;

src/entities/Entity.h

@@ -79,7 +79,7 @@ public:
 	uint32 bHasHitWall : 1;
 	uint32 bImBeingRendered : 1;
 	uint32 m_flagD8 : 1;
-	uint32 m_flagD10 : 1;
+	uint32 bIsSubway : 1;	// set when subway, but maybe different meaning?
 	uint32 bDrawLast : 1;
 	uint32 m_flagD40 : 1;
 	uint32 m_flagD80 : 1;	// CObject visibility?

src/entities/Ped.cpp

@@ -4,7 +4,6 @@
 #include "Particle.h"
 #include "Stats.h"
 #include "World.h"
-#include "PedStat.h"
 #include "DMaudio.h"
 #include "Ped.h"
 #include "PedType.h"

src/main.cpp

@@ -1,5 +1,7 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
+#include "General.h"
 #include "RwHelper.h"
 #include "Clouds.h"
 #include "Draw.h"
@@ -55,6 +57,8 @@
 #endif
 													   
 
+GlobalScene &Scene = *(GlobalScene*)0x726768;
+
 uint8 work_buff[55000];
 char gString[256];
 wchar *gUString = (wchar*)0x74B018;
@@ -576,6 +580,29 @@ ResetLoadingScreenBar(void)
 	NumberOfChunksLoaded = 0.0f;
 }
 
+char*
+GetRandomSplashScreen(void)
+{
+	int index;
+	static int index2 = 0;
+	static char splashName[128];
+	static int splashIndex[24] = {
+		25, 22, 4, 13,
+		1, 21, 14, 16,
+		10, 12, 5, 9,
+		11, 18, 3, 2,
+		19, 23, 7, 17,
+		15, 6, 8, 20
+	};
+
+	index = splashIndex[4*index2 + CGeneral::GetRandomNumberInRange(0, 3)];
+	index2++;
+	if(index2 == 6)
+		index2 = 0;
+	sprintf(splashName, "loadsc%d", index);
+	return splashName;
+}
+
 #include "rwcore.h"
 #include "rpworld.h"
 #include "rpmatfx.h"

src/main.h

@@ -0,0 +1,18 @@
+#pragma once
+
+struct GlobalScene
+{
+	RpWorld *world;
+	RwCamera *camera;
+};
+extern GlobalScene &Scene;
+
+extern uint8 work_buff[55000];
+extern char gString[256];
+extern wchar *gUString;
+
+class CSprite2d;
+
+void LoadingScreen(const char *str1, const char *str2, const char *splashscreen);
+CSprite2d *LoadSplash(const char *name);
+char *GetRandomSplashScreen(void);

src/modelinfo/BaseModelInfo.h

@@ -41,6 +41,9 @@ public:
 	virtual RwObject *GetRwObject(void) = 0;
 
 	bool IsSimple(void) { return m_type == MITYPE_SIMPLE || m_type == MITYPE_TIME; }
+	bool IsClump(void) { return m_type == MITYPE_CLUMP || m_type == MITYPE_PED || m_type == MITYPE_VEHICLE ||
+		m_type == MITYPE_MLO || m_type == MITYPE_XTRACOMPS;	// unused but what the heck
+	}
 	char *GetName(void) { return m_name; }
 	void SetName(const char *name) { strncpy(m_name, name, 24); }
 	void SetColModel(CColModel *col, bool free = false){

src/modelinfo/ModelIndices.h

@@ -320,9 +320,12 @@ enum
 	MI_CAR_PANEL,
 	MI_CAR_BONNET,
 	MI_CAR_BOOT,
-	MI_CAR_WEEL,
+	MI_CAR_WHEEL,
 	MI_BODYPARTA,
 	MI_BODYPARTB,
+
+	MI_AIRTRAIN_VLO = 198,
+	MI_LOPOLYGUY,
 };
 
 void InitModelIndices(void);

src/modelinfo/ModelInfo.cpp

@@ -1,5 +1,7 @@
 #include "common.h"
 #include "patcher.h"
+#include "TempColModels.h"
+#include "ModelIndices.h"
 #include "ModelInfo.h"
 
 CBaseModelInfo **CModelInfo::ms_modelInfoPtrs = (CBaseModelInfo**)0x83D408;
@@ -18,6 +20,8 @@ void
 CModelInfo::Initialise(void)
 {
 	int i;
+	CSimpleModelInfo *m;
+
 	for(i = 0; i < MODELINFOSIZE; i++)
 		ms_modelInfoPtrs[i] = nil;
 	ms_2dEffectStore.clear();
@@ -26,10 +30,58 @@ CModelInfo::Initialise(void)
 	ms_clumpModelStore.clear();
 	ms_pedModelStore.clear();
 	ms_vehicleModelStore.clear();
+
+	m = AddSimpleModel(MI_CAR_DOOR);
+	m->SetColModel(&CTempColModels::ms_colModelDoor1);
+	m->SetTexDictionary("generic");
+	m->SetNumAtomics(1);
+	m->m_lodDistances[0] = 80.0f;
+
+	m = AddSimpleModel(MI_CAR_BUMPER);
+	m->SetColModel(&CTempColModels::ms_colModelBumper1);
+	m->SetTexDictionary("generic");
+	m->SetNumAtomics(1);
+	m->m_lodDistances[0] = 80.0f;
+
+	m = AddSimpleModel(MI_CAR_PANEL);
+	m->SetColModel(&CTempColModels::ms_colModelPanel1);
+	m->SetTexDictionary("generic");
+	m->SetNumAtomics(1);
+	m->m_lodDistances[0] = 80.0f;
+
+	m = AddSimpleModel(MI_CAR_BONNET);
+	m->SetColModel(&CTempColModels::ms_colModelBonnet1);
+	m->SetTexDictionary("generic");
+	m->SetNumAtomics(1);
+	m->m_lodDistances[0] = 80.0f;
+
+	m = AddSimpleModel(MI_CAR_BOOT);
+	m->SetColModel(&CTempColModels::ms_colModelBoot1);
+	m->SetTexDictionary("generic");
+	m->SetNumAtomics(1);
+	m->m_lodDistances[0] = 80.0f;
+
+	m = AddSimpleModel(MI_CAR_WHEEL);
+	m->SetColModel(&CTempColModels::ms_colModelWheel1);
+	m->SetTexDictionary("generic");
+	m->SetNumAtomics(1);
+	m->m_lodDistances[0] = 80.0f;
+
+	m = AddSimpleModel(MI_BODYPARTA);
+	m->SetColModel(&CTempColModels::ms_colModelBodyPart1);
+	m->SetTexDictionary("generic");
+	m->SetNumAtomics(1);
+	m->m_lodDistances[0] = 80.0f;
+
+	m = AddSimpleModel(MI_BODYPARTB);
+	m->SetColModel(&CTempColModels::ms_colModelBodyPart2);
+	m->SetTexDictionary("generic");
+	m->SetNumAtomics(1);
+	m->m_lodDistances[0] = 80.0f;
 }
 
 void
-CModelInfo::Shutdown(void)
+CModelInfo::ShutDown(void)
 {
 	int i;
 	for(i = 0; i < ms_simpleModelStore.allocPtr; i++)
@@ -42,6 +94,8 @@ CModelInfo::Shutdown(void)
 		ms_pedModelStore.store[i].Shutdown();
 	for(i = 0; i < ms_vehicleModelStore.allocPtr; i++)
 		ms_vehicleModelStore.store[i].Shutdown();
+	for(i = 0; i < ms_2dEffectStore.allocPtr; i++)
+		ms_2dEffectStore.store[i].Shutdown();
 }
 
 CSimpleModelInfo*
@@ -115,10 +169,12 @@ CModelInfo::GetModelInfo(const char *name, int *id)
 }
 
 STARTPATCHES
-//	InjectHook(0x50B920, CModelInfo::AddSimpleModel, PATCH_JUMP);
-//	InjectHook(0x50B9C0, CModelInfo::AddTimeModel, PATCH_JUMP);
-//	InjectHook(0x50BA10, CModelInfo::AddClumpModel, PATCH_JUMP);
-//	InjectHook(0x50BAD0, CModelInfo::AddPedModel, PATCH_JUMP);
-//	InjectHook(0x50BA60, CModelInfo::AddPedModel, PATCH_JUMP);
+	InjectHook(0x50B310, CModelInfo::Initialise, PATCH_JUMP);
+	InjectHook(0x50B5B0, CModelInfo::ShutDown, PATCH_JUMP);
+	InjectHook(0x50B920, CModelInfo::AddSimpleModel, PATCH_JUMP);
+	InjectHook(0x50B9C0, CModelInfo::AddTimeModel, PATCH_JUMP);
+	InjectHook(0x50BA10, CModelInfo::AddClumpModel, PATCH_JUMP);
+	InjectHook(0x50BAD0, CModelInfo::AddPedModel, PATCH_JUMP);
+	InjectHook(0x50BA60, CModelInfo::AddVehicleModel, PATCH_JUMP);
 	InjectHook(0x50B860, (CBaseModelInfo *(*)(const char*, int*))CModelInfo::GetModelInfo, PATCH_JUMP);
 ENDPATCHES

src/modelinfo/ModelInfo.h

@@ -20,7 +20,7 @@ class CModelInfo
 
 public:
 	static void Initialise(void);
-	static void Shutdown(void);
+	static void ShutDown(void);
 
 	static CSimpleModelInfo *AddSimpleModel(int id);
 	static CTimeModelInfo *AddTimeModel(int id);
@@ -28,6 +28,8 @@ public:
 	static CPedModelInfo *AddPedModel(int id);
 	static CVehicleModelInfo *AddVehicleModel(int id);
 
+	static CStore<C2dEffect, TWODFXSIZE> &Get2dEffectStore(void) { return ms_2dEffectStore; }
+
 	static CBaseModelInfo *GetModelInfo(const char *name, int *id);
 	static CBaseModelInfo *GetModelInfo(int id){
 		return ms_modelInfoPtrs[id];

src/modelinfo/PedModelInfo.h

@@ -21,7 +21,7 @@ enum PedNode {
 class CPedModelInfo : public CClumpModelInfo
 {
 public:
-	void *m_animGroup;	// TODO
+	int32 m_animGroup;
 	int32 m_pedType;
 	int32 m_pedStatType;
 	uint32 m_carsCanDrive;

src/modelinfo/SimpleModelInfo.cpp

@@ -53,7 +53,7 @@ CSimpleModelInfo::Init(void)
 	m_atomics[1] = nil;
 	m_atomics[2] = nil;
 	m_numAtomics = 0;
-	m_furthest      = 0;
+	m_firstDamaged  = 0;
 	m_normalCull    = 0;
 	m_isDamaged     = 0;
 	m_isBigBuilding = 0;
@@ -103,11 +103,10 @@ float
 CSimpleModelInfo::GetLargestLodDistance(void)
 {
 	float d;
-	// TODO: what exactly is going on here?
-	if(m_furthest != 0 && !m_isDamaged)
-		d = m_lodDistances[m_furthest-1];
-	else
+	if(m_firstDamaged == 0 || m_isDamaged)
 		d = m_lodDistances[m_numAtomics-1];
+	else
+		d = m_lodDistances[m_firstDamaged-1];
 	return d * TheCamera.LODDistMultiplier;
 }
 
@@ -116,9 +115,8 @@ CSimpleModelInfo::GetAtomicFromDistance(float dist)
 {
 	int i;
 	i = 0;
-	// TODO: what exactly is going on here?
 	if(m_isDamaged)
-		i = m_furthest;
+		i = m_firstDamaged;
 	for(; i < m_numAtomics; i++)
 		if(dist < m_lodDistances[i] *TheCamera.LODDistMultiplier)
 			return m_atomics[i];

src/modelinfo/SimpleModelInfo.h

@@ -11,9 +11,9 @@ public:
 	float  m_lodDistances[3];
 	uint8  m_numAtomics;
 	uint8  m_alpha;
-	uint16 m_furthest      : 2; // 0: numAtomics-1 is furthest visible
-	                         // 1: atomic 0 is furthest
-	                         // 2: atomic 1 is furthest
+	uint16 m_firstDamaged   : 2; // 0: no damage model
+	                         // 1: 1 and 2 are damage models
+	                         // 2: 2 is damage model
 	uint16  m_normalCull    : 1;
 	uint16  m_isDamaged     : 1;
 	uint16  m_isBigBuilding : 1;

src/modelinfo/TimeModelInfo.h

@@ -12,7 +12,9 @@ public:
 
 	int32 GetTimeOn(void) { return m_timeOn; }
 	int32 GetTimeOff(void) { return m_timeOff; }
+	void SetTimes(int32 on, int32 off) { m_timeOn = on; m_timeOff = off; }
 	int32 GetOtherTimeModel(void) { return m_otherTimeModelID; }
+	void SetOtherTimeModel(int32 other) { m_otherTimeModelID = other; }
 	CTimeModelInfo *FindOtherTimeModel(void);
 };
 static_assert(sizeof(CTimeModelInfo) == 0x58, "CTimeModelInfo: error");

src/modelinfo/VehicleModelInfo.h

@@ -35,6 +35,17 @@ enum {
 	NUM_VEHICLE_TYPES
 };
 
+enum {
+	VEHICLE_CLASS_POOR,
+	VEHICLE_CLASS_RICH,
+	VEHICLE_CLASS_EXECUTIVE,
+	VEHICLE_CLASS_WORKER,
+	VEHICLE_CLASS_SPECIAL,
+	VEHICLE_CLASS_BIG,
+	VEHICLE_CLASS_TAXI,
+	NUM_VEHICLE_CLASSES
+};
+
 class CVehicleModelInfo : public CClumpModelInfo
 {
 public:

src/re3.cpp

@@ -10,8 +10,6 @@
 
 void **rwengine = *(void***)0x5A10E1;
 
-GlobalScene &Scene = *(GlobalScene*)0x726768;
-
 DebugMenuAPI gDebugMenuAPI;
 
 WRAPPER void *gtanew(uint32 sz) { EAXJMP(0x5A0690); }

src/render/2dEffect.h

@@ -1,3 +1,9 @@
+enum {
+	EFFECT_LIGHT,
+	EFFECT_PARTICLE,
+	EFFECT_ATTRACTOR
+};
+
 class C2dEffect
 {
 public:
@@ -7,26 +13,26 @@ public:
 		float size;
 		float innerRange;
 		uint8 flash;
-		uint8 wet;
-		uint8 flare;
-		uint8 shadowIntens;
-		uint8 flag;
+		uint8 roadReflection;
+		uint8 flareType;
+		uint8 shadowIntensity;
+		uint8 flags;
 		RwTexture *corona;
 		RwTexture *shadow;
 	};
 	struct Particle {
 		int particleType;
-		float dir[3];
+		CVector dir;
 		float scale;
 	};
 	struct Attractor {
 		CVector dir;
-		uint8 flag;
+		uint8 flags;
 		uint8 probability;
 	};
 
 	CVector pos;
-	RwRGBA col;
+	CRGBA col;
 	uint8 type;
 	union {
 		Light light;
@@ -35,5 +41,13 @@ public:
 	};
 
 	C2dEffect(void) {}
+	void Shutdown(void){
+		if(type == 0){	// TODO: enum
+			if(light.corona)
+				RwTextureDestroy(light.corona);
+			if(light.shadow)
+				RwTextureDestroy(light.shadow);
+		}
+	}
 };
 static_assert(sizeof(C2dEffect) == 0x34, "C2dEffect: error");

src/render/Coronas.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "General.h"
 #include "TxdStore.h"
 #include "Camera.h"

src/render/Hud.cpp

@@ -432,7 +432,7 @@ void CHud::Draw()
 				if (CWorld::Players[CWorld::PlayerInFocus].m_pPed->m_fHealth >= 10
 					|| CWorld::Players[CWorld::PlayerInFocus].m_pPed->m_fHealth < 10 && CTimer::GetFrameCounter() & 8) {
 
-					AsciiToUnicode("[", sPrintIcon);
+					AsciiToUnicode("{", sPrintIcon);
 					sprintf(sTemp, "%03d", (int32)CWorld::Players[CWorld::PlayerInFocus].m_pPed->m_fHealth);
 					AsciiToUnicode(sTemp, sPrint);
 

src/render/ParticleMgr.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "FileMgr.h"
 #include "ParticleMgr.h"
 

src/render/PointLights.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "Lights.h"
 #include "Camera.h"
 #include "Weather.h"

src/render/Renderer.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "Lights.h"
 #include "ModelInfo.h"
 #include "Treadable.h"

src/render/Sprite.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "Draw.h"
 #include "Camera.h"
 #include "Sprite.h"

src/render/Sprite2d.cpp

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "Draw.h"
 #include "Camera.h"
 #include "Sprite2d.h"

src/skel/win/win.cpp

@@ -83,6 +83,7 @@ static psGlobalType &PsGlobal = *(psGlobalType*)0x72CF60;
 
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "FileMgr.h"
 #include "Text.h"
 #include "Pad.h"

src/templates.h

@@ -8,8 +8,10 @@ public:
 	T store[n];
 
 	T *alloc(void){
-		if(this->allocPtr >= n)
+		if(this->allocPtr >= n){
 			printf("Size of this thing:%d needs increasing\n", n);
+			assert(0);
+		}
 		return &this->store[this->allocPtr++];
 	}
 	void clear(void){