falso
/
The-Simpsons-Hit-and-Run
mirror of https://github.com/Svxy/The-Simpsons-Hit-and-Run.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
The-Simpsons-Hit-and-Run/game/code/presentation/gui/backend/guiscreenloadingfe.cpp

567 lines
17 KiB
C++
Raw Permalink Blame History

//===========================================================================
// Copyright (C) 2000 Radical Entertainment Ltd. All rights reserved.
//
// Component: CGuiScreenLoadingFE
//
// Description: Implementation of the CGuiScreenLoadingFE class.
//
// Authors: Tony Chu
//
// Revisions Date Author Revision
// 2002/07/23 TChu Created for SRR2
//
//===========================================================================
//===========================================================================
// Includes
//===========================================================================
#include <presentation/gui/backend/guiscreenloadingfe.h>
#include <presentation/gui/backend/guiloadingbar.h>
#include <presentation/gui/utility/specialfx.h>
#include <gameflow/gameflow.h>
#include <memory/createheap.h>
#include <memory/memoryutilities.h>
#include <render/rendermanager/rendermanager.h>
#include <render/rendermanager/renderlayer.h>
#include <sound/soundmanager.h>
#include <p3d/drawable.hpp>
#include <p3d/camera.hpp>
#include <p3d/anim/multicontroller.hpp>
#include <raddebug.hpp> // Foundation
#include <screen.h>
#include <layer.h>
#include <page.h>
#include <group.h>
#include <text.h>
#include <sprite.h>
#include <polygon.h>
#include <pure3dobject.h>
//===========================================================================
// Global Data, Local Data, Local Classes
//===========================================================================
#define ENABLE_DYNA_LOADED_RESOURCES
//#define LOADING_BAR_FE_EXPLOSION
#ifdef ENABLE_DYNA_LOADED_RESOURCES
const char* LOADING_FE_PURE3D_FILE = "art\\frontend\\scrooby\\resource\\pure3d\\loading.p3d";
const char* LOADING_FE_INVENTORY = "LoadingFEScreen";
const char* LOADING_FE_DRAWABLE = "loading_screen";
const char* LOADING_FE_CAMERA = "loading_screen_cameraShape";
const char* LOADING_FE_MULTICONTROLLER = "loading_screen_MasterController";
#endif
//===========================================================================
// Public Member Functions
//===========================================================================
//===========================================================================
// CGuiScreenLoadingFE::CGuiScreenLoadingFE
//===========================================================================
// Description: Constructor.
//
// Constraints: None.
//
// Parameters: None.
//
// Return: N/A.
//
//===========================================================================
CGuiScreenLoadingFE::CGuiScreenLoadingFE
(
Scrooby::Screen* pScreen,
CGuiEntity* pParent
)
: CGuiScreen( pScreen, pParent, GUI_SCREEN_ID_LOADING_FE ),
m_loadingText( NULL ),
m_itchyAndScratchy( NULL ),
m_elapsedTime( 0 ),
m_loadingBarGroup( NULL ),
m_currentMemoryUsage( 0.0f ),
m_startingMemoryAvailable( 0 ),
m_elapsedFireTime( 0 ),
m_explosionLayer( NULL ),
m_explosion( NULL ),
m_elapsedExplosionTime( 0 )
{
// Retrieve the Scrooby drawing elements.
//
Scrooby::Page* pPage = m_pScroobyScreen->GetPage( "LoadingFE" );
rAssert( pPage != NULL );
Scrooby::Layer* foreground = pPage->GetLayer( "Foreground" );
Scrooby::Layer* background = pPage->GetLayer( "Background" );
m_loadingText = foreground->GetText( "Loading" );
rAssert( m_loadingText != NULL );
m_itchyAndScratchy = background->GetPure3dObject( "Loading" );
if( m_itchyAndScratchy != NULL )
{
m_itchyAndScratchy->SetDrawable( NULL );
m_itchyAndScratchy->SetCamera( NULL );
m_itchyAndScratchy->SetMultiController( NULL );
m_itchyAndScratchy->SetClearDepthBuffer( true );
}
// get loading bar
//
m_loadingBarGroup = pPage->GetGroup( "LoadingBar" );
rAssert( m_loadingBarGroup != NULL );
m_loadingBar.m_type = Slider::HORIZONTAL_SLIDER_RIGHT;
m_loadingBar.SetScroobyPolygon( m_loadingBarGroup->GetPolygon( "Wick" ),
m_loadingBarGroup->GetSprite( "Fire" ) );
// get explosion overlay (from Explosion.pag)
//
pPage = m_pScroobyScreen->GetPage( "Explosion" );
if( pPage != NULL )
{
m_explosionLayer = pPage->GetLayer( "Explosion" );
rAssert( m_explosionLayer != NULL );
m_explosion = m_explosionLayer->GetPolygon( "Explosion0" );
rAssert( m_explosion != NULL );
}
#ifdef ENABLE_DYNA_LOADED_RESOURCES
p3d::inventory->AddSection( LOADING_FE_INVENTORY );
#endif
}
//===========================================================================
// CGuiScreenLoadingFE::~CGuiScreenLoadingFE
//===========================================================================
// Description: Destructor.
//
// Constraints: None.
//
// Parameters: None.
//
// Return: N/A.
//
//===========================================================================
CGuiScreenLoadingFE::~CGuiScreenLoadingFE()
{
#ifdef ENABLE_DYNA_LOADED_RESOURCES
p3d::inventory->DeleteSection( LOADING_FE_INVENTORY );
#endif
}
//===========================================================================
// CGuiScreenLoadingFE::HandleMessage
//===========================================================================
// Description:
//
// Constraints: None.
//
// Parameters: None.
//
// Return: N/A.
//
//===========================================================================
void CGuiScreenLoadingFE::HandleMessage
(
eGuiMessage message,
unsigned int param1,
unsigned int param2
)
{
switch( message )
{
case GUI_MSG_UPDATE:
{
// update loading text
//
const unsigned int LOADING_TEXT_LOOP_TIME = 500; // in msec
m_elapsedTime += param1;
if( m_elapsedTime > LOADING_TEXT_LOOP_TIME )
{
rAssert( m_loadingText != NULL );
int nextIndex = (m_loadingText->GetIndex() + 1) % m_loadingText->GetNumOfStrings();
m_loadingText->SetIndex( nextIndex );
m_elapsedTime %= LOADING_TEXT_LOOP_TIME;
}
ContextEnum currentContext = GetGameFlow()->GetCurrentContext();
if( currentContext == CONTEXT_FRONTEND ||
currentContext == CONTEXT_LOADING_DEMO ||
currentContext == CONTEXT_LOADING_SUPERSPRINT ||
currentContext == CONTEXT_LOADING_GAMEPLAY )
{
// update loading bar
//
rAssert( m_loadingBarGroup != NULL );
m_loadingBarGroup->SetVisible( true );
float newMemoryUsage = this->GetCurrentMemoryUsage( currentContext );
// don't allow loading bar to go backwards
//
if( newMemoryUsage > m_currentMemoryUsage )
{
m_currentMemoryUsage = newMemoryUsage;
if( m_currentMemoryUsage < 1.0f )
{
m_loadingBar.SetValue( 1.0f - m_currentMemoryUsage );
}
else
{
#ifdef LOADING_BAR_FE_EXPLOSION
if( m_explosionLayer != NULL && m_explosion != NULL )
{
m_explosionLayer->SetVisible( true );
m_elapsedExplosionTime += param1;
/*
float explosionScale = EXPLOSION_SCALE_START + m_elapsedExplosionTime / 1000.0f * EXPLOSION_SCALE_RATE;
m_explosion->ResetTransformation();
m_explosion->ScaleAboutCenter( explosionScale );
*/
const unsigned int EXPLOSION_FLICKER_PERIOD = 50;
bool isBlinked = GuiSFX::Blink( m_explosion,
(float)m_elapsedExplosionTime,
(float)EXPLOSION_FLICKER_PERIOD );
if( isBlinked )
{
m_elapsedExplosionTime %= EXPLOSION_FLICKER_PERIOD;
}
/*
tColour currentColour;
GuiSFX::ModulateColour( &currentColour,
(float)m_elapsedExplosionTime,
100.0f,
tColour( 255, 255, 0 ),
tColour( 255, 0, 0 ) );
for( int i = 0; i < m_explosion->GetNumOfVertexes(); i++ )
{
m_explosion->SetVertexColour( i, currentColour );
}
*/
}
#else
#ifndef RAD_DEBUG
rReleaseWarningMsg( false, "Current memory usage for loading bar exceeds 100%!" );
#endif
#endif // LOADING_BAR_FE_EXPLOSION
}
}
// flicker loading bar flame
//
const unsigned int LOADING_BAR_FIRE_TIME = 50; // in msec
m_elapsedFireTime += param1;
if( m_elapsedFireTime > LOADING_BAR_FIRE_TIME )
{
rAssert( m_loadingBar.m_pImage != NULL );
m_loadingBar.m_pImage->SetIndex( 1 - m_loadingBar.m_pImage->GetIndex() );
m_elapsedFireTime %= LOADING_BAR_FIRE_TIME;
}
}
break;
}
case GUI_MSG_LOAD_RESOURCES:
{
this->LoadResources();
#ifdef RAD_XBOX
m_startingMemoryAvailable = Memory::GetTotalMemoryFree();
#else
m_startingMemoryAvailable = GetTotalMemoryFreeInAllHeaps();
#endif
rReleasePrintf( "Starting Memory Available = %.2f MB\n", (float)m_startingMemoryAvailable / MB );
#ifdef RAD_WIN32
GetLoadingManager()->ResetRequestsProcessed();
#endif
break;
}
default:
{
break;
}
}
// Propogate the message up the hierarchy.
//
CGuiScreen::HandleMessage( message, param1, param2 );
}
void
CGuiScreenLoadingFE::LoadResources()
{
#ifdef ENABLE_DYNA_LOADED_RESOURCES
if( m_itchyAndScratchy != NULL )
{
m_itchyAndScratchy->SetDrawable( NULL );
}
GameMemoryAllocator heapAllocator = GMA_DEFAULT;
ContextEnum nextContext = GetGameFlow()->GetNextContext();
switch( nextContext )
{
case CONTEXT_FRONTEND:
{
heapAllocator = GMA_LEVEL_MOVIE;
break;
}
case CONTEXT_LOADING_GAMEPLAY:
case CONTEXT_LOADING_DEMO:
{
heapAllocator = GMA_LEVEL_OTHER;
break;
}
case CONTEXT_LOADING_SUPERSPRINT:
case CONTEXT_SUPERSPRINT_FE:
{
heapAllocator = GMA_LEVEL_HUD;
break;
}
default:
{
break;
}
}
rAssert( heapAllocator != GMA_DEFAULT );
GetLoadingManager()->AddRequest( FILEHANDLER_PURE3D,
LOADING_FE_PURE3D_FILE,
heapAllocator,
LOADING_FE_INVENTORY,
LOADING_FE_INVENTORY,
this );
#endif
}
void
CGuiScreenLoadingFE::OnProcessRequestsComplete( void* pUserData )
{
if( m_itchyAndScratchy != NULL )
{
// push and select inventory section for searching
//
p3d::inventory->PushSection();
p3d::inventory->SelectSection( LOADING_FE_INVENTORY );
bool currentSectionOnly = p3d::inventory->GetCurrentSectionOnly();
p3d::inventory->SetCurrentSectionOnly( true );
// search for drawable, camera, and multicontroller, and assign
// them to the itchy & scratchy pure3d object
//
tDrawable* drawable = p3d::find<tDrawable>( LOADING_FE_DRAWABLE );
m_itchyAndScratchy->SetDrawable( drawable );
tCamera* camera = p3d::find<tCamera>( LOADING_FE_CAMERA );
m_itchyAndScratchy->SetCamera( camera );
tMultiController* multiController = p3d::find<tMultiController>( LOADING_FE_MULTICONTROLLER );
m_itchyAndScratchy->SetMultiController( multiController );
// pop inventory section and restore states
//
p3d::inventory->SetCurrentSectionOnly( currentSectionOnly );
p3d::inventory->PopSection();
}
}
//===========================================================================
// CGuiScreenLoadingFE::InitIntro
//===========================================================================
// Description:
//
// Constraints: None.
//
// Parameters: None.
//
// Return: N/A.
//
//===========================================================================
void CGuiScreenLoadingFE::InitIntro()
{
RenderLayer* levelLayer = GetRenderManager()->mpLayer( RenderEnums::LevelSlot );
if( levelLayer != NULL )
{
levelLayer->Freeze();
}
m_loadingBar.SetValue( 1.0f );
// reset current memory usage
//
m_currentMemoryUsage = 0.0f;
// hide loading bar by default
//
rAssert( m_loadingBarGroup != NULL );
m_loadingBarGroup->SetVisible( false );
// hide explosion overlay
//
if( m_explosionLayer != NULL && m_explosion != NULL )
{
m_explosionLayer->SetVisible( false );
m_explosion->SetVisible( true );
m_elapsedExplosionTime = 0;
}
}
//===========================================================================
// CGuiScreenLoadingFE::InitRunning
//===========================================================================
// Description:
//
// Constraints: None.
//
// Parameters: None.
//
// Return: N/A.
//
//===========================================================================
void CGuiScreenLoadingFE::InitRunning()
{
}
//===========================================================================
// CGuiScreenLoadingFE::InitOutro
//===========================================================================
// Description:
//
// Constraints: None.
//
// Parameters: None.
//
// Return: N/A.
//
//===========================================================================
void CGuiScreenLoadingFE::InitOutro()
{
RenderLayer* levelLayer = GetRenderManager()->mpLayer( RenderEnums::LevelSlot );
if( levelLayer != NULL && levelLayer->IsFrozen() )
{
levelLayer->Thaw();
}
#ifdef ENABLE_DYNA_LOADED_RESOURCES
p3d::pddi->DrawSync();
if( m_itchyAndScratchy != NULL )
{
m_itchyAndScratchy->SetDrawable( NULL );
m_itchyAndScratchy->SetCamera( NULL );
m_itchyAndScratchy->SetMultiController( NULL );
}
p3d::inventory->RemoveSectionElements( LOADING_FE_INVENTORY );
#endif
rReleasePrintf( "Final memory usage value for loading bar = %.3f\n", m_currentMemoryUsage );
m_loadingBar.SetValue( 0.0f );
// reset loading text animation
//
m_elapsedTime = 0;
rAssert( m_loadingText != NULL );
m_loadingText->SetIndex( 0 );
m_elapsedFireTime = 0;
GetSoundManager()->ResetDucking();
}
//---------------------------------------------------------------------
// Private Functions
//---------------------------------------------------------------------
float
CGuiScreenLoadingFE::GetCurrentMemoryUsage( ContextEnum currentContext ) const
{
float currentMemoryUsage = 0.0f;
#ifdef RAD_XBOX
int totalMemoryFree = Memory::GetTotalMemoryFree();
#else
int totalMemoryFree = GetTotalMemoryFreeInAllHeaps();
#endif
if( totalMemoryFree > 0 )
{
switch( currentContext )
{
case CONTEXT_LOADING_GAMEPLAY:
{
currentMemoryUsage = (m_startingMemoryAvailable - totalMemoryFree) / TOTAL_INGAME_MEMORY_USAGE;
break;
}
case CONTEXT_LOADING_DEMO:
{
currentMemoryUsage = (m_startingMemoryAvailable - totalMemoryFree) / TOTAL_DEMO_MEMORY_USAGE;
break;
}
case CONTEXT_LOADING_SUPERSPRINT:
{
#ifndef RAD_WIN32
currentMemoryUsage = (m_startingMemoryAvailable - totalMemoryFree) / TOTAL_SUPERSPRINT_MEMORY_USAGE;
#else
// this sucks but i just want to finish it.
float memUsage = float( GetLoadingManager()->GetNumRequestsProcessed() ) / TOTAL_SUPERSPRINT_FILES;
currentMemoryUsage = m_currentMemoryUsage;
if( memUsage - currentMemoryUsage < LOAD_MIN_SPEED )
{
currentMemoryUsage = memUsage;
}
else
{
float delta = (memUsage - currentMemoryUsage) / LOAD_BLEND_FACTOR;
currentMemoryUsage += delta > LOAD_MIN_SPEED ? delta : LOAD_MIN_SPEED;
}
#endif
break;
}
case CONTEXT_FRONTEND:
{
currentMemoryUsage = (m_startingMemoryAvailable - totalMemoryFree) / TOTAL_FE_MEMORY_USAGE;
break;
}
default:
{
rWarningMsg( false, "Invalid context!" );
break;
}
}
}
else
{
rWarningMsg( false, "Why is total memory free negative??" );
}
return currentMemoryUsage;
}
Reference in New Issue View Git Blame Copy Permalink