summaryrefslogtreecommitdiff
path: root/src/code
diff options
context:
space:
mode:
Diffstat (limited to 'src/code')
-rw-r--r--src/code/audio/audio_dcache.c15
-rw-r--r--src/code/audio/code_80194710.c5
-rw-r--r--src/code/z_bgcheck.c121
-rw-r--r--src/code/z_collision_check.c64
-rw-r--r--src/code/z_debug_display.c2
-rw-r--r--src/code/z_eff_blure.c1011
-rw-r--r--src/code/z_eff_shield_particle.c206
-rw-r--r--src/code/z_eff_spark.c264
-rw-r--r--src/code/z_eff_ss_dead.c110
-rw-r--r--src/code/z_eff_tire_mark.c286
-rw-r--r--src/code/z_effect.c232
-rw-r--r--src/code/z_effect_soft_sprite_old_init.c4
-rw-r--r--src/code/z_fireobj.c3
-rw-r--r--src/code/z_kaleido_manager.c103
-rw-r--r--src/code/z_kaleido_scope_call.c83
-rw-r--r--src/code/z_kaleido_setup.c4
-rw-r--r--src/code/z_parameter.c19
-rw-r--r--src/code/z_room.c4
18 files changed, 2211 insertions, 325 deletions
diff --git a/src/code/audio/audio_dcache.c b/src/code/audio/audio_dcache.c
new file mode 100644
index 000000000..27f019fef
--- /dev/null
+++ b/src/code/audio/audio_dcache.c
@@ -0,0 +1,15 @@
+#include "global.h"
+
+void Audio_InvalDCache(void* buf, size_t size) {
+ OSIntMask prevMask = osSetIntMask(1);
+
+ osInvalDCache(buf, size);
+ osSetIntMask(prevMask);
+}
+
+void Audio_WritebackDCache(void* buf, size_t size) {
+ OSIntMask prevMask = osSetIntMask(1);
+
+ osWritebackDCache(buf, size);
+ osSetIntMask(prevMask);
+}
diff --git a/src/code/audio/code_80194710.c b/src/code/audio/code_80194710.c
deleted file mode 100644
index 090c5735b..000000000
--- a/src/code/audio/code_80194710.c
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "global.h"
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80194710/func_80194710.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80194710/func_80194750.s")
diff --git a/src/code/z_bgcheck.c b/src/code/z_bgcheck.c
index e5cb1ddb1..d7a94da5b 100644
--- a/src/code/z_bgcheck.c
+++ b/src/code/z_bgcheck.c
@@ -68,10 +68,12 @@ BgSpecialSceneMaxObjects sCustomDynapolyMem[] = {
{ SCENE_21MITURINMAE, 1000, 600, 512 },
};
+// TODO: All these bss variables are localized to one function and can
+// likely be made into in-function static bss variables in the future
char D_801ED950[80];
char D_801ED9A0[80];
Vec3f D_801ED9F0[3]; // polyVerts
-Vec3f D_801EDA18[3]; // polyVerts //not ok, needs to be inlined to match
+Vec3f D_801EDA18[3]; // polyVerts
MtxF D_801EDA40;
Vec3f D_801EDA80[3]; // polyVerts
char D_801EDAA8[80];
@@ -79,8 +81,6 @@ char D_801EDAF8[80];
Vec3f D_801EDB48[3]; // polyVerts
Vec3f D_801EDB70[3];
Plane D_801EDB98;
-Sphere16 D_801EDBA8;
-TriNorm D_801EDBB0;
void BgCheck_GetStaticLookupIndicesFromPos(CollisionContext* colCtx, Vec3f* pos, Vec3i* sector);
f32 BgCheck_RaycastFloorDyna(DynaRaycast* dynaRaycast);
@@ -322,40 +322,34 @@ s32 CollisionPoly_CheckYIntersectApprox1(CollisionPoly* poly, Vec3s* vtxList, f3
* Checks if point (`x`,`z`) is within `checkDist` of `poly`, computing `yIntersect` if true
* Determinant max 0.0f (checks if on or within poly)
*/
-#ifdef NON_MATCHING
s32 CollisionPoly_CheckYIntersect(CollisionPoly* poly, Vec3s* vtxList, f32 x, f32 z, f32* yIntersect, f32 checkDist) {
- static Vec3f polyVerts[3]; // D_801EDA18
Vec3s* sVerts;
f32 nx;
f32 ny;
f32 nz;
sVerts = &vtxList[COLPOLY_VTX_INDEX(poly->flags_vIA)];
- polyVerts[0].x = sVerts->x;
- polyVerts[0].y = sVerts->y;
- polyVerts[0].z = sVerts->z;
+ D_801EDA18[0].x = sVerts->x;
+ D_801EDA18[0].y = sVerts->y;
+ D_801EDA18[0].z = sVerts->z;
sVerts = &vtxList[COLPOLY_VTX_INDEX(poly->flags_vIB)];
- polyVerts[1].x = sVerts->x;
- polyVerts[1].y = sVerts->y;
- polyVerts[1].z = sVerts->z;
- sVerts = &vtxList[poly->vIC];
- polyVerts[2].x = sVerts->x;
- polyVerts[2].y = sVerts->y;
- polyVerts[2].z = sVerts->z;
-
- if (!func_8017A304(&polyVerts[0], &polyVerts[1], &polyVerts[2], z, x, checkDist)) {
+ D_801EDA18[1].x = sVerts->x;
+ D_801EDA18[1].y = sVerts->y;
+ D_801EDA18[1].z = sVerts->z;
+ sVerts = &vtxList[(s32)poly->vIC];
+ D_801EDA18[2].x = sVerts->x;
+ D_801EDA18[2].y = sVerts->y;
+ D_801EDA18[2].z = sVerts->z;
+
+ if (!func_8017A304(&D_801EDA18[0], &D_801EDA18[1], &D_801EDA18[2], z, x, checkDist)) {
return 0;
}
nx = COLPOLY_GET_NORMAL(poly->normal.x);
ny = COLPOLY_GET_NORMAL(poly->normal.y);
nz = COLPOLY_GET_NORMAL(poly->normal.z);
- return Math3D_TriChkPointParaYIntersectInsideTri2(&polyVerts[0], &polyVerts[1], &polyVerts[2], nx, ny, nz,
+ return Math3D_TriChkPointParaYIntersectInsideTri2(&D_801EDA18[0], &D_801EDA18[1], &D_801EDA18[2], nx, ny, nz,
poly->dist, z, x, yIntersect, checkDist);
}
-#else
-s32 CollisionPoly_CheckYIntersect(CollisionPoly* poly, Vec3s* vtxList, f32 x, f32 z, f32* yIntersect, f32 checkDist);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/CollisionPoly_CheckYIntersect.s")
-#endif
s32 CollisionPoly_CheckYIntersectApprox2(CollisionPoly* poly, Vec3s* vtxList, f32 x, f32 z, f32* yIntersect) {
return CollisionPoly_CheckYIntersectApprox1(poly, vtxList, x, z, yIntersect, 1.0f);
@@ -427,8 +421,6 @@ s32 CollisionPoly_LineVsPoly(BgLineVsPolyTest* a0);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/CollisionPoly_LineVsPoly.s")
#endif
-#ifdef NON_MATCHING
-// OK but .bss order issues
s32 CollisionPoly_SphVsPoly(CollisionPoly* poly, Vec3s* vtxList, Vec3f* center, f32 radius) {
static Sphere16 sphere; // D_801EDBA8
static TriNorm tri; // D_801EDBB0
@@ -443,12 +435,7 @@ s32 CollisionPoly_SphVsPoly(CollisionPoly* poly, Vec3s* vtxList, Vec3f* center,
sphere.radius = radius;
return Math3D_ColSphereTri(&sphere, &tri, &intersect);
}
-#else
-s32 CollisionPoly_SphVsPoly(CollisionPoly* poly, Vec3s* vtxList, Vec3f* center, f32 radius);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/CollisionPoly_SphVsPoly.s")
-#endif
-#ifdef NON_MATCHING
/**
* Add poly to StaticLookup table
* Table is sorted by poly's smallest y vertex component
@@ -486,6 +473,8 @@ void StaticLookup_AddPolyToSSList(CollisionContext* colCtx, SSList* ssList, Coll
while (true) {
// if at the end of the list
if (curNode->next == SS_NULL) {
+ s32 pad;
+
newNodeId = SSNodeList_GetNextNodeIdx(&colCtx->polyNodes);
SSNode_SetValue(&colCtx->polyNodes.tbl[newNodeId], &polyId, SS_NULL);
curNode->next = newNodeId;
@@ -507,9 +496,6 @@ void StaticLookup_AddPolyToSSList(CollisionContext* colCtx, SSList* ssList, Coll
curNode = nextNode;
}
}
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/StaticLookup_AddPolyToSSList.s")
-#endif
/**
* Add CollisionPoly to StaticLookup list
@@ -871,28 +857,29 @@ s32 BgCheck_SphVsStaticWall(StaticLookup* lookup, CollisionContext* colCtx, u16
* `outPoly` returns the poly collided with
* `outY` returns the y coordinate needed to not collide with `outPoly`
*/
-#ifdef NON_MATCHING
s32 BgCheck_CheckStaticCeiling(StaticLookup* lookup, u16 xpFlags, CollisionContext* colCtx, f32* outY, Vec3f* pos,
f32 checkHeight, CollisionPoly** outPoly, Actor* actor) {
s32 result = false;
- // u16 nextId;
CollisionPoly* curPoly;
CollisionPoly* polyList;
+ s32 curPolyId;
f32 ceilingY;
- Vec3s* vtxList;
SSNode* curNode;
- s32 curPolyId;
+ Vec3s* vtxList;
if (lookup->ceiling.head == SS_NULL) {
return result;
}
- curNode = &colCtx->polyNodes.tbl[lookup->ceiling.head];
polyList = colCtx->colHeader->polyList;
vtxList = colCtx->colHeader->vtxList;
+ curNode = &colCtx->polyNodes.tbl[lookup->ceiling.head];
*outY = pos->y;
while (true) {
+ f32 intersectDist;
+ f32 ny;
+
curPolyId = curNode->polyId;
curPoly = &polyList[curPolyId];
if (COLPOLY_VIA_FLAG_TEST(colCtx->colHeader->polyList[curPolyId].flags_vIA, xpFlags) ||
@@ -908,8 +895,8 @@ s32 BgCheck_CheckStaticCeiling(StaticLookup* lookup, u16 xpFlags, CollisionConte
}
if (CollisionPoly_CheckYIntersectApprox2(curPoly, vtxList, pos->x, pos->z, &ceilingY)) {
- f32 intersectDist = ceilingY - *outY;
- f32 ny = COLPOLY_GET_NORMAL(curPoly->normal.y);
+ intersectDist = ceilingY - *outY;
+ ny = COLPOLY_GET_NORMAL(curPoly->normal.y);
if (intersectDist > 0 && intersectDist < checkHeight && intersectDist * ny <= 0) {
*outY = ceilingY - checkHeight;
@@ -926,11 +913,6 @@ s32 BgCheck_CheckStaticCeiling(StaticLookup* lookup, u16 xpFlags, CollisionConte
}
return result;
}
-#else
-s32 BgCheck_CheckStaticCeiling(StaticLookup* lookup, u16 xpFlags, CollisionContext* colCtx, f32* outY, Vec3f* pos,
- f32 checkHeight, CollisionPoly** outPoly, Actor* actor);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/BgCheck_CheckStaticCeiling.s")
-#endif
/**
* Tests if line `posA` to `posB` intersects with a static poly in list `ssList`. Uses polyCheckTbl
@@ -1049,7 +1031,6 @@ s32 BgCheck_CheckLineInSubdivision(StaticLineTest* arg0) {
* returns true if any poly intersects the sphere, else returns false
* `outPoly` returns the pointer of the first poly found that intersects
*/
-#ifdef NON_MATCHING
s32 BgCheck_SphVsFirstStaticPolyList(SSNode* node, u16 xpFlags, CollisionContext* colCtx, Vec3f* center, f32 radius,
CollisionPoly** outPoly, Actor* actor) {
Vec3s* vtxList;
@@ -1057,7 +1038,6 @@ s32 BgCheck_SphVsFirstStaticPolyList(SSNode* node, u16 xpFlags, CollisionContext
CollisionPoly* curPoly;
u16 nextId;
s16 curPolyId;
- s32 pad;
polyList = colCtx->colHeader->polyList;
vtxList = colCtx->colHeader->vtxList;
@@ -1088,17 +1068,14 @@ s32 BgCheck_SphVsFirstStaticPolyList(SSNode* node, u16 xpFlags, CollisionContext
}
if (node->next != SS_NULL) {
node = &colCtx->polyNodes.tbl[node->next];
+ { s32 pad; }
+
continue;
}
break;
}
return false;
}
-#else
-s32 BgCheck_SphVsFirstStaticPolyList(SSNode* node, u16 xpFlags, CollisionContext* colCtx, Vec3f* center, f32 radius,
- CollisionPoly** outPoly, Actor* actor);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/BgCheck_SphVsFirstStaticPolyList.s")
-#endif
/**
* Get first static poly intersecting sphere `center` `radius` within `lookup`
@@ -1539,16 +1516,12 @@ s32 BgCheck_GetSpecialSceneMaxObjects(GlobalContext* globalCtx, s32* maxNodes, s
/**
* Allocate CollisionContext
*/
-#ifdef NON_MATCHING
void BgCheck_Allocate(CollisionContext* colCtx, GlobalContext* globalCtx, CollisionHeader* colHeader) {
u32 tblMax;
u32 memSize;
u32 lookupTblMemSize;
SSNodeList* nodeList;
- s32 useCustomSubdivisions;
- u32 customMemSize;
s32 customNodeListMax;
- s32 i;
customNodeListMax = -1;
colCtx->colHeader = colHeader;
@@ -1563,6 +1536,10 @@ void BgCheck_Allocate(CollisionContext* colCtx, GlobalContext* globalCtx, Collis
colCtx->subdivAmount.y = 4;
colCtx->subdivAmount.z = 16;
} else {
+ u32 customMemSize;
+ s32 useCustomSubdivisions;
+ s32 i;
+
if (BgCheck_TryGetCustomMemsize(globalCtx->sceneNum, &customMemSize)) {
colCtx->memSize = customMemSize;
} else {
@@ -1631,10 +1608,6 @@ void BgCheck_Allocate(CollisionContext* colCtx, GlobalContext* globalCtx, Collis
DynaPoly_Init(globalCtx, &colCtx->dyna);
DynaPoly_Alloc(globalCtx, &colCtx->dyna);
}
-#else
-void BgCheck_Allocate(CollisionContext* colCtx, GlobalContext* globalCtx, CollisionHeader* colHeader);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/BgCheck_Allocate.s")
-#endif
/**
* Enables CollisionContext wide flags
@@ -2182,7 +2155,6 @@ s32 BgCheck_EntityCheckCeiling(CollisionContext* colCtx, f32* outY, Vec3f* pos,
return BgCheck_CheckCeilingImpl(colCtx, COLPOLY_IGNORE_ENTITY, outY, pos, checkHeight, outPoly, outBgId, actor);
}
-#ifdef NON_MATCHING
/**
* Tests if a line from `posA` to `posB` intersects with a poly
* returns true if it does, else false
@@ -2202,12 +2174,9 @@ s32 BgCheck_CheckLineImpl(CollisionContext* colCtx, u16 xpFlags1, u16 xpFlags2,
StaticLineTest checkLine;
Vec3f sectorMin;
Vec3f sectorMax;
- s32 k;
+ s32 temp_lo;
StaticLookup* lookup;
s32 j;
- StaticLookup* jLookup;
- s32 temp_lo;
- s32 pad[2];
lookupTbl = colCtx->lookupTbl;
posBTemp = *posB;
@@ -2247,11 +2216,15 @@ s32 BgCheck_CheckLineImpl(CollisionContext* colCtx, u16 xpFlags1, u16 xpFlags2,
sectorMax.z = colCtx->subdivLength.z + sectorMin.z;
for (i = subdivMin[2]; i < subdivMax[2] + 1; i++) {
- jLookup = iLookup + subdivMin[1] * colCtx->subdivAmount.x;
+ StaticLookup* jLookup = iLookup + subdivMin[1] * colCtx->subdivAmount.x;
+ s32 pad;
+
sectorMin.y = subdivMin[1] * colCtx->subdivLength.y + colCtx->minBounds.y;
sectorMax.y = colCtx->subdivLength.y + sectorMin.y;
for (j = subdivMin[1]; j < subdivMax[1] + 1; j++) {
+ s32 k;
+
lookup = jLookup + subdivMin[0];
sectorMin.x = subdivMin[0] * colCtx->subdivLength.x + colCtx->minBounds.x;
sectorMax.x = colCtx->subdivLength.x + sectorMin.x;
@@ -2292,9 +2265,6 @@ s32 BgCheck_CheckLineImpl(CollisionContext* colCtx, u16 xpFlags1, u16 xpFlags2,
}
return result;
}
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/BgCheck_CheckLineImpl.s")
-#endif
/**
* Get bccFlags
@@ -3373,8 +3343,6 @@ f32 BgCheck_RaycastFloorDyna(DynaRaycast* dynaRaycast) {
#pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/BgCheck_RaycastFloorDyna.s")
#endif
-#ifdef NON_MATCHING
-// regalloc, minor instruction ordering
/**
* Performs collision detection on a BgActor's wall polys on sphere `pos`, `radius`
* returns true if a collision was detected
@@ -3401,8 +3369,6 @@ s32 BgCheck_SphVsDynaWallInBgActor(CollisionContext* colCtx, u16 xpFlags, DynaCo
f32 invNormalXZ;
f32 planeDist;
f32 temp_f18;
- f32 zIntersectDist;
- f32 xIntersectDist;
f32 zMin;
f32 zMax;
f32 xMin;
@@ -3472,6 +3438,8 @@ s32 BgCheck_SphVsDynaWallInBgActor(CollisionContext* colCtx, u16 xpFlags, DynaCo
}
}
if (CollisionPoly_CheckZIntersectApprox(poly, dyna->vtxList, resultPos.x, pos->y, &intersect)) {
+ s32 pad;
+
if (fabsf(intersect - resultPos.z) <= radius / temp_f18) {
if ((intersect - resultPos.z) * nz <= 4.0f) {
if (BgCheck_ComputeWallDisplacement(colCtx, poly, &resultPos.x, &resultPos.z, nx, ny, nz,
@@ -3547,7 +3515,8 @@ s32 BgCheck_SphVsDynaWallInBgActor(CollisionContext* colCtx, u16 xpFlags, DynaCo
}
if (CollisionPoly_CheckXIntersectApprox(poly, dyna->vtxList, pos->y, resultPos.z, &intersect)) {
- xIntersectDist = intersect - resultPos.x;
+ f32 xIntersectDist = intersect - resultPos.x;
+
if (fabsf(xIntersectDist) <= radius / temp_f18) {
if (xIntersectDist * nx <= 4.0f) {
if (BgCheck_ComputeWallDisplacement(colCtx, poly, &resultPos.x, &resultPos.z, nx, ny, nz,
@@ -3567,12 +3536,6 @@ s32 BgCheck_SphVsDynaWallInBgActor(CollisionContext* colCtx, u16 xpFlags, DynaCo
*outZ = resultPos.z;
return result;
}
-#else
-s32 BgCheck_SphVsDynaWallInBgActor(CollisionContext* colCtx, u16 xpFlags, DynaCollisionContext* dyna, SSList* ssList,
- f32* outX, f32* outZ, CollisionPoly** outPoly, s32* outBgId, Vec3f* pos, f32 radius,
- s32 bgId, Actor* actor);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_bgcheck/BgCheck_SphVsDynaWallInBgActor.s")
-#endif
/**
* Performs collision detection on all dyna poly walls using sphere `pos`, `radius`
diff --git a/src/code/z_collision_check.c b/src/code/z_collision_check.c
index e11e6cbd7..44885d6c7 100644
--- a/src/code/z_collision_check.c
+++ b/src/code/z_collision_check.c
@@ -27,12 +27,12 @@ Vec3f D_801EE1C0;
Vec3f D_801EE1D0;
Vec3f D_801EE1E0;
Vec3f D_801EE1F0;
-EffSparkParams D_801EE200;
+EffectSparkInit D_801EE200;
TriNorm D_801EE6C8;
TriNorm D_801EE700;
-EffSparkParams D_801EE738;
-EffSparkParams D_801EEC00;
-EffSparkParams D_801EF0C8;
+EffectSparkInit D_801EE738;
+EffectSparkInit D_801EEC00;
+EffectSparkInit D_801EF0C8;
TriNorm D_801EF590;
TriNorm D_801EF5C8;
TriNorm D_801EF600;
@@ -1382,14 +1382,14 @@ void CollisionCheck_NoBlood(GlobalContext* globalCtx, Collider* collider, Vec3f*
#ifdef NON_MATCHING
// needs in-function static bss
void CollisionCheck_BlueBlood(GlobalContext* globalCtx, Collider* collider, Vec3f* v) {
- static EffSparkParams D_801EEC00;
+ static EffectSparkInit D_801EEC00;
s32 effectIndex;
D_801EEC00.position.x = v->x;
D_801EEC00.position.x = v->y;
D_801EEC00.position.x = v->z;
- D_801EEC00.particleFactor1 = 5;
- D_801EEC00.particleFactor2 = 5;
+ D_801EEC00.uDiv = 5;
+ D_801EEC00.vDiv = 5;
D_801EEC00.colorStart[0].r = 10;
D_801EEC00.colorStart[0].g = 10;
D_801EEC00.colorStart[0].b = 200;
@@ -1422,12 +1422,12 @@ void CollisionCheck_BlueBlood(GlobalContext* globalCtx, Collider* collider, Vec3
D_801EEC00.colorEnd[3].g = 0;
D_801EEC00.colorEnd[3].b = 64;
D_801EEC00.colorEnd[3].a = 0;
- D_801EEC00.age = 0;
+ D_801EEC00.timer = 0;
D_801EEC00.duration = 16;
- D_801EEC00.velocity = 8.0f;
+ D_801EEC00.speed = 8.0f;
D_801EEC00.gravity = -1.0f;
- Effect_Add(globalCtx, &effectIndex, 0, 0, 1, &D_801EEC00);
+ Effect_Add(globalCtx, &effectIndex, EFFECT_SPARK, 0, 1, &D_801EEC00);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/CollisionCheck_BlueBlood.s")
@@ -1440,14 +1440,14 @@ void CollisionCheck_BlueBlood(GlobalContext* globalCtx, Collider* collider, Vec3
#ifdef NON_MATCHING
// needs in-function static bss
void CollisionCheck_GreenBlood(GlobalContext* globalCtx, Collider* collider, Vec3f* v) {
- static EffSparkParams D_801EF0C8;
+ static EffectSparkInit D_801EF0C8;
s32 effectIndex;
D_801EF0C8.position.x = v->x;
D_801EF0C8.position.x = v->y;
D_801EF0C8.position.x = v->z;
- D_801EF0C8.particleFactor1 = 5;
- D_801EF0C8.particleFactor2 = 5;
+ D_801EF0C8.uDiv = 5;
+ D_801EF0C8.vDiv = 5;
D_801EF0C8.colorStart[0].r = 10;
D_801EF0C8.colorStart[0].g = 200;
D_801EF0C8.colorStart[0].b = 10;
@@ -1480,11 +1480,11 @@ void CollisionCheck_GreenBlood(GlobalContext* globalCtx, Collider* collider, Vec
D_801EF0C8.colorEnd[3].g = 64;
D_801EF0C8.colorEnd[3].b = 0;
D_801EF0C8.colorEnd[3].a = 0;
- D_801EF0C8.age = 0;
+ D_801EF0C8.timer = 0;
D_801EF0C8.duration = 16;
- D_801EF0C8.velocity = 8.0f;
+ D_801EF0C8.speed = 8.0f;
D_801EF0C8.gravity = -1.0f;
- Effect_Add(globalCtx, &effectIndex, 0, 0, 1, &D_801EF0C8);
+ Effect_Add(globalCtx, &effectIndex, EFFECT_SPARK, 0, 1, &D_801EF0C8);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/CollisionCheck_GreenBlood.s")
@@ -3751,14 +3751,14 @@ void Collider_UpdateSphere(s32 limb, ColliderSphere* collider) {
#ifdef NON_MATCHING
// needs in-function static bss
void CollisionCheck_SpawnRedBlood(GlobalContext* globalCtx, Vec3f* v) {
- static EffSparkParams D_801EE200;
+ static EffectSparkInit D_801EE200;
s32 effectIndex;
D_801EE200.position.x = v->x;
D_801EE200.position.x = v->y;
D_801EE200.position.x = v->z;
- D_801EE200.particleFactor1 = 5;
- D_801EE200.particleFactor2 = 5;
+ D_801EE200.uDiv = 5;
+ D_801EE200.vDiv = 5;
D_801EE200.colorStart[0].r = 128;
D_801EE200.colorStart[0].g = 0;
D_801EE200.colorStart[0].b = 64;
@@ -3791,12 +3791,12 @@ void CollisionCheck_SpawnRedBlood(GlobalContext* globalCtx, Vec3f* v) {
D_801EE200.colorEnd[3].g = 0;
D_801EE200.colorEnd[3].b = 64;
D_801EE200.colorEnd[3].a = 0;
- D_801EE200.age = 0;
+ D_801EE200.timer = 0;
D_801EE200.duration = 16;
- D_801EE200.velocity = 8.0f;
+ D_801EE200.speed = 8.0f;
D_801EE200.gravity = -1.0f;
- Effect_Add(globalCtx, &effectIndex, 0, 0, 1, &D_801EE200);
+ Effect_Add(globalCtx, &effectIndex, EFFECT_SPARK, 0, 1, &D_801EE200);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/CollisionCheck_SpawnRedBlood.s")
@@ -3809,14 +3809,14 @@ void CollisionCheck_SpawnRedBlood(GlobalContext* globalCtx, Vec3f* v) {
#ifdef NON_MATCHING
// needs in-function static bss
void CollisionCheck_SpawnWaterDroplets(GlobalContext* globalCtx, Vec3f* v) {
- static EffSparkParams D_801EE738;
+ static EffectSparkInit D_801EE738;
s32 effectIndex;
D_801EE738.position.x = v->x;
D_801EE738.position.x = v->y;
D_801EE738.position.x = v->z;
- D_801EE738.particleFactor1 = 5;
- D_801EE738.particleFactor2 = 5;
+ D_801EE738.uDiv = 5;
+ D_801EE738.vDiv = 5;
D_801EE738.colorStart[0].r = 255;
D_801EE738.colorStart[0].g = 255;
D_801EE738.colorStart[0].b = 255;
@@ -3849,12 +3849,12 @@ void CollisionCheck_SpawnWaterDroplets(GlobalContext* globalCtx, Vec3f* v) {
D_801EE738.colorEnd[3].g = 0;
D_801EE738.colorEnd[3].b = 0;
D_801EE738.colorEnd[3].a = 0;
- D_801EE738.age = 0;
+ D_801EE738.timer = 0;
D_801EE738.duration = 16;
- D_801EE738.velocity = 8.0f;
+ D_801EE738.speed = 8.0f;
D_801EE738.gravity = -1.0f;
- Effect_Add(globalCtx, &effectIndex, 0, 0, 1, &D_801EE738);
+ Effect_Add(globalCtx, &effectIndex, EFFECT_SPARK, 0, 1, &D_801EE738);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/CollisionCheck_SpawnWaterDroplets.s")
@@ -3864,7 +3864,7 @@ void CollisionCheck_SpawnWaterDroplets(GlobalContext* globalCtx, Vec3f* v) {
* Spawns streaks of light from hits against solid objects
*/
void CollisionCheck_SpawnShieldParticles(GlobalContext* globalCtx, Vec3f* v) {
- static EffShieldParticleInit shieldParticleInitMetal = {
+ static EffectShieldParticleInit shieldParticleInitMetal = {
16,
{ 0, 0, 0 },
{ 0, 200, 255, 255 },
@@ -3889,7 +3889,7 @@ void CollisionCheck_SpawnShieldParticles(GlobalContext* globalCtx, Vec3f* v) {
shieldParticleInitMetal.lightPoint.y = shieldParticleInitMetal.position.y;
shieldParticleInitMetal.lightPoint.z = shieldParticleInitMetal.position.z;
- Effect_Add(globalCtx, &effectIndex, 3, 0, 1, &shieldParticleInitMetal);
+ Effect_Add(globalCtx, &effectIndex, EFFECT_SHIELD_PARTICLE, 0, 1, &shieldParticleInitMetal);
}
/**
@@ -3919,7 +3919,7 @@ void CollisionCheck_SpawnShieldParticlesMetal2(GlobalContext* globalCtx, Vec3f*
* Spawns streaks of light and makes a wooden sound
*/
void CollisionCheck_SpawnShieldParticlesWood(GlobalContext* globalCtx, Vec3f* v, Vec3f* pos) {
- static EffShieldParticleInit shieldParticleInitWood = {
+ static EffectShieldParticleInit shieldParticleInitWood = {
16,
{ 0, 0, 0 },
{ 0, 200, 255, 255 },
@@ -3944,7 +3944,7 @@ void CollisionCheck_SpawnShieldParticlesWood(GlobalContext* globalCtx, Vec3f* v,
shieldParticleInitWood.lightPoint.y = shieldParticleInitWood.position.y;
shieldParticleInitWood.lightPoint.z = shieldParticleInitWood.position.z;
- Effect_Add(globalCtx, &effectIndex, 3, 0, 1, &shieldParticleInitWood);
+ Effect_Add(globalCtx, &effectIndex, EFFECT_SHIELD_PARTICLE, 0, 1, &shieldParticleInitWood);
func_8019F1C0(pos, NA_SE_IT_REFLECTION_WOOD);
}
diff --git a/src/code/z_debug_display.c b/src/code/z_debug_display.c
index a62d4ddb9..ab3478fa1 100644
--- a/src/code/z_debug_display.c
+++ b/src/code/z_debug_display.c
@@ -116,7 +116,7 @@ void func_800E992C(GlobalContext* globalCtx, s32 arg1) {
OPEN_DISPS(globalCtx->state.gfxCtx);
func_8012C560(globalCtx->state.gfxCtx);
- gSPMatrix(POLY_XLU_DISP++, &D_801D1DE0, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+ gSPMatrix(POLY_XLU_DISP++, &gIdentityMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPDisplayList(POLY_XLU_DISP++, func_800E99B0(globalCtx->state.gfxCtx, arg1));
CLOSE_DISPS(globalCtx->state.gfxCtx);
diff --git a/src/code/z_eff_blure.c b/src/code/z_eff_blure.c
index 17685de15..887534366 100644
--- a/src/code/z_eff_blure.c
+++ b/src/code/z_eff_blure.c
@@ -1,27 +1,18 @@
#include "global.h"
-#ifdef NON_MATCHING
-void func_800A81F0(EffectBlure* this, Vec3f* p1, Vec3f* p2) {
+void EffectBlure_AddVertex(EffectBlure* this, Vec3f* p1, Vec3f* p2) {
EffectBlureElement* elem;
s32 numElements;
- Vec3f sp16C;
- Vec3f sp160;
- Vec3f sp154;
- f32 scale;
- MtxF sp110;
- MtxF spD0;
- MtxF sp90;
- MtxF sp50;
- Vec3f sp44;
- Vec3f sp38;
+
+ if (this) {}
+ if (this) {}
if (this != NULL) {
- numElements = this->numElements;
- if (numElements >= 16) {
+ if (this->numElements >= ARRAY_COUNT(this->elements)) {
return;
}
- elem = &this->elements[numElements];
+ elem = &this->elements[this->numElements];
elem->state = 1;
if (!(this->flags & 2)) {
@@ -32,6 +23,17 @@ void func_800A81F0(EffectBlure* this, Vec3f* p1, Vec3f* p2) {
elem->p2.y = p2->y;
elem->p2.z = p2->z;
} else {
+ Vec3f sp16C;
+ Vec3f sp160;
+ Vec3f sp154;
+ f32 scale;
+ MtxF sp110;
+ MtxF spD0;
+ MtxF sp90;
+ MtxF sp50;
+ Vec3f sp44;
+ Vec3f sp38;
+
sp16C.x = ((f32)(elem - 1)->p2.x + (f32)(elem - 1)->p1.x) * 0.5f;
sp16C.y = ((f32)(elem - 1)->p2.y + (f32)(elem - 1)->p1.y) * 0.5f;
sp16C.z = ((f32)(elem - 1)->p2.z + (f32)(elem - 1)->p1.z) * 0.5f;
@@ -41,7 +43,7 @@ void func_800A81F0(EffectBlure* this, Vec3f* p1, Vec3f* p2) {
Math_Vec3f_Diff(&sp160, &sp16C, &sp154);
scale = Math3D_Vec3fMagnitude(&sp154);
- if (!(fabsf(scale) < D_801DC080)) {
+ if (!(fabsf(scale) < 0.008f)) {
scale = 1.0f / scale;
Math_Vec3f_Scale(&sp154, scale);
@@ -66,40 +68,977 @@ void func_800A81F0(EffectBlure* this, Vec3f* p1, Vec3f* p2) {
this->numElements++;
}
}
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800A81F0.s")
-#endif
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800A8514.s")
+void EffectBlure_AddSpace(EffectBlure* this) {
+ EffectBlureElement* elem;
+ s32 numElements;
+
+ if (this != NULL) {
+ numElements = this->numElements;
+ if (numElements >= ARRAY_COUNT(this->elements)) {
+ return;
+ }
+
+ elem = &this->elements[numElements];
+ elem->state = 0;
+ elem->timer = 1;
+
+ this->numElements++;
+ }
+}
+
+void EffectBlure_InitElements(EffectBlure* this) {
+ EffectBlureElement* elem;
+ s32 i;
+
+ this->numElements = 0;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/EffectBlure_Initcommon.s")
+ for (i = 0; i < ARRAY_COUNT(this->elements); i++) {
+ elem = &this->elements[i];
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/EffectBlure_Init1.s")
+ elem->state = 2;
+ elem->p1.x = 0;
+ elem->p1.y = 0;
+ elem->p1.z = 0;
+ elem->p2.x = 0;
+ elem->p2.y = 0;
+ elem->p2.z = 0;
+ elem->timer = 0;
+ elem->flags = 0;
+ }
+}
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/EffectBlure_Init2.s")
+void EffectBlure_Init1(void* thisx, void* initParamsx) {
+ EffectBlure* this = (EffectBlure*)thisx;
+ EffectBlureInit1* initParams = (EffectBlureInit1*)initParamsx;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/EffectBlure_Destroy.s")
+ if ((this != NULL) && (initParams != NULL)) {
+ EffectBlure_InitElements(this);
+ this->p1StartColor.r = initParams->p1StartColor[0];
+ this->p2StartColor.r = initParams->p2StartColor[0];
+ this->p1EndColor.r = initParams->p1EndColor[0];
+ this->p2EndColor.r = initParams->p2EndColor[0];
+ this->p1StartColor.g = initParams->p1StartColor[1];
+ this->p2StartColor.g = initParams->p2StartColor[1];
+ this->p1EndColor.g = initParams->p1EndColor[1];
+ this->p2EndColor.g = initParams->p2EndColor[1];
+ this->p1StartColor.b = initParams->p1StartColor[2];
+ this->p2StartColor.b = initParams->p2StartColor[2];
+ this->p1EndColor.b = initParams->p1EndColor[2];
+ this->p2EndColor.b = initParams->p2EndColor[2];
+ this->p1StartColor.a = initParams->p1StartColor[3];
+ this->p2StartColor.a = initParams->p2StartColor[3];
+ this->p1EndColor.a = initParams->p1EndColor[3];
+ this->p2EndColor.a = initParams->p2EndColor[3];
+ this->elemDuration = initParams->elemDuration;
+ this->unkFlag = initParams->unkFlag;
+ this->calcMode = initParams->calcMode;
+ this->flags = 0;
+ this->addAngleChange = 0;
+ this->addAngle = 0;
+ this->drawMode = 0;
+ this->altPrimColor.r = 0;
+ this->altPrimColor.g = 0;
+ this->altPrimColor.b = 0;
+ this->altPrimColor.a = 0;
+ this->altEnvColor.r = 0;
+ this->altEnvColor.g = 0;
+ this->altEnvColor.b = 0;
+ this->altEnvColor.a = 0;
+ this->mode4Param = 1.0f;
+ }
+}
+
+void EffectBlure_Init2(void* thisx, void* initParamsx) {
+ EffectBlure* this = (EffectBlure*)thisx;
+ EffectBlureInit2* initParams = (EffectBlureInit2*)initParamsx;
+
+ if ((this != NULL) && (initParams != NULL)) {
+ EffectBlure_InitElements(this);
+ this->p1StartColor.r = initParams->p1StartColor[0];
+ this->p2StartColor.r = initParams->p2StartColor[0];
+ this->p1EndColor.r = initParams->p1EndColor[0];
+ this->p2EndColor.r = initParams->p2EndColor[0];
+ this->p1StartColor.g = initParams->p1StartColor[1];
+ this->p2StartColor.g = initParams->p2StartColor[1];
+ this->p1EndColor.g = initParams->p1EndColor[1];
+ this->p2EndColor.g = initParams->p2EndColor[1];
+ this->p1StartColor.b = initParams->p1StartColor[2];
+ this->p2StartColor.b = initParams->p2StartColor[2];
+ this->p1EndColor.b = initParams->p1EndColor[2];
+ this->p2EndColor.b = initParams->p2EndColor[2];
+ this->p1StartColor.a = initParams->p1StartColor[3];
+ this->p2StartColor.a = initParams->p2StartColor[3];
+ this->p1EndColor.a = initParams->p1EndColor[3];
+ this->p2EndColor.a = initParams->p2EndColor[3];
+ this->elemDuration = initParams->elemDuration;
+ this->unkFlag = initParams->unkFlag;
+ this->calcMode = initParams->calcMode;
+ this->flags = initParams->flags;
+ this->drawMode = initParams->drawMode;
+ this->addAngleChange = initParams->addAngleChange;
+ this->addAngle = 0;
+ this->mode4Param = initParams->mode4Param;
+ this->altPrimColor = initParams->altPrimColor;
+ this->altEnvColor = initParams->altEnvColor;
+ }
+}
+
+void EffectBlure_Destroy(void* thisx) {
+}
+
+s32 EffectBlure_Update(void* thisx) {
+ EffectBlure* this = (EffectBlure*)thisx;
+ s32 i;
+
+ if (this == NULL) {
+ return 0;
+ }
+
+ if (this->numElements == 0) {
+ return 0;
+ }
+
+ while (true) {
+ if (this->elements[0].state == 0) {
+ for (i = 0; i < ARRAY_COUNT(this->elements) - 1; i++) {
+ this->elements[i] = this->elements[i + 1];
+ }
+
+ this->elements[i].state = 2;
+ this->elements[i].p1.x = 0;
+ this->elements[i].p1.y = 0;
+ this->elements[i].p1.z = 0;
+ this->elements[i].p2.x = 0;
+ this->elements[i].p2.y = 0;
+ this->elements[i].p2.z = 0;
+ this->elements[i].flags = 0;
+ this->elements[i].timer = 0;
+
+ this->numElements--;
+ if (this->numElements <= 0) {
+ this->numElements = 0;
+ return 0;
+ }
+ } else {
+ break;
+ }
+ }
+
+ if (this->elements[0].state == 2) {
+ return 0;
+ }
+
+ for (i = 0; i < this->numElements; i++) {
+ this->elements[i].timer++;
+ }
+
+ if (this->elemDuration < this->elements[0].timer) {
+ for (i = 0; i < ARRAY_COUNT(this->elements) - 1; i++) {
+ this->elements[i] = this->elements[i + 1];
+ if (this->elements[i].timer >= this->elemDuration) {
+ this->elements[i].timer = this->elemDuration;
+ }
+ }
+
+ this->elements[i].state = 2;
+ this->elements[i].p1.x = 0;
+ this->elements[i].p1.y = 0;
+ this->elements[i].p1.z = 0;
+ this->elements[i].p2.x = 0;
+ this->elements[i].p2.y = 0;
+ this->elements[i].p2.z = 0;
+ this->elements[i].flags = 0;
+ this->elements[i].timer = 0;
+
+ this->numElements--;
+ if (this->numElements <= 0) {
+ this->numElements = 0;
+ return 0;
+ }
+ return 0;
+ }
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/EffectBlure_Update.s")
+ for (i = 0; i < this->numElements; i++) {
+ if (this->elements[i].timer >= this->elemDuration) {
+ this->elements[i].timer = this->elemDuration;
+ }
+ }
+
+ this->addAngle += this->addAngleChange;
+ return 0;
+}
+
+void EffectBlure_UpdateFlags(EffectBlureElement* elem) {
+ Vec3f sp64;
+ Vec3f sp58;
+ Vec3f sp4C;
+ Vec3f sp40;
+ EffectBlureElement* prev = elem - 1;
+ EffectBlureElement* next = elem + 1;
+ f32 sp34;
+ f32 sp30;
+ f32 sp2C;
+
+ if (((elem - 1)->state == 0) || ((elem + 1)->state == 0)) {
+ elem->flags &= ~3;
+ elem->flags |= 2;
+ } else {
+ Math_Vec3s_DiffToVec3f(&sp64, &elem->p1, &prev->p1);
+ Math_Vec3s_DiffToVec3f(&sp58, &elem->p2, &prev->p2);
+ Math_Vec3s_DiffToVec3f(&sp4C, &next->p1, &elem->p1);
+ Math_Vec3s_DiffToVec3f(&sp40, &next->p2, &elem->p2);
+
+ if (Math3D_AngleBetweenVectors(&sp64, &sp4C, &sp34) || Math3D_AngleBetweenVectors(&sp58, &sp40, &sp30) ||
+ Math3D_AngleBetweenVectors(&sp4C, &sp40, &sp2C)) {
+ elem->flags &= ~3;
+ elem->flags |= 0;
+ } else if ((sp34 <= -0.5f) || (sp30 <= -0.5f) || (sp2C <= 0.7071f)) {
+ elem->flags &= ~3;
+ elem->flags |= 0;
+ } else {
+ elem->flags &= ~3;
+ elem->flags |= 1;
+ }
+ }
+}
+
+void EffectBlure_GetComputedValues(EffectBlure* this, s32 index, f32 ratio, Vec3s* vec1, Vec3s* vec2,
+ Color_RGBA8* color1, Color_RGBA8* color2) {
+ Vec3s sp30;
+ f32 mode4Param;
+ EffectBlureElement* elem = &this->elements[index];
+
+ switch (this->calcMode) {
+ case 1:
+ vec1->x = func_800B09D0(elem->p1.x, elem->p2.x, ratio);
+ vec1->y = func_800B09D0(elem->p1.y, elem->p2.y, ratio);
+ vec1->z = func_800B09D0(elem->p1.z, elem->p2.z, ratio);
+ vec2->x = elem->p2.x;
+ vec2->y = elem->p2.y;
+ vec2->z = elem->p2.z;
+ break;
+
+ case 2:
+ vec1->x = elem->p1.x;
+ vec1->y = elem->p1.y;
+ vec1->z = elem->p1.z;
+ vec2->x = func_800B09D0(elem->p2.x, elem->p1.x, ratio);
+ vec2->y = func_800B09D0(elem->p2.y, elem->p1.y, ratio);
+ vec2->z = func_800B09D0(elem->p2.z, elem->p1.z, ratio);
+ break;
+
+ case 3:
+ ratio *= 0.5f;
+ vec1->x = func_800B09D0(elem->p1.x, elem->p2.x, ratio);
+ vec1->y = func_800B09D0(elem->p1.y, elem->p2.y, ratio);
+ vec1->z = func_800B09D0(elem->p1.z, elem->p2.z, ratio);
+ vec2->x = func_800B09D0(elem->p2.x, elem->p1.x, ratio);
+ vec2->y = func_800B09D0(elem->p2.y, elem->p1.y, ratio);
+ vec2->z = func_800B09D0(elem->p2.z, elem->p1.z, ratio);
+ ratio *= 2.0f;
+ break;
+
+ case 4:
+ sp30.x = elem->p1.x - elem->p2.x;
+ sp30.y = elem->p1.y - elem->p2.y;
+ sp30.z = elem->p1.z - elem->p2.z;
+ mode4Param = this->mode4Param - 1.0f;
+
+ vec1->x = (sp30.x * 0.5f * mode4Param * ratio) + elem->p1.x;
+ vec1->y = (sp30.y * 0.5f * mode4Param * ratio) + elem->p1.y;
+ if (1) {} // Necessary to match
+ vec1->z = (sp30.z * 0.5f * mode4Param * ratio) + elem->p1.z;
+
+ vec2->x = -(sp30.x * 0.5f * mode4Param * ratio) + elem->p2.x;
+ vec2->y = -(sp30.y * 0.5f * mode4Param * ratio) + elem->p2.y;
+ vec2->z = -(sp30.z * 0.5f * mode4Param * ratio) + elem->p2.z;
+ break;
+
+ case 0:
+ default:
+ vec1->x = elem->p1.x;
+ vec1->y = elem->p1.y;
+ vec1->z = elem->p1.z;
+ vec2->x = elem->p2.x;
+ vec2->y = elem->p2.y;
+ vec2->z = elem->p2.z;
+ break;
+ }
+
+ sp30 = sp30; // Optimized out but seems necessary to match stack usage
+
+ if (this->flags & 0x10) {
+ color1->r = color1->g = color1->b = color1->a = 255;
+ color2->r = color2->g = color2->b = color2->a = 255;
+ } else {
+ color1->r = func_800B0A24(this->p1StartColor.r, this->p1EndColor.r, ratio);
+ color1->g = func_800B0A24(this->p1StartColor.g, this->p1EndColor.g, ratio);
+ color1->b = func_800B0A24(this->p1StartColor.b, this->p1EndColor.b, ratio);
+ color1->a = func_800B0A24(this->p1StartColor.a, this->p1EndColor.a, ratio);
+ color2->r = func_800B0A24(this->p2StartColor.r, this->p2EndColor.r, ratio);
+ color2->g = func_800B0A24(this->p2StartColor.g, this->p2EndColor.g, ratio);
+ color2->b = func_800B0A24(this->p2StartColor.b, this->p2EndColor.b, ratio);
+ color2->a = func_800B0A24(this->p2StartColor.a, this->p2EndColor.a, ratio);
+ }
+}
+
+void EffectBlure_SetupSmooth(EffectBlure* this, GraphicsContext* gfxCtx) {
+ OPEN_DISPS(gfxCtx);
+
+ POLY_XLU_DISP = Gfx_CallSetupDL(POLY_XLU_DISP, 0x26);
+
+ CLOSE_DISPS(gfxCtx);
+}
+
+void EffectBlure_DrawElemNoInterpolation(EffectBlure* this, EffectBlureElement* elem, s32 index,
+ GraphicsContext* gfxCtx) {
+ static Vtx_t baseVtx = VTX_T(0, 0, 0, 0, 0, 255, 255, 255, 255);
+ Vtx* vtx;
+ Vec3s sp8C;
+ Vec3s sp84;
+ f32 ratio;
+ Color_RGBA8 sp7C;
+ Color_RGBA8 sp78;
+ Vec3f sp6C;
+ Vec3f sp60;
+ Vec3f sp54;
+
+ OPEN_DISPS(gfxCtx);
+
+ Math_Vec3s_ToVec3f(&sp6C, &this->elements[0].p2);
+
+ vtx = GRAPH_ALLOC(gfxCtx, sizeof(Vtx[4]));
+ if (vtx == NULL) {
+ } else {
+ vtx[0].v = baseVtx;
+ vtx[1].v = baseVtx;
+ vtx[2].v = baseVtx;
+ vtx[3].v = baseVtx;
+
+ ratio = (f32)elem->timer / (f32)this->elemDuration;
+ EffectBlure_GetComputedValues(this, index, ratio, &sp8C, &sp84, &sp7C, &sp78);
+
+ sp60.x = sp84.x;
+ sp60.y = sp84.y;
+ sp60.z = sp84.z;
+ Math_Vec3f_Diff(&sp60, &sp6C, &sp54);
+ Math_Vec3f_Scale(&sp54, 10.0f);
+ vtx[0].v.ob[0] = sp54.x;
+ vtx[0].v.ob[1] = sp54.y;
+ vtx[0].v.ob[2] = sp54.z;
+ vtx[0].v.cn[0] = sp78.r;
+ vtx[0].v.cn[1] = sp78.g;
+ vtx[0].v.cn[2] = sp78.b;
+ vtx[0].v.cn[3] = sp78.a;
+
+ sp60.x = sp8C.x;
+ sp60.y = sp8C.y;
+ sp60.z = sp8C.z;
+ Math_Vec3f_Diff(&sp60, &sp6C, &sp54);
+ Math_Vec3f_Scale(&sp54, 10.0f);
+ vtx[1].v.ob[0] = sp54.x;
+ vtx[1].v.ob[1] = sp54.y;
+ vtx[1].v.ob[2] = sp54.z;
+ vtx[1].v.cn[0] = sp7C.r;
+ vtx[1].v.cn[1] = sp7C.g;
+ vtx[1].v.cn[2] = sp7C.b;
+ vtx[1].v.cn[3] = sp7C.a;
+
+ ratio = (f32)(elem + 1)->timer / (f32)this->elemDuration;
+ EffectBlure_GetComputedValues(this, index + 1, ratio, &sp8C, &sp84, &sp7C, &sp78);
+
+ sp60.x = sp8C.x;
+ sp60.y = sp8C.y;
+ sp60.z = sp8C.z;
+ Math_Vec3f_Diff(&sp60, &sp6C, &sp54);
+ Math_Vec3f_Scale(&sp54, 10.0f);
+ vtx[2].v.ob[0] = sp54.x;
+ vtx[2].v.ob[1] = sp54.y;
+ vtx[2].v.ob[2] = sp54.z;
+ vtx[2].v.cn[0] = sp7C.r;
+ vtx[2].v.cn[1] = sp7C.g;
+ vtx[2].v.cn[2] = sp7C.b;
+ vtx[2].v.cn[3] = sp7C.a;
+
+ sp60.x = sp84.x;
+ sp60.y = sp84.y;
+ sp60.z = sp84.z;
+ Math_Vec3f_Diff(&sp60, &sp6C, &sp54);
+ Math_Vec3f_Scale(&sp54, 10.0f);
+ vtx[3].v.ob[0] = sp54.x;
+ vtx[3].v.ob[1] = sp54.y;
+ vtx[3].v.ob[2] = sp54.z;
+ vtx[3].v.cn[0] = sp78.r;
+ vtx[3].v.cn[1] = sp78.g;
+ vtx[3].v.cn[2] = sp78.b;
+ vtx[3].v.cn[3] = sp78.a;
+
+ gSPVertex(POLY_XLU_DISP++, vtx, 4, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 0, 1, 2, 0, 0, 2, 3, 0);
+ }
+
+ CLOSE_DISPS(gfxCtx);
+}
+
+void EffectBlure_DrawElemHermiteInterpolation(EffectBlure* this, EffectBlureElement* elem, s32 index,
+ GraphicsContext* gfxCtx) {
+ static Vtx_t baseVtx = VTX_T(0, 0, 0, 0, 0, 255, 255, 255, 255);
+ Vtx* vtx;
+ Vec3s sp1EC;
+ Vec3s sp1E4;
+ f32 ratio;
+ Color_RGBA8 sp1DC;
+ Color_RGBA8 sp1D8;
+ Vec3f sp1CC;
+ Vec3f sp1C0;
+ Vec3f sp1B4;
+ Vec3f sp1A8;
+ Color_RGBA8 sp1A4;
+ Color_RGBA8 sp1A0;
+ Color_RGBA8 sp19C;
+ Color_RGBA8 sp198;
+ Vec3f sp18C;
+ Vec3f sp180;
+ Vec3f sp174;
+ Vec3f sp168;
+ s32 i;
+ Vec3f sp158;
+ Vec3f sp14C;
+ Color_RGBA8 sp148;
+ Color_RGBA8 sp144;
+ Vec3f sp138;
+
+ OPEN_DISPS(gfxCtx);
+
+ Math_Vec3s_ToVec3f(&sp138, &this->elements[0].p2);
+
+ ratio = (f32)elem->timer / (f32)this->elemDuration;
+ EffectBlure_GetComputedValues(this, index, ratio, &sp1EC, &sp1E4, &sp1A4, &sp1A0);
+ Math_Vec3s_ToVec3f(&sp1CC, &sp1EC);
+ Math_Vec3s_ToVec3f(&sp1C0, &sp1E4);
+
+ ratio = (f32)(elem + 1)->timer / (f32)this->elemDuration;
+ EffectBlure_GetComputedValues(this, index + 1, ratio, &sp1EC, &sp1E4, &sp19C, &sp198);
+ Math_Vec3s_ToVec3f(&sp18C, &sp1EC);
+ Math_Vec3s_ToVec3f(&sp180, &sp1E4);
+
+ if ((elem->flags & 3) == 2) {
+ Math_Vec3f_Diff(&sp18C, &sp1CC, &sp1B4);
+ Math_Vec3f_Diff(&sp180, &sp1C0, &sp1A8);
+ } else {
+ Vec3f sp118;
+ Vec3f sp10C;
+
+ ratio = (f32)(elem - 1)->timer / (f32)this->elemDuration;
+ EffectBlure_GetComputedValues(this, index - 1, ratio, &sp1EC, &sp1E4, &sp1DC, &sp1D8);
+ Math_Vec3s_ToVec3f(&sp118, &sp1EC);
+ Math_Vec3s_ToVec3f(&sp10C, &sp1E4);
+ Math_Vec3f_Diff(&sp18C, &sp118, &sp1B4);
+ Math_Vec3f_Diff(&sp180, &sp10C, &sp1A8);
+ }
+
+ Math_Vec3f_Scale(&sp1B4, 0.5f);
+ Math_Vec3f_Scale(&sp1A8, 0.5f);
+
+ if (((elem + 1)->flags & 3) == 2) {
+ Math_Vec3f_Diff(&sp18C, &sp1CC, &sp174);
+ Math_Vec3f_Diff(&sp180, &sp1C0, &sp168);
+ } else {
+ Vec3f sp100;
+ Vec3f spF4;
+
+ ratio = (f32)(elem + 2)->timer / (f32)this->elemDuration;
+ EffectBlure_GetComputedValues(this, index + 2, ratio, &sp1EC, &sp1E4, &sp1DC, &sp1D8);
+ Math_Vec3s_ToVec3f(&sp100, &sp1EC);
+ Math_Vec3s_ToVec3f(&spF4, &sp1E4);
+ Math_Vec3f_Diff(&sp100, &sp1CC, &sp174);
+ Math_Vec3f_Diff(&spF4, &sp1C0, &sp168);
+ }
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800A8C78.s")
+ Math_Vec3f_Scale(&sp174, 0.5f);
+ Math_Vec3f_Scale(&sp168, 0.5f);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800A8DE8.s")
+ vtx = GRAPH_ALLOC(gfxCtx, sizeof(Vtx[16]));
+ if (vtx == NULL) {
+ } else {
+ Math_Vec3f_Diff(&sp1CC, &sp138, &sp158);
+ Math_Vec3f_Scale(&sp158, 10.0f);
+ Math_Vec3f_Diff(&sp1C0, &sp138, &sp14C);
+ Math_Vec3f_Scale(&sp14C, 10.0f);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800A92FC.s")
+ Color_RGBA8_Copy(&sp148, &sp1A4);
+ Color_RGBA8_Copy(&sp144, &sp1A0);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800A9330.s")
+ vtx[0].v = baseVtx;
+ vtx[1].v = baseVtx;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800A9804.s")
+ vtx[0].v.ob[0] = func_80086814(sp158.x);
+ vtx[0].v.ob[1] = func_80086814(sp158.y);
+ vtx[0].v.ob[2] = func_80086814(sp158.z);
+ vtx[0].v.cn[0] = sp148.r;
+ vtx[0].v.cn[1] = sp148.g;
+ vtx[0].v.cn[2] = sp148.b;
+ vtx[0].v.cn[3] = sp148.a;
+ vtx[1].v.ob[0] = func_80086814(sp14C.x);
+ vtx[1].v.ob[1] = func_80086814(sp14C.y);
+ vtx[1].v.ob[2] = func_80086814(sp14C.z);
+ vtx[1].v.cn[0] = sp144.r;
+ vtx[1].v.cn[1] = sp144.g;
+ vtx[1].v.cn[2] = sp144.b;
+ vtx[1].v.cn[3] = sp144.a;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800AA190.s")
+ for (i = 1; i < 8; i++) {
+ s32 j1 = 2 * i;
+ s32 j2 = 2 * i + 1;
+ Vec3f spE0;
+ f32 temp_f28 = i / 7.0f; // t
+ f32 temp_f0 = SQ(temp_f28); // t^2
+ f32 temp_f2 = temp_f0 * temp_f28; // t^3
+ f32 temp_f20 = temp_f2 - temp_f0; // t^3 - t^2
+ f32 temp_f22 = temp_f2 - 2.0f * temp_f0 + temp_f28; // t^3 - 2t^2 + t
+ f32 temp_f24 = 2.0f * temp_f2 - temp_f0 * 3.0f + 1.0f; // 2t^3 - 3t^2 + 1
+ f32 temp_f26 = temp_f0 * 3.0f - 2.0f * temp_f2; // 3t^2 - 2t^3
+ s32 pad1;
+ s32 pad2;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800AA460.s")
+ // p = (2t^3 - 3t^2 + 1)p0 + (3t^2 - 2t^3)p1 + (t^3 - 2t^2 + t)m0 + (t^3 - t^2)m1
+ spE0.x = (temp_f24 * sp1CC.x) + (temp_f26 * sp18C.x) + (temp_f22 * sp1B4.x) + (temp_f20 * sp174.x);
+ spE0.y = (temp_f24 * sp1CC.y) + (temp_f26 * sp18C.y) + (temp_f22 * sp1B4.y) + (temp_f20 * sp174.y);
+ spE0.z = (temp_f24 * sp1CC.z) + (temp_f26 * sp18C.z) + (temp_f22 * sp1B4.z) + (temp_f20 * sp174.z);
+ Math_Vec3f_Diff(&spE0, &sp138, &sp158);
+ Math_Vec3f_Scale(&sp158, 10.0f);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800AA498.s")
+ spE0.x = (temp_f24 * sp1C0.x) + (temp_f26 * sp180.x) + (temp_f22 * sp1A8.x) + (temp_f20 * sp168.x);
+ spE0.y = (temp_f24 * sp1C0.y) + (temp_f26 * sp180.y) + (temp_f22 * sp1A8.y) + (temp_f20 * sp168.y);
+ spE0.z = (temp_f24 * sp1C0.z) + (temp_f26 * sp180.z) + (temp_f22 * sp1A8.z) + (temp_f20 * sp168.z);
+ Math_Vec3f_Diff(&spE0, &sp138, &sp14C);
+ Math_Vec3f_Scale(&sp14C, 10.0f);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800AA700.s")
+ vtx[j1].v = baseVtx;
+ vtx[j2].v = baseVtx;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_800AABE0.s")
+ vtx[j1].v.ob[0] = func_80086814(sp158.x);
+ vtx[j1].v.ob[1] = func_80086814(sp158.y);
+ vtx[j1].v.ob[2] = func_80086814(sp158.z);
+ vtx[j1].v.cn[0] = func_800B0A24(sp1A4.r, sp19C.r, temp_f28);
+ vtx[j1].v.cn[1] = func_800B0A24(sp1A4.g, sp19C.g, temp_f28);
+ vtx[j1].v.cn[2] = func_800B0A24(sp1A4.b, sp19C.b, temp_f28);
+ vtx[j1].v.cn[3] = func_800B0A24(sp1A4.a, sp19C.a, temp_f28);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/EffectBlure_Draw.s")
+ vtx[j2].v.ob[0] = func_80086814(sp14C.x);
+ vtx[j2].v.ob[1] = func_80086814(sp14C.y);
+ vtx[j2].v.ob[2] = func_80086814(sp14C.z);
+ vtx[j2].v.cn[0] = func_800B0A24(sp1A0.r, sp198.r, temp_f28);
+ vtx[j2].v.cn[1] = func_800B0A24(sp1A0.g, sp198.g, temp_f28);
+ vtx[j2].v.cn[2] = func_800B0A24(sp1A0.b, sp198.b, temp_f28);
+ vtx[j2].v.cn[3] = func_800B0A24(sp1A0.a, sp198.a, temp_f28);
+ }
+
+ gSPVertex(POLY_XLU_DISP++, vtx, 16, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 0, 1, 3, 0, 0, 3, 2, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 2, 3, 5, 0, 2, 5, 4, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 4, 5, 7, 0, 4, 7, 6, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 6, 7, 9, 0, 6, 9, 8, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 8, 9, 11, 0, 8, 11, 10, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 10, 11, 13, 0, 10, 13, 12, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 12, 13, 15, 0, 12, 15, 14, 0);
+ }
+
+ CLOSE_DISPS(gfxCtx);
+}
+
+void EffectBlure_DrawSmooth(EffectBlure* this2, GraphicsContext* gfxCtx) {
+ EffectBlure* this = this2;
+ EffectBlureElement* elem;
+ s32 i;
+ MtxF spDC;
+ MtxF sp9C;
+ MtxF sp5C;
+ Mtx* mtx;
+
+ OPEN_DISPS(gfxCtx);
+
+ if (this->numElements < 2) {
+ return;
+ }
+
+ this->elements[0].flags &= ~3;
+ this->elements[0].flags |= 2;
+
+ for (elem = &this->elements[1]; elem < this->elements + this->numElements - 1; elem++) {
+ EffectBlure_UpdateFlags(elem);
+ }
+
+ this->elements[this->numElements - 1].flags &= ~3;
+ this->elements[this->numElements - 1].flags |= 2;
+
+ EffectBlure_SetupSmooth(this, gfxCtx);
+ SkinMatrix_SetTranslate(&spDC, this->elements[0].p2.x, this->elements[0].p2.y, this->elements[0].p2.z);
+ SkinMatrix_SetScale(&sp9C, 0.1f, 0.1f, 0.1f);
+ SkinMatrix_MtxFMtxFMult(&spDC, &sp9C, &sp5C);
+
+ mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &sp5C);
+ if (mtx == NULL) {
+ return;
+ }
+
+ gSPMatrix(POLY_XLU_DISP++, mtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+
+ for (i = 0, elem = &this->elements[0]; elem < this->elements + this->numElements - 1; i++, elem++) {
+ if ((elem->state == 0) || ((elem + 1)->state == 0)) {
+ continue;
+ }
+ if ((((elem->flags & 3) == 0) && (((elem + 1)->flags & 3) == 0)) ||
+ (((elem->flags & 3) == 2) && (((elem + 1)->flags & 3) == 0)) ||
+ (((elem->flags & 3) == 0) && (((elem + 1)->flags & 3) == 2)) ||
+ (((elem->flags & 3) == 2) && (((elem + 1)->flags & 3) == 2))) {
+ EffectBlure_DrawElemNoInterpolation(this, elem, i, gfxCtx);
+ } else {
+ EffectBlure_DrawElemHermiteInterpolation(this, elem, i, gfxCtx);
+ }
+ }
+
+ CLOSE_DISPS(gfxCtx);
+}
+
+void EffectBlure_SetupSimple(GraphicsContext* gfxCtx, EffectBlure* this, Vtx* vtx) {
+ OPEN_DISPS(gfxCtx);
+
+ POLY_XLU_DISP = Gfx_CallSetupDL(POLY_XLU_DISP, 0x26);
+
+ CLOSE_DISPS(gfxCtx);
+}
+
+void EffectBlure_SetupSimpleAlt(GraphicsContext* gfxCtx, EffectBlure* this, Vtx* vtx) {
+ OPEN_DISPS(gfxCtx);
+
+ gDPPipeSync(POLY_XLU_DISP++);
+ POLY_XLU_DISP = Gfx_CallSetupDL(POLY_XLU_DISP, 0x26);
+
+ gDPSetCycleType(POLY_XLU_DISP++, G_CYC_2CYCLE);
+ gDPSetTextureLUT(POLY_XLU_DISP++, G_TT_NONE);
+ gSPTexture(POLY_XLU_DISP++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
+
+ gDPLoadTextureBlock(POLY_XLU_DISP++, D_04014570, G_IM_FMT_I, G_IM_SIZ_8b, 64, 32, 0, G_TX_NOMIRROR | G_TX_CLAMP,
+ G_TX_NOMIRROR | G_TX_WRAP, 6, 5, G_TX_NOLOD, G_TX_NOLOD);
+
+ gDPSetCombineLERP(POLY_XLU_DISP++, TEXEL0, PRIMITIVE, PRIM_LOD_FRAC, TEXEL0, TEXEL0, 0, PRIMITIVE, 0, PRIMITIVE,
+ ENVIRONMENT, COMBINED, ENVIRONMENT, 0, 0, 0, COMBINED);
+ gDPSetRenderMode(POLY_XLU_DISP++, G_RM_PASS, G_RM_ZB_CLD_SURF2);
+ gSPClearGeometryMode(POLY_XLU_DISP++, G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR);
+ gSPSetGeometryMode(POLY_XLU_DISP++, G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH);
+ gDPPipeSync(POLY_XLU_DISP++);
+
+ gDPSetEnvColor(POLY_XLU_DISP++, this->altEnvColor.r, this->altEnvColor.g, this->altEnvColor.b, this->altEnvColor.a);
+
+ CLOSE_DISPS(gfxCtx);
+}
+
+void (*sSetupHandlers[])(GraphicsContext* gfxCtx, EffectBlure* this, Vtx* vtx) = {
+ EffectBlure_SetupSimple,
+ EffectBlure_SetupSimpleAlt,
+};
+
+s32 D_801AE268 = 0; // unused
+
+void EffectBlure_DrawSimpleVertices(GraphicsContext* gfxCtx, EffectBlure* this, Vtx* vtx) {
+ Mtx* mtx;
+
+ OPEN_DISPS(gfxCtx);
+
+ sSetupHandlers[this->drawMode](gfxCtx, this, vtx);
+ gDPPipeSync(POLY_XLU_DISP++);
+
+ {
+ Vec3f sp1B0;
+ Vec3f sp1A4;
+ Vec3f sp198;
+ f32 alphaRatio;
+ MtxF sp154;
+ MtxF sp114;
+ MtxF spD4;
+ MtxF sp94;
+ f32 scale;
+ s32 i;
+ s32 j;
+
+ j = 0;
+
+ for (i = 0; i < this->numElements - 1; i++) {
+ if (this->drawMode == 1) {
+ alphaRatio = (f32)this->elements[i].timer / (f32)this->elemDuration;
+ gDPSetPrimColor(POLY_XLU_DISP++, 0x00, 0x80, this->altPrimColor.r, this->altPrimColor.g,
+ this->altPrimColor.b, this->altPrimColor.a * (1.0f - alphaRatio));
+ gDPPipeSync(POLY_XLU_DISP++);
+ }
+
+ if (1) {} // Necessary to match
+
+ gSPVertex(POLY_XLU_DISP++, &vtx[j], 4, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 0, 1, 3, 0, 0, 3, 2, 0);
+
+ if (this->flags & 4) {
+ sp1B0.x = ((f32)vtx[4 * i + 0].v.ob[0] + (f32)vtx[4 * i + 1].v.ob[0]) * 0.5f;
+ sp1B0.y = ((f32)vtx[4 * i + 0].v.ob[1] + (f32)vtx[4 * i + 1].v.ob[1]) * 0.5f;
+ sp1B0.z = ((f32)vtx[4 * i + 0].v.ob[2] + (f32)vtx[4 * i + 1].v.ob[2]) * 0.5f;
+ sp1A4.x = ((f32)vtx[4 * i + 2].v.ob[0] + (f32)vtx[4 * i + 3].v.ob[0]) * 0.5f;
+ sp1A4.y = ((f32)vtx[4 * i + 2].v.ob[1] + (f32)vtx[4 * i + 3].v.ob[1]) * 0.5f;
+ sp1A4.z = ((f32)vtx[4 * i + 2].v.ob[2] + (f32)vtx[4 * i + 3].v.ob[2]) * 0.5f;
+
+ Math_Vec3f_Diff(&sp1A4, &sp1B0, &sp198);
+ scale = sqrtf(SQXYZ(sp198));
+
+ if (fabsf(scale) > 0.0005f) {
+ scale = 1.0f / scale;
+ Math_Vec3f_Scale(&sp198, scale);
+
+ SkinMatrix_SetTranslate(&sp154, sp1B0.x, sp1B0.y, sp1B0.z);
+ SkinMatrix_SetRotateAroundVec(&sp114, 0x3FFF, sp198.x, sp198.y, sp198.z);
+ SkinMatrix_MtxFMtxFMult(&sp154, &sp114, &spD4);
+ SkinMatrix_SetTranslate(&sp154, -sp1B0.x, -sp1B0.y, -sp1B0.z);
+ SkinMatrix_MtxFMtxFMult(&spD4, &sp154, &sp94);
+
+ mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &sp94);
+ if (mtx == NULL) {
+ break;
+ }
+
+ gSPMatrix(POLY_XLU_DISP++, mtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+ gSPVertex(POLY_XLU_DISP++, &vtx[j], 4, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 0, 1, 3, 0, 0, 3, 2, 0);
+ gSPMatrix(POLY_XLU_DISP++, &gIdentityMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+ }
+ }
+
+ j += 4;
+ }
+ }
+
+ CLOSE_DISPS(gfxCtx);
+}
+
+Vtx_t D_801AE26C[] = {
+ VTX_T(0, 0, 0, 0, 1024, 255, 255, 255, 255),
+ VTX_T(0, 0, 0, 0, 0, 255, 255, 255, 255),
+ VTX_T(0, 0, 0, 2048, 1024, 255, 255, 255, 255),
+ VTX_T(0, 0, 0, 2048, 0, 255, 255, 255, 255),
+};
+
+Vtx_t D_801AE2AC[] = {
+ VTX_T(0, 0, 0, 2048, 1024, 255, 255, 255, 255),
+ VTX_T(0, 0, 0, 2048, 0, 255, 255, 255, 255),
+ VTX_T(0, 0, 0, 2048, 1024, 255, 255, 255, 255),
+ VTX_T(0, 0, 0, 2048, 0, 255, 255, 255, 255),
+};
+
+void EffectBlure_DrawSimple(EffectBlure* this2, GraphicsContext* gfxCtx) {
+ EffectBlure* this = this2;
+ Vtx* vtx;
+ Vtx* vtxIter;
+ EffectBlureElement* elem;
+ s32 vtxCount;
+ s32 i;
+ s32 j;
+ Vec3s sp74;
+ Vec3s sp6C;
+ f32 ratio;
+ Color_RGBA8 sp64;
+ Color_RGBA8 sp60;
+
+ if (this->numElements >= 2) {
+ vtxCount = this->numElements * 4;
+
+ vtx = GRAPH_ALLOC(gfxCtx, ALIGN16(vtxCount * sizeof(Vtx)));
+ if (vtx == NULL) {
+ return;
+ }
+
+ vtxIter = vtx;
+ for (i = 0; i < 4; i++) {
+ vtxIter->v = D_801AE26C[i];
+ vtxIter++;
+ }
+
+ if (this->numElements >= 2) {
+ for (elem = this->elements; elem < this->elements + this->numElements - 2; elem++) {
+ for (i = 0; i < 4; i++) {
+ vtxIter->v = D_801AE2AC[i];
+ vtxIter++;
+ }
+ }
+ }
+
+ for (i = 0; i < this->numElements; i++) {
+ elem = &this->elements[i];
+
+ ratio = (f32)elem->timer / (f32)this->elemDuration;
+ EffectBlure_GetComputedValues(this, i, ratio, &sp74, &sp6C, &sp64, &sp60);
+
+ j = i * 4 - 2;
+ if (j >= 0) {
+ vtx[j].v.ob[0] = sp74.x;
+ vtx[j].v.ob[1] = sp74.y;
+ vtx[j].v.ob[2] = sp74.z;
+ vtx[j].v.cn[0] = sp64.r;
+ vtx[j].v.cn[1] = sp64.g;
+ vtx[j].v.cn[2] = sp64.b;
+ vtx[j].v.cn[3] = sp64.a;
+ }
+
+ j++;
+ if (j >= 0) {
+ vtx[j].v.ob[0] = sp6C.x;
+ vtx[j].v.ob[1] = sp6C.y;
+ vtx[j].v.ob[2] = sp6C.z;
+ vtx[j].v.cn[0] = sp60.r;
+ vtx[j].v.cn[1] = sp60.g;
+ vtx[j].v.cn[2] = sp60.b;
+ vtx[j].v.cn[3] = sp60.a;
+ }
+
+ j++;
+ if (vtxCount >= j) {
+ vtx[j].v.ob[0] = sp74.x;
+ vtx[j].v.ob[1] = sp74.y;
+ vtx[j].v.ob[2] = sp74.z;
+ vtx[j].v.cn[0] = sp64.r;
+ vtx[j].v.cn[1] = sp64.g;
+ vtx[j].v.cn[2] = sp64.b;
+ vtx[j].v.cn[3] = sp64.a;
+ }
+
+ j++;
+ if (vtxCount >= j) {
+ vtx[j].v.ob[0] = sp6C.x;
+ vtx[j].v.ob[1] = sp6C.y;
+ vtx[j].v.ob[2] = sp6C.z;
+ vtx[j].v.cn[0] = sp60.r;
+ vtx[j].v.cn[1] = sp60.g;
+ vtx[j].v.cn[2] = sp60.b;
+ vtx[j].v.cn[3] = sp60.a;
+ }
+ }
+
+ EffectBlure_DrawSimpleVertices(gfxCtx, this, vtx);
+ }
+}
+
+void EffectBlure_Draw(void* thisx, GraphicsContext* gfxCtx) {
+ EffectBlure* this = (EffectBlure*)thisx;
+ Vtx* vtx;
+ EffectBlureElement* elem;
+ s32 i;
+ s32 j;
+ s32 phi_t2;
+
+ OPEN_DISPS(gfxCtx);
+
+ gSPMatrix(POLY_XLU_DISP++, &gIdentityMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+
+ if (this->numElements != 0) {
+ if (this->flags == 0) {
+ func_8012C560(gfxCtx);
+ gDPPipeSync(POLY_XLU_DISP++);
+
+ vtx = GRAPH_ALLOC(gfxCtx, sizeof(Vtx[32]));
+ if (vtx == NULL) {
+ } else {
+ j = 0;
+ for (i = 0; i < this->numElements; i++) {
+ elem = &this->elements[i];
+
+ if (elem->state == 1) {
+ f32 ratio = (f32)elem->timer / (f32)this->elemDuration;
+
+ switch (this->calcMode) {
+ case 1:
+ vtx[j].v.ob[0] = func_800B09D0(elem->p1.x, elem->p2.x, ratio);
+ vtx[j].v.ob[1] = func_800B09D0(elem->p1.y, elem->p2.y, ratio);
+ vtx[j].v.ob[2] = func_800B09D0(elem->p1.z, elem->p2.z, ratio);
+ vtx[j + 1].v.ob[0] = elem->p2.x;
+ vtx[j + 1].v.ob[1] = elem->p2.y;
+ vtx[j + 1].v.ob[2] = elem->p2.z;
+ break;
+ case 2:
+ vtx[j].v.ob[0] = elem->p1.x;
+ vtx[j].v.ob[1] = elem->p1.y;
+ vtx[j].v.ob[2] = elem->p1.z;
+ vtx[j + 1].v.ob[0] = func_800B09D0(elem->p2.x, elem->p1.x, ratio);
+ vtx[j + 1].v.ob[1] = func_800B09D0(elem->p2.y, elem->p1.y, ratio);
+ vtx[j + 1].v.ob[2] = func_800B09D0(elem->p2.z, elem->p1.z, ratio);
+ break;
+ case 3:
+ ratio *= 0.5f;
+ vtx[j].v.ob[0] = func_800B09D0(elem->p1.x, elem->p2.x, ratio);
+ vtx[j].v.ob[1] = func_800B09D0(elem->p1.y, elem->p2.y, ratio);
+ vtx[j].v.ob[2] = func_800B09D0(elem->p1.z, elem->p2.z, ratio);
+ vtx[j + 1].v.ob[0] = func_800B09D0(elem->p2.x, elem->p1.x, ratio);
+ vtx[j + 1].v.ob[1] = func_800B09D0(elem->p2.y, elem->p1.y, ratio);
+ vtx[j + 1].v.ob[2] = func_800B09D0(elem->p2.z, elem->p1.z, ratio);
+ ratio *= 2.0f;
+ break;
+ case 0:
+ default:
+ vtx[j].v.ob[0] = elem->p1.x;
+ vtx[j].v.ob[1] = elem->p1.y;
+ vtx[j].v.ob[2] = elem->p1.z;
+ vtx[j + 1].v.ob[0] = elem->p2.x;
+ vtx[j + 1].v.ob[1] = elem->p2.y;
+ vtx[j + 1].v.ob[2] = elem->p2.z;
+ break;
+ }
+
+ vtx[j].v.flag = 0;
+ vtx[j].v.tc[0] = 0;
+ vtx[j].v.tc[1] = 0;
+ vtx[j].v.cn[0] = func_800B0A24(this->p1StartColor.r, this->p1EndColor.r, ratio);
+ vtx[j].v.cn[1] = func_800B0A24(this->p1StartColor.g, this->p1EndColor.g, ratio);
+ vtx[j].v.cn[2] = func_800B0A24(this->p1StartColor.b, this->p1EndColor.b, ratio);
+ vtx[j].v.cn[3] = func_800B0A24(this->p1StartColor.a, this->p1EndColor.a, ratio);
+ j++;
+
+ vtx[j].v.flag = 0;
+ vtx[j].v.tc[0] = 0;
+ vtx[j].v.tc[1] = 0;
+ vtx[j].v.cn[0] = func_800B0A24(this->p2StartColor.r, this->p2EndColor.r, ratio);
+ vtx[j].v.cn[1] = func_800B0A24(this->p2StartColor.g, this->p2EndColor.g, ratio);
+ vtx[j].v.cn[2] = func_800B0A24(this->p2StartColor.b, this->p2EndColor.b, ratio);
+ vtx[j].v.cn[3] = func_800B0A24(this->p2StartColor.a, this->p2EndColor.a, ratio);
+ j++;
+ }
+ }
+
+ phi_t2 = 0;
+ j = 0;
+
+ gSPVertex(POLY_XLU_DISP++, vtx, 32, 0);
+
+ for (i = 0; i < this->numElements; i++) {
+ elem = &this->elements[i];
+
+ if (elem->state == 0) {
+ phi_t2 = 0;
+ } else {
+ if (phi_t2 == 0) {
+ phi_t2 = 1;
+ } else {
+ gSP1Quadrangle(POLY_XLU_DISP++, j - 2, j - 1, j + 1, j, 0);
+
+ if (this->unkFlag == 1) {
+ phi_t2 = 0;
+ }
+ }
+ j += 2;
+ }
+ }
+ }
+ } else if (this->drawMode < 2) {
+ EffectBlure_DrawSimple(this, gfxCtx);
+ } else {
+ EffectBlure_DrawSmooth(this, gfxCtx);
+ }
+ }
+
+ CLOSE_DISPS(gfxCtx);
+}
diff --git a/src/code/z_eff_shield_particle.c b/src/code/z_eff_shield_particle.c
index 29d93a715..05669d63a 100644
--- a/src/code/z_eff_shield_particle.c
+++ b/src/code/z_eff_shield_particle.c
@@ -1,11 +1,207 @@
#include "global.h"
+#include "vt.h"
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/EffectShieldParticle_Init.s")
+#include "assets/code/eff_shield_particle/eff_shield_particle.c"
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/EffectShieldParticle_Destroy.s")
+void EffectShieldParticle_Init(void* thisx, void* initParamsx) {
+ EffectShieldParticle* this = (EffectShieldParticle*)thisx;
+ EffectShieldParticleInit* initParams = (EffectShieldParticleInit*)initParamsx;
+ EffectShieldParticleElement* elem;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/EffectShieldParticle_Update.s")
+ if ((this != NULL) && (initParams != NULL)) {
+ this->numElements = initParams->numElements;
+ if (this->numElements > ARRAY_COUNT(this->elements)) {
+ return;
+ }
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/EffectShieldParticle_CalculateColors.s")
+ this->position = initParams->position;
+ this->primColorStart = initParams->primColorStart;
+ this->envColorStart = initParams->envColorStart;
+ this->primColorMid = initParams->primColorMid;
+ this->envColorMid = initParams->envColorMid;
+ this->primColorEnd = initParams->primColorEnd;
+ this->envColorEnd = initParams->envColorEnd;
+ this->deceleration = initParams->deceleration;
+ this->maxInitialSpeed = initParams->maxInitialSpeed;
+ this->lengthCutoff = initParams->lengthCutoff;
+ this->duration = initParams->duration;
+ this->timer = 0;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/EffectShieldParticle_Draw.s")
+ for (elem = &this->elements[0]; elem < &this->elements[this->numElements]; elem++) {
+ elem->initialSpeed = (Rand_ZeroOne() * (this->maxInitialSpeed * 0.5f)) + (this->maxInitialSpeed * 0.5f);
+ elem->endX = 0.0f;
+ elem->startXChange = 0.0f;
+ elem->startX = 0.0f;
+ elem->endXChange = elem->initialSpeed;
+ elem->yaw = Rand_ZeroOne() * 65534.0f;
+ elem->pitch = Rand_ZeroOne() * 65534.0f;
+ }
+
+ this->lightDecay = initParams->lightDecay;
+ if (this->lightDecay == true) {
+ this->lightInfo.type = LIGHT_POINT_NOGLOW;
+ this->lightInfo.params.point = initParams->lightPoint;
+ this->lightNode =
+ LightContext_InsertLight(Effect_GetGlobalCtx(), &Effect_GetGlobalCtx()->lightCtx, &this->lightInfo);
+ } else {
+ this->lightNode = NULL;
+ }
+ }
+}
+
+void EffectShieldParticle_Destroy(void* thisx) {
+ EffectShieldParticle* this = (EffectShieldParticle*)thisx;
+
+ if ((this != NULL) && (this->lightDecay == true)) {
+ if (this->lightNode == Effect_GetGlobalCtx()->lightCtx.listHead) {
+ Effect_GetGlobalCtx()->lightCtx.listHead = this->lightNode->next;
+ }
+ LightContext_RemoveLight(Effect_GetGlobalCtx(), &Effect_GetGlobalCtx()->lightCtx, this->lightNode);
+ }
+}
+
+s32 EffectShieldParticle_Update(void* thisx) {
+ EffectShieldParticle* this = (EffectShieldParticle*)thisx;
+ EffectShieldParticleElement* elem;
+
+ if (this == NULL) {
+ return 0;
+ }
+
+ for (elem = &this->elements[0]; elem < &this->elements[this->numElements]; elem++) {
+ elem->endXChange -= this->deceleration;
+ if (elem->endXChange < 0.0f) {
+ elem->endXChange = 0.0f;
+ }
+
+ if (elem->startXChange > 0.0f) {
+ elem->startXChange -= this->deceleration;
+ if (elem->startXChange < 0.0f) {
+ elem->startXChange = 0.0f;
+ }
+ }
+
+ elem->endX += elem->endXChange;
+ elem->startX += elem->startXChange;
+
+ if ((elem->startXChange == 0.0f) && (this->lengthCutoff < (elem->endX - elem->startX))) {
+ elem->startXChange = elem->initialSpeed;
+ }
+ }
+
+ if (this->lightDecay == true) {
+ this->lightInfo.params.point.radius /= 2;
+ }
+
+ this->timer++;
+
+ if (this->duration < this->timer) {
+ return 1;
+ }
+
+ return 0;
+}
+
+void EffectShieldParticle_GetColors(EffectShieldParticle* this, Color_RGBA8* primColor, Color_RGBA8* envColor) {
+ s32 halfDuration = this->duration * 0.5f;
+
+ if (halfDuration == 0) {
+ primColor->r = this->primColorStart.r;
+ primColor->g = this->primColorStart.g;
+ primColor->b = this->primColorStart.b;
+ primColor->a = this->primColorStart.a;
+ envColor->r = this->envColorStart.r;
+ envColor->g = this->envColorStart.g;
+ envColor->b = this->envColorStart.b;
+ envColor->a = this->envColorStart.a;
+ } else if (this->timer < halfDuration) {
+ f32 ratio = this->timer / (f32)halfDuration;
+
+ primColor->r = LERPIMP(this->primColorStart.r, this->primColorMid.r, ratio);
+ primColor->g = LERPIMP(this->primColorStart.g, this->primColorMid.g, ratio);
+ primColor->b = LERPIMP(this->primColorStart.b, this->primColorMid.b, ratio);
+ primColor->a = LERPIMP(this->primColorStart.a, this->primColorMid.a, ratio);
+ envColor->r = LERPIMP(this->envColorStart.r, this->envColorMid.r, ratio);
+ envColor->g = LERPIMP(this->envColorStart.g, this->envColorMid.g, ratio);
+ envColor->b = LERPIMP(this->envColorStart.b, this->envColorMid.b, ratio);
+ envColor->a = LERPIMP(this->envColorStart.a, this->envColorMid.a, ratio);
+ } else {
+ f32 ratio = (this->timer - halfDuration) / (f32)halfDuration;
+
+ primColor->r = LERPIMP(this->primColorMid.r, this->primColorEnd.r, ratio);
+ primColor->g = LERPIMP(this->primColorMid.g, this->primColorEnd.g, ratio);
+ primColor->b = LERPIMP(this->primColorMid.b, this->primColorEnd.b, ratio);
+ primColor->a = LERPIMP(this->primColorMid.a, this->primColorEnd.a, ratio);
+ envColor->r = LERPIMP(this->envColorMid.r, this->envColorEnd.r, ratio);
+ envColor->g = LERPIMP(this->envColorMid.g, this->envColorEnd.g, ratio);
+ envColor->b = LERPIMP(this->envColorMid.b, this->envColorEnd.b, ratio);
+ envColor->a = LERPIMP(this->envColorMid.a, this->envColorEnd.a, ratio);
+ }
+}
+
+void EffectShieldParticle_Draw(void* thisx, GraphicsContext* gfxCtx) {
+ EffectShieldParticle* this = (EffectShieldParticle*)thisx;
+ EffectShieldParticleElement* elem;
+ Color_RGBA8 primColor;
+ Color_RGBA8 envColor;
+
+ OPEN_DISPS(gfxCtx);
+
+ if (this != NULL) {
+ POLY_XLU_DISP = Gfx_CallSetupDL(POLY_XLU_DISP, 0x26);
+
+ gDPSetCycleType(POLY_XLU_DISP++, G_CYC_2CYCLE);
+ gDPPipeSync(POLY_XLU_DISP++);
+ gSPTexture(POLY_XLU_DISP++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
+
+ gDPLoadTextureBlock(POLY_XLU_DISP++, D_04054F20, G_IM_FMT_I, G_IM_SIZ_8b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
+ G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD);
+
+ gDPSetCombineLERP(POLY_XLU_DISP++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, PRIMITIVE, 0, TEXEL0, 0, 0, 0,
+ 0, COMBINED, 0, 0, 0, COMBINED);
+ gDPSetRenderMode(POLY_XLU_DISP++, G_RM_PASS, G_RM_ZB_CLD_SURF2);
+ gSPClearGeometryMode(POLY_XLU_DISP++, G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR);
+ gSPSetGeometryMode(POLY_XLU_DISP++, G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH);
+
+ EffectShieldParticle_GetColors(this, &primColor, &envColor);
+
+ gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, primColor.r, primColor.g, primColor.b, primColor.a);
+ gDPSetEnvColor(POLY_XLU_DISP++, envColor.r, envColor.g, envColor.b, envColor.a);
+ gDPPipeSync(POLY_XLU_DISP++);
+
+ for (elem = &this->elements[0]; elem < &this->elements[this->numElements]; elem++) {
+ Mtx* mtx;
+ MtxF sp104;
+ MtxF spC4;
+ MtxF sp84;
+ f32 temp1 = (elem->endX + elem->startX) * 0.5f;
+ f32 temp2 = elem->endX - elem->startX;
+ f32 temp3 = (temp2 * (1.0f / 64.0f)) / 0.02f;
+
+ if (temp3 < 1.0f) {
+ temp3 = 1.0f;
+ }
+
+ SkinMatrix_SetTranslate(&spC4, this->position.x, this->position.y, this->position.z);
+ SkinMatrix_SetRotateRPY(&sp104, 0, elem->yaw, 0);
+ SkinMatrix_MtxFMtxFMult(&spC4, &sp104, &sp84);
+ SkinMatrix_SetRotateRPY(&sp104, 0, 0, elem->pitch);
+ SkinMatrix_MtxFMtxFMult(&sp84, &sp104, &spC4);
+ SkinMatrix_SetTranslate(&sp104, temp1, 0.0f, 0.0f);
+ SkinMatrix_MtxFMtxFMult(&spC4, &sp104, &sp84);
+ SkinMatrix_SetScale(&sp104, temp3 * 0.02f, 0.02f, 0.02f);
+ SkinMatrix_MtxFMtxFMult(&sp84, &sp104, &spC4);
+
+ mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &spC4);
+ if (mtx == NULL) {
+ break;
+ }
+
+ gSPMatrix(POLY_XLU_DISP++, mtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+ gSPVertex(POLY_XLU_DISP++, sEffShieldParticleVtx, 4, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 0, 1, 2, 0, 0, 3, 1, 0);
+ }
+ }
+
+ CLOSE_DISPS(gfxCtx);
+}
diff --git a/src/code/z_eff_spark.c b/src/code/z_eff_spark.c
index d06bc4b27..27ed1443d 100644
--- a/src/code/z_eff_spark.c
+++ b/src/code/z_eff_spark.c
@@ -1,9 +1,265 @@
#include "global.h"
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/EffectSpark_Init.s")
+void EffectSpark_Init(void* thisx, void* initParamsx) {
+ EffectSpark* this = (EffectSpark*)thisx;
+ EffectSparkInit* initParams = (EffectSparkInit*)initParamsx;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/EffectSpark_Destroy.s")
+ f32 velocityNorm;
+ s32 i;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/EffectSpark_Update.s")
+ if ((this != NULL) && (initParams != NULL)) {
+ if ((initParams->uDiv == 0) || (initParams->vDiv == 0)) {
+ return;
+ }
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/EffectSpark_Draw.s")
+ this->position = initParams->position;
+ this->speed = initParams->speed;
+ this->gravity = initParams->gravity;
+ this->uDiv = initParams->uDiv;
+ this->vDiv = initParams->vDiv;
+ this->colorStart[0].r = initParams->colorStart[0].r;
+ this->colorStart[0].g = initParams->colorStart[0].g;
+ this->colorStart[0].b = initParams->colorStart[0].b;
+ this->colorStart[0].a = initParams->colorStart[0].a;
+ this->colorStart[1].r = initParams->colorStart[1].r;
+ this->colorStart[1].g = initParams->colorStart[1].g;
+ this->colorStart[1].b = initParams->colorStart[1].b;
+ this->colorStart[1].a = initParams->colorStart[1].a;
+ this->colorStart[2].r = initParams->colorStart[2].r;
+ this->colorStart[2].g = initParams->colorStart[2].g;
+ this->colorStart[2].b = initParams->colorStart[2].b;
+ this->colorStart[2].a = initParams->colorStart[2].a;
+ this->colorStart[3].r = initParams->colorStart[3].r;
+ this->colorStart[3].g = initParams->colorStart[3].g;
+ this->colorStart[3].b = initParams->colorStart[3].b;
+ this->colorStart[3].a = initParams->colorStart[3].a;
+ this->colorEnd[0].r = initParams->colorEnd[0].r;
+ this->colorEnd[0].g = initParams->colorEnd[0].g;
+ this->colorEnd[0].b = initParams->colorEnd[0].b;
+ this->colorEnd[0].a = initParams->colorEnd[0].a;
+ this->colorEnd[1].r = initParams->colorEnd[1].r;
+ this->colorEnd[1].g = initParams->colorEnd[1].g;
+ this->colorEnd[1].b = initParams->colorEnd[1].b;
+ this->colorEnd[1].a = initParams->colorEnd[1].a;
+ this->colorEnd[2].r = initParams->colorEnd[2].r;
+ this->colorEnd[2].g = initParams->colorEnd[2].g;
+ this->colorEnd[2].b = initParams->colorEnd[2].b;
+ this->colorEnd[2].a = initParams->colorEnd[2].a;
+ this->colorEnd[3].r = initParams->colorEnd[3].r;
+ this->colorEnd[3].g = initParams->colorEnd[3].g;
+ this->colorEnd[3].b = initParams->colorEnd[3].b;
+ this->colorEnd[3].a = initParams->colorEnd[3].a;
+ this->duration = initParams->duration;
+
+ this->numElements = (this->uDiv * this->vDiv) + 2;
+ if (this->numElements > ARRAY_COUNT(this->elements)) {
+ return;
+ }
+
+ for (i = 0; i < this->numElements; i++) {
+ EffectSparkElement* elem = &this->elements[i];
+
+ elem->position.x = this->position.x;
+ elem->position.y = this->position.y;
+ elem->position.z = this->position.z;
+ elem->velocity.x = Rand_ZeroOne() - 0.5f;
+ elem->velocity.y = Rand_ZeroOne() - 0.5f;
+ elem->velocity.z = Rand_ZeroOne() - 0.5f;
+
+ velocityNorm = sqrtf(SQXYZ(elem->velocity));
+
+ if (!(fabsf(velocityNorm) < 0.008f)) {
+ elem->velocity.x *= this->speed * (1.0f / velocityNorm);
+ elem->velocity.y *= this->speed * (1.0f / velocityNorm);
+ elem->velocity.z *= this->speed * (1.0f / velocityNorm);
+ } else {
+ elem->velocity.x = elem->velocity.z = 0.0f;
+ elem->velocity.y = this->speed;
+ }
+
+ elem->unkVelocity.x = 30000.0f - Rand_ZeroOne() * 15000.0f;
+ elem->unkVelocity.y = 30000.0f - Rand_ZeroOne() * 15000.0f;
+ elem->unkVelocity.z = 30000.0f - Rand_ZeroOne() * 15000.0f;
+ elem->unkPosition.x = Rand_ZeroOne() * 65534.0f;
+ elem->unkPosition.y = Rand_ZeroOne() * 65534.0f;
+ elem->unkPosition.z = Rand_ZeroOne() * 65534.0f;
+ }
+
+ this->timer = 0;
+ }
+}
+
+void EffectSpark_Destroy(void* thisx) {
+}
+
+s32 EffectSpark_Update(void* thisx) {
+ EffectSpark* this = (EffectSpark*)thisx;
+ EffectSparkElement* elem;
+ s32 i;
+
+ for (i = 0; i < this->numElements; i++) {
+ elem = &this->elements[i];
+
+ elem->position.x += elem->velocity.x;
+ elem->position.y += elem->velocity.y;
+ elem->position.z += elem->velocity.z;
+ elem->velocity.y += this->gravity;
+ elem->unkPosition.x += elem->unkVelocity.x;
+ elem->unkPosition.y += elem->unkVelocity.y;
+ elem->unkPosition.z += elem->unkVelocity.z;
+ }
+
+ this->timer++;
+
+ if (this->duration < this->timer) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+void EffectSpark_Draw(void* thisx, GraphicsContext* gfxCtx) {
+ Vtx* vertices;
+ EffectSpark* this = (EffectSpark*)thisx;
+ GlobalContext* globalCtx = Effect_GetGlobalCtx();
+ s32 i;
+ s32 j;
+ u8 sp1D3;
+ u8 sp1D2;
+ u8 sp1D1;
+ u8 sp1D0;
+ u8 sp1CF;
+ u8 sp1CE;
+ u8 sp1CD;
+ u8 sp1CC;
+ u8 sp1CB;
+ u8 sp1CA;
+ u8 sp1C9;
+ u8 sp1C8;
+ u8 sp1C7;
+ u8 sp1C6;
+ u8 sp1C5;
+ u8 sp1C4;
+ f32 ratio;
+
+ OPEN_DISPS(gfxCtx);
+
+ if (this != NULL) {
+ gSPMatrix(POLY_XLU_DISP++, &gIdentityMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+
+ POLY_XLU_DISP = Gfx_CallSetupDL(POLY_XLU_DISP, 0x26);
+ gDPSetCycleType(POLY_XLU_DISP++, G_CYC_2CYCLE);
+ gDPPipeSync(POLY_XLU_DISP++);
+
+ gSPTexture(POLY_XLU_DISP++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
+ gDPLoadTextureBlock(POLY_XLU_DISP++, D_04054F20, G_IM_FMT_I, G_IM_SIZ_8b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
+ G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD);
+
+ gDPSetCombineMode(POLY_XLU_DISP++, G_CC_SHADEDECALA, G_CC_PASS2);
+ gDPSetRenderMode(POLY_XLU_DISP++, G_RM_PASS, G_RM_ZB_CLD_SURF2);
+ gSPClearGeometryMode(POLY_XLU_DISP++, G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR);
+ gSPSetGeometryMode(POLY_XLU_DISP++, G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH);
+ gDPPipeSync(POLY_XLU_DISP++);
+
+ vertices = GRAPH_ALLOC(gfxCtx, ALIGN16(this->numElements * sizeof(Vtx[4])));
+ if (vertices == NULL) {
+ goto end;
+ }
+
+ j = 0;
+
+ ratio = (f32)this->timer / (f32)this->duration;
+ sp1D3 = F32_LERPIMP(this->colorStart[0].r, this->colorEnd[0].r, ratio);
+ sp1D2 = F32_LERPIMP(this->colorStart[0].g, this->colorEnd[0].g, ratio);
+ sp1D1 = F32_LERPIMP(this->colorStart[0].b, this->colorEnd[0].b, ratio);
+ sp1D0 = F32_LERPIMP(this->colorStart[0].a, this->colorEnd[0].a, ratio);
+ sp1CF = F32_LERPIMP(this->colorStart[1].r, this->colorEnd[1].r, ratio);
+ sp1CE = F32_LERPIMP(this->colorStart[1].g, this->colorEnd[1].g, ratio);
+ sp1CD = F32_LERPIMP(this->colorStart[1].b, this->colorEnd[1].b, ratio);
+ sp1CC = F32_LERPIMP(this->colorStart[1].a, this->colorEnd[1].a, ratio);
+ sp1CB = F32_LERPIMP(this->colorStart[2].r, this->colorEnd[2].r, ratio);
+ sp1CA = F32_LERPIMP(this->colorStart[2].g, this->colorEnd[2].g, ratio);
+ sp1C9 = F32_LERPIMP(this->colorStart[2].b, this->colorEnd[2].b, ratio);
+ sp1C8 = F32_LERPIMP(this->colorStart[2].a, this->colorEnd[2].a, ratio);
+ sp1C7 = F32_LERPIMP(this->colorStart[3].r, this->colorEnd[3].r, ratio);
+ sp1C6 = F32_LERPIMP(this->colorStart[3].g, this->colorEnd[3].g, ratio);
+ sp1C5 = F32_LERPIMP(this->colorStart[3].b, this->colorEnd[3].b, ratio);
+ sp1C4 = F32_LERPIMP(this->colorStart[3].a, this->colorEnd[3].a, ratio);
+
+ for (i = 0; i < this->numElements; i++) {
+ MtxF sp12C;
+ MtxF spEC;
+ MtxF spAC;
+ MtxF sp6C;
+ EffectSparkElement* elem = &this->elements[i];
+ Mtx* mtx;
+ f32 temp;
+
+ SkinMatrix_SetTranslate(&spEC, elem->position.x, elem->position.y, elem->position.z);
+ temp = ((Rand_ZeroOne() * 2.5f) + 1.5f) / 64.0f;
+ SkinMatrix_SetScale(&spAC, temp, temp, 1.0f);
+ SkinMatrix_MtxFMtxFMult(&spEC, &globalCtx->billboardMtxF, &sp6C);
+ SkinMatrix_MtxFMtxFMult(&sp6C, &spAC, &sp12C);
+
+ vertices[j].v.ob[0] = -32;
+ vertices[j].v.ob[1] = -32;
+ vertices[j].v.ob[2] = 0;
+ vertices[j].v.cn[0] = sp1D3;
+ vertices[j].v.cn[1] = sp1D2;
+ vertices[j].v.cn[2] = sp1D1;
+ vertices[j].v.cn[3] = sp1D0;
+ vertices[j].v.tc[0] = 0;
+ vertices[j].v.tc[1] = 1024;
+ vertices[j].v.flag = 0;
+
+ vertices[j + 1].v.ob[0] = 32;
+ vertices[j + 1].v.ob[1] = 32;
+ vertices[j + 1].v.ob[2] = 0;
+ vertices[j + 1].v.cn[0] = sp1CF;
+ vertices[j + 1].v.cn[1] = sp1CE;
+ vertices[j + 1].v.cn[2] = sp1CD;
+ vertices[j + 1].v.cn[3] = sp1CC;
+ vertices[j + 1].v.tc[0] = 1024;
+ vertices[j + 1].v.tc[1] = 0;
+ vertices[j + 1].v.flag = 0;
+
+ vertices[j + 2].v.ob[0] = -32;
+ vertices[j + 2].v.ob[1] = 32;
+ vertices[j + 2].v.ob[2] = 0;
+ vertices[j + 2].v.cn[0] = sp1CB;
+ vertices[j + 2].v.cn[1] = sp1CA;
+ vertices[j + 2].v.cn[2] = sp1C9;
+ vertices[j + 2].v.cn[3] = sp1C8;
+ vertices[j + 2].v.tc[0] = 0;
+ vertices[j + 2].v.tc[1] = 0;
+ vertices[j + 2].v.flag = 0;
+
+ vertices[j + 3].v.ob[0] = 32;
+ vertices[j + 3].v.ob[1] = -32;
+ vertices[j + 3].v.ob[2] = 0;
+ vertices[j + 3].v.cn[0] = sp1C7;
+ vertices[j + 3].v.cn[1] = sp1C6;
+ vertices[j + 3].v.cn[2] = sp1C5;
+ vertices[j + 3].v.cn[3] = sp1C4;
+ vertices[j + 3].v.tc[0] = 1024;
+ vertices[j + 3].v.tc[1] = 1024;
+ vertices[j + 3].v.flag = 0;
+
+ j += 4;
+
+ mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &sp12C);
+ if (mtx == NULL) {
+ goto end;
+ }
+
+ gSPMatrix(POLY_XLU_DISP++, mtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+ gSPVertex(POLY_XLU_DISP++, &vertices[4 * i], 4, 0);
+ gSP2Triangles(POLY_XLU_DISP++, 2, 0, 3, 0, 2, 3, 1, 0);
+ }
+
+ gDPPipeSync(POLY_XLU_DISP++);
+ }
+
+end:
+ CLOSE_DISPS(gfxCtx);
+}
diff --git a/src/code/z_eff_ss_dead.c b/src/code/z_eff_ss_dead.c
index 12665d6b2..bd93f5eed 100644
--- a/src/code/z_eff_ss_dead.c
+++ b/src/code/z_eff_ss_dead.c
@@ -1,13 +1,111 @@
#include "global.h"
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE2A0.s")
+void func_800AE2A0(GlobalContext* globalCtx, Color_RGBA8* color, s16 arg2, s16 arg3) {
+ f32 cos;
+ Gfx* displayListHead;
+ f32 absCos;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE434.s")
+ OPEN_DISPS(globalCtx->state.gfxCtx);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE5A0.s")
+ displayListHead = POLY_OPA_DISP;
+ cos = Math_CosS((0x8000 / arg3) * arg2);
+ absCos = fabsf(cos);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE5E4.s")
+ gDPPipeSync(displayListHead++);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE778.s")
+ if (color == NULL) {
+ gDPSetFogColor(displayListHead++, 255, 0, 0, 0);
+ } else {
+ gDPSetFogColor(displayListHead++, color->r, color->g, color->b, color->a);
+ }
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE8EC.s")
+ gSPFogPosition(displayListHead++, 0, (s16)(absCos * 3000.0f) + 1500);
+
+ POLY_OPA_DISP = displayListHead;
+
+ CLOSE_DISPS(globalCtx->state.gfxCtx);
+}
+
+void func_800AE434(GlobalContext* globalCtx, Color_RGBA8* color, s16 arg2, s16 arg3) {
+ Gfx* displayListHead;
+ f32 cos;
+
+ OPEN_DISPS(globalCtx->state.gfxCtx);
+
+ cos = Math_CosS((0x4000 / arg3) * arg2);
+ displayListHead = POLY_OPA_DISP;
+
+ gDPPipeSync(displayListHead++);
+ gDPSetFogColor(displayListHead++, color->r, color->g, color->b, color->a);
+ gSPFogPosition(displayListHead++, 0, (s16)(2800.0f * fabsf(cos)) + 1700);
+
+ POLY_OPA_DISP = displayListHead;
+
+ CLOSE_DISPS(globalCtx->state.gfxCtx);
+}
+
+void func_800AE5A0(GlobalContext* globalCtx) {
+ s32 pad;
+
+ OPEN_DISPS(globalCtx->state.gfxCtx);
+
+ gDPPipeSync(POLY_OPA_DISP++);
+ POLY_OPA_DISP = func_801660B8(globalCtx, POLY_OPA_DISP);
+
+ CLOSE_DISPS(globalCtx->state.gfxCtx);
+}
+
+void func_800AE5E4(GlobalContext* globalCtx, Color_RGBA8* color, s16 arg2, s16 arg3) {
+ f32 cos;
+ Gfx* displayListHead;
+ f32 absCos;
+
+ OPEN_DISPS(globalCtx->state.gfxCtx);
+
+ displayListHead = POLY_XLU_DISP;
+ cos = Math_CosS((0x8000 / arg3) * arg2);
+ absCos = fabsf(cos);
+
+ gDPPipeSync(displayListHead++);
+
+ if (color == NULL) {
+ gDPSetFogColor(displayListHead++, 255, 0, 0, 0);
+ } else {
+ gDPSetFogColor(displayListHead++, color->r, color->g, color->b, color->a);
+ }
+
+ gSPFogPosition(displayListHead++, 0, (s16)(absCos * 3000.0f) + 1500);
+
+ POLY_XLU_DISP = displayListHead;
+
+ CLOSE_DISPS(globalCtx->state.gfxCtx);
+}
+
+void func_800AE778(GlobalContext* globalCtx, Color_RGBA8* color, s16 arg2, s16 arg3) {
+ f32 cos;
+ Gfx* displayListHead;
+
+ OPEN_DISPS(globalCtx->state.gfxCtx);
+
+ displayListHead = POLY_XLU_DISP;
+ cos = Math_CosS((0x4000 / arg3) * arg2);
+
+ gDPPipeSync(displayListHead++);
+ gDPSetFogColor(displayListHead++, color->r, color->g, color->b, color->a);
+ gSPFogPosition(displayListHead++, 0, (s16)(2800.0f * fabsf(cos)) + 1700);
+
+ POLY_XLU_DISP = displayListHead;
+
+ CLOSE_DISPS(globalCtx->state.gfxCtx);
+}
+
+void func_800AE8EC(GlobalContext* globalCtx) {
+ s32 pad;
+
+ OPEN_DISPS(globalCtx->state.gfxCtx);
+
+ gDPPipeSync(POLY_XLU_DISP++);
+ POLY_XLU_DISP = func_801660B8(globalCtx, POLY_XLU_DISP);
+
+ CLOSE_DISPS(globalCtx->state.gfxCtx);
+}
diff --git a/src/code/z_eff_tire_mark.c b/src/code/z_eff_tire_mark.c
index 0ae14c86f..517ee5251 100644
--- a/src/code/z_eff_tire_mark.c
+++ b/src/code/z_eff_tire_mark.c
@@ -1,17 +1,287 @@
#include "global.h"
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/func_800AE930.s")
+void func_800AE930(CollisionContext* colCtx, EffectTireMark* this, Vec3f* pos, f32 arg3, s16 arg4,
+ CollisionPoly* colPoly, s32 arg6) {
+ Vec3s spB8;
+ Vec3s spB0;
+ EffectTireMarkElement* spAC;
+ EffectTireMarkElement* spA8;
+ u32 spA4;
+ u32 spA0;
+ Vec3s* vtxList = colCtx->colHeader->vtxList;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/func_800AEF44.s")
+ if ((arg6 != 50) || (this->numElements >= (ARRAY_COUNT(this->elements) - 1)) || (colPoly == NULL)) {
+ func_800AEF44(this);
+ return;
+ }
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_InitParticle.s")
+ spB8.x = (Math_SinS(arg4 - 0x4000) * arg3) + pos->x;
+ spB8.z = (Math_CosS(arg4 - 0x4000) * arg3) + pos->z;
+ spB8.y = func_800BFD84(colPoly, spB8.x, spB8.z) + 2.0f;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_Init.s")
+ spB0.x = (Math_SinS(arg4 + 0x4000) * arg3) + pos->x;
+ spB0.z = (Math_CosS(arg4 + 0x4000) * arg3) + pos->z;
+ spB0.y = func_800BFD84(colPoly, spB0.x, spB0.z) + 2.0f;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_Destroy.s")
+ spAC = &this->elements[this->numElements - 1];
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_Update.s")
+ if ((this->numElements != 0) && (spAC->colPoly != NULL) && (colPoly != spAC->colPoly) &&
+ (func_800BFDEC(spAC->colPoly, colPoly, &spA4, &spA0) == 2)) {
+ Vec3f sp90;
+ Vec3f sp84;
+ Vec3f sp78;
+ Vec3f sp6C;
+ Vec3f sp60;
+ Vec3f sp54;
+ Vec3f sp48;
+ Vec3f sp3C;
+ Vec3f sp30;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_InitVertices.s")
+ sp84.x = vtxList[spA4].x;
+ sp84.y = vtxList[spA4].y;
+ sp84.z = vtxList[spA4].z;
+ sp90.x = vtxList[spA0].x;
+ sp90.y = vtxList[spA0].y;
+ sp90.z = vtxList[spA0].z;
+ sp54.x = spAC->p1.x;
+ sp54.y = spAC->p1.y;
+ sp54.z = spAC->p1.z;
+ sp60.x = spB0.x;
+ sp60.y = spB0.y;
+ sp60.z = spB0.z;
+ sp3C.x = spAC->p2.x;
+ sp3C.y = spAC->p2.y;
+ sp3C.z = spAC->p2.z;
+ sp48.x = spB8.x;
+ sp48.y = spB8.y;
+ sp48.z = spB8.z;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_Draw.s")
+ if ((func_80179798(&sp84, &sp90, &sp54, &sp60, &sp6C, &sp30) != 0) &&
+ (func_80179798(&sp84, &sp90, &sp3C, &sp48, &sp78, &sp30) != 0)) {
+ if (!(spAC->flags & 2)) {
+ spAC->flags |= 1;
+ }
+
+ spA8 = &this->elements[this->numElements];
+ spA8->flags = 0;
+ spA8->p1.x = sp6C.x;
+ spA8->p1.y = sp6C.y;
+ spA8->p1.z = sp6C.z;
+ spA8->p2.x = sp78.x;
+ spA8->p2.y = sp78.y;
+ spA8->p2.z = sp78.z;
+ spA8->life = this->elemDuration;
+ spA8->colPoly = NULL;
+ this->numElements++;
+
+ spAC = &this->elements[this->numElements - 1];
+ if (!(spAC->flags & 2)) {
+ spAC->flags |= 1;
+ }
+
+ if (spA8) {} // Necessary to match
+
+ spA8 = &this->elements[this->numElements];
+ spA8->flags = 0;
+ spA8->p1 = spB0;
+ spA8->p2 = spB8;
+ spA8->life = this->elemDuration;
+ spA8->colPoly = colPoly;
+ this->numElements++;
+ return;
+ }
+
+ if (!(spAC->flags & 2)) {
+ spAC->flags |= 1;
+ }
+
+ spA8 = &this->elements[this->numElements];
+ spA8->flags = 0;
+ spA8->p1 = spB0;
+ spA8->p2 = spB8;
+ spA8->life = this->elemDuration;
+ spA8->colPoly = colPoly;
+
+ this->numElements++;
+ return;
+ }
+
+ if (!(spAC->flags & 2)) {
+ spAC->flags |= 1;
+ }
+
+ spA8 = &this->elements[this->numElements];
+ spA8->flags = 0;
+ spA8->p1 = spB0;
+ spA8->p2 = spB8;
+ spA8->life = this->elemDuration;
+ spA8->colPoly = colPoly;
+
+ this->numElements++;
+}
+
+void func_800AEF44(EffectTireMark* this) {
+ EffectTireMarkElement* elem = &this->elements[this->numElements - 1];
+
+ elem->flags |= 2;
+}
+
+void EffectTireMark_InitElement(EffectTireMarkElement* elem) {
+ elem->flags = 0;
+ elem->life = 0;
+ elem->colPoly = NULL;
+ elem->p1.x = elem->p1.y = elem->p1.z = elem->p2.x = elem->p2.y = elem->p2.z = 0;
+}
+
+void EffectTireMark_Init(void* thisx, void* initParamsx) {
+ EffectTireMark* this = (EffectTireMark*)thisx;
+ EffectTireMarkInit* initParams = (EffectTireMarkInit*)initParamsx;
+ s32 i;
+
+ for (i = 0; i < ARRAY_COUNT(this->elements); i++) {
+ EffectTireMark_InitElement(&this->elements[i]);
+ }
+
+ this->unk600 = initParams->unk0;
+ this->numElements = 0;
+
+ if (initParams->elemDuration > 62) {
+ this->elemDuration = 62;
+ } else {
+ this->elemDuration = initParams->elemDuration;
+ }
+
+ this->color = initParams->color;
+}
+
+void EffectTireMark_Destroy(void* thisx) {
+}
+
+s32 EffectTireMark_Update(void* thisx) {
+ EffectTireMark* this = (EffectTireMark*)thisx;
+ s32 i;
+ s32 j;
+
+ if (this->numElements == 0) {
+ return 0;
+ }
+
+ for (i = 0; i < this->numElements; i++) {
+ this->elements[i].life--;
+ }
+
+ if (this->elements[0].life <= 0) {
+ for (j = 0; j < ARRAY_COUNT(this->elements) - 1; j++) {
+ this->elements[j] = this->elements[j + 1];
+ }
+
+ EffectTireMark_InitElement(&this->elements[j]);
+
+ this->numElements--;
+ if (this->numElements < 0) {
+ this->numElements = 0;
+ }
+ return 0;
+ }
+
+ return 0;
+}
+
+void EffectTireMark_SetVertices(Vtx* vtx, EffectTireMarkElement* elem, s32 i, s32 alpha) {
+ s32 i1 = i * 2;
+ s32 i2 = i * 2 + 1;
+
+ vtx[i1].v.ob[0] = elem->p1.x;
+ vtx[i1].v.ob[1] = elem->p1.y;
+ vtx[i1].v.ob[2] = elem->p1.z;
+ vtx[i1].v.tc[0] = 2048;
+ vtx[i1].v.tc[1] = 0;
+ vtx[i1].v.cn[0] = 255;
+ vtx[i1].v.cn[1] = 255;
+ vtx[i1].v.cn[2] = 255;
+ vtx[i1].v.cn[3] = alpha;
+
+ vtx[i2].v.ob[0] = elem->p2.x;
+ vtx[i2].v.ob[1] = elem->p2.y;
+ vtx[i2].v.ob[2] = elem->p2.z;
+ vtx[i2].v.tc[0] = 2048;
+ vtx[i2].v.tc[1] = 1024;
+ vtx[i2].v.cn[0] = 255;
+ vtx[i2].v.cn[1] = 255;
+ vtx[i2].v.cn[2] = 255;
+ vtx[i2].v.cn[3] = alpha;
+}
+
+void EffectTireMark_Draw(void* thisx, GraphicsContext* gfxCtx) {
+ EffectTireMark* this = (EffectTireMark*)thisx;
+ EffectTireMarkElement* elem;
+ Vtx* vtx;
+ s32 pad;
+ f32 sp34;
+ s32 i;
+
+ sp34 = 1.0f / this->elemDuration;
+
+ OPEN_DISPS(gfxCtx);
+
+ if (this->numElements >= 2) {
+ vtx = GRAPH_ALLOC(gfxCtx, ALIGN16(this->numElements * sizeof(Vtx[2])));
+
+ if (vtx != NULL) {
+ gSPMatrix(POLY_OPA_DISP++, &gIdentityMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+
+ POLY_OPA_DISP = Gfx_CallSetupDL(POLY_OPA_DISP++, 0x2C);
+ gDPSetRenderMode(POLY_OPA_DISP++, G_RM_PASS, G_RM_ZB_CLD_SURF2);
+
+ gDPLoadTextureBlock(POLY_OPA_DISP++, D_04014570, G_IM_FMT_I, G_IM_SIZ_8b, 64, 32, 0,
+ G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_WRAP, 6, 5, G_TX_NOLOD, G_TX_NOLOD);
+
+ gDPSetCombineLERP(POLY_OPA_DISP++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0, COMBINED, 0, 0, 0,
+ COMBINED);
+ gSPSetGeometryMode(POLY_OPA_DISP++, G_SHADE | G_SHADING_SMOOTH);
+ gSPClearGeometryMode(POLY_OPA_DISP++, G_CULL_BACK | G_LIGHTING);
+
+ EffectTireMark_SetVertices(vtx, &this->elements[0], 0, 255);
+
+ vtx[0].v.tc[0] = 0;
+ vtx[0].v.tc[1] = 0;
+ vtx[1].v.tc[0] = 0;
+ vtx[1].v.tc[1] = 1024;
+
+ for (i = 1; i < this->numElements; i++) {
+ elem = &this->elements[i];
+
+ EffectTireMark_SetVertices(vtx, elem, i, 255);
+
+ if ((elem - 1)->flags & 1) {
+ if (!(elem->flags & 1)) {
+ vtx[i * 2 + 0].v.tc[0] = 0;
+ vtx[i * 2 + 0].v.tc[1] = 0;
+ vtx[i * 2 + 1].v.tc[0] = 0;
+ vtx[i * 2 + 1].v.tc[1] = 1024;
+ dummy_label:;
+ } else if ((i >= 2) && !((elem - 2)->flags & 1)) {
+ vtx[i * 2 - 2].v.tc[0] = 0;
+ vtx[i * 2 - 2].v.tc[1] = 0;
+ vtx[i * 2 - 1].v.tc[0] = 0;
+ vtx[i * 2 - 1].v.tc[1] = 1024;
+ }
+
+ if (i == (this->numElements - 1)) {
+ vtx[i * 2 + 0].v.tc[0] = 0;
+ vtx[i * 2 + 0].v.tc[1] = 0;
+ vtx[i * 2 + 1].v.tc[0] = 0;
+ vtx[i * 2 + 1].v.tc[1] = 1024;
+ }
+
+ gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, this->color.r, this->color.g, this->color.b,
+ (s32)((f32)this->color.a * (f32)elem->life * sp34));
+ gSPVertex(POLY_OPA_DISP++, &vtx[i * 2 - 2], 4, 0);
+ gSP2Triangles(POLY_OPA_DISP++, 0, 1, 3, 0, 0, 3, 2, 0);
+ }
+ }
+ }
+ }
+
+ CLOSE_DISPS(gfxCtx);
+}
diff --git a/src/code/z_effect.c b/src/code/z_effect.c
index 1c7ad3891..dd696393f 100644
--- a/src/code/z_effect.c
+++ b/src/code/z_effect.c
@@ -1,55 +1,57 @@
#include "global.h"
-EffInfo sEffInfoTable[] = {
+EffectContext sEffectContext;
+
+EffectInfo sEffectInfoTable[] = {
{
- sizeof(EffSparkParams),
- (eff_init_func)EffectSpark_Init,
- (eff_destroy_func)EffectSpark_Destroy,
- (eff_update_func)EffectSpark_Update,
- (eff_draw_func)EffectSpark_Draw,
+ sizeof(EffectSpark),
+ EffectSpark_Init,
+ EffectSpark_Destroy,
+ EffectSpark_Update,
+ EffectSpark_Draw,
},
{
sizeof(EffectBlure),
- (eff_init_func)EffectBlure_Init1,
- (eff_destroy_func)EffectBlure_Destroy,
- (eff_update_func)EffectBlure_Update,
- (eff_draw_func)EffectBlure_Draw,
+ EffectBlure_Init1,
+ EffectBlure_Destroy,
+ EffectBlure_Update,
+ EffectBlure_Draw,
},
{
sizeof(EffectBlure),
- (eff_init_func)EffectBlure_Init2,
- (eff_destroy_func)EffectBlure_Destroy,
- (eff_update_func)EffectBlure_Update,
- (eff_draw_func)EffectBlure_Draw,
+ EffectBlure_Init2,
+ EffectBlure_Destroy,
+ EffectBlure_Update,
+ EffectBlure_Draw,
},
{
- sizeof(EffShieldParticleParams),
- (eff_init_func)EffectShieldParticle_Init,
- (eff_destroy_func)EffectShieldParticle_Destroy,
- (eff_update_func)EffectShieldParticle_Update,
- (eff_draw_func)EffectShieldParticle_Draw,
+ sizeof(EffectShieldParticle),
+ EffectShieldParticle_Init,
+ EffectShieldParticle_Destroy,
+ EffectShieldParticle_Update,
+ EffectShieldParticle_Draw,
},
{
- sizeof(EffTireMarkParams),
- (eff_init_func)EffectTireMark_Init,
- (eff_destroy_func)EffectTireMark_Destroy,
- (eff_update_func)EffectTireMark_Update,
- (eff_draw_func)EffectTireMark_Draw,
+ sizeof(EffectTireMark),
+ EffectTireMark_Init,
+ EffectTireMark_Destroy,
+ EffectTireMark_Update,
+ EffectTireMark_Draw,
},
};
-GlobalContext* Effect_GetContext(void) {
- return sEffTable.globalCtx;
+GlobalContext* Effect_GetGlobalCtx(void) {
+ return sEffectContext.globalCtx;
}
-void* Effect_GetParams(s32 index) {
+void* Effect_GetByIndex(s32 index) {
if (index == TOTAL_EFFECT_COUNT) {
return NULL;
}
if (index < SPARK_COUNT) {
- if (sEffTable.sparks[index].base.active == 1) {
- return &sEffTable.sparks[index].params;
+ if (sEffectContext.sparks[index].status.active == true) {
+ return &sEffectContext.sparks[index].effect;
} else {
return NULL;
}
@@ -57,8 +59,8 @@ void* Effect_GetParams(s32 index) {
index -= SPARK_COUNT;
if (index < BLURE_COUNT) {
- if (sEffTable.blures[index].base.active == 1) {
- return &sEffTable.blures[index].params;
+ if (sEffectContext.blures[index].status.active == true) {
+ return &sEffectContext.blures[index].effect;
} else {
return NULL;
}
@@ -66,8 +68,8 @@ void* Effect_GetParams(s32 index) {
index -= BLURE_COUNT;
if (index < SHIELD_PARTICLE_COUNT) {
- if (sEffTable.shieldParticles[index].base.active == 1) {
- return &sEffTable.shieldParticles[index].params;
+ if (sEffectContext.shieldParticles[index].status.active == true) {
+ return &sEffectContext.shieldParticles[index].effect;
} else {
return NULL;
}
@@ -75,8 +77,8 @@ void* Effect_GetParams(s32 index) {
index -= SHIELD_PARTICLE_COUNT;
if (index < TIRE_MARK_COUNT) {
- if (sEffTable.tireMarks[index].base.active == 1) {
- return &sEffTable.tireMarks[index].params;
+ if (sEffectContext.tireMarks[index].status.active == true) {
+ return &sEffectContext.tireMarks[index].effect;
} else {
return NULL;
}
@@ -85,89 +87,87 @@ void* Effect_GetParams(s32 index) {
return NULL;
}
-void Effect_InitCommon(EffCommon* common) {
- common->active = 0;
- common->unk1 = 0;
- common->unk2 = 0;
+void Effect_InitStatus(EffectStatus* status) {
+ status->active = false;
+ status->unk1 = 0;
+ status->unk2 = 0;
}
void Effect_Init(GlobalContext* globalCtx) {
s32 i;
for (i = 0; i < SPARK_COUNT; i++) {
- Effect_InitCommon(&sEffTable.sparks[i].base);
+ Effect_InitStatus(&sEffectContext.sparks[i].status);
}
for (i = 0; i < BLURE_COUNT; i++) {
- Effect_InitCommon(&sEffTable.blures[i].base);
+ Effect_InitStatus(&sEffectContext.blures[i].status);
}
- //! @bug This is probably supposed to loop over shieldParticles, not blures again
for (i = 0; i < SHIELD_PARTICLE_COUNT; i++) {
- Effect_InitCommon(&sEffTable.blures[i].base);
+ //! @bug This is probably supposed to initialize shieldParticles, not blures again
+ Effect_InitStatus(&sEffectContext.blures[i].status);
}
for (i = 0; i < TIRE_MARK_COUNT; i++) {
- Effect_InitCommon(&sEffTable.tireMarks[i].base);
+ Effect_InitStatus(&sEffectContext.tireMarks[i].status);
}
- sEffTable.globalCtx = globalCtx;
+ sEffectContext.globalCtx = globalCtx;
}
-void Effect_Add(GlobalContext* globalCtx, s32* index, s32 type, u8 param_4, u8 param_5, void* initParams) {
+void Effect_Add(GlobalContext* globalCtx, s32* pIndex, s32 type, u8 arg3, u8 arg4, void* initParams) {
u32 slotFound;
s32 i;
- void* params;
- EffCommon* common;
+ void* effect = NULL;
+ EffectStatus* status = NULL;
- params = NULL;
- *index = TOTAL_EFFECT_COUNT;
- common = NULL;
+ *pIndex = TOTAL_EFFECT_COUNT;
if (FrameAdvance_IsEnabled(globalCtx) != true) {
- slotFound = 0;
+ slotFound = false;
switch (type) {
- case 0:
+ case EFFECT_SPARK:
for (i = 0; i < SPARK_COUNT; i++) {
- if (sEffTable.sparks[i].base.active == 0) {
- slotFound = 1;
- *index = i;
- params = &sEffTable.sparks[i].params;
- common = &sEffTable.sparks[i].base;
+ if (sEffectContext.sparks[i].status.active == false) {
+ slotFound = true;
+ *pIndex = i;
+ effect = &sEffectContext.sparks[i].effect;
+ status = &sEffectContext.sparks[i].status;
break;
}
}
break;
- case 1:
- case 2:
+ case EFFECT_BLURE1:
+ case EFFECT_BLURE2:
for (i = 0; i < BLURE_COUNT; i++) {
- if (sEffTable.blures[i].base.active == 0) {
- slotFound = 1;
- *index = i + 3;
- params = &sEffTable.blures[i].params;
- common = &sEffTable.blures[i].base;
+ if (sEffectContext.blures[i].status.active == false) {
+ slotFound = true;
+ *pIndex = i + SPARK_COUNT;
+ effect = &sEffectContext.blures[i].effect;
+ status = &sEffectContext.blures[i].status;
break;
}
}
break;
- case 3:
+ case EFFECT_SHIELD_PARTICLE:
for (i = 0; i < SHIELD_PARTICLE_COUNT; i++) {
- if (sEffTable.shieldParticles[i].base.active == 0) {
- slotFound = 1;
- *index = i + 28;
- params = &sEffTable.shieldParticles[i].params;
- common = &sEffTable.shieldParticles[i].base;
+ if (sEffectContext.shieldParticles[i].status.active == false) {
+ slotFound = true;
+ *pIndex = i + SPARK_COUNT + BLURE_COUNT;
+ effect = &sEffectContext.shieldParticles[i].effect;
+ status = &sEffectContext.shieldParticles[i].status;
break;
}
}
break;
- case 4:
+ case EFFECT_TIRE_MARK:
for (i = 0; i < TIRE_MARK_COUNT; i++) {
- if (sEffTable.tireMarks[i].base.active == 0) {
- slotFound = 1;
- *index = i + 31;
- params = &sEffTable.tireMarks[i].params;
- common = &sEffTable.tireMarks[i].base;
+ if (sEffectContext.tireMarks[i].status.active == false) {
+ slotFound = true;
+ *pIndex = i + SPARK_COUNT + BLURE_COUNT + SHIELD_PARTICLE_COUNT;
+ effect = &sEffectContext.tireMarks[i].effect;
+ status = &sEffectContext.tireMarks[i].status;
break;
}
}
@@ -175,10 +175,10 @@ void Effect_Add(GlobalContext* globalCtx, s32* index, s32 type, u8 param_4, u8 p
}
if (slotFound) {
- sEffInfoTable[type].init(params, initParams);
- common->unk2 = param_4;
- common->unk1 = param_5;
- common->active = 1;
+ sEffectInfoTable[type].init(effect, initParams);
+ status->unk2 = arg3;
+ status->unk1 = arg4;
+ status->active = true;
}
}
}
@@ -188,8 +188,8 @@ void Effect_DrawAll(GraphicsContext* gfxCtx) {
for (i = 0; i < SPARK_COUNT; i++) {
if (1) {} // necessary to match
- if (sEffTable.sparks[i].base.active) {
- sEffInfoTable[0].draw(&sEffTable.sparks[i].params, gfxCtx);
+ if (sEffectContext.sparks[i].status.active) {
+ sEffectInfoTable[EFFECT_SPARK].draw(&sEffectContext.sparks[i].effect, gfxCtx);
}
}
@@ -197,22 +197,22 @@ void Effect_DrawAll(GraphicsContext* gfxCtx) {
if (1) {
if (gfxCtx) {}
} // necessary to match
- if (sEffTable.blures[i].base.active) {
- sEffInfoTable[1].draw(&sEffTable.blures[i].params, gfxCtx);
+ if (sEffectContext.blures[i].status.active) {
+ sEffectInfoTable[EFFECT_BLURE1].draw(&sEffectContext.blures[i].effect, gfxCtx);
}
}
for (i = 0; i < SHIELD_PARTICLE_COUNT; i++) {
if (1) {} // necessary to match
- if (sEffTable.shieldParticles[i].base.active) {
- sEffInfoTable[3].draw(&sEffTable.shieldParticles[i].params, gfxCtx);
+ if (sEffectContext.shieldParticles[i].status.active) {
+ sEffectInfoTable[EFFECT_SHIELD_PARTICLE].draw(&sEffectContext.shieldParticles[i].effect, gfxCtx);
}
}
if (1) {} // necessary to match
for (i = 0; i < TIRE_MARK_COUNT; i++) {
- if (sEffTable.tireMarks[i].base.active) {
- sEffInfoTable[4].draw(&sEffTable.tireMarks[i].params, gfxCtx);
+ if (sEffectContext.tireMarks[i].status.active) {
+ sEffectInfoTable[EFFECT_TIRE_MARK].draw(&sEffectContext.tireMarks[i].effect, gfxCtx);
}
}
}
@@ -222,8 +222,8 @@ void Effect_UpdateAll(GlobalContext* globalCtx) {
for (i = 0; i < SPARK_COUNT; i++) {
if (1) {} // necessary to match
- if (sEffTable.sparks[i].base.active) {
- if (sEffInfoTable[0].update(&sEffTable.sparks[i].params) == 1) {
+ if (sEffectContext.sparks[i].status.active) {
+ if (sEffectInfoTable[EFFECT_SPARK].update(&sEffectContext.sparks[i].effect) == 1) {
Effect_Destroy(globalCtx, i);
}
}
@@ -231,27 +231,27 @@ void Effect_UpdateAll(GlobalContext* globalCtx) {
for (i = 0; i < BLURE_COUNT; i++) {
if (1) {} // necessary to match
- if (sEffTable.blures[i].base.active) {
- if (sEffInfoTable[1].update(&sEffTable.blures[i].params) == 1) {
- Effect_Destroy(globalCtx, i + 3);
+ if (sEffectContext.blures[i].status.active) {
+ if (sEffectInfoTable[EFFECT_BLURE1].update(&sEffectContext.blures[i].effect) == 1) {
+ Effect_Destroy(globalCtx, i + SPARK_COUNT);
}
}
}
for (i = 0; i < SHIELD_PARTICLE_COUNT; i++) {
if (1) {} // necessary to match
- if (sEffTable.shieldParticles[i].base.active) {
- if (sEffInfoTable[3].update(&sEffTable.shieldParticles[i].params) == 1) {
- Effect_Destroy(globalCtx, i + 28);
+ if (sEffectContext.shieldParticles[i].status.active) {
+ if (sEffectInfoTable[EFFECT_SHIELD_PARTICLE].update(&sEffectContext.shieldParticles[i].effect) == 1) {
+ Effect_Destroy(globalCtx, i + SPARK_COUNT + BLURE_COUNT);
}
}
}
for (i = 0; i < TIRE_MARK_COUNT; i++) {
if (1) {} // necessary to match
- if (sEffTable.tireMarks[i].base.active) {
- if (sEffInfoTable[4].update(&sEffTable.tireMarks[i].params) == 1) {
- Effect_Destroy(globalCtx, i + 31);
+ if (sEffectContext.tireMarks[i].status.active) {
+ if (sEffectInfoTable[EFFECT_TIRE_MARK].update(&sEffectContext.tireMarks[i].effect) == 1) {
+ Effect_Destroy(globalCtx, i + SPARK_COUNT + BLURE_COUNT + SHIELD_PARTICLE_COUNT);
}
}
}
@@ -263,29 +263,29 @@ void Effect_Destroy(GlobalContext* globalCtx, s32 index) {
}
if (index < SPARK_COUNT) {
- sEffTable.sparks[index].base.active = 0;
- sEffInfoTable[0].destroy(&sEffTable.sparks[index].params);
+ sEffectContext.sparks[index].status.active = false;
+ sEffectInfoTable[EFFECT_SPARK].destroy(&sEffectContext.sparks[index].effect);
return;
}
index -= SPARK_COUNT;
if (index < BLURE_COUNT) {
- sEffTable.blures[index].base.active = 0;
- sEffInfoTable[1].destroy(&sEffTable.blures[index].params);
+ sEffectContext.blures[index].status.active = false;
+ sEffectInfoTable[EFFECT_BLURE1].destroy(&sEffectContext.blures[index].effect);
return;
}
index -= BLURE_COUNT;
if (index < SHIELD_PARTICLE_COUNT) {
- sEffTable.shieldParticles[index].base.active = 0;
- sEffInfoTable[3].destroy(&sEffTable.shieldParticles[index].params);
+ sEffectContext.shieldParticles[index].status.active = false;
+ sEffectInfoTable[EFFECT_SHIELD_PARTICLE].destroy(&sEffectContext.shieldParticles[index].effect);
return;
}
index -= SHIELD_PARTICLE_COUNT;
if (index < TIRE_MARK_COUNT) {
- sEffTable.tireMarks[index].base.active = 0;
- sEffInfoTable[4].destroy(&sEffTable.tireMarks[index].params);
+ sEffectContext.tireMarks[index].status.active = false;
+ sEffectInfoTable[EFFECT_TIRE_MARK].destroy(&sEffectContext.tireMarks[index].effect);
return;
}
}
@@ -294,22 +294,22 @@ void Effect_DestroyAll(GlobalContext* globalCtx) {
s32 i;
for (i = 0; i < SPARK_COUNT; i++) {
- sEffTable.sparks[i].base.active = 0;
- sEffInfoTable[0].destroy(&sEffTable.sparks[i].params);
+ sEffectContext.sparks[i].status.active = false;
+ sEffectInfoTable[EFFECT_SPARK].destroy(&sEffectContext.sparks[i].effect);
}
for (i = 0; i < BLURE_COUNT; i++) {
- sEffTable.blures[i].base.active = 0;
- sEffInfoTable[1].destroy(&sEffTable.blures[i].params);
+ sEffectContext.blures[i].status.active = false;
+ sEffectInfoTable[EFFECT_BLURE1].destroy(&sEffectContext.blures[i].effect);
}
for (i = 0; i < SHIELD_PARTICLE_COUNT; i++) {
- sEffTable.shieldParticles[i].base.active = 0;
- sEffInfoTable[3].destroy(&sEffTable.shieldParticles[i].params);
+ sEffectContext.shieldParticles[i].status.active = false;
+ sEffectInfoTable[EFFECT_SHIELD_PARTICLE].destroy(&sEffectContext.shieldParticles[i].effect);
}
for (i = 0; i < TIRE_MARK_COUNT; i++) {
- sEffTable.tireMarks[i].base.active = 0;
- sEffInfoTable[4].destroy(&sEffTable.tireMarks[i].params);
+ sEffectContext.tireMarks[i].status.active = false;
+ sEffectInfoTable[EFFECT_TIRE_MARK].destroy(&sEffectContext.tireMarks[i].effect);
}
}
diff --git a/src/code/z_effect_soft_sprite_old_init.c b/src/code/z_effect_soft_sprite_old_init.c
index 6deeb7943..4303d3db2 100644
--- a/src/code/z_effect_soft_sprite_old_init.c
+++ b/src/code/z_effect_soft_sprite_old_init.c
@@ -590,7 +590,7 @@ extern Vec3f D_801AE3E0;
void func_800B2364(GlobalContext* globalCtx, Vec3f* pos, Gfx* dList) {
Vec3f posVec = D_801AE3E0;
- EffectSsHahen_Spawn(globalCtx, pos, &D_801D15B0, &posVec, 1, 5, 1, 10, dList);
+ EffectSsHahen_Spawn(globalCtx, pos, &gZeroVec3f, &posVec, 1, 5, 1, 10, dList);
}
// EffectSsStick Spawn Functions
@@ -1032,7 +1032,7 @@ void EffectSsDeadDs_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity,
}
void func_800B31BC(GlobalContext* globalCtx, Vec3f* pos, s16 scale, s16 scaleStep, s16 alpha, s32 life) {
- EffectSsDeadDs_Spawn(globalCtx, pos, &D_801D15B0, &D_801D15B0, scale, scaleStep, alpha, life);
+ EffectSsDeadDs_Spawn(globalCtx, pos, &gZeroVec3f, &gZeroVec3f, scale, scaleStep, alpha, life);
}
// EffectSsIceSmoke Spawn Functions
diff --git a/src/code/z_fireobj.c b/src/code/z_fireobj.c
index 6e543d115..7c5de646a 100644
--- a/src/code/z_fireobj.c
+++ b/src/code/z_fireobj.c
@@ -1,5 +1,6 @@
#include "global.h"
#include "overlays/actors/ovl_En_Arrow/z_en_arrow.h"
+#include "objects/gameplay_keep/gameplay_keep.h"
typedef enum {
FIRE_STATE_0,
@@ -162,7 +163,7 @@ void FireObj_Draw(GlobalContext* globalCtx, FireObj* fire) {
Matrix_Scale(fire->xScale, fire->yScale, 1.0f, MTXMODE_APPLY);
gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
- gSPDisplayList(POLY_XLU_DISP++, D_0407D590);
+ gSPDisplayList(POLY_XLU_DISP++, gGameplayKeepDrawFlameDL);
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
}
diff --git a/src/code/z_kaleido_manager.c b/src/code/z_kaleido_manager.c
index c79b0067f..318b033f6 100644
--- a/src/code/z_kaleido_manager.c
+++ b/src/code/z_kaleido_manager.c
@@ -1,15 +1,104 @@
#include "global.h"
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_manager/D_801DF9C0.s")
+#define KALEIDO_OVERLAY(name) \
+ { \
+ NULL, SEGMENT_ROM_START(ovl_##name), SEGMENT_ROM_END(ovl_##name), SEGMENT_START(ovl_##name), \
+ SEGMENT_END(ovl_##name), 0, #name, \
+ }
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_manager/func_80163700.s")
+KaleidoMgrOverlay gKaleidoMgrOverlayTable[] = {
+ KALEIDO_OVERLAY(kaleido_scope),
+ KALEIDO_OVERLAY(player_actor),
+};
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_manager/func_80163758.s")
+void* sKaleidoAreaPtr = NULL;
+KaleidoMgrOverlay* gKaleidoMgrCurOvl = NULL;
+FaultAddrConvClient sKaleidoAreaFaultClient;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_manager/func_801637B4.s")
+void* KaleidoManager_FaultAddrConvFunc(void* address, void* param) {
+ u8* ptr = address;
+ KaleidoMgrOverlay* ovl = &gKaleidoMgrCurOvl[0];
+ u8* ramStart;
+ u8* ramEnd;
+ size_t size;
+ uintptr_t offset;
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_manager/func_80163804.s")
+ if (ovl != NULL) {
+ size = (u8*)ovl->vramEnd - (u8*)ovl->vramStart;
+ ramStart = ovl->loadedRamAddr;
+ ramEnd = ramStart + size;
+ offset = (u8*)ovl->vramStart - ramStart;
+ if (ramStart != NULL) {
+ if (ptr >= ramStart && ptr < ramEnd) {
+ return ptr + offset;
+ }
+ }
+ }
+ return NULL;
+}
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_manager/func_8016388C.s")
+void KaleidoManager_LoadOvl(KaleidoMgrOverlay* ovl) {
+ ovl->loadedRamAddr = sKaleidoAreaPtr;
+ Load2_LoadOverlay(ovl->vromStart, ovl->vromEnd, ovl->vramStart, ovl->vramEnd, ovl->loadedRamAddr);
+ ovl->offset = (uintptr_t)ovl->loadedRamAddr - (uintptr_t)ovl->vramStart;
+ gKaleidoMgrCurOvl = ovl;
+}
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_manager/func_801638D8.s")
+void KaleidoManager_ClearOvl(KaleidoMgrOverlay* ovl) {
+ if (ovl->loadedRamAddr != NULL) {
+ ovl->offset = 0;
+ bzero(ovl->loadedRamAddr, (uintptr_t)ovl->vramEnd - (uintptr_t)ovl->vramStart);
+ ovl->loadedRamAddr = NULL;
+ gKaleidoMgrCurOvl = NULL;
+ }
+}
+
+void KaleidoManager_Init(GlobalContext* globalCtx) {
+ s32 largestSize = 0;
+ s32 size;
+ u32 i;
+
+ for (i = 0; i < ARRAY_COUNT(gKaleidoMgrOverlayTable); i++) {
+ size = (uintptr_t)gKaleidoMgrOverlayTable[i].vramEnd - (uintptr_t)gKaleidoMgrOverlayTable[i].vramStart;
+ if (size > largestSize) {
+ largestSize = size;
+ }
+ }
+
+ sKaleidoAreaPtr = THA_AllocEndAlign16(&globalCtx->state.heap, largestSize);
+ gKaleidoMgrCurOvl = NULL;
+ Fault_AddAddrConvClient(&sKaleidoAreaFaultClient, KaleidoManager_FaultAddrConvFunc, NULL);
+}
+
+void KaleidoManager_Destroy() {
+ Fault_RemoveAddrConvClient(&sKaleidoAreaFaultClient);
+
+ if (gKaleidoMgrCurOvl != NULL) {
+ KaleidoManager_ClearOvl(gKaleidoMgrCurOvl);
+ gKaleidoMgrCurOvl = NULL;
+ }
+
+ sKaleidoAreaPtr = NULL;
+}
+
+void* KaleidoManager_GetRamAddr(void* vram) {
+ if (gKaleidoMgrCurOvl == NULL) {
+ s32 pad[2];
+ KaleidoMgrOverlay* ovl = &gKaleidoMgrOverlayTable[0];
+
+ do {
+ if (((uintptr_t)vram >= (uintptr_t)ovl->vramStart) && ((uintptr_t)ovl->vramEnd >= (uintptr_t)vram)) {
+ KaleidoManager_LoadOvl(ovl);
+ return (void*)((uintptr_t)vram + ovl->offset);
+ }
+ ovl++;
+ } while (ovl != (KaleidoMgrOverlay*)&sKaleidoAreaPtr);
+
+ return NULL;
+ } else if (((uintptr_t)vram < (uintptr_t)gKaleidoMgrCurOvl->vramStart) ||
+ ((uintptr_t)vram >= (uintptr_t)gKaleidoMgrCurOvl->vramEnd)) {
+ return NULL;
+ }
+
+ return (void*)((uintptr_t)vram + gKaleidoMgrCurOvl->offset);
+}
diff --git a/src/code/z_kaleido_scope_call.c b/src/code/z_kaleido_scope_call.c
index 58f30ae16..b6d46eba1 100644
--- a/src/code/z_kaleido_scope_call.c
+++ b/src/code/z_kaleido_scope_call.c
@@ -1,11 +1,84 @@
#include "global.h"
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_scope_call/func_801639A0.s")
+void (*sKaleidoScopeUpdateFunc)(GlobalContext* globalCtx);
+void (*sKaleidoScopeDrawFunc)(GlobalContext* globalCtx);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_scope_call/func_801639EC.s")
+extern void KaleidoScope_Update(GlobalContext* globalCtx);
+extern void KaleidoScope_Draw(GlobalContext* globalCtx);
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_scope_call/func_80163A38.s")
+void KaleidoScopeCall_LoadPlayer() {
+ KaleidoMgrOverlay* playerActorOvl = &gKaleidoMgrOverlayTable[KALEIDO_OVL_PLAYER_ACTOR];
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_scope_call/func_80163A58.s")
+ if (gKaleidoMgrCurOvl != playerActorOvl) {
+ if (gKaleidoMgrCurOvl != NULL) {
+ KaleidoManager_ClearOvl(gKaleidoMgrCurOvl);
+ }
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_scope_call/func_80163C0C.s")
+ KaleidoManager_LoadOvl(playerActorOvl);
+ }
+}
+
+void KaleidoScopeCall_Init(GlobalContext* globalCtx) {
+ sKaleidoScopeUpdateFunc = KaleidoManager_GetRamAddr(KaleidoScope_Update);
+ sKaleidoScopeDrawFunc = KaleidoManager_GetRamAddr(KaleidoScope_Draw);
+ KaleidoSetup_Init(globalCtx);
+}
+
+void KaleidoScopeCall_Destroy(GlobalContext* globalCtx) {
+ KaleidoSetup_Destroy(globalCtx);
+}
+
+void KaleidoScopeCall_Update(GlobalContext* globalCtx) {
+ PauseContext* pauseCtx = &globalCtx->pauseCtx;
+ KaleidoMgrOverlay* kaleidoScopeOvl = &gKaleidoMgrOverlayTable[KALEIDO_OVL_KALEIDO_SCOPE];
+
+ if ((globalCtx->pauseCtx.state != 0) || (globalCtx->pauseCtx.debugState != 0)) {
+ if (pauseCtx->state == 1 || pauseCtx->state == 19) {
+ if (ShrinkWindow_GetLetterboxMagnitude() == 0) {
+ R_PAUSE_MENU_MODE = 1;
+ pauseCtx->unk_200 = 0;
+ pauseCtx->unk_208 = 0;
+ pauseCtx->state = (pauseCtx->state & 0xFFFF) + 1;
+ }
+ } else if (pauseCtx->state == 8) {
+ R_PAUSE_MENU_MODE = 1;
+ pauseCtx->unk_200 = 0;
+ pauseCtx->unk_208 = 0;
+ pauseCtx->state = (pauseCtx->state & 0xFFFF) + 1;
+ } else if ((pauseCtx->state == 2) || (pauseCtx->state == 9) || (pauseCtx->state == 20)) {
+ if (R_PAUSE_MENU_MODE == 3) {
+ pauseCtx->state++;
+ }
+ } else if (pauseCtx->state != 0) {
+ if (gKaleidoMgrCurOvl != kaleidoScopeOvl) {
+ if (gKaleidoMgrCurOvl != NULL) {
+ KaleidoManager_ClearOvl(gKaleidoMgrCurOvl);
+ }
+
+ KaleidoManager_LoadOvl(kaleidoScopeOvl);
+ }
+
+ if (gKaleidoMgrCurOvl == kaleidoScopeOvl) {
+ sKaleidoScopeUpdateFunc(globalCtx);
+
+ if ((globalCtx->pauseCtx.state == 0) && (globalCtx->pauseCtx.debugState == 0)) {
+ KaleidoManager_ClearOvl(kaleidoScopeOvl);
+ KaleidoScopeCall_LoadPlayer();
+ }
+ }
+ }
+ }
+}
+
+void KaleidoScopeCall_Draw(GlobalContext* globalCtx) {
+ KaleidoMgrOverlay* kaleidoScopeOvl = &gKaleidoMgrOverlayTable[KALEIDO_OVL_KALEIDO_SCOPE];
+
+ if (R_PAUSE_MENU_MODE == 3) {
+ if (((globalCtx->pauseCtx.state >= 4) && (globalCtx->pauseCtx.state <= 7)) ||
+ ((globalCtx->pauseCtx.state >= 11) && (globalCtx->pauseCtx.state <= 26))) {
+ if (gKaleidoMgrCurOvl == kaleidoScopeOvl) {
+ sKaleidoScopeDrawFunc(globalCtx);
+ }
+ }
+ }
+}
diff --git a/src/code/z_kaleido_setup.c b/src/code/z_kaleido_setup.c
index 8065a9a6b..7f4d43784 100644
--- a/src/code/z_kaleido_setup.c
+++ b/src/code/z_kaleido_setup.c
@@ -4,6 +4,6 @@
#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_setup/func_800F4C0C.s")
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_setup/func_800F4E20.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_setup/KaleidoSetup_Init.s")
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_setup/func_800F4F28.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_kaleido_setup/KaleidoSetup_Destroy.s")
diff --git a/src/code/z_parameter.c b/src/code/z_parameter.c
index b7c1c9a10..098b15957 100644
--- a/src/code/z_parameter.c
+++ b/src/code/z_parameter.c
@@ -1479,7 +1479,7 @@ void func_801149A0(s16 itemId, s16 invSlot) {
s16 new_var;
s32 phi_a1;
- gSaveContext.save.inventory.items[invSlot] = ITEM_NONE;;
+ gSaveContext.save.inventory.items[invSlot] = ITEM_NONE;
for (i = 1; i < 4; i++) {
if (i == 0) {
@@ -1491,15 +1491,15 @@ void func_801149A0(s16 itemId, s16 invSlot) {
if (itemId == (phi_a1 & 0xFF)) {
if (i == 0) {
phi_a1 = CUR_FORM;
- gSaveContext.save.equips.buttonItems[phi_a1][i] = ITEM_NONE;;
+ gSaveContext.save.equips.buttonItems[phi_a1][i] = ITEM_NONE;
} else {
- gSaveContext.save.equips.buttonItems[0][i] = ITEM_NONE;;
+ gSaveContext.save.equips.buttonItems[0][i] = ITEM_NONE;
}
if (i == 0) {
phi_a1 = CUR_FORM;
- gSaveContext.save.equips.cButtonSlots[phi_a1][i] = ITEM_NONE;;
+ gSaveContext.save.equips.cButtonSlots[phi_a1][i] = ITEM_NONE;
} else {
- gSaveContext.save.equips.cButtonSlots[0][i] = ITEM_NONE;;
+ gSaveContext.save.equips.cButtonSlots[0][i] = ITEM_NONE;
}
}
}
@@ -2356,7 +2356,6 @@ void func_8011B4E0(GlobalContext* globalCtx, s16 arg1) {
interfaceCtx->unk_28A[0] = 1;
}
-
s32 D_801BFC50[] = {
0xC000E000,
0x00002000,
@@ -2373,7 +2372,6 @@ s32 D_801BFC64[] = {
void func_8011B5C0(GlobalContext* globalCtx);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/func_8011B5C0.s")
-
s16 D_801BFC6C[] = {
0x004E, 0x0036, 0x001D, 0x0005, 0xFFEE, 0xFFD6, 0xFFBD, 0xFFAB,
};
@@ -2388,7 +2386,6 @@ s32 D_801BFC8C[] = {
void func_8011B9E0(GlobalContext* globalCtx);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/func_8011B9E0.s")
-
s32 D_801BFC98[] = {
0x004E0036,
0x001D0005,
@@ -2409,7 +2406,6 @@ s32 D_801BFCB8[] = {
void func_8011BF70(GlobalContext* globalCtx);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/func_8011BF70.s")
-
TexturePtr D_801BFCC4[] = {
gMinigameLetterPTex, gMinigameLetterETex, gMinigameLetterRTex, gMinigameLetterFTex,
gMinigameLetterETex, gMinigameLetterCTex, gMinigameLetterTTex, gMinigameExclamationTex,
@@ -2417,7 +2413,6 @@ TexturePtr D_801BFCC4[] = {
void func_8011C4C4(GlobalContext* globalCtx);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/func_8011C4C4.s")
-
#ifdef NON_MATCHING
void func_8011C808(GlobalContext* globalCtx) {
if (globalCtx->actorCtx.unk5 & 2) {
@@ -2438,7 +2433,6 @@ void func_8011C808(GlobalContext* globalCtx) {
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/func_8011C898.s")
-
s32 D_801BFCE4[] = {
0x00000000,
};
@@ -2466,15 +2460,12 @@ s16 D_801BFD0C[] = {
void func_8011CA64(GlobalContext* globalCtx);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/func_8011CA64.s")
-
void func_8011E3B4(GlobalContext* globalCtx);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/func_8011E3B4.s")
-
void func_8011E730(GlobalContext* globalCtx);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/func_8011E730.s")
-
// rupeeDigitsFirst
s16 D_801BFD1C[] = { 1, 0, 0, 0 };
// rupeeDigitsCount
diff --git a/src/code/z_room.c b/src/code/z_room.c
index fe4b51d68..1685acc80 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -18,14 +18,14 @@ void Room_DrawType0Mesh(GlobalContext* globalCtx, Room* room, u32 flags) {
func_800BCBF4(&D_801C1D10, globalCtx);
gSPSegment(gfxCtx->polyOpa.p++, 0x03, room->segment);
func_8012C268(globalCtx);
- gSPMatrix(gfxCtx->polyOpa.p++, &D_801D1DE0, G_MTX_MODELVIEW | G_MTX_LOAD);
+ gSPMatrix(gfxCtx->polyOpa.p++, &gIdentityMtx, G_MTX_MODELVIEW | G_MTX_LOAD);
}
if (flags & 2) {
func_800BCC68(&D_801C1D10, globalCtx);
gSPSegment(gfxCtx->polyXlu.p++, 0x03, room->segment);
func_8012C2DC(globalCtx->state.gfxCtx);
- gSPMatrix(gfxCtx->polyXlu.p++, &D_801D1DE0, G_MTX_MODELVIEW | G_MTX_LOAD);
+ gSPMatrix(gfxCtx->polyXlu.p++, &gIdentityMtx, G_MTX_MODELVIEW | G_MTX_LOAD);
}
mesh = &room->mesh->type0;
generated by cgit v1.2.3 (git 2.25.1) at 2026-10-24 20:53:21 +0000