Match and link IAnimReader.cpp

config/GM8E01_00/symbols.txt

@@ -18706,7 +18706,7 @@ lbl_803ED4B8 = .data:0x803ED4B8; // type:object size:0xC
 lbl_803ED4C4 = .data:0x803ED4C4; // type:object size:0xC
 lbl_803ED4D0 = .data:0x803ED4D0; // type:object size:0x1C
 lbl_803ED4EC = .data:0x803ED4EC; // type:object size:0x1C
-lbl_803ED508 = .data:0x803ED508; // type:object size:0x60
+__vt__11IAnimReader = .data:0x803ED508; // type:object size:0x60
 lbl_803ED568 = .data:0x803ED568; // type:object size:0x10
 __vt__15CARAMDvdRequest = .data:0x803ED578; // type:object size:0x1C scope:global
 __vt__15CRealDvdRequest = .data:0x803ED594; // type:object size:0x1C scope:global

config/GM8E01_01/splits.txt

@@ -878,8 +878,8 @@ MetroidPrime/Cameras/CPathCamera.cpp:
 
 MetroidPrime/CFluidPlaneManager.cpp:
 	.text       start:0x8012E988 end:0x8012F7F0
-	.data       start:0x803E0EC0 end:0x803E0EE0
 	.rodata     start:0x803D0218 end:0x803D0228
+	.data       start:0x803E0EC0 end:0x803E0EE0
 	.bss        start:0x8056FA94 end:0x80571BAC align:4 common
 	.sdata      start:0x805A78A8 end:0x805A78C0
 	.sdata2     start:0x805AB7C8 end:0x805AB830

config/GM8E01_01/symbols.txt

@@ -18740,7 +18740,7 @@ lbl_803ED698 = .data:0x803ED698; // type:object size:0xC
 lbl_803ED6A4 = .data:0x803ED6A4; // type:object size:0xC
 lbl_803ED6B0 = .data:0x803ED6B0; // type:object size:0x1C
 lbl_803ED6CC = .data:0x803ED6CC; // type:object size:0x1C
-lbl_803ED6E8 = .data:0x803ED6E8; // type:object size:0x60
+__vt__11IAnimReader = .data:0x803ED6E8; // type:object size:0x60
 lbl_803ED748 = .data:0x803ED748; // type:object size:0x10
 __vt__15CARAMDvdRequest = .data:0x803ED758; // type:object size:0x1C
 __vt__15CRealDvdRequest = .data:0x803ED774; // type:object size:0x1C

configure.py

