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

Merge branch 'master' of https://github.com/AxioDL/urde

This commit is contained in:
Jack Andersen 2016-09-16 10:21:43 -10:00
parent 2fed8f36fb b27821c5eb
commit 32be061783
30 changed files with 2746 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
DataSpec/DNACommon/Tweaks/ITweakPlayer.hpp
View File

@ -14,6 +14,8 @@ struct ITweakPlayer : BigYAML
virtual float GetPlayerSomething1() const=0; // x274
virtual float GetPlayerSomething2() const=0; // x278
virtual float GetPlayerSomething3() const=0; // x27c
virtual float GetPlayerSomething4() const=0; // x134
virtual bool GetPlayerSomething5() const=0; // x228_24
virtual float GetLeftLogicalThreshold() const=0;
virtual float GetRightLogicalThreshold() const=0;
};

6
DataSpec/DNAMP1/CMakeLists.txt
View File

@ -25,7 +25,8 @@ make_dnalist(liblist
Tweaks/CTweakGunRes
Tweaks/CTweakPlayerRes
Tweaks/CTweakGui
Tweaks/CTweakSlideShow)
Tweaks/CTweakSlideShow
Tweaks/CTweakCameraBob)
add_library(DNAMP1
DNAMP1.hpp DNAMP1.cpp
@ -42,4 +43,5 @@ add_library(DNAMP1
MREA.cpp
SCLY.hpp SCLY.cpp
FRME.cpp
DeafBabe.cpp)
DeafBabe.cpp
Tweaks/CTweakPlayer.cpp)

6
DataSpec/DNAMP1/DNAMP1.cpp
View File

@ -26,6 +26,8 @@
#include "../DNACommon/Tweaks/TweakWriter.hpp"
#include "Tweaks/CTweakPlayerRes.hpp"
#include "Tweaks/CTweakGunRes.hpp"
#include "Tweaks/CTweakPlayer.hpp"
#include "Tweaks/CTweakCameraBob.hpp"
namespace DataSpec
{
@ -315,6 +317,10 @@ ResExtractor<PAKBridge> PAKBridge::LookupExtractor(const PAK& pak, const PAK::En
return {ExtractTweak<CTweakPlayerRes>, nullptr, {_S(".yaml")}};
if (!name.compare("GunRes"))
return {ExtractTweak<CTweakGunRes>, nullptr, {_S(".yaml")}};
if (!name.compare("Player"))
return {ExtractTweak<CTweakPlayer>, nullptr, {_S(".yaml")}};
if (!name.compare("CameraBob"))
return {ExtractTweak<CTweakCameraBob>, nullptr, {_S(".yaml")}};
}
break;
}

31
DataSpec/DNAMP1/Tweaks/CTweakCameraBob.hpp Normal file
View File

@ -0,0 +1,31 @@
#ifndef __URDE_CTWEAKCAMERABOB_HPP__
#define __URDE_CTWEAKCAMERABOB_HPP__
#include "../../DNACommon/DNACommon.hpp"
namespace DataSpec
{
namespace DNAMP1
{
struct CTweakCameraBob : BigYAML
{
DECL_YAML
Value<float> cameraBobExtentX;
Value<float> cameraBobExtentY;
Value<float> cameraBobPeriod;
Value<float> orbitScale;
Value<float> maxOrbitScale;
Value<float> slowSpeedPeriodScale;
Value<float> targetMagnitudeTrackingRate;
Value<float> landingBobSpringConstant;
Value<float> viewWanderRadius;
Value<float> viewWanderSpeedMin;
Value<float> viewWanderSpeedMax;
Value<float> viewWanderRollVariation;
Value<float> gunBobMagnitude;
Value<float> helmetBobMagnitude;
};
}
}
#endif // __URDE_CTWEAKCAMERABOB_HPP__

1945
DataSpec/DNAMP1/Tweaks/CTweakPlayer.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

206
DataSpec/DNAMP1/Tweaks/CTweakPlayer.hpp
View File

