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

7694 lines
269 KiB
C++
Raw Normal View History

init
2025-02-23 17:40:52 +08:00
/////////////////////////////////////////////////////////////////////////////////
//
// FILE : CutSceneDebugManagerNew.h
// PURPOSE : A class for dealing with all the debug and tool aspects of the cut scene manager.
// AUTHOR : Thomas French
// STARTED :
//
/////////////////////////////////////////////////////////////////////////////////
#if __BANK
//Rage Headers
#include "bank/bank.h"
#include "bank/bkmgr.h"
#include "bank/combo.h"
#include "bank/data.h"
#include "bank/slider.h"
#include "cutfile/cutfobject.h"
#include "cutfile/cutfeventargs.h"
#include "cutfile/cutfevent.h"
#include "cutscene/cutschannel.h"
#include "cutscene/cutsevent.h"
#include "fwdebug/picker.h"
#include "system/nelem.h"
#include "system/controlMgr.h"
//Game Headers
#include "AnimatedModelEntity.h"
#include "camera/helpers/Frame.h"
#include "camera/CamInterface.h"
#include "camera/base/Basecamera.h"
#include "cutscene/CutSceneAnimManager.h"
#include "Cutscene/CutSceneOverlayEntity.h"
#include "cutscene/CutSceneCameraEntity.h"
#include "CutsceneCustomEvents.h"
#include "CutSceneDebugManager.h"
#include "CutSceneDefine.h"
#include "Cutscene/cutscene_channel.h"
#include "Cutscene/CutSceneCustomEvents.h"
#include "Cutscene/CutSceneParticleEffectObject.h"
#include "cutscene/CutSceneParticleEffectEntity.h"
#include "frontend/Scaleform/ScaleformStore.h"
#include "input/keyboard.h"
#include "input/keys.h"
#include "modelinfo/MloModelInfo.h"
#include "modelinfo/PedModelInfo.h"
#include "peds/rendering/PedVariationPack.h"
#include "peds/rendering/PedVariationDS.h"
#include "peds/rendering/PedVariationStream.h"
#include "frontend/scaleform/ScaleFormMgr.h"
#include "renderer/Renderer.h"
#include "renderer/Water.h"
#include "renderer/RenderPhases/RenderPhaseCascadeShadows.h"
#include "scene/entity.h"
#include "Streaming/streaming.h"
#include "../shader_source/Lighting/Shadows/cascadeshadows_common.fxh"
///////////////////////////////////////////////////////////////////////////////////////////////////
// DEBUG MANAGER
///////////////////////////////////////////////////////////////////////////////////////////////////
ANIM_OPTIMISATIONS()
//OPTIMISATIONS_OFF()
#if __BANK
#define MAX_EXTRA_VEHICLE_NAMES (10)
#define MAX_NUMBER_PARAM_TYPES (4)
#define MAX_NUMBER_SHADOW_TYPES (3)
#define MAX_NUMBER_DOF_STATES (3)
const char* VehicleExtraNames[MAX_EXTRA_VEHICLE_NAMES] = {"extra_1","extra_2","extra_3","extra_4","extra_5","extra_6","extra_7","extra_8","extra_9","extra_10"};
const char* OverlayParamNames[MAX_NUMBER_OVERLAY_PARAMS] = {"param_1","param_2","param_3","param_4","param_5","param_6","param_7"};
const char* OverlayParamTypes[MAX_NUMBER_PARAM_TYPES] = {"int", "float", "string", "bool"};
const char* ShadowSampleTypes[MAX_NUMBER_SHADOW_TYPES] = {"CSM_ST_BOX4x4", "CSM_ST_TWOTAP" , "CSM_ST_BOX3x3"};
const char* DofStates[MAX_NUMBER_DOF_STATES] = {"DOF_DATA_DRIVEN", "DOF_FORCED_ON (Preview Only)" , "DOF_FORCED_OFF (Preview Only)"};
bool CCutSceneDebugManager::m_cutfileValidationProcesses[CVP_MAX] = { 0 };
enum ParamTypes
{
PT_INT,
PT_FLOAT,
PT_STRING,
PT_BOOL
};
#endif
CCutSceneDebugManager::CCutSceneDebugManager()
{
//Display
m_bDisplayLoadedModels = false;
m_bPrintModelLoadingToDebug = false;
//Vehicles
m_pVehicleVarFrameSlider = NULL;
m_iVehicleModelIndex = 0;
m_pVehicle = NULL;
m_iMainBodyColour = 0;
m_iSecondBodyColour = 0;
m_iSpecularColour = 0;
m_iWheelTrimColour = 0;
m_iBodyColour5 = 0;
m_iBodyColour6 = 0;
m_iLivery = 0;
m_iLivery2 = 0;
m_fDirtLevel = 0.0f;
m_iVehicleExtraIndex = 0;
m_bDisplayVehicleVariation = false;
m_VehicleVarEventId = 0;
m_VehicleExtraEventId = 0;
m_pLiverySlider = NULL;
m_pLivery2Slider = NULL;
m_pVehicleExtraCombo = NULL;
m_pVehicleSelectCombo = NULL;
m_pVehicleVariationEventCombo = NULL;
m_pVehicleExtraEventCombo = NULL;
m_bVehicleDamageSelector = false;
m_fDerformation = 0.0f;
m_fDamageValue = 0.0f;
m_iVehicleDamageIndex = 0;
m_pVehicleDamageEventCombo = NULL;
m_vLocalDamage = VEC3_ZERO;
//Peds
m_pActorEntity = NULL;
m_iPedModelIndex = 0;
m_varDrawableId = 0;
m_varTextureId =0 ;
m_varComponentId = 0;
m_varPalette = 0;
m_maxDrawables = 0;
m_maxTextures = 0;
m_maxPalettes = 0;
m_PropSlotId = 0;
m_maxPropDrawableId= -1;
m_PropDrawableId = -1;
m_maxPropTextureId = -1;
m_PropTextureId = -1;
strncpy(m_varDrawablName, "Invalid", 24);
strncpy(m_varTexName, "Invalid", 24);
m_PedVarEventId = 0;
m_pEventCombo = NULL;
m_pPedSelectCombo = NULL;
m_pVarDrawablIdSlider = NULL;
m_CboCompVariationIndex = NULL;
m_CboPropVariationIndex = NULL;
m_pVarTexIdSlider = NULL;
m_pVarPaletteIdSlider = NULL;
m_pVarPedFrameSlider = NULL;
m_pPropDrawablIdSlider = NULL;
m_pPropTexIdSlider = NULL;
m_vWorldZOffset = VEC3_ZERO;
m_bDisplayAllSkeletons = false;
//ptfx
m_pPTFXSelectCombo = NULL;
m_PtfxEnt = NULL;
m_Ptfx = NULL;
m_iPtfxIndex = 0;
m_vPTFXPos = VEC3_ZERO;
m_vPTFXRot = VEC3_ZERO;
//prop
m_pPropSelectCombo = NULL;
m_iPropModelIndex = 0;
m_pPropEntity = NULL;
//Frame sliders
m_pVarDebugFrameSlider = NULL;
m_pVarSkipFrameSlider = NULL;
m_pPedVarPlayBackSlider = NULL;
m_pVehicleVarPlayBackSlider = NULL;
m_pVarFrameSlider = NULL;
m_pOverlayPlayBackSlider = NULL;
m_pWaterIndexFrameSlider = NULL;
//Timecycle
m_bOverrideTimeCycle = false;
m_fTimeCycleOverrideTime = 0;
m_cGameTime[0] = '\0';
m_CameraCutName[0] = '\0';
//Overlay
m_pOverlaySelectCombo = NULL;
m_pOverlayMethodsCombo = NULL;
m_iOverlayIndex = 0;
m_pOverlay = NULL;
m_pOverlayEventCombo = NULL;
m_vOverlayPos.x = 0.0f;
m_vOverlayPos.y = 0.0f;
m_vOverlaySize.x = 0.0f;
m_vOverlaySize.y = 0.0f;
m_iOverlayMethodIndex = 0;
m_OverlayEventId = 0;
m_iOverlayParamNameIndex = 0;
m_iOverlayParamTypeIndex = 0;
m_bUseScreenRenderTarget = true;
//camera
m_bOverrideCamBlendOutEvents = false;
m_vCameraPos = VEC3_ZERO;
m_vCameraRot = VEC3_ZERO;
m_bOverrideCam = false;
m_cameraMtx = M34_IDENTITY;
m_bOverrideCamUsingMatrix = false;
m_vDofPlanes = Vector4(Vector4::ZeroType);
m_RenderDofPlanes = false;
m_bOverrideCamUsingBinary = false;
m_binaryCamMatrix.Identity();
m_NearOutPlaneAlpha = 255;
m_NearInPlaneAlpha = 255;
m_FarInPlaneAlpha = 255;
m_FarOutPlaneAlpha = 255;
m_FocalPointAlpha = 255;
m_PlaneScale = 1.0f;
m_FocalPointScale = 0.5f;
m_fFov = 45.0f;
m_SetPlaneSolid = false;
m_scaleAsScreenRatio = false;
m_fFadeInDuration = 1.0f;
m_fFadeOutDuration = 1.0f;
m_vFadeInColor = VEC3_ZERO;
m_vFadeOutColor = VEC3_ZERO;
m_bShouldOverrideUseLightDof = false;
m_bShouldOverrideUseSimpleDof = false;
m_fMotionBlurStrength = 0.0f;
m_fWaterRefractionIndex = DEFAULT_REFRACTIONINDEX;
m_ReflectionLodRangeStart = -1.0f;
m_ReflectionLodRangeEnd = -1.0f;
m_ReflectionSLodRangeStart = -1.0f;
m_ReflectionSLodRangeEnd = -1.0f;
m_LodMultHD = -1.0f;
m_LodMultOrphanedHD = -1.0f;
m_LodMultLod = -1.0f;
m_LodMultSLod1 = -1.0f;
m_LodMultSLod2 = -1.0f;
m_LodMultSLod3 = -1.0f;
m_LodMultSLod4 = -1.0f;
m_WaterReflectionFarClip = -1.0f;
m_SSAOLightInten = -1.0f;
m_ExposurePush = 0.0f;
m_LodMult = -1.0f;
m_DirectionalLightMultiplier = -1.0f;
m_LensArtefactMultiplier = -1.0f;
m_MaxBloom = -1.0f;
m_bDisableHighQualityDof = false;
m_FreezeReflectionMap = false;
m_DisableDirectionalLight = false;
m_LightFadeDistanceMult = 1.0f;
m_LightShadowFadeDistanceMult = 1.0f;
m_LightSpecularFadeDistMult = 1.0f;
m_LightVolumetricFadeDistanceMult = 1.0f;
m_AbsoluteIntensityEnabled = false;
m_FirstPersonBlendOutSlider = NULL;
m_firstPersonCameraBlendDuration = 0.0f;
m_firstPersonBlendOutComboIndex = 0;
m_firstPersonBlendOutComboSlider = NULL;
m_firstPersonEventStatus = NULL;
m_firstPersonStatusText[0] = 0; ;
m_CharacterLight.Reset();
m_iWaterRefractionIndexId = 0;
m_pWaterRefractionIndexCombo = NULL;
m_bProfilingDisableCsLights = false;
m_bProfilingOverrideCharacterLight = false;
m_bProfilingDisableDof = false;
m_bProfilingUseDefaultFov = false;
m_pLoadInteriorIndexCombo = NULL;
m_FinalFrameCameraMat.Identity();
m_CameraWidgetData = NULL;
m_CutsceneStateWidgetData = NULL;
m_InteriorPos = VEC3_ZERO;
m_InteriorName[0] = '\0';
m_LoadInteriorIndexId = 0;
m_iTimecycleEventsIndexId = 0;
m_pTimeCycleCameraCutCombo = NULL;
m_vVehicleDamagerPos.Zero();
//day dof
m_DayCoCHours = 0;
m_bShouldSetCoCForAllDay = false;
m_bShouldSetCoCForAllNight = false;
m_bShouldUseRangeForCoC = false;
m_pHoursGrp = NULL;
//dof
m_bOverrideCoCModifier = false;
m_CoCModifierHours = 0;
m_UseDayCoCHoursForModifier = false;
m_UseNightCoCHoursForModifier = false;
m_CoCModifier = 1;
m_TimeDayDofOverrideFlags = 0;
m_CoCRadius = 1;
m_FocusPoint = 0.0f;
m_DofState = 0;
m_pCoCModifiersCameraCutCombo = NULL;
m_pPerCutCoCModifiersCombo = NULL;
m_AllCoCModifiersCombo = NULL;
m_pEndHourSlider = NULL;
m_pSaveStatusText = NULL;
m_iCoCModifiersCamerCutComboIndexId = 0;
m_iCoCModifierIndex = 0;
m_iAllCoCModifierIndex = 0;
m_saveStatus[0] = '\0';
m_ShouldSyncTimeOfDayDofOverridedWidgetIndexidtoCurrentCameraCut = true;
}
CCutSceneDebugManager::~CCutSceneDebugManager()
{
}
void CCutSceneDebugManager::Update()
{
HighLightSelectedVehicle();
DisplaySelectedVehicleInfo();
DisplayPedVariation();
UpdateInteriorPositionSelector();
UpdateCurrentCutName();
UpdateFirstPersonBlendOutDuration();
if (m_bVehicleDamageSelector)
{
Vector3 vZOffset; vZOffset.Zero();
UpdateMouseCursorPosition(m_vVehicleDamagerPos, m_vVehicleDamagerPos, vZOffset, false);
}
}
void CCutSceneDebugManager::UpdateInteriorPositionSelector()
{
const camBaseCamera* pCam = camInterface::GetDominantRenderedCamera();
if(pCam)
{
m_InteriorPos = pCam->GetFrame().GetPosition();
CInteriorInst* pIntInst = NULL;
s32 roomIdx = -1;
pIntInst = CPortalVisTracker::GetPrimaryInteriorInst();
roomIdx = CPortalVisTracker::GetPrimaryRoomIdx();
const char* interiorName = "none";
if (pIntInst && roomIdx>0 && roomIdx!=INTLOC_INVALID_INDEX)
{
// get the interior and room names
CMloModelInfo *pModelInfo = reinterpret_cast<CMloModelInfo*>(pIntInst->GetBaseModelInfo());
naAssertf(pModelInfo, "Failed to get model info from interior instance model index %d", pIntInst->GetModelIndex());
if (pModelInfo)
{
interiorName = pModelInfo->GetModelName();
}
}
strcpy(m_InteriorName, interiorName );
}
}
void CCutSceneDebugManager::Clear()
{
//Vehicle
m_pVehicle = NULL;
m_iMainBodyColour = 0;
m_iSecondBodyColour = 0;
m_iSpecularColour = 0;
m_iWheelTrimColour = 0;
m_iBodyColour5 = 0;
m_iBodyColour6 = 0;
m_iLivery = 0;
m_iLivery2 = 0;
m_fDirtLevel = 0.0f;
m_bDisplayVehicleVariation = false;
for(int i=0; i <m_VehicleModelObjectList.GetCount(); i++ )
{
m_VehicleModelObjectList[i] = NULL;
}
m_VehicleModelObjectList.Reset();
for(int i = 0; i<m_VehicleDamageEvents.GetCount(); i++)
{
m_VehicleDamageEvents[i] = NULL;
}
m_VehicleDamageEvents.Reset();
m_iVehicleDamageIndex = 0;
//Ped
m_pActorEntity = NULL;
m_iPedModelIndex = 0;
m_varDrawableId = 0;
m_varTextureId =0 ;
m_varComponentId = 0;
m_varPalette = 0;
m_maxDrawables = 0;
m_maxTextures = 0;
m_maxPalettes = 0;
strncpy(m_varDrawablName, "Invalid", 24);
strncpy(m_varTexName, "Invalid", 24);
//camera
m_vCameraPos = VEC3_ZERO;
m_vCameraRot = VEC3_ZERO;
m_bOverrideCam = false;
m_cameraMtx = M34_IDENTITY;
m_bOverrideCamUsingMatrix = false;
m_fFov = 45.0f;
m_vDofPlanes = Vector4(Vector4::ZeroType);
m_fFadeInDuration = 1.0f;
m_fFadeOutDuration = 1.0f;
m_vFadeInColor = VEC3_ZERO;
m_vFadeOutColor = VEC3_ZERO;
m_bShouldOverrideUseLightDof = false;
m_fMotionBlurStrength = 0.0f;
//ptfx
m_iPtfxIndex =0;
//props
m_iPropModelIndex = 0;
m_pPropEntity = NULL;
for (int i=0; i < m_CutSceneVariations.GetCount(); i++)
{
m_CutSceneVariations[0]= NULL;
}
m_CutSceneVariations.Reset();
//Overlay
for(int i=0; i <m_OverlayObjectList.GetCount(); i++ )
{
m_OverlayObjectList[i] = NULL;
}
m_OverlayObjectList.Reset();
for(int i=0; i < m_OverlayEvents.GetCount(); i++)
{
m_OverlayEvents[i] = NULL;
}
m_OverlayEvents.Reset();
//Props
for(int i=0; i < m_PropList.GetCount(); i++)
{
m_PropList[i] = NULL;
}
m_PropList.Reset();
for(int i=0; i < m_pAssetManagerList.GetCount(); i++)
{
m_pAssetManagerList[i] = NULL;
}
m_pAssetManagerList.Reset();
//ptfx
m_PtfxEnt = NULL;
m_Ptfx = NULL;
for(int i=0; i < m_PtfxList.GetCount(); i++)
{
m_PtfxList[i] = NULL;
}
m_PtfxList.Reset();
for(int i = 0; i <m_CameraCutsIndexEvents.GetCount(); i++)
{
m_CameraCutsIndexEvents[i] = NULL;
}
m_CameraCutsIndexEvents.Reset();
ClearMapObject();
PopulateSelectorList(m_pPedSelectCombo, "Ped Selector", m_iPedModelIndex, CutSceneManager::GetInstance()->m_pedModelObjectList,datCallback(MFA(CCutSceneDebugManager::GetSelectedPedEntityCallBack), (datBase*)this) );
PopulateSelectorList(m_pVehicleSelectCombo, "Vehicle Selector", m_iVehicleModelIndex, m_VehicleModelObjectList,datCallback(MFA(CCutSceneDebugManager::GetSelectedVehicleEntityCallBack), (datBase*)this) );
PopulateSelectorList(m_pOverlaySelectCombo, "Overlay Selector", m_iOverlayIndex, m_OverlayObjectList, datCallback(MFA(CCutSceneDebugManager::GetSelectedOverlayEntityCallBack), (datBase*)this) );
PopulateSelectorList(m_pPropSelectCombo, "Prop Selector", m_iPropModelIndex, m_PropList, datCallback(MFA(CCutSceneDebugManager::GetSelectedPropEntityCallBack), (datBase*)this));
PopulateCameraCutEventList(NULL, m_pTimeCycleCameraCutCombo, m_iTimecycleEventsIndexId, datCallback(MFA(CCutSceneDebugManager::UpdateTimeCycleParamsCB), (datBase*)this) );
PopulateCameraCutEventList(NULL, m_pCoCModifiersCameraCutCombo, m_iCoCModifiersCamerCutComboIndexId, datCallback(MFA(CCutSceneDebugManager::UpdateCoCModifierEventOverridesCB), (datBase*)this));
UpdateFirstPersonEventList();
m_CameraObjectList.Reset();
//Timecycle
m_bOverrideTimeCycle = false;
m_fTimeCycleOverrideTime = 0;
m_CascadeBounds.Reset();
}
void CCutSceneDebugManager::PopulateSelectorList(bkCombo* pCombo, const char* ComboName, int &index, atArray<const cutfObject*> &list, datCallback callback )
{
if (pCombo)
{
if ( list.GetCount() == 0 )
{
#if __BANK
if ( pCombo != NULL )
{
index = 0;
pCombo->UpdateCombo( ComboName, &index, 1, NULL, callback);
pCombo->SetString( 0, "(none)" );
}
#endif
return;
}
if(list.GetCount() > 0)
{
pCombo->UpdateCombo( ComboName, &index, list.GetCount() + 1, NULL, callback);
pCombo->SetString( 0, "(none)" );
for ( int i = 0; i < list.GetCount(); ++i )
{
pCombo->SetString( i + 1, list[i]->GetDisplayName().c_str() );
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Get the entity that managers vehicle and populate all the relevant lists.
void CCutSceneDebugManager::GetSelectedVehicleEntityCallBack()
{
if (m_iVehicleModelIndex > 0)
{
cutsEntity* pCutEntity = CutSceneManager::GetInstance()->GetEntityByObjectId(m_VehicleModelObjectList[m_iVehicleModelIndex - 1]->GetObjectId());
CCutsceneAnimatedVehicleEntity* pEnt = static_cast<CCutsceneAnimatedVehicleEntity*> (pCutEntity);
if(pEnt)
{
m_pVehicle = pEnt;
GetVehicleSettings();
PopulateVehicleExtraList();
PopulateVehicleVariationEventList(m_VehicleModelObjectList[m_iVehicleModelIndex - 1]);
PopulateVehicleExtraEventList(m_VehicleModelObjectList[m_iVehicleModelIndex - 1]);
PopulateVehicleDamageEventList(m_VehicleModelObjectList[m_iVehicleModelIndex - 1]);
}
}
else
{
//selected none from the vehicle selector.
m_pVehicle = NULL;
ResetVehicleSettings();
PopulateVehicleVariationEventList(NULL);
PopulateVehicleExtraEventList(NULL);
PopulateVehicleDamageEventList(NULL);
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Get the current vehicle settings
void CCutSceneDebugManager::InitWidgets()
{
XPARAM(enablecutscenelightauthoring);
#if SETUP_CUTSCENE_WIDGET_FOR_CONTENT_CONTROLLED_BUILD
bkGroup* CurrentSceneGrp = static_cast<bkGroup*>(BANKMGR.FindWidget("Cut Scene Debug/Current Scene/"));
bkBank* Ragebank = BANKMGR.FindBank("Cut Scene Debug");
if (CurrentSceneGrp)
{
Ragebank->SetCurrentGroup(*CurrentSceneGrp);
Ragebank->PushGroup("Time Cycle");
CutSceneManager::GetInstance()->CreateVCRWidget(Ragebank);
Ragebank->AddToggle("Override Time Cycle", &m_bOverrideTimeCycle, NullCB, "Override Time Cycle");
Ragebank->AddSlider("Current Time (minutes)", &m_fTimeCycleOverrideTime, 0, (24*60)-1, 1);
Ragebank->AddText("Game Time", &m_cGameTime[0], sizeof(m_cGameTime));
Ragebank->PopGroup();
Ragebank->UnSetCurrentGroup(*CurrentSceneGrp);
}
#else
bkBank* Ragebank = BANKMGR.FindBank("Cut Scene Debug");
bkGroup* CurrentSceneGrp = static_cast<bkGroup*>(BANKMGR.FindWidget("Cut Scene Debug/Current Scene/"));
bkGroup* DebugLinesGrp = static_cast<bkGroup*>(BANKMGR.FindWidget("Cut Scene Debug/Current Scene/Debug Display/Debug Display"));
bkGroup* CameraGrp = static_cast<bkGroup*>(BANKMGR.FindWidget("Cut Scene Debug/Current Scene/Camera Editing"));
bkGroup* PtfxGrp = static_cast<bkGroup*>(BANKMGR.FindWidget("Cut Scene Debug/Current Scene/Particle Effects Editing"));
if(Ragebank)
{
if(DebugLinesGrp)
{
Ragebank->SetCurrentGroup(*DebugLinesGrp);
Ragebank->AddToggle( "Display Skeletons", &m_bDisplayAllSkeletons,
datCallback(MFA(CCutSceneDebugManager::DisplaySceneSkeletons),this) );
Ragebank->AddToggle("Display Loaded Models", &m_bDisplayLoadedModels);
Ragebank->AddToggle("Print Asset Loading To Debug", &m_bPrintModelLoadingToDebug);
Ragebank->UnSetCurrentGroup(*DebugLinesGrp);
}
if(CameraGrp)
{
Ragebank->SetCurrentGroup(*CameraGrp);
Ragebank->PushGroup("Camera Overrides", false); //ped variation widget
Ragebank->AddToggle("Override Cam", &m_bOverrideCam, NullCB, "Override Cam");
Ragebank->AddVector("Cam Position", &m_vCameraPos, -100000.0f, 100000.0f, 0.25f);
Ragebank->AddVector("Cam Rotation", &m_vCameraRot, -360.0f, 360.0f, 1.0f);
Ragebank->AddSeparator();
Ragebank->AddToggle("Override Cam Using Matrix", &m_bOverrideCamUsingMatrix, NullCB, "Override Cam Using Matrix");
Ragebank->AddMatrix("Cam Matrix", &m_cameraMtx, WORLDLIMITS_XMIN, WORLDLIMITS_XMAX, 0.01f);
Ragebank->AddSeparator();
Ragebank->AddToggle("Override Cam Using Binary", &m_bOverrideCamUsingBinary, NullCB, "Override the camera matrix direct from the binary data widget stream");
Ragebank->AddDataWidget("BinaryCamData", (u8*)&m_binaryCamMatrix, sizeof(Matrix34));
Ragebank->AddSeparator();
Ragebank->AddSlider("Cam FOV", &m_fFov, g_MinFov, g_MaxFov, 0.1f);
Ragebank->AddSeparator();
Ragebank->AddCombo("Dof State", &m_DofState, 3, DofStates);
Ragebank->AddSeparator();
Ragebank->AddSlider("Near Out Of Focus Dof Plane", &m_vDofPlanes.x, 0.0, 5000.0f, 0.1f);
Ragebank->AddSlider("Near In Focus Dof Plane", &m_vDofPlanes.y, 0.0f, 5000.0f, 0.1f);
Ragebank->AddSlider("Far In Focus Dof Plane", &m_vDofPlanes.z, 0.0f, 5000.0f, 0.1f);
Ragebank->AddSlider("Far Out Of Focus Dof Plane", &m_vDofPlanes.w, 0.0f, 5000.0f, 0.1f);
//Ragebank->AddToggle("Use Light Dof", &m_bShouldOverrideUseLightDof, NullCB, "Use Shallow Dof");
//Ragebank->AddToggle("Use Simple Dof", &m_bShouldOverrideUseSimpleDof, NullCB, "Use Simple Dof");
Ragebank->AddSlider("Circle of Confusion (Dof Plane Strength)", &m_CoCRadius, 1, 15, 1);
Ragebank->PushGroup("Scene Day CoC Hours", false);
Ragebank->AddButton("Save Day CoC Hours", datCallback(MFA(CCutSceneDebugManager::SaveDayCoCValues), (datBase*)this));
Ragebank->AddToggle("Set All Hours To Use Day CoC Track", &m_bShouldSetCoCForAllDay, datCallback(MFA(CCutSceneDebugManager::ToggleNightCoCOverrides), (datBase*)this), "Use Shallow Dof");
Ragebank->AddToggle("Set All Hours To Use Night CoC Track", &m_bShouldSetCoCForAllNight, datCallback(MFA(CCutSceneDebugManager::ToggleDayCoCOverrides), (datBase*)this), "Use Shallow Dof");
Ragebank->AddToggle("Hours For Day CoC Values", &m_bShouldUseRangeForCoC, datCallback(MFA(CCutSceneDebugManager::ToggleDayRangeCoCOverrides), (datBase*)this), "Use Shallow Dof");
Ragebank->PopGroup();
Ragebank->PushGroup("Shot CoC Modifier", false);
Ragebank->AddToggle("Override CoC Modifier", &m_bOverrideCoCModifier);
Ragebank->AddToggle("Use Scene Day CoC Hours", &m_UseDayCoCHoursForModifier, datCallback(MFA(CCutSceneDebugManager::UpdateHourSliderToDayHours), (datBase*)this), "Override Cam Using Matrix");
Ragebank->AddToggle("Use Scene Night CoC Hours", &m_UseNightCoCHoursForModifier, datCallback(MFA(CCutSceneDebugManager::UpdateHourSliderToNightHours), (datBase*)this), "Override Cam Using Matrix");
Ragebank->AddSlider("Time Of Day Dof Modifier", &m_CoCModifier, -15, 15, 1);
Ragebank->PushGroup("Modifier Hours", false);
for(int i = 0; i < 24; i++)
{
char name[24];
if(i == 0)
{
formatf(name, sizeof(name)-1, "Hour %d (Midnight)", i);
}
else if(i == 12)
{
formatf(name, sizeof(name)-1, "Hour %d (Midday)", i);
}
else
{
formatf(name, sizeof(name)-1, "Hour %d", i);
}
u32 bitsPerBlock = sizeof(u32) * 8;
int block = i / bitsPerBlock;
int bitInBlock = i - (block * bitsPerBlock);
Ragebank->AddToggle(name, &m_CoCModifierHours, (u32)(1 << bitInBlock));
}
Ragebank->PopGroup();
const char *CoCModifierOverrides[] = { "(none)" };
Ragebank->AddSeparator();
Ragebank->AddText("CurrentCut:",&m_CameraCutName[0], 128, true);
const char *CameraCutList[] = { "(none)" };
m_pCoCModifiersCameraCutCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Camera Cut Events", &m_iCoCModifiersCamerCutComboIndexId, 1, CameraCutList, datCallback(MFA(CCutSceneDebugManager::UpdateCoCModifierEventOverridesCB), (datBase*)this) ) );
Ragebank->AddToggle("Sync the Camera Cut Events widget to the current cut", &m_ShouldSyncTimeOfDayDofOverridedWidgetIndexidtoCurrentCameraCut, NullCB, "Sync camera cut events to current cut");
m_pPerCutCoCModifiersCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Per Camera Cut CoC Modifiers", &m_iCoCModifierIndex, 1, CoCModifierOverrides ) );
Ragebank->AddButton("Save CoC Modifier", datCallback(MFA(CCutSceneDebugManager::BankSaveCoCModifierCallBack), (datBase*)this));
Ragebank->AddButton("Delete CoC Modifier", datCallback(MFA(CCutSceneDebugManager::DeleteCoCModifierCallBack), (datBase*)this));
Ragebank->AddButton("Save CoC Modifier to ALL camera cuts", datCallback(MFA(CCutSceneDebugManager::BankSaveAllCoCModifiersCallBack), (datBase*)this));
Ragebank->AddButton("Delete all CoC Modifiers", datCallback(MFA(CCutSceneDebugManager::DeleteAllCoCModifierOverrideCallBack), (datBase*)this));
m_pSaveStatusText = Ragebank->AddText("Save Status:",&m_saveStatus[0], 64, true);
m_AllCoCModifiersCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "All CoC Modifiers (READ ONLY)", &m_iAllCoCModifierIndex, 1, CoCModifierOverrides ) );
Ragebank->PopGroup();
Ragebank->PushGroup("First Person");
m_firstPersonEventStatus = Ragebank->AddText("Event Save Status:",&m_firstPersonStatusText[0], 256, true);
const char *BlendOutEvents[] = { "(none)" };
m_firstPersonBlendOutComboSlider = Ragebank->AddCombo("First person Camera Events", &m_firstPersonBlendOutComboIndex, 1, BlendOutEvents);
Ragebank->PushGroup("First Person Blend Out");
m_FirstPersonBlendOutSlider = Ragebank->AddSlider("Blend Out Duration", &m_firstPersonCameraBlendDuration, 0.0f, 1000.0f, 0.1f);
Ragebank->AddButton("Add First Person BlendOut", datCallback(MFA(CCutSceneDebugManager::AddFirstPersonBlendOutEvent), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("First Person Catch Up");
Ragebank->AddButton("Add First Person catchup", datCallback(MFA(CCutSceneDebugManager::AddFirstPersonCatchUpEvent), (datBase*)this));
Ragebank->PopGroup();
Ragebank->AddButton("Delete First Person camera Event", datCallback(MFA(CCutSceneDebugManager::DeleteFirstPersonCameraEvent), (datBase*)this));
Ragebank->AddSeparator();
Ragebank->AddButton("Save Data Cut file", datCallback(MFA(CCutSceneDebugManager::SaveFirstPersonCameraEvents), (datBase*)this));
Ragebank->PopGroup();
Ragebank->AddSeparator();
Ragebank->AddToggle("Render Dof Planes", &m_RenderDofPlanes, NullCB, "Use Render Dof Planes");
Ragebank->AddSlider("Near Strength Plane Alpha (Pink)", &m_NearOutPlaneAlpha, 0, 255, 1);
Ragebank->AddSlider("Near Plane Alpha (Orange)", &m_NearInPlaneAlpha, 0, 255, 1);
Ragebank->AddSlider("Far Plane Alpha (Blue)", &m_FarInPlaneAlpha, 0, 255, 1);
Ragebank->AddSlider("Far Strength Plane Alpha (Green)", &m_FarOutPlaneAlpha, 0, 255, 1);
Ragebank->AddSlider("Focal Point Alpha (Red)", &m_FocalPointAlpha, 0, 255, 1);
Ragebank->AddSlider("Set Absolute Plane Scale", &m_PlaneScale, 0.0f, 50.0f, 0.1f);
Ragebank->AddSlider("Set Focal Point Scale", &m_FocalPointScale, 0.0f, 50.0f, 0.1f);
Ragebank->AddToggle("Scale Planes as a screen ratio", &m_scaleAsScreenRatio, NullCB, "Set the planes to render as a ratio of the screen");
Ragebank->AddToggle("Set Planes Solid", &m_SetPlaneSolid, NullCB, "Set the planes to render solidly");
Ragebank->AddSeparator();
Ragebank->AddSlider("Cam Motion Blur", &m_fMotionBlurStrength, 0.0f, 1.0f, 0.01f);
Ragebank->AddSeparator();
Ragebank->AddButton("Fade Out", datCallback(MFA(CCutSceneDebugManager::BankFadeScreenOutCallBack), (datBase*)this));
Ragebank->AddSlider("Fade Out Duration", &m_fFadeOutDuration, 0.0f, 1000.0f, 1.0f);
Ragebank->AddColor( "Fade Out Colour", &m_vFadeOutColor);
Ragebank->AddButton("Fade In", datCallback(MFA(CCutSceneDebugManager::BankFadeScreenInCallBack), (datBase*)this));
Ragebank->AddSlider("Fade In Duration", &m_fFadeInDuration, 0.0f, 1000.0f, 1.0f);
Ragebank->AddColor( "Fade In Colour", &m_vFadeInColor);
Ragebank->AddSeparator();
if(PARAM_enablecutscenelightauthoring.Get())
{
m_bOverrideCamBlendOutEvents = true;
}
Ragebank->AddToggle("Override Camera Blendout Events", &m_bOverrideCamBlendOutEvents, NullCB, "");
Ragebank->PopGroup();
Ragebank->PushGroup("Camera Final Frame", false); //ped variation widget
Ragebank->AddMatrix("Cam Final Frame", &m_FinalFrameCameraMat,-100000.0f, 100000.0f, 0.1f);
Ragebank->PopGroup();
Ragebank->PushGroup("Timecycle Modifiers", false); // timecycle modifier values
Ragebank->AddText("CurrentCut:",&m_CameraCutName[0], 128, true);
//const char *CameraCutList[] = { "(none)" };
m_pTimeCycleCameraCutCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Camera Cut Events", &m_iTimecycleEventsIndexId, 1, CameraCutList, datCallback(MFA(CCutSceneDebugManager::UpdateTimeCycleParamsCB), (datBase*)this) ) );
Ragebank->AddSlider("ReflectionLodRangeStart", &m_ReflectionLodRangeStart, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("ReflectionLodRangeEnd", &m_ReflectionLodRangeEnd, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("ReflectionSLodRangeStart", &m_ReflectionSLodRangeStart, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("ReflectionSLodRangeEnd", &m_ReflectionSLodRangeEnd, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("LodMult", &m_LodMult, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("LodMultHD", &m_LodMultHD, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("LodMultOrphanedHD", &m_LodMultOrphanedHD, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("LodMultLod", &m_LodMultLod, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("LodMultSLod1", &m_LodMultSLod1, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("LodMultSLod2", &m_LodMultSLod2, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("LodMultSLod3", &m_LodMultSLod3, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("LodMultSLod4", &m_LodMultSLod4, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("WaterReflectionClip", &m_WaterReflectionFarClip, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("SSAOInten", &m_SSAOLightInten, -1.0, 10000.0f, 0.1f);
Ragebank->AddSlider("ExposurePush", &m_ExposurePush, -1.0, 1.0f, 0.1f);
Ragebank->AddSlider("Directional light mult", &m_DirectionalLightMultiplier, -1.0, 64.0f, 1.0f);
Ragebank->AddSlider("Lend Artefact mult", &m_LensArtefactMultiplier, -1.0, 1.0f, 0.01f);
Ragebank->AddSlider("Max Bloom", &m_MaxBloom, -1.0, 16.0f, 0.1f);
Ragebank->AddToggle("Freeze Reflection Map", &m_FreezeReflectionMap, NullCB, "Freezes the reflection map for the duration of this camera cut");
Ragebank->AddToggle("Disable Directional Light", &m_DisableDirectionalLight, NullCB, "Disables the worlds directional light for the duration cut");
Ragebank->AddToggle("Enable Absolute Intensity", &m_AbsoluteIntensityEnabled, NullCB, "Enables the absolute intensity");
Ragebank->AddSlider("LightFadeDistanceMult", &m_LightFadeDistanceMult, 0.0, 1.0f, 0.1f);
Ragebank->AddSlider("LightShadowFadeDistanceMult", &m_LightShadowFadeDistanceMult, 0.0, 1.0f, 0.1f);
Ragebank->AddSlider("LightSpecularFadeDistMult", &m_LightSpecularFadeDistMult, 0.0, 1.0f, 0.1f);
Ragebank->AddSlider("LightVolumetricFadeDistanceMult", &m_LightVolumetricFadeDistanceMult, 0.0, 1.0f, 0.1f);
/* Ragebank->PushGroup("DOF Override", false);
{
Ragebank->AddToggle("Disable High Quality DOF (override)", &m_bDisableHighQualityDof, NullCB, "If true it disables the High Quality DOF, overriding cutscene DOF events");
}
Ragebank->PopGroup(); // DOF Override*/
Ragebank->PushGroup("Character Light", false);
{
Ragebank->AddToggle("Use timecycle values", &m_CharacterLight.m_bUseTimeCycleValues, NullCB, "Override Cam Using Matrix");
Ragebank->AddToggle("Use as timecycle modifier", &m_CharacterLight.m_bUseAsIntensityModifier , NullCB, "Use the intensity as a time cycle modifier");
Ragebank->AddVector("Direction", &m_CharacterLight.m_vDirection, -1.0f, 1.0f, 0.01f);
Ragebank->AddColor("Colour", &m_CharacterLight.m_vColour);
Ragebank->AddSlider("Intensity", &m_CharacterLight.m_fIntensity, 0.0f, 64.0f, 0.1f);
}
Ragebank->PopGroup(); //ped variation widget
Ragebank->AddButton("Save Time Cycle Params", datCallback(MFA(CCutSceneDebugManager::BankSaveTimeCycleParamsCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("Interior", false); //ped variation widget
const char *InteriorLoadList[] = { "(none)" };
Ragebank->AddText("Interior name:",&m_InteriorName[0], 24, true);
Ragebank->AddVector("Cam Position for Interior: ", &m_InteriorPos, -100000.0f, 100000.0f, 0.25f);
m_pLoadInteriorIndexCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Load Interior Events", &m_LoadInteriorIndexId, 1, InteriorLoadList ) );
Ragebank->AddButton("Save Load Interior Event", datCallback(MFA(CCutSceneDebugManager::BankSaveLoadInteriorCallBack), (datBase*)this));
Ragebank->AddButton("Delete Load Interior Event", datCallback(MFA(CCutSceneDebugManager::BankDeleteLoadInteriorsCallBack), (datBase*)this));
Ragebank->PopGroup();
m_CameraWidgetData = Ragebank->AddDataWidget("Camera Override Data", NULL,1024, datCallback(MFA(CCutSceneDebugManager::BankCameraWidgetReceiveDataCallback), (datBase*)this), 0, false);
Ragebank->UnSetCurrentGroup(*CameraGrp);
}
if(PtfxGrp)
{
Ragebank->SetCurrentGroup(*PtfxGrp);
Ragebank->PushGroup("Particle Effects Overrides", false); //ped variation widget
const char *PtfxList[] = { "(none)" };
m_pPTFXSelectCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Ptfx Selector", &m_iPtfxIndex, 1, PtfxList ) );
Ragebank->AddToggle("Override Ptfx", &m_OverridePtfx, datCallback(MFA(CCutSceneDebugManager::SetCanOverridePtfx), this));
Ragebank->AddVector("PTFX Position", &m_vPTFXPos, -100000.0f, 100000.0f, 0.25f, datCallback(MFA(CCutSceneDebugManager::UpdatePtfxPos), (datBase*)this));
Ragebank->AddVector("PTFX Rotation", &m_vPTFXRot, -360.0f, 360.0f, 1.0f, datCallback(MFA(CCutSceneDebugManager::UpdatePtfxRot), (datBase*)this));
Ragebank->PopGroup();
Ragebank->UnSetCurrentGroup(*PtfxGrp);
}
if (CurrentSceneGrp)
{
Ragebank->SetCurrentGroup(*CurrentSceneGrp);
Ragebank->PushGroup("Ped Variations", false); //ped variation widget
CutSceneManager::GetInstance()->CreateVCRWidget(Ragebank);
m_pVarPedFrameSlider = Ragebank->AddSlider( "Current Frame", &CutSceneManager::GetInstance()->m_iCurrentFrameWithFrameRanges, 0, MAX_FRAMES, 1,
datCallback(MFA(CutSceneManager::BankFrameScrubbingCallback),CutSceneManager::GetInstance()) );
//need a non const version of the phase.... boo
//Ragebank->AddSlider("phase", &CutSceneManager::GetInstance()->GetCutScenePhase(), 0.0f 1.0f, 0.0f);
Ragebank->AddSeparator();
const char *PedNameList[] = { "(none)" };
m_pPedSelectCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Ped Selector", &m_iPedModelIndex, 1, PedNameList ) );
const char *EventNameList[] = { "(none)" }; //events
m_pEventCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Ped var events", &m_PedVarEventId, 1, EventNameList ) );
Ragebank->PushGroup("Ped Variations", false); //ped variation widget
const char* varSlotList[128];
for (u32 i=0; i<PV_MAX_COMP; i++)
{
varSlotList[i] = varSlotNames[i];
}
Ragebank->AddText("Drawable name:",&m_varDrawablName[0], 24, true);
Ragebank->AddText("Texture name:",&m_varTexName[0], 24, true);
Ragebank->AddCombo("Component", &m_varComponentId, 12, &varSlotList[0], datCallback(MFA(CCutSceneDebugManager::UpdateCutSceneVarComponentCB), (datBase*)this));
Ragebank->AddSlider("Max Drawable:", &m_maxDrawables, 0, 32, 0);
m_pVarDrawablIdSlider = Ragebank->AddSlider("Drawable Id", &m_varDrawableId, 0, 32, 1, datCallback(MFA(CCutSceneDebugManager::UpdateCutSceneVarDrawblCB), (datBase*)this));
Ragebank->AddSlider("Max Texture:", &m_maxTextures, 0, 32, 0);
m_pVarTexIdSlider = Ragebank->AddSlider("Texture Id", &m_varTextureId, 0, 32, 1, datCallback(MFA(CCutSceneDebugManager::UpdateCutSceneVarTexCB), (datBase*)this));
//bank.AddSlider("Max Palette:", &m_maxPalettes, 0, 15, 0);
//m_pVarPaletteIdSlider = bank.AddSlider("Palette Id", &m_varPaletteId, 0, 15, 1, datCallback(MFA(CutSceneManager::UpdateCutscneVarPaletteCB), (datBase*)this)));
Ragebank->AddButton("Save Ped Var Event", datCallback(MFA(CCutSceneDebugManager::BankSavePedVariationEventCallBack), (datBase*)this));
Ragebank->AddButton("Delete Ped Var Event", datCallback(MFA(CCutSceneDebugManager::BankDeletePedVariationCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("Prop Variations", false); //ped variation widget
Ragebank->AddSeparator();
const char* propSlotList[128];
for (u32 i=0; i<NUM_ANCHORS; i++)
{
propSlotList[i] = propSlotNames[i];
}
Ragebank->AddCombo("Prop Slot", &m_PropSlotId, NUM_ANCHORS, &propSlotList[0], datCallback(MFA(CCutSceneDebugManager::UpdateCutScenePropComponentCB), (datBase*)this));
m_pPropDrawablIdSlider = Ragebank->AddSlider("Prop Id", &m_PropDrawableId, -1, 32, 1, datCallback(MFA(CCutSceneDebugManager::UpdateCutScenePropDrawblCB), (datBase*)this));
m_pPropTexIdSlider = Ragebank->AddSlider("Tex Id", &m_PropTextureId, -1, 32, 1, datCallback(MFA(CCutSceneDebugManager::UpdateCutScenePropTexCB), (datBase*)this));
Ragebank->AddButton("Save Prop Var Event", datCallback(MFA(CCutSceneDebugManager::BankSavePedPropVariationEventCallBack), (datBase*)this));
Ragebank->AddButton("Delete Ped Var Event", datCallback(MFA(CCutSceneDebugManager::BankDeletePedVariationCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PopGroup();
//** VEHICLE VARITAION **
Ragebank->PushGroup("Vehicle Variation");
CutSceneManager::GetInstance()->CreateVCRWidget(Ragebank);
m_pVarFrameSlider = Ragebank->AddSlider( "Current Frame", &CutSceneManager::GetInstance()->m_iCurrentFrameWithFrameRanges, 0, MAX_FRAMES, 1,
datCallback(MFA(CutSceneManager::BankFrameScrubbingCallback),CutSceneManager::GetInstance()) );
Ragebank->AddToggle("Display Vehicle Var Config", &m_bDisplayVehicleVariation, NullCB, "Display Vehicle Variation");
const char *VehicleNameList[] = { "(none)" };
m_pVehicleSelectCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Vehicle Selector", &m_iVehicleModelIndex, 1, VehicleNameList ) );
Ragebank->AddSlider("Main Body Colour", &m_iMainBodyColour, 0, 255, 1, datCallback(MFA(CCutSceneDebugManager::UpdateVehicleBody1ColourCallBack), (datBase*)this));
Ragebank->AddSlider("Secondary Body Colour", &m_iSecondBodyColour, 0, 255, 1, datCallback(MFA(CCutSceneDebugManager::UpdateVehicleBody2ColourCallBack), (datBase*)this));
Ragebank->AddSlider("Body Specular", &m_iSpecularColour, 0, 255, 1, datCallback(MFA(CCutSceneDebugManager::UpdateVehicleBody3ColourCallBack), (datBase*)this));
Ragebank->AddSlider("Wheel Trim", &m_iWheelTrimColour, 0, 255, 1, datCallback(MFA(CCutSceneDebugManager::UpdateVehicleBody4ColourCallBack), (datBase*)this));
Ragebank->AddSlider("Body Colour 5", &m_iBodyColour5, 0, 255, 1, datCallback(MFA(CCutSceneDebugManager::UpdateVehicleBody5ColourCallBack), (datBase*)this));
Ragebank->AddSlider("Body Colour 6", &m_iBodyColour6, 0, 255, 1, datCallback(MFA(CCutSceneDebugManager::UpdateVehicleBody6ColourCallBack), (datBase*)this));
Ragebank->AddSlider("Dirt", &m_fDirtLevel, 0.0f, 15.0f, 0.5f, datCallback(MFA(CCutSceneDebugManager::UpdateVehicleDirtCallBack), (datBase*)this));
m_pLiverySlider = Ragebank->AddSlider("Livery", &m_iLivery, 0, MAX_NUM_LIVERIES, 1, datCallback(MFA(CCutSceneDebugManager::UpdateVehicleLiveriesCallBack), (datBase*)this));
m_pLivery2Slider= Ragebank->AddSlider("Livery2", &m_iLivery2, 0, MAX_NUM_LIVERIES, 1, datCallback(MFA(CCutSceneDebugManager::UpdateVehicleLiveriesCallBack), (datBase*)this));
//Vehicle Variation
const char *VehicleEventNameList[] = { "(none)" }; //events
m_pVehicleVariationEventCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Vehicle var events", &m_VehicleVarEventId, 1, VehicleEventNameList ) );
Ragebank->AddButton("Save Vehicle Var Event", datCallback(MFA(CCutSceneDebugManager::BankSaveVehicleVariationEventCallBack), (datBase*)this));
Ragebank->AddButton("Delete Vehicle Var Event", datCallback(MFA(CCutSceneDebugManager::BankDeleteVehicleVariationCallBack), (datBase*)this));
Ragebank->AddSeparator();
//Vehicle extras
const char *VehicleExtraList[] = { "(none)" };
m_pVehicleExtraCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Extra Selector", &m_iVehicleExtraIndex, 1, VehicleExtraList ) );
Ragebank->AddButton("Hide Vehicle Extra", datCallback(MFA(CCutSceneDebugManager::HideVehicleExtraCallBack), (datBase*)this));
Ragebank->AddButton("Show Vehicle Extra", datCallback(MFA(CCutSceneDebugManager::ShowVehicleExtraCallBack), (datBase*)this));
const char *VehicleExtraEventList[] = { "none" };
m_pVehicleExtraEventCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Vehicle Extra events", &m_VehicleExtraEventId, 1, VehicleExtraEventList ) );
Ragebank->AddButton("Save Vehicle Extra Event", datCallback(MFA(CCutSceneDebugManager::BankSaveVehicleExtraCallBack), (datBase*)this));
Ragebank->AddButton("Delete Vehicle Extra Event", datCallback(MFA(CCutSceneDebugManager::BankDeleteVehicleExtrasCallBack), (datBase*)this));
Ragebank->PushGroup("Vehicle Damage");
const char *VehicleDamageEventList[] = { "(none)" };
m_pVehicleDamageEventCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Damage Event Selector", &m_iVehicleDamageIndex, 1, VehicleDamageEventList ) );
Ragebank->AddToggle("Activate Vehicle Damage Pos", &m_bVehicleDamageSelector, NullCB, "Activate Vehicle Damage Pos");
Ragebank->AddSlider("Deformation", &m_fDerformation, 0.0f, 1000.0f, 1.0f);
Ragebank->AddSlider("Damage", &m_fDamageValue, 0.0f, 1000.0f, 1.0f);
Ragebank->AddButton("ApplyDamage", datCallback(MFA(CCutSceneDebugManager::BankApplyVehicleDamageEventCallBack), (datBase*)this));
Ragebank->AddButton("Save Vehicle Damage Event", datCallback(MFA(CCutSceneDebugManager::BankSaveVehicleDamageEvent), (datBase*)this));
Ragebank->AddButton("Delete Vehicle Damage Event", datCallback(MFA(CCutSceneDebugManager::BankDeleteVehicleDamageEvent), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PopGroup();
//Time Cycle debugging
Ragebank->PushGroup("Time Cycle");
CutSceneManager::GetInstance()->CreateVCRWidget(Ragebank);
Ragebank->AddToggle("Override Time Cycle", &m_bOverrideTimeCycle, NullCB, "Override Time Cycle");
Ragebank->AddSlider("Current Time (minutes)", &m_fTimeCycleOverrideTime, 0, (24*60)-1, 1);
Ragebank->AddText("Game Time", &m_cGameTime[0], sizeof(m_cGameTime));
Ragebank->PopGroup();
//Time Cycle debugging
Ragebank->PushGroup("Overlay");
CutSceneManager::GetInstance()->CreateVCRWidget(Ragebank);
m_pOverlayPlayBackSlider = Ragebank->AddSlider( "Current Frame", &CutSceneManager::GetInstance()->m_iCurrentFrameWithFrameRanges, 0, MAX_FRAMES, 1,
datCallback(MFA(CutSceneManager::BankFrameScrubbingCallback),CutSceneManager::GetInstance()) );
const char *OverlayNameList[] = { "(none)" };
m_pOverlaySelectCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Overlay Selector", &m_iOverlayIndex, 1, OverlayNameList ) );
const char *OverlayEventsList[] = { "(none)" };
m_pOverlayEventCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Overlay Events", &m_OverlayEventId, 1, OverlayEventsList ) );
Ragebank->PushGroup("Overlay Events");
Ragebank->PushGroup("Overlay Property Events");
Ragebank->AddSlider("Pos.x", &m_vOverlayPos.x, 0.0f, 1.0f, 0.1f, datCallback(MFA(CCutSceneDebugManager::SetOverlayPositionCB), (datBase*)this));
Ragebank->AddSlider("Pos.y", &m_vOverlayPos.y, 0.0f, 1.0f, 0.1f,datCallback(MFA(CCutSceneDebugManager::SetOverlayPositionCB), (datBase*)this));
Ragebank->AddSlider("Size.x", &m_vOverlaySize.x, 0.0f, 1.0f, 0.1f, datCallback(MFA(CCutSceneDebugManager::SetOverlaySizeCB), (datBase*)this));
Ragebank->AddSlider("Size.y", &m_vOverlaySize.y, 0.0f, 1.0f, 0.1f, datCallback(MFA(CCutSceneDebugManager::SetOverlaySizeCB), (datBase*)this));
Ragebank->AddToggle("Use Screen Render Target", &m_bUseScreenRenderTarget, NullCB, "Use Screen Render Target");
Ragebank->AddButton("Save Overlay Property Event", datCallback(MFA(CCutSceneDebugManager::BankSaveMovieProperties), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("Overlay Method Events");
const char *OverlayMethodNameList[] = { "(none)" };
m_pOverlayMethodsCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Overlay Method Selector", &m_iOverlayMethodIndex, 1, OverlayMethodNameList ) );
Ragebank->PushGroup("Params");
m_pOverlayParamNames = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Param Name", &m_iOverlayParamNameIndex, MAX_NUMBER_OVERLAY_PARAMS, OverlayParamNames ) );
m_pOverlayParamTypes = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Param Type", &m_iOverlayParamTypeIndex, MAX_NUMBER_PARAM_TYPES, OverlayParamTypes) );
Ragebank->AddButton("Add Overlay Param", datCallback(MFA(CCutSceneDebugManager::CreateParamWidgets), (datBase*)this));
Ragebank->AddButton("Delete Overlay Param", datCallback(MFA1(CCutSceneDebugManager::DeleteParamWidget), (datBase*)this, (CallbackData)(size_t)m_iOverlayParamNameIndex));
Ragebank->PopGroup();
Ragebank->AddButton("Add Overlay Method Event", datCallback(MFA(CCutSceneDebugManager::BankSaveOverlayEventsCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->AddButton("Delete Overlay Event", datCallback(MFA(CCutSceneDebugManager::BankDeleteOverlayEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PopGroup();
Ragebank->PushGroup("Props");
const char *PropNameList[] = { "(none)" };
m_pPropSelectCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Prop Selector", &m_iPropModelIndex, 1, PropNameList ) );
Ragebank->PopGroup();
Ragebank->PushGroup("Set Water Reflection Index");
CutSceneManager::GetInstance()->CreateVCRWidget(Ragebank);
m_pWaterIndexFrameSlider = Ragebank->AddSlider( "Current Frame", &CutSceneManager::GetInstance()->m_iCurrentFrameWithFrameRanges, 0, MAX_FRAMES, 1,
datCallback(MFA(CutSceneManager::BankFrameScrubbingCallback),CutSceneManager::GetInstance()) );
const char *WaterRelectList[] = { "(none)" };
m_pWaterRefractionIndexCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Water Reflection Event", &m_iWaterRefractionIndexId, 1, WaterRelectList ) );
Ragebank->AddSlider("Water Index", &m_fWaterRefractionIndex, 0.0f, 5.0f, 0.1f, datCallback(MFA(CCutSceneDebugManager::SetOverlayPositionCB), (datBase*)this));
Ragebank->AddButton("Save Water Reflection Event", datCallback(MFA(CCutSceneDebugManager::BankSaveWaterRefractionIndexEventCallBack), (datBase*)this));
Ragebank->AddButton("Delete Water Reflection Event", datCallback(MFA(CCutSceneDebugManager::BankDeleteWaterRefractionIndexEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("Profiling");
{
Ragebank->AddToggle("Turn off cutscene lights", &m_bProfilingDisableCsLights);
Ragebank->AddToggle("Override character light", &m_bProfilingOverrideCharacterLight);
Ragebank->AddToggle("Show all peds", &g_DrawPeds);
Ragebank->AddToggle("Hide all props", &CEntity::ms_cullProps);
Ragebank->AddToggle("Turn off DOF", &m_bProfilingDisableDof);
Ragebank->AddToggle("Use default FOV", &m_bProfilingUseDefaultFov);
}
Ragebank->PopGroup();
Ragebank->PushGroup("Validation");
{
Ragebank->AddToggle("Validate shadow events", &m_cutfileValidationProcesses[CVP_SHADOW_EVENTS]);
Ragebank->AddToggle("fix shadow events", &m_cutfileValidationProcesses[CVP_FIX_SHADOW_EVENTS]);
Ragebank->AddToggle("Validate light events", &m_cutfileValidationProcesses[CVP_LIGHT_EVENTS]);
Ragebank->AddButton("Validate this Scene", datCallback(MFA(CCutSceneDebugManager::ValidateEventInThisScene), (datBase*)this));
Ragebank->AddButton("Validate All Scenes", datCallback(MFA(CCutSceneDebugManager::BatchProcessCutfilesInMemory), (datBase*)this));
}
Ragebank->PopGroup();
m_CutsceneStateWidgetData = Ragebank->AddDataWidget("Cutscene Data", &m_CutsceneStateWidgetDataBuffer[0], CUTSCENE_STATE_DATA_WIDGET_SIZE, datCallback(MFA(CCutSceneDebugManager::BankCutsceneWidgetReceiveDataCallback), (datBase*)this), 0, false);
Ragebank->UnSetCurrentGroup(*CurrentSceneGrp);
}
}
m_CascadeBounds.InitWidgets();
if (CutSceneManager::GetInstance()->IsCutscenePlayingBack())
{
if(m_pPedSelectCombo)
{
PopulateSelectorList(m_pPedSelectCombo, "Ped Selector", m_iPedModelIndex, CutSceneManager::GetInstance()->m_pedModelObjectList,datCallback(MFA(CCutSceneDebugManager::GetSelectedPedEntityCallBack), (datBase*)this) );
}
if(m_pVehicleSelectCombo)
{
PopulateSelectorList(m_pVehicleSelectCombo, "Vehicle Selector", m_iVehicleModelIndex, m_VehicleModelObjectList,datCallback(MFA(CCutSceneDebugManager::GetSelectedVehicleEntityCallBack), (datBase*)this) );
}
if(m_pOverlaySelectCombo)
{
PopulateSelectorList(m_pOverlaySelectCombo, "Overlay Selector", m_iOverlayIndex, m_OverlayObjectList, datCallback(MFA(CCutSceneDebugManager::GetSelectedOverlayEntityCallBack), (datBase*)this) );
}
if(m_pPropSelectCombo)
{
PopulateSelectorList(m_pPropSelectCombo, "Prop Selector", m_iPropModelIndex, m_PropList, datCallback(MFA(CCutSceneDebugManager::GetSelectedPropEntityCallBack), (datBase*)this) );
}
if(m_pPTFXSelectCombo)
{
PopulateSelectorList(m_pPTFXSelectCombo, "Prop Selector", m_iPtfxIndex, m_PtfxList, datCallback(MFA(CCutSceneDebugManager::GetSelectedPtfxEntityCallBack), (datBase*)this));
}
if(m_CameraObjectList.GetCount()>0 )
{
PopulateWaterRefractionIndexEventList(m_CameraObjectList[0]);
PopulateCameraCutEventList(m_CameraObjectList[0], m_pTimeCycleCameraCutCombo, m_iTimecycleEventsIndexId, datCallback(MFA(CCutSceneDebugManager::UpdateTimeCycleParamsCB), (datBase*)this) );
PopulateCameraCutEventList(m_CameraObjectList[0], m_pCoCModifiersCameraCutCombo, m_iCoCModifiersCamerCutComboIndexId, datCallback(MFA(CCutSceneDebugManager::UpdateCoCModifierEventOverridesCB), (datBase*)this));
m_CascadeBounds.PopulateSetShadowBoundsEventList(m_CameraObjectList[0]);
UpdateFirstPersonEventList();
}
}
#endif
}
void CCutSceneDebugManager::DestroyWidgets()
{
m_FirstPersonBlendOutSlider = NULL;
m_CascadeBounds.DestroyWidgets();
m_pVarDebugFrameSlider = NULL;
m_pVarSkipFrameSlider = NULL;
m_pPedVarPlayBackSlider = NULL;
m_pVehicleVarPlayBackSlider = NULL;
m_pPedSelectCombo = NULL;
m_pCoCModifiersCameraCutCombo = NULL;
m_pPerCutCoCModifiersCombo = NULL;
m_pSaveStatusText = NULL;
m_AllCoCModifiersCombo = NULL;
m_firstPersonEventStatus = NULL;
m_firstPersonBlendOutComboSlider = NULL;
m_FirstPersonBlendOutSlider = NULL;
m_pTimeCycleCameraCutCombo = NULL;
m_pLoadInteriorIndexCombo = NULL;
m_CameraWidgetData = NULL;
m_pPTFXSelectCombo = NULL;
m_pVarPedFrameSlider = NULL;
m_pEventCombo = NULL;
m_pVarDrawablIdSlider = NULL;
m_pVarTexIdSlider = NULL;
m_pPropDrawablIdSlider = NULL;
m_pPropTexIdSlider = NULL;
m_pVarFrameSlider = NULL;
m_pVehicleSelectCombo = NULL;
m_pLiverySlider = NULL;
m_pLivery2Slider = NULL;
m_pVehicleVariationEventCombo = NULL;
m_pVehicleExtraCombo = NULL;
m_pVehicleExtraEventCombo = NULL;
m_pVehicleDamageEventCombo = NULL;
m_pOverlayPlayBackSlider = NULL;
m_pOverlaySelectCombo = NULL;
m_pOverlayEventCombo = NULL;
m_pOverlayMethodsCombo = NULL;
m_pOverlayParamNames = NULL;
m_pOverlayParamTypes = NULL;
m_pPropSelectCombo = NULL;
m_pWaterIndexFrameSlider = NULL;
m_pWaterRefractionIndexCombo = NULL;
m_CutsceneStateWidgetData = NULL;
}
void CCutSceneDebugManager::BankCameraWidgetReceiveDataCallback( )
{
u8* data = m_CameraWidgetData->GetData();
u16 length = m_CameraWidgetData->GetLength();
if(!Verifyf(data != NULL, "Camera widget bank received NULL data."))
return;
if(!Verifyf(length > 0, "Camera widget bank received data of zero length."))
return;
int offset = 0;
m_bOverrideCamUsingMatrix = *((bool*) &data[offset]);
offset += sizeof(bool);
m_bOverrideCam = *((bool*) &data[offset]);
offset += sizeof(bool);
m_bShouldOverrideUseLightDof = *((bool*) &data[offset]);
offset += sizeof(bool);
m_bShouldOverrideUseSimpleDof = *((bool*) &data[offset]);
offset += sizeof(bool);
float* matrix = (float*) &data[offset];
m_cameraMtx.Set(matrix[0], matrix[1], matrix[2],
matrix[3], matrix[4], matrix[5],
matrix[6], matrix[7], matrix[8],
matrix[9], matrix[10], matrix[11]);
offset += (sizeof(float) * 12);
m_fFov = *((float*) &data[offset]);
offset += sizeof(float);
float* dofPlanes = (float*) &data[offset];
m_vDofPlanes.Set(dofPlanes[0], dofPlanes[1], dofPlanes[2], dofPlanes[3]);
offset += sizeof(float) * 4;
m_fMotionBlurStrength = *((float*) &data[offset]);
offset += sizeof(float);
m_CoCRadius = (int)(*((float*) &data[offset]));
offset += sizeof(float);
TUNE_GROUP_BOOL(CUTSCENE, UseFocusPoint ,true);
if(UseFocusPoint)
{
m_FocusPoint = *((float*) &data[offset]);
m_FocusPoint /= 100.0f; //convert to meters from centimeters
offset += sizeof(float);
}
}
void CCutSceneDebugManager::BankCutsceneWidgetReceiveDataCallback( )
{
u8* data = m_CutsceneStateWidgetData->GetData();
u16 length = m_CutsceneStateWidgetData->GetLength();
if(!Verifyf(data != NULL, "Camera widget bank received NULL data."))
return;
if(!Verifyf(length > 0, "Camera widget bank received data of zero length."))
return;
memset(data, 0, CUTSCENE_STATE_DATA_WIDGET_SIZE);
int offset = 0;
//Cutscene state.
int stateInt = (int) CutSceneManager::GetInstance()->GetState();
memcpy(&data[offset], &stateInt, sizeof(int));
offset += sizeof(int);
//Save the current frame.
int iCurrentFrame = CutSceneManager::GetInstance()->m_iCurrentFrameWithFrameRanges;
memcpy(&data[offset], &iCurrentFrame, sizeof(int));
offset += sizeof(int);
m_CutsceneStateWidgetData->RemoteUpdate();
}
void CCutSceneDebugManager::BankFadeScreenInCallBack()
{
Color32 color(m_vFadeInColor);
//cutfScreenFadeEventArgs* pEventArgs = rage_new cutfScreenFadeEventArgs( m_fFadeInDuration, color );
//CutSceneManager::GetInstance()->DispatchEventToObjectType( CUTSCENE_FADE_GAME_ENITITY, CUTSCENE_FADE_IN_EVENT, pEventArgs);
//this fixes a problem in the fade system where is does not deal with colours that have alphas less than 200
s32 iFadeTime = (s32) (m_fFadeInDuration * 1000.0f);
color.SetAlpha(255);
camInterface::FadeIn(iFadeTime, color);
}
void CCutSceneDebugManager::BankFadeScreenOutCallBack()
{
Color32 color(m_vFadeOutColor);
//cutfScreenFadeEventArgs* pEventArgs = rage_new cutfScreenFadeEventArgs( m_fFadeOutDuration, color );
//CutSceneManager::GetInstance()->DispatchEventToObjectType( CUTSCENE_FADE_GAME_ENITITY, CUTSCENE_FADE_OUT_EVENT, pEventArgs);
s32 iFadeTime = (s32) (m_fFadeOutDuration * 1000.0f);
color.SetAlpha(255);
camInterface::FadeOut(iFadeTime, true, color);
}
void CCutSceneDebugManager::DisplaySceneSkeletons()
{
CutSceneManager::GetInstance()->DispatchEventToObjectType( CUTSCENE_MODEL_OBJECT_TYPE,
(m_bDisplayAllSkeletons) ? CUTSCENE_SHOW_DEBUG_LINES_EVENT : CUTSCENE_HIDE_DEBUG_LINES_EVENT );
}
/////////////////////////////////////////////////////////////////////////////////////
//Set the vehicle settings to some default values
void CCutSceneDebugManager::ResetVehicleSettings()
{
m_iMainBodyColour = 0;
m_iSecondBodyColour = 0;
m_iSpecularColour = 0;
m_iWheelTrimColour = 0;
m_iBodyColour5 = 0;
m_iBodyColour6 = 0;
m_fDirtLevel = 0.0f;
m_iLivery = -1;
m_iLivery2= -1;
for(int i=0; i<m_pBoneData.GetCount(); i++)
{
m_pBoneData[i]=NULL;
}
m_pBoneData.Reset();
if(m_pVehicleExtraCombo)
{
m_pVehicleExtraCombo->UpdateCombo( "Vehicle Extras", &m_iVehicleExtraIndex, m_pBoneData.GetCount()+1, NULL );
m_pVehicleExtraCombo->SetString(0, "none");
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Get the current vehicle settings
void CCutSceneDebugManager::GetVehicleSettings()
{
if((m_pLiverySlider == NULL) || (m_pLivery2Slider == NULL))
{
return;
}
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
CVehicleModelInfo* pVehicleInfo = NULL;
pVehicleInfo = m_pVehicle->GetGameEntity()->GetVehicleModelInfo();
if(pVehicleInfo)
{
m_pLiverySlider->SetRange(0, pVehicleInfo->GetLiveriesCount()); //set the range of the liveries widget
m_pLivery2Slider->SetRange(0, pVehicleInfo->GetLiveries2Count()); //set the range of the liveries widget
}
m_iMainBodyColour = m_pVehicle->GetGameEntity()->GetBodyColour1();
m_iSecondBodyColour = m_pVehicle->GetGameEntity()->GetBodyColour2();
m_iSpecularColour = m_pVehicle->GetGameEntity()->GetBodyColour3();
m_iWheelTrimColour = m_pVehicle->GetGameEntity()->GetBodyColour4();
m_iBodyColour5 = m_pVehicle->GetGameEntity()->GetBodyColour5();
m_iBodyColour6 = m_pVehicle->GetGameEntity()->GetBodyColour6();
m_fDirtLevel = m_pVehicle->GetGameEntity()->GetBodyDirtLevel();
m_iLivery = m_pVehicle->GetGameEntity()->GetLiveryId();
m_iLivery2 = m_pVehicle->GetGameEntity()->GetLivery2Id();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::UpdateVehicleBody1ColourCallBack()
{
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
m_pVehicle->GetGameEntity()->SetBodyColour1(m_iMainBodyColour);
m_pVehicle->GetGameEntity()->UpdateBodyColourRemapping();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::UpdateVehicleBody2ColourCallBack()
{
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
m_pVehicle->GetGameEntity()->SetBodyColour2(m_iSecondBodyColour);
m_pVehicle->GetGameEntity()->UpdateBodyColourRemapping();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::UpdateVehicleBody3ColourCallBack()
{
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
m_pVehicle->GetGameEntity()->SetBodyColour3(m_iSpecularColour);
m_pVehicle->GetGameEntity()->UpdateBodyColourRemapping();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::UpdateVehicleBody4ColourCallBack()
{
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
m_pVehicle->GetGameEntity()->SetBodyColour4(m_iWheelTrimColour);
m_pVehicle->GetGameEntity()->UpdateBodyColourRemapping();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::UpdateVehicleBody5ColourCallBack()
{
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
m_pVehicle->GetGameEntity()->SetBodyColour5(m_iBodyColour5);
m_pVehicle->GetGameEntity()->UpdateBodyColourRemapping();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::UpdateVehicleBody6ColourCallBack()
{
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
m_pVehicle->GetGameEntity()->SetBodyColour6(m_iBodyColour6);
m_pVehicle->GetGameEntity()->UpdateBodyColourRemapping();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::UpdateVehicleLiveriesCallBack()
{
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
m_pVehicle->GetGameEntity()->SetLiveryId(m_iLivery);
m_pVehicle->GetGameEntity()->SetLivery2Id(m_iLivery2);
m_pVehicle->GetGameEntity()->UpdateBodyColourRemapping();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::UpdateVehicleDirtCallBack()
{
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
m_pVehicle->GetGameEntity()->SetBodyDirtLevel(m_fDirtLevel);
m_pVehicle->GetGameEntity()->UpdateBodyColourRemapping();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::PopulateVehicleExtraList()
{
if(m_pVehicleExtraCombo == NULL)
{
return;
}
//reset the list of vehicle extras we have selected a new vehicle or there is no vehicle
for(int i=0; i<m_pBoneData.GetCount(); i++)
{
m_pBoneData[i]=NULL;
}
m_pBoneData.Reset();
m_pVehicleExtraCombo->UpdateCombo( "Vehicle Extras", &m_iVehicleExtraIndex, m_pBoneData.GetCount()+1, NULL );
m_pVehicleExtraCombo->SetString(0, "none");
if(m_pVehicle)
{
const crSkeletonData* pSkel = NULL;
if(m_pVehicle->GetGameEntity())
{
const crSkeletonData& Skel = m_pVehicle->GetGameEntity()->GetSkeletonData();
pSkel = &Skel;
}
else
{
return;
}
if (pSkel)
{
for(int i = 0; i < MAX_EXTRA_VEHICLE_NAMES-1; i++)
{
const crBoneData* pBoneData = pSkel->FindBoneData(VehicleExtraNames[i]);
if(pBoneData)
{
m_pBoneData.Grow() = pBoneData;
}
}
m_pVehicleExtraCombo->UpdateCombo( "Vehicle Extras", &m_iVehicleExtraIndex, m_pBoneData.GetCount(), NULL );
if (m_pBoneData.GetCount()>0)
{
for(int i=0; i<m_pBoneData.GetCount(); i++)
{
m_pVehicleExtraCombo->SetString(i,m_pBoneData[i]->GetName());
}
}
}
else
{
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::HideVehicleExtraCallBack()
{
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
m_pVehicle->SetBoneToHide(m_pBoneData[m_iVehicleExtraIndex]->GetBoneId(),true);
m_pVehicle->SetGameVehicleExtra(m_pVehicle->GetHiddenBoneList());
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::ShowVehicleExtraCallBack()
{
if(m_pVehicle)
{
if(m_pVehicle->GetGameEntity())
{
m_pVehicle->SetBoneToHide(m_pBoneData[m_iVehicleExtraIndex]->GetBoneId(),false);
m_pVehicle->SetGameVehicleExtra(m_pVehicle->GetHiddenBoneList());
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::HighLightSelectedVehicle()
{
if (m_iVehicleModelIndex > 0)
{
cutsEntity* pCutEntity = CutSceneManager::GetInstance()->GetEntityByObjectId(m_VehicleModelObjectList[m_iVehicleModelIndex - 1]->GetObjectId());
CCutsceneAnimatedVehicleEntity* pVehicleEnt = static_cast<CCutsceneAnimatedVehicleEntity*> (pCutEntity);
if(pVehicleEnt)
{
if(pVehicleEnt->GetGameEntity())
{
char VehicleInfo[32];
if(m_pVehicleSelectCombo)
{
formatf(VehicleInfo, sizeof(VehicleInfo)-1,"Edit: %s ", m_pVehicleSelectCombo->GetString(m_iVehicleModelIndex));
}
Color32 Colour (Color_red);
const Vector3& VehicleMax = m_pVehicle->GetGameEntity()->GetBoundingBoxMax();
const Vector3 vVehiclePosition = VEC3V_TO_VECTOR3(pVehicleEnt->GetGameEntity()->GetTransform().GetPosition());
Vector3 vPos = vVehiclePosition;
vPos.z += VehicleMax.z + 0.5f;
grcDebugDraw::Line(vVehiclePosition,vPos,Colour);
grcDebugDraw::Text(vPos, Colour, VehicleInfo );
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::DisplaySelectedVehicleInfo()
{
if( m_bDisplayVehicleVariation)
{
if (m_iVehicleModelIndex > 0)
{
cutsEntity* pCutEntity = CutSceneManager::GetInstance()->GetEntityByObjectId(m_VehicleModelObjectList[m_iVehicleModelIndex - 1]->GetObjectId());
CCutsceneAnimatedVehicleEntity* pVehicleEnt = static_cast<CCutsceneAnimatedVehicleEntity*> (pCutEntity);
if (pVehicleEnt == NULL)
{
return;
}
Color32 Colour (Color_red);
atArray<s32> RemovedComponenets;
if(pVehicleEnt->GetGameEntity())
{
RemovedComponenets = pVehicleEnt->GetHiddenBoneList();
}
else
{
return;
}
grcDebugDraw::AddDebugOutput(Colour , m_VehicleModelObjectList[m_iVehicleModelIndex -1]->GetDisplayName().c_str());
grcDebugDraw::AddDebugOutput("Main Body Colour: %d", m_iMainBodyColour);
grcDebugDraw::AddDebugOutput("Secondary Body Colour: %d", m_iSecondBodyColour);
grcDebugDraw::AddDebugOutput("Specular Colour: %d", m_iSpecularColour);
grcDebugDraw::AddDebugOutput("Wheel Trim Colour: %d", m_iWheelTrimColour);
grcDebugDraw::AddDebugOutput("Body Colour 5: %d", m_iBodyColour5);
grcDebugDraw::AddDebugOutput("Body Colour 6: %d", m_iBodyColour6);
grcDebugDraw::AddDebugOutput("Dirt: %f", m_fDirtLevel);
if(m_iLivery != -1)
{
grcDebugDraw::AddDebugOutput(Colour, "Livery: %d", m_iLivery);
}
else
{
grcDebugDraw::AddDebugOutput("Livery: %d", m_iLivery);
}
if(m_iLivery2 != -1)
{
grcDebugDraw::AddDebugOutput(Colour, "Livery2: %d", m_iLivery2);
}
else
{
grcDebugDraw::AddDebugOutput("Livery2: %d", m_iLivery2);
}
for(int i = 0; i < m_pBoneData.GetCount(); i++)
{
bool bComponentRemoved = false;
for(int j=0; j<RemovedComponenets.GetCount(); j++)
{
if(m_pBoneData[i]->GetBoneId() == RemovedComponenets[j])
{
grcDebugDraw::AddDebugOutput(Colour, "%s (%d)", m_pBoneData[i]->GetName(),m_pBoneData[i]->GetBoneId());
bComponentRemoved = true;
}
}
if (bComponentRemoved == false)
{
grcDebugDraw::AddDebugOutput("%s (%d)", m_pBoneData[i]->GetName(),m_pBoneData[i]->GetBoneId());
}
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::PopulateVehicleVariationEventList(const cutfObject* pObject)
{
if (m_pVehicleVariationEventCombo == NULL)
{
return;
}
//Nothing selected
if(!pObject)
{
m_VehicleVarEventId = 0;
m_pVehicleVariationEventCombo->UpdateCombo( "Vehicle var events", &m_VehicleVarEventId, 1, NULL );
m_pVehicleVariationEventCombo->SetString( 0 , "none");
return;
}
atArray<cutfEvent *> AllEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), AllEventList );
atArray<cutfEvent *>EventList;
for(int i =0; i < AllEventList.GetCount(); i++)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( AllEventList[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_VEHICLE_VARIATION_EVENT_ARGS_TYPE)
{
EventList.PushAndGrow(AllEventList[i]);
}
}
//look to edit a current event
if (EventList.GetCount() == 0)
{
m_pVehicleVariationEventCombo->UpdateCombo( "Vehicle var events", &m_VehicleVarEventId, 1, NULL );
m_pVehicleVariationEventCombo->SetString( 0 , "none");
}
else
{
if (EventList.GetCount() > 0)
{
m_pVehicleVariationEventCombo->UpdateCombo( "Ped var events", &m_VehicleVarEventId, EventList.GetCount(), NULL );
//Clear the list of variations, need to repopulate.
for (int i=0; i < m_VehicleCutSceneVariations.GetCount(); i++)
{
m_VehicleCutSceneVariations[i] = NULL;
}
m_VehicleCutSceneVariations.Reset();
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if (EventList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_VEHICLE_VARIATION_EVENT_ARGS_TYPE)
{
char EventInfo[64];
cutfVehicleVariationEventArgs* pObjectVar = static_cast<cutfVehicleVariationEventArgs*>(pEventArgs);
s32 FrameNumber = static_cast<s32>(EventList[i]->GetTime() * CUTSCENE_FPS);
formatf(EventInfo, sizeof(EventInfo)-1,"Event %d: Frame: %d , time: %f , BodyCol: %d, 2ndCol: %d, SpecCol: %d, WheelCol: %d, BodyCol5: %d, BodyCol6: %d, LiveryId: %d, Dirt: %f ", i , FrameNumber, EventList[i]->GetTime(),
pObjectVar->GetBodyColour(), pObjectVar->GetSecondaryBodyColour(), pObjectVar->GetSpecularBodyColour(), pObjectVar->GetWheelTrimColour(), pObjectVar->GetBodyColour5(), pObjectVar->GetBodyColour6(), pObjectVar->GetLiveryId(), pObjectVar->GetDirtLevel());
m_pVehicleVariationEventCombo->SetString( i, EventInfo );
//Store a list of pointers to our objects
m_VehicleCutSceneVariations.PushAndGrow(EventList[i]);
}
}
}
}
}
};
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::SaveVehicleVariationEvent(const cutfObject* pObject)
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "Save Ped Variation: No cutf file object loaded cannot save"))
{
return;
}
if ( pObject == NULL )
{
return;
}
RAGE_TRACK( CutSceneManager_SaveVehicleVariation );
atArray<cutfEvent *> EventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), EventList );
bool bAddNewEvent = true;
//look to edit a current event
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if (EventList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
{
if(EventList[i]->GetTime() == CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset() )
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_VEHICLE_VARIATION_EVENT_ARGS_TYPE)
{
//Don't add new event for a component that has the same id and time.
cutfVehicleVariationEventArgs* pObjectVar = static_cast<cutfVehicleVariationEventArgs*>(pEventArgs);
pObjectVar->SetBodyColour(m_iMainBodyColour);
pObjectVar->SetSecondaryBodyColour(m_iSecondBodyColour);
pObjectVar->SetSpecularColour(m_iSpecularColour);
pObjectVar->SetWheelTrimColour(m_iWheelTrimColour);
pObjectVar->SetBodyColour5(m_iBodyColour5);
pObjectVar->SetBodyColour6(m_iBodyColour6);
pObjectVar->SetLiveryId(m_iLivery);
pObjectVar->SetLivery2Id(m_iLivery2);
pObjectVar->SetDirtLevel(m_fDirtLevel);
bAddNewEvent = false;
}
}
}
}
if(bAddNewEvent)
{
cutfEventArgs *pEventArgs = rage_new cutfVehicleVariationEventArgs( pObject->GetObjectId(), m_iMainBodyColour, m_iSecondBodyColour, m_iSpecularColour, m_iWheelTrimColour, m_iBodyColour5, m_iBodyColour6, m_iLivery, m_iLivery2, m_fDirtLevel );
#if CUTSCENE_EXPORT_EVENTS_WITH_ZERO_BASE_TIME
float ftime = CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset();
#else
float ftime =CutSceneManager::GetInstance()-> GetCutSceneCurrentTime();
#endif
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), ftime, CUTSCENE_SET_VARIATION_EVENT, pEventArgs ) );
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::SaveVehicleExtraEvent(const cutfObject* pObject)
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "Save Ped Variation: No cutf file object loaded cannot save"))
{
return;
}
if ( pObject == NULL )
{
return;
}
RAGE_TRACK( CutSceneManager_SaveVehicleVariation );
atArray<cutfEvent *> EventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), EventList );
bool bAddNewEvent = true;
atArray<s32> BoneToHideList;
//populate the current bone list
if(m_pVehicle->GetGameEntity())
{
BoneToHideList = m_pVehicle->GetHiddenBoneList();
}
//look to edit a current event
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if (EventList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
{
if(EventList[i]->GetTime() == CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset() )
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_VEHICLE_EXTRA_EVENT_ARGS_TYPE)
{
//Overwrite the existing event with the new info
cutfVehicleExtraEventArgs* pObjectVar = static_cast<cutfVehicleExtraEventArgs*>(pEventArgs);
//if there is no extra to be removed create a single entry of zero
if(BoneToHideList.GetCount() == 0)
{
BoneToHideList.PushAndGrow(0);
}
pObjectVar->SetBoneIdList(BoneToHideList);
bAddNewEvent = false;
}
}
}
}
if(bAddNewEvent)
{
//if there is no extra to be removed create a single entry of zero
if(BoneToHideList.GetCount() == 0)
{
BoneToHideList.PushAndGrow(0);
}
cutfEventArgs *pEventArgs = rage_new cutfVehicleExtraEventArgs( pObject->GetObjectId(), BoneToHideList);
#if CUTSCENE_EXPORT_EVENTS_WITH_ZERO_BASE_TIME
float ftime = CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset();
#else
float ftime = CutSceneManager::GetInstance()->GetCutSceneCurrentTime();
#endif
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), ftime, CUTSCENE_SET_VARIATION_EVENT, pEventArgs ) );
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::BankSaveVehicleVariationEventCallBack()
{
if (m_VehicleModelObjectList.GetCount() > 0 && m_iVehicleModelIndex <= m_VehicleModelObjectList.GetCount() && m_iVehicleModelIndex > 0 )
{
const cutfObject* pObject = m_VehicleModelObjectList[m_iVehicleModelIndex - 1];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
SaveVehicleVariationEvent(pObject);
//update the combo box of ped variation events
PopulateVehicleVariationEventList(pObject);
//Save the changes out to the cuttune file.
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::BankSaveVehicleExtraCallBack()
{
if (m_VehicleModelObjectList.GetCount() > 0 && m_iVehicleModelIndex <= m_VehicleModelObjectList.GetCount() && m_iVehicleModelIndex > 0 )
{
const cutfObject* pObject = m_VehicleModelObjectList[m_iVehicleModelIndex - 1];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
SaveVehicleExtraEvent(pObject);
//update the combo box of ped variation events
PopulateVehicleExtraEventList(pObject);
//Save the changes out to the cuttune file.
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Populate the list of current vehicle extras
void CCutSceneDebugManager::PopulateVehicleExtraEventList(const cutfObject* pObject)
{
if (m_pVehicleExtraEventCombo == NULL)
{
return;
}
//Nothing selected
if(!pObject)
{
m_pVehicleExtraEventCombo->UpdateCombo( "Vehicle Extra events", &m_VehicleExtraEventId, 1, NULL );
m_pVehicleExtraEventCombo->SetString( 0 , "none");
return;
}
//Repopulate the list only with events that have extra argument types
atArray<cutfEvent *> AllEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), AllEventList );
atArray<cutfEvent *>EventList;
for(int i =0; i < AllEventList.GetCount(); i++)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( AllEventList[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_VEHICLE_EXTRA_EVENT_ARGS_TYPE)
{
EventList.PushAndGrow(AllEventList[i]);
}
}
//there are no events of the extra type
if (EventList.GetCount() == 0)
{
m_pVehicleExtraEventCombo->UpdateCombo( "Vehicle Extra events", &m_VehicleExtraEventId, 1, NULL );
m_pVehicleExtraEventCombo->SetString( 0 , "none");
}
else
{
if (EventList.GetCount() > 0)
{
m_pVehicleExtraEventCombo->UpdateCombo( "Vehicle Extra events", &m_VehicleExtraEventId, EventList.GetCount(), NULL );
//Clear the list of variations, need to repopulate.
for (int i=0; i < m_VehicleExtras.GetCount(); i++)
{
m_VehicleExtras[i] = NULL;
}
m_VehicleExtras.Reset();
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if (EventList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_VEHICLE_EXTRA_EVENT_ARGS_TYPE)
{
char EventInfo[128];
char BoneName[16];
cutfVehicleExtraEventArgs* pObjectVar = static_cast<cutfVehicleExtraEventArgs*>(pEventArgs);
const atArray<s32> &ibones = pObjectVar->GetBoneIdList();
s32 FrameNumber = static_cast<s32>(EventList[i]->GetTime() * CUTSCENE_FPS);
formatf(EventInfo, sizeof(EventInfo)-1, "Event: %d , Frame: %d , Extras Hidden: ", i, FrameNumber);
for(int j =0; j < ibones.GetCount(); j++)
{
//Special case where we are reactivating vehicle extras
if(ibones[j] == 0)
{
formatf(EventInfo, sizeof(EventInfo)-1, "Event: %d , Frame: %d , No Extras Hidden", i, FrameNumber);
}
else
{
formatf(BoneName, sizeof(BoneName)-1, " %s, " , GetExtraBoneNumberFromName(ibones[j]) );
strcat(EventInfo, BoneName);
}
}
m_pVehicleExtraEventCombo->SetString( i, EventInfo );
//Store a list of pointers to our objects
m_VehicleExtras.PushAndGrow(EventList[i]);
}
}
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
//grab the number at the end of the extra name to be able to display the extra just as a number
const char* CCutSceneDebugManager::GetExtraBoneNumberFromName(s32 iBone)
{
//Get a pointer to the dynamic only interested in the skeleton
CDynamicEntity* pEntity = NULL;
if(m_pVehicle->GetGameEntity())
{
pEntity = static_cast<CDynamicEntity*>(m_pVehicle->GetGameEntity());
}
if(pEntity)
{
const crSkeletonData& Skel = pEntity->GetSkeletonData();
int iBoneIndex;
if (Skel.ConvertBoneIdToIndex(static_cast<u16>(iBone), iBoneIndex))
{
const crBoneData* pBone = Skel.GetBoneData(iBoneIndex);
const char* pName = pBone->GetName();
const char* number = strrchr(pName, '_');
return number+1;
}
}
return "";
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::BankDeleteVehicleVariationCallBack()
{
if (m_VehicleCutSceneVariations.GetCount() > 0)
{
if(m_VehicleCutSceneVariations[m_VehicleVarEventId])
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent(m_VehicleCutSceneVariations[m_VehicleVarEventId]);
PopulateVehicleVariationEventList(m_VehicleModelObjectList[m_iVehicleModelIndex - 1]);
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::BankDeleteVehicleExtrasCallBack()
{
if (m_VehicleExtras.GetCount() > 0)
{
if(m_VehicleExtras[m_VehicleExtraEventId])
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent(m_VehicleExtras[m_VehicleExtraEventId]);
PopulateVehicleExtraEventList(m_VehicleModelObjectList[m_iVehicleModelIndex - 1]);
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::BankApplyVehicleDamageEventCallBack()
{
if (m_pVehicle)
{
Vector3 vLocal = m_vVehicleDamagerPos - VEC3V_TO_VECTOR3(m_pVehicle->GetGameEntity()->GetTransform().GetPosition());
Matrix34 vehiclemat = MAT34V_TO_MATRIX34(m_pVehicle->GetGameEntity()->GetMatrix());
vehiclemat.UnTransform3x3(vLocal); //convert into vehicle space
m_vLocalDamage = vLocal;
m_pVehicle->SetVehicleDamage(vLocal, m_fDamageValue, m_fDerformation, true );
}
}
void CCutSceneDebugManager::BankSaveVehicleDamageEvent()
{
if (m_VehicleModelObjectList.GetCount() > 0 && m_iVehicleModelIndex <= m_VehicleModelObjectList.GetCount() && m_iVehicleModelIndex > 0 )
{
const cutfObject* pObject = m_VehicleModelObjectList[m_iVehicleModelIndex - 1];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
parAttributeList DamageEventsAttributes;
DamageEventsAttributes.AddAttribute("vPos.x", m_vLocalDamage.x);
DamageEventsAttributes.AddAttribute("vPos.y", m_vLocalDamage.y);
DamageEventsAttributes.AddAttribute("vPos.z", m_vLocalDamage.z);
DamageEventsAttributes.AddAttribute("fDamage", m_fDamageValue);
DamageEventsAttributes.AddAttribute("fDeform", m_fDerformation);
SaveVehicleDamageEvent(pObject, DamageEventsAttributes);
//update the combo box of ped variation events
PopulateVehicleDamageEventList(pObject);
//Save the changes out to the cuttune file.
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
void CCutSceneDebugManager::SaveVehicleDamageEvent(const cutfObject* pObject, parAttributeList &Attributes)
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "Save Ped Variation: No cutf file object loaded cannot save"))
{
return;
}
if ( pObject == NULL )
{
return;
}
RAGE_TRACK( CutSceneManager_SaveVehicleDamageEventn );
atArray<cutfEvent *> EventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), EventList );
bool bAddNewEvent = true;
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if (EventList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
{
if(EventList[i]->GetTime() == CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset() )
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_NAME_EVENT_ARGS_TYPE)
{
}
}
}
}
if(bAddNewEvent)
{
cutfEventArgs *pEventArgs = rage_new cutfNameEventArgs("Damage Event", Attributes);
#if CUTSCENE_EXPORT_EVENTS_WITH_ZERO_BASE_TIME
float ftime = CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset();
#else
float ftime =CutSceneManager::GetInstance()-> GetCutSceneCurrentTime();
#endif
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), ftime, CutSceneCustomEvents::CUTSCENE_SET_VEHICLE_DAMAGE_EVENT, pEventArgs ) );
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
}
}
void CCutSceneDebugManager::BankDeleteVehicleDamageEvent()
{
if (m_VehicleDamageEvents.GetCount() > 0)
{
if(m_VehicleDamageEvents[m_iVehicleDamageIndex])
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent(m_VehicleDamageEvents[m_iVehicleDamageIndex]);
PopulateVehicleDamageEventList(m_VehicleModelObjectList[m_iVehicleModelIndex - 1]);
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
void CCutSceneDebugManager::PopulateVehicleDamageEventList(const cutfObject* pObject)
{
if (m_pVehicleDamageEventCombo == NULL)
{
return;
}
//Nothing selected
if(!pObject)
{
m_pVehicleDamageEventCombo->UpdateCombo( "Vehicle Damage events", &m_iVehicleDamageIndex, 1, NULL );
m_pVehicleDamageEventCombo->SetString( 0 , "none");
return;
}
//Repopulate the list only with events that have extra argument types
atArray<cutfEvent *> AllEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), AllEventList );
atArray<cutfEvent *>EventList;
for(int i =0; i < AllEventList.GetCount(); i++)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( AllEventList[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_NAME_EVENT_ARGS_TYPE && AllEventList[i]->GetEventId() == CutSceneCustomEvents::CUTSCENE_SET_VEHICLE_DAMAGE_EVENT)
{
EventList.PushAndGrow(AllEventList[i]);
}
}
//there are no events of the extra type
if (EventList.GetCount() == 0)
{
m_pVehicleDamageEventCombo->UpdateCombo( "Vehicle Damage events", &m_iVehicleDamageIndex, 1, NULL );
m_pVehicleDamageEventCombo->SetString( 0 , "none");
}
else
{
if (EventList.GetCount() > 0)
{
m_pVehicleDamageEventCombo->UpdateCombo( "Vehicle Damage events", &m_iVehicleDamageIndex, EventList.GetCount(), NULL );
//Clear the list of variations, need to repopulate.
for (int i=0; i < m_VehicleDamageEvents.GetCount(); i++)
{
m_VehicleDamageEvents[i] = NULL;
}
m_VehicleDamageEvents.Reset();
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if (EventList[i]->GetEventId() == CutSceneCustomEvents::CUTSCENE_SET_VEHICLE_DAMAGE_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_NAME_EVENT_ARGS_TYPE)
{
char EventInfo[128];
cutfNameEventArgs* pObjectVar = static_cast<cutfNameEventArgs*>(pEventArgs);
s32 FrameNumber = static_cast<s32>(EventList[i]->GetTime() * CUTSCENE_FPS);
Vector3 pos(VEC3_ZERO);
float Damage = 0.0f;
float Deform = 0.0f;
if(pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.x"))
{
pos.x = pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.x")->FindFloatValue();
}
if(pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.y"))
{
pos.y = pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.y")->FindFloatValue();
}
if(pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.z"))
{
pos.z = pObjectVar->GetAttributeList().FindAttributeAnyCase("vPos.z")->FindFloatValue();
}
if(pObjectVar->GetAttributeList().FindAttributeAnyCase("fDamage"))
{
Damage = pObjectVar->GetAttributeList().FindAttributeAnyCase("fDamage")->FindFloatValue();
}
if (pObjectVar->GetAttributeList().FindAttributeAnyCase("fDeform"))
{
Deform = pObjectVar->GetAttributeList().FindAttributeAnyCase("fDeform")->FindFloatValue();
}
formatf(EventInfo, sizeof(EventInfo)-1, "(%d) %s( <<%f,%f,%f,>>,%f,,%f)",FrameNumber,
pObjectVar->GetName().GetCStr(),pos.x,pos.y,pos.z, Damage, Deform);
m_pVehicleDamageEventCombo->SetString( i, EventInfo );
//Store a list of pointers to our objects
m_VehicleDamageEvents.PushAndGrow(EventList[i]);
}
}
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::GetSelectedPedEntityCallBack()
{
if (m_iPedModelIndex > 0)
{
cutsEntity* pCutEntity = CutSceneManager::GetInstance()->GetEntityByObjectId(CutSceneManager::GetInstance()->m_pedModelObjectList[m_iPedModelIndex - 1]->GetObjectId());
CCutsceneAnimatedActorEntity* pActorEnt = static_cast<CCutsceneAnimatedActorEntity*> (pCutEntity);
if(pActorEnt)
{
m_pActorEntity = pActorEnt;
UpdateCutSceneVarComponentCB();
UpdateCutScenePropComponentCB();
PopulatePedVariationEventList(CutSceneManager::GetInstance()->m_pedModelObjectList[m_iPedModelIndex - 1]);
}
}
else
{
PopulatePedVariationEventList(NULL);
m_pActorEntity = NULL;
}
}
void CCutSceneDebugManager::GetSelectedPropEntityCallBack()
{
if (m_iPropModelIndex > 0)
{
cutsEntity* pCutEntity = CutSceneManager::GetInstance()->GetEntityByObjectId(m_PropList[m_iPropModelIndex - 1]->GetObjectId());
CCutSceneAnimatedPropEntity* pPropEnt = static_cast<CCutSceneAnimatedPropEntity*> (pCutEntity);
if(pPropEnt)
{
m_pPropEntity = pPropEnt;
}
}
else
{
m_pPropEntity = NULL;
}
}
void CCutSceneDebugManager::GetSelectedPtfxEntityCallBack()
{
if (m_iPtfxIndex > 0)
{
cutsEntity* pCutEntity = CutSceneManager::GetInstance()->GetEntityByObjectId(m_PtfxList[m_iPtfxIndex - 1]->GetObjectId());
CCutSceneParticleEffectsEntity* pPtfxEnt = static_cast<CCutSceneParticleEffectsEntity*> (pCutEntity);
if(pPtfxEnt)
{
m_PtfxEnt = pPtfxEnt;
CCutSceneParticleEffect* pEffect = pPtfxEnt->GetParticleEffect();
if(pEffect)
{
m_Ptfx = pEffect;
m_vPTFXPos = m_Ptfx->GetEffectPosition();
m_Ptfx->SetEffectOverridePosition(m_vPTFXPos);
m_vPTFXRot = m_Ptfx->GetEffectRotation() * RtoD;
m_Ptfx->SetEffectOverrideRotation(m_vPTFXRot* DtoR);
m_OverridePtfx = m_Ptfx->CanOverrideEffect();
}
else
{
m_OverridePtfx = false;
}
}
}
else
{
m_PtfxEnt = NULL;
m_Ptfx = NULL;
}
}
void CCutSceneDebugManager::SetCanOverridePtfx()
{
if(m_Ptfx)
{
m_Ptfx->SetCanOverrideEffect(m_OverridePtfx);
}
else
{
m_OverridePtfx = false;
}
}
void CCutSceneDebugManager::UpdatePtfxPos()
{
if(m_Ptfx && m_Ptfx->CanOverrideEffect())
{
m_Ptfx->SetEffectOverridePosition(m_vPTFXPos);
}
}
void CCutSceneDebugManager::UpdatePtfxRot()
{
if(m_Ptfx && m_Ptfx->CanOverrideEffect())
{
m_Ptfx->SetEffectOverrideRotation(m_vPTFXRot * DtoR);
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Update the peds current variation
void CCutSceneDebugManager::UpdateCutSceneCompVarInfoIdxCB()
{
UpdateCutSceneVarComponentCB();
}
void CCutSceneDebugManager::UpdateCutSceneVarComponentCB()
{
if (m_pActorEntity)
{
CPedModelInfo* pedModelInfo = NULL;
if (m_pActorEntity->GetGameEntity())
{
m_varDrawableId = CPedVariationPack::GetCompVar(m_pActorEntity->GetGameEntity(), static_cast<ePedVarComp>(m_varComponentId));
pedModelInfo = m_pActorEntity->GetGameEntity()->GetPedModelInfo();
}
else
{
m_varDrawableId = 0;
}
if (pedModelInfo)
{
m_maxDrawables = pedModelInfo->GetVarInfo()->GetMaxNumDrawbls(static_cast<ePedVarComp>(m_varComponentId))-1;
UpdateCutSceneVarDrawblCB();
}
}
}
void CCutSceneDebugManager::UpdateCutScenePropVarInfoIdxCB()
{
UpdateCutScenePropComponentCB();
}
void CCutSceneDebugManager::UpdateCutScenePropComponentCB()
{
if (m_pActorEntity && m_pActorEntity->GetGameEntity())
{
ASSERT_ONLY(CPedModelInfo* pModelInfo = static_cast<CPedModelInfo*>(m_pActorEntity->GetGameEntity()->GetBaseModelInfo());)
Assert(pModelInfo);
if (m_pActorEntity->GetGameEntity())
{
m_PropDrawableId = CPedPropsMgr::GetPedPropIdx(m_pActorEntity->GetGameEntity(), (eAnchorPoints)m_PropSlotId);
}
m_maxPropDrawableId = CPedPropsMgr::GetMaxNumProps(m_pActorEntity->GetGameEntity(), (eAnchorPoints)m_PropSlotId)-1;
if (m_pPropDrawablIdSlider != NULL)
{
m_pPropDrawablIdSlider->SetRange(-1.0f, (float)(m_maxPropDrawableId));
}
}
}
void CCutSceneDebugManager::UpdateCutScenePropDrawblCB()
{
if (m_pActorEntity && m_pActorEntity->GetGameEntity())
{
if (m_PropDrawableId > m_maxPropDrawableId) {
m_PropDrawableId = m_maxPropDrawableId;
}
m_PropTextureId = 0; // reset texture to default when changing prop
UpdateCutScenePropTexCB();
//update the name of the prop
if (m_PropDrawableId == PED_PROP_NONE) {
//sprintf(propName, "No available prop");
CPedPropsMgr::ClearPedProp(m_pActorEntity->GetGameEntity(), (eAnchorPoints)m_PropSlotId);
} else {
//sprintf(propName,"%s_%03d",propSlotNames[m_varPropSlot],m_maxPropDrawableId);
}
m_maxPropTextureId = CPedPropsMgr::GetMaxNumPropsTex(m_pActorEntity->GetGameEntity(), (eAnchorPoints)m_PropSlotId, m_PropTextureId)-1;
if (m_pPropTexIdSlider != NULL)
{
m_pPropTexIdSlider->SetRange(0.0f, (float)(m_maxPropTextureId));
}
}
}
void CCutSceneDebugManager::UpdateCutScenePropTexCB()
{
if (m_pActorEntity && m_pActorEntity->GetGameEntity())
{
if (m_pActorEntity->GetGameEntity() && m_PropTextureId>=0 && m_PropDrawableId>=0)
{
// set the prop and texture to the current settings
CPedPropsMgr::SetPedProp(m_pActorEntity->GetGameEntity(), (eAnchorPoints)m_PropSlotId, m_PropDrawableId, m_PropTextureId, ANCHOR_NONE, NULL, NULL);
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
//updates the peds current drawable
void CCutSceneDebugManager::UpdateCutSceneVarDrawblCB(void)
{
if (m_varDrawableId > m_maxDrawables)
{
m_varDrawableId = m_maxDrawables;
}
if (m_pActorEntity)
{
CPedModelInfo* pedModelInfo = NULL;
if (m_pActorEntity->GetGameEntity())
{
m_varTextureId = CPedVariationPack::GetTexVar(m_pActorEntity->GetGameEntity(), static_cast<ePedVarComp>(m_varComponentId));
// want to pick up current palette ID from the current debug ped (for this drawable)
m_varPalette = CPedVariationPack::GetPaletteVar(m_pActorEntity->GetGameEntity(), static_cast<ePedVarComp>(m_varComponentId));
pedModelInfo = m_pActorEntity->GetGameEntity()->GetPedModelInfo();
}
else
{
m_varTextureId = 0;
m_varPalette = 0;
}
if(pedModelInfo)
{
m_maxTextures = pedModelInfo->GetVarInfo()->GetMaxNumTex(static_cast<ePedVarComp>(m_varComponentId), m_varDrawableId)-1;
UpdateCutSceneVarTexCB();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Update the texture for the current debug ped.
void CCutSceneDebugManager::UpdateCutSceneVarTexCB(void)
{
if (m_pVarDrawablIdSlider == NULL || m_pVarTexIdSlider == NULL)
{
return;
}
u32 maxVariations = 0;
char texVariation = 'a' + static_cast<char>(m_varTextureId);
char drawblRaceType = 'U';
u32 raceId = 0;
if (m_varTextureId > m_maxTextures){
m_varTextureId = m_maxTextures;
}
//get the modelInfo associated with this ped ID
if (m_pActorEntity)
{
CPedModelInfo* pedModelInfo = NULL;
if (m_pActorEntity->GetGameEntity())
{
pedModelInfo = m_pActorEntity->GetGameEntity()->GetPedModelInfo();
}
if(pedModelInfo)
{
if (pedModelInfo->GetVarInfo()->IsValidDrawbl(m_varComponentId,m_varDrawableId))
{
//pedInfoIndex = CModelInfo::GetModelIdFromName(pedModelInfo.GetModelName()).GetModelIndex();
raceId = pedModelInfo->GetVarInfo()->GetRaceType(m_varComponentId, m_varDrawableId, m_varTextureId, pedModelInfo);
if (pedModelInfo->GetVarInfo()->HasRaceTextures(m_varComponentId, m_varDrawableId)){
drawblRaceType = 'R';
}
if (pedModelInfo->GetVarInfo()->IsMatchComponent(m_varComponentId, m_varDrawableId, pedModelInfo)){
drawblRaceType = 'M';
}
// update the texture and drawable names
sprintf(m_varTexName,"%s_diff_%03d_%c_%s", varSlotNames[m_varComponentId], m_varDrawableId, texVariation, raceTypeNames[raceId]);
sprintf(m_varDrawablName,"%s_%03d_%c",varSlotNames[m_varComponentId],m_varDrawableId, drawblRaceType);
// update the max values in the sliders
maxVariations = pedModelInfo->GetVarInfo()->GetMaxNumDrawbls(static_cast<ePedVarComp>(m_varComponentId));
m_pVarDrawablIdSlider->SetRange(0.0f, float(maxVariations-1));
m_pVarDrawablIdSlider->SetStep(1);
maxVariations = pedModelInfo->GetVarInfo()->GetMaxNumTex(static_cast<ePedVarComp>(m_varComponentId), m_varDrawableId);
m_pVarTexIdSlider->SetRange(0.0f, float(maxVariations-1));
m_pVarTexIdSlider->SetStep(1);
//set the updated values for this ped (if it is the same type as being edited in the widget!)
if (m_pActorEntity->GetGameEntity())
{
if(!CPedVariationPack::HasVariation(m_pActorEntity->GetGameEntity(), static_cast<ePedVarComp>(m_varComponentId), m_varDrawableId, 0, m_varTextureId))
{
#if !__NO_OUTPUT
bool ReactivateLogging = false;
if(m_pActorEntity->GetGameEntity()->m_LogVariationCalls)
{
m_pActorEntity->GetGameEntity()->m_LogVariationCalls = false;
ReactivateLogging = true;
}
#endif //!__NO_OUTPUT
m_pActorEntity->GetGameEntity()->SetVariation(static_cast<ePedVarComp>(m_varComponentId), m_varDrawableId, 0, m_varTextureId, 0, 0, false);
#if !__NO_OUTPUT
if(ReactivateLogging)
{
m_pActorEntity->GetGameEntity()->m_LogVariationCalls = true;
}
#endif //!__NO_OUTPUT
}
}
}
else
{
sprintf(m_varTexName,"Invalid Texture");
sprintf(m_varDrawablName,"Invalid Drawable");
//pVarDrawablIdSlider->SetRange(0.0f, 0.0f);
//pVarTexIdSlider->SetRange(0.0f, 0.0f);
}
}
}
//UpdateVarPaletteCB();
}
/////////////////////////////////////////////////////////////////////////////////////
//Render the peds variation to the screen
void CCutSceneDebugManager::DisplayPedVariation()
{
if (m_pActorEntity)
{
Color32 Colour (Color_red);
if (m_pActorEntity->GetCutfObject())
{
grcDebugDraw::AddDebugOutput(Colour , m_pActorEntity->GetCutfObject()->GetDisplayName().c_str());
}
const cutfObject* pObject = m_pActorEntity->GetCutfObject();
const cutfModelObject* pModel = NULL;
if(pObject->GetType() == CUTSCENE_MODEL_OBJECT_TYPE)
{
pModel = static_cast<const cutfModelObject*>(pObject);
}
if(m_pActorEntity->GetGameEntity())
{
const Vector3 vGameEntityPosition = VEC3V_TO_VECTOR3(m_pActorEntity->GetGameEntity()->GetTransform().GetPosition());
Vector3 vPos = vGameEntityPosition;
vPos.z += 1.0f;
grcDebugDraw::Line(vGameEntityPosition,vPos,Colour);
char text [64];
if(pModel)
{
grcDebugDraw::Text(vPos, Colour, formatf(text, "Edit: %s (Scene Handle:%s)", m_pActorEntity->GetCutfObject()->GetDisplayName().c_str(), pModel->GetHandle().GetCStr()));
}
else
{
grcDebugDraw::Text(vPos, Colour, formatf(text, "Edit: %s", m_pActorEntity->GetCutfObject()->GetDisplayName().c_str()));
}
}
for(int index=0; index < PV_MAX_COMP ; index++)
{
int DrawableId = 0;
int TextureId = 0;
char text [24];
if(m_pActorEntity->GetGameEntity())
{
DrawableId = CPedVariationPack::GetCompVar(m_pActorEntity->GetGameEntity(), static_cast<ePedVarComp>(varSlotEnums[index]));
TextureId = CPedVariationPack::GetTexVar(m_pActorEntity->GetGameEntity(), static_cast<ePedVarComp>(varSlotEnums[index]));
}
strncpy(text, varSlotNames[index], 24 );
strncat(text, " D: %i, T: %i", 24);
if(DrawableId > 0 || TextureId > 0 )
{
grcDebugDraw::AddDebugOutput(Colour, text, DrawableId, TextureId );
}
else
{
grcDebugDraw::AddDebugOutput(text, DrawableId, TextureId );
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::BankSavePedVariationEventCallBack()
{
if (CutSceneManager::GetInstance()->m_pedModelObjectList.GetCount() > 0 && m_iPedModelIndex <= CutSceneManager::GetInstance()->m_pedModelObjectList.GetCount() && m_iPedModelIndex > 0 )
{
if ( m_varDrawableId > -1 && m_varTextureId >-1)
{
const cutfObject* pObject = CutSceneManager::GetInstance()->m_pedModelObjectList[m_iPedModelIndex - 1];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
SavePedVariationEvent(pObject);
//update the combo box of ped variation events
PopulatePedVariationEventList(pObject);
//Save the changes out to the cuttune file.
CutSceneManager::GetInstance()->SaveCutfile();
}
}
else
{
cutsceneWarningf("Save failed. Invalid drawable and/or texture in cutscene variation event.");
}
}
}
void CCutSceneDebugManager::BankSavePedPropVariationEventCallBack()
{
if (CutSceneManager::GetInstance()->m_pedModelObjectList.GetCount() > 0 && m_iPedModelIndex <= CutSceneManager::GetInstance()->m_pedModelObjectList.GetCount() && m_iPedModelIndex > 0 )
{
const cutfObject* pObject = CutSceneManager::GetInstance()->m_pedModelObjectList[m_iPedModelIndex - 1];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
SavePedPropVariationEvent(pObject);
//update the combo box of ped variation events
PopulatePedVariationEventList(pObject);
//Save the changes out to the cuttune file.
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Add the ped variation event to the event list.
void CCutSceneDebugManager::SavePedVariationEvent(const cutfObject* pObject)
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "Save Ped Variation: No cutf file object loaded cannot save"))
{
return;
}
if ( pObject == NULL )
{
return;
}
RAGE_TRACK( CutSceneManager_SavePedVariation );
atArray<cutfEvent *> PedEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), PedEventList );
bool bAddNewEvent = true;
//look to edit a current event
for ( int i = 0; i < PedEventList.GetCount(); ++i )
{
if (PedEventList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
{
if(PedEventList[i]->GetTime() == CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset())
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( PedEventList[i]->GetEventArgs() );
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_ACTOR_VARIATION_EVENT_ARGS_TYPE)
{
//Don't add new event for a component that has the same id and time.
cutfObjectVariationEventArgs* pObjectVar = static_cast<cutfObjectVariationEventArgs*>(pEventArgs);
if (pObjectVar->GetComponent() == m_varComponentId )
{
pObjectVar->SetDrawable(m_varDrawableId);
pObjectVar->SetTexture(m_varTextureId);
bAddNewEvent = false;
}
}
}
}
}
if(bAddNewEvent)
{
cutfEventArgs *pEventArgs = rage_new cutfObjectVariationEventArgs( pObject->GetObjectId(), m_varComponentId, m_varDrawableId, m_varTextureId );
#if CUTSCENE_EXPORT_EVENTS_WITH_ZERO_BASE_TIME
float ftime = CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset();
#else
float ftime = CutSceneManager::GetInstance()->GetCutSceneCurrentTime();
#endif
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), ftime, CUTSCENE_SET_VARIATION_EVENT, pEventArgs ) );
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Add the ped variation event to the event list.
void CCutSceneDebugManager::SavePedPropVariationEvent(const cutfObject* pObject)
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "Save Ped Variation: No cutf file object loaded cannot save"))
{
return;
}
if ( pObject == NULL )
{
return;
}
RAGE_TRACK( CutSceneManager_SavePedVariation );
atArray<cutfEvent *> PedEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), PedEventList );
bool bAddNewEvent = true;
//look to edit a current event
for ( int i = 0; i < PedEventList.GetCount(); ++i )
{
if (PedEventList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
{
if(PedEventList[i]->GetTime() == CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset())
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( PedEventList[i]->GetEventArgs() );
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_ACTOR_VARIATION_EVENT_ARGS_TYPE)
{
//Don't add new event for a component that has the same id and time.
cutfObjectVariationEventArgs* pObjectVar = static_cast<cutfObjectVariationEventArgs*>(pEventArgs);
if (pObjectVar->GetComponent() == m_PropSlotId + PV_MAX_COMP)
{
pObjectVar->SetDrawable(m_PropDrawableId);
pObjectVar->SetTexture(m_PropTextureId);
bAddNewEvent = false;
}
}
}
}
}
if(bAddNewEvent)
{
cutfEventArgs *pEventArgs = rage_new cutfObjectVariationEventArgs( pObject->GetObjectId(), m_PropSlotId + PV_MAX_COMP, m_PropDrawableId, m_PropTextureId );
#if CUTSCENE_EXPORT_EVENTS_WITH_ZERO_BASE_TIME
float ftime = CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset();
#else
float ftime = CutSceneManager::GetInstance()->GetCutSceneCurrentTime();
#endif
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), ftime, CUTSCENE_SET_VARIATION_EVENT, pEventArgs ) );
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Update the ped variation event list for a new ped or new events.
void CCutSceneDebugManager::PopulatePedVariationEventList(const cutfObject* pObject)
{
if (m_pEventCombo == NULL)
{
return;
}
//Nothing selected
if(!pObject)
{
m_PedVarEventId = 0;
m_pEventCombo->UpdateCombo( "Ped var events", &m_PedVarEventId, 1, NULL );
m_pEventCombo->SetString( 0 , "none");
return;
}
atArray<cutfEvent *> PedEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), PedEventList );
atArray<cutfEvent*> PedVariationList;
for ( int i = 0; i < PedEventList.GetCount(); i++ )
{
if (PedEventList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
{
if (PedEventList[i]->GetEventArgs())
{
if(PedEventList[i]->GetEventArgs()->GetType() == CUTSCENE_ACTOR_VARIATION_EVENT_ARGS_TYPE)
{
PedVariationList.Grow() = PedEventList[i];
}
}
else
{
if ( PedEventList[i]->GetType() == CUTSCENE_OBJECT_ID_EVENT_TYPE )
{
const cutfObjectIdEvent* pObjectIdEvent = static_cast<const cutfObjectIdEvent*>( PedEventList[i] );
if ( pObjectIdEvent )
{
const cutfObject* pObject = CutSceneManager::GetInstance()->GetObjectById(pObjectIdEvent->GetObjectId());
if ( pObject )
{
if ( pObject->GetType() == CUTSCENE_MODEL_OBJECT_TYPE )
{
const cutfModelObject* pModelObject = static_cast< const cutfModelObject* >(pObject);
if ( pModelObject->GetModelType() == CUTSCENE_PED_MODEL_TYPE )
{
PedVariationList.Grow() = PedEventList[i];
}
}
}
}
}
}
}
}
m_PedVarEventId = PedVariationList.GetCount() -1;
//look to edit a current event
if (PedVariationList.GetCount() == 0)
{
m_PedVarEventId = 0;
m_pEventCombo->UpdateCombo( "Ped var events", &m_PedVarEventId, 1, NULL );
m_pEventCombo->SetString( 0 , "none");
}
else
{
if (PedVariationList.GetCount() > 0)
{
m_pEventCombo->UpdateCombo( "Ped var events", &m_PedVarEventId, PedVariationList.GetCount(), NULL );
//Clear the list of variations, need to repopulate.
m_CutSceneVariations.Reset();
for ( int i = 0; i < PedVariationList.GetCount(); ++i )
{
if (PedVariationList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( PedVariationList[i]->GetEventArgs() );
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_ACTOR_VARIATION_EVENT_ARGS_TYPE)
{
char EventInfo[64];
cutfObjectVariationEventArgs* pObjectVar = static_cast<cutfObjectVariationEventArgs*>(pEventArgs);
s32 FrameNumber = static_cast<s32>(PedVariationList[i]->GetTime() * CUTSCENE_FPS);
if(pObjectVar->GetComponent() < PV_MAX_COMP)
{
formatf(EventInfo, sizeof(EventInfo)-1,"Event %d: Frame: %d , time: %f , %s , D: %d, T: %d ", i , FrameNumber, PedVariationList[i]->GetTime(),
varSlotNames[pObjectVar->GetComponent()], pObjectVar->GetDrawable(), pObjectVar->GetTexture());
}
else
{
formatf(EventInfo, sizeof(EventInfo)-1,"Event %d: Frame: %d , time: %f , %s , D: %d, T: %d ", i , FrameNumber, PedVariationList[i]->GetTime(),
propSlotNames[pObjectVar->GetComponent()-PV_MAX_COMP], pObjectVar->GetDrawable(), pObjectVar->GetTexture());
}
m_pEventCombo->SetString( i, EventInfo );
//Store a list of pointers to our objects
m_CutSceneVariations.PushAndGrow(PedVariationList[i]);
}
else
{
char EventInfo[64];
s32 FrameNumber = static_cast<s32>(PedVariationList[i]->GetTime() * CUTSCENE_FPS);
formatf(EventInfo, sizeof(EventInfo)-1,"Event %d: Frame: %d , time: %f , id: %i , CORRUPT EVENT!", i, FrameNumber, PedVariationList[i]->GetTime(), PedVariationList[i]->GetEventId());
m_pEventCombo->SetString( i, EventInfo );
//Store a list of pointers to our objects
m_CutSceneVariations.PushAndGrow(PedVariationList[i]);
}
}
}
//m_PedVarEventId = 0;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::BankDeletePedVariationCallBack()
{
if (m_CutSceneVariations.GetCount() > 0 && m_PedVarEventId < m_CutSceneVariations.GetCount())
{
if(m_CutSceneVariations[m_PedVarEventId])
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent(m_CutSceneVariations[m_PedVarEventId]);
PopulatePedVariationEventList(CutSceneManager::GetInstance()->m_pedModelObjectList[m_iPedModelIndex - 1]);
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
SEditCutfObjectLocationInfo* CCutSceneDebugManager::GetFixupObjectInfo()
{
if (m_pGameObject)
{
//Lets check the model index is valid before proceeding, otherwise it will crash when trying to get the name.
//Cant make parts of the map disappear only objects.
u32 index = m_pGameObject->GetModelIndex();
if(CModelInfo::IsValidModelInfo(index))
{
SEditCutfObjectLocationInfo* pEditInfo = rage_new SEditCutfObjectLocationInfo;
pEditInfo->vPosition = VEC3V_TO_VECTOR3(m_pGameObject->GetTransform().GetPosition());
strncpy(pEditInfo->cName,CModelInfo::GetBaseModelInfoName(fwModelId(strLocalIndex(index))), CUTSCENE_OBJNAMELEN);
pEditInfo->fRadius = m_pGameObject->GetBoundRadius();
return pEditInfo;
}
}
return NULL;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
SEditCutfObjectLocationInfo* CCutSceneDebugManager::GetHiddenObjectInfo()
{
if (m_pGameObject)
{
//Lets check the model index is valid before proceeding, otherwise it will crash when trying to get the name.
//Cant make parts of the map disappear only objects.
u32 index = m_pGameObject->GetModelIndex();
if(CModelInfo::IsValidModelInfo(index))
{
SEditCutfObjectLocationInfo* pEditInfo = rage_new SEditCutfObjectLocationInfo;
pEditInfo->vPosition = VEC3V_TO_VECTOR3(m_pGameObject->GetTransform().GetPosition());
strncpy(pEditInfo->cName,CModelInfo::GetBaseModelInfoName(fwModelId(strLocalIndex(index))), CUTSCENE_OBJNAMELEN);
pEditInfo->fRadius = m_pGameObject->GetBoundRadius();
return pEditInfo;
}
}
return NULL;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
sEditCutfBlockingBoundsInfo* CCutSceneDebugManager::GetBlockingBoundObjectInfo()
{
sEditCutfBlockingBoundsInfo* pEditInfo = rage_new sEditCutfBlockingBoundsInfo;
pEditInfo->vCorners[0] = m_vCorners[0];
pEditInfo->vCorners[1] = m_vCorners[1];
pEditInfo->vCorners[2] = m_vCorners[2];
pEditInfo->vCorners[3] = m_vCorners[3];
pEditInfo->fHeight = m_fHeight ;
char BoundName[CUTSCENE_OBJNAMELEN];
formatf(BoundName, sizeof(BoundName)-1, "%s_BB_%d", CutSceneManager::GetInstance()->GetCutsceneName(), CutSceneManager::GetInstance()->GetNumBlockingBoundObjects()+1);
strncpy(pEditInfo->cName, BoundName, CUTSCENE_OBJNAMELEN);
return pEditInfo;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::RightArrowFastForward()
{
if (CControlMgr::GetKeyboard().GetKeyJustDown(KEY_RIGHT, KEYBOARD_MODE_DEBUG))
{
CutSceneManager::GetInstance()->BankFastForwardCallback();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::LeftArrowRewind()
{
if (CControlMgr::GetKeyboard().GetKeyJustDown(KEY_LEFT, KEYBOARD_MODE_DEBUG))
{
CutSceneManager::GetInstance()->BankRewindCallback();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::UpArrowPause()
{
if (CControlMgr::GetKeyboard().GetKeyJustDown(KEY_UP, KEYBOARD_MODE_DEBUG))
{
CutSceneManager::GetInstance()->BankPauseCallback();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::DownArrowPlay()
{
if (CControlMgr::GetKeyboard().GetKeyJustDown(KEY_DOWN, KEYBOARD_MODE_DEBUG))
{
CutSceneManager::GetInstance()->BankPlayForwardsCallback();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::CtrlRightArrowStep()
{
if (CControlMgr::GetKeyboard().GetKeyJustDown(KEY_RIGHT, KEYBOARD_MODE_DEBUG_CTRL))
{
CutSceneManager::GetInstance()->BankStepForwardCallback();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void CCutSceneDebugManager::CtrlLeftArrowStep()
{
if (CControlMgr::GetKeyboard().GetKeyJustDown(KEY_LEFT, KEYBOARD_MODE_DEBUG_CTRL))
{
CutSceneManager::GetInstance()->BankStepBackwardCallback();
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Gets an object under the mouse when clicked on
void CCutSceneDebugManager::GetMapObject()
{
//Activation is set on a widget toggle so that entity can't just be selected by default
if(CutSceneManager::GetInstance()->m_ActivateMapObjectEditing)
{
if(!g_PickerManager.IsEnabled())
{
g_PickerManager.SetEnabled(true);
g_PickerManager.SetUiEnabled(false);
}
fwEntity* pEntity = g_PickerManager.GetSelectedEntity(); //CDebugScene::GetEntityUnderMouse();
//float radius;
if (pEntity)
{
if(CDebugScene::GetMouseLeftPressed())
{
m_pGameObject = (CEntity* )pEntity;
}
if(m_pGameObject)
{
CDebugScene::DrawEntityBoundingBox(m_pGameObject, Color32(255, 0, 0, 255));
}
}
else
{
if(CDebugScene::GetMouseLeftPressed())
{
m_pGameObject = NULL;
}
}
if(m_pGameObject)
{
if (m_pGameObject->IsArchetypeSet())
{
Vector3 vBoundMax = m_pGameObject->GetBoundingBoxMax();
CDebugScene::DrawEntityBoundingBox(m_pGameObject, Color32(0, 0, 255, 255));
grcDebugDraw::Text(VEC3V_TO_VECTOR3(m_pGameObject->GetTransform().GetPosition()), CRGBA(0,0,255,255),0, grcDebugDraw::GetScreenSpaceTextHeight(), "Selected for Edit");
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Null the pointer to our the game object.
void CCutSceneDebugManager::ClearMapObject()
{
m_pGameObject = NULL;
}
/////////////////////////////////////////////////////////////////////////////////////
//Select if the object is visible or not.
void CCutSceneDebugManager::DisplayHiddenObject()
{
if (CutSceneManager::GetInstance()->m_ActivateMapObjectEditing && CutSceneManager::GetInstance()->m_editHiddenObjectList.GetCount() > 0)
{
Vec3V textZOffset(0.0f, 0.0f, 0.8f);
for (int i =0 ; i < CutSceneManager::GetInstance()->m_editHiddenObjectList.GetCount(); i++)
{
u32 iModelIndex = CModelInfo::GetModelIdFromName( CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->cName ).GetModelIndex();
if (CModelInfo::IsValidModelInfo(iModelIndex))
{
CEntity* pEntity = CutSceneManager::GetEntityToAtPosition(CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->vPosition, CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->fRadius, iModelIndex );
if(CutSceneManager::GetInstance()->m_bRenderHiddenObjects && CutSceneManager::GetInstance()->m_ActivateMapObjectEditing)
{
//add special text if the object from the selector list is being edited
char Message[50];
sprintf(Message, "Model %s set to be hidden",CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->cName);
if(CutSceneManager::GetInstance()->m_iSelectedHiddenObjectIndex-1 == i)
{
Vec3V vPos = RCC_VEC3V(CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->vPosition);
if(pEntity)
{
vPos += And(RCC_VEC3V(pEntity->GetBoundingBoxMax()), Vec3V(V_MASKZ));
CDebugScene::DrawEntityBoundingBox(pEntity, Color32(0, 255, 0, 255));
}
grcDebugDraw::Line(RCC_VEC3V(CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->vPosition), vPos + Vec3V(V_Z_AXIS_WZERO), Color32(0, 255, 0, 255));
grcDebugDraw::Text(vPos + textZOffset, CRGBA(0,255,0,255),0, grcDebugDraw::GetScreenSpaceTextHeight(), "Selected for EDIT" );
grcDebugDraw::Cross(vPos, CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->fRadius, Color32(0, 255, 0, 255));
grcDebugDraw::Cross(RCC_VEC3V(CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->vPosition), CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->fRadius, Color32(0, 255, 0, 255));
grcDebugDraw::Text(CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->vPosition, CRGBA(0,0,255,255),0, grcDebugDraw::GetScreenSpaceTextHeight(), Message );
}
else
{
if(pEntity)
{
CDebugScene::DrawEntityBoundingBox(pEntity, Color32(0, 0, 255, 255));
}
grcDebugDraw::Cross(RCC_VEC3V(CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->vPosition), CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->fRadius, Color32(0, 0, 255, 255));
grcDebugDraw::Text(CutSceneManager::GetInstance()->m_editHiddenObjectList[i]->vPosition, CRGBA(0,0,255,255),0, grcDebugDraw::GetScreenSpaceTextHeight(), Message );
}
if (pEntity && !pEntity->IsVisible())
{
pEntity->SetIsVisibleForModule(SETISVISIBLE_MODULE_CUTSCENE, true);
//cutsceneModelEntityDebugf("CCutSceneDebugManager::DisplayHiddenObject: Showing entity (%s)", pEntity->GetModelName());
}
}
else
{
if(!CutSceneManager::GetInstance()->m_bRenderHiddenObjects)
{
if (pEntity && pEntity->IsVisible())
{
pEntity->SetIsVisibleForModule(SETISVISIBLE_MODULE_CUTSCENE, false);
//cutsceneModelEntityDebugf("CCutSceneDebugManager::DisplayHiddenObject: Hiding entity (%s)", pEntity->GetModelName());
}
}
}
}
}
}
}
//Select if the object is visible or not.
void CCutSceneDebugManager::FixupSelectedObject()
{
if (CutSceneManager::GetInstance()->m_editFixupObjectList.GetCount() > 0)
{
for (int i =0 ; i < CutSceneManager::GetInstance()->m_editFixupObjectList.GetCount(); i++)
{
u32 iModelIndex = CModelInfo::GetModelIdFromName( CutSceneManager::GetInstance()->m_editFixupObjectList[i]->cName ).GetModelIndex();
if (CModelInfo::IsValidModelInfo(iModelIndex))
{
CEntity* pEntity = CutSceneManager::GetEntityToAtPosition(CutSceneManager::GetInstance()->m_editFixupObjectList[i]->vPosition, CutSceneManager::GetInstance()->m_editFixupObjectList[i]->fRadius, iModelIndex );
if (pEntity)
{
if(CutSceneManager::GetInstance()->m_ActivateMapObjectEditing)
{
char Message[50];
sprintf(Message, "Model %s set to be fixed",CutSceneManager::GetInstance()->m_editFixupObjectList[i]->cName);
grcDebugDraw::Cross(RCC_VEC3V(CutSceneManager::GetInstance()->m_editFixupObjectList[i]->vPosition), CutSceneManager::GetInstance()->m_editFixupObjectList[i]->fRadius, Color32(0, 0, 255, 255));
CDebugScene::DrawEntityBoundingBox(pEntity, Color32(0, 0, 255, 255));
grcDebugDraw::Text(CutSceneManager::GetInstance()->m_editFixupObjectList[i]->vPosition, CRGBA(0,0,0,255),0, grcDebugDraw::GetScreenSpaceTextHeight(), Message );
}
else
{
if(CutSceneManager::GetInstance()->m_FixupMapObject)
{
CutSceneManager::GetInstance()->FixupRequestedObjects(CutSceneManager::GetInstance()->m_editFixupObjectList[i]->vPosition, CutSceneManager::GetInstance()->m_editFixupObjectList[i]->fRadius, iModelIndex);
CutSceneManager::GetInstance()->m_FixupMapObject = false;
}
}
}
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
//Get the mouse position of mouse in world coords, this interescts with collision so need to specify a z offset
void CCutSceneDebugManager::UpdateMouseCursorPosition(Vector3 &WorldPos1, Vector3 &WorldPos2, Vector3 &WorldPosZOffset, bool bUseMouseWheel)
{
Vector3 vPos;
Vector3 vNormal;
void *entity;
bool bHasPosition = CDebugScene::GetWorldPositionUnderMouse(vPos, ArchetypeFlags::GTA_MAP_TYPE_MOVER | ArchetypeFlags::GTA_VEHICLE_TYPE | ArchetypeFlags::GTA_OBJECT_TYPE , &vNormal, &entity);
if( bHasPosition )
{
if( ioMouse::GetPressedButtons() & ioMouse::MOUSE_LEFT || ioMouse::GetButtons() & ioMouse::MOUSE_LEFT )
{
WorldPos1 = vPos + WorldPosZOffset;
}
if ( ioMouse::GetPressedButtons() & ioMouse::MOUSE_RIGHT || ioMouse::GetButtons() & ioMouse::MOUSE_RIGHT )
{
WorldPos2 = vPos + WorldPosZOffset;
}
if(bUseMouseWheel)
{
if((ioMouse::HasWheel() && ioMouse::GetDZ()>0)||ioMapper::DebugKeyDown(KEY_COMMA))
{
WorldPosZOffset.z += 0.1f;
WorldPos1.z += 0.1f;
WorldPos2.z += 0.1f;
}
if((ioMouse::HasWheel() && ioMouse::GetDZ()<0)||ioMapper::DebugKeyDown(KEY_COMMA))
{
WorldPosZOffset.z -= 0.1f;
WorldPos1.z -= 0.1f;
WorldPos2.z -= 0.1f;
}
}
}
grcDebugDraw::Sphere(WorldPos2, 0.05f, Color32(1.0f, 0.0f, 1.0f) );
grcDebugDraw::Sphere(WorldPos1, 0.05f, Color32(1.0f, 0.0f, 0.0f) );
}
/////////////////////////////////////////////////////////////////////////////////////
// Create the word space representation of of the box
void CCutSceneDebugManager::CreateDebugAngledAreaMatrix(const Vector3 &vPos, float width, float length, float height, const Vector3 &vRot, Matrix34 &mMat, Vector3 &vMax)
{
mMat.Identity();
Vector3 SizeVector (width* 0.5f, length* 0.5f, height* 0.5f);
Vector3 vRot_temp = vRot * DtoR;
mMat.FromEulersXYZ(vRot_temp);
mMat.d = vPos;
vMax = SizeVector;
}
/////////////////////////////////////////////////////////////////////////////////////
//Convert the corner matrix into scene space
void CCutSceneDebugManager::ConvertMatrixAndVectorLocateToFourCornersAndHeight(const Matrix34 &mLocateMat, const Vector3 &vMax, Vector3 &vCorner1, Vector3 &vCorner2, Vector3 &vCorner3, Vector3 &vCorner4, float &fHeight )
{
//Get scene space
Matrix34 SceneMat(M34_IDENTITY);
CutSceneManager::GetInstance()->GetSceneOrientationMatrix(SceneMat);
//locate space
Matrix34 LocateMat(M34_IDENTITY);
LocateMat = mLocateMat;
Vector3 vMaxLocal(vMax);
Vector3 vMinLocal = (vMaxLocal * -1.0f);
fHeight = vMaxLocal.z - vMinLocal.z;
//set up the corners in local space
vCorner1 = Vector3(vMinLocal.x, vMinLocal.y, vMinLocal.z);
vCorner2 = Vector3(vMaxLocal.x, vMinLocal.y, vMinLocal.z);
vCorner3 = Vector3(vMaxLocal.x, vMaxLocal.y, vMinLocal.z);
vCorner4 = Vector3(vMinLocal.x, vMaxLocal.y, vMinLocal.z);
//to render the corner text in the correct world pos.
Vector3 vCorner1RenderPos = vCorner1;
Vector3 vCorner2RenderPos = vCorner2;
Vector3 vCorner3RenderPos = vCorner3;
Vector3 vCorner4RenderPos = vCorner4;
//transform our local vector into world space for rendering
mLocateMat.Transform(vCorner1RenderPos);
mLocateMat.Transform(vCorner2RenderPos);
mLocateMat.Transform(vCorner3RenderPos);
mLocateMat.Transform(vCorner4RenderPos);
//need to put our result into scene space they are both in world space. The locate is effectively a child of the scene mat.
LocateMat.DotTranspose(SceneMat);
//transform our local vector into locate space ie world space
LocateMat.Transform(vCorner1);
LocateMat.Transform(vCorner2);
LocateMat.Transform(vCorner3);
LocateMat.Transform(vCorner4);
//create the render text to display the scene space position in world space
char position[256];
formatf(position, sizeof(position)-1, "C1: (%f, %f, %f)",vCorner1.x, vCorner1.y, vCorner1.z );
grcDebugDraw::Text(vCorner1RenderPos, CRGBA(0,0,0,255),0, grcDebugDraw::GetScreenSpaceTextHeight(), position );
formatf(position, sizeof(position)-1, "C2: (%f, %f, %f)",vCorner2.x, vCorner2.y, vCorner2.z );
grcDebugDraw::Text(vCorner2RenderPos, CRGBA(0,0,0,255),0, grcDebugDraw::GetScreenSpaceTextHeight(), position );
formatf(position, sizeof(position)-1, "C3: (%f, %f, %f)",vCorner3.x, vCorner3.y, vCorner3.z );
grcDebugDraw::Text(vCorner3RenderPos, CRGBA(0,0,0,255),0, grcDebugDraw::GetScreenSpaceTextHeight(), position );
formatf(position, sizeof(position)-1, "C4: (%f, %f, %f)",vCorner4.x, vCorner4.y, vCorner4.z );
grcDebugDraw::Text(vCorner4RenderPos, CRGBA(0,0,0,255),0, grcDebugDraw::GetScreenSpaceTextHeight(), position );
}
///////////////////////////////////////////////////////////////////////////
// Applies post scene update
void CCutSceneDebugManager::DisplayAndEditBlockingBounds()
{
CutSceneManager* pManager = CutSceneManager::GetInstance();
if(pManager->m_bActivateBlockingObjectEditing)
{
CreateDebugAngledAreaMatrix(pManager->m_vBlockingBoundPos, pManager->m_fBoundingBoxWidth, pManager->m_fBoundingBoxLength, pManager->m_fBoundingBoxHeight, pManager->m_vBlockingBoundRot, m_Mat, m_vMax );
ConvertMatrixAndVectorLocateToFourCornersAndHeight(m_Mat, m_vMax, m_vCorners[0], m_vCorners[1], m_vCorners[2], m_vCorners[3], m_fHeight ) ;
grcDebugDraw::Axis( m_Mat, 0.25, true);
grcDebugDraw::BoxOriented(RCC_VEC3V(m_vMax) * ScalarV(V_NEGONE), RCC_VEC3V(m_vMax), RCC_MAT34V(m_Mat),CRGBA(0,0,255,255), false);
}
if (pManager->m_bRenderBlockingBoundObjects)
{
for (int i =0; i<pManager->m_editBlockingBoundObjectList.GetCount(); i++)
{
//Render the bound name for ease of editing
const char* BoundName = pManager->m_editBlockingBoundObjectList[i]->cName;
////have selected a locate from the bounding box list update it and then we can render it
if(pManager->m_iSelectedBlockingBoundObjectIndex-1 == i )
{
Vector3 vConvertedToRads (0.0f, 0.0f, pManager->m_LocateMatRot.z * DtoR);
pManager->m_editBlockingBoundObjectList[i]->LocateMat.FromEulersXYZ(vConvertedToRads);
ConvertMatrixAndVectorLocateToFourCornersAndHeight(pManager->m_editBlockingBoundObjectList[i]->LocateMat, pManager->m_editBlockingBoundObjectList[i]->vMax, pManager->m_editBlockingBoundObjectList[i]->vCorners[0], pManager->m_editBlockingBoundObjectList[i]->vCorners[1],
pManager->m_editBlockingBoundObjectList[i]->vCorners[2], pManager->m_editBlockingBoundObjectList[i]->vCorners[3], pManager->m_editBlockingBoundObjectList[i]->fHeight);
grcDebugDraw::Axis(pManager->m_editBlockingBoundObjectList[i]->LocateMat, 0.25, true);
grcDebugDraw::BoxOriented(RCC_VEC3V(pManager->m_editBlockingBoundObjectList[i]->vMax) * ScalarV(V_NEGONE),RCC_VEC3V(pManager->m_editBlockingBoundObjectList[i]->vMax), MATRIX34_TO_MAT34V(pManager->m_editBlockingBoundObjectList[i]->LocateMat),CRGBA(0,255,0,255), false);
grcDebugDraw::Text(pManager->m_editBlockingBoundObjectList[i]->LocateMat.d, CRGBA(0,255,0,255),0,grcDebugDraw::GetScreenSpaceTextHeight(), BoundName);
}
else
{
float creationTime = 0.0f;
float removalTime = pManager->GetCutfFile()->GetTotalDuration();
atArray<cutfEvent*>ObjectEvents;
pManager->GetCutfFile()->FindEventsForObjectIdOnly( pManager->m_editBlockingBoundObjectList[i]->pObject->GetObjectId(), pManager->GetCutfFile()->GetEventList(), ObjectEvents );
for (s32 j=0; j<ObjectEvents.GetCount(); j++)
{
if (ObjectEvents[j]->GetEventId()==CUTSCENE_ADD_BLOCKING_BOUNDS_EVENT)
{
creationTime = ObjectEvents[j]->GetTime();
}
else if (ObjectEvents[j]->GetEventId()==CUTSCENE_REMOVE_BLOCKING_BOUNDS_EVENT)
{
removalTime = ObjectEvents[j]->GetTime();
}
}
Color32 color;
if (pManager->GetCutSceneCurrentTime() < removalTime && pManager->GetCutSceneCurrentTime()>= creationTime)
{
color = CRGBA(255,0,0,255);
}
else
{
color = CRGBA(0,0,255,255);
}
pManager->ConvertAngledAreaToMatrixAndVectors(pManager->m_editBlockingBoundObjectList[i]->vCorners, pManager->m_editBlockingBoundObjectList[i]->fHeight, pManager->m_editBlockingBoundObjectList[i]->vMin, pManager->m_editBlockingBoundObjectList[i]->vMax, pManager->m_editBlockingBoundObjectList[i]->LocateMat, creationTime);
grcDebugDraw::Axis( pManager->m_editBlockingBoundObjectList[i]->LocateMat, 0.25, true);
grcDebugDraw::BoxOriented(RCC_VEC3V(pManager->m_editBlockingBoundObjectList[i]->vMin), VECTOR3_TO_VEC3V(pManager->m_editBlockingBoundObjectList[i]->vMax), MATRIX34_TO_MAT34V(pManager->m_editBlockingBoundObjectList[i]->LocateMat),color, false);
grcDebugDraw::Text(pManager->m_editBlockingBoundObjectList[i]->LocateMat.d, CRGBA(0,255,0,255),0,grcDebugDraw::GetScreenSpaceTextHeight(), BoundName);
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// OVERLAYS
///////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//Get the entity that managers vehicle and populate all the relevant lists.
void CCutSceneDebugManager::GetSelectedOverlayEntityCallBack()
{
if (m_iOverlayIndex > 0)
{
cutsEntity* pCutEntity = CutSceneManager::GetInstance()->GetEntityByObjectId(m_OverlayObjectList[m_iOverlayIndex - 1]->GetObjectId());
CCutSceneScaleformOverlayEntity* pEnt = static_cast<CCutSceneScaleformOverlayEntity*> (pCutEntity);
if(pEnt)
{
m_pOverlay = pEnt;
GetOverlaySettings();
PopulateOverlayEventList(m_OverlayObjectList[m_iOverlayIndex - 1]);
}
}
else
{
//selected none from the vehicle selector.
m_pOverlay = NULL;
PopulateOverlayEventList(NULL);
}
GetOverlayMovieMethods();
}
void CCutSceneDebugManager::GetOverlaySettings()
{
if(m_pOverlay)
{
m_vOverlayPos = m_pOverlay->GetOverlayPos();
m_vOverlaySize = m_pOverlay->GetOverlaySize();
}
}
void CCutSceneDebugManager::SetOverlayPositionCB()
{
if(m_pOverlay)
{
m_pOverlay->SetOverlayPos(m_vOverlayPos);
}
}
void CCutSceneDebugManager::SetOverlaySizeCB()
{
if(m_pOverlay)
{
m_pOverlay->SetOverlaySize(m_vOverlaySize);
}
}
void CCutSceneDebugManager::BankSaveOverlayEventsCallBack()
{
if (m_OverlayObjectList.GetCount() > 0 && m_iOverlayIndex <= m_OverlayObjectList.GetCount() && m_iOverlayIndex > 0 )
{
const cutfObject* pObject = m_OverlayObjectList[m_iOverlayIndex - 1];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
m_EventAttributes.Reset();
AddAttributesFromParams();
SaveOverlayEvent(pObject, m_OverlayMethodNames[m_iOverlayMethodIndex], CutSceneCustomEvents::CUTSCENE_SET_OVERLAY_METHOD_EVENT);
m_EventAttributes.Reset();
//update the combo box of ped variation events
PopulateOverlayEventList(pObject);
//Save the changes out to the cuttune file.
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
void CCutSceneDebugManager::PopulateOverlayEventList(const cutfObject* pObject)
{
if (m_pOverlayEventCombo == NULL)
{
return;
}
//Nothing selected
if(!pObject)
{
m_OverlayEventId = 0;
m_pOverlayEventCombo->UpdateCombo( "events", &m_OverlayEventId, 1, NULL );
m_pOverlayEventCombo->SetString( 0 , "none");
return;
}
atArray<cutfEvent *> AllEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), AllEventList );
atArray<cutfEvent *>EventList;
for(int i =0; i < AllEventList.GetCount(); i++)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( AllEventList[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_NAME_EVENT_ARGS_TYPE)
{
EventList.PushAndGrow(AllEventList[i]);
}
}
//look to edit a current event
if (EventList.GetCount() == 0)
{
m_pOverlayEventCombo->UpdateCombo( "Overlay Events", &m_OverlayEventId, 1, NULL );
m_pOverlayEventCombo->SetString( 0 , "none");
}
else
{
if (EventList.GetCount() > 0)
{
m_pOverlayEventCombo->UpdateCombo( "Overlay Events", &m_OverlayEventId, EventList.GetCount(), NULL );
//Clear the list of variations, need to repopulate.
for (int i=0; i < m_OverlayEvents.GetCount(); i++)
{
m_OverlayEvents[i] = NULL;
}
m_OverlayEvents.Reset();
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if (EventList[i]->GetEventId() == CutSceneCustomEvents::CUTSCENE_SET_OVERLAY_METHOD_EVENT || EventList[i]->GetEventId() == CutSceneCustomEvents::CUTSCENE_SET_OVERLAY_PROPERTIES_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_NAME_EVENT_ARGS_TYPE )
{
char EventInfo[64];
EventInfo[0] = '\0';
cutfNameEventArgs* pObjectVar = static_cast<cutfNameEventArgs*>(pEventArgs);
s32 FrameNumber = static_cast<s32>(EventList[i]->GetTime() * CUTSCENE_FPS);
char ParamInfo[64];
ParamInfo[0] = '\0';
for(int j =0; j<MAX_NUMBER_OVERLAY_PARAMS; j++)
{
char ParamName [32] ;
formatf(ParamName, 32, "param_%d", j+1);
const parAttribute* pAttribute = pEventArgs->GetAttributeList().FindAttributeAnyCase(ParamName);
if(pAttribute)
{
char ParamData [32] ;
ParamData[0] = '\0';
if (j > 0)
{
safecat(ParamInfo, " , " );
}
switch(pAttribute->GetType())
{
case parAttribute::DOUBLE:
{
formatf(ParamData, 32, "%f", pAttribute->GetFloatValue());
safecat(ParamInfo, ParamData );
}
break;
case parAttribute::BOOL:
{
if(pAttribute->GetBoolValue())
{
safecat(ParamInfo, "true" );
}
else
{
safecat(ParamInfo, "false" );
}
}
break;
case parAttribute::STRING:
{
safecat(ParamInfo, pAttribute->GetStringValue() );
}
break;
case parAttribute::INT64:
{
formatf(ParamData, 32, "%d", pAttribute->GetIntValue());
safecat(ParamInfo, ParamData );
}
break;
}
}
}
formatf(EventInfo, sizeof(EventInfo)-1,"(%d) %s(%s)",FrameNumber, pObjectVar->GetName().GetCStr(), ParamInfo );
m_pOverlayEventCombo->SetString( i, EventInfo );
//Store a list of pointers to our objects
m_OverlayEvents.PushAndGrow(EventList[i]);
}
}
}
}
}
};
void CCutSceneDebugManager::SaveOverlayEvent(const cutfObject* pObject, const char* ArgsName, s32 iEventId)
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "Overlay Event: No cutf file object loaded cannot save"))
{
return;
}
if ( pObject == NULL )
{
return;
}
atArray<cutfEvent *> EventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), EventList );
bool bAddNewEvent = true;
//look to edit a current event
//for ( int i = 0; i < EventList.GetCount(); ++i )
//{
// if (EventList[i]->GetEventId() == CUTSCENE_SET_VARIATION_EVENT)
// {
// if(EventList[i]->GetTime() == CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset() )
// {
// cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
// if(pEventArgs && pEventArgs->GetType() == CUTSCENE_NAME_EVENT_ARGS_TYPE)
// {
// //Don't add new event for a component that has the same id and time.
//
// bAddNewEvent = false;
// }
// }
// }
//}
if(bAddNewEvent)
{
cutfEventArgs *pEventArgs = NULL;
pEventArgs = rage_new cutfNameEventArgs(ArgsName, m_EventAttributes);
#if CUTSCENE_EXPORT_EVENTS_WITH_ZERO_BASE_TIME
float ftime = CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset();
#else
float ftime =CutSceneManager::GetInstance()-> GetCutSceneCurrentTime();
#endif
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), ftime, iEventId, pEventArgs ) );
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
for(int i=0; m_OverlayParams.GetCount() > 0; )
{
DeleteParamWidget(i);
}
}
}
void CCutSceneDebugManager::GetOverlayMovieMethods()
{
m_OverlayMethodNames.Reset();
if(m_pOverlay)
{
if (m_pOverlayMethodsCombo)
{
m_pOverlayMethodsCombo->UpdateCombo( "Overlay Methods", &m_iOverlayMethodIndex, m_OverlayMethodNames.GetCount(), &m_OverlayMethodNames[0], NullCB);
}
}
else
{
m_OverlayMethodNames.PushAndGrow("none"); //this is to match the combo box in index
if (m_pOverlayMethodsCombo)
{
m_pOverlayMethodsCombo->UpdateCombo( "Overlay Methods", &m_iOverlayMethodIndex, 1, NULL );
m_pOverlayMethodsCombo->SetString( 0 , "none");
}
}
}
void CCutSceneDebugManager::CreateParamWidgets()
{
//look for params that already exist and don't add twice
for(int i = 0; i <m_OverlayParams.GetCount(); i++)
{
if(m_OverlayParams[i].ParamNumber == m_iOverlayParamNameIndex)
{
return;
}
}
bkBank* Ragebank = BANKMGR.FindBank("Cut Scene Debug");
bkGroup* CurrentSceneGrp = static_cast<bkGroup*>(BANKMGR.FindWidget("Cut Scene Debug/Current Scene/Overlay/Overlay Events/Overlay Method Events/Params"));
if(Ragebank)
{
if (CurrentSceneGrp)
{
Ragebank->SetCurrentGroup(*CurrentSceneGrp);
switch(m_iOverlayParamTypeIndex)
{
case PT_INT:
{
Params NewParam;
NewParam.pParam = rage_new CParamTypeInt();
NewParam.ParamNumber = m_iOverlayParamNameIndex;
NewParam.pParam->AddWidgets(Ragebank, OverlayParamNames[m_iOverlayParamNameIndex]);
m_OverlayParams.PushAndGrow(NewParam);
}
break;
case PT_FLOAT:
{
Params NewParam;
NewParam.pParam = rage_new CParamTypeFloat();
NewParam.ParamNumber = m_iOverlayParamNameIndex;
NewParam.pParam->AddWidgets(Ragebank, OverlayParamNames[m_iOverlayParamNameIndex]);
m_OverlayParams.PushAndGrow(NewParam);
}
break;
case PT_STRING:
{
Params NewParam;
NewParam.pParam = rage_new CParamTypeString();
NewParam.ParamNumber = m_iOverlayParamNameIndex;
NewParam.pParam->AddWidgets(Ragebank, OverlayParamNames[m_iOverlayParamNameIndex]);
m_OverlayParams.PushAndGrow(NewParam);
}
break;
case PT_BOOL:
{
Params NewParam;
NewParam.pParam = rage_new CParamTypeBool();
NewParam.ParamNumber = m_iOverlayParamNameIndex;
NewParam.pParam->AddWidgets(Ragebank, OverlayParamNames[m_iOverlayParamNameIndex]);
m_OverlayParams.PushAndGrow(NewParam);
}
break;
}
Ragebank->UnSetCurrentGroup(*CurrentSceneGrp);
}
}
}
void CCutSceneDebugManager::DeleteParamWidget(s32 index)
{
if(index >=0 && index < m_OverlayParams.GetCount() )
{
m_OverlayParams[index].pParam->DeleteWidgets();
delete m_OverlayParams[index].pParam;
m_OverlayParams[index].pParam = NULL;
m_OverlayParams.Delete(index);
}
}
bool CCutSceneDebugManager::AddAttributesFromParams()
{
if(m_OverlayParams.GetCount() > 0)
{
for(int i = 0; i <m_OverlayParams.GetCount(); i++)
{
switch(m_OverlayParams[i].pParam->GetType())
{
case CParamType::kParameterFloat:
{
CParamTypeFloat* pTypeParam = static_cast<CParamTypeFloat*>(m_OverlayParams[i].pParam);
m_EventAttributes.AddAttribute(OverlayParamNames[m_OverlayParams[i].ParamNumber],pTypeParam->m_value);
}
break;
case CParamType::kParameterInt:
{
CParamTypeInt* pTypeParam = static_cast<CParamTypeInt*>(m_OverlayParams[i].pParam);
m_EventAttributes.AddAttribute(OverlayParamNames[m_OverlayParams[i].ParamNumber],pTypeParam->m_value);
}
break;
case CParamType::kParameterBool:
{
CParamTypeBool* pTypeParam = static_cast<CParamTypeBool*>(m_OverlayParams[i].pParam);
m_EventAttributes.AddAttribute(OverlayParamNames[m_OverlayParams[i].ParamNumber],pTypeParam->m_value);
}
break;
case CParamType::kParameterString:
{
CParamTypeString* pTypeParam = static_cast<CParamTypeString*>(m_OverlayParams[i].pParam);
m_EventAttributes.AddAttribute(OverlayParamNames[m_OverlayParams[i].ParamNumber],pTypeParam->m_value);
}
break;
case CParamType::kParameterWidgetNum:
default:
{
}
break;
}
}
return true;
}
else
{
return false;
}
}
void CCutSceneDebugManager::BankDeleteOverlayEventCallBack()
{
if (m_OverlayEventId < m_OverlayEvents.GetCount() )
{
if(m_OverlayEvents[m_OverlayEventId])
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent(m_OverlayEvents[m_OverlayEventId]);
PopulateOverlayEventList(m_OverlayObjectList[m_iOverlayIndex - 1]);
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
void CCutSceneDebugManager::BankSaveMovieProperties()
{
if (m_OverlayObjectList.GetCount() > 0 && m_iOverlayIndex <= m_OverlayObjectList.GetCount() && m_iOverlayIndex > 0 )
{
const cutfObject* pObject = m_OverlayObjectList[m_iOverlayIndex - 1];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
m_EventAttributes.Reset();
m_EventAttributes.AddAttribute("param_1", m_vOverlaySize.x);
m_EventAttributes.AddAttribute("param_2", m_vOverlaySize.y);
m_EventAttributes.AddAttribute("param_3", m_vOverlayPos.x);
m_EventAttributes.AddAttribute("param_4", m_vOverlayPos.y);
m_EventAttributes.AddAttribute("param_5", m_bUseScreenRenderTarget);
SaveOverlayEvent(pObject, "OVERLAY_PROP", CutSceneCustomEvents::CUTSCENE_SET_OVERLAY_PROPERTIES_EVENT);
m_EventAttributes.Reset();
//update the combo box of ped variation events
PopulateOverlayEventList(pObject);
//Save the changes out to the cuttune file.
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
//Water Refract index
void CCutSceneDebugManager::BankSaveWaterRefractionIndexEventCallBack()
{
if (m_CameraObjectList.GetCount() > 0)
{
const cutfObject* pObject = m_CameraObjectList[0];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
SaveWaterRefractionIndexEvent(pObject, CutSceneCustomEvents::CUTSCENE_SET_WATER_REFRACT_INDEX_EVENT);
//update the combo box of ped variation events
PopulateWaterRefractionIndexEventList(pObject);
//Save the changes out to the cuttune file.
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
void CCutSceneDebugManager::SaveWaterRefractionIndexEvent(const cutfObject* pObject, s32 iEventId)
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "Overlay Event: No cutf file object loaded cannot save"))
{
return;
}
if ( pObject == NULL )
{
return;
}
atArray<cutfEvent *> EventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), EventList );
bool bAddNewEvent = true;
if(bAddNewEvent)
{
cutfEventArgs *pEventArgs = NULL;
pEventArgs = rage_new cutfFloatValueEventArgs(m_fWaterRefractionIndex);
#if CUTSCENE_EXPORT_EVENTS_WITH_ZERO_BASE_TIME
float ftime = CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset();
#else
float ftime =CutSceneManager::GetInstance()-> GetCutSceneCurrentTime();
#endif
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), ftime, iEventId, pEventArgs ) );
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
}
}
void CCutSceneDebugManager::BankDeleteWaterRefractionIndexEventCallBack()
{
if (m_iWaterRefractionIndexId < m_WaterRefractionIndexEvents.GetCount() )
{
const cutfObject* pObject = m_CameraObjectList[0];
if(m_WaterRefractionIndexEvents[m_iWaterRefractionIndexId] && pObject)
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent(m_WaterRefractionIndexEvents[m_iWaterRefractionIndexId]);
PopulateWaterRefractionIndexEventList(pObject);
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
void CCutSceneDebugManager::PopulateWaterRefractionIndexEventList(const cutfObject* pObject)
{
if (m_pWaterRefractionIndexCombo == NULL)
{
return;
}
//Nothing selected
if(!pObject)
{
m_pWaterRefractionIndexCombo->UpdateCombo( "events", &m_iWaterRefractionIndexId, 1, NULL );
m_pWaterRefractionIndexCombo->SetString( 0 , "none");
return;
}
atArray<cutfEvent *> AllEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), AllEventList );
atArray<cutfEvent *>EventList;
for(int i =0; i < AllEventList.GetCount(); i++)
{
//cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( AllEventList[i]->GetEventArgs() );
if(AllEventList[i]->GetEventId() == CutSceneCustomEvents::CUTSCENE_SET_WATER_REFRACT_INDEX_EVENT)
{
EventList.PushAndGrow(AllEventList[i]);
}
}
//look to edit a current event
if (EventList.GetCount() == 0)
{
m_pWaterRefractionIndexCombo->UpdateCombo( "Water Refraction Index Events", &m_iWaterRefractionIndexId, 1, NULL );
m_pWaterRefractionIndexCombo->SetString( 0 , "none");
}
else
{
if (EventList.GetCount() > 0)
{
m_pWaterRefractionIndexCombo->UpdateCombo( "Water Refraction Index Events", &m_iWaterRefractionIndexId, EventList.GetCount(), NULL );
//Clear the list of variations, need to repopulate.
for (int i=0; i < m_WaterRefractionIndexEvents.GetCount(); i++)
{
m_WaterRefractionIndexEvents[i] = NULL;
}
m_WaterRefractionIndexEvents.Reset();
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if (EventList[i]->GetEventId() == CutSceneCustomEvents::CUTSCENE_SET_WATER_REFRACT_INDEX_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE )
{
char EventInfo[64];
EventInfo[0] = '\0';
cutfFloatValueEventArgs* pObjectVar = static_cast<cutfFloatValueEventArgs*>(pEventArgs);
s32 FrameNumber = static_cast<s32>(EventList[i]->GetTime() * CUTSCENE_FPS);
formatf(EventInfo, sizeof(EventInfo)-1,"(%d) Refraction index: %f", FrameNumber, pObjectVar->GetFloat1());
m_pWaterRefractionIndexCombo->SetString( i, EventInfo );
//Store a list of pointers to our objects
m_WaterRefractionIndexEvents.PushAndGrow(EventList[i]);
}
}
}
}
}
};
void CCutSceneDebugManager::BankSaveTimeCycleParamsCallBack()
{
if (m_CameraObjectList.GetCount() > 0)
{
const cutfObject* pObject = m_CameraObjectList[0];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
SaveTimeCycleParamsEvent(pObject);
//Save the changes out to the cuttune file.
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
}
}
void CCutSceneDebugManager::PopulateCameraCutEventList(const cutfObject* pObject, bkCombo* Combo, s32 &ComboIndex, datCallback CallBack)
{
if (Combo == NULL)
{
return;
}
//Nothing selected
if(!pObject)
{
ComboIndex = 0;
Combo->UpdateCombo( "camera cut events", &ComboIndex, 1, NULL );
Combo->SetString( 0 , "none");
return;
}
atArray<cutfEvent *> AllEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), AllEventList );
atArray<cutfEvent *>EventList;
for(int i =0; i < AllEventList.GetCount(); i++)
{
//cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( AllEventList[i]->GetEventArgs() );
if(AllEventList[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
EventList.PushAndGrow(AllEventList[i]);
}
}
//look to edit a current event
if (EventList.GetCount() == 0)
{
Combo->UpdateCombo( "Camera Cut Events", &ComboIndex, 1, NULL );
Combo->SetString( 0 , "none");
}
else
{
if (EventList.GetCount() > 0)
{
Combo->UpdateCombo( "Camera Cut Events", &ComboIndex, EventList.GetCount(), 0, CallBack );
//Clear the list of variations, need to repopulate.
for (int i=0; i < m_CameraCutsIndexEvents.GetCount(); i++)
{
m_CameraCutsIndexEvents[i] = NULL;
}
m_CameraCutsIndexEvents.Reset();
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if (EventList[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
char EventInfo[64];
EventInfo[0] = '\0';
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
s32 FrameNumber = static_cast<s32>(EventList[i]->GetTime() * CUTSCENE_FPS);
formatf(EventInfo, sizeof(EventInfo)-1,"(%d) %s", FrameNumber, pObjectVar->GetName().GetCStr());
Combo->SetString( i, EventInfo );
//Store a list of pointers to our objects
m_CameraCutsIndexEvents.PushAndGrow(EventList[i]);
}
}
}
}
}
};
void CCutSceneDebugManager::UpdateTimeCycleParamsCB()
{
if (m_pTimeCycleCameraCutCombo == NULL)
{
return;
}
if(m_CameraCutsIndexEvents[m_iTimecycleEventsIndexId])
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( m_CameraCutsIndexEvents[m_iTimecycleEventsIndexId]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pObjectVar)
{
m_ReflectionLodRangeStart = pObjectVar->GetReflectionLodRangeStart();
m_ReflectionLodRangeEnd = pObjectVar->GetReflectionLodRangeEnd();
m_ReflectionSLodRangeStart = pObjectVar->GetReflectionSLodRangeStart();
m_ReflectionSLodRangeEnd = pObjectVar->GetReflectionSLodRangeEnd();
m_LodMultHD = pObjectVar->GetLodMultHD();
m_LodMultOrphanedHD = pObjectVar->GetLodMultOrphanHD();
m_LodMultLod = pObjectVar->GetLodMultLod();
m_LodMultSLod1 = pObjectVar->GetLodMultSlod1();
m_LodMultSLod2 = pObjectVar->GetLodMultSlod2();
m_LodMultSLod3 = pObjectVar->GetLodMultSlod3();
m_LodMultSLod4 = pObjectVar->GetLodMultSlod4();
m_WaterReflectionFarClip = pObjectVar->GetWaterReflectionFarClip();
m_SSAOLightInten = pObjectVar->GetLightSSAOInten();
m_LodMult = pObjectVar->GetMapLodScale();
m_ExposurePush = pObjectVar->GetExposurePush();
m_bDisableHighQualityDof = pObjectVar->GetDisableHighQualityDof();
m_CharacterLight = pObjectVar->GetCharacterLightParams();
m_FreezeReflectionMap = pObjectVar->IsReflectionMapFrozen();
m_DisableDirectionalLight = pObjectVar->IsDirectionalLightDisabled();
m_LightFadeDistanceMult = pObjectVar->GetLightFadeDistanceMult();
m_LightShadowFadeDistanceMult = pObjectVar->GetLightShadowFadeDistanceMult();
m_LightSpecularFadeDistMult = pObjectVar->GetLightSpecularFadeDistMult();
m_LightVolumetricFadeDistanceMult = pObjectVar->GetLightVolumetricFadeDistanceMult();
m_AbsoluteIntensityEnabled = pObjectVar->IsAbsoluteIntensityEnabled();
m_DirectionalLightMultiplier = pObjectVar->GetDirectionalLightMultiplier();
m_LensArtefactMultiplier = pObjectVar->GetLensArtefactMultiplier();
m_MaxBloom = pObjectVar->GetBloomMax();
}
}
}
}
float CCutSceneDebugManager::ValidateTimeCycleParams(float &param)
{
if(param < 0.0f)
{
param = -1.0f;
}
return param;
};
void CCutSceneDebugManager::UpdateCurrentCutName()
{
s32 EventIndex;
atHashString CameraCut(FindCameraCutNameForTime(m_CameraCutsIndexEvents, CutSceneManager::GetInstance()->GetCutSceneCurrentTime(), EventIndex));
if(EventIndex > -1 && m_ShouldSyncTimeOfDayDofOverridedWidgetIndexidtoCurrentCameraCut)
{
if(m_iCoCModifiersCamerCutComboIndexId != EventIndex)
{
m_iCoCModifiersCamerCutComboIndexId = EventIndex;
UpdateCoCModifierEventOverridesCB();
}
}
char CutInfo[128];
CutInfo[0] = '\0';
float cutTime = FindCameraCutTimeForTime(m_CameraCutsIndexEvents, CutSceneManager::GetInstance()->GetCutSceneCurrentTime());
s32 FrameNumber = static_cast<s32>(cutTime * CUTSCENE_FPS);
formatf(CutInfo, sizeof(CutInfo)-1,"(%.2f %d) %s", cutTime, FrameNumber, CameraCut.GetCStr());
if(CameraCut.GetHash() == 0)
{
strcpy(m_CameraCutName, "none");
}
else
{
#if CUTSCENE_LIGHT_EVENT_LOGGING
if(strcmp(m_CameraCutName, CutInfo) != 0)
{
cutsDisplayf("\t%u\t%.2f\t%s\tCAMERA CUT", fwTimer::GetFrameCount(), CutSceneManager::GetInstance()->GetTime(), CutInfo);
}
#endif
strcpy(m_CameraCutName, CutInfo);
}
m_CascadeBounds.SelectShadowEvent(CameraCut);
}
void CCutSceneDebugManager::UpdateFirstPersonBlendOutDuration()
{
if(m_FirstPersonBlendOutSlider)
{
float TimeRemaining = CutSceneManager::GetInstance()->GetEndTime() - CutSceneManager::GetInstance()->GetTime();
m_FirstPersonBlendOutSlider->SetRange(0.0f, TimeRemaining);
}
}
atHashString CCutSceneDebugManager::FindCameraCutNameForTime(const atArray <cutfEvent*>& events, float time, s32 &EventIndex)
{
atHashString cameraCutName;
if(events.GetCount() > 0)
{
for ( int i = events.GetCount() - 1; i >= 0; --i )
{
if ( time >= events[i]->GetTime())
{
if (events[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( events[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pObjectVar)
{
cameraCutName = pObjectVar->GetName();
EventIndex = i;
return cameraCutName;
}
}
}
}
}
}
EventIndex = -1;
return cameraCutName;
}
atHashString CCutSceneDebugManager::FindNearestCameraCutNameForTime(const atArray <cutfEvent*>& events, float time, s32 &EventIndex)
{
atHashString cameraCutName;
atArray <cutfEvent*> cutEvents;
for(int i=0; i < events.GetCount(); i++)
{
if ( events[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
cutEvents.PushAndGrow(events[i]);
}
}
if(cutEvents.GetCount() > 0)
{
for ( int i = cutEvents.GetCount() - 1; i >= 0; --i )
{
if ( time >= cutEvents[i]->GetTime())
{
int index = i;
if(i < cutEvents.GetCount() - 1)
{
float SecondEventTimeDifference = ABS(time - cutEvents[i+1]->GetTime());
float firstEventTimeDifference = ABS(time - cutEvents[i]->GetTime());
if(SecondEventTimeDifference < firstEventTimeDifference)
{
index = i+1;
}
}
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( cutEvents[index]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pObjectVar)
{
cameraCutName = pObjectVar->GetName();
EventIndex = index;
return cameraCutName;
}
}
}
}
}
EventIndex = -1;
return cameraCutName;
}
float CCutSceneDebugManager::FindCameraCutTimeForTime(const atArray <cutfEvent*>& events, float time)
{
float cameraCutTime = -1.0f;
if(events.GetCount() > 0)
{
for ( int i = events.GetCount() - 1; i >= 0; --i )
{
if ( time >= events[i]->GetTime())
{
if (events[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
cameraCutTime = events[i]->GetTime();
return cameraCutTime;
}
}
}
}
return cameraCutTime;
}
const cutfEvent* CCutSceneDebugManager::FindCameraCutEventForTime(const atArray <cutfEvent*>& events, float time)
{
if(events.GetCount() > 0)
{
for ( int i = events.GetCount() - 1; i >= 0; --i )
{
if ( time >= events[i]->GetTime())
{
if (events[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
return events[i];
}
}
}
}
return NULL;
}
void CCutSceneDebugManager::SaveTimeCycleParamsEvent(const cutfObject* pObject)
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "Overlay Event: No cutf file object loaded cannot save"))
{
return;
}
if ( pObject == NULL )
{
return;
}
if(m_CameraCutsIndexEvents[m_iTimecycleEventsIndexId])
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( m_CameraCutsIndexEvents[m_iTimecycleEventsIndexId]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pObjectVar)
{
pObjectVar->SetReflectionLodRangeStart(ValidateTimeCycleParams(m_ReflectionLodRangeStart));
pObjectVar->SetReflectionLodRangeEnd(ValidateTimeCycleParams(m_ReflectionLodRangeEnd));
pObjectVar->SetReflectionSLodRangeStart(ValidateTimeCycleParams(m_ReflectionSLodRangeStart));
pObjectVar->SetReflectionSLodRangeEnd(ValidateTimeCycleParams(m_ReflectionSLodRangeEnd));
pObjectVar->SetLodMultHD(ValidateTimeCycleParams(m_LodMultHD));
pObjectVar->SetLodMultOrphanHD(ValidateTimeCycleParams(m_LodMultOrphanedHD));
pObjectVar->SetLodMultLod(ValidateTimeCycleParams(m_LodMultLod));
pObjectVar->SetLodMultSlod1(ValidateTimeCycleParams(m_LodMultSLod1));
pObjectVar->SetLodMultSlod2(ValidateTimeCycleParams(m_LodMultSLod2));
pObjectVar->SetLodMultSlod3(ValidateTimeCycleParams(m_LodMultSLod3));
pObjectVar->SetLodMultSlod4(ValidateTimeCycleParams(m_LodMultSLod4));
pObjectVar->SetWaterReflectionFarClip(ValidateTimeCycleParams(m_WaterReflectionFarClip));
pObjectVar->SetLightSSAOInten(ValidateTimeCycleParams(m_SSAOLightInten));
pObjectVar->SetMapLodScale(ValidateTimeCycleParams(m_LodMult));
pObjectVar->SetExposurePush(m_ExposurePush);
pObjectVar->SetDisableHighQualityDof(m_bDisableHighQualityDof);
pObjectVar->SetCharacterLightParams(m_CharacterLight);
pObjectVar->SetReflectionMapFrozen(m_FreezeReflectionMap);
pObjectVar->SetDirectionalLightDisabled(m_DisableDirectionalLight);
pObjectVar->SetLightFadeDistanceMult(m_LightFadeDistanceMult);
pObjectVar->SetLightShadowFadeDistanceMult(m_LightShadowFadeDistanceMult);
pObjectVar->SetLightSpecularFadeDistMult(m_LightSpecularFadeDistMult);
pObjectVar->SetLightVolumetricFadeDistanceMult(m_LightVolumetricFadeDistanceMult);
pObjectVar->SetAbsoluteIntensityEnabled(m_AbsoluteIntensityEnabled);
pObjectVar->SetDirectionalLightMultiplier(ValidateTimeCycleParams(m_DirectionalLightMultiplier));
pObjectVar->SetLensArtefactMultiplier(ValidateTimeCycleParams(m_LensArtefactMultiplier));
pObjectVar->SetBloomMax(ValidateTimeCycleParams(m_MaxBloom));
}
}
}
}
void CCascadeShadowBoundsDebug::Reset()
{
//rag control for commands
m_bSetCasCadeBoundsDepthBias = false;
m_bSetCasCadeBoundsSlopeBias = false;
m_bSetCasCadeBoundsShadowSample = false;
//Set cascade bounds
m_CascadeIndex = 0;
m_bCascadeBoundsEnabled = false;
m_CascadeBoundsPosition = VEC3_ZERO;
m_fCascadeBoundsScaleRadius = 0.0f;
m_EnableEntityTracker = false;
m_bEnableAirCraftMode = false;
m_bEnableDynamicDepthMode = false;
m_bEnableFlyCamMode = false;
//hFov
m_fBoundsHFov = 0.0f;
//vFov
m_fBoundsVFov = 0.0f;
m_fBoundScale = 0.0f;
m_fTrackerScale = 0.0f;
m_fSplitZExpWeight = 0.0f;
//World Height Update
m_bEnableWorldHeightUpdate = false;
//World Height
m_fWorldHeightMin = -20.0f;
m_fWorldHeightMax = 800.0f;
//Receiver Height Update
m_bEnableReceiverHeightUpdate = false;
//Receiver Height
m_fReceiveHeightMin = -20.0f;
m_fReceiveHeightMax = 800.0f;
//Dither Scale
m_fDitherScaleRadius = 1.0f;
//Depth Bias
m_bEnableDepthBias = false;
m_fDepthBias = 0.0f;
//Slope Bias
m_bEnableSlopeBias = false;
m_fSlopeBias = 0.0f;
//Shadow Sample
//m_ShadowSample;
m_ShadowSampleIndex = 0;
m_CascadeShadowsBoundEventsIndexId = 0;
m_pCascadeShadowsBoundEventsCombo = NULL;
m_pCascadeShadowsBoundPropertyEventsCombo = NULL;
m_CascadeShadowsBoundPropertyEventsIndexId = 0;
m_pCascadeShadowSampleEventsCombo = NULL;
m_pShadowFrameSlider = NULL;
m_UseCameraCutAsParent = true;
m_CascadeShadowsBoundIndexEvents.Reset();
}
void CCutSceneDebugManager::BankSaveLoadInteriorCallBack()
{
if (m_pAssetManagerList.GetCount() > 0)
{
const cutfObject* pObject = m_pAssetManagerList[0];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
SaveInteriorLoadEvent(pObject, CutSceneCustomEvents::CUTSCENE_LOAD_INTERIOR_EVENT);
//update the combo box of ped variation events
PopulateInteriorLoadEventList(pObject);
//Save the changes out to the cuttune file.
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
void CCutSceneDebugManager::SaveInteriorLoadEvent(const cutfObject* pObject, s32 UNUSED_PARAM(EventId))
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "SaveInteriorLoadEvent: No cutf file object loaded cannot save"))
{
return;
}
if ( pObject == NULL )
{
return;
}
atArray<cutfEvent *> EventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetLoadEventList(), EventList );
bool bAddNewEvent = true;
if(bAddNewEvent)
{
parAttributeList* pList = rage_new parAttributeList();
pList->AddAttribute("InteriorName", m_InteriorName);
pList->AddAttribute("InteriorPosX", m_InteriorPos.x);
pList->AddAttribute("InteriorPosY", m_InteriorPos.y);
pList->AddAttribute("InteriorPosZ", m_InteriorPos.z);
cutfEventArgs* pEventArgs = rage_new cutfEventArgs(*pList);
#if CUTSCENE_EXPORT_EVENTS_WITH_ZERO_BASE_TIME
float ftime = CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset();
#else
float ftime =CutSceneManager::GetInstance()-> GetCutSceneCurrentTime();
#endif
CutSceneManager::GetInstance()->GetCutfFile()->AddLoadEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), ftime, CutSceneCustomEvents::CUTSCENE_LOAD_INTERIOR_EVENT, pEventArgs ) );
CutSceneManager::GetInstance()->GetCutfFile()->SortLoadEvents();
}
}
void CCutSceneDebugManager::PopulateInteriorLoadEventList(const cutfObject* pObject)
{
if (m_pLoadInteriorIndexCombo == NULL)
{
return;
}
//Nothing selected
if(!pObject)
{
m_pLoadInteriorIndexCombo->UpdateCombo( "events", &m_LoadInteriorIndexId, 1, NULL );
m_pLoadInteriorIndexCombo->SetString( 0 , "none");
return;
}
atArray<cutfEvent *> AllEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetLoadEventList(), AllEventList );
atArray<cutfEvent *>EventList;
for(int i =0; i < AllEventList.GetCount(); i++)
{
//cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( AllEventList[i]->GetEventArgs() );
if(AllEventList[i]->GetEventId() == CutSceneCustomEvents::CUTSCENE_LOAD_INTERIOR_EVENT)
{
EventList.PushAndGrow(AllEventList[i]);
}
}
//look to edit a current event
if (EventList.GetCount() == 0)
{
m_pLoadInteriorIndexCombo->UpdateCombo( "Load Interior Index Events", &m_LoadInteriorIndexId, 1, NULL );
m_pLoadInteriorIndexCombo->SetString( 0 , "none");
}
else
{
if (EventList.GetCount() > 0)
{
m_pLoadInteriorIndexCombo->UpdateCombo( "Load Interior Index Events", &m_LoadInteriorIndexId, EventList.GetCount(), NULL );
//Clear the list of variations, need to repopulate.
for (int i=0; i < m_LoadInteriorIndexEvents.GetCount(); i++)
{
m_LoadInteriorIndexEvents[i] = NULL;
}
m_LoadInteriorIndexEvents.Reset();
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if (EventList[i]->GetEventId() == CutSceneCustomEvents::CUTSCENE_LOAD_INTERIOR_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( EventList[i]->GetEventArgs() );
char InteriorName[64];
Vector3 InteriorPos = VEC3_ZERO;
InteriorPos.x = pEventArgs->GetAttributeList().FindAttributeFloatValue("InteriorPosX", 0.0f, false);
InteriorPos.y = pEventArgs->GetAttributeList().FindAttributeFloatValue("InteriorPosY", 0.0f, false);
InteriorPos.z = pEventArgs->GetAttributeList().FindAttributeFloatValue("InteriorPosZ", 0.0f, false);
char EventInfo[128];
EventInfo[0] = '\0';
s32 FrameNumber = static_cast<s32>(EventList[i]->GetTime() * CUTSCENE_FPS);
formatf(EventInfo, sizeof(EventInfo)-1,"(%d) Load Interior: %s (Pos: %f,%f,%f)",
FrameNumber,
pEventArgs->GetAttributeList().FindAttributeStringValue("InteriorName", "",InteriorName, 64),
InteriorPos.x,
InteriorPos.y,
InteriorPos.z);
m_pLoadInteriorIndexCombo->SetString( i, EventInfo );
//Store a list of pointers to our objects
m_LoadInteriorIndexEvents.PushAndGrow(EventList[i]);
}
}
}
}
}
void CCutSceneDebugManager::BankDeleteLoadInteriorsCallBack()
{
if (m_LoadInteriorIndexEvents.GetCount() > 0)
{
if(m_LoadInteriorIndexEvents[m_LoadInteriorIndexId])
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveLoadEvent(m_LoadInteriorIndexEvents[m_LoadInteriorIndexId]);
PopulateInteriorLoadEventList(m_pAssetManagerList[0]);
CutSceneManager::GetInstance()->SaveCutfile();
}
}
}
void CCascadeShadowBoundsDebug::InitWidgets()
{
#if !SETUP_CUTSCENE_WIDGET_FOR_CONTENT_CONTROLLED_BUILD
bkBank* Ragebank = BANKMGR.FindBank("Cut Scene Debug");
bkGroup* CurrentSceneGrp = static_cast<bkGroup*>(BANKMGR.FindWidget("Cut Scene Debug/Current Scene/Camera Editing"));
if(Ragebank)
{
Ragebank->SetCurrentGroup(*CurrentSceneGrp);
Ragebank->PushGroup("Cascade shadow");
CutSceneManager::GetInstance()->CreateVCRWidget(Ragebank);
m_pShadowFrameSlider = Ragebank->AddSlider( "Current Frame", &CutSceneManager::GetInstance()->m_iCurrentFrameWithFrameRanges, 0, MAX_FRAMES, 1,
datCallback(MFA(CutSceneManager::BankFrameScrubbingCallback),CutSceneManager::GetInstance()) );
const char *List[] = { "(none)" };
m_pCascadeShadowsBoundEventsCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "Shadow Events", &m_CascadeShadowsBoundEventsIndexId, 1, List, datCallback(MFA(CCascadeShadowBoundsDebug::UpdateShadowBoxCombo), (datBase*)this)));
Ragebank->AddText("Current Cut:",&CutSceneManager::GetInstance()->GetDebugManager().m_CameraCutName[0], 32, true);
Ragebank->AddButton("Refresh Events",datCallback(MFA1(CCascadeShadowBoundsDebug::PopulateSetupShadowBoundsEventList), (datBase*)this));
Ragebank->PushGroup("SET_CASCADE_BOUNDS (Recommended Syncing to Cut Time)");
Ragebank->AddSlider("Cascade Index", &m_CascadeIndex, 0, 3, 1);
Ragebank->AddToggle("Enable", &m_bCascadeBoundsEnabled);
Ragebank->AddSlider("Position.x", &m_CascadeBoundsPosition.x, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddSlider("Position.y", &m_CascadeBoundsPosition.y, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddSlider("Position.z", &m_CascadeBoundsPosition.z, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddSlider("Scale Radius", &m_fCascadeBoundsScaleRadius, 0.0f, 9999.0f, 1.0f/32.0f);
Ragebank->AddButton("Get From Script Cascade Manual Control", datCallback(MFA(CCascadeShadowBoundsDebug::BankGetFromScriptCascadeManualControl), (datBase*)this));
Ragebank->AddButton("Send To Script Cascade Manual Control", datCallback(MFA(CCascadeShadowBoundsDebug::BankSendToScriptCascadeManualControl), (datBase*)this));
Ragebank->AddButton("Save Set Shadow Bounds Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT));
Ragebank->AddButton("Delete Set Shadow Bounds Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_RESET_CASCADE_SHADOWS");
Ragebank->AddButton("Save RESET_CASCADE_SHADOWS Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_RESET_CASCADE_SHADOWS));
Ragebank->AddButton("Delete RESET_CASCADE_SHADOWS Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER");
Ragebank->AddToggle("Set ENABLE_ENTITY_TRACKER Active", &m_EnableEntityTracker);
Ragebank->AddButton("Save ENABLE_ENTITY_TRACKER Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER));
Ragebank->AddButton("Delete ENABLE_ENTITY_TRACKER Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CASCADE_SHADOWS_SET_WORLD_HEIGHT_UPDATE");
Ragebank->AddToggle("set SET_WORLD_HEIGHT_UPDATE Active", &m_bEnableWorldHeightUpdate);
Ragebank->AddButton("Save SET_WORLD_HEIGHT_UPDATE Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_UPDATE));
Ragebank->AddButton("Delete SET_WORLD_HEIGHT_UPDATE Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_UPDATE");
Ragebank->AddToggle("Set SET_RECEIVER_HEIGHT_UPDATE Active", &m_bEnableReceiverHeightUpdate);
Ragebank->AddButton("Save SET_RECEIVER_HEIGHT_UPDATE Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_UPDATE));
Ragebank->AddButton("Delete SET_RECEIVER_HEIGHT_UPDATE Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CASCADE_SHADOWS_SET_AIRCRAFT_MODE");
Ragebank->AddToggle("set SET_AIRCRAFT_MODE Active", &m_bEnableAirCraftMode);
Ragebank->AddButton("Save SET_AIRCRAFT_MODE Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_AIRCRAFT_MODE));
Ragebank->AddButton("Delete SET_AIRCRAFT_MODE Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_MODE");
Ragebank->AddToggle("Set SET_DYNAMIC_DEPTH_MODE Active", &m_bEnableDynamicDepthMode);
Ragebank->AddButton("Save SET_DYNAMIC_DEPTH_MODE Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_MODE));
Ragebank->AddButton("Delete SET_DYNAMIC_DEPTH_MODE Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CASCADE_SHADOWS_SET_FLY_CAMERA_MODE");
Ragebank->AddToggle("Set SET_FLY_CAMERA_MODE Active", &m_bEnableFlyCamMode);
Ragebank->AddButton("Save SET_FLY_CAMERA_MODE Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_FLY_CAMERA_MODE));
Ragebank->AddButton("Delete SET_FLY_CAMERA_MODE Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_HFOV");
Ragebank->AddSlider("SET_CASCADE_BOUNDS_HFOV", &m_fBoundsHFov, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddButton("Save SET_CASCADE_BOUNDS_HFOV Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_HFOV));
Ragebank->AddButton("Delete SET_CASCADE_BOUNDS_HFOV Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_VFOV");
Ragebank->AddSlider("SET_CASCADE_BOUNDS_VFOV", &m_fBoundsVFov, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddButton("Save SET_CASCADE_BOUNDS_VFOV Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_VFOV));
Ragebank->AddButton("Delete SET_CASCADE_BOUNDS_VFOV Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE");
Ragebank->AddSlider("SET_CASCADE_BOUNDS_SCALE", &m_fBoundScale, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddButton("Save SET_CASCADE_BOUNDS_SCALE Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE));
Ragebank->AddButton("Delete SET_CASCADE_BOUNDS_SCALE Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE");
Ragebank->AddSlider("SET_ENTITY_TRACKER_SCALE", &m_fTrackerScale, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddButton("Save SET_ENTITY_TRACKER_SCALE Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE));
Ragebank->AddButton("Delete SET_ENTITY_TRACKER_SCALE Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_SPLIT_Z_EXP_WEIGHT");
Ragebank->AddSlider("SET_SPLIT_Z_EXP_WEIGHT", &m_fSplitZExpWeight, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddButton("Save SET_SPLIT_Z_EXP_WEIGHT Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_SPLIT_Z_EXP_WEIGHT));
Ragebank->AddButton("Delete SET_SPLIT_Z_EXP_WEIGHT Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_DITHER_RADIUS_SCALE");
Ragebank->AddSlider("SET_DITHER_RADIUS_SCALE", &m_fDitherScaleRadius, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddButton("Save SET_DITHER_RADIUS_SCALE Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_DITHER_RADIUS_SCALE));
Ragebank->AddButton("Delete SET_DITHER_RADIUS_SCALE Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_MINMAX");
Ragebank->AddSlider("SET_WORLD_HEIGHT_MIN", &m_fWorldHeightMin, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddSlider("SET_WORLD_HEIGHT_MAX", &m_fWorldHeightMax, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddButton("Save SET_WORLD_HEIGHT_MINMAX Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_MINMAX));
Ragebank->AddButton("Delete SET_WORLD_HEIGHT_MINMAX Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_MINMAX");
Ragebank->AddSlider("SET_RECEIVER_HEIGHT_MIN", &m_fReceiveHeightMin, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddSlider("SET_RECEIVER_HEIGHT_MAX", &m_fReceiveHeightMax, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddButton("Save SET_RECEIVER_HEIGHT_MINMAX Event ", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_MINMAX));
Ragebank->AddButton("Delete SET_RECEIVER_HEIGHT_MINMAX Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_DEPTH_BIAS");
Ragebank->AddToggle("OVERRIDE_DEPTH_BIAS", &m_bEnableDepthBias);
Ragebank->AddSlider("SET_DEPTH_BIAS", &m_fDepthBias, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddButton("Save SET_DEPTH_BIAS Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_DEPTH_BIAS));
Ragebank->AddButton("Delete SET_DEPTH_BIAS Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_SLOPE_BIAS");
Ragebank->AddToggle("OVERRIDE_SLOPE_BIAS", &m_bEnableSlopeBias);
Ragebank->AddSlider("SET_SLOPE_BIAS", &m_fSlopeBias, -10000.0f, 10000.0f, 1.0f);
Ragebank->AddButton("Save SET_SLOPE_BIAS Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_SLOPE_BIAS));
Ragebank->AddButton("Delete SET_SLOPE_BIAS Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("CUTSCENE_CASCADE_SHADOWS_SET_SHADOW_SAMPLE_TYPE");
m_pCascadeShadowSampleEventsCombo = dynamic_cast<bkCombo *>( Ragebank->AddCombo( "SHADOW_SAMPLE_TYPE", &m_ShadowSampleIndex, MAX_NUMBER_SHADOW_TYPES, ShadowSampleTypes ) );
Ragebank->AddButton("Save SET_SHADOW_SAMPLE_TYPE Event", datCallback(MFA1(CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack), (datBase*)this, (CallbackData)CUTSCENE_CASCADE_SHADOWS_SET_SHADOW_SAMPLE_TYPE));
Ragebank->AddButton("Delete SET_SHADOW_SAMPLE_TYPE Event", datCallback(MFA(CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack), (datBase*)this));
Ragebank->PopGroup();
Ragebank->PushGroup("Event Parenting");
Ragebank->AddToggle("Set Event Time To Current Camera Cut Event Time", &m_UseCameraCutAsParent);
Ragebank->PopGroup();
Ragebank->PopGroup();
Ragebank->UnSetCurrentGroup(*CurrentSceneGrp);
}
#endif
}
void CCascadeShadowBoundsDebug::DestroyWidgets()
{
m_pShadowFrameSlider = NULL;
m_pCascadeShadowsBoundEventsCombo = NULL;
m_pCascadeShadowSampleEventsCombo = NULL;
}
void CCascadeShadowBoundsDebug::BankGetFromScriptCascadeManualControl()
{
if (CutSceneManager::GetInstance()->IsPaused())
{
const cutfObject* pObject = CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList[0];
if (pObject)
{
#if CUTSCENE_EXPORT_EVENTS_WITH_ZERO_BASE_TIME
float fTime = CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset();
#else
float fTime = CutSceneManager::GetInstance()->GetCutSceneCurrentTime();
#endif
float fEventTime = fTime;
atArray<cutfEvent *> EventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly(pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), EventList);
s32 EventIndex;
atHashString cameraCutHash = CutSceneManager::GetInstance()->GetDebugManager().FindCameraCutNameForTime(EventList, CutSceneManager::GetInstance()-> GetCutSceneCurrentTime(), EventIndex);
if(m_UseCameraCutAsParent)
{
fEventTime = CutSceneManager::GetInstance()->GetDebugManager().FindCameraCutTimeForTime(EventList, fTime);
if(CutSceneManager::GetInstance()->GetCutSceneCurrentTime() == CutSceneManager::GetInstance()->GetEndTime())
{
fEventTime = CutSceneManager::GetInstance()->GetEndTime();
cameraCutHash.Clear();
cameraCutHash.SetFromString("endofscenecut");
}
else
{
fEventTime = CutSceneManager::GetInstance()->GetDebugManager().FindCameraCutTimeForTime(EventList, fTime);
}
}
/* Delete existing events */
for (int i = 0; i < EventList.GetCount(); i ++)
{
cutfEvent *pEvent = EventList[i];
if (pEvent && pEvent->GetEventId() == CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT)
{
const cutfEventArgs *pEventArgs = pEvent->GetEventArgs();
if (pEventArgs && pEventArgs->GetType() == CUTSCENE_CASCADE_SHADOW_EVENT_ARGS)
{
const cutfCascadeShadowEventArgs* pShadowEventArgs = static_cast< const cutfCascadeShadowEventArgs * >(pEventArgs);
if (pShadowEventArgs->GetCameraCutHash() == cameraCutHash)
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent(pEvent);
}
}
}
}
/* Create new events */
for (int iCascadeIndex = 0; iCascadeIndex < CASCADE_SHADOWS_COUNT; iCascadeIndex ++)
{
bool bIsEnabled = false;
float fCascadeBoundsPositionX = 0.0f, fCascadeBoundsPositionY = 0.0f, fCascadeBoundsPositionZ = 0.0f;
float fCascadeBoundsScaleRadius = 0.0f;
bool bLerpToDisabled = false;
float fLerpTime = 0.0f;
CRenderPhaseCascadeShadowsInterface::Script_GetCascadeBounds(iCascadeIndex, bIsEnabled, fCascadeBoundsPositionX, fCascadeBoundsPositionY, fCascadeBoundsPositionZ, fCascadeBoundsScaleRadius, bLerpToDisabled, fLerpTime);
Vector3 vCascadeBoundsPosition(fCascadeBoundsPositionX, fCascadeBoundsPositionY, fCascadeBoundsPositionZ);
if (bIsEnabled)
{
cutfEventArgs* pEventArgs = rage_new cutfCascadeShadowEventArgs(cameraCutHash, vCascadeBoundsPosition, fCascadeBoundsScaleRadius, fLerpTime, iCascadeIndex, bIsEnabled, bLerpToDisabled);
if (pEventArgs)
{
if (m_UseCameraCutAsParent)
{
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent(rage_new cutfObjectIdEvent(pObject->GetObjectId(), fEventTime, CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT, true, cameraCutHash, pEventArgs));
}
else
{
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent(rage_new cutfObjectIdEvent(pObject->GetObjectId(), fEventTime, CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT, false, 0, pEventArgs));
}
}
}
}
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
//update the combo box of ped variation events
PopulateSetShadowBoundsEventList(pObject);
UpdateShadowBoxCombo();
//Save the changes out to the cut tune file.
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
}
}
void CCascadeShadowBoundsDebug::BankSendToScriptCascadeManualControl()
{
if (CutSceneManager::GetInstance()->IsPaused())
{
s32 iCascadeShadowIndex = m_CascadeIndex;
bool bIsEnabled = m_bCascadeBoundsEnabled;
Vector3 vPosition = m_CascadeBoundsPosition;
float fRadius = m_fCascadeBoundsScaleRadius;
CRenderPhaseCascadeShadowsInterface::Script_SetCascadeBounds(iCascadeShadowIndex, bIsEnabled, vPosition.x, vPosition.y, vPosition.z, fRadius, true);
}
}
void CCascadeShadowBoundsDebug::BankSaveSetShadowBoundsEventCallBack(s32 Event)
{
if (CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList.GetCount() > 0)
{
const cutfObject* pObject = CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList[0];
if ((CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
if (Event==CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT)
{
// check if there's a matching shadow bounds event for this cut that we need to delete.
// first, grab the current camera cut name.
atArray<cutfEvent *> EventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), EventList );
s32 EventIndex;
atHashString cutHash = CutSceneManager::GetInstance()->GetDebugManager().FindCameraCutNameForTime(EventList, CutSceneManager::GetInstance()-> GetCutSceneCurrentTime(), EventIndex);
/* Try to find a matching event for the cascade index and camera cut name */
for(int i = 0; i < m_CascadeShadowsBoundIndexEvents.GetCount(); i ++)
{
cutfEvent *pTempEvent = m_CascadeShadowsBoundIndexEvents[i];
if(pTempEvent && pTempEvent->GetEventId() == CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT)
{
const cutfEventArgs *pTempEventArgs = pTempEvent->GetEventArgs();
if(pTempEventArgs && pTempEventArgs->GetType() == CUTSCENE_CASCADE_SHADOW_EVENT_ARGS)
{
const cutfCascadeShadowEventArgs *pTempShadowEventArgs = static_cast< const cutfCascadeShadowEventArgs * >(pTempEventArgs);
if(pTempShadowEventArgs->GetCameraCutHash() == cutHash && pTempShadowEventArgs->GetCascadeShadowIndex() == m_CascadeIndex)
{
// delete the matching event (since we need to replace it)
m_CascadeShadowsBoundEventsIndexId = i;
BankDeleteSetShadowBoundsEventCallBack();
break;
}
}
}
}
}
//Save the shadow bounds event into the event list
SaveSetShadowBoundsEvent(pObject, Event);
//update the combo box of shadow bound events
PopulateSetShadowBoundsEventList(pObject);
//Save the changes out to the cut tune file.
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
}
}
void CCascadeShadowBoundsDebug::BankDeleteSetShadowBoundsEventCallBack()
{
if (m_CascadeShadowsBoundEventsIndexId < m_CascadeShadowsBoundIndexEvents.GetCount() )
{
if(CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList.GetCount() > 0)
{
const cutfObject* pObject = CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList[0];
if(m_CascadeShadowsBoundIndexEvents[m_CascadeShadowsBoundEventsIndexId] && pObject)
{
cutfEvent* pEvent = m_CascadeShadowsBoundIndexEvents[m_CascadeShadowsBoundEventsIndexId];
if(pEvent)
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent(m_CascadeShadowsBoundIndexEvents[m_CascadeShadowsBoundEventsIndexId]);
PopulateSetShadowBoundsEventList(pObject);
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
}
}
}
}
void CCascadeShadowBoundsDebug::UpdateCascadeShadowDebugRender(const atHashString &cameraCutHash)
{
ClearCascadeShadowDebugRender();
const cutfObject *pObject = CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList[0];
if (pObject)
{
atArray< cutfEvent * > eventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly(pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), eventList);
for (int i = 0; i < eventList.GetCount(); i ++)
{
cutfEvent *pEvent = eventList[i];
if(pEvent && pEvent->GetEventId() == CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT)
{
const cutfEventArgs *pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_CASCADE_SHADOW_EVENT_ARGS)
{
const cutfCascadeShadowEventArgs *pShadowEventArgs = static_cast< const cutfCascadeShadowEventArgs * >(pEventArgs);
if(pShadowEventArgs && pShadowEventArgs->GetCameraCutHash() == cameraCutHash)
{
s32 iCascadeShadowIndex = pShadowEventArgs->GetCascadeShadowIndex();
bool bIsEnabled = pShadowEventArgs->GetIsEnabled();
Vector3 vPosition = pShadowEventArgs->GetPosition();
float fRadius = pShadowEventArgs->GetRadius();
CRenderPhaseCascadeShadowsInterface::Script_SetCascadeBounds(iCascadeShadowIndex, bIsEnabled, vPosition.x, vPosition.y, vPosition.z, fRadius, true);
}
}
}
}
}
}
void CCascadeShadowBoundsDebug::ClearCascadeShadowDebugRender()
{
for(int iCascadeShadowIndex = 0; iCascadeShadowIndex < CASCADE_SHADOWS_COUNT; iCascadeShadowIndex ++)
{
CRenderPhaseCascadeShadowsInterface::Script_SetCascadeBounds(iCascadeShadowIndex, false, 0.0f, 0.0f, 0.0f, 0.0f, true);
}
}
void CCascadeShadowBoundsDebug::SelectShadowEvent(const atHashString &cameraCutHash)
{
if(CutSceneManager::GetInstance()->IsPlaying())
{
for(int i = 0; i < m_CascadeShadowsBoundIndexEvents.GetCount(); i ++)
{
cutfEvent *pEvent = m_CascadeShadowsBoundIndexEvents[i];
if(pEvent && pEvent->GetEventId() == CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT)
{
const cutfEventArgs *pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_CASCADE_SHADOW_EVENT_ARGS)
{
const cutfCascadeShadowEventArgs *pCascadeShadowEventArgs = static_cast< const cutfCascadeShadowEventArgs * >(pEventArgs);
if(pCascadeShadowEventArgs->GetCameraCutHash() == cameraCutHash)
{
m_CascadeShadowsBoundEventsIndexId = i;
UpdateShadowBoxCombo();
break;
}
}
}
}
}
}
void CCascadeShadowBoundsDebug::UpdateShadowBoxCombo()
{
if(m_CascadeShadowsBoundEventsIndexId > -1 && m_CascadeShadowsBoundEventsIndexId < m_CascadeShadowsBoundIndexEvents.GetCount())
{
cutfEvent* pEvent = m_CascadeShadowsBoundIndexEvents[m_CascadeShadowsBoundEventsIndexId];
if(pEvent)
{
s32 iEventId = pEvent->GetEventId();
switch(iEventId)
{
case CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_CASCADE_SHADOW_EVENT_ARGS)
{
const cutfCascadeShadowEventArgs* pShadowEventArgs = static_cast<const cutfCascadeShadowEventArgs*>(pEventArgs);
m_CascadeIndex = pShadowEventArgs->GetCascadeShadowIndex();
m_bCascadeBoundsEnabled = pShadowEventArgs->GetIsEnabled();
m_CascadeBoundsPosition = pShadowEventArgs->GetPosition();
m_fCascadeBoundsScaleRadius = pShadowEventArgs->GetRadius();
UpdateCascadeShadowDebugRender(pShadowEventArgs->GetCameraCutHash());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pShadowEventArgs = static_cast<const cutfBoolValueEventArgs*>(pEventArgs);
m_EnableEntityTracker = pShadowEventArgs->GetValue();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_UPDATE:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pShadowEventArgs = static_cast<const cutfBoolValueEventArgs*>(pEventArgs);
m_bEnableWorldHeightUpdate = pShadowEventArgs->GetValue();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_UPDATE:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pShadowEventArgs = static_cast<const cutfBoolValueEventArgs*>(pEventArgs);
m_bEnableReceiverHeightUpdate = pShadowEventArgs->GetValue();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_AIRCRAFT_MODE:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pShadowEventArgs = static_cast<const cutfBoolValueEventArgs*>(pEventArgs);
m_bEnableAirCraftMode = pShadowEventArgs->GetValue();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_MODE:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pShadowEventArgs = static_cast<const cutfBoolValueEventArgs*>(pEventArgs);
m_bEnableDynamicDepthMode = pShadowEventArgs->GetValue();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_FLY_CAMERA_MODE:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pShadowEventArgs = static_cast<const cutfBoolValueEventArgs*>(pEventArgs);
m_bEnableFlyCamMode = pShadowEventArgs->GetValue();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_HFOV:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pShadowEventArgs = static_cast<const cutfFloatValueEventArgs*>(pEventArgs);
m_fBoundsHFov = pShadowEventArgs->GetFloat1();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_VFOV:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pShadowEventArgs = static_cast<const cutfFloatValueEventArgs*>(pEventArgs);
m_fBoundsVFov = pShadowEventArgs->GetFloat1();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pShadowEventArgs = static_cast<const cutfFloatValueEventArgs*>(pEventArgs);
m_fBoundScale = pShadowEventArgs->GetFloat1();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pShadowEventArgs = static_cast<const cutfFloatValueEventArgs*>(pEventArgs);
m_fTrackerScale = pShadowEventArgs->GetFloat1();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_SPLIT_Z_EXP_WEIGHT:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pShadowEventArgs = static_cast<const cutfFloatValueEventArgs*>(pEventArgs);
m_fSplitZExpWeight = pShadowEventArgs->GetFloat1();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_DITHER_RADIUS_SCALE:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pShadowEventArgs = static_cast<const cutfFloatValueEventArgs*>(pEventArgs);
m_fDitherScaleRadius = pShadowEventArgs->GetFloat1();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_MINMAX:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_TWO_FLOAT_VALUES_EVENT_ARGS_TYPE)
{
const cutfTwoFloatValuesEventArgs* pShadowEventArgs = static_cast<const cutfTwoFloatValuesEventArgs*>(pEventArgs);
m_fWorldHeightMin = pShadowEventArgs->GetFloat1();
m_fWorldHeightMax = pShadowEventArgs->GetFloat2();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_MINMAX:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_TWO_FLOAT_VALUES_EVENT_ARGS_TYPE)
{
const cutfTwoFloatValuesEventArgs* pShadowEventArgs = static_cast<const cutfTwoFloatValuesEventArgs*>(pEventArgs);
m_fReceiveHeightMin = pShadowEventArgs->GetFloat1();
m_fReceiveHeightMax = pShadowEventArgs->GetFloat2();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_SLOPE_BIAS:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_FLOAT_BOOL_EVENT_ARGS_TYPE)
{
const cutfFloatBoolValueEventArgs* pShadowEventArgs = static_cast<const cutfFloatBoolValueEventArgs*>(pEventArgs);
m_fSlopeBias = pShadowEventArgs->GetFloat1();
m_bEnableSlopeBias = pShadowEventArgs->GetValue();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_DEPTH_BIAS:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_FLOAT_BOOL_EVENT_ARGS_TYPE)
{
const cutfFloatBoolValueEventArgs* pShadowEventArgs = static_cast<const cutfFloatBoolValueEventArgs*>(pEventArgs);
m_fDepthBias = pShadowEventArgs->GetFloat1();
m_bEnableDepthBias = pShadowEventArgs->GetValue();
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_SHADOW_SAMPLE_TYPE:
{
const cutfEventArgs* pEventArgs = pEvent->GetEventArgs();
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_NAME_EVENT_ARGS_TYPE)
{
const cutfNameEventArgs* pShadowEventArgs = static_cast<const cutfNameEventArgs*>(pEventArgs);
u32 NameHash = pShadowEventArgs->GetName().GetHash();
for(int i=0; i < MAX_NUMBER_SHADOW_TYPES; i++)
{
u32 selectedShadowHash = atStringHash(ShadowSampleTypes[i]);
if(NameHash == selectedShadowHash)
{
m_ShadowSampleIndex = i;
break;
}
}
}
}
break;
}
if(iEventId != CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT)
{
ClearCascadeShadowDebugRender();
}
}
}
}
void CCascadeShadowBoundsDebug::PopulateSetupShadowBoundsEventList()
{
if(CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList.GetCount() > 0)
{
const cutfObject* pObject = CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList[0];
if (pObject)
PopulateSetShadowBoundsEventList(pObject);
}
}
void CCascadeShadowBoundsDebug::SaveSetShadowBoundsEvent(const cutfObject* pObject, s32 iEventId)
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "Overlay Event: No cutf file object loaded cannot save"))
{
return;
}
if ( pObject == NULL )
{
return;
}
atArray<cutfEvent *> EventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), EventList );
s32 EventIndex;
atHashString cutHash = CutSceneManager::GetInstance()->GetDebugManager().FindCameraCutNameForTime(EventList, CutSceneManager::GetInstance()-> GetCutSceneCurrentTime(), EventIndex);
#if CUTSCENE_EXPORT_EVENTS_WITH_ZERO_BASE_TIME
float ftime = CutSceneManager::GetInstance()->GetCutSceneTimeWithRangeOffset();
#else
float ftime =CutSceneManager::GetInstance()->GetCutSceneCurrentTime();
#endif
float fEventTime = ftime;
if(m_UseCameraCutAsParent)
{
fEventTime = CutSceneManager::GetInstance()->GetDebugManager().FindCameraCutTimeForTime(EventList, ftime);
if(CutSceneManager::GetInstance()->GetCutSceneCurrentTime() == CutSceneManager::GetInstance()->GetEndTime())
{
fEventTime = CutSceneManager::GetInstance()->GetEndTime();
cutHash.Clear();
cutHash.SetFromString("endofscenecut");
}
else
{
fEventTime = CutSceneManager::GetInstance()->GetDebugManager().FindCameraCutTimeForTime(EventList, ftime);
}
}
cutfEventArgs* pEventArgs = NULL;
switch(iEventId)
{
case CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT:
{
pEventArgs = rage_new cutfCascadeShadowEventArgs( cutHash, m_CascadeBoundsPosition, m_fCascadeBoundsScaleRadius, 0.0f, m_CascadeIndex, m_bCascadeBoundsEnabled, true);
}
break;
case CUTSCENE_CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER:
{
pEventArgs = rage_new cutfBoolValueEventArgs(m_EnableEntityTracker);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_UPDATE:
{
pEventArgs = rage_new cutfBoolValueEventArgs(m_bEnableWorldHeightUpdate);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_UPDATE:
{
pEventArgs = rage_new cutfBoolValueEventArgs(m_bEnableReceiverHeightUpdate);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_AIRCRAFT_MODE:
{
pEventArgs = rage_new cutfBoolValueEventArgs(m_bEnableAirCraftMode);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_MODE:
{
pEventArgs = rage_new cutfBoolValueEventArgs(m_bEnableDynamicDepthMode);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_FLY_CAMERA_MODE:
{
pEventArgs = rage_new cutfBoolValueEventArgs(m_bEnableFlyCamMode);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_HFOV:
{
pEventArgs = rage_new cutfFloatValueEventArgs(m_fBoundsHFov);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_VFOV:
{
pEventArgs = rage_new cutfFloatValueEventArgs(m_fBoundsVFov);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE:
{
pEventArgs = rage_new cutfFloatValueEventArgs(m_fBoundScale);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE:
{
pEventArgs = rage_new cutfFloatValueEventArgs(m_fTrackerScale);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_SPLIT_Z_EXP_WEIGHT:
{
pEventArgs = rage_new cutfFloatValueEventArgs(m_fSplitZExpWeight);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_DITHER_RADIUS_SCALE:
{
pEventArgs = rage_new cutfFloatValueEventArgs(m_fDitherScaleRadius);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_MINMAX:
{
pEventArgs = rage_new cutfTwoFloatValuesEventArgs(m_fWorldHeightMin, m_fWorldHeightMax);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_MINMAX:
{
pEventArgs = rage_new cutfTwoFloatValuesEventArgs(m_fReceiveHeightMin, m_fReceiveHeightMax);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_SLOPE_BIAS:
{
pEventArgs = rage_new cutfFloatBoolValueEventArgs(m_fSlopeBias, m_bEnableSlopeBias);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_DEPTH_BIAS:
{
pEventArgs = rage_new cutfFloatBoolValueEventArgs(m_fDepthBias, m_bEnableDepthBias);
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_SHADOW_SAMPLE_TYPE:
{
if(m_ShadowSampleIndex >= 0 && m_ShadowSampleIndex < MAX_NUMBER_SHADOW_TYPES )
{
pEventArgs = rage_new cutfNameEventArgs(ShadowSampleTypes[m_ShadowSampleIndex]);
}
else
{
cutsceneAssertf(0, "trying to write an invalid shadow sample type, index out of bounds of sample type array");
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_RESET_CASCADE_SHADOWS:
{
pEventArgs = rage_new cutfBoolValueEventArgs(true);
}
break;
}
Assertf(pEventArgs, "Must add any new event to SaveSetShadowBoundsEvent, must specify an event args or specify none");
if(pEventArgs)
{
if(m_UseCameraCutAsParent)
{
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), fEventTime, iEventId, true, cutHash, pEventArgs ) );
}
else
{
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), fEventTime, iEventId, false, 0, pEventArgs ) );
}
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
}
}
void CCascadeShadowBoundsDebug::PopulateSetShadowBoundsEventList(const cutfObject* pObject)
{
if (m_pCascadeShadowsBoundEventsCombo == NULL)
{
return;
}
//Nothing selected
if(!pObject)
{
m_CascadeShadowsBoundEventsIndexId = 0;
m_pCascadeShadowsBoundEventsCombo->UpdateCombo( "events", &m_CascadeShadowsBoundEventsIndexId, 1, 0, datCallback(MFA(CCascadeShadowBoundsDebug::UpdateShadowBoxCombo), (datBase*)this) );
m_pCascadeShadowsBoundEventsCombo->SetString( 0 , "none");
return;
}
atArray<cutfEvent *> AllEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), AllEventList );
atArray<cutfEvent *>EventList;
for(int i =0; i < AllEventList.GetCount(); i++)
{
//cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( AllEventList[i]->GetEventArgs() );
if(AllEventList[i]->GetEventId() == CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_UPDATE ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_UPDATE ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_AIRCRAFT_MODE ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_MODE ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_FLY_CAMERA_MODE ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_HFOV ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_VFOV ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_SPLIT_Z_EXP_WEIGHT ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DITHER_RADIUS_SCALE ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_MINMAX ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_MINMAX ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_SLOPE_BIAS||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DEPTH_BIAS||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_SHADOW_SAMPLE_TYPE ||
AllEventList[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_RESET_CASCADE_SHADOWS)
{
EventList.PushAndGrow(AllEventList[i]);
}
}
//look to edit a current event
if (EventList.GetCount() == 0)
{
m_pCascadeShadowsBoundEventsCombo->UpdateCombo( "Cascade shadow bounds events", &m_CascadeShadowsBoundEventsIndexId, 1, 0, datCallback(MFA(CCascadeShadowBoundsDebug::UpdateShadowBoxCombo), (datBase*)this) );
m_pCascadeShadowsBoundEventsCombo->SetString( 0 , "none");
}
else
{
if (EventList.GetCount() > 0)
{
//limit so we dont go over the bounds
if(m_CascadeShadowsBoundEventsIndexId == EventList.GetCount())
{
m_CascadeShadowsBoundEventsIndexId = EventList.GetCount() -1;
}
m_pCascadeShadowsBoundEventsCombo->UpdateCombo( "Cascade shadow bounds events", &m_CascadeShadowsBoundEventsIndexId, EventList.GetCount(), 0, datCallback(MFA(CCascadeShadowBoundsDebug::UpdateShadowBoxCombo), (datBase*)this) );
//Clear the list of variations, need to repopulate.
for (int i=0; i < m_CascadeShadowsBoundIndexEvents.GetCount(); i++)
{
m_CascadeShadowsBoundIndexEvents[i] = NULL;
}
m_CascadeShadowsBoundIndexEvents.Reset();
for ( int i = 0; i < EventList.GetCount(); ++i )
{
if(EventList[i])
{
const cutfEventArgs* pArgs = EventList[i]->GetEventArgs();
char EventInfo[128];
EventInfo[0] = '\0';
float FrameTime = EventList[i]->GetTime();
s32 FrameNumber = static_cast<s32>(FrameTime * CUTSCENE_FPS);
switch(EventList[i]->GetEventId())
{
case CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT:
{
if(pArgs && pArgs->GetType() == CUTSCENE_CASCADE_SHADOW_EVENT_ARGS)
{
const cutfCascadeShadowEventArgs* pEventArgs = static_cast< const cutfCascadeShadowEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_CASCADE_BOUNDS: index:%d, Active:%d, Pos:%.2f,%.2f,%.2f (%s)",
FrameTime, FrameNumber,
pEventArgs->GetCascadeShadowIndex(),
pEventArgs->GetIsEnabled(),
pEventArgs->GetPosition().x,
pEventArgs->GetPosition().y,
pEventArgs->GetPosition().z,
pEventArgs->GetCameraCutHash().GetCStr());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_RESET_CASCADE_SHADOWS:
{
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) RESET_CASCADE_SHADOWS", FrameTime, FrameNumber);
}
break;
case CUTSCENE_CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER:
{
if(pArgs && pArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pEventArgs = static_cast< const cutfBoolValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) ENABLE_ENTITY_TRACKER: %d ", FrameTime, FrameNumber, pEventArgs->GetValue());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_UPDATE:
{
if(pArgs && pArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pEventArgs = static_cast< const cutfBoolValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_WORLD_HEIGHT_UPDATE: %d",FrameTime, FrameNumber, pEventArgs->GetValue());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_UPDATE:
{
if(pArgs && pArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pEventArgs = static_cast< const cutfBoolValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_RECEIVER_HEIGHT_UPDATE: %d", FrameTime, FrameNumber, pEventArgs->GetValue());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_AIRCRAFT_MODE:
{
if(pArgs && pArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pEventArgs = static_cast< const cutfBoolValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_AIRCRAFT_MODE: %d", FrameTime, FrameNumber, pEventArgs->GetValue());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_MODE:
{
if(pArgs && pArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pEventArgs = static_cast< const cutfBoolValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_DYNAMIC_DEPTH_MODE: %d", FrameTime, FrameNumber, pEventArgs->GetValue());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_FLY_CAMERA_MODE:
{
if(pArgs && pArgs->GetType() == CUTSCENE_BOOL_VALUE_EVENT_ARGS_TYPE)
{
const cutfBoolValueEventArgs* pEventArgs = static_cast< const cutfBoolValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_FLY_CAMERA_MODE: %d", FrameTime, FrameNumber, pEventArgs->GetValue());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_HFOV:
{
if(pArgs && pArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pEventArgs = static_cast< const cutfFloatValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) CASCADE_BOUNDS_HFOV: %f", FrameTime, FrameNumber, pEventArgs->GetFloat1());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_VFOV:
{
if(pArgs && pArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pEventArgs = static_cast< const cutfFloatValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) CASCADE_BOUNDS_VFOV: %f", FrameTime, FrameNumber, pEventArgs->GetFloat1());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE:
{
if(pArgs && pArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pEventArgs = static_cast< const cutfFloatValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) CASCADE_BOUNDS_SCALE: %f", FrameTime, FrameNumber, pEventArgs->GetFloat1());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE:
{
if(pArgs && pArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pEventArgs = static_cast< const cutfFloatValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) ENTITY_TRACKER_SCALE: %f", FrameTime, FrameNumber, pEventArgs->GetFloat1());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_SPLIT_Z_EXP_WEIGHT:
{
if(pArgs && pArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pEventArgs = static_cast< const cutfFloatValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SPLIT_Z_EXP_WEIGHT: %f", FrameTime, FrameNumber, pEventArgs->GetFloat1());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_DITHER_RADIUS_SCALE:
{
if(pArgs && pArgs->GetType() == CUTSCENE_FLOAT_VALUE_EVENT_ARGS_TYPE)
{
const cutfFloatValueEventArgs* pEventArgs = static_cast< const cutfFloatValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) DITHER_RADIUS_SCALE: %f", FrameTime, FrameNumber, pEventArgs->GetFloat1());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_MINMAX:
{
if(pArgs && pArgs->GetType() == CUTSCENE_TWO_FLOAT_VALUES_EVENT_ARGS_TYPE)
{
const cutfTwoFloatValuesEventArgs* pEventArgs = static_cast< const cutfTwoFloatValuesEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_WORLD_HEIGHT_MINMAX: %f, %f", FrameTime, FrameNumber, pEventArgs->GetFloat1(), pEventArgs->GetFloat2());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_MINMAX:
{
if(pArgs && pArgs->GetType() == CUTSCENE_TWO_FLOAT_VALUES_EVENT_ARGS_TYPE)
{
const cutfTwoFloatValuesEventArgs* pEventArgs = static_cast< const cutfTwoFloatValuesEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_RECEIVER_HEIGHT_MINMAX: %f, %f", FrameTime, FrameNumber, pEventArgs->GetFloat1(), pEventArgs->GetFloat2());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_SLOPE_BIAS:
{
if(pArgs && pArgs->GetType() == CUTSCENE_FLOAT_BOOL_EVENT_ARGS_TYPE)
{
const cutfFloatBoolValueEventArgs* pEventArgs = static_cast< const cutfFloatBoolValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_SLOPE_BIAS: %d, %f", FrameTime, FrameNumber, pEventArgs->GetFloat1(), pEventArgs->GetValue());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_DEPTH_BIAS:
{
if(pArgs && pArgs->GetType() == CUTSCENE_FLOAT_BOOL_EVENT_ARGS_TYPE)
{
const cutfFloatBoolValueEventArgs* pEventArgs = static_cast< const cutfFloatBoolValueEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_DEPTH_BIAS: %d, %f", FrameTime, FrameNumber, pEventArgs->GetFloat1(), pEventArgs->GetValue());
}
}
break;
case CUTSCENE_CASCADE_SHADOWS_SET_SHADOW_SAMPLE_TYPE:
{
if(pArgs && pArgs->GetType() == CUTSCENE_NAME_EVENT_ARGS_TYPE)
{
const cutfNameEventArgs* pEventArgs = static_cast< const cutfNameEventArgs*>(pArgs);
formatf(EventInfo, sizeof(EventInfo)-1,"(%.2f %d) SET_SHADOW_SAMPLE_TYPE: %s", FrameTime, FrameNumber, pEventArgs->GetName().GetCStr());
}
}
break;
}
m_pCascadeShadowsBoundEventsCombo->SetString( i, EventInfo );
//Store a list of pointers to our objects
m_CascadeShadowsBoundIndexEvents.PushAndGrow(EventList[i]);
}
}
}
}
};
float FindTimeForCameraCutName(const atArray <cutfEvent*>& events, const char* cutname)
{
atHashString cameraCutName;
if(events.GetCount() > 0)
{
for ( int i = events.GetCount() - 1; i >= 0; --i )
{
if (events[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( events[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pObjectVar)
{
atHashString cameraCutName = pObjectVar->GetName();
if ( cameraCutName == cutname)
{
return events[i]->GetTime();
}
}
}
}
}
}
return -1.f;
}
void CCutSceneDebugManager::ToggleNightCoCOverrides()
{
if(m_bShouldSetCoCForAllDay)
{
m_bShouldSetCoCForAllNight = false;
m_bShouldUseRangeForCoC = false;
DeleteCoCDayRangeSelectorWidgets();
}
}
void CCutSceneDebugManager::ToggleDayCoCOverrides()
{
if(m_bShouldSetCoCForAllNight)
{
m_bShouldSetCoCForAllDay = false;
m_bShouldUseRangeForCoC = false;
DeleteCoCDayRangeSelectorWidgets();
}
}
void CCutSceneDebugManager::ToggleDayRangeCoCOverrides()
{
if(m_bShouldUseRangeForCoC)
{
CreateCoCHourSelectorWidgets();
m_bShouldSetCoCForAllDay = false;
m_bShouldSetCoCForAllNight = false;
}
else
{
DeleteCoCDayRangeSelectorWidgets();
}
}
void CCutSceneDebugManager::DeleteCoCDayRangeSelectorWidgets()
{
if(m_pHoursGrp)
{
m_pHoursGrp->Destroy();
m_pHoursGrp = NULL;
}
}
void CCutSceneDebugManager::CreateCoCHourSelectorWidgets()
{
bkBank* Ragebank = BANKMGR.FindBank("Cut Scene Debug");
bkGroup* CameraGrp = static_cast<bkGroup*>(BANKMGR.FindWidget("Cut Scene Debug/Current Scene/Camera Editing/Camera Overrides/Scene Day CoC Hours"));
if(Ragebank && CameraGrp)
{
if(m_pHoursGrp == NULL)
{
if(CutSceneManager::GetInstance())
{
cutfCutsceneFile2* pFile = CutSceneManager::GetInstance()->GetCutfFile();
if(pFile)
{
m_DayCoCHours = pFile->GetDayCoCHours();
}
}
Ragebank->SetCurrentGroup(*CameraGrp);
m_pHoursGrp = Ragebank->PushGroup("Hours");
for(int i = 0; i < 24; i++)
{
char name[24];
if(i == 0)
{
formatf(name, sizeof(name)-1, "Hour %d (Midnight)", i);
}
else if(i == 12)
{
formatf(name, sizeof(name)-1, "Hour %d (Midday)", i);
}
else
{
formatf(name, sizeof(name)-1, "Hour %d", i);
}
u32 bitsPerBlock = sizeof(u32) * 8;
int block = i / bitsPerBlock;
int bitInBlock = i - (block * bitsPerBlock);
Ragebank->AddToggle(name, &m_DayCoCHours, (u32)(1 << bitInBlock));
}
Ragebank->PopGroup();
Ragebank->UnSetCurrentGroup(*CameraGrp);
}
}
}
void CCutSceneDebugManager::SaveDayCoCValues()
{
if(CutSceneManager::GetInstance())
{
cutfCutsceneFile2* pFile = CutSceneManager::GetInstance()->GetCutfFile();
if(pFile)
{
//set all the values to be day 0 - 23
if(m_bShouldSetCoCForAllDay)
{
pFile->SetDayCoCHours(16777215);
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
//set
else if(m_bShouldSetCoCForAllNight)
{
pFile->SetDayCoCHours(0);
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
else if(m_bShouldUseRangeForCoC)
{
pFile->SetDayCoCHours(m_DayCoCHours);
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
}
}
}
void CCutSceneDebugManager::UpdateHourSliderToDayHours()
{
if(m_UseDayCoCHoursForModifier)
{
m_UseNightCoCHoursForModifier = false;
if(CutSceneManager::GetInstance())
{
cutfCutsceneFile2* pFile = CutSceneManager::GetInstance()->GetCutfFile();
if(pFile)
{
m_CoCModifierHours = pFile->GetDayCoCHours();
}
}
}
}
void CCutSceneDebugManager::UpdateHourSliderToNightHours()
{
if(m_UseNightCoCHoursForModifier)
{
m_UseDayCoCHoursForModifier = false;
if(CutSceneManager::GetInstance())
{
cutfCutsceneFile2* pFile = CutSceneManager::GetInstance()->GetCutfFile();
if(pFile)
{
u32 HourFlags = pFile->GetDayCoCHours(); ;
u32 NewHours = 0;
for(int i =0 ; i < 24; i++)
{
if (!(HourFlags & (1 << i)))
{
NewHours = NewHours | 1<<i;
}
}
m_CoCModifierHours = NewHours;
}
}
}
}
void CCutSceneDebugManager::BankSaveCoCModifierCallBack()
{
if (CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList.GetCount() > 0)
{
const cutfObject* pObject = CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList[0];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
SaveCoCModifier();
//update the combo box of ped variation events
UpdateCoCModifierEventOverridesCB();
//Save the changes out to the cut tune file.
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
}
}
void CCutSceneDebugManager::BankSaveAllCoCModifiersCallBack()
{
if (CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList.GetCount() > 0)
{
const cutfObject* pObject = CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList[0];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
//Save the ped variation into the event list
SaveAllCoCModifiers();
//update the combo box of ped variation events
UpdateCoCModifierEventOverridesCB();
//Save the changes out to the cut tune file.
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
}
}
void CCutSceneDebugManager::DeleteCoCModifierCallBack()
{
if(m_CameraCutsIndexEvents[m_iCoCModifiersCamerCutComboIndexId])
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( m_CameraCutsIndexEvents[m_iCoCModifiersCamerCutComboIndexId]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pObjectVar->GetCoCModifierList().GetCount() > 0)
{
pObjectVar->RemoveCoCModifier(m_iCoCModifierIndex);
UpdateCoCModifierEventOverridesCB();
}
}
}
}
void CCutSceneDebugManager::DeleteAllCoCModifierOverrideCallBack()
{
for(int i = 0; i < m_CameraCutsIndexEvents.GetCount(); i++)
{
if(m_CameraCutsIndexEvents[i])
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( m_CameraCutsIndexEvents[i]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pObjectVar->GetCoCModifierList().GetCount() > 0)
{
for(int j =0; j < pObjectVar->GetCoCModifierList().GetCount(); j++)
{
pObjectVar->RemoveCoCModifier(j);
}
m_iCoCModifiersCamerCutComboIndexId = i;
UpdateCoCModifierEventOverridesCB();
}
}
}
}
}
void CCutSceneDebugManager::SaveCoCModifier()
{
if(m_iCoCModifiersCamerCutComboIndexId < m_CameraCutsIndexEvents.GetCount())
{
if(m_CameraCutsIndexEvents[m_iCoCModifiersCamerCutComboIndexId])
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( m_CameraCutsIndexEvents[m_iCoCModifiersCamerCutComboIndexId]->GetEventArgs() );
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE)
{
if(m_CoCModifier != 0)
{
if(m_CoCModifierHours !=0)
{
cutfCameraCutEventArgs* pCameraCutEventArgs = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pCameraCutEventArgs->AddCoCModifier(m_CoCModifierHours, m_CoCModifier))
{
if(m_pSaveStatusText)
{
m_pSaveStatusText->SetString("Save Success");
}
}
else
{
if(m_pSaveStatusText)
{
m_pSaveStatusText->SetString("Save Fail - Cannot add CoC Modifier with the same hours");
}
}
}
else
{
if(m_pSaveStatusText)
{
m_pSaveStatusText->SetString("Save Fail - Cannot add CoC Modifier with no hour values");
}
}
}
else
{
if(m_pSaveStatusText)
{
m_pSaveStatusText->SetString("Save Fail - Cannot add CoC Modifier with 0");
}
}
}
}
}
}
void CCutSceneDebugManager::SaveAllCoCModifiers()
{
for(int i =0; i < m_CameraCutsIndexEvents.GetCount(); i++)
{
m_iCoCModifiersCamerCutComboIndexId = i;
SaveCoCModifier();
}
}
void CCutSceneDebugManager::UpdateAllCoCModifierEventOverridesCB()
{
if (m_AllCoCModifiersCombo == NULL)
{
return;
}
m_iAllCoCModifierIndex = 0;
u32 eventCountIndex = 0;
u32 TotalEventCount = 0;
bool NoEvents = true;
for(int k=0; k < m_CameraCutsIndexEvents.GetCount(); k++)
{
if(m_CameraCutsIndexEvents[k])
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( m_CameraCutsIndexEvents[k]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pObjectVar->GetCoCModifierList().GetCount() > 0)
{
TotalEventCount += pObjectVar->GetCoCModifierList().GetCount();
m_AllCoCModifiersCombo->UpdateCombo("All CoC Modifiers (READ ONLY)", &m_iAllCoCModifierIndex, TotalEventCount, NULL );
NoEvents = false;
for(int i=0; i < pObjectVar->GetCoCModifierList().GetCount(); i++)
{
char EventInfo[128];
EventInfo[0] = '\0';
//u32 m_TimeOfDayFlags;
//s32 m_DofStrengthModifier;
u32 HourFlags = pObjectVar->GetCoCModifierList()[i].m_TimeOfDayFlags;
char Hours[128];
atString atHours;
for(int j =0 ; j < 24; j++)
{
if (HourFlags & (1 << j))
{
formatf(Hours, sizeof(Hours)-1,"%d,",j);
atHours += Hours;
}
}
formatf(EventInfo, sizeof(EventInfo), "%s: CoC Modifier %d: Hours: %s",pObjectVar->GetName().GetCStr(), pObjectVar->GetCoCModifierList()[i].m_DofStrengthModifier, atHours.c_str());
m_AllCoCModifiersCombo->SetString(eventCountIndex, EventInfo);
eventCountIndex++;
}
}
}
}
}
if(NoEvents)
{
m_iAllCoCModifierIndex = 0;
m_AllCoCModifiersCombo->UpdateCombo( "All CoC Modifiers (READ ONLY)", &m_iAllCoCModifierIndex, 1, NULL );
m_AllCoCModifiersCombo->SetString( 0 , "none");
}
}
void CCutSceneDebugManager::UpdateCoCModifierEventOverridesCB()
{
if (m_pCoCModifiersCameraCutCombo == NULL)
{
return;
}
if(m_CameraCutsIndexEvents[m_iCoCModifiersCamerCutComboIndexId])
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( m_CameraCutsIndexEvents[m_iCoCModifiersCamerCutComboIndexId]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pObjectVar->GetCoCModifierList().GetCount() > 0)
{
m_iCoCModifierIndex = 0;
m_pPerCutCoCModifiersCombo->UpdateCombo( "Per Camera Cut CoC Modifiers", &m_iCoCModifierIndex, pObjectVar->GetCoCModifierList().GetCount(), NULL );
for(int i=0; i < pObjectVar->GetCoCModifierList().GetCount(); i++)
{
char EventInfo[128];
EventInfo[0] = '\0';
//u32 m_TimeOfDayFlags;
//s32 m_DofStrengthModifier;
u32 HourFlags = pObjectVar->GetCoCModifierList()[i].m_TimeOfDayFlags;
char Hours[128];
atString atHours;
for(int j =0 ; j < 24; j++)
{
if (HourFlags & (1 << j))
{
formatf(Hours, sizeof(Hours)-1,"%d,",j);
atHours += Hours;
}
}
formatf(EventInfo, sizeof(EventInfo), "%s: CoC Modifier %d: Hours: %s",pObjectVar->GetName().GetCStr(), pObjectVar->GetCoCModifierList()[i].m_DofStrengthModifier, atHours.c_str());
m_pPerCutCoCModifiersCombo->SetString(i, EventInfo);
}
}
else
{
m_iCoCModifierIndex = 0;
m_pPerCutCoCModifiersCombo->UpdateCombo( "Per Camera Cut CoC Modifiers", &m_iCoCModifierIndex, 1, NULL );
m_pPerCutCoCModifiersCombo->SetString( 0 , "none");
}
}
}
UpdateAllCoCModifierEventOverridesCB();
}
//void CCutSceneDebugManager::PopulateTimeOfDofModifiers()
//{
// if (m_pTimeOfDayDofOverrideCombo == NULL)
// {
// return;
// }
//
// //Nothing selected
// if(!pObject)
// {
// m_pTimeOfDayDofOverrideCombo->UpdateCombo( "TimeOfDayDofOverrides", &m_iTimeOfDayDofOverrideIndex, 1, NULL );
// m_pTimeOfDayDofOverrideCombo->SetString( 0 , "none");
// return;
// }
//
// atArray<cutfEvent *> AllEventList;
// CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), AllEventList );
//
// atArray<cutfEvent *>EventList;
//
// for(int i =0; i < AllEventList.GetCount(); i++)
// {
// //cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( AllEventList[i]->GetEventArgs() );
// if(AllEventList[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
// {
// EventList.PushAndGrow(AllEventList[i]);
// }
// }
//
// //look to edit a current event
// if (EventList.GetCount() == 0)
// {
// m_pTimeOfDayDofOverrideCombo->UpdateCombo( "TimeOfDayDofOverrides", &m_iTimeOfDayDofOverrideIndex, 1, NULL );
// m_pTimeOfDayDofOverrideCombo->SetString( 0 , "none");
// }
// else
// {
// if (EventList.GetCount() > 0)
// {
// m_iTimeOfDayDofOverrideIndex = 0;
// s32 NumEvents = 0;
//
// for(int i = 0; i < EventList.GetCount(); i++)
// {
// if(EventList[i] && EventList[i]->GetEventArgs() && EventList[i]->GetEventArgs().GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
// {
// const cutfCameraCutEventArgs* pCamCutEventArgs = static_cast<const cutfCameraCutEventArgs*>(EventList[i]->GetEventArgs());
//
// for( int j=0; j < pCamCutEventArgs->GetCoCModifierList().GetCount(); i++)
// {
// NumEvents++;
// }
// }
// }
//
// if(m_iTimeOfDayDofOverrideIndex == NumEvents)
// {
// m_iTimeOfDayDofOverrideIndex = NumEvents-1;
// }
//
// m_pTimeOfDayDofOverrideCombo->UpdateCombo( "Cascade shadow bounds events", &m_iTimeOfDayDofOverrideIndex, NumEvents, NULL );
//
// //Clear the list of variations, need to repopulate.
// for(int i = 0; i < EventList.GetCount(); i++)
// {
// m_CascadeShadowsBoundIndexEvents[i] = NULL;
// }
//
// m_CascadeShadowsBoundIndexEvents.Reset();
// }
//}
void CCutSceneDebugManager::WriteOutAllDynamicDepthEvents(const atArray<CutNearShadowDepth>& depths )
{
if (CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList.GetCount() > 0)
{
const cutfObject* pObject = CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList[0];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
SaveDynamicDepthEventsToCutscene( depths, pObject);
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
}
}
void CCutSceneDebugManager::ClearAllDynamicDepthEvents()
{
if (CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList.GetCount() > 0)
{
const cutfObject* pObject = CutSceneManager::GetInstance()->GetDebugManager().m_CameraObjectList[0];
if ( (CutSceneManager::GetInstance()->IsPaused() || CutSceneManager::GetInstance()->IsPlaying()) && pObject)
{
atArray<cutfEvent *> events;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), events );
for ( int i = events.GetCount() - 1; i >= 0; --i )
{
if (events[i]->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_VALUE)
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent( events[i]);
}
}
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
}
}
//Save the changes out to the cut tune file.
void CCutSceneDebugManager::SaveDynamicDepthEventsToCutscene( const atArray<CutNearShadowDepth>& depths, const cutfObject* pObject)
{
if(!Verifyf(CutSceneManager::GetInstance()->GetCutfFile(), "Overlay Event: No cutf file object loaded cannot save"))
{
return;
}
atArray<cutfEvent *> EventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( pObject->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), EventList );
for (int i=0; i<depths.GetCount(); i++){
float eventTime = FindTimeForCameraCutName( EventList, depths[i].m_name);
if ( eventTime >= 0)
{
Displayf(" Adding %s at time %f", depths[i].m_name, eventTime );
cutfEventArgs* pEventArgs = rage_new cutfFloatValueEventArgs(depths[i].m_minNearDepth);
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( pObject->GetObjectId(), eventTime, CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_VALUE, pEventArgs ) );
}
}
}
// PROFILING
bool CCutSceneDebugManager::IsLightDisabled(const CLightSource &light)
{
u32 flags = light.GetFlags();
// two main groups (cutscene and non-cutscene lights)
if (m_bProfilingDisableCsLights && (flags & LIGHTFLAG_CUTSCENE))
{
return true;
}
return false;
}
void CCutSceneDebugManager::ValidateCutscene()
{
const CutSceneManager* pConstCutsceneManager = const_cast<const CutSceneManager*>(CutSceneManager::GetInstance());
const cutfCutsceneFile2* pCutfile = pConstCutsceneManager->GetCutfFile();
if (pCutfile && CutSceneManager::GetInstance()->GetCamEntity() && CutSceneManager::GetInstance()->GetAnimManager())
{
static const crTag::Key TagKeyBlock = crTag::CalcKey("Block", 0xE433D77D);
//float fAccumulatedSectionStartTime = 0.0f;
//float fAccumulatedDuration = 0.0f;
float fStartTimeOfInterest = 0.0f;
float fEndTimeOfInterest = 0.0f;
//create enough requests for the number of sections
for(int i = 0; i < pConstCutsceneManager->GetSectionStartTimeList().GetCount(); i++ )
{
char dictName[CUTSCENE_LONG_OBJNAMELEN];
if(CutSceneManager::GetInstance()->GetCutsceneName())
{
if ( CutSceneManager::GetInstance()->GetAnimManager()->GetSectionedName(
dictName, CUTSCENE_LONG_OBJNAMELEN, CutSceneManager::GetInstance()->GetCutsceneName(), i, CutSceneManager::GetInstance()->GetSectionStartTimeList().GetCount() ) )
{
strLocalIndex iAnimDictIndex = strLocalIndex(fwAnimManager::FindSlot(dictName));
if (cutsceneVerifyf(iAnimDictIndex != -1 , "Clip dict %s has returned an invalid slot, will not attempt to load this dict" , dictName))
{
if (cutsceneVerifyf(CStreaming::IsObjectInImage(iAnimDictIndex, fwAnimManager::GetStreamingModuleId()), "Clip dict %s is not in the image" , dictName))
{
fwAnimManager::StreamingRequest(iAnimDictIndex, STRFLAG_FORCE_LOAD | STRFLAG_PRIORITY_LOAD | STRFLAG_DONTDELETE);
CStreaming::LoadAllRequestedObjects();
if ( CStreaming::HasObjectLoaded(iAnimDictIndex, fwAnimManager::GetStreamingModuleId()) )
{
cutsceneDisplayf("Loaded Clip dict %s", dictName);
crClipDictionary* pClipDict = fwAnimManager::Get(iAnimDictIndex);
if (pClipDict)
{
u32 AnimBase = CutSceneManager::GetInstance()->GetCamEntity()->GetCameraObject()->GetAnimStreamingBase();
u32 FinalHashString = 0;
if ( CutSceneManager::GetInstance()->GetAnimManager()->GetSectionedName( AnimBase, FinalHashString, i, CutSceneManager::GetInstance()->GetSectionStartTimeList().GetCount()) )
{
float fSectionStartTime = pConstCutsceneManager->GetSectionStartTimeList()[i];
float fTotalDuration = pConstCutsceneManager->GetCutfFile()->GetTotalDuration();
fStartTimeOfInterest = fSectionStartTime;
const crClip* pClip = pClipDict->GetClip(FinalHashString);
if(pClip)
{
crTagIterator it(*pClip->GetTags(), TagKeyBlock);
while(*it)
{
const crTag* tagBlock = static_cast<const crTag*>(*it);
float fStartTime = pClip->ConvertPhaseToTime(tagBlock->GetStart()) + fSectionStartTime;
float fEndTime = pClip->ConvertPhaseToTime(tagBlock->GetEnd()) + fSectionStartTime;
//
// Search from last time to upto the new blocking tag
//
fEndTimeOfInterest = fStartTime;
const atArray<cutfEvent *>& eventList = pCutfile->GetEventList();
for ( int i = 0; i < eventList.GetCount(); ++i )
{
if (eventList[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( eventList[i]->GetEventArgs());
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE)
{
float fEventTime = eventList[i]->GetTime();
if (fEventTime > fStartTimeOfInterest && fEventTime < fEndTimeOfInterest)
{
cutsceneDisplayf("Camera cut event: T(%.6f), F(%.6f), P(%.6f)\n",
fEventTime,
fEventTime * 30.0f,
fEventTime/fTotalDuration);
}
}
}
}
//
// Search from the start of the new blocking tag to the end of the new blocking tag
//
fStartTimeOfInterest = fStartTime;
fEndTimeOfInterest = fEndTime;
cutsceneDisplayf("Start Camera Blocking Tag: T(%.6f), F(%.6f), P(%.6f)\n",
fStartTime,
fStartTime * 30.0f,
fStartTime/fTotalDuration);
for ( int i = 0; i < eventList.GetCount(); ++i )
{
if (eventList[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( eventList[i]->GetEventArgs());
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE)
{
float fEventTime = eventList[i]->GetTime();
if (fEventTime > fStartTimeOfInterest && fEventTime < fEndTimeOfInterest)
{
cutsceneDisplayf("Camera cut event: T(%.6f), F(%.6f), P(%.6f)\n",
fEventTime,
fEventTime * 30.0f,
fEventTime/fTotalDuration);
}
}
}
}
cutsceneDisplayf("End Camera Blocking Tag: T(%.6f), F(%.6f), P(%.6f)\n",
fEndTime,
fEndTime * 30.0f,
fEndTime/fTotalDuration);
// Remember the end time for the next search
fStartTimeOfInterest = fEndTime;
++it;
}
}
}
}
}
}
}
}
}
}
//create enough requests for the number of sections
for(int i = 0; i < pConstCutsceneManager->GetSectionStartTimeList().GetCount(); i++ )
{
char dictName[CUTSCENE_LONG_OBJNAMELEN];
if(CutSceneManager::GetInstance()->GetCutsceneName())
{
if ( CutSceneManager::GetInstance()->GetAnimManager()->GetSectionedName(
dictName, CUTSCENE_LONG_OBJNAMELEN, CutSceneManager::GetInstance()->GetCutsceneName(), i, CutSceneManager::GetInstance()->GetSectionStartTimeList().GetCount() ) )
{
strLocalIndex iAnimDictIndex = fwAnimManager::FindSlot(dictName);
if (cutsceneVerifyf(iAnimDictIndex != -1 , "Clip dict %s has returned an invalid slot, will not attempt to load this dict" , dictName))
{
if (cutsceneVerifyf(CStreaming::IsObjectInImage(iAnimDictIndex, fwAnimManager::GetStreamingModuleId()), "Clip dict %s is not in the image" , dictName))
{
g_ClipDictionaryStore.ClearRequiredFlag(iAnimDictIndex.Get(), STRFLAG_DONTDELETE);
}
}
}
}
}
}
}
void CCutSceneDebugManager::BatchProcessCutfilesInMemory()
{
cutsceneDisplayf("Begin in memory cutfile event validation.");
CCutSceneDebugManager::IterateCutfile(MakeFunctor(*this, &CCutSceneDebugManager::ProcessCutfilesInMemory));
cutsceneDisplayf("In memory cutfile event validation complete.");
}
void CCutSceneDebugManager::IterateCutfile(CCutfileIteratorCallback callback)
{
m_NumberOfFailedScene = 0;
for (s32 c = 0; c < g_CutSceneStore.GetSize(); c++)
{
cutfCutsceneFile2Def* pNameDef = g_CutSceneStore.GetSlot(strLocalIndex(c));
if(pNameDef)
{
atHashString cutfilename(pNameDef->m_name.GetCStr());
strLocalIndex iIndex = g_CutSceneStore.FindSlotFromHashKey(cutfilename.GetHash());
if (Verifyf((iIndex != -1), "Cut scene doesn't exist, and will not be loaded"))
{
//if (g_CutSceneStore.LoadFile(iIndex, pNameDef->m_name.GetCStr()) )
if(g_CutSceneStore.StreamingBlockingLoad(iIndex, STRFLAG_FORCE_LOAD|STRFLAG_PRIORITY_LOAD))
{
g_CutSceneStore.AddRef(iIndex, REF_OTHER);
cutfCutsceneFile2Def* pDef = g_CutSceneStore.GetSlot(iIndex);
if(pDef)
{
cutfCutsceneFile2* pCutfile = pDef->m_pObject;
if(pCutfile)
{
callback(pCutfile, cutfilename);
}
//g_CutSceneStore.Remove(iIndex);
}
g_CutSceneStore.RemoveRef(iIndex, REF_OTHER);
g_CutSceneStore.ClearRequiredFlag(iIndex.Get(),STRFLAG_CUTSCENE_REQUIRED);
g_CutSceneStore.StreamingRemove(iIndex);
}
}
}
}
Displayf("Number of scenes failing validation: %d", m_NumberOfFailedScene);
}
void CCutSceneDebugManager::ValidateEventInThisScene()
{
if(CutSceneManager::GetInstance()->GetCutfFile())
{
cutsceneDisplayf("Validating: %s", CutSceneManager::GetInstance()->GetSceneHashString()->GetCStr());
atHashString sceneName( CutSceneManager::GetInstance()->GetSceneHashString()->GetCStr());
ProcessCutfilesInMemory(CutSceneManager::GetInstance()->GetCutfFile(), sceneName);
}
}
void CCutSceneDebugManager::AddCutAttributesToShadowEvents(cutfCutsceneFile2* pCutfFile, atHashString sceneName)
{
bool SaveGameData = false;
const atArray< cutfEvent * > &eventList = pCutfFile->GetEventList();
atArray<const cutfObject*> cameraObjectList;
s32 CameraObjectId =-1;
pCutfFile->FindObjectsOfType(CUTSCENE_CAMERA_OBJECT_TYPE, cameraObjectList );
if(cameraObjectList.GetCount() > 0)
{
CameraObjectId = cameraObjectList[0]->GetObjectId();
}
if(eventList.GetCount() > 0 && CameraObjectId > -1)
{
for(int i=0; i<eventList.GetCount(); i++)
{
cutfEvent *pShadowEvent = eventList[i];
if(pShadowEvent)
{
if(pShadowEvent->GetEventId() == CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_UPDATE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_UPDATE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_AIRCRAFT_MODE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_MODE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_FLY_CAMERA_MODE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_HFOV ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_VFOV ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_SPLIT_Z_EXP_WEIGHT||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DITHER_RADIUS_SCALE||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_MINMAX||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_MINMAX||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DEPTH_BIAS||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_SLOPE_BIAS||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_SHADOW_SAMPLE_TYPE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_VALUE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_RESET_CASCADE_SHADOWS)
{
s32 eventIndex;
atHashString cameraCutName = FindNearestCameraCutNameForTime(eventList, pShadowEvent->GetTime() , eventIndex);
if(eventIndex > -1)
{
const cutfEventArgs* pEventArgs = pShadowEvent->GetEventArgs();
if(pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_RESET_CASCADE_SHADOWS)
{
parAttributeList CutAttribute;
CutAttribute.AddAttribute("CamCut", cameraCutName.GetCStr());
cutfEventArgs* pNewEventArgs = rage_new cutfBoolValueEventArgs(true, CutAttribute);
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( CameraObjectId, pShadowEvent->GetTime(), CUTSCENE_CASCADE_SHADOWS_RESET_CASCADE_SHADOWS, pNewEventArgs ) );
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent(pShadowEvent);
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
pEventArgs = pNewEventArgs;
}
if(pEventArgs)
{
parAttributeList& pAttributeList = const_cast<parAttributeList&>(pEventArgs->GetAttributeList());
if(!pAttributeList.FindAttribute("CamCut"))
{
pAttributeList.AddAttribute("CamCut", cameraCutName.GetCStr());
SaveGameData = true;
}
}
}
}
}
}
}
if(SaveGameData)
{
if(CutSceneManager::GetInstance()->IsCutscenePlayingBack())
{
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
else
{
CutSceneManager::GetInstance()->cOrignalSceneName = sceneName.GetCStr();
CutSceneManager::GetInstance()->SetCutfFile(pCutfFile);
CutSceneManager::GetInstance()->SaveGameDataCutfile();
CutSceneManager::GetInstance()->SetCutfFile(NULL);
CutSceneManager::GetInstance()->cOrignalSceneName.Clear();
}
}
}
void CCutSceneDebugManager::PopulateFirstPersonEventCameraComboBox()
{
if(m_firstPersonBlendOutComboSlider)
{
m_firstPersonBlendOutComboIndex = 0;
if(m_BlendOutEvents.GetCount() == 0)
{
if(m_firstPersonBlendOutComboSlider)
{
m_firstPersonBlendOutComboSlider->UpdateCombo( "First person Camera Event", &m_firstPersonBlendOutComboIndex, 1, NULL);
m_firstPersonBlendOutComboSlider->SetString( 0, "");
return;
}
}
else
{
m_firstPersonBlendOutComboIndex =0;
}
m_firstPersonBlendOutComboSlider->UpdateCombo( "First person Camera Event", &m_firstPersonBlendOutComboIndex, m_BlendOutEvents.GetCount(), NULL);
for ( int i = 0; i < m_BlendOutEvents.GetCount(); ++i )
{
if(m_BlendOutEvents[i]->GetEventId() == CUTSCENE_FIRST_PERSON_BLENDOUT_CAMERA_EVENT)
{
const cutfFloatValueEventArgs* pEventArgs = static_cast<const cutfFloatValueEventArgs*> (m_BlendOutEvents[i]->GetEventArgs());
atVarString Event("CUTSCENE_FIRST_PERSON_BLENDOUT_CAMERA_EVENT: Time: %f, Duration: %f Concat Section: %d", m_BlendOutEvents[i]->GetTime(),
pEventArgs->GetFloat1(), CutSceneManager::GetInstance()->GetConcatSectionForTime(m_BlendOutEvents[i]->GetTime()));
m_firstPersonBlendOutComboSlider->SetString( i, Event.c_str());
}
if(m_BlendOutEvents[i]->GetEventId() == CUTSCENE_FIRST_PERSON_CATCHUP_CAMERA_EVENT)
{
atVarString Event("CUTSCENE_FIRST_PERSON_CATCHUP_CAMERA_EVENT: Time: %f, Concat Section: %d", m_BlendOutEvents[i]->GetTime(),
CutSceneManager::GetInstance()->GetConcatSectionForTime(m_BlendOutEvents[i]->GetTime()));
m_firstPersonBlendOutComboSlider->SetString( i, Event.c_str());
}
}
}
}
bool CCutSceneDebugManager::CanAddEventFirstPersonCameraEvent()
{
bool canAddEventForConcatSection = true;
if(CutSceneManager::GetInstance()->IsConcatted())
{
for(int i=0; i < m_BlendOutEvents.GetCount(); i++)
{
int ConcatSectionForTime = CutSceneManager::GetInstance()->GetConcatSectionForTime(CutSceneManager::GetInstance()->GetTime());
if(ConcatSectionForTime != -1)
{
int concatsecionForEvent = CutSceneManager::GetInstance()->GetConcatSectionForTime(m_BlendOutEvents[i]->GetTime());
if(concatsecionForEvent == ConcatSectionForTime)
{
canAddEventForConcatSection = false;
if(m_firstPersonEventStatus)
{
m_firstPersonEventStatus->SetString("ADD EVENT FAIL: CAN ONLY HAVE ONE FIRST PERSON CAMERA EVENT PER CONCAT SECTION, PLEASE DELETE CURRENT EVENT");
}
}
}
else
{
if(m_firstPersonEventStatus)
{
m_firstPersonEventStatus->SetString("ADD EVENT FAIL: TRYING TO ADD AN EVENT TO AN INVALID SECTION");
}
cutsceneAssertf(0, "AddFirstPersonBlendOutEvent:: Trying to add event to an invalid section");
canAddEventForConcatSection = false;
}
}
}
else
{
if(m_BlendOutEvents.GetCount() > 0)
{
canAddEventForConcatSection = false;
if(m_firstPersonEventStatus)
{
m_firstPersonEventStatus->SetString("ADD EVENT FAIL: CAN ONLY HAVE ONE FIRST PERSON CAMERA EVENT PER CONCAT SECTION, PLEASE DELETE CURRENT EVENT");
}
}
}
return canAddEventForConcatSection;
}
void CCutSceneDebugManager::AddFirstPersonBlendOutEvent()
{
if(m_CameraObjectList.GetCount() > 0 && m_CameraObjectList[0])
{
if(CanAddEventFirstPersonCameraEvent())
{
cutfFloatValueEventArgs* pEventArgs = rage_new cutfFloatValueEventArgs(m_firstPersonCameraBlendDuration);
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( m_CameraObjectList[0]->GetObjectId(), CutSceneManager::GetInstance()->GetTime(), CUTSCENE_FIRST_PERSON_BLENDOUT_CAMERA_EVENT, pEventArgs ) );
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
CCutSceneCameraEntity* pCamera = static_cast<CCutSceneCameraEntity*>(CutSceneManager::GetInstance()->GetEntityByObjectId( m_CameraObjectList[0]->GetObjectId()));
pCamera->SetCameraHasFirstPersonBlendOutEvent(true);
UpdateFirstPersonEventList();
if(m_firstPersonEventStatus)
{
m_firstPersonEventStatus->SetString("SUCCESSFULLY ADDED EVENT - NOT SAVED");
}
}
}
}
void CCutSceneDebugManager::AddFirstPersonCatchUpEvent()
{
if(m_CameraObjectList.GetCount() > 0 && m_CameraObjectList[0])
{
if(CanAddEventFirstPersonCameraEvent())
{
CutSceneManager::GetInstance()->GetCutfFile()->AddEvent( rage_new cutfObjectIdEvent( m_CameraObjectList[0]->GetObjectId(), CutSceneManager::GetInstance()->GetTime(), CUTSCENE_FIRST_PERSON_CATCHUP_CAMERA_EVENT, NULL ) );
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
CCutSceneCameraEntity* pCamera = static_cast<CCutSceneCameraEntity*>(CutSceneManager::GetInstance()->GetEntityByObjectId( m_CameraObjectList[0]->GetObjectId()));
if(pCamera)
{
pCamera->SetCameraHasFirstPersonBlendOutEvent(true);
}
UpdateFirstPersonEventList();
if(m_firstPersonEventStatus)
{
m_firstPersonEventStatus->SetString("SUCCESSFULLY ADDED EVENT - NOT SAVED");
}
}
}
}
void CCutSceneDebugManager::DeleteFirstPersonCameraEvent()
{
if(m_firstPersonBlendOutComboIndex < m_BlendOutEvents.GetCount())
{
if(m_BlendOutEvents[m_firstPersonBlendOutComboIndex])
{
CutSceneManager::GetInstance()->GetCutfFile()->RemoveEvent(m_BlendOutEvents[m_firstPersonBlendOutComboIndex]);
CutSceneManager::GetInstance()->GetCutfFile()->SortEvents();
CCutSceneCameraEntity* pCamera = static_cast<CCutSceneCameraEntity*>(CutSceneManager::GetInstance()->GetEntityByObjectId( m_CameraObjectList[0]->GetObjectId()));
if(pCamera)
{
pCamera->SetCameraHasFirstPersonBlendOutEvent(false);
}
if(m_firstPersonEventStatus)
{
m_firstPersonEventStatus->SetString("SUCCESSFULLY DELETED EVENT - NOT SAVED");
}
UpdateFirstPersonEventList();
}
}
}
void CCutSceneDebugManager::SaveFirstPersonCameraEvents()
{
CutSceneManager::GetInstance()->SaveGameDataCutfile();
if(m_firstPersonEventStatus)
{
m_firstPersonEventStatus->SetString("SAVED");
}
}
void CCutSceneDebugManager::UpdateFirstPersonEventList()
{
if(m_CameraObjectList.GetCount() > 0 && m_CameraObjectList[0])
{
for(int i=0; i<m_BlendOutEvents.GetCount(); i++)
{
m_BlendOutEvents[i] = NULL;
}
m_BlendOutEvents.Reset();
if(CutSceneManager::GetInstance()->GetCutfFile())
{
atArray<cutfEvent *> AllEventList;
CutSceneManager::GetInstance()->GetCutfFile()->FindEventsForObjectIdOnly( m_CameraObjectList[0]->GetObjectId(), CutSceneManager::GetInstance()->GetCutfFile()->GetEventList(), AllEventList );
for(int i =0; i < AllEventList.GetCount(); i++)
{
if(AllEventList[i]->GetEventId() == CUTSCENE_FIRST_PERSON_BLENDOUT_CAMERA_EVENT || AllEventList[i]->GetEventId() == CUTSCENE_FIRST_PERSON_CATCHUP_CAMERA_EVENT )
{
m_BlendOutEvents.PushAndGrow(AllEventList[i]);
}
}
}
}
else
{
m_BlendOutEvents.Reset();
}
PopulateFirstPersonEventCameraComboBox();
}
void CCutSceneDebugManager::ProcessCutfilesInMemory(cutfCutsceneFile2* pCutfile, atHashString sceneName)
{
if(pCutfile)
{
bool success = true;
atVector<CameraCutBlockingTagInfo> TagInfo;
if(m_cutfileValidationProcesses[CVP_SHADOW_EVENTS] || m_cutfileValidationProcesses[CVP_LIGHT_EVENTS])
{
ValidateCameraCutData(pCutfile, sceneName, TagInfo);
}
if (m_cutfileValidationProcesses[CVP_SHADOW_EVENTS] || m_cutfileValidationProcesses[CVP_FIX_SHADOW_EVENTS])
{
success = ValidateShadowData(pCutfile, sceneName, TagInfo, m_cutfileValidationProcesses[CVP_FIX_SHADOW_EVENTS]);
}
if (m_cutfileValidationProcesses[CVP_LIGHT_EVENTS])
{
success = ValidateLightData(pCutfile, sceneName, TagInfo);
}
if(!success)
{
m_NumberOfFailedScene++;
}
}
}
void CCutSceneDebugManager::ValidateCameraCutData(cutfCutsceneFile2* pCutfile, atHashString sceneName, atVector<CameraCutBlockingTagInfo> &BlockingTagInfo )
{
//const CutSceneManager* pConstCutsceneManager = const_cast<const CutSceneManager*>(CutSceneManager::GetInstance());
//const cutfCutsceneFile2* pCutfile = pConstCutsceneManager->GetCutfFile();
const atArray< cutfObject * > &objectList = pCutfile->GetObjectList();
cutfObject *pObject = NULL;
CCutSceneAnimMgrEntity* pAnimManager = NULL;
CCutSceneCameraEntity* pCamEntity = NULL;
atArray<float> fSectionStartTimeList;
pCutfile->GetCurrentSectionTimeList( fSectionStartTimeList );
for(int i = 0; i < objectList.GetCount(); i ++)
{
pObject = objectList[i];
if(Verifyf(pObject, "pObject is NULL!") && pObject->GetType() == CUTSCENE_ANIMATION_MANAGER_OBJECT_TYPE)
{
pAnimManager = rage_new CCutSceneAnimMgrEntity ( pObject);
}
if(Verifyf(pObject, "pObject is NULL!") && pObject->GetType() == CUTSCENE_CAMERA_OBJECT_TYPE)
{
pCamEntity = rage_new CCutSceneCameraEntity ( pObject);
}
}
if (pCutfile && pCamEntity && pAnimManager)
{
static const crTag::Key TagKeyBlock = crTag::CalcKey("Block", 0xE433D77D);
//float fAccumulatedSectionStartTime = 0.0f;
//float fAccumulatedDuration = 0.0f;
float fStartTimeOfInterest = 0.0f;
float fEndTimeOfInterest = 0.0f;
//create enough requests for the number of sections
for(int i = 0; i < fSectionStartTimeList.GetCount(); i++ )
{
char dictName[CUTSCENE_LONG_OBJNAMELEN];
if(sceneName.GetCStr())
{
if ( pAnimManager->GetSectionedName(
dictName, CUTSCENE_LONG_OBJNAMELEN, sceneName.GetCStr(), i, fSectionStartTimeList.GetCount() ) )
{
strLocalIndex iAnimDictIndex = strLocalIndex(fwAnimManager::FindSlot(dictName));
if (cutsceneVerifyf(iAnimDictIndex != -1 , "Clip dict %s has returned an invalid slot, will not attempt to load this dict" , dictName))
{
if (cutsceneVerifyf(CStreaming::IsObjectInImage(iAnimDictIndex, fwAnimManager::GetStreamingModuleId()), "Clip dict %s is not in the image" , dictName))
{
fwAnimManager::StreamingRequest(iAnimDictIndex, STRFLAG_FORCE_LOAD | STRFLAG_PRIORITY_LOAD | STRFLAG_DONTDELETE);
CStreaming::LoadAllRequestedObjects();
if ( CStreaming::HasObjectLoaded(iAnimDictIndex, fwAnimManager::GetStreamingModuleId()) )
{
// cutsceneDisplayf("Loaded Clip dict %s", dictName);
crClipDictionary* pClipDict = fwAnimManager::Get(iAnimDictIndex);
if (pClipDict)
{
u32 AnimBase = pCamEntity->GetCameraObject()->GetAnimStreamingBase();
u32 FinalHashString = 0;
if ( pAnimManager->GetSectionedName( AnimBase, FinalHashString, i, fSectionStartTimeList.GetCount()) )
{
float fSectionStartTime = fSectionStartTimeList[i];
//float fTotalDuration = pCutfile->GetTotalDuration();
fStartTimeOfInterest = fSectionStartTime;
const crClip* pClip = pClipDict->GetClip(FinalHashString);
if(pClip)
{
crTagIterator it(*pClip->GetTags(), TagKeyBlock);
while(*it)
{
CameraCutBlockingTagInfo& blockingTag = BlockingTagInfo.Grow();
const crTag* tagBlock = static_cast<const crTag*>(*it);
float fStartTime = pClip->ConvertPhaseToTime(tagBlock->GetStart()) + fSectionStartTime;
float fEndTime = pClip->ConvertPhaseToTime(tagBlock->GetEnd()) + fSectionStartTime;
//
// Search from last time to upto the new blocking tag
//
fEndTimeOfInterest = fStartTime;
const atArray<cutfEvent *>& eventList = pCutfile->GetEventList();
for ( int i = 0; i < eventList.GetCount(); ++i )
{
if (eventList[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( eventList[i]->GetEventArgs());
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE)
{
float fEventTime = eventList[i]->GetTime();
if (fEventTime > fStartTimeOfInterest && fEventTime < fEndTimeOfInterest)
{
blockingTag.index = i;
blockingTag.eventTime = fEventTime;
}
}
}
}
//
// Search from the start of the new blocking tag to the end of the new blocking tag
//
fStartTimeOfInterest = fStartTime;
fEndTimeOfInterest = fEndTime;
blockingTag.startBlockingTagTime = fStartTime;
for ( int i = 0; i < eventList.GetCount(); ++i )
{
if (eventList[i]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( eventList[i]->GetEventArgs());
if(pEventArgs && pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE)
{
float fEventTime = eventList[i]->GetTime();
if (fEventTime > fStartTimeOfInterest && fEventTime < fEndTimeOfInterest)
{
/* cutsceneDisplayf("Camera cut event: T(%.6f), F(%.6f), P(%.6f)\n",
fEventTime,
fEventTime * 30.0f,
fEventTime/fTotalDuration);*/
blockingTag.index = i;
blockingTag.eventTime = fEventTime;
}
}
}
}
/* cutsceneDisplayf("End Camera Blocking Tag: T(%.6f), F(%.6f), P(%.6f)\n",
fEndTime,
fEndTime * 30.0f,
fEndTime/fTotalDuration);*/
blockingTag.endBlockingTagTime = fEndTime;
// Remember the end time for the next search
fStartTimeOfInterest = fEndTime;
++it;
}
}
}
}
}
}
}
}
}
}
//create enough requests for the number of sections
for(int i = 0; i < fSectionStartTimeList.GetCount(); i++ )
{
char dictName[CUTSCENE_LONG_OBJNAMELEN];
if(sceneName.GetCStr())
{
if ( pAnimManager->GetSectionedName(
dictName, CUTSCENE_LONG_OBJNAMELEN, sceneName.GetCStr(), i, fSectionStartTimeList.GetCount() ) )
{
strLocalIndex iAnimDictIndex = fwAnimManager::FindSlot(dictName);
if (cutsceneVerifyf(iAnimDictIndex != -1 , "Clip dict %s has returned an invalid slot, will not attempt to load this dict" , dictName))
{
if (cutsceneVerifyf(CStreaming::IsObjectInImage(iAnimDictIndex, fwAnimManager::GetStreamingModuleId()), "Clip dict %s is not in the image" , dictName))
{
g_ClipDictionaryStore.ClearRequiredFlag(iAnimDictIndex.Get(), STRFLAG_DONTDELETE);
}
}
}
}
}
}
//widen any blocking tags which overlap
for(int i=0; i<BlockingTagInfo.GetCount(); i++)
{
if(BlockingTagInfo[i].index == -1)
{
if(i>0)
{
if(AreNearlyEqual(BlockingTagInfo[i-1].endBlockingTagTime, BlockingTagInfo[i].startBlockingTagTime, SMALL_FLOAT))
{
BlockingTagInfo[i-1].endBlockingTagTime = BlockingTagInfo[i].endBlockingTagTime;
}
}
}
}
//delete blocking tags without a camera cut index
for(int i= BlockingTagInfo.GetCount()-1; i>=0; i--)
{
if(BlockingTagInfo[i].index == -1)
{
BlockingTagInfo.Delete(i);
}
}
if(pAnimManager)
{
delete pAnimManager;
}
if(pCamEntity)
{
delete pCamEntity;
}
};
bool CCutSceneDebugManager::ValidateShadowData(cutfCutsceneFile2* pCutfFile, atHashString sceneName, const atVector<CameraCutBlockingTagInfo> &BlockingTagInfo, bool fixupEvents)
{
bool ValidaitionSuccess = true;
const atArray< cutfEvent * > &eventList = pCutfFile->GetEventList();
if(eventList.GetCount() > 0)
{
const atArray< cutfObject * > &objectList = pCutfFile->GetObjectList();
cutfObject *pObject = NULL;
for(int i = 0; i < objectList.GetCount(); i ++)
{
pObject = objectList[i];
if(Verifyf(pObject, "pObject is NULL!") && pObject->GetType() == CUTSCENE_CAMERA_OBJECT_TYPE)
{
break;
}
}
s32 cameraCutIndex = -2;
s32 SecondCameraCutIndex = -2;
if(pObject && pObject->GetType() == CUTSCENE_CAMERA_OBJECT_TYPE)
{
//cutfCameraObject *pCameraObject = static_cast< cutfCameraObject * >(pObject);
bool bSearchshadowEvents = false;
float firstEventTime = 0.0f;
float secondEventTime = pCutfFile->GetTotalDuration();
bool hasValidCameraCutEvents = false;
for(int j = 0; j < eventList.GetCount(); j ++)
{
cutfEvent *pCutEvent = eventList[j];
if(Verifyf(pCutEvent, "pCutEvent is NULL!") && pCutEvent->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
if(SecondCameraCutIndex < 0 && cameraCutIndex < 0)
{
cameraCutIndex = j;
hasValidCameraCutEvents = true;
}
else
{
SecondCameraCutIndex = j;
if(SecondCameraCutIndex >= 0 && cameraCutIndex >= 0)
{
secondEventTime = eventList[SecondCameraCutIndex]->GetTime();
firstEventTime = eventList[cameraCutIndex]->GetTime();
bSearchshadowEvents = true;
}
}
}
if(j == eventList.GetCount()-1)
{
if(pCutEvent->GetEventId() != CUTSCENE_CAMERA_CUT_EVENT)
{
secondEventTime = pCutfFile->GetTotalDuration();
SecondCameraCutIndex = eventList.GetCount();
if(cameraCutIndex >= 0 )
{
firstEventTime = eventList[cameraCutIndex]->GetTime();
}
else
{
cameraCutIndex = 0;
cutsceneDisplayf("WARNING: %s: HAS NO CAMERA CUT EVENTS", sceneName.GetCStr());
return false;
}
bSearchshadowEvents = true;
}
}
if(bSearchshadowEvents)
{
for(int k = cameraCutIndex; k < SecondCameraCutIndex; k ++)
{
cutfEvent *pShadowEvent = eventList[k];
if(pShadowEvent)
{
if(pShadowEvent->GetEventId() == CUTSCENE_ENABLE_CASCADE_SHADOW_BOUNDS_EVENT ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_UPDATE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_UPDATE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_AIRCRAFT_MODE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_MODE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_FLY_CAMERA_MODE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_HFOV ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_VFOV ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_SPLIT_Z_EXP_WEIGHT||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DITHER_RADIUS_SCALE||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_WORLD_HEIGHT_MINMAX||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_RECEIVER_HEIGHT_MINMAX||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DEPTH_BIAS||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_SLOPE_BIAS||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_SHADOW_SAMPLE_TYPE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_VALUE ||
pShadowEvent->GetEventId() == CUTSCENE_CASCADE_SHADOWS_RESET_CASCADE_SHADOWS)
{
int cameraCuttoCompare = cameraCutIndex;
float nearestCutTime = firstEventTime;
float firstEventTimeDifference = ABS(pShadowEvent->GetTime() - firstEventTime);
float SecondEventTimeDifference = ABS(pShadowEvent->GetTime() - secondEventTime);
if(SecondEventTimeDifference < firstEventTimeDifference)
{
cameraCuttoCompare = SecondCameraCutIndex;
nearestCutTime = secondEventTime;
}
bool isEventValid = false;
bool useBlockingTag = false;
for(int blockingTagIndex = 0; blockingTagIndex < BlockingTagInfo.GetCount(); blockingTagIndex++)
{
if(BlockingTagInfo[blockingTagIndex].index == cameraCuttoCompare)
{
if(pShadowEvent->GetTime() >= BlockingTagInfo[blockingTagIndex].startBlockingTagTime && pShadowEvent->GetTime() <= BlockingTagInfo[blockingTagIndex].endBlockingTagTime)
{
isEventValid = true;
}
useBlockingTag = true;
break;
}
}
if(!useBlockingTag)
{
if(AreNearlyEqual(pShadowEvent->GetTime(), nearestCutTime, SMALL_FLOAT))
{
isEventValid = true;
}
}
if(!isEventValid)
{
if(ValidaitionSuccess)
{
cutsceneDisplayf("%s: FAILED SHADOW EVENT VALIDATION", sceneName.GetCStr());
}
cutsceneDisplayf("Event '%s' (%f) IS NOT LINKED TO A CAMERA CUT - nearest camera cut is %f", pShadowEvent->GetDisplayName(), pShadowEvent->GetTime(), nearestCutTime);
ValidaitionSuccess = false;
}
if(fixupEvents)
{
if(cameraCuttoCompare >= 0 && cameraCuttoCompare < eventList.GetCount())
{
if(eventList[cameraCuttoCompare]->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
cutfEventArgs *pEventArgs = const_cast<cutfEventArgs *>( eventList[cameraCuttoCompare]->GetEventArgs() );
if(pEventArgs->GetType() == CUTSCENE_CAMERA_CUT_EVENT_ARGS_TYPE )
{
cutfCameraCutEventArgs* pObjectVar = static_cast<cutfCameraCutEventArgs*>(pEventArgs);
if(pObjectVar)
{
atHashString cameraCutName = pObjectVar->GetName();
pShadowEvent->SetIsChild(true);
pShadowEvent->SetStickyEventId(cameraCutName.GetHash());
pShadowEvent->SetTime(0.0f);
}
}
}
}
else if(nearestCutTime == pCutfFile->GetTotalDuration())
{
atHashString cameraCutName("endofscenecut");
pShadowEvent->SetIsChild(true);
pShadowEvent->SetTime(0.0f);
pShadowEvent->SetStickyEventId(cameraCutName.GetHash());
}
}
}
}
}
cameraCutIndex = SecondCameraCutIndex;
SecondCameraCutIndex = -1;
bSearchshadowEvents = false;
}
}
}
}
if(!ValidaitionSuccess && fixupEvents)
{
pCutfFile->SortEvents();
if(CutSceneManager::GetInstance()->IsCutscenePlayingBack())
{
CutSceneManager::GetInstance()->SaveGameDataCutfile();
}
else
{
CutSceneManager::GetInstance()->cOrignalSceneName = sceneName.GetCStr();
CutSceneManager::GetInstance()->SetCutfFile(pCutfFile);
CutSceneManager::GetInstance()->SaveGameDataCutfile();
CutSceneManager::GetInstance()->SetCutfFile(NULL);
CutSceneManager::GetInstance()->cOrignalSceneName.Clear();
}
}
return ValidaitionSuccess;
}
bool CCutSceneDebugManager::ValidateLightData(cutfCutsceneFile2* pCutfFile, atHashString sceneName, const atVector<CameraCutBlockingTagInfo> &BlockingTagInfo)
{
bool ValidaitionSuccess = true;
const atArray< cutfEvent * > &eventList = pCutfFile->GetEventList();
if(eventList.GetCount() > 0)
{
const atArray< cutfObject * > &objectList = pCutfFile->GetObjectList();
cutfObject *pObject = NULL;
for(int i = 0; i < objectList.GetCount(); i ++)
{
pObject = objectList[i];
if(Verifyf(pObject, "pObject is NULL!") && pObject->GetType() == CUTSCENE_CAMERA_OBJECT_TYPE)
{
break;
}
}
s32 cameraCutIndex = -1;
s32 SecondCameraCutIndex = -1;
if(pObject && pObject->GetType() == CUTSCENE_CAMERA_OBJECT_TYPE)
{
bool bSearchshadowEvents = false;
bool bHaveCameraCutBookendEvents = false;
for(int j = 0; j < eventList.GetCount(); j ++)
{
cutfEvent *pCutEvent = eventList[j];
if(Verifyf(pCutEvent, "pCutEvent is NULL!") && pCutEvent->GetEventId() == CUTSCENE_CAMERA_CUT_EVENT)
{
if(SecondCameraCutIndex == -1 && cameraCutIndex == -1)
{
cameraCutIndex = j;
}
else
{
SecondCameraCutIndex = j;
bSearchshadowEvents = true;
bHaveCameraCutBookendEvents = true;
}
}
if(j == eventList.GetCount()-1)
{
if(pCutEvent->GetEventId() != CUTSCENE_CAMERA_CUT_EVENT)
{
bHaveCameraCutBookendEvents = false;
SecondCameraCutIndex = eventList.GetCount();
bSearchshadowEvents = true;
if(cameraCutIndex != -1)
{
bSearchshadowEvents = true;
}
}
}
if(bSearchshadowEvents)
{
for(int k = cameraCutIndex; k < SecondCameraCutIndex; k ++)
{
cutfEvent *pTargetEvent = eventList[k];
if(pTargetEvent)
{
if(pTargetEvent->GetEventId() == CUTSCENE_SET_LIGHT_EVENT || pTargetEvent->GetEventId() == CUTSCENE_CLEAR_LIGHT_EVENT)
{
int cameraCuttoCompare = cameraCutIndex;
if(bHaveCameraCutBookendEvents)
{
if(cameraCutIndex != -1 && SecondCameraCutIndex !=-1)
{
float firstEventTimeDifference = ABS(pTargetEvent->GetTime() - eventList[cameraCutIndex]->GetTime());
float SecondEventTimeDifference = ABS(pTargetEvent->GetTime() - eventList[SecondCameraCutIndex]->GetTime());
if(SecondEventTimeDifference < firstEventTimeDifference)
{
cameraCuttoCompare = SecondCameraCutIndex;
}
}
}
bool isEventValid = false;
bool useBlockingTag = false;
for(int blockingTagIndex = 0; blockingTagIndex < BlockingTagInfo.GetCount(); blockingTagIndex++)
{
if(BlockingTagInfo[blockingTagIndex].index == cameraCuttoCompare)
{
if(pTargetEvent->GetTime() >= BlockingTagInfo[blockingTagIndex].startBlockingTagTime && pTargetEvent->GetTime() <= BlockingTagInfo[blockingTagIndex].endBlockingTagTime)
{
isEventValid = true;
}
useBlockingTag = true;
break;
}
}
if(!useBlockingTag)
{
if(AreNearlyEqual(pTargetEvent->GetTime(), eventList[cameraCuttoCompare]->GetTime(), SMALL_FLOAT))
{
isEventValid = true;
}
}
if(!isEventValid && !bHaveCameraCutBookendEvents && pTargetEvent->GetEventId() == CUTSCENE_CLEAR_LIGHT_EVENT)
{
//check the clear event
if(AreNearlyEqual(pTargetEvent->GetTime(), pCutfFile->GetTotalDuration(), SMALL_FLOAT))
{
isEventValid = true;
}
else
{
cutsceneDisplayf("%s: WARNING: Event %s(%f) is not parented but is past the final cut but not at scene end", sceneName.GetCStr(), pTargetEvent->GetDisplayName(), pTargetEvent->GetTime());
}
}
if(!isEventValid)
{
if(ValidaitionSuccess)
{
cutsceneDisplayf("%s: FAILED LIGHT EVENT VALIDATION", sceneName.GetCStr());
}
cutsceneDisplayf("Event '%s' (%f) IS NOT LINKED TO A CAMERA CUT - nearest camera cut is %f", pTargetEvent->GetDisplayName(), pTargetEvent->GetTime(), eventList[cameraCuttoCompare]->GetTime());
ValidaitionSuccess = false;
}
}
}
}
cameraCutIndex = SecondCameraCutIndex;
SecondCameraCutIndex = -1;
bHaveCameraCutBookendEvents = false;
bSearchshadowEvents = false;
}
}
}
}
return ValidaitionSuccess;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// END OF DEBUG MANAGER
///////////////////////////////////////////////////////////////////////////////////////////////////
#endif
Reference in New Issue Copy Permalink