1 files changed, 580 insertions, 373 deletions

diff --git a/src/core/Streaming.cpp b/src/core/Streaming.cpp
index 40189844..3c32b856 100644
--- a/src/core/Streaming.cpp
+++ b/src/core/Streaming.cpp
@@ -18,7 +18,6 @@
 #include "FileMgr.h"
 #include "FileLoader.h"
 #include "Zones.h"
-#include "ZoneCull.h"
 #include "Radar.h"
 #include "Camera.h"
 #include "Record.h"
@@ -28,10 +27,10 @@
 #include "CutsceneMgr.h"
 #include "CdStream.h"
 #include "Streaming.h"
-#ifdef FIX_BUGS
 #include "Replay.h"
-#endif
 #include "main.h"
+#include "ColStore.h"
+#include "DMAudio.h"
 
 bool CStreaming::ms_disableStreaming;
 bool CStreaming::ms_bLoadingBigModel;
@@ -51,9 +50,9 @@ int32 CStreaming::ms_channelError;
 int32 CStreaming::ms_numVehiclesLoaded;
 int32 CStreaming::ms_vehiclesLoaded[MAXVEHICLESLOADED];
 int32 CStreaming::ms_lastVehicleDeleted;
+bool CStreaming::ms_bIsPedFromPedGroupLoaded[NUMMODELSPERPEDGROUP];
 CDirectory *CStreaming::ms_pExtraObjectsDir;
 int32 CStreaming::ms_numPriorityRequests;
-bool CStreaming::ms_hasLoadedLODs;
 int32 CStreaming::ms_currentPedGrp;
 int32 CStreaming::ms_currentPedLoading;
 int32 CStreaming::ms_lastCullZone;
@@ -66,17 +65,12 @@ size_t CStreaming::ms_memoryAvailable;
 
 int32 desiredNumVehiclesLoaded = 12;
 
-CEntity *pIslandLODindustEntity;
-CEntity *pIslandLODcomIndEntity;
-CEntity *pIslandLODcomSubEntity;
-CEntity *pIslandLODsubIndEntity;
-CEntity *pIslandLODsubComEntity;
-int32 islandLODindust;
-int32 islandLODcomInd;
-int32 islandLODcomSub;
-int32 islandLODsubInd;
-int32 islandLODsubCom;
+CEntity *pIslandLODmainlandEntity;
+CEntity *pIslandLODbeachEntity;
+int32 islandLODmainland;
+int32 islandLODbeach;
 
+//--MIAMI: done
 bool
 CStreamingInfo::GetCdPosnAndSize(uint32 &posn, uint32 &size)
 {
@@ -87,6 +81,7 @@ CStreamingInfo::GetCdPosnAndSize(uint32 &posn, uint32 &size)
 	return true;
 }
 
+//--MIAMI: done
 void
 CStreamingInfo::SetCdPosnAndSize(uint32 posn, uint32 size)
 {
@@ -94,6 +89,7 @@ CStreamingInfo::SetCdPosnAndSize(uint32 posn, uint32 size)
 	m_size = size;
 }
 
+//--MIAMI: done
 void
 CStreamingInfo::AddToList(CStreamingInfo *link)
 {
@@ -104,6 +100,7 @@ CStreamingInfo::AddToList(CStreamingInfo *link)
 	m_next->m_prev = this;
 }
 
+//--MIAMI: done
 void
 CStreamingInfo::RemoveFromList(void)
 {
@@ -113,6 +110,7 @@ CStreamingInfo::RemoveFromList(void)
 	m_prev = nil;
 }
 
+//--MIAMI: done
 void
 CStreaming::Init2(void)
 {
@@ -182,13 +180,15 @@ CStreaming::Init2(void)
 		ms_vehiclesLoaded[i] = -1;
 	ms_numVehiclesLoaded = 0;
 
+	for(i = 0; i < ARRAY_SIZE(ms_bIsPedFromPedGroupLoaded); i++)
+		ms_bIsPedFromPedGroupLoaded[i] = false;
+
 	ms_pExtraObjectsDir = new CDirectory(EXTRADIRSIZE);
 	ms_numPriorityRequests = 0;
-	ms_hasLoadedLODs = true;
 	ms_currentPedGrp = -1;
 	ms_lastCullZone = -1;		// unused because RemoveModelsNotVisibleFromCullzone is gone
 	ms_loadedGangs = 0;
-	ms_currentPedLoading = 8;	// unused, whatever it is
+	ms_currentPedLoading = NUMMODELSPERPEDGROUP;	// unused, whatever it is
 
 	LoadCdDirectory();
 
@@ -199,49 +199,20 @@ CStreaming::Init2(void)
 	ms_pStreamingBuffer[1] = ms_pStreamingBuffer[0] + ms_streamingBufferSize*CDSTREAM_SECTOR_SIZE;
 	debug("Streaming buffer size is %d sectors", ms_streamingBufferSize);
 
-	// PC only, figure out how much memory we got
-#ifdef GTA_PC
 #define MB (1024*1024)
-
-	extern size_t _dwMemAvailPhys;
-	ms_memoryAvailable = (_dwMemAvailPhys - 10*MB)/2;
-	if(ms_memoryAvailable < 50*MB)
-		ms_memoryAvailable = 50*MB;
-	desiredNumVehiclesLoaded = (int32)((ms_memoryAvailable / MB - 50) / 3 + 12);
-	if(desiredNumVehiclesLoaded > MAXVEHICLESLOADED)
-		desiredNumVehiclesLoaded = MAXVEHICLESLOADED;
-	debug("Memory allocated to Streaming is %zuMB", ms_memoryAvailable/MB); // original modifier was %d
+	ms_memoryAvailable = 65 * MB;
+	desiredNumVehiclesLoaded = 25;
+	debug("Memory allocated to Streaming is %dMB", ms_memoryAvailable / MB);
 #undef MB
-#endif
 
 	// find island LODs
 
-	pIslandLODindustEntity = nil;
-	pIslandLODcomIndEntity = nil;
-	pIslandLODcomSubEntity = nil;
-	pIslandLODsubIndEntity = nil;
-	pIslandLODsubComEntity = nil;
-	islandLODindust = -1;
-	islandLODcomInd = -1;
-	islandLODcomSub = -1;
-	islandLODsubInd = -1;
-	islandLODsubCom = -1;
-        CModelInfo::GetModelInfo("IslandLODInd", &islandLODindust);
-        CModelInfo::GetModelInfo("IslandLODcomIND", &islandLODcomInd);
-        CModelInfo::GetModelInfo("IslandLODcomSUB", &islandLODcomSub);
-        CModelInfo::GetModelInfo("IslandLODsubIND", &islandLODsubInd);
-        CModelInfo::GetModelInfo("IslandLODsubCOM", &islandLODsubCom);
-
-	for(i = CPools::GetBuildingPool()->GetSize()-1; i >= 0; i--){
-		CBuilding *building = CPools::GetBuildingPool()->GetSlot(i);
-		if(building == nil)
-			continue;
-		if(building->GetModelIndex() == islandLODindust) pIslandLODindustEntity = building;
-		if(building->GetModelIndex() == islandLODcomInd) pIslandLODcomIndEntity = building;
-		if(building->GetModelIndex() == islandLODcomSub) pIslandLODcomSubEntity = building;
-		if(building->GetModelIndex() == islandLODsubInd) pIslandLODsubIndEntity = building;
-		if(building->GetModelIndex() == islandLODsubCom) pIslandLODsubComEntity = building;
-	}
+	pIslandLODmainlandEntity = nil;
+	pIslandLODbeachEntity = nil;
+	islandLODmainland = -1;
+	islandLODbeach = -1;
+        CModelInfo::GetModelInfo("IslandLODmainland", &islandLODmainland);
+        CModelInfo::GetModelInfo("IslandLODbeach", &islandLODbeach);
 }
 
 void
@@ -267,6 +238,7 @@ CStreaming::Init(void)
 #endif
 }
 
+//--MIAMI: done
 void
 CStreaming::Shutdown(void)
 {
@@ -276,10 +248,10 @@ CStreaming::Shutdown(void)
 		delete ms_pExtraObjectsDir;
 }
 