@ -10,22 +10,196 @@ namespace DNAMP1
struct CTweakPlayer : ITweakPlayer
{
DECL_YAML
Value<float> m_playerHeight;
Value<float> m_playerXYHalfExtent;
Value<float> m_unk1;
Value<float> m_unk2;
Value<float> m_unk3;
Value<float> m_leftDiv;
Value<float> m_rightDiv;
float GetPlayerHeight() const { return m_playerHeight; }
float GetPlayerXYHalfExtent() const { return m_playerXYHalfExtent; }
float GetPlayerSomething1() const { return m_unk1; }
float GetPlayerSomething2() const { return m_unk2; }
float GetPlayerSomething3() const { return m_unk3; }
float GetLeftLogicalThreshold() const {return m_leftDiv;}
float GetRightLogicalThreshold() const {return m_rightDiv;}
CTweakPlayer(athena::io::IStreamReader& reader) {this->read(reader);}
Delete _d;
Value<float> x4_[8];
Value<float> x24_[8];
Value<float> x44_[8];
Value<float> x64_[8];
Value<float> x84_[8];
Value<float> xa4_[8];
Value<float> xc4_;
Value<float> xc8_;
Value<float> xcc_;
Value<float> xd0_;
Value<float> xd4_;
Value<float> xd8_;
Value<float> xdc_;
Value<float> xe0_;
Value<float> xe4_;
Value<float> xe8_;
Value<float> xec_;
Value<float> xf0_;
Value<float> xf4_;
Value<float> xf8_;
Value<float> xfc_;
Value<float> x100_;
Value<float> x104_;
Value<float> x108_;
Value<float> x10c_;
Value<float> x110_;
Value<float> x114_;
Value<float> x118_;
Value<float> x11c_;
Value<float> x120_;
Value<float> x124_;
Value<float> x128_;
Value<float> x12c_;
Value<float> x130_;
Value<float> x134_;
Value<float> x138_;
Value<float> x13c_;
Value<float> x140_;
Value<float> x144_;
Value<float> x148_;
Value<float> x14c_;
Value<float> x150_leftDiv;
Value<float> x154_rightDiv;
Value<float> x158_[3];
Value<float> x164_[3];
Value<float> x170_[3];
Value<float> x17c_;
Value<float> x180_;
Value<float> x184_;
Value<float> x188_;
Value<float> x18c_;
Value<float> x190_;
Value<float> x194_;
Value<float> x198_;
Value<float> x19c_;
Value<float> x1a0_;
Value<float> x1a4_;
Value<atUint32> x1a8_[2];
Value<atUint32> x1b0_[2];
Value<atUint32> x1b8_[2];
Value<atUint32> x1c0_[2];
Value<atUint32> x1c8_[2];
Value<atUint32> x1d0_[2];
Value<float> x1d8_;
Value<float> x1dc_;
Value<float> x1e0_;
Value<float> x1e4_;
Value<float> x1e8_;
Value<float> x1ec_;
Value<float> x1f0_;
Value<float> x1f4_;
Value<float> x1f8_;
Value<float> x1fc_;
Value<bool> x200_24_ : 1;
Value<bool> x200_25_ : 1;
Value<float> x204_;
Value<float> x208_;
Value<float> x20c_;
Value<float> x210_;
Value<float> x214_;
Value<float> x218_;
Value<bool> x21c_24_ : 1;
Value<bool> x21c_25_ : 1;
Value<bool> x21c_26_ : 1;
Value<float> x220_;
Value<float> x224_;
Value<bool> x228_24_ : 1;
Value<bool> x228_25_ : 1;
Value<bool> x228_26_ : 1;
Value<bool> x228_27_ : 1;
Value<bool> x228_28_ : 1;
Value<bool> x228_29_ : 1;
Value<bool> x228_30_ : 1;
Value<bool> x228_31_ : 1;
Value<bool> x229_24_ : 1;
Value<bool> x229_25_ : 1;
Value<bool> x229_26_ : 1;
Value<bool> x229_27_ : 1;
Value<bool> x229_28_ : 1;
Value<bool> x229_29_ : 1;
Value<bool> x229_30_ : 1;
Value<bool> x229_31_ : 1;
Value<bool> x22a_24_ : 1;
Value<bool> x22a_25_ : 1;
Value<bool> x22a_26_ : 1;
Value<bool> x22a_27_ : 1;
Value<bool> x22a_28_ : 1;
Value<float> x22c_;
Value<float> x230_;
Value<float> x234_;
Value<float> x238_;
Value<float> x23c_;
Value<float> x240_;
Value<float> x244_;
Value<float> x248_;
Value<float> x24c_;
Value<float> x250_;
Value<float> x254_;
Value<float> x258_;
Value<float> x25c_;
Value<float> x260_;
Value<float> x264_;
Value<float> x268_;
Value<float> x26c_playerHeight;
Value<float> x270_playerXYHalfExtent;
Value<float> x274_;
Value<float> x278_;
Value<float> x27c_;
Value<float> x280_;
Value<float> x284_;
Value<float> x288_;
Value<float> x28c_;
Value<float> x290_;
Value<float> x294_;
Value<float> x298_;
Value<float> x29c_;
Value<float> x2a0_;
Value<float> x2a4_;
Value<float> x2a8_;
Value<float> x2ac_;
Value<float> x2b0_;
Value<float> x2b4_;
Value<float> x2b8_;
Value<float> x2bc_;
Value<float> x2c0_;
Value<float> x2c4_;
Value<float> x2c8_;
Value<float> x2cc_;
Value<atUint32> x2d0_;
Value<bool> x2d4_;
Value<bool> x2d5_;
Value<float> x2d8_;
Value<float> x2dc_;
Value<float> x2e0_;
Value<float> x2e4_;
Value<float> x2e8_;
Value<float> x2ec_;
Value<float> x2f0_;
Value<bool> x2f4_;
Value<float> x2f8_;
Value<atUint32> x2fc_;
Value<float> x300_;
Value<float> x304_;
Value<float> x308_;
float GetPlayerHeight() const { return x26c_playerHeight; }
float GetPlayerXYHalfExtent() const { return x270_playerXYHalfExtent; }
float GetPlayerSomething1() const { return x274_; }
float GetPlayerSomething2() const { return x278_; }
float GetPlayerSomething3() const { return x27c_; }
float GetPlayerSomething4() const { return x134_; }
bool GetPlayerSomething5() const { return x228_24_; }
float GetLeftLogicalThreshold() const {return x150_leftDiv;}
float GetRightLogicalThreshold() const {return x154_rightDiv;}
CTweakPlayer() = default;
CTweakPlayer(athena::io::IStreamReader& reader)
{
read(reader);
FixupValues();
}
void read(athena::io::IStreamReader& __dna_reader);
void write(athena::io::IStreamWriter& __dna_writer) const;
void read(athena::io::YAMLDocReader& __dna_docin);
void write(athena::io::YAMLDocWriter& __dna_docout) const;
void FixupValues();
static const char* DNAType();
const char* DNATypeV() const { return DNAType(); }
size_t binarySize(size_t __isz) const;
};
}

22
DataSpec/SpecMP1.cpp
View File

@ -22,7 +22,12 @@
#include "DNACommon/Tweaks/TweakWriter.hpp"
#include "DNAMP1/Tweaks/CTweakPlayerRes.hpp"
#include "DNAMP1/Tweaks/CTweakGunRes.hpp"
<<<<<<< HEAD
#include "DNAMP1/Tweaks/CTweakSlideShow.hpp"
=======
#include "DNAMP1/Tweaks/CTweakPlayer.hpp"
#include "DNAMP1/Tweaks/CTweakCameraBob.hpp"
>>>>>>> b27821c5eb1c9eb5b69acda11ab77c7cda018ca9
#include "hecl/ClientProcess.hpp"
@ -355,7 +360,13 @@ struct SpecMP1 : SpecBase
return true;
else if (!strcmp(classType, DNAMP1::CTweakGunRes::DNAType()))
return true;
<<<<<<< HEAD
else if (!strcmp(classType, DNAMP1::CTweakSlideShow::DNAType()))
=======
else if (!strcmp(classType, DNAMP1::CTweakPlayer::DNAType()))
return true;
else if (!strcmp(classType, DNAMP1::CTweakCameraBob::DNAType()))
>>>>>>> b27821c5eb1c9eb5b69acda11ab77c7cda018ca9
return true;
else if (!strcmp(classType, DNAMP1::HINT::DNAType()))
return true;
@ -515,6 +526,17 @@ struct SpecMP1 : SpecBase
DNAMP1::CTweakSlideShow slideShow;
slideShow.read(reader);
WriteTweak(slideShow, out);
else if (!classStr.compare(DNAMP1::CTweakPlayer::DNAType()))
{
DNAMP1::CTweakPlayer player;
player.read(reader);
WriteTweak(player, out);
}
else if (!classStr.compare(DNAMP1::CTweakCameraBob::DNAType()))
{
DNAMP1::CTweakCameraBob cBob;
cBob.read(reader);
WriteTweak(cBob, out);
}
else if (!classStr.compare(DNAMP1::HINT::DNAType()))
{

2
Editor/ProjectManager.cpp
View File

@ -131,7 +131,7 @@ makeProj:
m_factoryMP1.IndexMP1Resources(*m_proj);
m_mainMP1.emplace(m_factoryMP1, m_objStore, m_vm.m_mainBooFactory,
m_vm.m_mainCommandQueue, m_vm.m_renderTex, *m_vm.m_amuseAllocWrapper);
m_vm.m_mainCommandQueue, m_vm.m_renderTex);
m_vm.InitMP1(*m_mainMP1);
m_vm.BuildTestPART(m_objStore);