@@ -921,7 +921,7 @@ config.libs = [
             Object(MatchingFor("GM8E01_00", "GM8E01_01"), "Kyoto/Animation/CPOINode.cpp"),
             Object(NonMatching, "Kyoto/Animation/CSegStatementSet.cpp"),
             Object(NonMatching, "Kyoto/Animation/CTimeScaleFunctions.cpp"),
-            Object(NonMatching, "Kyoto/Animation/IAnimReader.cpp"),
+            Object(MatchingFor("GM8E01_00", "GM8E01_01"), "Kyoto/Animation/IAnimReader.cpp"),
             Object(NonMatching, "Kyoto/Animation/CAllFormatsAnimSource.cpp"),
             Object(MatchingFor("GM8E01_00", "GM8E01_01"), "Kyoto/CDvdRequestManager.cpp"),
             Object(MatchingFor("GM8E01_00", "GM8E01_01"), "Kyoto/CDvdRequest.cpp"),

include/Kyoto/Animation/CCharAnimTime.hpp

@@ -17,7 +17,7 @@ public:
   float GetSeconds() const { return x0_time; }
 
   explicit CCharAnimTime(CInputStream& in);
-  explicit CCharAnimTime(float time);
+  explicit CCharAnimTime(float time = 0.f);
   explicit CCharAnimTime(const EType& type, const float& time) : x0_time(time), x4_type(type) {}
   CCharAnimTime(const CCharAnimTime& other) : x0_time(other.x0_time), x4_type(other.x4_type) {}
 

include/Kyoto/Animation/IAnimReader.hpp

@@ -1,28 +1,34 @@
 #ifndef _IANIMREADER
 #define _IANIMREADER
 
-#include "Kyoto/Math/CVector3f.hpp"
 #include "Kyoto/Math/CQuaternion.hpp"
+#include "Kyoto/Math/CVector3f.hpp"
 
 #include "Kyoto/Animation/CCharAnimTime.hpp"
+#include "Kyoto/Particles/CParticleData.hpp"
 
+#include "rstl/auto_ptr.hpp"
+#include "rstl/optional_object.hpp"
 #include "rstl/string.hpp"
 
 struct SAdvancementDeltas {
   CVector3f x0_posDelta;
   CQuaternion xc_rotDelta;
 
-  static SAdvancementDeltas Interpolate(const SAdvancementDeltas& a, const SAdvancementDeltas& b, float oldWeight,
+  SAdvancementDeltas() : x0_posDelta(CVector3f::Zero()), xc_rotDelta(CQuaternion::NoRotation()) {}
-                                        float newWeight);
+  static SAdvancementDeltas Interpolate(const SAdvancementDeltas& a, const SAdvancementDeltas& b,
-  static SAdvancementDeltas Blend(const SAdvancementDeltas& a, const SAdvancementDeltas& b, float w);
+                                        float oldWeight, float newWeight);
+  static SAdvancementDeltas Blend(const SAdvancementDeltas& a, const SAdvancementDeltas& b,
+                                  float w);
 };
 
 struct SAdvancementResults {
   CCharAnimTime x0_remTime;
   SAdvancementDeltas x8_deltas;
+  SAdvancementResults() {}
+  SAdvancementResults(const CCharAnimTime& time) : x0_remTime(time) {}
 };
 
-
 class CSteadyStateAnimInfo {
   CCharAnimTime x0_duration;
   CVector3f x8_offset;
@@ -45,9 +51,14 @@ struct CAnimTreeEffectiveContribution {
   u32 x34_dbIdx;
 
 public:
-  CAnimTreeEffectiveContribution(float cweight, const rstl::string& name, const CSteadyStateAnimInfo& ssInfo,
+  CAnimTreeEffectiveContribution(float cweight, const rstl::string& name,
-                                 const CCharAnimTime& remTime, u32 dbIdx)
+                                 const CSteadyStateAnimInfo& ssInfo, const CCharAnimTime& remTime,
-  : x0_contributionWeight(cweight), x4_name(name), x14_ssInfo(ssInfo), x2c_remTime(remTime), x34_dbIdx(dbIdx) {}
+                                 u32 dbIdx)
+  : x0_contributionWeight(cweight)
+  , x4_name(name)
+  , x14_ssInfo(ssInfo)
+  , x2c_remTime(remTime)
+  , x34_dbIdx(dbIdx) {}
   float GetContributionWeight() const { return x0_contributionWeight; }
   const rstl::string& GetPrimitiveName() const { return x4_name; }
   const CSteadyStateAnimInfo& GetSteadyStateAnimInfo() const { return x14_ssInfo; }
@@ -73,22 +84,38 @@ public:
   virtual bool VHasOffset(const CSegId& seg) const = 0;
   virtual CVector3f VGetOffset(const CSegId& seg) const = 0;
   virtual CQuaternion VGetRotation(const CSegId& seg) const = 0;
-  virtual size_t VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, size_t capacity, size_t iterator,
+  virtual uint VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, uint capacity,
-                                 u32) const = 0;
+                               uint iterator, uint) const = 0;
-  virtual size_t VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, size_t capacity, size_t iterator,
+  virtual uint VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, uint capacity,
-                                  u32) const = 0;
+                                uint iterator, int) const = 0;
-  virtual size_t VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, size_t capacity,
+  virtual uint VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut,
-                                     size_t iterator, u32) const = 0;
+                                   uint capacity, uint iterator, int) const = 0;
-  virtual size_t VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, size_t capacity, size_t iterator,
+  virtual uint VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, uint capacity,
-                                  u32) const = 0;
+                                uint iterator, int) const = 0;
   virtual bool VGetBoolPOIState(const rstl::string& name) const = 0;
   virtual s32 VGetInt32POIState(const rstl::string& name) const = 0;