+//--MIAMI: done
 void
 CStreaming::Update(void)
 {
-	CEntity *train;
 	CStreamingInfo *si, *prev;
 	bool requestedSubway = false;
 
@@ -293,31 +265,32 @@ CStreaming::Update(void)
 	if(CTimer::GetIsPaused())
 		return;
 
-	train = FindPlayerTrain();
-	if(train && train->GetPosition().z < 0.0f){
-		RequestSubway();
-		requestedSubway = true;
-	}else if(!ms_disableStreaming)
+	LoadBigBuildingsWhenNeeded();
+	if(!ms_disableStreaming && TheCamera.GetPosition().z < 55.0f)
 		AddModelsToRequestList(TheCamera.GetPosition());
 
 	DeleteFarAwayRwObjects(TheCamera.GetPosition());
 
 	if(!ms_disableStreaming &&
-	   !CCutsceneMgr::IsRunning() &&
-	   !requestedSubway &&
-	   !CGame::playingIntro &&
+	   !CCutsceneMgr::IsCutsceneProcessing() &&
 	   ms_numModelsRequested < 5 &&
-	   !CRenderer::m_loadingPriority
-#ifdef FIX_BUGS
-		&& !CReplay::IsPlayingBack()
-#endif
-		){
+	   !CRenderer::m_loadingPriority &&
+	   CGame::currArea == AREA_MAIN_MAP &&
+	   !CReplay::IsPlayingBack()){
 		StreamVehiclesAndPeds();
 		StreamZoneModels(FindPlayerCoors());
 	}
 
 	LoadRequestedModels();
 
+	if(CWorld::Players[0].m_pRemoteVehicle){
+		CColStore::AddCollisionNeededAtPosn(FindPlayerCoors());
+		CColStore::LoadCollision(CWorld::Players[0].m_pRemoteVehicle->GetPosition());
+		CColStore::EnsureCollisionIsInMemory(CWorld::Players[0].m_pRemoteVehicle->GetPosition());
+	}else{
+		CColStore::LoadCollision(FindPlayerCoors());
+		CColStore::EnsureCollisionIsInMemory(FindPlayerCoors());
+	}
 
 	for(si = ms_endRequestedList.m_prev; si != &ms_startRequestedList; si = prev){
 		prev = si->m_prev;
@@ -326,6 +299,7 @@ CStreaming::Update(void)
 	}
 }
 
+//--MIAMI: done
 void
 CStreaming::LoadCdDirectory(void)
 {
@@ -339,12 +313,6 @@ CStreaming::LoadCdDirectory(void)
 	ms_imageOffsets[3] = -1;
 	ms_imageOffsets[4] = -1;
 	ms_imageOffsets[5] = -1;
-	ms_imageOffsets[6] = -1;
-	ms_imageOffsets[7] = -1;
-	ms_imageOffsets[8] = -1;
-	ms_imageOffsets[9] = -1;
-	ms_imageOffsets[10] = -1;
-	ms_imageOffsets[11] = -1;
 	ms_imageSize = GetGTA3ImgSize();
 	// PS2 uses CFileMgr::GetCdFile on all IMG files to fill the array
 #endif
@@ -360,12 +328,12 @@ CStreaming::LoadCdDirectory(void)
 	ms_imageSize /= CDSTREAM_SECTOR_SIZE;
 }
 
+//--MIAMI: done
 void
 CStreaming::LoadCdDirectory(const char *dirname, int n)
 {
 	int fd, lastID, imgSelector;
-	int modelId, txdId;
-	uint32 posn, size;
+	int modelId;
 	CDirectory::DirectoryInfo direntry;
 	char *dot;
 
@@ -376,23 +344,23 @@ CStreaming::LoadCdDirectory(const char *dirname, int n)
 	imgSelector = n<<24;
 	assert(sizeof(direntry) == 32);
 	while(CFileMgr::Read(fd, (char*)&direntry, sizeof(direntry))){
-		dot = strchr(direntry.name, '.');
-		if(dot) *dot = '\0';
+		bool bAddToStreaming = false;
+
 		if(direntry.size > (uint32)ms_streamingBufferSize)
 			ms_streamingBufferSize = direntry.size;
+		direntry.name[23] = '\0';
+		dot = strchr(direntry.name, '.');
+		if(dot == nil || dot-direntry.name > 20){
+			debug("%s is too long\n", direntry.name);
+			lastID = -1;
+			continue;
+		}
 
-		if(!CGeneral::faststrcmp(dot+1, "DFF") || !CGeneral::faststrcmp(dot+1, "dff")){
+		*dot = '\0';
+
+		if(strncasecmp(dot+1, "DFF", 3) == 0){
 			if(CModelInfo::GetModelInfo(direntry.name, &modelId)){
-				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].SetCdPosnAndSize(direntry.offset, direntry.size);
-					if(lastID != -1)
-						ms_aInfoForModel[lastID].m_nextID = modelId;
-					lastID = modelId;
-				}
+				bAddToStreaming = true;
 			}else{
 #ifdef FIX_BUGS
 				// remember which cdimage this came from
@@ -402,27 +370,63 @@ CStreaming::LoadCdDirectory(const char *dirname, int n)
 #endif
 				lastID = -1;
 			}
-		}else if(!CGeneral::faststrcmp(dot+1, "TXD") || !CGeneral::faststrcmp(dot+1, "txd")){
-			txdId = CTxdStore::FindTxdSlot(direntry.name);
-			if(txdId == -1)
-				txdId = CTxdStore::AddTxdSlot(direntry.name);
-			if(ms_aInfoForModel[txdId + STREAM_OFFSET_TXD].GetCdPosnAndSize(posn, size)){
-				debug("%s appears more than once in %s\n", direntry.name, dirname);
+		}else if(strncasecmp(dot+1, "TXD", 3) == 0){
+			modelId = CTxdStore::FindTxdSlot(direntry.name);
+			if(modelId == -1)
+				modelId = CTxdStore::AddTxdSlot(direntry.name);
+			modelId += STREAM_OFFSET_TXD;
+			bAddToStreaming = true;
+		}else if(strncasecmp(dot+1, "COL", 3) == 0){
+			modelId = CColStore::FindColSlot(direntry.name);
+			if(modelId == -1)
+				modelId = CColStore::AddColSlot(direntry.name);
+			modelId += STREAM_OFFSET_COL;
+			bAddToStreaming = true;
+		}else if(strncasecmp(dot+1, "IFP", 3) == 0){
+			modelId = CAnimManager::RegisterAnimBlock(direntry.name);
+			modelId += STREAM_OFFSET_ANIM;
+			bAddToStreaming = true;
+		}else{
+			*dot = '.';
+			lastID = -1;
+		}
+
+		if(bAddToStreaming){
+			if(ms_aInfoForModel[modelId].GetCdSize()){
+				debug("%s.%s appears more than once in %s\n", direntry.name, dot+1, dirname);
 				lastID = -1;
 			}else{
 				direntry.offset |= imgSelector;
-				ms_aInfoForModel[txdId + STREAM_OFFSET_TXD].SetCdPosnAndSize(direntry.offset, direntry.size);
+				ms_aInfoForModel[modelId].SetCdPosnAndSize(direntry.offset, direntry.size);
 				if(lastID != -1)
-					ms_aInfoForModel[lastID].m_nextID = txdId + STREAM_OFFSET_TXD;
-				lastID = txdId + STREAM_OFFSET_TXD;
+					ms_aInfoForModel[lastID].m_nextID = modelId;
+				lastID = modelId;
 			}
-		}else
-			lastID = -1;
+		}
 	}
 
 	CFileMgr::CloseFile(fd);
 }
 
+static char*
+GetObjectName(int streamId)
+{
+	static char objname[32];
+	if(streamId < STREAM_OFFSET_TXD)
+		sprintf(objname, "%s.dff", CModelInfo::GetModelInfo(streamId)->GetName());
+	else if(streamId >= STREAM_OFFSET_TXD && streamId < STREAM_OFFSET_COL)
+		sprintf(objname, "%s.txd", CTxdStore::GetTxdName(streamId-STREAM_OFFSET_TXD));
+	else if(streamId >= STREAM_OFFSET_COL && streamId < STREAM_OFFSET_ANIM)
+		sprintf(objname, "%s.col", CColStore::GetColName(streamId-STREAM_OFFSET_COL));
+	else{
+		assert(streamId < NUMSTREAMINFO);
+		sprintf(objname, "%s.ifp", CAnimManager::GetAnimationBlock(streamId-STREAM_OFFSET_ANIM)->name);
+	}
+	return objname;
+}
+
+
+//--MIAMI: done
 bool
 CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 {
@@ -444,22 +448,25 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 		// 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()));
+		// Txd and anim have to be loaded
+		int animId = mi->GetAnimFileIndex();
+		if(CTxdStore::GetSlot(mi->GetTxdSlot())->texDict == nil ||
+		   animId != -1 && !CAnimManager::GetAnimationBlock(animId)->isLoaded){
 			RemoveModel(streamId);
-			RemoveTxd(mi->GetTxdSlot());
 			ReRequestModel(streamId);
 			RwStreamClose(stream, &mem);
 			return false;
 		}
 
-		// Set Txd to use
+		// Set Txd and anims to use
 		CTxdStore::AddRef(mi->GetTxdSlot());
+		if(animId != -1)
+			CAnimManager::AddAnimBlockRef(animId);
 		CTxdStore::SetCurrentTxd(mi->GetTxdSlot());
 
 		if(mi->IsSimple()){
 			success = CFileLoader::LoadAtomicFile(stream, streamId);
+			// TODO(MIAMI)? complain if file is not pre-instanced. we hardly are interested in that
 		} else if (mi->GetModelType() == MITYPE_VEHICLE) {
 			// load vehicles in two parts
 			CModelInfo::GetModelInfo(streamId)->AddRef();
@@ -471,9 +478,12 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 		}
 		UpdateMemoryUsed();
 
-		// Txd no longer needed unless we only read part of the file
-		if(ms_aInfoForModel[streamId].m_loadState != STREAMSTATE_STARTED)
+		// Txd and anims no longer needed unless we only read part of the file
+		if(ms_aInfoForModel[streamId].m_loadState != STREAMSTATE_STARTED){
 			CTxdStore::RemoveRefWithoutDelete(mi->GetTxdSlot());
+			if(animId != -1)
+				CAnimManager::RemoveAnimBlockRefWithoutDelete(animId);
+		}
 
 		if(!success){
 			debug("Failed to load %s\n", CModelInfo::GetModelInfo(streamId)->GetName());
@@ -482,9 +492,8 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 			RwStreamClose(stream, &mem);
 			return false;
 		}
-	}else{
+	}else if(streamId >= STREAM_OFFSET_TXD && streamId < STREAM_OFFSET_COL){
 		// Txd
-		assert(streamId < NUMSTREAMINFO);
 		if((ms_aInfoForModel[streamId].m_flags & STREAMFLAGS_KEEP_IN_MEMORY) == 0 &&
 		   !IsTxdUsedByRequestedModels(streamId - STREAM_OFFSET_TXD)){
 			RemoveModel(streamId);
@@ -507,20 +516,28 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 			RwStreamClose(stream, &mem);
 			return false;
 		}
+	}else if(streamId >= STREAM_OFFSET_COL && streamId < STREAM_OFFSET_ANIM){
+		if(!CColStore::LoadCol(streamId-STREAM_OFFSET_COL, mem.start, mem.length)){
+			debug("Failed to load %s.col\n", CColStore::GetColName(streamId - STREAM_OFFSET_COL));
+			RemoveModel(streamId);
+			ReRequestModel(streamId);
+			RwStreamClose(stream, &mem);
+			return false;
+		}
+	}else if(streamId >= STREAM_OFFSET_ANIM){
+		assert(streamId < NUMSTREAMINFO);
+		if((ms_aInfoForModel[streamId].m_flags & STREAMFLAGS_KEEP_IN_MEMORY) == 0 &&
+		   !AreAnimsUsedByRequestedModels(streamId - STREAM_OFFSET_ANIM)){
+			RemoveModel(streamId);
+			RwStreamClose(stream, &mem);
+			return false;
+		}
+		CAnimManager::LoadAnimFile(stream, true, nil);
+		CAnimManager::CreateAnimAssocGroups();
 	}
 
 	RwStreamClose(stream, &mem);
 
