1 files changed, 953 insertions, 56 deletions

diff --git a/src/Streaming.cpp b/src/Streaming.cpp
index 2504ed9c..149de7c3 100644
--- a/src/Streaming.cpp
+++ b/src/Streaming.cpp
@@ -1,5 +1,8 @@
 #include "common.h"
 #include "patcher.h"
+#include "Pad.h"
+#include "Hud.h"
+#include "Text.h"
 #include "ModelInfo.h"
 #include "TxdStore.h"
 #include "ModelIndices.h"
@@ -13,11 +16,6 @@
 #include "CdStream.h"
 #include "Streaming.h"
 
-/*
-CStreaming::ms_channelError	0x880DB8	
-CStreaming::ms_lastVehicleDeleted	0x95CBF8	
-*/
-
 bool &CStreaming::ms_disableStreaming = *(bool*)0x95CD6E;
 bool &CStreaming::ms_bLoadingBigModel = *(bool*)0x95CDB0;
 int32 &CStreaming::ms_numModelsRequested = *(int32*)0x8E2C10;
@@ -28,12 +26,14 @@ CStreamingInfo &CStreaming::ms_startRequestedList = *(CStreamingInfo*)0x8F1B3C;
 CStreamingInfo &CStreaming::ms_endRequestedList = *(CStreamingInfo*)0x940738;
 int32 &CStreaming::ms_oldSectorX = *(int32*)0x8F2C84;
 int32 &CStreaming::ms_oldSectorY = *(int32*)0x8F2C88;
-uint32 &CStreaming::ms_streamingBufferSize = *(uint32*)0x942FB0;
-uint8 **CStreaming::ms_pStreamingBuffer = (uint8**)0x87F818;
+int32 &CStreaming::ms_streamingBufferSize = *(int32*)0x942FB0;
+int8 **CStreaming::ms_pStreamingBuffer = (int8**)0x87F818;
 int32 &CStreaming::ms_memoryUsed = *(int32*)0x940568;
 CStreamingChannel *CStreaming::ms_channel = (CStreamingChannel*)0x727EE0;
+int32 &CStreaming::ms_channelError = *(int32*)0x880DB8;
 int32 &CStreaming::ms_numVehiclesLoaded = *(int32*)0x8F2C80;
 int32 *CStreaming::ms_vehiclesLoaded = (int32*)0x773560;
+int32 &CStreaming::ms_lastVehicleDeleted = *(int32*)0x95CBF8;
 CDirectory *&CStreaming::ms_pExtraObjectsDir = *(CDirectory**)0x95CB90;
 int32 &CStreaming::ms_numPriorityRequests = *(int32*)0x8F31C4;
 bool &CStreaming::ms_hasLoadedLODs = *(bool*)0x95CD47;
@@ -60,8 +60,8 @@ int32 &islandLODsubInd = *(int32*)0x6212D4;
 int32 &islandLODsubCom = *(int32*)0x6212D8;
 
 WRAPPER void CStreaming::MakeSpaceFor(int32 size) { EAXJMP(0x409B70); }
-WRAPPER bool CStreaming::IsTxdUsedByRequestedModels(int32 txdId) { EAXJMP(0x4094C0); }
-WRAPPER bool CStreaming::AddToLoadedVehiclesList(int32 modelId) { EAXJMP(0x40B060); }
+//WRAPPER bool CStreaming::IsTxdUsedByRequestedModels(int32 txdId) { EAXJMP(0x4094C0); }
+//WRAPPER bool CStreaming::AddToLoadedVehiclesList(int32 modelId) { EAXJMP(0x40B060); }
 
 
 void
@@ -78,6 +78,8 @@ CStreaming::Init(void)
 		ms_aInfoForModel[i].m_position = 0;
 	}
 
+	ms_channelError = -1;
+
 	// init lists
 
 	ms_startLoadedList.m_next = &ms_endLoadedList;
@@ -101,12 +103,12 @@ CStreaming::Init(void)
 
 	// init channels
 
-	ms_channel[0].state = CHANNELSTATE_0;
-	ms_channel[1].state = CHANNELSTATE_0;
+	ms_channel[0].state = CHANNELSTATE_IDLE;
+	ms_channel[1].state = CHANNELSTATE_IDLE;
 	for(i = 0; i < 4; i++){
-		ms_channel[0].modelIds[i] = -1;
+		ms_channel[0].streamIds[i] = -1;
 		ms_channel[0].offsets[i] = -1;
-		ms_channel[1].modelIds[i] = -1;
+		ms_channel[1].streamIds[i] = -1;
 		ms_channel[1].offsets[i] = -1;
 	}
 
