A reimplementation of Mario Kart Wii's physics engine in C++
Loading...
Searching...
No Matches
ObjectVolcanoPiece.hh
1#pragma once
2
3#include "game/field/obj/ObjectKCL.hh"
4
5namespace Kinoko::Field {
6
8class ObjectVolcanoPiece final : public ObjectKCL {
9public:
10 ObjectVolcanoPiece(const System::MapdataGeoObj &params);
11 ~ObjectVolcanoPiece() override;
12
13 void calc() override;
14
16 [[nodiscard]] LoadFlags loadFlags() const override {
17 return LoadFlags(eLoadFlags::Calc);
18 }
19
21 [[nodiscard]] const char *getKclName() const override {
22 return m_modelName;
23 }
24
25 typedef bool (ObjColMgr::*CheckPointPartialFunc)(const EGG::Vector3f &v0,
26 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfoPartial *pInfo,
27 KCLTypeMask *pFlagsOut);
28
29 typedef bool (ObjColMgr::*CheckPointFullFunc)(const EGG::Vector3f &v0, const EGG::Vector3f &v1,
30 KCLTypeMask flags, CollisionInfo *pInfo, KCLTypeMask *pFlagsOut);
31
32 typedef bool (ObjColMgr::*CheckSpherePartialFunc)(f32 radius, const EGG::Vector3f &v0,
33 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfoPartial *pInfo,
34 KCLTypeMask *pFlagsOut);
35
36 typedef bool (ObjColMgr::*CheckSphereFullFunc)(f32 radius, const EGG::Vector3f &v0,
37 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfo *pInfo,
38 KCLTypeMask *pFlagsOut);
39
40 void createCollision() override;
41
42 template <typename T, typename U>
43 requires(std::is_same_v<T, CollisionInfo> || std::is_same_v<T, CollisionInfoPartial>) &&
44 (std::is_same_v<U, CheckPointPartialFunc> || std::is_same_v<U, CheckPointFullFunc>)
45 [[nodiscard]] bool checkPointImpl(const EGG::Vector3f &v0, const EGG::Vector3f &v1,
46 KCLTypeMask flags, T *pInfo, KCLTypeMask *pFlagsOut, U checkFunc);
47
48 template <typename T, typename U>
49 requires(std::is_same_v<T, CollisionInfo> || std::is_same_v<T, CollisionInfoPartial>) &&
50 (std::is_same_v<U, CheckSpherePartialFunc> || std::is_same_v<U, CheckSphereFullFunc>)
51 [[nodiscard]] bool checkSphereImpl(f32 radius, const EGG::Vector3f &v0, const EGG::Vector3f &v1,
52 KCLTypeMask flags, T *pInfo, KCLTypeMask *pFlagsOut, u32 timeOffset, U checkFunc);
53
54 [[nodiscard]] bool checkCollisionImpl(f32 radius, const EGG::Vector3f &v0,
55 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfo *pInfo,
56 KCLTypeMask *pFlagsOut, u32 timeOffset, CheckSphereFullFunc checkFunc);
57
59 [[nodiscard]] bool checkPointPartial(const EGG::Vector3f &v0, const EGG::Vector3f &v1,
60 KCLTypeMask flags, CollisionInfoPartial *pInfo, KCLTypeMask *pFlagsOut) override {
61 return checkPointImpl(v0, v1, flags, pInfo, pFlagsOut, &ObjColMgr::checkPointPartial);
62 }
63
65 [[nodiscard]] bool checkPointPartialPush(const EGG::Vector3f &v0, const EGG::Vector3f &v1,
66 KCLTypeMask flags, CollisionInfoPartial *pInfo, KCLTypeMask *pFlagsOut) override {
67 return checkPointImpl(v0, v1, flags, pInfo, pFlagsOut, &ObjColMgr::checkPointPartialPush);
68 }
69
71 [[nodiscard]] bool checkPointFull(const EGG::Vector3f &v0, const EGG::Vector3f &v1,
72 KCLTypeMask flags, CollisionInfo *pInfo, KCLTypeMask *pFlagsOut) override {
73 return checkPointImpl(v0, v1, flags, pInfo, pFlagsOut, &ObjColMgr::checkPointFull);
74 }
75
77 [[nodiscard]] bool checkPointFullPush(const EGG::Vector3f &v0, const EGG::Vector3f &v1,
78 KCLTypeMask flags, CollisionInfo *pInfo, KCLTypeMask *pFlagsOut) override {
79 return checkPointImpl(v0, v1, flags, pInfo, pFlagsOut, &ObjColMgr::checkPointFullPush);
80 }
81
83 [[nodiscard]] bool checkSpherePartial(f32 radius, const EGG::Vector3f &v0,
84 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfoPartial *pInfo,
85 KCLTypeMask *pFlagsOut, u32 timeOffset) override {
86 return checkSphereImpl(radius, v0, v1, flags, pInfo, pFlagsOut, timeOffset,
87 &ObjColMgr::checkSpherePartial);
88 }
89
91 [[nodiscard]] bool checkSpherePartialPush(f32 radius, const EGG::Vector3f &v0,
92 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfoPartial *pInfo,
93 KCLTypeMask *pFlagsOut, u32 timeOffset) override {
94 return checkSphereImpl(radius, v0, v1, flags, pInfo, pFlagsOut, timeOffset,
95 &ObjColMgr::checkSpherePartialPush);
96 }
97
99 [[nodiscard]] bool checkSphereFull(f32 radius, const EGG::Vector3f &v0, const EGG::Vector3f &v1,
100 KCLTypeMask flags, CollisionInfo *pInfo, KCLTypeMask *pFlagsOut,
101 u32 timeOffset) override {
102 return checkSphereImpl(radius, v0, v1, flags, pInfo, pFlagsOut, timeOffset,
103 &ObjColMgr::checkSphereFull);
104 }
105
107 [[nodiscard]] bool checkSphereFullPush(f32 radius, const EGG::Vector3f &v0,
108 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfo *pInfo,
109 KCLTypeMask *pFlagsOut, u32 timeOffset) override {
110 return checkCollision(radius, v0, v1, flags, pInfo, pFlagsOut, timeOffset);
111 }
112
113 void narrScLocal(f32 radius, const EGG::Vector3f &pos, KCLTypeMask mask,
114 u32 timeOffset) override;
115
117 [[nodiscard]] bool checkPointCachedPartial(const EGG::Vector3f &v0, const EGG::Vector3f &v1,
118 KCLTypeMask flags, CollisionInfoPartial *pInfo, KCLTypeMask *pFlagsOut) override {
119 return checkPointImpl(v0, v1, flags, pInfo, pFlagsOut, &ObjColMgr::checkPointCachedPartial);
120 }
121
123 [[nodiscard]] bool checkPointCachedPartialPush(const EGG::Vector3f &v0, const EGG::Vector3f &v1,
124 KCLTypeMask flags, CollisionInfoPartial *pInfo, KCLTypeMask *pFlagsOut) override {
125 return checkPointImpl(v0, v1, flags, pInfo, pFlagsOut,
126 &ObjColMgr::checkPointCachedPartialPush);
127 }
128
130 [[nodiscard]] bool checkPointCachedFull(const EGG::Vector3f &v0, const EGG::Vector3f &v1,
131 KCLTypeMask flags, CollisionInfo *pInfo, KCLTypeMask *pFlagsOut) override {
132 return checkPointImpl(v0, v1, flags, pInfo, pFlagsOut, &ObjColMgr::checkPointCachedFull);
133 }
134
136 [[nodiscard]] bool checkPointCachedFullPush(const EGG::Vector3f &v0, const EGG::Vector3f &v1,
137 KCLTypeMask flags, CollisionInfo *pInfo, KCLTypeMask *pFlagsOut) override {
138 return checkPointImpl(v0, v1, flags, pInfo, pFlagsOut,
139 &ObjColMgr::checkPointCachedFullPush);
140 }
141
143 [[nodiscard]] bool checkSphereCachedPartial(f32 radius, const EGG::Vector3f &v0,
144 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfoPartial *pInfo,
145 KCLTypeMask *pFlagsOut, u32 timeOffset) override {
146 return checkSphereImpl(radius, v0, v1, flags, pInfo, pFlagsOut, timeOffset,
147 &ObjColMgr::checkSphereCachedPartial);
148 }
149
151 [[nodiscard]] bool checkSphereCachedPartialPush(f32 radius, const EGG::Vector3f &v0,
152 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfoPartial *pInfo,
153 KCLTypeMask *pFlagsOut, u32 timeOffset) override {
154 return checkSphereImpl(radius, v0, v1, flags, pInfo, pFlagsOut, timeOffset,
155 &ObjColMgr::checkSphereCachedPartialPush);
156 }
157
159 [[nodiscard]] bool checkSphereCachedFull(f32 radius, const EGG::Vector3f &v0,
160 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfo *pInfo,
161 KCLTypeMask *pFlagsOut, u32 timeOffset) override {
162 return checkSphereImpl(radius, v0, v1, flags, pInfo, pFlagsOut, timeOffset,
163 &ObjColMgr::checkSphereCachedFull);
164 }
165
167 [[nodiscard]] bool checkSphereCachedFullPush(f32 radius, const EGG::Vector3f &v0,
168 const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfo *pInfo,
169 KCLTypeMask *pFlagsOut, u32 timeOffset) override {
170 return checkCollisionCached(radius, v0, v1, flags, pInfo, pFlagsOut, timeOffset);
171 }
172
173 void update(u32 timeOffset) override;
174 void calcScale(u32 timeOffset) override;
175 void setMovingObjVel(const EGG::Vector3f &v) override;
176
178 [[nodiscard]] const EGG::Matrix34f &getUpdatedMatrix(u32 timeOffset) override {
179 return calcShakeAndFall(nullptr, timeOffset);
180 }
181
183 [[nodiscard]] bool checkCollision(f32 radius, const EGG::Vector3f &pos,
184 const EGG::Vector3f &prevPos, KCLTypeMask mask, CollisionInfo *info,
185 KCLTypeMask *maskOut, u32 timeOffset) override {
186 return checkCollisionImpl(radius, pos, prevPos, mask, info, maskOut, timeOffset,
187 &ObjColMgr::checkSphereFullPush);
188 }
189
191 [[nodiscard]] bool checkCollisionCached(f32 radius, const EGG::Vector3f &pos,
192 const EGG::Vector3f &prevPos, KCLTypeMask mask, CollisionInfo *info,
193 KCLTypeMask *maskOut, u32 timeOffset) override {
194 return checkCollisionImpl(radius, pos, prevPos, mask, info, maskOut, timeOffset,
195 &ObjColMgr::checkSphereCachedFullPush);
196 }
197
198private:
199 enum class State {
200 Rest = 0,
201 Shake = 1,
202 Quake = 2,
203 Fall = 3,
204 Gone = 4,
205 };
206
207 const EGG::Matrix34f &calcShakeAndFall(EGG::Vector3f *vel, u32 timeOffset);
208 State calcState(u32 frame) const;
209 f32 calcT(u32 frame) const;
210
211 char m_modelName[16];
212 const EGG::Vector3f m_initialPos;
213 const u32 m_restDuration;
214 const u32 m_shakeDuration;
215 const u32 m_quakeDuration;
216 EGG::Matrix34f m_rtMat;
217 ObjColMgr *m_colMgrB;
218 ObjColMgr *m_colMgrC;
219
220 static constexpr u32 FALL_DURATION = 900;
221};
222
223} // namespace Kinoko::Field
Kinoko::Field::ObjectBase::LoadFlags
EGG::TBitFlag< u8, eLoadFlags > LoadFlags
A bitfield of eLoadFlags that represents the update requirements of the object.
Definition ObjectBase.hh:36
Kinoko::Field::ObjectBase::eLoadFlags::Calc
@ Calc
The state of the object should be recalculated every frame.
Definition ObjectBase.hh:30
Kinoko::Field::ObjectVolcanoPiece::loadFlags
LoadFlags loadFlags() const override
Returns a bitmask indicating which lifecycle hooks should be called for the object.
Definition ObjectVolcanoPiece.hh:16
Kinoko::Field
Pertains to collision.
Definition BoxColManager.cc:10
Kinoko::EGG::Vector3f
A 3D float vector.
Definition Vector.hh:107