-	// We shouldn't even end up here unless load was successful
-	if(!success){
-		ReRequestModel(streamId);
-		if(streamId < STREAM_OFFSET_TXD)
-			debug("Failed to load %s.dff\n", mi->GetName());
-		else
-			debug("Failed to load %s.txd\n", CTxdStore::GetTxdName(streamId - STREAM_OFFSET_TXD));
-		return false;
-	}
-
 	if(streamId < STREAM_OFFSET_TXD){
 		// Model
 		// Vehicles and Peds not in loaded list
@@ -535,12 +552,14 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 					smi->m_alpha = 0;
 			}
 
-			if((ms_aInfoForModel[streamId].m_flags & STREAMFLAGS_CANT_REMOVE) == 0)
+			if(CanRemoveModel(streamId))
 				ms_aInfoForModel[streamId].AddToList(&ms_startLoadedList);
 		}
-	}else{
-		// Txd
-		if((ms_aInfoForModel[streamId].m_flags & STREAMFLAGS_CANT_REMOVE) == 0)
+	}else if(streamId >= STREAM_OFFSET_TXD && streamId < STREAM_OFFSET_COL ||
+	         streamId >= STREAM_OFFSET_ANIM){
+		assert(streamId < NUMSTREAMINFO);
+		// Txd and anims
+		if(CanRemoveModel(streamId))
 			ms_aInfoForModel[streamId].AddToList(&ms_startLoadedList);
 	}
 
@@ -552,17 +571,13 @@ CStreaming::ConvertBufferToObject(int8 *buf, int32 streamId)
 
 	endTime = CTimer::GetCurrentTimeInCycles() / CTimer::GetCyclesPerMillisecond();
 	timeDiff = endTime - startTime;
-	if(timeDiff > 5){
-		if(streamId < STREAM_OFFSET_TXD)
-			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);
-	}
+	if(timeDiff > 5)
+		debug("%s took %d ms\n", GetObjectName(streamId), timeDiff);
 
 	return true;
 }
 
-
+//--MIAMI: done
 bool
 CStreaming::FinishLoadingLargeFile(int8 *buf, int32 streamId)
 {
@@ -593,11 +608,15 @@ CStreaming::FinishLoadingLargeFile(int8 *buf, int32 streamId)
 			success = AddToLoadedVehiclesList(streamId);
 		mi->RemoveRef();
 		CTxdStore::RemoveRefWithoutDelete(mi->GetTxdSlot());
-	}else{
+		if(mi->GetAnimFileIndex() != -1)
+			CAnimManager::RemoveAnimBlockRefWithoutDelete(mi->GetAnimFileIndex());
+	}else if(streamId >= STREAM_OFFSET_TXD && streamId < STREAM_OFFSET_COL){
 		// Txd
 		CTxdStore::AddRef(streamId - STREAM_OFFSET_TXD);
 		success = CTxdStore::FinishLoadTxd(streamId - STREAM_OFFSET_TXD, stream);
 		CTxdStore::RemoveRefWithoutDelete(streamId - STREAM_OFFSET_TXD);
+	}else{
+		assert(0 && "invalid streamId");
 	}
 
 	RwStreamClose(stream, &mem);
@@ -615,16 +634,13 @@ CStreaming::FinishLoadingLargeFile(int8 *buf, int32 streamId)
 
 	endTime = CTimer::GetCurrentTimeInCycles() / CTimer::GetCyclesPerMillisecond();
 	timeDiff = endTime - startTime;
-	if(timeDiff > 5){
-		if(streamId < STREAM_OFFSET_TXD)
-			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);
-	}
+	if(timeDiff > 5)
+		debug("%s took %d ms\n", GetObjectName(streamId), timeDiff);
 
 	return true;
 }
 
+//--MIAMI: done
 void
 CStreaming::RequestModel(int32 id, int32 flags)
 {
@@ -653,15 +669,20 @@ CStreaming::RequestModel(int32 id, int32 flags)
 		// reinsert into list
 		if(ms_aInfoForModel[id].m_next){
 			ms_aInfoForModel[id].RemoveFromList();
-			if((ms_aInfoForModel[id].m_flags & STREAMFLAGS_CANT_REMOVE) == 0)
+			if(CanRemoveModel(id))
 				ms_aInfoForModel[id].AddToList(&ms_startLoadedList);
 		}
 	}else if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_NOTLOADED ||
 	         ms_aInfoForModel[id].m_loadState == STREAMSTATE_LOADED){	// how can this be true again?
 
 		if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_NOTLOADED){
-			if(id < STREAM_OFFSET_TXD)
-				RequestTxd(CModelInfo::GetModelInfo(id)->GetTxdSlot(), flags);
+			if(id < STREAM_OFFSET_TXD){
+				mi = (CSimpleModelInfo*)CModelInfo::GetModelInfo(id);
+				RequestTxd(mi->GetTxdSlot(), flags);
+				int anim = mi->GetAnimFileIndex();
+				if(anim != -1)
+					RequestAnim(anim, STREAMFLAGS_DEPENDENCY);
+			}
 			ms_aInfoForModel[id].AddToList(&ms_startRequestedList);
 			ms_numModelsRequested++;
 			if(flags & STREAMFLAGS_PRIORITY)
@@ -673,52 +694,28 @@ CStreaming::RequestModel(int32 id, int32 flags)
 	}
 }
 
+#define BIGBUILDINGFLAGS STREAMFLAGS_DONT_REMOVE
+
+//--MIAMI: done
 void
-CStreaming::RequestSubway(void)
-{
-	RequestModel(MI_SUBWAY1, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY2, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY3, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY4, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY5, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY6, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY7, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY8, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY9, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY10, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY11, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY12, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY13, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY14, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY15, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY16, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY17, STREAMFLAGS_NOFADE);
-	RequestModel(MI_SUBWAY18, STREAMFLAGS_NOFADE);
-
-	switch(CGame::currLevel){
-	case LEVEL_INDUSTRIAL:
-		RequestModel(MI_SUBPLATFORM_IND, STREAMFLAGS_NOFADE);
-		break;
-	case LEVEL_COMMERCIAL:
-		if(FindPlayerTrain()->GetPosition().y < -700.0f){
-			RequestModel(MI_SUBPLATFORM_COMS, STREAMFLAGS_NOFADE);
-			RequestModel(MI_SUBPLATFORM_COMS2, STREAMFLAGS_NOFADE);
-		}else{
-			RequestModel(MI_SUBPLATFORM_COMN, STREAMFLAGS_NOFADE);
-		}
-		break;
-	case LEVEL_SUBURBAN:
-		RequestModel(MI_SUBPLATFORM_SUB, STREAMFLAGS_NOFADE);
-		RequestModel(MI_SUBPLATFORM_SUB2, STREAMFLAGS_NOFADE);
-		break;
-	default: break;
+CStreaming::RequestBigBuildings(eLevelName level)
+{
+	int i, n;
+	CBuilding *b;
+
+	n = CPools::GetBuildingPool()->GetSize()-1;
+	for(i = n; i >= 0; i--){
+		b = CPools::GetBuildingPool()->GetSlot(i);
+		if(b && b->bIsBIGBuilding && b->m_level == level)
+			if(!b->bStreamBIGBuilding)
+				RequestModel(b->GetModelIndex(), BIGBUILDINGFLAGS);
 	}
+	RequestIslands(level);
 }
 
-#define BIGBUILDINGFLAGS STREAMFLAGS_DONT_REMOVE|STREAMFLAGS_PRIORITY
-
+//--MIAMI: done
 void
-CStreaming::RequestBigBuildings(eLevelName level)
+CStreaming::RequestBigBuildings(eLevelName level, const CVector &pos)
 {
 	int i, n;
 	CBuilding *b;
@@ -731,34 +728,93 @@ CStreaming::RequestBigBuildings(eLevelName level)
 		    && b->m_level == level
 #endif
 		)
-			RequestModel(b->GetModelIndex(), BIGBUILDINGFLAGS);
+			if(b->bStreamBIGBuilding){
+				if(CRenderer::ShouldModelBeStreamed(b, pos))
+					RequestModel(b->GetModelIndex(), 0);
+			}else
+				RequestModel(b->GetModelIndex(), BIGBUILDINGFLAGS);
 	}
 	RequestIslands(level);
-	ms_hasLoadedLODs = false;
 }
 
