AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
metaforce/Runtime/CStateManager.cpp

2911 lines
104 KiB
C++
Raw Normal View History

More CRidley imps
2019-11-12 20:25:21 +00:00
#include "Runtime/CStateManager.hpp"
Some CGameArea state imps
2016-07-23 03:07:07 +00:00
#include <cmath>
More CRidley imps
2019-11-12 20:25:21 +00:00
#include "Runtime/AutoMapper/CMapWorldInfo.hpp"
#include "Runtime/Camera/CBallCamera.hpp"
#include "Runtime/Camera/CCameraShakeData.hpp"
#include "Runtime/Camera/CGameCamera.hpp"
#include "Runtime/CGameState.hpp"
#include "Runtime/CMemoryCardSys.hpp"
Initial CMetroidPrimeExo imps
2020-09-23 19:41:51 +00:00
#include "Runtime/Collision/CCollisionActor.hpp"
More CRidley imps
2019-11-12 20:25:21 +00:00
#include "Runtime/Collision/CCollidableSphere.hpp"
#include "Runtime/Collision/CGameCollision.hpp"
#include "Runtime/Collision/CMaterialFilter.hpp"
#include "Runtime/Collision/CollisionUtil.hpp"
#include "Runtime/CPlayerState.hpp"
#include "Runtime/CSortedLists.hpp"
#include "Runtime/CTimeProvider.hpp"
#include "Runtime/GameGlobalObjects.hpp"
#include "Runtime/Graphics/CBooRenderer.hpp"
#include "Runtime/Graphics/CLight.hpp"
#include "Runtime/Input/ControlMapper.hpp"
#include "Runtime/Input/CRumbleManager.hpp"
#include "Runtime/MP1/CSamusHud.hpp"
#include "Runtime/MP1/MP1.hpp"
#include "Runtime/Particle/CDecalManager.hpp"
#include "Runtime/Particle/CParticleElectric.hpp"
#include "Runtime/Weapon/CProjectileWeapon.hpp"
#include "Runtime/Weapon/CWeapon.hpp"
#include "Runtime/Weapon/CWeaponMgr.hpp"
#include "Runtime/World/CDestroyableRock.hpp"
#include "Runtime/World/CGameLight.hpp"
#include "Runtime/World/CPathFindSearch.hpp"
#include "Runtime/World/CPatterned.hpp"
#include "Runtime/World/CPlayer.hpp"
#include "Runtime/World/CProjectedShadow.hpp"
#include "Runtime/World/CScriptDebris.hpp"
#include "Runtime/World/CScriptDock.hpp"
#include "Runtime/World/CScriptDoor.hpp"
#include "Runtime/World/CScriptEffect.hpp"
#include "Runtime/World/CScriptPlatform.hpp"
#include "Runtime/World/CScriptPlayerActor.hpp"
#include "Runtime/World/CScriptRoomAcoustics.hpp"
#include "Runtime/World/CScriptSpawnPoint.hpp"
#include "Runtime/World/CScriptSpecialFunction.hpp"
#include "Runtime/World/CScriptWater.hpp"
#include "Runtime/World/CSnakeWeedSwarm.hpp"
#include "Runtime/World/CWallCrawlerSwarm.hpp"
#include "Runtime/World/CWorld.hpp"
#include "TCastTo.hpp" // Generated file, do not modify include path
#include <hecl/CVarManager.hpp>
#include <zeus/CMRay.hpp>
Rename everything
2021-04-10 08:42:06 +00:00
namespace metaforce {
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
namespace {
hecl::CVar* debugToolDrawAiPath = nullptr;
hecl::CVar* debugToolDrawLighting = nullptr;
hecl::CVar* debugToolDrawCollisionActors = nullptr;
hecl::CVar* debugToolDrawMazePath = nullptr;
Add debug rendering for CScriptPlatform (CVar: debugTool.drawPlatformCollision)
2021-01-17 03:33:03 +00:00
hecl::CVar* debugToolDrawPlatformCollision = nullptr;
Better handling for logging CVar
2018-06-13 03:20:49 +00:00
hecl::CVar* sm_logScripting = nullptr;
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
} // namespace
Rename everything
2021-04-10 08:42:06 +00:00
logvisor::Module LogModule("metaforce::CStateManager");
Rename CWorldLayerState to CScriptLayerManager (this is it's actual name)
2021-06-04 06:08:05 +00:00
CStateManager::CStateManager(const std::weak_ptr<CScriptMailbox>& mailbox,
New code style refactor
2018-12-08 05:30:43 +00:00
const std::weak_ptr<CMapWorldInfo>& mwInfo, const std::weak_ptr<CPlayerState>& playerState,
Work on memory card sys; CMake fixes
2016-10-09 07:45:04 +00:00
const std::weak_ptr<CWorldTransManager>& wtMgr,
Rename CWorldLayerState to CScriptLayerManager (this is it's actual name)
2021-06-04 06:08:05 +00:00
const std::weak_ptr<CScriptLayerManager>& layerState)
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
: x8b8_playerState(playerState)
Rename CWorldLayerState to CScriptLayerManager (this is it's actual name)
2021-06-04 06:08:05 +00:00
, x8bc_mailbox(mailbox)
CScriptTrigger work
2017-01-15 03:59:37 +00:00
, x8c0_mapWorldInfo(mwInfo)
, x8c4_worldTransManager(wtMgr)
RuntimeCommonB: Make use of bitfield initializers where applicable Given that we now target C++20, we can make use of bitfield initializers where applicable.
2020-04-20 04:57:50 +00:00
, x8c8_worldLayerState(layerState) {
Runtime: Make use of std::make_unique where applicable Makes use of the C++14 make_unique allocation function to allocate class instances where applicable instead of a reset with a new operator within it. This doesn't touch cases where buffers are allocated, given make_unique would zero-initialize them.
2019-09-12 03:50:38 +00:00
x86c_stateManagerContainer = std::make_unique<CStateManagerContainer>();
New code style refactor
2018-12-08 05:30:43 +00:00
x870_cameraManager = &x86c_stateManagerContainer->x0_cameraManager;
x874_sortedListManager = &x86c_stateManagerContainer->x3c0_sortedListManager;
x878_weaponManager = &x86c_stateManagerContainer->xe3d8_weaponManager;
x87c_fluidPlaneManager = &x86c_stateManagerContainer->xe3ec_fluidPlaneManager;
x880_envFxManager = &x86c_stateManagerContainer->xe510_envFxManager;
x884_actorModelParticles = &x86c_stateManagerContainer->xf168_actorModelParticles;
x88c_rumbleManager = &x86c_stateManagerContainer->xf250_rumbleManager;
g_Renderer->SetDrawableCallback(&CStateManager::RendererDrawCallback, this);
x908_loaderCount = int(EScriptObjectType::ScriptObjectTypeMAX);
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
x90c_loaderFuncs[size_t(EScriptObjectType::Actor)] = ScriptLoader::LoadActor;
x90c_loaderFuncs[size_t(EScriptObjectType::Waypoint)] = ScriptLoader::LoadWaypoint;
x90c_loaderFuncs[size_t(EScriptObjectType::Door)] = ScriptLoader::LoadDoor;
x90c_loaderFuncs[size_t(EScriptObjectType::Trigger)] = ScriptLoader::LoadTrigger;
x90c_loaderFuncs[size_t(EScriptObjectType::Timer)] = ScriptLoader::LoadTimer;
x90c_loaderFuncs[size_t(EScriptObjectType::Counter)] = ScriptLoader::LoadCounter;
x90c_loaderFuncs[size_t(EScriptObjectType::Effect)] = ScriptLoader::LoadEffect;
x90c_loaderFuncs[size_t(EScriptObjectType::Platform)] = ScriptLoader::LoadPlatform;
x90c_loaderFuncs[size_t(EScriptObjectType::Sound)] = ScriptLoader::LoadSound;
x90c_loaderFuncs[size_t(EScriptObjectType::Generator)] = ScriptLoader::LoadGenerator;
x90c_loaderFuncs[size_t(EScriptObjectType::Dock)] = ScriptLoader::LoadDock;
x90c_loaderFuncs[size_t(EScriptObjectType::Camera)] = ScriptLoader::LoadCamera;
x90c_loaderFuncs[size_t(EScriptObjectType::CameraWaypoint)] = ScriptLoader::LoadCameraWaypoint;
x90c_loaderFuncs[size_t(EScriptObjectType::NewIntroBoss)] = ScriptLoader::LoadNewIntroBoss;
x90c_loaderFuncs[size_t(EScriptObjectType::SpawnPoint)] = ScriptLoader::LoadSpawnPoint;
x90c_loaderFuncs[size_t(EScriptObjectType::CameraHint)] = ScriptLoader::LoadCameraHint;
x90c_loaderFuncs[size_t(EScriptObjectType::Pickup)] = ScriptLoader::LoadPickup;
x90c_loaderFuncs[size_t(EScriptObjectType::MemoryRelay)] = ScriptLoader::LoadMemoryRelay;
x90c_loaderFuncs[size_t(EScriptObjectType::RandomRelay)] = ScriptLoader::LoadRandomRelay;
x90c_loaderFuncs[size_t(EScriptObjectType::Relay)] = ScriptLoader::LoadRelay;
x90c_loaderFuncs[size_t(EScriptObjectType::Beetle)] = ScriptLoader::LoadBeetle;
x90c_loaderFuncs[size_t(EScriptObjectType::HUDMemo)] = ScriptLoader::LoadHUDMemo;
x90c_loaderFuncs[size_t(EScriptObjectType::CameraFilterKeyframe)] = ScriptLoader::LoadCameraFilterKeyframe;
x90c_loaderFuncs[size_t(EScriptObjectType::CameraBlurKeyframe)] = ScriptLoader::LoadCameraBlurKeyframe;
x90c_loaderFuncs[size_t(EScriptObjectType::DamageableTrigger)] = ScriptLoader::LoadDamageableTrigger;
x90c_loaderFuncs[size_t(EScriptObjectType::Debris)] = ScriptLoader::LoadDebris;
x90c_loaderFuncs[size_t(EScriptObjectType::CameraShaker)] = ScriptLoader::LoadCameraShaker;
x90c_loaderFuncs[size_t(EScriptObjectType::ActorKeyframe)] = ScriptLoader::LoadActorKeyframe;
x90c_loaderFuncs[size_t(EScriptObjectType::Water)] = ScriptLoader::LoadWater;
x90c_loaderFuncs[size_t(EScriptObjectType::Warwasp)] = ScriptLoader::LoadWarWasp;
x90c_loaderFuncs[size_t(EScriptObjectType::SpacePirate)] = ScriptLoader::LoadSpacePirate;
x90c_loaderFuncs[size_t(EScriptObjectType::FlyingPirate)] = ScriptLoader::LoadFlyingPirate;
x90c_loaderFuncs[size_t(EScriptObjectType::ElitePirate)] = ScriptLoader::LoadElitePirate;
x90c_loaderFuncs[size_t(EScriptObjectType::MetroidBeta)] = ScriptLoader::LoadMetroidBeta;
x90c_loaderFuncs[size_t(EScriptObjectType::ChozoGhost)] = ScriptLoader::LoadChozoGhost;
x90c_loaderFuncs[size_t(EScriptObjectType::CoverPoint)] = ScriptLoader::LoadCoverPoint;
x90c_loaderFuncs[size_t(EScriptObjectType::SpiderBallWaypoint)] = ScriptLoader::LoadSpiderBallWaypoint;
x90c_loaderFuncs[size_t(EScriptObjectType::BloodFlower)] = ScriptLoader::LoadBloodFlower;
x90c_loaderFuncs[size_t(EScriptObjectType::FlickerBat)] = ScriptLoader::LoadFlickerBat;
x90c_loaderFuncs[size_t(EScriptObjectType::PathCamera)] = ScriptLoader::LoadPathCamera;
x90c_loaderFuncs[size_t(EScriptObjectType::GrapplePoint)] = ScriptLoader::LoadGrapplePoint;
x90c_loaderFuncs[size_t(EScriptObjectType::PuddleSpore)] = ScriptLoader::LoadPuddleSpore;
x90c_loaderFuncs[size_t(EScriptObjectType::DebugCameraWaypoint)] = ScriptLoader::LoadDebugCameraWaypoint;
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
x90c_loaderFuncs[size_t(EScriptObjectType::SpiderBallAttractionSurface)] =
ScriptLoader::LoadSpiderBallAttractionSurface;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
x90c_loaderFuncs[size_t(EScriptObjectType::PuddleToadGamma)] = ScriptLoader::LoadPuddleToadGamma;
x90c_loaderFuncs[size_t(EScriptObjectType::DistanceFog)] = ScriptLoader::LoadDistanceFog;
x90c_loaderFuncs[size_t(EScriptObjectType::FireFlea)] = ScriptLoader::LoadFireFlea;
x90c_loaderFuncs[size_t(EScriptObjectType::Metaree)] = ScriptLoader::LoadMetaree;
x90c_loaderFuncs[size_t(EScriptObjectType::DockAreaChange)] = ScriptLoader::LoadDockAreaChange;
x90c_loaderFuncs[size_t(EScriptObjectType::ActorRotate)] = ScriptLoader::LoadActorRotate;
x90c_loaderFuncs[size_t(EScriptObjectType::SpecialFunction)] = ScriptLoader::LoadSpecialFunction;
x90c_loaderFuncs[size_t(EScriptObjectType::SpankWeed)] = ScriptLoader::LoadSpankWeed;
x90c_loaderFuncs[size_t(EScriptObjectType::Parasite)] = ScriptLoader::LoadParasite;
x90c_loaderFuncs[size_t(EScriptObjectType::PlayerHint)] = ScriptLoader::LoadPlayerHint;
x90c_loaderFuncs[size_t(EScriptObjectType::Ripper)] = ScriptLoader::LoadRipper;
x90c_loaderFuncs[size_t(EScriptObjectType::PickupGenerator)] = ScriptLoader::LoadPickupGenerator;
x90c_loaderFuncs[size_t(EScriptObjectType::AIKeyframe)] = ScriptLoader::LoadAIKeyframe;
x90c_loaderFuncs[size_t(EScriptObjectType::PointOfInterest)] = ScriptLoader::LoadPointOfInterest;
x90c_loaderFuncs[size_t(EScriptObjectType::Drone)] = ScriptLoader::LoadDrone;
x90c_loaderFuncs[size_t(EScriptObjectType::Metroid)] = ScriptLoader::LoadMetroid;
x90c_loaderFuncs[size_t(EScriptObjectType::DebrisExtended)] = ScriptLoader::LoadDebrisExtended;
x90c_loaderFuncs[size_t(EScriptObjectType::Steam)] = ScriptLoader::LoadSteam;
x90c_loaderFuncs[size_t(EScriptObjectType::Ripple)] = ScriptLoader::LoadRipple;
x90c_loaderFuncs[size_t(EScriptObjectType::BallTrigger)] = ScriptLoader::LoadBallTrigger;
x90c_loaderFuncs[size_t(EScriptObjectType::TargetingPoint)] = ScriptLoader::LoadTargetingPoint;
x90c_loaderFuncs[size_t(EScriptObjectType::EMPulse)] = ScriptLoader::LoadEMPulse;
x90c_loaderFuncs[size_t(EScriptObjectType::IceSheegoth)] = ScriptLoader::LoadIceSheegoth;
x90c_loaderFuncs[size_t(EScriptObjectType::PlayerActor)] = ScriptLoader::LoadPlayerActor;
x90c_loaderFuncs[size_t(EScriptObjectType::Flaahgra)] = ScriptLoader::LoadFlaahgra;
x90c_loaderFuncs[size_t(EScriptObjectType::AreaAttributes)] = ScriptLoader::LoadAreaAttributes;
x90c_loaderFuncs[size_t(EScriptObjectType::FishCloud)] = ScriptLoader::LoadFishCloud;
x90c_loaderFuncs[size_t(EScriptObjectType::FishCloudModifier)] = ScriptLoader::LoadFishCloudModifier;
x90c_loaderFuncs[size_t(EScriptObjectType::VisorFlare)] = ScriptLoader::LoadVisorFlare;
x90c_loaderFuncs[size_t(EScriptObjectType::WorldTeleporter)] = ScriptLoader::LoadWorldTeleporter;
x90c_loaderFuncs[size_t(EScriptObjectType::VisorGoo)] = ScriptLoader::LoadVisorGoo;
x90c_loaderFuncs[size_t(EScriptObjectType::JellyZap)] = ScriptLoader::LoadJellyZap;
x90c_loaderFuncs[size_t(EScriptObjectType::ControllerAction)] = ScriptLoader::LoadControllerAction;
x90c_loaderFuncs[size_t(EScriptObjectType::Switch)] = ScriptLoader::LoadSwitch;
x90c_loaderFuncs[size_t(EScriptObjectType::PlayerStateChange)] = ScriptLoader::LoadPlayerStateChange;
x90c_loaderFuncs[size_t(EScriptObjectType::Thardus)] = ScriptLoader::LoadThardus;
x90c_loaderFuncs[size_t(EScriptObjectType::WallCrawlerSwarm)] = ScriptLoader::LoadWallCrawlerSwarm;
x90c_loaderFuncs[size_t(EScriptObjectType::AIJumpPoint)] = ScriptLoader::LoadAiJumpPoint;
x90c_loaderFuncs[size_t(EScriptObjectType::FlaahgraTentacle)] = ScriptLoader::LoadFlaahgraTentacle;
x90c_loaderFuncs[size_t(EScriptObjectType::RoomAcoustics)] = ScriptLoader::LoadRoomAcoustics;
x90c_loaderFuncs[size_t(EScriptObjectType::ColorModulate)] = ScriptLoader::LoadColorModulate;
x90c_loaderFuncs[size_t(EScriptObjectType::ThardusRockProjectile)] = ScriptLoader::LoadThardusRockProjectile;
x90c_loaderFuncs[size_t(EScriptObjectType::Midi)] = ScriptLoader::LoadMidi;
x90c_loaderFuncs[size_t(EScriptObjectType::StreamedAudio)] = ScriptLoader::LoadStreamedAudio;
x90c_loaderFuncs[size_t(EScriptObjectType::WorldTeleporterToo)] = ScriptLoader::LoadWorldTeleporter;
x90c_loaderFuncs[size_t(EScriptObjectType::Repulsor)] = ScriptLoader::LoadRepulsor;
x90c_loaderFuncs[size_t(EScriptObjectType::GunTurret)] = ScriptLoader::LoadGunTurret;
x90c_loaderFuncs[size_t(EScriptObjectType::FogVolume)] = ScriptLoader::LoadFogVolume;
x90c_loaderFuncs[size_t(EScriptObjectType::Babygoth)] = ScriptLoader::LoadBabygoth;
x90c_loaderFuncs[size_t(EScriptObjectType::Eyeball)] = ScriptLoader::LoadEyeball;
x90c_loaderFuncs[size_t(EScriptObjectType::RadialDamage)] = ScriptLoader::LoadRadialDamage;
x90c_loaderFuncs[size_t(EScriptObjectType::CameraPitchVolume)] = ScriptLoader::LoadCameraPitchVolume;
x90c_loaderFuncs[size_t(EScriptObjectType::EnvFxDensityController)] = ScriptLoader::LoadEnvFxDensityController;
x90c_loaderFuncs[size_t(EScriptObjectType::Magdolite)] = ScriptLoader::LoadMagdolite;
x90c_loaderFuncs[size_t(EScriptObjectType::TeamAIMgr)] = ScriptLoader::LoadTeamAIMgr;
x90c_loaderFuncs[size_t(EScriptObjectType::SnakeWeedSwarm)] = ScriptLoader::LoadSnakeWeedSwarm;
x90c_loaderFuncs[size_t(EScriptObjectType::ActorContraption)] = ScriptLoader::LoadActorContraption;
x90c_loaderFuncs[size_t(EScriptObjectType::Oculus)] = ScriptLoader::LoadOculus;
x90c_loaderFuncs[size_t(EScriptObjectType::Geemer)] = ScriptLoader::LoadGeemer;
x90c_loaderFuncs[size_t(EScriptObjectType::SpindleCamera)] = ScriptLoader::LoadSpindleCamera;
x90c_loaderFuncs[size_t(EScriptObjectType::AtomicAlpha)] = ScriptLoader::LoadAtomicAlpha;
x90c_loaderFuncs[size_t(EScriptObjectType::CameraHintTrigger)] = ScriptLoader::LoadCameraHintTrigger;
x90c_loaderFuncs[size_t(EScriptObjectType::RumbleEffect)] = ScriptLoader::LoadRumbleEffect;
x90c_loaderFuncs[size_t(EScriptObjectType::AmbientAI)] = ScriptLoader::LoadAmbientAI;
x90c_loaderFuncs[size_t(EScriptObjectType::AtomicBeta)] = ScriptLoader::LoadAtomicBeta;
x90c_loaderFuncs[size_t(EScriptObjectType::IceZoomer)] = ScriptLoader::LoadIceZoomer;
x90c_loaderFuncs[size_t(EScriptObjectType::Puffer)] = ScriptLoader::LoadPuffer;
x90c_loaderFuncs[size_t(EScriptObjectType::Tryclops)] = ScriptLoader::LoadTryclops;
x90c_loaderFuncs[size_t(EScriptObjectType::Ridley)] = ScriptLoader::LoadRidley;
x90c_loaderFuncs[size_t(EScriptObjectType::Seedling)] = ScriptLoader::LoadSeedling;
x90c_loaderFuncs[size_t(EScriptObjectType::ThermalHeatFader)] = ScriptLoader::LoadThermalHeatFader;
x90c_loaderFuncs[size_t(EScriptObjectType::Burrower)] = ScriptLoader::LoadBurrower;
x90c_loaderFuncs[size_t(EScriptObjectType::ScriptBeam)] = ScriptLoader::LoadBeam;
x90c_loaderFuncs[size_t(EScriptObjectType::WorldLightFader)] = ScriptLoader::LoadWorldLightFader;
Initial CMetroidPrimeEssence behavior
2020-09-19 22:08:07 +00:00
x90c_loaderFuncs[size_t(EScriptObjectType::MetroidPrimeStage2)] = ScriptLoader::LoadMetroidPrimeEssence;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
x90c_loaderFuncs[size_t(EScriptObjectType::MetroidPrimeStage1)] = ScriptLoader::LoadMetroidPrimeStage1;
x90c_loaderFuncs[size_t(EScriptObjectType::MazeNode)] = ScriptLoader::LoadMazeNode;
x90c_loaderFuncs[size_t(EScriptObjectType::OmegaPirate)] = ScriptLoader::LoadOmegaPirate;
x90c_loaderFuncs[size_t(EScriptObjectType::PhazonPool)] = ScriptLoader::LoadPhazonPool;
x90c_loaderFuncs[size_t(EScriptObjectType::PhazonHealingNodule)] = ScriptLoader::LoadPhazonHealingNodule;
x90c_loaderFuncs[size_t(EScriptObjectType::NewCameraShaker)] = ScriptLoader::LoadNewCameraShaker;
x90c_loaderFuncs[size_t(EScriptObjectType::ShadowProjector)] = ScriptLoader::LoadShadowProjector;
x90c_loaderFuncs[size_t(EScriptObjectType::EnergyBall)] = ScriptLoader::LoadEnergyBall;
New code style refactor
2018-12-08 05:30:43 +00:00
CGameCollision::InitCollision();
ControlMapper::ResetCommandFilters();
x8f0_shadowTex = g_SimplePool->GetObj("DefaultShadow");
g_StateManager = this;
sm_logScripting = hecl::CVarManager::instance()->findOrMakeCVar(
"stateManager.logScripting"sv, "Prints object communication to the console", false,
hecl::CVar::EFlags::ReadOnly | hecl::CVar::EFlags::Archive | hecl::CVar::EFlags::Game);
}
CStateManager::~CStateManager() {
x88c_rumbleManager->HardStopAll();
x880_envFxManager->Cleanup();
x900_activeRandom = &x8fc_random;
ClearGraveyard();
for (auto it = x808_objLists[0]->begin(); it != x808_objLists[0]->end();) {
CEntity* ent = *it;
++it;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ent == x84c_player.get()) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
ent->AcceptScriptMsg(EScriptObjectMessage::Deleted, kInvalidUniqueId, *this);
RemoveObject(ent->GetUniqueId());
std::default_delete<CEntity>()(ent);
}
ClearGraveyard();
x84c_player->AcceptScriptMsg(EScriptObjectMessage::Deleted, kInvalidUniqueId, *this);
RemoveObject(x84c_player->GetUniqueId());
x84c_player.reset();
CCollisionPrimitive::Uninitialize();
g_StateManager = nullptr;
}
void CStateManager::UpdateThermalVisor() {
xf28_thermColdScale2 = 0.f;
xf24_thermColdScale1 = 0.f;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const auto visor = x8b8_playerState->GetActiveVisor(*this);
if (visor != CPlayerState::EPlayerVisor::Thermal || x8cc_nextAreaId == kInvalidAreaId) {
return;
}
CGameArea* area = x850_world->GetArea(x8cc_nextAreaId);
const zeus::CTransform& playerXf = x84c_player->GetTransform();
const zeus::CVector3f playerXYPos(playerXf.origin.x(), playerXf.origin.y(), 0.f);
CGameArea* lastArea = nullptr;
float closestDist = FLT_MAX;
for (const CGameArea::Dock& dock : area->GetDocks()) {
zeus::CVector3f dockCenter = (dock.GetPlaneVertices()[0] + dock.GetPlaneVertices()[1] + dock.GetPlaneVertices()[2] +
dock.GetPlaneVertices()[3]) *
0.25f;
dockCenter.z() = 0.f;
const float dist = (playerXYPos - dockCenter).magSquared();
if (dist < closestDist) {
const TAreaId connAreaId = dock.GetConnectedAreaId(0);
if (connAreaId != kInvalidAreaId) {
CGameArea* connArea = x850_world->GetArea(x8cc_nextAreaId);
if (connArea->IsPostConstructed()) {
const auto occState = connArea->GetPostConstructed()->x10dc_occlusionState;
if (occState == CGameArea::EOcclusionState::Visible) {
closestDist = dist;
lastArea = connArea;
New code style refactor
2018-12-08 05:30:43 +00:00
}
Some CGameArea state imps
2016-07-23 03:07:07 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Additional ThermalCold filter work; CStateManager fields
2016-07-22 19:46:30 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Additional ThermalCold filter work; CStateManager fields
2016-07-22 19:46:30 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (lastArea != nullptr) {
if (closestDist != 0.f) {
closestDist /= std::sqrt(closestDist);
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
closestDist -= 2.f;
if (closestDist < 8.f) {
if (closestDist > 0.f) {
closestDist = (closestDist / 8.f) * 0.5f + 0.5f;
} else {
closestDist = 0.5f;
}
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
xf24_thermColdScale1 = (1.f - closestDist) * lastArea->GetPostConstructed()->x111c_thermalCurrent +
closestDist * area->GetPostConstructed()->x111c_thermalCurrent;
return;
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
xf24_thermColdScale1 = area->GetPostConstructed()->x111c_thermalCurrent;
New code style refactor
2018-12-08 05:30:43 +00:00
}
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
void CStateManager::RendererDrawCallback(void* drawable, void* ctx, int type) {
CStateManager& mgr = *static_cast<CStateManager*>(ctx);
New code style refactor
2018-12-08 05:30:43 +00:00
switch (type) {
case 0: {
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
CActor& actor = *static_cast<CActor*>(drawable);
if (actor.xc8_drawnToken == mgr.x8dc_objectDrawToken) {
New code style refactor
2018-12-08 05:30:43 +00:00
break;
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
}
if (actor.xc6_nextDrawNode != kInvalidUniqueId) {
New code style refactor
2018-12-08 05:30:43 +00:00
mgr.RecursiveDrawTree(actor.xc6_nextDrawNode);
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
actor.Render(mgr);
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
actor.xc8_drawnToken = mgr.x8dc_objectDrawToken;
New code style refactor
2018-12-08 05:30:43 +00:00
break;
}
case 1:
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
static_cast<CSimpleShadow*>(drawable)->Render(mgr.x8f0_shadowTex);
New code style refactor
2018-12-08 05:30:43 +00:00
break;
case 2:
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
static_cast<CDecal*>(drawable)->Render();
New code style refactor
2018-12-08 05:30:43 +00:00
break;
default:
break;
}
}
bool CStateManager::RenderLast(TUniqueId uid) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x86c_stateManagerContainer->xf39c_renderLast.size() == 20) {
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
x86c_stateManagerContainer->xf39c_renderLast.push_back(uid);
return true;
AutoMapper work
2017-03-20 05:09:53 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
void CStateManager::AddDrawableActorPlane(CActor& actor, const zeus::CPlane& plane, const zeus::CAABox& aabb) const {
actor.SetAddedToken(x8dc_objectDrawToken + 1);
CStateManager: Remove unnecessary casts
2020-03-17 00:01:57 +00:00
g_Renderer->AddPlaneObject(&actor, aabb, plane, 0);
Various Implementations
2016-11-20 21:53:15 +00:00
}
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
void CStateManager::AddDrawableActor(CActor& actor, const zeus::CVector3f& vec, const zeus::CAABox& aabb) const {
actor.SetAddedToken(x8dc_objectDrawToken + 1);
CStateManager: Remove unnecessary casts
2020-03-17 00:01:57 +00:00
g_Renderer->AddDrawable(&actor, vec, aabb, 0, IRenderer::EDrawableSorting::SortedCallback);
CStateManager method stubs
2016-04-17 05:35:32 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
bool CStateManager::SpecialSkipCinematic() {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (xf38_skipCineSpecialFunc == kInvalidUniqueId) {
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Lots of CMFGame integration
2017-02-18 02:19:50 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
auto* ent = static_cast<CScriptSpecialFunction*>(ObjectById(xf38_skipCineSpecialFunc));
if (ent == nullptr || !ent->ShouldSkipCinematic(*this)) {
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Lots of CMFGame integration
2017-02-18 02:19:50 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const bool hadRandom = x900_activeRandom != nullptr;
New code style refactor
2018-12-08 05:30:43 +00:00
SetActiveRandomToDefault();
x870_cameraManager->SkipCinematic(*this);
ent->SkipCinematic(*this);
x900_activeRandom = hadRandom ? &x8fc_random : nullptr;
Lots of CMFGame integration
2017-02-18 02:19:50 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
return true;
Lots of CMFGame integration
2017-02-18 02:19:50 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
TAreaId CStateManager::GetVisAreaId() const {
const CGameCamera* cam = static_cast<const CGameCamera*>(x870_cameraManager->GetCurrentCamera(*this));
const CBallCamera* ballCam = x870_cameraManager->GetBallCamera();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const TAreaId curArea = x850_world->x68_curAreaId;
if (cam != ballCam) {
New code style refactor
2018-12-08 05:30:43 +00:00
return curArea;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Work on CStateManager rendering functions
2017-03-03 07:18:12 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
const zeus::CVector3f& camTranslation = ballCam->GetTranslation();
zeus::CAABox camAABB(camTranslation, camTranslation);
camAABB.accumulateBounds(x84c_player->GetTranslation());
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
EntityList nearList;
New code style refactor
2018-12-08 05:30:43 +00:00
BuildNearList(nearList, camAABB,
CMaterialFilter(EMaterialTypes::AIBlock, CMaterialList(), CMaterialFilter::EFilterType::Include),
nullptr);
Runtime: Resolve -Wrange-loop-analysis warnings (part 2)
2020-09-18 21:04:50 +00:00
for (const auto& id : nearList) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToConstPtr<CScriptDock> dock = GetObjectById(id)) {
if (dock->GetAreaId() == curArea && dock->HasPointCrossedDock(*this, camTranslation)) {
New code style refactor
2018-12-08 05:30:43 +00:00
return dock->GetCurrentConnectedAreaId(*this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
}
Work on CStateManager rendering functions
2017-03-03 07:18:12 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
return curArea;
Work on CStateManager rendering functions
2017-03-03 07:18:12 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
RuntimeCommon: Use const on member functions where applicable Adds missing const qualifiers on class member functions that don't modify instance state.
2019-08-14 10:04:11 +00:00
s32 CStateManager::GetWeaponIdCount(TUniqueId uid, EWeaponType type) const {
New code style refactor
2018-12-08 05:30:43 +00:00
return x878_weaponManager->GetNumActive(uid, type);
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::RemoveWeaponId(TUniqueId uid, EWeaponType type) { x878_weaponManager->DecrCount(uid, type); }
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::AddWeaponId(TUniqueId uid, EWeaponType type) { x878_weaponManager->IncrCount(uid, type); }
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::UpdateEscapeSequenceTimer(float dt) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (xf0c_escapeTimer <= 0.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
xf0c_escapeTimer = std::max(FLT_EPSILON, xf0c_escapeTimer - dt);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (xf0c_escapeTimer <= FLT_EPSILON) {
New code style refactor
2018-12-08 05:30:43 +00:00
x8b8_playerState->SetPlayerAlive(false);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (!g_EscapeShakeCountdownInit) {
g_EscapeShakeCountdown = 0.f;
g_EscapeShakeCountdownInit = true;
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
g_EscapeShakeCountdown -= dt;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (g_EscapeShakeCountdown >= 0.f) {
return;
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float factor = 1.f - xf0c_escapeTimer / xf10_escapeTotalTime;
const float factor2 = factor * factor;
const CCameraShakeData shakeData(1.f, factor2 * 0.2f * x900_activeRandom->Range(0.5f, 1.f));
x870_cameraManager->AddCameraShaker(shakeData, true);
x88c_rumbleManager->Rumble(*this, ERumbleFxId::EscapeSequenceShake, 0.75f, ERumblePriority::One);
g_EscapeShakeCountdown = -12.f * factor2 + 15.f;
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::ResetEscapeSequenceTimer(float time) {
xf0c_escapeTimer = time;
xf10_escapeTotalTime = time;
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::SetupParticleHook(const CActor& actor) const {
x884_actorModelParticles->SetupHook(actor.GetUniqueId());
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::MurderScriptInstanceNames() { xb40_uniqueInstanceNames.clear(); }
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
std::string CStateManager::HashInstanceName(CInputStream& in) { return in.readString(); }
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::SetActorAreaId(CActor& actor, TAreaId aid) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const TAreaId actorAid = actor.GetAreaIdAlways();
if (actorAid == aid) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (actorAid != kInvalidAreaId) {
CGameArea* area = x850_world->GetArea(actorAid);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (area->IsPostConstructed()) {
New code style refactor
2018-12-08 05:30:43 +00:00
area->GetAreaObjects()->RemoveObject(actor.GetUniqueId());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
actor.x4_areaId = aid;
Various movement and HUD bug fixes
2017-12-19 03:05:50 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (aid == kInvalidAreaId) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CGameArea* area = x850_world->GetArea(aid);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!area->IsPostConstructed() || area->GetAreaObjects()->GetValidObjectById(actor.GetUniqueId())) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
area->GetAreaObjects()->AddObject(actor);
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::TouchSky() const { x850_world->TouchSky(); }
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::TouchPlayerActor() {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (xf6c_playerActorHead == kInvalidUniqueId) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
if (CEntity* ent = ObjectById(xf6c_playerActorHead)) {
New code style refactor
2018-12-08 05:30:43 +00:00
static_cast<CScriptPlayerActor*>(ent)->TouchModels(*this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Prelim CPlayer imps, fix race condition in CGameGlobalObjects
2016-09-25 16:45:22 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::DrawSpaceWarp(const zeus::CVector3f& v, float strength) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const CPlayerState::EPlayerVisor visor = x8b8_playerState->GetActiveVisor(*this);
if (visor != CPlayerState::EPlayerVisor::Scan && visor != CPlayerState::EPlayerVisor::Combat) {
return;
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f screenV =
TCastToConstPtr<CGameCamera>(x870_cameraManager->GetCurrentCamera(*this))->ConvertToScreenSpace(v);
g_Renderer->DrawSpaceWarp(screenV, strength);
CStateManager method stubs
2016-04-17 05:35:32 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::DrawReflection(const zeus::CVector3f& reflectPoint) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CAABox aabb = x84c_player->GetBoundingBox();
const zeus::CVector3f playerPos = aabb.center();
New code style refactor
2018-12-08 05:30:43 +00:00
zeus::CVector3f surfToPlayer = playerPos - reflectPoint;
surfToPlayer.z() = 0.f;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f viewPos = playerPos - surfToPlayer.normalized() * 3.5f;
const zeus::CTransform look = zeus::lookAt(viewPos, playerPos, {0.f, 0.f, -1.f});
Player reflection and other imps
2017-03-26 05:53:04 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CTransform backupView = CGraphics::g_ViewMatrix;
New code style refactor
2018-12-08 05:30:43 +00:00
CGraphics::SetViewPointMatrix(look);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const CGraphics::CProjectionState backupProj = CGraphics::GetProjectionState();
const CGameCamera* cam = x870_cameraManager->GetCurrentCamera(*this);
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->SetPerspective(cam->GetFov(), g_Viewport.x8_width, g_Viewport.xc_height, cam->GetNearClipDistance(),
cam->GetFarClipDistance());
Player reflection and other imps
2017-03-26 05:53:04 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
x84c_player->RenderReflectedPlayer(*this);
Player reflection and other imps
2017-03-26 05:53:04 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
CGraphics::SetViewPointMatrix(backupView);
CGraphics::SetProjectionState(backupProj);
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::ReflectionDrawer(void* ctx, const zeus::CVector3f& vec) {
CStateManager: Convert reinterpret_cast instances over to static_cast Conversions from void* can be done with static_cast.
2020-03-17 00:05:21 +00:00
static_cast<CStateManager*>(ctx)->DrawReflection(vec);
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::CacheReflection() { g_Renderer->CacheReflection(ReflectionDrawer, this, true); }
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
bool CStateManager::CanCreateProjectile(TUniqueId uid, EWeaponType type, int maxAllowed) const {
return x878_weaponManager->GetNumActive(uid, type) < maxAllowed;
Additional CStateManager imps
2017-03-26 19:36:07 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::BuildDynamicLightListForWorld() {
if (x8b8_playerState->GetActiveVisor(*this) == CPlayerState::EPlayerVisor::Thermal) {
Work on CStateManager rendering functions
2017-03-03 07:18:12 +00:00
x8e0_dynamicLights.clear();
New code style refactor
2018-12-08 05:30:43 +00:00
return;
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CStateManager: Fix condition in BuildDynamicLightListForWorld
2020-07-07 10:14:41 +00:00
if (GetLightObjectList().size() == 0) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
x8e0_dynamicLights.clear();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
for (const CEntity* ent : GetLightObjectList()) {
const auto& light = static_cast<const CGameLight&>(*ent);
New code style refactor
2018-12-08 05:30:43 +00:00
if (light.GetActive()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const CLight l = light.GetLight();
if (l.GetIntensity() > FLT_EPSILON && l.GetRadius() > FLT_EPSILON) {
New code style refactor
2018-12-08 05:30:43 +00:00
x8e0_dynamicLights.push_back(l);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Additional CStateManager imps
2017-03-26 19:36:07 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Additional CStateManager imps
2017-03-26 19:36:07 +00:00
}
Space pirate bug fixes
2018-12-15 06:29:41 +00:00
void CStateManager::DrawDebugStuff() const {
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
if (hecl::com_developer != nullptr && !hecl::com_developer->toBoolean()) {
return;
}
// FIXME: Add proper globals for CVars
if (debugToolDrawAiPath == nullptr || debugToolDrawCollisionActors == nullptr || debugToolDrawLighting == nullptr ||
Add debug rendering for CScriptPlatform (CVar: debugTool.drawPlatformCollision)
2021-01-17 03:33:03 +00:00
debugToolDrawMazePath == nullptr || debugToolDrawPlatformCollision == nullptr) {
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
debugToolDrawAiPath = hecl::CVarManager::instance()->findCVar("debugTool.drawAiPath");
debugToolDrawMazePath = hecl::CVarManager::instance()->findCVar("debugTool.drawMazePath");
debugToolDrawCollisionActors = hecl::CVarManager::instance()->findCVar("debugTool.drawCollisionActors");
debugToolDrawLighting = hecl::CVarManager::instance()->findCVar("debugTool.drawLighting");
Add debug rendering for CScriptPlatform (CVar: debugTool.drawPlatformCollision)
2021-01-17 03:33:03 +00:00
debugToolDrawPlatformCollision = hecl::CVarManager::instance()->findCVar("debugTool.drawPlatformCollision");
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
return;
}
CScriptMazeNode: Fix reversed enter/target & add debug rendering
2020-09-22 00:42:54 +00:00
CGraphics::SetModelMatrix(zeus::CTransform());
Space pirate bug fixes
2018-12-15 06:29:41 +00:00
for (CEntity* ent : GetActorObjectList()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CPatterned> ai = ent) {
Space pirate bug fixes
2018-12-15 06:29:41 +00:00
if (CPathFindSearch* path = ai->GetSearchPath()) {
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
if (debugToolDrawAiPath->toBoolean()) {
path->DebugDraw();
}
Space pirate bug fixes
2018-12-15 06:29:41 +00:00
}
Add light visualization (requires custom models)
2020-12-13 07:39:55 +00:00
} else if (const TCastToPtr<CGameLight> light = ent) {
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
if (debugToolDrawLighting->toBoolean()) {
light->DebugDraw();
}
Initial CMetroidPrimeExo imps
2020-09-23 19:41:51 +00:00
} else if (const TCastToPtr<CCollisionActor> colAct = ent) {
More imps, initial AI execution
2020-09-25 08:30:57 +00:00
if (colAct->GetUniqueId() == x870_cameraManager->GetBallCamera()->GetCollisionActorId()) {
continue;
}
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
if (debugToolDrawCollisionActors->toBoolean()) {
colAct->DebugDraw();
}
Add debug rendering for CScriptPlatform (CVar: debugTool.drawPlatformCollision)
2021-01-17 03:33:03 +00:00
} else if (const TCastToPtr<CScriptPlatform> plat = ent) {
if (debugToolDrawPlatformCollision->toBoolean() && plat->GetActive()) {
plat->DebugDraw();
}
Add trigger visualization to inspecter
2021-05-27 08:30:40 +00:00
} else if (const TCastToPtr<CScriptTrigger> tr = ent) {
tr->DebugDraw();
Space pirate bug fixes
2018-12-15 06:29:41 +00:00
}
}
Add light visualization (requires custom models)
2020-12-13 07:39:55 +00:00
auto* gameArea = x850_world->GetArea(x850_world->GetCurrentAreaId());
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
if (gameArea != nullptr && debugToolDrawLighting->toBoolean()) {
Add light visualization (requires custom models)
2020-12-13 07:39:55 +00:00
gameArea->DebugDraw();
}
I feex
2020-10-18 23:57:41 +00:00
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
if (xf70_currentMaze && debugToolDrawMazePath->toBoolean()) {
xf70_currentMaze->DebugRender();
I feex
2020-10-18 23:57:41 +00:00
}
Space pirate bug fixes
2018-12-15 06:29:41 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
void CStateManager::RenderCamerasAndAreaLights() {
New code style refactor
2018-12-08 05:30:43 +00:00
x870_cameraManager->RenderCameras(*this);
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
for (const CCameraFilterPassPoly& filter : xb84_camFilterPasses) {
New code style refactor
2018-12-08 05:30:43 +00:00
filter.Draw();
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
void CStateManager::DrawE3DeathEffect() {
const CPlayer& player = *x84c_player;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (player.x9f4_deathTime <= 0.f) {
return;
}
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (player.x2f8_morphBallState != CPlayer::EPlayerMorphBallState::Unmorphed) {
const float blurAmt = zeus::clamp(0.f, (player.x9f4_deathTime - 1.f) / (6.f - 1.f), 1.f);
if (blurAmt > 0.f) {
CCameraBlurPass blur;
blur.SetBlur(EBlurType::HiBlur, 7.f * blurAmt, 0.f);
blur.Draw();
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float whiteAmt = zeus::clamp(0.f, 1.f - player.x9f4_deathTime / (0.05f * 6.f), 1.f);
zeus::CColor color = zeus::skWhite;
color.a() = whiteAmt;
m_deathWhiteout.draw(color);
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
void CStateManager::DrawAdditionalFilters() {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (xf0c_escapeTimer >= 1.f || xf0c_escapeTimer <= 0.f || x870_cameraManager->IsInCinematicCamera()) {
return;
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
zeus::CColor color = zeus::skWhite;
color.a() = 1.f - xf0c_escapeTimer;
m_escapeWhiteout.draw(color);
New code style refactor
2018-12-08 05:30:43 +00:00
}
zeus::CFrustum CStateManager::SetupDrawFrustum(const SViewport& vp) const {
zeus::CFrustum ret;
const CGameCamera* cam = x870_cameraManager->GetCurrentCamera(*this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CTransform camXf = x870_cameraManager->GetCurrentCameraTransform(*this);
const int vpWidth = static_cast<int>(xf2c_viewportScale.x() * vp.x8_width);
const int vpHeight = static_cast<int>(xf2c_viewportScale.y() * vp.xc_height);
const int vpLeft = static_cast<int>((vp.x8_width - vpWidth) / 2 + vp.x0_left);
const int vpTop = static_cast<int>((vp.xc_height - vpHeight) / 2 + vp.x4_top);
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->SetViewport(vpLeft, vpTop, vpWidth, vpHeight);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float fov = std::atan(std::tan(zeus::degToRad(cam->GetFov()) * 0.5f) * xf2c_viewportScale.y()) * 2.f;
const float width = xf2c_viewportScale.x() * vp.x8_width;
const float height = xf2c_viewportScale.y() * vp.xc_height;
New code style refactor
2018-12-08 05:30:43 +00:00
zeus::CProjection proj;
proj.setPersp(zeus::SProjPersp{fov, width / height, cam->GetNearClipDistance(), cam->GetFarClipDistance()});
ret.updatePlanes(camXf, proj);
return ret;
}
zeus::CFrustum CStateManager::SetupViewForDraw(const SViewport& vp) const {
const CGameCamera* cam = x870_cameraManager->GetCurrentCamera(*this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CTransform camXf = x870_cameraManager->GetCurrentCameraTransform(*this);
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->SetWorldViewpoint(camXf);
CBooModel::SetNewPlayerPositionAndTime(x84c_player->GetTranslation());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const int vpWidth = static_cast<int>(xf2c_viewportScale.x() * vp.x8_width);
const int vpHeight = static_cast<int>(xf2c_viewportScale.y() * vp.xc_height);
const int vpLeft = static_cast<int>((vp.x8_width - vpWidth) / 2 + vp.x0_left);
const int vpTop = static_cast<int>((vp.xc_height - vpHeight) / 2 + vp.x4_top);
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->SetViewport(vpLeft, vpTop, vpWidth, vpHeight);
CGraphics::SetDepthRange(DEPTH_WORLD, DEPTH_FAR);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float fov = std::atan(std::tan(zeus::degToRad(cam->GetFov()) * 0.5f) * xf2c_viewportScale.y()) * 2.f;
const float width = xf2c_viewportScale.x() * vp.x8_width;
const float height = xf2c_viewportScale.y() * vp.xc_height;
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->SetPerspective(zeus::radToDeg(fov), width, height, cam->GetNearClipDistance(), cam->GetFarClipDistance());
zeus::CFrustum frustum;
zeus::CProjection proj;
proj.setPersp(zeus::SProjPersp{fov, width / height, cam->GetNearClipDistance(), cam->GetFarClipDistance()});
frustum.updatePlanes(camXf, proj);
g_Renderer->SetClippingPlanes(frustum);
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
// g_Renderer->PrimColor(zeus::skWhite);
CGraphics::SetModelMatrix(zeus::CTransform());
New code style refactor
2018-12-08 05:30:43 +00:00
x87c_fluidPlaneManager->StartFrame(false);
g_Renderer->SetDebugOption(IRenderer::EDebugOption::One, 1);
return frustum;
Work on CStateManager rendering functions
2017-03-03 07:18:12 +00:00
}
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
zeus::CFrustum CStateManager::SetupViewForCubeFaceDraw(const zeus::CVector3f& pos, int face) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CTransform mainCamXf = x870_cameraManager->GetCurrentCameraTransform(*this);
const zeus::CTransform camXf = zeus::CTransform(mainCamXf.basis * CGraphics::skCubeBasisMats[face], pos);
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
g_Renderer->SetWorldViewpoint(camXf);
CBooModel::SetNewPlayerPositionAndTime(x84c_player->GetTranslation());
constexpr float width = CUBEMAP_RES;
g_Renderer->SetViewport(0, 0, width, width);
CGraphics::SetDepthRange(DEPTH_WORLD, DEPTH_FAR);
constexpr float fov = zeus::degToRad(90.f);
g_Renderer->SetPerspective(zeus::radToDeg(fov), width, width, 0.2f, 750.f);
zeus::CFrustum frustum;
zeus::CProjection proj;
proj.setPersp(zeus::SProjPersp{fov, 1.f, 0.2f, 750.f});
frustum.updatePlanes(camXf, proj);
g_Renderer->SetClippingPlanes(frustum);
CGraphics::SetModelMatrix(zeus::CTransform());
return frustum;
}
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
void CStateManager::ResetViewAfterDraw(const SViewport& backupViewport,
New code style refactor
2018-12-08 05:30:43 +00:00
const zeus::CTransform& backupViewMatrix) const {
g_Renderer->SetViewport(backupViewport.x0_left, backupViewport.x4_top, backupViewport.x8_width,
backupViewport.xc_height);
const CGameCamera* cam = x870_cameraManager->GetCurrentCamera(*this);
zeus::CFrustum frustum;
Bug fixes and CAutoMapper mouse events
2019-01-23 07:52:19 +00:00
frustum.updatePlanes(backupViewMatrix, zeus::SProjPersp(zeus::degToRad(cam->GetFov()), g_Viewport.aspect,
New code style refactor
2018-12-08 05:30:43 +00:00
cam->GetNearClipDistance(), cam->GetFarClipDistance()));
g_Renderer->SetClippingPlanes(frustum);
g_Renderer->SetPerspective(cam->GetFov(), g_Viewport.x8_width, g_Viewport.xc_height, cam->GetNearClipDistance(),
cam->GetFarClipDistance());
}
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
void CStateManager::DrawWorld() {
Graphics debug groups and bug fixes
2019-07-21 08:42:52 +00:00
SCOPED_GRAPHICS_DEBUG_GROUP("CStateManager::DrawWorld", zeus::skBlue);
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
const CTimeProvider timeProvider(xf14_curTimeMod900);
const SViewport backupViewport = g_Viewport;
New code style refactor
2018-12-08 05:30:43 +00:00
/* Area camera is in (not necessarily player) */
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
const TAreaId visAreaId = GetVisAreaId();
New code style refactor
2018-12-08 05:30:43 +00:00
x850_world->TouchSky();
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
DrawWorldCubeFaces();
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
const zeus::CFrustum frustum = SetupViewForDraw(g_Viewport);
const zeus::CTransform backupViewMatrix = CGraphics::g_ViewMatrix;
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
int areaCount = 0;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
std::array<const CGameArea*, 10> areaArr;
New code style refactor
2018-12-08 05:30:43 +00:00
for (const CGameArea& area : *x850_world) {
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (areaCount == 10) {
New code style refactor
2018-12-08 05:30:43 +00:00
break;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CGameArea::EOcclusionState occState = CGameArea::EOcclusionState::Occluded;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (area.IsPostConstructed()) {
New code style refactor
2018-12-08 05:30:43 +00:00
occState = area.GetOcclusionState();
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
if (occState == CGameArea::EOcclusionState::Visible) {
New code style refactor
2018-12-08 05:30:43 +00:00
areaArr[areaCount++] = &area;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
std::sort(areaArr.begin(), areaArr.begin() + areaCount, [visAreaId](const CGameArea* a, const CGameArea* b) {
if (a->x4_selfIdx == b->x4_selfIdx) {
return false;
}
if (visAreaId == a->x4_selfIdx) {
return false;
}
if (visAreaId == b->x4_selfIdx) {
return true;
}
return CGraphics::g_ViewPoint.dot(a->GetAABB().center()) > CGraphics::g_ViewPoint.dot(b->GetAABB().center());
});
New code style refactor
2018-12-08 05:30:43 +00:00
int pvsCount = 0;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
std::array<CPVSVisSet, 10> pvsArr;
for (auto area = areaArr.cbegin(); area != areaArr.cbegin() + areaCount; ++area) {
New code style refactor
2018-12-08 05:30:43 +00:00
const CGameArea* areaPtr = *area;
CPVSVisSet& pvsSet = pvsArr[pvsCount++];
pvsSet.Reset(EPVSVisSetState::OutOfBounds);
GetVisSetForArea(areaPtr->x4_selfIdx, visAreaId, pvsSet);
}
int mask;
int targetMask;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const auto visor = x8b8_playerState->GetActiveVisor(*this);
const bool thermal = visor == CPlayerState::EPlayerVisor::Thermal;
New code style refactor
2018-12-08 05:30:43 +00:00
if (thermal) {
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
xf34_thermalFlag = EThermalDrawFlag::Cold;
New code style refactor
2018-12-08 05:30:43 +00:00
mask = 0x34;
targetMask = 0;
} else {
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
xf34_thermalFlag = EThermalDrawFlag::Bypass;
New code style refactor
2018-12-08 05:30:43 +00:00
mask = 1 << (visor == CPlayerState::EPlayerVisor::XRay ? 3 : 1);
targetMask = 0;
}
g_Renderer->SetThermal(thermal, g_tweakGui->GetThermalVisorLevel(), g_tweakGui->GetThermalVisorColor());
g_Renderer->SetThermalColdScale(xf28_thermColdScale2 + xf24_thermColdScale1);
for (int i = areaCount - 1; i >= 0; --i) {
Using optick, linked from boo
2021-04-03 16:48:39 +00:00
OPTICK_EVENT("CStateManager::DrawWorld DrawArea");
New code style refactor
2018-12-08 05:30:43 +00:00
const CGameArea& area = *areaArr[i];
SetupFogForArea(area);
g_Renderer->EnablePVS(pvsArr[i], area.x4_selfIdx);
g_Renderer->SetWorldLightFadeLevel(area.GetPostConstructed()->x1128_worldLightingLevel);
g_Renderer->UpdateAreaUniforms(area.x4_selfIdx);
g_Renderer->DrawUnsortedGeometry(area.x4_selfIdx, mask, targetMask);
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!SetupFogForDraw()) {
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
g_Renderer->SetWorldFog(ERglFogMode::None, 0.f, 1.f, zeus::skBlack);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Tons of DrawWorld-related implementations
2017-03-04 04:31:08 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
x850_world->DrawSky(zeus::CTransform::Translate(CGraphics::g_ViewPoint));
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (areaCount != 0) {
New code style refactor
2018-12-08 05:30:43 +00:00
SetupFogForArea(*areaArr[areaCount - 1]);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
Runtime: Resolve -Wrange-loop-analysis warnings (part 2)
2020-09-18 21:04:50 +00:00
for (const auto& id : x86c_stateManagerContainer->xf370_) {
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
if (auto* ent = static_cast<CActor*>(ObjectById(id))) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!thermal || (ent->xe6_27_thermalVisorFlags & 1) != 0) {
New code style refactor
2018-12-08 05:30:43 +00:00
ent->Render(*this);
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
}
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
bool morphingPlayerVisible = false;
int thermalActorCount = 0;
De-hardcode max entity count
2021-06-06 23:53:41 +00:00
std::array<CActor*, kMaxEntities> thermalActorArr;
New code style refactor
2018-12-08 05:30:43 +00:00
for (int i = 0; i < areaCount; ++i) {
const CGameArea& area = *areaArr[i];
CPVSVisSet& pvs = pvsArr[i];
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const bool isVisArea = area.x4_selfIdx == visAreaId;
New code style refactor
2018-12-08 05:30:43 +00:00
SetupFogForArea(area);
g_Renderer->SetWorldLightFadeLevel(area.GetPostConstructed()->x1128_worldLightingLevel);
for (CEntity* ent : *area.GetAreaObjects()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CActor> actor = ent) {
if (!actor->IsDrawEnabled()) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
const TUniqueId actorId = actor->GetUniqueId();
if (!thermal && area.LookupPVSUniqueID(actorId) == actorId) {
if (pvs.GetVisible(area.LookupPVSID(actorId)) == EPVSVisSetState::EndOfTree) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (x84c_player.get() == actor.GetPtr()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (thermal) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
switch (x84c_player->GetMorphballTransitionState()) {
case CPlayer::EPlayerMorphBallState::Unmorphed:
case CPlayer::EPlayerMorphBallState::Morphed:
x84c_player->AddToRenderer(frustum, *this);
continue;
default:
morphingPlayerVisible = true;
continue;
}
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!thermal || (actor->xe6_27_thermalVisorFlags & 1) != 0) {
New code style refactor
2018-12-08 05:30:43 +00:00
actor->AddToRenderer(frustum, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
if (thermal && (actor->xe6_27_thermalVisorFlags & 2) != 0) {
New code style refactor
2018-12-08 05:30:43 +00:00
thermalActorArr[thermalActorCount++] = actor.GetPtr();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Tons of DrawWorld-related implementations
2017-03-04 04:31:08 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (isVisArea && !thermal) {
CDecalManager::AddToRenderer(frustum, *this);
x884_actorModelParticles->AddStragglersToRenderer(*this);
Tons of DrawWorld-related implementations
2017-03-04 04:31:08 +00:00
}
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
++x8dc_objectDrawToken;
Tons of DrawWorld-related implementations
2017-03-04 04:31:08 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
x84c_player->GetMorphBall()->DrawBallShadow(*this);
Tons of DrawWorld-related implementations
2017-03-04 04:31:08 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (xf7c_projectedShadow != nullptr) {
New code style refactor
2018-12-08 05:30:43 +00:00
xf7c_projectedShadow->Render(*this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Tons of DrawWorld-related implementations
2017-03-04 04:31:08 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->EnablePVS(pvs, area.x4_selfIdx);
g_Renderer->DrawSortedGeometry(area.x4_selfIdx, mask, targetMask);
}
Tons of DrawWorld-related implementations
2017-03-04 04:31:08 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
x880_envFxManager->Render(*this);
Tons of DrawWorld-related implementations
2017-03-04 04:31:08 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (morphingPlayerVisible) {
New code style refactor
2018-12-08 05:30:43 +00:00
x84c_player->Render(*this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->PostRenderFogs();
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (thermal) {
if (x86c_stateManagerContainer->xf39c_renderLast.size()) {
CGraphics::SetDepthRange(DEPTH_SCREEN_ACTORS, DEPTH_GUN);
Runtime: Resolve -Wrange-loop-analysis warnings (part 2)
2020-09-18 21:04:50 +00:00
for (const auto& id : x86c_stateManagerContainer->xf39c_renderLast) {
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
if (auto* actor = static_cast<CActor*>(ObjectById(id))) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if ((actor->xe6_27_thermalVisorFlags & 1) != 0) {
New code style refactor
2018-12-08 05:30:43 +00:00
actor->Render(*this);
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
}
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
CGraphics::SetDepthRange(DEPTH_WORLD, DEPTH_FAR);
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->DoThermalBlendCold();
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
xf34_thermalFlag = EThermalDrawFlag::Hot;
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
Runtime: Resolve -Wrange-loop-analysis warnings (part 2)
2020-09-18 21:04:50 +00:00
for (const auto& id : x86c_stateManagerContainer->xf370_) {
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
if (auto* actor = static_cast<CActor*>(ObjectById(id))) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if ((actor->xe6_27_thermalVisorFlags & 2) != 0) {
New code style refactor
2018-12-08 05:30:43 +00:00
actor->Render(*this);
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
}
}
}
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
for (int i = areaCount - 1; i >= 0; --i) {
const CGameArea& area = *areaArr[i];
CPVSVisSet& pvs = pvsArr[i];
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->EnablePVS(pvs, area.x4_selfIdx);
g_Renderer->DrawUnsortedGeometry(area.x4_selfIdx, mask, 0x20);
g_Renderer->DrawAreaGeometry(area.x4_selfIdx, mask, 0x10);
}
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
++x8dc_objectDrawToken;
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
for (int i = 0; i < areaCount; ++i) {
const CGameArea& area = *areaArr[i];
CPVSVisSet& pvs = pvsArr[i];
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
for (int j = 0; j < thermalActorCount; ++j) {
CActor* actor = thermalActorArr[j];
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (actor->GetAreaIdAlways() != area.x4_selfIdx) {
if (actor->GetAreaIdAlways() != kInvalidAreaId || area.x4_selfIdx != visAreaId) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
actor->AddToRenderer(frustum, *this);
}
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (areaCount - 1 == i) {
x884_actorModelParticles->AddStragglersToRenderer(*this);
CDecalManager::AddToRenderer(frustum, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x84c_player) {
New code style refactor
2018-12-08 05:30:43 +00:00
x84c_player->AddToRenderer(frustum, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
++x8dc_objectDrawToken;
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->EnablePVS(pvs, area.x4_selfIdx);
g_Renderer->DrawSortedGeometry(area.x4_selfIdx, mask, 0x10);
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->PostRenderFogs();
}
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
x87c_fluidPlaneManager->EndFrame();
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
g_Renderer->SetWorldFog(ERglFogMode::None, 0.f, 1.f, zeus::skBlack);
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
#if 0
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (false) {
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
CacheReflection();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
DrawWorld implementation complete
2017-03-06 06:33:51 +00:00
#endif
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x84c_player) {
New code style refactor
2018-12-08 05:30:43 +00:00
x84c_player->RenderGun(*this, x870_cameraManager->GetGlobalCameraTranslation(*this));
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (x86c_stateManagerContainer->xf39c_renderLast.size()) {
CGraphics::SetDepthRange(DEPTH_SCREEN_ACTORS, DEPTH_GUN);
Runtime: Resolve -Wrange-loop-analysis warnings (part 2)
2020-09-18 21:04:50 +00:00
for (const auto& id : x86c_stateManagerContainer->xf39c_renderLast) {
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
if (auto* actor = static_cast<CActor*>(ObjectById(id))) {
if (!thermal || actor->xe6_27_thermalVisorFlags & 0x2) {
New code style refactor
2018-12-08 05:30:43 +00:00
actor->Render(*this);
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
}
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
CGraphics::SetDepthRange(DEPTH_WORLD, DEPTH_FAR);
}
if (thermal) {
g_Renderer->DoThermalBlendHot();
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
g_Renderer->SetThermal(false, 0.f, zeus::skBlack);
CStateManager: Remove instances of const_cast where applicable Eliminates trivial casts that don't require much modifications to other existing interfaces.
2020-03-17 00:07:53 +00:00
xf34_thermalFlag = EThermalDrawFlag::Bypass;
New code style refactor
2018-12-08 05:30:43 +00:00
}
DrawDebugStuff();
RenderCamerasAndAreaLights();
ResetViewAfterDraw(backupViewport, backupViewMatrix);
DrawE3DeathEffect();
DrawAdditionalFilters();
}
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
void CStateManager::DrawActorCubeFaces(CActor& actor, int& cubeInst) const {
if (!actor.m_reflectionCube ||
Initial CMetroidBeta imps
2019-08-11 15:14:52 +00:00
(!TCastToPtr<CPlayer>(actor) && (!actor.GetActive() || !actor.IsDrawEnabled() || actor.xe4_30_outOfFrustum)))
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const TAreaId visAreaId = actor.GetAreaIdAlways();
const SViewport backupVp = g_Viewport;
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
int areaCount = 0;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
std::array<const CGameArea*, 10> areaArr;
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
for (const CGameArea& area : *x850_world) {
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (areaCount == 10) {
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
break;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
auto occState = CGameArea::EOcclusionState::Occluded;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (area.IsPostConstructed()) {
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
occState = area.GetOcclusionState();
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
if (occState == CGameArea::EOcclusionState::Visible) {
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
areaArr[areaCount++] = &area;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
}
for (int f = 0; f < 6; ++f) {
Update fmtlib
2020-04-11 22:51:39 +00:00
SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(FMT_STRING("CStateManager::DrawActorCubeFaces [{}] {} {} {}"), f,
Initial CMetroidBeta imps
2019-08-11 15:14:52 +00:00
actor.GetUniqueId(), actor.GetEditorId(), actor.GetName())
.c_str(),
zeus::skOrange);
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
CGraphics::g_BooMainCommandQueue->setRenderTarget(actor.m_reflectionCube, f);
SetupViewForCubeFaceDraw(actor.GetRenderBounds().center(), f);
CGraphics::g_BooMainCommandQueue->clearTarget();
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
std::sort(areaArr.begin(), areaArr.begin() + areaCount, [visAreaId](const CGameArea* a, const CGameArea* b) {
if (a->x4_selfIdx == b->x4_selfIdx) {
return false;
}
if (visAreaId == a->x4_selfIdx) {
return false;
}
if (visAreaId == b->x4_selfIdx) {
return true;
}
return CGraphics::g_ViewPoint.dot(a->GetAABB().center()) > CGraphics::g_ViewPoint.dot(b->GetAABB().center());
});
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
int pvsCount = 0;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
std::array<CPVSVisSet, 10> pvsArr;
for (auto area = areaArr.cbegin(); area != areaArr.cbegin() + areaCount; ++area) {
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
const CGameArea* areaPtr = *area;
CPVSVisSet& pvsSet = pvsArr[pvsCount++];
pvsSet.Reset(EPVSVisSetState::OutOfBounds);
GetVisSetForArea(areaPtr->x4_selfIdx, visAreaId, pvsSet);
}
for (int i = areaCount - 1; i >= 0; --i) {
const CGameArea& area = *areaArr[i];
SetupFogForArea(area);
g_Renderer->EnablePVS(pvsArr[i], area.x4_selfIdx);
g_Renderer->SetWorldLightFadeLevel(area.GetPostConstructed()->x1128_worldLightingLevel);
CPuddleToadGamma and animation system fixes
2019-06-21 06:02:56 +00:00
g_Renderer->UpdateAreaUniforms(area.x4_selfIdx, EWorldShadowMode::None, true, cubeInst * 6 + f);
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
g_Renderer->DrawUnsortedGeometry(area.x4_selfIdx, 0x2, 0x0);
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!SetupFogForDraw()) {
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
g_Renderer->SetWorldFog(ERglFogMode::None, 0.f, 1.f, zeus::skBlack);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
x850_world->DrawSky(zeus::CTransform::Translate(CGraphics::g_ViewPoint));
for (int i = 0; i < areaCount; ++i) {
const CGameArea& area = *areaArr[i];
CPVSVisSet& pvs = pvsArr[i];
SetupFogForArea(area);
g_Renderer->SetWorldLightFadeLevel(area.GetPostConstructed()->x1128_worldLightingLevel);
g_Renderer->EnablePVS(pvs, area.x4_selfIdx);
g_Renderer->DrawSortedGeometry(area.x4_selfIdx, 0x2, 0x0);
}
}
CGraphics::g_BooMainCommandQueue->generateMipmaps(actor.m_reflectionCube);
CBooRenderer::BindMainDrawTarget();
g_Renderer->SetViewport(backupVp.x0_left, backupVp.x4_top, backupVp.x8_width, backupVp.xc_height);
++cubeInst;
}
void CStateManager::DrawWorldCubeFaces() const {
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
size_t areaCount = 0;
std::array<const CGameArea*, 10> areaArr;
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
for (const CGameArea& area : *x850_world) {
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (areaCount == areaArr.size()) {
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
break;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
auto occState = CGameArea::EOcclusionState::Occluded;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (area.IsPostConstructed()) {
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
occState = area.GetOcclusionState();
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
if (occState == CGameArea::EOcclusionState::Visible) {
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
areaArr[areaCount++] = &area;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
}
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
for (size_t ai = 0; ai < areaCount; ++ai) {
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
const CGameArea& area = *areaArr[ai];
int cubeInst = 0;
for (CEntity* ent : *area.GetAreaObjects()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CActor> actor = ent) {
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
DrawActorCubeFaces(*actor, cubeInst);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Support for rendering dynamic cubemaps
2019-06-01 03:41:01 +00:00
}
}
}
More ChozoGhost imps
2020-03-05 01:32:49 +00:00
void CStateManager::SetupFogForArea3XRange(TAreaId area) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (area == kInvalidAreaId) {
More ChozoGhost imps
2020-03-05 01:32:49 +00:00
area = x8cc_nextAreaId;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
More ChozoGhost imps
2020-03-05 01:32:49 +00:00
const CGameArea* areaObj = x850_world->GetAreaAlways(area);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (areaObj->IsPostConstructed()) {
More ChozoGhost imps
2020-03-05 01:32:49 +00:00
SetupFogForArea3XRange(*areaObj);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
More ChozoGhost imps
2020-03-05 01:32:49 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::SetupFogForArea(TAreaId area) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (area == kInvalidAreaId) {
New code style refactor
2018-12-08 05:30:43 +00:00
area = x8cc_nextAreaId;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
const CGameArea* areaObj = x850_world->GetAreaAlways(area);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (areaObj->IsPostConstructed()) {
New code style refactor
2018-12-08 05:30:43 +00:00
SetupFogForArea(*areaObj);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Finish CFlickerBat imps
2018-12-17 05:40:27 +00:00
void CStateManager::SetupFogForAreaNonCurrent(TAreaId area) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (area == kInvalidAreaId) {
Finish CFlickerBat imps
2018-12-17 05:40:27 +00:00
area = x8cc_nextAreaId;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Finish CFlickerBat imps
2018-12-17 05:40:27 +00:00
const CGameArea* areaObj = x850_world->GetAreaAlways(area);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (areaObj->IsPostConstructed()) {
Finish CFlickerBat imps
2018-12-17 05:40:27 +00:00
SetupFogForAreaNonCurrent(*areaObj);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Finish CFlickerBat imps
2018-12-17 05:40:27 +00:00
}
More ChozoGhost imps
2020-03-05 01:32:49 +00:00
void CStateManager::SetupFogForArea3XRange(const CGameArea& area) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x8b8_playerState->GetActiveVisor(*this) != CPlayerState::EPlayerVisor::XRay) {
return;
More ChozoGhost imps
2020-03-05 01:32:49 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float fogDist = area.GetXRayFogDistance();
const float farz = (g_tweakGui->GetXRayFogNearZ() * (1.f - fogDist) + g_tweakGui->GetXRayFogFarZ() * fogDist) * 3.f;
g_Renderer->SetWorldFog(ERglFogMode(g_tweakGui->GetXRayFogMode()), g_tweakGui->GetXRayFogNearZ(), farz,
g_tweakGui->GetXRayFogColor());
More ChozoGhost imps
2020-03-05 01:32:49 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::SetupFogForArea(const CGameArea& area) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (SetupFogForDraw()) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (x8b8_playerState->GetActiveVisor(*this) == CPlayerState::EPlayerVisor::XRay) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float fogDist = area.GetXRayFogDistance();
const float farz = g_tweakGui->GetXRayFogNearZ() * (1.f - fogDist) + g_tweakGui->GetXRayFogFarZ() * fogDist;
New code style refactor
2018-12-08 05:30:43 +00:00
g_Renderer->SetWorldFog(ERglFogMode(g_tweakGui->GetXRayFogMode()), g_tweakGui->GetXRayFogNearZ(), farz,
g_tweakGui->GetXRayFogColor());
} else {
area.GetAreaFog()->SetCurrent();
}
}
Finish CFlickerBat imps
2018-12-17 05:40:27 +00:00
void CStateManager::SetupFogForAreaNonCurrent(const CGameArea& area) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (SetupFogForDraw()) {
Finish CFlickerBat imps
2018-12-17 05:40:27 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Finish CFlickerBat imps
2018-12-17 05:40:27 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x8b8_playerState->GetActiveVisor(*this) != CPlayerState::EPlayerVisor::XRay) {
return;
Finish CFlickerBat imps
2018-12-17 05:40:27 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float fogDist = area.GetXRayFogDistance();
const float farz = g_tweakGui->GetXRayFogNearZ() * (1.f - fogDist) + g_tweakGui->GetXRayFogFarZ() * fogDist;
g_Renderer->SetWorldFog(ERglFogMode(g_tweakGui->GetXRayFogMode()), g_tweakGui->GetXRayFogNearZ(), farz,
g_tweakGui->GetXRayFogColor());
Finish CFlickerBat imps
2018-12-17 05:40:27 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
bool CStateManager::SetupFogForDraw() const {
switch (x8b8_playerState->GetActiveVisor(*this)) {
case CPlayerState::EPlayerVisor::Thermal:
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
g_Renderer->SetWorldFog(ERglFogMode::None, 0.f, 1.f, zeus::skBlack);
New code style refactor
2018-12-08 05:30:43 +00:00
return true;
case CPlayerState::EPlayerVisor::XRay:
default:
return false;
case CPlayerState::EPlayerVisor::Combat:
case CPlayerState::EPlayerVisor::Scan:
auto& fog = x870_cameraManager->Fog();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (fog.IsFogDisabled()) {
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
fog.SetCurrent();
return true;
}
}
void CStateManager::PreRender() {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!xf94_24_readyToRender) {
return;
}
SCOPED_GRAPHICS_DEBUG_GROUP("CStateManager::PreRender", zeus::skBlue);
const zeus::CFrustum frustum = SetupDrawFrustum(g_Viewport);
x86c_stateManagerContainer->xf370_.clear();
x86c_stateManagerContainer->xf39c_renderLast.clear();
xf7c_projectedShadow = nullptr;
x850_world->PreRender();
BuildDynamicLightListForWorld();
for (const CGameArea& area : *x850_world) {
auto occState = CGameArea::EOcclusionState::Occluded;
if (area.IsPostConstructed()) {
occState = area.GetOcclusionState();
}
if (occState == CGameArea::EOcclusionState::Visible) {
for (CEntity* ent : *area.GetPostConstructed()->x10c0_areaObjs) {
if (const TCastToPtr<CActor> act = ent) {
if (act->IsDrawEnabled()) {
act->CalculateRenderBounds();
act->PreRender(*this, frustum);
New code style refactor
2018-12-08 05:30:43 +00:00
}
Work on CStateManager rendering functions
2017-03-03 07:18:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
}
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
CacheReflection();
g_Renderer->PrepareDynamicLights(x8e0_dynamicLights);
New code style refactor
2018-12-08 05:30:43 +00:00
}
void CStateManager::GetCharacterRenderMaskAndTarget(bool thawed, int& mask, int& target) const {
switch (x8b8_playerState->GetActiveVisor(*this)) {
case CPlayerState::EPlayerVisor::Combat:
case CPlayerState::EPlayerVisor::Scan:
mask = 0x1000;
target = 0x0;
break;
case CPlayerState::EPlayerVisor::XRay:
mask = 0x800;
target = 0x0;
break;
case CPlayerState::EPlayerVisor::Thermal:
if (thawed) {
if (xf34_thermalFlag == EThermalDrawFlag::Hot) {
mask = 0x600;
Various bug fixes
2018-11-08 00:53:38 +00:00
target = 0x0;
New code style refactor
2018-12-08 05:30:43 +00:00
} else {
mask = 0x600;
target = 0x200;
}
} else {
if (xf34_thermalFlag == EThermalDrawFlag::Cold) {
mask = 0x500;
Various bug fixes
2018-11-08 00:53:38 +00:00
target = 0x0;
New code style refactor
2018-12-08 05:30:43 +00:00
} else {
mask = 0x500;
target = 0x100;
}
Various bug fixes
2018-11-08 00:53:38 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
break;
default:
mask = 0x0;
target = 0x0;
break;
}
Various bug fixes
2018-11-08 00:53:38 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
bool CStateManager::GetVisSetForArea(TAreaId a, TAreaId b, CPVSVisSet& setOut) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (b == kInvalidAreaId) {
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
PVS implementations
2017-02-19 09:27:01 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f viewPoint = CGraphics::g_ViewMatrix.origin;
New code style refactor
2018-12-08 05:30:43 +00:00
zeus::CVector3f closestDockPoint = viewPoint;
bool hasClosestDock = false;
if (a != b) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const CGameArea& area = *x850_world->GetGameAreas()[b];
New code style refactor
2018-12-08 05:30:43 +00:00
if (area.IsPostConstructed()) {
for (const CGameArea::Dock& dock : area.GetDocks()) {
for (int i = 0; i < dock.GetDockRefs().size(); ++i) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const TAreaId connArea = dock.GetConnectedAreaId(i);
New code style refactor
2018-12-08 05:30:43 +00:00
if (connArea == a) {
const auto& verts = dock.GetPlaneVertices();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f dockCenter = (verts[0] + verts[1] + verts[2] + verts[3]) * 0.25f;
if (hasClosestDock) {
if ((dockCenter - viewPoint).magSquared() >= (closestDockPoint - viewPoint).magSquared()) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
closestDockPoint = dockCenter;
hasClosestDock = true;
}
PVS implementations
2017-02-19 09:27:01 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
PVS implementations
2017-02-19 09:27:01 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
} else {
hasClosestDock = true;
}
PVS implementations
2017-02-19 09:27:01 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (hasClosestDock) {
if (CPVSAreaSet* pvs = x850_world->GetGameAreas()[a]->GetPostConstructed()->xa0_pvs.get()) {
const CPVSVisOctree& octree = pvs->GetVisOctree();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f closestDockLocal = x850_world->GetGameAreas()[a]->GetInverseTransform() * closestDockPoint;
New code style refactor
2018-12-08 05:30:43 +00:00
CPVSVisSet set;
set.SetTestPoint(octree, closestDockLocal);
if (set.GetState() == EPVSVisSetState::NodeFound) {
setOut = set;
return true;
}
PVS implementations
2017-02-19 09:27:01 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
PVS implementations
2017-02-19 09:27:01 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
PVS implementations
2017-02-19 09:27:01 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
void CStateManager::RecursiveDrawTree(TUniqueId node) {
if (const TCastToPtr<CActor> actor = ObjectById(node)) {
New code style refactor
2018-12-08 05:30:43 +00:00
if (x8dc_objectDrawToken != actor->xc8_drawnToken) {
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
if (actor->xc6_nextDrawNode != kInvalidUniqueId) {
New code style refactor
2018-12-08 05:30:43 +00:00
RecursiveDrawTree(actor->xc6_nextDrawNode);
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
}
if (x8dc_objectDrawToken == actor->xcc_addedToken) {
New code style refactor
2018-12-08 05:30:43 +00:00
actor->Render(*this);
CActor: Make Render() a non-const function A few implementations of Render() contain const-casts nested within its their call hierarchy to get around the fact that this function is marked const. We can just make the member function non-const to allow removal of these casts in follow up changes.
2020-04-09 17:28:20 +00:00
}
actor->xc8_drawnToken = x8dc_objectDrawToken;
Tons of DrawWorld-related implementations
2017-03-04 04:31:08 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Tons of DrawWorld-related implementations
2017-03-04 04:31:08 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::SendScriptMsg(CEntity* dest, TUniqueId src, EScriptObjectMessage msg) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (dest == nullptr || dest->x30_26_scriptingBlocked) {
return;
}
if (sm_logScripting != nullptr && sm_logScripting->toBoolean()) {
LogModule.report(logvisor::Info, FMT_STRING("Sending '{}' to '{}' id= {}"), ScriptObjectMessageToStr(msg),
dest->GetName(), dest->GetUniqueId());
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
dest->AcceptScriptMsg(msg, src, *this);
Additional state imps
2016-07-24 04:46:32 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::SendScriptMsg(TUniqueId dest, TUniqueId src, EScriptObjectMessage msg) {
CEntity* ent = ObjectById(dest);
SendScriptMsg(ent, src, msg);
Work on CStateManager::InitializeState flow
2016-08-14 03:00:58 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::SendScriptMsgAlways(TUniqueId dest, TUniqueId src, EScriptObjectMessage msg) {
CEntity* dst = ObjectById(dest);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (dst == nullptr) {
return;
}
if (sm_logScripting != nullptr && sm_logScripting->toBoolean()) {
LogModule.report(logvisor::Info, FMT_STRING("Sending '{}' to '{}' id= {}"), ScriptObjectMessageToStr(msg),
dst->GetName(), dst->GetUniqueId());
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
dst->AcceptScriptMsg(msg, src, *this);
Minor CStateManager fixes, CScriptColorModulate imps
2016-08-18 18:34:06 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::SendScriptMsg(TUniqueId src, TEditorId dest, EScriptObjectMessage msg, EScriptObjectState state) {
More ChozoGhost imps
2020-03-05 01:32:49 +00:00
// CEntity* ent = GetObjectById(src);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const auto search = GetIdListForScript(dest);
if (search.first == x890_scriptIdMap.cend()) {
return;
}
for (auto it = search.first; it != search.second; ++it) {
const TUniqueId id = it->second;
CEntity* dobj = GetAllObjectList().GetObjectById(id);
SendScriptMsg(dobj, src, msg);
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::FreeScriptObjects(TAreaId aid) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
for (const auto& p : x890_scriptIdMap) {
if (p.first.AreaNum() == aid) {
New code style refactor
2018-12-08 05:30:43 +00:00
FreeScriptObject(p.second);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
Bug fixes and more CStateManager imps
2017-02-14 04:27:20 +00:00
Add incoming connections
2021-05-27 06:31:38 +00:00
std::set<TEditorId> freedObjects;
New code style refactor
2018-12-08 05:30:43 +00:00
for (auto it = x8a4_loadedScriptObjects.begin(); it != x8a4_loadedScriptObjects.end();) {
if (it->first.AreaNum() == aid) {
Add incoming connections
2021-05-27 06:31:38 +00:00
freedObjects.emplace(it->first);
New code style refactor
2018-12-08 05:30:43 +00:00
it = x8a4_loadedScriptObjects.erase(it);
continue;
Bug fixes and more CStateManager imps
2017-02-14 04:27:20 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
++it;
}
Bug fixes and more CStateManager imps
2017-02-14 04:27:20 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const CGameArea* area = x850_world->GetGameAreas()[aid].get();
New code style refactor
2018-12-08 05:30:43 +00:00
if (area->IsPostConstructed()) {
const CGameArea::CPostConstructed* pc = area->GetPostConstructed();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
for (CEntity* ent : *pc->x10c0_areaObjs) {
if (ent != nullptr && !ent->IsInUse()) {
New code style refactor
2018-12-08 05:30:43 +00:00
FreeScriptObject(ent->GetUniqueId());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Add incoming connections
2021-05-27 06:31:38 +00:00
for (const auto& id : freedObjects) {
m_incomingConnections.erase(id);
}
Bug fixes and more CStateManager imps
2017-02-14 04:27:20 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::FreeScriptObject(TUniqueId id) {
CEntity* ent = ObjectById(id);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ent == nullptr || ent->IsInGraveyard()) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Bug fixes and more CStateManager imps
2017-02-14 04:27:20 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
ent->SetIsInGraveyard(true);
x854_objectGraveyard.push_back(id);
ent->AcceptScriptMsg(EScriptObjectMessage::Deleted, kInvalidUniqueId, *this);
ent->SetIsScriptingBlocked(true);
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CActor> act = ent) {
New code style refactor
2018-12-08 05:30:43 +00:00
x874_sortedListManager->Remove(act.GetPtr());
act->SetUseInSortedLists(false);
}
Various bug fixes
2017-11-26 03:04:25 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (sm_logScripting && sm_logScripting->toBoolean()) {
Update fmtlib
2020-04-11 22:51:39 +00:00
LogModule.report(logvisor::Info, FMT_STRING("Removed '{}'"), ent->GetName());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Bug fixes and more CStateManager imps
2017-02-14 04:27:20 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
std::pair<const SScriptObjectStream*, TEditorId> CStateManager::GetBuildForScript(TEditorId id) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const auto search = x8a4_loadedScriptObjects.find(id);
if (search == x8a4_loadedScriptObjects.cend()) {
New code style refactor
2018-12-08 05:30:43 +00:00
return {nullptr, kInvalidEditorId};
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
return {&search->second, search->first};
Bug fixes and more CStateManager imps
2017-02-14 04:27:20 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
TEditorId CStateManager::GetEditorIdForUniqueId(TUniqueId id) const {
const CEntity* ent = GetObjectById(id);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ent != nullptr) {
New code style refactor
2018-12-08 05:30:43 +00:00
return ent->GetEditorId();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
return kInvalidEditorId;
Bug fixes and more CStateManager imps
2017-02-14 04:27:20 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
TUniqueId CStateManager::GetIdForScript(TEditorId id) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const auto search = x890_scriptIdMap.find(id);
if (search == x890_scriptIdMap.cend()) {
New code style refactor
2018-12-08 05:30:43 +00:00
return kInvalidUniqueId;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
return search->second;
Bug fixes and more CStateManager imps
2017-02-14 04:27:20 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CScriptTrigger work
2017-01-15 03:59:37 +00:00
std::pair<std::multimap<TEditorId, TUniqueId>::const_iterator, std::multimap<TEditorId, TUniqueId>::const_iterator>
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager::GetIdListForScript(TEditorId id) const {
auto ret = x890_scriptIdMap.equal_range(id);
if (ret.first != x890_scriptIdMap.cend() && ret.first->first != id) {
ret.first = x890_scriptIdMap.cend();
ret.second = x890_scriptIdMap.cend();
}
return ret;
}
void CStateManager::LoadScriptObjects(TAreaId aid, CInputStream& in, std::vector<TEditorId>& idsOut) {
in.readUByte();
CStateManager: Silence sign conversion and truncation warnings in LoadScriptObjects()
2020-05-09 21:16:51 +00:00
const u32 objCount = in.readUint32Big();
New code style refactor
2018-12-08 05:30:43 +00:00
idsOut.reserve(idsOut.size() + objCount);
CStateManager: Silence sign conversion and truncation warnings in LoadScriptObjects()
2020-05-09 21:16:51 +00:00
for (u32 i = 0; i < objCount; ++i) {
const auto objType = static_cast<EScriptObjectType>(in.readUByte());
const u32 objSize = in.readUint32Big();
const u32 pos = static_cast<u32>(in.position());
const auto id = LoadScriptObject(aid, objType, objSize, in);
if (id.first == kInvalidEditorId) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Silence sign conversion and truncation warnings in LoadScriptObjects()
2020-05-09 21:16:51 +00:00
}
const auto build = GetBuildForScript(id.first);
if (build.first) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Silence sign conversion and truncation warnings in LoadScriptObjects()
2020-05-09 21:16:51 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
x8a4_loadedScriptObjects[id.first] = SScriptObjectStream{objType, pos, objSize};
idsOut.push_back(id.first);
}
Add incoming connections
2021-05-27 06:31:38 +00:00
for (const auto& pair : m_incomingConnections) {
if (auto* ent = ObjectById(GetIdForScript(pair.first))) {
ent->SetIncomingConnectionList(&pair.second);
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
std::pair<TEditorId, TUniqueId> CStateManager::LoadScriptObject(TAreaId aid, EScriptObjectType type, u32 length,
CInputStream& in) {
Using optick, linked from boo
2021-04-03 16:48:39 +00:00
OPTICK_EVENT();
CEntityInfo: std::move vector in constructor Allows calling code to potentially avoid copies altogether by moving into the constructor.
2019-09-15 20:04:13 +00:00
const TEditorId id = in.readUint32Big();
const u32 connCount = in.readUint32Big();
New code style refactor
2018-12-08 05:30:43 +00:00
length -= 8;
std::vector<SConnection> conns;
conns.reserve(connCount);
CEntityInfo: std::move vector in constructor Allows calling code to potentially avoid copies altogether by moving into the constructor.
2019-09-15 20:04:13 +00:00
for (u32 i = 0; i < connCount; ++i) {
const auto state = EScriptObjectState(in.readUint32Big());
const auto msg = EScriptObjectMessage(in.readUint32Big());
const TEditorId target = in.readUint32Big();
Add incoming connections
2021-05-27 06:31:38 +00:00
// Metaforce Addition
if (m_incomingConnections.find(target) == m_incomingConnections.cend()) {
m_incomingConnections.emplace(target, std::set<SConnection>());
}
SConnection inConn{state, msg, id};
m_incomingConnections[target].emplace(inConn);
// End Metaforce Addition
New code style refactor
2018-12-08 05:30:43 +00:00
length -= 12;
conns.push_back(SConnection{state, msg, target});
}
CEntityInfo: std::move vector in constructor Allows calling code to potentially avoid copies altogether by moving into the constructor.
2019-09-15 20:04:13 +00:00
const u32 propCount = in.readUint32Big();
New code style refactor
2018-12-08 05:30:43 +00:00
length -= 4;
CEntityInfo: std::move vector in constructor Allows calling code to potentially avoid copies altogether by moving into the constructor.
2019-09-15 20:04:13 +00:00
const auto startPos = in.position();
New code style refactor
2018-12-08 05:30:43 +00:00
bool error = false;
FScriptLoader loader = {};
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (type < EScriptObjectType::ScriptObjectTypeMAX && type >= EScriptObjectType::Actor) {
loader = x90c_loaderFuncs[size_t(type)];
}
New code style refactor
2018-12-08 05:30:43 +00:00
CEntity* ent = nullptr;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (loader != nullptr) {
CStateManager: Revert debug commit
2020-04-20 01:20:25 +00:00
const CEntityInfo info(aid, std::move(conns), id);
New code style refactor
2018-12-08 05:30:43 +00:00
ent = loader(*this, in, propCount, info);
} else {
error = true;
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ent != nullptr) {
New code style refactor
2018-12-08 05:30:43 +00:00
AddObject(ent);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
} else {
New code style refactor
2018-12-08 05:30:43 +00:00
error = true;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
const u32 readAmt = in.position() - startPos;
if (readAmt > length) {
LogModule.report(logvisor::Fatal, FMT_STRING("Script object overread while reading {}"),
ScriptObjectTypeToStr(type));
}
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const u32 leftover = length - readAmt;
for (u32 i = 0; i < leftover; ++i) {
New code style refactor
2018-12-08 05:30:43 +00:00
in.readByte();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (error || ent == nullptr) {
MSVC & zeus fixes; update hecl-gui
2020-04-20 01:09:30 +00:00
in.seek(startPos, athena::SeekOrigin::Begin);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const std::string name = HashInstanceName(in);
CStateManager: Fix seek again (I tested it this time)
2020-04-20 01:40:08 +00:00
in.seek(startPos + length, athena::SeekOrigin::Begin);
MSVC & zeus fixes; update hecl-gui
2020-04-20 01:09:30 +00:00
LogModule.report(logvisor::Error, FMT_STRING("Script load error while loading {}, name: {}"),
ScriptObjectTypeToStr(type), name);
Implement CScriptGenerator
2017-01-24 17:23:10 +00:00
return {kInvalidEditorId, kInvalidUniqueId};
Fix Impact Crater causing an infinite loop for simply not having a skybox
2019-11-06 17:33:45 +00:00
} else {
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
#ifndef NDEBUG
Update fmtlib
2020-04-11 22:51:39 +00:00
LogModule.report(logvisor::Info, FMT_STRING("Loaded {} in area {}"), ent->GetName(), ent->GetAreaIdAlways());
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
#endif
New code style refactor
2018-12-08 05:30:43 +00:00
return {id, ent->GetUniqueId()};
Fix Impact Crater causing an infinite loop for simply not having a skybox
2019-11-06 17:33:45 +00:00
}
Implement CScriptGenerator
2017-01-24 17:23:10 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
std::pair<TEditorId, TUniqueId> CStateManager::GenerateObject(TEditorId eid) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const std::pair<const SScriptObjectStream*, TEditorId> build = GetBuildForScript(eid);
New code style refactor
2018-12-08 05:30:43 +00:00
if (build.first) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const CGameArea* area = x850_world->GetArea(build.second.AreaNum());
New code style refactor
2018-12-08 05:30:43 +00:00
if (area->IsPostConstructed()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const std::pair<const u8*, u32> buf = area->GetLayerScriptBuffer(build.second.LayerNum());
New code style refactor
2018-12-08 05:30:43 +00:00
CMemoryInStream stream(buf.first + build.first->x4_position, build.first->x8_length);
Add incoming connections
2021-05-27 06:31:38 +00:00
auto ret = LoadScriptObject(build.second.AreaNum(), build.first->x0_type, build.first->x8_length, stream);
// Metaforce Addition
if (m_incomingConnections.find(eid) != m_incomingConnections.end()) {
if (auto ent = ObjectById(ret.second)) {
ent->SetIncomingConnectionList(&m_incomingConnections[eid]);
}
}
// End Metaforce Addition
return ret;
Additional state imps
2016-07-24 04:46:32 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
return {kInvalidEditorId, kInvalidUniqueId};
Additional state imps
2016-07-24 04:46:32 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::InitScriptObjects(const std::vector<TEditorId>& ids) {
Runtime: Resolve -Wrange-loop-analysis warnings (part 2)
2020-09-18 21:04:50 +00:00
for (const auto& id : ids) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (id == kInvalidEditorId) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
const TUniqueId uid = GetIdForScript(id);
New code style refactor
2018-12-08 05:30:43 +00:00
SendScriptMsg(uid, kInvalidUniqueId, EScriptObjectMessage::InitializedInArea);
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
MurderScriptInstanceNames();
Additional CStateManager imps
2017-03-26 19:36:07 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::InformListeners(const zeus::CVector3f& pos, EListenNoiseType type) {
for (CEntity* ent : GetListeningAiObjectList()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CAi> ai = ent) {
if (!ai->GetActive()) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CGameArea* area = x850_world->GetArea(ai->GetAreaIdAlways());
CGameArea::EOcclusionState occState = CGameArea::EOcclusionState::Occluded;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (area->IsPostConstructed()) {
New code style refactor
2018-12-08 05:30:43 +00:00
occState = area->GetPostConstructed()->x10dc_occlusionState;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
if (occState != CGameArea::EOcclusionState::Occluded) {
New code style refactor
2018-12-08 05:30:43 +00:00
ai->Listen(pos, type);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::ApplyKnockBack(CActor& actor, const CDamageInfo& info, const CDamageVulnerability& vuln,
const zeus::CVector3f& pos, float dampen) {
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (vuln.GetVulnerability(info.GetWeaponMode(), false) == EVulnerability::Deflect) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const CHealthInfo* hInfo = actor.HealthInfo(*this);
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (hInfo == nullptr) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float dampedPower = (1.f - dampen) * info.GetKnockBackPower();
if (const TCastToPtr<CPlayer> player = actor) {
New code style refactor
2018-12-08 05:30:43 +00:00
KnockBackPlayer(*player, pos, dampedPower, hInfo->GetKnockbackResistance());
return;
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const TCastToPtr<CAi> ai = actor;
New code style refactor
2018-12-08 05:30:43 +00:00
if (!ai && hInfo->GetHP() <= 0.f) {
if (dampedPower > hInfo->GetKnockbackResistance()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CPhysicsActor> physActor = actor) {
const zeus::CVector3f kbVec =
pos * (dampedPower - hInfo->GetKnockbackResistance()) * physActor->GetMass() * 1.5f;
New code style refactor
2018-12-08 05:30:43 +00:00
if (physActor->GetMaterialList().HasMaterial(EMaterialTypes::Immovable) ||
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
!physActor->GetMaterialList().HasMaterial(EMaterialTypes::Solid)) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
physActor->ApplyImpulseWR(kbVec, zeus::CAxisAngle());
Work on CStateManager
2017-03-29 02:51:12 +00:00
return;
New code style refactor
2018-12-08 05:30:43 +00:00
}
}
}
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (ai) {
New code style refactor
2018-12-08 05:30:43 +00:00
ai->KnockBack(pos, *this, info, dampen == 0.f ? EKnockBackType::Direct : EKnockBackType::Radius, false,
dampedPower);
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
void CStateManager::KnockBackPlayer(CPlayer& player, const zeus::CVector3f& pos, float power, float resistance) {
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (player.GetMaterialList().HasMaterial(EMaterialTypes::Immovable)) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
float usePower;
if (player.GetMorphballTransitionState() != CPlayer::EPlayerMorphBallState::Morphed) {
usePower = power * 1000.f;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const auto surface =
New code style refactor
2018-12-08 05:30:43 +00:00
player.x2b0_outOfWaterTicks == 2 ? player.x2ac_surfaceRestraint : CPlayer::ESurfaceRestraints::Water;
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
if (surface != CPlayer::ESurfaceRestraints::Normal &&
player.GetOrbitState() == CPlayer::EPlayerOrbitState::NoOrbit) {
New code style refactor
2018-12-08 05:30:43 +00:00
usePower /= 7.f;
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
} else {
usePower = power * 500.f;
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float minVel = player.GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Morphed ? 35.f : 70.f;
const float playerVel = player.x138_velocity.magnitude();
const float maxVel = std::max(playerVel, minVel);
const zeus::CVector3f negVel = -player.x138_velocity;
New code style refactor
2018-12-08 05:30:43 +00:00
usePower *= (1.f - 0.5f * zeus::CVector3f::getAngleDiff(pos, negVel) / M_PIF);
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
player.ApplyImpulseWR(pos * usePower, zeus::CAxisAngle());
New code style refactor
2018-12-08 05:30:43 +00:00
player.UseCollisionImpulses();
player.x2d4_accelerationChangeTimer = 0.25f;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float newVel = player.x138_velocity.magnitude();
New code style refactor
2018-12-08 05:30:43 +00:00
if (newVel > maxVel) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f vel = (1.f / newVel) * player.x138_velocity * maxVel;
New code style refactor
2018-12-08 05:30:43 +00:00
player.SetVelocityWR(vel);
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
}
void CStateManager::ApplyDamageToWorld(TUniqueId damager, const CActor& actor, const zeus::CVector3f& pos,
New code style refactor
2018-12-08 05:30:43 +00:00
const CDamageInfo& info, const CMaterialFilter& filter) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CAABox aabb(pos - info.GetRadius(), pos + info.GetRadius());
New code style refactor
2018-12-08 05:30:43 +00:00
bool bomb = false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const TCastToConstPtr<CWeapon> weapon = actor;
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (weapon) {
Implement CFishCloud
2019-04-03 04:32:31 +00:00
bomb = True(weapon->GetAttribField() & (EProjectileAttrib::Bombs | EProjectileAttrib::PowerBombs));
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
EntityList nearList;
New code style refactor
2018-12-08 05:30:43 +00:00
BuildNearList(nearList, aabb, filter, &actor);
Runtime: Resolve -Wrange-loop-analysis warnings (part 2)
2020-09-18 21:04:50 +00:00
for (const auto& id : nearList) {
New code style refactor
2018-12-08 05:30:43 +00:00
CEntity* ent = ObjectById(id);
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (ent == nullptr) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const TCastToPtr<CPlayer> player = ent;
New code style refactor
2018-12-08 05:30:43 +00:00
if (bomb && player) {
if (player->GetFrozenState()) {
g_GameState->SystemOptions().IncrementFrozenBallCount();
Update submodules, minor fixes
2019-08-26 01:29:25 +00:00
MP1::CSamusHud::DisplayHudMemo(u"", CHUDMemoParms{0.f, true, true, true});
New code style refactor
2018-12-08 05:30:43 +00:00
player->UnFreeze(*this);
} else {
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if ((weapon->GetAttribField() & EProjectileAttrib::Bombs) == EProjectileAttrib::Bombs) {
New code style refactor
2018-12-08 05:30:43 +00:00
player->BombJump(pos, *this);
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
} else if (ent->GetUniqueId() != damager) {
TestBombHittingWater(actor, pos, static_cast<CActor&>(*ent));
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (TestRayDamage(pos, static_cast<CActor&>(*ent), nearList)) {
New code style refactor
2018-12-08 05:30:43 +00:00
ApplyRadiusDamage(actor, pos, static_cast<CActor&>(*ent), info);
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CWallCrawlerSwarm> swarm = ent) {
New code style refactor
2018-12-08 05:30:43 +00:00
swarm->ApplyRadiusDamage(pos, info, *this);
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CSnakeWeedSwarm> swarm = ent) {
New code style refactor
2018-12-08 05:30:43 +00:00
swarm->ApplyRadiusDamage(pos, info, *this);
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
}
void CStateManager::ProcessRadiusDamage(const CActor& damager, CActor& damagee, TUniqueId senderId,
const CDamageInfo& info, const CMaterialFilter& filter) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CAABox aabb(damager.GetTranslation() - info.GetRadius(), damager.GetTranslation() + info.GetRadius());
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
EntityList nearList;
New code style refactor
2018-12-08 05:30:43 +00:00
BuildNearList(nearList, aabb, filter, nullptr);
Runtime: Resolve -Wrange-loop-analysis warnings (part 2)
2020-09-18 21:04:50 +00:00
for (const auto& id : nearList) {
New code style refactor
2018-12-08 05:30:43 +00:00
CEntity* ent = ObjectById(id);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ent == nullptr || ent->GetUniqueId() == damager.GetUniqueId() || ent->GetUniqueId() == senderId ||
ent->GetUniqueId() == damagee.GetUniqueId()) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
TestBombHittingWater(damager, damager.GetTranslation(), static_cast<CActor&>(*ent));
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (TestRayDamage(damager.GetTranslation(), static_cast<CActor&>(*ent), nearList)) {
New code style refactor
2018-12-08 05:30:43 +00:00
ApplyRadiusDamage(damager, damager.GetTranslation(), static_cast<CActor&>(*ent), info);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::ApplyRadiusDamage(const CActor& a1, const zeus::CVector3f& pos, CActor& a2,
const CDamageInfo& info) {
zeus::CVector3f delta = a2.GetTranslation() - pos;
CActorContraption fixes, better CMake dependency handling
2019-06-12 02:05:17 +00:00
std::optional<zeus::CAABox> bounds;
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
if (delta.magSquared() < info.GetRadius() * info.GetRadius() ||
((bounds = a2.GetTouchBounds()) &&
CCollidableSphere::Sphere_AABox_Bool(zeus::CSphere{pos, info.GetRadius()}, *bounds))) {
float rad = info.GetRadius();
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (rad > FLT_EPSILON) {
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
rad = delta.magnitude() / rad;
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
} else {
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
rad = 0.f;
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
if (rad > 0.f) {
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
delta.normalize();
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
bool alive = false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const CHealthInfo* hInfo = a2.HealthInfo(*this)) {
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (hInfo->GetHP() > 0.f) {
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
alive = true;
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
}
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
Add debugging tool CVars
2021-01-11 02:44:42 +00:00
const CDamageVulnerability* vuln =
rad > 0.f ? a2.GetDamageVulnerability(pos, delta, info) : a2.GetDamageVulnerability();
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
if (vuln->WeaponHurts(info.GetWeaponMode(), true)) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float dam = info.GetRadiusDamage(*vuln);
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (dam > 0.f) {
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
ApplyLocalDamage(pos, delta, a2, dam, info.GetWeaponMode());
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
a2.SendScriptMsgs(EScriptObjectState::Damage, *this, EScriptObjectMessage::None);
SendScriptMsg(&a2, a1.GetUniqueId(), EScriptObjectMessage::Damage);
} else {
a2.SendScriptMsgs(EScriptObjectState::InvulnDamage, *this, EScriptObjectMessage::None);
SendScriptMsg(&a2, a1.GetUniqueId(), EScriptObjectMessage::InvulnDamage);
New code style refactor
2018-12-08 05:30:43 +00:00
}
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
if (alive && info.GetKnockBackPower() > 0.f) {
Fix CNewIntroBoss and particle bugs
2019-01-05 03:28:02 +00:00
ApplyKnockBack(a2, info, *vuln, (a2.GetTranslation() - a1.GetTranslation()).normalized(), rad);
Initial PAL/JP/Trilogy imps, various cleanup
2020-04-16 05:26:14 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
}
Initial collision testing and CStateManager work
2017-03-30 22:36:18 +00:00
bool CStateManager::TestRayDamage(const zeus::CVector3f& pos, const CActor& damagee,
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
const EntityList& nearList) const {
New code style refactor
2018-12-08 05:30:43 +00:00
const CHealthInfo* hInfo = const_cast<CActor&>(damagee).HealthInfo(const_cast<CStateManager&>(*this));
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (hInfo == nullptr) {
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
CStateManager: Mark material filters and lists as constexpr in TestRayDamage() Allows potential runtime initializers to be elided.
2020-04-09 18:52:49 +00:00
static constexpr CMaterialList incList(EMaterialTypes::Solid);
static constexpr CMaterialList exList(EMaterialTypes::ProjectilePassthrough, EMaterialTypes::Player,
EMaterialTypes::Occluder, EMaterialTypes::Character);
static constexpr CMaterialFilter filter(incList, exList, CMaterialFilter::EFilterType::IncludeExclude);
Work on CStateManager
2017-03-29 02:51:12 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const std::optional<zeus::CAABox> bounds = damagee.GetTouchBounds();
if (!bounds) {
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f center = bounds->center();
New code style refactor
2018-12-08 05:30:43 +00:00
zeus::CVector3f dir = center - pos;
Work on CStateManager
2017-03-29 02:51:12 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!dir.canBeNormalized()) {
New code style refactor
2018-12-08 05:30:43 +00:00
return true;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
const float origMag = dir.magnitude();
New code style refactor
2018-12-08 05:30:43 +00:00
dir = dir * (1.f / origMag);
Work on CStateManager
2017-03-29 02:51:12 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (RayCollideWorld(pos, center, nearList, filter, &damagee)) {
New code style refactor
2018-12-08 05:30:43 +00:00
return true;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CMRay ray(pos, dir, origMag);
if (!MultiRayCollideWorld(ray, filter)) {
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
float depth;
zeus::CVector3f norm;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const u32 count = CollisionUtil::RayAABoxIntersection(ray, *bounds, norm, depth);
if (count == 0 || count == 1) {
New code style refactor
2018-12-08 05:30:43 +00:00
return true;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
return CGameCollision::RayDynamicIntersectionBool(*this, pos, dir, filter, nearList, &damagee, depth * origMag);
Work on CStateManager
2017-03-29 02:51:12 +00:00
}
Work on CPlayer
2017-08-18 01:30:15 +00:00
bool CStateManager::RayCollideWorld(const zeus::CVector3f& start, const zeus::CVector3f& end,
New code style refactor
2018-12-08 05:30:43 +00:00
const CMaterialFilter& filter, const CActor* damagee) const {
zeus::CVector3f delta = end - start;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float mag = delta.magnitude();
New code style refactor
2018-12-08 05:30:43 +00:00
delta = delta / mag;
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
EntityList nearList;
New code style refactor
2018-12-08 05:30:43 +00:00
BuildNearList(nearList, start, delta, mag, filter, damagee);
return RayCollideWorldInternal(start, end, filter, nearList, damagee);
Work on CPlayer
2017-08-18 01:30:15 +00:00
}
Initial work on CGroundMovement
2017-06-19 07:00:50 +00:00
bool CStateManager::RayCollideWorld(const zeus::CVector3f& start, const zeus::CVector3f& end,
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
const EntityList& nearList,
New code style refactor
2018-12-08 05:30:43 +00:00
const CMaterialFilter& filter, const CActor* damagee) const {
return RayCollideWorldInternal(start, end, filter, nearList, damagee);
Initial collision testing and CStateManager work
2017-03-30 22:36:18 +00:00
}
Initial work on CGroundMovement
2017-06-19 07:00:50 +00:00
bool CStateManager::RayCollideWorldInternal(const zeus::CVector3f& start, const zeus::CVector3f& end,
Initial collision testing and CStateManager work
2017-03-30 22:36:18 +00:00
const CMaterialFilter& filter,
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
const EntityList& nearList,
New code style refactor
2018-12-08 05:30:43 +00:00
const CActor* damagee) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f delta = end - start;
if (!delta.canBeNormalized()) {
New code style refactor
2018-12-08 05:30:43 +00:00
return true;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float mag = delta.magnitude();
const zeus::CVector3f dir = delta * (1.f / mag);
if (!CGameCollision::RayStaticIntersectionBool(*this, start, dir, mag, filter)) {
Move weapon code to RuntimeWeapon
2016-11-22 20:43:16 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
return CGameCollision::RayDynamicIntersectionBool(*this, start, dir, filter, nearList, damagee, mag);
}
bool CStateManager::MultiRayCollideWorld(const zeus::CMRay& ray, const CMaterialFilter& filter) const {
zeus::CVector3f crossed = {-ray.dir.z() * ray.dir.z() - ray.dir.y() * ray.dir.x(),
ray.dir.x() * ray.dir.x() - ray.dir.z() * ray.dir.y(),
ray.dir.y() * ray.dir.y() - ray.dir.x() * -ray.dir.z()};
crossed.normalize();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f crossed2 = ray.dir.cross(crossed) * 0.35355338f;
const zeus::CVector3f negCrossed2 = -crossed2;
const zeus::CVector3f rms = crossed * 0.35355338f;
const zeus::CVector3f negRms = -rms;
New code style refactor
2018-12-08 05:30:43 +00:00
for (int i = 0; i < 4; ++i) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f& useCrossed = (i & 2) != 0 ? negCrossed2 : crossed2;
const zeus::CVector3f& useRms = (i & 1) != 0 ? rms : negRms;
if (CGameCollision::RayStaticIntersectionBool(*this, ray.start + useCrossed + useRms, ray.dir, ray.length,
filter)) {
New code style refactor
2018-12-08 05:30:43 +00:00
return true;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
return false;
}
void CStateManager::TestBombHittingWater(const CActor& damager, const zeus::CVector3f& pos, CActor& damagee) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const TCastToConstPtr<CWeapon> wpn = damager;
if (!wpn) {
return;
}
if (False(wpn->GetAttribField() & (EProjectileAttrib::Bombs | EProjectileAttrib::PowerBombs))) {
return;
}
const bool powerBomb = (wpn->GetAttribField() & EProjectileAttrib::PowerBombs) == EProjectileAttrib::PowerBombs;
const TCastToPtr<CScriptWater> water = damagee;
if (!water) {
return;
}
const zeus::CAABox bounds = water->GetTriggerBoundsWR();
const zeus::CVector3f hitPos(pos.x(), pos.y(), bounds.max.z());
const float bombRad = powerBomb ? 4.f : 2.f;
const float delta = bounds.max.z() - pos.dot(zeus::skUp);
if (delta <= bombRad && delta > 0.f) {
// Below surface
const float rippleFactor = 1.f - delta / bombRad;
if (x87c_fluidPlaneManager->GetLastRippleDeltaTime(damager.GetUniqueId()) >= 0.15f) {
const float bombMag = powerBomb ? 1.f : 0.75f;
const float mag = 0.6f * bombMag + 0.4f * bombMag * std::sin(2.f * M_PIF * rippleFactor * 0.25f);
water->GetFluidPlane().AddRipple(mag, damager.GetUniqueId(), hitPos, *water, *this);
}
if (!powerBomb) {
x87c_fluidPlaneManager->CreateSplash(damager.GetUniqueId(), *this, *water, hitPos, rippleFactor, true);
}
} else {
// Above surface
const float bombMag = powerBomb ? 2.f : 1.f;
if (delta <= -bombMag || delta >= 0.f) {
return;
}
const CRayCastResult res = RayStaticIntersection(pos, zeus::skDown, -delta, CMaterialFilter::skPassEverything);
if (res.IsInvalid() && x87c_fluidPlaneManager->GetLastRippleDeltaTime(damager.GetUniqueId()) >= 0.15f) {
// Not blocked by static geometry
const float mag = 0.6f * bombMag + 0.4f * bombMag * std::sin(2.f * M_PIF * -delta / bombMag * 0.25f);
water->GetFluidPlane().AddRipple(mag, damager.GetUniqueId(), hitPos, *water, *this);
Initial collision testing and CStateManager work
2017-03-30 22:36:18 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Work on CStateManager
2017-03-29 02:51:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
bool CStateManager::ApplyLocalDamage(const zeus::CVector3f& pos, const zeus::CVector3f& dir, CActor& damagee, float dam,
const CWeaponMode& weapMode) {
CHealthInfo* hInfo = damagee.HealthInfo(*this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (hInfo == nullptr || dam < 0.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Move weapon code to RuntimeWeapon
2016-11-22 20:43:16 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (hInfo->GetHP() <= 0.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
return true;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Move weapon code to RuntimeWeapon
2016-11-22 20:43:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
float mulDam = dam;
Move weapon code to RuntimeWeapon
2016-11-22 20:43:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
TCastToPtr<CPlayer> player = damagee;
CAi* ai = TCastToPtr<CPatterned>(damagee).GetPtr();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ai == nullptr) {
New code style refactor
2018-12-08 05:30:43 +00:00
ai = TCastToPtr<CDestroyableRock>(damagee).GetPtr();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Move weapon code to RuntimeWeapon
2016-11-22 20:43:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (player) {
if (GetPlayerState()->CanTakeDamage()) {
if (x870_cameraManager->IsInCinematicCamera() ||
(weapMode.GetType() == EWeaponType::Phazon &&
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
x8b8_playerState->HasPowerUp(CPlayerState::EItemType::PhazonSuit))) {
New code style refactor
2018-12-08 05:30:43 +00:00
return false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Implement god mode, and CWeaponMgr
2018-06-13 19:36:11 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (g_GameState->GetHardMode()) {
New code style refactor
2018-12-08 05:30:43 +00:00
mulDam *= g_GameState->GetHardModeDamageMultiplier();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Implement god mode, and CWeaponMgr
2018-06-13 19:36:11 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
float damReduction = 0.f;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x8b8_playerState->HasPowerUp(CPlayerState::EItemType::VariaSuit)) {
New code style refactor
2018-12-08 05:30:43 +00:00
damReduction = g_tweakPlayer->GetVariaDamageReduction();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
if (x8b8_playerState->HasPowerUp(CPlayerState::EItemType::GravitySuit)) {
New code style refactor
2018-12-08 05:30:43 +00:00
damReduction = std::max(g_tweakPlayer->GetGravityDamageReduction(), damReduction);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
if (x8b8_playerState->HasPowerUp(CPlayerState::EItemType::PhazonSuit)) {
New code style refactor
2018-12-08 05:30:43 +00:00
damReduction = std::max(g_tweakPlayer->GetPhazonDamageReduction(), damReduction);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Implement god mode, and CWeaponMgr
2018-06-13 19:36:11 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
mulDam = -(damReduction * mulDam - mulDam);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
} else {
New code style refactor
2018-12-08 05:30:43 +00:00
mulDam = 0.f;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Implement remaining CStateManager stubs
2017-03-31 19:51:40 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const float newHp = hInfo->GetHP() - mulDam;
const bool significant = std::fabs(newHp - hInfo->GetHP()) >= 0.00001;
Space pirate bug fixes
2018-12-15 06:29:41 +00:00
hInfo->SetHP(newHp);
Implement remaining CStateManager stubs
2017-03-31 19:51:40 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (player && GetPlayerState()->CanTakeDamage()) {
player->TakeDamage(significant, pos, mulDam, weapMode.GetType(), *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (newHp <= 0.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
x8b8_playerState->SetPlayerAlive(false);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Implement remaining CStateManager stubs
2017-03-31 19:51:40 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ai != nullptr) {
if (significant) {
New code style refactor
2018-12-08 05:30:43 +00:00
ai->TakeDamage(dir, mulDam);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
if (newHp <= 0.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
ai->Death(*this, dir, EScriptObjectState::DeathRattle);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Implement remaining CStateManager stubs
2017-03-31 19:51:40 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
return significant;
Implement remaining CStateManager stubs
2017-03-31 19:51:40 +00:00
}
Implement MetroidPrimeStage1 loader
2017-08-20 05:23:22 +00:00
bool CStateManager::ApplyDamage(TUniqueId damagerId, TUniqueId damageeId, TUniqueId radiusSender,
Implement remaining CStateManager stubs
2017-03-31 19:51:40 +00:00
const CDamageInfo& info, const CMaterialFilter& filter,
New code style refactor
2018-12-08 05:30:43 +00:00
const zeus::CVector3f& knockbackVec) {
CEntity* ent0 = ObjectById(damagerId);
CEntity* ent1 = ObjectById(damageeId);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const TCastToPtr<CActor> damager = ent0;
const TCastToPtr<CActor> damagee = ent1;
const bool isPlayer = TCastToPtr<CPlayer>(ent1);
New code style refactor
2018-12-08 05:30:43 +00:00
if (damagee) {
if (CHealthInfo* hInfo = damagee->HealthInfo(*this)) {
zeus::CVector3f position;
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
zeus::CVector3f direction = zeus::skRight;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const bool alive = hInfo->GetHP() > 0.f;
New code style refactor
2018-12-08 05:30:43 +00:00
if (damager) {
position = damager->GetTranslation();
direction = damager->GetTransform().basis[1];
}
const CDamageVulnerability* dVuln;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (damager || isPlayer) {
New code style refactor
2018-12-08 05:30:43 +00:00
dVuln = damagee->GetDamageVulnerability(position, direction, info);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
} else {
New code style refactor
2018-12-08 05:30:43 +00:00
dVuln = damagee->GetDamageVulnerability();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (info.GetWeaponMode().GetType() == EWeaponType::None || dVuln->WeaponHurts(info.GetWeaponMode(), false)) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (info.GetDamage() > 0.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
ApplyLocalDamage(position, direction, *damagee, info.GetDamage(), info.GetWeaponMode());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
damagee->SendScriptMsgs(EScriptObjectState::Damage, *this, EScriptObjectMessage::None);
SendScriptMsg(damagee.GetPtr(), damagerId, EScriptObjectMessage::Damage);
} else {
damagee->SendScriptMsgs(EScriptObjectState::InvulnDamage, *this, EScriptObjectMessage::None);
SendScriptMsg(damagee.GetPtr(), damagerId, EScriptObjectMessage::InvulnDamage);
}
if (alive && damager && info.GetKnockBackPower() > 0.f) {
I feex
2020-10-18 23:57:41 +00:00
zeus::CVector3f delta =
New code style refactor
2018-12-08 05:30:43 +00:00
knockbackVec.isZero() ? (damagee->GetTranslation() - damager->GetTranslation()) : knockbackVec;
I feex
2020-10-18 23:57:41 +00:00
delta.z() = FLT_EPSILON;
New code style refactor
2018-12-08 05:30:43 +00:00
ApplyKnockBack(*damagee, info, *dVuln, delta.normalized(), 0.f);
}
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (damager && info.GetRadius() > 0.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
ProcessRadiusDamage(*damager, *damagee, radiusSender, info, filter);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CWallCrawlerSwarm> swarm = ent1) {
if (damager) {
New code style refactor
2018-12-08 05:30:43 +00:00
swarm->ApplyRadiusDamage(damager->GetTranslation(), info, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
return false;
}
void CStateManager::UpdateAreaSounds() {
rstl::reserved_vector<TAreaId, 10> areas;
for (CGameArea& area : *x850_world) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
auto occState = CGameArea::EOcclusionState::Occluded;
if (area.IsPostConstructed()) {
New code style refactor
2018-12-08 05:30:43 +00:00
occState = area.GetOcclusionState();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
if (occState == CGameArea::EOcclusionState::Visible) {
Attempt 4 to fix ScriptLayerController for Tom
2020-10-21 22:55:45 +00:00
areas.push_back(area.GetAreaId());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CSfxManager::SetActiveAreas(areas);
}
void CStateManager::FrameEnd() { g_SimplePool->Flush(); }
void CStateManager::ProcessPlayerInput() {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x84c_player) {
New code style refactor
2018-12-08 05:30:43 +00:00
x84c_player->ProcessInput(xb54_finalInput, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
void CStateManager::SetGameState(EGameState state) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x904_gameState == state) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x904_gameState == EGameState::SoftPaused) {
New code style refactor
2018-12-08 05:30:43 +00:00
x850_world->SetLoadPauseState(false);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
switch (state) {
case EGameState::Running:
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x88c_rumbleManager->IsDisabled()) {
New code style refactor
2018-12-08 05:30:43 +00:00
x88c_rumbleManager->SetDisabled(false);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
break;
case EGameState::SoftPaused:
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!x88c_rumbleManager->IsDisabled()) {
New code style refactor
2018-12-08 05:30:43 +00:00
x88c_rumbleManager->SetDisabled(true);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
x850_world->SetLoadPauseState(true);
Working CScriptGunTurret
2019-02-18 05:47:46 +00:00
break;
New code style refactor
2018-12-08 05:30:43 +00:00
default:
break;
}
x904_gameState = state;
Lots of CSamusHud imps
2017-04-03 01:39:23 +00:00
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
static const CFinalInput s_DisabledFinalInput = {};
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::ProcessInput(const CFinalInput& input) {
if (input.ControllerIdx() == 0) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const CGameCamera* cam = x870_cameraManager->GetCurrentCamera(*this);
New code style refactor
2018-12-08 05:30:43 +00:00
bool disableInput = cam->x170_25_disablesInput;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x84c_player->x9c6_29_disableInput) {
New code style refactor
2018-12-08 05:30:43 +00:00
disableInput = true;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (disableInput) {
xb54_finalInput = s_DisabledFinalInput;
xb54_finalInput.x0_dt = input.DeltaTime();
} else {
xb54_finalInput = input;
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
x870_cameraManager->ProcessInput(input, *this);
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::UpdateGraphicsTiming(float dt) {
xf14_curTimeMod900 += dt;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (xf14_curTimeMod900 > 900.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
xf14_curTimeMod900 -= 900.f;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Various movement and HUD bug fixes
2017-12-19 03:05:50 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::Update(float dt) {
MP1::CMain::UpdateDiscordPresence(GetWorld()->IGetStringTableAssetId());
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
CElementGen::SetGlobalSeed(x8d8_updateFrameIdx);
CParticleElectric::SetGlobalSeed(x8d8_updateFrameIdx);
CDecal::SetGlobalSeed(x8d8_updateFrameIdx);
CProjectileWeapon::SetGlobalSeed(x8d8_updateFrameIdx);
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
xf08_pauseHudMessage = {};
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
CScriptEffect::ResetParticleCounts();
UpdateThermalVisor();
UpdateGameState();
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const bool dying = x84c_player->x9f4_deathTime > 0.f;
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (x904_gameState == EGameState::Running) {
if (!TCastToPtr<CCinematicCamera>(x870_cameraManager->GetCurrentCamera(*this))) {
Update submodules, initial CTextureCache
2019-12-11 04:51:33 +00:00
g_GameState->SetTotalPlayTime(g_GameState->GetTotalPlayTime() + dt);
New code style refactor
2018-12-08 05:30:43 +00:00
UpdateHintState(dt);
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
for (size_t i = 0; i < numCameraPasses; ++i) {
New code style refactor
2018-12-08 05:30:43 +00:00
xb84_camFilterPasses[i].Update(dt);
xd14_camBlurPasses[i].Update(dt);
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (x904_gameState != EGameState::Paused) {
PreThinkObjects(dt);
x87c_fluidPlaneManager->Update(dt);
}
if (x904_gameState == EGameState::Running) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!dying) {
New code style refactor
2018-12-08 05:30:43 +00:00
CDecalManager::Update(dt, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
UpdateSortedLists();
if (!dying) {
MovePlatforms(dt);
MoveActors(dt);
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
ProcessPlayerInput();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x904_gameState != EGameState::SoftPaused) {
New code style refactor
2018-12-08 05:30:43 +00:00
CGameCollision::Move(*this, *x84c_player, dt, nullptr);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
UpdateSortedLists();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!dying) {
New code style refactor
2018-12-08 05:30:43 +00:00
CrossTouchActors();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
} else {
ProcessPlayerInput();
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!dying && x904_gameState == EGameState::Running) {
New code style refactor
2018-12-08 05:30:43 +00:00
x884_actorModelParticles->Update(dt, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x904_gameState == EGameState::Running || x904_gameState == EGameState::SoftPaused) {
New code style refactor
2018-12-08 05:30:43 +00:00
Think(dt);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x904_gameState != EGameState::SoftPaused) {
New code style refactor
2018-12-08 05:30:43 +00:00
x870_cameraManager->Update(dt, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
while (xf76_lastRelay != kInvalidUniqueId) {
if (CEntity* ent = ObjectById(xf76_lastRelay)) {
ent->Think(dt, *this);
} else {
xf76_lastRelay = kInvalidUniqueId;
break;
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x904_gameState != EGameState::Paused) {
New code style refactor
2018-12-08 05:30:43 +00:00
PostUpdatePlayer(dt);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (xf84_ == xf80_hudMessageFrameCount) {
ShowPausedHUDMemo(xf88_, xf8c_);
--xf84_;
xf88_.Reset();
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!dying && x904_gameState == EGameState::Running && !x870_cameraManager->IsInCinematicCamera()) {
New code style refactor
2018-12-08 05:30:43 +00:00
UpdateEscapeSequenceTimer(dt);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
x850_world->Update(dt);
x88c_rumbleManager->Update(dt);
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!dying) {
New code style refactor
2018-12-08 05:30:43 +00:00
x880_envFxManager->Update(dt, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
UpdateAreaSounds();
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
xf94_24_readyToRender = true;
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (xf94_27_inMapScreen) {
if (const CHintOptions::SHintState* hint = g_GameState->HintOptions().GetCurrentDisplayedHint()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (hint->CanContinue()) {
New code style refactor
2018-12-08 05:30:43 +00:00
g_GameState->HintOptions().DismissDisplayedHint();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Various bug fixes, implement `CMain::WarpTo`
2018-09-21 03:41:57 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
xf94_27_inMapScreen = false;
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (!m_warping) {
g_GameState->CurrentWorldState().SetAreaId(x8cc_nextAreaId);
x850_world->TravelToArea(x8cc_nextAreaId, *this, false);
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
ClearGraveyard();
++x8d8_updateFrameIdx;
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::UpdateGameState() {
// Intentionally empty
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::UpdateHintState(float dt) {
CHintOptions& ho = g_GameState->HintOptions();
ho.Update(dt, *this);
u32 nextHintIdx = -1;
u32 pageIdx = -1;
if (const CHintOptions::SHintState* state = ho.GetCurrentDisplayedHint()) {
const CGameHintInfo::CGameHint& next = g_MemoryCardSys->GetHints()[ho.GetNextHintIdx()];
for (const CGameHintInfo::SHintLocation& loc : next.GetLocations()) {
const auto& mwInfo = g_GameState->StateForWorld(loc.x0_mlvlId).MapWorldInfo();
mwInfo->SetIsMapped(loc.x8_areaId, true);
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (state->x4_time < next.GetTextTime()) {
nextHintIdx = ho.GetNextHintIdx();
pageIdx = state->x4_time / 3.f;
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Fix actor physics move
2018-05-15 02:56:05 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (xeec_hintIdx != nextHintIdx || xef0_hintPeriods != pageIdx) {
if (nextHintIdx == -1) {
CHUDMemoParms memoInfo = {0.f, true, true, true};
MP1::CSamusHud::DisplayHudMemo(u"", memoInfo);
} else {
const CGameHintInfo::CGameHint& data = g_MemoryCardSys->GetHints()[nextHintIdx];
CHUDMemoParms memoInfo = {0.f, true, false, true};
MP1::CSamusHud::DeferHintMemo(data.GetStringID(), pageIdx, memoInfo);
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
xeec_hintIdx = nextHintIdx;
xef0_hintPeriods = pageIdx;
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::PreThinkObjects(float dt) {
if (x84c_player->x9f4_deathTime > 0.f) {
x84c_player->DoPreThink(dt, *this);
CBeetle implementation
2018-12-31 05:01:42 +00:00
} else if (x904_gameState == EGameState::SoftPaused) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
for (CEntity* ent : GetAllObjectList()) {
if (const TCastToPtr<CScriptEffect> effect = ent) {
New code style refactor
2018-12-08 05:30:43 +00:00
effect->PreThink(dt, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
CBeetle implementation
2018-12-31 05:01:42 +00:00
} else {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
for (CEntity* ent : GetAllObjectList()) {
if (ent != nullptr && !GetCameraObjectList().GetObjectById(ent->GetUniqueId())) {
CBeetle implementation
2018-12-31 05:01:42 +00:00
ent->PreThink(dt, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
CBeetle implementation
2018-12-31 05:01:42 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
void CStateManager::MovePlatforms(float dt) {
for (CEntity* ent : GetPlatformAndDoorObjectList()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ent == nullptr || !GetPlatformAndDoorObjectList().IsPlatform(*ent)) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
auto& plat = static_cast<CScriptPlatform&>(*ent);
if (!plat.GetActive() || plat.GetMass() == 0.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CGameCollision::Move(*this, plat, dt, nullptr);
}
}
void CStateManager::MoveActors(float dt) {
for (CEntity* ent : GetPhysicsActorObjectList()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ent == nullptr || !ent->GetActive()) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
auto& physActor = static_cast<CPhysicsActor&>(*ent);
if (physActor.GetMass() == 0.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CAi> ai = physActor) {
New code style refactor
2018-12-08 05:30:43 +00:00
bool doThink = !xf94_29_cinematicPause;
if (doThink && ai->GetAreaIdAlways() != kInvalidAreaId) {
const CGameArea* area = x850_world->GetAreaAlways(ai->GetAreaIdAlways());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
float occTime = 0.0f;
if (area->IsPostConstructed()) {
New code style refactor
2018-12-08 05:30:43 +00:00
occTime = area->GetPostConstructed()->x10e4_occludedTime;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
if (occTime > 5.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
doThink = false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
if (!doThink) {
SendScriptMsgAlways(ai->GetUniqueId(), kInvalidUniqueId, EScriptObjectMessage::SuspendedMove);
continue;
}
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x84c_player.get() != ent) {
if (!GetPlatformAndDoorObjectList().IsPlatform(*ent)) {
New code style refactor
2018-12-08 05:30:43 +00:00
CGameCollision::Move(*this, physActor, dt, nullptr);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
}
void CStateManager::CrossTouchActors() {
De-hardcode max entity count
2021-06-06 23:53:41 +00:00
std::array<bool, kMaxEntities> visits{};
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
EntityList nearList;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
for (CEntity* ent : GetActorObjectList()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ent == nullptr) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
auto& actor = static_cast<CActor&>(*ent);
if (!actor.GetActive() || !actor.GetCallTouch()) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const std::optional<zeus::CAABox> touchAABB = actor.GetTouchBounds();
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (!touchAABB) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CMaterialFilter filter = CMaterialFilter::skPassEverything;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (actor.GetMaterialList().HasMaterial(EMaterialTypes::Trigger)) {
New code style refactor
2018-12-08 05:30:43 +00:00
filter = CMaterialFilter::MakeExclude(EMaterialTypes::Trigger);
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
Don't recreate the nearList for each entity
2021-04-03 01:32:26 +00:00
nearList.clear();
New code style refactor
2018-12-08 05:30:43 +00:00
BuildNearList(nearList, *touchAABB, filter, &actor);
Player reflection and other imps
2017-03-26 05:53:04 +00:00
Runtime: Resolve -Wrange-loop-analysis warnings (part 2)
2020-09-18 21:04:50 +00:00
for (const auto& id : nearList) {
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
auto* ent2 = static_cast<CActor*>(ObjectById(id));
if (!ent2) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const std::optional<zeus::CAABox> touchAABB2 = ent2->GetTouchBounds();
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (!ent2->GetActive() || !touchAABB2) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (visits[ent2->GetUniqueId().Value()]) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (touchAABB->intersects(*touchAABB2)) {
actor.Touch(*ent2, *this);
ent2->Touch(actor, *this);
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
visits[actor.GetUniqueId().Value()] = true;
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::Think(float dt) {
if (x84c_player->x9f4_deathTime > 0.f) {
x84c_player->DoThink(dt, *this);
return;
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (x904_gameState == EGameState::SoftPaused) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
for (CEntity* ent : GetAllObjectList()) {
if (const TCastToPtr<CScriptEffect> effect = ent) {
New code style refactor
2018-12-08 05:30:43 +00:00
effect->Think(dt, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
} else {
for (CEntity* ent : GetAllObjectList()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CAi> ai = ent) {
New code style refactor
2018-12-08 05:30:43 +00:00
bool doThink = !xf94_29_cinematicPause;
if (doThink && ai->GetAreaIdAlways() != kInvalidAreaId) {
const CGameArea* area = x850_world->GetAreaAlways(ai->GetAreaIdAlways());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
float occTime = 0.0f;
if (area->IsPostConstructed()) {
New code style refactor
2018-12-08 05:30:43 +00:00
occTime = area->GetPostConstructed()->x10e4_occludedTime;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
if (occTime > 5.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
doThink = false;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Implement CScriptSound and bug fixes
2017-11-27 05:06:53 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!doThink) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!GetCameraObjectList().GetObjectById(ent->GetUniqueId())) {
New code style refactor
2018-12-08 05:30:43 +00:00
ent->Think(dt, *this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
}
}
void CStateManager::PostUpdatePlayer(float dt) { x84c_player->PostUpdate(dt, *this); }
void CStateManager::ShowPausedHUDMemo(CAssetId strg, float time) {
xf78_hudMessageTime = time;
xf08_pauseHudMessage = strg;
DeferStateTransition(EStateManagerTransition::MessageScreen);
}
void CStateManager::ClearGraveyard() {
Runtime: Resolve -Wrange-loop-analysis warnings (part 2)
2020-09-18 21:04:50 +00:00
for (const auto& id : x854_objectGraveyard) {
New code style refactor
2018-12-08 05:30:43 +00:00
CEntity* ent = GetAllObjectList().GetValidObjectById(id);
RemoveObject(id);
std::default_delete<CEntity>()(ent);
}
x854_objectGraveyard.clear();
}
void CStateManager::FrameBegin(s32 frameCount) { x8d4_inputFrameIdx = frameCount; }
void CStateManager::InitializeState(CAssetId mlvlId, TAreaId aid, CAssetId mreaId) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const bool hadRandom = x900_activeRandom != nullptr;
New code style refactor
2018-12-08 05:30:43 +00:00
SetActiveRandomToDefault();
if (xb3c_initPhase == EInitPhase::LoadWorld) {
CreateStandardGameObjects();
Runtime: Make use of std::make_unique where applicable Makes use of the C++14 make_unique allocation function to allocate class instances where applicable instead of a reset with a new operator within it. This doesn't touch cases where buffers are allocated, given make_unique would zero-initialize them.
2019-09-12 03:50:38 +00:00
x850_world = std::make_unique<CWorld>(*g_SimplePool, *g_ResFactory, mlvlId);
New code style refactor
2018-12-08 05:30:43 +00:00
xb3c_initPhase = EInitPhase::LoadFirstArea;
}
if (xb3c_initPhase == EInitPhase::LoadFirstArea) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!x8f0_shadowTex.IsLoaded()) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
x8f0_shadowTex.GetObj();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!x850_world->CheckWorldComplete(this, aid, mreaId)) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
x8cc_nextAreaId = x850_world->x68_curAreaId;
CGameArea* area = x850_world->x18_areas[x8cc_nextAreaId].get();
if (x850_world->ScheduleAreaToLoad(area, *this)) {
area->StartStreamIn(*this);
return;
}
xb3c_initPhase = EInitPhase::Done;
}
SetCurrentAreaId(x8cc_nextAreaId);
g_GameState->CurrentWorldState().SetAreaId(x8cc_nextAreaId);
x850_world->TravelToArea(x8cc_nextAreaId, *this, true);
UpdateRoomAcoustics(x8cc_nextAreaId);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
for (CEntity* ent : GetAllObjectList()) {
New code style refactor
2018-12-08 05:30:43 +00:00
SendScriptMsg(ent, kInvalidUniqueId, EScriptObjectMessage::WorldInitialized);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
for (CEntity* ent : GetAllObjectList()) {
CScriptSpawnPoint* sp = TCastToPtr<CScriptSpawnPoint>(ent);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (sp != nullptr && sp->x30_24_active && sp->FirstSpawn()) {
New code style refactor
2018-12-08 05:30:43 +00:00
const zeus::CTransform& xf = sp->GetTransform();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CVector3f lookVec = xf.frontVector();
New code style refactor
2018-12-08 05:30:43 +00:00
if (lookVec.canBeNormalized()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const auto lookXf = zeus::lookAt(xf.origin, xf.origin + lookVec);
New code style refactor
2018-12-08 05:30:43 +00:00
x84c_player->Teleport(lookXf, *this, true);
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!g_GameState->x228_25_initPowerupsAtFirstSpawn) {
New code style refactor
2018-12-08 05:30:43 +00:00
break;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
g_GameState->x228_25_initPowerupsAtFirstSpawn = false;
for (int i = 0; i < int(CPlayerState::EItemType::Max); ++i) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const auto iType = CPlayerState::EItemType(i);
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
u32 spawnPu = sp->GetPowerup(iType);
u32 statePu = x8b8_playerState->GetItemAmount(iType);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (statePu < spawnPu) {
Refactor for blender 2.8 and new shader model
2019-05-08 03:50:21 +00:00
x8b8_playerState->AddPowerUp(iType, spawnPu - statePu);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
spawnPu = sp->GetPowerup(iType);
statePu = x8b8_playerState->GetItemAmount(iType);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (statePu < spawnPu) {
New code style refactor
2018-12-08 05:30:43 +00:00
x8b8_playerState->IncrPickup(iType, spawnPu - statePu);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
x84c_player->AsyncLoadSuit(*this);
x870_cameraManager->ResetCameras(*this);
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!hadRandom) {
New code style refactor
2018-12-08 05:30:43 +00:00
ClearActiveRandom();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
} else {
Lots of CMFGame integration
2017-02-18 02:19:50 +00:00
SetActiveRandomToDefault();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
CStateManager::InitializeResources() dependencies all in
2016-08-15 01:19:04 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
x880_envFxManager->AsyncLoadResources(*this);
}
void CStateManager::CreateStandardGameObjects() {
Runtime: Make use of std::make_unique where applicable Makes use of the C++14 make_unique allocation function to allocate class instances where applicable instead of a reset with a new operator within it. This doesn't touch cases where buffers are allocated, given make_unique would zero-initialize them.
2019-09-12 03:50:38 +00:00
const float height = g_tweakPlayer->GetPlayerHeight();
const float xyHe = g_tweakPlayer->GetPlayerXYHalfExtent();
const float stepUp = g_tweakPlayer->GetStepUpHeight();
const float stepDown = g_tweakPlayer->GetStepDownHeight();
const float ballRadius = g_tweakPlayer->GetPlayerBallHalfExtent();
const zeus::CAABox pBounds = {{-xyHe, -xyHe, 0.f}, {xyHe, xyHe, height}};
const auto q = zeus::CQuaternion::fromAxisAngle(zeus::CVector3f{0.f, 0.f, 1.f}, zeus::degToRad(129.6f));
x84c_player = std::make_unique<CPlayer>(
AllocateUniqueId(), zeus::CTransform(q), pBounds, g_tweakPlayerRes->xc4_ballTransitionsANCS,
zeus::CVector3f{1.65f, 1.65f, 1.65f}, 200.f, stepUp, stepDown, ballRadius,
CMaterialList(EMaterialTypes::Player, EMaterialTypes::Solid, EMaterialTypes::GroundCollider));
New code style refactor
2018-12-08 05:30:43 +00:00
AddObject(*x84c_player);
x870_cameraManager->CreateStandardCameras(*this);
}
CObjectList* CStateManager::ObjectListById(EGameObjectList type) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (type == EGameObjectList::Invalid) {
New code style refactor
2018-12-08 05:30:43 +00:00
return nullptr;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
return x808_objLists[int(type)].get();
}
const CObjectList* CStateManager::GetObjectListById(EGameObjectList type) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (type == EGameObjectList::Invalid) {
New code style refactor
2018-12-08 05:30:43 +00:00
return nullptr;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
return x808_objLists[int(type)].get();
}
void CStateManager::RemoveObject(TUniqueId uid) {
if (CEntity* ent = GetAllObjectList().GetValidObjectById(uid)) {
if (ent->GetEditorId() != kInvalidEditorId) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const auto search = x890_scriptIdMap.equal_range(ent->GetEditorId());
New code style refactor
2018-12-08 05:30:43 +00:00
for (auto it = search.first; it != search.second;) {
if (it->second == uid) {
it = x890_scriptIdMap.erase(it);
continue;
Plenty of dependency stubs for CStateManager
2016-08-14 21:11:44 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
++it;
}
Plenty of dependency stubs for CStateManager
2016-08-14 21:11:44 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (ent->GetAreaIdAlways() != kInvalidAreaId) {
CGameArea* area = x850_world->GetArea(ent->GetAreaIdAlways());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (area->IsPostConstructed()) {
New code style refactor
2018-12-08 05:30:43 +00:00
area->GetAreaObjects()->RemoveObject(uid);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CActor> act = ent) {
New code style refactor
2018-12-08 05:30:43 +00:00
x874_sortedListManager->Remove(act.GetPtr());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
for (auto& list : x808_objLists) {
New code style refactor
2018-12-08 05:30:43 +00:00
list->RemoveObject(uid);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::UpdateRoomAcoustics(TAreaId aid) {
u32 updateCount = 0;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
std::array<CScriptRoomAcoustics*, 10> updates;
New code style refactor
2018-12-08 05:30:43 +00:00
for (CEntity* ent : GetAllObjectList()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CScriptRoomAcoustics> acoustics = ent) {
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (acoustics->GetAreaIdAlways() != aid || !acoustics->GetActive()) {
New code style refactor
2018-12-08 05:30:43 +00:00
continue;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
updates[updateCount++] = acoustics.GetPtr();
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (updateCount >= updates.size()) {
New code style refactor
2018-12-08 05:30:43 +00:00
break;
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Proper CObjectList imps; CGameLight, and CScriptAiJumpPoint imps
2016-10-01 19:00:16 +00:00
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
if (updateCount == 0) {
New code style refactor
2018-12-08 05:30:43 +00:00
CScriptRoomAcoustics::DisableAuxCallbacks();
return;
}
Proper CObjectList imps; CGameLight, and CScriptAiJumpPoint imps
2016-10-01 19:00:16 +00:00
CStateManager: Make use of std::array where applicable Same behavior, but allows dehardcoding array sizes and makes the array types more strongly typed.
2020-03-18 02:41:29 +00:00
const auto idx = int(updateCount * x900_activeRandom->Float() * 0.99f);
New code style refactor
2018-12-08 05:30:43 +00:00
updates[idx]->EnableAuxCallbacks();
Player reflection and other imps
2017-03-26 05:53:04 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::SetCurrentAreaId(TAreaId aid) {
if (aid != x8cc_nextAreaId) {
x8d0_prevAreaId = x8cc_nextAreaId;
UpdateRoomAcoustics(aid);
x8cc_nextAreaId = aid;
}
Work on CStateManager::InitializeState flow
2016-08-14 03:00:58 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (aid == kInvalidAreaId) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
if (x8c0_mapWorldInfo->IsAreaVisited(aid)) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
x8c0_mapWorldInfo->SetAreaVisited(aid, true);
CWorld: Rename IMapWorld to IGetMapWorld() Allows const overloading to function properly and prevents potential compilation errors from occurring if constness on functions is ever changed.
2020-03-21 03:24:13 +00:00
x850_world->IGetMapWorld()->RecalculateWorldSphere(*x8c0_mapWorldInfo, *x850_world);
CStateManager method stubs
2016-04-17 05:35:32 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::AreaUnloaded(TAreaId) {
// Intentionally empty
Implement remaining CStateManager stubs
2017-03-31 19:51:40 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::PrepareAreaUnload(TAreaId aid) {
for (CEntity* ent : GetAllObjectList()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CScriptDoor> door = ent) {
if (door->IsConnectedToArea(*this, aid)) {
New code style refactor
2018-12-08 05:30:43 +00:00
door->ForceClosed(*this);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
FreeScriptObjects(aid);
Implement remaining CStateManager stubs
2017-03-31 19:51:40 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::AreaLoaded(TAreaId aid) {
Rename CWorldLayerState to CScriptLayerManager (this is it's actual name)
2021-06-04 06:08:05 +00:00
x8bc_mailbox->SendMsgs(aid, *this);
New code style refactor
2018-12-08 05:30:43 +00:00
x880_envFxManager->AreaLoaded();
Implement remaining CStateManager stubs
2017-03-31 19:51:40 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
void CStateManager::BuildNearList(EntityList& listOut, const zeus::CVector3f& v1,
Player reflection and other imps
2017-03-26 05:53:04 +00:00
const zeus::CVector3f& v2, float f1, const CMaterialFilter& filter,
New code style refactor
2018-12-08 05:30:43 +00:00
const CActor* actor) const {
x874_sortedListManager->BuildNearList(listOut, v1, v2, f1, filter, actor);
CStateManager method stubs
2016-04-17 05:35:32 +00:00
}
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
void CStateManager::BuildColliderList(EntityList& listOut, const CActor& actor,
New code style refactor
2018-12-08 05:30:43 +00:00
const zeus::CAABox& aabb) const {
x874_sortedListManager->BuildNearList(listOut, actor, aabb);
CStateManager method stubs
2016-04-17 05:35:32 +00:00
}
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
void CStateManager::BuildNearList(EntityList& listOut, const zeus::CAABox& aabb,
New code style refactor
2018-12-08 05:30:43 +00:00
const CMaterialFilter& filter, const CActor* actor) const {
x874_sortedListManager->BuildNearList(listOut, aabb, filter, actor);
}
void CStateManager::UpdateActorInSortedLists(CActor& act) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!act.GetUseInSortedLists() || !act.xe4_27_notInSortedLists) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const std::optional<zeus::CAABox> aabb = CalculateObjectBounds(act);
const bool actorInLists = x874_sortedListManager->ActorInLists(&act);
New code style refactor
2018-12-08 05:30:43 +00:00
if (actorInLists || aabb) {
act.xe4_27_notInSortedLists = false;
if (actorInLists) {
if (!act.GetActive() || !aabb) {
x874_sortedListManager->Remove(&act);
} else {
x874_sortedListManager->Move(&act, *aabb);
}
} else if (act.GetActive() && aabb) {
x874_sortedListManager->Insert(&act, *aabb);
}
}
}
void CStateManager::UpdateSortedLists() {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!x850_world) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
for (CEntity* actor : GetActorObjectList()) {
New code style refactor
2018-12-08 05:30:43 +00:00
UpdateActorInSortedLists(static_cast<CActor&>(*actor));
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CActorContraption fixes, better CMake dependency handling
2019-06-12 02:05:17 +00:00
std::optional<zeus::CAABox> CStateManager::CalculateObjectBounds(const CActor& actor) {
std::optional<zeus::CAABox> bounds = actor.GetTouchBounds();
New code style refactor
2018-12-08 05:30:43 +00:00
if (bounds) {
zeus::CAABox aabb;
aabb.accumulateBounds(bounds->min);
aabb.accumulateBounds(bounds->max);
if (TCastToConstPtr<CPhysicsActor> physAct = actor) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const zeus::CAABox physAabb = physAct->GetBoundingBox();
New code style refactor
2018-12-08 05:30:43 +00:00
aabb.accumulateBounds(physAabb.min);
aabb.accumulateBounds(physAabb.max);
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
return aabb;
New code style refactor
2018-12-08 05:30:43 +00:00
} else {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToConstPtr<CPhysicsActor> physAct = actor) {
return physAct->GetBoundingBox();
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
return std::nullopt;
New code style refactor
2018-12-08 05:30:43 +00:00
}
void CStateManager::AddObject(CEntity& ent) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ent.GetEditorId() != kInvalidEditorId) {
New code style refactor
2018-12-08 05:30:43 +00:00
x890_scriptIdMap.insert(std::make_pair(ent.GetEditorId(), ent.GetUniqueId()));
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
for (auto& list : x808_objLists) {
New code style refactor
2018-12-08 05:30:43 +00:00
list->AddObject(ent);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (ent.GetAreaIdAlways() == kInvalidAreaId && x84c_player && ent.GetUniqueId() != x84c_player->GetUniqueId()) {
New code style refactor
2018-12-08 05:30:43 +00:00
ent.x4_areaId = x84c_player->GetAreaIdAlways();
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (ent.GetAreaIdAlways() != kInvalidAreaId) {
CGameArea* area = x850_world->GetArea(ent.GetAreaIdAlways());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (area->IsPostConstructed()) {
New code style refactor
2018-12-08 05:30:43 +00:00
area->GetAreaObjects()->AddObject(ent);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (const TCastToPtr<CActor> act = ent) {
New code style refactor
2018-12-08 05:30:43 +00:00
UpdateActorInSortedLists(*act.GetPtr());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
ent.AcceptScriptMsg(EScriptObjectMessage::Registered, kInvalidUniqueId, *this);
Various bug fixes
2017-11-26 03:04:25 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (ent.GetAreaIdAlways() != kInvalidAreaId && x850_world) {
CGameArea* area = x850_world->GetArea(ent.GetAreaIdAlways());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (area->IsValidated()) {
New code style refactor
2018-12-08 05:30:43 +00:00
SendScriptMsg(&ent, kInvalidUniqueId, EScriptObjectMessage::InitializedInArea);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Better handling for logging CVar
2018-06-13 03:20:49 +00:00
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (sm_logScripting != nullptr && sm_logScripting->toBoolean()) {
Update fmtlib
2020-04-11 22:51:39 +00:00
LogModule.report(logvisor::Info, FMT_STRING("Added '{}'"), ent.GetName());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::AddObject(CEntity* ent) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (!ent) {
return;
}
AddObject(*ent);
Implement CStateManager::Update
2017-03-24 05:30:16 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
CRayCastResult CStateManager::RayStaticIntersection(const zeus::CVector3f& pos, const zeus::CVector3f& dir,
float length, const CMaterialFilter& filter) const {
return CGameCollision::RayStaticIntersection(*this, pos, dir, length, filter);
CStateManager method stubs
2016-04-17 05:35:32 +00:00
}
Initial collision testing and CStateManager work
2017-03-30 22:36:18 +00:00
CRayCastResult CStateManager::RayWorldIntersection(TUniqueId& idOut, const zeus::CVector3f& pos,
New code style refactor
2018-12-08 05:30:43 +00:00
const zeus::CVector3f& dir, float length,
const CMaterialFilter& filter,
Use EntityList instead of `rstl::resverved_vector<TUniqueId, 1024>' directly
2021-06-07 00:07:45 +00:00
const EntityList& list) const {
New code style refactor
2018-12-08 05:30:43 +00:00
return CGameCollision::RayWorldIntersection(*this, idOut, pos, dir, length, filter, list);
Implement remaining CStateManager stubs
2017-03-31 19:51:40 +00:00
}
CStateManager method stubs
2016-04-17 05:35:32 +00:00
Finish CSpacePirate implementation
2018-12-13 07:39:16 +00:00
zeus::CVector3f CStateManager::Random2f(float scaleMin, float scaleMax) {
zeus::CVector3f ret(x900_activeRandom->Float() - 0.5f, x900_activeRandom->Float() - 0.5f, 0.f);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (std::fabs(ret.x()) < 0.001f) {
Finish CSpacePirate implementation
2018-12-13 07:39:16 +00:00
ret.x() = 0.001f;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Finish CSpacePirate implementation
2018-12-13 07:39:16 +00:00
ret.normalize();
return ret * ((scaleMax - scaleMin) * x900_activeRandom->Float() + scaleMin);
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::UpdateObjectInLists(CEntity& ent) {
for (auto& list : x808_objLists) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (list->GetValidObjectById(ent.GetUniqueId())) {
if (!list->IsQualified(ent)) {
New code style refactor
2018-12-08 05:30:43 +00:00
list->RemoveObject(ent.GetUniqueId());
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
}
if (!list->GetValidObjectById(ent.GetUniqueId())) {
New code style refactor
2018-12-08 05:30:43 +00:00
list->AddObject(ent);
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
}
TUniqueId CStateManager::AllocateUniqueId() {
const s16 lastIndex = x0_nextFreeIndex;
s16 ourIndex;
do {
ourIndex = x0_nextFreeIndex;
CScriptMazeNode: Working implementation
2020-09-20 07:25:56 +00:00
x0_nextFreeIndex = (ourIndex + 1) & 0x3ff;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x0_nextFreeIndex == lastIndex) {
CScriptMazeNode: Working implementation
2020-09-20 07:25:56 +00:00
LogModule.report(logvisor::Fatal, FMT_STRING("Object list full!"));
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
} while (GetAllObjectList().GetObjectByIndex(ourIndex) != nullptr);
CScriptTrigger work
2017-01-15 03:59:37 +00:00
Rename CStateManager::x8_idArr to CStateManager::x4_idArr to better match the game
2021-06-05 05:30:38 +00:00
x4_idxArr[ourIndex] = (x4_idxArr[ourIndex] + 1) & 0x3f;
if (TUniqueId(ourIndex, x4_idxArr[ourIndex]) == kInvalidUniqueId) {
x4_idxArr[ourIndex] = 0;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
CScriptTrigger work
2017-01-15 03:59:37 +00:00
Rename CStateManager::x8_idArr to CStateManager::x4_idArr to better match the game
2021-06-05 05:30:38 +00:00
return TUniqueId(ourIndex, x4_idxArr[ourIndex]);
various implementation
2015-08-19 05:48:57 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::DeferStateTransition(EStateManagerTransition t) {
if (t == EStateManagerTransition::InGame) {
if (xf90_deferredTransition != EStateManagerTransition::InGame) {
x850_world->SetLoadPauseState(false);
xf90_deferredTransition = EStateManagerTransition::InGame;
Lots of CMFGame integration
2017-02-18 02:19:50 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
} else {
if (xf90_deferredTransition == EStateManagerTransition::InGame) {
x850_world->SetLoadPauseState(true);
xf90_deferredTransition = t;
Lots of CMFGame integration
2017-02-18 02:19:50 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Lots of CMFGame integration
2017-02-18 02:19:50 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
bool CStateManager::CanShowMapScreen() const {
const CHintOptions::SHintState* curDispHint = g_GameState->HintOptions().GetCurrentDisplayedHint();
More CThardus imps, add CRandom16 stats
2020-09-05 06:04:28 +00:00
return curDispHint == nullptr || curDispHint->CanContinue();
Lots of CMFGame integration
2017-02-18 02:19:50 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
std::pair<u32, u32> CStateManager::CalculateScanCompletionRate() const {
u32 num = 0;
u32 denom = 0;
int idx = 0;
for (const std::pair<CAssetId, float>& scan : x8b8_playerState->GetScanTimes()) {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
const auto category = g_MemoryCardSys->GetScanStates()[idx++].second;
Rename CSavwWorld to CWorldSaveGameInfo
2021-06-05 05:27:52 +00:00
if (category != CWorldSaveGameInfo::EScanCategory::None && category != CWorldSaveGameInfo::EScanCategory::Research) {
New code style refactor
2018-12-08 05:30:43 +00:00
++denom;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (scan.second == 1.f) {
New code style refactor
2018-12-08 05:30:43 +00:00
++num;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
Work on CMemoryCardDriver
2016-12-20 21:51:50 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
return {num, denom};
Work on CMemoryCardDriver
2016-12-20 21:51:50 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CStateManager::SetBossParams(TUniqueId bossId, float maxEnergy, u32 stringIdx) {
xf18_bossId = bossId;
xf1c_totalBossEnergy = maxEnergy;
Fix CAutoMapper strings, disable saving on non-USA/GC versions
2020-04-17 12:53:22 +00:00
xf20_bossStringIdx = stringIdx - (g_Main->IsUSA() && !g_Main->IsTrilogy() ? 0 : 6);
Additional HUD interfaces
2017-04-04 05:48:13 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
float CStateManager::IntegrateVisorFog(float f) const {
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
if (x8b8_playerState->GetActiveVisor(*this) == CPlayerState::EPlayerVisor::Scan) {
New code style refactor
2018-12-08 05:30:43 +00:00
return (1.f - x8b8_playerState->GetVisorTransitionFactor()) * f;
CStateManager: Make bracing explicit Makes one of the most heavily read parts of the codebase fully consistent across the board. While we're at it, we can mark variables const where applicable to make mutability explicit.
2020-05-09 21:32:12 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
return f;
Nearly finish CScriptWater
2017-08-13 07:56:35 +00:00
}
Player reflection and other imps
2017-03-26 05:53:04 +00:00
float CStateManager::g_EscapeShakeCountdown;
bool CStateManager::g_EscapeShakeCountdownInit = false;
CDrone: Implement sub_80165984 & sub_801656d4
2020-09-15 04:46:32 +00:00
void CStateManager::sub_80044098(const CCollisionResponseData& colRespData, const CRayCastResult& rayCast,
Update hecl; fix uint -> u32
2020-09-15 23:31:29 +00:00
TUniqueId uid, const CWeaponMode& weaponMode, u32 w1, u8 thermalFlags) {
CDrone: Implement sub_80165984 & sub_801656d4
2020-09-15 04:46:32 +00:00
// TODO implement
}
Update submodules, add room timer
2020-12-31 22:00:10 +00:00
const CGameArea* CStateManager::GetCurrentArea() const {
Add incoming connections
2021-05-27 06:31:38 +00:00
if (x850_world != nullptr && x850_world->GetCurrentAreaId() != kInvalidAreaId) {
return x850_world->GetAreaAlways(x850_world->GetCurrentAreaId());
Update submodules, add room timer
2020-12-31 22:00:10 +00:00
}
Add incoming connections
2021-05-27 06:31:38 +00:00
return nullptr;
Update submodules, add room timer
2020-12-31 22:00:10 +00:00
};
Rename everything
2021-04-10 08:42:06 +00:00
} // namespace metaforce