Backups/GTASource
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
GTASource/game/Cutscene/AnimatedModelEntity.cpp

4773 lines
167 KiB
C++
Raw Permalink Normal View History

init
2025-02-23 17:40:52 +08:00
/////////////////////////////////////////////////////////////////////////////////
//
// FILE : AnimatedModelEntity.cpp
// PURPOSE :
// AUTHOR : Thomas French
//
/////////////////////////////////////////////////////////////////////////////////
//Rage Headers
#include "cutfile/cutfobject.h"
#include "cutscene/cutsevent.h"
#include "cutscene/cutsmanager.h"
#include "cutscene/cutseventargs.h"
#include "cranimation/animation.h"
#include "fwanimation/animdirector.h"
#include "fwanimation/directorcomponentfacialrig.h"
//Game Headers
#include "animation/debug/AnimDebug.h"
#include "animation/debug/AnimViewer.h"
#include "animation/EventTags.h"
#include "animation/FacialData.h"
#include "animation/MovePed.h"
#include "animation/MoveObject.h"
#include "camera/CamInterface.h"
#include "camera/Cutscene/CutsceneDirector.h"
#include "camera/cutscene/AnimatedCamera.h"
#include "cutscene/CutSceneCameraEntity.h"
#include "cutscene/AnimatedModelEntity.h"
#include "Cutscene/cutscene_channel.h"
#include "cutscene/CutSceneAnimManager.h"
#include "cutscene/CutSceneManagerNew.h"
#include "cutscene/CutSceneDefine.h"
#include "cutscene/CutsceneCustomEvents.h"
#include "event/Events.h"
#include "Network/NetworkInterface.h"
#include "Objects/ObjectIntelligence.h"
#include "Objects/Door.h"
#include "Peds/PedFactory.h"
#include "peds/ped.h"
#include "Peds/PedHelmetComponent.h"
#include "peds/PedIntelligence.h"
#include "peds/rendering/PedVariationStream.h"
#include "peds/rendering/PedVariationPack.h"
#include "physics/gtaInst.h"
#include "physics/physics.h"
#include "physics/simulator.h"
#include "physics/Archetype.h"
#include "control/record.h"
#include "scene/entities/compEntity.h"
#include "scene/world/GameWorld.h"
#include "script/script.h"
#include "script/commands_object.h"
#include "script/Handlers/GameScriptEntity.h"
#include "task/motion/TaskMotionBase.h"
#include "task/system/TaskManager.h"
#include "task/System/Task.h"
#include "task/Animation/TaskAnims.h"
#include "task/Animation/TaskCutScene.h"
#include "task/system/TaskTypes.h"
#include "task/general/TaskBasic.h"
#include "vehicleAi/VehicleAILodManager.h"
#include "vehicleAI/VehicleIntelligence.h"
#include "vehicles/VehicleFactory.h"
#include "vehicles/train.h"
#include "weapons/inventory/PedInventoryLoadOut.h"
//ANIM_OPTIMISATIONS()
///////////////////////////////////////////////////////////////////////////////////////////////////
// Animated model entity
///////////////////////////////////////////////////////////////////////////////////////////////////
const fwMvPropertyId CCutsceneAnimatedModelEntity::ms_VisibleToScriptKey("VisibleToScript",0xF301E135);
u32 CCutsceneAnimatedModelEntity::ms_EventKey = ATSTRINGHASH("Event", 2915749078);
Mat34V identityMat(V_IDENTITY);
#if RECORDING_VERTS
namespace rage
{
extern dbgRecords<recordCustomClothEvent> g_DbgRecordCustomClothEvents;
EXT_PFD_DECLARE_ITEM( DebugRecords );
}
#endif
CCutsceneAnimatedModelEntity::CCutsceneAnimatedModelEntity(const cutfObject* pObject)
:cutsUniqueEntity()
, m_CollisionBound(NULL)
, m_bUpdateCollisionBound(false)
{
m_pCutfObject = pObject;
//create a real game side object (CPed, CObject or CVehicle) not a cut scene type object which all derive from CObject
m_bCreateGameObject = false;
if(pObject->GetType() == CUTSCENE_MODEL_OBJECT_TYPE)
{
const cutfModelObject* pModel = static_cast<const cutfModelObject*>(pObject);
if(pModel)
{
m_ModelNameHash = pModel->GetStreamingName();
m_SceneHandleHash = pModel->GetHandle();
}
if (m_SceneHandleHash.GetHash()==0)
{
m_SceneHandleHash = atHashString(atFinalizeHash(pModel->GetAnimStreamingBase()));
}
}
cutsceneAssert(m_ModelNameHash.GetHash()>0);
//creation position
m_vCreatePos = CutSceneManager::GetInstance()->GetSceneOffset();
//Pointer to a game side object
m_pEntity = NULL;
//Pointer to a registered entity that is just hidden and repositioned by the cut scene
m_pEntityForRepositionOnly = NULL;
m_pClip = NULL;
m_vVelocity = VEC3_ZERO;
m_pCutSceneTask = NULL;
m_HasBeenDeletedByCutscene = false;
m_bWasInvincible = false;
m_fOriginalLODMultiplier = 1.0f;
m_fOriginalHairScale = 0.0f;
m_CurrentPosition = VEC3_ZERO;
m_CurrentHeading = 0.0f;
m_bComputeInitialVariationsForGameEntity = false;
m_bComputeVariationsForSkipForRepositionOnlyEntity = false;
m_bRequestRepositionOnlyEntity = false;
m_SectionAnimWasRecieved = 0;
m_bIsReadyForGame = false;
m_bStoppedCalled = false;
m_bIsRegisteredEntityScriptControlled = false;
m_bCreatedByCutscene = false;
m_bClearedOrSetAnimThisFrame = false;
m_bShouldProcessTags = false;
m_FrameTagsAreProcessed = 0;
m_OptionFlags.ClearAllFlags();
m_StreamingOptionFlags.ClearAllFlags();
#if !__NO_OUTPUT
m_bIsloggingEntityCalls = false;
#endif
}
///////////////////////////////////////////////////////////////////////////////////////////////////
CCutsceneAnimatedModelEntity::~CCutsceneAnimatedModelEntity()
{
bool bDeleteRegisteredEntities = CutSceneManager::GetInstancePtr() && CutSceneManager::GetInstance()->ShouldDeleteAllRegisteredEntites();
DeleteNonRegisteredEntities();
if (m_pEntity && m_pEntity->GetPortalTracker())
{
m_pEntity->GetPortalTracker()->SetIsCutsceneControlled(false);
}
if (bDeleteRegisteredEntities)
{
if (m_pEntity && (!m_pEntity->GetIsTypePed() || !((CPed*)m_pEntity.Get())->IsPlayer()))
RemoveEntityFromTheWorld(m_pEntity, true);
if (m_pEntityForRepositionOnly && (!m_pEntityForRepositionOnly->GetIsTypePed() || !((CPed*)m_pEntityForRepositionOnly.Get())->IsPlayer()))
RemoveEntityFromTheWorld(m_pEntityForRepositionOnly, true);
}
m_pEntity = NULL;
m_pEntityForRepositionOnly = NULL;
if(m_pClip != NULL)
{
m_pClip->Release();
m_pClip = NULL;
}
m_pCutSceneTask = NULL;
}
void CCutsceneAnimatedModelEntity::DeleteNonRegisteredEntities()
{
if(RemoveEntityFromTheWorld(m_pEntity))
{
m_pEntity = NULL;
}
if(RemoveEntityFromTheWorld(m_pEntityForRepositionOnly))
{
m_pEntityForRepositionOnly = NULL;
}
}
void CCutsceneAnimatedModelEntity::RegisterPlayer(cutsManager* pManager, const cutfObject* pObject)
{
CutSceneManager* pCutsManager = static_cast<CutSceneManager*>(pManager);
//Register the player
if(pCutsManager->GetPlayerSceneId() == pObject->GetObjectId())
{
if(m_pEntity == NULL)
{
CPed *pPed = CGameWorld::FindLocalPlayer();
if(pPed)
{
if(pObject->GetType() == CUTSCENE_MODEL_OBJECT_TYPE)
{
pCutsManager->RegisterGameEntity(pPed, GetSceneHandleHash(), GetModelNameHash(), false, false);
m_bWasInvincible = pPed->m_nPhysicalFlags.bNotDamagedByAnything;
}
}
}
}
}
void CCutsceneAnimatedModelEntity::SetVisibility(CEntity* pEnt, bool Visible)
{
if(pEnt)
{
#if !__NO_OUTPUT
CPhysical* phys = NULL;
bool reactivateLogging = false;
if(pEnt->GetIsPhysical())
{
phys = static_cast<CPhysical*>(pEnt);
if(phys && m_bIsloggingEntityCalls && phys->m_LogVisibiltyCalls)
{
phys->m_LogVisibiltyCalls = false;
reactivateLogging = true;
}
#endif //!__NO_OUTPUT
pEnt->SetIsVisibleForModule(SETISVISIBLE_MODULE_CUTSCENE, Visible);
#if !__NO_OUTPUT
if(phys && m_bIsloggingEntityCalls && reactivateLogging)
{
phys->m_LogVisibiltyCalls = true;
}
}
#endif //!__NO_OUTPUT
}
}
void CCutsceneAnimatedModelEntity::SetUpScriptRegisteredEntity(cutsManager* UNUSED_PARAM(pManager), const cutfObject* pObject)
{
//going to animate this version of the entity its has a valid scene handle and model hash
if (IsRegisteredWithScript())
{
//the id is stored as it could be used later for creating script required entities
m_RegisteredEntityFromScript.iSceneId = pObject->GetObjectId();
if(IsScriptRegisteredGameEntity())
{
if(m_RegisteredEntityFromScript.bAppearInScene == false)
{
//remove our initial entity its not going to be needed
if(m_pEntity)
{
if(m_pEntity->GetIsTypePed())
{
SetVisibility(m_pEntity, false);
cutsceneModelEntityDebugf2("CCutsceneAnimatedModelEntity::SetUpScriptRegisteredEntity1: Hiding entity (%s)", m_pEntity->GetModelName());
//have to add to the world to safely delete, though check its not already in the world
if( !m_pEntity->GetIsAddedToWorld() )
{
CGameWorld::Add((CPed*)m_pEntity.Get(), CGameWorld::OUTSIDE);
}
}
#if !__NO_OUTPUT
if(m_pEntity->GetIsPhysical() && m_bIsloggingEntityCalls)
{
((CPhysical*)m_pEntity.Get())->m_LogDeletions = false;
}
#endif
m_pEntity->FlagToDestroyWhenNextProcessed();
m_pEntity = NULL;
}
}
//animating the script given entity, not a CS version
else if(m_RegisteredEntityFromScript.pEnt )
{
//remove our initial entity its not going to be needed
if(m_pEntity)
{
if(m_pEntity->GetIsTypePed())
{
SetVisibility(m_pEntity, false);
cutsceneModelEntityDebugf2("CCutsceneAnimatedModelEntity::SetUpScriptRegisteredEntity2: Hiding entity (%s)", m_pEntity->GetModelName());
//have to add to the world to safely release
if( !m_pEntity->GetIsAddedToWorld() )
{
CGameWorld::Add((CPed*)m_pEntity.Get(), CGameWorld::OUTSIDE);
}
}
#if !__NO_OUTPUT
if(m_pEntity->GetIsPhysical() && m_bIsloggingEntityCalls)
{
((CPhysical*)m_pEntity.Get())->m_LogDeletions = false;
}
#endif
m_pEntity->FlagToDestroyWhenNextProcessed();
m_pEntity = NULL;
}
//check that there is no game entity already
if(m_pEntity == NULL)
{
m_pEntity = m_RegisteredEntityFromScript.pEnt;
m_pEntity->GetPortalTracker()->SetIsCutsceneControlled(true);
if(m_pEntity->GetIsPhysical())
{
CPhysical* pPhys = static_cast<CPhysical*>(m_pEntity.Get());
m_bWasInvincible = pPhys->m_nPhysicalFlags.bNotDamagedByAnything;
}
}
}
}
else
{
//check if its registered by scene handle only
if(IsScriptRegisteredRepositionOnlyEntity())
{
if(m_RegisteredEntityFromScript.pEnt)
{
//assign this reposition only, as this is a ig version of the cutscene
m_pEntityForRepositionOnly = m_RegisteredEntityFromScript.pEnt;
SetRepositionOnlyEntityReadyForCutscene();
}
}
}
}
}
#if !__NO_OUTPUT
void CCutsceneAnimatedModelEntity::CommonDebugStr(const cutfObject* pObject, char * debugStr)
{
if (!pObject)
{
return;
}
CutSceneManager::CommonDebugStr(debugStr); // first write in cutscene manager debug
sprintf(debugStr, "%sModel Entity(%p, %d, %s), G-Ent(%p, %s), RO-Ent(%p, %s) - ",
debugStr,
pObject,
pObject->GetObjectId(),
m_SceneHandleHash.TryGetCStr(),
GetGameEntity(),
m_ModelNameHash.TryGetCStr(),
GetGameRepositionOnlyEntity(),
m_RegisteredEntityFromScript.ModelNameHash.TryGetCStr());
}
#endif // !__NO_OUTPUT
void CCutsceneAnimatedModelEntity::CreateRepositionOnlyGameEntityWhenModelLoaded(cutsManager* pManager, const cutfObject* pObject, bool bRequestVariations, bool bApplyVariations)
{
if(m_bRequestRepositionOnlyEntity && m_pEntityForRepositionOnly == NULL)
{
CutSceneManager* pCutsManager = static_cast<CutSceneManager*>(pManager);
//set the model index to invalid and then check that we have made a request, if not the model index will remain at zero
s32 iModelIndex = strLocalIndex::INVALID_INDEX;
pCutsManager->GetAssetManager()->GetModelStreamingRequestId(pObject->GetObjectId(), m_RegisteredEntityFromScript.ModelNameHash, iModelIndex);
if(iModelIndex != strLocalIndex::INVALID_INDEX)
{
if(pCutsManager->GetAssetManager()->HasRequestedModelLoaded(pObject->GetObjectId(), m_RegisteredEntityFromScript.ModelNameHash))
{
cutsceneModelEntityDebugf2("CreateRepositionOnlyGameEntity - Actor - bRequestVariations(%s), bApplyVariations(%s)", bRequestVariations ? "T" : "F", bApplyVariations ? "T" : "F");
CreateGameEntity(strLocalIndex(iModelIndex), true, bRequestVariations, bApplyVariations);
SetRepositionOnlyEntityReadyForCutscene();
m_RegisteredEntityFromScript.pEnt = m_pEntityForRepositionOnly;
pCutsManager->GetAssetManager()->RemoveStreamingRequest(pObject->GetObjectId(), true, MODEL_TYPE, m_RegisteredEntityFromScript.ModelNameHash);
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedModelEntity::CreateAnimatedEntityWhenModelLoaded(cutsManager* pManager, const cutfObject* pObject, bool bRequestVariations, bool bApplyVariations)
{
if(m_RegisteredEntityFromScript.bAppearInScene)
{
CutSceneManager* pCutsManager = static_cast<CutSceneManager*>(pManager);
if (pCutsManager->GetAssetManager()->HasRequestedModelLoaded(pObject->GetObjectId(), m_ModelNameHash))
{
cutsceneModelEntityDebugf2("CreateAnimatedEntity - Actor - Model Loaded - bRequestVariations(%s), bApplyVariations(%s)", bRequestVariations ? "T" : "F", bApplyVariations ? "T" : "F");
//set the model index to invalid and then check that we have made a request, if not the model index will remain at zero
s32 iModelIndex = strLocalIndex::INVALID_INDEX;
//we are now creating our game entity just before we play an anim on it
if(pCutsManager->GetAssetManager()->GetModelStreamingRequestId(pObject->GetObjectId(), m_ModelNameHash, iModelIndex))
{
m_vCreatePos = pCutsManager->GetSceneOffset();
CreateGameEntity(strLocalIndex(iModelIndex), false, bRequestVariations, bApplyVariations);
if(m_RegisteredEntityFromScript.bCreatedForScript)
{
if(m_RegisteredEntityFromScript.pEnt == NULL)
{
if(IsScriptRegisteredGameEntity())
{
if(GetGameEntity())
{
m_RegisteredEntityFromScript.pEnt = m_pEntity;
}
}
else
{
if(IsScriptRegisteredRepositionOnlyEntity())
{
if(GetGameRepositionOnlyEntity())
{
m_RegisteredEntityFromScript.pEnt = m_pEntityForRepositionOnly;
}
}
}
}
}
m_HasBeenDeletedByCutscene = false;
}
}
}
}
CTaskCutScene* CCutsceneAnimatedModelEntity::GetCutsceneTaskForEntity()
{
CTask* pTask = NULL;
if(GetGameEntity())
{
if(GetGameEntity()->GetIsTypeObject())
{
const CObject* pObject = static_cast<CObject*>(GetGameEntity());
if(pObject->GetObjectIntelligence())
{
pTask = pObject->GetObjectIntelligence()->FindTaskByType(CTaskTypes::TASK_CUTSCENE);
}
}
if(GetGameEntity()->GetIsTypeVehicle())
{
const CVehicle* pVeh = static_cast<CVehicle*>(GetGameEntity());
if( pVeh->GetIntelligence() && pVeh->GetIntelligence()->GetTaskManager())
{
aiTask* CurrentVehicleTask = pVeh->GetIntelligence()->GetTaskManager()->GetTree(VEHICLE_TASK_TREE_SECONDARY)->GetTask(VEHICLE_TASK_SECONDARY_ANIM);
if(CurrentVehicleTask && CurrentVehicleTask->GetTaskType() == CTaskTypes::TASK_CUTSCENE)
{
pTask = static_cast<CTask*>(CurrentVehicleTask);
}
}
}
if(GetGameEntity()->GetIsTypePed())
{
CPed* pPed = static_cast<CPed*>(GetGameEntity());
if(pPed->GetPedIntelligence())
{
pTask = pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_CUTSCENE);
}
}
}
if(pTask)
{
CTaskCutScene* pCutScene = static_cast<CTaskCutScene*>(pTask);
return pCutScene;
}
return NULL;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedModelEntity::DispatchEvent( cutsManager* pManager, const cutfObject* pObject, s32 iEventId, const cutfEventArgs* pEventArgs, const float UNUSED_PARAM(fTime), const u32 UNUSED_PARAM(StickyId) )
{
switch ( iEventId )
{
case CUTSCENE_START_OF_SCENE_EVENT:
{
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*> (pManager);
m_ExitSceneTime = pCutSceneManager->GetTotalSeconds();
//register the player
if (!NetworkInterface::IsGameInProgress())
RegisterPlayer(pManager, pObject);
//possibly need to set the object matrix to be the same as the local space
SetUpScriptRegisteredEntity(pManager, pObject);
//create any cutscene animated entities that were loaded before the cutscene starts
CreateAnimatedEntityWhenModelLoaded(pManager, pObject, true, true);
//create any reposition only entities that were loaded before the cutscene starts
//CreateRepositionOnlyGameEntityWhenModelLoaded(pManager, pObject, true, true);
//Set the entity game ready to enter the scene
SetGameEntityReadyForCutscene();
if (GetGameEntity() )
{
if (pObject)
{
cutsceneModelEntityDebugf2("CUTSCENE_START_OF_SCENE_EVENT");
}
//have a game side object
if(GetGameEntity())
{
if(m_pClip)
{
SetVisibility(GetGameEntity(), true);
cutsceneModelEntityDebugf2("CUTSCENE_START_OF_SCENE_EVENT: Showing GetGameEntity (%s)", GetGameEntity()->GetModelName());
}
else
{
SetVisibility(GetGameEntity(), false);
cutsceneModelEntityDebugf2("CUTSCENE_START_OF_SCENE_EVENT: Hiding GetGameEntity (%s)", GetGameEntity()->GetModelName());
}
}
}
}
break;
case CUTSCENE_SKIPPED_EVENT:
{
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*> (pManager);
// Is a reposition only entity model needed
RequestRepositionOnlyEntityModelWhenNeeded(pCutSceneManager, pObject);
if( GetGameEntity() && GetGameEntity()->GetIsTypePed() )
{
CPed* pPed = static_cast<CPed*>(GetGameEntity());
if( pPed )
{
for( int i = 0; i < PV_MAX_COMP; ++i )
{
if( pPed->m_CClothController[i] )
{
pPed->m_CClothController[i]->SetFlag( characterClothController::enIsQueuedPinning, true );
}
}
} // end if( pPed )
}
}
break;
case CUTSCENE_UPDATE_EVENT:
{
if( m_bUpdateCollisionBound )
{
CEntity* pEntity = GetGameEntity();
if( pEntity )
{
crSkeleton* pSkel = pEntity->GetSkeleton();
if( pSkel )
{
Mat34V rootBoneMat;
pSkel->GetGlobalMtx(0, rootBoneMat);
Vec3V col1 = rootBoneMat.GetCol1();
rootBoneMat.SetCol1( rootBoneMat.GetCol0() );
rootBoneMat.SetCol0( col1 );
Assert( m_CollisionBound );
m_CollisionBound->SetCurrentMatrix(0, rootBoneMat);
}
}
}
if (m_bIsReadyForGame)
{
return;
}
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*> (pManager);
// Is a reposition only entity model needed? Check if we are n seconds before the scene ends
if (pCutSceneManager->GetCutSceneCurrentTime() > (m_ExitSceneTime - DEFAULT_STREAMING_OFFSET))
{
RequestRepositionOnlyEntityModelWhenNeeded(pCutSceneManager, pObject);
}
// RequestRepositionOnlyEntityModel is called on skip or n seconds before the scene ends
// Created a reposition only game entity during the cutscene (as opposed to before the cutscene or after it ends)
CreateRepositionOnlyGameEntityWhenModelLoaded(pManager, pObject, true, true);
// Has the associated entity (ped/vehicle/prop) been created?
if(GetGameEntity())
{
m_CurrentPosition = VEC3V_TO_VECTOR3(m_pEntity->GetTransform().GetPosition());
m_CurrentHeading = m_pEntity->GetTransform().GetHeading();
atHashString modelHash(GetModelNameHash());
// the streaming request has been removed we can now delete the object managed by this entity
if (!pCutSceneManager->GetAssetManager()->IsModelInRequestList(pObject->GetObjectId(), modelHash))
{
if(!IsScriptRegisteredGameEntity() || (IsScriptRegisteredGameEntity() && m_RegisteredEntityFromScript.bDeleteBeforeEnd))
{
if(GetGameEntity()->GetIsTypeVehicle())
{
//set it to be ambient so it can be deleted by the population cont
CVehicle* pVeh = static_cast<CVehicle*>(GetGameEntity());
pVeh->PopTypeSet(POPTYPE_RANDOM_AMBIENT);
}
if(GetGameEntity()->GetIsTypePed())
{
//set it to be ambient so it can be deleted by the population cont
CPed* pPed = static_cast<CPed*>(GetGameEntity());
pPed->PopTypeSet(POPTYPE_RANDOM_AMBIENT);
}
cutsceneModelEntityDebugf2("CUTSCENE_UPDATE_EVENT - Deleting entity as its model is no longer in the request list.");
#if !__NO_OUTPUT
if(GetGameEntity()->GetIsPhysical() && m_bIsloggingEntityCalls)
{
((CPhysical*)GetGameEntity())->m_LogDeletions = false;
}
#endif
GetGameEntity()->FlagToDestroyWhenNextProcessed();
GetGameEntity()->DisableCollision();
SetVisibility(GetGameEntity(), false);
cutsceneModelEntityDebugf2("CUTSCENE_UPDATE_EVENT: Show GetGameEntity (%s)", GetGameEntity()->GetModelName());
m_pEntity = NULL;
m_pCutSceneTask = NULL;
m_HasBeenDeletedByCutscene = true;
}
}
}
else
{
//
// The associated entity (ped/vehicle/prop) has not been created yet?
//
// Do script want us to create the associated entity (e.g. the character is dead and therefore not needed in the scene)
if(m_RegisteredEntityFromScript.bAppearInScene)
{
bool bCanCreate = false;
// If the script has not "registered" the game entity we can create the ped
if(!IsScriptRegisteredGameEntity())
{
bCanCreate = true;
}
else
{
// If the script has "registered" the game entity. Script can decide if they want
// the cutscene to create the reposition only entity or if they want to create it themselves
bCanCreate = m_RegisteredEntityFromScript.bCreatedForScript;
}
// Check we are not under script control (in the exit state)
if(!m_bIsRegisteredEntityScriptControlled)
{
if(cutsceneVerifyf(m_HasBeenDeletedByCutscene || bCanCreate, "The registered entity %s owned by the cutscene has been deleted whilst the scene active", pObject->GetDisplayName().c_str()))
{
// Created an animated actor during the cutscene (as opposed to before the cutscene or after it ends)
CreateAnimatedEntityWhenModelLoaded( pManager, pObject, true, true);
SetGameEntityReadyForCutscene();
//have a game side object
if(GetGameEntity())
{
if(m_pClip)
{
PlayClip(pCutSceneManager, m_pClip, pManager->GetSectionStartTime(pManager->GetCurrentSection()), m_AnimDict);
ComputeScriptVisibleTagsOnAnimSet(pCutSceneManager);
SetVisibility(GetGameEntity(), true);
cutsceneModelEntityDebugf2("CUTSCENE_UPDATE_EVENT: Showing GetGameEntity (%s)", GetGameEntity()->GetModelName());
}
else
{
SetVisibility(GetGameEntity(), false);
cutsceneModelEntityDebugf2("CUTSCENE_UPDATE_EVENT: Hiding GetGameEntity (%s)", GetGameEntity()->GetModelName());
}
cutsceneModelEntityDebugf2("CUTSCENE_UPDATE_EVENT - Created entity.");
}
}
}
}
}
ComputeScriptVisibleTagsOnUpdate(pCutSceneManager);
m_bClearedOrSetAnimThisFrame = false;
}
break;
case CUTSCENE_DICTIONARY_LOADED_EVENT:
{
if (m_ExitSceneTime==pManager->GetTotalSeconds())
{
const cutsDictionaryLoadedEventArgs *pDictEventArgs = static_cast<const cutsDictionaryLoadedEventArgs *>( pEventArgs );
crClipDictionary* pDict = pDictEventArgs->GetDictionary();
if (pDict && pObject)
{
if(pObject->GetAnimStreamingType() == CUTSCENE_NAMED_STREAMED_ANIMATED_OBJECT )
{
const cutfNamedAnimatedStreamedObject* pAnimNamedStreamed = static_cast<const cutfNamedAnimatedStreamedObject*>(pObject);
u32 animBaseHash = pAnimNamedStreamed->GetAnimStreamingBase();
s32 iSectionIndex = pDictEventArgs->GetSection();
char indexBuff[8];
formatf(indexBuff, 8, "-%d", iSectionIndex);
atHashString FinalHash = atStringHash(indexBuff, animBaseHash);
crClip* pClip = pDict->GetClip(FinalHash);
if (pClip)
{
// search for the
const crTag* pTag = CClipEventTags::FindFirstEventTag(pClip, CClipEventTags::TagSyncBlendOut);
if(pTag)
{
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*> (pManager);
m_ExitSceneTime = pCutSceneManager->GetSectionStartTime(pDictEventArgs->GetSection()) + pClip->ConvertPhaseToTime(pTag->GetStart());
}
}
}
}
}
}
break;
case CUTSCENE_SET_CLIP_EVENT:
{
if (m_bIsReadyForGame)
{
return;
}
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*> (pManager);
// set the clip and the initial playback time
if (pEventArgs && pEventArgs->GetType() == CUTSCENE_CLIP_EVENT_ARGS_TYPE )
{
const cutsClipEventArgs *pClipEventArgs = static_cast<const cutsClipEventArgs *>( pEventArgs );
//store the clip dictionary and anim dict we may not have an object to play an anim on yet
const crClip* pClip = pClipEventArgs->GetClip();
if(pClip != NULL)
{
pClip->AddRef();
}
if(m_pClip != NULL)
{
ComputeScriptVisibleTagsOnAnimClear(pCutSceneManager);
m_pClip->Release();
}
m_pClip = pClip;
m_SectionAnimWasRecieved = pCutSceneManager->GetCurrentSection();
formatf(m_AnimDict, sizeof(m_AnimDict), pClipEventArgs->GetAnimDict());
cutsceneAssertf(m_pClip, "CUTSCENE_SET_CLIP_EVENT has a null clip on %s, anim dict %s",
pObject->GetDisplayName().c_str(), pClipEventArgs->GetAnimDict());
//Here we have a created our own cut scene object
CutSceneManager* pCutManager = static_cast<CutSceneManager*>(pManager);
if(GetGameEntity())
{
PlayClip(pCutManager, pClipEventArgs->GetClip(), pManager->GetSectionStartTime(pManager->GetCurrentSection()), pClipEventArgs->GetAnimDict());
ComputeScriptVisibleTagsOnAnimSet(pCutManager);
SetVisibility(GetGameEntity(), true);
cutsceneModelEntityDebugf2("SET_CLIP_EVENT: Showing GetGameEntity (%s)", GetGameEntity()->GetModelName());
}
cutsceneModelEntityDebugf2("SET_CLIP_EVENT %s : pClip:%s", pClipEventArgs->GetAnimDict(), m_pClip ? m_pClip->GetName() : "Clip not found!");
}
else
{
cutsceneModelEntityDebugf2("NO_SET_CLIP_EVENT");
}
}
break;
case CUTSCENE_SCENE_ORIENTATION_CHANGED_EVENT:
{
if (m_bIsReadyForGame)
{
return;
}
CTaskCutScene* pTask = GetCutsceneTaskForEntity();
if(pTask)
{
Matrix34 SceneMat;
pManager->GetSceneOrientationMatrix(SceneMat);
pTask->SetAnimOrigin(SceneMat);
}
}
break;
case CUTSCENE_CLEAR_ANIM_EVENT:
{
cutsceneModelEntityDebugf2("CUTSCENE_CLEAR_ANIM_EVENT");
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*> (pManager);
bool bDuringCutscene = (pCutSceneManager->GetCutSceneCurrentTime() > pCutSceneManager->GetStartTime()) && (pCutSceneManager->GetCutSceneCurrentTime() < pCutSceneManager->GetEndTime());
ComputeScriptVisibleTagsOnAnimClear(pCutSceneManager);
if(m_pClip != NULL)
{
m_pClip->Release();
m_pClip = NULL;
}
if (bDuringCutscene)
{
if (m_pCutSceneTask)
{
Matrix34 SceneMat;
pManager->GetSceneOrientationMatrix(SceneMat);
m_pCutSceneTask->SetClip(m_pClip,SceneMat, 0.0f);
}
}
if (m_bIsReadyForGame)
{
return;
}
if(bDuringCutscene)
{
// stop event has been called already and the ped is being returned to the game don't set them to be invisible.
if(GetGameEntity() && !m_bStoppedCalled)
{
SetVisibility(GetGameEntity(), false);
cutsceneModelEntityDebugf2("CUTSCENE_CLEAR_ANIM_EVENT: Hiding GetGameEntity (%s)", GetGameEntity()->GetModelName());
}
}
}
break;
case CUTSCENE_END_OF_SCENE_EVENT:
{
m_CollisionBound = NULL;
m_bUpdateCollisionBound = false;
cutsceneModelEntityDebugf2("CUTSCENE_END_OF_SCENE_EVENT");
// make sure our entity has been returned to game mode if necessary
SetGameEntityReadyForGame(pManager);
DeleteNonRegisteredEntities();
// Force update the ai for the ped so we don't see the final frame twice
if (GetGameEntity() && GetCutsceneTaskForEntity())
{
cutsceneModelEntityDebugf2("CUTSCENE_END_OF_SCENE_EVENT - Force AI Update");
ForceUpdateAi(pManager);
}
}
break;
case CUTSCENE_STOP_EVENT:
{
cutsceneModelEntityDebugf3("CUTSCENE_STOP_EVENT");
m_bStoppedCalled = true;
}
break;
case CUTSCENE_RESTART_EVENT:
{
m_pCutSceneTask = NULL;
}
break;
case CutSceneCustomEvents::CUTSCENE_CUSTOM_CLOTH_EVENT:
{
//cutsceneModelEntityDebugf("CCutsceneAnimatedModelEntity::DispatchEvent: CUTSCENE_CUSTOM_CLOTH_EVENT");
const CutSceneCustomEvents::ICutsceneCustomCustomEventArgs* pObjectVar = static_cast<const CutSceneCustomEvents::ICutsceneCustomCustomEventArgs*>(pEventArgs);
CEntity* pEntity = GetGameEntity();
if ( pEntity && pObjectVar
&& pObjectVar->GetEventType() == CCEVENT_TYPE_CUSTOM_0
)
{
crSkeleton* pSkel = pEntity->GetSkeleton();
if( pSkel )
{
Mat34V rootBoneMat;
pSkel->GetGlobalMtx(0, rootBoneMat);
atHashString ModelNameHash("cs_mrs_thornhill");
CCutsceneAnimatedModelEntity* pAnimatedModel = ((CutSceneManager*)pManager)->GetAnimatedModelEntityFromModelHash(ModelNameHash);
CEntity* pEntity = pAnimatedModel->GetGameEntity();
if( pEntity && pEntity->GetIsTypePed() )
{
CPed* pPed = static_cast<CPed*>(pEntity);
if( pPed )
{
for( int i = 0; i < PV_MAX_COMP; ++i )
{
if( pPed->m_CClothController[i] )
{
phVerletCloth* pVerletCloth = pPed->m_CClothController[i]->GetCloth(0);
Assert( pVerletCloth );
if( !pVerletCloth->m_VirtualBound )
{
float fCapsuleLen = pObjectVar->GetCapsuleLength();
float fCapsuleRad = pObjectVar->GetCapsuleRadius();
pVerletCloth->SetFlag(phVerletCloth::FLAG_COLLIDE_EDGES, true);
pVerletCloth->SetFlag(phVerletCloth::FLAG_IGNORE_OFFSET, true);
pVerletCloth->CreateVirtualBound( 1, &identityMat );
pVerletCloth->AttachVirtualBoundCapsule( fCapsuleRad, fCapsuleLen, rootBoneMat, 0 );
m_CollisionBound = (phBoundComposite*)pVerletCloth->m_VirtualBound.ptr;
#if USE_CAPSULE_EXTRA_EXTENTS
Assert( m_CollisionBound );
phBound* pColBound = m_CollisionBound->GetBound(0);
Assert( pColBound );
static float fCapsuleHalfHeight = 0.15f;
((phBoundCapsule*)pColBound)->SetHalfHeight( fCapsuleHalfHeight );
#endif
m_bUpdateCollisionBound = true;
}
}
}
} // if( pPed )
}
} // if( pSkel )
}
break;
}
case CUTSCENE_SET_ANIMATION_EVENT:
case CUTSCENE_PLAY_EVENT:
case CUTSCENE_PAUSE_EVENT:
case CUTSCENE_UPDATE_LOADING_EVENT:
case CUTSCENE_STEP_FORWARD_EVENT:
case CUTSCENE_STEP_BACKWARD_EVENT:
case CUTSCENE_FAST_FORWARD_EVENT:
case CUTSCENE_REWIND_EVENT:
break;
}
//this is here to dispatch debug draw event for this entity.
#if __BANK
cutsEntity::DispatchEvent(pManager, pObject, iEventId, pEventArgs);
#endif
}
#if !__NO_OUTPUT
XPARAM(cutscenecallstacklogging);
#endif //!__NO_OUTPUT
#if !__NO_OUTPUT
void CCutsceneAnimatedModelEntity::SetUpEntityForCallStackLogging()
{
if(GetGameEntity() && GetGameEntity()->GetIsPhysical())
{
if(PARAM_cutscenecallstacklogging.Get() BANK_ONLY (&& (CutSceneManager::GetInstance() && CutSceneManager::GetInstance()->IsCallStackLogging())) )
{
CPhysical* phys = static_cast<CPhysical*>(GetGameEntity());
phys->m_LogSetMatrixCalls = true;
phys->m_LogVisibiltyCalls = true;
phys->m_LogDeletions = true;
phys->m_LogVariationCalls = true;
m_bIsloggingEntityCalls = true;
}
}
};
#endif //!__NO_OUTPUT
#if !__NO_OUTPUT
void CCutsceneAnimatedModelEntity::ResetEntityForCallStackLogging()
{
if(GetGameEntity() && GetGameEntity()->GetIsPhysical())
{
if(PARAM_cutscenecallstacklogging.Get() BANK_ONLY (&& (CutSceneManager::GetInstance() && CutSceneManager::GetInstance()->IsCallStackLogging())) )
{
CPhysical* phys = static_cast<CPhysical*>(GetGameEntity());
phys->m_LogSetMatrixCalls = false;
phys->m_LogVisibiltyCalls = false;
phys->m_LogDeletions = false;
phys->m_LogVariationCalls = false;
m_bIsloggingEntityCalls = false;
}
}
};
#endif //!__NO_OUTPUT
bool CCutsceneAnimatedModelEntity::HasScriptVisibleTagPassed(s32 TagHash)
{
for(int i=0; i < SIZE_OF_SCRIPT_VISIBLE_TAG_LIST; i++)
{
if(m_ScriptVisibleTags[i] != 0)
{
if(m_ScriptVisibleTags[i] == TagHash)
{
return true;
}
}
}
return false;
}
void CCutsceneAnimatedModelEntity::ResetScriptVisibleTags()
{
for(int i=0; i < SIZE_OF_SCRIPT_VISIBLE_TAG_LIST; i++)
{
m_ScriptVisibleTags[i] = 0;
}
}
void CCutsceneAnimatedModelEntity::FindScriptVisibleTags(const crClip* pClip, float startPhase, float endPhase)
{
if(m_FrameTagsAreProcessed != fwTimer::GetFrameCount())
{
ResetScriptVisibleTags();
m_FrameTagsAreProcessed = fwTimer::GetFrameCount();
}
startPhase = Clamp(startPhase, 0.0f, 1.0f);
endPhase = Clamp(endPhase, 0.0f, 1.0f);
crTagIterator it(*pClip->GetTags(), startPhase, endPhase, ms_VisibleToScriptKey);
int numOfTags =0;
while (*it)
{
const crTag* pTag = *it;
if(pTag)
{
const crPropertyAttribute* pAttr = pTag->GetAttribute(ms_EventKey );
if(pAttr && pAttr->GetType() == crPropertyAttribute::kTypeHashString)
{
const crPropertyAttributeHashString *pAttrHashString = static_cast< const crPropertyAttributeHashString * >(pAttr);
for(int i=0; i < SIZE_OF_SCRIPT_VISIBLE_TAG_LIST; i++)
{
if(m_ScriptVisibleTags[i] == 0)
{
m_ScriptVisibleTags[i] = pAttrHashString->GetHashString().GetHash();
cutsceneModelEntityDebugf3("Found Script Visible Tag: %s (%d) in Clip: %s between phases: (s:%f , e:%f)",
pAttrHashString->GetHashString().TryGetCStr(), pAttrHashString->GetHashString().GetHash(), m_pClip->GetName(), startPhase, endPhase);
break;
}
}
}
}
++it;
numOfTags++;
}
cutsceneAssertf(numOfTags < SIZE_OF_SCRIPT_VISIBLE_TAG_LIST, "Found more than %d script visible tags between phases: %f, %f for clip: %s ", SIZE_OF_SCRIPT_VISIBLE_TAG_LIST, startPhase, endPhase, pClip->GetName());
}
void CCutsceneAnimatedModelEntity::ComputeScriptVisibleTagsOnAnimClear(CutSceneManager* pCutSceneManager)
{
if (m_pClip && m_bShouldProcessTags)
{
if(!pCutSceneManager->IsConcatted())
{
float startPhase = (pCutSceneManager->GetCutScenePreviousTime() - m_fStartTime) / m_pClip->GetDuration();
if(startPhase != 1.0f)
{
FindScriptVisibleTags(m_pClip, startPhase, 1.0f);
cutsceneModelEntityDebugf3("Non Concat - ComputeScriptVisibleTagsOnAnimClear: %s (s:%f , e:%f)", m_pClip->GetName(), startPhase, 1.0f);
}
}
else
{
//compute anim phases based on concat boundaries
s32 currentConcatSection = pCutSceneManager->GetConcatSectionForTime(pCutSceneManager->GetCutSceneCurrentTime());
s32 previousConcatSection = pCutSceneManager->GetConcatSectionForTime(pCutSceneManager->GetCutScenePreviousTime());
if(currentConcatSection != previousConcatSection && ((currentConcatSection-previousConcatSection) > 1))
{
//compute the anim end time based concat boundary of the next concat section
float animEndEndTime = pCutSceneManager->GetConcatSectionStartTime(previousConcatSection + 1);
float endPhase = (animEndEndTime - m_fStartTime) / m_pClip->GetDuration();
float startPhase = (pCutSceneManager->GetCutScenePreviousTime() - m_fStartTime) / m_pClip->GetDuration();
if(endPhase != startPhase)
{
FindScriptVisibleTags(m_pClip, startPhase, endPhase);
cutsceneModelEntityDebugf3("Concat Boundary - ComputeScriptVisibleTagsOnAnimClear: %s (s:%f , e:%f)", m_pClip->GetName(), startPhase, endPhase);
}
}
else
{
//search for tags to the end of the anim, still in the same concat section
float startPhase = (pCutSceneManager->GetCutScenePreviousTime() - m_fStartTime) / m_pClip->GetDuration();
float endPhase = (pCutSceneManager->GetCutSceneCurrentTime() - m_fStartTime) / m_pClip->GetDuration();
endPhase = Clamp(endPhase, startPhase, 1.0f);
if(startPhase != endPhase)
{
FindScriptVisibleTags(m_pClip, startPhase, endPhase);
cutsceneModelEntityDebugf3("Concat Non-Boundary - ComputeScriptVisibleTagsOnAnimClear: %s (s:%f , e:%f)", m_pClip->GetName(), startPhase, endPhase);
}
}
}
m_bClearedOrSetAnimThisFrame = true;
}
}
void CCutsceneAnimatedModelEntity::ComputeScriptVisibleTagsOnUpdate(CutSceneManager* pCutSceneManager)
{
if (m_pClip && !m_bClearedOrSetAnimThisFrame && m_bShouldProcessTags)
{
float startPhase = (pCutSceneManager->GetCutScenePreviousTime() - m_fStartTime) / m_pClip->GetDuration();
float endPhase = (pCutSceneManager->GetCutSceneCurrentTime() - m_fStartTime) / m_pClip->GetDuration();
if(endPhase != startPhase)
{
FindScriptVisibleTags(m_pClip, startPhase, endPhase);
}
}
}
void CCutsceneAnimatedModelEntity::ComputeScriptVisibleTagsOnAnimSet(CutSceneManager* pCutSceneManager)
{
if (m_pClip)
{
m_bShouldProcessTags = false;
const crTag* pTag = CClipEventTags::FindFirstEventTag(m_pClip, ms_VisibleToScriptKey);
if(pTag)
{
m_bShouldProcessTags = true;
}
if(m_bShouldProcessTags)
{
if(!pCutSceneManager->IsConcatted())
{
//get the last anim phase
//set end phase = 1.0f we are about to get a new anim
float endPhase = (pCutSceneManager->GetCutSceneCurrentTime() - m_fStartTime) / m_pClip->GetDuration();
if(endPhase != 0.0f)
{
FindScriptVisibleTags(m_pClip, 0.0f, endPhase);
cutsceneModelEntityDebugf3("Non Concat - ComputeScriptVisibleTagsOnAnimSet: %s (s:%f , e:%f)", m_pClip->GetName(), 0.0f, endPhase );
}
}
else
{
float previousTime = pCutSceneManager->GetCutScenePreviousTime();
if(pCutSceneManager->GetInternalTime() == pCutSceneManager->GetStartTime())
{
if(!pCutSceneManager->IsConcatSectionValidForPlayBack(0))
{
previousTime = -1.0f;
}
}
//Crossed a concat boundary compute the tag from the start of concat boundary to the current time
s32 currentConcatSection = pCutSceneManager->GetConcatSectionForTime(pCutSceneManager->GetCutSceneCurrentTime());
s32 previousConcatSection = pCutSceneManager->GetConcatSectionForTime(previousTime);
if(currentConcatSection != previousConcatSection && ((currentConcatSection-previousConcatSection) > 1))
{
//we compute the phase from this point into the anim
float concatStartTime = pCutSceneManager->GetConcatSectionStartTime(currentConcatSection);
s32 currentAnimSection = pCutSceneManager->GetSectionForTime( pCutSceneManager->GetCutSceneCurrentTime() );
float animSectionStartTime = pCutSceneManager->GetSectionStartTime(currentAnimSection);
float startPhase = 0.0f;
float endPhase = 0.0f;
//The start of the concat section is further on in time so need to calculate the phase of the anim relative to the concat section
//because it's the concat section that defines what to play not the anim section. Other wise the anim time is in a valid part of the
//concat so just use a start phase of zero and whatever has progressed.
//Showing how anim and cocnat sections can vary.
//e.g anim section: Start:0 | A1 end: 10 | A2 end:20| A3 end:30|
// concat section start:0 | end 12| end:18| end:30|
if(concatStartTime >= animSectionStartTime)
{
startPhase = (concatStartTime - animSectionStartTime) / m_pClip->GetDuration();
}
endPhase = (pCutSceneManager->GetCutSceneCurrentTime() - animSectionStartTime) / m_pClip->GetDuration();
if(endPhase != startPhase)
{
FindScriptVisibleTags(m_pClip, startPhase, endPhase);
cutsceneModelEntityDebugf3("Concat Boundary - ComputeScriptVisibleTagsOnAnimSet: %s (s:%f , e:%f)", m_pClip->GetName(), startPhase, endPhase );
}
}
else
{
float startPhase = (pCutSceneManager->GetCutScenePreviousTime() - m_fStartTime) / m_pClip->GetDuration();
float endPhase = (pCutSceneManager->GetCutSceneCurrentTime() - m_fStartTime) / m_pClip->GetDuration();
startPhase = Clamp(startPhase, 0.0f, endPhase);
if(endPhase != startPhase)
{
FindScriptVisibleTags(m_pClip, startPhase, endPhase);
}
cutsceneModelEntityDebugf3("Concat Non Boundary - ComputeScriptVisibleTagsOnAnimSet: %s (s:%f , e:%f)", m_pClip->GetName(), startPhase, endPhase );
}
}
}
m_bClearedOrSetAnimThisFrame = true;
}
}
//////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedModelEntity::RequestRepositionOnlyEntityModelWhenNeeded(CutSceneManager* pManager, const cutfObject* pObject)
{
// check if we want to request a reposition only entity
if (!IsScriptRegisteredGameEntity() // check that script have not registered this as a game entity
&& IsScriptRegisteredRepositionOnlyEntity() // check that script have registered this as a reposition only entity
&& !m_RegisteredEntityFromScript.pEnt // check the entity has not been assigned to script already
&& m_pEntityForRepositionOnly == NULL // reposition entity has not been made yet
&& m_RegisteredEntityFromScript.bCreatedForScript // entity is to be created by the cutscene for the script
&& !m_bRequestRepositionOnlyEntity // request has not been made yet
)
{
cutsceneModelEntityDebugf2("RequestRepositionOnlyEntityModel ------------------------------------------- ");
// add the streaming request
pManager->GetAssetManager()->SetModelStreamingRequest(m_RegisteredEntityFromScript.ModelNameHash, pObject->GetObjectId(), MODEL_TYPE);
m_bRequestRepositionOnlyEntity = true;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedModelEntity::SetAnimPlayBackEventTime(float fEventTime)
{
m_fStartTime = fEventTime;
}
void CCutsceneAnimatedModelEntity::GetMoverTrackVelocity(const crClip* pClip, float fCurrentPhase, float fLastPhase, float fTimeStep)
{
if(m_pEntity)
{
if(fTimeStep > 0.0f)
{
if(pClip)
{
const float time = pClip->ConvertPhaseToTime(fCurrentPhase);
const float timeOnPreviousUpdate = pClip->ConvertPhaseToTime(fLastPhase);
bool bIsWarpFrame = pClip->CalcBlockPassed(timeOnPreviousUpdate, time);
if (bIsWarpFrame)
{
m_vVelocity.Zero();
}
else
{
m_vVelocity = fwAnimHelpers::GetMoverTrackDisplacement(*pClip, fLastPhase, fCurrentPhase);
m_vVelocity /= fTimeStep;
}
//printf("CCutsceneAnimatedModelEntity::GetMoverTrackVelocity: %s, m_vVelocity: %.2f, %.2f, %.2f, Phases: %.2f - %.2f\n", pClip->GetName(), m_vVelocity.x, m_vVelocity.y, m_vVelocity.z, fLastPhase, fCurrentPhase);
}
else
{
m_vVelocity.Zero();
}
cutsceneAssertf(rage::FPIsFinite(m_vVelocity.x), "Exit x velocity from cutscene is not finite" );
cutsceneAssertf(rage::FPIsFinite(m_vVelocity.y), "Exit y velocity from cutscene is not finite" );
cutsceneAssertf(rage::FPIsFinite(m_vVelocity.z), "Exit z velocity from cutscene is not finite" );
Matrix34 mEntityMat = MAT34V_TO_MATRIX34(m_pEntity->GetMatrix());
mEntityMat.Transform3x3(m_vVelocity);
}
}
}
void CCutsceneAnimatedModelEntity::UpdateCutSceneTaskPhase(CTask* pTask, cutsManager* pManager)
{
CutSceneManager* pCutsManager = static_cast<CutSceneManager*>(pManager);
if(ShouldUpdateCutSceneTask(pTask, pManager))
{
if(pTask && pTask->GetTaskType() == CTaskTypes::TASK_CUTSCENE)
{
CTaskCutScene* pCutSceneTask = static_cast<CTaskCutScene*>(pTask);
const crClip* pClip = pCutSceneTask->GetClip();
if (pClip)
{
float fPhase = pCutsManager->GetPhaseUpdateAmount(pClip, GetAnimEventStartTime());
pCutSceneTask->SetPhase(fPhase);
if(pCutSceneTask->WillFinishThisPhase(fPhase))
{
cutsceneModelEntityDebugf1("CUTSCENE_BLEND_OUT_TAG");
m_bStoppedCalled = true;
}
}
}
}
}
bool CCutsceneAnimatedModelEntity::ShouldUpdateCutSceneTask(CTask* pTask, cutsManager* pManager)
{
CutSceneManager* pCutsManager = static_cast<CutSceneManager*>(pManager);
if(m_SectionAnimWasRecieved != pCutsManager->GetCurrentSection())
{
if(pTask && pTask->GetTaskType() == CTaskTypes::TASK_CUTSCENE)
{
CTaskCutScene* pCutSceneTask = static_cast<CTaskCutScene*>(pTask);
pCutSceneTask->SetPhase(1.0f);
}
return false;
}
return true;
}
bool CCutsceneAnimatedModelEntity::RemoveEntityFromTheWorld(CEntity* pEntity, bool bDeleteScriptRegistered)
{
bool ShouldRemove = false;
if (pEntity)
{
bool CanDelete = m_RegisteredEntityFromScript.pEnt != pEntity || bDeleteScriptRegistered;
if(CanDelete|| m_RegisteredEntityFromScript.bDeleteBeforeEnd)
{
cutsceneModelEntityDebugf2("RemoveEntityFromWorld");
if(pEntity->GetIsPhysical())
{
//about to delete a script registered object
CTheScripts::UnregisterEntity((CPhysical*)pEntity, true);
}
#if !__NO_OUTPUT
if(pEntity->GetIsPhysical() && m_bIsloggingEntityCalls)
{
((CPhysical*)pEntity)->m_LogDeletions = false;
}
#endif //!__NO_OUTPUT
pEntity->FlagToDestroyWhenNextProcessed();
pEntity->DisableCollision();
SetVisibility(pEntity, false);
cutsceneModelEntityDebugf2("CCutsceneAnimatedModelEntity::RemoveEntityFromTheWorld: Hide entity (%s)", pEntity->GetModelName());
ShouldRemove = true;
}
}
return ShouldRemove;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
#if __DEV
void CCutsceneAnimatedModelEntity::DebugDraw() const
{
Vector3 vGameEntityPosition;
Vector3 vPos;
Color32 Colour (Color_blue);
const CEntity* pEnt = NULL;
if(GetGameEntity())
{
pEnt = GetGameEntity();
}
if(!pEnt)
{
return;
}
if(pEnt)
{
if(CutSceneManager::GetInstance()->GetDebugManager().m_bDisplayAllSkeletons)
{
const crSkeleton* pSkeleton = pEnt->GetSkeleton();
CAnimViewer::RenderSkeleton(*pSkeleton, Color_red, Color_blue, 0.01f);
Matrix34 m = MAT34V_TO_MATRIX34(pEnt->GetMatrix());
grcDebugDraw::Axis(m, 0.5f, true);
}
vGameEntityPosition = VEC3V_TO_VECTOR3(pEnt->GetTransform().GetPosition());
}
//draw the scene handles
vPos = vGameEntityPosition;
vPos.z += 1.0f;
grcDebugDraw::Line(vGameEntityPosition,vPos,Colour);
char text [128];
const cutfModelObject* pModel = NULL;
if(GetCutfObject()->GetType() == CUTSCENE_MODEL_OBJECT_TYPE)
{
pModel = static_cast<const cutfModelObject*>(GetCutfObject());
}
if(pModel)
{
grcDebugDraw::Text(vPos, Colour, formatf(text, "Display Name: %s Scene Handle: %s", GetCutfObject()->GetDisplayName().c_str(), pModel->GetHandle().GetCStr()));
}
else
{
grcDebugDraw::Text(vPos, Colour, formatf(text, "Display Name: %s", GetCutfObject()->GetDisplayName().c_str()));
}
}
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
// Animated Prop Entity
///////////////////////////////////////////////////////////////////////////////////////////////////
CCutSceneAnimatedPropEntity::CCutSceneAnimatedPropEntity(const cutfObject* pObject)
:CCutsceneAnimatedModelEntity(pObject)
{
}
CCutSceneAnimatedPropEntity::~CCutSceneAnimatedPropEntity()
{
//check that the script registered entity is being picked up by the script
if(m_RegisteredEntityFromScript.SceneNameHash > 0 && m_RegisteredEntityFromScript.bCreatedForScript)
{
if(m_RegisteredEntityFromScript.pEnt != NULL)
{
const CScriptEntityExtension* pExtension = m_RegisteredEntityFromScript.pEnt->GetExtension<CScriptEntityExtension>();
if(!CutSceneManager::GetInstance()->ShouldDeleteAllRegisteredEntites())
{
if(!IsRegisteredGameEntityUnderScriptControl())
{
cutsceneAssertf(pExtension, "Deleting a cutscene entity (\"%s\" %u) scene handle (\"%s\" %u) that was registered with CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY use GET_ENTITY_INDEX_OF_REGISTERED_ENTITY to make sure it is pickup up by the script",
m_RegisteredEntityFromScript.ModelNameHash.TryGetCStr(),
m_RegisteredEntityFromScript.ModelNameHash.GetHash(),
m_RegisteredEntityFromScript.SceneNameHash.TryGetCStr(),
m_RegisteredEntityFromScript.SceneNameHash.GetHash());
}
}
if(!pExtension)
{
m_RegisteredEntityFromScript.bDeleteBeforeEnd = true;
if(m_bCreatedByCutscene)
{
if(GetGameEntity())
{
GetGameEntity()->SetOwnedBy(ENTITY_OWNEDBY_TEMP);
}
}
}
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////
//need to implement a game version of this
void CCutSceneAnimatedPropEntity::CreateGameEntity(strLocalIndex iModelIndex, bool CreateRepositionEntity, bool UNUSED_PARAM(bRequestVariations), bool UNUSED_PARAM(bApplyVariations))
{
if(GetGameEntity() == NULL)
{
cutsceneModelEntityDebugf2("CreateGameEntity - Prop");
fwModelId modelId((strLocalIndex(iModelIndex)));
CBaseModelInfo* pModelInfo = CModelInfo::GetBaseModelInfo(modelId);
if(pModelInfo)
{
cutsceneAssertf(pModelInfo->GetIsTypeObject(), "CUTSCENE ASSET (Assign to *Default Anim Cutscene*): Exported incorrectly, %s is not a PropModel type", pModelInfo->GetModelName());
if(pModelInfo->GetIsTypeObject())
{
// By default objects are created at the origin and their drawables are created automatically this flag allows objects to be created without
// their drawable they are then moved to the scene origin and then their drawable is created
// this matters if the drawable contains lights as these lights will only be updated to be relative to the object when the lights bounding box
// is on screen and not when the object is moved (FTR I think this is the real bug)
// We don't want to make this the default behavior at this stage for fear of "fixing" things and causing double lighting etc
bool bCreateObjectsAtSceneOrigin = CutSceneManager::GetInstance()->GetOptionFlags().IsFlagSet(CUTSCENE_CREATE_OBJECTS_AT_SCENE_ORIGIN);
CObject* pObject = CObjectPopulation::CreateObject(modelId, ENTITY_OWNEDBY_CUTSCENE, bCreateObjectsAtSceneOrigin? false : true, true, false);
if (pObject)
{
#if GTA_REPLAY
CReplayMgr::RecordObject(pObject);
#endif //GTA_REPLAY
Matrix34 TempMat;
TempMat.Identity();
TempMat.d = m_vCreatePos;
//cant create objects on top of each other, the game complains about it.
TempMat.d.z += 0.001f * m_pCutfObject->GetObjectId();
pObject->SetMatrix(TempMat);
if (bCreateObjectsAtSceneOrigin)
{
pObject->CreateDrawable();
}
// Add Object to world after its position has been set
CGameWorld::Add(pObject, CGameWorld::OUTSIDE );
pObject->GetPortalTracker()->ScanUntilProbeTrue();
pObject->GetPortalTracker()->Update(VEC3V_TO_VECTOR3(pObject->GetTransform().GetPosition()));
pObject->GetPortalTracker()->SetIsCutsceneControlled(true);
if(CreateRepositionEntity)
{
SetRepositionOnlyEntity(pObject);
}
else
{
SetGameEntity(pObject);
}
m_bCreatedByCutscene = true;
}
}
}
}
}
void CCutSceneAnimatedPropEntity::ForceUpdateAi(cutsManager* pManager)
{
if(pManager)
{
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*> (pManager);
if(pCutSceneManager->GetShutDownMode() != SHUTDOWN_SESSION)
{
CObject* pObj = GetGameEntity();
if (pObj && pObj->GetObjectIntelligence())
{
pObj->GetObjectIntelligence()->Process();
}
}
}
};
void CCutSceneAnimatedPropEntity::SetRepositionOnlyEntityReadyForCutscene()
{
if(GetGameRepositionOnlyEntity())
{
GetGameRepositionOnlyEntity()->m_nPhysicalFlags.bNotDamagedByAnything = true;
GetGameRepositionOnlyEntity()->SetIsVisibleForModule(SETISVISIBLE_MODULE_CUTSCENE, false);
cutsceneModelEntityDebugf2("CCutSceneAnimatedPropEntity::SetRepositionOnlyEntityReadyForCutscene: Hiding GetGameRepositionOnlyEntity (%s)", GetGameRepositionOnlyEntity()->GetModelName());
NetworkInterface::CutsceneStartedOnEntity(*GetGameRepositionOnlyEntity());
}
}
void CCutSceneAnimatedPropEntity::SetGameEntityReadyForCutscene()
{
if(GetGameEntity())
{
#if !__NO_OUTPUT
SetUpEntityForCallStackLogging();
#endif
GetGameEntity()->SetFixedPhysics(true);
GetGameEntity()->m_nPhysicalFlags.bNotDamagedByAnything = true;
GetGameEntity()->m_nDEflags.bForcePrePhysicsAnimUpdate = true;
GetGameEntity()->DisableCollision();
NetworkInterface::CutsceneStartedOnEntity(*GetGameEntity());
if(!m_RegisteredEntityFromScript.bCreatedForScript)
{
if(GetGameEntity()->IsADoor() && m_OptionFlags.IsFlagSet(CEO_UPDATE_AS_REAL_DOOR))
{
CDoor* door = static_cast<CDoor*>(GetGameEntity());
door->SetRegisteredWithCutscene(true);
}
}
}
}
void CCutSceneAnimatedPropEntity::SetGameEntityReadyForGame(cutsManager* UNUSED_PARAM(pManager))
{
if(!m_bIsReadyForGame)
{
if(GetGameEntity())
{
NetworkInterface::CutsceneFinishedOnEntity(*GetGameEntity());
if(!m_RegisteredEntityFromScript.bCreatedForScript)
{
if(GetGameEntity()->IsADoor() && m_OptionFlags.IsFlagSet(CEO_UPDATE_AS_REAL_DOOR))
{
CDoor* door = static_cast<CDoor*>(GetGameEntity());
door->SetRegisteredWithCutscene(false);
}
}
#if !__NO_OUTPUT
ResetEntityForCallStackLogging();
#endif
if(m_RegisteredEntityFromScript.bCreatedForScript || !m_RegisteredEntityFromScript.bDeleteBeforeEnd)
{
cutsceneModelEntityDebugf2("SetGameEntityReadyForGame - Prop");
GetGameEntity()->m_nPhysicalFlags.bNotDamagedByAnything = m_bWasInvincible;
GetGameEntity()->m_nDEflags.bForcePrePhysicsAnimUpdate = false;
GetGameEntity()->EnableCollision();
GetGameEntity()->SetFixedPhysics(false);
}
bool CanDelete = m_RegisteredEntityFromScript.pEnt != GetGameEntity();
if(CanDelete|| m_RegisteredEntityFromScript.bDeleteBeforeEnd)
{
GetGameEntity()->SetOwnedBy(ENTITY_OWNEDBY_TEMP);
}
else
{
GetGameEntity()->SetOwnedBy(ENTITY_OWNEDBY_SCRIPT);
SetVisibility(GetGameEntity(), true);
cutsceneModelEntityDebugf2("CCutSceneAnimatedPropEntity::SetGameEntityReadyForGame: Showing GetGameEntity (%s)", GetGameEntity()->GetModelName());
}
}
if(GetGameRepositionOnlyEntity())
{
cutsceneModelEntityDebugf2("SetGameEntityReadyForGame - Prop (reposition only)");
GetGameRepositionOnlyEntity()->SetPosition(m_CurrentPosition);
GetGameRepositionOnlyEntity()->SetHeading(m_CurrentHeading);
GetGameRepositionOnlyEntity()->m_nPhysicalFlags.bNotDamagedByAnything = m_bWasInvincible;
GetGameRepositionOnlyEntity()->SetIsVisibleForModule(SETISVISIBLE_MODULE_CUTSCENE, true);
cutsceneModelEntityDebugf2("CCutSceneAnimatedPropEntity::SetGameEntityReadyForGame: Showing GetGameRepositionOnlyEntity (%s)", GetGameRepositionOnlyEntity()->GetModelName());
if(m_bCreatedByCutscene)
{
GetGameRepositionOnlyEntity()->SetOwnedBy(ENTITY_OWNEDBY_SCRIPT);
}
}
if (m_pCutSceneTask)
{
m_pCutSceneTask->SetExitNextUpdate();
}
m_bIsReadyForGame = true;
}
}
void CCutSceneAnimatedPropEntity::PlayClip (CutSceneManager* pCutManager, const crClip* pClip, float fEventTime, const strStreamingObjectName UNUSED_PARAM(pAnimDict))
{
if(GetGameEntity())
{
if(!m_pCutSceneTask)
{
m_pCutSceneTask = CreateCutsceneTask(pCutManager, pClip, fEventTime);
GetGameEntity()->SetTask(m_pCutSceneTask);
}
else
{
if(cutsceneVerifyf(m_pCutSceneTask->GetTaskType() == CTaskTypes::TASK_CUTSCENE, "Trying to set the clip on a CTaskCutscene, but entity %s is not running a cutscene task", m_pCutfObject->GetDisplayName().c_str()))
{
Matrix34 SceneMat;
pCutManager->GetSceneOrientationMatrix(SceneMat);
m_pCutSceneTask->SetClip(pClip,SceneMat, fEventTime);
}
}
}
//store info about the which section the anim started at.
SetAnimPlayBackEventTime(fEventTime);
}
void CCutSceneAnimatedPropEntity::UpdateCutSceneTask(cutsManager* pManager)
{
if(GetGameEntity())
{
const CObject* pObject = GetGameEntity();
if(pObject && pObject->GetObjectIntelligence())
{
CTask* pTask = pObject->GetObjectIntelligence()->FindTaskByType(CTaskTypes::TASK_CUTSCENE);
UpdateCutSceneTaskPhase(pTask, pManager);
}
}
}
/////////////////////////////////////////////////////////////////////////
CTaskCutScene* CCutsceneAnimatedModelEntity::CreateCutsceneTask(CutSceneManager* pManager, const crClip* pClip, float fEventTime)
{
Matrix34 SceneMat(M34_IDENTITY);
pManager->GetSceneOrientationMatrix(SceneMat);
float fPhase = pManager->GetPhaseUpdateAmount(pClip,fEventTime);
CTaskCutScene* pTask = rage_new CTaskCutScene(pClip, SceneMat, fPhase, fEventTime);
return pTask;
}
/////////////////////////////////////////////////////////////////////////
void CCutSceneAnimatedPropEntity::DispatchEvent( cutsManager* pManager, const cutfObject* pObject, s32 iEventId, const cutfEventArgs* pEventArgs, const float UNUSED_PARAM(fTime), const u32 UNUSED_PARAM(StickyId) )
{
switch ( iEventId )
{
case CUTSCENE_PAUSE_EVENT:
case CUTSCENE_UPDATE_EVENT:
{
if (iEventId==CUTSCENE_UPDATE_EVENT && m_bStoppedCalled)
{
CreateRepositionOnlyGameEntityWhenModelLoaded(pManager, pObject, true, true );
SetGameEntityReadyForGame(pManager);
}
UpdateCutSceneTask(pManager);
}
break;
}
CCutsceneAnimatedModelEntity::DispatchEvent( pManager,pObject, iEventId,pEventArgs);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Animated Weapon Entity
///////////////////////////////////////////////////////////////////////////////////////////////////
CCutSceneAnimatedWeaponEntity::CCutSceneAnimatedWeaponEntity(const cutfObject* pObject)
:CCutSceneAnimatedPropEntity(pObject)
{
m_RegisteredGenericWeaponType = 0;
}
CCutSceneAnimatedWeaponEntity::~CCutSceneAnimatedWeaponEntity()
{
}
u32 CCutSceneAnimatedWeaponEntity::GetCutObjectGenericWeaponType () const
{
u32 GenericWeaponType = 0;
if(m_pCutfObject && m_pCutfObject->GetType() == CUTSCENE_MODEL_OBJECT_TYPE)
{
const cutfModelObject* pModelObject = static_cast<const cutfModelObject*>(m_pCutfObject);
if(pModelObject && pModelObject->GetModelType() == CUTSCENE_WEAPON_MODEL_TYPE)
{
const cutfWeaponModelObject* pWeapon = static_cast<const cutfWeaponModelObject*>(pModelObject);
if(pWeapon)
{
GenericWeaponType = pWeapon->GetGenericWeaponType();
}
}
}
return GenericWeaponType;
}
bool CCutSceneAnimatedWeaponEntity::IsScriptRegisteredGameEntity()
{
if(m_RegisteredGenericWeaponType == 0)
{
return CCutsceneAnimatedModelEntity::IsScriptRegisteredGameEntity();
}
else
{
if(m_pCutfObject)
{
const cutfWeaponModelObject* pWeapon = static_cast<const cutfWeaponModelObject*>(m_pCutfObject);
if(pWeapon)
{
return ((m_RegisteredEntityFromScript.SceneNameHash.GetHash()>0 && (m_RegisteredEntityFromScript.SceneNameHash.GetHash() == GetSceneHandleHash().GetHash())) && pWeapon->GetGenericWeaponType() == m_RegisteredGenericWeaponType);
}
}
}
return false;
}
void CCutSceneAnimatedWeaponEntity::SetGameEntityReadyForCutscene()
{
// Base
CCutSceneAnimatedPropEntity::SetGameEntityReadyForCutscene();
CObject* pGameObject = GetGameEntity();
if (pGameObject && !pGameObject->m_pWeapon && pGameObject->GetBaseModelInfo() && pGameObject->GetBaseModelInfo()->GetModelType() == MI_TYPE_WEAPON)
{
CWeaponModelInfo* pWeaponModelInfo = static_cast<CWeaponModelInfo*>(pGameObject->GetBaseModelInfo());
// Get the weapon info from the model hash
const u32 uWeaponModelHash = pWeaponModelInfo->GetModelNameHash();
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfoFromModelNameHash<CWeaponInfo>(uWeaponModelHash ASSERT_ONLY(, true));
if(pWeaponInfo)
{
CPedEquippedWeapon::SetupAsWeapon(pGameObject, pWeaponInfo, 0);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Animated Actor Entity
///////////////////////////////////////////////////////////////////////////////////////////////////
#if __DEV
//THIS CURRENTLY DOES NOTHING TO FILTER ANY ANIMS BECAUSE THERE IS NO FILTER TO REMOVE ALL ANIM EXCEPT FACIAL
void CCutsceneAnimatedActorEntity::UpdateWithFaceViewer(CutSceneManager* pManager, CTaskCutScene* pCutSceneTask)
{
if(!pCutSceneTask || !pManager)
{
return;
}
const CCutSceneCameraEntity* pCam = pManager->GetCamEntity();
//camera is pointing at ped
if(pCam && pCam->IsCameraPointingAtThisObject(this))
{
pCutSceneTask->SetCanApplyMoverTrackUpdate(false);
Matrix34 mSceneMat(M34_IDENTITY);
pManager->GetSceneOrientationMatrix(mSceneMat);
//pCutSceneTask->SetFilter(BONEMASK_HEADONLY); //removed because facial anims are applied by extra dofs that arent bones
//apply the new ped pos
mSceneMat.d.z+=1000.0f;
GetGameEntity()->SetMatrix(mSceneMat);
}
else
{
//if(pCutSceneTask->GetFilter().GetHash() != BONEMASK_ALL)
//{
//removed because facial anims are applied by extra dofs that arent bones this filter will remove facial anims
// pCutSceneTask->SetFilter(BONEMASK_ALL);
pCutSceneTask->SetCanApplyMoverTrackUpdate(true);
//}
}
};
#endif
/////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedActorEntity::InitActor(CPed* pPed)
{
if (pPed)
{
pPed->PopTypeSet(POPTYPE_MISSION);
pPed->SetDefaultDecisionMaker();
pPed->SetBlockingOfNonTemporaryEvents(true);
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_DrownsInWater, false );
pPed->GetPedIntelligence()->SetDefaultRelationshipGroup();
pPed->m_nPhysicalFlags.bNotDamagedByAnything = true;
//possibly add the rag doll and low lod physics commands here
pPed->SetCharParamsBasedOnManagerType();
CGameWorld::Add(pPed, CGameWorld::OUTSIDE);
pPed->SetFixedPhysics(true);
}
};
/////////////////////////////////////////////////////////////////////////
// store the ped variation for when a ped has to be recreated
void CCutsceneAnimatedActorEntity::StoreActorVariationData(u32 iComponent, s32 iDrawable, s32 iTexture, sActorVariationData& ActorData )
{
cutsceneAssertf((iDrawable>-1 && iTexture>-1) || (iComponent>=PV_MAX_COMP && iDrawable>-2), "Component, Drawable or Texture is invalid (Component: %d (%s), Drawable: %d, Texture: %d)", iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent), iDrawable, iTexture);
for (int i =0; i < ActorData.iPedVarData.GetCount(); i++)
{
if(iComponent == ActorData.iPedVarData[i].iComponent)
{
ActorData.iPedVarData[i].iDrawable = iDrawable;
ActorData.iPedVarData[i].iTexture = iTexture;
return;
}
}
sPedComponentVar& NewPedComponent = ActorData.iPedVarData.Grow();
NewPedComponent.iComponent = iComponent;
NewPedComponent.iDrawable = iDrawable;
NewPedComponent.iTexture = iTexture;
}
/////////////////////////////////////////////////////////////////////////
// Pass the latest setup to a newly streamed ped
void CCutsceneAnimatedActorEntity::RestoreEntityProperties(CEntity * pEnt)
{
if(pEnt && pEnt->GetIsTypePed())
{
CPed* pPed = static_cast<CPed*>(pEnt);
for(int i =0; i < m_sCurrentActorVariationData.iPedVarData.GetCount(); i ++)
{
SetCurrentActorVariation(pPed, m_sCurrentActorVariationData.iPedVarData[i].iComponent, m_sCurrentActorVariationData.iPedVarData[i].iDrawable, m_sCurrentActorVariationData.iPedVarData[i].iTexture);
}
}
}
bool CCutsceneAnimatedActorEntity::RemoveEntityFromTheWorld(CEntity * pEnt, bool bDeleteRegistered)
{
if(pEnt && pEnt->GetIsTypePed())
{
CPed* pPed = static_cast<CPed*>(pEnt);
{
pPed->CleanUpPreloadData();
}
}
return CCutsceneAnimatedModelEntity::RemoveEntityFromTheWorld(pEnt, bDeleteRegistered);
}
/////////////////////////////////////////////////////////////////////////
CCutsceneAnimatedActorEntity::CCutsceneAnimatedActorEntity(const cutfObject* pObject)
:CCutsceneAnimatedModelEntity(pObject)
{
GetEntityVariationEvents();
m_VariationStreamingIndex = 0;
m_fVehicleLightingScalar = 0.0f;
m_fVehicleLightingScalarTargetValue = 0.0f;
m_fVehicleLightingScalarBlendRate = 1000.0f;
}
/////////////////////////////////////////////////////////////////////////
//create our ingame ped
void CCutsceneAnimatedActorEntity::CreateGamePed(u32 iModelIndex, bool CreateRepositionEntity)
{
fwModelId modelId((strLocalIndex(iModelIndex)));
CBaseModelInfo* pModelInfo = CModelInfo::GetBaseModelInfo(modelId);
cutsceneModelEntityDebugf2("CreateGamePed - Actor");
if(pModelInfo)
{
cutsceneAssertf(pModelInfo->GetModelType() == MI_TYPE_PED, "CUTSCENE ASSET (Assign to *Default Anim Cutscene*): Exported incorrectly, %s is not a PedModel type", pModelInfo->GetModelName());
if(pModelInfo->GetModelType() == MI_TYPE_PED)
{
Matrix34 TempMat;
TempMat.Identity();
TempMat.d = m_vCreatePos;
if(iModelIndex != strLocalIndex::INVALID_INDEX)
{
const CControlledByInfo localAiControl(false, false);
CPedModelInfo* pPedModelInfo = static_cast<CPedModelInfo*>(pModelInfo);
CPed* pPed = NULL;
if (CreateRepositionEntity)
{
pPed = CPedFactory::GetFactory()->CreatePedFromSource(localAiControl, modelId, &TempMat, GetGameEntity(), true, false, false);
}
else
{
if(m_sScriptActorVariationData.iPedVarData.GetCount() > 0)
{
// Previously we called CreatePed with bApplyDefaultVariation = true but this still generated random
// peds if the ped was non streamed. Now we use bApplyDefaultVariation = false in order minimise streaming
// bandwidth on streamed peds. Either way we need to manually set non streamed peds to default after creation
pPed = CPedFactory::GetFactory()->CreatePed(localAiControl, modelId, &TempMat, false, false, false);
if (!pPedModelInfo->GetIsStreamedGfx())
{
pPed->SetVarDefault();
}
}
else
{
pPed = CPedFactory::GetFactory()->CreatePedFromSource(localAiControl, modelId, &TempMat, GetGameRepositionOnlyEntity(), true, false, false);
}
}
CPedInventoryLoadOutManager::SetDefaultLoadOut(pPed);
if (Verifyf(pPed, "trying to store a null ped pointer something has gone wrong with the registration"))
{
if(CreateRepositionEntity)
{
SetRepositionOnlyEntity(pPed);
}
else
{
SetGameEntity(pPed);
}
}
}
}
}
}
void CCutsceneAnimatedActorEntity::GetEntityVariationEvents()
{
m_pVariationEvents.Reset();
atArray<cutfEvent *> AllEventList;
const cutfCutsceneFile2* pCutfile = const_cast<const CutSceneManager*>(CutSceneManager::GetInstance())->GetCutfFile();
pCutfile->FindEventsForObjectIdOnly( m_pCutfObject->GetObjectId(), pCutfile->GetEventList(), AllEventList );
for ( int i = 0; i < AllEventList.GetCount(); ++i )
{
if (AllEventList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( AllEventList[i]->GetEventArgs());
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_ACTOR_VARIATION_EVENT_ARGS_TYPE)
{
if(CutSceneManager::GetInstance()->IsConcatted())
{
// Are the events in a concat section that is going to be played
#if !__NO_OUTPUT
const cutfObjectVariationEventArgs* pVariationEventFlag = static_cast<const cutfObjectVariationEventArgs *>( pEventArgs );
int Component = pVariationEventFlag->GetComponent();
int Drawable = pVariationEventFlag->GetDrawable();
int Texture = pVariationEventFlag->GetTexture();
s32 section = CutSceneManager::GetInstance()->GetConcatSectionForTime(AllEventList[i]->GetTime());
#endif
bool bValidEventTime = CutSceneManager::GetInstance()->ValidateEventTime(AllEventList[i]->GetTime());
if (bValidEventTime)
{
cutsceneModelEntityDebugf3("GetEntityVariationEvents:: Variation event has valid section/time (%d/%f) : (Component: %d (%s), Drawable: %d, Texture: %d)", section, AllEventList[i]->GetTime(), Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
m_pVariationEvents.PushAndGrow(AllEventList[i]);
}
else
{
cutsceneModelEntityDebugf3("GetEntityVariationEvents:: Variation event has invalid section/time (%d/%f) : (Component: %d (%s), Drawable: %d, Texture: %d)", section, AllEventList[i]->GetTime(), Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture );
}
}
else
{
m_pVariationEvents.PushAndGrow(AllEventList[i]);
}
}
}
}
}
void CCutsceneAnimatedActorEntity::PreStreamVariations(CutSceneManager* pManager, float CurrentTime, float LookAhead)
{
float StreamingOffsetBuffer = pManager->CalculateStreamingOffset(LookAhead, CurrentTime);
float LookAheadTime = pManager->GetTime() + StreamingOffsetBuffer;
//cutsceneModelEntityDebugf("PreStreamVariations - Current Time (%6.4f) -> Streaming time(%6.4f)", pManager->GetTime(), pManager->GetTime() + StreamingOffsetBuffer);
for ( int i = m_VariationStreamingIndex; i < m_pVariationEvents.GetCount(); ++i )
{
if(m_pVariationEvents[i]->GetTime() <= LookAheadTime)
{
bool bIsValidEventTime = true;
if (pManager->IsConcatted())
{
bIsValidEventTime = pManager->ValidateEventTime(m_pVariationEvents[i]->GetTime());
}
if ( bIsValidEventTime)
{
const cutfObjectVariationEventArgs *pEventArgs = static_cast<const cutfObjectVariationEventArgs *>( m_pVariationEvents[i]->GetEventArgs() );
if(pEventArgs)
{
s32 Component = pEventArgs->GetComponent();
s32 Drawable = pEventArgs->GetDrawable();
s32 Texture = pEventArgs->GetTexture();
if((Component>-1 && Drawable>-1 && Texture>-1) || (Component>=PV_MAX_COMP && Drawable>-1))
{
pManager->GetAssetManager()->SetActorVariationStreamingRequest(Component, Drawable, Texture, m_ModelNameHash, m_pCutfObject->GetObjectId());
}
else
{
if (Component<PV_MAX_COMP)
cutsceneModelEntityDebugf3( "PreStreamVariations: Ignoring invalid cutscene variation event (Component: %d (%s), Drawable: %d, Texture: %d)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
}
}
else
{
cutsceneModelEntityDebugf3( "PreStreamVariations: Ignoring invalid cutscene variation args");
}
}
// Increment m_VariationStreamingIndex so we don't consider this variation again
m_VariationStreamingIndex++;
}
}
}
void CCutsceneAnimatedActorEntity::ComputeInitialVariations(atHashString& UNUSED_PARAM(modelHashString))
{
//bool bRepositionOnlyEntity = (modelHashString == m_RegisteredEntityFromScript.ModelNameHash);
if ( /*!bRepositionOnlyEntity &&*/ !m_bComputeInitialVariationsForGameEntity)
{
m_bComputeInitialVariationsForGameEntity = true;
cutsceneModelEntityDebugf3( "ComputeInitialVariations (%s) ---------------------------------------------", m_ModelNameHash.TryGetCStr());
// Copy all the variations set by script from the initial variations array into the current variations array
for(int i = 0; i < m_sScriptActorVariationData.iPedVarData.GetCount(); i++ )
{
s32 Component = m_sScriptActorVariationData.iPedVarData[i].iComponent;
s32 Drawable = m_sScriptActorVariationData.iPedVarData[i].iDrawable;
s32 Texture = m_sScriptActorVariationData.iPedVarData[i].iTexture;
if((Component>-1 && Drawable>-1 && Texture>-1) || (Component>=PV_MAX_COMP && Drawable>-2))
{
cutsceneModelEntityDebugf3("ComputeInitialVariations - Script variation (Component: %d (%s), Drawable: %d, Texture: %d)",
Component,
CPedVariationData::GetVarOrPropSlotName(Component),
Drawable,
Texture);
StoreActorVariationData(Component, Drawable, Texture, m_sCurrentActorVariationData);
}
}
// For each cutscene variation event that happened on the start frame (may or may not be 0.0 depending on if the cutscene in branched)
for ( int i = m_VariationStreamingIndex; i < m_pVariationEvents.GetCount(); ++i )
{
float fEventTime = m_pVariationEvents[i]->GetTime();
float fStartTime = CutSceneManager::GetInstance()->GetStartTime();
if(fEventTime <= fStartTime)
{
bool bIsValidEventTime = true;
if (CutSceneManager::GetInstance()->IsConcatted())
{
bIsValidEventTime = CutSceneManager::GetInstance()->ValidateEventTime(fEventTime);
}
if (bIsValidEventTime)
{
bool bUseVariationFromCutsceneStartFrame = true;
const cutfObjectVariationEventArgs *pEventArgs = static_cast<const cutfObjectVariationEventArgs *>( m_pVariationEvents[i]->GetEventArgs() );
if(pEventArgs)
{
s32 Component = pEventArgs->GetComponent();
s32 Drawable = pEventArgs->GetDrawable();
s32 Texture = pEventArgs->GetTexture();
if((Component>-1 && Drawable>-1 && Texture>-1) || (Component>=PV_MAX_COMP && Drawable>-2))
{
// Favour script variation events over cutscene variation events on the first frame
for(int j = 0; j < m_sScriptActorVariationData.iPedVarData.GetCount(); j++ )
{
if((u32)Component == m_sScriptActorVariationData.iPedVarData[j].iComponent)
{
cutsceneModelEntityDebugf3("ComputeInitialVariations - Script variation (Component: %d (%s), Drawable: %d, Texture: %d) used rather than cutscene start frame variation (Component: %d (%s), Drawable: %d, Texture: %d)",
m_sScriptActorVariationData.iPedVarData[j].iComponent,
CPedVariationData::GetVarOrPropSlotName(m_sScriptActorVariationData.iPedVarData[j].iComponent),
m_sScriptActorVariationData.iPedVarData[j].iDrawable,
m_sScriptActorVariationData.iPedVarData[j].iTexture,
Component,
CPedVariationData::GetVarOrPropSlotName(Component),
Drawable,
Texture);
bUseVariationFromCutsceneStartFrame = false;
break;
}
}
if(bUseVariationFromCutsceneStartFrame)
{
cutsceneModelEntityDebugf3("ComputeInitialVariations - Cutscene start frame variation (Component: %d (%s), Drawable: %d, Texture: %d)",
Component,
CPedVariationData::GetVarOrPropSlotName(Component),
Drawable,
Texture);
StoreActorVariationData(Component, Drawable, Texture, m_sCurrentActorVariationData);
}
}
else
{
cutsceneModelEntityDebugf3( "ComputeInitialVariations: Ignoring invalid cutscene variation event (Component: %d (%s), Drawable: %d, Texture: %d)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
}
}
else
{
cutsceneModelEntityDebugf3( "ComputeInitialVariations: Ignoring invalid cutscene variation args");
}
}
// Cutscene variations events are so increment m_VariationStreamingIndex so we don't consider this variation again
m_VariationStreamingIndex++;
}
}
//
// Make sure all variation kinds have at least a default entry
//
// For each kind of variation component
for(u32 i = 0; i < PV_MAX_COMP; i++)
{
// Search for a valid entry
bool bFoundValidVariationEntry = false;
for(u32 j=0; j<m_sCurrentActorVariationData.iPedVarData.GetCount(); j++)
{
if(m_sCurrentActorVariationData.iPedVarData[j].iComponent == i)
{
bFoundValidVariationEntry = true;
break;
}
}
// If there is no matching entry make a new "default" entry for that kind of variation in the initial variations array
if(!bFoundValidVariationEntry)
{
cutsceneModelEntityDebugf3("ComputeInitialVariations - Fallback variation (Component: %d (%s), Drawable: %d, Texture: %d)",
i,
CPedVariationData::GetVarOrPropSlotName(i),
0,
0);
StoreActorVariationData(i, 0, 0, m_sCurrentActorVariationData);
}
/*
cutsceneModelEntityDebugf( "ComputeInitialVariations: m_sCurrentActorVariationData[%d] (Component: %d (%s), Drawable: %d, Texture: %d)",
i,
m_sCurrentActorVariationData.iPedVarData[i].iComponent,
CPedVariationData::GetVarOrPropSlotName(m_sCurrentActorVariationData.iPedVarData[i].iComponent),
m_sCurrentActorVariationData.iPedVarData[i].iDrawable,
m_sCurrentActorVariationData.iPedVarData[i].iTexture);
*/
}
for(int i=0; i < m_sCurrentActorVariationData.iPedVarData.GetCount(); i++)
{
s32 Component = m_sCurrentActorVariationData.iPedVarData[i].iComponent;
s32 Drawable = m_sCurrentActorVariationData.iPedVarData[i].iDrawable;
s32 Texture = m_sCurrentActorVariationData.iPedVarData[i].iTexture;
if((Component>-1 && Drawable>-1 && Texture>-1) || (Component>=PV_MAX_COMP && Drawable>-1))
{
eStreamingRequestReturnValue streamingRequestReturnValue = CutSceneManager::GetInstance()->GetAssetManager()->SetActorVariationStreamingRequest((u32)Component, (u32)Drawable, (u32)Texture, m_ModelNameHash, m_pCutfObject->GetObjectId());
if(Component < PV_MAX_COMP)
{
if ((streamingRequestReturnValue == ESRRV_INVALID_VARIATION) && (Drawable > 0 || Texture > 0))
{
cutsceneModelEntityDebugf3( "ComputeInitialVariations: Ignoring invalid cutscene variation request (Component: %d (%s), Drawable: %d, Texture: %d) (requesting default instead)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
CutSceneManager::GetInstance()->GetAssetManager()->SetActorVariationStreamingRequest((u32)Component, 0, 0, m_ModelNameHash, m_pCutfObject->GetObjectId());
}
}
}
else
{
if (Component<PV_MAX_COMP)
cutsceneModelEntityDebugf3( "ComputeInitialVariations: Ignoring invalid cutscene variation event (Component: %d (%s), Drawable: %d, Texture: %d)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
}
}
}
}
void CCutsceneAnimatedActorEntity::ComputeVariationsForSkip(atHashString& modelHashString)
{
/*cutsceneModelEntityDebugf("ComputeVariationsForSkip %s ---------------------------------------------", modelHashString.TryGetCStr());
cutsceneModelEntityDebugf("(iSceneId(%d),SceneNameHash(%s),ModelNameHash(%s),bDeleteBeforeEnd(%d),bCreatedForScript(%d),iEnterStatePhase(%6.4f),iExitStatePhase(%6.4f),bAppearInScene(%d)",
m_RegisteredEntityFromScript.iSceneId,
m_RegisteredEntityFromScript.SceneNameHash.TryGetCStr(),
m_RegisteredEntityFromScript.ModelNameHash.TryGetCStr(),
m_RegisteredEntityFromScript.bDeleteBeforeEnd,
m_RegisteredEntityFromScript.bCreatedForScript,
m_RegisteredEntityFromScript.iEnterStatePhase,
m_RegisteredEntityFromScript.iExitStatePhase,
m_RegisteredEntityFromScript.bAppearInScene );
bool bNeedsVariations = false;
static bool bMethodA = true;
if (bMethodA)
{
if (!IsScriptRegisteredGameEntity()
&& IsScriptRegisteredRepositionOnlyEntity()
&& !m_RegisteredEntityFromScript.pEnt
&& m_RegisteredEntityFromScript.bCreatedForScript )
{
bNeedsVariations = true;
}
// Only run when the repositionOnlyEntities model is loaded
bNeedsVariations = bNeedsVariations || ((modelHashString.GetHash() == m_RegisteredEntityFromScript.ModelNameHash) && !m_bComputeVariationsForSkipForRepositionOnlyEntity);
}
else
{
atHashString modelNameHash(m_ModelNameHash);
if (!IsScriptRegisteredGameEntity()
&& IsScriptRegisteredRepositionOnlyEntity()
&& !m_RegisteredEntityFromScript.pEnt // no script entity being animated by the scene
&& m_RegisteredEntityFromScript.bCreatedForScript ) // reposition entity is to be created by the cutscene for the script
{
cutsceneModelEntityDebugf("ComputeVariationsForSkip - repositiononly = true = m_RegisteredEntityFromScript.ModelNameHash");
bNeedsVariations = true;
modelNameHash = m_RegisteredEntityFromScript.ModelNameHash;
}
if (!m_RegisteredEntityFromScript.bDeleteBeforeEnd)
{
bNeedsVariations = true;
cutsceneModelEntityDebugf("ComputeVariationsForSkip - repositiononly = true = ModelNameHash");
}
}
if ( bNeedsVariations && !m_bComputeVariationsForSkipForRepositionOnlyEntity )
{
*/
atHashString modelNameHash(m_ModelNameHash);
if (!IsScriptRegisteredGameEntity()
&& IsScriptRegisteredRepositionOnlyEntity()
&& !m_RegisteredEntityFromScript.pEnt // no script entity being animated by the scene
&& m_RegisteredEntityFromScript.bCreatedForScript ) // reposition entity is to be created by script for the cutscene
{
modelNameHash = m_RegisteredEntityFromScript.ModelNameHash;
cutsceneModelEntityDebugf3("ComputeVariationsForSkip - repositiononly = true");
}
else
{
cutsceneModelEntityDebugf3("ComputeVariationsForSkip - repositiononly = false");
}
bool bAppropriateEntity = (modelHashString.GetHash() == modelNameHash.GetHash());
if ( bAppropriateEntity && !m_bComputeVariationsForSkipForRepositionOnlyEntity )
{
m_bComputeVariationsForSkipForRepositionOnlyEntity = true;
cutsceneModelEntityDebugf3("ComputeVariationsForSkip ---------------------------------------------");
//
// Any variations we have set thus far are collected in the current variations array
//
for(int i=0; i<m_sCurrentActorVariationData.iPedVarData.GetCount(); i++)
{
cutsceneModelEntityDebugf3("ComputeVariationsForSkip - PreExisting variations (Component: %d (%s), Drawable: %d, Texture: %d)",
m_sCurrentActorVariationData.iPedVarData[i].iComponent,
CPedVariationData::GetVarOrPropSlotName(m_sCurrentActorVariationData.iPedVarData[i].iComponent),
m_sCurrentActorVariationData.iPedVarData[i].iDrawable,
m_sCurrentActorVariationData.iPedVarData[i].iTexture);
}
float fEndTime = CutSceneManager::GetInstance()->GetEndTime();
float fStartTime = CutSceneManager::GetInstance()->GetStartTime();
// Search through all the variation events for this ped from the current time to the end time
for ( int i = 0; i < m_pVariationEvents.GetCount(); ++i )
{
float fEventTime = m_pVariationEvents[i]->GetTime();
if((fEventTime > fStartTime) && (fEventTime <= fEndTime))
{
bool bIsValidEventTime = true;
if (CutSceneManager::GetInstance()->IsConcatted())
{
bIsValidEventTime = CutSceneManager::GetInstance()->ValidateEventTime(fEventTime);
}
if (bIsValidEventTime)
{
const cutfObjectVariationEventArgs *pEventArgs = static_cast<const cutfObjectVariationEventArgs *>( m_pVariationEvents[i]->GetEventArgs() );
if(pEventArgs)
{
s32 Component = pEventArgs->GetComponent();
s32 Drawable = pEventArgs->GetDrawable();
s32 Texture = pEventArgs->GetTexture();
if((Component>-1 && Drawable>-1 && Texture>-1) || (Component>=PV_MAX_COMP))
{
cutsceneModelEntityDebugf3("ComputeVariationsForSkip - Cutscene variation (not start frame) (Component: %d (%s), Drawable: %d, Texture: %d)",
Component,
CPedVariationData::GetVarOrPropSlotName(Component),
Drawable,
Texture);
StoreActorVariationData(Component, Drawable, Texture, m_sCurrentActorVariationData);
}
else
{
cutsceneModelEntityDebugf3( "ComputeVariationsForSkip: Ignoring invalid cutscene variation event (Component: %d (%s), Drawable: %d, Texture: %d)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
}
}
else
{
cutsceneModelEntityDebugf3( "ComputeVariationsForSkip: Ignoring invalid cutscene variation args");
}
}
}
}
//
// Make sure all variation kinds have at least a default entry
//
// For each kind of variation
for(u32 i = 0; i < PV_MAX_COMP; i++)
{
// Search for a matching entry
bool bFoundComponent = false;
for(int j=0; j<m_sCurrentActorVariationData.iPedVarData.GetCount(); j++)
{
if(m_sCurrentActorVariationData.iPedVarData[j].iComponent == i)
{
bFoundComponent = true;
break;
}
}
// If there is no matching entry make a new "default" entry for that kind of variation in the initial variations array
if(!bFoundComponent)
{
cutsceneModelEntityDebugf3("ComputeVariationsForSkip - Fallback variation (Component: %d (%s), Drawable: %d, Texture: %d)",
i,
CPedVariationData::GetVarOrPropSlotName(i),
0,
0);
StoreActorVariationData(i, 0, 0, m_sCurrentActorVariationData);
}
}
//
// Request each variation in the current variation array
//
for(int i=0; i < m_sCurrentActorVariationData.iPedVarData.GetCount(); i++)
{
s32 Component = m_sCurrentActorVariationData.iPedVarData[i].iComponent;
s32 Drawable = m_sCurrentActorVariationData.iPedVarData[i].iDrawable;
s32 Texture = m_sCurrentActorVariationData.iPedVarData[i].iTexture;
if((Component>-1 && Drawable>-1 && Texture>-1) || (Component>=PV_MAX_COMP && Drawable>-1))
{
eStreamingRequestReturnValue streamingRequestReturnValue = CutSceneManager::GetInstance()->GetAssetManager()->SetActorVariationStreamingRequest((u32)Component, (u32)Drawable, (u32)Texture, modelNameHash, m_pCutfObject->GetObjectId());
if(Component < PV_MAX_COMP)
{
if ((streamingRequestReturnValue == ESRRV_INVALID_VARIATION) && (Drawable > 0 || Texture > 0))
{
cutsceneModelEntityDebugf3( "ComputeVariationsForSkip: Ignoring invalid cutscene variation request (Component: %d (%s), Drawable: %d, Texture: %d) (requesting default instead)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
CutSceneManager::GetInstance()->GetAssetManager()->SetActorVariationStreamingRequest((u32)Component, 0, 0, modelNameHash, m_pCutfObject->GetObjectId());
}
}
}
else
{
if (Component<PV_MAX_COMP)
cutsceneModelEntityDebugf3( "ComputeVariationsForSkip: Ignoring invalid cutscene variation event (Component: %d (%s), Drawable: %d, Texture: %d)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
}
}
}
}
void CCutsceneAnimatedActorEntity::AddActorToWorld(CPed* pPed)
{
if(pPed)
{
InitActor(pPed);
pPed->GetPortalTracker()->SetIsCutsceneControlled(true);
if (IsScriptRegisteredGameEntity())
{
m_RegisteredEntityFromScript.pEnt = pPed;
}
m_bCreatedByCutscene = true;
}
}
void CCutsceneAnimatedActorEntity::CreateGameEntity(strLocalIndex iModelIndex, bool CreateRepositionEntity, bool bRequestVariations, bool bApplyVariations)
{
CPed* pPed = NULL;
if(CreateRepositionEntity)
{
pPed = GetGameRepositionOnlyEntity();
}
else
{
pPed = GetGameEntity();
}
if(pPed == NULL)
{
cutsceneModelEntityDebugf2("CreateGameEntity - Actor - bRequestVariations(%s), bApplyVariations(%s)", bRequestVariations ? "T" : "F", bApplyVariations ? "T" : "F");
CreateGamePed(iModelIndex.Get(), CreateRepositionEntity);
if(CreateRepositionEntity)
{
pPed = GetGameRepositionOnlyEntity();
}
else
{
pPed = GetGameEntity();
}
}
if(pPed && !pPed->GetIsAddedToWorld())
{
AddActorToWorld(pPed);
}
if (pPed)
{
if (bRequestVariations && !IsBlockingVariationStreamingAndApplication())
{
//
// Make sure all variation kinds have at least a default entry
//
// For each kind of variation component
for(u32 i = 0; i < PV_MAX_COMP; i++)
{
// Search for a valid entry
bool bFoundValidVariationEntry = false;
for(u32 j=0; j<m_sCurrentActorVariationData.iPedVarData.GetCount(); j++)
{
if(m_sCurrentActorVariationData.iPedVarData[j].iComponent == i)
{
bFoundValidVariationEntry = true;
break;
}
}
// If there is no matching entry make a new "default" entry for that kind of variation in the initial variations array
if(!bFoundValidVariationEntry)
{
cutsceneModelEntityDebugf2("CreateGameEntity - Actor - - Fallback variation (Component: %d (%s), Drawable: %d, Texture: %d)",
i,
CPedVariationData::GetVarOrPropSlotName(i),
0,
0);
StoreActorVariationData(i, 0, 0, m_sCurrentActorVariationData);
}
/*
cutsceneModelEntityDebugf( "CreateGameEntity - Actor -: m_sCurrentActorVariationData[%d] (Component: %d (%s), Drawable: %d, Texture: %d)",
i,
m_sCurrentActorVariationData.iPedVarData[i].iComponent,
CPedVariationData::GetVarOrPropSlotName(m_sCurrentActorVariationData.iPedVarData[i].iComponent),
m_sCurrentActorVariationData.iPedVarData[i].iDrawable,
m_sCurrentActorVariationData.iPedVarData[i].iTexture);
*/
}
// Request the current variations
for(int i=0; i < m_sCurrentActorVariationData.iPedVarData.GetCount(); i++)
{
s32 Component = m_sCurrentActorVariationData.iPedVarData[i].iComponent;
s32 Drawable = m_sCurrentActorVariationData.iPedVarData[i].iDrawable;
s32 Texture = m_sCurrentActorVariationData.iPedVarData[i].iTexture;
if((Component>-1 && Drawable>-1 && Texture>-1) || (Component>=PV_MAX_COMP && Drawable>-1))
{
if (pPed && pPed->GetPedModelInfo() && pPed->GetPedModelInfo()->GetIsStreamedGfx())
{
atHashString modelNameHash(m_ModelNameHash);
if (CreateRepositionEntity && m_RegisteredEntityFromScript.ModelNameHash.GetHash()>0)
{
modelNameHash = m_RegisteredEntityFromScript.ModelNameHash.GetHash();
}
// Now we have a ped pointer we can check the variation requested by the cutscene or script is valid
if (pPed->IsVariationInRange(static_cast<ePedVarComp>(Component), Drawable, Texture))
{
CutSceneManager::GetInstance()->GetAssetManager()->SetActorVariationStreamingRequest((u32)Component, (u32)Drawable, (u32)Texture, modelNameHash, m_pCutfObject->GetObjectId());
}
else
{
if (Drawable > 0 || Texture > 0)
{
cutsceneModelEntityDebugf2( "CreateGameEntity: Ignoring out of range cutscene variation request (Component: %d (%s), Drawable: %d, Texture: %d) (requesting default instead)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
CutSceneManager::GetInstance()->GetAssetManager()->SetActorVariationStreamingRequest((u32)Component, 0, 0, modelNameHash, m_pCutfObject->GetObjectId());
}
else
{
cutsceneModelEntityDebugf2( "CreateGameEntity: Ignoring out of range cutscene variation request (Component: %d (%s), Drawable: %d, Texture: %d) (no valid default)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
}
}
}
}
else
{
//cutsceneModelEntityDebugf( "CCutsceneAnimatedActorEntity: Ignoring invalid cutscene variation event (Component: %d (%s), Drawable: %d, Texture: %d)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
}
}
}
if (bApplyVariations && !IsBlockingVariationStreamingAndApplication())
{
// Apply the current variations
RestoreEntityProperties(pPed);
}
}
}
void CCutsceneAnimatedActorEntity::UpdateCutSceneTask(cutsManager* pManager)
{
CutSceneManager* pCutsManager = static_cast<CutSceneManager*>(pManager);
if(GetGameEntity())
{
CTask* pTask = GetGameEntity()->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_CUTSCENE);
if(pTask && pTask->GetTaskType() == CTaskTypes::TASK_CUTSCENE)
{
CTaskCutScene* pCutSceneTask = static_cast<CTaskCutScene*>(pTask);
const crClip* pClip = pCutSceneTask->GetClip();
if (pClip)
{
float fPhase = pCutsManager->GetPhaseUpdateAmount(pClip, GetAnimEventStartTime());
float fLastPhase = pCutsManager->GetAnimPhaseForSection(pClip->GetDuration(),GetAnimEventStartTime(),pCutsManager->GetCutScenePreviousTime());
GetMoverTrackVelocity(pClip,fPhase,fLastPhase, pCutsManager->GetCurrentCutSceneTimeStep());
//Vector3 localEuler = pCutSceneTask->GetAnimOrigin().GetEulers();
//printf("Rotation for %s: %7.4f, %7.4f, %7.4f \n", pClip->GetName(), localEuler.x*RtoD, localEuler.y*RtoD, localEuler.z*RtoD);
//UpdateActorMotionState();
GetGameEntity()->SetDesiredHeading(GetGameEntity()->GetTransform().GetHeading());
UpdateCutSceneTaskPhase(pTask, pManager);
#if __DEV
//THIS CURRENTLY DOES NOTHING TO FILTER ANY ANIMS BECAUSE THERE IS NO FILTER TO REMOVE ALL ANIM EXCEPT FACIAL
UpdateWithFaceViewer(pCutsManager, pCutSceneTask);
#endif
// Vehicle lighting - Have we crossed any CutsceneBlendToVehicleLighting tags?
const crTags* pTags = pClip->GetTags();
if (pTags)
{
for (int i=0; i < pTags->GetNumTags(); i++)
{
const crTag* pTag = pTags->GetTag(i);
if (pTag)
{
//static CClipEventTags::Key cutsceneBlendToVehicleLightingKey("CutsceneBlendToVehicleLighting",0xB8336AF5);
if (pTag->GetKey() == CClipEventTags::CutsceneBlendToVehicleLighting.GetHash())
{
// Tag phase
const float fTagPhase = pTag->GetStart();
// Process this tag?
if (fTagPhase >= fLastPhase && fTagPhase <= fPhase)
{
const crProperty& rProperty = pTag->GetProperty();
const crPropertyAttribute* pAttribTarget = rProperty.GetAttribute(CClipEventTags::TargetValue.GetHash());
const crPropertyAttribute* pAttribTime = rProperty.GetAttribute(CClipEventTags::BlendTime.GetHash());
// Target value
if (pAttribTarget && pAttribTarget->GetType() == crPropertyAttribute::kTypeFloat)
{
const crPropertyAttributeFloat* pTagTargetValueFloat = static_cast<const crPropertyAttributeFloat*>(pAttribTarget);
{
m_fVehicleLightingScalarTargetValue = pTagTargetValueFloat->GetFloat();
m_fVehicleLightingScalarTargetValue = Clamp(m_fVehicleLightingScalarTargetValue, 0.0f, 1.0f);
}
}
// Blend time - converted to rate
if (pAttribTime && pAttribTime->GetType() == crPropertyAttribute::kTypeFloat)
{
const crPropertyAttributeFloat* pTagBlendTimeFloat = static_cast<const crPropertyAttributeFloat*>(pAttribTime);
{
const float fBlendTime = pTagBlendTimeFloat->GetFloat();
if (fBlendTime > VERY_SMALL_FLOAT)
{
// Blend up or down?
if (m_fVehicleLightingScalarTargetValue < m_fVehicleLightingScalar)
{
m_fVehicleLightingScalarBlendRate = -(1.0f / fBlendTime);
}
else
{
m_fVehicleLightingScalarBlendRate = 1.0f / fBlendTime;
}
}
else
{
m_fVehicleLightingScalarBlendRate = 1000.0f;
}
}
}
}
}
}
}
}
}
// Vehicle lighting - Update vehicle lighting scalar.
if (m_fVehicleLightingScalar != m_fVehicleLightingScalarTargetValue)
{
Assert(m_fVehicleLightingScalarTargetValue >= 0.0f && m_fVehicleLightingScalarTargetValue <= 1.0f);
if (m_fVehicleLightingScalarBlendRate == 1000.0f || m_fVehicleLightingScalarBlendRate == -1000.0f)
{
// Instant
m_fVehicleLightingScalar = m_fVehicleLightingScalarTargetValue;
}
else
{
// Blend
const float fDelta = pCutsManager->GetCutSceneCurrentTime() - pCutsManager->GetCutScenePreviousTime();
m_fVehicleLightingScalar += (fDelta * m_fVehicleLightingScalarBlendRate);
// Clamp
if (m_fVehicleLightingScalarBlendRate < 0.0f && m_fVehicleLightingScalar < m_fVehicleLightingScalarTargetValue)
{
m_fVehicleLightingScalar = m_fVehicleLightingScalarTargetValue;
}
else if (m_fVehicleLightingScalarBlendRate > 0.0f && m_fVehicleLightingScalar > m_fVehicleLightingScalarTargetValue)
{
m_fVehicleLightingScalar = m_fVehicleLightingScalarTargetValue;
}
}
}
// Set the vehicle lighting scalar on the cutscene task
Assert(m_fVehicleLightingScalar >= 0.0f && m_fVehicleLightingScalar <= 1.0f);
pCutSceneTask->SetVehicleLightingScalar(m_fVehicleLightingScalar);
}
}
}
void CCutsceneAnimatedActorEntity:: ForceUpdateAi(cutsManager* pManager)
{
if(pManager)
{
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*> (pManager);
if(pCutSceneManager->GetShutDownMode() != SHUTDOWN_SESSION)
{
CPed* pPed = GetGameEntity();
if (pPed)
{
pPed->InstantAIUpdate();
}
}
}
};
/////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedActorEntity::SetGameEntityReadyForGame(cutsManager* pManager)
{
if(!m_bIsReadyForGame)
{
cutsceneModelEntityDebugf2("SetGameEntityReadyForGame - Actor");
if (GetGameEntity())
{
NetworkInterface::CutsceneFinishedOnEntity(*GetGameEntity());
}
if (GetGameRepositionOnlyEntity())
{
NetworkInterface::CutsceneFinishedOnEntity(*GetGameRepositionOnlyEntity());
}
if (GetGameEntity() && !GetGameRepositionOnlyEntity())
{
#if !__NO_OUTPUT
ResetEntityForCallStackLogging();
#endif
//only set entities needed for the game ready for the game
if(m_RegisteredEntityFromScript.bCreatedForScript || !m_RegisteredEntityFromScript.bDeleteBeforeEnd)
{
cutsceneModelEntityDebugf2("SetGameEntityReadyForGame: Setting cutscene ped (%s) ready for game", GetGameEntity()->GetModelName());
SetVisibility(GetGameEntity(), true);
cutsceneModelEntityDebugf2("CCutsceneAnimatedActorEntity::SetGameEntityReadyForGame1 : Showing GetGameEntity (%s)", GetGameEntity()->GetModelName());
GetGameEntity()->SetDesiredHeading(GetGameEntity()->GetTransform().GetHeading());
GetGameEntity()->SetFixedPhysics(false);
GetGameEntity()->EnableCollision();
GetGameEntity()->SetUseExtractedZ(false);
GetGameEntity()->m_nPhysicalFlags.bNotDamagedByAnything = m_bWasInvincible;
GetGameEntity()->SetVelocity(GetAnimatedVelocity());
if (m_OptionFlags.IsFlagSet(CEO_RESET_CAPSULE_AT_END))
{
GetGameEntity()->ClearBound();
GetGameEntity()->SetBoundPitch(0.0f);
GetGameEntity()->SetBoundHeading(0.0f);
GetGameEntity()->SetBoundOffset(VEC3_ZERO);
}
if(m_pCutfObject && !GetGameEntity()->GetPedAiLod().IsSafeToSwitchToFullPhysics())
{
cutsceneModelEntityWarningf("Scene %s has left %s where it's unsafe to turn physics on. Check that the anim is leaving the player out of collision with objects or map", pManager->GetCutsceneName(), m_pCutfObject->GetDisplayName().c_str());
}
GetGameEntity()->GetPedAiLod().ClearLowLodPhysicsFlag();
//if the entity is created by the scene lets reset these variables
if(m_bCreatedByCutscene)
{
GetGameEntity()->SetBlockingOfNonTemporaryEvents(false);
GetGameEntity()->SetPedConfigFlag( CPED_CONFIG_FLAG_DrownsInWater, true );
}
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*>(pManager);
//Set the matrices to be the same for the ragdoll if the scene has been skipped
if(pCutSceneManager->WasSkipped())
{
if(GetGameEntity()->GetRagdollInst() && GetGameEntity()->GetRagdollInst()->IsInLevel()
&& GetGameEntity()->GetRagdollState()!=RAGDOLL_STATE_PHYS
&& GetGameEntity()->GetRagdollState()!=RAGDOLL_STATE_ANIM_DRIVEN)
{
GetGameEntity()->GetRagdollInst()->SetMatrix(GetGameEntity()->GetMatrix());
PHSIM->SetLastInstanceMatrix(GetGameEntity()->GetRagdollInst(), GetGameEntity()->GetMatrix());
GetGameEntity()->GetRagdollInst()->PoseBoundsFromSkeleton(true, true);
GetGameEntity()->GetRagdollInst()->PoseBoundsFromSkeleton(true, true);
}
}
CPed* pPed = GetGameEntity();
if (pPed->GetFacialData())
{
pPed->GetFacialData()->ResetFacialIdleAnimation(pPed);
}
if (!m_OptionFlags.IsFlagSet(CEO_PRESERVE_FACE_BLOOD_DAMAGE))
{
pPed->HideBloodDamage(kDamageZoneHead, false);
}
if (!m_OptionFlags.IsFlagSet(CEO_PRESERVE_BODY_BLOOD_DAMAGE))
{
if (m_OptionFlags.IsFlagSet(CEO_REMOVE_BODY_BLOOD_DAMAGE))
{
pPed->HideBloodDamage(kDamageZoneTorso, false);
pPed->HideBloodDamage(kDamageZoneLeftArm, false);
pPed->HideBloodDamage(kDamageZoneRightArm, false);
pPed->HideBloodDamage(kDamageZoneLeftLeg, false);
pPed->HideBloodDamage(kDamageZoneRightLeg, false);
}
else
{
pPed->LimitBloodDamage(kDamageZoneTorso, -1);
pPed->LimitBloodDamage(kDamageZoneLeftArm, -1);
pPed->LimitBloodDamage(kDamageZoneRightArm, -1);
pPed->LimitBloodDamage(kDamageZoneLeftLeg, -1);
pPed->LimitBloodDamage(kDamageZoneRightLeg, -1);
}
}
}
else
{
cutsceneModelEntityDebugf2("SetGameEntityReadyForGame: Disabling collision on cutscene ped (%s) as it is to be deleted", GetGameEntity()->GetModelName());
//Switch off the collision flags as this entity is to be deleted
if(GetGameEntity()->GetCurrentPhysicsInst()->IsInLevel())
{
CPhysics::GetLevel()->SetInstanceIncludeFlags(GetGameEntity()->GetCurrentPhysicsInst()->GetLevelIndex(), 0);
}
}
}
else
{
//Switch off the collision flags as this entity is to be deleted
if(GetGameEntity() && GetGameEntity()->GetCurrentPhysicsInst()->IsInLevel())
{
cutsceneModelEntityDebugf2("SetGameEntityReadyForGame: Disabling collision on cutscene ped (%s) as it is to be deleted", GetGameEntity()->GetModelName());
CPhysics::GetLevel()->SetInstanceIncludeFlags(GetGameEntity()->GetCurrentPhysicsInst()->GetLevelIndex(), 0);
}
}
if (GetGameRepositionOnlyEntity() && !m_RegisteredEntityFromScript.bDeleteBeforeEnd)
{
cutsceneModelEntityDebugf2("SetGameEntityReadyForGame: Setting reposition ped (%s) ready for game", GetGameRepositionOnlyEntity()->GetModelName());
GetGameRepositionOnlyEntity()->SetFixedPhysics(false);
GetGameRepositionOnlyEntity()->SetPosition(m_CurrentPosition);
GetGameRepositionOnlyEntity()->SetHeading(m_CurrentHeading);
GetGameRepositionOnlyEntity()->SetDesiredHeading(m_CurrentHeading);
GetGameRepositionOnlyEntity()->GetPortalTracker()->RequestRescanNextUpdate();
GetGameRepositionOnlyEntity()->EnableCollision();
GetGameRepositionOnlyEntity()->SetVelocity(GetAnimatedVelocity());
if (m_OptionFlags.IsFlagSet(CEO_RESET_CAPSULE_AT_END))
{
GetGameRepositionOnlyEntity()->ClearBound();
GetGameRepositionOnlyEntity()->SetBoundPitch(0.0f);
GetGameRepositionOnlyEntity()->SetBoundHeading(0.0f);
GetGameRepositionOnlyEntity()->SetBoundOffset(VEC3_ZERO);
}
GetGameRepositionOnlyEntity()->m_nPhysicalFlags.bNotDamagedByAnything = m_bWasInvincible;
GetGameRepositionOnlyEntity()->SetIsVisibleForModule(SETISVISIBLE_MODULE_CUTSCENE, true);
cutsceneModelEntityDebugf2("CCutsceneAnimatedActorEntity::SetGameEntityReadyForGame2: Showing GetGameRepositionOnlyEntity (%s)", GetGameRepositionOnlyEntity()->GetModelName());
CPed* pPed = GetGameRepositionOnlyEntity();
if (pPed->GetFacialData())
{
pPed->GetFacialData()->ResetFacialIdleAnimation(pPed);
}
if (GetGameEntity())
{
SetVisibility(GetGameEntity(), false);
cutsceneModelEntityDebugf2("CCutsceneAnimatedActorEntity::SetGameEntityReadyForGame3: Hiding GetGameEntity (%s)", GetGameEntity()->GetModelName());
}
}
if (m_pCutSceneTask)
{
m_pCutSceneTask->SetExitNextUpdate();
}
m_bIsReadyForGame = true;
}
}
/////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedActorEntity::SetGameEntityReadyForCutscene()
{
if (GetGameEntity())
{
#if !__NO_OUTPUT
SetUpEntityForCallStackLogging();
#endif
cutsceneModelEntityDebugf2("SetGameEntityReadyForCutscene - Actor");
m_fOriginalLODMultiplier = GetGameEntity()->GetLodMultiplier();
GetGameEntity()->SetLodMultiplier(4.0f);
//remove any tasks or motion on the peds before scene starts
// PedIntelligence->FlushImmediately should be done before EquipWeapon to ensure correct prop cleanup [12/21/2012 mdawe]
GetGameEntity()->GetPedIntelligence()->FlushImmediately(true);
// Set the ped's hands to be empty [12/21/2012 mdawe]
if(GetGameEntity()->GetWeaponManager())
{
GetGameEntity()->GetWeaponManager()->EquipWeapon(GetGameEntity()->GetDefaultUnarmedWeaponHash(), -1, true);
}
// Kill off any non-facial idle animations
if (GetGameEntity()->GetAnimDirector())
{
fwAnimDirectorComponentFacialRig* pFacialRigComp = GetGameEntity()->GetAnimDirector()->GetComponentByPhase<fwAnimDirectorComponentFacialRig>(fwAnimDirectorComponent::kPhaseAll);
if (pFacialRigComp)
{
pFacialRigComp->RemoveAllNonIdleFacialAnims();
}
}
if (GetGameEntity()->GetIsAttachedToGround())
{
GetGameEntity()->DetachFromGround();
}
GetGameEntity()->SetPedResetFlag(CPED_RESET_FLAG_DisableGroundAttachment, true);
GetGameEntity()->SetIsCrouching(false);
GetGameEntity()->RemoveMovementAnims();
GetGameEntity()->BlendOutAnyNonMovementAnims(INSTANT_BLEND_OUT_DELTA);
GetGameEntity()->StopAllMotion(true);
if(!m_OptionFlags.IsFlagSet(CEO_DONT_RESET_PED_CAPSULE))
{
GetGameEntity()->InstantResetDesiredMainMoverCapsuleDataForCutscene();
}
GetGameEntity()->SetFixedPhysics(true);
GetGameEntity()->DisableCollision();
GetGameEntity()->m_nPhysicalFlags.bNotDamagedByAnything = true;
// Clone damage from reposition only entity?
if(GetGameRepositionOnlyEntity() && m_OptionFlags.IsFlagSet(CEO_CLONE_DAMAGE_TO_CS_MODEL))
{
GetGameEntity()->CloneDamage(GetGameRepositionOnlyEntity(), true);
}
if (m_OptionFlags.IsFlagSet(CEO_PRESERVE_HAIR_SCALE))
{
m_fOriginalHairScale = GetGameEntity()->GetTargetHairScale();
}
if (!m_OptionFlags.IsFlagSet(CEO_PRESERVE_FACE_BLOOD_DAMAGE))
{
GetGameEntity()->HideBloodDamage(kDamageZoneHead, true);
PEDDAMAGEMANAGER.ClearDamageDecals( GetGameEntity()->GetDamageSetID(), kDamageZoneHead, ATSTRINGHASH("bruise",0xe838afb1));
}
if (!m_OptionFlags.IsFlagSet(CEO_PRESERVE_BODY_BLOOD_DAMAGE))
{
if (m_OptionFlags.IsFlagSet(CEO_REMOVE_BODY_BLOOD_DAMAGE))
{
GetGameEntity()->HideBloodDamage(kDamageZoneTorso, true);
GetGameEntity()->HideBloodDamage(kDamageZoneLeftArm, true);
GetGameEntity()->HideBloodDamage(kDamageZoneRightArm, true);
GetGameEntity()->HideBloodDamage(kDamageZoneLeftLeg, true);
GetGameEntity()->HideBloodDamage(kDamageZoneRightLeg, true);
}
else
{
static s32 s_maxBloodDamageForCutscene = 2;
GetGameEntity()->LimitBloodDamage(kDamageZoneTorso, s_maxBloodDamageForCutscene);
GetGameEntity()->LimitBloodDamage(kDamageZoneLeftArm, s_maxBloodDamageForCutscene);
GetGameEntity()->LimitBloodDamage(kDamageZoneRightArm, s_maxBloodDamageForCutscene);
GetGameEntity()->LimitBloodDamage(kDamageZoneLeftLeg, s_maxBloodDamageForCutscene);
GetGameEntity()->LimitBloodDamage(kDamageZoneRightLeg, s_maxBloodDamageForCutscene);
}
}
if (m_OptionFlags.IsFlagSet(CEO_IS_CASCADE_SHADOW_FOCUS_ENTITY_DURING_EXIT) && CutSceneManager::GetInstance() && CutSceneManager::GetInstance()->GetCamEntity())
{
// Register this with the camera
CCutSceneCameraEntity* pCam = const_cast<CCutSceneCameraEntity*>(CutSceneManager::GetInstance()->GetCamEntity());
if (pCam)
{
if (GetGameRepositionOnlyEntity())
{
pCam->SetCascadeShadowFocusEntityForSeamlessExit(GetGameRepositionOnlyEntity());
}
else
{
pCam->SetCascadeShadowFocusEntityForSeamlessExit(GetGameEntity());
}
}
}
NetworkInterface::CutsceneStartedOnEntity(*GetGameEntity());
}
}
void CCutsceneAnimatedActorEntity::SetRepositionOnlyEntityReadyForCutscene()
{
if(GetGameRepositionOnlyEntity())
{
m_fOriginalLODMultiplier = GetGameRepositionOnlyEntity()->GetLodMultiplier();
GetGameRepositionOnlyEntity()->SetLodMultiplier(4.0f);
if(GetGameRepositionOnlyEntity()->GetWeaponManager())
{
GetGameRepositionOnlyEntity()->GetWeaponManager()->EquipWeapon(GetGameRepositionOnlyEntity()->GetDefaultUnarmedWeaponHash(), -1, true);
}
if(GetGameRepositionOnlyEntity()->IsNetworkClone())
{
GetGameRepositionOnlyEntity()->GetPedIntelligence()->FlushImmediately(false);
GetGameRepositionOnlyEntity()->GetPedIntelligence()->AddTaskDefault(rage_new CTaskNetworkClone());
}
else
{
GetGameRepositionOnlyEntity()->GetPedIntelligence()->FlushImmediately(true);
}
GetGameRepositionOnlyEntity()->SetIsCrouching(false);
GetGameRepositionOnlyEntity()->RemoveMovementAnims();
GetGameRepositionOnlyEntity()->BlendOutAnyNonMovementAnims(INSTANT_BLEND_OUT_DELTA);
GetGameRepositionOnlyEntity()->StopAllMotion(true);
GetGameRepositionOnlyEntity()->DisableCollision();
GetGameRepositionOnlyEntity()->SetFixedPhysics(true);
GetGameRepositionOnlyEntity()->m_nPhysicalFlags.bNotDamagedByAnything = true;
GetGameRepositionOnlyEntity()->SetIsVisibleForModule(SETISVISIBLE_MODULE_CUTSCENE, false);
cutsceneModelEntityDebugf2("CCutsceneAnimatedActorEntity::SetRepositionOnlyEntityReadyForCutscene: Hiding GetGameRepositionOnlyEntity (%s)", GetGameRepositionOnlyEntity()->GetModelName());
NetworkInterface::CutsceneStartedOnEntity(*GetGameRepositionOnlyEntity());
}
}
/////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedActorEntity::UpdateActorMotionState()
{
if(GetGameEntity())
{
GetGameEntity()->ForceMotionStateThisFrame(CPedMotionStates::MotionState_DoNothing);
}
}
/////////////////////////////////////////////////////////////////////////
namespace
{
void* g_pCharClothController = NULL;
int g_capsuleLeftT = 0;
int g_capsuleRightT = 1;
float g_customLength = -1.0f;
float g_customRadius = -1.0f;
}
void CCutsceneAnimatedActorEntity::DispatchEvent(cutsManager* pManager, const cutfObject* pObject, s32 iEventId, const cutfEventArgs* pEventArgs,const float fEventTime, const u32 UNUSED_PARAM(StickyId))
{
switch ( iEventId )
{
case CUTSCENE_UPDATE_EVENT:
case CUTSCENE_PAUSE_EVENT:
{
if (m_bIsReadyForGame)
{
return;
}
/*if ( iEventId == CUTSCENE_UPDATE_EVENT)
{
cutsceneModelEntityDebugf("CCutsceneAnimatedActorEntity::DispatchEvent: CUTSCENE_UPDATE_EVENT");
}
else
{
cutsceneModelEntityDebugf("CCutsceneAnimatedActorEntity::DispatchEvent: CUTSCENE_PAUSE_EVENT");
}*/
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*>(pManager);
if (GetGameEntity())
GetGameEntity()->SetPedResetFlag(CPED_RESET_FLAG_OverridePhysics, true);
if(GetGameEntity() && m_pCutSceneTask == NULL)
{
GetGameEntity()->SetPedResetFlag(CPED_RESET_FLAG_DisablePotentialBlastReactions, true);
}
if(!IsBlockingVariationStreamingAndApplication())
{
PreStreamVariations(pCutSceneManager, pManager->GetTime(), PED_VARIATION_STREAMING_OFFSET);
}
if (iEventId==CUTSCENE_UPDATE_EVENT && m_bStoppedCalled)
{
CreateRepositionOnlyGameEntityWhenModelLoaded(pManager, pObject, true, true );
SetGameEntityReadyForGame(pManager);
}
UpdateCutSceneTask(pManager);
//Need to prevent time slicing if being updated by the cut scene system, cant just rely on the task blocking it
if (GetGameEntity())
{
GetGameEntity()->GetPedAiLod().SetForceNoTimesliceIntelligenceUpdate(true);
GetGameEntity()->GetPedAiLod().SetBlockedLodFlag(CPedAILod::AL_LodTimesliceIntelligenceUpdate | CPedAILod::AL_LodTimesliceAnimUpdate);
}
}
break;
case CUTSCENE_SET_VARIATION_EVENT:
{
if(IsBlockingVariationStreamingAndApplication())
{
return;
}
if (m_bIsReadyForGame)
{
//cutsceneModelEntityDebugf("CCutsceneAnimatedActorEntity::DispatchEvent: Ignoring CUTSCENE_SET_VARIATION_EVENT m_bIsReadyForGame = false");
return;
}
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*>(pManager);
//dont set the variations from the first frame, it has already been done.
if((pCutSceneManager->GetCutSceneCurrentTime() > pCutSceneManager->GetStartTime()) && (fEventTime > pCutSceneManager->GetStartTime()) && !m_bIsReadyForGame )
{
if(!GetGameEntity())
{
cutsceneModelEntityWarningf("No ped entity to set a variation on %s", pObject->GetDisplayName().c_str());
}
//cutsceneModelEntityDebugf("CCutsceneAnimatedActorEntity::DispatchEvent - CUTSCENE_SET_VARIATION_EVENT");
cutsceneAssertf(pEventArgs, "Cutscene content bug! CUTSCENE_SET_VARIATION_EVENT (object name=%s type=%s)(event id=%i) is corrupted and needs to be recreated, variation will not be applied!", pObject->GetDisplayName().c_str(), pObject->GetTypeName(), iEventId);
if (pEventArgs && pEventArgs->GetType() == CUTSCENE_ACTOR_VARIATION_EVENT_ARGS_TYPE)
{
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*>(pManager);
CCutSceneAssetMgrEntity* pAssetManager = pCutSceneManager->GetAssetManager();
const cutfObjectVariationEventArgs* pVariationEventFlag = static_cast<const cutfObjectVariationEventArgs *>( pEventArgs );
int Component = pVariationEventFlag->GetComponent();
int Drawable = pVariationEventFlag->GetDrawable();
int Texture = pVariationEventFlag->GetTexture();
if ((Component>-1 && Drawable>-1 && Texture>-1) || (Component>=PV_MAX_COMP && Drawable>-2))
{
cutsceneModelEntityDebugf3("CCutsceneAnimatedActorEntity::DispatchEvent: CUTSCENE_SET_VARIATION_EVENT: (Component: %d (%s), Drawable: %d, Texture: %d)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
SetCurrentActorVariation(GetGameEntity(), Component, Drawable, Texture);
if (Component<PV_MAX_COMP)
pAssetManager->RemoveVariationStreamRequest(Component, Drawable, Texture, m_ModelNameHash, pObject->GetObjectId());
}
else
{
cutsceneModelEntityDebugf3("CCutsceneAnimatedActorEntity::DispatchEvent: Ignoring CUTSCENE_SET_VARIATION_EVENT with invalid data: (Component: %d (%s), Drawable: %d, Texture: %d)", Component, CPedVariationData::GetVarOrPropSlotName(Component), Drawable, Texture);
}
}
else
{
cutsceneModelEntityDebugf3("CCutsceneAnimatedActorEntity::DispatchEvent: Ignoring CUTSCENE_SET_VARIATION_EVENT with invalid or null event arguments");
}
}
else
{
//cutsceneModelEntityDebugf("CCutsceneAnimatedActorEntity::DispatchEvent: Ignoring CUTSCENE_SET_VARIATION_EVENT pCutSceneManager->GetCutSceneCurrentTime() != pCutSceneManager->GetStartTimeFromStartFrame() && !m_bIsReadyForGame");
}
}
break;
case CUTSCENE_SET_DUAL_CLIP_EVENT:
{
if (pEventArgs && pEventArgs->GetType() == CUTSCENE_DUAL_CLIP_EVENT_ARGS_TYPE)
{
if (pObject)
{
cutsceneAssertf (0,"Not supported : CUTSCENE_SET_DUAL_CLIP_EVENT %s ",pObject->GetDisplayName().c_str());
}
}
}
break;
case CUTSCENE_END_OF_SCENE_EVENT:
{
cutsceneModelEntityDebugf3("CCutsceneAnimatedActorEntity::DispatchEvent - CUTSCENE_END_OF_SCENE_EVENT");
#if RECORDING_VERTS
if( PFD_DebugRecords.WillDraw() )
{
g_DbgRecordCustomClothEvents.Reset();
}
#endif
if( GetGameEntity() && GetGameEntity()->GetIsTypePed() )
{
CPed* pPed = static_cast<CPed*>(GetGameEntity());
if( pPed )
{
for( int i = 0; i < PV_MAX_COMP; ++i )
{
characterClothController* pCharClothController = pPed->m_CClothController[i];
if( pCharClothController )
{
pCharClothController->CheckQueuedPinning();
pCharClothController->SetPinRadiusSetThreshold( PIN_RADIUSSETS_PACKAGE_THRESHOLD );
pCharClothController->SetFlag( characterClothController::enIsForceSkin, false);
pCharClothController->SetFlag( characterClothController::enIsProne, false );
pCharClothController->SetFlag( characterClothController::enIsProneFlipped, false );
pCharClothController->SetFlag( characterClothController::enIsEndCutscene, true );
pCharClothController->SetPackageIndex(0);
if( (i == PV_COMP_UPPR) && (g_pCharClothController == pCharClothController) )
{
characterCloth* pCharCloth = (characterCloth*)pCharClothController->GetOwner();
Assert( pCharCloth );
const phBoundComposite* pCustomBound = pCharCloth->GetBoundComposite();
Assert( pCustomBound );
if( pCustomBound )
{
Assert( g_customLength > 0.0f );
Assert( g_customRadius > 0.0f );
phBound* pBoundPart = pCustomBound->GetBound(g_capsuleLeftT);
Assert( pBoundPart );
Assert( pBoundPart->GetType() == phBound::CAPSULE );
phBoundCapsule* pBoundCapsule = (phBoundCapsule*)pBoundPart;
Assert( pBoundCapsule );
pBoundCapsule->SetCapsuleSize( g_customRadius, g_customLength );
pBoundPart = pCustomBound->GetBound(g_capsuleRightT);
Assert( pBoundPart );
Assert( pBoundPart->GetType() == phBound::CAPSULE );
pBoundCapsule = (phBoundCapsule*)pBoundPart;
Assert( pBoundCapsule );
pBoundCapsule->SetCapsuleSize( g_customRadius, g_customLength );
g_pCharClothController = NULL;
g_customLength = -1.0f;
g_customRadius = -1.0f;
}
}
phVerletCloth* verletCloth = pCharClothController->GetCloth(0);
Assert( verletCloth );
verletCloth->DetachVirtualBound();
verletCloth->SetFlag(phVerletCloth::FLAG_COLLIDE_EDGES, false);
verletCloth->SetFlag(phVerletCloth::FLAG_IGNORE_OFFSET, false);
} // if( pPed->m_CClothController[i] )
} // for( int i = 0; i < PV_MAX_COMP; ++i )
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForceSkinCharacterCloth, false );
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForcePoseCharacterCloth, false );
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForcePackageCharacterCloth, false );
} // CPed* pPed = static_cast<CPed*>(GetGameEntity());
} // if( GetGameEntity() && GetGameEntity()->GetIsTypePed() )
}
break;
case CutSceneCustomEvents::CUTSCENE_CUSTOM_CLOTH_EVENT:
{
//cutsceneModelEntityDebugf("CCutsceneAnimatedActorEntity::DispatchEvent: CUTSCENE_CUSTOM_CLOTH_EVENT");
const CutSceneCustomEvents::ICutsceneCustomCustomEventArgs* pObjectVar = static_cast<const CutSceneCustomEvents::ICutsceneCustomCustomEventArgs*>(pEventArgs);
if( GetGameEntity() && GetGameEntity()->GetIsTypePed() && pObjectVar )
{
clothDebugf1("CUTSCENE_CUSTOM_CLOTH_EVENT: eventType = %d", pObjectVar->GetEventType() );
CPed* pPed = static_cast<CPed*>(GetGameEntity());
if( pPed )
{
const int eventType = pObjectVar->GetEventType();
AssertMsg( (eventType > 0 && eventType < CCEVENT_TYPE_MAX), "The event type value is not correct" );
if( eventType == CCEVENT_TYPE_SET_SKIN_ON_ONCREATE )
{
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForceSkinCharacterCloth, true );
}
else if( eventType == CCEVENT_TYPE_SET_SKIN_OFF_ONCREATE )
{
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForceSkinCharacterCloth, false );
}
else if( eventType == CCEVENT_TYPE_QUEUE_POSE_ON || eventType == CCEVENT_TYPE_SET_POSE )
{
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForcePoseCharacterCloth, true );
pPed->QueueClothPoseIndex( (u8)pObjectVar->GetCapsuleLength() );
}
else if( eventType == CCEVENT_TYPE_QUEUE_POSE_OFF )
{
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForcePoseCharacterCloth, false );
}
else if( eventType == CCEVENT_TYPE_SET_PACKAGE_INDEX )
{
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForcePackageCharacterCloth, true );
pPed->QueueClothPackageIndex( (u8)pObjectVar->GetCapsuleLength() );
}
else if( eventType == CCEVENT_TYPE_SET_PRONE_ON )
{
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForceProneCharacterCloth, true );
}
for( int i = 0; i < PV_MAX_COMP; ++i )
{
characterClothController* pCharClothController = pPed->m_CClothController[i];
if( pCharClothController )
{
phVerletCloth* verletCloth = pCharClothController->GetCloth(0);
Assert( verletCloth );
#if RECORDING_VERTS
if( PFD_DebugRecords.WillDraw()
&& eventType != CCEVENT_TYPE_ATTACH_COLLISION
&& eventType != CCEVENT_TYPE_SET_PACKAGE_INDEX
&& eventType != CCEVENT_TYPE_SET_POSE
)
{
recordCustomClothEvent rec;
rec.m_Text = "CUTSCENE_CUSTOM_CLOTH_EVENT";
rec.m_ClothControllerName = pPed->m_CClothController[i]->GetName();
rec.m_EventType = eventType;
//rec.m_Frames = 60;
g_DbgRecordCustomClothEvents.Push( rec );
}
#endif
// TODO: add debug text showing warning on the screen if bound exists already ?
if( eventType == CCEVENT_TYPE_ATTACH_COLLISION && !verletCloth->m_VirtualBound )
{
Vector3 vPos = VEC3_ZERO;
vPos.x = pObjectVar->GetPositionX();
vPos.y = pObjectVar->GetPositionY();
vPos.z = pObjectVar->GetPositionZ();
Vector3 vRot = VEC3_ZERO;
vRot.x = pObjectVar->GetRotationX();
vRot.y = pObjectVar->GetRotationY();
vRot.z = pObjectVar->GetRotationZ();
Mat34V boundMat;
Mat34VFromEulersXYZ( boundMat, VECTOR3_TO_VEC3V(vRot) );
boundMat.SetCol3( VECTOR3_TO_VEC3V(vPos) );
float fCapsuleLen = pObjectVar->GetCapsuleLength();
float fCapsuleRad = pObjectVar->GetCapsuleRadius();
verletCloth->SetFlag(phVerletCloth::FLAG_COLLIDE_EDGES, true);
verletCloth->SetFlag(phVerletCloth::FLAG_IGNORE_OFFSET, true);
verletCloth->CreateVirtualBound( 1, &identityMat );
verletCloth->AttachVirtualBoundCapsule( fCapsuleRad, fCapsuleLen, boundMat, 0 );
#if RECORDING_VERTS
if( PFD_DebugRecords.WillDraw() )
{
recordCustomClothEvent rec;
rec.m_Text = "CUTSCENE_CUSTOM_CLOTH_EVENT";
rec.m_ClothControllerName = pPed->m_CClothController[i]->GetName();
rec.m_EventType = eventType;
rec.m_Position = VECTOR3_TO_VEC3V(vPos);
rec.m_Rotation = VECTOR3_TO_VEC3V(vRot);
rec.m_CapsuleLength = fCapsuleLen;
rec.m_CapsuleRadius = fCapsuleRad;
//rec.m_Frames = 60;
g_DbgRecordCustomClothEvents.Push( rec );
}
#endif
}
else if( eventType == CCEVENT_TYPE_DETACH_COLLISION )
{
verletCloth->DetachVirtualBound();
verletCloth->SetFlag(phVerletCloth::FLAG_COLLIDE_EDGES, false);
verletCloth->SetFlag(phVerletCloth::FLAG_IGNORE_OFFSET, false);
}
else if( eventType == CCEVENT_TYPE_SET_SKIN_ON )
{
pCharClothController->SetFlag( characterClothController::enIsForceSkin, true);
}
else if( eventType == CCEVENT_TYPE_SET_SKIN_OFF )
{
pCharClothController->SetFlag( characterClothController::enIsForceSkin, false);
}
else if( eventType == CCEVENT_TYPE_FORCE_PIN )
{
pCharClothController->SetForcePin(1);
}
else if( eventType == CCEVENT_TYPE_SET_PACKAGE_INDEX )
{
pCharClothController->SetPackageIndex( (u8)pObjectVar->GetCapsuleLength() );
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForcePackageCharacterCloth, false );
#if RECORDING_VERTS
if( PFD_DebugRecords.WillDraw() )
{
recordCustomClothEvent rec;
rec.m_Text = "CUTSCENE_CUSTOM_CLOTH_EVENT";
rec.m_ClothControllerName = pPed->m_CClothController[i]->GetName();
rec.m_EventType = eventType;
rec.m_CapsuleLength = pObjectVar->GetCapsuleLength();
//rec.m_Frames = 60;
g_DbgRecordCustomClothEvents.Push( rec );
}
#endif
}
else if( eventType == CCEVENT_TYPE_SET_PRONE_ON )
{
pCharClothController->SetFlag( characterClothController::enIsProneFlipped, true );
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForceProneCharacterCloth, false );
}
else if( eventType == CCEVENT_TYPE_SET_PRONE_OFF )
{
pCharClothController->SetFlag( characterClothController::enIsProne, false );
pCharClothController->SetFlag( characterClothController::enIsProneFlipped, false );
}
else if( eventType == CCEVENT_TYPE_SET_PIN_RADIUS_THRESHOLD )
{
pCharClothController->SetPinRadiusSetThreshold( pObjectVar->GetCapsuleLength() );
}
else if( eventType == CCEVENT_TYPE_SET_POSE )
{
// NOTE: if we set a pose then don't skin
pCharClothController->SetFlag( characterClothController::enIsForceSkin, false );
pCharClothController->SetForcePin( 0 );
characterCloth* pCharCloth = (characterCloth*)pCharClothController->GetOwner();
Assert( pCharCloth );
pCharCloth->SetPose( (u8)pObjectVar->GetCapsuleLength() );
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_ForcePoseCharacterCloth, false );
#if RECORDING_VERTS
if( PFD_DebugRecords.WillDraw() )
{
recordCustomClothEvent rec;
rec.m_Text = "CUTSCENE_CUSTOM_CLOTH_EVENT";
rec.m_ClothControllerName = pPed->m_CClothController[i]->GetName();
rec.m_EventType = eventType;
rec.m_CapsuleLength = pObjectVar->GetCapsuleLength();
g_DbgRecordCustomClothEvents.Push( rec );
}
#endif
}
else if( eventType == CCEVENT_TYPE_CUSTOM_1 && i == PV_COMP_UPPR )
{
// TODO: hacky way to increase the raduis on the collision bounds from cutscene
characterCloth* pCharCloth = (characterCloth*)pCharClothController->GetOwner();
Assert( pCharCloth );
const phBoundComposite* pCustomBound = pCharCloth->GetBoundComposite();
Assert( pCustomBound );
if( pCustomBound )
{
phBound* pBoundPart = pCustomBound->GetBound(g_capsuleLeftT);
Assert( pBoundPart );
Assert( pBoundPart->GetType() == phBound::CAPSULE );
phBoundCapsule* pBoundCapsule = (phBoundCapsule*)pBoundPart;
Assert( pBoundCapsule );
pBoundCapsule->SetCapsuleSize( pObjectVar->GetCapsuleRadius(), pObjectVar->GetCapsuleLength() );
pBoundPart = pCustomBound->GetBound(g_capsuleRightT);
Assert( pBoundPart );
Assert( pBoundPart->GetType() == phBound::CAPSULE );
pBoundCapsule = (phBoundCapsule*)pBoundPart;
Assert( pBoundCapsule );
pBoundCapsule->SetCapsuleSize( pObjectVar->GetCapsuleRadius(), pObjectVar->GetCapsuleLength() );
Assert( !g_pCharClothController );
g_pCharClothController = pCharClothController;
g_customLength = pObjectVar->GetCapsuleLength();
g_customRadius = pObjectVar->GetCapsuleRadius();
}
}
}
} // for
} // if( pPed )
} // if ( GetGameEntity ...
}
break;
case CUTSCENE_STOP_EVENT:
{
}
break;
}
//this is here to dispatch debug draw event for this entity.
#if __BANK
cutsEntity::DispatchEvent(pManager, pObject, iEventId, pEventArgs);
#endif
CCutsceneAnimatedModelEntity::DispatchEvent(pManager, pObject, iEventId, pEventArgs);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedActorEntity::PlayClip (CutSceneManager* pCutManager, const crClip* pClip, float fEventTime, const strStreamingObjectName UNUSED_PARAM(pAnimDict))
{
//Assertf(CutSceneManager::GetInstance()->GetAssetManager()->HaveAllVariationsLoaded(PED_VARIATION_TYPE), "Variations not yet loaded");
//CutSceneManager::GetInstance()->GetAssetManager()->DumpAllVariationsLoaded(m_pCutfObject->GetObjectId());
if(GetGameEntity())
{
if(!m_pCutSceneTask)
{
GetGameEntity()->SetPedResetFlag( CPED_RESET_FLAG_AllowUpdateIfNoCollisionLoaded, true );
// Make sure we don't timeslice the ai / animation this frame.
GetGameEntity()->GetPedAiLod().SetForceNoTimesliceIntelligenceUpdate(true);
GetGameEntity()->GetPedAiLod().SetBlockedLodFlag(CPedAILod::AL_LodTimesliceIntelligenceUpdate | CPedAILod::AL_LodTimesliceAnimUpdate);
if(GetGameEntity()->IsProtectedBaseFlagSet(fwEntity::IS_FIXED_UNTIL_COLLISION))
{
GetGameEntity()->UpdateFixedWaitingForCollision(false);
}
if(GetGameEntity()->GetPedIntelligence()->GetTaskEventResponse())
{
GetGameEntity()->GetPedIntelligence()->FlushImmediately(true);
}
m_pCutSceneTask = CreateCutsceneTask(pCutManager, pClip, fEventTime);
m_pCutSceneTask->SetPreserveHairScale(m_OptionFlags.IsFlagSet(CEO_PRESERVE_HAIR_SCALE));
m_pCutSceneTask->SetInstantHairScaleUpdate(m_OptionFlags.IsFlagSet(CEO_INSTANT_HAIR_SCALE_SETUP));
m_pCutSceneTask->SetOriginalHairScale(m_fOriginalHairScale);
if(GetGameEntity()->IsNetworkClone())
{
GetGameEntity()->GetPedIntelligence()->AddLocalCloneTask(m_pCutSceneTask, PED_TASK_PRIORITY_PRIMARY);
}
else
{
GetGameEntity()->GetPedIntelligence()->AddTaskAtPriority(m_pCutSceneTask, PED_TASK_PRIORITY_PRIMARY, TRUE);
}
GetGameEntity()->SetFixedPhysics(false);
}
else
{
if(cutsceneVerifyf(m_pCutSceneTask->GetTaskType() == CTaskTypes::TASK_CUTSCENE, "Trying to set the clip on a CTaskCutscene, but entity %s is not running a cutscene task", m_pCutfObject->GetDisplayName().c_str()))
{
Matrix34 SceneMat;
pCutManager->GetSceneOrientationMatrix(SceneMat);
m_pCutSceneTask->SetClip(pClip,SceneMat, fEventTime);
}
}
}
#if __DEV
if(GetGameEntity() && m_pCutSceneTask && m_pCutSceneTask->GetTaskType() == CTaskTypes::TASK_CUTSCENE)
{
//THIS CURRENTLY DOES NOTHING TO FILTER ANY ANIMS BECAUSE THERE IS NO FILTER TO REMOVE ALL ANIM EXCEPT FACIAL
UpdateWithFaceViewer(pCutManager, m_pCutSceneTask);
}
#endif
SetAnimPlayBackEventTime(fEventTime);
}
/////////////////////////////////////////////////////////////////////////
//Gets the position of an actors bone (used for face zoom but could use for hands etc
bool CCutsceneAnimatedActorEntity::GetActorBonePosition(eAnimBoneTag ePedBone, Matrix34 &mMat) const
{
const crSkeleton* pSkel = NULL;
s32 nBoneIndex = -1;
if (GetGameEntity())
{
pSkel = GetGameEntity()->GetSkeleton();
nBoneIndex = GetGameEntity()->GetBoneIndexFromBoneTag(ePedBone);
}
if (pSkel && nBoneIndex!= -1)
{
pSkel->GetGlobalMtx(nBoneIndex, RC_MAT34V(mMat));
return true;
}
return false;
}
/////////////////////////////////////////////////////////////////////////
//set the variation on an actor
void CCutsceneAnimatedActorEntity::SetCurrentActorVariation(CPed* pPed, u32 iComponent, s32 iDrawable, s32 iTexture)
{
if(IsBlockingVariationStreamingAndApplication())
{
return;
}
//setting the variation on a ped
if (pPed && pPed->GetPedModelInfo() && pPed->GetPedModelInfo()->GetVarInfo())
{
if(iComponent < PV_MAX_COMP)
{
if(pPed->IsVariationInRange(static_cast<ePedVarComp>(iComponent),iDrawable,iTexture))
{
//if(!pPed->HasVariation(static_cast<ePedVarComp>(iComponent), iDrawable, iTexture))
{
if (pPed->GetPedModelInfo()->GetIsStreamedGfx())
{
// Check the variation is loaded
eVariationStreamingStatus variationStreamingStatus = CutSceneManager::GetInstance()->GetAssetManager()->GetVariationLoadingState(iComponent, iDrawable, iTexture, m_ModelNameHash, m_pCutfObject->GetObjectId());
if( variationStreamingStatus == LOADING_VARIATION)
{
cutsceneModelEntityDebugf3("SetCurrentActorVariation (%s, %p) - Variation is still loading (Component: %d (%s), Drawable: %d, Texture: %d) ",
pPed->GetModelName(), pPed, iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent), iDrawable, iTexture );
}
else if ( variationStreamingStatus == NO_REQUEST_FOR_VARIATION )
{
cutsceneModelEntityDebugf3("SetCurrentActorVariation (%s, %p) - Variation has no request (Component: %d (%s), Drawable: %d, Texture: %d) ",
pPed->GetModelName(), pPed, iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent), iDrawable, iTexture );
}
}
#if !__NO_OUTPUT
bool ReactivateLogging = false;
if(pPed->m_LogVariationCalls)
{
pPed->m_LogVariationCalls = false;
ReactivateLogging = true;
}
#endif //!__NO_OUTPUT
pPed->SetVariation(static_cast<ePedVarComp>(iComponent), iDrawable, 0, iTexture, 0, 0, true);
#if !__NO_OUTPUT
if(ReactivateLogging)
{
pPed->m_LogVariationCalls = true;
}
#endif //!__NO_OUTPUT
cutsceneModelEntityDebugf3("SetCurrentActorVariation (%s, %p) - Actual SetVariation - (Component: %d (%s), Drawable: %d/%d, Texture: %d/%d)",
pPed->GetModelName(), pPed, iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent),
iDrawable, pPed->GetPedModelInfo()->GetVarInfo()->GetMaxNumDrawbls(static_cast<ePedVarComp>(iComponent)),
iTexture, pPed->GetPedModelInfo()->GetVarInfo()->GetMaxNumTex(static_cast<ePedVarComp>(iComponent),iDrawable));
}
/*else
{
cutsceneModelEntityDebugf("SetCurrentActorVariation (%s, %p) - Already has variation - (Component: %d (%s), Drawable: %d/%d, Texture: %d/%d)",
pPed->GetModelName(), pPed, iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent),
iDrawable, pPed->GetPedModelInfo()->GetVarInfo()->GetMaxNumDrawbls(static_cast<ePedVarComp>(iComponent)),
iTexture, pPed->GetPedModelInfo()->GetVarInfo()->GetMaxNumTex(static_cast<ePedVarComp>(iComponent),iDrawable));
}*/
}
else
{
cutsceneModelEntityDebugf3("SetCurrentActorVariation (%s, %p) - Variation not in range - (Component: %d (%s), Drawable: %d/%d, Texture: %d/%d) (using default instead) ",
pPed->GetModelName(), pPed, iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent),
iDrawable, pPed->GetPedModelInfo()->GetVarInfo()->GetMaxNumDrawbls(static_cast<ePedVarComp>(iComponent)),
iTexture, pPed->GetPedModelInfo()->GetVarInfo()->GetMaxNumTex(static_cast<ePedVarComp>(iComponent),iDrawable));
// Check the default variation is loaded
eVariationStreamingStatus variationStreamingStatus = CutSceneManager::GetInstance()->GetAssetManager()->GetVariationLoadingState(iComponent, 0, 0, m_ModelNameHash, m_pCutfObject->GetObjectId());
if( variationStreamingStatus == LOADING_VARIATION)
{
cutsceneModelEntityDebugf3("SetCurrentActorVariation (%s, %p) - Variation is still loading (Component: %d (%s), Drawable: %d, Texture: %d) ",
pPed->GetModelName(), pPed, iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent), 0, 0 );
}
else if ( variationStreamingStatus == NO_REQUEST_FOR_VARIATION )
{
cutsceneModelEntityDebugf3("SetCurrentActorVariation (%s, %p) - Variation has no request (Component: %d (%s), Drawable: %d, Texture: %d) ",
pPed->GetModelName(), pPed, iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent), 0, 0 );
}
#if !__NO_OUTPUT
bool ReactivateLogging = false;
if(pPed->m_LogVariationCalls)
{
pPed->m_LogVariationCalls = false;
ReactivateLogging = true;
}
#endif //!__NO_OUTPUT
pPed->SetVariation(static_cast<ePedVarComp>(iComponent), 0, 0, 0, 0, 0, true);
#if !__NO_OUTPUT
if(ReactivateLogging)
{
pPed->m_LogVariationCalls = true;
}
#endif //!__NO_OUTPUT
cutsceneModelEntityDebugf3("SetCurrentActorVariation (%s, %p) - Actual SetVariation - (Component: %d (%s), Drawable: %d/%d, Texture: %d/%d)",
pPed->GetModelName(), pPed, iComponent, CPedVariationData::GetVarOrPropSlotName(0),
0, pPed->GetPedModelInfo()->GetVarInfo()->GetMaxNumDrawbls(static_cast<ePedVarComp>(0)),
0, pPed->GetPedModelInfo()->GetVarInfo()->GetMaxNumTex(static_cast<ePedVarComp>(0),0));
}
}
else
{
int iPropComponent = iComponent - PV_MAX_COMP;
if(iDrawable != -1)
{
CPedPropsMgr::SetPedProp(pPed, (eAnchorPoints)iPropComponent , iDrawable, iTexture, ANCHOR_NONE, NULL, NULL);
cutsceneModelEntityDebugf3("SetCurrentActorVariation (%s, %p) - Actual SetPedProp - (Component: %d (%s), Drawable: %d, Texture: %d)", pPed->GetModelName(), pPed, iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent), iDrawable, iTexture);
}
else
{
CPedPropsMgr::ClearPedProp(pPed, (eAnchorPoints)iPropComponent );
if(iComponent == PV_COMP_HEAD && pPed->GetHelmetComponent())
{
pPed->GetHelmetComponent()->DisableHelmet(false);
}
cutsceneModelEntityDebugf3("SetActorCurrentVariation (%s, %p) - Actual ClearPedProp - (Component: %d (%s))", pPed->GetModelName(), pPed, iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent));
}
}
}
else
{
cutsceneModelEntityDebugf3("SetCurrentActorVariation - Ped not loaded (or malformed). Failed to set variation on ped but storing the variation to apply once the ped is loaded. - (Component: %d (%s), Drawable: %d, Texture: %d)",
iComponent, CPedVariationData::GetVarOrPropSlotName(iComponent),iDrawable, iTexture);
}
if ((iDrawable>-1 && iTexture>-1) || (iComponent>=PV_MAX_COMP && iDrawable>-2))
{
StoreActorVariationData( iComponent, iDrawable, iTexture, m_sCurrentActorVariationData);
}
}
void CCutsceneAnimatedActorEntity::SetScriptActorVariationData( u32 iComponent, s32 iDrawable, s32 iTexture)
{
if((iDrawable>-1 && iTexture>-1) || (iComponent>=PV_MAX_COMP && iDrawable>-2))
{
// Store the variations set by script in their own array
// These will be used in favour of cutscene variations on the start frame
StoreActorVariationData(iComponent, iDrawable, iTexture, m_sScriptActorVariationData);
// Also copy the variations into the current array
// Peds not loaded before the scene dotn get ComputeInitialVariations called on them
StoreActorVariationData(iComponent, iDrawable, iTexture, m_sCurrentActorVariationData);
}
}
/////////////////////////////////////////////////////////////////////////
CCutsceneAnimatedActorEntity::~CCutsceneAnimatedActorEntity()
{
//check that the script registered entity is being picked up by the script
if(m_RegisteredEntityFromScript.pEnt != NULL)
{
if(m_RegisteredEntityFromScript.pEnt->GetIsTypePed())
{
CPed* pPed = (CPed*)m_RegisteredEntityFromScript.pEnt.Get();
if(!pPed->IsLocalPlayer())
{
if(m_RegisteredEntityFromScript.SceneNameHash > 0 && m_RegisteredEntityFromScript.bCreatedForScript)
{
const CScriptEntityExtension* pExtension = m_RegisteredEntityFromScript.pEnt->GetExtension<CScriptEntityExtension>();
if(!CutSceneManager::GetInstance()->ShouldDeleteAllRegisteredEntites())
{
if(!IsRegisteredGameEntityUnderScriptControl())
{
cutsceneAssertf(pExtension, "Deleting a cutscene entity (\"%s\" %u) scene handle (\"%s\" %u) that was registered with CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY use GET_ENTITY_INDEX_OF_REGISTERED_ENTITY to make sure it is pickup up by the script",
m_RegisteredEntityFromScript.ModelNameHash.TryGetCStr(),
m_RegisteredEntityFromScript.ModelNameHash.GetHash(),
m_RegisteredEntityFromScript.SceneNameHash.TryGetCStr(),
m_RegisteredEntityFromScript.SceneNameHash.GetHash());
}
}
if(!pExtension)
{
m_RegisteredEntityFromScript.bDeleteBeforeEnd = true;
}
}
}
}
}
if (GetGameEntity())
{
bool CanDelete = m_RegisteredEntityFromScript.pEnt != GetGameEntity();
if(CanDelete|| m_RegisteredEntityFromScript.bDeleteBeforeEnd)
{
GetGameEntity()->PopTypeSet(POPTYPE_RANDOM_AMBIENT);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Vehicle
///////////////////////////////////////////////////////////////////////////////////////////////////
CCutsceneAnimatedVehicleEntity::CCutsceneAnimatedVehicleEntity(const cutfObject* pObject)
:CCutsceneAnimatedModelEntity(pObject)
{
m_iAnimDict = -1;
#if __BANK
InitaliseVehicleExtraList();
#endif
}
/////////////////////////////////////////////////////////////////////////
CCutsceneAnimatedVehicleEntity::~CCutsceneAnimatedVehicleEntity()
{
//check that the script registered entity is being picked up by the script
if(m_RegisteredEntityFromScript.SceneNameHash > 0 && m_RegisteredEntityFromScript.bCreatedForScript)
{
if(m_RegisteredEntityFromScript.pEnt != NULL)
{
const CScriptEntityExtension* pExtension = m_RegisteredEntityFromScript.pEnt->GetExtension<CScriptEntityExtension>();
if(!CutSceneManager::GetInstance()->ShouldDeleteAllRegisteredEntites())
{
if(!IsRegisteredGameEntityUnderScriptControl())
{
cutsceneAssertf(pExtension, "Deleting a cutscene entity (\"%s\" %u) scene handle (\"%s\" %u) that was registered with CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY use GET_ENTITY_INDEX_OF_REGISTERED_ENTITY to make sure it is pickup up by the script",
m_RegisteredEntityFromScript.ModelNameHash.TryGetCStr(),
m_RegisteredEntityFromScript.ModelNameHash.GetHash(),
m_RegisteredEntityFromScript.SceneNameHash.TryGetCStr(),
m_RegisteredEntityFromScript.SceneNameHash.GetHash());
}
}
if(!pExtension)
{
m_RegisteredEntityFromScript.bDeleteBeforeEnd = true;
}
}
}
}
/////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedVehicleEntity::DispatchEvent(cutsManager* pManager, const cutfObject* pObject, s32 iEventId, const cutfEventArgs* pEventArgs, const float UNUSED_PARAM(fTime), const u32 UNUSED_PARAM(StickyId))
{
switch ( iEventId )
{
case CUTSCENE_UPDATE_EVENT:
case CUTSCENE_PAUSE_EVENT:
{
if (iEventId==CUTSCENE_UPDATE_EVENT && m_bStoppedCalled)
{
CreateRepositionOnlyGameEntityWhenModelLoaded(pManager, pObject, true, true );
SetGameEntityReadyForGame(pManager);
}
UpdateCutSceneTask(pManager);
if (GetGameEntity() && !m_bIsReadyForGame)
{
CVehicleAILodManager::DisableTimeslicingImmediately(*GetGameEntity());
}
}
break;
case CUTSCENE_SET_VARIATION_EVENT:
{
if (m_bIsReadyForGame)
{
return;
}
cutsceneModelEntityDebugf3("CCutsceneAnimatedVehicleEntity:CUTSCENE_SET_VARIATION_EVENT");
cutsceneAssertf(pEventArgs, "Cutscene content bug! CUTSCENE_SET_VARIATION_EVENT (object name=%s type=%s)(event id=%i) is corrupted and needs to be recreated, variation will not be applied!", pObject->GetDisplayName().c_str(), pObject->GetTypeName(), iEventId);
if (pEventArgs && pEventArgs->GetType() == CUTSCENE_VEHICLE_VARIATION_EVENT_ARGS_TYPE)
{
const cutfVehicleVariationEventArgs* pVariationEventFlag = static_cast<const cutfVehicleVariationEventArgs *>( pEventArgs );
SetVariation(pVariationEventFlag->GetBodyColour() ,
pVariationEventFlag->GetSecondaryBodyColour(),
pVariationEventFlag->GetSpecularBodyColour(),
pVariationEventFlag->GetWheelTrimColour(),
pVariationEventFlag->GetBodyColour5(),
pVariationEventFlag->GetBodyColour6(),
pVariationEventFlag->GetLiveryId(),
pVariationEventFlag->GetLivery2Id(),
pVariationEventFlag->GetDirtLevel() );
cutsceneDebugf1("%s CCutsceneAnimatedVehicleEntity:CUTSCENE_SET_VARIATION_EVENT BodyColor: %d, Second BodyColor: %d, SpecBody: %d, Wheel Trim Col: %d, BodyColor5: %d, BodyColor6: %d, Livery id: %d, Livery2 id: %d, Dirt Lev: %f "
, pObject->GetDisplayName().c_str(), pVariationEventFlag->GetBodyColour(),
pVariationEventFlag->GetSecondaryBodyColour(),
pVariationEventFlag->GetSpecularBodyColour(),
pVariationEventFlag->GetWheelTrimColour(),
pVariationEventFlag->GetBodyColour5(),
pVariationEventFlag->GetBodyColour6(),
pVariationEventFlag->GetLiveryId(),
pVariationEventFlag->GetLivery2Id(),
pVariationEventFlag->GetDirtLevel());
}
if (pEventArgs && pEventArgs->GetType() == CUTSCENE_VEHICLE_EXTRA_EVENT_ARGS_TYPE)
{
const cutfVehicleExtraEventArgs* pExtraEventFlag = static_cast<const cutfVehicleExtraEventArgs *>( pEventArgs );
if(GetGameEntity())
{
SetGameVehicleExtra(pExtraEventFlag->GetBoneIdList());
}
}
}
break;
case CutSceneCustomEvents::CUTSCENE_SET_VEHICLE_DAMAGE_EVENT:
{
if (m_bIsReadyForGame)
{
return;
}
cutsceneDebugf1("%s CCutsceneAnimatedVehicleEntity:CUTSCENE_SET_VEHICLE_DAMAGE_EVENT", pObject->GetDisplayName().c_str());
if (pEventArgs && pEventArgs->GetType() == CUTSCENE_NAME_EVENT_ARGS_TYPE)
{
const cutfNameEventArgs* pObjectVar = static_cast<const cutfNameEventArgs*>(pEventArgs);
Vector3 vDamage = VEC3_ZERO;
float fDamage = 0.0f;
float fDeform = 0.0f;
if(pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.x"))
{
vDamage.x = pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.x")->FindFloatValue();
}
if(pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.y"))
{
vDamage.y = pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.y")->FindFloatValue();
}
if(pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.z"))
{
vDamage.z = pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.z")->FindFloatValue();
}
if(pObjectVar->GetAttributeList().FindAttributeAnyCase("fDamage"))
{
fDamage = pObjectVar->GetAttributeList().FindAttributeAnyCase("fDamage")->FindFloatValue();
}
if(pObjectVar->GetAttributeList().FindAttributeAnyCase("fDeform"))
{
fDeform = pObjectVar->GetAttributeList().FindAttributeAnyCase("fDeform")->FindFloatValue();
}
//cutsceneDebugf1("%s CCutsceneAnimatedVehicleEntity:CUTSCENE_SET_VEHICLE_DAMAGE_EVENT pos: x:%f, y:%f, z:%f, ", pObject->GetDisplayName(), )
SetVehicleDamage(vDamage,fDamage,fDeform, true);
}
}
break;
}
CCutsceneAnimatedModelEntity::DispatchEvent(pManager, pObject, iEventId, pEventArgs);
}
void CCutsceneAnimatedVehicleEntity::ForceUpdateAi(cutsManager* pManager)
{
if(pManager)
{
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*> (pManager);
if(pCutSceneManager->GetShutDownMode() != SHUTDOWN_SESSION)
{
CVehicle* pVeh = GetGameEntity();
if (pVeh && pVeh->GetIntelligence() && pVeh->GetIntelligence()->GetTaskManager() && GetCutsceneTaskForEntity())
{
// TODO - Update the vehicle a.i. properly if we find we need to cross blend between vehicle anims, etc
// For now lets just get rid of the cutscene task.
pVeh->GetIntelligence()->GetTaskManager()->ClearTask(VEHICLE_TASK_TREE_SECONDARY, VEHICLE_TASK_SECONDARY_ANIM);
}
}
}
};
/////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedVehicleEntity::PlayClip (CutSceneManager* pCutManager, const crClip* pClip, float fEventTime, const strStreamingObjectName UNUSED_PARAM(pAnimDict))
{
if (GetGameEntity())
{
if(!m_pCutSceneTask)
{
// Ready the vehicle for animation
GetGameEntity()->SetFixedPhysics(true);
GetGameEntity()->m_nVehicleFlags.bAnimateWheels = true;
GetGameEntity()->m_nVehicleFlags.bAnimatePropellers = true;
GetGameEntity()->m_nVehicleFlags.bAnimateJoints = true;
CVehicleAILodManager::DisableTimeslicingImmediately(*GetGameEntity());
GetGameEntity()->InitAnimLazy();
GetGameEntity()->SetDriveMusclesToAnimation(true);
m_pCutSceneTask = CreateCutsceneTask(pCutManager, pClip, fEventTime);
GetGameEntity()->GetIntelligence()->GetTaskManager()->GetTree(VEHICLE_TASK_TREE_SECONDARY)->SetTask(m_pCutSceneTask, VEHICLE_TASK_SECONDARY_ANIM);
}
else
{
if(cutsceneVerifyf(m_pCutSceneTask->GetTaskType() == CTaskTypes::TASK_CUTSCENE, "Trying to set the clip on a CTaskCutscene, but entity %s is not running a cutscene task", m_pCutfObject->GetDisplayName().c_str()))
{
Matrix34 SceneMat;
pCutManager->GetSceneOrientationMatrix(SceneMat);
m_pCutSceneTask->SetClip(pClip,SceneMat, fEventTime);
}
}
}
SetAnimPlayBackEventTime(fEventTime);
}
/////////////////////////////////////////////////////////////////////////
//Restore a vehicle to a previous setting
void CCutsceneAnimatedVehicleEntity::RestoreEntityProperties(CEntity* UNUSED_PARAM(pEnt))
{
SetVariation(m_sVehicleData.iBodyColour, m_sVehicleData.iSecondColour, m_sVehicleData.iSpecColour, m_sVehicleData.iWheelColour, m_sVehicleData.iBodyColour5, m_sVehicleData.iBodyColour6,
m_sVehicleData.iLiveryId, m_sVehicleData.iLivery2Id, m_sVehicleData.fDirt);
if(m_sVehicleData.HiddenBones.GetCount() > 0 )
{
if(GetGameEntity())
{
SetGameVehicleExtra(m_sVehicleData.HiddenBones);
}
}
}
/////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedVehicleEntity::SetVariation(int iBodyColour, int iSecondColour, int iSpecColour, int iWheelColour, int iBodyColour5, int iBodyColour6, int LiveryId, int Livery2Id, float fDirt)
{
//store the variation for later use if we delete and need to recreate the vehicle
m_sVehicleData.iBodyColour = iBodyColour;
m_sVehicleData.iSecondColour = iSecondColour;
m_sVehicleData.iSpecColour = iSpecColour;
m_sVehicleData.iWheelColour = iWheelColour;
m_sVehicleData.iBodyColour5 = iBodyColour5;
m_sVehicleData.iBodyColour6 = iBodyColour6;
m_sVehicleData.iLiveryId = LiveryId;
m_sVehicleData.iLivery2Id = Livery2Id;
m_sVehicleData.fDirt = fDirt;
if(GetGameEntity())
{
GetGameEntity()->SetBodyColour1( static_cast<u8>(iBodyColour) );
GetGameEntity()->SetBodyColour2( static_cast<u8>(iSecondColour) );
GetGameEntity()->SetBodyColour3( static_cast<u8>(iSpecColour));
GetGameEntity()->SetBodyColour4( static_cast<u8>(iWheelColour) );
GetGameEntity()->SetBodyColour5( static_cast<u8>(iBodyColour5) );
GetGameEntity()->SetBodyColour6( static_cast<u8>(iBodyColour6) );
GetGameEntity()->SetLiveryId(LiveryId);
GetGameEntity()->SetLivery2Id(Livery2Id);
GetGameEntity()->SetBodyDirtLevel(fDirt);
GetGameEntity()->UpdateBodyColourRemapping();
}
}
/////////////////////////////////////////////////////////////////////////
//Game side vehicles have a hierarchy that describes various components, need to map our bone ids to its hierachy
void CCutsceneAnimatedVehicleEntity::SetGameVehicleExtra(const atArray<s32>& Bones)
{
//store the variation for later use if we delete and need to recreate the vehicle for streaming.
m_sVehicleData.HiddenBones.Reset();
for (int i =0; i < Bones.GetCount(); i++)
{
m_sVehicleData.HiddenBones.PushAndGrow(Bones[i]);
}
//m_sVehicleData.HiddenBones.CopyFrom(Bones, Bones.GetCount());
//have reserved the first array to be 0 if extras have been reactivated
if(Bones.GetCount()> 0 && Bones[0] != 0)
{
//Reactivate any previous turned off bones
for(int i=0; i < 10; i ++)
{
int VehicleHeirachy = i + VEH_EXTRA_1;
bool bReactivateExtra = true;
if (!GetGameEntity()->GetIsExtraOn(((eHierarchyId)VehicleHeirachy))) //extra is off do we need ot turn it off or is it on the list.
{
//look through our list of bones
for(int i = 0; i < Bones.GetCount(); i++ )
{
s32 iMappedNewBoneId = (Bones[i] - VEHICLE_HEIRACHY_MODIFIER) + (VEH_EXTRA_1 - 1);
//if its on our list already, leave it.
if(VehicleHeirachy == iMappedNewBoneId )
{
bReactivateExtra = false;
break;
}
}
if (bReactivateExtra)
{
GetGameEntity()->TurnOffExtra(((eHierarchyId)VehicleHeirachy), false );
}
}
}
//Turn off any bones on our list
for(int i = 0; i < Bones.GetCount(); i++ )
{
s32 iBoneId = Bones[i]; //store the bone id
//remap to the heirchy- iboneids are u16hash of the bone name, starting at extra_1
//VEHICLE_HEIRACHY_MODIFIER is the hash of extra_0 so we subtract to get 1, 2, 3 etc
//and add to a zeroed VEH_EXTRA_X
int iMappedNewBoneId = (iBoneId - VEHICLE_HEIRACHY_MODIFIER) + (VEH_EXTRA_1 - 1);
if (GetGameEntity()->GetIsExtraOn(((eHierarchyId)iMappedNewBoneId)))
{
GetGameEntity()->TurnOffExtra(((eHierarchyId)iMappedNewBoneId), true );
}
}
}
else
{
//Careful: reactivating vehicle extras actually repairs the whole vehicle
for(int i=0; i < 10; i ++)
{
int VehicleHeirachy = i + VEH_EXTRA_1;
if (!GetGameEntity()->GetIsExtraOn(((eHierarchyId)VehicleHeirachy)))
{
GetGameEntity()->TurnOffExtra(((eHierarchyId)VehicleHeirachy), false);
}
}
}
};
void CCutsceneAnimatedVehicleEntity::SetVehicleDamage(const Vector3& scrVecDamage, float damageAmount, float deformationScale, bool localDamage)
{
CVehicle *pVehicle = GetGameEntity();
if (pVehicle)
{
const Vector3 passedPos(scrVecDamage);
Vector3 impactPos = passedPos;
if( localDamage )
{
impactPos = pVehicle->TransformIntoWorldSpace(impactPos);
}
Vector3 impactImpulse = -passedPos;
impactImpulse.Normalize();
Vector3 normalizedImpulse = impactImpulse;
impactImpulse *= damageAmount;
if( localDamage )
{
impactImpulse = VEC3V_TO_VECTOR3(pVehicle->GetTransform().Transform3x3(VECTOR3_TO_VEC3V(impactImpulse)));
}
// Deformation
pVehicle->GetVehicleDamage()->GetDeformation()->ApplyCollisionImpact(impactImpulse*deformationScale, impactPos, NULL);
// Damage
pVehicle->GetVehicleDamage()->ApplyDamage(NULL,DAMAGE_TYPE_UNKNOWN, 0, damageAmount, impactPos, normalizedImpulse, -normalizedImpulse, 0);
}
}
/////////////////////////////////////////////////////////////////////////
void CCutsceneAnimatedVehicleEntity::CreateGameEntity(strLocalIndex iModelIndex, bool CreateRepositionEntity, bool UNUSED_PARAM(bRequestVariations), bool UNUSED_PARAM(bApplyVariations))
{
if(GetGameEntity() == NULL)
{
cutsceneModelEntityDebugf2("CreateGameEntity - Vehicle");
CBaseModelInfo* pModelInfo = CModelInfo::GetBaseModelInfo(fwModelId(iModelIndex));
if(pModelInfo)
{
cutsceneAssertf(pModelInfo->GetModelType() == MI_TYPE_VEHICLE, "CUTSCENE ASSET (Assign to *Default Anim Cutscene*): Exported incorrectly, %s is not a VehicleModel type", pModelInfo->GetModelName());
if(pModelInfo->GetModelType() == MI_TYPE_VEHICLE)
{
Matrix34 TempMat;
TempMat.Identity();
TempMat.d = m_vCreatePos;
const CControlledByInfo localAiControl(false, false);
fwModelId modelId(iModelIndex);
CVehicle* pVehicle = CVehicleFactory::GetFactory()->Create(modelId, ENTITY_OWNEDBY_CUTSCENE, POPTYPE_MISSION, &TempMat, false);
if (Verifyf(pVehicle, "trying to store a null ped pointer something has gone wrong with the registration"))
{
//store the vehicle pointer
if(CreateRepositionEntity)
{
SetRepositionOnlyEntity(pVehicle);
}
else
{
SetGameEntity(pVehicle);
}
if(pVehicle)
{
pVehicle->SetIsAbandoned();
pVehicle->m_nPhysicalFlags.bNotDamagedByAnything = true;
CGameWorld::Add(pVehicle, CGameWorld::OUTSIDE);
pVehicle->SetFixedPhysics(true);
pVehicle->GetPortalTracker()->RequestRescanNextUpdate();
pVehicle->GetPortalTracker()->SetIsCutsceneControlled(true);
pVehicle->m_nDEflags.bForcePrePhysicsAnimUpdate = true;
if (pVehicle->GetVehicleType() == VEHICLE_TYPE_TRAIN)
{
((CTrain*)pVehicle)->m_nTrainFlags.bIsCutsceneControlled = true;
}
m_bCreatedByCutscene = true;
//if (bApplyVariations)
//{
// Apply the current variations
//RestoreEntityProperties(pVehicle);
//}
}
}
}
}
}
}
void CCutsceneAnimatedVehicleEntity::HideVehicleFragmentComponent()
{
if(GetCutfObject() && GetGameEntity())
{
if(m_pCutfObject->GetType() == CUTSCENE_MODEL_OBJECT_TYPE)
{
const cutfModelObject* pModel = static_cast<const cutfModelObject*>(m_pCutfObject);
if(pModel->GetModelType() == CUTSCENE_VEHICLE_MODEL_TYPE)
{
const cutfVehicleModelObject* pModelObject = static_cast<const cutfVehicleModelObject*>(m_pCutfObject);
if(pModelObject->GetRemoveBoneNameList().GetCount() > 0)
{
for (int i = 0; i < pModelObject->GetRemoveBoneNameList().GetCount(); i++)
{
const crBoneData* pBoneData = GetGameEntity()->GetSkeletonData().FindBoneData(pModelObject->GetRemoveBoneNameList()[i].c_str());
if(pBoneData)
{
int BoneIndex = pBoneData->GetIndex();
CVehicleModelInfo* pModel = GetGameEntity()->GetVehicleModelInfo();
if(pModel)
{
CVehicleStructure* pVehicleStruct = pModel->GetStructure();
if(pVehicleStruct)
{
for(int j=0; j < VEH_NUM_NODES; j++)
{
if (pVehicleStruct->m_nBoneIndices[j] == BoneIndex)
{
eHierarchyId HeirarchyId = (eHierarchyId)j;
if(GetGameEntity()->HasFragmentComponent(HeirarchyId))
{
GetGameEntity()->RemoveFragmentComponent(HeirarchyId);
cutsceneModelEntityDebugf2("HideVehicleFragmentComponent: Removing component %s from vehicle", pModelObject->GetRemoveBoneNameList()[i].c_str());
}
else
{
cutsceneModelEntityDebugf2("HideVehicleFragmentComponent: Couldn't remove component %s, it may have already been removed", pModelObject->GetRemoveBoneNameList()[i].c_str());
}
}
}
}
}
}
}
}
}
}
}
}
void CCutsceneAnimatedVehicleEntity::SetGameEntityReadyForCutscene()
{
if(GetGameEntity())
{
#if !__NO_OUTPUT
SetUpEntityForCallStackLogging();
#endif
GetGameEntity()->SetOwnedBy(ENTITY_OWNEDBY_CUTSCENE);
GetGameEntity()->SetFixedPhysics(true);
GetGameEntity()->m_nPhysicalFlags.bNotDamagedByAnything = true;
GetGameEntity()->m_nDEflags.bForcePrePhysicsAnimUpdate = true;
GetGameEntity()->DisableCollision();
GetGameEntity()->ResetSuspension();
GetGameEntity()->SetForceHd(true);
CVehicleRecordingMgr::StopPlaybackRecordedCar(GetGameEntity());
HideVehicleFragmentComponent();
if (m_OptionFlags.IsFlagSet(CEO_IS_CASCADE_SHADOW_FOCUS_ENTITY_DURING_EXIT) && CutSceneManager::GetInstance() && CutSceneManager::GetInstance()->GetCamEntity())
{
// Register this with the camera
CCutSceneCameraEntity* pCam = const_cast<CCutSceneCameraEntity*>(CutSceneManager::GetInstance()->GetCamEntity());
if (pCam)
{
pCam->SetCascadeShadowFocusEntityForSeamlessExit(GetGameEntity());
}
}
NetworkInterface::CutsceneStartedOnEntity(*GetGameEntity());
}
}
void CCutsceneAnimatedVehicleEntity::SetRepositionOnlyEntityReadyForCutscene()
{
if(GetGameRepositionOnlyEntity())
{
cutsceneModelEntityDebugf2("SetRepositionOnlyEntityReadyForCutscene - Vehicle");
GetGameRepositionOnlyEntity()->m_nPhysicalFlags.bNotDamagedByAnything = true;
GetGameRepositionOnlyEntity()->SetIsVisibleForModule(SETISVISIBLE_MODULE_CUTSCENE, false);
cutsceneModelEntityDebugf2("CCutsceneAnimatedVehicleEntity::SetRepositionOnlyEntityReadyForCutscene: Hiding GetGameRepositionOnlyEntity (%s)", GetGameRepositionOnlyEntity()->GetModelName());
NetworkInterface::CutsceneStartedOnEntity(*GetGameRepositionOnlyEntity());
}
}
void CCutsceneAnimatedVehicleEntity::SetGameEntityReadyForGame(cutsManager* UNUSED_PARAM(pManager))
{
if(!m_bIsReadyForGame)
{
if(GetGameEntity())
{
NetworkInterface::CutsceneFinishedOnEntity(*GetGameEntity());
#if !__NO_OUTPUT
ResetEntityForCallStackLogging();
#endif
GetGameEntity()->SetLodMultiplier(m_fOriginalLODMultiplier);
cutsceneModelEntityDebugf2("CCutsceneAnimatedVehicleEntity::SetGameEntityReadyForGame - Vehicle");
if (GetGameEntity()->GetVehicleType() == VEHICLE_TYPE_TRAIN)
{
((CTrain*)GetGameEntity())->m_nTrainFlags.bIsCutsceneControlled = false;
}
bool canEnableCollision = true;
if(NetworkInterface::IsGameInProgress() && GetGameEntity()->GetNetworkObject())
{
canEnableCollision = !SafeCast(CNetObjPhysical, GetGameEntity()->GetNetworkObject())->GetKeepCollisionDisabledAfterAnimScene();
}
if(canEnableCollision)
{
GetGameEntity()->EnableCollision();
}
GetGameEntity()->SetForceHd(false);
GetGameEntity()->SetFixedPhysics(false);
GetGameEntity()->m_nVehicleFlags.bAnimateWheels = false;
GetGameEntity()->m_nVehicleFlags.bAnimatePropellers = false;
GetGameEntity()->m_nVehicleFlags.bAnimateJoints = false;
GetGameEntity()->m_nPhysicalFlags.bNotDamagedByAnything = m_bWasInvincible;
GetGameEntity()->m_nDEflags.bForcePrePhysicsAnimUpdate = false;
GetGameEntity()->SetDriveMusclesToAnimation(false);
if(!GetGameEntity()->m_nVehicleFlags.bUseCutsceneWheelCompression)
{
GetGameEntity()->PlaceOnRoadAdjust();
}
if(GetGameEntity()->InheritsFromTrailer())
{
//Need to enforce constraint limits on trailers to avoid pops
GetGameEntity()->ActivatePhysics();
}
bool CanDelete = m_RegisteredEntityFromScript.pEnt != GetGameEntity();
if(CanDelete|| m_RegisteredEntityFromScript.bDeleteBeforeEnd)
{
GetGameEntity()->SetOwnedBy(ENTITY_OWNEDBY_TEMP);
GetGameEntity()->PopTypeSet(POPTYPE_RANDOM_AMBIENT);
}
else
{
GetGameEntity()->SetOwnedBy(ENTITY_OWNEDBY_SCRIPT);
SetVisibility(GetGameEntity(), true);
cutsceneModelEntityDebugf3("CCutsceneAnimatedVehicleEntity::SetGameEntityReadyForGame1: Showing GetGameEntity (%s)", GetGameEntity()->GetModelName());
}
}
if(GetGameRepositionOnlyEntity())
{
cutsceneModelEntityDebugf2("SetGameEntityReadyForGame - Vehicle (reposition only");
GetGameRepositionOnlyEntity()->SetLodMultiplier(m_fOriginalLODMultiplier);
GetGameRepositionOnlyEntity()->SetHeading(m_CurrentHeading);
GetGameRepositionOnlyEntity()->SetPosition(m_CurrentPosition);
GetGameRepositionOnlyEntity()->SetFixedPhysics(false);
GetGameRepositionOnlyEntity()->m_nPhysicalFlags.bNotDamagedByAnything = m_bWasInvincible;
GetGameRepositionOnlyEntity()->SetIsVisibleForModule(SETISVISIBLE_MODULE_CUTSCENE, true);
cutsceneModelEntityDebugf2("CCutsceneAnimatedVehicleEntity::SetGameEntityReadyForGame2: Showing GetGameRepositionOnlyEntity (%s)", GetGameRepositionOnlyEntity()->GetModelName());
GetGameRepositionOnlyEntity()->m_nDEflags.bForcePrePhysicsAnimUpdate = false;
}
if (m_pCutSceneTask)
{
m_pCutSceneTask->SetExitNextUpdate();
}
m_bIsReadyForGame = true;
}
}
void CCutsceneAnimatedVehicleEntity::SetupSuspension()
{
for(int i = 0; i < GetGameEntity()->GetNumWheels(); i++)
{
CWheel *pWheel = GetGameEntity()->GetWheel(i);
pWheel->UpdateSuspension(NULL, false);
}
if(GetGameEntity()->GetCurrentPhysicsInst() && CPhysics::GetLevel()->IsInactive(GetGameEntity()->GetCurrentPhysicsInst()->GetLevelIndex()))
{
fragInstGta * pVehicleFragInst = GetGameEntity()->GetVehicleFragInst();
if(pVehicleFragInst && pVehicleFragInst->GetCacheEntry() && pVehicleFragInst->GetCacheEntry()->GetHierInst() &&
pVehicleFragInst->GetCacheEntry()->GetHierInst()->articulatedCollider)
{
GetGameEntity()->GetVehicleFragInst()->GetCacheEntry()->GetHierInst()->articulatedCollider->SetColliderMatrixFromInstance();
}
}
GetGameEntity()->GetVehicleFragInst()->SyncSkeletonToArticulatedBody(true);
}
void CCutsceneAnimatedVehicleEntity::UpdateCutSceneTask(cutsManager* pManager)
{
if(GetGameEntity() && GetGameEntity()->GetIntelligence())
{
aiTask* CurrentVehicleTask = GetGameEntity()->GetIntelligence()->GetTaskManager()->GetTree(VEHICLE_TASK_TREE_SECONDARY)->GetTask(VEHICLE_TASK_SECONDARY_ANIM);
if(CurrentVehicleTask && CurrentVehicleTask->GetTaskType() == CTaskTypes::TASK_CUTSCENE)
{
CTask* pTask = static_cast<CTask*>(CurrentVehicleTask);
UpdateCutSceneTaskPhase(pTask, pManager);
// Update vehicle velocity
if (!m_bStoppedCalled)
{
CTaskCutScene* pCutSceneTask = static_cast<CTaskCutScene*>(pTask);
const crClip* pClip = pCutSceneTask->GetClip();
if (pClip)
{
CutSceneManager* pCutsManager = static_cast<CutSceneManager*>(pManager);
float fPhase = pCutsManager->GetPhaseUpdateAmount(pClip, GetAnimEventStartTime());
float fLastPhase = pCutsManager->GetAnimPhaseForSection(pClip->GetDuration(),GetAnimEventStartTime(), pCutsManager->GetCutScenePreviousTime());
const float time = pClip->ConvertPhaseToTime(fPhase);
const float timeOnPreviousUpdate = pClip->ConvertPhaseToTime(fLastPhase);
bool bIsWarpFrame = pClip->CalcBlockPassed(timeOnPreviousUpdate, time);
const float fCurrentTimeStep = pCutsManager->GetCurrentCutSceneTimeStep();
if (bIsWarpFrame || fCurrentTimeStep <= 0.0001f)
{
GetGameEntity()->SetVelocity(VEC3_ZERO);
}
else
{
Vector3 vehVelocity(VEC3_ZERO);
Vector3 vehDistance = fwAnimHelpers::GetMoverTrackTranslationDiff(*pClip, fLastPhase, fPhase);
vehVelocity = vehDistance/fCurrentTimeStep;
pCutSceneTask->GetAnimOrigin().Transform3x3(vehVelocity);
#if __ASSERT
if (vehVelocity.Mag2() > 62500.0f)
{
cutsceneAssertf(0, "Cutscene vehicle (%s) velocity is > 250 ms-1. Moved distance (%.2f, %.2f, %.2f) meters in %6.4f seconds\n", GetGameEntity()->GetModelName(), vehDistance.x, vehDistance.y, vehDistance.z, fCurrentTimeStep);
}
#endif //__ASSERT
GetGameEntity()->SetVelocity( vehVelocity );
}
}
}
}
}
}
/////////////////////////////////////////////////////////////////////////
//Allow for manual adding and subtraction of bones
#if __BANK
void CCutsceneAnimatedVehicleEntity::SetBoneToHide(s32 Boneid, bool bHide)
{
for(int i=0; i < m_HiddenBones.GetCount(); i++)
{
if(m_HiddenBones[i] == Boneid )
{
if(!bHide)
{
m_HiddenBones.Delete(i);
}
return;
}
}
m_HiddenBones.PushAndGrow(Boneid);
}
/////////////////////////////////////////////////////////////////////////
//When debugging a real vehicle find the extras that are already switched off.
void CCutsceneAnimatedVehicleEntity::InitaliseVehicleExtraList()
{
if(GetGameEntity())
{
for(int i=0; i < 10; i ++)
{
int VehicleHeirachy = i + VEH_EXTRA_1;
if (!GetGameEntity()->GetIsExtraOn(((eHierarchyId)VehicleHeirachy)))
{
m_HiddenBones.PushAndGrow((VEHICLE_HEIRACHY_MODIFIER+1) + i );
}
}
}
}
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
// Rayfire
///////////////////////////////////////////////////////////////////////////////////////////////////
CCutSceneRayFireEntity::CCutSceneRayFireEntity(const cutfObject* pObject)
: cutsUniqueEntity(pObject)
{
m_fEventTime = 0.0f;
m_iRayFireId = -1;
}
CCutSceneRayFireEntity::~CCutSceneRayFireEntity()
{
if (m_iRayFireId>-1)
{
CCompEntity* pCompEntity = CCompEntity::GetPool()->GetAt(m_iRayFireId);
if (pCompEntity)
{
pCompEntity->SetIsCutsceneDriven(false);
}
}
m_iRayFireId = -1;
}
void CCutSceneRayFireEntity::DispatchEvent(cutsManager* pManager, const cutfObject* pObject, s32 iEventId, const cutfEventArgs* UNUSED_PARAM(pEventArgs), const float fTime, const u32 UNUSED_PARAM(StickyId))
{
switch ( iEventId )
{
case CUTSCENE_START_OF_SCENE_EVENT:
{
}
break;
case CUTSCENE_PAUSE_EVENT:
case CUTSCENE_UPDATE_EVENT:
{
if(m_iRayFireId > -1 )
{
CCompEntity* pCompEntity = CCompEntity::GetPool()->GetAt(m_iRayFireId);
if(pCompEntity && pCompEntity->GetPrimaryAnimatedObject())
{
if(object_commands::CommandGetCompositeEntityState(m_iRayFireId) == CE_STATE_ANIMATING)
{
CObject* pObj = pCompEntity->GetPrimaryAnimatedObject();
if(cutsceneVerifyf(pObj, "CUTSCENE_UPDATE_EVENT: Component entity failed to create the animated rayfire object: %s", pObj->GetModelName()))
{
if(cutsceneVerifyf(pObj->GetAnimDirector(), "CUTSCENE_UPDATE_EVENT: Rayfire object %s has failed to create an anim director", pObj->GetModelName()))
{
CMoveObject& move = pObj->GetMoveObject();
const crClip* pClip = move.GetClipHelper().GetClip();
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*>(pManager);
if(pClip)
{
float fPhase = pCutSceneManager->GetAnimPhaseForSection(pClip->GetDuration(), m_fEventTime, pCutSceneManager->GetCutSceneCurrentTime() );
pCompEntity->SetIsCutsceneDriven(true);
move.GetClipHelper().SetRate(0.0f);
move.GetClipHelper().SetPhase(fPhase);
for(u32 i=1; i<pCompEntity->GetChildObjects().GetCount(); i++){
if (pCompEntity->GetChild(i)){
CMoveObject& move = pCompEntity->GetChild(i)->GetMoveObject();
move.GetClipHelper().SetRate(0.0f);
move.GetClipHelper().SetPhase(fPhase);
}
}
}
}
}
}
}
}
}
break;
case CUTSCENE_SET_ANIM_EVENT:
{
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*>(pManager);
CCutSceneAssetMgrEntity* pAssetManager = pCutSceneManager->GetAssetManager();
s32 iIndex = pAssetManager->GetGameIndex(pObject->GetObjectId());
if(iIndex > -1)
{
if(object_commands::CommandGetCompositeEntityState(iIndex) != 0 )
{
if(object_commands::CommandGetCompositeEntityState(iIndex) == CE_STATE_PRIMED)
{
object_commands::CommandSetCompositeEntityState(iIndex, CE_STATE_START_ANIM);
CCompEntity* pCompEntity = CCompEntity::GetPool()->GetAt(iIndex);
//calling update to make sure we create the anim director
pCompEntity->Update();
if(pCompEntity && pCompEntity->GetPrimaryAnimatedObject())
{
CObject* pObj = pCompEntity->GetPrimaryAnimatedObject();
if(cutsceneVerifyf(pObj, "CUTSCENE_SET_ANIM_EVENT: Component entity failed to create the animated rayfire object: %s", pObj->GetModelName()))
{
if(cutsceneVerifyf(pObj->GetAnimDirector(), "CUTSCENE_SET_ANIM_EVENT: Rayfire object %s has failed to create an anim director", pObj->GetModelName()))
{
CMoveObject& move = pObj->GetMoveObject();
const crClip* pClip = move.GetClipHelper().GetClip();
CutSceneManager* pCutSceneManager = static_cast<CutSceneManager*>(pManager);
m_fEventTime = fTime;
if(pClip)
{
//m_HaveAnimToUpdate = true;
float fPhase = pCutSceneManager->GetAnimPhaseForSection(pClip->GetDuration(), m_fEventTime, pCutSceneManager->GetCutSceneCurrentTime() );
move.GetClipHelper().SetRate(0.0f);
move.GetClipHelper().SetPhase(fPhase);
pCompEntity->SetIsCutsceneDriven(true);
for(u32 i=1; i<pCompEntity->GetChildObjects().GetCount(); i++){
if (pCompEntity->GetChild(i)){
CMoveObject& move = pCompEntity->GetChild(i)->GetMoveObject();
move.GetClipHelper().SetRate(0.0f);
move.GetClipHelper().SetPhase(fPhase);
}
}
}
m_iRayFireId = pAssetManager->GetGameIndex(pObject->GetObjectId());
}
}
}
}
}
}
}
break;
}
}
Reference in New Issue Copy Permalink