+//--MIAMI: done
+void
+CStreaming::InstanceBigBuildings(eLevelName level, const CVector &pos)
+{
+	int i, n;
+	CBuilding *b;
+
+	n = CPools::GetBuildingPool()->GetSize()-1;
+	for(i = n; i >= 0; i--){
+		b = CPools::GetBuildingPool()->GetSlot(i);
+		if(b && b->bIsBIGBuilding && b->m_level == level &&
+		   b->bStreamBIGBuilding && b->m_rwObject == nil)
+			if(CRenderer::ShouldModelBeStreamed(b, pos))
+				b->CreateRwObject();
+	}
+}
+
+//--MIAMI: done
+void
+CStreaming::InstanceLoadedModelsInSectorList(CPtrList &list)
+{
+	CPtrNode *node;
+	CEntity *e;
+	for(node = list.first; node; node = node->next) {
+		e = (CEntity *)node->item;
+		if(IsAreaVisible(e->m_area) && e->m_rwObject == nil)
+			e->CreateRwObject();
+	}
+}
+
+//--MIAMI: done
+void
+CStreaming::InstanceLoadedModels(const CVector &pos)
+{
+	int minX = CWorld::GetSectorIndexX(pos.x - 80.0f);
+	if(minX <= 0) minX = 0;
+
+	int minY = CWorld::GetSectorIndexY(pos.y - 80.0f);
+	if(minY <= 0) minY = 0;
+
+	int maxX = CWorld::GetSectorIndexX(pos.x + 80.0f);
+	if(maxX >= NUMSECTORS_X) maxX = NUMSECTORS_X - 1;
+
+	int maxY = CWorld::GetSectorIndexY(pos.y + 80.0f);
+	if(maxY >= NUMSECTORS_Y) maxY = NUMSECTORS_Y - 1;
+
+	int x, y;
+	for(y = minY; y <= maxY; y++){
+		for(x = minX; x <= maxX; x++){
+			CSector *sector = CWorld::GetSector(x, y);
+			InstanceLoadedModelsInSectorList(sector->m_lists[ENTITYLIST_BUILDINGS]);
+			InstanceLoadedModelsInSectorList(sector->m_lists[ENTITYLIST_BUILDINGS_OVERLAP]);
+			InstanceLoadedModelsInSectorList(sector->m_lists[ENTITYLIST_OBJECTS]);
+			InstanceLoadedModelsInSectorList(sector->m_lists[ENTITYLIST_DUMMIES]);
+		}
+	}
+}
+
+//--MIAMI: done
 void
 CStreaming::RequestIslands(eLevelName level)
 {
 #ifndef NO_ISLAND_LOADING
 	switch(level){
-	case LEVEL_INDUSTRIAL:
-		RequestModel(islandLODcomInd, BIGBUILDINGFLAGS);
-		RequestModel(islandLODsubInd, BIGBUILDINGFLAGS);
-		break;
-	case LEVEL_COMMERCIAL:
-		RequestModel(islandLODindust, BIGBUILDINGFLAGS);
-		RequestModel(islandLODsubCom, BIGBUILDINGFLAGS);
+	case LEVEL_MAINLAND:
+		if(islandLODbeach != -1)
+			RequestModel(islandLODbeach, BIGBUILDINGFLAGS);
 		break;
-	case LEVEL_SUBURBAN:
-		RequestModel(islandLODindust, BIGBUILDINGFLAGS);
-		RequestModel(islandLODcomSub, BIGBUILDINGFLAGS);
+	case LEVEL_BEACH:
+		if(islandLODmainland != -1)
+			RequestModel(islandLODmainland, BIGBUILDINGFLAGS);
 		break;
 	default: break;
 	}
 #endif
 }
 
+//--MIAMI: TODO
 void
 CStreaming::RequestSpecialModel(int32 modelId, const char *modelName, int32 flags)
 {
@@ -800,24 +856,28 @@ CStreaming::RequestSpecialModel(int32 modelId, const char *modelName, int32 flag
 	RequestModel(modelId, flags);
 }
 
+//--MIAMI: done
 void
 CStreaming::RequestSpecialChar(int32 charId, const char *modelName, int32 flags)
 {
 	RequestSpecialModel(charId + MI_SPECIAL01, modelName, flags);
 }
 
+//--MIAMI: done
 bool
 CStreaming::HasSpecialCharLoaded(int32 id)
 {
 	return HasModelLoaded(id + MI_SPECIAL01);
 }
 
+//--MIAMI: done
 void
 CStreaming::SetMissionDoesntRequireSpecialChar(int32 id)
 {
 	return SetMissionDoesntRequireModel(id + MI_SPECIAL01);
 }
 
+//--MIAMI: done
 void
 CStreaming::DecrementRef(int32 id)
 {
@@ -828,6 +888,7 @@ CStreaming::DecrementRef(int32 id)
 	}
 }
 
+//--MIAMI: done
 void
 CStreaming::RemoveModel(int32 id)
 {
@@ -839,8 +900,14 @@ CStreaming::RemoveModel(int32 id)
 	if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_LOADED){
 		if(id < STREAM_OFFSET_TXD)
 			CModelInfo::GetModelInfo(id)->DeleteRwObject();
-		else
+		else if(id >= STREAM_OFFSET_TXD && id < STREAM_OFFSET_COL)
 			CTxdStore::RemoveTxd(id - STREAM_OFFSET_TXD);
+		else if(id >= STREAM_OFFSET_COL && id < STREAM_OFFSET_ANIM)
+			CColStore::RemoveCol(id - STREAM_OFFSET_COL);
+		else if(id >= STREAM_OFFSET_ANIM){
+			assert(id < NUMSTREAMINFO);
+			CAnimManager::RemoveAnimBlock(id - STREAM_OFFSET_ANIM);
+		}
 		ms_memoryUsed -= ms_aInfoForModel[id].GetCdSize()*CDSTREAM_SECTOR_SIZE;
 	}
 
@@ -861,24 +928,30 @@ CStreaming::RemoveModel(int32 id)
 	if(ms_aInfoForModel[id].m_loadState == STREAMSTATE_STARTED){
 		if(id < STREAM_OFFSET_TXD)
 			RpClumpGtaCancelStream();
-		else
+		else if(id >= STREAM_OFFSET_TXD && id < STREAM_OFFSET_COL)
 			CTxdStore::RemoveTxd(id - STREAM_OFFSET_TXD);
+		else if(id >= STREAM_OFFSET_COL && id < STREAM_OFFSET_ANIM)
+			CColStore::RemoveCol(id - STREAM_OFFSET_COL);
+		else if(id >= STREAM_OFFSET_ANIM){
+			assert(id < NUMSTREAMINFO);
+			CAnimManager::RemoveAnimBlock(id - STREAM_OFFSET_ANIM);
+		}
 	}
 
 	ms_aInfoForModel[id].m_loadState = STREAMSTATE_NOTLOADED;
 }
 
+//--MIAMI: done
 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);
+	if(level != LEVEL_BEACH)
+		RemoveBuildings(LEVEL_BEACH);
+	if(level != LEVEL_MAINLAND)
+		RemoveBuildings(LEVEL_MAINLAND);
 }
 
+//--MIAMI: done
 void
 CStreaming::RemoveBuildings(eLevelName level)
 {
@@ -939,20 +1012,20 @@ CStreaming::RemoveBuildings(eLevelName level)
 	}
 }
 
+//--MIAMI: done
 void
 CStreaming::RemoveUnusedBigBuildings(eLevelName level)
 {
 #ifndef NO_ISLAND_LOADING
-	if(level != LEVEL_INDUSTRIAL)
-		RemoveBigBuildings(LEVEL_INDUSTRIAL);
-	if(level != LEVEL_COMMERCIAL)
-		RemoveBigBuildings(LEVEL_COMMERCIAL);
-	if(level != LEVEL_SUBURBAN)
-		RemoveBigBuildings(LEVEL_SUBURBAN);
+	if(level != LEVEL_BEACH)
+		RemoveBigBuildings(LEVEL_BEACH);
+	if(level != LEVEL_MAINLAND)
+		RemoveBigBuildings(LEVEL_MAINLAND);
 #endif
 	RemoveIslandsNotUsed(level);
 }
 
