Files
GTASource/game/debug/MarketingTools.cpp
expvintl 419f2e4752 init
2025-02-23 17:40:52 +08:00

923 lines
31 KiB
C++

//
// debug/MarketingTools.cpp
//
// Copyright (C) 1999-2010 Rockstar Games. All Rights Reserved.
//
#include "debug/MarketingTools.h"
#if __BANK //Marketing tools are only available in BANK builds.
#include "bank/bkmgr.h"
#include "bank/io.h"
#include "fwsys/timer.h"
#include "animation/debug/AnimViewer.h"
#include "audio/northaudioengine.h"
#include "camera/CamInterface.h"
#include "camera/gameplay/GameplayDirector.h"
#include "camera/helpers/ControlHelper.h"
#include "camera/marketing/MarketingDirector.h"
#include "camera/viewports/ViewportManager.h"
#include "frontend/MiniMap.h"
#include "Frontend/MovieClipText.h"
#include "game/cheat.h"
#include "game/Clock.h"
#include "game/weather.h"
#include "peds/PedDebugVisualiser.h"
#include "peds/pedpopulation.h"
#include "peds/Ped.h"
#include "renderer/Lights/lights.h"
#include "renderer/PostProcessFX.h"
#include "scene/lod/LodScale.h"
#include "scene/world/GameWorld.h"
#include "system/controlMgr.h"
#include "text/messages.h"
#include "vfx\misc\markers.h"
enum eInvincibilityModes
{
VULNERABLE = 0,
INVINCIBLE,
INVINCIBLE_NO_REACTIONS,
NUM_INVINCIBILITY_MODES
};
static const char* g_InvincibilityModeLabels[NUM_INVINCIBILITY_MODES] =
{
"HELP_NOINVIN", // VULNERABLE
"HELP_INVIN", // INVINCIBLE
"MKT_INVIN_NORCT" // INVINCIBLE_NO_REACTIONS
};
enum eBloodModes
{
BLOOD_ENABLED = 0,
BLOOD_DISABLED_FOR_PLAYER,
BLOOD_DISABLED_GLOBALLY,
NUM_BLOOD_MODES
};
static const char* g_BloodModeLabels[NUM_BLOOD_MODES] =
{
"MKT_BLOOD", // BLOOD_ENABLED
"MKT_NO_P_BLOOD", // BLOOD_DISABLED_FOR_PLAYER
"MKT_NO_BLOOD" // BLOOD_DISABLED_GLOBALLY
};
enum eAmmoModes
{
LIMITED_AMMO = 0,
UNLIMITED_AMMO,
INFINITE_CLIPS,
NUM_AMMO_MODES
};
static const char* g_AmmoModeLabels[NUM_BLOOD_MODES] =
{
"MKT_LTD_AMMO", // LIMITED_AMMO
"MKT_UNLTD_AMMO", // UNLIMITED_AMMO
"MKT_INF_CLIP" // INFINITE_CLIPS
};
static const char *g_LightTypeNames[] =
{
"Point",
"Spot",
"Capsule"
};
// OPTIMISATIONS_OFF()
u32 CMarketingTools::ms_InvincibilityMode = VULNERABLE;
u32 CMarketingTools::ms_BloodMode = BLOOD_ENABLED;
u32 CMarketingTools::ms_AmmoMode = LIMITED_AMMO;
u32 CMarketingTools::ms_ForcedWeatherType = 0;
u32 CMarketingTools::ms_LightArrayNumUsed = 0;
u32 CMarketingTools::ms_LightArrayEditIndex = 0;
float CMarketingTools::ms_SlowMotionSpeed = 0.5f;
bool CMarketingTools::ms_IsActive = false;
bool CMarketingTools::ms_ShouldMuteMusic = false;
bool CMarketingTools::ms_ShouldMuteSpeech = false;
bool CMarketingTools::ms_ShouldMuteSfx = false;
bool CMarketingTools::ms_ShouldMuteAmbience = false;
bool CMarketingTools::ms_OverrideMotionBlur = false;
bool CMarketingTools::ms_LightsEnabled = false;
bool CMarketingTools::ms_WasHudShown = true;
bool CMarketingTools::ms_DisplayHud = true;
bool CMarketingTools::ms_DisplayMiniMap = true;
bool CMarketingTools::ms_DisplayMarkers = true;
bool CMarketingTools::ms_DisplayHudComponent[MAX_NEW_HUD_COMPONENTS];
float CMarketingTools::ms_OverrideMotionBlurStrength = 0.0f;
CExplosionManager::CExplosionArgs * CMarketingTools::ms_ExplosionSetup = NULL;
struct CMarketingTools::CLightDebugSetup CMarketingTools::ms_LightArray[CMarketingTools::MAX_DEBUG_LIGHTS];
rage::bkGroup * CMarketingTools::ms_LightControlGroup = NULL;
rage::bkGroup * CMarketingTools::ms_LightWidgetGroup = NULL;
rage::bkGroup * CMarketingTools::ms_CharacterWidgetGroup= NULL;
rage::bkGroup * CMarketingTools::ms_CharacterControlsGroup= NULL;
void CMarketingTools::Init(unsigned /*initMode*/)
{
for(s32 i=0; i<MAX_NEW_HUD_COMPONENTS; i++)
{
ms_DisplayHudComponent[i] = true;
}
}
void CMarketingTools::Update()
{
PF_PUSH_TIMEBAR("marketing tools");
ms_IsActive = (CControlMgr::GetKeyboard().GetKeyboardMode() == KEYBOARD_MODE_MARKETING);
if(ms_IsActive)
{
UpdateKeyboardInput();
UpdatePadInput();
UpdateAudioControls();
UpdateGfxControls();
UpdateHudControls();
}
PF_POP_TIMEBAR();
}
void CMarketingTools::UpdateLights()
{
ms_IsActive = (CControlMgr::GetKeyboard().GetKeyboardMode() == KEYBOARD_MODE_MARKETING);
if(ms_IsActive)
{
UpdateLightControls();
}
}
void CMarketingTools::UpdateKeyboardInput()
{
CKeyboard& keyboard = CControlMgr::GetKeyboard();
CNumberWithinMessage NumberArray[1];
if(keyboard.GetKeyJustDown(KEY_O, KEYBOARD_MODE_MARKETING, "Toggle HUD and any screen overlay"))
{
if(ms_WasHudShown)
{
WidgetHudHideAll();
}
else
{
WidgetHudShowAll();
}
}
else if(keyboard.GetKeyJustDown(KEY_V, KEYBOARD_MODE_MARKETING, "Cycle invincibility mode (vulnerable/invincible/invincible with reactions off)"))
{
ms_InvincibilityMode = (ms_InvincibilityMode + 1) % NUM_INVINCIBILITY_MODES;
CPlayerInfo::ms_bDebugPlayerInvincible = (ms_InvincibilityMode != VULNERABLE);
CPed* player = CGameWorld::FindFollowPlayer();
if(player)
{
const bool canPlayerBeDamaged = (ms_InvincibilityMode != INVINCIBLE_NO_REACTIONS);
player->GetPlayerInfo()->SetPlayerCanBeDamaged(canPlayerBeDamaged);
}
//Display confirmation debug text (if the HUD is enabled.)
if(ms_InvincibilityMode < NUM_INVINCIBILITY_MODES)
{
char *string = TheText.Get(g_InvincibilityModeLabels[ms_InvincibilityMode]);
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string);
}
}
else if(keyboard.GetKeyJustDown(KEY_J, KEYBOARD_MODE_MARKETING, "Skip to the next checkpoint"))
{
//TODO: Use script functionality from Game overlay.
}
else if(keyboard.GetKeyJustDown(KEY_H, KEYBOARD_MODE_MARKETING, "Increase LOD draw distance") &&
(keyboard.GetKeyDown(KEY_LSHIFT, KEYBOARD_MODE_MARKETING) ||
keyboard.GetKeyDown(KEY_RSHIFT, KEYBOARD_MODE_MARKETING)))
{
//Increase the global LOD scale by 0.1.
float lodScale = g_LodScale.GetMarketingCameraScale_In();
lodScale = Min(lodScale + 0.1f, 100.0f);
g_LodScale.SetMarketingCameraScale_In(lodScale);
//Display confirmation debug text (if the HUD is enabled.)
char *string = TheText.Get("MKT_LOD");
const s32 lodScalePercentage = (s32)Floorf((lodScale * 100.0f) + 0.5f);
NumberArray[0].Set(lodScalePercentage);
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string, NumberArray, 1);
}
else if(keyboard.GetKeyJustDown(KEY_K, KEYBOARD_MODE_MARKETING, "Decrease LOD draw distance") &&
(keyboard.GetKeyDown(KEY_LSHIFT, KEYBOARD_MODE_MARKETING) ||
keyboard.GetKeyDown(KEY_RSHIFT, KEYBOARD_MODE_MARKETING)))
{
//Decrease the global LOD scale by 0.1.
float lodScale = g_LodScale.GetMarketingCameraScale_In();
lodScale = Max(lodScale - 0.1f, 0.1f);
g_LodScale.SetMarketingCameraScale_In(lodScale);
//Display confirmation debug text (if the HUD is enabled.)
char *string = TheText.Get("MKT_LOD");
const s32 lodScalePercentage = (s32)Floorf((lodScale * 100.0f) + 0.5f);
NumberArray[0].Set(lodScalePercentage);
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string, NumberArray, 1);
}
else if(keyboard.GetKeyJustDown(KEY_H, KEYBOARD_MODE_MARKETING, "Heal player model"))
{
CCheat::HealthCheat();
}
else if(keyboard.GetKeyJustDown(KEY_B, KEYBOARD_MODE_MARKETING, "Cycle blood mode"))
{
ms_BloodMode = (ms_BloodMode + 1) % NUM_BLOOD_MODES;
//Display confirmation debug text (if the HUD is enabled.)
if(ms_BloodMode < NUM_BLOOD_MODES)
{
char *string = TheText.Get(g_BloodModeLabels[ms_BloodMode]);
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string);
}
}
else if(keyboard.GetKeyJustDown(KEY_M, KEYBOARD_MODE_MARKETING, "Toggle marketing menu"))
{
//TODO: Toggle display of a custom marketing menu, containing links to other XML menus.
}
else if(keyboard.GetKeyJustDown(KEY_W, KEYBOARD_MODE_MARKETING, "Give player all weapons"))
{
CCheat::WeaponCheat1();
}
else if(keyboard.GetKeyJustDown(KEY_Z, KEYBOARD_MODE_MARKETING, "Trigger lightning strike"))
{
g_weather.ForceLightningFlash();
}
else if(keyboard.GetKeyJustDown(KEY_P, KEYBOARD_MODE_MARKETING, "Toggle pausing of time of day"))
{
const bool isPaused = CClock::GetIsPaused();
CClock::Pause(!isPaused);
}
else if(keyboard.GetKeyJustDown(KEY_U, KEYBOARD_MODE_MARKETING, "Cycle player ammo mode"))
{
ms_AmmoMode = (ms_AmmoMode + 1) % NUM_AMMO_MODES;
CPed * player = CGameWorld::FindFollowPlayer();
if(player && player->GetInventory())
{
const bool shouldUseInfiniteAmmo = (ms_AmmoMode != LIMITED_AMMO);
player->GetInventory()->GetAmmoRepository().SetUsingInfiniteAmmo(shouldUseInfiniteAmmo);
const bool shouldUseInfiniteClips = (ms_AmmoMode == INFINITE_CLIPS);
player->GetInventory()->GetAmmoRepository().SetUsingInfiniteClips(shouldUseInfiniteClips);
}
//Display confirmation debug text (if the HUD is enabled.)
if(ms_AmmoMode < NUM_AMMO_MODES)
{
char *string = TheText.Get(g_AmmoModeLabels[ms_AmmoMode]);
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string);
}
}
else if(keyboard.GetKeyJustDown(KEY_F1, KEYBOARD_MODE_MARKETING, "Toggle unlimited deadeye/bullet-time"))
{
//TODO: Toggle unlimited bullet-time in MP3.
}
else if(keyboard.GetKeyJustDown(KEY_1, KEYBOARD_MODE_MARKETING, "Toggle slow-motion"))
{
const float slowMotionSpeed = fwTimer::GetDebugTimeScale();
if(slowMotionSpeed < 1.0f)
{
//NOTE: The current marketing slow-motion speed is preserved.
fwTimer::SetDebugTimeScale(1.0f);
//Display confirmation debug text (if the HUD is enabled.)
char *string = TheText.Get("MKT_NOSLOW");
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string);
}
else
{
fwTimer::SetDebugTimeScale(ms_SlowMotionSpeed);
//Display confirmation debug text (if the HUD is enabled.)
char *string = TheText.Get("MKT_SLOW");
const s32 slowMotionPercentage = (s32)Floorf((ms_SlowMotionSpeed * 100.0f) + 0.5f);
NumberArray[0].Set(slowMotionPercentage);
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string, NumberArray, 1);
}
}
else if(keyboard.GetKeyJustDown(KEY_2, KEYBOARD_MODE_MARKETING, "Increase slow-motion speed"))
{
ms_SlowMotionSpeed = Min(ms_SlowMotionSpeed + 0.1f, 0.9f);
//NOTE: Slow-motion is activated if necessary.
fwTimer::SetDebugTimeScale(ms_SlowMotionSpeed);
//Display confirmation debug text (if the HUD is enabled.)
char *string = TheText.Get("MKT_SLOW");
const s32 slowMotionPercentage = (s32)Floorf((ms_SlowMotionSpeed * 100.0f) + 0.5f);
NumberArray[0].Set(slowMotionPercentage);
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string, NumberArray, 1);
}
else if(keyboard.GetKeyJustDown(KEY_3, KEYBOARD_MODE_MARKETING, "Decrease slow-motion speed"))
{
ms_SlowMotionSpeed = Max(ms_SlowMotionSpeed - 0.1f, 0.1f);
//NOTE: Slow-motion is activated if necessary.
fwTimer::SetDebugTimeScale(ms_SlowMotionSpeed);
//Display confirmation debug text (if the HUD is enabled.)
char *string = TheText.Get("MKT_SLOW");
const s32 slowMotionPercentage = (s32)Floorf((ms_SlowMotionSpeed * 100.0f) + 0.5f);
NumberArray[0].Set(slowMotionPercentage);
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string, NumberArray, 1);
}
else if(keyboard.GetKeyJustDown(KEY_4, KEYBOARD_MODE_MARKETING, "Toggle buttons images in movie clips text"))
{
CMovieClipText::ms_bDontUseIcons = !CMovieClipText::ms_bDontUseIcons;
}
else if(keyboard.GetKeyJustDown(KEY_PAGEUP, KEYBOARD_MODE_MARKETING, "Next weather type"))
{
const u32 numTypes = g_weather.GetNumTypes();
ms_ForcedWeatherType = (ms_ForcedWeatherType + 1) % numTypes;
g_weather.ForceTypeNow(ms_ForcedWeatherType, CWeather::FT_None);
PostFX::ResetAdaptedLuminance();
}
else if(keyboard.GetKeyJustDown(KEY_PAGEDOWN, KEYBOARD_MODE_MARKETING, "Previous weather type"))
{
const u32 numTypes = g_weather.GetNumTypes();
ms_ForcedWeatherType = (ms_ForcedWeatherType + numTypes - 1) % numTypes;
g_weather.ForceTypeNow(ms_ForcedWeatherType, CWeather::FT_None);
PostFX::ResetAdaptedLuminance();
}
else if(keyboard.GetKeyJustDown(KEY_EQUALS, KEYBOARD_MODE_MARKETING, "Advance time one hour") ||
keyboard.GetKeyJustDown(KEY_ADD, KEYBOARD_MODE_MARKETING, "Advance time one hour"))
{
CClock::AddTime(1, 0, 0);
PostFX::ResetAdaptedLuminance();
}
else if(keyboard.GetKeyJustDown(KEY_MINUS, KEYBOARD_MODE_MARKETING, "Decrease time one hour") ||
keyboard.GetKeyJustDown(KEY_SUBTRACT, KEYBOARD_MODE_MARKETING, "Decrease time one hour"))
{
CClock::AddTime(-1, 0, 0);
PostFX::ResetAdaptedLuminance();
}
else if(keyboard.GetKeyJustDown(KEY_UP, KEYBOARD_MODE_MARKETING, "Increase ped density") &&
(keyboard.GetKeyDown(KEY_LSHIFT, KEYBOARD_MODE_MARKETING) ||
keyboard.GetKeyDown(KEY_RSHIFT, KEYBOARD_MODE_MARKETING)))
{
//Increase the global max population scale by 0.1.
float maxPopulationScale = CPedPopulation::GetPopCycleMaxPopulationScaler();
maxPopulationScale = Min(maxPopulationScale + 0.1f, 50.0f);
CPedPopulation::SetPopCycleMaxPopulationScaler(maxPopulationScale);
//Display confirmation debug text (if the HUD is enabled.)
char *string = TheText.Get("MKT_PEDPOP");
const s32 maxPopulationScalePercentage = (s32)Floorf((maxPopulationScale * 100.0f) + 0.5f);
NumberArray[0].Set(maxPopulationScalePercentage);
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string, NumberArray, 1);
}
else if(keyboard.GetKeyJustDown(KEY_DOWN, KEYBOARD_MODE_MARKETING, "Decrease ped density") &&
(keyboard.GetKeyDown(KEY_LSHIFT, KEYBOARD_MODE_MARKETING) ||
keyboard.GetKeyDown(KEY_RSHIFT, KEYBOARD_MODE_MARKETING)))
{
//Decrease the global max population scale by 0.1.
float maxPopulationScale = CPedPopulation::GetPopCycleMaxPopulationScaler();
maxPopulationScale = Max(maxPopulationScale - 0.1f, 0.1f);
CPedPopulation::SetPopCycleMaxPopulationScaler(maxPopulationScale);
//Display confirmation debug text (if the HUD is enabled.)
char *string = TheText.Get("MKT_PEDPOP");
const s32 maxPopulationScalePercentage = (s32)Floorf((maxPopulationScale * 100.0f) + 0.5f);
NumberArray[0].Set(maxPopulationScalePercentage);
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string, NumberArray, 1);
}
else if(keyboard.GetKeyJustDown(KEY_R, KEYBOARD_MODE_MARKETING, "Toggle marketing camera GTA/RDR control mapping") &&
(keyboard.GetKeyDown(KEY_LMENU, KEYBOARD_MODE_MARKETING) || keyboard.GetKeyDown(KEY_RMENU, KEYBOARD_MODE_MARKETING)))
{
//Toggle the control mapping for the marketing cameras.
camMarketingDirector& marketingDirector = camInterface::GetMarketingDirector();
const bool shouldUseRdrControlMapping = !marketingDirector.ShouldUseRdrControlMapping();
marketingDirector.SetShouldUseRdrControlMapping(shouldUseRdrControlMapping);
//Display confirmation debug text (if the HUD is enabled.)
char *string = TheText.Get(shouldUseRdrControlMapping ? "MKT_RDRCTRLMAP" : "MKT_GTACTRLMAP");
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string);
}
}
void CMarketingTools::UpdatePadInput()
{
//Ensure that the player pad, rather than the debug pad, is used for RAG widget control.
s32 playerPadIndex = CControlMgr::GetMainPlayerIndex();
bkIo::SetPadIndex(playerPadIndex);
CPad& debugPad = CControlMgr::GetDebugPad();
//NOTE: Ignore further pad input here if start is held down, as special debug buttons may be pressed (in combination with start.)
const u32 debugButtons = debugPad.GetDebugButtons();
if(!(debugButtons & ioPad::START))
{
if(debugPad.GetDPadRight())
{
CClock::AddTime(1, 0, 0);
PostFX::ResetAdaptedLuminance();
}
else if(debugPad.DPadLeftJustDown())
{
//Advance to next weather type and force it to remain active.
const u32 numTypes = g_weather.GetNumTypes();
ms_ForcedWeatherType = (ms_ForcedWeatherType + 1) % numTypes;
g_weather.ForceTypeNow(ms_ForcedWeatherType, CWeather::FT_None);
PostFX::ResetAdaptedLuminance();
}
if(debugPad.ButtonCircleJustDown())
{
ms_LightsEnabled = !ms_LightsEnabled;
if (ms_LightsEnabled && ms_LightArrayNumUsed==0)
WidgetAddLight(); // if we just turned on the lights and there is not one available then make a new light
//Display confirmation debug text (if the HUD is enabled.)
char *string = ms_LightsEnabled ? TheText.Get("MKT_CAMLIGHTON") : TheText.Get("MKT_CAMLIGHTOFF");
CHelpMessage::SetMessageText(HELP_TEXT_SLOT_STANDARD, string);
}
}
else
{
if (ms_LightArrayEditIndex < ms_LightArrayNumUsed)
{
if (debugButtons & ioPad::LLEFT)
{
//control spread of cam light
ms_LightArray[ms_LightArrayEditIndex].m_LightRange -= 0.1f;
if (ms_LightArray[ms_LightArrayEditIndex].m_LightRange < 0.2f)
ms_LightArray[ms_LightArrayEditIndex].m_LightRange = 0.2f;
}
else if (debugButtons & ioPad::LRIGHT)
{
ms_LightArray[ms_LightArrayEditIndex].m_LightRange += 0.1f;
if (ms_LightArray[ms_LightArrayEditIndex].m_LightRange > 100.0f)
ms_LightArray[ms_LightArrayEditIndex].m_LightRange = 100.0f;
}
if (debugButtons & ioPad::LDOWN)
{
//control brightness of cam light
ms_LightArray[ms_LightArrayEditIndex].m_LightIntensity -= 0.1f;
if (ms_LightArray[ms_LightArrayEditIndex].m_LightIntensity < 0.1f)
ms_LightArray[ms_LightArrayEditIndex].m_LightIntensity = 0.1f;
}
else if (debugButtons & ioPad::LUP)
{
ms_LightArray[ms_LightArrayEditIndex].m_LightIntensity += 0.1f;
if (ms_LightArray[ms_LightArrayEditIndex].m_LightIntensity > 100.0f)
ms_LightArray[ms_LightArrayEditIndex].m_LightIntensity = 100.0f;
}
}
}
}
void CMarketingTools::UpdateAudioControls()
{
//Ensure that our audio muting preferences are applied every frame, as the marketing tools should dominate when active.
const bool isMusicMuted = audNorthAudioEngine::GetIsMusicMuted();
if(ms_ShouldMuteMusic != isMusicMuted)
{
audNorthAudioEngine::MuteMusic(ms_ShouldMuteMusic);
}
const bool isSpeechMuted = audNorthAudioEngine::GetIsSpeechMuted();
if(ms_ShouldMuteSpeech != isSpeechMuted)
{
audNorthAudioEngine::MuteSpeech(ms_ShouldMuteSpeech);
}
const bool isSfxMuted = audNorthAudioEngine::GetIsSfxMuted();
if(ms_ShouldMuteSfx != isSfxMuted)
{
audNorthAudioEngine::MuteSfx(ms_ShouldMuteSfx);
}
const bool isAmbienceMuted = audNorthAudioEngine::GetIsAmbienceMuted();
if(ms_ShouldMuteAmbience != isAmbienceMuted)
{
audNorthAudioEngine::MuteAmbience(ms_ShouldMuteAmbience);
}
}
void CMarketingTools::UpdateGfxControls()
{
// stomp the existing gfx setings if the overrides are active
if (ms_OverrideMotionBlur)
{
camInterface::GetGameplayDirector().DebugSetOverrideMotionBlurThisUpdate(ms_OverrideMotionBlurStrength);
camInterface::GetMarketingDirector().DebugSetOverrideMotionBlurThisUpdate(ms_OverrideMotionBlurStrength);
}
}
void CMarketingTools::UpdateLightControls()
{
for(int i=0;i<ms_LightArrayNumUsed;i++)
{
struct CLightDebugSetup & light = ms_LightArray[i];
if( light.m_IsLightOrientedToCam )
{
//Move the light with the camera frame.
const Vector3 lightDir(0.0f, 1.0f, 0.0f);
const Vector3 lightTan(1.0f, 0.0f, 0.0f);
camInterface::GetMat().Transform3x3(lightDir, light.m_LightDirection);
camInterface::GetMat().Transform3x3(lightTan, light.m_LightTangent);
}
if( light.m_IsLightAttached )
{
light.m_LightPosition = camInterface::GetPos();
}
if (ms_LightsEnabled)
{
//It looks like this light must be added every update and is automatically removed when we no longer add it.
fwInteriorLocation outside;
u32 lightFlags = LIGHTFLAG_CUTSCENE;
lightFlags |= light.m_IsDynamicShadowLight ? (LIGHTFLAG_CAST_SHADOWS | LIGHTFLAG_CAST_DYNAMIC_GEOM_SHADOWS) : 0;
lightFlags |= light.m_IsCoronaOnly ? LIGHTFLAG_CORONA_ONLY : 0;
lightFlags |= light.m_IsFXLight ? LIGHTFLAG_FX : 0;
Vector3 normalizedColor = light.m_LightColour/255.0f;
eLightType lightType = LIGHT_TYPE_SPOT;
switch( light.m_LightType )
{
case 0:
lightType = LIGHT_TYPE_POINT;
break;
case 1:
lightType = LIGHT_TYPE_SPOT;
break;
case 2:
lightType = LIGHT_TYPE_CAPSULE;
break;
default:
break;
};
CLightSource lightToAdd(lightType, lightFlags, light.m_LightPosition, normalizedColor, light.m_LightIntensity, LIGHT_ALWAYS_ON);
lightToAdd.SetRadius(light.m_LightRange);
lightToAdd.SetFalloffExponent(light.m_LightFalloffExponent);
if( lightType == LIGHT_TYPE_SPOT )
{
lightToAdd.SetSpotlight(light.m_LightConeAngle * light.m_LightInnerCone * 0.01f, light.m_LightConeAngle * light.m_LightOuterCone * 0.01f);
lightToAdd.SetDirTangent(light.m_LightDirection, light.m_LightTangent);
}
if( lightType == LIGHT_TYPE_CAPSULE )
{
lightToAdd.SetCapsule(light.m_LightCapsuleExtent);
lightToAdd.SetDirTangent(light.m_LightDirection, light.m_LightTangent);
}
if (light.m_IsDynamicShadowLight)
{
lightToAdd.SetShadowTrackingId(fwIdKeyGenerator::Get( ms_LightArray, i));
}
Lights::AddSceneLight(lightToAdd);
}
}
}
void CMarketingTools::UpdateHudControls()
{
for(s32 i=0; i<MAX_NEW_HUD_COMPONENTS; i++)
{
if(ms_DisplayHudComponent[i])
{
CNewHud::SetHudComponentToBeShown(i);
}
else
{
CNewHud::SetHudComponentToBeHidden(i);
}
}
}
void CMarketingTools::InitWidgets()
{
if (!ms_ExplosionSetup)
ms_ExplosionSetup = rage_new CExplosionManager::CExplosionArgs(EXP_TAG_GRENADE,VEC3_ZERO);
bkBank& bank = BANKMGR.CreateBank("Marketing Tools");
bank.PushGroup("Audio controls", false);
{
bank.AddToggle("Mute music", &ms_ShouldMuteMusic);
bank.AddToggle("Mute speech", &ms_ShouldMuteSpeech);
bank.AddToggle("Mute sfx", &ms_ShouldMuteSfx);
bank.AddToggle("Mute ambient noise", &ms_ShouldMuteAmbience);
}
bank.PopGroup();
bank.PushGroup("Gfx Controls", false);
{
bank.AddToggle("Override Motion Blur", &ms_OverrideMotionBlur);
bank.AddSlider("Motion Blur Strength", &ms_OverrideMotionBlurStrength, 0.0f, 1.0f, 0.02f);
}
bank.PopGroup();
if (ms_ExplosionSetup)
{
bank.PushGroup("Explosion Controls", false);
{
bank.AddButton("Drop Explosion", datCallback(CFA(CMarketingTools::WidgetDropExplosion)));
ms_ExplosionSetup->AddWidgets(bank);
}
bank.PopGroup();
}
ms_LightControlGroup = bank.PushGroup("Light Controls", false);
{
//bank.AddButton("Drop Light", datCallback(CFA(CMarketingTools::WidgetDropLight)));
bank.AddButton("Add Light", datCallback(CFA(CMarketingTools::WidgetAddLight)));
bank.AddSlider("Current Light", &ms_LightArrayEditIndex, 0, MAX_DEBUG_LIGHTS-1, 1, datCallback(CFA(CMarketingTools::WidgetChangeEditIndex)));
bank.AddButton("Delete Current Light", datCallback(CFA(CMarketingTools::WidgetDeleteLight)));
}
bank.PopGroup();
bank.PushGroup("Hud Controls");
{
bank.AddToggle("Update help text when paused", &CNewHud::bUpdateHelpTextWhenPaused);
bank.AddButton("Show All", datCallback(CFA(CMarketingTools::WidgetHudShowAll)));
bank.AddButton("Hide All", datCallback(CFA(CMarketingTools::WidgetHudHideAll)));
bank.AddToggle("Display Hud", &ms_DisplayHud, datCallback(CFA(CMarketingTools::WidgetChangedHudToggles)));
bank.AddToggle("Display MiniMap", &ms_DisplayMiniMap, datCallback(CFA(CMarketingTools::WidgetChangedHudToggles)));
bank.AddToggle("Display Markers", &ms_DisplayMarkers, datCallback(CFA(CMarketingTools::WidgetChangedHudToggles)));
}
bank.PopGroup();
ms_CharacterControlsGroup = bank.PushGroup("Character Controls");
{
bank.AddButton("Add Controls", datCallback(CFA(CMarketingTools::WidgetAddCharacterControls)));
}
bank.PopGroup();
bank.PushGroup("Camera Look Around Controls");
{
bank.AddSlider("Adjust Control Sensitivity", &camControlHelper::ms_LookAroundSpeedScalar, 0.0f, 10.0f, 0.1f);
bank.AddToggle("Override Look Around Settings", &camControlHelper::ms_UseOverriddenLookAroundHelper);
bank.AddSlider("Input Mag Power", &camControlHelper::ms_OverriddenLookAroundHelper.m_InputMagPowerFactor, 0.0f, 10.0f, 0.1f);
bank.AddSlider("Acceleration", &camControlHelper::ms_OverriddenLookAroundHelper.m_Acceleration, 0.0f, 100.0f, 0.1f);
bank.AddSlider("Deceleration", &camControlHelper::ms_OverriddenLookAroundHelper.m_Deceleration, 0.0f, 100.0f, 0.1f);
bank.AddSlider("Max Heading Speed", &camControlHelper::ms_OverriddenLookAroundHelper.m_MaxHeadingSpeed, 0.0f, 1000.0f, 0.1f);
bank.AddSlider("Max Pitch Speed", &camControlHelper::ms_OverriddenLookAroundHelper.m_MaxPitchSpeed, 0.0f, 1000.0f, 0.1f);
}
bank.PopGroup();
}
//NOTE: We must initialise the HUD component widgets separately to the other marketing widgets, as we require access to component filenames
//that only become available once the HUD has been initialised.
void CMarketingTools::InitHudComponentWidgets()
{
bkGroup* parentGroup = static_cast<bkGroup*>(BANKMGR.FindWidget("Marketing Tools/Hud Controls"));
if(!parentGroup)
{
return;
}
//Clean-up any existing widgets, for safety.
bkGroup* componentGroup = static_cast<bkGroup*>(BANKMGR.FindWidget("Marketing Tools/Hud Controls/Display Hud Components"));
if(componentGroup)
{
componentGroup->Destroy();
}
componentGroup = parentGroup->AddGroup("Display Hud Components", true);
if(componentGroup)
{
for(s32 i=0; i<MAX_NEW_HUD_COMPONENTS; i++)
{
const char* componentName = CNewHud::GetHudComponentFileName(i);
if(componentName)
{
componentGroup->AddToggle(componentName, &ms_DisplayHudComponent[i]);
}
}
}
}
void CMarketingTools::CLightDebugSetup::Reset()
{
m_LightColour.Set(255.0f,255.0f,255.0f);
m_LightPosition.Zero();
m_LightDirection.Set(0.0f, 0.0f, 1.0f);
m_LightTangent.Set(0.0f, 1.0f, 0.0f);
m_LightRange = 10.0f;
m_LightInnerCone = 50.0f;
m_LightOuterCone = 50.0f;
m_LightConeAngle = 30.0f;
m_LightIntensity = 10.0f;
m_LightFalloffExponent = 8.0f;
m_LightType = 1;
m_IsCoronaOnly = false;
m_IsLightAttached = true;
m_IsLightOrientedToCam = true;
m_IsDynamicShadowLight = false;
m_IsFXLight = false;
m_LightCapsuleExtent = 10.0f;
}
void CMarketingTools::CLightDebugSetup::AddWidgets(bkBank & bank)
{
bank.AddCombo("Light Type", &m_LightType, 3, g_LightTypeNames, datCallback(WidgetRefreshLightWidgets));
if( m_LightType != 0 )
{
bank.AddToggle("Orient light to camera", &m_IsLightOrientedToCam, datCallback(WidgetRefreshLightWidgets));
}
bank.AddToggle("Attach light to camera", &m_IsLightAttached, datCallback(WidgetRefreshLightWidgets));
if( m_LightType != 2 )
{
bank.AddToggle("Use dynamic shadows", &m_IsDynamicShadowLight);
}
bank.AddToggle("Is Corona Only", &m_IsCoronaOnly);
bank.AddToggle("Is FX Light", &m_IsFXLight);
// common
bank.AddSlider("Colour", &m_LightColour, 0.0f, 255.0f, 1.0f);
bank.AddSlider("Range", &m_LightRange, 1.0f, 50.0f, 1.0f);
bank.AddSlider("Intensity", &m_LightIntensity, 0.0f, 100.0f, 0.1f);
bank.AddSlider("Falloff speed", &m_LightFalloffExponent, 0.0f, 64.0f, 0.1f);
bank.AddSlider("Position", &m_LightPosition, -12000.0f, 12000.0f, 0.1f);
// type-specific parameters
if( m_LightType == 1 )
{
bank.AddSlider("Direction", &m_LightDirection, -1.0f, 1.0f, 0.01f);
bank.AddSlider("Inner Cone percentage", &m_LightInnerCone, 0.0f, 100.0f, 1.0f);
bank.AddSlider("Outer Cone percentage", &m_LightOuterCone, 0.0f, 100.0f, 1.0f);
bank.AddSlider("Cone Angle", &m_LightConeAngle, 0.0f, 179.0f, 1.0f);
}
if( m_LightType == 2 )
{
bank.AddSlider("Direction", &m_LightDirection, -1.0f, 1.0f, 0.01f);
bank.AddSlider("Capsule extent", &m_LightCapsuleExtent, 0.0f, 200.0f, 1.0f);
}
}
void CMarketingTools::WidgetAddLight()
{
if (ms_LightArrayNumUsed<MAX_DEBUG_LIGHTS)
{
if (ms_LightArrayNumUsed>0)
{
// copy the current light's settings
ms_LightArray[ms_LightArrayNumUsed] = ms_LightArray[ms_LightArrayEditIndex];
// detatch the current light from the camera
ms_LightArray[ms_LightArrayEditIndex].m_IsLightAttached = false;
}
else
{
// Adding a first light
ms_LightsEnabled = true;
ms_LightArray[ms_LightArrayNumUsed].Reset();
}
// Set the light position/direction to the current camera position (leave everything else alone)
//Move the light with the camera frame.
const Vector3 lightDir(0.0f, 1.0f, 0.0f);
const Vector3 lightTan(1.0f, 0.0f, 0.0f);
camInterface::GetMat().Transform3x3(lightDir, ms_LightArray[ms_LightArrayNumUsed].m_LightDirection);
camInterface::GetMat().Transform3x3(lightTan, ms_LightArray[ms_LightArrayNumUsed].m_LightTangent);
ms_LightArray[ms_LightArrayNumUsed].m_LightPosition = camInterface::GetPos();
// attach the new light to the camera
ms_LightArray[ms_LightArrayNumUsed].m_IsLightAttached = true;
ms_LightArray[ms_LightArrayNumUsed].m_IsLightOrientedToCam = true;
ms_LightArrayEditIndex = ms_LightArrayNumUsed;
ms_LightArrayNumUsed++;
WidgetRefreshLightWidgets();
}
}
void CMarketingTools::WidgetDeleteLight()
{
if (ms_LightArrayNumUsed<=0)
return;
ms_LightArrayNumUsed--;
for(int i=ms_LightArrayEditIndex;i<ms_LightArrayNumUsed;i++)
ms_LightArray[i] = ms_LightArray[i-1];
WidgetRefreshLightWidgets();
}
void CMarketingTools::WidgetChangeEditIndex()
{
WidgetRefreshLightWidgets();
}
void CMarketingTools::WidgetRefreshLightWidgets()
{
if (ms_LightArrayEditIndex >= ms_LightArrayNumUsed)
ms_LightArrayEditIndex = ms_LightArrayNumUsed-1;
bkBank * bank = BANKMGR.FindBank("Marketing Tools");
if (ms_LightWidgetGroup)
bank->DeleteGroup(*ms_LightWidgetGroup);
ms_LightWidgetGroup = NULL;
if (ms_LightArrayNumUsed>0)
{
bank->SetCurrentGroup(*ms_LightControlGroup);
ms_LightWidgetGroup = bank->PushGroup("Current Light", true);
ms_LightArray[ms_LightArrayEditIndex].AddWidgets(*bank);
bank->PopGroup();
bank->UnSetCurrentGroup(*ms_LightControlGroup);
}
else
ms_LightArrayEditIndex = 0;
}
void CMarketingTools::WidgetDropExplosion()
{
if (!ms_ExplosionSetup)
return;
// put the explosion 1m in front of the camera
Vector3 dropPos = camInterface::GetPos();
dropPos += camInterface::GetFront();
ms_ExplosionSetup->m_explosionPosition = dropPos;
ms_ExplosionSetup->m_vDirection = camInterface::GetUp();
CExplosionManager::AddExplosion(*ms_ExplosionSetup);
}
bool CMarketingTools::ShouldDisableBloodForPed(const CPed& ped)
{
const bool shouldDisableBlood = (ms_BloodMode == BLOOD_DISABLED_GLOBALLY) || ((ms_BloodMode == BLOOD_DISABLED_FOR_PLAYER) &&
(CGameWorld::FindFollowPlayer() == &ped));
return shouldDisableBlood;
}
void CMarketingTools::WidgetHudShowAll()
{
ms_DisplayHud = true;
ms_DisplayMiniMap = true;
ms_DisplayMarkers = true;
for(s32 i=0; i<MAX_NEW_HUD_COMPONENTS; i++)
{
ms_DisplayHudComponent[i] = true;
}
WidgetChangedHudToggles();
ms_WasHudShown = true;
}
void CMarketingTools::WidgetHudHideAll()
{
ms_DisplayHud = false;
ms_DisplayMiniMap = false;
ms_DisplayMarkers = false;
for(s32 i=0; i<MAX_NEW_HUD_COMPONENTS; i++)
{
ms_DisplayHudComponent[i] = false;
}
WidgetChangedHudToggles();
ms_WasHudShown = false;
}
void CMarketingTools::WidgetChangedHudToggles()
{
CHudTools::bDisplayHud = ms_DisplayHud;
CMarkers::g_bDisplayMarkers = ms_DisplayMarkers;
CMiniMap::SetVisible(ms_DisplayMiniMap);
}
void CMarketingTools::WidgetAddCharacterControls()
{
if (ms_CharacterWidgetGroup)
return;
CAnimViewer::InitModelNameCombo();
bkBank * bank = BANKMGR.FindBank("Marketing Tools");
//if (ms_CharacterWidgetGroup)
// bank->DeleteGroup(*ms_CharacterWidgetGroup);
//ms_CharacterWidgetGroup = NULL;
bank->SetCurrentGroup(*ms_CharacterControlsGroup);
ms_CharacterWidgetGroup = bank->PushGroup("Character", true);
{
// yuck!
bank->AddCombo("Select Model", &CAnimViewer::m_modelIndex, CAnimViewer::m_modelNames.GetCount(), &CAnimViewer::m_modelNames[0], datCallback(CFA(CAnimViewer::SelectPed)), "Lists the models");
bank->AddButton("Set Focus to Player", CPedDebugVisualiserMenu::ChangeFocusToPlayer, "Sets the focused entity to be the players ped");
// Add the weapon/inventory widgets
CPedInventory::AddWidgets(*bank);
}
bank->PopGroup();
bank->UnSetCurrentGroup(*ms_CharacterControlsGroup);
}
#endif // __BANK