mirror/mm
1
0
Fork 0
mirror of https://github.com/zeldaret/mm.git synced 2026-06-08 12:17:05 -04:00
Code Issues Packages Projects Releases Wiki Activity

z_skin and z_skin_awb OK and documented a bit (#415)

Browse Source 
* oot copypaste

* func_8013859C non matching and func_80138700

* protos

* the other functions

* func_80138300

* progress

* func_80137F58

* func_80137EBC

* func_80137B34 NON_MATCHING

* func_80137970

* func_8013835C

* z64skin

* some docs

* some bits

* Match func_80137B34

* Match Skin_DrawImpl

* Match Skin_Init tahnks to Anon

* Some docs?

* AnimatedLimb

* SkinVtx

* more names

* fix merge issue

* format

* another clean

* trailing comma

* cleanup

* format

* add some descriptions

* Import bss

* last cleanup

* Update ZAPD symbol map

* Reanme gIdentityMtx and gIdentityMtxF

* fix merge issues

* bss

* review

* Update include/z64skin.h

Co-authored-by: Derek Hensley <hensley.derek58@gmail.com>

* bss

* Port @fig02 skin docs

* format and a few changes

* format

* Port over OoT review

* fixes

* Engineer's review

* format

* address pr

* Fix bss

* fix bss

* Update src/code/z_skin_awb.c

Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com>

* bss

* bss

* undo

* pr

* Skin_Setup

Co-authored-by: Derek Hensley <hensley.derek58@gmail.com>
Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com>
This commit is contained in:
Anghelo Carvajal
2022-03-23 18:30:34 -03:00
committed by GitHub
parent f1560614d6
commit 92c4d42f44
20 changed files with 618 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/code/z_bgcheck.c
+1
View File
@@ -1,3 +1,4 @@
#include "prevent_bss_reordering.h"
#include "global.h"
#include "vt.h"
src/code/z_demo.c
+1
View File
@@ -1,3 +1,4 @@
#include "prevent_bss_reordering.h"
#include "global.h"
#include "overlays/gamestates/ovl_daytelop/z_daytelop.h"
src/code/z_lifemeter.c
+9 -8
View File
@@ -1,15 +1,16 @@
#include "prevent_bss_reordering.h"
#include "global.h"
#include "interface/parameter_static/parameter_static.h"
#include "prevent_bss_reordering.h"
static s16 sHeartsPrimColors[3][3] = { { 255, 70, 50 }, { 255, 190, 0 }, { 100, 100, 255 } };
static s16 sHeartsEnvColors[3][3] = { { 50, 40, 60 }, { 255, 0, 0 }, { 0, 0, 255 } };
static s16 sHeartsPrimFactors[3][3] = { { 0, 0, 0 }, { 0, 120, -50 }, { -155, 30, 205 } };
static s16 sHeartsEnvFactors[3][3] = { { 0, 0, 0 }, { 205, -40, -60 }, { -50, -40, 195 } };
static s16 sHeartsDDPrimColors[3][3] = { { 255, 255, 255 }, { 255, 190, 0 }, { 100, 100, 255 } };
static s16 sHeartsDDEnvColors[3][3] = { { 200, 0, 0 }, { 255, 0, 0 }, { 0, 0, 255 } };
static s16 sHeartsDDPrimFactors[3][3] = { { 0, 0, 0 }, { 0, -65, -255 }, { -155, -155, 0 } };
static s16 sHeartsDDEnvFactors[3][3] = { { 0, 0, 0 }, { 55, 0, 0 }, { -200, 0, 255 } };
s16 sHeartsPrimColors[3][3] = { { 255, 70, 50 }, { 255, 190, 0 }, { 100, 100, 255 } };
s16 sHeartsEnvColors[3][3] = { { 50, 40, 60 }, { 255, 0, 0 }, { 0, 0, 255 } };
s16 sHeartsPrimFactors[3][3] = { { 0, 0, 0 }, { 0, 120, -50 }, { -155, 30, 205 } };
s16 sHeartsEnvFactors[3][3] = { { 0, 0, 0 }, { 205, -40, -60 }, { -50, -40, 195 } };
s16 sHeartsDDPrimColors[3][3] = { { 255, 255, 255 }, { 255, 190, 0 }, { 100, 100, 255 } };
s16 sHeartsDDEnvColors[3][3] = { { 200, 0, 0 }, { 255, 0, 0 }, { 0, 0, 255 } };
s16 sHeartsDDPrimFactors[3][3] = { { 0, 0, 0 }, { 0, -65, -255 }, { -155, -155, 0 } };
s16 sHeartsDDEnvFactors[3][3] = { { 0, 0, 0 }, { 55, 0, 0 }, { -200, 0, 255 } };
s16 sBeatingHeartsDDPrim[3];
s16 sBeatingHeartsDDEnv[3];
src/code/z_skelanime.c
+1 -1
View File
@@ -1577,7 +1577,7 @@ void SkelAnime_InitFlex(GlobalContext* globalCtx, SkelAnime* skelAnime, FlexSkel
/**
* Initializes a skeleton with SkinLimbs to a looping animation, dynamically allocating the frame tables.
*/
void SkelAnime_InitSkin(GlobalContext* globalCtx, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg,
void SkelAnime_InitSkin(GameState* gameState, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg,
AnimationHeader* animation) {
SkeletonHeader* skeletonHeader;
src/code/z_skin.c
+261 -11
View File
@@ -1,23 +1,273 @@
#include "global.h"
#include "z64skin.h"
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_80137970.s")
// 60 is an arbitrary number which specifies the max amount of limbs per skeleton this system supports
MtxF gSkinLimbMatrices[60];
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_80137B34.s")
static s32 sUnused;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_80137EBC.s")
void Skin_UpdateVertices(MtxF* mtx, SkinVertex* skinVertices, SkinLimbModif* modifEntry, Vtx* vtxBuf, Vec3f* pos) {
SkinVertex* vertexEntry;
Vtx* vtx;
Vec3f wTemp;
Vec3f normal;
Vec3f sp44;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_80137F58.s")
wTemp.x = mtx->wx;
wTemp.y = mtx->wy;
wTemp.z = mtx->wz;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_80138050.s")
mtx->wx = 0.0f;
mtx->wy = 0.0f;
mtx->wz = 0.0f;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_80138228.s")
for (vertexEntry = skinVertices; vertexEntry < &skinVertices[modifEntry->vtxCount]; vertexEntry++) {
vtx = &vtxBuf[vertexEntry->index];
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_80138258.s")
vtx->n.ob[0] = pos->x;
vtx->n.ob[1] = pos->y;
vtx->n.ob[2] = pos->z;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_8013828C.s")
sp44.x = vertexEntry->normX;
sp44.y = vertexEntry->normY;
sp44.z = vertexEntry->normZ;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_801382C4.s")
SkinMatrix_Vec3fMtxFMultXYZ(mtx, &sp44, &normal);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_80138300.s")
vtx->n.n[0] = normal.x;
vtx->n.n[1] = normal.y;
vtx->n.n[2] = normal.z;
}
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin/func_8013835C.s")
mtx->wx = wTemp.x;
mtx->wy = wTemp.y;
mtx->wz = wTemp.z;
}
void Skin_ApplyLimbModifications(GraphicsContext* gfxCtx, Skin* skin, s32 limbIndex, s32 arg3) {
s32 modifCount;
SkinLimb** skeleton;
s32 pad;
SkinAnimatedLimbData* data;
s32 pad2[5];
SkinLimbModif* modif;
SkinLimbVtx* vtxEntry;
s32 pad3;
s32 transformCount;
f32 scale;
SkinVertex* skinVertices;
Vec3f sp88;
Vtx* vtxBuf;
SkinTransformation* limbTransformations;
Vec3f spDC;
Vec3f spD0;
SkinTransformation* transformationEntry;
SkinLimb* limb;
SkinLimbModif* modifications;
OPEN_DISPS(gfxCtx);
skeleton = (SkinLimb**)Lib_SegmentedToVirtual(skin->skeletonHeader->segment);
limb = (SkinLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
data = Lib_SegmentedToVirtual(limb->segment);
modifications = (SkinLimbModif*)Lib_SegmentedToVirtual(data->limbModifications);
vtxEntry = &skin->vtxTable[limbIndex];
vtxBuf = vtxEntry->buf[vtxEntry->index];
modifCount = data->limbModifCount;
for (modif = modifications; modif < &modifications[modifCount]; modif++) {
Vec3f spAC;
Vec3f spA0;
skinVertices = (SkinVertex*)Lib_SegmentedToVirtual(modif->skinVertices);
limbTransformations = (SkinTransformation*)Lib_SegmentedToVirtual(modif->limbTransformations);
transformCount = modif->transformCount;
if (transformCount == 1) {
spAC.x = limbTransformations[0].x;
spAC.y = limbTransformations[0].y;
spAC.z = limbTransformations[0].z;
SkinMatrix_Vec3fMtxFMultXYZ(&gSkinLimbMatrices[limbTransformations[0].limbIndex], &spAC, &spDC);
} else if (arg3) {
transformationEntry = &limbTransformations[modif->unk_04];
spA0.x = transformationEntry->x;
spA0.y = transformationEntry->y;
spA0.z = transformationEntry->z;
SkinMatrix_Vec3fMtxFMultXYZ(&gSkinLimbMatrices[transformationEntry->limbIndex], &spA0, &spDC);
} else {
spDC.x = 0.0f;
spDC.y = 0.0f;
spDC.z = 0.0f;
for (transformationEntry = limbTransformations; transformationEntry < &limbTransformations[transformCount];
transformationEntry++) {
scale = transformationEntry->scale * 0.01f;
sp88.x = transformationEntry->x;
sp88.y = transformationEntry->y;
sp88.z = transformationEntry->z;
SkinMatrix_Vec3fMtxFMultXYZ(&gSkinLimbMatrices[transformationEntry->limbIndex], &sp88, &spD0);
spDC.x += spD0.x * scale;
spDC.y += spD0.y * scale;
spDC.z += spD0.z * scale;
}
}
Skin_UpdateVertices(&gSkinLimbMatrices[limbTransformations[modif->unk_04].limbIndex], skinVertices, modif,
vtxBuf, &spDC);
}
gSPSegment(POLY_OPA_DISP++, 0x08, vtxEntry->buf[vtxEntry->index]);
vtxEntry->index = (vtxEntry->index == 0);
CLOSE_DISPS(gfxCtx);
}
/**
* Draw a limb of type SKIN_LIMB_TYPE_ANIMATED, of the skeleton `skin` at index `limbIndex`
* The vertices of this limb are modified dynamically
*/
void Skin_DrawAnimatedLimb(GraphicsContext* gfxCtx, Skin* skin, s32 limbIndex, s32 arg3, s32 drawFlags) {
SkinLimb** skeleton;
s32 pad[3];
SkinAnimatedLimbData* data;
OPEN_DISPS(gfxCtx);
skeleton = Lib_SegmentedToVirtual(skin->skeletonHeader->segment);
data = Lib_SegmentedToVirtual(((SkinLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]))->segment);
if (!(drawFlags & SKIN_DRAW_FLAG_CUSTOM_TRANSFORMS)) {
Skin_ApplyLimbModifications(gfxCtx, skin, limbIndex, arg3);
}
gSPDisplayList(POLY_OPA_DISP++, data->dlist);
CLOSE_DISPS(gfxCtx);
}
/**
* Draw a limb of type SKIN_LIMB_TYPE_NORMAL, of the skeleton `skin` at index `limbIndex`
*/
void Skin_DrawLimb(GraphicsContext* gfxCtx, Skin* skin, s32 limbIndex, Gfx* dListOverride, s32 drawFlags) {
Gfx* gfx = dListOverride;
SkinLimb** skeleton;
OPEN_DISPS(gfxCtx);
skeleton = Lib_SegmentedToVirtual(skin->skeletonHeader->segment);
if (dListOverride == NULL) {
gfx = ((SkinLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]))->segment;
}
if (gfx != NULL) {
Mtx* mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &gSkinLimbMatrices[limbIndex]);
if (mtx != NULL) {
gSPMatrix(POLY_OPA_DISP++, mtx, G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
gSPDisplayList(POLY_OPA_DISP++, gfx);
gSPPopMatrix(POLY_OPA_DISP++, G_MTX_MODELVIEW);
gDPPipeSync(POLY_OPA_DISP++);
}
}
CLOSE_DISPS(gfxCtx);
}
void Skin_DrawImpl(Actor* actor, GlobalContext* globalCtx, Skin* skin, SkinPostDraw postDraw,
SkinOverrideLimbDraw overrideLimbDraw, s32 setTranslation, s32 arg6, s32 drawFlags) {
s32 i;
SkinLimb** skeleton;
GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
OPEN_DISPS(gfxCtx);
if (!(drawFlags & SKIN_DRAW_FLAG_CUSTOM_TRANSFORMS)) {
Skin_ApplyAnimTransformations(skin, gSkinLimbMatrices, actor, setTranslation);
}
skeleton = Lib_SegmentedToVirtual(skin->skeletonHeader->segment);
if (!(drawFlags & SKIN_DRAW_FLAG_CUSTOM_MATRIX)) {
Mtx* mtx;
gSPMatrix(POLY_OPA_DISP++, &gIdentityMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &skin->mtx);
if (mtx == NULL) {
goto close_disps;
}
gSPMatrix(POLY_OPA_DISP++, mtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
}
for (i = 0; i < skin->skeletonHeader->limbCount; i++) {
s32 shouldDraw = true;
s32 segmentType;
if (overrideLimbDraw != NULL) {
shouldDraw = overrideLimbDraw(actor, globalCtx, i, skin);
}
segmentType = ((SkinLimb*)Lib_SegmentedToVirtual(skeleton[i]))->segmentType;
if (segmentType == SKIN_LIMB_TYPE_ANIMATED && shouldDraw) {
Skin_DrawAnimatedLimb(gfxCtx, skin, i, arg6, drawFlags);
} else if (segmentType == SKIN_LIMB_TYPE_NORMAL && shouldDraw) {
Skin_DrawLimb(gfxCtx, skin, i, NULL, drawFlags);
}
}
if (postDraw != NULL) {
postDraw(actor, globalCtx, skin);
}
close_disps:;
CLOSE_DISPS(gfxCtx);
}
// allows specifying postDraw and setTranslation
void func_80138228(Actor* actor, GlobalContext* globalCtx, Skin* skin, SkinPostDraw postDraw, s32 setTranslation) {
Skin_DrawImpl(actor, globalCtx, skin, postDraw, NULL, setTranslation, false, 0);
}
// allows specifying OverrideLimbDraw, postDraw and setTranslation
void func_80138258(Actor* actor, GlobalContext* globalCtx, Skin* skin, SkinPostDraw postDraw,
SkinOverrideLimbDraw overrideLimbDraw, s32 setTranslation) {
Skin_DrawImpl(actor, globalCtx, skin, postDraw, overrideLimbDraw, setTranslation, false, 0);
}
// allows specifying OverrideLimbDraw, postDraw, setTranslation, and arg6
void func_8013828C(Actor* actor, GlobalContext* globalCtx, Skin* skin, SkinPostDraw postDraw,
SkinOverrideLimbDraw overrideLimbDraw, s32 setTranslation, s32 arg6) {
Skin_DrawImpl(actor, globalCtx, skin, postDraw, overrideLimbDraw, setTranslation, arg6, 0);
}
// allows specifying all variables
void func_801382C4(Actor* actor, GlobalContext* globalCtx, Skin* skin, SkinPostDraw postDraw,
SkinOverrideLimbDraw overrideLimbDraw, s32 setTranslation, s32 arg6, s32 drawFlags) {
Skin_DrawImpl(actor, globalCtx, skin, postDraw, overrideLimbDraw, setTranslation, arg6, drawFlags);
}
void Skin_GetLimbPos(Skin* skin, s32 limbIndex, Vec3f* offset, Vec3f* dst) {
MtxF mtxf;
SkinMatrix_MtxFMtxFMult(&skin->mtx, &gSkinLimbMatrices[limbIndex], &mtxf);
SkinMatrix_Vec3fMtxFMultXYZ(&mtxf, offset, dst);
}
void Skin_GetVertexPos(Skin* skin, s32 limbIndex, s32 vtxIndex, Vec3f* dst) {
Vec3f pos;
Vtx* vtx = &skin->vtxTable[limbIndex].buf[skin->vtxTable[0].index][vtxIndex];
pos.x = vtx->n.ob[0];
pos.y = vtx->n.ob[1];
pos.z = vtx->n.ob[2];
SkinMatrix_Vec3fMtxFMultXYZ(&skin->mtx, &pos, dst);
}
src/code/z_skin_awb.c
+197 -6
View File
@@ -1,13 +1,204 @@
#include "global.h"
#include "z64skin.h"
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_awb/func_80138410.s")
void Skin_Setup(Skin* skin) {
skin->skeletonHeader = NULL;
skin->limbCount = 0;
skin->vtxTable = NULL;
}
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_awb/func_80138424.s")
/**
* Initialises the Vtx buffers used for limb at index `limbIndex`
*/
void Skin_InitAnimatedLimb(GameState* gameState, Skin* skin, s32 limbIndex) {
s32 i;
SkinLimb** skeleton = Lib_SegmentedToVirtual(skin->skeletonHeader->segment);
SkinAnimatedLimbData* animatedLimbData =
Lib_SegmentedToVirtual(((SkinLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]))->segment);
SkinLimbModif* limbModifications = Lib_SegmentedToVirtual(animatedLimbData->limbModifications);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_awb/func_8013859C.s")
for (i = 0; i < ARRAY_COUNT(skin->vtxTable->buf); i++) {
Vtx* vertices = skin->vtxTable[limbIndex].buf[i];
SkinLimbModif* modifEntry;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_awb/func_80138700.s")
for (modifEntry = limbModifications; modifEntry < &limbModifications[animatedLimbData->limbModifCount];
modifEntry++) {
SkinVertex* skinVertices = Lib_SegmentedToVirtual(modifEntry->skinVertices);
SkinVertex* skinVtxEntry;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_awb/func_801387D4.s")
for (skinVtxEntry = skinVertices; skinVtxEntry < &skinVertices[modifEntry->vtxCount];) {
Vtx* vtx = &vertices[skinVtxEntry->index];
#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_awb/func_801388E4.s")
skinVtxEntry++;
vtx->n.flag = 0;
vtx->n.tc[0] = skinVtxEntry[-1].s;
vtx->n.tc[1] = skinVtxEntry[-1].t;
vtx->n.a = skinVtxEntry[-1].alpha;
}
}
}
}
/**
* Initializes a skin skeleton to looping animation, dynamically allocating the frame tables,
* and dynamically allocating and initialising the Vtx and SkinLimbVtx buffers for its animated limbs
*/
void Skin_Init(GameState* gameState, Skin* skin, SkeletonHeader* skeletonHeader, AnimationHeader* animationHeader) {
s32 limbCount;
s32 i;
SkinLimb** skeleton;
SkeletonHeader* virtSkelHeader = Lib_SegmentedToVirtual(skeletonHeader);
skin->limbCount = virtSkelHeader->limbCount;
skin->skeletonHeader = virtSkelHeader;
limbCount = skin->skeletonHeader->limbCount;
skeleton = Lib_SegmentedToVirtual(skin->skeletonHeader->segment);
skin->vtxTable = ZeldaArena_Malloc(limbCount * sizeof(SkinLimbVtx));
for (i = 0; i < limbCount; i++) {
SkinLimbVtx* vtxEntry = &skin->vtxTable[i];
if ((((SkinLimb*)Lib_SegmentedToVirtual(skeleton[i]))->segmentType != SKIN_LIMB_TYPE_ANIMATED) ||
(((SkinLimb*)Lib_SegmentedToVirtual(skeleton[i]))->segment == NULL)) {
vtxEntry->index = 0;
vtxEntry->buf[0] = NULL;
vtxEntry->buf[1] = NULL;
} else {
SkinAnimatedLimbData* animatedLimbData =
Lib_SegmentedToVirtual((((SkinLimb*)Lib_SegmentedToVirtual(skeleton[i]))->segment));
{ s32 tmp; }
vtxEntry->index = 0;
vtxEntry->buf[0] = ZeldaArena_Malloc(animatedLimbData->totalVtxCount * sizeof(Vtx));
vtxEntry->buf[1] = ZeldaArena_Malloc(animatedLimbData->totalVtxCount * sizeof(Vtx));
Skin_InitAnimatedLimb(gameState, skin, i);
}
}
SkelAnime_InitSkin(gameState, &skin->skelAnime, skeletonHeader, animationHeader);
}
/**
* Frees the dynamically allocated Vtx and SkinLimbVtx buffers and tables
*/
void Skin_Free(GameState* gameState, Skin* skin) {
if (skin->vtxTable != NULL) {
s32 i;
for (i = 0; i < skin->limbCount; i++) {
if (skin->vtxTable[i].buf[0] != NULL) {
ZeldaArena_Free(skin->vtxTable[i].buf[0]);
skin->vtxTable[i].buf[0] = NULL;
}
if (skin->vtxTable[i].buf[1] != NULL) {
ZeldaArena_Free(skin->vtxTable[i].buf[1]);
skin->vtxTable[i].buf[1] = NULL;
}
}
if (skin->vtxTable != NULL) {
ZeldaArena_Free(skin->vtxTable);
}
SkelAnime_Free(&skin->skelAnime, (GlobalContext*)gameState);
}
}
s32 func_801387D4(Skin* skin, SkinLimb** skeleton, MtxF* limbMatrices, u8 parentIndex, u8 limbIndex) {
s32 pad;
SkinLimb* limb = Lib_SegmentedToVirtual(skeleton[limbIndex]);
MtxF* mtx;
s32 ret;
MtxF sp28;
if (parentIndex == LIMB_DONE) {
SkinMatrix_GetClear(&mtx);
} else {
mtx = &limbMatrices[(s32)parentIndex];
}
SkinMatrix_MtxFMtxFMult(mtx, &limbMatrices[limbIndex], &sp28);
SkinMatrix_MtxFCopy(&sp28, &limbMatrices[limbIndex]);
if (limb->child != LIMB_DONE) {
ret = func_801387D4(skin, skeleton, limbMatrices, limbIndex, limb->child);
if (ret) {
return ret;
}
}
if (limb->sibling != LIMB_DONE) {
ret = func_801387D4(skin, skeleton, limbMatrices, parentIndex, limb->sibling);
if (ret) {
return ret;
}
}
return false;
}
/**
* Recursively applies matrix tranformations to each limb
*/
s32 Skin_ApplyAnimTransformations(Skin* skin, MtxF* limbMatrices, Actor* actor, s32 setTranslation) {
s32 i;
s32 pad;
f32 yRot;
f32 xRot;
f32 zRot;
s32 ret;
f32 yTransl;
f32 xTransl;
f32 zTransl;
SkinLimb** skeleton = Lib_SegmentedToVirtual(skin->skeletonHeader->segment);
Vec3s* jointRot = skin->skelAnime.jointTable;
jointRot++;
xRot = jointRot->x;
yRot = jointRot->y;
zRot = jointRot->z;
if (setTranslation) {
jointRot--;
xTransl = jointRot->x;
yTransl = jointRot->y;
zTransl = jointRot->z;
jointRot++;
SkinMatrix_SetRotateRPYTranslate(limbMatrices, xRot, yRot, zRot, xTransl, yTransl, zTransl);
} else {
SkinMatrix_SetRotateRPYTranslate(limbMatrices, xRot, yRot, zRot, 0.0f, 0.0f, 0.0f);
}
jointRot++;
for (i = 1; i < skin->skeletonHeader->limbCount; i++) {
SkinLimb* limb = Lib_SegmentedToVirtual(skeleton[i]);
xTransl = limb->jointPos.x;
yTransl = limb->jointPos.y;
zTransl = limb->jointPos.z;
xRot = jointRot->x;
yRot = jointRot->y;
zRot = jointRot->z;
jointRot++;
SkinMatrix_SetRotateRPYTranslate(&limbMatrices[i], xRot, yRot, zRot, xTransl, yTransl, zTransl);
}
SkinMatrix_SetScaleRotateYRPTranslate(
&skin->mtx, actor->scale.x, actor->scale.y, actor->scale.z, actor->shape.rot.x, actor->shape.rot.y,
actor->shape.rot.z, actor->world.pos.x, actor->world.pos.y + (actor->shape.yOffset * actor->scale.y),
actor->world.pos.z);
ret = func_801387D4(skin, Lib_SegmentedToVirtual(skin->skeletonHeader->segment), limbMatrices, LIMB_DONE, 0);
if (!ret) {
return ret;
}
return false;
}