+//--MIAMI: done
 void
 DeleteIsland(CEntity *island)
 {
@@ -966,39 +1039,36 @@ DeleteIsland(CEntity *island)
 	}
 }
 
+//--MIAMI: done
 void
 CStreaming::RemoveIslandsNotUsed(eLevelName level)
 {
 #ifndef NO_ISLAND_LOADING
+	int i;
+	if(pIslandLODmainlandEntity == nil)
+	for(i = CPools::GetBuildingPool()->GetSize()-1; i >= 0; i--){
+		CBuilding *building = CPools::GetBuildingPool()->GetSlot(i);
+		if(building == nil)
+			continue;
+		if(building->GetModelIndex() == islandLODmainland)
+			pIslandLODmainlandEntity = building;
+		if(building->GetModelIndex() == islandLODbeach)
+			pIslandLODbeachEntity = building;
+	}
+
 	switch(level){
-	case LEVEL_INDUSTRIAL:
-		DeleteIsland(pIslandLODindustEntity);
-		DeleteIsland(pIslandLODcomSubEntity);
-		DeleteIsland(pIslandLODsubComEntity);
+	case LEVEL_MAINLAND:
+		DeleteIsland(pIslandLODmainlandEntity);
 		break;
-	case LEVEL_COMMERCIAL:
-		DeleteIsland(pIslandLODcomIndEntity);
-		DeleteIsland(pIslandLODcomSubEntity);
-		DeleteIsland(pIslandLODsubIndEntity);
-		break;
-	case LEVEL_SUBURBAN:
-		DeleteIsland(pIslandLODsubIndEntity);
-		DeleteIsland(pIslandLODsubComEntity);
-		DeleteIsland(pIslandLODcomIndEntity);
-		break;
-	default:
-#endif // !NO_ISLAND_LOADING
-		DeleteIsland(pIslandLODindustEntity);
-		DeleteIsland(pIslandLODcomIndEntity);
-		DeleteIsland(pIslandLODcomSubEntity);
-		DeleteIsland(pIslandLODsubIndEntity);
-		DeleteIsland(pIslandLODsubComEntity);
-#ifndef NO_ISLAND_LOADING
+	case LEVEL_BEACH:
+		DeleteIsland(pIslandLODbeachEntity);
+
 		break;
 	}
 #endif // !NO_ISLAND_LOADING
 }
 
+//--MIAMI: done
 void
 CStreaming::RemoveBigBuildings(eLevelName level)
 {
@@ -1030,8 +1100,7 @@ CStreaming::RemoveLoadedVehicle(void)
 		if(ms_lastVehicleDeleted == MAXVEHICLESLOADED)
 			ms_lastVehicleDeleted = 0;
 		id = ms_vehiclesLoaded[ms_lastVehicleDeleted];
-		if(id != -1 &&
-		   (ms_aInfoForModel[id].m_flags & STREAMFLAGS_CANT_REMOVE) == 0 && CModelInfo::GetModelInfo(id)->GetNumRefs() == 0 &&
+		if(id != -1 && CanRemoveModel(id) && CModelInfo::GetModelInfo(id)->GetNumRefs() == 0 &&
 		   ms_aInfoForModel[id].m_loadState == STREAMSTATE_LOADED)
 			goto found;
 	}
@@ -1040,33 +1109,47 @@ found:
 	RemoveModel(ms_vehiclesLoaded[ms_lastVehicleDeleted]);
 	ms_numVehiclesLoaded--;
 	ms_vehiclesLoaded[ms_lastVehicleDeleted] = -1;
+	CVehicleModelInfo* pVehicleInfo = (CVehicleModelInfo*)CModelInfo::GetModelInfo(id);
+	if (pVehicleInfo->m_vehicleClass != -1)
+		CCarCtrl::RemoveFromLoadedVehicleArray(id, pVehicleInfo->m_vehicleClass);
 	return true;
 }
 
+//--MIAMI: done
 bool
-CStreaming::RemoveLeastUsedModel(void)
+CStreaming::RemoveLeastUsedModel(uint32 excludeMask)
 {
 	CStreamingInfo *si;
 	int streamId;
 
 	for(si = ms_endLoadedList.m_prev; si != &ms_startLoadedList; si = si->m_prev){
+		if(si->m_flags & excludeMask)
+			continue;
 		streamId = si - ms_aInfoForModel;
 		if(streamId < STREAM_OFFSET_TXD){
 			if (CModelInfo::GetModelInfo(streamId)->GetNumRefs() == 0) {
 				RemoveModel(streamId);
 				return true;
 			}
-		}else{
+		}else if(streamId >= STREAM_OFFSET_TXD && streamId < STREAM_OFFSET_COL){
 			if(CTxdStore::GetNumRefs(streamId - STREAM_OFFSET_TXD) == 0 &&
 			   !IsTxdUsedByRequestedModels(streamId - STREAM_OFFSET_TXD)){
 				RemoveModel(streamId);
 				return true;
 			}
+		}else if(streamId >= STREAM_OFFSET_ANIM){
+			assert(streamId < NUMSTREAMINFO);
+			if(CAnimManager::GetNumRefsToAnimBlock(streamId - STREAM_OFFSET_ANIM) == 0 &&
+			   !AreAnimsUsedByRequestedModels(streamId - STREAM_OFFSET_ANIM)){
+				RemoveModel(streamId);
+				return true;
+			}
 		}
 	}
-	return ms_numVehiclesLoaded > 7 && RemoveLoadedVehicle();
+	return (ms_numVehiclesLoaded > 7 || CGame::currArea != AREA_MAIN_MAP && ms_numVehiclesLoaded > 4) && RemoveLoadedVehicle();
 }
 
+//--MIAMI: done
 void
 CStreaming::RemoveAllUnusedModels(void)
 {
@@ -1077,7 +1160,6 @@ CStreaming::RemoveAllUnusedModels(void)
 
 	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)->GetNumRefs() == 0) {
 			RemoveModel(i);
 			ms_aInfoForModel[i].m_loadState = STREAMSTATE_NOTLOADED;
@@ -1085,30 +1167,14 @@ CStreaming::RemoveAllUnusedModels(void)
 	}
 }
 
-bool
-CStreaming::RemoveReferencedTxds(size_t 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;
-}
-
+//--MIAMI: done
 void
 CStreaming::RemoveUnusedModelsInLoadedList(void)
 {
 	// empty
 }
 
+//--MIAMI: done
 bool
 CStreaming::IsTxdUsedByRequestedModels(int32 txdId)
 {
@@ -1137,6 +1203,34 @@ CStreaming::IsTxdUsedByRequestedModels(int32 txdId)
 	return false;
 }
 
+bool
+CStreaming::AreAnimsUsedByRequestedModels(int32 animId)
+{
+	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)->GetAnimFileIndex() == animId)
+			return true;
+	}
+
+	for(i = 0; i < 4; i++){
+		streamId = ms_channel[0].streamIds[i];
+		if(streamId != -1 && streamId < STREAM_OFFSET_TXD &&
+		   CModelInfo::GetModelInfo(streamId)->GetAnimFileIndex() == animId)
+			return true;
+		streamId = ms_channel[1].streamIds[i];
+		if(streamId != -1 && streamId < STREAM_OFFSET_TXD &&
+		   CModelInfo::GetModelInfo(streamId)->GetAnimFileIndex() == animId)
+			return true;
+	}
+
+	return false;
+}
+
 int32
 CStreaming::GetAvailableVehicleSlot(void)
 {
@@ -1168,8 +1262,8 @@ CStreaming::AddToLoadedVehiclesList(int32 modelId)
 		// 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_CANT_REMOVE) == 0 && CModelInfo::GetModelInfo(id)->GetNumRefs() == 0)
+			if(id != -1 && CanRemoveModel(id) &&
+			   CModelInfo::GetModelInfo(id)->GetNumRefs() == 0)
 				goto found;
 			ms_lastVehicleDeleted++;
 			if(ms_lastVehicleDeleted == MAXVEHICLESLOADED)
@@ -1185,13 +1279,21 @@ found:
 			ms_lastVehicleDeleted = id;
 			// this is more that we wanted actually
 			ms_numVehiclesLoaded++;
-		}else
+		}
+		else{
 			RemoveModel(id);
+			CVehicleModelInfo* pVehicleInfo = (CVehicleModelInfo*)CModelInfo::GetModelInfo(id);
+			if (pVehicleInfo->m_vehicleClass != -1)
+				CCarCtrl::RemoveFromLoadedVehicleArray(id, pVehicleInfo->m_vehicleClass);
+		}
 	}
 
 	ms_vehiclesLoaded[ms_lastVehicleDeleted++] = modelId;
 	if(ms_lastVehicleDeleted == MAXVEHICLESLOADED)
 		ms_lastVehicleDeleted = 0;
+	CVehicleModelInfo* pVehicleInfo = (CVehicleModelInfo*)CModelInfo::GetModelInfo(modelId);
+	if (pVehicleInfo->m_vehicleClass != -1)
+		CCarCtrl::AddToLoadedVehicleArray(modelId, pVehicleInfo->m_vehicleClass, pVehicleInfo->m_frequency);
 	return true;
 }
 
