falso
/
botw
mirror of https://github.com/zeldaret/botw.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ksys/phys: Rename collision filter info structs for more clarity 

And consistency.
This commit is contained in:
Léo Lam 2022-02-28 22:01:05 +01:00
parent c18d9dc4b5
commit 7fab958e72
No known key found for this signature in database
GPG Key ID: 0DF30F9081000741
12 changed files with 155 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
data/uking_functions.csv
View File

@ -83016,8 +83016,8 @@ Address,Quality,Size,Name
0x0000007100f8f7a4,O,000208,_ZN4ksys4phys9RigidBody27setContactLayerAndGroundHitENS0_12ContactLayerENS0_9GroundHitE
0x0000007100f8f874,O,000088,_ZN4ksys4phys9RigidBody16setGroundHitTypeENS0_9GroundHitE
0x0000007100f8f8cc,O,000216,_ZN4ksys4phys9RigidBody37setContactLayerAndGroundHitAndHandlerENS0_12ContactLayerENS0_9GroundHitEPNS0_18SystemGroupHandlerE
0x0000007100f8f9a4,O,000068,_ZN4ksys4phys9RigidBody23setSensorCustomReceiverERKNS0_12ReceiverMaskE
0x0000007100f8f9e8,O,000092,_ZN4ksys4phys9RigidBody23setSensorCustomReceiverERKNS0_12ReceiverMaskEPKNS0_18SystemGroupHandlerE
0x0000007100f8f9a4,O,000068,_ZN4ksys4phys9RigidBody23setSensorCustomReceiverERKNS0_19SensorCollisionMaskE
0x0000007100f8f9e8,O,000092,_ZN4ksys4phys9RigidBody23setSensorCustomReceiverERKNS0_19SensorCollisionMaskEPKNS0_18SystemGroupHandlerE
0x0000007100f8fa44,O,000092,_ZN4ksys4phys9RigidBody16setGroundHitMaskENS0_12ContactLayerEj
0x0000007100f8faa0,O,000056,_ZN4ksys4phys9RigidBody28addGroundTypeToGroundHitMaskENS0_9GroundHitE
0x0000007100f8fad8,O,000044,_ZNK4ksys4phys9RigidBody16getGroundHitTypeEv
@ -83772,7 +83772,7 @@ Address,Quality,Size,Name
0x0000007100fb3b50,U,000100,phys::ContactInfoTable::x_22
0x0000007100fb3bb4,U,000652,phys::ContactInfoTable::getLayerMaskForContactPoints
0x0000007100fb3e40,U,000644,phys::ContactInfoTable::getLayerMaskForCollisionInfoStuff
0x0000007100fb40c4,O,000356,_ZNK4ksys4phys10ContactMgr18getSensorLayerMaskEPNS0_12ReceiverMaskERKN4sead14SafeStringBaseIcEE
0x0000007100fb40c4,O,000356,_ZNK4ksys4phys10ContactMgr18getSensorLayerMaskEPNS0_19SensorCollisionMaskERKN4sead14SafeStringBaseIcEE
0x0000007100fb4228,U,000204,phys::ContactInfoTable::x_26
0x0000007100fb42f4,U,001092,phys::ContactInfoTable::x_27
0x0000007100fb4738,U,000668,phys::ContactInfoTable::x_28
@ -83782,9 +83782,9 @@ Address,Quality,Size,Name
0x0000007100fb4bb0,O,000160,_ZN4ksys4phys16ContactInfoTable8ReceiverD2Ev
0x0000007100fb4c50,O,000004,_ZN4ksys4phys16ContactInfoTable8ReceiverD0Ev
0x0000007100fb4c54,O,000432,_ZN4sead9SafeArrayIN3agl3utl9ParameterIiEELi32EEC2Ev
0x0000007100fb4e04,O,000056,_ZN4ksys4phys23receiverMaskEnableLayerEPNS0_12ReceiverMaskENS0_12ContactLayerE
0x0000007100fb4e3c,O,000036,_ZN4ksys4phys37receiverMaskGetSensorLayerMaskForTypeEPNS0_12ReceiverMaskERKN4sead14SafeStringBaseIcEE
0x0000007100fb4e60,O,000016,_ZN4ksys4phys30receiverMaskSetSensorLayerMaskEPNS0_12ReceiverMaskEj
0x0000007100fb4e04,O,000056,_ZN4ksys4phys23receiverMaskEnableLayerEPNS0_19SensorCollisionMaskENS0_12ContactLayerE
0x0000007100fb4e3c,O,000036,_ZN4ksys4phys37receiverMaskGetSensorLayerMaskForTypeEPNS0_19SensorCollisionMaskERKN4sead14SafeStringBaseIcEE
0x0000007100fb4e60,O,000016,_ZN4ksys4phys30receiverMaskSetSensorLayerMaskEPNS0_19SensorCollisionMaskEj
0x0000007100fb4e70,O,000144,_ZN4ksys4phys17EntityGroupFilter4makeENS0_12ContactLayer9ValueTypeES3_PN4sead4HeapE
0x0000007100fb4f00,O,000004,_ZN4ksys4phys17EntityGroupFilterD1Ev
0x0000007100fb4f04,O,000008,_ZThn16_N4ksys4phys17EntityGroupFilterD1Ev
@ -84142,8 +84142,8 @@ Address,Quality,Size,Name
0x0000007100fc82b8,U,000188,
0x0000007100fc8374,O,000192,_ZN4ksys4phys17SensorGroupFilter30doInitSystemGroupHandlerLists_EPN4sead4HeapE
0x0000007100fc8434,O,000016,_ZN4ksys4phys17SensorGroupFilter16getFreeListIndexEPKNS0_18SystemGroupHandlerE
0x0000007100fc8444,O,000072,_ZN4ksys4phys26sensorReceiverMaskSetLayerENS0_12ContactLayerEj
0x0000007100fc848c,O,000060,_ZN4ksys4phys27sensorReceiverMaskSetLayer2EbNS0_12ContactLayerEj
0x0000007100fc8444,O,000072,_ZN4ksys4phys27sensorCollisionMaskSetLayerENS0_12ContactLayerEj
0x0000007100fc848c,O,000060,_ZN4ksys4phys28sensorCollisionMaskSetLayer2EbNS0_12ContactLayerEj
0x0000007100fc84c8,O,000056,_ZN4ksys4phys24SensorSystemGroupHandler23makeCollisionFilterInfoEjNS0_12ContactLayerENS0_9GroundHitE
0x0000007100fc8500,O,000020,_ZN4ksys4phys24SensorSystemGroupHandler22makeQueryCollisionMaskEjNS0_9GroundHitEb
0x0000007100fc8514,O,000020,_ZN4ksys4phys24SensorSystemGroupHandler2m8Ev

