diff --git a/README.md b/README.md index c2fa94da..821de78e 100644 --- a/README.md +++ b/README.md @@ -5,9 +5,9 @@ This repo contains a work-in-progress decompilation of Diddy Kong Racing for the All versions are supported, and the US 1.0 version (SHA1 = 0cb115d8716dbbc2922fda38e533b9fe63bb9670) of the game is the default if not specified. -As of June 5, 2025, this is our current score: +As of June 8, 2025, this is our current score: -    Decomp progress: 89.17% +    Decomp progress: 89.54%     Documentation progress: 59.17% @@ -117,20 +117,20 @@ s32 is_drumstick_unlocked(void) { ``` -As of June 5, 2025, this is our current score: +As of June 8, 2025, this is our current score: ``` ==================================================================== ADVENTURE ONE (ASM -> C Decompilation) - -------------- 89.17% Complete (90.50% NON_MATCHING) --------------- - # Decompiled functions: 1907 - # GLOBAL_ASM remaining: 44 + -------------- 89.54% Complete (90.88% NON_MATCHING) --------------- + # Decompiled functions: 1909 + # GLOBAL_ASM remaining: 42 # NON_MATCHING functions: 6 - # NON_EQUIVALENT WIP functions: 23 + # NON_EQUIVALENT WIP functions: 21 --------------------------- Game Status ---------------------------- - Balloons: 41/47, Keys: 4/4, Trophies: 4/5 + Balloons: 42/47, Keys: 4/4, Trophies: 4/5 T.T. Amulets: 4/4, Wizpig Amulets: 4/4 -------------------------------------------------------------------- - We are racing in Spaceport Alpha. (Lap 3/3) + We are racing in Star City. (Lap 1/3) ==================================================================== ADVENTURE TWO (Cleanup & Documentation) ------------------------- 59.17% Complete -------------------------- diff --git a/src/object_models.c b/src/object_models.c index 2431f3c2..11e118c5 100644 --- a/src/object_models.c +++ b/src/object_models.c @@ -671,342 +671,198 @@ s32 func_80060C58(Vertex *vertices, s32 i1, s32 i2, s32 i3, s32 i4) { #undef NEARBY } -#ifdef NON_EQUIVALENT -s32 func_80060EA8(ObjectModel *arg0) { - Triangle *spB0; - f32 *spAC; - Vec3s *spA0; - s16 sp98; - TriangleBatchInfo *sp50; - f32 *sp58; - f32 sp5C; - f32 sp60; - f32 *sp64; - f32 sp68; - f32 sp6C; - f32 *sp70; - f32 sp74; - f32 sp78; - s16 *temp_v0_2; - f32 *temp_v0_3; - s16 *temp_v0_5; - Vec3f *temp_v0_6; - TriangleBatchInfo *temp_a3; - TriangleBatchInfo *temp_a3_2; - TriangleBatchInfo *temp_ra; - TriangleBatchInfo *temp_t0; - TriangleBatchInfo *temp_t8_2; - TriangleBatchInfo *temp_v0; - TriangleBatchInfo *temp_v0_4; - TriangleBatchInfo *var_ra; - Vertex *temp_s3; - Vertex *temp_v1_2; - Vertex *temp_v1_3; - Vertex *temp_v1_4; - Vertex *temp_v1_5; - Vertex *temp_v1_6; - f32 *temp_t7; - f32 *temp_t8; - f32 temp_f0; - f32 temp_f0_2; - f32 temp_f0_3; - f32 temp_f0_4; - f32 temp_f14; - f32 temp_f14_2; - f32 temp_f2; - f32 temp_f2_2; - f32 temp_f2_3; - s16 temp_a2; - s16 temp_a2_2; - s16 temp_s4; - s16 temp_t7_2; - s16 temp_t8_3; - s16 temp_v1; - s16 var_a0; - s16 var_a0_2; - s16 var_a0_3; - s16 var_a1; - s16 var_a1_2; - s16 var_a2; - s16 var_a2_2; - s16 var_a3; - s16 var_a3_2; - s16 var_a3_3; - s16 var_a3_4; - s16 var_a3_5; - s16 var_s1_2; - s16 batchNum; - s16 var_s5; - s16 var_s5_2; - s16 var_s6; - s16 var_t3; - s16 var_v1; - s16 var_v1_2; - s16 var_v1_3; - s32 temp_a3_3; - s32 temp_lo; - s32 temp_s1; - s32 temp_s1_2; - s16 var_s1; - s32 var_s1_4; - s32 var_t7; - s32 var_t8; - s32 var_t8_2; - s32 var_t9; - s32 var_t9_2; - u8 *temp_a0; - u8 *var_t6; - u8 temp_t4; - f32 *temp_s0; - f32 *temp_s0_2; - f32 *temp_s0_3; - f32 *temp_v0_7; - f32 *temp_v1_7; - f32 *temp_v1_8; - s16 *temp_v1_9; +s32 func_80060EA8(ObjectModel *model) { + Vertex *vertices; // s3 + Triangle *triangles; // spB0 + Vec3f *spAC; // spAC + s16 i; // s1 + TriangleBatchInfo *batches; // spA4 + Vec3s *spA0; // spA0 + s16 s6; + s16 l; + s16 q; + s16 k; // sp98; + s16 a2; + s16 j; // s5 + s16 a0; + s16 vertOffset; + f32 length; + Vec3f *v06; + s16 *v0; + s16 vx, vy, vz; - temp_v1 = arg0->numberOfBatches; - temp_ra = arg0->batches; - arg0->unk40 = NULL; + batches = model->batches; + model->unk40 = NULL; - var_a3 = 0; - for (var_s1 = 0; var_s1 < temp_v1; var_s1++) { - if (temp_ra[var_s1].miscData != BATCH_VTX_COL || (temp_ra[var_s1].flags & RENDER_ENVMAP)) { - var_a3 = (var_a3 + (temp_ra[var_s1 + 1]).verticesOffset) - temp_ra[var_s1].verticesOffset; + k = 0; + for (i = 0; i < model->numberOfBatches; i++) { + if (batches[i].miscData != BATCH_VTX_COL || (batches[i].flags & RENDER_ENVMAP)) { + k += batches[i + 1].verticesOffset - batches[i].verticesOffset; } } - if (var_a3 > 0) { - temp_s3 = arg0->vertices; - spB0 = arg0->triangles; - sp98 = var_a3; - temp_v0_2 = mempool_alloc(arg0->numberOfTriangles * 0xC, COLOUR_TAG_ORANGE); - spAC = temp_v0_2; - if (temp_v0_2 == NULL) { + + if (k > 0) { + vertices = model->vertices; + triangles = model->triangles; + + spAC = (Vec3f *) mempool_alloc(model->numberOfTriangles * sizeof(Vec3f), COLOUR_TAG_ORANGE); + if (spAC == NULL) { return 1; } - temp_v0_3 = mempool_alloc(var_a3 * 6, COLOUR_TAG_ORANGE); - var_ra = temp_ra; - spA0 = temp_v0_3; - if (temp_v0_3 == NULL) { + + spA0 = (Vec3s *) mempool_alloc(k * sizeof(Vec3s), COLOUR_TAG_ORANGE); + if (spA0 == NULL) { mempool_free(spAC); return 1; } - var_v1 = arg0->numberOfBatches; - for (var_s1_2 = 0; var_s1_2 < var_v1; var_s1_2++) { - temp_v0_4 = &var_ra[var_s1_2]; - temp_s4 = temp_v0_4->verticesOffset; - for (var_s5 = temp_v0_4->facesOffset; var_s5 < (temp_v0_4 + 1)->facesOffset; var_s5 += 1) { - for (var_a3_2 = 0; var_a3_2 < 3; var_a3_2++) { - temp_v1_2 = &temp_s3[(s16) (spB0[var_s5].verticesArray[var_a3_2 + 1] + temp_s4)]; - temp_t7 = &(&sp64[0])[var_a3_2]; - temp_t8 = &(&sp58[0])[var_a3_2]; - (&sp70[0])[var_a3_2] = (f32) temp_v1_2->x; - *temp_t7 = (f32) temp_v1_2->y; - *temp_t8 = (f32) temp_v1_2->z; + for (i = 0; i < model->numberOfBatches; i++) { + vertOffset = batches[i].verticesOffset; + for (j = batches[i].facesOffset; j < batches[i + 1].facesOffset; j++) { + f32 sp70[3]; + f32 sp64[3]; + f32 sp58[3]; + for (k = 0; k < 3; k++) { + a2 = triangles[j].verticesArray[k + 1] + vertOffset; + sp70[k] = vertices[a2].x; + sp64[k] = vertices[a2].y; + sp58[k] = vertices[a2].z; } - temp_s0 = spAC + (var_s5 * 0xC); - temp_s0[0] = (f32) (((sp58[0] - sp60) * (sp64[0] - sp68)) - ((sp58[0] - sp5C) * (sp64[0] - sp6C))); - temp_s0[1] = (f32) (((sp58[0] - sp5C) * (sp70[0] - sp78)) - ((sp58[0] - sp60) * (sp70[0] - sp74))); - temp_s0[2] = (f32) (((sp70[0] - sp74) * (sp64[0] - sp6C)) - ((sp64[0] - sp68) * (sp70[0] - sp78))); - temp_f0_2 = sqrtf((temp_s0[2] * temp_s0[2]) + ((temp_s0[0] * temp_s0[0]) + (temp_s0[1] * temp_s0[1]))); - if (temp_f0_2 != 0.0f) { - temp_s0[0] = (f32) (temp_s0[0] / temp_f0_2); - temp_s0[1] = (f32) (temp_s0[1] / temp_f0_2); - temp_s0[2] = (f32) (temp_s0[2] / temp_f0_2); + + spAC[j].x = (sp58[0] - sp58[2]) * (sp64[0] - sp64[1]) - (sp64[0] - sp64[2]) * (sp58[0] - sp58[1]); + spAC[j].y = (sp58[0] - sp58[1]) * (sp70[0] - sp70[2]) - (sp70[0] - sp70[1]) * (sp58[0] - sp58[2]); + spAC[j].z = (sp70[0] - sp70[1]) * (sp64[0] - sp64[2]) - (sp70[0] - sp70[2]) * (sp64[0] - sp64[1]); + length = sqrtf(spAC[j].x * spAC[j].x + spAC[j].y * spAC[j].y + spAC[j].z * spAC[j].z); + if (length != 0.0f) { + spAC[j].x /= length; + spAC[j].y /= length; + spAC[j].z /= length; } } } - temp_v0_5 = mempool_alloc(arg0->numberOfVertices * 2, COLOUR_TAG_ORANGE); - if (temp_v0_5 == NULL) { + + v0 = (s16 *) mempool_alloc(model->numberOfVertices * sizeof(s16), COLOUR_TAG_ORANGE); + if (v0 == NULL) { mempool_free(spAC); mempool_free(spA0); return 1; } - var_s6 = 0; - for (batchNum = 0; batchNum < arg0->numberOfBatches; batchNum++) { - temp_t8_2 = &var_ra[batchNum]; - sp50 = temp_t8_2; - var_t3 = temp_t8_2->verticesOffset; - if (var_t3 < (temp_t8_2 + 1)->verticesOffset) { - do { - if (sp50->miscData < 0xFE) { - var_a2 = -1; - var_a1 = 0; - temp_v1_3 = &temp_s3[var_t3]; - if (batchNum >= 0) { - loop_30: - temp_a3 = &var_ra[var_a1]; - if ((sp50->miscData == temp_a3->miscData) && - (((var_a0 = temp_a3->verticesOffset, (var_a1 == batchNum)) && (var_a0 < var_t3)) || - ((var_a1 != batchNum) && (var_a0 < (temp_a3 + 1)->verticesOffset))) && - (var_a2 < 0)) { - loop_36: - temp_v1_4 = &temp_s3[var_a0]; - if ((temp_v1_3->x == temp_v1_4->x) && (temp_v1_3->y == temp_v1_4->y) && - (temp_v1_3->z == temp_v1_4->z)) { - var_a2 = *(temp_v0_5 + (var_a0 * 2)); + + s6 = 0; + + for (i = 0; i < model->numberOfBatches; i++) { + for (l = batches[i].verticesOffset; l < batches[i + 1].verticesOffset; l++) { + if (batches[i].miscData < 0xFE) { + a2 = -1; + vx = vertices[l].x; + vy = vertices[l].y; + vz = vertices[l].z; + + for (q = 0; q <= i && a2 < 0; q++) { + if (batches[i].miscData == batches[q].miscData) { + a0 = batches[q].verticesOffset; + while (((q == i && a0 < l) || (q != i && a0 < batches[q + 1].verticesOffset)) && a2 < 0) { + if (vx == vertices[a0].x && vy == vertices[a0].y && vz == vertices[a0].z) { + a2 = v0[a0]; } - temp_t8_3 = var_a0 + 1; - var_a0 = temp_t8_3; - if ((((var_a1 == batchNum) && (temp_t8_3 < var_t3)) || - ((var_a1 != batchNum) && (var_a0 < (temp_a3 + 1)->verticesOffset))) && - (var_a2 < 0)) { - goto loop_36; - } - } - var_a1 += 1; - if ((batchNum >= var_a1) && (var_a2 < 0)) { - goto loop_30; + a0++; } } - if (var_a2 < 0) { - *(temp_v0_5 + (var_t3 * 2)) = var_s6; - var_s6 += 1; - } else { - *(temp_v0_5 + (var_t3 * 2)) = var_a2; - } - } else if (sp50->miscData == 0xFE) { - *(temp_v0_5 + (var_t3 * 2)) = var_s6; - var_s6 += 1; - } else if (sp50->flags & RENDER_ENVMAP) { - var_a2_2 = -1; - var_a1_2 = 0; - temp_v1_5 = &temp_s3[var_t3]; - if (batchNum >= 0) { - loop_54: - temp_a3_2 = &var_ra[var_a1_2]; - if ((temp_a3_2->flags & RENDER_ENVMAP) && - (((var_a0_2 = temp_a3_2->verticesOffset, (var_a1_2 == batchNum)) && - (var_a0_2 < var_t3)) || - ((var_a1_2 != batchNum) && (var_a0_2 < (temp_a3_2 + 1)->facesOffset))) && - (var_a2_2 < 0)) { - loop_60: - temp_v1_6 = &temp_s3[var_a0_2]; - if ((temp_v1_5->x == temp_v1_6->x) && (temp_v1_5->y == temp_v1_6->y) && - (temp_v1_5->z == temp_v1_6->z)) { - var_a2_2 = *(temp_v0_5 + (var_a0_2 * 2)); - } - var_a0_2++; - if ((((var_a1_2 == batchNum) && (var_a0_2 < var_t3)) || - ((var_a1_2 != batchNum) && (var_a0_2 < (temp_a3_2 + 1)->facesOffset))) && - (var_a2_2 < 0)) { - goto loop_60; - } - } - var_a1_2 += 1; - if ((batchNum >= var_a1_2) && (var_a2_2 < 0)) { - goto loop_54; - } - } - if (var_a2_2 < 0) { - *(temp_v0_5 + (var_t3 * 2)) = var_s6; - var_s6 += 1; - } else { - *(temp_v0_5 + (var_t3 * 2)) = var_a2_2; - } - } else { - *(temp_v0_5 + (var_t3 * 2)) = -1; } - var_t3 += 1; - } while (var_t3 < (sp50 + 1)->verticesOffset); - } - } - temp_v0_6 = mempool_alloc(var_s6 * 0xC, COLOUR_TAG_ORANGE); - if (temp_v0_6 == NULL) { - mempool_free(spAC); - mempool_free(spA0); - mempool_free(temp_v0_5); - return 1; - } - var_a3_3 = 0; - var_s1_4 = 0; - while (var_a3_3 < var_s6) { - temp_lo = var_a3_3 * 0xC; - var_a3_3 += 1; - temp_v1_7 = temp_v0_6 + temp_lo; - temp_v1_7[0] = 0.0f; - temp_v1_7[1] = 0.0f; - temp_v1_7[2] = 0.0f; - } - var_v1_3 = arg0->numberOfBatches; - while (var_s1_4 < var_v1_3) { - temp_s1_2 = var_s1_4 + 1; - temp_t0 = &var_ra[var_s1_4]; - if ((temp_t0->miscData != BATCH_VTX_COL) || - (var_t8_2 = temp_s1_2 << 0x10, ((temp_t0->flags & RENDER_ENVMAP) != 0))) { - var_s5_2 = temp_t0->facesOffset; - var_t8_2 = temp_s1_2 << 0x10; - if (var_s5_2 < (temp_t0 + 1)->facesOffset) { - var_t7 = var_s5_2 * 0x10; - do { - temp_a0 = &spB0->verticesArray[var_t7]; - var_a3_4 = 0; - var_t6 = temp_a0; - loop_89: - temp_a2 = *(temp_v0_5 + ((s16) (var_t6[1] + temp_t0->verticesOffset) * 2)); - var_a3_4 += 1; - if (temp_a2 >= 0) { - temp_v1_8 = temp_v0_6 + (temp_a2 * 0xC); - temp_s0_2 = spAC + (var_s5_2 * 0xC); - temp_v1_8[0] += temp_s0_2[0]; - temp_v1_8[1] += temp_s0_2[1]; - temp_v1_8[2] += temp_s0_2[2]; + if (a2 < 0) { + v0[l] = s6++; + } else { + v0[l] = a2; + } + } else if (batches[i].miscData == 0xFE) { + v0[l] = s6++; + } else if (batches[i].flags & RENDER_ENVMAP) { + a2 = -1; + vx = vertices[l].x; + vy = vertices[l].y; + vz = vertices[l].z; + for (q = 0; q <= i && a2 < 0; q++) { + if (batches[q].flags & RENDER_ENVMAP) { + a0 = batches[q].verticesOffset; + while (((q == i && a0 < l) || (q != i && a0 < batches[q + 1].verticesOffset)) && a2 < 0) { + if (vx == vertices[a0].x && vy == vertices[a0].y && vz == vertices[a0].z) { + a2 = v0[a0]; + } + a0++; + } } - var_t6 = &temp_a0[var_a3_4]; - if (var_a3_4 < 3) { - goto loop_89; - } - var_s5_2 += 1; - var_t7 = var_s5_2 * 0x10; - } while (var_s5_2 < (temp_t0 + 1)->verticesOffset); - var_v1_3 = arg0->numberOfBatches; - var_t8_2 = temp_s1_2 << 0x10; + } + + if (a2 < 0) { + v0[l] = s6++; + } else { + v0[l] = a2; + } + } else { + v0[l] = -1; } } - var_s1_4 = var_t8_2 >> 0x10; } - for (var_a3_5 = 0; var_a3_5 < var_s6; var_a3_5++) { - temp_s0_3 = temp_v0_6 + (var_a3_5 * 0xC); - temp_f2_2 = temp_s0_3[0]; - temp_f14_2 = temp_s0_3[1]; - temp_f0_3 = temp_s0_3[2]; - sp98 = var_a3_5; - temp_f0_4 = sqrtf((temp_f0_3 * temp_f0_3) + ((temp_f2_2 * temp_f2_2) + (temp_f14_2 * temp_f14_2))); - if (temp_f0_4 != 0.0f) { - temp_f0_4 *= 0.00012207031f; - temp_s0_3[0] /= temp_f0_4; - temp_s0_3[1] /= temp_f0_4; - temp_s0_3[2] /= temp_f0_4; + + v06 = (Vec3f *) mempool_alloc(s6 * sizeof(Vec3f), COLOUR_TAG_ORANGE); + if (v06 == NULL) { + mempool_free(spAC); + mempool_free(spA0); + mempool_free(v0); + return 1; + } + + for (k = 0; k < s6; k++) { + v06[k].x = 0.0f; + v06[k].y = 0.0f; + v06[k].z = 0.0f; + } + + for (i = 0; i < model->numberOfBatches; i++) { + if (batches[i].miscData != BATCH_VTX_COL || (batches[i].flags & RENDER_ENVMAP)) { + vertOffset = batches[i].verticesOffset; + for (j = batches[i].facesOffset; j < batches[i + 1].facesOffset; j++) { + for (k = 0; k < 3; k++) { + a2 = triangles[j].verticesArray[k + 1] + vertOffset; + a2 = v0[a2]; + + if (a2 >= 0) { + v06[a2].x += spAC[j].x; + v06[a2].y += spAC[j].y; + v06[a2].z += spAC[j].z; + } + } + } } } - var_a3_5 = 0; - var_a0_3 = 0; - var_t9 = 0 * 2; - while (var_a3_5 < arg0->numberOfVertices) { - temp_a2_2 = temp_v0_5[var_t9]; - temp_a3_3 = var_a3_5 + 1; - var_t9_2 = temp_a3_3 << 0x10; - if (temp_a2_2 >= 0) { - spA0[var_a0_3].x = temp_v0_6[temp_a2_2].x; - spA0[var_a0_3].y = temp_v0_6[temp_a2_2].y; - spA0[var_a0_3].z = temp_v0_6[temp_a2_2].z; - var_t9_2 = temp_a3_3 << 0x10; - var_a0_3++; + + for (k = 0; k < s6; k++) { + length = sqrtf(v06[k].x * v06[k].x + v06[k].y * v06[k].y + v06[k].z * v06[k].z); + if (length != 0.0f) { + v06[k].x /= length * (1.0f / 0x2000); + v06[k].y /= length * (1.0f / 0x2000); + v06[k].z /= length * (1.0f / 0x2000); } - var_a3_5 = (s16) (var_t9_2 >> 0x10); - var_t9 = var_a3_5 * 2; } - arg0->unk40 = (Vec3s *) spA0; - mempool_free(temp_v0_5); - mempool_free(temp_v0_6); + + a0 = 0; + for (k = 0; k < model->numberOfVertices; k++) { + a2 = v0[k]; + if (a2 >= 0) { + spA0[a0].x = v06[a2].x; + spA0[a0].y = v06[a2].y; + spA0[a0].z = v06[a2].z; + a0++; + } + } + + model->unk40 = spA0; + mempool_free(v0); + mempool_free(v06); mempool_free(spAC); } return 0; } -#else -#pragma GLOBAL_ASM("asm/nonmatchings/object_models/func_80060EA8.s") -#endif void func_800619F4(s32 arg0) { D_8011D640 = arg0; diff --git a/src/objects.c b/src/objects.c index 56c5d9ec..1b8e4e8d 100644 --- a/src/objects.c +++ b/src/objects.c @@ -2460,7 +2460,7 @@ void func_800101AC(Object *obj, s32 arg1) { } } else { for (j = 0; j < numberOfModelIds; j++) { - sprite_free(&tempObj->unk68[j]->sprite); + sprite_free(tempObj->unk68[j]->sprite); } } try_free_object_header(tempObj->segment.object.unk2C); @@ -2509,7 +2509,7 @@ void func_800101AC(Object *obj, s32 arg1) { // TODO: Get a Snowball struct? snowball = &obj->unk64->racer; if (snowball->unk20 != NULL) { - audspat_point_stop(snowball->unk20); + audspat_point_stop((AudioPoint *) snowball->unk20); } break; case BHV_WAVE_GENERATOR: @@ -2520,7 +2520,7 @@ void func_800101AC(Object *obj, s32 arg1) { break; case BHV_ANIMATION: if (obj->unk64 != NULL && arg1 == 0) { - free_object(&obj->unk64->obj); + free_object(obj->unk64->obj); } break; case BHV_OVERRIDE_POS: @@ -2610,7 +2610,7 @@ void func_800101AC(Object *obj, s32 arg1) { } if (gObjPtrList[i]->behaviorId == BHV_WEAPON_2 || gObjPtrList[i]->behaviorId == BHV_FLY_COIN || gObjPtrList[i]->behaviorId == BHV_WEAPON) { - free_object(gObjPtrList[i]); + free_object((Object *) gObjPtrList[i]); } } } @@ -2629,11 +2629,11 @@ void func_800101AC(Object *obj, s32 arg1) { } } else if (obj->segment.header->modelType == OBJECT_MODEL_TYPE_MISC) { for (i = 0; i < numberOfModelIds; i++) { - tex_free(&obj->unk68[i]->texHeader); + tex_free(obj->unk68[i]->texHeader); } } else { for (i = 0; i < numberOfModelIds; i++) { - sprite_free(&obj->unk68[i]->sprite); + sprite_free(obj->unk68[i]->sprite); } } if (obj->segment.header->particleCount > 0) { diff --git a/src/tracks.c b/src/tracks.c index c3d25027..1eab87cb 100644 --- a/src/tracks.c +++ b/src/tracks.c @@ -3775,11 +3775,11 @@ void func_8002E904(LevelModelSegment *arg0, s32 arg1, s32 arg2) { if (gNewShadowY2 >= minY) { if (maxY >= gNewShadowY1) { for (i = 0; i < 3; i++) { - sp100[i].unk0 = vertices[triangles->verticesArray[i + 1]].x; - sp100[i].unk8 = vertices[triangles->verticesArray[i + 1]].z; - sp100[i].unkE = -1; + sp100[i].x = vertices[triangles->verticesArray[i + 1]].x; + sp100[i].z = vertices[triangles->verticesArray[i + 1]].z; + sp100[i].unkC_union.s.unkE = -1; } - // @note while the cast to Vec4f is incorrect, func_8002FD74 only uses unk0 and unk8 which + // @note while the cast to Vec4f is incorrect, func_8002FD74 x uses unk0 and z which // are both floats so this is fine as the size is the same if (func_8002FD74(spD0[2].x, spD0[2].y, spD0[0].x, spD0[0].y, 3, (Vec4f *) sp100) != 0) { temp_t6 = arg0->unk14[curFacesOffset].triangleIndex * 4; @@ -3792,26 +3792,26 @@ void func_8002E904(LevelModelSegment *arg0, s32 arg1, s32 arg2) { if (someCount >= 3) { D_8011C238[D_8011C230].unk1 = 0; for (i2 = 0; i2 < someCount; i2++) { - if (sp100[i2].unkE < 0) { + if (sp100[i2].unkC_union.s.unkE < 0) { foundIndex = -1; i = 0; while ((i < D_8011B118) && (foundIndex == -1)) { - if ((D_8011B120[i].x == sp100[i2].unk0) && - (D_8011B120[i].z == sp100[i2].unk8)) { + if ((D_8011B120[i].x == sp100[i2].x) && + (D_8011B120[i].z == sp100[i2].z)) { foundIndex = i; } i++; } if (foundIndex == -1) { - D_8011B120[D_8011B118].x = sp100[i2].unk0; + D_8011B120[D_8011B118].x = sp100[i2].x; D_8011B120[D_8011B118].unkC = D_8011D0BC; - D_8011B120[D_8011B118].z = sp100[i2].unk8; + D_8011B120[D_8011B118].z = sp100[i2].z; D_8011C238[D_8011C230].unk2[i2] = D_8011B118++; } else { D_8011C238[D_8011C230].unk2[i2] = foundIndex; } } else { - D_8011C238[D_8011C230].unk2[i2] = sp100[i2].unkE; + D_8011C238[D_8011C230].unk2[i2] = sp100[i2].unkC_union.s.unkE; D_8011C238[D_8011C230].unk1 |= 1 << i2; } } @@ -3833,6 +3833,7 @@ void func_8002E904(LevelModelSegment *arg0, s32 arg1, s32 arg2) { } } +// Handles water shadow generation? void func_8002EEEC(s32 arg0) { unk8011C8B8 spA8[8]; Vec2f sp88[4]; @@ -3863,29 +3864,29 @@ void func_8002EEEC(s32 arg0) { // clang-format on for (var_s4 = 0; var_s4 < temp_v0; var_s4++) { - var_a0 = D_8011C3B8[var_s4].unk2; - var_a1 = D_8011C3B8[var_s4].unk2; - if (D_8011C3B8[var_s4].unk8 < var_a1) { - var_a0 = D_8011C3B8[var_s4].unk8; - } else if (var_a1 < D_8011C3B8[var_s4].unk8) { - var_a1 = D_8011C3B8[var_s4].unk8; + var_a0 = D_8011C3B8[var_s4].y1; + var_a1 = D_8011C3B8[var_s4].y1; + if (D_8011C3B8[var_s4].y2 < var_a0) { + var_a0 = D_8011C3B8[var_s4].y2; + } else if (var_a1 < D_8011C3B8[var_s4].y2) { + var_a1 = D_8011C3B8[var_s4].y2; } - if (D_8011C3B8[var_s4].unkE < var_a0) { - var_a0 = D_8011C3B8[var_s4].unkE; - } else if (var_a1 < D_8011C3B8[var_s4].unkE) { - var_a1 = D_8011C3B8[var_s4].unkE; + if (D_8011C3B8[var_s4].y3 < var_a0) { + var_a0 = D_8011C3B8[var_s4].y3; + } else if (var_a1 < D_8011C3B8[var_s4].y3) { + var_a1 = D_8011C3B8[var_s4].y3; } if (gNewShadowY2 >= var_a0) { if (var_a1 >= gNewShadowY1) { - spA8[0].unk0 = D_8011C3B8[var_s4].unk0; - spA8[0].unk8 = D_8011C3B8[var_s4].unk4; - spA8[1].unk0 = D_8011C3B8[var_s4].unk6; - spA8[1].unk8 = D_8011C3B8[var_s4].unkA; - spA8[2].unk0 = D_8011C3B8[var_s4].unkC; - spA8[2].unk8 = D_8011C3B8[var_s4].unk10; + spA8[0].x = D_8011C3B8[var_s4].x1; + spA8[0].z = D_8011C3B8[var_s4].z1; + spA8[1].x = D_8011C3B8[var_s4].x2; + spA8[1].z = D_8011C3B8[var_s4].z2; + spA8[2].x = D_8011C3B8[var_s4].x3; + spA8[2].z = D_8011C3B8[var_s4].z3; for (var_v0 = 0; var_v0 != 3; var_v0++) { - spA8[var_v0].unkE = -1; + spA8[var_v0].unkC_union.s.unkE = -1; } D_8011D0BC = &D_8011C8B8[D_8011D0B8 + var_s4]; @@ -3894,26 +3895,26 @@ void func_8002EEEC(s32 arg0) { tempIdx = D_8011C230; D_8011C238[tempIdx].unk1 = 0; for (var_t1 = 0; var_t1 < temp_v0_3; var_t1++) { - if (spA8[var_t1].unkE < 0) { + if (spA8[var_t1].unkC_union.s.unkE < 0) { var_a1 = -1; var_v1 = 0; while (var_v1 < D_8011B118 && var_a1 == -1) { - if ((D_8011B120[var_v1].x == spA8[var_t1].unk0) && - (D_8011B120[var_v1].z == spA8[var_t1].unk8)) { + if ((D_8011B120[var_v1].x == spA8[var_t1].x) && + (D_8011B120[var_v1].z == spA8[var_t1].z)) { var_a1 = var_v1; } var_v1++; } if (var_a1 == -1) { - D_8011B120[D_8011B118].x = spA8[var_t1].unk0; + D_8011B120[D_8011B118].x = spA8[var_t1].x; D_8011B120[D_8011B118].unkC = D_8011D0BC; - D_8011B120[D_8011B118].z = spA8[var_t1].unk8; + D_8011B120[D_8011B118].z = spA8[var_t1].z; D_8011C238[tempIdx].unk2[var_t1] = D_8011B118++; } else { D_8011C238[tempIdx].unk2[var_t1] = var_a1; } } else { - D_8011C238[tempIdx].unk2[var_t1] = spA8[var_t1].unkE; + D_8011C238[tempIdx].unk2[var_t1] = spA8[var_t1].unkC_union.s.unkE; D_8011C238[tempIdx].unk1 |= 1 << var_t1; } } @@ -3927,32 +3928,29 @@ void func_8002EEEC(s32 arg0) { D_8011D0B8 += temp_v0; } -#ifdef NON_EQUIVALENT void func_8002F2AC(void) { f32 temp_f12; f32 temp_f16; unk8011C8B8 *var_v0; - s32 i, j; + s32 i, j, k; + unk8011B330 *curr; for (i = 0; i < D_8011B118; i++) { var_v0 = D_8011B120[i].unkC; - temp_f16 = D_8011B120[i].x * var_v0->unk0; - temp_f12 = D_8011B120[i].z * var_v0->unk8; - D_8011B120[i].y = (f32) (-(temp_f16 + temp_f12 + var_v0->unkC) / var_v0->unk4); + temp_f16 = D_8011B120[i].x * var_v0->x; + temp_f12 = D_8011B120[i].z * var_v0->z; + D_8011B120[i].y = (f32) (-(temp_f16 + temp_f12 + var_v0->unkC_union.w) / var_v0->y); } for (i = 0; i < ARRAY_COUNT(D_8011B320); i++) { - for (j = 0; j < D_8011B320[i]; j++) { - var_v0 = D_8011B330[j + i].unkC; - temp_f16 = D_8011B330[j + i].x * var_v0->unk0; - temp_f12 = D_8011B330[j + i].z * var_v0->unk8; - D_8011B330[j + i].y = (f32) (-(temp_f16 + temp_f12 + var_v0->unkC) / var_v0->unk4); + for (j = 0, k = i * sizeof(unk8011B330); j < D_8011B320[i]; j++, k++) { + var_v0 = D_8011B330[k].unkC; + temp_f16 = D_8011B330[k].x * var_v0->x; + temp_f12 = D_8011B330[k].z * var_v0->z; + D_8011B330[k].y = (f32) (-(temp_f16 + temp_f12 + var_v0->unkC_union.w) / var_v0->y); } } } -#else -#pragma GLOBAL_ASM("asm/nonmatchings/tracks/func_8002F2AC.s") -#endif void func_8002F440(void) { s32 spAC; @@ -4185,58 +4183,56 @@ s32 func_8002FF6C(s32 arg0, unk8011C8B8 *arg1, s32 arg2, Vec2f *arg3) { if (var_v1 >= var_s2) { var_v1 = 0; } - temp_f16 = (temp_f12 * var_s3[var_t1].unk0) + (var_s3[var_t1].unk8 * temp_f14) + var_f2; - temp_f22 = (temp_f12 * var_s3[var_v1].unk0) + (var_s3[var_v1].unk8 * temp_f14) + var_f2; + temp_f16 = (temp_f12 * var_s3[var_t1].x) + (var_s3[var_t1].z * temp_f14) + var_f2; + temp_f22 = (temp_f12 * var_s3[var_v1].x) + (var_s3[var_v1].z * temp_f14) + var_f2; if ((temp_f16 >= 0.0f && temp_f22 < 0.0f) || (temp_f16 < 0.0f && temp_f22 >= 0.0f)) { var_a0 = D_8011B320[var_v0]; var_a1 = -1; var_v1_3 = var_v0 << 5; while (var_a0 > 0 && var_a1 < 0) { - if ((D_8011B330[var_v1_3].unk10 == var_s3[var_t1].unk0) && - (D_8011B330[var_v1_3].unk14 == var_s3[var_t1].unk8) && - (D_8011B330[var_v1_3].unk18 == var_s3[var_v1].unk0) && - (D_8011B330[var_v1_3].unk1C == var_s3[var_v1].unk8)) { + if ((D_8011B330[var_v1_3].unk10 == var_s3[var_t1].x) && + (D_8011B330[var_v1_3].unk14 == var_s3[var_t1].z) && + (D_8011B330[var_v1_3].unk18 == var_s3[var_v1].x) && + (D_8011B330[var_v1_3].unk1C == var_s3[var_v1].z)) { var_a1 = var_v1_3; - } else if ((D_8011B330[var_v1_3].unk10 == var_s3[var_v1].unk0) && - (D_8011B330[var_v1_3].unk14 == var_s3[var_v1].unk8) && - (D_8011B330[var_v1_3].unk18 == var_s3[var_t1].unk0) && - (D_8011B330[var_v1_3].unk1C == var_s3[var_t1].unk8)) { + } else if ((D_8011B330[var_v1_3].unk10 == var_s3[var_v1].x) && + (D_8011B330[var_v1_3].unk14 == var_s3[var_v1].z) && + (D_8011B330[var_v1_3].unk18 == var_s3[var_t1].x) && + (D_8011B330[var_v1_3].unk1C == var_s3[var_t1].z)) { var_a1 = var_v1_3; } var_a0 -= 1; var_v1_3++; } if (var_a1 >= 0) { - var_s0[var_t2].unkE = var_a1; - var_s0[var_t2].unk0 = D_8011B330[var_a1].x; - var_s0[var_t2].unk8 = D_8011B330[var_a1].z; + var_s0[var_t2].unkC_union.s.unkE = var_a1; + var_s0[var_t2].x = D_8011B330[var_a1].x; + var_s0[var_t2].z = D_8011B330[var_a1].z; var_t2++; } else { temp_f24 = temp_f16 / (temp_f16 - temp_f22); - var_s0[var_t2].unk0 = - var_s3[var_t1].unk0 + ((var_s3[var_v1].unk0 - var_s3[var_t1].unk0) * temp_f24); - var_s0[var_t2].unk8 = - var_s3[var_t1].unk8 + ((var_s3[var_v1].unk8 - var_s3[var_t1].unk8) * temp_f24); + var_s0[var_t2].x = var_s3[var_t1].x + ((var_s3[var_v1].x - var_s3[var_t1].x) * temp_f24); + var_s0[var_t2].z = var_s3[var_t1].z + ((var_s3[var_v1].z - var_s3[var_t1].z) * temp_f24); if (D_8011B320[var_v0] > 0x1F) { D_8011B320[var_v0] = 0x1F; } var_v1_3 = D_8011B320[var_v0] + (var_v0 << 5); - D_8011B330[var_v1_3].unk10 = var_s3[var_t1].unk0; - D_8011B330[var_v1_3].unk14 = var_s3[var_t1].unk8; - D_8011B330[var_v1_3].unk18 = var_s3[var_v1].unk0; - D_8011B330[var_v1_3].unk1C = var_s3[var_v1].unk8; - D_8011B330[var_v1_3].x = var_s0[var_t2].unk0; - D_8011B330[var_v1_3].z = var_s0[var_t2].unk8; + D_8011B330[var_v1_3].unk10 = var_s3[var_t1].x; + D_8011B330[var_v1_3].unk14 = var_s3[var_t1].z; + D_8011B330[var_v1_3].unk18 = var_s3[var_v1].x; + D_8011B330[var_v1_3].unk1C = var_s3[var_v1].z; + D_8011B330[var_v1_3].x = var_s0[var_t2].x; + D_8011B330[var_v1_3].z = var_s0[var_t2].z; D_8011B330[var_v1_3].unkC = D_8011D0BC; D_8011B320[var_v0]++; - var_s0[var_t2].unkE = var_v1_3; + var_s0[var_t2].unkC_union.s.unkE = var_v1_3; var_t2++; } } if (temp_f22 <= 0.0f) { - var_s0[var_t2].unkE = var_s3[var_v1].unkE; - var_s0[var_t2].unk0 = var_s3[var_v1].unk0; - var_s0[var_t2].unk8 = var_s3[var_v1].unk8; + var_s0[var_t2].unkC_union.s.unkE = var_s3[var_v1].unkC_union.s.unkE; + var_s0[var_t2].x = var_s3[var_v1].x; + var_s0[var_t2].z = var_s3[var_v1].z; var_t2++; } } @@ -4251,9 +4247,9 @@ s32 func_8002FF6C(s32 arg0, unk8011C8B8 *arg1, s32 arg2, Vec2f *arg3) { if (var_s2 >= 3) { if (var_s3 != arg1) { for (var_t1 = 0; var_t1 < var_s2; var_t1++) { - arg1[var_t1].unk0 = var_s3[var_t1].unk0; - arg1[var_t1].unk8 = var_s3[var_t1].unk8; - arg1[var_t1].unkE = var_s3[var_t1].unkE; + arg1[var_t1].x = var_s3[var_t1].x; + arg1[var_t1].z = var_s3[var_t1].z; + arg1[var_t1].unkC_union.s.unkE = var_s3[var_t1].unkC_union.s.unkE; } } } else { diff --git a/src/tracks.h b/src/tracks.h index 6fb30176..046720e3 100644 --- a/src/tracks.h +++ b/src/tracks.h @@ -18,31 +18,36 @@ enum ShadowUpdate { /* Size: 0x10 bytes */ typedef struct unk8011C8B8 { - f32 unk0; - f32 unk4; - f32 unk8; - s16 unkC; - s16 unkE; + /* 0x00 */ f32 x; + /* 0x04 */ f32 y; + /* 0x08 */ f32 z; + union { + /* 0x0C */ f32 w; + struct { + /* 0x0C */ s16 unkC; + /* 0x0E */ s16 unkE; + } s; + } unkC_union; } unk8011C8B8; /* Size: 0x10 bytes */ typedef struct unk8011B120 { - f32 x; - f32 y; - f32 z; - unk8011C8B8 *unkC; + /* 0x00 */ f32 x; + /* 0x04 */ f32 y; + /* 0x08 */ f32 z; + /* 0x0C */ unk8011C8B8 *unkC; } unk8011B120; /* Size: 0x20 bytes */ typedef struct unk8011B330 { - f32 x; - f32 y; - f32 z; - unk8011C8B8 *unkC; - f32 unk10; - f32 unk14; - f32 unk18; - f32 unk1C; + /* 0x00 */ f32 x; + /* 0x04 */ f32 y; + /* 0x08 */ f32 z; + /* 0x0C */ unk8011C8B8 *unkC; + /* 0x10 */ f32 unk10; + /* 0x14 */ f32 unk14; + /* 0x18 */ f32 unk18; + /* 0x1C */ f32 unk1C; } unk8011B330; /* Size: 0x10 bytes */ @@ -69,16 +74,16 @@ typedef struct unk8011D478 { /* Size: 0x14 bytes */ typedef struct unk8011C3B8 { - s16 unk0; - s16 unk2; - s16 unk4; - s16 unk6; - s16 unk8; - s16 unkA; - s16 unkC; - s16 unkE; - s16 unk10; - s16 unk12; + /* 0x00 */ s16 x1; + /* 0x02 */ s16 y1; + /* 0x04 */ s16 z1; + /* 0x06 */ s16 x2; + /* 0x08 */ s16 y2; + /* 0x0A */ s16 z2; + /* 0x0C */ s16 x3; + /* 0x0E */ s16 y3; + /* 0x10 */ s16 z3; + /* 0x12 */ s16 unk12; } unk8011C3B8; // In this struct, data is rightshifted 16 bytes, so make the smooth transition more precise. diff --git a/src/waves.c b/src/waves.c index be3e603f..c7baed28 100644 --- a/src/waves.c +++ b/src/waves.c @@ -1837,291 +1837,228 @@ void func_800BCC70(LevelModel *model) { #ifdef NON_EQUIVALENT s32 func_800BDC80(s32 arg0, unk8011C3B8 *arg1, unk8011C8B8 *arg2, f32 shadowXNegPosition, f32 shadowZNegPosition, f32 shadowXPosition, f32 shadowZPosition) { - s32 sp36C; - s32 sp368; - s32 sp364; + s32 colCount; + s32 startCol; // sp368 + s32 startRow; // sp364 f32 var_f0; - f32 var_f12; - s32 sp358; - s32 sp354; - f32 var_f14; - s32 sp34C; - f32 var_f16; - f32 var_f18; + f32 pad_sp35C; + s32 endCol; // sp358 + s32 endRow; // sp354 + s32 colOffset; // sp350 + s32 rowOffset; // sp34C + f32 pad_sp348; + f32 pad_sp344; + f32 pad_sp340; f32 var_f24; f32 var_f26; - f32 var_f28; - f32 var_f20; + f32 pad_sp334; s16 var_a1; // sp332 + f32 var_f20; f32 var_f22; s16 var_s8; s16 var_s2_s16; s16 var_s3_2; - s32 var_s5; - s32 var_a2_2; - s32 var_lo; - s32 var_lo_2; + s32 pad_sp27C; + s32 pad_sp278; + s32 pad_sp274; + s32 pad_sp270; s32 var_s0; - s32 var_s1; - s32 var_v1; - s32 var_s6; - s32 var_t0; + s32 currentCol; + s32 currentRow; + s32 waveCount; s32 temp1_2; s32 temp2_2; - s16 spD8[0x110]; // probably incorrect size + s32 pad_sp254; + s32 var_a3; + s32 pad_sp24C; + s32 var_t0; + s32 var_v0; + unk8011C8B8 *var_v0_4; + s32 pad_sp23C; + unk8011C3B8 *var_s0_2; + s16 spD8[256]; // 16 x 16 s32 var_s2; s32 var_s4; - f32 spCC; - f32 spC8; - s32 var_v0; - s32 spA4; - unk8011C8B8 *var_v0_4; - s32 sp98; - unk8011C3B8 *var_s0_2; - s32 sp90; + f32 steps[2]; // spC8 + s32 pad_spC4; s32 temp3_2; s32 temp4_2; - s32 var_s7; // sp74 + s32 counter; s32 var_t8; + s32 var_t6; + s32 pad[3]; - var_t0 = (arg0 * gWaveTileTotal); - spCC = gWaveVtxStepX; - spC8 = gWaveVtxStepZ; + steps[1] = gWaveVtxStepX; + steps[0] = gWaveVtxStepZ; var_f24 = (1.0f - gWaveController.unk44) / 127.0f; - if (gWaveController.doubleDensity != FALSE) { - sp36C = gWaveController.subdivisions * 2; - spCC *= 0.5; - spC8 *= 0.5; + waveCount = (arg0 * gWaveTileTotal); + if (gWaveController.doubleDensity) { var_f22 = 0.5f; + steps[1] *= 0.5; + steps[0] *= 0.5; + colCount = gWaveController.subdivisions * 2; } else { var_f22 = 1.0f; - sp36C = gWaveController.subdivisions; + colCount = gWaveController.subdivisions; } - var_f12 = shadowXNegPosition - gWaveModel[arg0].originX; - var_f14 = shadowZNegPosition - gWaveModel[arg0].originZ; - var_f16 = shadowXPosition - gWaveModel[arg0].originX; - var_f18 = shadowZPosition - gWaveModel[arg0].originZ; + shadowXNegPosition -= gWaveModel[arg0].originX; + shadowZNegPosition -= gWaveModel[arg0].originZ; + shadowXPosition -= gWaveModel[arg0].originX; + shadowZPosition -= gWaveModel[arg0].originZ; - if (var_f12 < 0.0f) { - sp368 = 0; + if (shadowXNegPosition < 0.0f) { + startCol = 0; } else { - sp368 = var_f12 / spCC; + startCol = shadowXNegPosition / steps[1]; } - if (var_f14 < 0.0f) { - sp364 = 0; + // 0 instead of 0.0f is "correct" here + if (shadowZNegPosition < 0) { + startRow = 0; } else { - sp364 = var_f14 / spC8; + startRow = shadowZNegPosition / steps[0]; } - if (gWaveBoundingBoxW <= var_f16) { - sp358 = sp36C; + if (gWaveBoundingBoxW <= shadowXPosition) { + endCol = colCount; } else { - sp358 = (s32) (var_f16 / spCC) + 1; + endCol = (s32) (shadowXPosition / steps[1]) + 1; } - if (gWaveBoundingBoxH <= var_f18) { - sp354 = sp36C; + if (gWaveBoundingBoxH <= shadowZPosition) { + endRow = colCount; } else { - sp354 = (s32) (var_f18 / spCC) + 1; + endRow = (s32) (shadowZPosition / steps[1]) + 1; } - var_v1 = gWaveModel[arg0].unk12 + sp368; - while (var_v1 >= gWaveController.tileCount) { - var_v1 -= gWaveController.tileCount; + colOffset = gWaveModel[arg0].unk12 + startCol; + while (colOffset >= gWaveController.tileCount) { + colOffset -= gWaveController.tileCount; } - var_v0 = gWaveModel[arg0].unk10 + sp364; - while (var_v0 >= gWaveController.tileCount) { - var_v0 -= gWaveController.tileCount; + rowOffset = gWaveModel[arg0].unk10 + startRow; + while (rowOffset >= gWaveController.tileCount) { + rowOffset -= gWaveController.tileCount; } - var_s6 = sp364; - var_s7 = 0; - if (sp354 >= sp364) { - spA4 = var_t0 + sp368 + (sp364 * sp36C); - sp90 = sp354 + 1; - sp34C = var_v0; - do { - var_s4 = spA4; - var_s0 = var_v1; - var_s2 = (sp34C * gWaveController.tileCount) + var_v1; - if (sp358 >= sp368) { - var_s1 = sp368; - var_s5 = sp358 + 1; - do { - var_f20 = (gWaveHeightTable[gWaveHeightIndices[var_s2].s[0]] + - gWaveHeightTable[gWaveHeightIndices[var_s2].s[1]]) * - gWaveController.magnitude; - if (gWaveGenCount > 0) { - var_f20 += waves_get_y(arg0, var_s1, var_s6); - } - if (D_800E3178[var_s4] < 0x7F) { - // s32 cast below required - var_f20 *= gWaveController.unk44 + ((s32) D_800E3178[var_s4] * var_f24); - } - var_s1++; - var_s7++; - var_s0++; - var_s4++; - var_s2++; - spD8[var_s7 - 1] = gWaveModel[arg0].originY + (s32) (var_f20 * var_f22); - if (var_s0 >= gWaveController.tileCount) { - var_s0 -= gWaveController.tileCount; - var_s2 -= gWaveController.tileCount; - } - } while (var_s5 != var_s1); + for (currentRow = startRow, counter = 0; endRow >= currentRow; currentRow++) { + var_s0 = colOffset; + var_s2 = (rowOffset * gWaveController.tileCount) + var_s0; + var_s4 = waveCount + startCol + (currentRow * colCount); + for (currentCol = startCol; endCol >= currentCol; currentCol++) { + var_f20 = (gWaveHeightTable[gWaveHeightIndices[var_s2].s[0]] + + gWaveHeightTable[gWaveHeightIndices[var_s2].s[1]]) * + gWaveController.magnitude; + if (gWaveGenCount > 0) { + var_f20 += waves_get_y(arg0, currentCol, currentRow); } - sp34C++; - if (sp34C >= gWaveController.tileCount) { - sp34C -= gWaveController.tileCount; + var_v0 = D_800E3178[var_s4]; + if (var_v0 < 0x7F) { + var_f20 *= gWaveController.unk44 + (var_v0 * var_f24); } - spA4 += sp36C; - var_s6++; - } while (sp90 != var_s6); + + // s32 cast below required + spD8[counter] = gWaveModel[arg0].originY + (s32) (var_f20 * var_f22); + + counter++; + var_s4++; + var_s0++; + var_s2++; + if (var_s0 >= gWaveController.tileCount) { + var_s0 -= gWaveController.tileCount; + var_s2 -= gWaveController.tileCount; + } + } + + rowOffset++; + if (rowOffset >= gWaveController.tileCount) { + rowOffset -= gWaveController.tileCount; + } } - var_s7 = 0; - sp36C = (sp358 - sp368) + 1; - var_a1 = gWaveModel[arg0].originZ + (s32) (sp364 * spC8); - if (sp364 < sp354) { - sp98 = sp368 * spCC; - var_s6 = sp364; - do { - var_s8 = gWaveModel[arg0].originZ + (s32) ((var_s6 + 1) * spC8); - var_s3_2 = gWaveModel[arg0].originX + sp98; - if (sp368 < sp358) { - var_s0_2 = &arg1[var_s7]; - // a3 / t5 as index - var_lo = (var_s6 - sp364) * sp36C; - // t0 / t8 as index - var_lo_2 = ((var_s6 - sp364) + 1) * sp36C; - /* - t4 = sp368 - t8 = t4 - t4 ???? - t6 = t8 * 2 - t3 = spD8 - v0 = t6 + t3 - -- - a3 = a2 * t7 (var_lo) - t5 = a3 * 2 - s4 = v0 + t5 - */ - // temp1 = &spD8[sp368 - sp368 + var_lo]; - var_t8 = sp368; - temp1_2 = sp368 + var_lo - sp368; - /* - t4 = sp368 - t6 = t4 * 2 - at = neg t4 - t3 = at * 2 - t9 = t6 + t3 - t1 = t9 + t5 - -- - a3 = a2 * t7 (var_lo) - t5 = a3 * 2 - a3 = t5 - -- - v1 = t1 + a3 - */ - // temp2 = &spD8[sp368 + var_lo]; - temp2_2 = sp368 + var_lo; - /* - t4 = sp368 - t8 = t4 - t4 ???? - t6 = t8 * 2 - t3 = spD8 - v0 = t6 + t3 - -- - t0 = t2 * t7 (var_lo_2) - t8 = t0 * 2 - -- - s5 = v0 + t8 - */ - // temp3 = &spD8[(sp368 - sp368) + var_lo_2]; - temp3_2 = sp368 + var_lo_2 - sp368; - /* - t4 = sp368 - t6 = t4 * 2 - at = neg t4 - t3 = at * 2 - t9 = t6 + t3 - t1 = t9 + t5 - -- - t0 = t2 * t7 (var_lo_2) - t8 = t0 * 2 - -- - a0 = t1 + t8 - */ - // temp4 = &spD8[sp368 + var_lo_2]; - temp4_2 = sp368 + var_lo_2; - var_s1 = var_s6; - var_f26 = spCC * spC8; - var_f28 = var_f26 * var_f26; - do { - var_s0_2->unk0 = var_s3_2; - var_s2_s16 = gWaveModel[arg0].originX + (s32) (var_s1 * spCC); - var_s0_2->unk6 = var_s3_2; - var_s0_2->unkC = var_s2_s16; - var_s0_2->unk2 = spD8[temp1_2]; - var_s0_2->unk8 = spD8[temp3_2]; - var_s0_2->unkE = spD8[temp2_2 + 1]; - var_s0_2->unk4 = var_a1; - var_s0_2->unkA = var_s8; - var_s0_2->unk10 = var_a1; - var_f20 = (var_s0_2->unk2 - var_s0_2->unkE) * spC8; - var_f22 = (var_s0_2->unk2 - var_s0_2->unk8) * spCC; - var_f0 = sqrtf((var_f20 * var_f20) + var_f28 + (var_f22 * var_f22)); - if (var_f0 > 0.0f) { - var_f24 = (1.0f / var_f0); - var_v0_4 = &arg2[var_s7]; - var_v0_4->unk0 = var_f20 * var_f24; - var_v0_4->unk4 = var_f26 * var_f24; - var_v0_4->unk8 = var_f22 * var_f24; - var_v0_4->unkC = -((var_v0_4->unk8 * var_s0_2->unk4) + - ((var_s0_2->unk0 * var_v0_4->unk0) + (var_s0_2->unk2 * var_v0_4->unk4))); - var_s7++; - var_s0_2++; - } - var_s0_2->unk0 = var_s2_s16; - var_s0_2->unk6 = var_s3_2; - var_s0_2->unkC = var_s2_s16; - var_s0_2->unk2 = spD8[temp1_2 + 1]; - var_s0_2->unk8 = spD8[temp3_2]; - var_s0_2->unkE = spD8[temp4_2 + 1]; - var_s0_2->unk4 = var_a1; - var_s0_2->unkA = var_s8; - var_s0_2->unk10 = var_s8; - var_f20 = (var_s0_2->unk8 - var_s0_2->unkE) * spC8; - var_f22 = (var_s0_2->unk2 - var_s0_2->unkE) * spCC; - var_f0 = sqrtf((var_f20 * var_f20) + var_f28 + (var_f22 * var_f22)); - if (var_f0 > 0.0f) { - var_f24 = (1.0f / var_f0); - var_v0_4 = &arg2[var_s7]; - var_v0_4->unk0 = var_f20 * var_f24; - var_v0_4->unk4 = var_f26 * var_f24; - var_v0_4->unk8 = var_f22 * var_f24; + colCount = (endCol - startCol) + 1; + var_a1 = gWaveModel[arg0].originZ + (s32) (steps[0] * startRow); + var_s3_2 = gWaveModel[arg0].originX + (s32) (steps[1] * startCol); + counter = 0; + var_s0_2 = &arg1[counter]; + for (currentRow = startRow; currentRow < endRow; currentRow++) { + // 0 .. 15 + var_a3 = (currentRow - startRow) * colCount; + // 1 .. 16 + var_t0 = ((currentRow - startRow) + 1) * colCount; - var_v0_4->unkC = -((var_v0_4->unk8 * var_s0_2->unk4) + - ((var_s0_2->unk0 * var_v0_4->unk0) + (var_s0_2->unk2 * var_v0_4->unk4))); - var_s7++; - var_s0_2++; - } - var_s1++; - temp1_2++; - temp3_2++; - temp2_2++; - temp4_2++; - var_s3_2 = var_s2_s16; - } while (var_s1 != sp358); - } - var_a1 = var_s8; - var_s6++; - } while (var_s6 != sp354); + var_s8 = gWaveModel[arg0].originZ + (s32) (steps[0] * (currentRow + 1)); + var_f26 = steps[0] * steps[1]; + if (startCol < endCol) { + currentCol = startCol; // s1 + do { + // v0 = currentCol - startCol as index of spD8 + // t1 = -currentCol + startCol as index of spD8 + var_t6 = (startCol * -1) + currentCol; + var_t8 = currentCol - startCol; + temp1_2 = var_a3 + var_t8; // s4 current row + col + temp2_2 = var_t0 + var_t8; // v1 current row + next col + temp3_2 = var_a3 + var_t6; // s5 next row + current col + temp4_2 = var_t0 + var_t6; // a0 next row + col + pad_spC4 = steps[1] * (currentCol + 1); + var_s2_s16 = gWaveModel[arg0].originX + pad_spC4; + var_s0_2->x1 = var_s3_2; + var_s0_2->x2 = var_s3_2; + var_s0_2->x3 = var_s2_s16; + var_s0_2->y1 = spD8[temp1_2]; + var_s0_2->y2 = spD8[temp3_2]; + var_s0_2->y3 = spD8[temp2_2 + 1]; + var_s0_2->z1 = var_a1; + var_s0_2->z2 = var_s8; + var_s0_2->z3 = var_a1; + var_f20 = (var_s0_2->y1 - var_s0_2->y3) * steps[0]; + var_f22 = (var_s0_2->y1 - var_s0_2->y2) * steps[1]; + var_f0 = sqrtf((var_f20 * var_f20) + (var_f26 * var_f26) + (var_f22 * var_f22)); + if (var_f0 > 0.0f) { + var_f24 = (1.0f / var_f0); + var_v0_4 = &arg2[counter]; + var_v0_4->x = var_f20 * var_f24; + var_v0_4->y = var_f26 * var_f24; + var_v0_4->z = var_f22 * var_f24; + var_v0_4->unkC_union.w = + -((var_v0_4->z * var_s0_2->z1) + ((var_s0_2->x1 * var_v0_4->x) + (var_s0_2->y1 * var_v0_4->y))); + counter++; + var_s0_2++; + } + var_s0_2->x1 = var_s2_s16; + var_s0_2->x2 = var_s3_2; + var_s0_2->x3 = var_s2_s16; + var_s0_2->y1 = spD8[temp1_2 + 1]; + var_s0_2->y2 = spD8[temp3_2]; + var_s0_2->y3 = spD8[temp4_2 + 1]; + var_s0_2->z1 = var_a1; + var_s0_2->z2 = var_s8; + var_s0_2->z3 = var_s8; + var_f20 = (var_s0_2->y2 - var_s0_2->y3) * steps[0]; + var_f22 = (var_s0_2->y1 - var_s0_2->y3) * steps[1]; + var_f0 = sqrtf((var_f20 * var_f20) + (var_f26 * var_f26) + (var_f22 * var_f22)); + if (var_f0 > 0) { + var_f24 = (1.0f / var_f0); + var_v0_4 = &arg2[counter]; + var_v0_4->x = var_f20 * var_f24; + var_v0_4->y = var_f26 * var_f24; + var_v0_4->z = var_f22 * var_f24; + + var_v0_4->unkC_union.w = + -((var_v0_4->z * var_s0_2->z1) + ((var_s0_2->x1 * var_v0_4->x) + (var_s0_2->y1 * var_v0_4->y))); + counter++; + var_s0_2++; + } + currentCol++; + var_s3_2 = var_s2_s16; + } while (currentCol < endCol); + } + + var_a1 = var_s8; } - return var_s7; + return counter; } #else #pragma GLOBAL_ASM("asm/nonmatchings/waves/func_800BDC80.s")