@@ -1203,41 +1305,6 @@ CStreaming::IsObjectInCdImage(int32 id)
 }
 
 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()-1;
-	for(i = n; i >= 0; 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;
@@ -1256,6 +1323,7 @@ CStreaming::SetModelTxdIsDeletable(int32 id)
 	SetModelIsDeletable(CModelInfo::GetModelInfo(id)->GetTxdSlot() + STREAM_OFFSET_TXD);
 }
 
+//--MIAMI: done
 void
 CStreaming::SetMissionDoesntRequireModel(int32 id)
 {
@@ -1278,6 +1346,13 @@ CStreaming::LoadInitialPeds(void)
 }
 
 void
+CStreaming::LoadInitialWeapons(void)
+{
+	CStreaming::RequestModel(MI_NIGHTSTICK, STREAMFLAGS_DONT_REMOVE);
+	CStreaming::RequestModel(MI_MISSILE, STREAMFLAGS_DONT_REMOVE);
+}
+
+void
 CStreaming::LoadInitialVehicles(void)
 {
 	int id;
@@ -1316,11 +1391,11 @@ CStreaming::StreamVehiclesAndPeds(void)
 	}
 
 	if(FindPlayerPed()->m_pWanted->AreFbiRequired()){
-		RequestModel(MI_FBICAR, STREAMFLAGS_DONT_REMOVE);
+		RequestModel(MI_FBIRANCH, STREAMFLAGS_DONT_REMOVE);
 		RequestModel(MI_FBI, STREAMFLAGS_DONT_REMOVE);
 	}else{
-		SetModelIsDeletable(MI_FBICAR);
-		if(!HasModelLoaded(MI_FBICAR))
+		SetModelIsDeletable(MI_FBIRANCH);
+		if(!HasModelLoaded(MI_FBIRANCH))
 			SetModelIsDeletable(MI_FBI);
 	}
 
@@ -1340,28 +1415,73 @@ CStreaming::StreamVehiclesAndPeds(void)
 	else
 		SetModelIsDeletable(MI_CHOPPER);
 