4
Editor/ProjectResourceFactoryMP1.cpp
View File

@ -141,7 +141,9 @@ SObjectTag ProjectResourceFactoryMP1::TagFromPath(const hecl::ProjectPath& path,
}
else if (!strcmp(className, "DataSpec::DNAMP1::CTweakPlayerRes") ||
!strcmp(className, "DataSpec::DNAMP1::CTweakGunRes") ||
!strcmp(className, "DataSpec::DNAMP1::CTweakSlideShow"))
!strcmp(className, "DataSpec::DNAMP1::CTweakSlideShow") ||
!strcmp(className, "DataSpec::DNAMP1::CTweakPlayer") ||
!strcmp(className, "DataSpec::DNAMP1::CTweakCameraBob"))
{
resTag.type = SBIG('CTWK');
return true;

2
Editor/ViewManager.cpp
View File

@ -77,7 +77,7 @@ void ViewManager::BuildTestPART(urde::IObjectStore& objStore)
void ViewManager::InitMP1(MP1::CMain& main)
{
main.Init(m_fileStoreManager, m_voiceEngine.get());
main.Init(m_fileStoreManager, m_voiceEngine.get(), *m_amuseAllocWrapper);
}
void ViewManager::ParticleView::resized(const boo::SWindowRect& root, const boo::SWindowRect& sub)

12
Runtime/CPlayerState.cpp
View File

@ -1,6 +1,9 @@
#include "CPlayerState.hpp"
#include "IOStreams.hpp"
#include "zeus/Math.hpp"
#include "CStateManager.hpp"
#include "Camera/CCameraManager.hpp"
#include "Camera/CFirstPersonCamera.hpp"
namespace urde
{
@ -201,13 +204,8 @@ bool CPlayerState::CanVisorSeeFog(const CStateManager& stateMgr) const
CPlayerState::EPlayerVisor CPlayerState::GetActiveVisor(const CStateManager& stateMgr) const
{
/* TODO: We need CGameCamera, and gang in order to enable this */
#if 0
CFirstPersionCamera* cam = dynamic_cast<CFirstPersonCamera*>(stateMgr.GetCameraManager()->GetCurrentCamera(stateMgr));
if (!cam)
return EVisorType::Combat;
#endif
return x14_currentVisor;
const CFirstPersonCamera* cam = static_cast<const CFirstPersonCamera*>(stateMgr.GetCameraManager()->GetCurrentCamera(stateMgr));
return (cam ? x14_currentVisor : EPlayerVisor::Combat);
}
void CPlayerState::UpdateStaticInterference(CStateManager& stateMgr, const float& dt)

10
Runtime/CStateManager.cpp
View File

@ -1,5 +1,7 @@
#include "CStateManager.hpp"
#include "Camera/CCameraShakeData.hpp"
#include "Camera/CGameCamera.hpp"
#include "Graphics/CBooRenderer.hpp"
#include "CSortedLists.hpp"
#include "CWeaponMgr.hpp"
#include "CFluidPlaneManager.hpp"
@ -301,8 +303,14 @@ void CStateManager::TouchSky() const
{
}
void CStateManager::DrawSpaceWarp(const zeus::CVector3f&, float) const
void CStateManager::DrawSpaceWarp(const zeus::CVector3f& v, float strength) const
{
CPlayerState::EPlayerVisor visor = x8b8_playerState->GetActiveVisor(*this);
if (visor == CPlayerState::EPlayerVisor::Scan || visor == CPlayerState::EPlayerVisor::Combat)
{
zeus::CVector3f screenV = x870_cameraManager->GetCurrentCamera(*this)->ConvertToScreenSpace(v);
g_Renderer->DrawSpaceWarp(screenV, strength);
}
}
void CStateManager::DrawReflection(const zeus::CVector3f&)

2
Runtime/CStateManager.hpp
View File

@ -283,7 +283,7 @@ public:
CWorld* GetWorld() {return x850_world.get();}
CRelayTracker* GetRelayTracker() { return x8bc_relayTracker.get(); }
CCameraManager* GetCameraManager() { return x870_cameraManager; }
CCameraManager* GetCameraManager() const { return x870_cameraManager; }
std::shared_ptr<CMapWorldInfo> MapWorldInfo() { return x8c0_mapWorldInfo; }

32
Runtime/Camera/CCameraManager.cpp
View File

@ -1,5 +1,6 @@
#include "CCameraManager.hpp"
#include "CCameraShakeData.hpp"
#include "CFirstPersonCamera.hpp"
#include "Audio/CSfxManager.hpp"
#include "CGameCamera.hpp"
#include "CStateManager.hpp"
@ -10,11 +11,9 @@
namespace urde
{
CCameraManager::CCameraManager(TUniqueId curCameraId)
: x0_curCameraId(curCameraId)
CCameraManager::CCameraManager(TUniqueId curCameraId) : x0_curCameraId(curCameraId)
{
CSfxManager::AddListener(CSfxManager::ESfxChannels::One,
zeus::CVector3f::skZero, zeus::CVector3f::skZero,
CSfxManager::AddListener(CSfxManager::ESfxChannels::One, zeus::CVector3f::skZero, zeus::CVector3f::skZero,
{1.f, 0.f, 0.f}, {0.f, 0.f, 1.f}, 50.f, 50.f, 1000.f, 1, 0x7f);
}
@ -32,7 +31,7 @@ zeus::CTransform CCameraManager::GetCurrentCameraTransform(const CStateManager&
void CCameraManager::RemoveCameraShaker(int id)
{
for (auto it=x18_shakers.begin() ; it != x18_shakers.end() ; ++it)
for (auto it = x18_shakers.begin(); it != x18_shakers.end(); ++it)
if (it->x20_shakerId == id)
{
x18_shakers.erase(it);
@ -47,10 +46,7 @@ int CCameraManager::AddCameraShaker(const CCameraShakeData& data)
return x2c_lastShakeId;
}
void CCameraManager::AddCinemaCamera(TUniqueId id, CStateManager& stateMgr)
{
x4_cineCameras.push_back(id);
}
void CCameraManager::AddCinemaCamera(TUniqueId id, CStateManager& stateMgr) { x4_cineCameras.push_back(id); }
void CCameraManager::SetInsideFluid(bool val, TUniqueId fluidId)
{
@ -67,11 +63,10 @@ void CCameraManager::Update(float dt, CStateManager& stateMgr)
{
const CGameCamera* camera = GetCurrentCamera(stateMgr);
zeus::CVector3f heading = camera->GetTransform().basis * zeus::CVector3f{0.f, 1.f, 0.f};
CSfxManager::UpdateListener(camera->GetTransform().origin, zeus::CVector3f::skZero,
heading, {0.f, 0.f, 1.f}, 0x7f);
CSfxManager::UpdateListener(camera->GetTransform().origin, zeus::CVector3f::skZero, heading, {0.f, 0.f, 1.f}, 0x7f);
x30_shakeOffset = zeus::CVector3f::skZero;
for (auto it=x18_shakers.begin() ; it != x18_shakers.end() ;)
for (auto it = x18_shakers.begin(); it != x18_shakers.end();)
{
if (it->x1c_curTime >= it->x18_duration)
{
@ -106,12 +101,11 @@ void CCameraManager::Update(float dt, CStateManager& stateMgr)
if (water)
{
// TODO: Finish
zeus::CColor tmpColor; // Get from water
zeus::CColor tmpColor; // Get from water
zeus::CVector2f tmpVector; // Get from camera
x3c_fog.SetFogExplicit(ERglFogMode::PerspExp, tmpColor, tmpVector);
stateMgr.GetCameraFilterPass(4).SetFilter(CCameraFilterPass::EFilterType::Multiply,
CCameraFilterPass::EFilterShape::Fullscreen,
0.f, tmpColor, -1);
CCameraFilterPass::EFilterShape::Fullscreen, 0.f, tmpColor, -1);
}
x86_26_inWater = true;
}
@ -137,6 +131,13 @@ const CGameCamera* CCameraManager::GetCurrentCamera(const CStateManager& stateMg
return static_cast<const CGameCamera*>(camList->GetObjectById(GetCurrentCameraId()));
}
float CCameraManager::sub80009148() const
{
const zeus::CVector3f uVec = x7c_fpCamera->GetTransform().upVector();
return 1.f - std::min(std::fabs(std::min(std::fabs(uVec.y * uVec.x * uVec.z * zeus::kUpVec.y + zeus::kUpVec.x +
zeus::kUpVec.z), 1.f) / std::cos(zeus::degToRad(30.f))), 1.f);
}
void CCameraManager::ResetCameras(CStateManager& mgr)
{
zeus::CTransform xf = mgr.GetPlayer().CreateTransformFromMovementDirection();
@ -148,5 +149,4 @@ void CCameraManager::ResetCameras(CStateManager& mgr)
camObj->Reset(xf, mgr);
}
}
}

2
Runtime/Camera/CCameraManager.hpp
View File

@ -73,6 +73,8 @@ public:
CFirstPersonCamera* GetFirstPersonCamera() { return x7c_fpCamera; }
CBallCamera* GetBallCamera() { return x80_ballCamera; }
float sub80009148() const;
};
}

53
Runtime/Camera/CFirstPersonCamera.cpp
View File

@ -1,11 +1,15 @@
#include "CFirstPersonCamera.hpp"
#include "GameGlobalObjects.hpp"
#include "Character/CCharLayoutInfo.hpp"
#include "CStateManager.hpp"
#include "World/CPlayer.hpp"
#include <math.h>
namespace urde
{
CFirstPersonCamera::CFirstPersonCamera(TUniqueId uid, const zeus::CTransform& xf, TUniqueId watchedObj,
float, float fov, float nearz, float farz, float aspect)
float f1, float fov, float nearz, float farz, float aspect)
: CGameCamera(uid, true, "First Person Camera",
CEntityInfo(kInvalidAreaId, CEntity::NullConnectionList),
xf, fov, nearz, farz, aspect, watchedObj, false, 0)
@ -20,4 +24,51 @@ void CFirstPersonCamera::Reset(const zeus::CTransform&, CStateManager& mgr)
{
}
void CFirstPersonCamera::sub800E318()
{
x1c8_ = zeus::CVector3f::skZero;
x1d4_ = 0.f;
}
zeus::CTransform CFirstPersonCamera::GetGunFollowTransform()
{
return x190_gunFollowXf;
}
void CFirstPersonCamera::UpdateTransform(CStateManager& mgr)
{
CPlayer* player = static_cast<CPlayer*>(mgr.ObjectById(GetWatchedObject()));
if (!player)
{
x34_transform = zeus::CTransform::Identity();
xe4_27_ = true;
xe4_28_ = true;
xe4_29_ = true;
return;
}
zeus::CTransform playerXf = player->GetTransform();
float rZ = std::sin(x1c0_);
if (std::fabs(rZ) > 1.0f)
rZ = (rZ > -0.f ? -1.0f : 1.0f);
float rY = std::cos(x1c0_);
if (std::fabs(rY) > 1.0f)
rY = (rY > -0.f ? -1.0f : 1.0f);
zeus::CVector3f rVec = playerXf.rotate({0.f, rY, rZ});
#if 1
if (player->x3dc_)
{
float f32 = g_tweakPlayer->GetPlayerSomething4();
}
#endif
}
void CFirstPersonCamera::UpdateElevation(CStateManager&)
{
}
}

23
Runtime/Camera/CFirstPersonCamera.hpp
View File

@ -8,11 +8,34 @@ namespace urde
class CFirstPersonCamera : public CGameCamera
{
float x188_;
u8 x18c_;
zeus::CTransform x190_gunFollowXf;
float x1c0_;
TUniqueId x1c4_;
union
{
struct
{
bool x1c6_24_ : 1;
};
u16 _dummy = 0;
};
zeus::CVector3f x1c8_;
float x1d4_ = 0.f;
public:
CFirstPersonCamera(TUniqueId, const zeus::CTransform& xf, TUniqueId, float, float, float, float, float);
void PreThink(float, CStateManager &);
void Think(float, CStateManager &);
void ProcessInput(const CFinalInput&, CStateManager& mgr);
void Reset(const zeus::CTransform&, CStateManager& mgr);
void sub800E318();
zeus::CTransform GetGunFollowTransform();
void UpdateTransform(CStateManager&);
void UpdateElevation(CStateManager&);
};
}

56
Runtime/Camera/CGameCamera.cpp
View File

@ -110,5 +110,59 @@ TUniqueId CGameCamera::GetWatchedObject() const { return xe8_watchedObject; }
float CGameCamera::GetFov() const { return x15c_fov; }
void CGameCamera::SetFov(float fov) { x15c_fov = fov; }
void CGameCamera::sub8005AE3C(float f1)
{
if (x174_ > 0.f)
{
x174_ -= f1;
return;
}
if (x178_ <= 0.f)
return;
x178_ -= f1;
if (x178_ > 0.f)
{
x15c_fov = x184_;
x170_24_perspDirty = true;
}
else
{
x15c_fov = zeus::clamp(0.f, (f1 / x17c_), 1.f) + ((x180_ - x184_) * x184_);
x170_24_perspDirty = true;
}
}
void CGameCamera::sub8005AF18(float f1, float f2, float f3, float f4)
{
if (f3 < 0.f)
{
x15c_fov = f2;
x170_24_perspDirty = true;
x184_ = f2;
x184_ = x174_ = 0.f;
}
else
{
x174_ = std::max(0.f, f4);
x17c_ = f3;
x178_ = f3;
x180_ = f1;
x184_ = f2;
x15c_fov = f1;
x170_24_perspDirty = true;
}
}
void CGameCamera::sub8005AF88()
{
if (x178_ > 0)
{
x15c_fov = x184_;
x170_24_perspDirty = true;
}
x178_ = x174_ = 0.f;
}
}

5
Runtime/Camera/CGameCamera.hpp
View File

@ -49,10 +49,11 @@ public:
float GetAspectRatio() const;
TUniqueId GetWatchedObject() const;
float GetFov() const;
void SetFov(float);
void GetControllerNumber() const;
bool DisablesInput() const;
void sub8005AE3C(float);
void sub8005AF18(float, float, float, float);
void sub8005AF88();
};
}

