1#include "Library/LiveActor/ActorPoseUtil.h"
2
3#include "Library/LiveActor/ActorAnimFunction.h"
4#include "Library/LiveActor/ActorPoseKeeper.h"
5#include "Library/LiveActor/LiveActor.h"
6#include "Library/Math/MathUtil.h"
7#include "Library/Matrix/MatrixUtil.h"
8
9namespace al {
10class LiveActor;
11
12void initActorPoseT(LiveActor* actor, const sead::Vector3f& trans) {
13 actor->initPoseKeeper(poseKeeper: new ActorPoseKeeperTRSV());
14 setTrans(actor, trans);
15}
16
17void setTrans(LiveActor* actor, const sead::Vector3f& trans) {
18 *getTransPtr(actor) = trans;
19}
20
21void initActorPoseTR(LiveActor* actor, const sead::Vector3f& trans, const sead::Vector3f& rotate) {
22 actor->initPoseKeeper(poseKeeper: new ActorPoseKeeperTRSV());
23 setTrans(actor, trans);
24 setRotate(actor, rotate);
25}
26
27void setRotate(LiveActor* actor, const sead::Vector3f& rotate) {
28 getRotatePtr(actor)->set(rotate);
29}
30
31void makeMtxSRT(sead::Matrix34f* mtx, const LiveActor* actor) {
32 ActorPoseKeeperBase* poseKeeper = actor->getPoseKeeper();
33 poseKeeper->calcBaseMtx(mtx);
34 preScaleMtx(outMtx: mtx, scale: poseKeeper->getScale());
35}
36
37void makeMtxRT(sead::Matrix34f* mtx, const LiveActor* actor) {
38 actor->getPoseKeeper()->calcBaseMtx(mtx);
39}
40
41void makeMtxR(sead::Matrix34f* mtx, const LiveActor* actor) {
42 makeMtxRT(mtx, actor);
43 mtx->setBase(axis: 3, v: sead::Vector3f::zero);
44}
45
46void calcAnimFrontGravityPos(LiveActor* actor, const sead::Vector3f& front) {
47 sead::Vector3f up = -getGravity(actor);
48 if (actor->getBaseMtx()) {
49 const sead::Matrix34f* mtx = actor->getBaseMtx();
50 sead::Vector3f side;
51 side.setCross(a: front, b: up);
52 if (isNearZero(vec: side))
53 up.setCross(a: front, b: mtx->getBase(axis: 0));
54 }
55
56 sead::Matrix34f mtx;
57 makeMtxFrontUpPos(outMtx: &mtx, front, up, pos: getTrans(actor));
58 setBaseMtxAndCalcAnim(actor, mtx, getScale(actor));
59}
60
61const sead::Vector3f& getGravity(const LiveActor* actor) {
62 return actor->getPoseKeeper()->getGravity();
63}
64
65const sead::Vector3f& getTrans(const LiveActor* actor) {
66 return actor->getPoseKeeper()->getTrans();
67}
68
69const sead::Vector3f& getScale(const LiveActor* actor) {
70 return actor->getPoseKeeper()->getScale();
71}
72
73void copyPose(LiveActor* actor, const LiveActor* target) {
74 actor->getPoseKeeper()->copyPose(other: target->getPoseKeeper());
75}
76
77void updatePoseTrans(LiveActor* actor, const sead::Vector3f& trans) {
78 actor->getPoseKeeper()->updatePoseTrans(trans);
79}
80
81void updatePoseRotate(LiveActor* actor, const sead::Vector3f& rotate) {
82 actor->getPoseKeeper()->updatePoseRotate(rot: rotate);
83}
84
85void updatePoseQuat(LiveActor* actor, const sead::Quatf& quat) {
86 actor->getPoseKeeper()->updatePoseQuat(quat);
87}
88
89void updatePoseMtx(LiveActor* actor, const sead::Matrix34f* mtx) {
90 actor->getPoseKeeper()->updatePoseMtx(mtx);
91}
92
93void calcSideDir(sead::Vector3f* side, const LiveActor* actor) {
94 sead::Matrix34f mtx;
95 makeMtxRT(mtx: &mtx, actor);
96 mtx.getBase(o&: *side, axis: 0);
97}
98
99void calcLeftDir(sead::Vector3f* left, const LiveActor* actor) {
100 return calcSideDir(side: left, actor);
101}
102
103void calcRightDir(sead::Vector3f* right, const LiveActor* actor) {
104 sead::Vector3f left;
105 calcLeftDir(left: &left, actor);
106 *right = left;
107 right->negate();
108}
109
110void calcUpDir(sead::Vector3f* up, const LiveActor* actor) {
111 sead::Matrix34f mtx;
112 makeMtxRT(mtx: &mtx, actor);
113 mtx.getBase(o&: *up, axis: 1);
114}
115
116void calcDownDir(sead::Vector3f* down, const LiveActor* actor) {
117 sead::Vector3f up;
118 calcUpDir(up: &up, actor);
119 *down = up;
120 down->negate();
121}
122
123void calcFrontDir(sead::Vector3f* front, const LiveActor* actor) {
124 sead::Matrix34f mtx;
125 makeMtxRT(mtx: &mtx, actor);
126 mtx.getBase(o&: *front, axis: 2);
127}
128
129void calcBackDir(sead::Vector3f* back, const LiveActor* actor) {
130 sead::Vector3f front;
131 calcFrontDir(front: &front, actor);
132 *back = front;
133 back->negate();
134}
135
136void calcPoseDir(sead::Vector3f* side, sead::Vector3f* up, sead::Vector3f* front,
137 const LiveActor* actor) {
138 sead::Matrix34f mtx;
139 makeMtxRT(mtx: &mtx, actor);
140 if (side)
141 mtx.getBase(o&: *side, axis: 0);
142 if (up)
143 mtx.getBase(o&: *up, axis: 1);
144 if (front)
145 mtx.getBase(o&: *front, axis: 2);
146}
147
148void calcQuat(sead::Quatf* quat, const LiveActor* actor) {
149 sead::Matrix34f mtx;
150 makeMtxRT(mtx: &mtx, actor);
151 mtx.toQuat(q&: *quat);
152}
153
154f32 calcDistanceSignLocalXDir(const LiveActor* actor, const sead::Vector3f& pos) {
155 sead::Vector3f left;
156 calcLeftDir(left: &left, actor);
157 return left.dot(t: pos - getTrans(actor));
158}
159
160f32 calcDistanceSignLocalYDir(const LiveActor* actor, const sead::Vector3f& pos) {
161 sead::Vector3f up;
162 calcUpDir(up: &up, actor);
163 return up.dot(t: pos - getTrans(actor));
164}
165
166f32 calcDistanceSignLocalZDir(const LiveActor* actor, const sead::Vector3f& pos) {
167 sead::Vector3f front;
168 calcFrontDir(front: &front, actor);
169 return front.dot(t: pos - getTrans(actor));
170}
171
172f32 calcDistanceLocalXDir(const LiveActor* actor, const sead::Vector3f& pos) {
173 return sead::Mathf::abs(x: calcDistanceSignLocalXDir(actor, pos));
174}
175
176f32 calcDistanceLocalYDir(const LiveActor* actor, const sead::Vector3f& pos) {
177 return sead::Mathf::abs(x: calcDistanceSignLocalYDir(actor, pos));
178}
179
180f32 calcDistanceLocalZDir(const LiveActor* actor, const sead::Vector3f& pos) {
181 return sead::Mathf::abs(x: calcDistanceSignLocalZDir(actor, pos));
182}
183
184sead::Vector3f* getTransPtr(LiveActor* actor) {
185 return actor->getPoseKeeper()->getTransPtr();
186}
187
188void setTrans(LiveActor* actor, f32 x, f32 y, f32 z) {
189 setTrans(actor, trans: {x, y, z});
190}
191
192void setTransX(LiveActor* actor, f32 x) {
193 getTransPtr(actor)->x = x;
194}
195
196void setTransY(LiveActor* actor, f32 y) {
197 getTransPtr(actor)->y = y;
198}
199
200void setTransZ(LiveActor* actor, f32 z) {
201 getTransPtr(actor)->z = z;
202}
203
204const sead::Vector3f& getRotate(const LiveActor* actor) {
205 return actor->getPoseKeeper()->getRotate();
206}
207
208sead::Vector3f* getRotatePtr(LiveActor* actor) {
209 return actor->getPoseKeeper()->getRotatePtr();
210}
211
212void setRotate(LiveActor* actor, f32 x, f32 y, f32 z) {
213 setRotate(actor, rotate: {x, y, z});
214}
215
216void setRotateX(LiveActor* actor, f32 x) {
217 getRotatePtr(actor)->x = x;
218}
219
220void setRotateY(LiveActor* actor, f32 y) {
221 getRotatePtr(actor)->y = y;
222}
223
224void setRotateZ(LiveActor* actor, f32 z) {
225 getRotatePtr(actor)->z = z;
226}
227
228sead::Vector3f* getScalePtr(LiveActor* actor) {
229 return tryGetScalePtr(actor);
230}
231
232sead::Vector3f* tryGetScalePtr(LiveActor* actor) {
233 return actor->getPoseKeeper()->getScalePtr();
234}
235
236f32 getScaleX(const LiveActor* actor) {
237 return getScale(actor).x;
238}
239
240f32 getScaleY(const LiveActor* actor) {
241 return getScale(actor).y;
242}
243
244f32 getScaleZ(const LiveActor* actor) {
245 return getScale(actor).z;
246}
247
248void setScale(LiveActor* actor, const sead::Vector3f& scale) {
249 *getScalePtr(actor) = scale;
250}
251
252void setScale(LiveActor* actor, f32 x, f32 y, f32 z) {
253 setScale(actor, scale: {x, y, z});
254}
255
256void setScaleAll(LiveActor* actor, f32 scale) {
257 setScale(actor, scale: {scale, scale, scale});
258}
259
260void setScaleX(LiveActor* actor, f32 x) {
261 getScalePtr(actor)->x = x;
262}
263
264void setScaleY(LiveActor* actor, f32 y) {
265 getScalePtr(actor)->y = y;
266}
267
268void setScaleZ(LiveActor* actor, f32 z) {
269 getScalePtr(actor)->z = z;
270}
271
272bool isFrontTarget(const LiveActor* actor, const sead::Vector3f& pos) {
273 return isFrontDir(actor, dir: pos - getTrans(actor));
274}
275
276bool isFrontDir(const LiveActor* actor, const sead::Vector3f& dir) {
277 sead::Vector3f front;
278 calcFrontDir(front: &front, actor);
279 return front.dot(t: dir) > 0.0f;
280}
281
282bool isBackTarget(const LiveActor* actor, const sead::Vector3f& pos) {
283 return isBackDir(actor, dir: pos - getTrans(actor));
284}
285
286bool isBackDir(const LiveActor* actor, const sead::Vector3f& dir) {
287 sead::Vector3f back;
288 calcBackDir(back: &back, actor);
289 return back.dot(t: dir) > 0.0f;
290}
291
292bool isLeftTarget(const LiveActor* actor, const sead::Vector3f& pos) {
293 return isLeftDir(actor, dir: pos - getTrans(actor));
294}
295
296bool isLeftDir(const LiveActor* actor, const sead::Vector3f& dir) {
297 sead::Vector3f left;
298 calcLeftDir(left: &left, actor);
299 return left.dot(t: dir) > 0.0f;
300}
301
302bool isRightTarget(const LiveActor* actor, const sead::Vector3f& pos) {
303 return isRightDir(actor, dir: pos - getTrans(actor));
304}
305
306bool isRightDir(const LiveActor* actor, const sead::Vector3f& dir) {
307 sead::Vector3f right;
308 calcRightDir(right: &right, actor);
309 return right.dot(t: dir) > 0.0f;
310}
311
312bool isUpTarget(const LiveActor* actor, const sead::Vector3f& pos) {
313 return isUpDir(actor, dir: pos - getTrans(actor));
314}
315
316bool isUpDir(const LiveActor* actor, const sead::Vector3f& dir) {
317 sead::Vector3f up;
318 calcUpDir(up: &up, actor);
319 return up.dot(t: dir) > 0.0f;
320}
321
322bool isDownTarget(const LiveActor* actor, const sead::Vector3f& pos) {
323 return isDownDir(actor, dir: pos - getTrans(actor));
324}
325
326bool isDownDir(const LiveActor* actor, const sead::Vector3f& dir) {
327 sead::Vector3f down;
328 calcDownDir(down: &down, actor);
329 return down.dot(t: dir) > 0.0f;
330}
331
332const sead::Quatf& getQuat(const LiveActor* actor) {
333 return actor->getPoseKeeper()->getQuat();
334}
335
336sead::Quatf* getQuatPtr(LiveActor* actor) {
337 return tryGetQuatPtr(actor);
338}
339
340sead::Quatf* tryGetQuatPtr(LiveActor* actor) {
341 return actor->getPoseKeeper()->getQuatPtr();
342}
343
344void setQuat(LiveActor* actor, const sead::Quatf& quat) {
345 getQuatPtr(actor)->set(quat);
346}
347
348sead::Vector3f* getGravityPtr(const LiveActor* actor) {
349 return actor->getPoseKeeper()->getGravityPtr();
350}
351
352void setGravity(const LiveActor* actor, const sead::Vector3f& gravity) {
353 getGravityPtr(actor)->set(gravity);
354}
355
356const sead::Vector3f& getFront(const LiveActor* actor) {
357 return actor->getPoseKeeper()->getFront();
358}
359
360sead::Vector3f* getFrontPtr(LiveActor* actor) {
361 return actor->getPoseKeeper()->getFrontPtr();
362}
363
364void setFront(LiveActor* actor, const sead::Vector3f& front) {
365 getFrontPtr(actor)->set(front);
366}
367
368const sead::Vector3f& getUp(const LiveActor* actor) {
369 return actor->getPoseKeeper()->getUp();
370}
371
372sead::Vector3f* getUpPtr(LiveActor* actor) {
373 return actor->getPoseKeeper()->getUpPtr();
374}
375
376void setUp(LiveActor* actor, const sead::Vector3f& up) {
377 getUpPtr(actor)->set(up);
378}
379
380void multVecPoseNoTrans(sead::Vector3f* posOut, const LiveActor* actor,
381 const sead::Vector3f& posIn) {
382 sead::Matrix34f mtx;
383 makeMtxR(mtx: &mtx, actor);
384 posOut->setMul(m: mtx, a: posIn);
385}
386
387void multVecPose(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn) {
388 sead::Matrix34f mtx;
389 makeMtxRT(mtx: &mtx, actor);
390 posOut->setMul(m: mtx, a: posIn);
391}
392
393void multVecPoseAndScale(sead::Vector3f* posOut, const LiveActor* actor,
394 const sead::Vector3f& posIn) {
395 sead::Matrix34f mtx;
396 makeMtxSRT(mtx: &mtx, actor);
397 posOut->setMul(m: mtx, a: posIn);
398}
399
400void multVecInvPose(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn) {
401 sead::Matrix34f mtx;
402 makeMtxRT(mtx: &mtx, actor);
403 mtx.invert();
404 posOut->setMul(m: mtx, a: posIn);
405}
406
407// TODO: requires Quatf::rotate to be implemented
408// void multVecInvQuat(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn);
409
410void multMtxInvPose(sead::Matrix34f* mtxOut, const LiveActor* actor, const sead::Matrix34f& mtxIn) {
411 sead::Matrix34f mtx;
412 makeMtxRT(mtx: &mtx, actor);
413 mtx.invert();
414 mtxOut->setMul(a: mtx, b: mtxIn);
415}
416
417void calcTransLocalOffset(sead::Vector3f* transOut, const LiveActor* actor,
418 const sead::Vector3f& transIn) {
419 sead::Matrix34f mtx;
420 makeMtxRT(mtx: &mtx, actor);
421 calcTransLocalOffsetByMtx(transOut, mtx, transIn);
422}
423
424} // namespace al
425
426namespace alActorPoseFunction {
427
428void calcBaseMtx(sead::Matrix34f* mtx, const al::LiveActor* actor) {
429 actor->getPoseKeeper()->calcBaseMtx(mtx);
430}
431
432void updatePoseTRMSV(al::LiveActor* actor) {
433 al::ActorPoseKeeperBase* poseKeeper = actor->getPoseKeeper();
434 poseKeeper->updatePoseRotate(rot: poseKeeper->getRotate());
435}
436
437} // namespace alActorPoseFunction
438