a3x
/
re3
mirror of https://git.rip/DMCA_FUCKER/re3.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

colstore done

This commit is contained in:
aap 2021-01-23 12:40:23 +01:00
parent 552497d71b
commit 20bcd4bd69
9 changed files with 234 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
src/collision/ColStore.cpp
View File

@ -1,5 +1,7 @@
#include "common.h"
#include "main.h"
#include "smallHeap.h"
#include "templates.h"
#include "General.h"
#include "ModelInfo.h"
@ -8,6 +10,9 @@
#include "Script.h"
#include "Timer.h"
#include "Camera.h"
#include "World.h"
#include "Zones.h"
#include "Garages.h"
#include "Frontend.h"
#include "Physical.h"
#include "ColStore.h"
@ -15,16 +20,55 @@
#include "Pools.h"
CPool<ColDef,ColDef> *CColStore::ms_pColPool;
bool CColStore::m_onlyBB;
#ifndef MASTER
bool bDispColInMem;
#endif
// LCS: file done except unused:
// CColStore::LoadCol(int,char const*)
// CColStore::LoadAllBoundingBoxes(void)
// CColStore::Write(base::cRelocatableChunkWriter &)
const CVector&
LevelPos(eLevelName level)
{
static CVector pos[4] = {
CVector(1060.0f, -800.0f, 0.0f),
CVector(1060.0f, -800.0f, 0.0f),
CVector(350.0f, -624.0f, 0.0f),
CVector(-670.0f, -511.0f, 0.0f)
};
return pos[level];
};
static eLevelName
PosLevel(const CVector &pos)
{
static eLevelName lastPlayerLevel = LEVEL_INDUSTRIAL;
static eLevelName lastOtherLevel = LEVEL_INDUSTRIAL;
if(Abs(FindPlayerCoors().x - pos.x) < 5.0f &&
Abs(FindPlayerCoors().y - pos.y) < 5.0f &&
Abs(FindPlayerCoors().z - pos.z) < 5.0f){
if(CGame::currLevel != LEVEL_GENERIC)
lastPlayerLevel = CGame::currLevel;
return lastPlayerLevel;
}else{
eLevelName lvl = CTheZones::GetLevelFromPosition(&pos);
if(lvl != LEVEL_GENERIC)
lastOtherLevel = lvl;
return lastOtherLevel;
}
}
void
CColStore::Initialise(void)
{
if(ms_pColPool == nil)
if(ms_pColPool == nil){
ms_pColPool = new CPool<ColDef,ColDef>(COLSTORESIZE, "CollisionFiles");
AddColSlot("generic"); // slot 0. not streamed
AddColSlot("generic"); // slot 0. not streamed
}
#ifndef MASTER
VarConsole.Add("Display collision in memory", &bDispColInMem, true);
#endif
@ -38,7 +82,9 @@ CColStore::Shutdown(void)
RemoveColSlot(i);
if(ms_pColPool)
delete ms_pColPool;
#ifdef FIX_BUGS
ms_pColPool = nil;
#endif
}
int
@ -119,11 +165,34 @@ CColStore::LoadCol(int32 slot, uint8 *buffer, int32 bufsize)
return success;
}
struct ColChunkEntry
{
int32 modelId; // -1 marks end
CColModel *colModel;
};
void
CColStore::LoadColCHK(int32 slot, void *data, void *chunk)
{
ColDef *def = GetSlot(slot);
def->chunk = chunk;
CStreaming::RegisterPointer(&def->chunk, 1, true);
for(ColChunkEntry *entry = (ColChunkEntry*)data; entry->modelId != -1; entry++){
CBaseModelInfo *mi = CModelInfo::GetModelInfo(entry->modelId);
mi->SetColModel(entry->colModel, true); // we own this? can that work?
CStreaming::RegisterPointer(&mi->m_colModel, 1, true);
}
def->isLoaded = true;
}
CColModel nullCollision;
void
CColStore::RemoveCol(int32 slot)
{
int id;
GetSlot(slot)->isLoaded = false;
ColDef *def = GetSlot(slot);
def->isLoaded = false;
for(id = 0; id < MODELINFOSIZE; id++){
CBaseModelInfo *mi = CModelInfo::GetModelInfo(id);
if(mi){
@ -132,6 +201,23 @@ CColStore::RemoveCol(int32 slot)
col->RemoveCollisionVolumes();
}
}
if(gUseChunkFiles){
for(id = 0; id < MODELINFOSIZE; id++){
CBaseModelInfo *mi = CModelInfo::GetModelInfo(id);
if(mi){
CColModel *col = mi->GetColModel();
if(col && col->level == slot){
mi->SetColModel(&nullCollision);
CStreaming::UnregisterPointer(&mi->m_colModel, 1);
}
}
}
if(def->chunk){
CStreaming::UnregisterPointer(&def->chunk, 1);
cSmallHeap::msInstance.Free(def->chunk);
def->chunk = nil;
}
}
}
void
@ -156,29 +242,49 @@ CColStore::RemoveAllCollision(void)
}
static bool bLoadAtSecondPosition;
static CVector2D secondPosition;
static CVector secondPosition;
void
CColStore::AddCollisionNeededAtPosn(const CVector2D &pos)
CColStore::AddCollisionNeededAtPosn(const CVector &pos)
{
bLoadAtSecondPosition = true;
secondPosition = pos;
}
void
CColStore::LoadCollision(const CVector2D &pos)
CColStore::LoadCollision(const CVector &pos, eLevelName level)
{
int i;
if(CStreaming::ms_disableStreaming)
return;
if(level == LEVEL_GENERIC)
level = PosLevel(pos);
eLevelName allowedLevel = (eLevelName)CTheScripts::AllowedCollision[0];
if(allowedLevel == LEVEL_GENERIC)
allowedLevel = (eLevelName)CTheScripts::AllowedCollision[1];
bool requestedSomething = false;
for(i = 1; i < COLSTORESIZE; i++){
if(GetSlot(i) == nil)
if(GetSlot(i) == nil || !DoScriptsWantThisIn(i))
continue;
bool wantThisOne = false;
if(strcmp(GetColName(i), "indust") == 0){
if(allowedLevel != LEVEL_GENERIC && level != LEVEL_INDUSTRIAL)
wantThisOne = allowedLevel == LEVEL_INDUSTRIAL;
else
wantThisOne = level == LEVEL_INDUSTRIAL;
}else if(GetBoundingBox(i).IsPointInside(LevelPos(level)))
wantThisOne = true;
else if(allowedLevel != LEVEL_GENERIC && GetBoundingBox(i).IsPointInside(LevelPos(allowedLevel)))
wantThisOne = true;
/* // LCS: removed
if(GetBoundingBox(i).IsPointInside(pos) ||
bLoadAtSecondPosition && GetBoundingBox(i).IsPointInside(secondPosition, -119.0f) ||
strcmp(GetColName(i), "yacht") == 0){
@ -203,28 +309,38 @@ CColStore::LoadCollision(const CVector2D &pos)
}
}
}
*/
if(wantThisOne)
if(wantThisOne){
CStreaming::RequestCol(i, STREAMFLAGS_PRIORITY);
else
requestedSomething = true;
}else
CStreaming::RemoveCol(i);
}
if(requestedSomething){
CTimer::Suspend();
// BUG? request was done with priority but now loading non-priority?
CStreaming::LoadAllRequestedModels(false);
CGarages::SetupAnyGaragesForThisIsland();
CTimer::Resume();
}
bLoadAtSecondPosition = false;
}
void
CColStore::RequestCollision(const CVector2D &pos)
CColStore::RequestCollision(const CVector &pos)
{
int i;
for(i = 1; i < COLSTORESIZE; i++)
if(GetSlot(i) && GetBoundingBox(i).IsPointInside(pos, -115.0f))
if(GetSlot(i) && DoScriptsWantThisIn(i) && GetBoundingBox(i).IsPointInside(LevelPos(PosLevel(pos)), -115.0f))
CStreaming::RequestCol(i, STREAMFLAGS_PRIORITY);
}
void
CColStore::EnsureCollisionIsInMemory(const CVector2D &pos)
CColStore::EnsureCollisionIsInMemory(const CVector &pos)
{
/* // LCS: removed
int i;
if(CStreaming::ms_disableStreaming)
@ -240,16 +356,48 @@ CColStore::EnsureCollisionIsInMemory(const CVector2D &pos)
CStreaming::LoadAllRequestedModels(false);
CTimer::Resume();
}
*/
}
bool
CColStore::HasCollisionLoaded(const CVector2D &pos)
CColStore::DoScriptsWantThisIn(int32 slot)
{
if(slot == 0)
return false;
ColDef *coldef = GetSlot(slot);
if(coldef == nil)
return false;
if(strcmp(coldef->name, "fortstaunton") == 0)
return !CTheScripts::IsFortStauntonDestroyed();
if(strcmp(coldef->name, "fortdestroyed") == 0)
return CTheScripts::IsFortStauntonDestroyed();
return true;
}
bool
CColStore::HasCollisionLoaded(eLevelName level)
{
int i;
const CVector &pos = LevelPos(level);
for(i = 1; i < COLSTORESIZE; i++)
if(GetSlot(i) && GetBoundingBox(i).IsPointInside(pos, -115.0f) &&
if(GetSlot(i) && DoScriptsWantThisIn(i) &&
(!CGeneral::faststricmp(GetColName(i), "indust") && level == LEVEL_INDUSTRIAL ||
GetBoundingBox(i).IsPointInside(pos)) &&
!GetSlot(i)->isLoaded)
return false;
return true;
}
bool
CColStore::HasCollisionLoaded(const CVector &pos)
{
return HasCollisionLoaded(PosLevel(pos));
}
void
CColStore::Load(bool onlyBB, CPool<ColDef> *pool)
{
ms_pColPool = pool;
m_onlyBB = onlyBB;
}

17
src/collision/ColStore.h
View File

@ -9,11 +9,13 @@ struct ColDef { // made up name
char name[20];
int16 minIndex;
int16 maxIndex;
void *chunk;
};
class CColStore
{
static CPool<ColDef,ColDef> *ms_pColPool;
static bool m_onlyBB;
public:
static void Initialise(void);
@ -25,15 +27,18 @@ public:
static CRect &GetBoundingBox(int32 slot);
static void IncludeModelIndex(int32 slot, int32 modelIndex);
static bool LoadCol(int32 storeID, uint8 *buffer, int32 bufsize);
static void LoadColCHK(int32 slot, void *data, void *chunk);
static void RemoveCol(int32 slot);
static void AddCollisionNeededAtPosn(const CVector2D &pos);
static void AddCollisionNeededAtPosn(const CVector &pos);
static void LoadAllCollision(void);
static void RemoveAllCollision(void);
static void LoadCollision(const CVector2D &pos);
static void RequestCollision(const CVector2D &pos);
static void EnsureCollisionIsInMemory(const CVector2D &pos);
static bool HasCollisionLoaded(const CVector2D &pos);
static bool HasCollisionLoaded(eLevelName level) { return true; }; // TODO
static void LoadCollision(const CVector &pos, eLevelName level = LEVEL_GENERIC);
static void RequestCollision(const CVector &pos);
static void EnsureCollisionIsInMemory(const CVector &pos);
static bool DoScriptsWantThisIn(int32 slot);
static bool HasCollisionLoaded(eLevelName level);
static bool HasCollisionLoaded(const CVector &pos);
static void Load(bool, CPool<ColDef> *pool);
static ColDef *GetSlot(int slot) {
assert(slot >= 0);

2
src/control/Garages.h
View File

@ -293,4 +293,6 @@ public:
}
static bool IsThisGarageTypeSafehouse(uint8 type) { return FindSafeHouseIndexForGarageType(type) >= 0; }
static void SetupAnyGaragesForThisIsland(void) {} // TODO(LCS)
};

2
src/control/Script.h
View File

@ -485,7 +485,7 @@ public:
static void SetObjectiveForAllPedsInCollective(int, eObjective);
#endif
bool IsFortStauntonDestroyed() { return *(int32*)&ScriptSpace[FSDestroyedFlag] == 1; }
static bool IsFortStauntonDestroyed() { return FSDestroyedFlag && *(int32*)&ScriptSpace[FSDestroyedFlag] == 1; }
};

