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

196 lines
9.2 KiB
C++
Raw Normal View History

Convert to pragma once
2018-10-07 03:42:33 +00:00
#pragma once
Work on CStateManager
2017-03-29 02:51:12 +00:00
CMetroidAreaCollider: Make use of std::array where applicable Makes arrays strongly typed and allows eliminating some hardcoded array sizes. We can also use it to make input data to some data types and functions significantly more informative. This also makes it easier for static analysis tools to track out of bounds accesses if they ever occur.
2020-04-06 08:52:56 +00:00
#include <array>
General: Normalize RuntimeCommon include paths Performs the same normalizing done to the RuntimeCommonB target, now all of the runtime headers have normalized include paths.
2019-09-28 02:53:03 +00:00
#include "Runtime/RetroTypes.hpp"
#include "Runtime/rstl.hpp"
#include "Runtime/Collision/CAreaOctTree.hpp"
#include <zeus/CAABox.hpp>
#include <zeus/CLineSeg.hpp>
#include <zeus/CVector3d.hpp>
#include <zeus/CVector3f.hpp>
Work on collision related implementations
2017-06-18 01:58:13 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
namespace urde {
Add some moving collision implementations
2017-06-22 17:56:51 +00:00
class CCollisionInfo;
General: Normalize RuntimeCommon include paths Performs the same normalizing done to the RuntimeCommonB target, now all of the runtime headers have normalized include paths.
2019-09-28 02:53:03 +00:00
class CCollisionInfoList;
Work on collision related implementations
2017-06-18 01:58:13 +00:00
class CMaterialList;
Work on CStateManager
2017-03-29 02:51:12 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
class CAABoxAreaCache {
friend class CMetroidAreaCollider;
const zeus::CAABox& x0_aabb;
CMetroidAreaCollider: Make use of std::array where applicable Makes arrays strongly typed and allows eliminating some hardcoded array sizes. We can also use it to make input data to some data types and functions significantly more informative. This also makes it easier for static analysis tools to track out of bounds accesses if they ever occur.
2020-04-06 08:52:56 +00:00
const std::array<zeus::CPlane, 6>& x4_planes;
New code style refactor
2018-12-08 05:30:43 +00:00
const CMaterialFilter& x8_filter;
const CMaterialList& xc_material;
CCollisionInfoList& x10_collisionList;
zeus::CVector3f x14_center;
zeus::CVector3f x20_halfExtent;
Finish AABB area colliders
2017-06-26 01:36:31 +00:00
public:
CMetroidAreaCollider: Make use of std::array where applicable Makes arrays strongly typed and allows eliminating some hardcoded array sizes. We can also use it to make input data to some data types and functions significantly more informative. This also makes it easier for static analysis tools to track out of bounds accesses if they ever occur.
2020-04-06 08:52:56 +00:00
CAABoxAreaCache(const zeus::CAABox& aabb, const std::array<zeus::CPlane, 6>& pl, const CMaterialFilter& filter,
New code style refactor
2018-12-08 05:30:43 +00:00
const CMaterialList& material, CCollisionInfoList& collisionList);
Finish AABB area colliders
2017-06-26 01:36:31 +00:00
};
New code style refactor
2018-12-08 05:30:43 +00:00
class CBooleanAABoxAreaCache {
friend class CMetroidAreaCollider;
const zeus::CAABox& x0_aabb;
const CMaterialFilter& x4_filter;
zeus::CVector3f x8_center;
zeus::CVector3f x14_halfExtent;
Initial CMetroidAreaCollider implementations
2017-06-24 04:58:59 +00:00
public:
New code style refactor
2018-12-08 05:30:43 +00:00
CBooleanAABoxAreaCache(const zeus::CAABox& aabb, const CMaterialFilter& filter);
Initial CMetroidAreaCollider implementations
2017-06-24 04:58:59 +00:00
};
New code style refactor
2018-12-08 05:30:43 +00:00
class CSphereAreaCache {
friend class CMetroidAreaCollider;
const zeus::CAABox& x0_aabb;
const zeus::CSphere& x4_sphere;
const CMaterialFilter& x8_filter;
const CMaterialList& xc_material;
CCollisionInfoList& x10_collisionList;
Finish CMetroidAreaCollider
2017-06-30 01:39:34 +00:00
public:
New code style refactor
2018-12-08 05:30:43 +00:00
CSphereAreaCache(const zeus::CAABox& aabb, const zeus::CSphere& sphere, const CMaterialFilter& filter,
const CMaterialList& material, CCollisionInfoList& collisionList);
Finish CMetroidAreaCollider
2017-06-30 01:39:34 +00:00
};
New code style refactor
2018-12-08 05:30:43 +00:00
class CBooleanSphereAreaCache {
friend class CMetroidAreaCollider;
const zeus::CAABox& x0_aabb;
const zeus::CSphere& x4_sphere;
const CMaterialFilter& x8_filter;
Finish CMetroidAreaCollider
2017-06-30 01:39:34 +00:00
public:
New code style refactor
2018-12-08 05:30:43 +00:00
CBooleanSphereAreaCache(const zeus::CAABox& aabb, const zeus::CSphere& sphere, const CMaterialFilter& filter);
Finish CMetroidAreaCollider
2017-06-30 01:39:34 +00:00
};
New code style refactor
2018-12-08 05:30:43 +00:00
struct SBoxEdge {
zeus::CLineSeg x0_seg;
zeus::CVector3d x28_start;
zeus::CVector3d x40_end;
zeus::CVector3d x58_delta;
zeus::CVector3d x70_coDir;
double x88_dirCoDirDot;
SBoxEdge(const zeus::CAABox& aabb, int idx, const zeus::CVector3f& dir);
Finish AABB area colliders
2017-06-26 01:36:31 +00:00
};
New code style refactor
2018-12-08 05:30:43 +00:00
class CMovingAABoxComponents {
friend class CMetroidAreaCollider;
friend class CCollidableOBBTree;
rstl::reserved_vector<SBoxEdge, 12> x0_edges;
rstl::reserved_vector<u32, 8> x6c4_vertIdxs;
zeus::CAABox x6e8_aabb;
Finish AABB area colliders
2017-06-26 01:36:31 +00:00
public:
New code style refactor
2018-12-08 05:30:43 +00:00
CMovingAABoxComponents(const zeus::CAABox& aabb, const zeus::CVector3f& dir);
Finish AABB area colliders
2017-06-26 01:36:31 +00:00
};
New code style refactor
2018-12-08 05:30:43 +00:00
class CMetroidAreaCollider {
friend class CCollidableOBBTree;
static u32 g_CalledClip;
static u32 g_RejectedByClip;
static u32 g_TrianglesProcessed;
static u32 g_DupTrianglesProcessed;
static u16 g_DupPrimitiveCheckCount;
CMetroidAreaCollider: Make use of std::array where applicable Makes arrays strongly typed and allows eliminating some hardcoded array sizes. We can also use it to make input data to some data types and functions significantly more informative. This also makes it easier for static analysis tools to track out of bounds accesses if they ever occur.
2020-04-06 08:52:56 +00:00
static std::array<u16, 0x5000> g_DupVertexList;
static std::array<u16, 0xC000> g_DupEdgeList;
static std::array<u16, 0x4000> g_DupTriangleList;
New code style refactor
2018-12-08 05:30:43 +00:00
static bool AABoxCollisionCheckBoolean_Internal(const CAreaOctTree::Node& node, const CBooleanAABoxAreaCache& cache);
static bool AABoxCollisionCheck_Internal(const CAreaOctTree::Node& node, const CAABoxAreaCache& cache);
static bool SphereCollisionCheckBoolean_Internal(const CAreaOctTree::Node& node,
const CBooleanSphereAreaCache& cache);
static bool SphereCollisionCheck_Internal(const CAreaOctTree::Node& node, const CSphereAreaCache& cache);
static bool MovingAABoxCollisionCheck_BoxVertexTri(const CCollisionSurface& surf, const zeus::CAABox& aabb,
const rstl::reserved_vector<u32, 8>& vertIndices,
const zeus::CVector3f& dir, double& d, zeus::CVector3f& normal,
zeus::CVector3f& point);
static bool MovingAABoxCollisionCheck_TriVertexBox(const zeus::CVector3f& vert, const zeus::CAABox& aabb,
const zeus::CVector3f& dir, double& d, zeus::CVector3f& normal,
zeus::CVector3f& point);
static bool MovingAABoxCollisionCheck_Edge(const zeus::CVector3f& ev0, const zeus::CVector3f& ev1,
const rstl::reserved_vector<SBoxEdge, 12>& edges,
const zeus::CVector3f& dir, double& d, zeus::CVector3f& normal,
zeus::CVector3f& point);
Work on CStateManager
2017-03-29 02:51:12 +00:00
public:
New code style refactor
2018-12-08 05:30:43 +00:00
class COctreeLeafCache {
friend class CMetroidAreaCollider;
const CAreaOctTree& x0_octTree;
rstl::reserved_vector<CAreaOctTree::Node, 64> x4_nodeCache;
bool x908_24_overflow : 1;
public:
Runtime: Add more usages of explicit Prevents error-prone implicit conversions where applicable. This targets the regular RuntimeCommon target this time around.
2020-03-31 03:52:22 +00:00
explicit COctreeLeafCache(const CAreaOctTree& octTree);
New code style refactor
2018-12-08 05:30:43 +00:00
void AddLeaf(const CAreaOctTree::Node& node);
u32 GetNumLeaves() const { return x4_nodeCache.size(); }
bool HasCacheOverflowed() const { return x908_24_overflow; }
const CAreaOctTree& GetOctTree() const { return x0_octTree; }
Implement CWallCrawlerSwarm
2019-03-24 08:06:59 +00:00
rstl::reserved_vector<CAreaOctTree::Node, 64>::const_iterator begin() const { return x4_nodeCache.begin(); }
rstl::reserved_vector<CAreaOctTree::Node, 64>::const_iterator end() const { return x4_nodeCache.end(); }
New code style refactor
2018-12-08 05:30:43 +00:00
};
static void BuildOctreeLeafCache(const CAreaOctTree::Node& root, const zeus::CAABox& aabb,
CMetroidAreaCollider::COctreeLeafCache& cache);
CCollisionSurface: Return std::array by reference from GetVerts() Same behavior, facilitates better static analysis for out-of-bounds accesses, and also even allows size querying if necessary.
2020-04-06 10:02:49 +00:00
static bool ConvexPolyCollision(const std::array<zeus::CPlane, 6>& planes,
const std::array<zeus::CVector3f, 3>& verts, zeus::CAABox& aabb);
New code style refactor
2018-12-08 05:30:43 +00:00
static bool AABoxCollisionCheckBoolean_Cached(const COctreeLeafCache& leafCache, const zeus::CAABox& aabb,
const CMaterialFilter& filter);
static bool AABoxCollisionCheckBoolean(const CAreaOctTree& octTree, const zeus::CAABox& aabb,
const CMaterialFilter& filter);
static bool SphereCollisionCheckBoolean_Cached(const COctreeLeafCache& leafCache, const zeus::CAABox& aabb,
const zeus::CSphere& sphere, const CMaterialFilter& filter);
static bool SphereCollisionCheckBoolean(const CAreaOctTree& octTree, const zeus::CAABox& aabb,
const zeus::CSphere& sphere, const CMaterialFilter& filter);
static bool AABoxCollisionCheck_Cached(const COctreeLeafCache& leafCache, const zeus::CAABox& aabb,
const CMaterialFilter& filter, const CMaterialList& matList,
CCollisionInfoList& list);
static bool AABoxCollisionCheck(const CAreaOctTree& octTree, const zeus::CAABox& aabb, const CMaterialFilter& filter,
const CMaterialList& matList, CCollisionInfoList& list);
static bool SphereCollisionCheck_Cached(const COctreeLeafCache& leafCache, const zeus::CAABox& aabb,
const zeus::CSphere& sphere, const CMaterialList& matList,
const CMaterialFilter& filter, CCollisionInfoList& list);
static bool SphereCollisionCheck(const CAreaOctTree& octTree, const zeus::CAABox& aabb, const zeus::CSphere& sphere,
const CMaterialList& matList, const CMaterialFilter& filter,
CCollisionInfoList& list);
static bool MovingAABoxCollisionCheck_Cached(const COctreeLeafCache& leafCache, const zeus::CAABox& aabb,
const CMaterialFilter& filter, const CMaterialList& matList,
const zeus::CVector3f& dir, float mag, CCollisionInfo& infoOut,
double& dOut);
static bool MovingSphereCollisionCheck_Cached(const COctreeLeafCache& leafCache, const zeus::CAABox& aabb,
const zeus::CSphere& sphere, const CMaterialFilter& filter,
const CMaterialList& matList, const zeus::CVector3f& dir, float mag,
CCollisionInfo& infoOut, double& dOut);
static void ResetInternalCounters();
Work on collision related implementations
2017-06-18 01:58:13 +00:00
};
New code style refactor
2018-12-08 05:30:43 +00:00
class CAreaCollisionCache {
zeus::CAABox x0_aabb;
rstl::reserved_vector<CMetroidAreaCollider::COctreeLeafCache, 3> x18_leafCaches;
Runtime/Collision: Replace bitfield unions with constructor initializers
2020-04-10 19:03:24 +00:00
bool x1b40_24_leafOverflow : 1;
bool x1b40_25_cacheOverflow : 1;
New code style refactor
2018-12-08 05:30:43 +00:00
Work on collision related implementations
2017-06-18 01:58:13 +00:00
public:
Runtime/Collision: Replace bitfield unions with constructor initializers
2020-04-10 19:03:24 +00:00
explicit CAreaCollisionCache(const zeus::CAABox& aabb)
: x0_aabb(aabb), x1b40_24_leafOverflow(false), x1b40_25_cacheOverflow(false) {}
New code style refactor
2018-12-08 05:30:43 +00:00
void ClearCache();
const zeus::CAABox& GetCacheBounds() const { return x0_aabb; }
void SetCacheBounds(const zeus::CAABox& aabb) { x0_aabb = aabb; }
void AddOctreeLeafCache(const CMetroidAreaCollider::COctreeLeafCache& leafCache);
u32 GetNumCaches() const { return x18_leafCaches.size(); }
const CMetroidAreaCollider::COctreeLeafCache& GetOctreeLeafCache(int idx) { return x18_leafCaches[idx]; }
bool HasCacheOverflowed() const { return x1b40_24_leafOverflow; }
Implement CWallCrawlerSwarm
2019-03-24 08:06:59 +00:00
rstl::reserved_vector<CMetroidAreaCollider::COctreeLeafCache, 3>::const_iterator begin() const
{ return x18_leafCaches.begin(); }
rstl::reserved_vector<CMetroidAreaCollider::COctreeLeafCache, 3>::const_iterator end() const
{ return x18_leafCaches.end(); }
Work on CStateManager
2017-03-29 02:51:12 +00:00
};
New code style refactor
2018-12-08 05:30:43 +00:00
} // namespace urde