CMetroidAreaCollider & CCollidableOBBTree

config/GM8E01_00/symbols.txt

@@ -11627,19 +11627,19 @@ GetTriangleArray__Q212CAreaOctTree4NodeCFv = .text:0x802A2D3C; // type:function
 GetChild__Q212CAreaOctTree4NodeCFi = .text:0x802A2D60; // type:function size:0x150 scope:global
 BoxFromIndex__FiRC9CVector3fRC9CVector3fRC9CVector3f = .text:0x802A2EB0; // type:function size:0x1EC scope:local
 __ct__Q220CMetroidAreaCollider22CMovingAABoxComponentsFRC6CAABoxRC9CVector3f = .text:0x802A309C; // type:function size:0x2E8 scope:global
-fn_802A3384 = .text:0x802A3384; // type:function size:0x48
-fn_802A33CC = .text:0x802A33CC; // type:function size:0x28
-fn_802A33F4 = .text:0x802A33F4; // type:function size:0xB4
+push_back__Q24rstl53reserved_vector<Q220CMetroidAreaCollider8SBoxEdge,12>FRCQ220CMetroidAreaCollider8SBoxEdge = .text:0x802A3384; // type:function size:0x48 scope:weak
+construct<Q220CMetroidAreaCollider8SBoxEdge>__4rstlFPvRCQ220CMetroidAreaCollider8SBoxEdge = .text:0x802A33CC; // type:function size:0x28 scope:local
+__ct__Q220CMetroidAreaCollider8SBoxEdgeFRCQ220CMetroidAreaCollider8SBoxEdge = .text:0x802A33F4; // type:function size:0xB4 scope:weak
 __ct__Q220CMetroidAreaCollider8SBoxEdgeFRC6CAABoxiRC9CVector3f = .text:0x802A34A8; // type:function size:0x118 scope:global
 FlagVertexIndicesForFace__FUiPb = .text:0x802A35C0; // type:function size:0xC4 scope:global
 FlagEdgeIndicesForFace__FUiPb = .text:0x802A3684; // type:function size:0xC4 scope:global
 BuildOctreeLeafCache__20CMetroidAreaColliderFRCQ212CAreaOctTree4NodeRC6CAABoxRQ220CMetroidAreaCollider16COctreeLeafCache = .text:0x802A3748; // type:function size:0xF0 scope:global
 ClearCache__19CAreaCollisionCacheFv = .text:0x802A3838; // type:function size:0xAC scope:global
 SetCacheBounds__19CAreaCollisionCacheFRC6CAABox = .text:0x802A38E4; // type:function size:0x34 scope:global
 AddOctreeLeafCache__19CAreaCollisionCacheFRCQ220CMetroidAreaCollider16COctreeLeafCache = .text:0x802A3918; // type:function size:0x78 scope:global
-fn_802A3990 = .text:0x802A3990; // type:function size:0x48
-fn_802A39D8 = .text:0x802A39D8; // type:function size:0x28
-fn_802A3A00 = .text:0x802A3A00; // type:function size:0x90
+push_back__Q24rstl61reserved_vector<Q220CMetroidAreaCollider16COctreeLeafCache,3>FRCQ220CMetroidAreaCollider16COctreeLeafCache = .text:0x802A3990; // type:function size:0x48 scope:global
+construct<Q220CMetroidAreaCollider16COctreeLeafCache>__4rstlFPvRCQ220CMetroidAreaCollider16COctreeLeafCache = .text:0x802A39D8; // type:function size:0x28 scope:local
+__ct__Q220CMetroidAreaCollider16COctreeLeafCacheFRCQ220CMetroidAreaCollider16COctreeLeafCache = .text:0x802A3A00; // type:function size:0x90 scope:global
 __ct__19CAreaCollisionCacheFRC6CAABox = .text:0x802A3A90; // type:function size:0x54 scope:global
 AddLeaf__Q220CMetroidAreaCollider16COctreeLeafCacheFRCQ212CAreaOctTree4Node = .text:0x802A3AE4; // type:function size:0x88 scope:global
 __ct__Q220CMetroidAreaCollider16COctreeLeafCacheFRC12CAreaOctTree = .text:0x802A3B6C; // type:function size:0x1C scope:global