3
src/control/Script7.cpp
View File

@ -423,9 +423,10 @@ int8 CRunningScript::ProcessCommands1200To1299(int32 command)
case COMMAND_REQUEST_COLLISION:
{
CollectParameters(&m_nIp, 2);
CVector2D pos;
CVector pos;
pos.x = GET_FLOAT_PARAM(0);
pos.y = GET_FLOAT_PARAM(1);
pos.z = 0.0f;
CColStore::RequestCollision(pos);
return 0;
}

40
src/core/Streaming.cpp
View File

@ -3150,6 +3150,46 @@ CStreaming::LoadSceneCollision(const CVector &pos)
CStreaming::LoadAllRequestedModels(false);
}
//--LCS: TODO PSP and PS2
// some things commented out that might be Rsl3D dependent
void CStreaming::RegisterPointer(void *ptr, int, bool) {}
RpAtomic *CStreaming::RegisterAtomic(RpAtomic *atomic, void *)
{
return atomic;
}
void CStreaming::RegisterClump(RpClump *clump)
{
RpClumpForAllAtomics(clump, RegisterAtomic, nil);
}
RpAtomic *CStreaming::RegisterInstance(RpAtomic *atomic, void *)
{
// RegisterPointer(&atomic->geometry, 2, true);
return atomic;
}
void CStreaming::RegisterInstance(RpClump *clump)
{
RpClumpForAllAtomics(clump, RegisterInstance, nil);
}
void CStreaming::UnregisterPointer(void *ptr, int) {}
RpAtomic *CStreaming::UnregisterAtomic(RpAtomic *atomic, void *)
{
return atomic;
}
void CStreaming::UnregisterClump(RpClump *clump)
{
RpClumpForAllAtomics(clump, UnregisterAtomic, nil);
}
RpAtomic *CStreaming::UnregisterInstance(RpAtomic *atomic, void *)
{
// UnregisterPointer(&atomic->geometry, 2);
return atomic;
}
void CStreaming::UnregisterInstance(RpClump *clump)
{
RpClumpForAllAtomics(clump, UnregisterInstance, nil);
}
void
CStreaming::MemoryCardSave(uint8 *buf, uint32 *size)
{

12
src/core/Streaming.h
View File

@ -20,6 +20,7 @@ enum StreamFlags
STREAMFLAGS_40 = 0x40, // TODO(LCS): what's this
STREAMFLAGS_AMBIENT_SCRIPT_OWNED = 0x80,
// TODO(LCS): STREAMFLAGS_AMBIENT_SCRIPT_OWNED in STREAMFLAGS_CANT_REMOVE? check CColStore
STREAMFLAGS_CANT_REMOVE = STREAMFLAGS_DONT_REMOVE|STREAMFLAGS_SCRIPTOWNED,
STREAMFLAGS_KEEP_IN_MEMORY = STREAMFLAGS_DONT_REMOVE|STREAMFLAGS_SCRIPTOWNED|STREAMFLAGS_DEPENDENCY,
};
@ -209,6 +210,17 @@ public:
static void LoadScene(const CVector &pos);
static void LoadSceneCollision(const CVector &pos);
static void RegisterPointer(void *ptr, int, bool);
static RpAtomic *RegisterAtomic(RpAtomic *atomic, void *);
static void RegisterClump(RpClump *clump);
static RpAtomic *RegisterInstance(RpAtomic *atomic, void *);
static void RegisterInstance(RpClump *clump);
static void UnregisterPointer(void *ptr, int);
static RpAtomic *UnregisterAtomic(RpAtomic *atomic, void *);
static void UnregisterClump(RpClump *clump);
static RpAtomic *UnregisterInstance(RpAtomic *atomic, void *);
static void UnregisterInstance(RpClump *clump);
static void MemoryCardSave(uint8 *buffer, uint32 *length);
static void MemoryCardLoad(uint8 *buffer, uint32 length);

