From 0f3e4b4a383c947db174f01740070ef25f5294b0 Mon Sep 17 00:00:00 2001 From: Phillip Stephens Date: Thu, 26 Jan 2017 02:06:18 -0800 Subject: [PATCH] Tweak Imps --- DataSpec/DNACommon/CMakeLists.txt | 5 +- .../DNACommon/Tweaks/ITweakAutoMapper.hpp | 15 + DataSpec/DNACommon/Tweaks/ITweakBall.hpp | 14 + DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp | 13 + DataSpec/DNAMP1/CMakeLists.txt | 8 +- DataSpec/DNAMP1/DNAMP1.cpp | 15 + DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.cpp | 0 DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp | 90 ++ DataSpec/DNAMP1/Tweaks/CTweakBall.cpp | 935 ++++++++++++++++++ DataSpec/DNAMP1/Tweaks/CTweakBall.hpp | 121 +++ DataSpec/DNAMP1/Tweaks/CTweakGui.hpp | 51 +- DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp | 145 +++ DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp | 1 + .../DNAMP1/Tweaks/CTweakPlayerControl.hpp | 1 + DataSpec/SpecMP1.cpp | 66 +- Editor/ProjectResourceFactoryBase.cpp | 3 +- Runtime/AutoMapper/CMakeLists.txt | 3 +- Runtime/AutoMapper/CMappableObject.cpp | 1 - Runtime/AutoMapper/CMappableObject.hpp | 3 +- Runtime/AutoMapper/ITweakAutoMapper.hpp | 17 - Runtime/CScannableObjectInfo.cpp | 1 - Runtime/GameGlobalObjects.cpp | 25 +- Runtime/GameGlobalObjects.hpp | 47 +- Runtime/GuiSys/CMakeLists.txt | 111 +-- Runtime/GuiSys/CTargetingManager.cpp | 0 Runtime/GuiSys/CTargetingManager.hpp | 0 Runtime/GuiSys/CTextParser.cpp | 4 +- Runtime/GuiSys/ITweakGui.hpp | 18 - Runtime/MP1/CMakeLists.txt | 3 - Runtime/MP1/CTweaks.cpp | 32 + Runtime/MP1/Tweaks/CTweakAutoMapper.cpp | 81 -- Runtime/MP1/Tweaks/CTweakAutoMapper.hpp | 95 -- Runtime/MP1/Tweaks/CTweakGui.cpp | 215 ---- Runtime/MP1/Tweaks/CTweakGui.hpp | 198 ---- Runtime/MP1/Tweaks/CTweakPlayer.cpp | 182 ---- Runtime/MP1/Tweaks/CTweakPlayer.hpp | 202 ---- 36 files changed, 1574 insertions(+), 1147 deletions(-) create mode 100644 DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp create mode 100644 DataSpec/DNACommon/Tweaks/ITweakBall.hpp create mode 100644 DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp create mode 100644 DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.cpp create mode 100644 DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp create mode 100644 DataSpec/DNAMP1/Tweaks/CTweakBall.cpp create mode 100644 DataSpec/DNAMP1/Tweaks/CTweakBall.hpp create mode 100644 DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp delete mode 100644 Runtime/AutoMapper/ITweakAutoMapper.hpp create mode 100644 Runtime/GuiSys/CTargetingManager.cpp create mode 100644 Runtime/GuiSys/CTargetingManager.hpp delete mode 100644 Runtime/GuiSys/ITweakGui.hpp delete mode 100644 Runtime/MP1/Tweaks/CTweakAutoMapper.cpp delete mode 100644 Runtime/MP1/Tweaks/CTweakAutoMapper.hpp delete mode 100644 Runtime/MP1/Tweaks/CTweakGui.cpp delete mode 100644 Runtime/MP1/Tweaks/CTweakGui.hpp delete mode 100644 Runtime/MP1/Tweaks/CTweakPlayer.cpp delete mode 100644 Runtime/MP1/Tweaks/CTweakPlayer.hpp diff --git a/DataSpec/DNACommon/CMakeLists.txt b/DataSpec/DNACommon/CMakeLists.txt index 731a76125..15f3408ec 100644 --- a/DataSpec/DNACommon/CMakeLists.txt +++ b/DataSpec/DNACommon/CMakeLists.txt @@ -42,7 +42,10 @@ set(DNACOMMON_SOURCES Tweaks/ITweakPlayerRes.hpp Tweaks/ITweakGui.hpp Tweaks/ITweakSlideShow.hpp - Tweaks/ITweakTargeting.hpp) + Tweaks/ITweakTargeting.hpp + Tweaks/ITweakAutoMapper.hpp + Tweaks/ITweakBall.hpp + Tweaks/ITweakGuiColors.hpp) dataspec_add_list(DNACommon DNACOMMON_SOURCES) list(APPEND DNACOMMON_SOURCES ${liblist}) diff --git a/DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp b/DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp new file mode 100644 index 000000000..7e7e89433 --- /dev/null +++ b/DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp @@ -0,0 +1,15 @@ +#ifndef __DNACOMMON_ITWEAKAUTOMAPPER_HPP__ +#define __DNACOMMON_ITWEAKAUTOMAPPER_HPP__ + +#include "ITweak.hpp" + +namespace DataSpec +{ +struct ITweakAutoMapper : public ITweak +{ + virtual const zeus::CVector3f& GetDoorCenter() const=0; +}; +} + + +#endif // __DNACOMMON_ITWEAKAUTOMAPPER_HPP__ diff --git a/DataSpec/DNACommon/Tweaks/ITweakBall.hpp b/DataSpec/DNACommon/Tweaks/ITweakBall.hpp new file mode 100644 index 000000000..5a85d0cfc --- /dev/null +++ b/DataSpec/DNACommon/Tweaks/ITweakBall.hpp @@ -0,0 +1,14 @@ +#ifndef __DNACOMMON_ITWEAKBALL_HPP__ +#define __DNACOMMON_ITWEAKBALL_HPP__ + +#include "ITweak.hpp" + +namespace DataSpec +{ +struct ITweakBall : ITweak +{ + +}; +} + +#endif // __DNACOMMON_ITWEAKBALL_HPP__ diff --git a/DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp b/DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp new file mode 100644 index 000000000..c6bd392aa --- /dev/null +++ b/DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp @@ -0,0 +1,13 @@ +#ifndef __DNACOMMON_ITWEAKGUICOLORS_HPP__ +#define __DNACOMMON_ITWEAKGUICOLORS_HPP__ + +#include "../DNACommon.hpp" + +namespace DataSpec +{ +struct ITweakGuiColors : BigYAML +{ +}; +} + +#endif // __DNACOMMON_ITWEAKGUICOLORS_HPP__ diff --git a/DataSpec/DNAMP1/CMakeLists.txt b/DataSpec/DNAMP1/CMakeLists.txt index 631e93233..98438d243 100644 --- a/DataSpec/DNAMP1/CMakeLists.txt +++ b/DataSpec/DNAMP1/CMakeLists.txt @@ -29,7 +29,10 @@ make_dnalist(liblist DNAMP1 Tweaks/CTweakGui Tweaks/CTweakSlideShow Tweaks/CTweakCameraBob - Tweaks/CTweakTargeting) + Tweaks/CTweakTargeting + Tweaks/CTweakAutoMapper + Tweaks/CTweakBall + Tweaks/CTweakGuiColors) set(DNAMP1_SOURCES DNAMP1.hpp DNAMP1.cpp @@ -50,7 +53,8 @@ set(DNAMP1_SOURCES FRME.cpp DeafBabe.cpp Tweaks/CTweakPlayer.cpp - Tweaks/CTweakTargeting.cpp) + Tweaks/CTweakTargeting.cpp + Tweaks/CTweakBall.cpp) dataspec_add_list(DNAMP1 DNAMP1_SOURCES) list(APPEND DNAMP1_SOURCES ${liblist}) diff --git a/DataSpec/DNAMP1/DNAMP1.cpp b/DataSpec/DNAMP1/DNAMP1.cpp index 594fdd5d2..20a6299b3 100644 --- a/DataSpec/DNAMP1/DNAMP1.cpp +++ b/DataSpec/DNAMP1/DNAMP1.cpp @@ -34,7 +34,12 @@ #include "Tweaks/CTweakSlideShow.hpp" #include "Tweaks/CTweakGame.hpp" #include "Tweaks/CTweakTargeting.hpp" +#include "Tweaks/CTweakAutoMapper.hpp" #include "Tweaks/CTweakGui.hpp" +#include "Tweaks/CTweakPlayerControl.hpp" +#include "Tweaks/CTweakBall.hpp" +#include "Tweaks/CTweakParticle.hpp" +#include "Tweaks/CTweakGuiColors.hpp" namespace DataSpec { @@ -391,6 +396,16 @@ ResExtractor PAKBridge::LookupExtractor(const PAK& pak, const PAK::En return {ExtractTweak, {_S(".yaml")}}; if (!name.compare("Gui")) return {ExtractTweak, {_S(".yaml")}}; + if (!name.compare("AutoMapper")) + return {ExtractTweak, {_S(".yaml")}}; + if (!name.compare("PlayerControls") || !name.compare("PlayerControls2")) + return {ExtractTweak, {_S(".yaml")}}; + if (!name.compare("Ball")) + return {ExtractTweak, {_S(".yaml")}}; + if (!name.compare("Particle")) + return {ExtractTweak, {_S(".yaml")}}; + if (!name.compare("GuiColors")) + return {ExtractTweak, {_S(".yaml")}}; } break; } diff --git a/DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.cpp b/DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.cpp new file mode 100644 index 000000000..e69de29bb diff --git a/DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp b/DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp new file mode 100644 index 000000000..23b7bc72d --- /dev/null +++ b/DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp @@ -0,0 +1,90 @@ +#ifndef __DNAMP1_CTWEAKAUTOMAPPER_HPP__ +#define __DNAMP1_CTWEAKAUTOMAPPER_HPP__ + +#include "../../DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp" +#include "zeus/CVector3f.hpp" + +namespace DataSpec +{ +namespace DNAMP1 +{ +struct CTweakAutoMapper : public ITweakAutoMapper +{ + DECL_YAML + Value x4_24_ : 1; + Value x4_25_ : 1; + Value x4_26_ : 1; + Value x8_; + Value xc_; + Value x10_; + Value x14_; + Value x18_; + Value x1c_; + Value x20_; + DNAColor x24_; + Value x28_; + Value x2c_; + Value x30_; + Value x34_; + DNAColor x38_; + DNAColor x3c_; + DNAColor x40_; + DNAColor x44_; + DNAColor x48_; + DNAColor x4c_; + DNAColor x50_; + Value x54_; + Value x58_; + Value x5c_; + float x60_ = 0.4f; + Value x64_; + Value x68_; + Value x6c_; + Value x70_; + Value x74_; + Value x78_; + DNAColor x7c_; + DNAColor x80_; + Value x84_; + Value x88_; + Value x8c_; + Value x90_; + Value x94_; + Value x98_; + Value x9c_; + Value xa0_; + /* Originally 4 separate floats */ + Value xa4_doorCenter; + Value xb0_; + Value xb4_; + Value xb8_; + Value xbc_; + Value xc0_; + Value xc4_; + Value xc8_; + Value xcc_; + Value xd0_; + Value xd4_; + Value xd8_; + Value xdc_; + Value xe0_; + Value xe4_; + Value xe8_; + Value xec_; + DNAColor xf0_; + DNAColor xf4_; + DNAColor xf8_; + DNAColor xfc_; + Value x100_doorColorCount; + Vector x104_doorColors; + DNAColor x118_doorBorderColor; + DNAColor x11c_openDoorColor; + + CTweakAutoMapper() = default; + CTweakAutoMapper(athena::io::IStreamReader& r) { this->read(r); } + const zeus::CVector3f& GetDoorCenter() const { return xa4_doorCenter; } +}; +} +} + +#endif // __DNAMP1_CTWEAKAUTOMAPPER_HPP__ diff --git a/DataSpec/DNAMP1/Tweaks/CTweakBall.cpp b/DataSpec/DNAMP1/Tweaks/CTweakBall.cpp new file mode 100644 index 000000000..83134b9a3 --- /dev/null +++ b/DataSpec/DNAMP1/Tweaks/CTweakBall.cpp @@ -0,0 +1,935 @@ +#include "CTweakBall.hpp" + +namespace DataSpec +{ +namespace DNAMP1 +{ + +void CTweakBall::read(athena::io::IStreamReader& __dna_reader) +{ + /* x4_[0] */ + x4_[0] = __dna_reader.readFloatBig(); + /* x4_[1] */ + x4_[1] = __dna_reader.readFloatBig(); + /* x4_[2] */ + x4_[2] = __dna_reader.readFloatBig(); + /* x4_[3] */ + x4_[3] = __dna_reader.readFloatBig(); + /* x4_[4] */ + x4_[4] = __dna_reader.readFloatBig(); + /* x4_[5] */ + x4_[5] = __dna_reader.readFloatBig(); + /* x4_[6] */ + x4_[6] = __dna_reader.readFloatBig(); + /* x4_[7] */ + x4_[7] = __dna_reader.readFloatBig(); + /* x24_[0] */ + x24_[0] = __dna_reader.readFloatBig(); + /* x24_[1] */ + x24_[1] = __dna_reader.readFloatBig(); + /* x24_[2] */ + x24_[2] = __dna_reader.readFloatBig(); + /* x24_[3] */ + x24_[3] = __dna_reader.readFloatBig(); + /* x24_[4] */ + x24_[4] = __dna_reader.readFloatBig(); + /* x24_[5] */ + x24_[5] = __dna_reader.readFloatBig(); + /* x24_[6] */ + x24_[6] = __dna_reader.readFloatBig(); + /* x24_[7] */ + x24_[7] = __dna_reader.readFloatBig(); + /* x44_[0] */ + x44_[0] = __dna_reader.readFloatBig(); + /* x44_[1] */ + x44_[1] = __dna_reader.readFloatBig(); + /* x44_[2] */ + x44_[2] = __dna_reader.readFloatBig(); + /* x44_[3] */ + x44_[3] = __dna_reader.readFloatBig(); + /* x44_[4] */ + x44_[4] = __dna_reader.readFloatBig(); + /* x44_[5] */ + x44_[5] = __dna_reader.readFloatBig(); + /* x44_[6] */ + x44_[6] = __dna_reader.readFloatBig(); + /* x44_[7] */ + x44_[7] = __dna_reader.readFloatBig(); + /* x64_ */ + x64_ = __dna_reader.readFloatBig(); + /* x68_ */ + x68_ = __dna_reader.readFloatBig(); + /* x6c_ */ + x6c_ = __dna_reader.readFloatBig(); + /* x70_ */ + x70_ = __dna_reader.readFloatBig(); + /* xc4_[0] */ + xc4_[0] = __dna_reader.readFloatBig(); + /* xc4_[1] */ + xc4_[1] = __dna_reader.readFloatBig(); + /* xc4_[2] */ + xc4_[2] = __dna_reader.readFloatBig(); + /* xc4_[3] */ + xc4_[3] = __dna_reader.readFloatBig(); + /* xc4_[4] */ + xc4_[4] = __dna_reader.readFloatBig(); + /* xc4_[5] */ + xc4_[5] = __dna_reader.readFloatBig(); + /* xc4_[6] */ + xc4_[6] = __dna_reader.readFloatBig(); + /* xc4_[7] */ + xc4_[7] = __dna_reader.readFloatBig(); + /* xe4_ */ + xe4_ = __dna_reader.readFloatBig(); + /* xe8_ */ + xe8_ = __dna_reader.readFloatBig(); + /* x14c_ */ + x14c_ = __dna_reader.readFloatBig(); + /* x150_ */ + x150_ = __dna_reader.readFloatBig(); + /* x158_ */ + x158_ = __dna_reader.readFloatBig(); + /* x1dc_ */ + x1dc_ = __dna_reader.readFloatBig(); + /* x1e0_ */ + x1e0_ = __dna_reader.readFloatBig(); + /* x1ec_ */ + x1ec_ = __dna_reader.readFloatBig(); + /* x1f0_ */ + x1f0_ = __dna_reader.readFloatBig(); + /* x1f4_ */ + x1f4_ = __dna_reader.readFloatBig(); + /* x1f8_ */ + x1f8_ = __dna_reader.readFloatBig(); + /* x1fc_ */ + x1fc_ = __dna_reader.readFloatBig(); + /* x74_ */ + x74_ = __dna_reader.readFloatBig(); + /* x78_ */ + x78_ = __dna_reader.readVec3fBig(); + /* x84_ */ + x84_ = __dna_reader.readFloatBig(); + /* x88_ */ + x88_ = __dna_reader.readFloatBig(); + /* x8c_ */ + x8c_ = __dna_reader.readFloatBig(); + /* x90_ */ + x90_ = __dna_reader.readFloatBig(); + /* x94_ */ + x94_ = __dna_reader.readFloatBig(); + /* x98_ */ + x98_ = __dna_reader.readFloatBig(); + /* x9c_ */ + x9c_ = __dna_reader.readFloatBig(); + /* xa0_ */ + xa0_ = __dna_reader.readFloatBig(); + /* xa4_ */ + xa4_ = __dna_reader.readFloatBig(); + /* xa8_ */ + xa8_ = __dna_reader.readFloatBig(); + /* xac_ */ + xac_ = __dna_reader.readFloatBig(); + /* xb0_ */ + xb0_ = __dna_reader.readFloatBig(); + /* xb4_ */ + xb4_ = __dna_reader.readFloatBig(); + /* xb8_ */ + xb8_ = __dna_reader.readFloatBig(); + /* xbc_ */ + xbc_ = __dna_reader.readFloatBig(); + /* xc0_ */ + xc0_ = __dna_reader.readFloatBig(); + /* x154_ */ + x154_ = __dna_reader.readFloatBig(); + /* x15c_ */ + x15c_ = __dna_reader.readFloatBig(); + /* x160_ */ + x160_ = __dna_reader.readFloatBig(); + /* x164_ */ + x164_ = __dna_reader.readFloatBig(); + /* x168_ */ + x168_ = __dna_reader.readFloatBig(); + /* x16c_ */ + x16c_ = __dna_reader.readFloatBig(); + /* x170_ */ + x170_ = __dna_reader.readFloatBig(); + /* x174_ */ + x174_ = __dna_reader.readFloatBig(); + /* x178_ */ + x178_ = __dna_reader.readFloatBig(); + /* x17c_ */ + x17c_ = __dna_reader.readFloatBig(); + /* x180_ */ + x180_ = __dna_reader.readFloatBig(); + /* x184_ */ + x184_ = __dna_reader.readFloatBig(); + /* x188_ */ + x188_ = __dna_reader.readFloatBig(); + /* x18c_ */ + x18c_ = __dna_reader.readVec3fBig(); + /* x198_ */ + x198_ = __dna_reader.readFloatBig(); + /* x19c_ */ + x19c_ = __dna_reader.readFloatBig(); + /* x1a0_ */ + x1a0_ = __dna_reader.readFloatBig(); + /* x1a4_ */ + x1a4_ = __dna_reader.readFloatBig(); + /* x1a8_ */ + x1a8_ = __dna_reader.readFloatBig(); + /* x1ac_ */ + x1ac_ = __dna_reader.readFloatBig(); + /* x1b0_ */ + x1b0_ = __dna_reader.readFloatBig(); + /* x1b4_ */ + x1b4_ = __dna_reader.readFloatBig(); + /* x1b8_ */ + x1b8_ = __dna_reader.readVec3fBig(); + /* x1c4_ */ + x1c4_ = __dna_reader.readFloatBig(); + /* x1c8_ */ + x1c8_ = __dna_reader.readFloatBig(); + /* x1cc_ */ + x1cc_ = __dna_reader.readFloatBig(); + /* x1d0_ */ + x1d0_ = __dna_reader.readFloatBig(); + /* x1d4_ */ + x1d4_ = __dna_reader.readFloatBig(); + /* x1d8_ */ + x1d8_ = __dna_reader.readFloatBig(); + /* x1e4_ */ + x1e4_ = __dna_reader.readFloatBig(); + /* x1e8_ */ + x1e8_ = __dna_reader.readFloatBig(); + /* x200_ */ + x200_ = __dna_reader.readFloatBig(); + /* x204_ */ + x204_ = __dna_reader.readFloatBig(); + /* x20c_ */ + x20c_ = __dna_reader.readFloatBig(); + /* x218_ */ + x218_ = __dna_reader.readFloatBig(); + /* x21c_ */ + x21c_ = __dna_reader.readFloatBig(); + /* x220_ */ + x220_ = __dna_reader.readFloatBig(); + /* x224_ */ + x224_ = __dna_reader.readFloatBig(); + /* x210_ */ + x210_ = __dna_reader.readFloatBig(); + /* x22c_ */ + x22c_ = __dna_reader.readFloatBig(); + /* x230_ */ + x230_ = __dna_reader.readFloatBig(); + /* x234_ */ + x234_ = __dna_reader.readFloatBig(); +} + +void CTweakBall::write(athena::io::IStreamWriter& __dna_writer) const +{ + /* x4_[0] */ + __dna_writer.writeFloatBig(x4_[0]); + /* x4_[1] */ + __dna_writer.writeFloatBig(x4_[1]); + /* x4_[2] */ + __dna_writer.writeFloatBig(x4_[2]); + /* x4_[3] */ + __dna_writer.writeFloatBig(x4_[3]); + /* x4_[4] */ + __dna_writer.writeFloatBig(x4_[4]); + /* x4_[5] */ + __dna_writer.writeFloatBig(x4_[5]); + /* x4_[6] */ + __dna_writer.writeFloatBig(x4_[6]); + /* x4_[7] */ + __dna_writer.writeFloatBig(x4_[7]); + /* x24_[0] */ + __dna_writer.writeFloatBig(x24_[0]); + /* x24_[1] */ + __dna_writer.writeFloatBig(x24_[1]); + /* x24_[2] */ + __dna_writer.writeFloatBig(x24_[2]); + /* x24_[3] */ + __dna_writer.writeFloatBig(x24_[3]); + /* x24_[4] */ + __dna_writer.writeFloatBig(x24_[4]); + /* x24_[5] */ + __dna_writer.writeFloatBig(x24_[5]); + /* x24_[6] */ + __dna_writer.writeFloatBig(x24_[6]); + /* x24_[7] */ + __dna_writer.writeFloatBig(x24_[7]); + /* x44_[0] */ + __dna_writer.writeFloatBig(x44_[0]); + /* x44_[1] */ + __dna_writer.writeFloatBig(x44_[1]); + /* x44_[2] */ + __dna_writer.writeFloatBig(x44_[2]); + /* x44_[3] */ + __dna_writer.writeFloatBig(x44_[3]); + /* x44_[4] */ + __dna_writer.writeFloatBig(x44_[4]); + /* x44_[5] */ + __dna_writer.writeFloatBig(x44_[5]); + /* x44_[6] */ + __dna_writer.writeFloatBig(x44_[6]); + /* x44_[7] */ + __dna_writer.writeFloatBig(x44_[7]); + /* x64_ */ + __dna_writer.writeFloatBig(x64_); + /* x68_ */ + __dna_writer.writeFloatBig(x68_); + /* x6c_ */ + __dna_writer.writeFloatBig(x6c_); + /* x70_ */ + __dna_writer.writeFloatBig(x70_); + /* xc4_[0] */ + __dna_writer.writeFloatBig(xc4_[0]); + /* xc4_[1] */ + __dna_writer.writeFloatBig(xc4_[1]); + /* xc4_[2] */ + __dna_writer.writeFloatBig(xc4_[2]); + /* xc4_[3] */ + __dna_writer.writeFloatBig(xc4_[3]); + /* xc4_[4] */ + __dna_writer.writeFloatBig(xc4_[4]); + /* xc4_[5] */ + __dna_writer.writeFloatBig(xc4_[5]); + /* xc4_[6] */ + __dna_writer.writeFloatBig(xc4_[6]); + /* xc4_[7] */ + __dna_writer.writeFloatBig(xc4_[7]); + /* xe4_ */ + __dna_writer.writeFloatBig(xe4_); + /* xe8_ */ + __dna_writer.writeFloatBig(xe8_); + /* x14c_ */ + __dna_writer.writeFloatBig(x14c_); + /* x150_ */ + __dna_writer.writeFloatBig(x150_); + /* x158_ */ + __dna_writer.writeFloatBig(x158_); + /* x1dc_ */ + __dna_writer.writeFloatBig(x1dc_); + /* x1e0_ */ + __dna_writer.writeFloatBig(x1e0_); + /* x1ec_ */ + __dna_writer.writeFloatBig(x1ec_); + /* x1f0_ */ + __dna_writer.writeFloatBig(x1f0_); + /* x1f4_ */ + __dna_writer.writeFloatBig(x1f4_); + /* x1f8_ */ + __dna_writer.writeFloatBig(x1f8_); + /* x1fc_ */ + __dna_writer.writeFloatBig(x1fc_); + /* x74_ */ + __dna_writer.writeFloatBig(x74_); + /* x78_ */ + __dna_writer.writeVec3fBig(x78_); + /* x84_ */ + __dna_writer.writeFloatBig(x84_); + /* x88_ */ + __dna_writer.writeFloatBig(x88_); + /* x8c_ */ + __dna_writer.writeFloatBig(x8c_); + /* x90_ */ + __dna_writer.writeFloatBig(x90_); + /* x94_ */ + __dna_writer.writeFloatBig(x94_); + /* x98_ */ + __dna_writer.writeFloatBig(x98_); + /* x9c_ */ + __dna_writer.writeFloatBig(x9c_); + /* xa0_ */ + __dna_writer.writeFloatBig(xa0_); + /* xa4_ */ + __dna_writer.writeFloatBig(xa4_); + /* xa8_ */ + __dna_writer.writeFloatBig(xa8_); + /* xac_ */ + __dna_writer.writeFloatBig(xac_); + /* xb0_ */ + __dna_writer.writeFloatBig(xb0_); + /* xb4_ */ + __dna_writer.writeFloatBig(xb4_); + /* xb8_ */ + __dna_writer.writeFloatBig(xb8_); + /* xbc_ */ + __dna_writer.writeFloatBig(xbc_); + /* xc0_ */ + __dna_writer.writeFloatBig(xc0_); + /* x154_ */ + __dna_writer.writeFloatBig(x154_); + /* x15c_ */ + __dna_writer.writeFloatBig(x15c_); + /* x160_ */ + __dna_writer.writeFloatBig(x160_); + /* x164_ */ + __dna_writer.writeFloatBig(x164_); + /* x168_ */ + __dna_writer.writeFloatBig(x168_); + /* x16c_ */ + __dna_writer.writeFloatBig(x16c_); + /* x170_ */ + __dna_writer.writeFloatBig(x170_); + /* x174_ */ + __dna_writer.writeFloatBig(x174_); + /* x178_ */ + __dna_writer.writeFloatBig(x178_); + /* x17c_ */ + __dna_writer.writeFloatBig(x17c_); + /* x180_ */ + __dna_writer.writeFloatBig(x180_); + /* x184_ */ + __dna_writer.writeFloatBig(x184_); + /* x188_ */ + __dna_writer.writeFloatBig(x188_); + /* x18c_ */ + __dna_writer.writeVec3fBig(x18c_); + /* x198_ */ + __dna_writer.writeFloatBig(x198_); + /* x19c_ */ + __dna_writer.writeFloatBig(x19c_); + /* x1a0_ */ + __dna_writer.writeFloatBig(x1a0_); + /* x1a4_ */ + __dna_writer.writeFloatBig(x1a4_); + /* x1a8_ */ + __dna_writer.writeFloatBig(x1a8_); + /* x1ac_ */ + __dna_writer.writeFloatBig(x1ac_); + /* x1b0_ */ + __dna_writer.writeFloatBig(x1b0_); + /* x1b4_ */ + __dna_writer.writeFloatBig(x1b4_); + /* x1b8_ */ + __dna_writer.writeVec3fBig(x1b8_); + /* x1c4_ */ + __dna_writer.writeFloatBig(x1c4_); + /* x1c8_ */ + __dna_writer.writeFloatBig(x1c8_); + /* x1cc_ */ + __dna_writer.writeFloatBig(x1cc_); + /* x1d0_ */ + __dna_writer.writeFloatBig(x1d0_); + /* x1d4_ */ + __dna_writer.writeFloatBig(x1d4_); + /* x1d8_ */ + __dna_writer.writeFloatBig(x1d8_); + /* x1e4_ */ + __dna_writer.writeFloatBig(x1e4_); + /* x1e8_ */ + __dna_writer.writeFloatBig(x1e8_); + /* x200_ */ + __dna_writer.writeFloatBig(x200_); + /* x204_ */ + __dna_writer.writeFloatBig(x204_); + /* x20c_ */ + __dna_writer.writeFloatBig(x20c_); + /* x218_ */ + __dna_writer.writeFloatBig(x218_); + /* x21c_ */ + __dna_writer.writeFloatBig(x21c_); + /* x220_ */ + __dna_writer.writeFloatBig(x220_); + /* x224_ */ + __dna_writer.writeFloatBig(x224_); + /* x210_ */ + __dna_writer.writeFloatBig(x210_); + /* x22c_ */ + __dna_writer.writeFloatBig(x22c_); + /* x230_ */ + __dna_writer.writeFloatBig(x230_); + /* x234_ */ + __dna_writer.writeFloatBig(x234_); +} + +void CTweakBall::read(athena::io::YAMLDocReader& __dna_docin) +{ + /* x4_ */ + size_t __x4_Count; + __dna_docin.enterSubVector("x4_", __x4_Count); + /* x4_[0] */ + x4_[0] = __dna_docin.readFloat("x4_"); + /* x4_[1] */ + x4_[1] = __dna_docin.readFloat("x4_"); + /* x4_[2] */ + x4_[2] = __dna_docin.readFloat("x4_"); + /* x4_[3] */ + x4_[3] = __dna_docin.readFloat("x4_"); + /* x4_[4] */ + x4_[4] = __dna_docin.readFloat("x4_"); + /* x4_[5] */ + x4_[5] = __dna_docin.readFloat("x4_"); + /* x4_[6] */ + x4_[6] = __dna_docin.readFloat("x4_"); + /* x4_[7] */ + x4_[7] = __dna_docin.readFloat("x4_"); + /* */ + __dna_docin.leaveSubVector(); + /* x24_ */ + size_t __x24_Count; + __dna_docin.enterSubVector("x24_", __x24_Count); + /* x24_[0] */ + x24_[0] = __dna_docin.readFloat("x24_"); + /* x24_[1] */ + x24_[1] = __dna_docin.readFloat("x24_"); + /* x24_[2] */ + x24_[2] = __dna_docin.readFloat("x24_"); + /* x24_[3] */ + x24_[3] = __dna_docin.readFloat("x24_"); + /* x24_[4] */ + x24_[4] = __dna_docin.readFloat("x24_"); + /* x24_[5] */ + x24_[5] = __dna_docin.readFloat("x24_"); + /* x24_[6] */ + x24_[6] = __dna_docin.readFloat("x24_"); + /* x24_[7] */ + x24_[7] = __dna_docin.readFloat("x24_"); + /* */ + __dna_docin.leaveSubVector(); + /* x44_ */ + size_t __x44_Count; + __dna_docin.enterSubVector("x44_", __x44_Count); + /* x44_[0] */ + x44_[0] = __dna_docin.readFloat("x44_"); + /* x44_[1] */ + x44_[1] = __dna_docin.readFloat("x44_"); + /* x44_[2] */ + x44_[2] = __dna_docin.readFloat("x44_"); + /* x44_[3] */ + x44_[3] = __dna_docin.readFloat("x44_"); + /* x44_[4] */ + x44_[4] = __dna_docin.readFloat("x44_"); + /* x44_[5] */ + x44_[5] = __dna_docin.readFloat("x44_"); + /* x44_[6] */ + x44_[6] = __dna_docin.readFloat("x44_"); + /* x44_[7] */ + x44_[7] = __dna_docin.readFloat("x44_"); + /* */ + __dna_docin.leaveSubVector(); + /* x64_ */ + x64_ = __dna_docin.readFloat("x64_"); + /* x68_ */ + x68_ = __dna_docin.readFloat("x68_"); + /* x6c_ */ + x6c_ = __dna_docin.readFloat("x6c_"); + /* x70_ */ + x70_ = __dna_docin.readFloat("x70_"); + /* xc4_ */ + size_t __xc4_Count; + __dna_docin.enterSubVector("xc4_", __xc4_Count); + /* xc4_[0] */ + xc4_[0] = __dna_docin.readFloat("xc4_"); + /* xc4_[1] */ + xc4_[1] = __dna_docin.readFloat("xc4_"); + /* xc4_[2] */ + xc4_[2] = __dna_docin.readFloat("xc4_"); + /* xc4_[3] */ + xc4_[3] = __dna_docin.readFloat("xc4_"); + /* xc4_[4] */ + xc4_[4] = __dna_docin.readFloat("xc4_"); + /* xc4_[5] */ + xc4_[5] = __dna_docin.readFloat("xc4_"); + /* xc4_[6] */ + xc4_[6] = __dna_docin.readFloat("xc4_"); + /* xc4_[7] */ + xc4_[7] = __dna_docin.readFloat("xc4_"); + /* */ + __dna_docin.leaveSubVector(); + /* xe4_ */ + xe4_ = __dna_docin.readFloat("xe4_"); + /* xe8_ */ + xe8_ = __dna_docin.readFloat("xe8_"); + /* x14c_ */ + x14c_ = __dna_docin.readFloat("x14c_"); + /* x150_ */ + x150_ = __dna_docin.readFloat("x150_"); + /* x158_ */ + x158_ = __dna_docin.readFloat("x158_"); + /* x1dc_ */ + x1dc_ = __dna_docin.readFloat("x1dc_"); + /* x1e0_ */ + x1e0_ = __dna_docin.readFloat("x1e0_"); + /* x1ec_ */ + x1ec_ = __dna_docin.readFloat("x1ec_"); + /* x1f0_ */ + x1f0_ = __dna_docin.readFloat("x1f0_"); + /* x1f4_ */ + x1f4_ = __dna_docin.readFloat("x1f4_"); + /* x1f8_ */ + x1f8_ = __dna_docin.readFloat("x1f8_"); + /* x1fc_ */ + x1fc_ = __dna_docin.readFloat("x1fc_"); + /* x74_ */ + x74_ = __dna_docin.readFloat("x74_"); + /* x78_ */ + x78_ = __dna_docin.readVec3f("x78_"); + /* x84_ */ + x84_ = __dna_docin.readFloat("x84_"); + /* x88_ */ + x88_ = __dna_docin.readFloat("x88_"); + /* x8c_ */ + x8c_ = __dna_docin.readFloat("x8c_"); + /* x90_ */ + x90_ = __dna_docin.readFloat("x90_"); + /* x94_ */ + x94_ = __dna_docin.readFloat("x94_"); + /* x98_ */ + x98_ = __dna_docin.readFloat("x98_"); + /* x9c_ */ + x9c_ = __dna_docin.readFloat("x9c_"); + /* xa0_ */ + xa0_ = __dna_docin.readFloat("xa0_"); + /* xa4_ */ + xa4_ = __dna_docin.readFloat("xa4_"); + /* xa8_ */ + xa8_ = __dna_docin.readFloat("xa8_"); + /* xac_ */ + xac_ = __dna_docin.readFloat("xac_"); + /* xb0_ */ + xb0_ = __dna_docin.readFloat("xb0_"); + /* xb4_ */ + xb4_ = __dna_docin.readFloat("xb4_"); + /* xb8_ */ + xb8_ = __dna_docin.readFloat("xb8_"); + /* xbc_ */ + xbc_ = __dna_docin.readFloat("xbc_"); + /* xc0_ */ + xc0_ = __dna_docin.readFloat("xc0_"); + /* x154_ */ + x154_ = __dna_docin.readFloat("x154_"); + /* x15c_ */ + x15c_ = __dna_docin.readFloat("x15c_"); + /* x160_ */ + x160_ = __dna_docin.readFloat("x160_"); + /* x164_ */ + x164_ = __dna_docin.readFloat("x164_"); + /* x168_ */ + x168_ = __dna_docin.readFloat("x168_"); + /* x16c_ */ + x16c_ = __dna_docin.readFloat("x16c_"); + /* x170_ */ + x170_ = __dna_docin.readFloat("x170_"); + /* x174_ */ + x174_ = __dna_docin.readFloat("x174_"); + /* x178_ */ + x178_ = __dna_docin.readFloat("x178_"); + /* x17c_ */ + x17c_ = __dna_docin.readFloat("x17c_"); + /* x180_ */ + x180_ = __dna_docin.readFloat("x180_"); + /* x184_ */ + x184_ = __dna_docin.readFloat("x184_"); + /* x188_ */ + x188_ = __dna_docin.readFloat("x188_"); + /* x18c_ */ + x18c_ = __dna_docin.readVec3f("x18c_"); + /* x198_ */ + x198_ = __dna_docin.readFloat("x198_"); + /* x19c_ */ + x19c_ = __dna_docin.readFloat("x19c_"); + /* x1a0_ */ + x1a0_ = __dna_docin.readFloat("x1a0_"); + /* x1a4_ */ + x1a4_ = __dna_docin.readFloat("x1a4_"); + /* x1a8_ */ + x1a8_ = __dna_docin.readFloat("x1a8_"); + /* x1ac_ */ + x1ac_ = __dna_docin.readFloat("x1ac_"); + /* x1b0_ */ + x1b0_ = __dna_docin.readFloat("x1b0_"); + /* x1b4_ */ + x1b4_ = __dna_docin.readFloat("x1b4_"); + /* x1b8_ */ + x1b8_ = __dna_docin.readVec3f("x1b8_"); + /* x1c4_ */ + x1c4_ = __dna_docin.readFloat("x1c4_"); + /* x1c8_ */ + x1c8_ = __dna_docin.readFloat("x1c8_"); + /* x1cc_ */ + x1cc_ = __dna_docin.readFloat("x1cc_"); + /* x1d0_ */ + x1d0_ = __dna_docin.readFloat("x1d0_"); + /* x1d4_ */ + x1d4_ = __dna_docin.readFloat("x1d4_"); + /* x1d8_ */ + x1d8_ = __dna_docin.readFloat("x1d8_"); + /* x1e4_ */ + x1e4_ = __dna_docin.readFloat("x1e4_"); + /* x1e8_ */ + x1e8_ = __dna_docin.readFloat("x1e8_"); + /* x200_ */ + x200_ = __dna_docin.readFloat("x200_"); + /* x204_ */ + x204_ = __dna_docin.readFloat("x204_"); + /* x20c_ */ + x20c_ = __dna_docin.readFloat("x20c_"); + /* x218_ */ + x218_ = __dna_docin.readFloat("x218_"); + /* x21c_ */ + x21c_ = __dna_docin.readFloat("x21c_"); + /* x220_ */ + x220_ = __dna_docin.readFloat("x220_"); + /* x224_ */ + x224_ = __dna_docin.readFloat("x224_"); + /* x210_ */ + x210_ = __dna_docin.readFloat("x210_"); + /* x22c_ */ + x22c_ = __dna_docin.readFloat("x22c_"); + /* x230_ */ + x230_ = __dna_docin.readFloat("x230_"); + /* x234_ */ + x234_ = __dna_docin.readFloat("x234_"); +} + +void CTweakBall::write(athena::io::YAMLDocWriter& __dna_docout) const +{ + /* x4_ */ + __dna_docout.enterSubVector("x4_"); + /* x4_[0] */ + __dna_docout.writeFloat("x4_", x4_[0]); + /* x4_[1] */ + __dna_docout.writeFloat("x4_", x4_[1]); + /* x4_[2] */ + __dna_docout.writeFloat("x4_", x4_[2]); + /* x4_[3] */ + __dna_docout.writeFloat("x4_", x4_[3]); + /* x4_[4] */ + __dna_docout.writeFloat("x4_", x4_[4]); + /* x4_[5] */ + __dna_docout.writeFloat("x4_", x4_[5]); + /* x4_[6] */ + __dna_docout.writeFloat("x4_", x4_[6]); + /* x4_[7] */ + __dna_docout.writeFloat("x4_", x4_[7]); + /* */ + __dna_docout.leaveSubVector(); + /* x24_ */ + __dna_docout.enterSubVector("x24_"); + /* x24_[0] */ + __dna_docout.writeFloat("x24_", x24_[0]); + /* x24_[1] */ + __dna_docout.writeFloat("x24_", x24_[1]); + /* x24_[2] */ + __dna_docout.writeFloat("x24_", x24_[2]); + /* x24_[3] */ + __dna_docout.writeFloat("x24_", x24_[3]); + /* x24_[4] */ + __dna_docout.writeFloat("x24_", x24_[4]); + /* x24_[5] */ + __dna_docout.writeFloat("x24_", x24_[5]); + /* x24_[6] */ + __dna_docout.writeFloat("x24_", x24_[6]); + /* x24_[7] */ + __dna_docout.writeFloat("x24_", x24_[7]); + /* */ + __dna_docout.leaveSubVector(); + /* x44_ */ + __dna_docout.enterSubVector("x44_"); + /* x44_[0] */ + __dna_docout.writeFloat("x44_", x44_[0]); + /* x44_[1] */ + __dna_docout.writeFloat("x44_", x44_[1]); + /* x44_[2] */ + __dna_docout.writeFloat("x44_", x44_[2]); + /* x44_[3] */ + __dna_docout.writeFloat("x44_", x44_[3]); + /* x44_[4] */ + __dna_docout.writeFloat("x44_", x44_[4]); + /* x44_[5] */ + __dna_docout.writeFloat("x44_", x44_[5]); + /* x44_[6] */ + __dna_docout.writeFloat("x44_", x44_[6]); + /* x44_[7] */ + __dna_docout.writeFloat("x44_", x44_[7]); + /* */ + __dna_docout.leaveSubVector(); + /* x64_ */ + __dna_docout.writeFloat("x64_", x64_); + /* x68_ */ + __dna_docout.writeFloat("x68_", x68_); + /* x6c_ */ + __dna_docout.writeFloat("x6c_", x6c_); + /* x70_ */ + __dna_docout.writeFloat("x70_", x70_); + /* xc4_ */ + __dna_docout.enterSubVector("xc4_"); + /* xc4_[0] */ + __dna_docout.writeFloat("xc4_", xc4_[0]); + /* xc4_[1] */ + __dna_docout.writeFloat("xc4_", xc4_[1]); + /* xc4_[2] */ + __dna_docout.writeFloat("xc4_", xc4_[2]); + /* xc4_[3] */ + __dna_docout.writeFloat("xc4_", xc4_[3]); + /* xc4_[4] */ + __dna_docout.writeFloat("xc4_", xc4_[4]); + /* xc4_[5] */ + __dna_docout.writeFloat("xc4_", xc4_[5]); + /* xc4_[6] */ + __dna_docout.writeFloat("xc4_", xc4_[6]); + /* xc4_[7] */ + __dna_docout.writeFloat("xc4_", xc4_[7]); + /* */ + __dna_docout.leaveSubVector(); + /* xe4_ */ + __dna_docout.writeFloat("xe4_", xe4_); + /* xe8_ */ + __dna_docout.writeFloat("xe8_", xe8_); + /* x14c_ */ + __dna_docout.writeFloat("x14c_", x14c_); + /* x150_ */ + __dna_docout.writeFloat("x150_", x150_); + /* x158_ */ + __dna_docout.writeFloat("x158_", x158_); + /* x1dc_ */ + __dna_docout.writeFloat("x1dc_", x1dc_); + /* x1e0_ */ + __dna_docout.writeFloat("x1e0_", x1e0_); + /* x1ec_ */ + __dna_docout.writeFloat("x1ec_", x1ec_); + /* x1f0_ */ + __dna_docout.writeFloat("x1f0_", x1f0_); + /* x1f4_ */ + __dna_docout.writeFloat("x1f4_", x1f4_); + /* x1f8_ */ + __dna_docout.writeFloat("x1f8_", x1f8_); + /* x1fc_ */ + __dna_docout.writeFloat("x1fc_", x1fc_); + /* x74_ */ + __dna_docout.writeFloat("x74_", x74_); + /* x78_ */ + __dna_docout.writeVec3f("x78_", x78_); + /* x84_ */ + __dna_docout.writeFloat("x84_", x84_); + /* x88_ */ + __dna_docout.writeFloat("x88_", x88_); + /* x8c_ */ + __dna_docout.writeFloat("x8c_", x8c_); + /* x90_ */ + __dna_docout.writeFloat("x90_", x90_); + /* x94_ */ + __dna_docout.writeFloat("x94_", x94_); + /* x98_ */ + __dna_docout.writeFloat("x98_", x98_); + /* x9c_ */ + __dna_docout.writeFloat("x9c_", x9c_); + /* xa0_ */ + __dna_docout.writeFloat("xa0_", xa0_); + /* xa4_ */ + __dna_docout.writeFloat("xa4_", xa4_); + /* xa8_ */ + __dna_docout.writeFloat("xa8_", xa8_); + /* xac_ */ + __dna_docout.writeFloat("xac_", xac_); + /* xb0_ */ + __dna_docout.writeFloat("xb0_", xb0_); + /* xb4_ */ + __dna_docout.writeFloat("xb4_", xb4_); + /* xb8_ */ + __dna_docout.writeFloat("xb8_", xb8_); + /* xbc_ */ + __dna_docout.writeFloat("xbc_", xbc_); + /* xc0_ */ + __dna_docout.writeFloat("xc0_", xc0_); + /* x154_ */ + __dna_docout.writeFloat("x154_", x154_); + /* x15c_ */ + __dna_docout.writeFloat("x15c_", x15c_); + /* x160_ */ + __dna_docout.writeFloat("x160_", x160_); + /* x164_ */ + __dna_docout.writeFloat("x164_", x164_); + /* x168_ */ + __dna_docout.writeFloat("x168_", x168_); + /* x16c_ */ + __dna_docout.writeFloat("x16c_", x16c_); + /* x170_ */ + __dna_docout.writeFloat("x170_", x170_); + /* x174_ */ + __dna_docout.writeFloat("x174_", x174_); + /* x178_ */ + __dna_docout.writeFloat("x178_", x178_); + /* x17c_ */ + __dna_docout.writeFloat("x17c_", x17c_); + /* x180_ */ + __dna_docout.writeFloat("x180_", x180_); + /* x184_ */ + __dna_docout.writeFloat("x184_", x184_); + /* x188_ */ + __dna_docout.writeFloat("x188_", x188_); + /* x18c_ */ + __dna_docout.writeVec3f("x18c_", x18c_); + /* x198_ */ + __dna_docout.writeFloat("x198_", x198_); + /* x19c_ */ + __dna_docout.writeFloat("x19c_", x19c_); + /* x1a0_ */ + __dna_docout.writeFloat("x1a0_", x1a0_); + /* x1a4_ */ + __dna_docout.writeFloat("x1a4_", x1a4_); + /* x1a8_ */ + __dna_docout.writeFloat("x1a8_", x1a8_); + /* x1ac_ */ + __dna_docout.writeFloat("x1ac_", x1ac_); + /* x1b0_ */ + __dna_docout.writeFloat("x1b0_", x1b0_); + /* x1b4_ */ + __dna_docout.writeFloat("x1b4_", x1b4_); + /* x1b8_ */ + __dna_docout.writeVec3f("x1b8_", x1b8_); + /* x1c4_ */ + __dna_docout.writeFloat("x1c4_", x1c4_); + /* x1c8_ */ + __dna_docout.writeFloat("x1c8_", x1c8_); + /* x1cc_ */ + __dna_docout.writeFloat("x1cc_", x1cc_); + /* x1d0_ */ + __dna_docout.writeFloat("x1d0_", x1d0_); + /* x1d4_ */ + __dna_docout.writeFloat("x1d4_", x1d4_); + /* x1d8_ */ + __dna_docout.writeFloat("x1d8_", x1d8_); + /* x1e4_ */ + __dna_docout.writeFloat("x1e4_", x1e4_); + /* x1e8_ */ + __dna_docout.writeFloat("x1e8_", x1e8_); + /* x200_ */ + __dna_docout.writeFloat("x200_", x200_); + /* x204_ */ + __dna_docout.writeFloat("x204_", x204_); + /* x20c_ */ + __dna_docout.writeFloat("x20c_", x20c_); + /* x218_ */ + __dna_docout.writeFloat("x218_", x218_); + /* x21c_ */ + __dna_docout.writeFloat("x21c_", x21c_); + /* x220_ */ + __dna_docout.writeFloat("x220_", x220_); + /* x224_ */ + __dna_docout.writeFloat("x224_", x224_); + /* x210_ */ + __dna_docout.writeFloat("x210_", x210_); + /* x22c_ */ + __dna_docout.writeFloat("x22c_", x22c_); + /* x230_ */ + __dna_docout.writeFloat("x230_", x230_); + /* x234_ */ + __dna_docout.writeFloat("x234_", x234_); +} + +const char* CTweakBall::DNAType() +{ + return "DataSpec::DNAMP1::CTweakBall"; +} + +size_t CTweakBall::binarySize(size_t __isz) const +{ + return __isz + 456; +} + +} +} diff --git a/DataSpec/DNAMP1/Tweaks/CTweakBall.hpp b/DataSpec/DNAMP1/Tweaks/CTweakBall.hpp new file mode 100644 index 000000000..89a07dc74 --- /dev/null +++ b/DataSpec/DNAMP1/Tweaks/CTweakBall.hpp @@ -0,0 +1,121 @@ +#ifndef __DNAMP1_CTWEAKBALL_HPP__ +#define __DNAMP1_CTWEAKBALL_HPP__ + +#include "../../DNACommon/Tweaks/ITweakBall.hpp" +#include "zeus/CVector3f.hpp" + +namespace DataSpec +{ +namespace DNAMP1 +{ +struct CTweakBall : public ITweakBall +{ + DECL_YAML + Delete __d; + Value x4_[8]; + Value x24_[8]; + Value x44_[8]; + Value x64_; + Value x68_; + Value x6c_; + Value x70_; + Value x74_; + Value x78_; + Value x84_; + Value x88_; + Value x8c_; + Value x90_; + Value x94_; + Value x98_; + Value x9c_; + Value xa0_; + Value xa4_; + Value xa8_; + Value xac_; + Value xb0_; + Value xb4_; + Value xb8_; + Value xbc_; + Value xc0_; + Value xc4_[8]; + Value xe4_; + Value xe8_; + float xec_ = 10000.f; + float xf0_ = 1000.f; + float xf4_ = 40000.f; + float xf8_ = 40000.f; + float xfc_ = 40000.f; + float x100_ = 40000.f; + float x104_ = 40000.f; + float x108_ = 40000.f; + float x10c_ = 10000.f; + float x110_ = 1000.f; + float x114_ = 40000.f; + float x118_ = 40000.f; + float x11c_ = 40000.f; + float x120_ = 40000.f; + float x124_ = 40000.f; + float x128_ = 40000.f; + float x12c_ = 10000.f; + float x130_ = 10000.f; + Value x14c_; + Value x150_; + Value x158_; + Value x154_; + Value x15c_; + Value x160_; + Value x164_; + Value x168_; + Value x16c_; + Value x170_; + Value x174_; + Value x178_; + Value x17c_; + Value x180_; + Value x184_; + Value x188_; + Value x18c_; + Value x198_; + Value x19c_; + Value x1a0_; + Value x1a4_; + Value x1a8_; + Value x1ac_; + Value x1b0_; + Value x1b4_; + Value x1b8_; + Value x1c4_; + Value x1c8_; + Value x1cc_; + Value x1d0_; + Value x1d4_; + Value x1d8_; + Value x1dc_; + Value x1e0_; + Value x1ec_; + Value x1f0_; + Value x1f4_; + Value x1f8_; + Value x1fc_; + Value x1e4_; + Value x1e8_; + Value x200_; + Value x204_; + float x208_; + Value x20c_; + Value x218_; + Value x21c_; + Value x220_; + Value x224_; + Value x210_; + float x228_; + Value x22c_; + Value x230_; + Value x234_; + + CTweakBall()=default; + CTweakBall(athena::io::IStreamReader& r) { this->read(r); } +}; +} +} +#endif // __DNAMP1_CTWEAKBALL_HPP__ diff --git a/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp b/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp index 18070492f..ecf6b0339 100644 --- a/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp +++ b/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp @@ -119,7 +119,7 @@ struct CTweakGui : ITweakGui Value x1f4_; Value x1f8_; Value x1fc_; - atVec4f x200_; + float x200_; float x204_xrayBlurScaleLinear = 0.0014f; float x208_xrayBlurScaleQuadratic = 0.0000525f; Value x20c_; @@ -149,23 +149,23 @@ struct CTweakGui : ITweakGui Value x26c_; Value x270_; Value x274_; - Value x275_ = true; + bool x275_ = true; Value x278_; Value x27c_; Value x280_; Value x284_; - Value x288_; + DNAColor x288_; Value x28c_; - Value x290_; - Value x294_; - Value x298_; - Value x29c_; - Value x2a0_; - Value x2a4_; - Value x2a8_; - Value x2ac_; - Value x2b0_; - Value x2b4_; + DNAColor x290_; + DNAColor x294_; + DNAColor x298_; + DNAColor x29c_; + DNAColor x2a0_; + DNAColor x2a4_; + DNAColor x2a8_; + DNAColor x2ac_; + DNAColor x2b0_; + DNAColor x2b4_; Value x2b8_; Value x2bc_; Value x2c0_; @@ -174,24 +174,26 @@ struct CTweakGui : ITweakGui String<-1> x2d0_; String<-1> x2e0_; String<-1> x2f0_; - Value x300_; - Value x304_; + DNAColor x300_; + DNAColor x304_; Value x308_; Value x30c_; Value x310_; String<-1> x314_; String<-1> x324_; String<-1> x334_; - Value x344_; - Value x348_; - Value x34c_; - Value x350_; - Value x354_; - Value x358_; + DNAColor x344_; + DNAColor x348_; + DNAColor x34c_; + DNAColor x350_; + DNAColor x354_; + DNAColor x358_; Value x35c_; Value x360_; Value x364_; + CTweakGui() = default; + CTweakGui(athena::io::IStreamReader& r) { this->read(r); } float GetXrayBlurScaleLinear() const { return x204_xrayBlurScaleLinear; } float GetXrayBlurScaleQuadratic() const { return x208_xrayBlurScaleQuadratic; } @@ -207,10 +209,9 @@ struct CTweakGui : ITweakGui xd8_ = zeus::degToRad(xd8_); xdc_ = zeus::degToRad(xdc_); - x200_.vec[0] = x1f4_ * 0.25f; - x200_.vec[1] = x1f8_ * 0.25f; - x200_.vec[2] = x1fc_ * 0.25f; - x200_.vec[3] = 1.f; + x200_ = x1f4_ * 0.25f; + x204_xrayBlurScaleLinear = x1f8_ * 0.25f; + x208_xrayBlurScaleQuadratic = x1fc_ * 0.25f; x210_ = zeus::degToRad(x210_); x228_ = x220_ + x224_; diff --git a/DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp b/DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp new file mode 100644 index 000000000..960ebf310 --- /dev/null +++ b/DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp @@ -0,0 +1,145 @@ +#ifndef __DNAMP1_CTWEAKGUICOLORS_HPP__ +#define __DNAMP1_CTWEAKGUICOLORS_HPP__ + +#include "../../DNACommon/Tweaks/ITweakGuiColors.hpp" + +namespace DataSpec +{ +namespace DNAMP1 +{ +struct CTweakGuiColors : public ITweakGuiColors +{ + DECL_YAML + DNAColor x4_; + DNAColor x8_; + DNAColor xc_; + DNAColor x10_; + DNAColor x14_; + DNAColor x18_; + DNAColor x1c_; + DNAColor x20_; + DNAColor x24_; + DNAColor x28_; + DNAColor x2c_; + DNAColor x30_; + DNAColor x34_; + DNAColor x38_; + DNAColor x3c_; + DNAColor x40_; + DNAColor x44_; + DNAColor x48_; + DNAColor x4c_; + DNAColor x50_; + DNAColor x54_; + DNAColor x58_; + DNAColor x5c_; + DNAColor x60_; + DNAColor x64_; + DNAColor x68_; + DNAColor x6c_; + DNAColor x70_; + DNAColor x74_; + DNAColor x78_; + DNAColor x7c_; + DNAColor x80_; + DNAColor x84_; + DNAColor x88_; + DNAColor x8c_; + DNAColor x90_; + DNAColor x94_; + DNAColor x98_; + DNAColor x9c_; + DNAColor xa0_; + DNAColor xa4_; + DNAColor xa8_; + DNAColor xac_; + DNAColor xb0_; + DNAColor xb4_; + DNAColor xb8_; + DNAColor xbc_; + DNAColor xc0_; + DNAColor xc4_; + DNAColor xc8_; + DNAColor xcc_; + DNAColor xd0_; + DNAColor xd4_; + DNAColor xd8_; + DNAColor xdc_; + DNAColor xe0_; + DNAColor xe4_; + DNAColor xe8_; + DNAColor xec_; + DNAColor xf0_; + DNAColor xf4_; + DNAColor xf8_; + DNAColor xfc_; + DNAColor x100_; + DNAColor x104_; + DNAColor x108_; + DNAColor x10c_; + DNAColor x110_; + DNAColor x114_; + DNAColor x118_; + DNAColor x11c_; + DNAColor x120_; + DNAColor x124_; + DNAColor x128_; + DNAColor x12c_; + DNAColor x130_; + DNAColor x134_; + DNAColor x138_; + DNAColor x13c_; + DNAColor x140_; + DNAColor x144_; + DNAColor x148_; + DNAColor x14c_; + DNAColor x150_; + DNAColor x154_; + DNAColor x158_; + DNAColor x15c_; + DNAColor x160_; + DNAColor x164_; + DNAColor x168_; + DNAColor x16c_; + DNAColor x170_; + DNAColor x174_; + DNAColor x178_; + DNAColor x17c_; + DNAColor x180_; + DNAColor x184_; + DNAColor x188_; + DNAColor x18c_; + DNAColor x190_; + DNAColor x194_; + DNAColor x198_; + DNAColor x19c_; + DNAColor x1a0_; + DNAColor x1a4_; + DNAColor x1a8_; + DNAColor x1ac_; + DNAColor x1b0_; + DNAColor x1b4_; + DNAColor x1b8_; + DNAColor x1bc_; + DNAColor x1c0_; + struct UnkColors : BigYAML + { + DECL_YAML + DNAColor x0_; + DNAColor x4_; + DNAColor x8_; + DNAColor xc_; + DNAColor x10_; + DNAColor x14_; + DNAColor x18_; + }; + Value x1c4_count; + Vector x1c4_; + + CTweakGuiColors() = default; + CTweakGuiColors(athena::io::IStreamReader& r) { this->read(r); } +}; +} +} + +#endif // __DNAMP1_CTWEAKGUICOLORS_HPP__ diff --git a/DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp b/DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp index ee60f0c03..ea93b613c 100644 --- a/DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp +++ b/DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp @@ -15,6 +15,7 @@ struct CTweakParticle : ITweakParticle String<-1> m_powerBeam; String<-1> m_genThrust; + CTweakParticle()=default; CTweakParticle(athena::io::IStreamReader& reader) { this->read(reader); } }; diff --git a/DataSpec/DNAMP1/Tweaks/CTweakPlayerControl.hpp b/DataSpec/DNAMP1/Tweaks/CTweakPlayerControl.hpp index 480fd9aa2..d42383066 100644 --- a/DataSpec/DNAMP1/Tweaks/CTweakPlayerControl.hpp +++ b/DataSpec/DNAMP1/Tweaks/CTweakPlayerControl.hpp @@ -13,6 +13,7 @@ struct CTweakPlayerControl : ITweakPlayerControl DECL_YAML Vector m_mappings; atUint32 GetMapping(atUint32 command) const {return m_mappings[command];} + CTweakPlayerControl() = default; CTweakPlayerControl(athena::io::IStreamReader& reader) {this->read(reader);} }; diff --git a/DataSpec/SpecMP1.cpp b/DataSpec/SpecMP1.cpp index 63dff7619..91f67eae8 100644 --- a/DataSpec/SpecMP1.cpp +++ b/DataSpec/SpecMP1.cpp @@ -29,6 +29,13 @@ #include "DNAMP1/Tweaks/CTweakPlayer.hpp" #include "DNAMP1/Tweaks/CTweakCameraBob.hpp" #include "DNAMP1/Tweaks/CTweakGame.hpp" +#include "DNAMP1/Tweaks/CTweakTargeting.hpp" +#include "DNAMP1/Tweaks/CTweakAutoMapper.hpp" +#include "DNAMP1/Tweaks/CTweakGui.hpp" +#include "DNAMP1/Tweaks/CTweakPlayerControl.hpp" +#include "DNAMP1/Tweaks/CTweakBall.hpp" +#include "DNAMP1/Tweaks/CTweakParticle.hpp" +#include "DNAMP1/Tweaks/CTweakGuiColors.hpp" #include "hecl/ClientProcess.hpp" @@ -372,6 +379,20 @@ struct SpecMP1 : SpecBase return true; else if (!strcmp(classType, DNAMP1::CTweakGame::DNAType())) return true; + else if (!strcmp(classType, DNAMP1::CTweakAutoMapper::DNAType())) + return true; + else if (!strcmp(classType, DNAMP1::CTweakTargeting::DNAType())) + return true; + else if (!strcmp(classType, DNAMP1::CTweakGui::DNAType())) + return true; + else if (!strcmp(classType, DNAMP1::CTweakPlayerControl::DNAType())) + return true; + else if (!strcmp(classType, DNAMP1::CTweakBall::DNAType())) + return true; + else if (!strcmp(classType, DNAMP1::CTweakParticle::DNAType())) + return true; + else if (!strcmp(classType, DNAMP1::CTweakGuiColors::DNAType())) + return true; else if (!strcmp(classType, DNAMP1::HINT::DNAType())) return true; else if (!strcmp(classType, "ATBL")) @@ -524,7 +545,14 @@ struct SpecMP1 : SpecBase !strcmp(className, "DataSpec::DNAMP1::CTweakSlideShow") || !strcmp(className, "DataSpec::DNAMP1::CTweakPlayer") || !strcmp(className, "DataSpec::DNAMP1::CTweakCameraBob") || - !strcmp(className, "DataSpec::DNAMP1::CTweakGame")) + !strcmp(className, "DataSpec::DNAMP1::CTweakGame") || + !strcmp(className, "DataSpec::DNAMP1::CTweakTargeting") || + !strcmp(className, "DataSpec::DNAMP1::CTweakAutoMapper") || + !strcmp(className, "DataSpec::DNAMP1::CTweakGui") || + !strcmp(className, "DataSpec::DNAMP1::CTweakPlayerControl") || + !strcmp(className, "DataSpec::DNAMP1::CTweakBall") || + !strcmp(className, "DataSpec::DNAMP1::CTweakParticle") || + !strcmp(className, "DataSpec::DNAMP1::CTweakGuiColors")) { resTag.type = SBIG('CTWK'); return true; @@ -739,6 +767,42 @@ struct SpecMP1 : SpecBase cGame.read(reader); WriteTweak(cGame, out); } + else if (!classStr.compare(DNAMP1::CTweakAutoMapper::DNAType())) + { + DNAMP1::CTweakAutoMapper autoMapper; + autoMapper.read(reader); + WriteTweak(autoMapper, out); + } + else if (!classStr.compare(DNAMP1::CTweakTargeting::DNAType())) + { + DNAMP1::CTweakTargeting targeting; + targeting.read(reader); + WriteTweak(targeting, out); + } + else if (!classStr.compare(DNAMP1::CTweakGui::DNAType())) + { + DNAMP1::CTweakGui gui; + gui.read(reader); + WriteTweak(gui, out); + } + else if (!classStr.compare(DNAMP1::CTweakBall::DNAType())) + { + DNAMP1::CTweakBall ball; + ball.read(reader); + WriteTweak(ball, out); + } + else if (!classStr.compare(DNAMP1::CTweakParticle::DNAType())) + { + DNAMP1::CTweakParticle part; + part.read(reader); + WriteTweak(part, out); + } + else if (!classStr.compare(DNAMP1::CTweakGuiColors::DNAType())) + { + DNAMP1::CTweakGuiColors gColors; + gColors.read(reader); + WriteTweak(gColors, out); + } else if (!classStr.compare(DNAMP1::HINT::DNAType())) { DNAMP1::HINT::Cook(in, out); diff --git a/Editor/ProjectResourceFactoryBase.cpp b/Editor/ProjectResourceFactoryBase.cpp index a88d4b628..48dcf4f8f 100644 --- a/Editor/ProjectResourceFactoryBase.cpp +++ b/Editor/ProjectResourceFactoryBase.cpp @@ -509,8 +509,7 @@ void ProjectResourceFactoryBase::AsyncTask::CookComplete() /* Ready for buffer transaction at this point */ u32 availSz = std::max(0, s32(fr.length()) - s32(x14_resOffset)); x14_resSize = std::min(x14_resSize, availSz); - u8* derp = new u8[x14_resSize]; - x10_loadBuffer.reset(std::move(derp)); + x10_loadBuffer.reset(new u8[x14_resSize]); m_bufTransaction = m_parent.m_clientProc.addBufferTransaction(m_cookedPath, x10_loadBuffer.get(), x14_resSize, x14_resOffset); diff --git a/Runtime/AutoMapper/CMakeLists.txt b/Runtime/AutoMapper/CMakeLists.txt index 13f6e9153..cd8d20217 100644 --- a/Runtime/AutoMapper/CMakeLists.txt +++ b/Runtime/AutoMapper/CMakeLists.txt @@ -4,7 +4,6 @@ set(AUTOMAPPER_SOURCES CMapWorld.hpp CMapWorld.cpp CMapArea.hpp CMapArea.cpp CMappableObject.hpp CMappableObject.cpp - CAutoMapper.hpp CAutoMapper.cpp - ITweakAutoMapper.hpp) + CAutoMapper.hpp CAutoMapper.cpp) runtime_add_list(AutoMapper AUTOMAPPER_SOURCES) diff --git a/Runtime/AutoMapper/CMappableObject.cpp b/Runtime/AutoMapper/CMappableObject.cpp index f37a0df7e..0f7c32c85 100644 --- a/Runtime/AutoMapper/CMappableObject.cpp +++ b/Runtime/AutoMapper/CMappableObject.cpp @@ -1,6 +1,5 @@ #include "CMappableObject.hpp" #include "GameGlobalObjects.hpp" -#include "ITweakAutoMapper.hpp" namespace urde { diff --git a/Runtime/AutoMapper/CMappableObject.hpp b/Runtime/AutoMapper/CMappableObject.hpp index 1c24690dc..6a1d02b5f 100644 --- a/Runtime/AutoMapper/CMappableObject.hpp +++ b/Runtime/AutoMapper/CMappableObject.hpp @@ -4,12 +4,11 @@ #include "RetroTypes.hpp" #include "zeus/CAABox.hpp" #include "zeus/CTransform.hpp" +#include "GameGlobalObjects.hpp" namespace urde { class CStateManager; -class ITweakAutoMapper; - class CMappableObject { public: diff --git a/Runtime/AutoMapper/ITweakAutoMapper.hpp b/Runtime/AutoMapper/ITweakAutoMapper.hpp deleted file mode 100644 index bb2cc603b..000000000 --- a/Runtime/AutoMapper/ITweakAutoMapper.hpp +++ /dev/null @@ -1,17 +0,0 @@ -#ifndef __URDE_ITWEAKAUTOMAPPER_HPP__ -#define __URDE_ITWEAKAUTOMAPPER_HPP__ - -#include "zeus/CVector3f.hpp" -#include "ITweak.hpp" - -namespace urde -{ -class ITweakAutoMapper : public ITweak -{ -public: - virtual ~ITweakAutoMapper() {} - virtual const zeus::CVector3f& GetDoorCenter() const=0; -}; -} - -#endif // __URDE_ITWEAKAUTOMAPPER_HPP__ diff --git a/Runtime/CScannableObjectInfo.cpp b/Runtime/CScannableObjectInfo.cpp index cce5dad2f..b7692a148 100644 --- a/Runtime/CScannableObjectInfo.cpp +++ b/Runtime/CScannableObjectInfo.cpp @@ -1,6 +1,5 @@ #include "CScannableObjectInfo.hpp" #include "GameGlobalObjects.hpp" -#include "GuiSys/ITweakGui.hpp" namespace urde { diff --git a/Runtime/GameGlobalObjects.cpp b/Runtime/GameGlobalObjects.cpp index 1a545152c..bc738c447 100644 --- a/Runtime/GameGlobalObjects.cpp +++ b/Runtime/GameGlobalObjects.cpp @@ -18,15 +18,20 @@ class CInGameTweakManagerBase* g_TweakManager = nullptr; class CBooRenderer* g_Renderer = nullptr; class CStringTable* g_MainStringTable = nullptr; -DataSpec::ITweakGame* g_tweakGame = nullptr; -DataSpec::ITweakPlayer* g_tweakPlayer = nullptr; -DataSpec::ITweakPlayerControl* g_tweakPlayerControl = nullptr; -DataSpec::ITweakPlayerControl* g_tweakPlayerControlAlt = nullptr; -DataSpec::ITweakPlayerControl* g_currentPlayerControl = nullptr; -DataSpec::ITweakPlayerGun* g_tweakPlayerGun = nullptr; -DataSpec::ITweakGunRes* g_tweakGunRes = nullptr; -DataSpec::ITweakPlayerRes* g_tweakPlayerRes = nullptr; -DataSpec::ITweakGui* g_tweakGui = nullptr; -DataSpec::ITweakSlideShow* g_tweakSlideShow = nullptr; +ITweakGame* g_tweakGame = nullptr; +ITweakPlayer* g_tweakPlayer = nullptr; +ITweakPlayerControl* g_tweakPlayerControl = nullptr; +ITweakPlayerControl* g_tweakPlayerControlAlt = nullptr; +ITweakPlayerControl* g_currentPlayerControl = nullptr; +ITweakPlayerGun* g_tweakPlayerGun = nullptr; +ITweakGunRes* g_tweakGunRes = nullptr; +ITweakPlayerRes* g_tweakPlayerRes = nullptr; +ITweakTargeting* g_tweakTargeting = nullptr; +ITweakAutoMapper* g_tweakAutoMapper = nullptr; +ITweakGui* g_tweakGui = nullptr; +ITweakSlideShow* g_tweakSlideShow = nullptr; +ITweakParticle* g_tweakParticle = nullptr; +ITweakBall* g_tweakBall = nullptr; +ITweakGuiColors* g_tweakGuiColors = nullptr; } diff --git a/Runtime/GameGlobalObjects.hpp b/Runtime/GameGlobalObjects.hpp index e82e3e581..647a61c83 100644 --- a/Runtime/GameGlobalObjects.hpp +++ b/Runtime/GameGlobalObjects.hpp @@ -8,8 +8,12 @@ #include "../DataSpec/DNACommon/Tweaks/ITweakPlayerRes.hpp" #include "../DataSpec/DNACommon/Tweaks/ITweakGui.hpp" #include "../DataSpec/DNACommon/Tweaks/ITweakSlideShow.hpp" -#include "AutoMapper/ITweakAutoMapper.hpp" -#include "GuiSys/ITweakGui.hpp" +#include "../DataSpec/DNACommon/Tweaks/ITweakGui.hpp" +#include "../DataSpec/DNACommon/Tweaks/ITweakTargeting.hpp" +#include "../DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp" +#include "../DataSpec/DNACommon/Tweaks/ITweakParticle.hpp" +#include "../DataSpec/DNACommon/Tweaks/ITweakBall.hpp" +#include "../DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp" namespace urde { @@ -18,7 +22,6 @@ namespace MP1 { extern class CGameArchitectureSupport* g_archSupport; } - extern class CMemoryCardSys* g_MemoryCardSys; extern class IFactory* g_ResFactory; extern class CSimplePool* g_SimplePool; @@ -29,17 +32,35 @@ extern class CInGameTweakManagerBase* g_TweakManager; extern class CBooRenderer* g_Renderer; extern class CStringTable* g_MainStringTable; -extern DataSpec::ITweakGame* g_tweakGame; -extern DataSpec::ITweakPlayer* g_tweakPlayer; -extern DataSpec::ITweakPlayerControl* g_tweakPlayerControl; -extern DataSpec::ITweakPlayerControl* g_tweakPlayerControlAlt; -extern DataSpec::ITweakPlayerControl* g_currentPlayerControl; -extern DataSpec::ITweakPlayerGun* g_tweakPlayerGun; -extern DataSpec::ITweakGunRes* g_tweakGunRes; -extern DataSpec::ITweakPlayerRes* g_tweakPlayerRes; +using ITweakGame = DataSpec::ITweakGame; +using ITweakPlayer = DataSpec::ITweakPlayer; +using ITweakPlayerRes = DataSpec::ITweakPlayerRes; +using ITweakPlayerControl = DataSpec::ITweakPlayerControl; +using ITweakPlayerGun = DataSpec::ITweakPlayerGun; +using ITweakGunRes = DataSpec::ITweakGunRes; +using ITweakTargeting = DataSpec::ITweakTargeting; +using ITweakAutoMapper = DataSpec::ITweakAutoMapper; +using ITweakGui = DataSpec::ITweakGui; +using ITweakSlideShow = DataSpec::ITweakSlideShow; +using ITweakParticle = DataSpec::ITweakParticle; +using ITweakBall = DataSpec::ITweakBall; +using ITweakGuiColors = DataSpec::ITweakGuiColors; + +extern ITweakGame* g_tweakGame; +extern ITweakPlayer* g_tweakPlayer; +extern ITweakPlayerControl* g_tweakPlayerControl; +extern ITweakPlayerControl* g_tweakPlayerControlAlt; +extern ITweakPlayerControl* g_currentPlayerControl; +extern ITweakPlayerGun* g_tweakPlayerGun; +extern ITweakGunRes* g_tweakGunRes; +extern ITweakPlayerRes* g_tweakPlayerRes; +extern ITweakTargeting* g_tweakTargeting; extern ITweakAutoMapper* g_tweakAutoMapper; -extern DataSpec::ITweakGui* g_tweakGui; -extern DataSpec::ITweakSlideShow* g_tweakSlideShow; +extern ITweakGui* g_tweakGui; +extern ITweakSlideShow* g_tweakSlideShow; +extern ITweakParticle* g_tweakParticle; +extern ITweakBall* g_tweakBall; +extern ITweakGuiColors* g_tweakGuiColors; } diff --git a/Runtime/GuiSys/CMakeLists.txt b/Runtime/GuiSys/CMakeLists.txt index 8f2c231b3..9766082a5 100644 --- a/Runtime/GuiSys/CMakeLists.txt +++ b/Runtime/GuiSys/CMakeLists.txt @@ -1,77 +1,40 @@ set(GUISYS_SOURCES - CSplashScreen.cpp - CSplashScreen.hpp - CGuiObject.cpp - CGuiObject.hpp - CConsoleOutputWindow.cpp - CConsoleOutputWindow.hpp - CAuiEnergyBarT01.cpp - CAuiEnergyBarT01.hpp - CAuiImagePane.cpp - CAuiImagePane.hpp - CAuiMeter.cpp - CAuiMeter.hpp - CConsoleOutputWindow.cpp - CConsoleOutputWindow.hpp - CErrorOutputWindow.cpp - CErrorOutputWindow.hpp - CGuiCamera.cpp - CGuiCamera.hpp - CGuiFrame.cpp - CGuiFrame.hpp - CGuiLight.cpp - CGuiLight.hpp - CGuiModel.cpp - CGuiModel.hpp - CGuiSliderGroup.cpp - CGuiSliderGroup.hpp - CGuiSys.cpp - CGuiSys.hpp - CGuiTableGroup.cpp - CGuiTableGroup.hpp - CGuiTextPane.cpp - CGuiTextPane.hpp - CGuiTextSupport.cpp - CGuiTextSupport.hpp - CGuiWidget.cpp - CGuiWidgetDrawParms.cpp - CGuiWidgetDrawParms.hpp - CGuiWidget.hpp - CMakeLists.txt - CSplashScreen.cpp - CSplashScreen.hpp - CGuiCompoundWidget.cpp - CGuiCompoundWidget.hpp - CSaveableState.cpp - CSaveableState.hpp - CDrawStringOptions.cpp - CDrawStringOptions.hpp - CRasterFont.cpp - CRasterFont.hpp - CGuiGroup.cpp - CGuiGroup.hpp - CGuiWidgetIdDB.cpp - CGuiWidgetIdDB.hpp - CGuiHeadWidget.cpp - CGuiHeadWidget.hpp - CGuiPane.cpp - CGuiPane.hpp - CFontRenderState.cpp - CFontRenderState.hpp - CTextExecuteBuffer.cpp - CTextExecuteBuffer.hpp - CTextRenderBuffer.cpp - CTextRenderBuffer.hpp - CInstruction.cpp - CInstruction.hpp - CTextParser.cpp - CTextParser.hpp - CWordBreakTables.cpp - CWordBreakTables.hpp - CFontImageDef.cpp - CFontImageDef.hpp - ITweakGui.hpp - CStringTable.cpp - CStringTable.hpp) + CSplashScreen.hpp CSplashScreen.cpp + CGuiObject.hpp CGuiObject.cpp + CConsoleOutputWindow.hpp CConsoleOutputWindow.cpp + CAuiEnergyBarT01.hpp CAuiEnergyBarT01.cpp + CAuiImagePane.hpp CAuiImagePane.cpp + CAuiMeter.hpp CAuiMeter.cpp + CConsoleOutputWindow.hpp CConsoleOutputWindow.cpp + CErrorOutputWindow.hpp CErrorOutputWindow.cpp + CGuiCamera.hpp CGuiCamera.cpp + CGuiFrame.hpp CGuiFrame.cpp + CGuiLight.hpp CGuiLight.cpp + CGuiModel.hpp CGuiModel.cpp + CGuiSliderGroup.hpp CGuiSliderGroup.cpp + CGuiSys.hpp CGuiSys.cpp + CGuiTableGroup.hpp CGuiTableGroup.cpp + CGuiTextPane.hpp CGuiTextPane.cpp + CGuiTextSupport.hpp CGuiTextSupport.cpp + CGuiWidget.hpp CGuiWidget.cpp + CGuiWidgetDrawParms.hpp CGuiWidgetDrawParms.cpp + CSplashScreen.hpp CSplashScreen.cpp + CGuiCompoundWidget.hpp CGuiCompoundWidget.cpp + CSaveableState.hpp CSaveableState.cpp + CDrawStringOptions.hpp CDrawStringOptions.cpp + CRasterFont.hpp CRasterFont.cpp + CGuiGroup.hpp CGuiGroup.cpp + CGuiWidgetIdDB.hpp CGuiWidgetIdDB.cpp + CGuiHeadWidget.hpp CGuiHeadWidget.cpp + CGuiPane.hpp CGuiPane.cpp + CFontRenderState.hpp CFontRenderState.cpp + CTextExecuteBuffer.hpp CTextExecuteBuffer.cpp + CTextRenderBuffer.hpp CTextRenderBuffer.cpp + CInstruction.hpp CInstruction.cpp + CTextParser.hpp CTextParser.cpp + CWordBreakTables.hpp CWordBreakTables.cpp + CFontImageDef.hpp CFontImageDef.cpp + CStringTable.hpp CStringTable.cpp + CTargetingManager.hpp CTargetingManager.cpp) runtime_add_list(GuiSys GUISYS_SOURCES) diff --git a/Runtime/GuiSys/CTargetingManager.cpp b/Runtime/GuiSys/CTargetingManager.cpp new file mode 100644 index 000000000..e69de29bb diff --git a/Runtime/GuiSys/CTargetingManager.hpp b/Runtime/GuiSys/CTargetingManager.hpp new file mode 100644 index 000000000..e69de29bb diff --git a/Runtime/GuiSys/CTextParser.cpp b/Runtime/GuiSys/CTextParser.cpp index 309afd61d..0e4fd45d4 100644 --- a/Runtime/GuiSys/CTextParser.cpp +++ b/Runtime/GuiSys/CTextParser.cpp @@ -158,7 +158,7 @@ void CTextParser::ParseTag(CTextExecuteBuffer& out, const char16_t* str, int len out.AddJustification(EJustification::Center); else if (Equals(str + 5, len - 5, u"right")) out.AddJustification(EJustification::Right); - else if (Equals(str + 5, len - 5, u"fulu")) + else if (Equals(str + 5, len - 5, u"full")) out.AddJustification(EJustification::Full); else if (Equals(str + 5, len - 5, u"nleft")) out.AddJustification(EJustification::NLeft); @@ -175,7 +175,7 @@ void CTextParser::ParseTag(CTextExecuteBuffer& out, const char16_t* str, int len out.AddVerticalJustification(EVerticalJustification::Center); else if (Equals(str + 6, len - 6, u"bottom")) out.AddVerticalJustification(EVerticalJustification::Bottom); - else if (Equals(str + 6, len - 6, u"fulu")) + else if (Equals(str + 6, len - 6, u"full")) out.AddVerticalJustification(EVerticalJustification::Full); else if (Equals(str + 6, len - 6, u"ntop")) out.AddVerticalJustification(EVerticalJustification::NTop); diff --git a/Runtime/GuiSys/ITweakGui.hpp b/Runtime/GuiSys/ITweakGui.hpp deleted file mode 100644 index 349030bd3..000000000 --- a/Runtime/GuiSys/ITweakGui.hpp +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef __URDE_ITWEAKGUI_HPP__ -#define __URDE_ITWEAKGUI_HPP__ - -#include "RetroTypes.hpp" -#include "ITweak.hpp" - -namespace urde -{ -class ITweakGui : public ITweak -{ -public: - virtual ~ITweakGui() {} - - virtual float GetScanSpeed(s32) const=0; -}; -} - -#endif // __URDE_ITWEAKGUI_HPP__ diff --git a/Runtime/MP1/CMakeLists.txt b/Runtime/MP1/CMakeLists.txt index 3a1589172..cc0fd6aa2 100644 --- a/Runtime/MP1/CMakeLists.txt +++ b/Runtime/MP1/CMakeLists.txt @@ -2,9 +2,6 @@ include_directories(. ..) set(MP1_SOURCES CTweaks.hpp CTweaks.cpp CInGameTweakManager.hpp CInGameTweakManager.cpp - Tweaks/CTweakAutoMapper.hpp Tweaks/CTweakAutoMapper.cpp - Tweaks/CTweakPlayer.hpp Tweaks/CTweakPlayer.cpp - Tweaks/CTweakGui.hpp Tweaks/CTweakGui.cpp CGBASupport.hpp CGBASupport.cpp CNESEmulator.hpp CNESEmulator.cpp CMainFlow.hpp CMainFlow.cpp diff --git a/Runtime/MP1/CTweaks.cpp b/Runtime/MP1/CTweaks.cpp index 73ab46595..194830dd2 100644 --- a/Runtime/MP1/CTweaks.cpp +++ b/Runtime/MP1/CTweaks.cpp @@ -11,6 +11,12 @@ #include "DataSpec/DNAMP1/Tweaks/CTweakGunRes.hpp" #include "DataSpec/DNAMP1/Tweaks/CTweakPlayerRes.hpp" #include "DataSpec/DNAMP1/Tweaks/CTweakSlideShow.hpp" +#include "DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp" +#include "DataSpec/DNAMP1/Tweaks/CTweakTargeting.hpp" +#include "DataSpec/DNAMP1/Tweaks/CTweakGui.hpp" +#include "DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp" +#include "DataSpec/DNAMP1/Tweaks/CTweakBall.hpp" +#include "DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp" #include "World/CPlayerCameraBob.hpp" namespace urde @@ -36,6 +42,9 @@ void CTweaks::RegisterTweaks() const SObjectTag* tag; /* Particle */ + tag = factory.GetResourceIdByName("Particle"); + strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag)); + g_tweakParticle = new DataSpec::DNAMP1::CTweakParticle(*strm); /* Player */ tag = factory.GetResourceIdByName("Player"); @@ -48,10 +57,16 @@ void CTweaks::RegisterTweaks() CPlayerCameraBob::ReadTweaks(*strm); /* Ball */ + tag = factory.GetResourceIdByName("Ball"); + strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag)); + g_tweakBall = new DataSpec::DNAMP1::CTweakBall(*strm); /* PlayerGun */ /* Targeting */ + tag = factory.GetResourceIdByName("Targeting"); + strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag)); + g_tweakTargeting = new DataSpec::DNAMP1::CTweakTargeting(*strm); /* Game */ tag = factory.GetResourceIdByName("Game"); @@ -59,14 +74,31 @@ void CTweaks::RegisterTweaks() g_tweakGame = new DataSpec::DNAMP1::CTweakGame(*strm); /* GuiColors */ + tag = factory.GetResourceIdByName("GuiColors"); + strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag)); + g_tweakGuiColors = new DataSpec::DNAMP1::CTweakGuiColors(*strm); /* AutoMapper */ + tag = factory.GetResourceIdByName("AutoMapper"); + strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag)); + g_tweakAutoMapper = new DataSpec::DNAMP1::CTweakAutoMapper(*strm); /* Gui */ + tag = factory.GetResourceIdByName("Gui"); + strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag)); + g_tweakGui = new DataSpec::DNAMP1::CTweakGui(*strm); /* PlayerControls */ + tag = factory.GetResourceIdByName("PlayerControls"); + strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag)); + g_tweakPlayerControl = new DataSpec::DNAMP1::CTweakPlayerControl(*strm); /* PlayerControls2 */ + tag = factory.GetResourceIdByName("PlayerControls2"); + strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag)); + g_tweakPlayerControlAlt = new DataSpec::DNAMP1::CTweakPlayerControl(*strm); + + g_currentPlayerControl = g_tweakPlayerControl; /* SlideShow */ tag = factory.GetResourceIdByName("SlideShow"); diff --git a/Runtime/MP1/Tweaks/CTweakAutoMapper.cpp b/Runtime/MP1/Tweaks/CTweakAutoMapper.cpp deleted file mode 100644 index 9ed31f645..000000000 --- a/Runtime/MP1/Tweaks/CTweakAutoMapper.cpp +++ /dev/null @@ -1,81 +0,0 @@ -#include "CTweakAutoMapper.hpp" -namespace urde -{ -namespace MP1 -{ -CTweakAutoMapper::CTweakAutoMapper(CInputStream& in) -{ - x4_24_ = in.readBool(); - x4_25_ = in.readBool(); - x4_26_ = in.readBool(); - x8_ = in.readFloatBig(); - xc_ = in.readFloatBig(); - x10_ = in.readFloatBig(); - x14_ = in.readFloatBig(); - x18_ = in.readFloatBig(); - x1c_ = in.readFloatBig(); - x20_ = in.readFloatBig(); - x24_.readRGBABig(in); - x28_ = in.readFloatBig(); - x2c_ = in.readFloatBig(); - x30_ = in.readFloatBig(); - x34_ = in.readFloatBig(); - x38_.readRGBABig(in); - x3c_.readRGBABig(in); - x40_.readRGBABig(in); - x44_.readRGBABig(in); - x48_.readRGBABig(in); - x4c_.readRGBABig(in); - x50_.readRGBABig(in); - x54_ = in.readFloatBig(); - x58_ = in.readFloatBig(); - x5c_ = in.readFloatBig(); - x64_ = in.readFloatBig(); - x68_ = in.readFloatBig(); - x6c_ = in.readFloatBig(); - x70_ = in.readFloatBig(); - x74_ = in.readFloatBig(); - x78_ = in.readFloatBig(); - x7c_.readRGBABig(in); - x80_.readRGBABig(in); - x84_ = in.readFloatBig(); - x88_ = in.readFloatBig(); - x8c_ = in.readFloatBig(); - x90_ = in.readFloatBig(); - x94_ = in.readFloatBig(); - x98_ = in.readFloatBig(); - x9c_ = in.readFloatBig(); - xa0_ = in.readFloatBig(); - /* Originally 4 separate floats */ - xa4_doorCenter.readBig(in); - xb0_ = in.readFloatBig(); - xb4_ = in.readFloatBig(); - xb8_ = in.readFloatBig(); - xbc_ = in.readFloatBig(); - xc0_ = in.readFloatBig(); - xc4_ = in.readFloatBig(); - xc8_ = in.readFloatBig(); - xcc_ = in.readBool(); - xd0_ = in.readFloatBig(); - xd4_ = in.readFloatBig(); - xd8_ = in.readFloatBig(); - xdc_ = in.readFloatBig(); - xe0_ = in.readFloatBig(); - xe4_ = in.readFloatBig(); - xe8_ = in.readFloatBig(); - xec_ = in.readFloatBig(); - xf0_.readRGBABig(in); - xf4_.readRGBABig(in); - xf8_.readRGBABig(in); - xfc_.readRGBABig(in); - x100_doorColorCount = in.readUint32Big(); - for (u32 i = 0 ; i x104_doorColors; - zeus::CColor x118_doorBorderColor; - zeus::CColor x11c_openDoorColor; -public: - CTweakAutoMapper(CInputStream&); - const zeus::CVector3f& GetDoorCenter() const { return xa4_doorCenter; } -}; -} -} -#endif // __URDE_MP1_CTWEAKAUTOMAPPER_HPP__ diff --git a/Runtime/MP1/Tweaks/CTweakGui.cpp b/Runtime/MP1/Tweaks/CTweakGui.cpp deleted file mode 100644 index f22916bea..000000000 --- a/Runtime/MP1/Tweaks/CTweakGui.cpp +++ /dev/null @@ -1,215 +0,0 @@ -#include "CTweakGui.hpp" - -namespace urde -{ -u32 ReadUnknownValx27c(CInputStream& in) -{ - u32 tmp = in.readUint32Big(); - - if (tmp == 1) - return 2; - else if (tmp == 2) - return 4; - else if (tmp == 3) - return 5; - - return 0; -} -std::vector ReadScanSpeeds(CInputStream& in) -{ - u32 count = in.readUint32Big(); - std::vector ret; - ret.reserve(count); - for (u32 i = 0 ; i= x2c4_scanSpeeds.size()) - return 0.f; - return x2c4_scanSpeeds[idx]; -} - -} diff --git a/Runtime/MP1/Tweaks/CTweakGui.hpp b/Runtime/MP1/Tweaks/CTweakGui.hpp deleted file mode 100644 index a2c65fb36..000000000 --- a/Runtime/MP1/Tweaks/CTweakGui.hpp +++ /dev/null @@ -1,198 +0,0 @@ -#ifndef __URDE_MP1_CTWEAKGUI_HPP__ -#define __URDE_MP1_CTWEAKGUI_HPP__ - -#include "GuiSys/ITweakGui.hpp" -#include "zeus/CVector3f.hpp" -#include "zeus/CColor.hpp" - -namespace urde -{ -class CTweakGui : public ITweakGui -{ - bool x4_; - float x8_; - float xc_; - float x10_; - float x14_; - float x18_; - float x1c_; - float x20_; - float x24_; - float x28_; - u32 x2c_ = 0; - float x30_; - float x34_; - float x38_; - float x3c_; - bool x40_; - float x44_; - float x48_; - float x4c_; - float x50_; - float x54_; - float x58_; - float x5c_; - float x60_; - zeus::CVector3f x64_; - zeus::CVector3f x70_; - float x7c_; - float x80_; - float x84_; - float x88_; - float x8c_; - float x90_; - float x94_; - float x98_; - float x9c_; - float xa0_; - float xa4_; - u32 xa8_; - u32 xac_; - u32 xb0_; - float xb4_; - float xb8_; - float xbc_; - float xc0_; - float xc4_; - float xc8_; - float xcc_; - float xd0_; - u32 xd4_; - float xd8_; - float xdc_; - float xe0_; - float xe4_; - float xe8_; - float xec_; - float xf0_; - float xf4_; - u32 xf8_; - u32 xfc_; - u32 x100_; - u32 x104_; - u32 x108_; - u32 x10c_; - float x110_; - float x114_; - float x118_; - float x11c_; - float x120_; - float x124_; - float x128_; - float x12c_; - bool x130_; - float x134_; - float x138_; - float x13c_; - float x140_; - float x144_; - float x148_; - float x14c_; - std::string x150_; - std::string x160_; - std::string x170_; - std::string x180_; - std::string x190_; - float x1a0_; - float x1a4_; - float x1a8_; - float x1ac_; - float x1b0_; - float x1b4_; - float x1b8_; - float x1bc_; - float x1c0_; - float x1c4_; - float x1c8_; - bool x1cc_; - bool x1cd_; - float x1d0_; - float x1d4_; - float x1d8_; - float x1dc_; - float x1e0_; - float x1e4_; - float x1e8_; - float x1ec_; - float x1f0_; - float x1f4_; - float x1f8_; - float x1fc_; - zeus::CColor x200_; - float x204_ = 0.0014f; - float x208_ = 0.0000525f; - float x20c_; - float x210_; - float x214_; - float x218_; - float x21c_; - float x220_; - float x224_; - float x228_; - float x22c_; - float x230_; - float x234_; - float x238_; - float x23c_; - float x240_; - float x244_; - float x248_; - float x24c_; - float x250_; - float x254_; - float x258_; - float x25c_; - float x260_; - float x264_; - float x268_; - float x26c_; - float x270_; - bool x274_; - bool x275_ = true; - float x278_; - u32 x27c_; - float x280_; - float x284_; - zeus::CColor x288_; - float x28c_; - zeus::CColor x290_; - zeus::CColor x294_; - zeus::CColor x298_; - zeus::CColor x29c_; - zeus::CColor x2a0_; - zeus::CColor x2a4_; - zeus::CColor x2a8_; - zeus::CColor x2ac_; - zeus::CColor x2b0_; - zeus::CColor x2b4_; - float x2b8_; - float x2bc_; - float x2c0_; - std::vector x2c4_scanSpeeds; - std::string x2d0_; - std::string x2e0_; - std::string x2f0_; - zeus::CColor x300_; - zeus::CColor x304_; - float x308_; - float x30c_; - float x310_; - std::string x314_; - std::string x324_; - std::string x334_; - zeus::CColor x344_; - zeus::CColor x348_; - zeus::CColor x34c_; - zeus::CColor x350_; - zeus::CColor x354_; - zeus::CColor x358_; - float x35c_; - float x360_; - float x364_; -public: - CTweakGui(CInputStream&); - - float GetScanSpeed(s32) const; -}; -} -#endif // __URDE_MP1_CTWEAKGUI_HPP__ diff --git a/Runtime/MP1/Tweaks/CTweakPlayer.cpp b/Runtime/MP1/Tweaks/CTweakPlayer.cpp deleted file mode 100644 index 147db90fd..000000000 --- a/Runtime/MP1/Tweaks/CTweakPlayer.cpp +++ /dev/null @@ -1,182 +0,0 @@ -#include "CTweakPlayer.hpp" -#include "zeus/Math.hpp" - -namespace urde -{ -namespace MP1 -{ -CTweakPlayer::CTweakPlayer(urde::CInputStream& in) -{ - for (u32 i = 0 ; i<8 ; ++i) - x4_[i] = in.readFloatBig(); - for (u32 i = 0 ; i<8 ; ++i) - x24_[i] = in.readFloatBig(); - for (u32 i = 0 ; i<8 ; ++i) - x44_[i] = in.readFloatBig(); - for (u32 i = 0 ; i<8 ; ++i) - x64_[i] = in.readFloatBig(); - for (u32 i = 0 ; i<8 ; ++i) - x84_[i] = in.readFloatBig(); - for (u32 i = 0 ; i<8 ; ++i) - xa4_[i] = in.readFloatBig(); - xc4_ = in.readFloatBig(); - xc8_ = in.readFloatBig(); - xcc_ = in.readFloatBig(); - xd0_ = in.readFloatBig(); - xd4_ = in.readFloatBig(); - xd8_ = in.readFloatBig(); - xdc_ = in.readFloatBig(); - xe0_ = in.readFloatBig(); - xe4_ = in.readFloatBig(); - xe8_ = in.readFloatBig(); - xec_ = in.readFloatBig(); - xf0_ = in.readFloatBig(); - xf4_ = in.readFloatBig(); - xf8_ = in.readFloatBig(); - xfc_ = in.readFloatBig(); - x100_ = in.readFloatBig(); - x104_ = in.readFloatBig(); - x108_ = in.readFloatBig(); - x10c_ = in.readFloatBig(); - x11c_ = in.readFloatBig(); - x120_ = in.readFloatBig(); - x124_ = in.readFloatBig(); - x128_ = in.readFloatBig(); - x12c_ = in.readFloatBig(); - x130_ = zeus::degToRad(in.readFloatBig()); - x134_ = zeus::degToRad(in.readFloatBig()); - x138_ = zeus::degToRad(in.readFloatBig()); - x13c_ = zeus::degToRad(in.readFloatBig()); - x140_ = zeus::degToRad(in.readFloatBig()); - x144_ = zeus::degToRad(in.readFloatBig()); - x148_ = in.readFloatBig(); - x14c_ = in.readFloatBig(); - x150_ = in.readFloatBig(); - x228_24_ = in.readBool(); - x228_25_ = in.readBool(); - x228_26_ = in.readBool(); - x228_27_ = in.readBool(); - x228_28_ = in.readBool(); - x228_29_ = in.readBool(); - x228_30_ = in.readBool(); - x228_31_ = in.readBool(); - x229_24_ = in.readBool(); - x229_25_ = in.readBool(); - x229_26_ = in.readBool(); - x229_27_ = in.readBool(); - x229_28_ = in.readBool(); - x229_29_ = in.readBool(); - x229_30_ = in.readBool(); - x229_31_ = in.readBool(); - x22a_24_ = in.readBool(); - x22a_25_ = in.readBool(); - x22a_26_ = in.readBool(); - x22a_27_ = in.readBool(); - x22a_28_ = in.readBool(); - x22c_ = in.readFloatBig(); - x230_ = in.readFloatBig(); - x234_ = in.readFloatBig(); - x238_ = zeus::degToRad(in.readFloatBig()); - x23c_ = zeus::degToRad(in.readFloatBig()); - x240_ = zeus::degToRad(in.readFloatBig()); - x244_ = zeus::degToRad(in.readFloatBig()); - x248_ = zeus::degToRad(in.readFloatBig()); - x24c_ = in.readFloatBig(); - x250_ = zeus::degToRad(in.readFloatBig()); - x254_ = in.readFloatBig(); - x258_ = in.readFloatBig(); - x25c_ = in.readFloatBig(); - x260_ = in.readFloatBig(); - x264_ = zeus::degToRad(in.readFloatBig()); - for (u32 i = 0 ; i<3 ; ++i) - { - x158_[i] = in.readFloatBig(); - x164_[i] = in.readFloatBig(); - x170_[i] = in.readFloatBig(); - } - x17c_ = zeus::degToRad(in.readFloatBig()); - x180_ = in.readFloatBig(); - x184_ = zeus::degToRad(in.readFloatBig()); - x188_ = zeus::degToRad(in.readFloatBig()); - x18c_ = zeus::degToRad(in.readFloatBig()); - x190_ = zeus::degToRad(in.readFloatBig()); - x194_ = zeus::degToRad(in.readFloatBig()); - x198_ = zeus::degToRad(in.readFloatBig()); - x19c_ = in.readFloatBig(); - x1a0_ = in.readFloatBig(); - x1a4_ = in.readFloatBig(); - for (u32 i = 0 ; i<2 ; ++i) - { - x1a8_[i] = in.readUint32Big(); - x1b0_[i] = in.readUint32Big(); - x1b8_[i] = in.readUint32Big(); - x1c0_[i] = in.readUint32Big(); - x1c8_[i] = in.readUint32Big(); - } - - x1d8_ = in.readFloatBig(); - x1dc_ = in.readFloatBig(); - x1e0_ = in.readFloatBig(); - x1e4_ = in.readFloatBig(); - x1e8_ = in.readFloatBig(); - x1ec_ = in.readFloatBig(); - x1f0_ = zeus::degToRad(in.readFloatBig()); - x1f4_ = zeus::degToRad(in.readFloatBig()); - x1f8_ = in.readFloatBig(); - x1fc_ = in.readFloatBig(); - x200_24_ = in.readBool(); - x200_25_ = in.readBool(); - x204_ = in.readFloatBig(); - x208_ = in.readFloatBig(); - x20c_ = in.readFloatBig(); - x210_ = in.readFloatBig(); - x214_ = in.readFloatBig(); - x218_ = in.readFloatBig(); - x21c_24_ = in.readBool(); - x21c_25_ = in.readBool(); - x220_ = in.readFloatBig(); - x224_ = in.readFloatBig(); - x2a0_ = in.readFloatBig(); - x2a4_ = in.readFloatBig(); - x2a8_ = in.readFloatBig(); - x2ac_ = in.readFloatBig(); - x2b0_ = zeus::degToRad(in.readFloatBig()); - x2b4_ = in.readFloatBig(); - x2b8_ = in.readFloatBig(); - x2bc_ = in.readFloatBig(); - x2c0_ = zeus::degToRad(in.readFloatBig()); - x2c4_ = in.readFloatBig(); - x2c8_ = in.readFloatBig(); - x2cc_ = in.readFloatBig(); - x2d0_ = in.readUint32Big(); - x2d4_ = in.readBool(); - x2d5_ = in.readBool(); - x2d8_ = in.readFloatBig(); - x2dc_ = in.readFloatBig(); - x2e0_ = in.readFloatBig(); - x2e4_ = in.readFloatBig(); - x26c_ = in.readFloatBig(); - x270_ = in.readFloatBig(); - x274_ = in.readFloatBig(); - x278_ = in.readFloatBig(); - x27c_ = in.readFloatBig(); - x280_ = zeus::degToRad(in.readFloatBig()); - x284_ = zeus::degToRad(in.readFloatBig()); - x288_ = in.readFloatBig(); - x28c_ = in.readFloatBig(); - x290_ = zeus::degToRad(in.readFloatBig()); - x294_ = in.readFloatBig(); - x298_ = in.readFloatBig(); - x29c_ = zeus::degToRad(in.readFloatBig()); - x2e8_ = in.readFloatBig(); - x2ec_ = in.readFloatBig(); - x2f0_ = in.readFloatBig(); - x2f4_ = in.readBool(); - x2f8_ = in.readFloatBig(); - x2fc_ = in.readFloatBig(); - x300_ = in.readFloatBig(); - x304_ = in.readFloatBig(); - x308_ = in.readFloatBig(); -} -} -} diff --git a/Runtime/MP1/Tweaks/CTweakPlayer.hpp b/Runtime/MP1/Tweaks/CTweakPlayer.hpp deleted file mode 100644 index 10dba65c2..000000000 --- a/Runtime/MP1/Tweaks/CTweakPlayer.hpp +++ /dev/null @@ -1,202 +0,0 @@ -#ifndef __URDE_MP1_CTWEAKPLAYER_HPP__ -#define __URDE_MP1_CTWEAKPLAYER_HPP__ - -#include "RetroTypes.hpp" -#include "ITweak.hpp" -namespace urde -{ -namespace MP1 -{ -class CTweakPlayer : public ITweak -{ - float x4_[8]; - float x24_[8]; - float x44_[8]; - float x64_[8]; - float x84_[8]; - float xa4_[8]; - float xc4_; - float xc8_; - float xcc_; - float xd0_; - float xd4_; - float xd8_; - float xdc_; - float xe0_; - float xe4_; - float xe8_; - float xec_; - float xf0_; - float xf4_; - float xf8_; - float xfc_; - float x100_; - float x104_; - float x108_; - float x10c_; - float x110_; - float x114_; - float x118_; - float x11c_; - float x120_; - float x124_; - float x128_; - float x12c_; - float x130_; - float x134_; - float x138_; - float x13c_; - float x140_; - float x144_; - float x148_; - float x14c_; - float x150_; - float x154_; - float x158_[3]; - float x164_[3]; - float x170_[3]; - float x17c_; - float x180_; - float x184_; - float x188_; - float x18c_; - float x190_; - float x194_; - float x198_; - float x19c_; - float x1a0_; - float x1a4_; - u32 x1a8_[2]; - u32 x1b0_[2]; - u32 x1b8_[2]; - u32 x1c0_[2]; - u32 x1c8_[2]; - u32 x1d0_[2]; - float x1d8_; - float x1dc_; - float x1e0_; - float x1e4_; - float x1e8_; - float x1ec_; - float x1f0_; - float x1f4_; - float x1f8_; - float x1fc_; - union - { - struct - { - bool x200_24_ : 1; - bool x200_25_ : 1; - }; - u8 _dummy1 = 0; - }; - float x204_; - float x208_; - float x20c_; - float x210_; - float x214_; - float x218_; - union - { - struct - { - bool x21c_24_ : 1; - bool x21c_25_ : 1; - }; - u8 _dummy2 = 0; - }; - float x220_; - float x224_; - union - { - struct - { - bool x228_24_ : 1; - bool x228_25_ : 1; - bool x228_26_ : 1; - bool x228_27_ : 1; - bool x228_28_ : 1; - bool x228_29_ : 1; - bool x228_30_ : 1; - bool x228_31_ : 1; - bool x229_24_ : 1; - bool x229_25_ : 1; - bool x229_26_ : 1; - bool x229_27_ : 1; - bool x229_28_ : 1; - bool x229_29_ : 1; - bool x229_30_ : 1; - bool x229_31_ : 1; - bool x22a_24_ : 1; - bool x22a_25_ : 1; - bool x22a_26_ : 1; - bool x22a_27_ : 1; - bool x22a_28_ : 1; - }; - u32 _dummy3 = 0; - }; - float x22c_; - float x230_; - float x234_; - float x238_; - float x23c_; - float x240_; - float x244_; - float x248_; - float x24c_; - float x250_; - float x254_; - float x258_; - float x25c_; - float x260_; - float x264_; - float x268_; - float x26c_; - float x270_; - float x274_; - float x278_; - float x27c_; - float x280_; - float x284_; - float x288_; - float x28c_; - float x290_; - float x294_; - float x298_; - float x29c_; - float x2a0_; - float x2a4_; - float x2a8_; - float x2ac_; - float x2b0_; - float x2b4_; - float x2b8_; - float x2bc_; - float x2c0_; - float x2c4_; - float x2c8_; - float x2cc_; - u32 x2d0_; - bool x2d4_; - bool x2d5_; - float x2d8_; - float x2dc_; - float x2e0_; - float x2e4_; - float x2e8_; - float x2ec_; - float x2f0_; - bool x2f4_; - float x2f8_; - u32 x2fc_; - float x300_; - float x304_; - float x308_; -public: - CTweakPlayer(CInputStream&); - virtual ~CTweakPlayer() {} -}; -} -} -#endif // __URDE_MP1_CTWEAKPLAYER_HPP__