vrmiguel
/
sm64pc
mirror of https://github.com/sm64pc/sm64pc.git
1
0
Fork 0
Code Issues Releases Wiki Activity
sm64pc/src/goddard/objects.c

2024 lines
55 KiB
C
Raw Permalink Blame History

#include <PR/ultratypes.h>
#include <stdarg.h>
#include <stdio.h>
#include "objects.h"
#include "debug_utils.h"
#include "draw_objects.h"
#include "dynlist_proc.h"
#include "gd_macros.h"
#include "gd_main.h"
#include "gd_math.h"
#include "gd_types.h"
#include "joints.h"
#include "macros.h"
#include "old_menu.h"
#include "particles.h"
#include "renderer.h"
#include "sfx.h"
#include "shape_helper.h"
#include "skin.h"
// structs
struct Unk801B9E68 {
/* 0x00 */ s32 count;
/* 0x04 */ u8 pad[0x14];
}; /* sizeof() = 0x18 */
struct Unk8017F3CC {
/*0x00*/ u8 pad[0x20];
/*0x20*/ struct GdVec3f unk20;
};
// data
f32 D_801A81C0 = 0.0f;
f32 D_801A81C4 = 0.0f;
// bss
struct GdPlaneF D_801B9DA0;
struct ObjCamera *sCurrentMoveCamera; // @ 801B9DB8
struct ObjView *sCurrentMoveView; // @ 801B9DBC
struct DebugCounters gGdCounter; // @ 801B9DC0
Mat4f D_801B9DC8;
struct GdVec3f D_801B9E08;
struct ObjGroup *sCurrentMoveGrp; // @ 801B9E14
struct GdVec3f D_801B9E18;
struct GdVec3f D_801B9E28;
f32 D_801B9E34;
Mat4f *D_801B9E38;
struct ObjParticle *D_801B9E3C;
s32 D_801B9E40;
s32 D_801B9E44;
Mat4f *D_801B9E48;
struct ObjCamera *gGdCameraList; // @ 801B9E4C
void *D_801B9E50;
struct ObjGroup *gGdGroupList; // @ 801B9E54
s32 gGdObjCount; // @ 801B9E58
s32 gGdGroupCount; // @ 801B9E5C
s32 gGdPlaneCount; // @ 801B9E60
s32 gGdCameraCount; // @ 801B9E64
struct Unk801B9E68 sGdViewInfo; // @ 801B9E68
void *D_801B9E80;
struct ObjJoint *gGdJointList; // @ 801B9E84
struct ObjBone *gGdBoneList; // @ 801B9E88
struct GdObj *gGdObjectList; // @ 801B9E8C
struct ObjGroup *gGdViewsGroup; // @ 801B9E90
/* @ 22A480 for 0x70 */
void func_8017BCB0(void) { /* Initialize Plane? */
D_801B9DA0.p0.x = 10000000.0f;
D_801B9DA0.p0.y = 10000000.0f;
D_801B9DA0.p0.z = 10000000.0f;
D_801B9DA0.p1.x = -10000000.0f;
D_801B9DA0.p1.y = -10000000.0f;
D_801B9DA0.p1.z = -10000000.0f;
}
// TODO: fix first argument's type once type of set_cur_dynobj is known
// Should be an ObjVertex*
/* @ 22A4F0 for 0x140 */
void func_8017BD20(void *a0) {
struct GdVec3f sp1c;
set_cur_dynobj(a0);
d_get_world_pos(&sp1c);
if (sp1c.x < D_801B9DA0.p0.x) {
D_801B9DA0.p0.x = sp1c.x;
}
if (sp1c.y < D_801B9DA0.p0.y) {
D_801B9DA0.p0.y = sp1c.y;
}
if (sp1c.z < D_801B9DA0.p0.z) {
D_801B9DA0.p0.z = sp1c.z;
}
if (sp1c.x > D_801B9DA0.p1.x) {
D_801B9DA0.p1.x = sp1c.x;
}
if (sp1c.y > D_801B9DA0.p1.y) {
D_801B9DA0.p1.y = sp1c.y;
}
if (sp1c.z > D_801B9DA0.p1.z) {
D_801B9DA0.p1.z = sp1c.z;
}
}
/* @ 22A630 for 0x70 */
void func_8017BE60(struct GdPlaneF *a0) {
a0->p0.x = D_801B9DA0.p0.x;
a0->p0.y = D_801B9DA0.p0.y;
a0->p0.z = D_801B9DA0.p0.z;
a0->p1.x = D_801B9DA0.p1.x;
a0->p1.y = D_801B9DA0.p1.y;
a0->p1.z = D_801B9DA0.p1.z;
}
/* @ 22A6A0 for 0x24 */
void func_8017BED0(UNUSED struct ObjGroup *a0, UNUSED struct GdObj *a1) {
UNUSED u8 sp00[8];
/* Debug stub? */
return;
}
/* @ 22A6C4 for 0x2CC; orig. name: func_8017BEF4 */
const char *get_obj_name_str(enum ObjTypeFlag objFlag) {
/* sp04 */ const char *objName;
switch (objFlag) {
case OBJ_TYPE_JOINTS:
objName = "joints";
break;
case OBJ_TYPE_BONES:
objName = "bones";
break;
case OBJ_TYPE_GROUPS:
objName = "groups";
break;
case OBJ_TYPE_PARTICLES:
objName = "particles";
break;
case OBJ_TYPE_SHAPES:
objName = "shapes";
break;
case OBJ_TYPE_NETS:
objName = "nets";
break;
case OBJ_TYPE_PLANES:
objName = "planes";
break;
case OBJ_TYPE_VERTICES:
objName = "vertices";
break;
case OBJ_TYPE_CAMERAS:
objName = "cameras";
break;
case OBJ_TYPE_FACES:
objName = "faces";
break;
case OBJ_TYPE_MATERIALS:
objName = "materials";
break;
case OBJ_TYPE_LIGHTS:
objName = "lights";
break;
case OBJ_TYPE_WEIGHTS:
objName = "weights";
break;
case OBJ_TYPE_GADGETS:
objName = "gadgets";
break;
case OBJ_TYPE_VIEWS:
objName = "views";
break;
case OBJ_TYPE_LABELS:
objName = "labels";
break;
case OBJ_TYPE_ANIMATORS:
objName = "animators";
break;
case OBJ_TYPE_VALPTRS:
objName = "valptrs";
break;
case OBJ_TYPE_ZONES:
objName = "zones";
break;
default:
objName = "unkown";
break;
}
return objName;
}
/* @ 22A990 for 0x510 */
struct GdObj *make_object(enum ObjTypeFlag objType) {
struct GdObj *newObj;
struct GdObj *objListOldHead;
s32 objSize;
s32 i;
drawmethod_t objDrawFn;
const char *objNameStr;
u8 *newObjBytes;
s32 objPermanence = 0x10;
add_to_stacktrace("make_object");
switch (objType) {
case OBJ_TYPE_JOINTS:
objSize = sizeof(struct ObjJoint);
objDrawFn = (drawmethod_t) draw_joint;
break;
case OBJ_TYPE_BONES:
objSize = sizeof(struct ObjBone);
objDrawFn = (drawmethod_t) draw_bone;
break;
case OBJ_TYPE_GROUPS:
objSize = sizeof(struct ObjGroup);
objDrawFn = (drawmethod_t) draw_group;
break;
case OBJ_TYPE_PARTICLES:
objSize = sizeof(struct ObjParticle);
objDrawFn = (drawmethod_t) draw_particle;
break;
case OBJ_TYPE_SHAPES:
objSize = sizeof(struct ObjShape);
objDrawFn = (drawmethod_t) nop_obj_draw;
break;
case OBJ_TYPE_UNK200000:
objSize = sizeof(struct ObjUnk200000);
objDrawFn = (drawmethod_t) nop_obj_draw;
break;
case OBJ_TYPE_NETS:
objSize = sizeof(struct ObjNet);
objDrawFn = (drawmethod_t) draw_net;
break;
case OBJ_TYPE_PLANES:
objSize = sizeof(struct ObjPlane);
objDrawFn = (drawmethod_t) draw_plane;
break;
case OBJ_TYPE_VERTICES:
objSize = sizeof(struct ObjVertex);
objDrawFn = (drawmethod_t) nop_obj_draw;
break;
case OBJ_TYPE_CAMERAS:
objSize = sizeof(struct ObjCamera);
objDrawFn = (drawmethod_t) draw_camera;
break;
case OBJ_TYPE_FACES:
objSize = sizeof(struct ObjFace);
objDrawFn = (drawmethod_t) draw_face;
objPermanence = 1;
break;
case OBJ_TYPE_MATERIALS:
objSize = sizeof(struct ObjMaterial);
objDrawFn = (drawmethod_t) draw_material;
break;
case OBJ_TYPE_LIGHTS:
objSize = sizeof(struct ObjLight);
objDrawFn = (drawmethod_t) draw_light;
break;
case OBJ_TYPE_WEIGHTS:
objSize = sizeof(struct ObjWeight);
objDrawFn = (drawmethod_t) nop_obj_draw;
break;
case OBJ_TYPE_GADGETS:
objSize = sizeof(struct ObjGadget);
objDrawFn = (drawmethod_t) draw_gadget;
break;
case OBJ_TYPE_VIEWS:
objSize = sizeof(struct ObjView);
objDrawFn = (drawmethod_t) nop_obj_draw;
break;
case OBJ_TYPE_LABELS:
objSize = sizeof(struct ObjLabel);
objDrawFn = (drawmethod_t) draw_label;
break;
case OBJ_TYPE_ANIMATORS:
objSize = sizeof(struct ObjAnimator);
objDrawFn = (drawmethod_t) nop_obj_draw;
break;
case OBJ_TYPE_VALPTRS:
objSize = sizeof(struct ObjValPtrs);
objDrawFn = (drawmethod_t) nop_obj_draw;
break;
case OBJ_TYPE_ZONES:
objSize = sizeof(struct ObjZone);
objDrawFn = (drawmethod_t) nop_obj_draw;
break;
default:
fatal_print("make_object() : Unkown object!");
}
objNameStr = get_obj_name_str(objType);
start_memtracker(objNameStr);
newObj = gd_malloc(objSize, objPermanence);
if (newObj == NULL) {
fatal_printf("Cant allocate object '%s' memory!", objNameStr);
}
stop_memtracker(objNameStr);
newObjBytes = (u8 *) newObj;
for (i = 0; i < objSize; i++) {
newObjBytes[i] = 0;
}
gGdObjCount++;
objListOldHead = gGdObjectList;
gGdObjectList = newObj;
newObj->prev = NULL;
if (objListOldHead != NULL) {
newObj->next = objListOldHead;
objListOldHead->prev = newObj;
}
newObj->number = gGdObjCount;
newObj->type = objType;
newObj->objDrawFn = objDrawFn;
newObj->drawFlags = 0;
imout();
return newObj;
}
/* @ 22AEA0 for 0xD0; orig name: func_8017C6D0 */
struct ObjZone *make_zone(struct ObjGroup *a0, struct GdPlaneF *a1, struct ObjGroup *a2) {
struct ObjZone *newZone = (struct ObjZone *) make_object(OBJ_TYPE_ZONES);
newZone->unk14.p0.x = a1->p0.x;
newZone->unk14.p0.y = a1->p0.y;
newZone->unk14.p0.z = a1->p0.z;
newZone->unk14.p1.x = a1->p1.x;
newZone->unk14.p1.y = a1->p1.y;
newZone->unk14.p1.z = a1->p1.z;
// pointers? prev, next?
newZone->unk2C = a2;
newZone->unk30 = a0;
//! @bug Created `ObjZone` is not returned
#ifdef AVOID_UB
return newZone;
#endif
}
/* @ 22AF70 for 0x60 */
struct ObjUnk200000 *func_8017C7A0(struct ObjVertex *a0, struct ObjFace *a1) {
struct ObjUnk200000 *sp1C = (struct ObjUnk200000 *) make_object(OBJ_TYPE_UNK200000);
sp1C->unk30 = a0;
sp1C->unk34 = a1;
return sp1C;
}
/* @ 22AFD0 for 0xC0; orig name: func_8017C800 */
struct Links *make_link_to_obj(struct Links *head, struct GdObj *a1) {
struct Links *newLink;
start_memtracker("links");
newLink = gd_malloc_perm(sizeof(struct Links));
if (newLink == NULL) {
fatal_print("Cant allocate link memory!");
}
stop_memtracker("links");
if (head != NULL) {
head->next = newLink;
}
newLink->prev = head;
newLink->next = NULL;
newLink->obj = a1;
return newLink;
}
/* @ 22B090 -> 22B154; orig name: func_8017C8C0 */
struct VtxLink *make_vtx_link(struct VtxLink *prevlink, Vtx *data) {
struct VtxLink *newLink;
newLink = gd_malloc_perm(sizeof(struct VtxLink));
if (newLink == NULL) {
fatal_print("Cant allocate link memory!");
}
if (prevlink != NULL) {
prevlink->next = newLink;
}
newLink->prev = prevlink;
newLink->next = NULL;
newLink->data = data;
// WTF?
if (((uintptr_t)(newLink)) == 0x3F800000) {
fatal_printf("bad3\n");
}
return newLink;
}
/* @ 22B154 for 0x88; orig name: func8017C984 */
struct ObjValPtrs *make_valptrs(struct GdObj *obj, s32 flags, enum ValPtrType type, size_t offset) {
struct ObjValPtrs *sp1C = (struct ObjValPtrs *) make_object(OBJ_TYPE_VALPTRS);
sp1C->obj = obj;
sp1C->unk20 = flags;
sp1C->offset = offset;
sp1C->datatype = type;
return sp1C;
}
/* @ 22B1DC for 0x430 */
void reset_plane(struct ObjPlane *plane) {
struct ObjFace *sp4C;
f32 sp48;
f32 sp44;
UNUSED u32 sp40;
UNUSED u32 sp3C;
UNUSED u32 sp38;
s32 i;
s32 sp30;
register f32 sp28;
add_to_stacktrace("reset_plane");
sp4C = plane->unk40;
calc_face_normal(sp4C);
plane->unk1C = gd_dot_vec3f(&sp4C->vertices[0]->pos, &sp4C->normal);
sp48 = 0.0f;
sp28 = sp4C->normal.x < 0.0f ? -sp4C->normal.x : sp4C->normal.x;
sp44 = sp28;
if (sp44 > sp48) {
sp30 = 0;
sp48 = sp44;
}
sp28 = sp4C->normal.y < 0.0f ? -sp4C->normal.y : sp4C->normal.y;
sp44 = sp28;
if (sp44 > sp48) {
sp30 = 1;
sp48 = sp44;
}
sp28 = sp4C->normal.z < 0.0f ? -sp4C->normal.z : sp4C->normal.z;
sp44 = sp28;
if (sp44 > sp48) {
sp30 = 2;
}
switch (sp30) {
case 0:
plane->unk20 = 1;
plane->unk24 = 2;
break;
case 1:
plane->unk20 = 0;
plane->unk24 = 2;
break;
case 2:
plane->unk20 = 0;
plane->unk24 = 1;
break;
}
func_8017BCB0();
for (i = 0; i < sp4C->vtxCount; i++) {
func_8017BD20(sp4C->vertices[i]);
}
plane->plane28.p0.x = D_801B9DA0.p0.x;
plane->plane28.p0.y = D_801B9DA0.p0.y;
plane->plane28.p0.z = D_801B9DA0.p0.z;
plane->plane28.p1.x = D_801B9DA0.p1.x;
plane->plane28.p1.y = D_801B9DA0.p1.y;
plane->plane28.p1.z = D_801B9DA0.p1.z;
if (plane->plane28.p1.x - plane->plane28.p0.x < 100.0f) {
plane->plane28.p1.x += 50.0f;
plane->plane28.p0.x -= 50.0f;
}
plane->plane28.p1.y += 200.0f;
plane->plane28.p0.y -= 200.0f;
if (plane->plane28.p1.z - plane->plane28.p0.z < 100.0f) {
plane->plane28.p1.z += 50.0f;
plane->plane28.p0.z -= 50.0f;
}
imout();
}
/* @ 22B60C for 0x94; orig name: func_8017CE3C */
struct ObjPlane *make_plane(s32 inZone, struct ObjFace *a1) {
UNUSED u32 pad1C;
struct ObjPlane *newPlane = (struct ObjPlane *) make_object(OBJ_TYPE_PLANES);
gGdPlaneCount++;
newPlane->id = gGdPlaneCount;
newPlane->unk18 = inZone;
newPlane->unk40 = a1;
reset_plane(newPlane);
return newPlane;
}
/* @ 22B6A0 for 0x21C; orig name: func_8017CED0 */
struct ObjCamera *make_camera(s32 a0, struct GdObj *a1) {
struct ObjCamera *newCam;
struct ObjCamera *oldCameraHead;
newCam = (struct ObjCamera *) make_object(OBJ_TYPE_CAMERAS);
gGdCameraCount++;
newCam->id = gGdCameraCount;
oldCameraHead = gGdCameraList;
gGdCameraList = newCam;
if (oldCameraHead != NULL) {
newCam->next = oldCameraHead;
oldCameraHead->prev = newCam;
}
newCam->unk2C = a0 | 0x10;
newCam->unk30 = a1;
gd_set_identity_mat4(&newCam->unk64);
gd_set_identity_mat4(&newCam->unkA8);
newCam->unk180.x = 1.0f;
newCam->unk180.y = 0.1f;
newCam->unk180.z = 1.0f;
newCam->unk134.x = 4.0f;
newCam->unk134.y = 4.0f;
newCam->unk134.z = 4.0f;
newCam->unk178 = 0.0f;
newCam->unk17C = 0.25f;
newCam->zoom = 0;
newCam->zoomLevels = -1;
newCam->unkA4 = 0.0f;
newCam->unk34.x = newCam->unk34.y = newCam->unk34.z = 0.0f;
newCam->unk14.x = newCam->unk14.y = newCam->unk14.z = 0.0f;
return newCam;
}
/* @ 22B8BC for 0xA8; orig. name: func_8017D0EC */
struct ObjMaterial *make_material(UNUSED s32 a0, char *name, s32 id) {
struct ObjMaterial *newMtl;
newMtl = (struct ObjMaterial *) make_object(OBJ_TYPE_MATERIALS);
if (name != NULL) {
gd_strcpy(newMtl->name, name);
} else {
gd_strcpy(newMtl->name, "NoName");
}
newMtl->id = id;
newMtl->gddlNumber = 0;
newMtl->type = 16;
return newMtl;
}
/* @ 22B964 for 0x114; orig name: func_8017D194 */
struct ObjLight *make_light(s32 flags, char *name, s32 id) {
struct ObjLight *newLight;
newLight = (struct ObjLight *) make_object(OBJ_TYPE_LIGHTS);
if (name != NULL) {
gd_strcpy(newLight->name, name);
} else {
gd_strcpy(newLight->name, "NoName");
}
newLight->id = id;
newLight->unk30 = 1.0f;
newLight->unk4C = 0;
newLight->flags = flags | LIGHT_NEW_UNCOUNTED;
newLight->unk98 = 0;
newLight->unk40 = 0;
newLight->unk68.x = newLight->unk68.y = newLight->unk68.z = 0;
return newLight;
}
/* @ 22BA78 for 0x294; orig name: func_8017D2A8*/
struct ObjView *make_view(const char *name, s32 flags, s32 a2, s32 ulx, s32 uly, s32 lrx, s32 lry,
struct ObjGroup *parts) {
struct ObjView *newView = (struct ObjView *) make_object(OBJ_TYPE_VIEWS);
if (gGdViewsGroup == NULL) {
gGdViewsGroup = make_group(0);
}
addto_group(gGdViewsGroup, &newView->header);
newView->flags = flags | VIEW_UPDATE | VIEW_LIGHT;
newView->id = sGdViewInfo.count++;
if ((newView->components = parts) != NULL) {
reset_nets_and_gadgets(parts);
}
newView->unk78 = 0;
newView->unk38 = a2;
newView->clipping.x = 30.0f;
newView->clipping.y = 5000.0f;
newView->clipping.z = 45.0f;
newView->upperLeft.x = (f32) ulx;
newView->upperLeft.y = (f32) uly;
newView->lowerRight.x = (f32) lrx;
newView->lowerRight.y = (f32) lry;
newView->unk48 = 1.0f;
newView->unk4C = 1.0f;
newView->colour.r = newView->id * 0.1; //? 0.1f, unless the extra precision was wanted for the tenth
newView->colour.g = 0.06f;
newView->colour.b = 1.0f;
newView->proc = NULL;
newView->unk9C = 0;
if (name != NULL) {
newView->unk1C = setup_view_buffers(name, newView, ulx, uly, lrx, lry);
}
newView->namePtr = name;
newView->lights = NULL;
return newView;
}
/* @ 22BD0C for 0x78; orig name: func_8017D53C */
struct ObjAnimator *make_animator(void) {
struct ObjAnimator *newAnim = (struct ObjAnimator *) make_object(OBJ_TYPE_ANIMATORS);
newAnim->unk24 = 1.0f;
newAnim->unk28 = 1.0f;
newAnim->fn48 = NULL;
newAnim->unk4C = 0;
return newAnim;
}
/* @ 22BD84 for 0x78; orig name: func_8017D5B4 */
struct ObjWeight *make_weight(UNUSED s32 a0, s32 id, struct ObjVertex *vtx, f32 weight) {
struct ObjWeight *newWeight = (struct ObjWeight *) make_object(OBJ_TYPE_WEIGHTS);
newWeight->id = id;
newWeight->unk38 = weight;
newWeight->unk3C = vtx;
return newWeight;
}
/* @ 22BDFC for 0xCC; orig name: func_8017D62C */
struct ObjGroup *make_group_of_type(enum ObjTypeFlag type, struct GdObj *fromObj, struct GdObj *toObj) {
struct ObjGroup *newGroup;
struct GdObj *curObj;
newGroup = make_group(0);
curObj = fromObj;
while (curObj != NULL) {
if (curObj->type & type) {
addto_group(newGroup, curObj);
}
if (curObj == toObj) {
break;
}
curObj = curObj->prev;
}
return newGroup;
}
/* @ 22BEC8 for 0x1CC; orig name: func_8017D6F8 */
void sprint_obj_id(char *str, struct GdObj *obj) {
enum ObjTypeFlag type = obj->type;
switch (type) {
case OBJ_TYPE_BONES:
sprintf(str, "b%d ", ((struct ObjBone *) obj)->id);
break;
case OBJ_TYPE_JOINTS:
sprintf(str, "j%d ", ((struct ObjJoint *) obj)->id);
break;
case OBJ_TYPE_GROUPS:
sprintf(str, "g%d ", ((struct ObjGroup *) obj)->id);
break;
case OBJ_TYPE_PARTICLES:
sprintf(str, "p%d ", ((struct ObjParticle *) obj)->id);
break;
case OBJ_TYPE_NETS:
sprintf(str, "net(no id) ");
break;
case OBJ_TYPE_CAMERAS:
sprintf(str, "c%d ", ((struct ObjCamera *) obj)->id);
break;
case OBJ_TYPE_VERTICES:
sprintf(str, "v(no id) ");
break;
case OBJ_TYPE_PLANES:
sprintf(str, "pl%d ", ((struct ObjPlane *) obj)->id);
break;
default:
sprintf(str, "?%x ", type);
break;
}
}
/* @ 22C094 for 0x210 */
struct ObjGroup *make_group(s32 count, ...) {
va_list args;
s32 i;
UNUSED u32 sp5C;
struct GdObj *curObj;
UNUSED u32 sp54;
UNUSED u32 sp50;
UNUSED u32 sp4C;
struct ObjGroup *newGroup;
struct ObjGroup *oldGroupListHead;
struct GdObj *vargObj;
char idStrBuf[0x20];
struct Links *curLink;
newGroup = (struct ObjGroup *) make_object(OBJ_TYPE_GROUPS);
newGroup->id = ++gGdGroupCount;
newGroup->objCount = 0;
newGroup->link1C = newGroup->link20 = NULL;
printf("Made group no.%d\n", newGroup->id);
oldGroupListHead = gGdGroupList;
gGdGroupList = newGroup;
if (oldGroupListHead != NULL) {
newGroup->next = oldGroupListHead;
oldGroupListHead->prev = newGroup;
}
if (count == 0) {
return newGroup;
}
va_start(args, count);
curLink = NULL;
for (i = 0; i < count; i++) {
// get the next pointer in the struct.
vargObj = va_arg(args, struct GdObj *);
if (vargObj == NULL) { // one of our pointers was NULL. raise an error.
fatal_printf("make_group() NULL group ptr");
}
curObj = vargObj;
newGroup->groupObjTypes |= curObj->type;
addto_group(newGroup, vargObj);
}
va_end(args);
curLink = newGroup->link1C;
printf("Made group no.%d from: ", newGroup->id);
while (curLink != NULL) {
curObj = curLink->obj;
sprint_obj_id(idStrBuf, curObj);
printf("%s", idStrBuf);
printf("\n");
curLink = curLink->next;
}
return newGroup;
}
/* @ 22C2A4 for 0xEC */
void addto_group(struct ObjGroup *group, struct GdObj *obj) {
char strbuf[0x20];
UNUSED u8 pad[0x8];
add_to_stacktrace("addto_group");
if (group->link1C == NULL) {
group->link1C = make_link_to_obj(NULL, obj);
group->link20 = group->link1C;
} else {
group->link20 = make_link_to_obj(group->link20, obj);
}
group->groupObjTypes |= obj->type;
group->objCount++;
printf("Added ");
sprint_obj_id(strbuf, obj);
printf("%s", strbuf);
printf(" to ");
sprint_obj_id(strbuf, &group->header);
printf("%s", strbuf);
printf("\n");
imout();
}
/* @ 22C390 for 0xFC; orig name: func_8017DBC0 */
void addto_groupfirst(struct ObjGroup *group, struct GdObj *obj) {
struct Links *newLink;
add_to_stacktrace("addto_groupfirst");
if (group->link1C == NULL) {
group->link1C = make_link_to_obj(NULL, obj);
group->link20 = group->link1C;
} else {
newLink = make_link_to_obj(NULL, obj);
group->link1C->prev = newLink;
newLink->next = group->link1C;
group->link1C = newLink;
}
group->groupObjTypes |= obj->type;
group->objCount++;
imout();
}
/* @ 22C48C for 0x84; orig name: func_8017DCBC */
s32 group_contains_obj(struct ObjGroup *group, struct GdObj *obj) {
struct Links *objLink = group->link1C;
while (objLink != NULL) {
if (objLink->obj->number == obj->number) {
return 1;
}
objLink = objLink->next;
}
return 0;
}
/* @ 22C510 for 0x4A8 */
/* this shows details about all objects in the main object linked list */
void show_details(enum ObjTypeFlag type) {
enum ObjTypeFlag curObjType;
struct Links *curGroupLink;
struct ObjGroup *curSubGroup;
struct GdObj *curObj;
char idStrBuf[0x24];
s32 curGroupTypes;
gd_printf("\nDetails about: ");
switch (type) {
case OBJ_TYPE_GROUPS:
gd_printf("Groups\n");
break;
case OBJ_TYPE_BONES:
gd_printf("Bones\n");
break;
case OBJ_TYPE_JOINTS:
gd_printf("Joints\n");
break;
case OBJ_TYPE_PARTICLES:
gd_printf("Particles\n");
break;
default:
gd_printf("Everything?\n");
break;
}
curObj = gGdObjectList;
while (curObj != NULL) {
curObjType = curObj->type;
if (curObjType == type) {
sprint_obj_id(idStrBuf, curObj);
switch (curObjType) {
case OBJ_TYPE_GROUPS:
gd_printf("Group %s: ", idStrBuf);
curGroupTypes = ((struct ObjGroup *) curObj)->groupObjTypes;
if (curGroupTypes & OBJ_TYPE_GROUPS) {
gd_printf("groups ");
}
if (curGroupTypes & OBJ_TYPE_BONES) {
gd_printf("bones ");
}
if (curGroupTypes & OBJ_TYPE_JOINTS) {
gd_printf("joints ");
}
if (curGroupTypes & OBJ_TYPE_PARTICLES) {
gd_printf("particles ");
}
if (curGroupTypes & OBJ_TYPE_CAMERAS) {
gd_printf("cameras ");
}
if (curGroupTypes & OBJ_TYPE_NETS) {
gd_printf("nets ");
}
if (curGroupTypes & OBJ_TYPE_GADGETS) {
gd_printf("gadgets ");
}
if (curGroupTypes & OBJ_TYPE_LABELS) {
gd_printf("labels ");
}
if (curGroupTypes & OBJ_TYPE_FACES) {
gd_printf("face ");
}
if (curGroupTypes & OBJ_TYPE_VERTICES) {
gd_printf("vertex ");
}
curGroupLink = ((struct ObjGroup *) curObj)->link1C;
while (curGroupLink != NULL) {
sprint_obj_id(idStrBuf, curGroupLink->obj);
gd_printf("%s", idStrBuf);
curGroupLink = curGroupLink->next;
}
gd_printf("\n");
break;
case OBJ_TYPE_BONES:
gd_printf("Bone %s: ", idStrBuf);
curSubGroup = ((struct ObjBone *) curObj)->unk10C;
curGroupLink = curSubGroup->link1C;
while (curGroupLink != NULL) {
sprint_obj_id(idStrBuf, curGroupLink->obj);
gd_printf("%s", idStrBuf);
curGroupLink = curGroupLink->next;
}
gd_printf("\n");
break;
case OBJ_TYPE_JOINTS:
gd_printf("Joint %s: ", idStrBuf);
curSubGroup = ((struct ObjJoint *) curObj)->unk1C4;
curGroupLink = curSubGroup->link1C;
while (curGroupLink != NULL) {
sprint_obj_id(idStrBuf, curGroupLink->obj);
gd_printf("%s", idStrBuf);
curGroupLink = curGroupLink->next;
}
gd_printf("\n");
break;
default:;
}
}
curObj = curObj->next;
}
}
/* @ 22C9B8 for 0x24 */
s32 func_8017E1E8(void) {
s32 sp4 = 0;
return sp4;
}
/* @ 22C9DC for 0x24 */
s32 func_8017E20C(void) {
s32 sp4 = 0;
return sp4;
}
/* @ 22CA00 for 0x88 */
void gd_loadtexture(struct GdObj *obj) {
struct GdObj *localObjPtr = obj;
switch (obj->type) {
case OBJ_TYPE_JOINTS:
func_80191604((struct ObjJoint *) localObjPtr);
break;
case OBJ_TYPE_NETS:
reset_net((struct ObjNet *) localObjPtr);
break;
default:;
}
}
/* @ 22CA88 for 0x38 */
void func_8017E2B8(void) {
apply_to_obj_types_in_group(OBJ_TYPE_NETS, (applyproc_t) gd_loadtexture, sCurrentMoveGrp);
}
/* @ 22CAC0 for 0xF0 */
struct GdObj *func_8017E2F0(struct GdObj *obj, enum ObjTypeFlag type) {
UNUSED u32 sp2C;
enum ObjTypeFlag curObjType;
struct Links *curGroupLink;
curObjType = obj->type;
switch (curObjType) {
case OBJ_TYPE_GROUPS:
curGroupLink = ((struct ObjGroup *) obj)->link1C;
while (curGroupLink != NULL) {
func_8017E2F0(curGroupLink->obj, type);
curGroupLink = curGroupLink->next;
}
break;
case OBJ_TYPE_BONES:
break;
default:;
}
if (curObjType == type) {
return obj;
}
//! @bug Nothing is returned if a GdObj of `type` is not found
#ifdef AVOID_UB
return NULL;
#endif
}
/* @ 22CBB0 for 0x1A4; orig name: func8017E3E0 */
s32 apply_to_obj_types_in_group(s32 types, applyproc_t fn, struct ObjGroup *group) {
struct Links *curLink;
struct Links *nextLink;
struct GdObj *linkedObj;
enum ObjTypeFlag linkedObjType;
applyproc_t objFn;
UNUSED u8 pad2C[0x20];
s32 fnAppliedCount;
fnAppliedCount = 0;
//! @bug When `group` pointer is NULL, garbage is returned, not the
//! count of `fn` calls
if (group == NULL) {
#ifdef AVOID_UB
return fnAppliedCount;
#else
return;
#endif
}
if (group->linkType & 1) { // compressed data, not an Obj
return fnAppliedCount;
}
if (!((group->groupObjTypes & OBJ_TYPE_GROUPS) | (group->groupObjTypes & types))) {
return fnAppliedCount;
}
objFn = fn;
curLink = group->link1C;
while (curLink != NULL) {
linkedObj = curLink->obj;
linkedObjType = linkedObj->type;
nextLink = curLink->next;
if (linkedObjType == OBJ_TYPE_GROUPS) {
fnAppliedCount += apply_to_obj_types_in_group(types, fn, (struct ObjGroup *) linkedObj);
}
if (linkedObjType & types) {
(*objFn)(linkedObj);
fnAppliedCount++;
}
curLink = nextLink;
}
return fnAppliedCount;
}
/* @ 22CD54 for 0x2B4 */
void func_8017E584(struct ObjNet *a0, struct GdVec3f *a1, struct GdVec3f *a2) {
struct GdVec3f sp94;
struct GdVec3f sp88;
struct GdVec3f sp7C;
struct GdVec3f sp70;
UNUSED u8 pad30[0x40]; // unused MyMatrix4x4? f32[4][4]
f32 sp2C;
UNUSED u32 sp28;
struct GdVec3f sp1C;
sp70.x = a2->x;
sp70.y = a2->y;
sp70.z = a2->z;
gd_normalize_vec3f(&sp70);
sp7C.x = a1->x;
sp7C.y = a1->y;
sp7C.z = a1->z;
sp1C.x = a0->unkB0.x;
sp1C.y = a0->unkB0.y;
sp1C.z = a0->unkB0.z;
gd_rotate_and_translate_vec3f(&sp1C, &a0->mat128);
sp7C.x -= sp1C.x;
sp7C.y -= sp1C.y;
sp7C.z -= sp1C.z;
if (gd_normalize_vec3f(&sp7C) == FALSE) {
sp7C.x = -sp70.x;
sp7C.y = -sp70.y;
sp7C.z = -sp70.z;
}
gd_cross_vec3f(&sp70, a1, &sp94);
sp2C = (f32) gd_sqrt_d((sp94.x * sp94.x) + (sp94.z * sp94.z));
if (sp2C > 1000.0) { //? 1000.0f
sp2C = 1000.0f;
}
sp2C /= 1000.0; //? 1000.0f
sp2C = 1.0 - sp2C; //? 1.0f - sp2C
sp88.x = a2->x * sp2C;
sp88.y = a2->y * sp2C;
sp88.z = a2->z * sp2C;
a0->unk74.x += sp88.x;
a0->unk74.y += sp88.y;
a0->unk74.z += sp88.z;
}
/* @ 22D008 for 0x1B4 */
void func_8017E838(struct ObjNet *a0, struct GdVec3f *a1, struct GdVec3f *a2) {
UNUSED u32 sp84;
UNUSED u32 sp80;
UNUSED u32 sp7C;
struct GdVec3f sp70;
struct GdVec3f sp64;
UNUSED u8 pad24[0x40];
struct GdVec3f sp18;
sp64.x = a1->x;
sp64.y = a1->y;
sp64.z = a1->z;
sp18.x = a0->unkB0.x;
sp18.y = a0->unkB0.y;
sp18.z = a0->unkB0.z;
gd_rotate_and_translate_vec3f(&sp18, &a0->mat128);
sp64.x -= sp18.x;
sp64.y -= sp18.y;
sp64.z -= sp18.z;
sp64.x *= 0.01; //? 0.01f;
sp64.y *= 0.01; //? 0.01f;
sp64.z *= 0.01; //? 0.01f;
gd_cross_vec3f(a2, &sp64, &sp70);
gd_clamp_vec3f(&sp70, 5.0f);
a0->unk80.x += sp70.x;
a0->unk80.y += sp70.y;
a0->unk80.z += sp70.z;
}
/* @ 22D1BC for 0xA8 */
void func_8017E9EC(struct ObjNet *a0) {
struct GdVec3f sp5C;
Mat4f sp1C;
f32 sp18;
sp5C.x = a0->unkA4.x;
sp5C.y = a0->unkA4.y;
sp5C.z = a0->unkA4.z;
gd_normalize_vec3f(&sp5C);
sp18 = gd_vec3f_magnitude(&a0->unkA4);
gd_create_rot_mat_angular(&sp1C, &sp5C, -sp18);
gd_mult_mat4f(&D_801B9DC8, &sp1C, &D_801B9DC8);
}
/* @ 22D264 for 0x90 */
s32 func_8017EA94(struct GdVec3f *vec, Mat4f matrix) {
if (vec->x >= matrix[2][2] && vec->x <= matrix[3][1] && vec->z >= matrix[3][0]
&& vec->z <= matrix[3][3]) {
return 1;
}
return 0;
}
/* @ 22D2F4 for 0x1DC */
s32 func_8017EB24(struct GdObj *a0, struct GdObj *a1) {
struct GdVec3f sp44;
struct GdVec3f sp38;
struct GdPlaneF *sp34;
struct GdPlaneF *sp30;
struct GdPlaneF sp18;
set_cur_dynobj(a0);
d_get_world_pos(&sp44);
sp34 = d_get_plane();
set_cur_dynobj(a1);
d_get_world_pos(&sp38);
sp30 = d_get_plane();
sp18.p0.x = sp34->p0.x + sp30->p0.x;
sp18.p0.y = sp34->p0.y + sp30->p0.y;
sp18.p0.z = sp34->p0.z + sp30->p0.z;
sp18.p1.x = sp34->p1.x + sp30->p1.x;
sp18.p1.y = sp34->p1.y + sp30->p1.y;
sp18.p1.z = sp34->p1.z + sp30->p1.z;
D_801B9E08.x = sp38.x - sp44.x;
D_801B9E08.y = sp38.y - sp44.y;
D_801B9E08.z = sp38.z - sp44.z;
if (D_801B9E08.x >= sp18.p0.x) {
if (D_801B9E08.x <= sp18.p1.x) {
if (D_801B9E08.z >= sp18.p0.z) {
if (D_801B9E08.z <= sp18.p1.z) {
return 1;
}
}
}
}
return 0;
}
/* @ 22D4D0 for 0xCC */
s32 func_8017ED00(struct GdObj *a0, struct GdPlaneF *a1) {
struct GdVec3f sp1C;
set_cur_dynobj(a0);
d_get_world_pos(&sp1C);
if (sp1C.x >= a1->p0.x) {
if (sp1C.x <= a1->p1.x) {
if (sp1C.z >= a1->p0.z) {
if (sp1C.z <= a1->p1.z) {
return 1;
}
}
}
}
return 0;
}
/* @ 22D59C for 0x90 */
s32 func_8017EDCC(struct GdVec3f *a0, struct GdPlaneF *a1) {
if (a0->x >= a1->p0.x) {
if (a0->x <= a1->p1.x) {
if (a0->z >= a1->p0.z) {
if (a0->z <= a1->p1.z) {
return 1;
}
}
}
}
return 0;
}
/* @ 22D62C for 0x1F8; orig name: func_8017EE5C */
s32 gd_plane_point_within(struct GdPlaneF *a0, struct GdPlaneF *a1) {
if (a0->p0.x >= a1->p0.x) {
if (a0->p0.x <= a1->p1.x) {
if (a0->p0.z >= a1->p0.z) {
if (a0->p0.z <= a1->p1.z) {
return TRUE;
}
}
}
}
if (a0->p1.x >= a1->p0.x) {
if (a0->p1.x <= a1->p1.x) {
if (a0->p0.z >= a1->p0.z) {
if (a0->p0.z <= a1->p1.z) {
return TRUE;
}
}
}
}
if (a0->p1.x >= a1->p0.x) {
if (a0->p1.x <= a1->p1.x) {
if (a0->p1.z >= a1->p0.z) {
if (a0->p1.z <= a1->p1.z) {
return TRUE;
}
}
}
}
if (a0->p0.x >= a1->p0.x) {
if (a0->p0.x <= a1->p1.x) {
if (a0->p1.z >= a1->p0.z) {
if (a0->p1.z <= a1->p1.z) {
return TRUE;
}
}
}
}
return FALSE;
}
/* @ 22D824 for 0x1BC */
s32 func_8017F054(struct GdObj *a0, struct GdObj *a1) {
struct Links *curLink;
struct ObjGroup *curGroup;
UNUSED u32 sp54;
Mat4f *sp50;
Mat4f *sp4C;
Mat4f *sp48;
Mat4f *sp44;
Mat4f *sp40;
UNUSED u8 pad20[0x18];
struct GdVec3f sp1C;
if (a1 != NULL) {
set_cur_dynobj(a1);
sp50 = d_get_matrix_ptr();
sp44 = (Mat4f *) d_get_rot_mtx_ptr();
set_cur_dynobj(a0);
sp4C = d_get_idn_mtx_ptr();
sp40 = (Mat4f *) d_get_rot_mtx_ptr();
d_get_scale(&sp1C);
sp48 = d_get_matrix_ptr();
gd_mult_mat4f(sp4C, sp50, sp48);
gd_mult_mat4f(sp4C, sp44, sp40);
gd_scale_mat4f_by_vec3f(sp40, &sp1C);
} else {
set_cur_dynobj(a0);
sp48 = d_get_matrix_ptr();
sp4C = d_get_idn_mtx_ptr();
sp44 = (Mat4f *) d_get_rot_mtx_ptr();
d_get_scale(&sp1C);
gd_set_identity_mat4(sp48);
gd_copy_mat4f(sp4C, sp44);
gd_scale_mat4f_by_vec3f(sp44, &sp1C);
}
set_cur_dynobj(a0);
curGroup = d_get_att_objgroup();
if (curGroup != NULL) {
curLink = curGroup->link1C;
while (curLink != NULL) {
func_8017F054(curLink->obj, a0);
curLink = curLink->next;
}
}
return 0;
}
/* @ 22D9E0 for 0x1BC */
s32 func_8017F210(struct GdObj *a0, struct GdObj *a1) {
struct Links *sp6C;
struct ObjGroup *sp68;
UNUSED u32 sp64;
UNUSED Mat4f *sp60;
Mat4f *sp5C;
UNUSED Mat4f *sp58;
Mat4f *sp54;
Mat4f *sp50;
UNUSED u8 pad38[0x18];
struct GdVec3f sp2C;
s32 count = 0;
count++;
if (a1 != NULL) {
set_cur_dynobj(a1);
sp60 = d_get_matrix_ptr();
sp54 = (Mat4f *) d_get_rot_mtx_ptr();
set_cur_dynobj(a0);
sp5C = d_get_idn_mtx_ptr();
sp50 = (Mat4f *) d_get_rot_mtx_ptr();
d_get_scale(&sp2C);
gd_mult_mat4f(sp5C, sp54, sp50);
gd_scale_mat4f_by_vec3f(sp50, &sp2C);
} else {
set_cur_dynobj(a0);
sp58 = d_get_matrix_ptr();
sp5C = d_get_idn_mtx_ptr();
sp54 = (Mat4f *) d_get_rot_mtx_ptr();
d_get_scale(&sp2C);
gd_copy_mat4f(sp5C, sp54);
gd_scale_mat4f_by_vec3f(sp54, &sp2C);
}
set_cur_dynobj(a0);
sp68 = d_get_att_objgroup();
if (sp68 != NULL) {
sp6C = sp68->link1C;
while (sp6C != NULL) {
count += func_8017F210(sp6C->obj, a0);
sp6C = sp6C->next;
}
}
return count;
}
/* @ 22DB9C for 0x38; a0 might be ObjUnk200000* */
void func_8017F3CC(struct Unk8017F3CC *a0) {
gd_rotate_and_translate_vec3f(&a0->unk20, D_801B9E48);
}
/* @ 22DBD4 for 0x20 */
void func_8017F404(UNUSED f32 a0, UNUSED struct GdObj *a1, UNUSED struct GdObj *a2) {
UNUSED u8 pad[0x30];
}
/* @ 22DBF4 for 0x1A0 */
void func_8017F424(struct GdTriangleF *a0, struct GdTriangleF *a1, f32 a2) {
Mat4f sp40;
struct GdTriangleF sp1C;
gd_set_identity_mat4(&sp40);
if (a2 != 0.0f) {
sp1C.p1.x = a0->p1.x + (a1->p1.x - a0->p1.x) * a2;
sp1C.p1.y = a0->p1.y + (a1->p1.y - a0->p1.y) * a2;
sp1C.p1.z = a0->p1.z + (a1->p1.z - a0->p1.z) * a2;
sp1C.p2.x = a0->p2.x + (a1->p2.x - a0->p2.x) * a2;
sp1C.p2.y = a0->p2.y + (a1->p2.y - a0->p2.y) * a2;
sp1C.p2.z = a0->p2.z + (a1->p2.z - a0->p2.z) * a2;
gd_scale_mat4f_by_vec3f(&sp40, &a0->p0);
gd_rot_mat_about_vec(&sp40, &sp1C.p1);
gd_add_vec3f_to_mat4f_offset(&sp40, &sp1C.p2);
} else { // L8017F568
d_set_scale(a0->p0.x, a0->p0.y, a0->p0.z);
gd_rot_mat_about_vec(&sp40, &a0->p1);
gd_add_vec3f_to_mat4f_offset(&sp40, &a0->p2);
} // L8017F5A4
d_set_idn_mtx(&sp40);
}
/* @ 22DD94 for 0x1060; orig name: func_8017F5C4 */
void move_animator(struct ObjAnimator *animObj) {
struct AnimDataInfo *animData; // array?
Mat4f *mtxArr;
Mat4f localMtx;
struct GdTriangleF *triPtr; // Used as GdTriangleF[] or GdTriangleF*
struct GdTriangleF tri1;
struct GdTriangleF tri2;
s16(*triHArr)[9]; // GdTriangleH[]?
s16(*vec3hArr)[3]; // MyVec3h[]?
s16(*planeHArr)[6]; // GdPlaneH[]?
s16(*camPlaneHArr)[6]; // camera GdPlaneH[]?
struct GdObj *stubObj1 = NULL; // used only for call to stubbed function
struct GdObj *stubObj2 = NULL; // used only for call to stubbed function
UNUSED s32 sp50;
UNUSED s32 sp4C;
UNUSED s32 sp48;
UNUSED struct GdVec3f unusedVec;
s32 sp38;
s32 sp34;
f32 sp30;
f32 scale = 0.1f;
struct AnimMtxVec *sp28;
register struct Links *link;
struct GdObj *linkedObj;
if (animObj->fn48 != NULL) {
(*animObj->fn48)(animObj);
}
if (animObj->unk14 == NULL) {
return;
}
animData = (struct AnimDataInfo *) animObj->animdata->link1C->obj;
if (animObj->unk44 != NULL) {
animObj->unk28 = ((struct ObjAnimator *) animObj->unk44)->unk28
/ ((struct ObjAnimator *) animObj->unk44)->unk24;
animData +=
((struct ObjAnimator *) animObj->unk44)->unk20; //...why offset this pointer like this...
}
if (animData->type == 0) {
return;
}
unusedVec.x = 4.0f;
unusedVec.y = 1.0f;
unusedVec.z = 1.0f;
if (animObj->unk28 > (f32) animData->count) {
animObj->unk28 = 1.0f;
} else if (animObj->unk28 < 0.0f) {
animObj->unk28 = (f32) animData->count;
}
sp38 = animObj->unk28;
sp30 = animObj->unk28 - (f32) sp38;
sp34 = sp38 + 1;
if (sp34 > animData->count) {
sp34 = 1;
}
sp38--;
sp34--;
link = animObj->unk14->link1C;
while (link != NULL) {
linkedObj = link->obj;
set_cur_dynobj(linkedObj);
switch (animData->type) {
case GD_ANIM_MATRIX: // data = Mat4f* (f32[4][4])
mtxArr = (Mat4f *) animData->data;
/* This needs be be un-dereferenced pointer addition to make the registers match */
d_set_idn_mtx(mtxArr + (s32) animObj->unk28);
break;
case GD_ANIM_3H_SCALED: // data = s16(*)[3] or MyVec3h[]...
vec3hArr = (s16(*)[3]) animData->data;
d_get_scale(&tri1.p0);
tri2.p0.x = tri1.p0.x;
tri2.p0.y = tri1.p0.y;
tri2.p0.z = tri1.p0.z;
d_get_init_pos(&tri1.p2);
tri2.p2.x = tri1.p2.x;
tri2.p2.y = tri1.p2.y;
tri2.p2.z = tri1.p2.z;
tri1.p1.x = (f32) vec3hArr[sp38][0] * scale;
tri1.p1.y = (f32) vec3hArr[sp38][1] * scale;
tri1.p1.z = (f32) vec3hArr[sp38][2] * scale;
tri2.p1.x = (f32) vec3hArr[sp34][0] * scale;
tri2.p1.y = (f32) vec3hArr[sp34][1] * scale;
tri2.p1.z = (f32) vec3hArr[sp34][2] * scale;
func_8017F424(&tri1, &tri2, sp30);
break;
case GD_ANIM_3H: // data = s16(*)[3] or MyVec3h[]...
vec3hArr = (s16(*)[3]) animData->data;
d_get_scale(&tri1.p0);
tri2.p0.x = tri1.p0.x;
tri2.p0.y = tri1.p0.y;
tri2.p0.z = tri1.p0.z;
d_get_init_rot(&tri1.p1);
tri2.p1.x = tri1.p1.x;
tri2.p1.y = tri1.p1.y;
tri2.p1.z = tri1.p1.z;
tri1.p2.x = (f32) vec3hArr[sp38][0];
tri1.p2.y = (f32) vec3hArr[sp38][1];
tri1.p2.z = (f32) vec3hArr[sp38][2];
tri2.p2.x = (f32) vec3hArr[sp34][0];
tri2.p2.y = (f32) vec3hArr[sp34][1];
tri2.p2.z = (f32) vec3hArr[sp34][2];
func_8017F424(&tri1, &tri2, sp30);
break;
case GD_ANIM_6H_SCALED: // data = s16(*)[6] or GdPlaneH[]...
planeHArr = (s16(*)[6]) animData->data;
d_get_scale(&tri1.p0);
tri2.p0.x = tri1.p0.x;
tri2.p0.y = tri1.p0.y;
tri2.p0.z = tri1.p0.z;
tri1.p1.x = (f32) planeHArr[sp38][0] * scale;
tri1.p1.y = (f32) planeHArr[sp38][1] * scale;
tri1.p1.z = (f32) planeHArr[sp38][2] * scale;
tri2.p1.x = (f32) planeHArr[sp34][0] * scale;
tri2.p1.y = (f32) planeHArr[sp34][1] * scale;
tri2.p1.z = (f32) planeHArr[sp34][2] * scale;
tri1.p2.x = (f32) planeHArr[sp38][3];
tri1.p2.y = (f32) planeHArr[sp38][4];
tri1.p2.z = (f32) planeHArr[sp38][5];
tri2.p2.x = (f32) planeHArr[sp34][3];
tri2.p2.y = (f32) planeHArr[sp34][4];
tri2.p2.z = (f32) planeHArr[sp34][5];
func_8017F424(&tri1, &tri2, sp30);
break;
case GD_ANIM_9H: // data = s16(*)[9] or GdTriangleFH[]...
triHArr = (s16(*)[9]) animData->data;
tri1.p0.x = (f32) triHArr[sp38][0] * scale;
tri1.p0.y = (f32) triHArr[sp38][1] * scale;
tri1.p0.z = (f32) triHArr[sp38][2] * scale;
tri1.p1.x = (f32) triHArr[sp38][3] * scale;
tri1.p1.y = (f32) triHArr[sp38][4] * scale;
tri1.p1.z = (f32) triHArr[sp38][5] * scale;
tri1.p2.x = (f32) triHArr[sp38][6];
tri1.p2.y = (f32) triHArr[sp38][7];
tri1.p2.z = (f32) triHArr[sp38][8];
tri2.p0.x = (f32) triHArr[sp34][0] * scale;
tri2.p0.y = (f32) triHArr[sp34][1] * scale;
tri2.p0.z = (f32) triHArr[sp34][2] * scale;
tri2.p1.x = (f32) triHArr[sp34][3] * scale;
tri2.p1.y = (f32) triHArr[sp34][4] * scale;
tri2.p1.z = (f32) triHArr[sp34][5] * scale;
tri2.p2.x = (f32) triHArr[sp34][6];
tri2.p2.y = (f32) triHArr[sp34][7];
tri2.p2.z = (f32) triHArr[sp34][8];
func_8017F424(&tri1, &tri2, sp30);
break;
case GD_ANIM_CAMERA: // s16(*)[6]?
if (linkedObj->type == OBJ_TYPE_CAMERAS) {
camPlaneHArr = animData->data;
tri1.p2.x = (f32) camPlaneHArr[sp38][0];
tri1.p2.y = (f32) camPlaneHArr[sp38][1];
tri1.p2.z = (f32) camPlaneHArr[sp38][2];
tri2.p2.x = (f32) camPlaneHArr[sp38][3];
tri2.p2.y = (f32) camPlaneHArr[sp38][4];
tri2.p2.z = (f32) camPlaneHArr[sp38][5];
((struct ObjCamera *) linkedObj)->unk14.x = tri1.p2.x;
((struct ObjCamera *) linkedObj)->unk14.y = tri1.p2.y;
((struct ObjCamera *) linkedObj)->unk14.z = tri1.p2.z;
((struct ObjCamera *) linkedObj)->unk34.x = tri2.p2.x;
((struct ObjCamera *) linkedObj)->unk34.y = tri2.p2.y;
((struct ObjCamera *) linkedObj)->unk34.z = tri2.p2.z;
}
break;
case GD_ANIM_TRI_F_2: // GdTriangleF[]
triPtr = (struct GdTriangleF *) animData->data;
func_8017F424(&triPtr[sp38], &triPtr[sp34], sp30);
break;
case GD_ANIM_MTX_VEC: // AnimMtxVec[]
sp28 = &((struct AnimMtxVec *) animData->data)[sp38];
d_set_idn_mtx(&sp28->matrix);
d_set_scale(sp28->vec.x, sp28->vec.y, sp28->vec.z);
break;
case GD_ANIM_TRI_F_4: // GdTriangleF*
triPtr = (struct GdTriangleF *) animData->data;
gd_set_identity_mat4(&localMtx);
gd_scale_mat4f_by_vec3f(&localMtx, &triPtr->p0);
gd_rot_mat_about_vec(&localMtx, &triPtr->p1);
gd_add_vec3f_to_mat4f_offset(&localMtx, &triPtr->p2);
d_set_idn_mtx(&localMtx);
break;
case GD_ANIM_STUB:
if (stubObj1 == NULL) {
stubObj1 = linkedObj;
} else {
if (stubObj2 == NULL) {
stubObj2 = linkedObj;
func_8017F404(animObj->unk28, stubObj1, stubObj2);
} else {
fatal_printf("Too many objects to morph");
}
}
break;
default:
fatal_printf("move_animator(): Unkown animation data type");
}
link = link->next;
}
}
/* @ 22EDF4 for 0x300; orig name: func_80180624 */
void drag_picked_object(struct GdObj *inputObj) {
UNUSED u32 spE4;
UNUSED u32 spE0;
UNUSED u32 spDC;
struct GdVec3f spD0;
struct GdVec3f spC4;
struct GdControl *ctrl;
Mat4f sp80;
Mat4f sp40;
UNUSED u32 pad34[3];
struct GdObj *obj;
UNUSED u32 pad2C;
f32 sp28;
ctrl = &gGdCtrl;
if (gViewUpdateCamera == NULL) {
return;
}
sp28 = gd_vec3f_magnitude(&gViewUpdateCamera->unk40);
sp28 /= 1000.0f;
spD0.x = ((f32)(ctrl->csrX - ctrl->csrXatApress)) * sp28;
spD0.y = ((f32) - (ctrl->csrY - ctrl->csrYatApress)) * sp28;
spD0.z = 0.0f;
gd_inverse_mat4f(&gViewUpdateCamera->unkE8, &sp40);
gd_mat4f_mult_vec3f(&spD0, &sp40);
obj = inputObj;
if ((inputObj->drawFlags & OBJ_PICKED) && gGdCtrl.btnApressed) {
gd_play_sfx(GD_SFX_PINCH_FACE);
// Note: this second sfx won't play, as it is "overwritten" by the first
if (ABS(ctrl->stickDeltaX) + ABS(ctrl->stickDeltaY) >= 11) {
gd_play_sfx(GD_SFX_PINCH_FACE_2);
}
switch (inputObj->type) {
case OBJ_TYPE_JOINTS:
((struct ObjJoint *) obj)->mat128[3][0] += spD0.x;
((struct ObjJoint *) obj)->mat128[3][1] += spD0.y;
((struct ObjJoint *) obj)->mat128[3][2] += spD0.z;
break;
case OBJ_TYPE_GADGETS:
break;
case OBJ_TYPE_NETS:
gd_inverse_mat4f(&((struct ObjNet *) obj)->mat128, &sp80);
spC4.x = spD0.x;
spC4.y = spD0.y;
spC4.z = spD0.z;
gd_mat4f_mult_vec3f(&spC4, &sp80);
((struct ObjNet *) obj)->matE8[3][0] += spD0.x;
((struct ObjNet *) obj)->matE8[3][1] += spD0.y;
((struct ObjNet *) obj)->matE8[3][2] += spD0.z;
break;
case OBJ_TYPE_PARTICLES:
break;
default:;
}
}
}
/* @ 22F0F4 for 0x50; orig name: func_80180924*/
void move_animators(struct ObjGroup *group) {
restart_timer("move_animators");
apply_to_obj_types_in_group(OBJ_TYPE_ANIMATORS, (applyproc_t) move_animator, group);
split_timer("move_animators");
}
/* @ 22F144 for 0x3C; orig name: func_80180974 */
void find_and_drag_picked_object(struct ObjGroup *group) {
apply_to_obj_types_in_group(OBJ_TYPE_ALL, (applyproc_t) drag_picked_object, group);
}
/* @ 22F180 for 0x624; orig name: func_801809B0 */
void move_camera(struct ObjCamera *cam) {
struct GdObj *spEC;
struct GdVec3f spE0;
struct GdVec3f spD4;
struct GdVec3f spC8;
UNUSED u8 padBC[0xC8 - 0xBC];
struct GdVec3f spB0;
Mat4f sp70;
UNUSED u8 pad30[0x70 - 0x30];
Mat4f *sp2C;
struct GdControl *ctrl; // 28
ctrl = &gGdCtrl;
if ((cam->unk2C & 0x10) == 0) {
return;
}
spE0.x = spE0.y = spE0.z = 0.0f;
spB0.x = spB0.y = spB0.z = 0.0f;
if ((spEC = cam->unk30) != NULL) {
set_cur_dynobj(spEC);
d_get_world_pos(&spE0);
d_get_matrix(&sp70);
spC8.x = sp70[2][0] - cam->unk58;
spC8.z = sp70[2][2] - cam->unk60;
cam->unk58 += spC8.x * cam->unk180.y;
cam->unk60 += spC8.z * cam->unk180.y;
cam->unkA8[2][0] = cam->unk58;
cam->unkA8[2][1] = 0.0f;
cam->unkA8[2][2] = cam->unk60;
cam->unkA8[0][0] = cam->unkA8[2][2];
cam->unkA8[0][1] = 0.0f;
cam->unkA8[0][2] = -cam->unkA8[2][0];
cam->unkA8[1][0] = 0.0f;
cam->unkA8[1][1] = 1.0f;
cam->unkA8[1][2] = 0.0f;
gd_set_identity_mat4(&cam->unkA8);
} else {
gd_set_identity_mat4(&cam->unkA8);
}
sp2C = &cam->unk64;
if ((cam->unk2C & 0x4) != 0) { // new B press
if (ctrl->btnB != FALSE && ctrl->prevFrame->btnB == FALSE) {
cam->zoom++;
if (cam->zoom > cam->zoomLevels) {
cam->zoom = 0;
}
switch (cam->zoom) {
case 0:
gd_play_sfx(GD_SFX_CAM_ZOOM_IN);
break;
case 1:
case 2:
gd_play_sfx(GD_SFX_CAM_ZOOM_OUT);
break;
}
}
if (ctrl->cleft) {
cam->unk128.y += cam->unk134.y;
}
if (ctrl->cright) {
cam->unk128.y -= cam->unk134.y;
}
if (ctrl->cup) {
cam->unk128.x += cam->unk134.x;
}
if (ctrl->cdown) {
cam->unk128.x -= cam->unk134.x;
}
cam->unk128.x = gd_clamp_f32(cam->unk128.x, 80.0f);
cam->unk4C.x = cam->positions[cam->zoom].x;
cam->unk4C.y = cam->positions[cam->zoom].y;
cam->unk4C.z = cam->positions[cam->zoom].z;
gd_rot_2d_vec(cam->unk128.x, &cam->unk4C.y, &cam->unk4C.z);
gd_rot_2d_vec(-cam->unk128.y, &cam->unk4C.x, &cam->unk4C.z);
cam->unk40.x += (cam->unk4C.x - cam->unk40.x) * cam->unk17C;
cam->unk40.y += (cam->unk4C.y - cam->unk40.y) * cam->unk17C;
cam->unk40.z += (cam->unk4C.z - cam->unk40.z) * cam->unk17C;
} else {
gd_set_identity_mat4(sp2C);
}
spD4.x = cam->unk40.x;
spD4.y = cam->unk40.y;
spD4.z = cam->unk40.z;
spD4.x += spB0.x;
spD4.y += spB0.y;
spD4.z += spB0.z;
gd_mult_mat4f(sp2C, &cam->unkA8, &cam->unkA8);
gd_mat4f_mult_vec3f(&spD4, &cam->unkA8);
cam->unk14.x = spD4.x;
cam->unk14.y = spD4.y;
cam->unk14.z = spD4.z;
cam->unk14.x += spE0.x;
cam->unk14.y += spE0.y;
cam->unk14.z += spE0.z;
}
/* @ 22F7A4 for 0x38; orig name: func_80180FD4 */
void move_cameras_in_grp(struct ObjGroup *group) {
apply_to_obj_types_in_group(OBJ_TYPE_CAMERAS, (applyproc_t) move_camera, group);
}
/* @ 22F7DC for 0x36C*/
void func_8018100C(struct ObjLight *light) {
Mat4f mtx;
UNUSED u32 pad1C[3];
if (light->unk40 == 3) {
if (light->unk30 > 0.0) { //? 0.0f
light->unk30 -= 0.2; //? 0.2f
}
if (light->unk30 < 0.0f) {
light->unk30 = 0.0f;
}
if ((light->unk3C & 0x1) != 0) {
light->unk30 = 1.0f;
}
light->unk3C &= ~1;
}
// if (1)?
return;
// unreachable
light->position.x += light->unk80.x;
light->position.y += light->unk80.y;
light->position.z += light->unk80.z;
// should be position.x for second comparison?
if (light->position.x > 500.0f || light->position.y < -500.0f) {
light->unk80.x = -light->unk80.x;
}
if (light->position.y > 500.0f || light->position.y < -500.0f) {
light->unk80.y = -light->unk80.y;
}
if (light->position.z > 500.0f || light->position.z < -500.0f) {
light->unk80.z = -light->unk80.z;
}
return;
// more unreachable
D_801A81C0 += 1.0; //? 1.0f
D_801A81C4 += 0.6; //? 0.6f
gd_set_identity_mat4(&mtx);
gd_absrot_mat4(&mtx, GD_Y_AXIS, light->unk68.y);
gd_absrot_mat4(&mtx, GD_X_AXIS, light->unk68.x);
gd_absrot_mat4(&mtx, GD_Z_AXIS, light->unk68.z);
gd_mat4f_mult_vec3f(&light->unk8C, &mtx);
light->position.x = light->unk8C.x;
light->position.y = light->unk8C.y;
light->position.z = light->unk8C.z;
return;
// even more unreachable
gd_mat4f_mult_vec3f(&light->unk80, &mtx);
imout(); // this call would cause an issue if it was reachable
}
/* @ 22FB48 for 0x38; orig name: func_80181378 */
void move_lights_in_grp(struct ObjGroup *group) {
apply_to_obj_types_in_group(OBJ_TYPE_LIGHTS, (applyproc_t) func_8018100C, group);
}
/* @ 22FB80 for 0xAC; orig name: func_801813B0 */
void move_group_members(void) {
s32 i;
if (gGdMoveScene != 0) {
reset_gadgets_in_grp(sCurrentMoveGrp);
move_lights_in_grp(sCurrentMoveGrp);
move_particles_in_grp(sCurrentMoveGrp);
move_animators(sCurrentMoveGrp);
for (i = 0; i <= 0; i++) {
move_nets(sCurrentMoveGrp);
}
move_cameras_in_grp(sCurrentMoveGrp);
}
}
/* @ 22FC2C for 0x98; orig name: func_8018145C */
void proc_view_movement(struct ObjView *view) {
add_to_stacktrace("movement");
sCurrentMoveCamera = view->activeCam;
sCurrentMoveView = view;
if ((sCurrentMoveGrp = view->components) != NULL) {
move_group_members();
}
if ((sCurrentMoveGrp = view->lights) != NULL) {
move_group_members();
}
imout();
}
/* @ 22FCC4 for 0x44; orig name: func_801814F4 */
void reset_nets_and_gadgets(struct ObjGroup *group) {
func_80193848(group);
apply_to_obj_types_in_group(OBJ_TYPE_GADGETS, (applyproc_t) reset_gadget, group);
}
/* @ 22FD08 for 0x9C; orig name: func_80181538*/
void null_obj_lists(void) {
D_801B9E44 = 0;
gGdObjCount = 0;
gGdGroupCount = 0;
gGdPlaneCount = 0;
gGdCameraCount = 0;
sGdViewInfo.count = 0;
gGdCameraList = NULL;
D_801B9E50 = NULL;
gGdBoneList = NULL;
gGdJointList = NULL;
gGdGroupList = NULL;
D_801B9E80 = NULL;
gGdObjectList = NULL;
gGdViewsGroup = NULL;
reset_net_count();
reset_joint_counts();
}
Reference in New Issue View Git Blame Copy Permalink