Can't render this file because it is too large.

26
src/KingSystem/Physics/RigidBody/physRigidBody.cpp
View File

@ -651,7 +651,7 @@ ContactLayer RigidBody::getContactLayer() const {
return getContactLayer(getEntityCollisionFilterInfo());
}
ContactLayer RigidBody::getContactLayer(EntityCollisionFilterInfo info) const {
ContactLayer RigidBody::getContactLayer(EntityCollisionMask info) const {
return isSensor() ? info.getLayerSensor() : info.getLayer();
}
@ -662,7 +662,7 @@ void RigidBody::setContactLayer(ContactLayer layer) {
const auto current_info = getCollisionFilterInfo();
auto info = current_info;
if (isSensor())
info = sensorReceiverMaskSetLayer(layer, info);
info = sensorCollisionMaskSetLayer(layer, info);
else
info = makeEntityCollisionMask(layer, info);
@ -704,7 +704,7 @@ void RigidBody::setCollisionFilterInfo(u32 info) {
if (getCollisionFilterInfo() != info) {
if (isFlag8Set()) {
if (int(current_layer) != getContactLayer(EntityCollisionFilterInfo(info)))
if (int(current_layer) != getContactLayer(EntityCollisionMask(info)))
System::instance()->registerRigidBodyForContactSystem(this);
}
@ -720,7 +720,7 @@ void RigidBody::setCollisionFilterInfo(u32 info) {
void RigidBody::setSensorReceiverLayer2(ContactLayer layer) {
static_cast<void>(isSensor());
static_cast<void>(isSensor());
const auto info = sensorReceiverMaskSetLayer2(true, layer, getCollisionFilterInfo());
const auto info = sensorCollisionMaskSetLayer2(true, layer, getCollisionFilterInfo());
setCollisionFilterInfo(info);
}
@ -733,7 +733,7 @@ void RigidBody::clearSensorReceiverLayer2() {
// The layer we pass here is actually irrelevant because we're clearing the layer value anyway.
const auto info =
sensorReceiverMaskSetLayer2(false, ContactLayer::SensorNoHit, getCollisionFilterInfo());
sensorCollisionMaskSetLayer2(false, ContactLayer::SensorNoHit, getCollisionFilterInfo());
setCollisionFilterInfo(info);
}
@ -769,30 +769,30 @@ void RigidBody::setSystemGroupHandler(SystemGroupHandler* handler) {
SEAD_WARN("handler layer type doesn't match rigid body type; ignoring handler");
}
} else if (isEntity()) {
setCollisionFilterInfo(EntityCollisionFilterInfo::make(layer, ground_hit).raw);
setCollisionFilterInfo(EntityCollisionMask::make(layer, ground_hit).raw);
} else {
setCollisionFilterInfo(ReceiverMask::make(layer).raw);
setCollisionFilterInfo(SensorCollisionMask::make(layer).raw);
}
}
void RigidBody::setSensorCustomReceiver(const ReceiverMask& mask) {
ReceiverMask info = mask;
void RigidBody::setSensorCustomReceiver(const SensorCollisionMask& mask) {
SensorCollisionMask info = mask;
if (!isSensor())
return;
info.raw = sensorReceiverMaskSetLayer(ContactLayer::SensorCustomReceiver, info.raw);
info.raw = sensorCollisionMaskSetLayer(ContactLayer::SensorCustomReceiver, info.raw);
setCollisionFilterInfo(info.raw);
}
void RigidBody::setSensorCustomReceiver(const ReceiverMask& mask,
void RigidBody::setSensorCustomReceiver(const SensorCollisionMask& mask,
const SystemGroupHandler* handler) {
ReceiverMask info = mask;
SensorCollisionMask info = mask;
if (!isSensor())
return;
info.raw = sensorReceiverMaskSetLayer(ContactLayer::SensorCustomReceiver, info.raw);
info.raw = sensorCollisionMaskSetLayer(ContactLayer::SensorCustomReceiver, info.raw);
if (handler) {
info.group_handler_index.SetUnsafe(handler->getIndex());
}

9
src/KingSystem/Physics/RigidBody/physRigidBody.h
View File

@ -216,7 +216,7 @@ public:
// region Collision filter info, receiver, group handler
ContactLayer getContactLayer() const;
ContactLayer getContactLayer(EntityCollisionFilterInfo info) const;
ContactLayer getContactLayer(EntityCollisionMask info) const;
/// Set a new contact layer. Its type must match the layer type of this rigid body.
/// (Otherwise, this function does nothing.)
void setContactLayer(ContactLayer layer);
@ -225,7 +225,7 @@ public:
void setCollisionFilterInfo(u32 info);
auto getEntityCollisionFilterInfo() const {
return EntityCollisionFilterInfo(getCollisionFilterInfo());
return EntityCollisionMask(getCollisionFilterInfo());
}
/// Only works for sensor rigid bodies that do not use a custom receiver.
@ -241,8 +241,9 @@ public:
void setSystemGroupHandler(SystemGroupHandler* handler);
void setSensorCustomReceiver(const ReceiverMask& mask);
void setSensorCustomReceiver(const ReceiverMask& mask, const SystemGroupHandler* handler);
void setSensorCustomReceiver(const SensorCollisionMask& mask);
void setSensorCustomReceiver(const SensorCollisionMask& mask,
const SystemGroupHandler* handler);
// endregion

4
src/KingSystem/Physics/RigidBody/physRigidBodyFromShape.cpp
View File

@ -343,14 +343,14 @@ RigidBodyT* RigidBodyFromShape::make(const Shape& shape, RigidBodyInstanceParam*
if (body->isEntity()) {
const u32 idx = group_handler ? group_handler->getIndex() : 0;
collision_filter_info = [&] {
EntityCollisionFilterInfo info{collision_filter_info};
EntityCollisionMask info{collision_filter_info};
info.group_handler_index.SetUnsafe(idx);
return info.raw;
}();
} else {
const u32 idx = group_handler ? group_handler->getIndex() : 0;
collision_filter_info = [&] {
ReceiverMask info{collision_filter_info};
SensorCollisionMask info{collision_filter_info};
info.group_handler_index.SetUnsafe(idx);
return info.raw;
}();

2
src/KingSystem/Physics/RigidBody/physRigidBodyParam.h
View File

@ -82,7 +82,7 @@ public:
GroundHit groundhit = GroundHit::HitAll;
u32 groundhit_mask = 0;
u32 contact_mask = 0;
ReceiverMask receiver_mask{ReceiverMask::CustomReceiverTag{}};
SensorCollisionMask receiver_mask{SensorCollisionMask::CustomReceiverTag{}};
bool ignore_normal_for_impulse = false;
bool no_hit_ground = false;
bool no_hit_water = false;

2
src/KingSystem/Physics/System/physContactMgr.cpp
View File

@ -112,7 +112,7 @@ void ContactMgr::freeContactPoints(IRigidContactPoints* points) {
delete points;
}
bool ContactMgr::getSensorLayerMask(ReceiverMask* mask,
bool ContactMgr::getSensorLayerMask(SensorCollisionMask* mask,
const sead::SafeString& receiver_type) const {
const auto& receivers = mContactInfoTables[int(ContactLayerType::Sensor)].receivers;
for (int i = 0; i < receivers.size(); ++i) {

2
src/KingSystem/Physics/System/physContactMgr.h
View File

@ -77,7 +77,7 @@ public:
void loadContactInfoTable(sead::Heap* heap, agl::utl::ResParameterArchive archive,
ContactLayerType type);
bool getSensorLayerMask(ReceiverMask* mask, const sead::SafeString& receiver_type) const;
bool getSensorLayerMask(SensorCollisionMask* mask, const sead::SafeString& receiver_type) const;
RigidContactPoints* allocContactPoints(sead::Heap* heap, int num, const sead::SafeString& name,
int a, int b, int c);

51
src/KingSystem/Physics/System/physEntityGroupFilter.cpp
View File

@ -21,16 +21,16 @@ namespace ksys::phys {
constexpr int NumEntityHandlersInList0 = 0x10;
constexpr int NumEntityHandlers = 0x400;
void receiverMaskEnableLayer(ReceiverMask* mask, ContactLayer layer) {
void receiverMaskEnableLayer(SensorCollisionMask* mask, ContactLayer layer) {
mask->raw |= 1 << getContactLayerBaseRelativeValue(layer);
}
bool receiverMaskGetSensorLayerMaskForType(ReceiverMask* mask,
bool receiverMaskGetSensorLayerMaskForType(SensorCollisionMask* mask,
const sead::SafeString& receiver_type) {
return System::instance()->getContactMgr()->getSensorLayerMask(mask, receiver_type);
}
void receiverMaskSetSensorLayerMask(ReceiverMask* mask, u32 layer_mask) {
void receiverMaskSetSensorLayerMask(SensorCollisionMask* mask, u32 layer_mask) {
*mask = {};
mask->layer_mask = layer_mask;
mask->is_custom_receiver = true;
@ -56,10 +56,10 @@ void EntityGroupFilter::doInit_(sead::Heap* heap) {
hkBool EntityGroupFilter::shouldHandleGroundCollision(u32 infoA, u32 infoB,
ContactLayer::ValueType layerA,
ContactLayer::ValueType layerB) const {
const EntityCollisionFilterInfo a{infoA};
const EntityCollisionFilterInfo b{infoB};
const EntityCollisionMask a{infoA};
const EntityCollisionMask b{infoB};
if (EntityCollisionFilterInfo(infoA | infoB).ground_col_mode != GroundCollisionMode::Normal) {
if (EntityCollisionMask(infoA | infoB).ground_col_mode != GroundCollisionMode::Normal) {
if (a.ground_col_mode != GroundCollisionMode::Normal) {
bool ground = isEntityGroundLayer(layerB);
if (a.ground_col_mode == GroundCollisionMode::IgnoreNonGround && !ground)
@ -82,10 +82,10 @@ hkBool EntityGroupFilter::shouldHandleGroundCollision(u32 infoA, u32 infoB,
hkBool EntityGroupFilter::shouldHandleWaterCollision(u32 infoA, u32 infoB,
ContactLayer::ValueType layerA,
ContactLayer::ValueType layerB) const {
const EntityCollisionFilterInfo a{infoA};
const EntityCollisionFilterInfo b{infoB};
const EntityCollisionMask a{infoA};
const EntityCollisionMask b{infoB};
if (EntityCollisionFilterInfo(infoA | infoB).water_col_mode != WaterCollisionMode::Normal) {
if (EntityCollisionMask(infoA | infoB).water_col_mode != WaterCollisionMode::Normal) {
if (a.water_col_mode == WaterCollisionMode::IgnoreWater &&
layerB == ContactLayer::EntityWater) {
return false;
@ -108,13 +108,13 @@ hkBool EntityGroupFilter::testCollisionForEntities(u32 infoA, u32 infoB) const {
if (mInhibitCollisions)
return false;
const EntityCollisionFilterInfo a{infoA};
const EntityCollisionFilterInfo b{infoB};
const EntityCollisionMask a{infoA};
const EntityCollisionMask b{infoB};
constexpr auto GroupHandlerIdxMask = decltype(a.group_handler_index)::GetMask();
constexpr auto GroupHandlerIdxShift = decltype(a.group_handler_index)::StartBit();
if (!EntityCollisionFilterInfo(infoA | infoB).is_ground_hit_mask) {
if (!EntityCollisionMask(infoA | infoB).is_ground_hit_mask) {
if (a.unk30 && b.unk30) {
if (((infoA ^ infoB) & GroupHandlerIdxMask) != 0) {
if (testHandler(a.group_handler_index) || testHandler(b.group_handler_index))
@ -171,7 +171,7 @@ hkBool EntityGroupFilter::testCollisionForEntities(u32 infoA, u32 infoB) const {
return !a.ground_hit.unk23 && !b.ground_hit.unk23;
}
EntityCollisionFilterInfo entity_mask, ground_hit_mask;
EntityCollisionMask entity_mask, ground_hit_mask;
if (a.is_ground_hit_mask && !b.is_ground_hit_mask) {
const auto layerA = static_cast<ContactLayer::ValueType>(a.ground_hit.layer.Value());
@ -212,8 +212,8 @@ hkBool EntityGroupFilter::testCollisionForPhantom(u32 infoPhantom, u32 infoB) co
if (mInhibitCollisions)
return false;
RayCastCollisionMask infoPhantomData{infoPhantom};
const EntityCollisionFilterInfo info{infoB};
EntityQueryCollisionMask infoPhantomData{infoPhantom};
const EntityCollisionMask info{infoB};
if (info.is_ground_hit_mask)
return infoPhantomData.raw & (1 << info.ground_hit.getLayer());
return infoPhantomData.layer_mask & (1 << info.data.layer);
@ -311,9 +311,8 @@ end:
return testCollisionForEntities(infoA, infoB);
}
static hkBool
checkCollisionWithGroundHitMask(EntityCollisionFilterInfo::GroundHitMask ground_hit_mask,
RayCastCollisionMask ray_cast) {
static hkBool checkCollisionWithGroundHitMask(EntityCollisionMask::GroundHitMask ground_hit_mask,
EntityQueryCollisionMask ray_cast) {
if (!(ray_cast.layer_mask & (1 << ground_hit_mask.getLayer())))
return false;
@ -330,8 +329,8 @@ hkBool EntityGroupFilter::testCollisionForRayCasting(u32 infoRayCast, u32 info)
if (mInhibitCollisions)
return false;
RayCastCollisionMask a{infoRayCast};
EntityCollisionFilterInfo b{info};
EntityQueryCollisionMask a{infoRayCast};
EntityCollisionMask b{info};
if (b.is_ground_hit_mask)
return checkCollisionWithGroundHitMask(b.ground_hit, a);
@ -393,7 +392,7 @@ int EntityGroupFilter::getFreeListIndex(const SystemGroupHandler* handler) {
}
u32 orEntityGroundHitMask(u32 mask, GroundHit type) {
EntityCollisionFilterInfo info{mask};
EntityCollisionMask info{mask};
info.ground_hit.ground_hit_types |= 1 << type;
return info.raw;
}
@ -403,9 +402,9 @@ u32 orEntityGroundHitMask(u32 mask, const sead::SafeString& type) {
}
template <bool WithUnk>
static EntityCollisionFilterInfo makeEntityGroundHitMaskImpl(ContactLayer layer, u32 mask) {
const EntityCollisionFilterInfo current{mask};
EntityCollisionFilterInfo info{};
static EntityCollisionMask makeEntityGroundHitMaskImpl(ContactLayer layer, u32 mask) {
const EntityCollisionMask current{mask};
EntityCollisionMask info{};
info.ground_hit.layer.SetUnsafe(layer);
info.ground_hit.ground_hit_types = current.ground_hit.ground_hit_types;
info.is_ground_hit_mask = true;
@ -419,7 +418,7 @@ u32 makeEntityGroundHitMask(ContactLayer layer, u32 mask) {
}
u32 makeEntityCollisionMask(ContactLayer layer, u32 mask) {
EntityCollisionFilterInfo current{mask};
EntityCollisionMask current{mask};
if (current.is_ground_hit_mask) {
return makeEntityGroundHitMaskImpl<true>(layer, mask).raw;
} else {
@ -429,7 +428,7 @@ u32 makeEntityCollisionMask(ContactLayer layer, u32 mask) {
}
u32 setEntityCollisionMaskGroundHit(GroundHit ground_hit, u32 mask) {
EntityCollisionFilterInfo current{mask};
EntityCollisionMask current{mask};
if (current.is_ground_hit_mask) {
// This shouldn't happen: this function is not supposed to be called on ground hit masks.
} else {

30
src/KingSystem/Physics/System/physEntityGroupFilter.h
View File

@ -81,10 +81,10 @@ private:
sead::SafeArray<u32, ContactLayer::size()> mMasks;
};
void receiverMaskEnableLayer(ReceiverMask* mask, ContactLayer layer);
bool receiverMaskGetSensorLayerMaskForType(ReceiverMask* mask,
void receiverMaskEnableLayer(SensorCollisionMask* mask, ContactLayer layer);
bool receiverMaskGetSensorLayerMaskForType(SensorCollisionMask* mask,
const sead::SafeString& receiver_type);
void receiverMaskSetSensorLayerMask(ReceiverMask* mask, u32 layer_mask);
void receiverMaskSetSensorLayerMask(SensorCollisionMask* mask, u32 layer_mask);
u32 orEntityGroundHitMask(u32 mask, GroundHit type);
u32 orEntityGroundHitMask(u32 mask, const sead::SafeString& type);
@ -102,8 +102,8 @@ u32 setEntityCollisionMaskGroundHit(GroundHit ground_hit, u32 mask);
inline u32 EntitySystemGroupHandler::makeCollisionFilterInfo(u32 info, ContactLayer layer,
GroundHit ground_hit) {
const EntityCollisionFilterInfo current_info{info};
EntityCollisionFilterInfo result;
const EntityCollisionMask current_info{info};
EntityCollisionMask result;
if (layer == ContactLayer::EntityRagdoll) {
result.data.layer.Init(layer);
@ -123,7 +123,7 @@ inline u32 EntitySystemGroupHandler::makeCollisionFilterInfo(u32 info, ContactLa
inline u32 EntitySystemGroupHandler::makeQueryCollisionMask(u32 layer_mask, GroundHit ground_hit,
bool unk) {
RayCastCollisionMask mask;
EntityQueryCollisionMask mask;
mask.layer_mask = layer_mask;
mask.group_handler_index.Init(getIndex());
mask.ground_hit_type.Init(static_cast<GroundHit::ValueType>(int(ground_hit)));
@ -132,7 +132,7 @@ inline u32 EntitySystemGroupHandler::makeQueryCollisionMask(u32 layer_mask, Grou
}
inline u32 EntitySystemGroupHandler::makeRagdollCollisionFilterInfo(GroundHit ground_hit) {
EntityCollisionFilterInfo info;
EntityCollisionMask info;
info.data.layer.Init(ContactLayer::EntityRagdoll);
info.group_handler_index.Init(getIndex());
info.data.ground_hit.Init(ground_hit);
@ -148,16 +148,16 @@ inline bool EntityGroupFilter::m2(ContactLayer layerA, ContactLayer layerB) {
}
inline u32 EntityGroupFilter::makeCollisionFilterInfo(ContactLayer layer, GroundHit ground_hit) {
return EntityCollisionFilterInfo::make(layer, ground_hit).raw;
return EntityCollisionMask::make(layer, ground_hit).raw;
}
inline ContactLayer EntityGroupFilter::getCollisionFilterInfoLayer(u32 info) {
return EntityCollisionFilterInfo(info).getLayer();
return EntityCollisionMask(info).getLayer();
}
inline u32 EntityGroupFilter::makeQueryCollisionMask(u32 layer_mask, GroundHit ground_hit,
bool unk) {
RayCastCollisionMask mask;
EntityQueryCollisionMask mask;
mask.layer_mask = layer_mask;
mask.ground_hit_type = ground_hit.value();
mask.unk.SetBit(unk);
@ -165,19 +165,19 @@ inline u32 EntityGroupFilter::makeQueryCollisionMask(u32 layer_mask, GroundHit g
}
inline GroundHit EntityGroupFilter::getQueryCollisionMaskGroundHit(u32 info) {
return RayCastCollisionMask(info).ground_hit_type.Value();
return EntityQueryCollisionMask(info).ground_hit_type.Value();
}
inline void EntityGroupFilter::getCollisionFilterInfoLayerAndGroundHit(u32 info,
ContactLayer* layer,
GroundHit* ground_hit) {
EntityCollisionFilterInfo info_{info};
EntityCollisionMask info_{info};
*layer = info_.getLayer();
*ground_hit = info_.getGroundHit();
}
inline const char* EntityGroupFilter::getCollisionFilterInfoLayerText(u32 info) {
EntityCollisionFilterInfo info_{info};
EntityCollisionMask info_{info};
if (info_.is_ground_hit_mask) {
return "GroundHitMaskMode";
}
@ -189,12 +189,12 @@ inline void EntityGroupFilter::setLayerCustomMask(ContactLayer layer, u32 mask)
}
inline u32 EntityGroupFilter::getCollisionFilterInfoGroupHandlerIdx(u32 info) {
return EntityCollisionFilterInfo(info).group_handler_index;
return EntityCollisionMask(info).group_handler_index;
}
inline u32 EntityGroupFilter::makeCollisionFilterInfo(ContactLayer layer, GroundHit ground_hit,
u32 unk5, u32 unk10) {
EntityCollisionFilterInfo info;
EntityCollisionMask info;
info.data.layer.Init(layer);
info.data.unk5.Init(unk5);
info.data.unk10.Init(unk10);

8
src/KingSystem/Physics/System/physSensorGroupFilter.cpp
View File

@ -73,10 +73,10 @@ int SensorGroupFilter::getFreeListIndex(const SystemGroupHandler* handler) {
return handler->getIndex() < NumSensorHandlersInList0;
}
u32 sensorReceiverMaskSetLayer(ContactLayer layer, u32 mask) {
u32 sensorCollisionMaskSetLayer(ContactLayer layer, u32 mask) {
SEAD_ASSERT(getContactLayerType(layer) == ContactLayerType::Sensor);
ReceiverMask info{mask};
SensorCollisionMask info{mask};
if (layer == ContactLayer::SensorCustomReceiver) {
info.is_custom_receiver = true;
@ -98,10 +98,10 @@ u32 sensorReceiverMaskSetLayer(ContactLayer layer, u32 mask) {
return info.raw;
}
u32 sensorReceiverMaskSetLayer2(bool set, ContactLayer layer, u32 mask) {
u32 sensorCollisionMaskSetLayer2(bool set, ContactLayer layer, u32 mask) {
SEAD_ASSERT(getContactLayerType(layer) == ContactLayerType::Sensor);
ReceiverMask info{mask};
SensorCollisionMask info{mask};
if (info.is_custom_receiver)
return info.raw;

24
src/KingSystem/Physics/System/physSensorGroupFilter.h
View File

@ -58,23 +58,23 @@ protected:
void doInit_(sead::Heap* heap) override;
};
/// Set the contact layer in a sensor receiver mask.
/// Set the contact layer in a sensor collision mask.
/// @param layer A sensor contact layer
/// @param mask An existing receiver mask
u32 sensorReceiverMaskSetLayer(ContactLayer layer, u32 mask);
/// @param mask An existing sensor collision mask
u32 sensorCollisionMaskSetLayer(ContactLayer layer, u32 mask);
/// Set or clear a second contact layer in a sensor receiver mask.
/// Set or clear a second contact layer in a sensor collision mask.
/// This function does nothing when using a custom receiver.
/// @param set If true, set the specified layer. Clear it otherwise
/// @param layer A sensor contact layer
/// @param mask An existing receiver mask
/// @param mask An existing sensor collision mask
// TODO: rename once we figure out what this layer is used for
u32 sensorReceiverMaskSetLayer2(bool set, ContactLayer layer, u32 mask);
u32 sensorCollisionMaskSetLayer2(bool set, ContactLayer layer, u32 mask);
inline u32 SensorSystemGroupHandler::makeCollisionFilterInfo(u32 info, ContactLayer layer,
GroundHit ground_hit) {
const ReceiverMask current_info{info};
ReceiverMask result;
const SensorCollisionMask current_info{info};
SensorCollisionMask result;
if (layer == ContactLayer::SensorCustomReceiver) {
result.is_custom_receiver = true;
@ -101,11 +101,11 @@ inline bool SensorSystemGroupHandler::m8() {
}
inline u32 SensorGroupFilter::makeCollisionFilterInfo(ContactLayer layer, GroundHit ground_hit) {
return ReceiverMask::make(layer).raw;
return SensorCollisionMask::make(layer).raw;
}
inline ContactLayer SensorGroupFilter::getCollisionFilterInfoLayer(u32 info) {
return ReceiverMask(info).getLayer();
return SensorCollisionMask(info).getLayer();
}
inline u32 SensorGroupFilter::makeQueryCollisionMask(u32 layer_mask, GroundHit ground_hit,
@ -122,7 +122,7 @@ inline GroundHit SensorGroupFilter::getQueryCollisionMaskGroundHit(u32 info) {
inline void SensorGroupFilter::getCollisionFilterInfoLayerAndGroundHit(u32 info,
ContactLayer* layer,
GroundHit* ground_hit) {
ReceiverMask mask{info};
SensorCollisionMask mask{info};
*layer = mask.getLayer();
*ground_hit = {};
}
@ -132,7 +132,7 @@ inline const char* SensorGroupFilter::getCollisionFilterInfoLayerText(u32 info)
}
inline u32 SensorGroupFilter::getCollisionFilterInfoGroupHandlerIdx(u32 info) {
return ReceiverMask(info).group_handler_index;
return SensorCollisionMask(info).group_handler_index;
}
inline u32 SensorGroupFilter::makeCollisionFilterInfo(ContactLayer layer, GroundHit ground_hit,

136
src/KingSystem/Physics/physDefines.h
View File

@ -208,59 +208,7 @@ enum class WaterCollisionMode {
IgnoreWater = 1,
};
// TODO: rename to SensorCollisionFilterInfo.
union ReceiverMask {
struct CustomReceiverTag {};
union Data {
ContactLayer getLayer() const { return int(layer) + FirstSensor; }
/// ContactLayer minus FirstSensor.
util::BitField<0, 5, u32> layer;
// TODO: rename once we figure out what this layer is used for
util::BitField<5, 1, bool, u32> has_layer2;
util::BitField<6, 5, u32> layer2;
};
union CustomReceiverData {
util::BitField<0, NumRegularSensorLayers, u32> layer;
};
constexpr ReceiverMask() : raw(0) {}
constexpr explicit ReceiverMask(CustomReceiverTag) : raw(0) { is_custom_receiver = true; }
constexpr explicit ReceiverMask(u32 raw_) : raw(raw_) {}
constexpr ReceiverMask(const ReceiverMask&) = default;
constexpr ReceiverMask& operator=(const ReceiverMask& m) {
raw = m.raw;
return *this;
}
static ReceiverMask make(ContactLayer layer) {
ReceiverMask mask;
if (layer == ContactLayer::SensorCustomReceiver) {
mask.is_custom_receiver = true;
mask.custom_receiver_data.layer.Init(ContactLayer::SensorCustomReceiver - FirstSensor);
} else {
mask.is_custom_receiver = false;
mask.data.layer.Init(layer - FirstSensor);
}
return mask;
}
ContactLayer getLayer() const {
return is_custom_receiver ? ContactLayer::SensorCustomReceiver : data.getLayer();
}
u32 raw;
Data data;
CustomReceiverData custom_receiver_data;
/// Sensor layer mask.
util::BitField<0, NumRegularSensorLayers, u32> layer_mask;
util::BitField<21, 10, u32> group_handler_index;
util::BitField<31, 1, bool, u32> is_custom_receiver;
};
union EntityCollisionFilterInfo {
union EntityCollisionMask {
union Data {
ContactLayer getLayer() const { return int(layer); }
ContactLayer getLayerSensor() const { return int(layer + FirstSensor); }
@ -292,18 +240,18 @@ union EntityCollisionFilterInfo {
util::BitField<25, 5, u32> layer;
};
constexpr explicit EntityCollisionFilterInfo(u32 raw_ = 0) : raw(raw_) {}
constexpr EntityCollisionFilterInfo(const EntityCollisionFilterInfo&) = default;
constexpr EntityCollisionFilterInfo& operator=(const EntityCollisionFilterInfo& m) {
constexpr explicit EntityCollisionMask(u32 raw_ = 0) : raw(raw_) {}
constexpr EntityCollisionMask(const EntityCollisionMask&) = default;
constexpr EntityCollisionMask& operator=(const EntityCollisionMask& m) {
raw = m.raw;
return *this;
}
bool operator==(EntityCollisionFilterInfo rhs) const { return raw == rhs.raw; }
bool operator!=(EntityCollisionFilterInfo rhs) const { return raw != rhs.raw; }
bool operator==(EntityCollisionMask rhs) const { return raw == rhs.raw; }
bool operator!=(EntityCollisionMask rhs) const { return raw != rhs.raw; }
static EntityCollisionFilterInfo make(ContactLayer layer, GroundHit ground_hit) {
EntityCollisionFilterInfo mask;
static EntityCollisionMask make(ContactLayer layer, GroundHit ground_hit) {
EntityCollisionMask mask;
mask.data.layer.Init(layer);
mask.data.ground_hit.Init(ground_hit);
return mask;
@ -334,19 +282,18 @@ union EntityCollisionFilterInfo {
util::BitField<30, 1, bool, u32> unk30;
util::BitField<31, 1, bool, u32> is_ground_hit_mask;
};
static_assert(sizeof(EntityCollisionFilterInfo) == sizeof(u32));
static_assert(sizeof(EntityCollisionMask) == sizeof(u32));
/// Collision mask that is used for raycast-based queries against entities.
// TODO: rename to make it clear this is used for entities, not sensors
union RayCastCollisionMask {
constexpr explicit RayCastCollisionMask(u32 raw_ = 0) : raw(raw_) {}
constexpr RayCastCollisionMask(const RayCastCollisionMask&) = default;
constexpr RayCastCollisionMask& operator=(const RayCastCollisionMask& m) {
union EntityQueryCollisionMask {
constexpr explicit EntityQueryCollisionMask(u32 raw_ = 0) : raw(raw_) {}
constexpr EntityQueryCollisionMask(const EntityQueryCollisionMask&) = default;
constexpr EntityQueryCollisionMask& operator=(const EntityQueryCollisionMask& m) {
raw = m.raw;
return *this;
}
constexpr bool operator==(RayCastCollisionMask rhs) const { return raw == rhs.raw; }
constexpr bool operator!=(RayCastCollisionMask rhs) const { return raw != rhs.raw; }
constexpr bool operator==(EntityQueryCollisionMask rhs) const { return raw == rhs.raw; }
constexpr bool operator!=(EntityQueryCollisionMask rhs) const { return raw != rhs.raw; }
util::BitField<0, NumRegularEntityLayers, u32> layer_mask;
util::BitField<17, 1, u32> unk;
@ -355,6 +302,59 @@ union RayCastCollisionMask {
u32 raw;
};
union SensorCollisionMask {
struct CustomReceiverTag {};
union Data {
ContactLayer getLayer() const { return int(layer) + FirstSensor; }
/// ContactLayer minus FirstSensor.
util::BitField<0, 5, u32> layer;
// TODO: rename once we figure out what this layer is used for
util::BitField<5, 1, bool, u32> has_layer2;
util::BitField<6, 5, u32> layer2;
};
union CustomReceiverData {
util::BitField<0, NumRegularSensorLayers, u32> layer;
};
constexpr SensorCollisionMask() : raw(0) {}
constexpr explicit SensorCollisionMask(CustomReceiverTag) : raw(0) {
is_custom_receiver = true;
}
constexpr explicit SensorCollisionMask(u32 raw_) : raw(raw_) {}
constexpr SensorCollisionMask(const SensorCollisionMask&) = default;
constexpr SensorCollisionMask& operator=(const SensorCollisionMask& m) {
raw = m.raw;
return *this;
}
static SensorCollisionMask make(ContactLayer layer) {
SensorCollisionMask mask;
if (layer == ContactLayer::SensorCustomReceiver) {
mask.is_custom_receiver = true;
mask.custom_receiver_data.layer.Init(ContactLayer::SensorCustomReceiver - FirstSensor);
} else {
mask.is_custom_receiver = false;
mask.data.layer.Init(layer - FirstSensor);
}
return mask;
}
ContactLayer getLayer() const {
return is_custom_receiver ? ContactLayer::SensorCustomReceiver : data.getLayer();
}
u32 raw;
Data data;
CustomReceiverData custom_receiver_data;
/// Sensor layer mask.
util::BitField<0, NumRegularSensorLayers, u32> layer_mask;
util::BitField<21, 10, u32> group_handler_index;
util::BitField<31, 1, bool, u32> is_custom_receiver;
};
/// Collision mask that is used for raycast-based queries against sensors.
union SensorQueryCollisionMask {
constexpr explicit SensorQueryCollisionMask(u32 raw_ = 0) : raw(raw_) {}