@@ -115,8 +117,8 @@ CStreaming::Init(void)
 	for(i = 0; i < MODELINFOSIZE; i++){
 		CBaseModelInfo *mi = CModelInfo::GetModelInfo(i);
 		if(mi && mi->GetRwObject()){
-			ms_aInfoForModel[i + STREAM_OFFSET_MODEL].m_loadState = STREAMSTATE_LOADED;
-			ms_aInfoForModel[i + STREAM_OFFSET_MODEL].m_flags = STREAMFLAGS_DONT_REMOVE;
+			ms_aInfoForModel[i].m_loadState = STREAMSTATE_LOADED;
+			ms_aInfoForModel[i].m_flags = STREAMFLAGS_DONT_REMOVE;
 			if(mi->IsSimple())
 				((CSimpleModelInfo*)mi)->m_alpha = 255;
 		}
@@ -143,7 +145,7 @@ CStreaming::Init(void)
 
 	// allocate streaming buffers
 	if(ms_streamingBufferSize & 1) ms_streamingBufferSize++;
-	ms_pStreamingBuffer[0] = (uint8*)RwMallocAlign(ms_streamingBufferSize*CDSTREAM_SECTOR_SIZE, CDSTREAM_SECTOR_SIZE);
+	ms_pStreamingBuffer[0] = (int8*)RwMallocAlign(ms_streamingBufferSize*CDSTREAM_SECTOR_SIZE, CDSTREAM_SECTOR_SIZE);
 	ms_streamingBufferSize /= 2;
 	ms_pStreamingBuffer[1] = ms_pStreamingBuffer[0] + ms_streamingBufferSize*CDSTREAM_SECTOR_SIZE;
 	debug("Streaming buffer size is %d sectors", ms_streamingBufferSize);
@@ -211,6 +213,9 @@ CStreaming::LoadCdDirectory(void)
 		ms_imageOffsets[i] = -1;
 	ms_imageSize = GetGTA3ImgSize();
 
+	// PS2 uses CFileMgr::GetCdFile on all IMG files to fill the array
+
+
 	i = CdStreamGetNumImages();
 	while(i-- >= 1){
 		strcpy(dirname, CdStreamGetImageName(i));
@@ -240,20 +245,20 @@ CStreaming::LoadCdDirectory(const char *dirname, int n)
 	while(CFileMgr::Read(fd, (char*)&direntry, sizeof(direntry))){
 		dot = strchr(direntry.name, '.');
 		if(dot) *dot = '\0';
-		if(direntry.size > ms_streamingBufferSize)
+		if(direntry.size > (uint32)ms_streamingBufferSize)
 			ms_streamingBufferSize = direntry.size;
 
 		if(strcmp(dot+1, "DFF") == 0 || strcmp(dot+1, "dff") == 0){
 			if(CModelInfo::GetModelInfo(direntry.name, &modelId)){
-				if(ms_aInfoForModel[modelId + STREAM_OFFSET_MODEL].GetCdPosnAndSize(posn, size)){
+				if(ms_aInfoForModel[modelId].GetCdPosnAndSize(posn, size)){
 					debug("%s appears more than once in %s\n", direntry.name, dirname);
 					lastID = -1;
 				}else{
 					direntry.offset |= imgSelector;
-					ms_aInfoForModel[modelId + STREAM_OFFSET_MODEL].SetCdPosnAndSize(direntry.offset, direntry.size);
+					ms_aInfoForModel[modelId].SetCdPosnAndSize(direntry.offset, direntry.size);
 					if(lastID != -1)
-						ms_aInfoForModel[lastID].m_nextID = modelId + STREAM_OFFSET_MODEL;
-					lastID = modelId + STREAM_OFFSET_MODEL;
+						ms_aInfoForModel[lastID].m_nextID = modelId;
+					lastID = modelId;
 				}
 			}else{
 				// BUG: doesn't remember which cdimage this was in
@@ -300,15 +305,14 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 
 	if(streamId < STREAM_OFFSET_TXD){
 		// Model
-		mi = CModelInfo::GetModelInfo(streamId - STREAM_OFFSET_MODEL);
+		mi = CModelInfo::GetModelInfo(streamId);
 
 		// Txd has to be loaded
 		if(CTxdStore::GetSlot(mi->GetTxdSlot())->texDict == nil){
 			debug("failed to load %s because TXD %s is not in memory\n", mi->GetName(), CTxdStore::GetTxdName(mi->GetTxdSlot()));
 			RemoveModel(streamId);
-			RemoveModel(mi->GetTxdSlot() + STREAM_OFFSET_TXD);
-			// re-request
-			RequestModel(streamId, ms_aInfoForModel[streamId].m_flags);
+			RemoveTxd(mi->GetTxdSlot());
+			ReRequestModel(streamId);
 			RwStreamClose(stream, &mem);
 			return false;
 		}
@@ -318,15 +322,15 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 		CTxdStore::SetCurrentTxd(mi->GetTxdSlot());
 
 		if(mi->IsSimple()){
-			success = CFileLoader::LoadAtomicFile(stream, streamId - STREAM_OFFSET_MODEL);
+			success = CFileLoader::LoadAtomicFile(stream, streamId);
 		}else if(mi->m_type == MITYPE_VEHICLE){
 			// load vehicles in two parts
-			CModelInfo::GetModelInfo(streamId - STREAM_OFFSET_MODEL)->AddRef();
-			success = CFileLoader::StartLoadClumpFile(stream, streamId - STREAM_OFFSET_MODEL);
+			CModelInfo::GetModelInfo(streamId)->AddRef();
+			success = CFileLoader::StartLoadClumpFile(stream, streamId);
 			if(success)
 				ms_aInfoForModel[streamId].m_loadState = STREAMSTATE_STARTED;
 		}else{
-			success = CFileLoader::LoadClumpFile(stream, streamId - STREAM_OFFSET_MODEL);
+			success = CFileLoader::LoadClumpFile(stream, streamId);
 		}
 		UpdateMemoryUsed();
 
@@ -335,10 +339,9 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 			CTxdStore::RemoveRefWithoutDelete(mi->GetTxdSlot());
 
 		if(!success){
-			debug("Failed to load %s\n", CModelInfo::GetModelInfo(streamId - STREAM_OFFSET_MODEL)->GetName());
+			debug("Failed to load %s\n", CModelInfo::GetModelInfo(streamId)->GetName());
 			RemoveModel(streamId);
-			// re-request
-			RequestModel(streamId, ms_aInfoForModel[streamId].m_flags);
+			ReRequestModel(streamId);
 			RwStreamClose(stream, &mem);
 			return false;
 		}
@@ -363,8 +366,7 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 		if(!success){
 			debug("Failed to load %s.txd\n", CTxdStore::GetTxdName(streamId - STREAM_OFFSET_TXD));
 			RemoveModel(streamId);
-			// re-request
-			RequestModel(streamId, ms_aInfoForModel[streamId].m_flags);
+			ReRequestModel(streamId);
 			RwStreamClose(stream, &mem);
 			return false;
 		}
@@ -374,7 +376,7 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 
 	// We shouldn't even end up here unless load was successful
 	if(!success){
-		RequestModel(streamId, ms_aInfoForModel[streamId].m_flags);
+		ReRequestModel(streamId);
 		if(streamId < STREAM_OFFSET_TXD)
 			debug("Failed to load %s.dff\n", mi->GetName());
 		else
@@ -415,7 +417,7 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 	timeDiff = endTime - startTime;
 	if(timeDiff > 5){
 		if(streamId < STREAM_OFFSET_TXD)
-			debug("model %s took %d ms\n", CModelInfo::GetModelInfo(streamId - STREAM_OFFSET_MODEL)->GetName(), timeDiff);
+			debug("model %s took %d ms\n", CModelInfo::GetModelInfo(streamId)->GetName(), timeDiff);
 		else
 			debug("txd %s took %d ms\n", CTxdStore::GetTxdName(streamId - STREAM_OFFSET_TXD), timeDiff);
 	}
@@ -437,7 +439,7 @@ CStreaming::FinishLoadingLargeFile(int8 *buf, int32 streamId)
 
 	if(ms_aInfoForModel[streamId].m_loadState != STREAMSTATE_STARTED){
 		if(streamId < STREAM_OFFSET_TXD)
-			CModelInfo::GetModelInfo(streamId - STREAM_OFFSET_MODEL)->RemoveRef();
+			CModelInfo::GetModelInfo(streamId)->RemoveRef();
 		return false;
 	}
 
@@ -447,7 +449,7 @@ CStreaming::FinishLoadingLargeFile(int8 *buf, int32 streamId)
 
 	if(streamId < STREAM_OFFSET_TXD){
 		// Model
-		mi = CModelInfo::GetModelInfo(streamId - STREAM_OFFSET_MODEL);
+		mi = CModelInfo::GetModelInfo(streamId);
 		CTxdStore::SetCurrentTxd(mi->GetTxdSlot());
 		success = CFileLoader::FinishLoadClumpFile(stream, streamId);
 		if(success)
@@ -467,8 +469,7 @@ CStreaming::FinishLoadingLargeFile(int8 *buf, int32 streamId)
 
 	if(!success){
 		RemoveModel(streamId);
-		// re-request
-		RequestModel(streamId, ms_aInfoForModel[streamId].m_flags);
+		ReRequestModel(streamId);
 		UpdateMemoryUsed();
 		return false;
 	}
@@ -479,7 +480,7 @@ CStreaming::FinishLoadingLargeFile(int8 *buf, int32 streamId)
 	timeDiff = endTime - startTime;
 	if(timeDiff > 5){
 		if(streamId < STREAM_OFFSET_TXD)
-			debug("finish model %s took %d ms\n", CModelInfo::GetModelInfo(streamId - STREAM_OFFSET_MODEL)->GetName(), timeDiff);
+			debug("finish model %s took %d ms\n", CModelInfo::GetModelInfo(streamId)->GetName(), timeDiff);
 		else
 			debug("finish txd %s took %d ms\n", CTxdStore::GetTxdName(streamId - STREAM_OFFSET_TXD), timeDiff);
 	}
@@ -494,7 +495,7 @@ CStreaming::RequestModel(int32 id, int32 flags)
 
 	if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_INQUEUE){
 		// updgrade to priority
-		if(flags & STREAMFLAGS_PRIORITY && (ms_aInfoForModel[id].m_flags & STREAMFLAGS_PRIORITY) == 0){
+		if(flags & STREAMFLAGS_PRIORITY && !ms_aInfoForModel[id].IsPriority()){
 			ms_numPriorityRequests++;
 			ms_aInfoForModel[id].m_flags |= STREAMFLAGS_PRIORITY;
 		}
@@ -507,7 +508,7 @@ CStreaming::RequestModel(int32 id, int32 flags)
 		// Already loaded, only check changed flags
 
 		if(ms_aInfoForModel[id].m_flags & STREAMFLAGS_NOFADE && id < STREAM_OFFSET_TXD){
-			mi = (CSimpleModelInfo*)CModelInfo::GetModelInfo(id - STREAM_OFFSET_MODEL);
+			mi = (CSimpleModelInfo*)CModelInfo::GetModelInfo(id);
 			if(mi->IsSimple())
 				mi->m_alpha = 255;
 		}
@@ -523,7 +524,7 @@ CStreaming::RequestModel(int32 id, int32 flags)
 
 		if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_NOTLOADED){
 			if(id < STREAM_OFFSET_TXD)
-				RequestTxd(CModelInfo::GetModelInfo(id - STREAM_OFFSET_MODEL)->GetTxdSlot(), flags);
+				RequestTxd(CModelInfo::GetModelInfo(id)->GetTxdSlot(), flags);
 			ms_aInfoForModel[id].AddToList(&ms_startRequestedList);
 			ms_numModelsRequested++;
 			if(flags & STREAMFLAGS_PRIORITY)
@@ -658,6 +659,16 @@ CStreaming::RequestSpecialChar(int32 charId, const char *modelName, int32 flags)
 }
 
 void
+CStreaming::DecrementRef(int32 id)
+{
+	ms_numModelsRequested--;
+	if(ms_aInfoForModel[id].IsPriority()){
+		ms_aInfoForModel[id].m_flags &= ~STREAMFLAGS_PRIORITY;
+		ms_numPriorityRequests--;
+	}
+}
+
+void
 CStreaming::RemoveModel(int32 id)
 {
 	int i;
@@ -667,7 +678,7 @@ CStreaming::RemoveModel(int32 id)
 
 	if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_LOADED){
 		if(id < STREAM_OFFSET_TXD)
-			CModelInfo::GetModelInfo(id - STREAM_OFFSET_MODEL)->DeleteRwObject();
+			CModelInfo::GetModelInfo(id)->DeleteRwObject();
 		else
 			CTxdStore::RemoveTxd(id - STREAM_OFFSET_TXD);
 		ms_memoryUsed -= ms_aInfoForModel[id].GetCdSize()*CDSTREAM_SECTOR_SIZE;
@@ -675,20 +686,15 @@ CStreaming::RemoveModel(int32 id)
 
 	if(ms_aInfoForModel[id].m_next){
 		// Remove from list, model is neither loaded nor requested
-		if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_INQUEUE){
-			ms_numModelsRequested--;
-			if(ms_aInfoForModel[id].m_flags & STREAMFLAGS_PRIORITY){
-				ms_aInfoForModel[id].m_flags &= ~STREAMFLAGS_PRIORITY;
-				ms_numPriorityRequests--;
-			}
-		}
+		if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_INQUEUE)
+			DecrementRef(id);
 		ms_aInfoForModel[id].RemoveFromList();
 	}else if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_READING){
 		for(i = 0; i < 4; i++){
-			if(ms_channel[0].modelIds[i] == id - STREAM_OFFSET_MODEL)
-				ms_channel[0].modelIds[i] = -1;
-			if(ms_channel[1].modelIds[i] == id - STREAM_OFFSET_MODEL)
-				ms_channel[1].modelIds[i] = -1;
+			if(ms_channel[0].streamIds[i] == id)
+				ms_channel[0].streamIds[i] = -1;
+			if(ms_channel[1].streamIds[i] == id)
+				ms_channel[1].streamIds[i] = -1;
 		}
 	}
 
@@ -702,10 +708,868 @@ CStreaming::RemoveModel(int32 id)
 	ms_aInfoForModel[id].m_loadState = STREAMSTATE_NOTLOADED;
 }
 
+void
+CStreaming::RemoveUnusedBuildings(eLevelName level)
+{
+	if(level != LEVEL_INDUSTRIAL)
+		RemoveBuildings(LEVEL_INDUSTRIAL);
+	if(level != LEVEL_COMMERCIAL)
+		RemoveBuildings(LEVEL_COMMERCIAL);
+	if(level != LEVEL_SUBURBAN)
+		RemoveBuildings(LEVEL_SUBURBAN);
+}
+
+void
+CStreaming::RemoveBuildings(eLevelName level)
+{
+	int i, n;
+	CEntity *e;
+	CBaseModelInfo *mi;
+
+	n = CPools::GetBuildingPool()->GetSize();
+	for(i = 0; i < n; i++){
+		e = CPools::GetBuildingPool()->GetSlot(i);
+		if(e && e->m_level == level){
+			mi = CModelInfo::GetModelInfo(e->GetModelIndex());
+			if(!e->bImBeingRendered){
+				e->DeleteRwObject();
+				if(mi->m_refCount == 0)
+					RemoveModel(e->GetModelIndex());
+			}
+		}
+	}
+
+	n = CPools::GetTreadablePool()->GetSize();
+	for(i = 0; i < n; i++){
+		e = CPools::GetTreadablePool()->GetSlot(i);
+		if(e && e->m_level == level){
+			mi = CModelInfo::GetModelInfo(e->GetModelIndex());
+			if(!e->bImBeingRendered){
+				e->DeleteRwObject();
+				if(mi->m_refCount == 0)
+					RemoveModel(e->GetModelIndex());
+			}
+		}
+	}
+
+	n = CPools::GetObjectPool()->GetSize();
+	for(i = 0; i < n; i++){
+		e = CPools::GetObjectPool()->GetSlot(i);
+		if(e && e->m_level == level){
+			mi = CModelInfo::GetModelInfo(e->GetModelIndex());
+			if(!e->bImBeingRendered && ((CObject*)e)->ObjectCreatedBy == GAME_OBJECT){
+				e->DeleteRwObject();
+				if(mi->m_refCount == 0)
+					RemoveModel(e->GetModelIndex());
+			}
+		}
+	}
+
+	n = CPools::GetDummyPool()->GetSize();
+	for(i = 0; i < n; i++){
+		e = CPools::GetDummyPool()->GetSlot(i);
+		if(e && e->m_level == level){
+			mi = CModelInfo::GetModelInfo(e->GetModelIndex());
+			if(!e->bImBeingRendered){
+				e->DeleteRwObject();
+				if(mi->m_refCount == 0)
+					RemoveModel(e->GetModelIndex());
+			}
+		}
+	}
+}
+
+void
+CStreaming::RemoveUnusedBigBuildings(eLevelName level)
+{
+	if(level != LEVEL_INDUSTRIAL)
+		RemoveBigBuildings(LEVEL_INDUSTRIAL);
+	if(level != LEVEL_COMMERCIAL)
+		RemoveBigBuildings(LEVEL_COMMERCIAL);
+	if(level != LEVEL_SUBURBAN)
+		RemoveBigBuildings(LEVEL_SUBURBAN);
+	RemoveIslandsNotUsed(level);
+}
+
+void
+DeleteIsland(CEntity *island)
+{
+	if(island == nil)
+		return;
+	if(island->bImBeingRendered)
+		debug("Didn't delete island because it was being rendered\n");
+	else{
+		island->DeleteRwObject();
+		CStreaming::RemoveModel(island->GetModelIndex());
+	}
+}
+
+void
+CStreaming::RemoveIslandsNotUsed(eLevelName level)
+{
+	switch(level){
+	case LEVEL_INDUSTRIAL:
+		DeleteIsland(pIslandLODindustEntity);
+		DeleteIsland(pIslandLODcomSubEntity);
+		DeleteIsland(pIslandLODsubComEntity);
+		break;
+	case LEVEL_COMMERCIAL:
+		DeleteIsland(pIslandLODcomIndEntity);
+		DeleteIsland(pIslandLODcomSubEntity);
+		DeleteIsland(pIslandLODsubIndEntity);
+		break;
+	case LEVEL_SUBURBAN:
+		DeleteIsland(pIslandLODsubIndEntity);
+		DeleteIsland(pIslandLODsubComEntity);
+		DeleteIsland(pIslandLODcomIndEntity);
+		break;
+	default:
+		DeleteIsland(pIslandLODindustEntity);
+		DeleteIsland(pIslandLODcomIndEntity);
+		DeleteIsland(pIslandLODcomSubEntity);
+		DeleteIsland(pIslandLODsubIndEntity);
+		DeleteIsland(pIslandLODsubComEntity);
+		break;
+	}
+}
+
+void
+CStreaming::RemoveBigBuildings(eLevelName level)
+{
+	int i, n;
+	CEntity *e;
+	CBaseModelInfo *mi;
+
+	n = CPools::GetBuildingPool()->GetSize();
+	for(i = 0; i < n; i++){
+		e = CPools::GetBuildingPool()->GetSlot(i);
+		if(e && e->bIsBIGBuilding && e->m_level == level){
+			mi = CModelInfo::GetModelInfo(e->GetModelIndex());
+			if(!e->bImBeingRendered){
+				e->DeleteRwObject();
+				if(mi->m_refCount == 0)
+					RemoveModel(e->GetModelIndex());
+			}
+		}
+	}
+}
+
+bool
+CStreaming::RemoveLoadedVehicle(void)
+{
+	int i, id;
+
+	for(i = 0; i < MAXVEHICLESLOADED; i++){
+		ms_lastVehicleDeleted++;
+		if(ms_lastVehicleDeleted == MAXVEHICLESLOADED)
+			ms_lastVehicleDeleted = 0;
+		id = ms_vehiclesLoaded[ms_lastVehicleDeleted];
+		if(id != -1 &&
+		   (ms_aInfoForModel[id].m_flags & STREAMFLAGS_NOT_IN_LIST) == 0 &&
+		   CModelInfo::GetModelInfo(id)->m_refCount == 0 &&
+		   ms_aInfoForModel[id].m_loadState == STREAMSTATE_LOADED)
+			goto found;
+	}
+	return false;
+found:
+	RemoveModel(ms_vehiclesLoaded[ms_lastVehicleDeleted]);
+	ms_numVehiclesLoaded--;
+	ms_vehiclesLoaded[ms_lastVehicleDeleted] = -1;
+	return true;
+}
+
+bool
+CStreaming::RemoveLeastUsedModel(void)
+{
+	CStreamingInfo *si;
+	int streamId;
+
+	for(si = ms_endLoadedList.m_prev; si != &ms_startLoadedList; si = si->m_prev){
+		streamId = si - ms_aInfoForModel;
+		if(streamId < STREAM_OFFSET_TXD){
+			if(CModelInfo::GetModelInfo(streamId)->m_refCount == 0){
+				RemoveModel(streamId);
+				return true;
+			}
+		}else{
+			if(CTxdStore::GetNumRefs(streamId - STREAM_OFFSET_TXD) == 0 &&
+			   !IsTxdUsedByRequestedModels(streamId - STREAM_OFFSET_TXD)){
+				RemoveModel(streamId);
+				return true;
+			}
+		}
+	}
+	return ms_numVehiclesLoaded > 7 && RemoveLoadedVehicle();
+}
+
+void
+CStreaming::RemoveAllUnusedModels(void)
+{
+	int i;
+
+	for(i = 0; i < MAXVEHICLESLOADED; i++)
+		RemoveLoadedVehicle();
+
+	for(i = NUM_DEFAULT_MODELS; i < MODELINFOSIZE; i++){
+		if(ms_aInfoForModel[i].m_loadState == STREAMSTATE_LOADED &&
+		   ms_aInfoForModel[i].m_flags & STREAMFLAGS_DONT_REMOVE &&
+		   CModelInfo::GetModelInfo(i)->m_refCount == 0){
+			RemoveModel(i);
+			ms_aInfoForModel[i].m_loadState = STREAMSTATE_NOTLOADED;
+		}
+	}
+}
+
+bool
+CStreaming::RemoveReferencedTxds(int32 mem)
+{
+	CStreamingInfo *si;
+	int streamId;
+
+	for(si = ms_endLoadedList.m_prev; si != &ms_startLoadedList; si = si->m_prev){
+		streamId = si - ms_aInfoForModel;
+		if(streamId >= STREAM_OFFSET_TXD &&
+		   CTxdStore::GetNumRefs(streamId-STREAM_OFFSET_TXD) == 0){
+			RemoveModel(streamId);
+			if(ms_memoryUsed < mem)
+				return true;
+		}
+	}
+	return false;
+}
+
+// TODO: RemoveCurrentZonesModels
+
+void
+CStreaming::RemoveUnusedModelsInLoadedList(void)
+{
+	// empty
+}
+
+bool
+CStreaming::IsTxdUsedByRequestedModels(int32 txdId)
+{
+	CStreamingInfo *si;
+	int streamId;
+	int i;
+
+	for(si = ms_startRequestedList.m_next; si != &ms_endRequestedList; si = si->m_next){
+		streamId = si - ms_aInfoForModel;
+		if(streamId < STREAM_OFFSET_TXD &&
+		   CModelInfo::GetModelInfo(streamId)->GetTxdSlot() == txdId)
+			return true;
+	}
+
+	for(i = 0; i < 4; i++){
+		streamId = ms_channel[0].streamIds[i];
+		if(streamId != -1 && streamId < STREAM_OFFSET_TXD &&
+		   CModelInfo::GetModelInfo(streamId)->GetTxdSlot() == txdId)
+			return true;
+		streamId = ms_channel[1].streamIds[i];
+		if(streamId != -1 && streamId < STREAM_OFFSET_TXD &&
+		   CModelInfo::GetModelInfo(streamId)->GetTxdSlot() == txdId)
+			return true;
+	}
+
+	return false;
+}
+
+int32
+CStreaming::GetAvailableVehicleSlot(void)
+{
+	int i;
+	for(i = 0; i < MAXVEHICLESLOADED; i++)
+		if(ms_vehiclesLoaded[i] == -1)
+			return i;
+	return -1;
+}
+
+bool
+CStreaming::AddToLoadedVehiclesList(int32 modelId)
+{
+	int i;
+	int id;
+
+	if(ms_numVehiclesLoaded < desiredNumVehiclesLoaded){
+		// still room for vehicles
+		for(i = 0; i < MAXVEHICLESLOADED; i++){
+			if(ms_vehiclesLoaded[ms_lastVehicleDeleted] == -1)
+				break;
+			ms_lastVehicleDeleted++;
+			if(ms_lastVehicleDeleted == MAXVEHICLESLOADED)
+				ms_lastVehicleDeleted = 0;
+		}
+		assert(ms_vehiclesLoaded[ms_lastVehicleDeleted] == -1);
+		ms_numVehiclesLoaded++;
+	}else{
+		// find vehicle we can remove
+		for(i = 0; i < MAXVEHICLESLOADED; i++){
+			id = ms_vehiclesLoaded[ms_lastVehicleDeleted];
+			if(id != -1 &&
+			   (ms_aInfoForModel[id].m_flags & STREAMFLAGS_NOT_IN_LIST) == 0 &&
+			    CModelInfo::GetModelInfo(id)->m_refCount == 0)
+				goto found;
+			ms_lastVehicleDeleted++;
+			if(ms_lastVehicleDeleted == MAXVEHICLESLOADED)
+				ms_lastVehicleDeleted = 0;
+		}
+		id = -1;
+found:
+		if(id == -1){
+			// didn't find anything, try a free slot
+			id = GetAvailableVehicleSlot();
+			if(id == -1)
+				return false;	// still no luck
+			ms_lastVehicleDeleted = id;
+			// this is more that we wanted actually
+			ms_numVehiclesLoaded++;
+		}else
+			RemoveModel(id);
+	}
+
+	ms_vehiclesLoaded[ms_lastVehicleDeleted++] = modelId;
+	if(ms_lastVehicleDeleted == MAXVEHICLESLOADED)
+		ms_lastVehicleDeleted = 0;
+	return true;
+}
+
+bool
+CStreaming::IsObjectInCdImage(int32 id)
+{
+	uint32 posn, size;
+	return ms_aInfoForModel[id].GetCdPosnAndSize(posn, size);
+}
+
+void
+CStreaming::HaveAllBigBuildingsLoaded(eLevelName level)
+{
+	int i, n;
+	CEntity *e;
+
+	if(ms_hasLoadedLODs)
+		return;
+
+	if(level == LEVEL_INDUSTRIAL){
+		if(ms_aInfoForModel[islandLODcomInd].m_loadState != STREAMSTATE_LOADED ||
+		   ms_aInfoForModel[islandLODsubInd].m_loadState != STREAMSTATE_LOADED)
+			return;
+	}else if(level == LEVEL_COMMERCIAL){
+		if(ms_aInfoForModel[islandLODindust].m_loadState != STREAMSTATE_LOADED ||
+		   ms_aInfoForModel[islandLODsubCom].m_loadState != STREAMSTATE_LOADED)
+			return;
+	}else if(level == LEVEL_SUBURBAN){
+		if(ms_aInfoForModel[islandLODindust].m_loadState != STREAMSTATE_LOADED ||
+		   ms_aInfoForModel[islandLODcomSub].m_loadState != STREAMSTATE_LOADED)
+			return;
+	}
+
+	n = CPools::GetBuildingPool()->GetSize();
+	for(i = 0; i < n; i++){
+		e = CPools::GetBuildingPool()->GetSlot(i);
+		if(e && e->bIsBIGBuilding && e->m_level == level &&
+		   ms_aInfoForModel[e->GetModelIndex()].m_loadState != STREAMSTATE_LOADED)
+			return;
+	}
+
+	RemoveUnusedBigBuildings(level);
+	ms_hasLoadedLODs = true;
+}
+
+void
+CStreaming::SetModelIsDeletable(int32 id)
+{
+	ms_aInfoForModel[id].m_flags &= ~STREAMFLAGS_DONT_REMOVE;
+	if((id >= STREAM_OFFSET_TXD || CModelInfo::GetModelInfo(id)->m_type != MITYPE_VEHICLE) &&
+	   (ms_aInfoForModel[id].m_flags & STREAMFLAGS_SCRIPTOWNED) == 0){
+		if(ms_aInfoForModel[id].m_loadState != STREAMSTATE_LOADED)
+			RemoveModel(id);
+		else if(ms_aInfoForModel[id].m_next == nil)
+			ms_aInfoForModel[id].AddToList(&ms_startLoadedList);
+	}
+}
+
+void
+CStreaming::SetModelTxdIsDeletable(int32 id)
+{
+	SetModelIsDeletable(CModelInfo::GetModelInfo(id)->GetTxdSlot() + STREAM_OFFSET_TXD);
+}
+
+void
+CStreaming::SetMissionDoesntRequireModel(int32 id)
+{
+	ms_aInfoForModel[id].m_flags &= ~STREAMFLAGS_SCRIPTOWNED;
+	if((id >= STREAM_OFFSET_TXD || CModelInfo::GetModelInfo(id)->m_type != MITYPE_VEHICLE) &&
+	   (ms_aInfoForModel[id].m_flags & STREAMFLAGS_DONT_REMOVE) == 0){
+		if(ms_aInfoForModel[id].m_loadState != STREAMSTATE_LOADED)
+			RemoveModel(id);
+		else if(ms_aInfoForModel[id].m_next == nil)
+			ms_aInfoForModel[id].AddToList(&ms_startLoadedList);
+	}
+}
+
+void
+CStreaming::LoadInitialPeds(void)
+{
+	RequestModel(MI_COP, STREAMFLAGS_DONT_REMOVE);
+	RequestModel(MI_MALE01, STREAMFLAGS_DONT_REMOVE);
+	RequestModel(MI_TAXI_D, STREAMFLAGS_DONT_REMOVE);
+}
+
+void
+CStreaming::LoadInitialVehicles(void)
+{
+	int id;
+
+	ms_numVehiclesLoaded = 0;
+	ms_lastVehicleDeleted = 0;
+
+	if(CModelInfo::GetModelInfo("taxi", &id))
+		RequestModel(id, STREAMFLAGS_DONT_REMOVE);
+	if(CModelInfo::GetModelInfo("police", &id))
+		RequestModel(id, STREAMFLAGS_DONT_REMOVE);
+}
+
+
+// Find starting offset of the cdimage we next want to read
+// Not useful at all on PC...
+int32
+CStreaming::GetCdImageOffset(int32 lastPosn)
+{
+	int offset, off;
+	int i, img;
+	int dist, mindist;
+
+	img = -1;
+	mindist = INT_MAX;
+	offset = ms_imageOffsets[ms_lastImageRead];
+	if(lastPosn <= offset || lastPosn > offset + ms_imageSize){
+		// last read position is not in last image
+		for(i = 0; i < NUMCDIMAGES; i++){
+			off = ms_imageOffsets[i];
+			if(off == -1) continue;
+			if((uint32)lastPosn > (uint32)off)
+				// after start of image, get distance from end
+				// negative if before end!
+				dist = lastPosn - (off + ms_imageSize);
+			else
+				// before image, get offset to start
+				// this will never be negative
+				dist = off - lastPosn;
+			if(dist < mindist){
+				img = i;
+				mindist = dist;
+			}
+		}
+		assert(img >= 0);
+		offset = ms_imageOffsets[img];
+		ms_lastImageRead = img;
+	}
+	return offset;
+}
+
+inline bool
+TxdAvailable(int32 txdId)
+{
+	CStreamingInfo *si = &CStreaming::ms_aInfoForModel[txdId + STREAM_OFFSET_TXD];
+	return si->m_loadState == STREAMSTATE_LOADED || si->m_loadState == STREAMSTATE_READING;
+}
+
+// Find stream id of next requested file in cdimage
+int32
+CStreaming::GetNextFileOnCd(int32 lastPosn, bool priority)
+{
+	CStreamingInfo *si, *next;
+	int streamId;
+	uint32 posn, size;
+	int streamIdFirst, streamIdNext;
+	uint32 posnFirst, posnNext;
+
+	streamIdFirst = -1;
+	streamIdNext = -1;
+	posnFirst = UINT_MAX;
+	posnNext = UINT_MAX;
+
+	for(si = ms_startRequestedList.m_next; si != &ms_endRequestedList; si = next){
+		next = si->m_next;
+		streamId = si - ms_aInfoForModel;
+
+		// only priority requests if there are any
+		if(priority && ms_numPriorityRequests != 0 && !si->IsPriority())
+			continue;
+
+		// request Txd if necessary
+		if(streamId < STREAM_OFFSET_TXD &&
+		   !TxdAvailable(CModelInfo::GetModelInfo(streamId)->GetTxdSlot())){
+			ReRequestTxd(CModelInfo::GetModelInfo(streamId)->GetTxdSlot());
+		}else if(ms_aInfoForModel[streamId].GetCdPosnAndSize(posn, size)){
+			if(posn < posnFirst){
+				// find first requested file in image
+				streamIdFirst = streamId;
+				posnFirst = posn;
+			}
+			if(posn < posnNext && posn >= (uint32)lastPosn){
+				// find first requested file after last read position
+				streamIdNext = streamId;
+				posnNext = posn;
+			}
+		}else{
+			// empty file
+			DecrementRef(streamId);
+			si->RemoveFromList();
+			si->m_loadState = STREAMSTATE_LOADED;
+		}
+	}
+
+	// wrap around
+	if(streamIdNext == -1)
+		streamIdNext = streamIdFirst;
+
+	if(streamIdNext == -1 && ms_numPriorityRequests != 0){
+		// try non-priority files
+		ms_numPriorityRequests = 0;
+		streamIdNext = GetNextFileOnCd(lastPosn, false);
+	}
+
+	return streamIdNext;
+}
+
+/*
+ * Streaming buffer size is half of the largest file.
+ * Files larger than the buffer size can only be loaded by channel 0,
+ * which then uses both buffers, while channel 1 is idle.
+ * ms_bLoadingBigModel is set to true to indicate this state.
+ *
+ * TODO: two-part files
+ */
+
+// Make channel read from disc
+void
+CStreaming::RequestModelStream(int32 ch)
+{
+	int lastPosn, imgOffset, streamId;
+	int totalSize;
+	uint32 posn, size, unused;
+	int i;
+	int haveBigFile, havePed;
+
+	lastPosn = CdStreamGetLastPosn();
+	imgOffset = GetCdImageOffset(lastPosn);
+	streamId = GetNextFileOnCd(lastPosn - imgOffset, true);
+
+	if(streamId == -1)
+		return;
+
+	// remove Txds that aren't requested anymore
+	while(streamId >= STREAM_OFFSET_TXD){
+		if(ms_aInfoForModel[streamId].m_flags & STREAMFLAGS_KEEP_IN_MEMORY ||
+		   IsTxdUsedByRequestedModels(streamId - STREAM_OFFSET_TXD))
+			break;
+		RemoveModel(streamId);
+		// so try next file
+		ms_aInfoForModel[streamId].GetCdPosnAndSize(posn, size);
+		streamId = GetNextFileOnCd(posn + size, true);
+	}
+
+	if(streamId == -1)
+		return;
+
+	ms_aInfoForModel[streamId].GetCdPosnAndSize(posn, size);
+	if(size > (uint32)ms_streamingBufferSize){
+		// Can only load big models on channel 0, and 1 has to be idle
+		if(ch == 1 || ms_channel[1].state != CHANNELSTATE_IDLE)
+			return;
+		ms_bLoadingBigModel = true;
+	}
+
+	// Load up to 4 adjacent files
+	haveBigFile = 0;
+	havePed = 0;
+	totalSize = 0;
+	for(i = 0; i < 4; i++){
+		// no more files we can read
+		if(streamId == -1 || ms_aInfoForModel[streamId].m_loadState != STREAMSTATE_INQUEUE)
+			break;
+
+		// also stop at non-priority files
+		ms_aInfoForModel[streamId].GetCdPosnAndSize(unused, size);
+		if(ms_numPriorityRequests != 0 && !ms_aInfoForModel[streamId].IsPriority())
+			break;
+
+		// Can't load certain combinations of files together
+		if(streamId < STREAM_OFFSET_TXD){
+			if(havePed && CModelInfo::GetModelInfo(streamId)->m_type == MITYPE_PED ||
+			   haveBigFile && CModelInfo::GetModelInfo(streamId)->m_type == MITYPE_VEHICLE ||
+			   !TxdAvailable(CModelInfo::GetModelInfo(streamId)->GetTxdSlot()))
+				break;
+		}else{
+			if(haveBigFile && size > 200)
+				break;
+		}
+
+		// Now add the file
+		ms_channel[ch].streamIds[i] = streamId;
+		ms_channel[ch].offsets[i] = totalSize;
+		totalSize += size;
+
+		// To big for buffer, remove again
+		if(totalSize > ms_streamingBufferSize && i > 0){
+			totalSize -= size;
+			break;
+		}
+		if(streamId < STREAM_OFFSET_TXD){
+			if(CModelInfo::GetModelInfo(streamId)->m_type == MITYPE_PED)
+				havePed = 1;
+			if(CModelInfo::GetModelInfo(streamId)->m_type == MITYPE_VEHICLE)
+				haveBigFile = 1;
+		}else{
+			if(size > 200)
+				haveBigFile = 1;
+		}
+		ms_aInfoForModel[streamId].m_loadState = STREAMSTATE_READING;
+		ms_aInfoForModel[streamId].RemoveFromList();
+		DecrementRef(streamId);
+
+		streamId = ms_aInfoForModel[streamId].m_nextID;
+	}
+
+	// clear remaining slots
+	for(; i < 4; i++)
+		ms_channel[ch].streamIds[i] = -1;
+	// Now read the data
+	assert(!(ms_bLoadingBigModel && ch == 1));	// this would clobber the buffer
+	if(CdStreamRead(ch, ms_pStreamingBuffer[ch], imgOffset+posn, totalSize) == STREAM_NONE)
+		debug("FUCKFUCKFUCK\n");
+	ms_channel[ch].state = CHANNELSTATE_READING;
+	ms_channel[ch].field24 = 0;
+	ms_channel[ch].size = totalSize;
+	ms_channel[ch].position = imgOffset+posn;
+	ms_channel[ch].numTries = 0;
+}
+
+// Load data previously read from disc
+bool
+CStreaming::ProcessLoadingChannel(int32 ch)
+{
+	int status;
+	int i, id, cdsize;
+
+	status = CdStreamGetStatus(ch);
+	if(status != STREAM_NONE){
+		// busy
+		if(status != STREAM_READING && status != STREAM_WAITING){
+			ms_channelError = ch;
+			ms_channel[ch].state = CHANNELSTATE_ERROR;
+			ms_channel[ch].status = status;
+		}
+		return false;
+	}
+
+	if(ms_channel[ch].state == CHANNELSTATE_STARTED){
+		ms_channel[ch].state = CHANNELSTATE_IDLE;
+		FinishLoadingLargeFile(&ms_pStreamingBuffer[ch][ms_channel[ch].offsets[0]*CDSTREAM_SECTOR_SIZE],
+			ms_channel[ch].streamIds[0]);
+		ms_channel[ch].streamIds[0] = -1;
+	}else{
+		ms_channel[ch].state = CHANNELSTATE_IDLE;
+		for(i = 0; i < 4; i++){
+			id = ms_channel[ch].streamIds[i];
+			if(id == -1)
+				continue;
+
+			cdsize = ms_aInfoForModel[id].GetCdSize();
+			if(id < STREAM_OFFSET_TXD &&
+			   CModelInfo::GetModelInfo(id)->m_type == MITYPE_VEHICLE &&
+			   ms_numVehiclesLoaded >= desiredNumVehiclesLoaded &&
+			   !RemoveLoadedVehicle() &&
+			   ((ms_aInfoForModel[id].m_flags & STREAMFLAGS_NOT_IN_LIST) == 0 || GetAvailableVehicleSlot() == -1)){
+				// can't load vehicle
+				RemoveModel(id);
+				if(ms_aInfoForModel[id].m_flags & STREAMFLAGS_NOT_IN_LIST)
+					ReRequestModel(id);
+				else if(CTxdStore::GetNumRefs(CModelInfo::GetModelInfo(id)->GetTxdSlot()) == 0)
+					RemoveTxd(CModelInfo::GetModelInfo(id)->GetTxdSlot());
+			}else{
+				MakeSpaceFor(cdsize * CDSTREAM_SECTOR_SIZE);
+				ConvertBufferToObject(&ms_pStreamingBuffer[ch][ms_channel[ch].offsets[i]*CDSTREAM_SECTOR_SIZE],
+					id);
+				if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_STARTED){
+					// queue for second part
+					ms_channel[ch].state = CHANNELSTATE_STARTED;
+					ms_channel[ch].offsets[0] = ms_channel[ch].offsets[i];
+					ms_channel[ch].streamIds[0] = id;
+					if(i != 0)
+						ms_channel[ch].streamIds[i] = -1;
+				}else
+					ms_channel[ch].streamIds[i] = -1;
+			}
+		}
+	}
+
+	if(ms_bLoadingBigModel && ms_channel[ch].state != CHANNELSTATE_STARTED){
+		ms_bLoadingBigModel = false;
+		// reset channel 1 after loading a big model
+		for(i = 0; i < 4; i++)
+			ms_channel[1].streamIds[i] = -1;
+		ms_channel[1].state = CHANNELSTATE_IDLE;
+	}
+
+	return true;
+}
+
+void
+CStreaming::RetryLoadFile(int32 ch)
+{
+	char *key;
+
+	CPad::StopPadsShaking();
+
+	if(ms_channel[ch].numTries >= 3){
+		switch(ms_channel[ch].status){
+		case STREAM_ERROR_NOCD: key = "NOCD"; break;
+		case STREAM_ERROR_OPENCD: key = "OPENCD"; break;
+		case STREAM_ERROR_WRONGCD: key = "WRONGCD"; break;
+		default: key = "CDERROR"; break;
+		}
+		CHud::SetMessage(TheText.Get(key));
+		CTimer::SetCodePause(true);
+	}
+
+	switch(ms_channel[ch].state){
+	case CHANNELSTATE_IDLE:
+streamread:
+		CdStreamRead(ch, ms_pStreamingBuffer[ch], ms_channel[ch].position, ms_channel[ch].size);
+		ms_channel[ch].state = CHANNELSTATE_READING;
+		ms_channel[ch].field24 = -600;
+		break;
+	case CHANNELSTATE_READING:
+		if(ProcessLoadingChannel(ch)){
+			ms_channelError = -1;
+			CTimer::SetCodePause(false);
+		}
+		break;
+	case CHANNELSTATE_ERROR:
+		ms_channel[ch].numTries++;
+		if(CdStreamGetStatus(ch) != STREAM_READING && CdStreamGetStatus(ch) != STREAM_WAITING)
+			goto streamread;
+		break;
+	}
+}
+
+void
+CStreaming::LoadRequestedModels(void)
+{
+	static int currentChannel = 0;
+
+	// We can't read with channel 1 while channel 0 is using its buffer
+	if(ms_bLoadingBigModel)
+		currentChannel = 0;
+
+	// We have data, load
+	if(ms_channel[currentChannel].state == CHANNELSTATE_READING ||
+	   ms_channel[currentChannel].state == CHANNELSTATE_STARTED)
+		ProcessLoadingChannel(currentChannel);
+
+	if(ms_channelError == -1){
+		// Channel is idle, read more data
+		if(ms_channel[currentChannel].state == CHANNELSTATE_IDLE)
+			RequestModelStream(currentChannel);
+		// Switch channel
+		if(ms_channel[currentChannel].state != CHANNELSTATE_STARTED)
+			currentChannel = 1 - currentChannel;
+	}
+}
+
+void
+CStreaming::LoadAllRequestedModels(bool priority)
+{
+	static bool bInsideLoadAll = false;
+	int imgOffset, streamId, status;
+	int i;
+	uint32 posn, size;
+
+	if(bInsideLoadAll)
+		return;
+
+	FlushChannels();
+	imgOffset = GetCdImageOffset(CdStreamGetLastPosn());
+
+	while(ms_endRequestedList.m_prev != &ms_startRequestedList){
+		streamId = GetNextFileOnCd(0, priority);
+		if(streamId == -1)
+			break;
+
+		ms_aInfoForModel[streamId].RemoveFromList();
+		DecrementRef(streamId);
+
+		if(ms_aInfoForModel[streamId].GetCdPosnAndSize(posn, size)){
+			do
+				status = CdStreamRead(0, ms_pStreamingBuffer[0], imgOffset+posn, size);
+			while(CdStreamSync(0) || status == STREAM_NONE);
+			ms_aInfoForModel[streamId].m_loadState = STREAMSTATE_READING;
+
+			MakeSpaceFor(size * CDSTREAM_SECTOR_SIZE);
+			ConvertBufferToObject(ms_pStreamingBuffer[0], streamId);
+			if(ms_aInfoForModel[streamId].m_loadState == STREAMSTATE_STARTED)
+				FinishLoadingLargeFile(ms_pStreamingBuffer[0], streamId);
+
+			if(streamId < STREAM_OFFSET_TXD){
+				CSimpleModelInfo *mi = (CSimpleModelInfo*)CModelInfo::GetModelInfo(streamId);
+				if(mi->IsSimple())
+					mi->m_alpha = 255;
+			}
+		}else{
+			// empty
+			ms_aInfoForModel[streamId].m_loadState = STREAMSTATE_LOADED;
+		}
+	}
+
+	ms_bLoadingBigModel = false;
+	for(i = 0; i < 4; i++){
+		ms_channel[1].streamIds[i] = -1;
+		ms_channel[1].offsets[i] = -1;
+	}
+	ms_channel[1].state = CHANNELSTATE_IDLE;
+	bInsideLoadAll = false;
+}
+
+void
+CStreaming::FlushChannels(void)
+{
+	if(ms_channel[1].state == CHANNELSTATE_STARTED)
+		ProcessLoadingChannel(1);
+
+	if(ms_channel[0].state == CHANNELSTATE_READING){
+		CdStreamSync(0);
+		ProcessLoadingChannel(0);
+	}
+	if(ms_channel[0].state == CHANNELSTATE_STARTED)
+		ProcessLoadingChannel(0);
+
+	if(ms_channel[1].state == CHANNELSTATE_READING){
+		CdStreamSync(1);
+		ProcessLoadingChannel(1);
+	}
+	if(ms_channel[1].state == CHANNELSTATE_STARTED)
+		ProcessLoadingChannel(1);
+}
+
+void
+CStreaming::FlushRequestList(void)
+{
+	CStreamingInfo *si, *next;
+
+	for(si = ms_startRequestedList.m_next; si != &ms_endRequestedList; si = next){
+		next = si->m_next;
+		RemoveModel(si - ms_aInfoForModel);
+	}
+	FlushChannels();
+}
+
 
 void
 CStreaming::ImGonnaUseStreamingMemory(void)
 {
+	// empty
 }
 
 void
@@ -717,6 +1581,7 @@ CStreaming::IHaveUsedStreamingMemory(void)
 void
 CStreaming::UpdateMemoryUsed(void)
 {
+	// empty
 }
 
 WRAPPER void CStreaming::LoadScene(CVector *pos) { EAXJMP(0x40A6D0); }
@@ -771,7 +1636,39 @@ STARTPATCHES
 	InjectHook(0x408210, CStreaming::RequestIslands, PATCH_JUMP);
 	InjectHook(0x40A890, CStreaming::RequestSpecialModel, PATCH_JUMP);
 	InjectHook(0x40ADA0, CStreaming::RequestSpecialChar, PATCH_JUMP);
+
 	InjectHook(0x408830, CStreaming::RemoveModel, PATCH_JUMP);
+	InjectHook(0x4083A0, CStreaming::RemoveUnusedBuildings, PATCH_JUMP);
+	InjectHook(0x4083D0, CStreaming::RemoveBuildings, PATCH_JUMP);
+	InjectHook(0x408640, CStreaming::RemoveUnusedBigBuildings, PATCH_JUMP);
+	InjectHook(0x408680, CStreaming::RemoveBigBuildings, PATCH_JUMP);
+	InjectHook(0x408780, CStreaming::RemoveIslandsNotUsed, PATCH_JUMP);
+	InjectHook(0x40B180, CStreaming::RemoveLoadedVehicle, PATCH_JUMP);
+	InjectHook(0x4089B0, CStreaming::RemoveLeastUsedModel, PATCH_JUMP);
+	InjectHook(0x408940, CStreaming::RemoveAllUnusedModels, PATCH_JUMP);
+	InjectHook(0x409450, CStreaming::RemoveReferencedTxds, PATCH_JUMP);
+
+	InjectHook(0x40B160, CStreaming::GetAvailableVehicleSlot, PATCH_JUMP);
+	InjectHook(0x40B060, CStreaming::AddToLoadedVehiclesList, PATCH_JUMP);
+	InjectHook(0x4094C0, CStreaming::IsTxdUsedByRequestedModels, PATCH_JUMP);
+	InjectHook(0x407E70, CStreaming::IsObjectInCdImage, PATCH_JUMP);
+	InjectHook(0x408280, CStreaming::HaveAllBigBuildingsLoaded, PATCH_JUMP);
+	InjectHook(0x40A790, CStreaming::SetModelIsDeletable, PATCH_JUMP);
+	InjectHook(0x40A800, CStreaming::SetModelTxdIsDeletable, PATCH_JUMP);
+	InjectHook(0x40A820, CStreaming::SetMissionDoesntRequireModel, PATCH_JUMP);
+
+	InjectHook(0x40AA00, CStreaming::LoadInitialPeds, PATCH_JUMP);
+	InjectHook(0x40ADF0, CStreaming::LoadInitialVehicles, PATCH_JUMP);
+
+	InjectHook(0x409BE0, CStreaming::ProcessLoadingChannel, PATCH_JUMP);
+	InjectHook(0x40A610, CStreaming::FlushChannels, PATCH_JUMP);
+	InjectHook(0x40A680, CStreaming::FlushRequestList, PATCH_JUMP);
+	InjectHook(0x409FF0, CStreaming::GetCdImageOffset, PATCH_JUMP);
+	InjectHook(0x409E50, CStreaming::GetNextFileOnCd, PATCH_JUMP);
+	InjectHook(0x40A060, CStreaming::RequestModelStream, PATCH_JUMP);
+	InjectHook(0x4077F0, CStreaming::RetryLoadFile, PATCH_JUMP);
+	InjectHook(0x40A390, CStreaming::LoadRequestedModels, PATCH_JUMP);
+	InjectHook(0x40A440, CStreaming::LoadAllRequestedModels, PATCH_JUMP);
 
 	InjectHook(0x4063E0, &CStreamingInfo::GetCdPosnAndSize, PATCH_JUMP);
 	InjectHook(0x406410, &CStreamingInfo::SetCdPosnAndSize, PATCH_JUMP);