1
Runtime/GameGlobalObjects.cpp
View File

@ -5,6 +5,7 @@ namespace urde
namespace MP1
{
class CMain* g_Main = nullptr;
class CGameArchitectureSupport* g_archSupport = nullptr;
}
class CMemoryCardSys* g_MemoryCardSys = nullptr;

1
Runtime/GameGlobalObjects.hpp
View File

@ -16,6 +16,7 @@ namespace urde
namespace MP1
{
extern class CMain* g_Main;
extern class CGameArchitectureSupport* g_archSupport;
}
extern class CMemoryCardSys* g_MemoryCardSys;

4
Runtime/Graphics/Shaders/CTexturedQuadFilter.cpp
View File

@ -23,7 +23,7 @@ CTexturedQuadFilter::CTexturedQuadFilter(CCameraFilterPass::EFilterType type, bo
CTexturedQuadFilter::CTexturedQuadFilter(CCameraFilterPass::EFilterType type,
TLockedToken<CTexture> tex)
: CTexturedQuadFilter(type, tex->GetBooTexture())
: CTexturedQuadFilter(type, (tex ? tex->GetBooTexture() : nullptr))
{
m_tex = tex;
}
@ -93,7 +93,7 @@ CTexturedQuadFilterAlpha::CTexturedQuadFilterAlpha(CCameraFilterPass::EFilterTyp
CTexturedQuadFilterAlpha::CTexturedQuadFilterAlpha(CCameraFilterPass::EFilterType type,
TLockedToken<CTexture> tex)
: CTexturedQuadFilterAlpha(type, tex->GetBooTexture())
: CTexturedQuadFilterAlpha(type, (tex ? tex->GetBooTexture() : nullptr))
{
m_tex = tex;
}

33
Runtime/MP1/CMFGame.cpp
View File

@ -10,8 +10,24 @@ namespace urde
namespace MP1
{
CMFGameLoader::CMFGameLoader()
: CMFGameLoaderBase("CMFGameLoader")
CMFGame::CMFGame(const std::weak_ptr<CStateManager>& stateMgr, const std::weak_ptr<CInGameGuiManager>& guiMgr,
const CArchitectureQueue&)
: CMFGameBase("CMFGame"), x14_stateManager(stateMgr.lock()), x18_guiManager(guiMgr.lock()), x2a_25_(true)
{
//g_Main->x160_25_ = true;
}
CIOWin::EMessageReturn CMFGame::OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue)
{
return EMessageReturn::Normal;
}
void CMFGame::Draw() const
{
}
CMFGameLoader::CMFGameLoader() : CMFGameLoaderBase("CMFGameLoader")
{
switch (g_Main->GetFlowState())
{
@ -19,8 +35,8 @@ CMFGameLoader::CMFGameLoader()
case CMain::FlowState::Six:
{
ResId mlvlId = g_GameState->CurrentWorldAssetId();
//g_GameState->WorldTransitionManager()->
//g_MemoryCardSys->
// g_GameState->WorldTransitionManager()->
// g_MemoryCardSys->
}
default:
{
@ -38,15 +54,12 @@ CIOWin::EMessageReturn CMFGameLoader::OnMessage(const CArchitectureMessage& msg,
{
const CArchMsgParmReal32& tick = MakeMsg::GetParmTimerTick(msg);
}
default: break;
default:
break;
}
return EMessageReturn::Exit;
}
void CMFGameLoader::Draw() const
{
g_GameState->GetWorldTransitionManager()->Draw();
}
void CMFGameLoader::Draw() const { g_GameState->GetWorldTransitionManager()->Draw(); }
}
}

17
Runtime/MP1/CMFGame.hpp
View File

@ -14,8 +14,23 @@ namespace MP1
class CMFGame : public CMFGameBase
{
std::shared_ptr<CStateManager> x14_stateManager;
std::shared_ptr<CInGameGuiManager> x18_guiManager;
u32 x1c_ = 0;
u32 x24_ = 0;
TUniqueId x28_ = kInvalidUniqueId;
union
{
struct
{
bool x2a_24_ : 1;
bool x2a_25_ : 1;
};
u8 _dummy = 0;
};
public:
CMFGame() : CMFGameBase("CMFGame") {}
CMFGame(const std::weak_ptr<CStateManager>& stateMgr, const std::weak_ptr<CInGameGuiManager>& guiMgr,
const CArchitectureQueue&);
CIOWin::EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue);
void Draw() const;
};

12
Runtime/MP1/CTweaks.cpp
View File

@ -10,7 +10,11 @@
#include "DataSpec/DNAMP1/Tweaks/CTweakPlayerControl.hpp"
#include "DataSpec/DNAMP1/Tweaks/CTweakGunRes.hpp"
#include "DataSpec/DNAMP1/Tweaks/CTweakPlayerRes.hpp"
<<<<<<< HEAD
#include "DataSpec/DNAMP1/Tweaks/CTweakSlideShow.hpp"
=======
#include "World/CPlayerCameraBob.hpp"
>>>>>>> b27821c5eb1c9eb5b69acda11ab77c7cda018ca9
namespace urde
{
@ -36,6 +40,14 @@ void CTweaks::RegisterTweaks()
SObjectTag tag = factory.ProjectResourceFactoryBase::TagFromPath(_S("MP1/Tweaks/SlideShow.yaml"));
strm.emplace(factory.LoadResourceSync(tag).release(), factory.ResourceSize(tag));
g_tweakSlideShow = new DataSpec::DNAMP1::CTweakSlideShow(*strm);
tag = factory.ProjectResourceFactoryBase::TagFromPath(_S("MP1/Tweaks/Player.yaml"));
strm.emplace(factory.LoadResourceSync(tag).release(), factory.ResourceSize(tag));
g_tweakPlayer = new DataSpec::DNAMP1::CTweakPlayer(*strm);
tag = factory.ProjectResourceFactoryBase::TagFromPath(_S("MP1/Tweaks/CameraBob.yaml"));
strm.emplace(factory.LoadResourceSync(tag).release(), factory.ResourceSize(tag));
CPlayerCameraBob::ReadTweaks(*strm);
}
void CTweaks::RegisterResourceTweaks()

19
Runtime/MP1/MP1.cpp
View File

@ -25,8 +25,8 @@ namespace MP1
CGameArchitectureSupport::CGameArchitectureSupport(amuse::IBackendVoiceAllocator& backend)
: m_audioSys(backend, 0,0,0,0,0),
m_inputGenerator(0.0f /*g_tweakPlayer->GetLeftLogicalThreshold()*/,
0.0f /*g_tweakPlayer->GetRightLogicalThreshold()*/),
m_inputGenerator(g_tweakPlayer->GetLeftLogicalThreshold(),
g_tweakPlayer->GetRightLogicalThreshold()),
m_guiSys(*g_ResFactory, *g_SimplePool, CGuiSys::EUsageMode::Zero)
{
g_GuiSys = &m_guiSys;
@ -90,11 +90,9 @@ void CGameArchitectureSupport::Draw()
CMain::CMain(IFactory& resFactory, CSimplePool& resStore,
boo::IGraphicsDataFactory* gfxFactory,
boo::IGraphicsCommandQueue* cmdQ,
boo::ITextureR* spareTex,
amuse::IBackendVoiceAllocator& backend)
boo::ITextureR* spareTex)
: m_booSetter(gfxFactory, cmdQ, spareTex),
x128_globalObjects(resFactory, resStore),
m_archSupport(backend)
x128_globalObjects(resFactory, resStore)
{
xe4_gameplayResult = EGameplayResult::Playing;
g_Main = this;
@ -141,25 +139,28 @@ void CMain::LoadAudio()
}
void CMain::Init(const hecl::Runtime::FileStoreManager& storeMgr,
boo::IAudioVoiceEngine* voiceEngine)
boo::IAudioVoiceEngine* voiceEngine,
amuse::IBackendVoiceAllocator& backend)
{
InitializeSubsystems(storeMgr, voiceEngine);
x128_globalObjects.PostInitialize();
x70_tweaks.RegisterTweaks();
x70_tweaks.RegisterResourceTweaks();
m_archSupport.reset(new CGameArchitectureSupport(backend));
g_archSupport = m_archSupport.get();
//g_TweakManager->ReadFromMemoryCard("AudioTweaks");
FillInAssetIDs();
}
bool CMain::Proc()
{
xe8_b24_finished = m_archSupport.Update();
xe8_b24_finished = m_archSupport->Update();
return xe8_b24_finished;
}
void CMain::Draw()
{
m_archSupport.Draw();
m_archSupport->Draw();
}
void CMain::Shutdown()

