478 lines
15 KiB
C++
478 lines
15 KiB
C++
//
|
|
// scene/LoadScene.cpp
|
|
//
|
|
// Copyright (C) 1999-2014 Rockstar Games. All Rights Reserved.
|
|
//
|
|
|
|
#include "scene/LoadScene.h"
|
|
|
|
#include "fwscene/stores/maptypesstore.h"
|
|
#include "streaming/streaming.h"
|
|
#include "Objects/objectpopulation.h"
|
|
#include "scene/streamer/StreamVolume.h"
|
|
#include "script/gta_thread.h"
|
|
#include "script/script.h"
|
|
#include "camera/CamInterface.h"
|
|
#include "renderer/Lights/LightEntity.h"
|
|
|
|
CLoadScene g_LoadScene;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
#if __BANK
|
|
#include "camera/CamInterface.h"
|
|
#include "grcore/debugdraw.h"
|
|
|
|
static const char* apszDbgStateNames[] =
|
|
{
|
|
"STATE_PROBE_INTERIOR_PHYSICS",
|
|
"STATE_POPULATING_INTERIOR",
|
|
"STATE_STREAMINGVOLUME"
|
|
};
|
|
|
|
bool CLoadScene::ms_bDbgShowInfo = false;
|
|
bool CLoadScene::ms_bDbgUseFrustum = false;
|
|
bool CLoadScene::ms_bDbgLoadCollision = false;
|
|
bool CLoadScene::ms_bDbgLongSwitchCutscene = false;
|
|
float CLoadScene::ms_fDbgRange = 15.0f;
|
|
atString CLoadScene::ms_dbgScriptName;
|
|
#endif //__BANK
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: Start
|
|
// PURPOSE: starts a new load scene at the specified position
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::Start(Vec3V_In vPos, Vec3V_In vDir, float fRange, bool bUseFrustum, s32 controlFlags, eLoadSceneOwner owner)
|
|
{
|
|
streamDisplayf("Starting new load scene at -playercoords %4.2f,%4.2f,%4.2f", vPos.GetXf(), vPos.GetYf(), vPos.GetZf());
|
|
|
|
#if STREAMING_VISUALIZE
|
|
char markerText[256];
|
|
const char *origin = "unknown";
|
|
|
|
#if __BANK
|
|
origin = m_bOwnedByScript? ms_dbgScriptName.c_str() : "Code";
|
|
#endif // __BANK
|
|
|
|
formatf(markerText, "New LoadScene from %s at %.2f, %.2f %.2f", origin, vPos.GetXf(), vPos.GetYf(), vPos.GetZf());
|
|
STRVIS_SET_MARKER_TEXT(markerText);
|
|
STRVIS_ADD_MARKER(strStreamingVisualize::MARKER);
|
|
STRVIS_ADD_CALLSTACK_TO_MARKER();
|
|
#endif // STREAMING_VISUALIZE
|
|
|
|
Assertf(!bUseFrustum || !IsEqualAll(vDir, Vec3V(V_ZERO)) , "vDir should be nonzero");
|
|
|
|
if (m_bActive)
|
|
{
|
|
#if __BANK
|
|
Warningf( "Starting a new load scene, but one is already active at -playercoords %4.2f,%4.2f,%4.2f owned by %s",
|
|
vPos.GetXf(), vPos.GetYf(), vPos.GetZf(),
|
|
( m_bOwnedByScript? ms_dbgScriptName.c_str() : "CODE" )
|
|
);
|
|
#endif //__BANK
|
|
|
|
Stop();
|
|
}
|
|
|
|
m_owner = owner;
|
|
m_controlFlags = controlFlags;
|
|
m_bUseFrustum = bUseFrustum;
|
|
m_bUseCameraMatrix = false;
|
|
m_bUseOverriddenAssetRequirements = false;
|
|
m_fRange = fRange;
|
|
m_bOwnedByScript = false;
|
|
m_bActive = true;
|
|
m_vPos = vPos;
|
|
m_vDir = vDir;
|
|
m_pInteriorProxy = NULL;
|
|
m_roomIdx = -1;
|
|
m_eCurrentState = STATE_PROBE_INTERIOR_PHYSICS;
|
|
STRVIS_SET_MARKER_TEXT("LoadScene - start probing interior physics");
|
|
|
|
strStreamingEngine::SetLoadSceneActive(true);
|
|
|
|
CObjectPopulation::FlushAllSuppressedDummyObjects();
|
|
|
|
CStreaming::RequestRenderThreadFlush();
|
|
|
|
if (camInterface::IsFadedOut())
|
|
{
|
|
LightEntityMgr::Flush();
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: StartFromScript
|
|
// PURPOSE: starts a new load scene at specified position, owned by the specified script
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::StartFromScript(Vec3V_In vPos, Vec3V_In vDir, float fRange, scrThreadId scriptThreadId, bool bUseFrustum, s32 controlFlags/*=0*/)
|
|
{
|
|
streamDisplayf("Script %s requesting new load scene", GtaThread::GetThreadWithThreadId(scriptThreadId)->GetScriptName());
|
|
|
|
Assertf(
|
|
!bUseFrustum || !IsEqualAll(vDir, Vec3V(V_ZERO)),
|
|
"Script %s started new load scene with invalid camera direction (should be nonzero)",
|
|
GtaThread::GetThreadWithThreadId(scriptThreadId)->GetScriptName()
|
|
);
|
|
|
|
#if STREAMING_VISUALIZE
|
|
char markerText[256];
|
|
formatf(markerText, "LoadScene from %s: ", GtaThread::GetThreadWithThreadId(scriptThreadId)->GetScriptName());
|
|
STRVIS_SET_MARKER_TEXT(markerText);
|
|
formatf(markerText, "(%s)", CTheScripts::GetCurrentScriptNameAndProgramCounter());
|
|
STRVIS_SET_MARKER_TEXT(markerText);
|
|
#endif // STREAMING_VISUALIZE
|
|
|
|
Start(vPos, vDir, fRange, bUseFrustum, controlFlags, LOADSCENE_OWNER_SCRIPT);
|
|
SetScriptThreadId(scriptThreadId);
|
|
|
|
#if __BANK
|
|
ms_dbgScriptName = GtaThread::GetThreadWithThreadId(scriptThreadId)->GetScriptName();
|
|
#endif
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: Update
|
|
// PURPOSE: returns true if still running, false otherwise
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::Update()
|
|
{
|
|
if (m_bActive)
|
|
{
|
|
switch (m_eCurrentState)
|
|
{
|
|
case STATE_PROBE_INTERIOR_PHYSICS:
|
|
UpdateProbeInteriorPhysics();
|
|
break;
|
|
case STATE_POPULATING_INTERIOR:
|
|
UpdatePopulatingInterior();
|
|
break;
|
|
case STATE_STREAMINGVOLUME:
|
|
UpdateStreamingVolume();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: IsLoaded
|
|
// PURPOSE: returns true if there is an active load scene and all requirements are in memory
|
|
//////////////////////////////////////////////////////////////////////////
|
|
bool CLoadScene::IsLoaded()
|
|
{
|
|
if (m_bActive && m_eCurrentState==STATE_STREAMINGVOLUME)
|
|
{
|
|
return CStreamVolumeMgr::HasLoaded( CStreamVolumeMgr::VOLUME_SLOT_PRIMARY );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: Stop
|
|
// PURPOSE: ends load scene and releases any resources
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::Stop()
|
|
{
|
|
if (!m_bActive)
|
|
return;
|
|
|
|
STRVIS_SET_MARKER_TEXT("LoadScene ends");
|
|
|
|
if (CStreamVolumeMgr::IsVolumeActive( CStreamVolumeMgr::VOLUME_SLOT_PRIMARY ))
|
|
{
|
|
CStreamVolumeMgr::Deregister( CStreamVolumeMgr::VOLUME_SLOT_PRIMARY );
|
|
}
|
|
|
|
if (m_pInteriorProxy)
|
|
{
|
|
m_pInteriorProxy->SetRequiredByLoadScene(false);
|
|
m_pInteriorProxy->SetRequestedState( CInteriorProxy::RM_LOADSCENE, CInteriorProxy::PS_NONE, true);
|
|
m_pInteriorProxy->ReleaseStaticBoundsFile();
|
|
m_pInteriorProxy->UpdateImapPinState();
|
|
}
|
|
|
|
m_bActive = false;
|
|
|
|
//if ( m_owner != LOADSCENE_OWNER_PLAYERSWITCH ) // player switch takes responsibilty for clearing loadscene flags
|
|
{
|
|
strStreamingEngine::GetInfo().ClearFlagForAll(STRFLAG_LOADSCENE);
|
|
}
|
|
|
|
strStreamingEngine::SetLoadSceneActive(false);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: UpdateProbeInteriorPhysics
|
|
// PURPOSE:
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::UpdateProbeInteriorPhysics()
|
|
{
|
|
Vector3 vCurrentPos = VEC3V_TO_VECTOR3(m_vPos);
|
|
CInteriorProxy* pIntProxy = NULL;
|
|
bool bKnownResult = CInteriorInst::RequestInteriorAtLocation(vCurrentPos, pIntProxy, m_roomIdx);
|
|
|
|
if (pIntProxy)
|
|
{
|
|
m_pInteriorProxy = pIntProxy;
|
|
}
|
|
|
|
if (bKnownResult)
|
|
{
|
|
if (m_pInteriorProxy)
|
|
{
|
|
StartPopulatingInterior();
|
|
}
|
|
else
|
|
{
|
|
StartStreamingForExterior();
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: UpdatePopulatingInterior
|
|
// PURPOSE:
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::UpdatePopulatingInterior()
|
|
{
|
|
if (m_pInteriorProxy && m_pInteriorProxy->GetCurrentState()== CInteriorProxy::PS_FULL_WITH_COLLISIONS)
|
|
{
|
|
StartStreamingForInterior();
|
|
} else
|
|
{
|
|
Displayf("*** WAITING FOR INTERIOR TO POPULATE! (%s - CurrentState:%d RequestedState:%d ImapActive:%i IsDisabled:%i IsCapped:%i) ***",
|
|
m_pInteriorProxy->GetName().TryGetCStr(),
|
|
m_pInteriorProxy->GetCurrentState(),
|
|
m_pInteriorProxy->GetRequestedState(CInteriorProxy::RM_LOADSCENE),
|
|
m_pInteriorProxy->IsContainingImapActive(),
|
|
m_pInteriorProxy->GetIsDisabled(),
|
|
m_pInteriorProxy->GetIsCappedAtPartial() );
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: UpdateStreamingVolume
|
|
// PURPOSE:
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::UpdateStreamingVolume()
|
|
{
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: StartStreamingForExteriors
|
|
// PURPOSE: creates a streaming volume for exterior map streaming
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::StartStreamingForExterior()
|
|
{
|
|
STRVIS_SET_MARKER_TEXT("LoadScene - start streaming for exterior");
|
|
m_eCurrentState = STATE_STREAMINGVOLUME;
|
|
|
|
// make sure there is no volume already running
|
|
CStreamVolumeMgr::Deregister(CStreamVolumeMgr::VOLUME_SLOT_PRIMARY);
|
|
|
|
fwBoxStreamerAssetFlags assetFlags = m_bUseOverriddenAssetRequirements ? m_overrideAssetFlags : fwBoxStreamerAsset::MASK_MAPDATA;
|
|
if ((m_controlFlags & FLAG_INCLUDE_COLLISION)!=0)
|
|
{
|
|
assetFlags |= fwBoxStreamerAsset::FLAG_STATICBOUNDS_MOVER;
|
|
}
|
|
|
|
const bool bLongSwitchCutscene = ((m_controlFlags & FLAG_LONGSWITCH_CUTSCENE) != 0);
|
|
|
|
if (m_bUseFrustum)
|
|
{
|
|
CStreamVolumeMgr::RegisterFrustum(m_vPos, m_vDir, m_fRange, assetFlags, true, CStreamVolumeMgr::VOLUME_SLOT_PRIMARY, bLongSwitchCutscene);
|
|
|
|
if (m_bUseCameraMatrix)
|
|
{
|
|
CStreamVolume& volume = CStreamVolumeMgr::GetVolume(CStreamVolumeMgr::VOLUME_SLOT_PRIMARY);
|
|
volume.SetCameraMtx(m_rageCameraMatrix);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
spdSphere searchVolume(m_vPos, ScalarV(m_fRange));
|
|
CStreamVolumeMgr::RegisterSphere(searchVolume, assetFlags, true, CStreamVolumeMgr::VOLUME_SLOT_PRIMARY, bLongSwitchCutscene, true);
|
|
}
|
|
|
|
// for long switches in the middle of a cutscene, only stream high detail
|
|
if (bLongSwitchCutscene)
|
|
{
|
|
CStreamVolume& volume = CStreamVolumeMgr::GetVolume( CStreamVolumeMgr::VOLUME_SLOT_PRIMARY );
|
|
volume.SetLodMask( LODTYPES_FLAG_HD | LODTYPES_FLAG_ORPHANHD );
|
|
}
|
|
else if (m_bUseOverriddenAssetRequirements)
|
|
{
|
|
CStreamVolume& volume = CStreamVolumeMgr::GetVolume( CStreamVolumeMgr::VOLUME_SLOT_PRIMARY );
|
|
volume.SetLodMask( m_overrideLodMask );
|
|
}
|
|
|
|
#if !__FINAL
|
|
if (m_bOwnedByScript)
|
|
{
|
|
CStreamVolumeMgr::SetVolumeScriptInfo(
|
|
m_scriptThreadId,
|
|
( GtaThread::GetThreadWithThreadId(m_scriptThreadId)
|
|
? GtaThread::GetThreadWithThreadId(m_scriptThreadId)->GetScriptName()
|
|
: "<not running>" )
|
|
);
|
|
}
|
|
#endif //!__FINAL
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: StartPopulatingInterior
|
|
// PURPOSE: start firing up an interior, may involve some streaming in the future
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::StartPopulatingInterior()
|
|
{
|
|
STRVIS_SET_MARKER_TEXT("LoadScene - start populating interior");
|
|
m_eCurrentState = STATE_POPULATING_INTERIOR;
|
|
m_pInteriorProxy->SkipShellAssetBlocking(true);
|
|
m_pInteriorProxy->SetRequestedState( CInteriorProxy::RM_LOADSCENE, CInteriorProxy::PS_FULL_WITH_COLLISIONS, true);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: StartStreamingForInterior
|
|
// PURPOSE: creates a streaming volume for interior streaming
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::StartStreamingForInterior()
|
|
{
|
|
STRVIS_SET_MARKER_TEXT("LoadScene - start streaming interior");
|
|
m_eCurrentState = STATE_STREAMINGVOLUME;
|
|
|
|
// make sure there is no volume already running
|
|
CStreamVolumeMgr::Deregister(CStreamVolumeMgr::VOLUME_SLOT_PRIMARY);
|
|
|
|
fwBoxStreamerAssetFlags assetFlags = m_bUseOverriddenAssetRequirements ? m_overrideAssetFlags : 0;
|
|
|
|
if ((m_controlFlags & FLAG_INTERIOR_AND_EXTERIOR)!=0)
|
|
{
|
|
assetFlags |= fwBoxStreamerAsset::MASK_MAPDATA;
|
|
}
|
|
|
|
if ((m_controlFlags & FLAG_INCLUDE_COLLISION)!=0)
|
|
{
|
|
assetFlags |= fwBoxStreamerAsset::FLAG_STATICBOUNDS_MOVER;
|
|
}
|
|
|
|
const bool bLongSwitchCutscene = ((m_controlFlags & FLAG_LONGSWITCH_CUTSCENE) != 0);
|
|
|
|
if (m_bUseFrustum)
|
|
{
|
|
CStreamVolumeMgr::RegisterFrustum(m_vPos, m_vDir, m_fRange, assetFlags, true, CStreamVolumeMgr::VOLUME_SLOT_PRIMARY, bLongSwitchCutscene);
|
|
|
|
if (m_bUseCameraMatrix)
|
|
{
|
|
CStreamVolume& volume = CStreamVolumeMgr::GetVolume(CStreamVolumeMgr::VOLUME_SLOT_PRIMARY);
|
|
volume.SetCameraMtx(m_rageCameraMatrix);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
spdSphere searchVolume(m_vPos, ScalarV(m_fRange));
|
|
CStreamVolumeMgr::RegisterSphere(searchVolume, assetFlags, true, CStreamVolumeMgr::VOLUME_SLOT_PRIMARY, bLongSwitchCutscene, true);
|
|
}
|
|
|
|
// for long switches in the middle of a cutscene, only stream high detail
|
|
if (bLongSwitchCutscene)
|
|
{
|
|
CStreamVolume& volume = CStreamVolumeMgr::GetVolume( CStreamVolumeMgr::VOLUME_SLOT_PRIMARY );
|
|
volume.SetLodMask( LODTYPES_FLAG_HD | LODTYPES_FLAG_ORPHANHD );
|
|
}
|
|
|
|
|
|
#if !__FINAL
|
|
if (m_bOwnedByScript)
|
|
{
|
|
CStreamVolumeMgr::SetVolumeScriptInfo(
|
|
m_scriptThreadId,
|
|
( GtaThread::GetThreadWithThreadId(m_scriptThreadId)
|
|
? GtaThread::GetThreadWithThreadId(m_scriptThreadId)->GetScriptName()
|
|
: "<not running>" )
|
|
);
|
|
}
|
|
#endif //!__FINAL
|
|
}
|
|
|
|
#if __BANK
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: InitWidgets
|
|
// PURPOSE: some debug widgets for testing a load scene
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::InitWidgets(bkBank& bank)
|
|
{
|
|
bank.PushGroup("New Load Scene");
|
|
bank.AddToggle("Show active load scene", &ms_bDbgShowInfo);
|
|
bank.AddSlider("Range", &ms_fDbgRange, 1.0f, 4500.0f, 1.0f);
|
|
bank.AddToggle("Use frustum", &ms_bDbgUseFrustum);
|
|
bank.AddToggle("Load collision", &ms_bDbgLoadCollision);
|
|
bank.AddToggle("Long switch cut", &ms_bDbgLongSwitchCutscene);
|
|
bank.AddButton("Start load scene at cam pos", StartLoadSceneCB);
|
|
bank.AddButton("Stop load scene", StopLoadSceneCB);
|
|
bank.PopGroup();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: UpdateDebug
|
|
// PURPOSE: debug draw etc
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::UpdateDebug()
|
|
{
|
|
if (ms_bDbgShowInfo && m_bActive)
|
|
{
|
|
// pos and state
|
|
grcDebugDraw::AddDebugOutput("Load scene active at (%4.2f, %4.2f, %4.2f) range %4.2fm", m_vPos.GetXf(), m_vPos.GetYf(), m_vPos.GetZf(), m_fRange);
|
|
grcDebugDraw::AddDebugOutput("Current state: %s", apszDbgStateNames[m_eCurrentState]);
|
|
grcDebugDraw::AddDebugOutput("Control flags: 0x%x", m_controlFlags);
|
|
|
|
// owner
|
|
if (m_bOwnedByScript)
|
|
{
|
|
grcDebugDraw::AddDebugOutput("Owned by: script %s", GtaThread::GetThreadWithThreadId(m_scriptThreadId)->GetScriptName());
|
|
}
|
|
else
|
|
{
|
|
grcDebugDraw::AddDebugOutput("Owned by: code");
|
|
}
|
|
|
|
// interiors
|
|
if (m_pInteriorProxy)
|
|
{
|
|
grcDebugDraw::AddDebugOutput("interior: %s (%d)", m_pInteriorProxy->GetModelName(), m_pInteriorProxy->GetCurrentState());
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: StartLoadSceneCB
|
|
// PURPOSE: debug callback for rag to initiate a load scene
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::StartLoadSceneCB()
|
|
{
|
|
s32 controlFlags = 0;
|
|
if (ms_bDbgLoadCollision)
|
|
{
|
|
controlFlags |= FLAG_INCLUDE_COLLISION;
|
|
}
|
|
if (ms_bDbgLongSwitchCutscene)
|
|
{
|
|
controlFlags |= FLAG_LONGSWITCH_CUTSCENE;
|
|
}
|
|
g_LoadScene.Start( VECTOR3_TO_VEC3V(camInterface::GetPos()), VECTOR3_TO_VEC3V(camInterface::GetFront()), ms_fDbgRange, ms_bDbgUseFrustum, controlFlags, LOADSCENE_OWNER_DEBUG );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// FUNCTION: StopLoadSceneCB
|
|
// PURPOSE: debug callback for rag to terminate a load scene
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void CLoadScene::StopLoadSceneCB()
|
|
{
|
|
g_LoadScene.Stop();
|
|
}
|
|
|
|
#endif //__BANK
|