2
src/modelinfo/BaseModelInfo.h
View File

@ -29,7 +29,9 @@ protected:
uint8 m_type;
uint8 m_num2dEffects;
bool m_bOwnsColModel;
public: // need this in colstore
CColModel *m_colModel;
protected:
int16 m_2dEffectsID;
int16 m_objectId;
uint16 m_refCount;

4
src/render/SpecialFX.cpp
View File

@ -877,7 +877,7 @@ C3dMarkers::PlaceMarker(uint32 identifier, uint16 type, CVector &pos, float size
pMarker->m_Matrix.GetPosition() = pos;
if (pMarker->m_bFindZOnNextPlacement) {
if ((playerPos - pos).MagnitudeSqr() < sq(100.f) && CColStore::HasCollisionLoaded(CVector2D(pos))) {
if ((playerPos - pos).MagnitudeSqr() < sq(100.f) && CColStore::HasCollisionLoaded(pos)) {
float z = CWorld::FindGroundZFor3DCoord(pos.x, pos.y, pos.z + 1.0f, nil);
if (z != 0.0f)
pMarker->m_Matrix.GetPosition().z = z - 0.05f * size;
@ -893,7 +893,7 @@ C3dMarkers::PlaceMarker(uint32 identifier, uint16 type, CVector &pos, float size
pMarker->AddMarker(identifier, type, size, r, g, b, a, pulsePeriod, pulseFraction, rotateRate);
if (type == MARKERTYPE_CYLINDER || type == MARKERTYPE_0 || type == MARKERTYPE_2) {
if ((playerPos - pos).MagnitudeSqr() < sq(100.f) && CColStore::HasCollisionLoaded(CVector2D(pos))) {
if ((playerPos - pos).MagnitudeSqr() < sq(100.f) && CColStore::HasCollisionLoaded(pos)) {
float z = CWorld::FindGroundZFor3DCoord(pos.x, pos.y, pos.z + 1.0f, nil);
if (z != 0.0f)
pos.z = z - 0.05f * size;