9
Runtime/MP1/MP1.hpp
View File

@ -146,6 +146,7 @@ class CGameArchitectureSupport
public:
CGameArchitectureSupport(amuse::IBackendVoiceAllocator& backend);
void PreloadAudio();
bool Update();
void Draw();
@ -203,7 +204,7 @@ private:
/* urde addition: these are simply initialized along with everything else */
CGameGlobalObjects x128_globalObjects;
CGameArchitectureSupport m_archSupport;
std::unique_ptr<CGameArchitectureSupport> m_archSupport;
FlowState x12c_ = FlowState::Five;
@ -235,8 +236,7 @@ public:
CMain(IFactory& resFactory, CSimplePool& resStore,
boo::IGraphicsDataFactory* gfxFactory,
boo::IGraphicsCommandQueue* cmdQ,
boo::ITextureR* spareTex,
amuse::IBackendVoiceAllocator& backend);
boo::ITextureR* spareTex);
void RegisterResourceTweaks();
void ResetGameState();
void StreamNewGameState(CInputStream&);
@ -244,7 +244,8 @@ public:
//int RsMain(int argc, const boo::SystemChar* argv[]);
void Init(const hecl::Runtime::FileStoreManager& storeMgr,
boo::IAudioVoiceEngine* voiceEngine);
boo::IAudioVoiceEngine* voiceEngine,
amuse::IBackendVoiceAllocator& backend);
bool Proc();
void Draw();
void Shutdown();