-  // virtual CParticleData::EParentedMode VGetParticlePOIState(const rstl::string& name) const = 0;
+  virtual CParticleData::EParentedMode VGetParticlePOIState(const rstl::string& name) const = 0;
   virtual void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const = 0;
   virtual void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut,
                                    const CCharAnimTime& time) const = 0;
-  // virtual std::unique_ptr<IAnimReader> VClone() const = 0;
+  virtual rstl::auto_ptr< IAnimReader > VClone() const = 0;
+  virtual rstl::optional_object< rstl::auto_ptr< IAnimReader > > VSimplified();
+  virtual void VSetPhase(float) = 0;
+  virtual SAdvancementResults VGetAdvancementResults(const CCharAnimTime& aTime,
+                                                     const CCharAnimTime& bTime) const;
+  virtual uint Depth() const = 0;
+
+  uint GetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, uint capacity,
+                      uint iterator, int unk) const;
+
+  uint GetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, uint capacity,
+                       uint iterator, int unk) const;
+
+  uint GetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, uint capacity,
+                          uint iterator, int unk) const;
+
+  uint GetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, uint capacity,
+                       uint iterator, int unk) const;
 };
 
-
 #endif // _IANIMREADER

src/Kyoto/Animation/IAnimReader.cpp

@@ -0,0 +1,46 @@
+#include "Kyoto/Animation/IAnimReader.hpp"
+#include "Kyoto/Animation/CParticlePOINode.hpp"
+#include "Kyoto/Animation/CSoundPOINode.hpp"
+
+IAnimReader::~IAnimReader() {}
+
+rstl::optional_object< rstl::auto_ptr< IAnimReader > > IAnimReader::VSimplified() {
+  return rstl::optional_object_null();
+}
+
+SAdvancementResults IAnimReader::VGetAdvancementResults(const CCharAnimTime& aTime,
+                                                        const CCharAnimTime& bTime) const {
+  return SAdvancementResults(aTime);
+};
+
+uint IAnimReader::GetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, uint capacity,
+                                 uint iterator, int unk) const {
+  if (time.GreaterThanZero()) {
+    return VGetBoolPOIList(time, listOut, capacity, iterator, unk);
+  }
+  return 0;
+}
+
+uint IAnimReader::GetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, uint capacity,
+                                  uint iterator, int unk) const {
+  if (time.GreaterThanZero()) {
+    return VGetInt32POIList(time, listOut, capacity, iterator, unk);
+  }
+  return 0;
+}
+
+uint IAnimReader::GetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut,
+                                     uint capacity, uint iterator, int unk) const {
+  if (time.GreaterThanZero()) {
+    return VGetParticlePOIList(time, listOut, capacity, iterator, unk);
+  }
+  return 0;
+}
+
+uint IAnimReader::GetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, uint capacity,
+                                  uint iterator, int unk) const {
+  if (time.GreaterThanZero()) {
+    return VGetSoundPOIList(time, listOut, capacity, iterator, unk);
+  }
+  return 0;
+}

src/Kyoto/CDependencyGroup.cpp

@@ -1,6 +1,8 @@
 #include "Kyoto/CDependencyGroup.hpp"
 #include "Kyoto/CResFactory.hpp"
 #include "Kyoto/Streams/CInputStream.hpp"
+/* this is such a hack... */
+#pragma inline_max_size(250)
 
 CDependencyGroup::CDependencyGroup(CInputStream& in) { ReadFromStream(in); }
 
@@ -27,8 +29,7 @@ int CDependencyGroup::GetCountForResType(FourCC type) const {
   return ret;
 }
 