@@ -11704,7 +11704,7 @@ LineIntersectsLeaf__18CCollidableOBBTreeCFRCQ28COBBTree9CLeafDataR12CRayCastInfo
 LineIntersectsOBBTree__18CCollidableOBBTreeCFPCQ28COBBTree5CNodePCQ28COBBTree5CNodeR12CRayCastInfo = .text:0x802A9A88; // type:function size:0x2E8 scope:global
 LineIntersectsOBBTree__18CCollidableOBBTreeCFPCQ28COBBTree5CNodeR12CRayCastInfo = .text:0x802A9D70; // type:function size:0xF0 scope:global
 LineIntersectsTree__18CCollidableOBBTreeCFRC5CMRayRC15CMaterialFilterfRC12CTransform4f = .text:0x802A9E60; // type:function size:0x26C scope:global
-TransformPlane__FRC6CPlaneRC12CTransform4f = .text:0x802AA0CC; // type:function size:0xEC scope:global
+TransformPlane__FRC6CPlaneRC12CTransform4f = .text:0x802AA0CC; // type:function size:0xEC scope:local
 CastRayInternal__18CCollidableOBBTreeCFRC25CInternalRayCastStructure = .text:0x802AA1B8; // type:function size:0x38 scope:global
 SphereCollideWithLeafMoving__18CCollidableOBBTreeCFRCQ28COBBTree9CLeafDataRC12CTransform4fRC7CSphereRC13CMaterialListRC15CMaterialFilterRC9CVector3fRdR14CCollisionInfo = .text:0x802AA1F0; // type:function size:0xF54 scope:global
 SphereCollisionMoving__18CCollidableOBBTreeCFRCQ28COBBTree5CNodeRC12CTransform4fRC7CSphereRC6COBBoxRC13CMaterialListRC15CMaterialFilterRC9CVector3fRdR14CCollisionInfo = .text:0x802AB144; // type:function size:0x13C scope:global
@@ -18701,8 +18701,8 @@ __vt__22CSustainedPlayerDamage = .data:0x803EC370; // type:object size:0x20
 __vt__17CPoisonProjectile = .data:0x803EC390; // type:object size:0x74 scope:global
 jumptable_803EC408 = .data:0x803EC408; // type:object size:0x20 scope:local
 lbl_803EC428 = .data:0x803EC428; // type:object size:0x10
-lbl_803EC438 = .data:0x803EC438; // type:object size:0x10
-lbl_803EC448 = .data:0x803EC448; // type:object size:0x28
+mod3$501 = .data:0x803EC438; // type:object size:0x10 scope:local
+__vt__18CCollidableOBBTree = .data:0x803EC448; // type:object size:0x28 scope:global
 __vt__23CCollidableOBBTreeGroup = .data:0x803EC470; // type:object size:0x28 scope:global
 __vt__60TObjOwnerDerivedFromIObj<32CCollidableOBBTreeGroupContainer> = .data:0x803EC498; // type:object size:0x10
 jumptable_803EC4A8 = .data:0x803EC4A8; // type:object size:0x20 scope:local
@@ -21239,7 +21239,7 @@ lbl_805A8620 = .sdata:0x805A8620; // type:object size:0x4 data:4byte
 lbl_805A8624 = .sdata:0x805A8624; // type:object size:0x4 data:4byte
 lbl_805A8628 = .sdata:0x805A8628; // type:object size:0x4 data:4byte
 lbl_805A862C = .sdata:0x805A862C; // type:object size:0x1 data:byte