+	if (FindPlayerPed()->m_pWanted->AreMiamiViceRequired()) {
+		SetModelIsDeletable(MI_VICE1);
+		SetModelIsDeletable(MI_VICE2);
+		SetModelIsDeletable(MI_VICE3);
+		SetModelIsDeletable(MI_VICE4);
+		SetModelIsDeletable(MI_VICE5);
+		SetModelIsDeletable(MI_VICE6);
+		SetModelIsDeletable(MI_VICE7);
+		SetModelIsDeletable(MI_VICE8);
+		switch (CCarCtrl::MiamiViceCycle) {
+		case 0:
+			RequestModel(MI_VICE1, STREAMFLAGS_DONT_REMOVE);
+			RequestModel(MI_VICE2, STREAMFLAGS_DONT_REMOVE);
+			break;
+		case 1:
+			RequestModel(MI_VICE3, STREAMFLAGS_DONT_REMOVE);
+			RequestModel(MI_VICE4, STREAMFLAGS_DONT_REMOVE);
+			break;
+		case 2:
+			RequestModel(MI_VICE5, STREAMFLAGS_DONT_REMOVE);
+			RequestModel(MI_VICE6, STREAMFLAGS_DONT_REMOVE);
+			break;
+		case 3:
+			RequestModel(MI_VICE7, STREAMFLAGS_DONT_REMOVE);
+			RequestModel(MI_VICE8, STREAMFLAGS_DONT_REMOVE);
+			break;
+		}
+		RequestModel(MI_VICECHEE, STREAMFLAGS_DONT_REMOVE);
+	}
+	else {
+		SetModelIsDeletable(MI_VICECHEE);
+		SetModelIsDeletable(MI_VICE1);
+		SetModelIsDeletable(MI_VICE2);
+		SetModelIsDeletable(MI_VICE3);
+		SetModelIsDeletable(MI_VICE4);
+		SetModelIsDeletable(MI_VICE5);
+		SetModelIsDeletable(MI_VICE6);
+		SetModelIsDeletable(MI_VICE7);
+		SetModelIsDeletable(MI_VICE8);
+	}
+
 	if(timeBeforeNextLoad >= 0)
 		timeBeforeNextLoad--;
 	else if(ms_numVehiclesLoaded <= desiredNumVehiclesLoaded){
-		for(i = 1; i <= 10; i++){
-			model =  CCarCtrl::ChooseCarModel(modelQualityClass);
-			modelQualityClass++;
-			if(modelQualityClass >= CCarCtrl::TOTAL_CUSTOM_CLASSES)
-				modelQualityClass = 0;
-
-			// check if we want to load this model
-			if(ms_aInfoForModel[model].m_loadState == STREAMSTATE_NOTLOADED &&
-			   ((CVehicleModelInfo*)CModelInfo::GetModelInfo(model))->m_level & (1 << (CGame::currLevel-1)))
-				break;
+		CZoneInfo zone;
+		CVector coors = FindPlayerCoors();
+		CTheZones::GetZoneInfoForTimeOfDay(&coors, &zone);
+		int32 maxReq = -1;
+		int32 mostRequestedRating = 0;
+		for(i = 0; i < CCarCtrl::TOTAL_CUSTOM_CLASSES; i++){
+			if(CCarCtrl::NumRequestsOfCarRating[i] > maxReq &&
+				((i == 0 && zone.carThreshold[0] != 0) ||
+				(i != 0 && zone.carThreshold[i] != zone.carThreshold[i-1]))) {
+				maxReq = CCarCtrl::NumRequestsOfCarRating[i];
+				mostRequestedRating = i;
+			}
 		}
-
-		if(i <= 10){
+		model = CCarCtrl::ChooseCarModelToLoad(mostRequestedRating);
+		if(!HasModelLoaded(model)){
 			RequestModel(model, STREAMFLAGS_DEPENDENCY);
-			timeBeforeNextLoad = 500;
+			timeBeforeNextLoad = 350;
 		}
+		CCarCtrl::NumRequestsOfCarRating[mostRequestedRating] = 0;
 	}
 }
 
+//--MIAMI: TODO
 void
 CStreaming::StreamZoneModels(const CVector &pos)
 {
@@ -1387,58 +1507,54 @@ CStreaming::StreamZoneModels(const CVector &pos)
 		for(i = 0; i < NUMMODELSPERPEDGROUP; i++){
 			if(CPopulation::ms_pPedGroups[ms_currentPedGrp].models[i] == -1)
 				break;
-			RequestModel(CPopulation::ms_pPedGroups[ms_currentPedGrp].models[i], STREAMFLAGS_DONT_REMOVE);
+			RequestModel(CPopulation::ms_pPedGroups[ms_currentPedGrp].models[i], STREAMFLAGS_DEPENDENCY);
 		}
 	}
 	RequestModel(MI_MALE01, STREAMFLAGS_DONT_REMOVE);
+	//RequestModel(MI_HMOCA, STREAMFLAGS_DONT_REMOVE);
 
 	gangsToLoad = 0;
 	gangCarsToLoad = 0;
-	if(info.gangDensity[0] != 0) gangsToLoad |= 1<<0;
-	if(info.gangDensity[1] != 0) gangsToLoad |= 1<<1;
-	if(info.gangDensity[2] != 0) gangsToLoad |= 1<<2;
-	if(info.gangDensity[3] != 0) gangsToLoad |= 1<<3;
-	if(info.gangDensity[4] != 0) gangsToLoad |= 1<<4;
-	if(info.gangDensity[5] != 0) gangsToLoad |= 1<<5;
-	if(info.gangDensity[6] != 0) gangsToLoad |= 1<<6;
-	if(info.gangDensity[7] != 0) gangsToLoad |= 1<<7;
-	if(info.gangDensity[8] != 0) gangsToLoad |= 1<<8;
-	if(info.gangThreshold[0] != info.copDensity) gangCarsToLoad |= 1<<0;
-	if(info.gangThreshold[1] != info.gangThreshold[0]) gangCarsToLoad |= 1<<1;
-	if(info.gangThreshold[2] != info.gangThreshold[1]) gangCarsToLoad |= 1<<2;
-	if(info.gangThreshold[3] != info.gangThreshold[2]) gangCarsToLoad |= 1<<3;
-	if(info.gangThreshold[4] != info.gangThreshold[3]) gangCarsToLoad |= 1<<4;
-	if(info.gangThreshold[5] != info.gangThreshold[4]) gangCarsToLoad |= 1<<5;
-	if(info.gangThreshold[6] != info.gangThreshold[5]) gangCarsToLoad |= 1<<6;
-	if(info.gangThreshold[7] != info.gangThreshold[6]) gangCarsToLoad |= 1<<7;
-	if(info.gangThreshold[8] != info.gangThreshold[7]) gangCarsToLoad |= 1<<8;
+	if(info.gangPedThreshold[0] != info.copPedThreshold)
+		gangsToLoad = 1;
+	for(i = 1; i < NUM_GANGS; i++)
+		if(info.gangPedThreshold[i] != info.gangPedThreshold[i-1])
+			gangsToLoad |= 1<<i;
+	if(info.gangThreshold[0] != info.copThreshold)
+		gangCarsToLoad = 1;
+	for(i = 1; i < NUM_GANGS; i++)
+		if(info.gangThreshold[i] != info.gangThreshold[i-1])
+			gangCarsToLoad |= 1<<i;
 
 	if(gangsToLoad == ms_loadedGangs && gangCarsToLoad == ms_loadedGangCars)
 		return;
 
-	// This makes things simpler than the game does it
 	gangsToLoad |= gangCarsToLoad;
 
 	for(i = 0; i < NUM_GANGS; i++){
 		bit = 1<<i;
 
 		if(gangsToLoad & bit && (ms_loadedGangs & bit) == 0){
-			RequestModel(MI_GANG01 + i*2, STREAMFLAGS_DONT_REMOVE);
-			RequestModel(MI_GANG01 + i*2 + 1, STREAMFLAGS_DONT_REMOVE);
+			RequestModel(CGangs::GetGangPedModel1(i), STREAMFLAGS_DEPENDENCY);
+			RequestModel(CGangs::GetGangPedModel2(i), STREAMFLAGS_DEPENDENCY);
 			ms_loadedGangs |= bit;
 		}else if((gangsToLoad & bit) == 0 && ms_loadedGangs & bit){
-			SetModelIsDeletable(MI_GANG01 + i*2);
-			SetModelIsDeletable(MI_GANG01 + i*2 + 1);
-			SetModelTxdIsDeletable(MI_GANG01 + i*2);
-			SetModelTxdIsDeletable(MI_GANG01 + i*2 + 1);
+			SetModelIsDeletable(CGangs::GetGangPedModel1(i));
+			SetModelIsDeletable(CGangs::GetGangPedModel2(i));
+			SetModelTxdIsDeletable(CGangs::GetGangPedModel1(i));
+			SetModelTxdIsDeletable(CGangs::GetGangPedModel2(i));
 			ms_loadedGangs &= ~bit;
 		}
 
-		if(gangCarsToLoad & bit && (ms_loadedGangCars & bit) == 0){
-			RequestModel(CGangs::GetGangInfo(i)->m_nVehicleMI, STREAMFLAGS_DONT_REMOVE);
+		// TODO(MIAMI): check this
+		if(CGangs::GetGangVehicleModel(i) < 0)
+			continue;
+
+		if((gangCarsToLoad & bit) && (ms_loadedGangCars & bit) == 0){
+			RequestModel(CGangs::GetGangVehicleModel(i), STREAMFLAGS_DEPENDENCY);
 		}else if((gangCarsToLoad & bit) == 0 && ms_loadedGangCars & bit){
-			SetModelIsDeletable(CGangs::GetGangInfo(i)->m_nVehicleMI);
-			SetModelTxdIsDeletable(CGangs::GetGangInfo(i)->m_nVehicleMI);
+			SetModelIsDeletable(CGangs::GetGangVehicleModel(i));
+			SetModelTxdIsDeletable(CGangs::GetGangVehicleModel(i));
 		}
 	}
 	ms_loadedGangCars = gangCarsToLoad;
@@ -1449,19 +1565,32 @@ CStreaming::RemoveCurrentZonesModels(void)
 {
 	int i;
 
-	if(ms_currentPedGrp != -1)
-		for(i = 0; i < 8; i++){
-			if(CPopulation::ms_pPedGroups[ms_currentPedGrp].models[i] == -1)
+	if (ms_currentPedGrp != -1)
+		for (i = 0; i < NUMMODELSPERPEDGROUP; i++) {
+			if (CPopulation::ms_pPedGroups[ms_currentPedGrp].models[i] == -1)
 				break;
-			if(CPopulation::ms_pPedGroups[ms_currentPedGrp].models[i] != MI_MALE01)
+			if (CPopulation::ms_pPedGroups[ms_currentPedGrp].models[i] != MI_MALE01) {
 				SetModelIsDeletable(CPopulation::ms_pPedGroups[ms_currentPedGrp].models[i]);
+				SetModelTxdIsDeletable(CPopulation::ms_pPedGroups[ms_currentPedGrp].models[i]);
+			}
 		}
 
-	for(i = 0; i < NUM_GANGS; i++){
-		SetModelIsDeletable(MI_GANG01 + i*2);
-		SetModelIsDeletable(MI_GANG01 + i*2 + 1);
-		if(CGangs::GetGangInfo(i)->m_nVehicleMI != -1)
-			SetModelIsDeletable(CGangs::GetGangInfo(i)->m_nVehicleMI);
+	CStreaming::RequestModel(MI_MALE01, STREAMFLAGS_DONT_REMOVE);
+	CStreaming::RequestModel(MI_TAXI_D, STREAMFLAGS_DONT_REMOVE);
+
+	for (i = 0; i < NUM_GANGS; i++) {
+		if (CGangs::GetGangPedModel1(i) != -1) {
+			SetModelIsDeletable(CGangs::GetGangPedModel1(i));
+			SetModelTxdIsDeletable(CGangs::GetGangPedModel1(i));
+		}
+		if (CGangs::GetGangPedModel2(i) != -1) {
+			SetModelIsDeletable(CGangs::GetGangPedModel2(i));
+			SetModelTxdIsDeletable(CGangs::GetGangPedModel2(i));
+		}
+		if (CGangs::GetGangVehicleModel(i) != -1) {
+			SetModelIsDeletable(CGangs::GetGangVehicleModel(i));
+			SetModelTxdIsDeletable(CGangs::GetGangVehicleModel(i));
+		}
 	}
 
 	ms_currentPedGrp = -1;
@@ -1469,6 +1598,42 @@ CStreaming::RemoveCurrentZonesModels(void)
 	ms_loadedGangCars = 0;
 }
 
+void
+CStreaming::LoadBigBuildingsWhenNeeded(void)
+{
+	// Very much like CCollision::Update and CCollision::LoadCollisionWhenINeedIt
+	if(CCutsceneMgr::IsCutsceneProcessing())
+		return;
+
+	if(CTheZones::m_CurrLevel == LEVEL_GENERIC || 
+	   CTheZones::m_CurrLevel == CGame::currLevel)
+		return;
+
+	CTimer::Suspend();
+	CGame::currLevel = CTheZones::m_CurrLevel;
+	DMAudio.SetEffectsFadeVol(0);
+	CPad::StopPadsShaking();
+	CCollision::LoadCollisionScreen(CGame::currLevel);
+	DMAudio.Service();
+
+	// CPopulation::DealWithZoneChange is unused in VC
+	RemoveUnusedBigBuildings(CGame::currLevel);
+	RemoveUnusedBuildings(CGame::currLevel);
+	RemoveUnusedModelsInLoadedList();
+	CGame::TidyUpMemory(true, true);
+
+	CReplay::EmptyReplayBuffer();
+	if(CGame::currLevel != LEVEL_GENERIC)
+		LoadSplash(GetLevelSplashScreen(CGame::currLevel));
+
+	CStreaming::RequestBigBuildings(CGame::currLevel, TheCamera.GetPosition());
+	CStreaming::LoadAllRequestedModels(true);
+
+	CGame::TidyUpMemory(true, true);
+	CTimer::Resume();
+	DMAudio.SetEffectsFadeVol(127);
+}
+
 
 // Find starting offset of the cdimage we next want to read
 // Not useful at all on PC...
@@ -1515,6 +1680,7 @@ ModelNotLoaded(int32 modelId)
 }
 
 inline bool TxdNotLoaded(int32 txdId) { return ModelNotLoaded(txdId + STREAM_OFFSET_TXD); }
+inline bool AnimNotLoaded(int32 animId) { return animId != -1 && ModelNotLoaded(animId + STREAM_OFFSET_ANIM); }
 
 // Find stream id of next requested file in cdimage
 int32
@@ -1539,14 +1705,20 @@ CStreaming::GetNextFileOnCd(int32 lastPosn, bool priority)
 		if(priority && ms_numPriorityRequests != 0 && !si->IsPriority())
 			continue;
 
-		// request Txd if necessary
+		// request Txds or anims if necessary
 		if(streamId < STREAM_OFFSET_TXD){
 			int txdId = CModelInfo::GetModelInfo(streamId)->GetTxdSlot();
 			if(TxdNotLoaded(txdId)){
 				ReRequestTxd(txdId);
 				continue;
 			}
-		}
+			int animId = CModelInfo::GetModelInfo(streamId)->GetAnimFileIndex();
+			if(AnimNotLoaded(animId)){
+				ReRequestAnim(animId);
+				continue;
+			}
+		}else if(streamId >= STREAM_OFFSET_ANIM && CCutsceneMgr::IsCutsceneProcessing())
+			continue;
 
 		if(ms_aInfoForModel[streamId].GetCdPosnAndSize(posn, size)){
 			if(posn < posnFirst){
@@ -1589,6 +1761,7 @@ CStreaming::GetNextFileOnCd(int32 lastPosn, bool priority)
  * TODO: two-part files
  */
 
+//--MIAMI: done
 // Make channel read from disc
 void
 CStreaming::RequestModelStream(int32 ch)
@@ -1603,13 +1776,18 @@ CStreaming::RequestModelStream(int32 ch)
 	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))
+	// remove Txds and Anims that aren't requested anymore
+	while(streamId != -1){
+		if(ms_aInfoForModel[streamId].m_flags & STREAMFLAGS_KEEP_IN_MEMORY)
+			break;
+		if(streamId >= STREAM_OFFSET_TXD && streamId < STREAM_OFFSET_COL){
+			if(IsTxdUsedByRequestedModels(streamId - STREAM_OFFSET_TXD))
+				break;
+		}else if(streamId >= STREAM_OFFSET_ANIM){
+			assert(streamId < NUMSTREAMINFO);
+			if(AreAnimsUsedByRequestedModels(streamId - STREAM_OFFSET_ANIM))
+				break;
+		}else
 			break;
 		RemoveModel(streamId);
 		// so try next file
@@ -1646,7 +1824,8 @@ CStreaming::RequestModelStream(int32 ch)
 		if(streamId < STREAM_OFFSET_TXD){
 			if (havePed && CModelInfo::GetModelInfo(streamId)->GetModelType() == MITYPE_PED ||
 			    haveBigFile && CModelInfo::GetModelInfo(streamId)->GetModelType() == MITYPE_VEHICLE ||
-			    TxdNotLoaded(CModelInfo::GetModelInfo(streamId)->GetTxdSlot()))
+			    TxdNotLoaded(CModelInfo::GetModelInfo(streamId)->GetTxdSlot()) ||
+			    AnimNotLoaded(CModelInfo::GetModelInfo(streamId)->GetAnimFileIndex()))
 				break;
 		}else{
 			if(haveBigFile && size > 200)
@@ -1693,6 +1872,7 @@ CStreaming::RequestModelStream(int32 ch)
 	ms_channel[ch].numTries = 0;
 }
 
+//--MIAMI: done
 // Load data previously read from disc
 bool
 CStreaming::ProcessLoadingChannel(int32 ch)
@@ -1727,10 +1907,10 @@ CStreaming::ProcessLoadingChannel(int32 ch)
 			if(id < STREAM_OFFSET_TXD && CModelInfo::GetModelInfo(id)->GetModelType() == MITYPE_VEHICLE &&
 			   ms_numVehiclesLoaded >= desiredNumVehiclesLoaded &&
 			   !RemoveLoadedVehicle() &&
-			   ((ms_aInfoForModel[id].m_flags & STREAMFLAGS_CANT_REMOVE) == 0 || GetAvailableVehicleSlot() == -1)){
+			   (CanRemoveModel(id) || GetAvailableVehicleSlot() == -1)){
 				// can't load vehicle
 				RemoveModel(id);
-				if(ms_aInfoForModel[id].m_flags & STREAMFLAGS_CANT_REMOVE)
+				if(!CanRemoveModel(id))
 					ReRequestModel(id);
 				else if(CTxdStore::GetNumRefs(CModelInfo::GetModelInfo(id)->GetTxdSlot()) == 0)
 					RemoveTxd(CModelInfo::GetModelInfo(id)->GetTxdSlot());
@@ -1762,6 +1942,7 @@ CStreaming::ProcessLoadingChannel(int32 ch)
 	return true;
 }
 
+//--MIAMI: done
 void
 CStreaming::RetryLoadFile(int32 ch)
 {
@@ -1798,6 +1979,7 @@ CStreaming::RetryLoadFile(int32 ch)
 	}
 }
 
+//--MIAMI: done
 void
 CStreaming::LoadRequestedModels(void)
 {
@@ -1822,6 +2004,7 @@ CStreaming::LoadRequestedModels(void)
 	}
 }
 
