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

ksys/phys: Implement more StaticCompound functions 

The other functions require RE'ing BodyGroup, which in turn requires
RigidBody stuff
This commit is contained in:
Léo Lam 2022-01-06 15:50:13 +01:00
parent 9343ed56e7
commit 423eb84362
No known key found for this signature in database
GPG Key ID: 0DF30F9081000741
12 changed files with 324 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
data/uking_functions.csv
View File

@ -84182,7 +84182,7 @@ Address,Quality,Size,Name
0x0000007100fc9eec,U,000008,
0x0000007100fc9ef4,U,000036,ResourceHksc::dtorDelete
0x0000007100fc9f18,U,000040,
0x0000007100fc9f40,U,001356,ResourceHksc::doCreate
0x0000007100fc9f40,O,001356,_ZN4ksys4phys14StaticCompound9doCreate_EPhjPN4sead4HeapE
0x0000007100fca48c,U,000268,ResourceHksc::afterParse
0x0000007100fca598,U,000416,ResourceHksc::m7
0x0000007100fca738,U,000156,ResourceHksc::calledFromMapDtor
@ -84191,14 +84191,14 @@ Address,Quality,Size,Name
0x0000007100fca91c,U,000212,ResourceHksc::x_4
0x0000007100fca9f0,U,000112,
0x0000007100fcaa60,U,000136,ResourceHksc::cleanUp
0x0000007100fcaae8,U,000076,ResourceHksc::x_0
0x0000007100fcab34,U,000072,
0x0000007100fcab7c,U,000176,ResourceHksc::disableObj
0x0000007100fcaae8,O,000076,_ZN4ksys4phys14StaticCompound12setMapObjectEjjPNS_3map6ObjectE
0x0000007100fcab34,O,000072,_ZNK4ksys4phys14StaticCompound12getMapObjectEi
0x0000007100fcab7c,O,000176,_ZN4ksys4phys14StaticCompound16disableCollisionEib
0x0000007100fcac2c,U,000112,
0x0000007100fcac9c,U,000112,
0x0000007100fcad0c,U,000328,
0x0000007100fcae54,O,000028,_ZN4ksys4phys14StaticCompound17getFieldBodyGroupEi
0x0000007100fcae70,O,000084,_ZNK4ksys4phys14StaticCompound17hasFieldBodyGroupEPNS0_14FieldBodyGroupE
0x0000007100fcae70,O,000084,_ZNK4ksys4phys14StaticCompound17hasFieldBodyGroupEPNS0_9BodyGroupE
0x0000007100fcaec4,O,000008,_ZNK4ksys4phys14StaticCompound27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
0x0000007100fcaecc,O,000092,_ZNK4ksys4phys14StaticCompound18getRuntimeTypeInfoEv
0x0000007100fcaf28,O,000008,_ZNK4ksys4phys14StaticCompound10needsParseEv
@ -84206,12 +84206,12 @@ Address,Quality,Size,Name
0x0000007100fcb0a4,O,000004,_ZN10hkTypeInfo19cleanupFunctionImplIN4ksys4phys9ShapeInfoEEEvPv
0x0000007100fcb0a8,O,000004,_ZN10hkTypeInfo19cleanupFunctionImplIN4ksys4phys9ActorInfoEEEvPv
0x0000007100fcb0ac,O,000136,_ZN10hkTypeInfo19cleanupFunctionImplIN4ksys4phys18StaticCompoundInfoEEEvPv
0x0000007100fcb134,U,000088,
0x0000007100fcb18c,U,000048,
0x0000007100fcb1bc,U,000048,
0x0000007100fcb1ec,U,000048,
0x0000007100fcb21c,U,000120,
0x0000007100fcb294,O,000396,_GLOBAL__sub_I_physStaticCompoundInfo.cpp
0x0000007100fcb134,O,000088,_ZNK4ksys4phys18StaticCompoundInfo11getActorIdxEjj
0x0000007100fcb18c,O,000048,_ZNK4ksys4phys18StaticCompoundInfo17getShapeInfoStartEi
0x0000007100fcb1bc,O,000048,_ZNK4ksys4phys18StaticCompoundInfo15getShapeInfoEndEi
0x0000007100fcb1ec,O,000048,_ZNK4ksys4phys18StaticCompoundInfo12getShapeInfoEi
0x0000007100fcb21c,O,000120,_ZN4ksys4phys16getBodyLayerTypeENS0_12ContactLayerE
0x0000007100fcb294,O,000396,_GLOBAL__sub_I_physStaticCompoundAutogen.cpp
0x0000007100fcb420,U,000080,
0x0000007100fcb470,U,000076,
0x0000007100fcb4bc,U,000084,
@ -84230,7 +84230,7 @@ Address,Quality,Size,Name
0x0000007100fcbbe4,U,000176,
0x0000007100fcbc94,U,000324,
0x0000007100fcbdd8,U,000104,
0x0000007100fcbe40,O,000168,_ZN4ksys4phys14FieldBodyGroupC1Ev
0x0000007100fcbe40,O,000168,_ZN4ksys4phys9BodyGroupC1Ev
0x0000007100fcbee8,U,000288,
0x0000007100fcc008,U,001492,FieldBodyGroup::init
0x0000007100fcc5dc,U,000120,

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