-/* this is such a hack... */
+
-#pragma inline_max_size(250)
 CFactoryFnReturn FDependencyGroupFactory(const SObjectTag& tag, CInputStream& in,
                                          const CVParamTransfer& xfer) {
   return rs_new CDependencyGroup(in);

src/Kyoto/Math/CMatrix3f.cpp

@@ -112,26 +112,36 @@ void CMatrix3f::AddScaledMatrix(const CMatrix3f& mat, float scale) {
   m22 = mat.m22 * scale + m22;
 }
 
-CMatrix3f::CMatrix3f(const CMatrix3f& other) {
+/* TODO: I think these are fake matches on compiler generated functions */
-  m00 = other.m00;
+CMatrix3f::CMatrix3f(register const CMatrix3f& other) {
-  m01 = other.m01;
+  register CMatrix3f &thiz = *this;
-  m02 = other.m02;
+  asm {
-  m10 = other.m10;
+    lfd f0, CMatrix3f.m00(other);
-  m11 = other.m11;
+    lfd f1, CMatrix3f.m02(other);
-  m12 = other.m12;
+    lfd f2, CMatrix3f.m11(other);
-  m20 = other.m20;
+    stfd f0, CMatrix3f.m00(thiz);
-  m21 = other.m21;
+    stfd f1, CMatrix3f.m02(thiz);
-  m22 = other.m22;
+    stfd f2, CMatrix3f.m11(thiz);
+    lfd f0, CMatrix3f.m20(other);
+    lfs f1, CMatrix3f.m22(other);
+    stfd f0, CMatrix3f.m20(thiz);
+    stfs f1, CMatrix3f.m22(thiz);
+  }
 }
 
-const CMatrix3f& CMatrix3f::operator=(const CMatrix3f& other) {
+const CMatrix3f& CMatrix3f::operator=(register const CMatrix3f& other) {
-  m00 = other.m00;
+  register CMatrix3f &thiz = *this;
-  m01 = other.m01;
+  asm {
-  m02 = other.m02;
+    lfd f0, CMatrix3f.m00(other);
-  m10 = other.m10;
+    lfd f1, CMatrix3f.m02(other);
-  m11 = other.m11;
+    lfd f2, CMatrix3f.m11(other);
-  m12 = other.m12;
+    stfd f0, CMatrix3f.m00(thiz);
-  m20 = other.m20;
+    stfd f1, CMatrix3f.m02(thiz);
-  m21 = other.m21;
+    stfd f2, CMatrix3f.m11(thiz);
-  m22 = other.m22;
+    lfd f0, CMatrix3f.m20(other);
+    lfs f1, CMatrix3f.m22(other);
+    stfd f0, CMatrix3f.m20(thiz);
+    stfs f1, CMatrix3f.m22(thiz);
+  }
+  return thiz;
 }

src/Kyoto/Math/RMathUtils.cpp

@@ -72,22 +72,27 @@ CVector3f CMath::BaryToWorld(const CVector3f& p0, const CVector3f& p1, const CVe
 
 float CMath::FastSinR(float x) {
   if (fabs(x) > M_PI) {
-    x = -((float)(int)(x * (1 / M_2PIF)) * M_2PIF - x);
+    f32 temp = x;
+    temp *= (1 / M_2PIF);
+    temp = (int)temp;
+    x -= temp * M_2PIF;
     if (x > M_PIF) {
-      x -= M_2PIF;
+      x = x - M_2PIF;
     } else if (x < -M_PIF) {
       x = M_2PIF + x;
     }
   }
 
-  float f4 = x * x;
+  float f4 = x;
-  float f5 = x * 0.9998508f;
+  f4 *= x;
+  float f5 = x;
+  f5 *= 0.9998508f;
   x *= f4;
-  f5 += -0.16621658f * x;
+  f5 += x * -0.16621658f;
   x *= f4;
-  f5 += 0.008087108f * x;
+  f5 += x * 0.008087108f;
   x *= f4;
-  f5 += -0.000152977f * x;
+  f5 += x * -0.000152977f;
   return f5;
 }
 

src/MetroidPrime/CExplosion.cpp

@@ -14,7 +14,7 @@
 
 CExplosion::CExplosion(const TLockedToken< CGenDescription >& particle, TUniqueId uid, bool active,
                        const CEntityInfo& info, const rstl::string& name, const CTransform4f& xf,
-                       uint flags, const CVector3f& scale, const CColor& color)
+                       const uint flags, const CVector3f& scale, const CColor& color)
 : CEffect(uid, info, active, name, xf)
 , xe8_particleGen(rs_new CElementGen(TToken< CGenDescription >(particle), CElementGen::kMOT_Normal,
                                      flags & 0x2 ? CElementGen::kOSF_Two : CElementGen::kOSF_One))