+//--MIAMI: done
 void
 CStreaming::LoadAllRequestedModels(bool priority)
 {
@@ -1875,6 +2058,7 @@ CStreaming::LoadAllRequestedModels(bool priority)
 	bInsideLoadAll = false;
 }
 
+//--MIAMI: done
 void
 CStreaming::FlushChannels(void)
 {
@@ -1896,6 +2080,7 @@ CStreaming::FlushChannels(void)
 		ProcessLoadingChannel(1);
 }
 
+//--MIAMI: done
 void
 CStreaming::FlushRequestList(void)
 {
@@ -2004,8 +2189,7 @@ CStreaming::ProcessEntitiesInSectorList(CPtrList &list, float x, float y, float
 				if(xmin < pos.x && pos.x < xmax &&
 				   ymin < pos.y && pos.y < ymax &&
 				   (CVector2D(x, y) - pos).MagnitudeSqr() < lodDistSq)
-					if(CRenderer::IsEntityCullZoneVisible(e))
-						RequestModel(e->GetModelIndex(), 0);
+					RequestModel(e->GetModelIndex(), 0);
 			}
 		}
 	}
@@ -2028,8 +2212,7 @@ CStreaming::ProcessEntitiesInSectorList(CPtrList &list)
 		   (!e->IsObject() || ((CObject*)e)->ObjectCreatedBy != TEMP_OBJECT)){
 			CTimeModelInfo *mi = (CTimeModelInfo*)CModelInfo::GetModelInfo(e->GetModelIndex());
 			if (mi->GetModelType() != MITYPE_TIME || CClock::GetIsTimeInRange(mi->GetTimeOn(), mi->GetTimeOff()))
-				if(CRenderer::IsEntityCullZoneVisible(e))
-					RequestModel(e->GetModelIndex(), 0);
+				RequestModel(e->GetModelIndex(), 0);
 		}
 	}
 }
@@ -2267,9 +2450,6 @@ CStreaming::DeleteRwObjectsBehindCamera(size_t mem)
 			}
 		}
 
-		if(RemoveReferencedTxds(mem))
-			return;
-
 		// As last resort, delete objects from the last step more aggressively
 		for(y = ymin; y <= ymax; y++){
 			for(x = xmax; x != xmin; x -= inc){
@@ -2331,9 +2511,6 @@ CStreaming::DeleteRwObjectsBehindCamera(size_t mem)
 			}
 		}
 
-		if(RemoveReferencedTxds(mem))
-			return;
-
 		// As last resort, delete objects from the last step more aggressively
 		for(x = xmin; x <= xmax; x++){
 			for(y = ymax; y != ymin; y -= inc){
@@ -2432,12 +2609,13 @@ CStreaming::MakeSpaceFor(int32 size)
 	// but it's not nice....
 
 	while(ms_memoryUsed >= ms_memoryAvailable - size)
-		if(!RemoveLeastUsedModel()){
+		if(!RemoveLeastUsedModel(STREAMFLAGS_20)){
 			DeleteRwObjectsBehindCamera(ms_memoryAvailable - size);
 			return;
 		}
 }
 
+//--MIAMI: done
 void
 CStreaming::LoadScene(const CVector &pos)
 {
@@ -2452,16 +2630,44 @@ CStreaming::LoadScene(const CVector &pos)
 			RemoveModel(si - ms_aInfoForModel);
 	}
 	CRenderer::m_loadingPriority = false;
-	CCullZones::ForceCullZoneCoors(pos);
 	DeleteAllRwObjects();
+	if(level == LEVEL_GENERIC)
+		level = CGame::currLevel;
+	CGame::currLevel = level;
+	RemoveUnusedBigBuildings(level);
+	RequestBigBuildings(level, pos);
+	RequestBigBuildings(LEVEL_GENERIC, pos);
+	RemoveIslandsNotUsed(level);
+	LoadAllRequestedModels(false);
+	InstanceBigBuildings(level, pos);
+	InstanceBigBuildings(LEVEL_GENERIC, pos);
 	AddModelsToRequestList(pos);
 	CRadar::StreamRadarSections(pos);
-	RemoveUnusedBigBuildings(level);
-	RequestBigBuildings(level);
+
+	if (!CGame::IsInInterior()) {
+		for (int i = 0; i < 5; i++) {
+			CZoneInfo zone;
+			CTheZones::GetZoneInfoForTimeOfDay(&pos, &zone);
+			int32 model = CCarCtrl::ChooseCarModelToLoad(CCarCtrl::ChooseCarRating(&zone));
+			CStreaming::RequestModel(model, STREAMFLAGS_DEPENDENCY);
+		}
+	}
 	LoadAllRequestedModels(false);
+	InstanceLoadedModels(pos);
+
+	for(int i = 0; i < NUMSTREAMINFO; i++)
+		ms_aInfoForModel[i].m_flags &= ~STREAMFLAGS_20;
 	debug("End load scene\n");
 }
 
+//--MIAMI: done
+void
+CStreaming::LoadSceneCollision(const CVector &pos)
+{
+	CColStore::LoadCollision(pos);
+	CStreaming::LoadAllRequestedModels(false);
+}
+
 void
 CStreaming::MemoryCardSave(uint8 *buf, uint32 *size)
 {
@@ -2493,7 +2699,8 @@ CStreaming::UpdateForAnimViewer(void)
 	if (CStreaming::ms_channelError == -1) {
 		CStreaming::AddModelsToRequestList(CVector(0.0f, 0.0f, 0.0f));
 		CStreaming::LoadRequestedModels();
-		sprintf(gString, "Requested %d, memory size %zuK\n", CStreaming::ms_numModelsRequested, 2 * CStreaming::ms_memoryUsed); // original modifier was %d
+		// original modifier was %d
+		sprintf(gString, "Requested %d, memory size %zuK\n", CStreaming::ms_numModelsRequested, 2 * CStreaming::ms_memoryUsed);
 	}
 	else {
 		CStreaming::RetryLoadFile(CStreaming::ms_channelError);