2
lib/sead

@ -1 +1 @@
Subproject commit c2ffe0c2d03a2ffa2a8b2a679810e08ebd16d45d
Subproject commit 21c20627a40e2c3eb2d62c36008cf68146d369ad

4
src/KingSystem/ActorSystem/actActor.h
View File

@ -39,7 +39,7 @@ class UMii;
} // namespace mii
namespace phys {
class FieldBodyGroup;
class BodyGroup;
class Physics;
class Reaction;
class RigidBody;
@ -380,7 +380,7 @@ protected:
/* 0x580 */ PhysicsConstraints mConstraints;
/* 0x598 */ void* _598 = nullptr;
/* 0x5a0 */ BoneControl* mBoneControl = nullptr;
/* 0x5a8 */ phys::FieldBodyGroup* mFieldBodyGroup = nullptr;
/* 0x5a8 */ phys::BodyGroup* mFieldBodyGroup = nullptr;
/* 0x5b0 */ void* _5b0 = nullptr;
/* 0x5b8 */ sead::Heap* mDualHeap = nullptr; // TODO: rename
/* 0x5c0 */ sead::Heap* mDualHeap2 = nullptr; // TODO: rename

5
src/KingSystem/Physics/CMakeLists.txt
View File

@ -32,8 +32,9 @@ target_sources(uking PRIVATE
StaticCompound/physStaticCompound.cpp
StaticCompound/physStaticCompound.h
StaticCompound/physStaticCompoundFieldBodyGroup.cpp
StaticCompound/physStaticCompoundFieldBodyGroup.h
StaticCompound/physStaticCompoundAutogen.cpp
StaticCompound/physStaticCompoundBodyGroup.cpp
StaticCompound/physStaticCompoundBodyGroup.h
StaticCompound/physStaticCompoundInfo.cpp
StaticCompound/physStaticCompoundInfo.h

95
src/KingSystem/Physics/StaticCompound/physStaticCompound.cpp
View File

@ -1,19 +1,108 @@
#include "KingSystem/Physics/StaticCompound/physStaticCompound.h"
#include "KingSystem/Physics/StaticCompound/physStaticCompoundFieldBodyGroup.h"
#include <Havok/Common/Serialize/Util/hkNativePackfileUtils.h>
#include <Havok/Common/Serialize/Util/hkRootLevelContainer.h>
#include <Havok/Physics2012/Utilities/Serialize/hkpPhysicsData.h>
#include "KingSystem/Physics/StaticCompound/physStaticCompoundBodyGroup.h"
#include "KingSystem/Physics/StaticCompound/physStaticCompoundInfo.h"
#include "KingSystem/Utils/Debug.h"
#include "KingSystem/Utils/HeapUtil.h"
namespace ksys::phys {
// + 1 because body groups are one indexed, with the 0th group acting as a dummy group
constexpr int NumBodyGroups = 16 + 1;
StaticCompound::StaticCompound() = default;
StaticCompound::~StaticCompound() {
// FIXME
}
FieldBodyGroup* StaticCompound::getFieldBodyGroup(int idx) {
void StaticCompound::doCreate_(u8* buffer, u32 buffer_size, sead::Heap* parent_heap) {
const char* error = nullptr;
mBuffer = buffer;
auto result = hkNativePackfileUtils::validatePackfileHeader(mBuffer, &error);
if (!result.isSuccess())
util::PrintDebugFmt("%s: invalid packfile: %s", __func__, error);
mBufferSize = hkNativePackfileUtils::getRequiredBufferSize(mBuffer, int(buffer_size));
mStaticCompoundInfo = static_cast<const StaticCompoundInfo*>(
hkNativePackfileUtils::loadInPlace(mBuffer, mBufferSize, nullptr, &error));
mContainerBuffer = buffer + mStaticCompoundInfo->m_Offset;
auto result2 = hkNativePackfileUtils::validatePackfileHeader(mContainerBuffer, &error);
if (!result2.isSuccess())
util::PrintDebugFmt("%s: invalid physics packfile: %s", __func__, error);
mContainerBufferSize =
hkNativePackfileUtils::getRequiredBufferSize(mContainerBuffer, int(buffer_size));
auto* container = static_cast<hkRootLevelContainer*>(
hkNativePackfileUtils::loadInPlace(mContainerBuffer, mContainerBufferSize));
auto* physics_data = container->findObject<hkpPhysicsData>();
mHeap = util::tryCreateDualHeap(parent_heap);
if (!mHeap) {
util::PrintDebugFmt("%s: failed to create dual heap", __func__);
return;
}
mHeap->enableWarning(false);
auto* heap = mHeap;
const auto& systems = physics_data->getPhysicsSystems();
mFieldBodyGroups.allocBufferAssert(NumBodyGroups, heap);
for (int i = 0, n = mFieldBodyGroups.size(); i < n; ++i)
mFieldBodyGroups[i].init(*systems[i], &mMtx, this, heap);
mName = systems[0]->getName();
mName.trimMatchedString("_0");
if (mStaticCompoundInfo->m_ActorInfo.getSize() > 0)
mMapObjects.allocBufferAssert(mStaticCompoundInfo->m_ActorInfo.getSize(), heap);
mFlags.set(Flag::Initialised);
mHeap->adjust();
}
void StaticCompound::setMapObject(u32 hash_id, u32 srt_hash, map::Object* object) {
int idx = mStaticCompoundInfo->getActorIdx(hash_id, srt_hash);
if (idx < 0 || idx >= mMapObjects.size())
return;
mMapObjects[idx] = object;
}
map::Object* StaticCompound::getMapObject(int shape_idx) const {
auto* info = mStaticCompoundInfo->getShapeInfo(shape_idx);
if (!info)
return nullptr;
const int idx = info->m_ActorInfoIndex;
if (!mMapObjects.isIndexValid(idx))
return nullptr;
return mMapObjects[idx];
}
bool StaticCompound::disableCollision(int actor_idx, bool x) {
const int start = mStaticCompoundInfo->getShapeInfoStart(actor_idx);
const int end = mStaticCompoundInfo->getShapeInfoEnd(actor_idx);
for (int i = start; i <= end; ++i) {
auto* info = mStaticCompoundInfo->getShapeInfo(i);
if (!info || info->m_ActorInfoIndex < 0)
continue;
const auto group = info->m_BodyGroup;
const auto type = static_cast<BodyLayerType>(info->m_BodyLayerType);
const auto instance_id = info->m_InstanceId;
mFieldBodyGroups[group].disableCollision(type, instance_id, x);
}
return true;
}
BodyGroup* StaticCompound::getFieldBodyGroup(int idx) {
return &mFieldBodyGroups[idx];
}
bool StaticCompound::hasFieldBodyGroup(FieldBodyGroup* group) const {
bool StaticCompound::hasFieldBodyGroup(BodyGroup* group) const {
for (int i = 0, n = mFieldBodyGroups.size(); i < n; ++i) {
if (&mFieldBodyGroups[i] == group)
return true;

33
src/KingSystem/Physics/StaticCompound/physStaticCompound.h
View File

@ -10,9 +10,15 @@
#include "KingSystem/Resource/resResource.h"
#include "KingSystem/Utils/Types.h"
namespace ksys::map {
class Object;
}
namespace ksys::phys {
class FieldBodyGroup;
struct ActorInfo;
class BodyGroup;
struct StaticCompoundInfo;
class StaticCompound : public res::Resource, public sead::hostio::Node {
SEAD_RTTI_OVERRIDE(StaticCompound, res::Resource)
@ -21,11 +27,16 @@ public:
StaticCompound();
~StaticCompound() override;
FieldBodyGroup* getFieldBodyGroup(int idx);
bool hasFieldBodyGroup(FieldBodyGroup* group) const;
void setMapObject(u32 hash_id, u32 srt_hash, map::Object* object);
map::Object* getMapObject(int shape_idx) const;
bool disableCollision(int actor_idx, bool x);
BodyGroup* getFieldBodyGroup(int idx);
bool hasFieldBodyGroup(BodyGroup* group) const;
// res::Resource interface
void doCreate_(u8* buffer, u32 buffer_size, sead::Heap* heap) override;
void doCreate_(u8* buffer, u32 buffer_size, sead::Heap* parent_heap) override;
bool needsParse() const override { return true; }
bool finishParsing_() override;
bool m7_() override;
@ -37,15 +48,15 @@ private:
sead::TypedBitFlag<Flag> mFlags;
sead::Heap* mHeap{};
void* _50{};
void* mData{};
int _60{};
void* _68{};
int _70{};
sead::Buffer<FieldBodyGroup> mFieldBodyGroups;
const StaticCompoundInfo* mStaticCompoundInfo{};
void* mBuffer{};
int mBufferSize{};
void* mContainerBuffer{};
int mContainerBufferSize{};
sead::Buffer<BodyGroup> mFieldBodyGroups;
sead::FixedSafeString<32> mName;
sead::Matrix34f mMtx = sead::Matrix34f::ident;
sead::Buffer<void*> _f0{};
sead::Buffer<map::Object*> mMapObjects{};
sead::CriticalSection mCS;
};
KSYS_CHECK_SIZE_NX150(StaticCompound, 0x140);

104
src/KingSystem/Physics/StaticCompound/physStaticCompoundAutogen.cpp Normal file
View File

@ -0,0 +1,104 @@
#include <Havok/Common/Base/Reflection/hkClass.h>
#include <Havok/Common/Base/Reflection/hkClassMember.h>
#include <Havok/Common/Base/Reflection/hkTypeInfo.h>
#include <array>
#include "KingSystem/Physics/StaticCompound/physStaticCompoundInfo.h"
namespace ksys::phys {
// Reflection data is normally autogenerated with a Havok script and type parser,
// but considering we only have 3 classes it's easier to just write the data manually.
// ShapeInfo
static constexpr hkClassMember ShapeInfo_Members[] = {
{"ActorInfoIndex", nullptr, nullptr, hkClassMember::Type::TYPE_INT32,
hkClassMember::Type::TYPE_VOID, 0, 0, 0, nullptr},
{"InstanceId", nullptr, nullptr, hkClassMember::Type::TYPE_INT32,
hkClassMember::Type::TYPE_VOID, 0, 0, 4, nullptr},
{"BodyGroup", nullptr, nullptr, hkClassMember::Type::TYPE_INT8, hkClassMember::Type::TYPE_VOID,
0, 0, 8, nullptr},
{"BodyLayerType", nullptr, nullptr, hkClassMember::Type::TYPE_UINT8,
hkClassMember::Type::TYPE_VOID, 0, 0, 9, nullptr},
};
const hkClass ShapeInfo_Class{
"ShapeInfo",
nullptr,
sizeof(ShapeInfo),
nullptr,
0,
nullptr,
0,
ShapeInfo_Members,
std::size(ShapeInfo_Members),
};
const hkClass& ShapeInfo::staticClass() {
return ShapeInfo_Class;
}
const hkTypeInfo ShapeInfo_TypeInfo = hkTypeInfo::make<ShapeInfo>("ShapeInfo", "!ShapeInfo");
// ActorInfo
static constexpr hkClassMember ActorInfo_Members[] = {
{"HashId", nullptr, nullptr, hkClassMember::Type::TYPE_UINT32, hkClassMember::Type::TYPE_VOID,
0, 0, 0, nullptr},
{"SRTHash", nullptr, nullptr, hkClassMember::Type::TYPE_INT32, hkClassMember::Type::TYPE_VOID,
0, 0, 4, nullptr},
{"ShapeInfoStart", nullptr, nullptr, hkClassMember::Type::TYPE_INT32,
hkClassMember::Type::TYPE_VOID, 0, 0, 8, nullptr},
{"ShapeInfoEnd", nullptr, nullptr, hkClassMember::Type::TYPE_INT32,
hkClassMember::Type::TYPE_VOID, 0, 0, 0xc, nullptr},
};
const hkClass ActorInfo_Class{
"ActorInfo",
nullptr,
sizeof(ActorInfo),
nullptr,
0,
nullptr,
0,
ActorInfo_Members,
std::size(ActorInfo_Members),
};
const hkClass& ActorInfo::staticClass() {
return ActorInfo_Class;
}
const hkTypeInfo ActorInfo_TypeInfo = hkTypeInfo::make<ActorInfo>("ActorInfo", "!ActorInfo");
// StaticCompoundInfo
static constexpr hkClassMember StaticCompoundInfo_Members[] = {
{"Offset", nullptr, nullptr, hkClassMember::Type::TYPE_UINT32, hkClassMember::Type::TYPE_VOID,
0, 0, 0, nullptr},
{"ActorInfo", &ActorInfo_Class, nullptr, hkClassMember::Type::TYPE_ARRAY,
hkClassMember::Type::TYPE_STRUCT, 0, 0, 8, nullptr},
{"ShapeInfo", &ShapeInfo_Class, nullptr, hkClassMember::Type::TYPE_ARRAY,
hkClassMember::Type::TYPE_STRUCT, 0, 0, 0x18, nullptr},
};
const hkClass StaticCompoundInfo_Class{
"StaticCompoundInfo",
nullptr,
sizeof(StaticCompoundInfo),
nullptr,
0,
nullptr,
0,
StaticCompoundInfo_Members,
std::size(StaticCompoundInfo_Members),
};
const hkClass& StaticCompoundInfo::staticClass() {
return StaticCompoundInfo_Class;
}
const hkTypeInfo StaticCompoundInfo_TypeInfo =
hkTypeInfo::make<StaticCompoundInfo>("StaticCompoundInfo", "!StaticCompoundInfo");
} // namespace ksys::phys

7
src/KingSystem/Physics/StaticCompound/physStaticCompoundBodyGroup.cpp Normal file
View File

@ -0,0 +1,7 @@
#include "KingSystem/Physics/StaticCompound/physStaticCompoundBodyGroup.h"
namespace ksys::phys {
BodyGroup::BodyGroup() = default;
} // namespace ksys::phys

20
src/KingSystem/Physics/StaticCompound/physStaticCompoundFieldBodyGroup.h → src/KingSystem/Physics/StaticCompound/physStaticCompoundBodyGroup.h
View File

@ -8,18 +8,26 @@
#include <thread/seadAtomic.h>
#include "KingSystem/Utils/Types.h"
class hkpPhysicsSystem;
namespace ksys::phys {
enum class BodyLayerType;
class RigidBody;
class StaticCompound;
class FieldBodyGroup {
class BodyGroup {
public:
FieldBodyGroup();
~FieldBodyGroup();
BodyGroup();
~BodyGroup();
FieldBodyGroup(const FieldBodyGroup&) = delete;
auto operator=(const FieldBodyGroup&) = delete;
BodyGroup(const BodyGroup&) = delete;
auto operator=(const BodyGroup&) = delete;
void init(const hkpPhysicsSystem& system, sead::Matrix34f* mtx, StaticCompound* sc,
sead::Heap* heap);
void disableCollision(BodyLayerType body_layer_type, int instance_id, bool x);
sead::Atomic<u32> _0;
sead::Atomic<u32> _4;
@ -37,6 +45,6 @@ public:
u32 _e0{};
sead::Buffer<void*> _e8;
};
KSYS_CHECK_SIZE_NX150(FieldBodyGroup, 0xf8);
KSYS_CHECK_SIZE_NX150(BodyGroup, 0xf8);
} // namespace ksys::phys

7
src/KingSystem/Physics/StaticCompound/physStaticCompoundFieldBodyGroup.cpp
View File

@ -1,7 +0,0 @@
#include "KingSystem/Physics/StaticCompound/physStaticCompoundFieldBodyGroup.h"
namespace ksys::phys {
FieldBodyGroup::FieldBodyGroup() = default;
} // namespace ksys::phys

136
src/KingSystem/Physics/StaticCompound/physStaticCompoundInfo.cpp
View File

@ -1,104 +1,56 @@
#include "KingSystem/Physics/StaticCompound/physStaticCompoundInfo.h"
#include <Havok/Common/Base/Reflection/hkClass.h>
#include <Havok/Common/Base/Reflection/hkClassMember.h>
#include <Havok/Common/Base/Reflection/hkTypeInfo.h>
#include <array>
namespace ksys::phys {
// Reflection data is normally autogenerated with a Havok script and type parser,
// but considering we only have 3 classes it's easier to just write the data manually.
// ShapeInfo
static constexpr hkClassMember ShapeInfo_Members[] = {
{"ActorInfoIndex", nullptr, nullptr, hkClassMember::Type::TYPE_INT32,
hkClassMember::Type::TYPE_VOID, 0, 0, 0, nullptr},
{"InstanceId", nullptr, nullptr, hkClassMember::Type::TYPE_INT32,
hkClassMember::Type::TYPE_VOID, 0, 0, 4, nullptr},
{"BodyGroup", nullptr, nullptr, hkClassMember::Type::TYPE_INT8, hkClassMember::Type::TYPE_VOID,
0, 0, 8, nullptr},
{"BodyLayerType", nullptr, nullptr, hkClassMember::Type::TYPE_UINT8,
hkClassMember::Type::TYPE_VOID, 0, 0, 9, nullptr},
};
const hkClass ShapeInfo_Class{
"ShapeInfo",
nullptr,
sizeof(ShapeInfo),
nullptr,
0,
nullptr,
0,
ShapeInfo_Members,
std::size(ShapeInfo_Members),
};
const hkClass& ShapeInfo::staticClass() {
return ShapeInfo_Class;
int StaticCompoundInfo::getActorIdx(u32 hash_id, u32 srt_hash) const {
for (int i = 0; i < m_ActorInfo.getSize(); ++i) {
const auto& info = m_ActorInfo[i];
if (info.m_HashId == hash_id && u32(info.m_SRTHash) == srt_hash)
return i;
}
return -1;
}
const hkTypeInfo ShapeInfo_TypeInfo = hkTypeInfo::make<ShapeInfo>("ShapeInfo", "!ShapeInfo");
// ActorInfo
static constexpr hkClassMember ActorInfo_Members[] = {
{"HashId", nullptr, nullptr, hkClassMember::Type::TYPE_UINT32, hkClassMember::Type::TYPE_VOID,
0, 0, 0, nullptr},
{"SRTHash", nullptr, nullptr, hkClassMember::Type::TYPE_INT32, hkClassMember::Type::TYPE_VOID,
0, 0, 4, nullptr},
{"ShapeInfoStart", nullptr, nullptr, hkClassMember::Type::TYPE_INT32,
hkClassMember::Type::TYPE_VOID, 0, 0, 8, nullptr},
{"ShapeInfoEnd", nullptr, nullptr, hkClassMember::Type::TYPE_INT32,
hkClassMember::Type::TYPE_VOID, 0, 0, 0xc, nullptr},
};
const hkClass ActorInfo_Class{
"ActorInfo",
nullptr,
sizeof(ActorInfo),
nullptr,
0,
nullptr,
0,
ActorInfo_Members,
std::size(ActorInfo_Members),
};
const hkClass& ActorInfo::staticClass() {
return ActorInfo_Class;
int StaticCompoundInfo::getShapeInfoStart(int actor_idx) const {
if (actor_idx < 0 || actor_idx >= m_ActorInfo.getSize())
return -1;
return m_ActorInfo[actor_idx].m_ShapeInfoStart;
}
const hkTypeInfo ActorInfo_TypeInfo = hkTypeInfo::make<ActorInfo>("ActorInfo", "!ActorInfo");
// StaticCompoundInfo
static constexpr hkClassMember StaticCompoundInfo_Members[] = {
{"Offset", nullptr, nullptr, hkClassMember::Type::TYPE_UINT32, hkClassMember::Type::TYPE_VOID,
0, 0, 0, nullptr},
{"ActorInfo", &ActorInfo_Class, nullptr, hkClassMember::Type::TYPE_ARRAY,
hkClassMember::Type::TYPE_STRUCT, 0, 0, 8, nullptr},
{"ShapeInfo", &ShapeInfo_Class, nullptr, hkClassMember::Type::TYPE_ARRAY,
hkClassMember::Type::TYPE_STRUCT, 0, 0, 0x18, nullptr},
};
const hkClass StaticCompoundInfo_Class{
"StaticCompoundInfo",
nullptr,
sizeof(StaticCompoundInfo),
nullptr,
0,
nullptr,
0,
StaticCompoundInfo_Members,
std::size(StaticCompoundInfo_Members),
};
const hkClass& StaticCompoundInfo::staticClass() {
return StaticCompoundInfo_Class;
int StaticCompoundInfo::getShapeInfoEnd(int actor_idx) const {
if (actor_idx < 0 || actor_idx >= m_ActorInfo.getSize())
return -1;
return m_ActorInfo[actor_idx].m_ShapeInfoEnd;
}
const hkTypeInfo StaticCompoundInfo_TypeInfo =
hkTypeInfo::make<StaticCompoundInfo>("StaticCompoundInfo", "!StaticCompoundInfo");
const ShapeInfo* StaticCompoundInfo::getShapeInfo(int shape_idx) const {
if (shape_idx < 0 || shape_idx >= m_ShapeInfo.getSize())
return nullptr;
return &m_ShapeInfo[shape_idx];
}
static ContactLayer getContactLayerForBodyLayerType(BodyLayerType type) {
ContactLayer map[NumBodyLayerTypes];
map[int(BodyLayerType::EntityGround)] = ContactLayer::EntityGround;
map[int(BodyLayerType::EntityGroundSmooth)] = ContactLayer::EntityGroundSmooth;
map[int(BodyLayerType::EntityGroundRough)] = ContactLayer::EntityGroundRough;
map[int(BodyLayerType::EntityObject)] = ContactLayer::EntityObject;
map[int(BodyLayerType::EntityGroundObject)] = ContactLayer::EntityGroundObject;
map[int(BodyLayerType::EntityTree)] = ContactLayer::EntityTree;
map[int(BodyLayerType::SensorInDoor)] = ContactLayer::SensorInDoor;
map[int(BodyLayerType::EntityNoHit)] = ContactLayer::EntityNoHit;
map[int(BodyLayerType::EntityWallForClimb)] = ContactLayer::EntityWallForClimb;
map[int(BodyLayerType::EntityWater)] = ContactLayer::EntityWater;
return map[int(type)];
}
BodyLayerType getBodyLayerType(ContactLayer layer) {
for (int i = 0; i < NumBodyLayerTypes; ++i) {
auto type = static_cast<BodyLayerType>(i);
if (int(getContactLayerForBodyLayerType(type)) == int(layer))
return type;
}
return BodyLayerType::Invalid;
}
} // namespace ksys::phys

23
src/KingSystem/Physics/StaticCompound/physStaticCompoundInfo.h
View File

@ -1,11 +1,27 @@
#pragma once
#include <Havok/Common/Base/hkBase.h>
#include "KingSystem/Physics/System/physDefines.h"
class hkTypeInfo;
namespace ksys::phys {
enum class BodyLayerType {
EntityGround,
EntityGroundSmooth,
EntityGroundRough,
EntityObject,
EntityGroundObject,
EntityTree,
SensorInDoor,
EntityNoHit,
EntityWallForClimb,
EntityWater,
Invalid = -1,
};
constexpr int NumBodyLayerTypes = 10;
struct ShapeInfo {
HK_DECLARE_REFLECTION()
@ -31,6 +47,11 @@ extern const hkTypeInfo ActorInfo_TypeInfo;
struct StaticCompoundInfo {
HK_DECLARE_REFLECTION()
int getActorIdx(u32 hash_id, u32 srt_hash) const;
int getShapeInfoStart(int actor_idx) const;
int getShapeInfoEnd(int actor_idx) const;
const ShapeInfo* getShapeInfo(int shape_idx) const;
hkUint32 m_Offset;
hkArray<ActorInfo> m_ActorInfo;
hkArray<ShapeInfo> m_ShapeInfo;
@ -38,4 +59,6 @@ struct StaticCompoundInfo {
extern const hkClass StaticCompoundInfo_Class;
extern const hkTypeInfo StaticCompoundInfo_TypeInfo;
BodyLayerType getBodyLayerType(ContactLayer layer);
} // namespace ksys::phys