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/camera/animatedcam.cpp

747 lines
23 KiB
C++
Raw Permalink Blame History

//=============================================================================
// Copyright (C) 2002 Radical Entertainment Ltd. All rights reserved.
//
// File: AnimatedCam.cpp
//
// Description: Implement AnimatedCam
//
// History: 24/04/2002 + Created -- Cary Brisebois, based from the Bumper Camera
//
//=============================================================================
//========================================
// System Includes
//========================================
//========================================
// Project Includes
//========================================
#include <camera/animatedcam.h>
#include <camera/supercammanager.h>
#include <events/eventmanager.h>
#include <input/inputmanager.h>
#include <p3d/anim/multicontroller.hpp>
#include <p3d/camera.hpp>
#include <p3d/utility.hpp>
#include <presentation/gui/ingame/guimanageringame.h>
#include <presentation/gui/ingame/guiscreenletterbox.h>
#include <presentation/gui/ingame/guiscreenmultihud.h>
#include <presentation/gui/guimanager.h>
#include <presentation/gui/guisystem.h>
#include <presentation/gui/guiwindow.h>
#include <interiors/interiormanager.h>
//========================================
// Definitions
//========================================
//******************************************************************************
//
// Global Data, Local Data, Local Classes
//
//******************************************************************************
#define SKIPPING_DEFAULT false
static tName g_CameraName;
static tName g_MulticontrollerName;
static tName g_MissionStartCameraName;
static tName g_MissionStartMulticontrollerName;
static tCamera* g_Camera = NULL;
static tMultiController* g_Multicontroller = NULL;
static bool g_CameraSwitchPending = false;
static bool g_TriggeredNextCamera = false;
static int g_InstanceCount = 0;
static int g_CameraTransitionFlags = 0;
static bool g_AllowSkipping = SKIPPING_DEFAULT;
static bool g_SurpressNextLetterbox = false;
const int DEFAULT_TRANSITION_FLAGS = SuperCamCentral::QUICK | SuperCamCentral::FORCE;
//******************************************************************************
//
// Public Member Functions
//
//******************************************************************************
void AnimatedCam::Abort()
{
if( g_Multicontroller != NULL )
{
int flags = DEFAULT_TRANSITION_FLAGS;
if ( 0 != g_CameraTransitionFlags )
{
//Override the flags.
flags = g_CameraTransitionFlags;
}
rAssert( m_NextCameraType != NUM_TYPES );
GetSuperCamManager()->GetSCC( 0 )->SelectSuperCam( m_NextCameraType, flags, 3000 );
g_TriggeredNextCamera = true;
//Reset the flags override.
g_CameraTransitionFlags = 0;
tRefCounted::Release( g_Multicontroller );
tRefCounted::Release( g_Camera );
AllowSkipping( SKIPPING_DEFAULT );
}
}
//==============================================================================
// AnimatedCam::AnimatedCam
//==============================================================================
// Description: Constructor.
//
// Parameters: None.
//
// Return: N/A.
//
//==============================================================================
AnimatedCam::AnimatedCam():
m_NextCameraType( INVALID )
{
++g_InstanceCount;
}
//==============================================================================
// AnimatedCam::~AnimatedCam
//==============================================================================
// Description: Destructor.
//
// Parameters: None.
//
// Return: N/A.
//
//==============================================================================
AnimatedCam::~AnimatedCam()
{
--g_InstanceCount;
if( g_InstanceCount == 0 )
{
tRefCounted::Release( g_Multicontroller );
tRefCounted::Release( g_Camera );
g_CameraName.SetText(NULL);
g_MulticontrollerName.SetText(NULL);
g_MissionStartCameraName.SetText(NULL);
g_MissionStartMulticontrollerName.SetText(NULL);
g_TriggeredNextCamera = false;
}
}
//==============================================================================
// AnimatedCam::AllowSkipping
//==============================================================================
// Description: should the animated camera allow the user to skip it with a
// button press
//
// Parameters: None.
//
// Return: N/A.
//
//==============================================================================
void AnimatedCam::AllowSkipping( const bool skippingAllowed )
{
g_AllowSkipping = skippingAllowed;
}
//==============================================================================
// AnimatedCam::CameraSwitchPending
//==============================================================================
// Description: is there a camera switch pending?
//
// Parameters: None.
//
// Return: N/A.
//
//==============================================================================
bool AnimatedCam::CameraSwitchPending()
{
return g_CameraSwitchPending;
}
//==============================================================================
// AnimatedCam::CheckPendingCameraSwitch
//==============================================================================
// Description: checks if we've queued up a camera switch to the animated camera
// because the camera system isn't always set up in time.
//
// Parameters: None.
//
// Return: N/A.
//
//==============================================================================
void AnimatedCam::CheckPendingCameraSwitch()
{
if( CameraSwitchPending() )
{
LookupCamera();
LookupMulticontroller();
SuperCamManager* scm = GetSuperCamManager();
SuperCamCentral* scc = scm->GetSCC( 0 );
SuperCam* sc = scc->GetActiveSuperCam();
if( sc == NULL )
{
GetSuperCamManager()->GetSCC( 0 )->SelectSuperCam( ANIMATED_CAM );
}
else
{
SuperCam::Type type = sc->GetType();
if( type != ANIMATED_CAM )
{
GetSuperCamManager()->GetSCC( 0 )->SelectSuperCam( ANIMATED_CAM );
}
}
SetCameraSwitchPending( false );
}
}
//=============================================================================
// AnimatedCam::ClearCamera
//=============================================================================
// Description: clears out the animated camera
//
// Parameters: none
//
// Return: none
//
//=============================================================================
void AnimatedCam::ClearCamera()
{
tCamera* pCamera = NULL;
tMultiController* pMultiController = NULL;
tRefCounted::Assign( g_Camera, pCamera);
tRefCounted::Assign( g_Multicontroller,pMultiController );
}
//=============================================================================
// AnimatedCam::GetName
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: const char* const
//
//=============================================================================
const char* const AnimatedCam::GetName() const
{
return "ANIMATED_CAM";
}
//=============================================================================
// AnimatedCam::GetType
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: Type
//
//=============================================================================
SuperCam::Type AnimatedCam::GetType()
{
return ANIMATED_CAM;
}
//=============================================================================
// AnimatedCam::GetWatcherName
//=============================================================================
// Description: the name of the class for the watcher or other debug purposes
//
// Parameters: NONE
//
// Return: const char* - the name of the class
//
//=============================================================================
#ifdef DEBUGWATCH
const char* AnimatedCam::GetWatcherName() const
{
return "AnimatedCam";
}
#endif
//=============================================================================
// AnimatedCam::LetterBoxStart
//=============================================================================
// Description: start the letterbox for this camera
//
// Parameters: ()
//
// Return: Type
//
//=============================================================================
void AnimatedCam::LetterBoxStart()
{
if( !g_SurpressNextLetterbox )
{
CGuiManager* gm = GetGuiSystem()->GetCurrentManager();
CGuiWindow::eGuiWindowID currentScreenId = gm->GetCurrentScreen();
CGuiWindow* currentWindow = gm->FindWindowByID( currentScreenId );
currentWindow->ForceClearTransitions();
CGuiScreenLetterBox::SuppressAcceptCancelButtons();
if( g_AllowSkipping )
{
CGuiScreenLetterBox::UnSurpressSkipButton();
}
else
{
CGuiScreenLetterBox::SurpressSkipButton();
}
GetGuiSystem()->GotoScreen( CGuiWindow::GUI_SCREEN_ID_LETTER_BOX, 0x00, 0x00, CLEAR_WINDOW_HISTORY );
CGuiManagerInGame* guiIngameManager = GetGuiSystem()->GetInGameManager();
if( guiIngameManager != NULL )
{
CGuiWindow* window = guiIngameManager->FindWindowByID( CGuiWindow::GUI_SCREEN_ID_LETTER_BOX );
CGuiScreenLetterBox* letterBox = dynamic_cast< CGuiScreenLetterBox* >( window );
letterBox->CheckIfScreenShouldBeBlank();
window = guiIngameManager->FindWindowByID( CGuiWindow::GUI_SCREEN_ID_MULTI_HUD );
CGuiScreenMultiHud* multiHud = dynamic_cast< CGuiScreenMultiHud* >( window );
if( multiHud != NULL )
{
multiHud->ShowLetterBox();
}
}
}
}
//=============================================================================
// AnimatedCam::LetterBoxStop
//=============================================================================
// Description: stop the letterbox for this camera
//
// Parameters: ()
//
// Return: Type
//
//=============================================================================
void AnimatedCam::LetterBoxStop()
{
if( !g_SurpressNextLetterbox )
{
CGuiScreenLetterBox::ForceOpen();
CGuiScreenLetterBox::SuppressAcceptCancelButtons( false );
GetGuiSystem()->GotoScreen( CGuiWindow::GUI_SCREEN_ID_HUD, 0x00, 0x00, CLEAR_WINDOW_HISTORY );
}
else
{
g_SurpressNextLetterbox = false;
}
}
//=============================================================================
// AnimatedCam::LookupCamera
//=============================================================================
// Description: sets up the camera pointer for this animated camera
//
// Parameters: name - tName of the camera to find in the inventory
//
// Return: void
//
//=============================================================================
void AnimatedCam::LookupCamera()
{
if( g_Camera == NULL )
{
if( g_CameraName.GetUID() != static_cast< tUID >( 0 ) )
{
tCamera* found = p3d::find< tCamera >( g_CameraName.GetUID() );
if( found != NULL )
{
tRefCounted::Assign( g_Camera, found );
}
}
}
}
//=============================================================================
// AnimatedCam::LookupMulticontroller
//=============================================================================
// Description: finds the multicontroller in the inventory
//
// Parameters: none
//
// Return: void
//
//=============================================================================
void AnimatedCam::LookupMulticontroller()
{
if( g_Multicontroller == NULL )
{
if( g_MulticontrollerName.GetUID() != static_cast< tUID >( 0 ) )
{
tMultiController* found = p3d::find< tMultiController >( g_MulticontrollerName.GetUID() );
if( found != NULL )
{
tRefCounted::Assign( g_Multicontroller, found );
}
Reset();
}
}
}
//=============================================================================
// AnimatedCam::OnInit
//=============================================================================
// Description: called when the camera is started
//
// Parameters: NONE
//
// Return: void
//
//=============================================================================
void AnimatedCam::OnInit()
{
LetterBoxStart();
InitMyController();
InputManager::GetInstance()->SetGameState( Input::ACTIVE_ANIM_CAM );
}
//=============================================================================
// AnimatedCam::OnShutdown
//=============================================================================
// Description: called when the camera is deactivated
//
// Parameters: NONE
//
// Return: void
//
//=============================================================================
void AnimatedCam::OnShutdown()
{
LetterBoxStop();
InputManager::GetInstance()->SetGameState( Input::DEACTIVE_ANIM_CAM );
GetEventManager()->TriggerEvent( EVENT_ANIMATED_CAM_SHUTDOWN );
m_NextCameraType = INVALID;
}
//=============================================================================
// AnimatedCam::Reset
//=============================================================================
// Description: resets the camera to the start of the animation
//
// Parameters: NONE
//
// Return: void
//
//=============================================================================
void AnimatedCam::Reset()
{
if( g_Multicontroller != NULL )
{
g_Multicontroller->Reset();
}
g_TriggeredNextCamera = false;
}
//=============================================================================
// AnimatedCam::SetCamera
//=============================================================================
// Description: sets up the camera pointer for this animated camera
//
// Parameters: name - tName of the camera to find in the inventory
//
// Return: void
//
//=============================================================================
void AnimatedCam::SetCamera( tName name )
{
// tRefCounted::Release( g_Camera );
g_CameraName = name;
if( g_CameraName.GetUID() == static_cast< tUID >( 0 ) )
{
SetCameraSwitchPending( false );
}
else
{
SetCameraSwitchPending( true );
}
}
//=============================================================================
// AnimatedCam::SetMulticontroller
//=============================================================================
// Description: sets up the multicontroller pointer for this animated camera
//
// Parameters: name - tName of the camera to find in the inventory
//
// Return: void
//
//=============================================================================
void AnimatedCam::SetMulticontroller( tName name )
{
//tRefCounted::Release( g_Multicontroller );
g_MulticontrollerName = name;
if( g_MulticontrollerName.GetUID() == static_cast< tUID >( 0 ) )
{
SetCameraSwitchPending( false );
}
else
{
SetCameraSwitchPending( true );
}
}
//=============================================================================
// AnimatedCam::SetMissionStartCamera
//=============================================================================
// Description: sets up the camera pointer for this animated camera
//
// Parameters: name - tName of the camera to find in the inventory
//
// Return: void
//
//=============================================================================
void AnimatedCam::SetMissionStartCamera( tName name )
{
g_MissionStartCameraName = name;
}
//=============================================================================
// AnimatedCam::SetMissionStartMulticontroller
//=============================================================================
// Description: sets up the multicontroller pointer for this animated camera
//
// Parameters: name - tName of the camera to find in the inventory
//
// Return: void
//
//=============================================================================
void AnimatedCam::SetMissionStartMulticontroller( tName name )
{
g_MissionStartMulticontrollerName = name;
}
//=============================================================================
// AnimatedCam::SetNextCameraType
//=============================================================================
// Description: sets up the camera that will get used after this camera is done
//
// Parameters: type - what kind of camera should we use
//
// Return: void
//
//=============================================================================
void AnimatedCam::SetNextCameraType( const SuperCam::Type type )
{
rAssert( type != ANIMATED_CAM );
m_NextCameraType = type;
//m_NextCameraType = SuperCam::DEFAULT_CAM;
}
//=============================================================================
// AnimatedCam::SetTarget
//=============================================================================
// Description: sets the target (actually sets it for the next camera in the
// chain
//
// Parameters: target - the target for the camera to look at
//
// Return: void
//
//=============================================================================
void AnimatedCam::SetTarget( ISuperCamTarget* target )
{
//nothing
}
//=============================================================================
// AnimatedCam::Skip
//=============================================================================
// Description: skips the animated camera
//
// Parameters: NONE
//
// Return: void
//
//=============================================================================
void AnimatedCam::Skip()
{
if( g_AllowSkipping )
{
if( g_Multicontroller != NULL )
{
g_Multicontroller->Advance( 20000.0f );
}
AllowSkipping( SKIPPING_DEFAULT );
}
}
//=============================================================================
// AnimatedCam::TriggerMissionStartCamera
//=============================================================================
// Description: switches to the mission start camera
//
// Parameters: NONE
//
// Return: void
//
//=============================================================================
void AnimatedCam::TriggerMissionStartCamera()
{
SetCamera( g_MissionStartCameraName );
SetMulticontroller( g_MissionStartMulticontrollerName );
g_MissionStartCameraName = "";
g_MissionStartMulticontrollerName = "";
}
//=============================================================================
// AnimatedCam::SetCameraSwitchPending
//=============================================================================
// Description: changes the setting on the camera switch flag
//
// Parameters: pending - the new state of the flag
//
// Return: void
//
//=============================================================================
void AnimatedCam::SetCameraSwitchPending( const bool pending )
{
g_CameraSwitchPending = pending;
}
//=============================================================================
// AnimatedCam::SetCameraTransitionFlags
//=============================================================================
// Description: Overrides the default camera transition flags
//
// Parameters: ( int flags )
//
// Return: void
//
//=============================================================================
void AnimatedCam::SetCameraTransitionFlags( int flags )
{
g_CameraTransitionFlags = flags;
}
//=============================================================================
// AnimatedCam::SupressNextLetterbox
//=============================================================================
// Description: won't trigger the letterbox next time
//
// Parameters:
//
// Return: void
//
//=============================================================================
void AnimatedCam::SupressNextLetterbox()
{
g_SurpressNextLetterbox = true;
}
//=============================================================================
// AnimatedCam::Update
//=============================================================================
// Description: called to animate the camera
//
// Parameters: ( unsigned int milliseconds
//
// Return: void
//
//=============================================================================
void AnimatedCam::Update( unsigned int milliseconds )
{
if( g_TriggeredNextCamera )
{
return;
}
if( g_Multicontroller != NULL )
{
g_Multicontroller->Advance( static_cast< float >( milliseconds ) );
InteriorManager* im = GetInteriorManager();
//This is a last chance test to make sure that we do not play cameras
//in interiors.
if( g_Multicontroller->LastFrameReached() ||
(im && ( im->IsEntering() || im->IsInside() || im->IsExiting() ) ) )
{
//
// The animation has looped
//
if( g_TriggeredNextCamera == false )
{
int flags = DEFAULT_TRANSITION_FLAGS;
if ( 0 != g_CameraTransitionFlags )
{
//Override the flags.
flags = g_CameraTransitionFlags;
}
rAssert( m_NextCameraType != NUM_TYPES );
GetSuperCamManager()->GetSCC( 0 )->SelectSuperCam( m_NextCameraType, flags, 3000 );
g_TriggeredNextCamera = true;
//Reset the flags override.
g_CameraTransitionFlags = 0;
tRefCounted::Release( g_Multicontroller );
tRefCounted::Release( g_Camera );
AllowSkipping( SKIPPING_DEFAULT );
}
}
else
{
//
// Update the camera values
//
rmt::Vector position;
rmt::Vector target;
g_Camera->GetWorldPosition( &position );
g_Camera->GetWorldLookAtDirection( &target );
static rmt::Vector oldPosition = position;
static float maxDistance = 30;
target *= 10.0f;
target += position;
SetCameraValues( milliseconds, position, target);
}
}
else
{
//
// We never found the multicontroller in the inventory
//
int flags = DEFAULT_TRANSITION_FLAGS;
if ( 0 != g_CameraTransitionFlags )
{
//Override the flags.
flags = g_CameraTransitionFlags;
}
GetSuperCamManager()->GetSCC( 0 )->SelectSuperCam( SuperCam::DEFAULT_CAM, flags, 0 );
g_TriggeredNextCamera = true;
//Reset the flags override.
g_CameraTransitionFlags = 0;
tRefCounted::Release( g_Multicontroller );
tRefCounted::Release( g_Camera );
//
// Since our camera system doesn't use regular p3d cameras, i have to fake
// the following information
//
if( g_Camera == NULL )
{
//this is a bad bad case to ever get into
rWarningMsg( false, "Camera could not be loaded" );
//SetCameraValues( milliseconds, rmt::Vector( 0, 0, 0 ), rmt::Vector( 1, 0, 0 ) );
}
}
}
Reference in New Issue View Git Blame Copy Permalink