7
Runtime/World/CPlayer.hpp
View File

@ -15,11 +15,14 @@ class CDamageInfo;
class CScriptWater;
class IVisitor;
class CFinalInput;
class CPlayerCameraBob;
class CFirstPersonCamera;
class CPlayer : public CPhysicsActor
{
friend class CStateManager;
friend class CFirstPersonCamera;
friend class CPlayerCameraBob;
public:
enum class EPlayerScanState
{
@ -72,9 +75,11 @@ private:
: x0_(a), x4_(b), x8_(c), xc_(d), x1c_(e) {}
};
bool x38c_;
bool x3dc_;
std::unique_ptr<CPlayerGun> x490_gun;
std::unique_ptr<CMorphBall> x768_morphball;
std::unique_ptr<CPlayerCameraBob> x76c_cameraBob;
public:
CPlayer(TUniqueId, const zeus::CTransform&, const zeus::CAABox&, unsigned int,
const zeus::CVector3f&, float, float, float, float, const CMaterialList&);

235
Runtime/World/CPlayerCameraBob.cpp
View File

@ -1,10 +1,243 @@
#include "CPlayerCameraBob.hpp"
#include "World/CPlayer.hpp"
#include "CStateManager.hpp"
#include "Camera/CCameraManager.hpp"
#include "zeus/Math.hpp"
namespace urde
{
float CPlayerCameraBob::kCameraBobExtentX = 0.071f;
float CPlayerCameraBob::kCameraBobExtentY = 0.142f;
float CPlayerCameraBob::kCameraBobPeriod = 0.47f;
float CPlayerCameraBob::kOrbitBobScale = 0.769f;
float CPlayerCameraBob::kMaxOrbitBobScale = 0.8f;
float CPlayerCameraBob::kSlowSpeedPeriodScale = 0.3f;
float CPlayerCameraBob::kTargetMagnitudeTrackingRate = 0.1f;
float CPlayerCameraBob::kLandingBobSpringConstant = 150.f;
float CPlayerCameraBob::kViewWanderRadius = 2.9f;
float CPlayerCameraBob::kViewWanderSpeedMin = 0.1f;
float CPlayerCameraBob::kViewWanderSpeedMax = 0.3f;
float CPlayerCameraBob::kViewWanderRollVariation = 0.3f;
float CPlayerCameraBob::kGunBobMagnitude = 0.3f;
float CPlayerCameraBob::kHelmetBobMagnitude = 2.f;
const float CPlayerCameraBob::kLandingBobDamping = 2.f * zeus::sqrtF(150.f);
CPlayerCameraBob::CPlayerCameraBob(ECameraBobType type, const zeus::CVector2f& vec, float)
CPlayerCameraBob::CPlayerCameraBob(ECameraBobType type, const zeus::CVector2f& vec, float f1)
: x0_type(type), x4_vec(vec), xc_(f1)
{
}
zeus::CTransform CPlayerCameraBob::GetViewWanderTransform() const { return xd0_viewWanderXf; }
zeus::CVector3f CPlayerCameraBob::GetHelmetBobTranslation() const
{
return {kHelmetBobMagnitude * x2c_cameraBobTransform.origin.x,
kHelmetBobMagnitude * x2c_cameraBobTransform.origin.y,
kHelmetBobMagnitude * (x2c_cameraBobTransform.origin.z - x78_)};
}
zeus::CTransform CPlayerCameraBob::GetGunBobTransformation() const
{
return zeus::CTransform::Translate((1.f + kGunBobMagnitude) * x2c_cameraBobTransform.origin);
}
zeus::CTransform CPlayerCameraBob::GetCameraBobTransformation() const { return x2c_cameraBobTransform; }
void CPlayerCameraBob::SetPlayerVelocity(const zeus::CVector3f& velocity)
{
x5c_playerVelocity = velocity;
x68_ = zeus::min(x68_, velocity.z);
}
void CPlayerCameraBob::SetBobMagnitude(float magnitude) { x10_bobMagnitude = zeus::clamp(0.f, magnitude, 1.f); }
void CPlayerCameraBob::SetBobTimeScale(float ts) { x18_bobTimeScale = zeus::clamp(0.f, ts, 1.f); }
void CPlayerCameraBob::ResetCameraBobTime() { x1c_bobTime = 0.f; }
void CPlayerCameraBob::SetState(CPlayerCameraBob::ECameraBobState state, CStateManager& mgr)
{
if (x24_curState == state)
return;
x20_oldState = x24_curState;
x24_curState = state;
if (x20_oldState == ECameraBobState::Two)
{
x28_applyLandingTrans = true;
x68_ = std::min(x68_, -35.f);
x29_ = (x68_ >= -30.f);
if (x29_)
x74_ += x68_;
else
{
x6c_ += x68_;
x68_ = 0.f;
}
}
if (x24_curState == ECameraBobState::Three && x100_ != 0.f)
InitViewWander(mgr);
}
void CPlayerCameraBob::InitViewWander(CStateManager& mgr)
{
x7c_wanderPoints[0] = {0.f, 1.f, 0.f};
x7c_wanderPoints[1] = x7c_wanderPoints[0];
x7c_wanderPoints[2] = x7c_wanderPoints[0];
x7c_wanderPoints[3] = CalculateRandomViewWanderPosition(mgr);
xb0_wanderPitches[0] = 0.f;
xb0_wanderPitches[1] = xb0_wanderPitches[0];
xb0_wanderPitches[2] = xb0_wanderPitches[0];
xb0_wanderPitches[3] = CalculateRandomViewWanderPitch(mgr);
xc8_viewWanderSpeed =
(kViewWanderSpeedMax - kViewWanderRadius) * kViewWanderRadius + mgr.GetActiveRandom()->Float();
xc4_wanderTime = 0.f;
xcc_wanderIndex = 0;
}
void CPlayerCameraBob::UpdateViewWander(float dt, CStateManager& mgr)
{
zeus::CVector3f pt = zeus::getCatmullRomSplinePoint(
x7c_wanderPoints[xcc_wanderIndex], x7c_wanderPoints[(xcc_wanderIndex + 1) & 3],
x7c_wanderPoints[(xcc_wanderIndex + 2) & 3], x7c_wanderPoints[(xcc_wanderIndex + 3) & 3], dt);
pt.x *= x100_;
pt.z *= x100_;
zeus::CTransform orient = zeus::CTransform::RotateY((
zeus::getCatmullRomSplinePoint(xb0_wanderPitches[xcc_wanderIndex], xb0_wanderPitches[(xcc_wanderIndex + 1) & 3],
xb0_wanderPitches[(xcc_wanderIndex + 2) & 3],
xb0_wanderPitches[(xcc_wanderIndex + 3) & 3], dt) *
x100_));
xd0_viewWanderXf = zeus::lookAt(pt, zeus::CVector3f::skZero, zeus::kUpVec) * orient;
xc4_wanderTime = (xc8_viewWanderSpeed * xc4_wanderTime) + dt;
if (xc4_wanderTime > 1.f)
{
x7c_wanderPoints[xcc_wanderIndex] = CalculateRandomViewWanderPosition(mgr);
xb0_wanderPitches[xcc_wanderIndex] = CalculateRandomViewWanderPitch(mgr);
xc8_viewWanderSpeed =
((kViewWanderSpeedMax - kViewWanderSpeedMin) * kViewWanderSpeedMin) + mgr.GetActiveRandom()->Float();
xcc_wanderIndex = (xcc_wanderIndex + 1) & 3;
xc4_wanderTime -= 1.f;
}
}
void CPlayerCameraBob::Update(float dt, CStateManager& mgr)
{
x1c_bobTime = (dt * x1c_bobTime) + x18_bobTimeScale;
float landSpring = kLandingBobSpringConstant;
float landDampen = kLandingBobDamping;
if (x28_applyLandingTrans)
{
landDampen = 4.f * zeus::sqrtF(40.f);
landSpring = 40.f;
}
x6c_ = dt * x6c_ + -(landSpring * -(landDampen * x6c_) - x28_applyLandingTrans);
x70_landingTranslation = x6c_ * x28_applyLandingTrans + dt;
x74_ = dt * x74_ + -(80.f * -((6.f * zeus::sqrtF(80.f)) * x74_) - x78_);
x78_ = x74_ * x78_ + dt;
if (std::fabs(x6c_) < 0.0049f && std::fabs(x70_landingTranslation) < 0.0049f && std::fabs(x78_) < 0.0049f)
{
x28_applyLandingTrans = false;
x28_applyLandingTrans = 0.f;
x78_ = 0.f;
}
if (x24_curState == ECameraBobState::Three)
x104_ = 1.f;
else
x104_ = 0.f;
float f1 = mgr.GetCameraManager()->sub80009148();
x70_landingTranslation *= f1;
x78_ *= f1;
x104_ *= f1;
if (mgr.GetPlayer().x38c_)
{
x70_landingTranslation *= 0.2f;
x78_ *= 0.2f;
x104_ *= 0.4f;
}
x100_ = kTargetMagnitudeTrackingRate * x100_ + (x104_ - x100_);
x100_ = std::max(x100_, 0.f);
float tmp = x14_;
x14_ = kTargetMagnitudeTrackingRate * tmp + (x10_bobMagnitude - tmp);
UpdateViewWander(dt, mgr);
x78_ = tmp;
x2c_cameraBobTransform = GetViewWanderTransform() * CalculateCameraBobTransformation() *
zeus::lookAt(zeus::CVector3f::skZero, {0.f, 2.f, x78_}, zeus::kUpVec);
}
zeus::CVector3f CPlayerCameraBob::CalculateRandomViewWanderPosition(CStateManager& mgr)
{
const float angle = (2.f * (M_PIF * mgr.GetActiveRandom()->Float()));
const float bias = kViewWanderRadius * mgr.GetActiveRandom()->Float();
return {(bias * std::sin(angle)), 1.f, (bias * std::cos(angle))};
}
float CPlayerCameraBob::CalculateRandomViewWanderPitch(CStateManager& mgr)
{
return zeus::degToRad((2.f * (mgr.GetActiveRandom()->Float() - 0.5f)) * kViewWanderRollVariation);
}
void CPlayerCameraBob::CalculateMovingTranslation(float& x, float& y) const
{
if (x0_type == ECameraBobType::Zero)
{
double c = ((M_PIF * 2.f) * std::fmod(x1c_bobTime, 2.0f * xc_) / xc_);
x = (x14_ * x4_vec.x) * std::sin(c);
y = (x14_ * x4_vec.y) * (std::fabs(std::cos(c * .5)) * std::cos(c * .5));
}
else if (x0_type == ECameraBobType::One)
{
float fX = std::fmod(x1c_bobTime, 2.f * xc_);
if (fX > xc_)
x = (2.f - (fX / xc_)) * (x14_ * x4_vec.x);
else
x = ((fX / xc_)) * (x14_ * x4_vec.x);
float sY = std::sin(std::fmod((M_PI * fX) / xc_, M_PI));
y = (((1.f - sY) * (x14_ * x4_vec.y)) * (0.5f * (-((sY * 1.f) - sY) * (x14_ * x4_vec.y)))) + 0.5f;
}
}
float CPlayerCameraBob::CalculateLandingTranslation() const { return x70_landingTranslation; }
zeus::CTransform CPlayerCameraBob::CalculateCameraBobTransformation() const
{
float x = 0.f;
float y = 0.f;
CalculateMovingTranslation(x, y);
if (x28_applyLandingTrans)
y += CalculateLandingTranslation();
return zeus::CTransform::Translate(x, 0.f, y);
}
void CPlayerCameraBob::ReadTweaks(CInputStream& in)
{
if (in.hasError())
return;
kCameraBobExtentX = in.readFloatBig();
kCameraBobExtentY = in.readFloatBig();
kCameraBobPeriod = in.readFloatBig();
kOrbitBobScale = in.readFloatBig();
kMaxOrbitBobScale = in.readFloatBig();
kSlowSpeedPeriodScale = in.readFloatBig();
kTargetMagnitudeTrackingRate = in.readFloatBig();
kLandingBobSpringConstant = in.readFloatBig();
kViewWanderRadius = in.readFloatBig();
kViewWanderSpeedMin = in.readFloatBig();
kViewWanderSpeedMax = in.readFloatBig();
kViewWanderRollVariation = in.readFloatBig();
kGunBobMagnitude = in.readFloatBig();
kHelmetBobMagnitude = in.readFloatBig();
}
}

82
Runtime/World/CPlayerCameraBob.hpp
View File

@ -9,6 +9,7 @@
namespace urde
{
class CStateManager;
class CPlayerCameraBob
{
public:
@ -17,37 +18,84 @@ public:
Zero,
One
};
enum class ECameraBobState
{
Zero,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight
};
private:
static float kCameraBobExtentX;
static float kCameraBobExtentY;
static float kCameraBobPeriod;
static float kOrbitBobScale;
static float kMaxOrbitBobScale;
static float kSlowSpeedPeriodScale;
static float kTargetMagnitudeTrackingRate;
static float kLandingBobSpringConstant;
static float kViewWanderRadius;
static float kViewWanderSpeedMin;
static float kViewWanderSpeedMax;
static float kViewWanderRollVariation;
static float kGunBobMagnitude;
static float kHelmetBobMagnitude;
static const float kLandingBobDamping;
ECameraBobType x0_type;
zeus::CVector2f x4_vec;
float xc_;
float x10_ = 0.f;
float x10_bobMagnitude = 0.f;
float x14_ = 0.f;
float x18_ = 0.f;
float x1c_ = 0.f;
u32 x20_ = 8;
u32 x24_ = 8;
bool x28_ = false;
float x18_bobTimeScale = 0.f;
float x1c_bobTime = 0.f;
ECameraBobState x20_oldState = ECameraBobState::Eight;
ECameraBobState x24_curState = ECameraBobState::Eight;
bool x28_applyLandingTrans = false;
bool x29_ = false;
zeus::CTransform x2c_;
float x5c_ = 0.f;
float x60_ = 0.f;
float x64_ = 0.f;
zeus::CTransform x2c_cameraBobTransform;
zeus::CVector3f x5c_playerVelocity;
float x68_ = 0.f;
float x6c_ = 0.f;
float x70_ = 0.f;
float x70_landingTranslation = 0.f;
float x74_ = 0.f;
float x78_ = 0.f;
zeus::CVector3f x7c_[4] = {zeus::CVector3f{0.f, 1.f, 0.f}};
float xb0_[4] = {0.f};
float xc4_ = 0.f;
float xc8_ = 0.1f;
u32 xcc_ = 0;
zeus::CTransform xd0_;
zeus::CVector3f x7c_wanderPoints[4] = {zeus::CVector3f{0.f, 1.f, 0.f}};
float xb0_wanderPitches[4] = {0.f};
float xc4_wanderTime = 0.f;
float xc8_viewWanderSpeed = kViewWanderSpeedMin;
u32 xcc_wanderIndex = 0;
zeus::CTransform xd0_viewWanderXf;
float x100_ = FLT_EPSILON;
float x104_ = 0.f;
public:
CPlayerCameraBob(ECameraBobType type, const zeus::CVector2f& vec, float);
zeus::CTransform GetViewWanderTransform() const;
zeus::CVector3f GetHelmetBobTranslation() const;
zeus::CTransform GetGunBobTransformation() const;
zeus::CTransform GetCameraBobTransformation() const;
void SetPlayerVelocity(const zeus::CVector3f& velocity);
void SetBobMagnitude(float);
void SetBobTimeScale(float);
void ResetCameraBobTime();
void SetState(ECameraBobState, CStateManager&);
void InitViewWander(CStateManager&);
void UpdateViewWander(float, CStateManager&);
void Update(float, CStateManager &);
zeus::CVector3f CalculateRandomViewWanderPosition(CStateManager&);
float CalculateRandomViewWanderPitch(CStateManager&);
void CalculateMovingTranslation(float& x, float& y) const;
float CalculateLandingTranslation() const;
zeus::CTransform CalculateCameraBobTransformation() const;
static void ReadTweaks(CInputStream& in);
};
}