-lbl_805A8630 = .sdata:0x805A8630; // type:object size:0x8 data:4byte
+sTableIndex__18CCollidableOBBTree = .sdata:0x805A8630; // type:object size:0x4 scope:global data:4byte
 lbl_805A8638 = .sdata:0x805A8638; // type:object size:0x8 data:4byte
 lbl_805A8640 = .sdata:0x805A8640; // type:object size:0x8
 skGlobalSeed__17CProjectileWeapon = .sdata:0x805A8648; // type:object size:0x4 data:4byte

include/Kyoto/Math/CUnitVector3f.hpp

@@ -13,6 +13,12 @@ class CUnitVector3f : public CVector3f {
   };
 
   CUnitVector3f(const float x, const float y, const float z) : CVector3f(x, y, z) {}
+  CUnitVector3f(const float x, const float y, const float z, const ENormalize normalize)
+  : CVector3f(x, y, z) {
+    if (normalize == kN_Yes) {
+      Normalize();
+    }
+  }
   CUnitVector3f(const CVector3f& vec, const ENormalize normalize) : CVector3f(vec) {
     if (normalize == kN_Yes) {
       Normalize();

include/Kyoto/Math/CVector3d.hpp

@@ -17,8 +17,8 @@ class CVector3d {
   double GetY() const { return mY; }
   double GetZ() const { return mZ; }
 
-  double& operator[](int i) { return (&mX)[i]; }
-  const double operator[](int i) const { return (&mX)[i]; }
+  double& operator[](int i) { return reinterpret_cast< double* >(this)[i]; }
+  const double& operator[](int i) const { return reinterpret_cast< const double* >(this)[i]; }
 
   static double Dot(const CVector3d& a, const CVector3d& b);
   static CVector3d Cross(const CVector3d& a, const CVector3d& b);

include/WorldFormat/CAreaOctTree.hpp

@@ -10,7 +10,8 @@
 
 #include "rstl/optional_object.hpp"
 
-class CCollisionEdge;
+#include "WorldFormat/CCollisionEdge.hpp"
+
 class CLine;
 class CMaterialFilter;
 
@@ -26,11 +27,18 @@ class CAreaOctTree {
 
   class TriListReference {
   public:
+    explicit TriListReference(const void* ptr)
+    : m_ptr(reinterpret_cast< const ushort* >(ptr)) {}
     explicit TriListReference(const ushort* ptr) : m_ptr(ptr) {}
-    ushort GetAt(int idx) const { return m_ptr[idx + 1]; }
-    ushort GetSize() const { return m_ptr[0]; }
+    ushort GetAt(int idx) const { return m_ptr[idx + kTriangleDataOffset]; }
+    ushort GetSize() const { return m_ptr[kTriangleCountOffset]; }
 
   private:
+    enum {
+      kTriangleCountOffset = sizeof(CAABox) / sizeof(ushort),
+      kTriangleDataOffset = kTriangleCountOffset + 1,
+    };
+
     const ushort* m_ptr;
   };
 
@@ -72,16 +80,24 @@ class CAreaOctTree {
   };
 
   CAreaOctTree(const CAABox& bounds, Node::ETreeType treeType, uchar* buf, void* treeBuf,
-                             uint materialCount, uint* materials, uchar* vertexMaterials, uchar* edgeMaterials,
-                             uchar* triMaterials, uint edgeCount, CCollisionEdge* edges, uint triCount,
-                             ushort* triangles, uint vertexCount, CVector3f* vertices);
+               uint materialCount, uint* materials, uchar* vertexMaterials,
+               uchar* edgeMaterials, uchar* triMaterials, uint edgeCount,
+               CCollisionEdge* edges, uint triCount, ushort* triangles, uint vertexCount,
+               CVector3f* vertices);
   void MakeFromMemory(void* buf, uint bufLen, CAreaOctTree** treeOut, bool*);
   CCollisionSurface GetMasterListTriangle(ushort idx) const;
   Node GetRootNode() const { return Node(x20_treeBuf, x0_aabb, *this, x18_treeType); }
   const void* GetTreeMemory() const { return x20_treeBuf; }
   const CAABox& GetBoundingBox() const { return x0_aabb; }
   Node::ETreeType GetTreeType() const { return x18_treeType; }
-  // TODO
+
+  const CVector3f& GetVert(int idx) const { return x4c_verts[idx]; }
+  const CCollisionEdge& GetEdge(int idx) const { return x3c_edges[idx]; }
+  uint GetVertMaterial(int idx) const { return x28_materials[x2c_vertMats[idx]]; }
+  uint GetEdgeMaterial(int idx) const { return x28_materials[x30_edgeMats[idx]]; }
+  uint GetTriangleMaterial(int idx) const { return x28_materials[x34_polyMats[idx]]; }
+  void GetTriangleVertexIndices(ushort idx, ushort indicesOut[3]) const;
+  const ushort* GetTriangleEdgeIndices(ushort idx) const;
 
 private:
   CAABox x0_aabb;

include/WorldFormat/CCollidableOBBTree.hpp

@@ -1,19 +1,114 @@
 #ifndef _CCOLLIDABLEOBBTREE
 #define _CCOLLIDABLEOBBTREE
 
-#include <Collision/CCollisionPrimitive.hpp>
+#include "Collision/CCollisionPrimitive.hpp"
+#include "Collision/CMaterialFilter.hpp"
+#include "Collision/CMaterialList.hpp"
 
-class COBBTree;
-class CCollidableOBBTree : public CCollisionPrimitive {
+#include "Kyoto/Math/CPlane.hpp"
+
+#include "WorldFormat/CMetroidAreaCollider.hpp"
+#include "WorldFormat/COBBTree.hpp"
+
+class CCollisionInfo;
+class CCollisionInfoList;
+class CMRay;
+class COBBox;
+class CSphere;
+
+class CRayCastInfo {
+  const CMRay& x0_ray;
+  const CMaterialFilter& x4_filter;
+  float x8_mag;
+  CPlane xc_plane;
+  CMaterialList x20_material;
 
 public:
-  CCollidableOBBTree(const COBBTree& tree, const CMaterialList& list);
+  CRayCastInfo(const CMRay& ray, const CMaterialFilter& filter, float mag)
+  : x0_ray(ray)
+  , x4_filter(filter)
+  , x8_mag(mag)
+  , xc_plane(CVector3f::Zero(), CUnitVector3f(CVector3f(0.f, 0.f, 1.f), CUnitVector3f::kN_Yes))
+  , x20_material() {}
+
+  const CMRay& GetRay() const { return x0_ray; }
+  const CMaterialFilter& GetMaterialFilter() const { return x4_filter; }
+  float GetMagnitude() const { return x8_mag; }
+  float& Magnitude() { return x8_mag; }
+  const CPlane& GetPlane() const { return xc_plane; }
+  CPlane& Plane() { return xc_plane; }
+  const CMaterialList& GetMaterial() const { return x20_material; }
+  CMaterialList& Material() { return x20_material; }
+};
+
+class CCollidableOBBTree : public CCollisionPrimitive {
+public:
+  CCollidableOBBTree(COBBTree* tree, const CMaterialList& list);
 
   uint GetTableIndex() const override;
   CAABox CalculateAABox(const CTransform4f& xf) const override;
-  const CAABox CalculateLocalAABox() const override;
+  CAABox CalculateLocalAABox() const override;
   FourCC GetPrimType() const override;
-  CRayCastResult CastRayInternal(const CInternalRayCastStructure& intRayCast) const override;
+  CRayCastResult CastRayInternal(const CInternalRayCastStructure& rayCast) const override;
+
+  const COBBTree& GetOBBTree() const { return *x10_tree; }
+
+  bool AABoxCollision(const COBBTree::CNode& node, const CTransform4f& xf, const CAABox& aabb,
+                      const COBBox& obb, const CMaterialList& material,
+                      const CMaterialFilter& filter, const CPlane* planes,
+                      CCollisionInfoList& infoList) const;
+  bool AABoxCollideWithLeaf(const COBBTree::CLeafData& leaf, const CTransform4f& xf,
+                            const CAABox& aabb, const CMaterialList& material,
+                            const CMaterialFilter& filter, const CPlane* planes,
+                            CCollisionInfoList& infoList) const;
+  bool SphereCollision(const COBBTree::CNode& node, const CTransform4f& xf,
+                       const CSphere& sphere, const COBBox& obb, const CMaterialList& material,
+                       const CMaterialFilter& filter, CCollisionInfoList& infoList) const;
+  bool SphereCollideWithLeaf(const COBBTree::CLeafData& leaf, const CTransform4f& xf,
+                             const CSphere& sphere, const CMaterialList& material,
+                             const CMaterialFilter& filter, CCollisionInfoList& infoList) const;
+  bool AABoxCollisionBoolean(const COBBTree::CNode& node, const CTransform4f& xf,
+                             const CAABox& aabb, const COBBox& obb,
+                             const CMaterialFilter& filter) const;
+  bool SphereCollisionBoolean(const COBBTree::CNode& node, const CTransform4f& xf,
+                              const CSphere& sphere, const COBBox& obb,
+                              const CMaterialFilter& filter) const;
+  bool AABoxCollisionMoving(const COBBTree::CNode& node, const CTransform4f& xf,
+                            const CAABox& aabb, const COBBox& obb,
+                            const CMaterialList& material, const CMaterialFilter& filter,
+                            const CMetroidAreaCollider::CMovingAABoxComponents& components,
+                            const CVector3f& dir, double& dOut, CCollisionInfo& info) const;
+  bool AABoxCollideWithLeafMoving(
+      const COBBTree::CLeafData& leaf, const CTransform4f& xf, const CAABox& aabb,
+      const CMaterialList& material, const CMaterialFilter& filter,
+      const CMetroidAreaCollider::CMovingAABoxComponents& components, const CVector3f& dir,
+      double& dOut, CCollisionInfo& info) const;
+  bool SphereCollisionMoving(const COBBTree::CNode& node, const CTransform4f& xf,
+                             const CSphere& sphere, const COBBox& obb,
+                             const CMaterialList& material, const CMaterialFilter& filter,
+                             const CVector3f& dir, double& dOut, CCollisionInfo& info) const;
+  bool SphereCollideWithLeafMoving(const COBBTree::CLeafData& leaf, const CTransform4f& xf,
+                                   const CSphere& sphere, const CMaterialList& material,
+                                   const CMaterialFilter& filter, const CVector3f& dir,
+                                   double& dOut, CCollisionInfo& info) const;
+
+  CRayCastResult LineIntersectsTree(const CMRay& ray, const CMaterialFilter& filter, float maxTime,
+                                    const CTransform4f& xf) const;
+  bool LineIntersectsOBBTree(const COBBTree::CNode* node, CRayCastInfo& info) const;
+  bool LineIntersectsOBBTree(const COBBTree::CNode* n0, const COBBTree::CNode* n1,
+                             CRayCastInfo& info) const;
+  bool LineIntersectsLeaf(const COBBTree::CLeafData& leaf, CRayCastInfo& info) const;
+
+  static void SetStaticTableIndex(uint idx) { sTableIndex = idx; }
+
+private:
+  COBBTree* x10_tree;
+  mutable uint x14_tries;
+  mutable uint x18_misses;
+  mutable uint x1c_hits;
+
+  static uint sTableIndex;
 };
+CHECK_SIZEOF(CCollidableOBBTree, 0x20)
 
 #endif // _CCOLLIDABLEOBBTREE