mirror of https://github.com/AxioDL/metaforce.git
286 lines
10 KiB
C++
286 lines
10 KiB
C++
#include "CCollisionPrimitive.hpp"
|
|
#include "CInternalRayCastStructure.hpp"
|
|
#include "CMaterialFilter.hpp"
|
|
#include "InternalColliders.hpp"
|
|
#include "CCollisionInfoList.hpp"
|
|
|
|
namespace urde {
|
|
s32 CCollisionPrimitive::sNumTypes = 0;
|
|
bool CCollisionPrimitive::sInitComplete = false;
|
|
bool CCollisionPrimitive::sTypesAdded = false;
|
|
bool CCollisionPrimitive::sTypesAdding = false;
|
|
bool CCollisionPrimitive::sCollidersAdded = false;
|
|
bool CCollisionPrimitive::sCollidersAdding = false;
|
|
std::unique_ptr<std::vector<CCollisionPrimitive::Type>> CCollisionPrimitive::sCollisionTypeList;
|
|
std::unique_ptr<std::vector<ComparisonFunc>> CCollisionPrimitive::sTableOfCollidables;
|
|
std::unique_ptr<std::vector<BooleanComparisonFunc>> CCollisionPrimitive::sTableOfBooleanCollidables;
|
|
std::unique_ptr<std::vector<MovingComparisonFunc>> CCollisionPrimitive::sTableOfMovingCollidables;
|
|
ComparisonFunc CCollisionPrimitive::sNullCollider = {};
|
|
BooleanComparisonFunc CCollisionPrimitive::sNullBooleanCollider = {};
|
|
MovingComparisonFunc CCollisionPrimitive::sNullMovingCollider = {};
|
|
CCollisionPrimitive::CCollisionPrimitive(const CMaterialList& list) : x8_material(list) {}
|
|
|
|
void CCollisionPrimitive::SetMaterial(const CMaterialList& material) { x8_material = material; }
|
|
|
|
const CMaterialList& CCollisionPrimitive::GetMaterial() const { return x8_material; }
|
|
|
|
CRayCastResult CCollisionPrimitive::CastRay(const zeus::CVector3f& start, const zeus::CVector3f& dir, float length,
|
|
const CMaterialFilter& filter, const zeus::CTransform& xf) const {
|
|
return CastRayInternal(CInternalRayCastStructure(start, dir, length, xf, filter));
|
|
}
|
|
|
|
bool CCollisionPrimitive::InternalCollide(const CInternalCollisionStructure& collision, CCollisionInfoList& list) {
|
|
u32 idx0 = collision.GetLeft().GetPrim().GetTableIndex();
|
|
u32 idx1 = collision.GetRight().GetPrim().GetTableIndex();
|
|
|
|
ComparisonFunc func;
|
|
if (idx0 == UINT32_MAX || idx1 == UINT32_MAX) {
|
|
sNullCollider = nullptr;
|
|
func = sNullCollider;
|
|
} else {
|
|
func = (*sTableOfCollidables)[sNumTypes * idx1 + idx0];
|
|
}
|
|
|
|
if (func) {
|
|
if (!collision.GetLeft().GetFilter().Passes(collision.GetRight().GetPrim().GetMaterial()) ||
|
|
!collision.GetRight().GetFilter().Passes(collision.GetLeft().GetPrim().GetMaterial()))
|
|
return false;
|
|
return func(collision, list);
|
|
}
|
|
|
|
if (idx0 == UINT32_MAX || idx1 == UINT32_MAX) {
|
|
sNullCollider = nullptr;
|
|
func = sNullCollider;
|
|
} else {
|
|
func = (*sTableOfCollidables)[sNumTypes * idx0 + idx1];
|
|
}
|
|
|
|
if (func) {
|
|
if (!collision.GetLeft().GetFilter().Passes(collision.GetRight().GetPrim().GetMaterial()) ||
|
|
!collision.GetRight().GetFilter().Passes(collision.GetLeft().GetPrim().GetMaterial()))
|
|
return false;
|
|
CInternalCollisionStructure swappedCollision(collision.GetRight(), collision.GetLeft());
|
|
u32 startListCount = list.GetCount();
|
|
if (func(swappedCollision, list)) {
|
|
for (auto it = list.begin() + startListCount; it != list.end(); ++it)
|
|
it->Swap();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CCollisionPrimitive::Collide(const CInternalCollisionStructure::CPrimDesc& prim0,
|
|
const CInternalCollisionStructure::CPrimDesc& prim1, CCollisionInfoList& list) {
|
|
return InternalCollide({prim0, prim1}, list);
|
|
}
|
|
|
|
bool CCollisionPrimitive::InternalCollideBoolean(const CInternalCollisionStructure& collision) {
|
|
u32 idx0 = collision.GetLeft().GetPrim().GetTableIndex();
|
|
u32 idx1 = collision.GetRight().GetPrim().GetTableIndex();
|
|
|
|
BooleanComparisonFunc func;
|
|
if (idx0 == UINT32_MAX || idx1 == UINT32_MAX) {
|
|
sNullBooleanCollider = nullptr;
|
|
func = sNullBooleanCollider;
|
|
} else {
|
|
func = (*sTableOfBooleanCollidables)[sNumTypes * idx1 + idx0];
|
|
}
|
|
|
|
if (func) {
|
|
if (!collision.GetLeft().GetFilter().Passes(collision.GetRight().GetPrim().GetMaterial()) ||
|
|
!collision.GetRight().GetFilter().Passes(collision.GetLeft().GetPrim().GetMaterial()))
|
|
return false;
|
|
return func(collision);
|
|
}
|
|
|
|
if (idx0 == UINT32_MAX || idx1 == UINT32_MAX) {
|
|
sNullBooleanCollider = nullptr;
|
|
func = sNullBooleanCollider;
|
|
} else {
|
|
func = (*sTableOfBooleanCollidables)[sNumTypes * idx0 + idx1];
|
|
}
|
|
|
|
if (func) {
|
|
if (!collision.GetLeft().GetFilter().Passes(collision.GetRight().GetPrim().GetMaterial()) ||
|
|
!collision.GetRight().GetFilter().Passes(collision.GetLeft().GetPrim().GetMaterial()))
|
|
return false;
|
|
CInternalCollisionStructure swappedCollision(collision.GetRight(), collision.GetLeft());
|
|
return func(swappedCollision);
|
|
}
|
|
|
|
CCollisionInfoList list;
|
|
return InternalCollide(collision, list);
|
|
}
|
|
|
|
bool CCollisionPrimitive::CollideBoolean(const CInternalCollisionStructure::CPrimDesc& prim0,
|
|
const CInternalCollisionStructure::CPrimDesc& prim1) {
|
|
return InternalCollideBoolean({prim0, prim1});
|
|
}
|
|
|
|
bool CCollisionPrimitive::InternalCollideMoving(const CInternalCollisionStructure& collision,
|
|
const zeus::CVector3f& dir, double& dOut, CCollisionInfo& infoOut) {
|
|
u32 idx0 = collision.GetLeft().GetPrim().GetTableIndex();
|
|
u32 idx1 = collision.GetRight().GetPrim().GetTableIndex();
|
|
|
|
MovingComparisonFunc func;
|
|
if (idx0 == UINT32_MAX || idx1 == UINT32_MAX) {
|
|
sNullMovingCollider = nullptr;
|
|
func = sNullMovingCollider;
|
|
} else {
|
|
func = (*sTableOfMovingCollidables)[sNumTypes * idx1 + idx0];
|
|
}
|
|
|
|
if (func) {
|
|
if (!collision.GetLeft().GetFilter().Passes(collision.GetRight().GetPrim().GetMaterial()) ||
|
|
!collision.GetRight().GetFilter().Passes(collision.GetLeft().GetPrim().GetMaterial()))
|
|
return false;
|
|
return func(collision, dir, dOut, infoOut);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CCollisionPrimitive::CollideMoving(const CInternalCollisionStructure::CPrimDesc& prim0,
|
|
const CInternalCollisionStructure::CPrimDesc& prim1, const zeus::CVector3f& dir,
|
|
double& dOut, CCollisionInfo& infoOut) {
|
|
return InternalCollideMoving({prim0, prim1}, dir, dOut, infoOut);
|
|
}
|
|
|
|
void CCollisionPrimitive::InitBeginTypes() {
|
|
sCollisionTypeList = std::make_unique<std::vector<Type>>();
|
|
sCollisionTypeList->reserve(3);
|
|
sTypesAdding = true;
|
|
InternalColliders::AddTypes();
|
|
}
|
|
|
|
void CCollisionPrimitive::InitAddType(const Type& tp) {
|
|
tp.GetSetter()(sCollisionTypeList->size());
|
|
sCollisionTypeList->push_back(tp);
|
|
}
|
|
|
|
void CCollisionPrimitive::InitEndTypes() {
|
|
sCollisionTypeList->shrink_to_fit();
|
|
sNumTypes = sCollisionTypeList->size();
|
|
sTypesAdding = false;
|
|
sTypesAdded = true;
|
|
}
|
|
|
|
void CCollisionPrimitive::InitBeginColliders() {
|
|
const size_t tableSz = sCollisionTypeList->size() * sCollisionTypeList->size();
|
|
sTableOfCollidables = std::make_unique<std::vector<ComparisonFunc>>(tableSz);
|
|
sTableOfBooleanCollidables = std::make_unique<std::vector<BooleanComparisonFunc>>(tableSz);
|
|
sTableOfMovingCollidables = std::make_unique<std::vector<MovingComparisonFunc>>(tableSz);
|
|
sCollidersAdding = true;
|
|
InternalColliders::AddColliders();
|
|
}
|
|
|
|
void CCollisionPrimitive::InitAddBooleanCollider(const CCollisionPrimitive::BooleanComparison& cmp) {
|
|
int idx0 = -1;
|
|
for (int i = 0; i < sCollisionTypeList->size(); ++i) {
|
|
if (!strcmp(cmp.GetType1(), (*sCollisionTypeList)[i].GetInfo())) {
|
|
idx0 = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
int idx1 = -1;
|
|
for (int i = 0; i < sCollisionTypeList->size(); ++i) {
|
|
if (!strcmp(cmp.GetType2(), (*sCollisionTypeList)[i].GetInfo())) {
|
|
idx1 = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (idx0 < 0 || idx1 < 0 || idx0 >= sNumTypes || idx1 >= sNumTypes)
|
|
return;
|
|
|
|
BooleanComparisonFunc& funcOut =
|
|
(idx0 == -1 || idx1 == -1) ? sNullBooleanCollider : (*sTableOfBooleanCollidables)[idx1 * sNumTypes + idx0];
|
|
funcOut = cmp.GetCollider();
|
|
}
|
|
|
|
void CCollisionPrimitive::InitAddBooleanCollider(BooleanComparisonFunc cmp, const char* a, const char* b) {
|
|
InitAddBooleanCollider({cmp, a, b});
|
|
}
|
|
|
|
void CCollisionPrimitive::InitAddMovingCollider(const CCollisionPrimitive::MovingComparison& cmp) {
|
|
int idx0 = -1;
|
|
for (int i = 0; i < sCollisionTypeList->size(); ++i) {
|
|
if (!strcmp(cmp.GetType1(), (*sCollisionTypeList)[i].GetInfo())) {
|
|
idx0 = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
int idx1 = -1;
|
|
for (int i = 0; i < sCollisionTypeList->size(); ++i) {
|
|
if (!strcmp(cmp.GetType2(), (*sCollisionTypeList)[i].GetInfo())) {
|
|
idx1 = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (idx0 < 0 || idx1 < 0 || idx0 >= sNumTypes || idx1 >= sNumTypes)
|
|
return;
|
|
|
|
MovingComparisonFunc& funcOut =
|
|
(idx0 == -1 || idx1 == -1) ? sNullMovingCollider : (*sTableOfMovingCollidables)[idx1 * sNumTypes + idx0];
|
|
funcOut = cmp.GetCollider();
|
|
}
|
|
|
|
void CCollisionPrimitive::InitAddMovingCollider(MovingComparisonFunc cmp, const char* a, const char* b) {
|
|
InitAddMovingCollider({cmp, a, b});
|
|
}
|
|
|
|
void CCollisionPrimitive::InitAddCollider(const CCollisionPrimitive::Comparison& cmp) {
|
|
int idx0 = -1;
|
|
for (int i = 0; i < sCollisionTypeList->size(); ++i) {
|
|
if (!strcmp(cmp.GetType1(), (*sCollisionTypeList)[i].GetInfo())) {
|
|
idx0 = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
int idx1 = -1;
|
|
for (int i = 0; i < sCollisionTypeList->size(); ++i) {
|
|
if (!strcmp(cmp.GetType2(), (*sCollisionTypeList)[i].GetInfo())) {
|
|
idx1 = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (idx0 < 0 || idx1 < 0 || idx0 >= sNumTypes || idx1 >= sNumTypes)
|
|
return;
|
|
|
|
ComparisonFunc& funcOut =
|
|
(idx0 == -1 || idx1 == -1) ? sNullCollider : (*sTableOfCollidables)[idx1 * sNumTypes + idx0];
|
|
funcOut = cmp.GetCollider();
|
|
}
|
|
|
|
void CCollisionPrimitive::InitAddCollider(ComparisonFunc cmp, const char* a, const char* b) {
|
|
InitAddCollider({cmp, a, b});
|
|
}
|
|
|
|
void CCollisionPrimitive::InitEndColliders() {
|
|
sCollidersAdding = false;
|
|
sCollidersAdded = true;
|
|
sInitComplete = true;
|
|
}
|
|
|
|
void CCollisionPrimitive::Uninitialize() {
|
|
sInitComplete = false;
|
|
sCollidersAdding = false;
|
|
sCollidersAdded = false;
|
|
sTypesAdding = false;
|
|
sTypesAdded = false;
|
|
sNumTypes = 0;
|
|
sCollisionTypeList.reset();
|
|
sTableOfCollidables.reset();
|
|
sTableOfMovingCollidables.reset();
|
|
sTableOfBooleanCollidables.reset();
|
|
}
|
|
|
|
} // namespace urde
|