summaryrefslogtreecommitdiffstats
path: root/src/Streaming.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/Streaming.cpp')
-rw-r--r--src/Streaming.cpp1009
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);