EffectSs Sync (#1799)

* gEffectSsOverlayTable

* Sync with OoT docs

5 files changed, 172 insertions, 166 deletions

diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index 7a21566ba..e54fc18e7 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -3187,7 +3187,7 @@ void Actor_DrawAll(PlayState* play, ActorContext* actorCtx) {
     }
 
     Effect_DrawAll(play->state.gfxCtx);
-    EffectSS_DrawAllParticles(play);
+    EffectSs_DrawAll(play);
     EffFootmark_Draw(play);
 
     ref2 = POLY_XLU_DISP;
diff --git a/src/code/z_eff_blure.c b/src/code/z_eff_blure.c
index d31155042..ebfe79bff 100644
--- a/src/code/z_eff_blure.c
+++ b/src/code/z_eff_blure.c
@@ -310,9 +310,9 @@ void EffectBlure_GetComputedValues(EffectBlure* this, s32 index, f32 ratio, Vec3
 
     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);
+            vec1->x = EffectSs_LerpS16(elem->p1.x, elem->p2.x, ratio);
+            vec1->y = EffectSs_LerpS16(elem->p1.y, elem->p2.y, ratio);
+            vec1->z = EffectSs_LerpS16(elem->p1.z, elem->p2.z, ratio);
             vec2->x = elem->p2.x;
             vec2->y = elem->p2.y;
             vec2->z = elem->p2.z;
@@ -322,19 +322,19 @@ void EffectBlure_GetComputedValues(EffectBlure* this, s32 index, f32 ratio, Vec3
             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);
+            vec2->x = EffectSs_LerpS16(elem->p2.x, elem->p1.x, ratio);
+            vec2->y = EffectSs_LerpS16(elem->p2.y, elem->p1.y, ratio);
+            vec2->z = EffectSs_LerpS16(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);
+            vec1->x = EffectSs_LerpS16(elem->p1.x, elem->p2.x, ratio);
+            vec1->y = EffectSs_LerpS16(elem->p1.y, elem->p2.y, ratio);
+            vec1->z = EffectSs_LerpS16(elem->p1.z, elem->p2.z, ratio);
+            vec2->x = EffectSs_LerpS16(elem->p2.x, elem->p1.x, ratio);
+            vec2->y = EffectSs_LerpS16(elem->p2.y, elem->p1.y, ratio);
+            vec2->z = EffectSs_LerpS16(elem->p2.z, elem->p1.z, ratio);
             ratio *= 2.0f;
             break;
 
@@ -370,14 +370,14 @@ void EffectBlure_GetComputedValues(EffectBlure* this, s32 index, f32 ratio, Vec3
         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[0], this->p1EndColor[0], ratio);
-        color1->g = func_800B0A24(this->p1StartColor[1], this->p1EndColor[1], ratio);
-        color1->b = func_800B0A24(this->p1StartColor[2], this->p1EndColor[2], ratio);
-        color1->a = func_800B0A24(this->p1StartColor[3], this->p1EndColor[3], ratio);
-        color2->r = func_800B0A24(this->p2StartColor[0], this->p2EndColor[0], ratio);
-        color2->g = func_800B0A24(this->p2StartColor[1], this->p2EndColor[1], ratio);
-        color2->b = func_800B0A24(this->p2StartColor[2], this->p2EndColor[2], ratio);
-        color2->a = func_800B0A24(this->p2StartColor[3], this->p2EndColor[3], ratio);
+        color1->r = EffectSs_LerpU8(this->p1StartColor[0], this->p1EndColor[0], ratio);
+        color1->g = EffectSs_LerpU8(this->p1StartColor[1], this->p1EndColor[1], ratio);
+        color1->b = EffectSs_LerpU8(this->p1StartColor[2], this->p1EndColor[2], ratio);
+        color1->a = EffectSs_LerpU8(this->p1StartColor[3], this->p1EndColor[3], ratio);
+        color2->r = EffectSs_LerpU8(this->p2StartColor[0], this->p2EndColor[0], ratio);
+        color2->g = EffectSs_LerpU8(this->p2StartColor[1], this->p2EndColor[1], ratio);
+        color2->b = EffectSs_LerpU8(this->p2StartColor[2], this->p2EndColor[2], ratio);
+        color2->a = EffectSs_LerpU8(this->p2StartColor[3], this->p2EndColor[3], ratio);
     }
 }
 
@@ -620,18 +620,18 @@ void EffectBlure_DrawElemHermiteInterpolation(EffectBlure* this, EffectBlureElem
             vtx[j1].v.ob[0] = Math_FNearbyIntF(sp158.x);
             vtx[j1].v.ob[1] = Math_FNearbyIntF(sp158.y);
             vtx[j1].v.ob[2] = Math_FNearbyIntF(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);
+            vtx[j1].v.cn[0] = EffectSs_LerpU8(sp1A4.r, sp19C.r, temp_f28);
+            vtx[j1].v.cn[1] = EffectSs_LerpU8(sp1A4.g, sp19C.g, temp_f28);
+            vtx[j1].v.cn[2] = EffectSs_LerpU8(sp1A4.b, sp19C.b, temp_f28);
+            vtx[j1].v.cn[3] = EffectSs_LerpU8(sp1A4.a, sp19C.a, temp_f28);
 
             vtx[j2].v.ob[0] = Math_FNearbyIntF(sp14C.x);
             vtx[j2].v.ob[1] = Math_FNearbyIntF(sp14C.y);
             vtx[j2].v.ob[2] = Math_FNearbyIntF(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);
+            vtx[j2].v.cn[0] = EffectSs_LerpU8(sp1A0.r, sp198.r, temp_f28);
+            vtx[j2].v.cn[1] = EffectSs_LerpU8(sp1A0.g, sp198.g, temp_f28);
+            vtx[j2].v.cn[2] = EffectSs_LerpU8(sp1A0.b, sp198.b, temp_f28);
+            vtx[j2].v.cn[3] = EffectSs_LerpU8(sp1A0.a, sp198.a, temp_f28);
         }
 
         gSPVertex(POLY_XLU_DISP++, vtx, 16, 0);
@@ -961,9 +961,9 @@ void EffectBlure_Draw(void* thisx, GraphicsContext* gfxCtx) {
 
                         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].v.ob[0] = EffectSs_LerpS16(elem->p1.x, elem->p2.x, ratio);
+                                vtx[j].v.ob[1] = EffectSs_LerpS16(elem->p1.y, elem->p2.y, ratio);
+                                vtx[j].v.ob[2] = EffectSs_LerpS16(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;
@@ -973,19 +973,19 @@ void EffectBlure_Draw(void* thisx, GraphicsContext* gfxCtx) {
                                 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);
+                                vtx[j + 1].v.ob[0] = EffectSs_LerpS16(elem->p2.x, elem->p1.x, ratio);
+                                vtx[j + 1].v.ob[1] = EffectSs_LerpS16(elem->p2.y, elem->p1.y, ratio);
+                                vtx[j + 1].v.ob[2] = EffectSs_LerpS16(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);
+                                vtx[j].v.ob[0] = EffectSs_LerpS16(elem->p1.x, elem->p2.x, ratio);
+                                vtx[j].v.ob[1] = EffectSs_LerpS16(elem->p1.y, elem->p2.y, ratio);
+                                vtx[j].v.ob[2] = EffectSs_LerpS16(elem->p1.z, elem->p2.z, ratio);
+                                vtx[j + 1].v.ob[0] = EffectSs_LerpS16(elem->p2.x, elem->p1.x, ratio);
+                                vtx[j + 1].v.ob[1] = EffectSs_LerpS16(elem->p2.y, elem->p1.y, ratio);
+                                vtx[j + 1].v.ob[2] = EffectSs_LerpS16(elem->p2.z, elem->p1.z, ratio);
                                 ratio *= 2.0f;
                                 break;
 
@@ -1003,19 +1003,19 @@ void EffectBlure_Draw(void* thisx, GraphicsContext* gfxCtx) {
                         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[0], this->p1EndColor[0], ratio);
-                        vtx[j].v.cn[1] = func_800B0A24(this->p1StartColor[1], this->p1EndColor[1], ratio);
-                        vtx[j].v.cn[2] = func_800B0A24(this->p1StartColor[2], this->p1EndColor[2], ratio);
-                        vtx[j].v.cn[3] = func_800B0A24(this->p1StartColor[3], this->p1EndColor[3], ratio);
+                        vtx[j].v.cn[0] = EffectSs_LerpU8(this->p1StartColor[0], this->p1EndColor[0], ratio);
+                        vtx[j].v.cn[1] = EffectSs_LerpU8(this->p1StartColor[1], this->p1EndColor[1], ratio);
+                        vtx[j].v.cn[2] = EffectSs_LerpU8(this->p1StartColor[2], this->p1EndColor[2], ratio);
+                        vtx[j].v.cn[3] = EffectSs_LerpU8(this->p1StartColor[3], this->p1EndColor[3], 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[0], this->p2EndColor[0], ratio);
-                        vtx[j].v.cn[1] = func_800B0A24(this->p2StartColor[1], this->p2EndColor[1], ratio);
-                        vtx[j].v.cn[2] = func_800B0A24(this->p2StartColor[2], this->p2EndColor[2], ratio);
-                        vtx[j].v.cn[3] = func_800B0A24(this->p2StartColor[3], this->p2EndColor[3], ratio);
+                        vtx[j].v.cn[0] = EffectSs_LerpU8(this->p2StartColor[0], this->p2EndColor[0], ratio);
+                        vtx[j].v.cn[1] = EffectSs_LerpU8(this->p2StartColor[1], this->p2EndColor[1], ratio);
+                        vtx[j].v.cn[2] = EffectSs_LerpU8(this->p2StartColor[2], this->p2EndColor[2], ratio);
+                        vtx[j].v.cn[3] = EffectSs_LerpU8(this->p2StartColor[3], this->p2EndColor[3], ratio);
                         j++;
                     }
                 }
diff --git a/src/code/z_effect_soft_sprite.c b/src/code/z_effect_soft_sprite.c
index 8fd5d2568..dedd91290 100644
--- a/src/code/z_effect_soft_sprite.c
+++ b/src/code/z_effect_soft_sprite.c
@@ -5,50 +5,48 @@
 #include "zelda_arena.h"
 #include "global.h"
 
-void EffectSS_ResetEntry(EffectSs* particle);
+void EffectSs_Reset(EffectSs* effectSs);
 
 EffectSsInfo sEffectSsInfo = { NULL, 0, 0 };
 
-void EffectSS_Init(PlayState* play, s32 numEntries) {
+void EffectSs_InitInfo(PlayState* play, s32 tableSize) {
     u32 i;
-    EffectSs* effectsSs;
+    EffectSs* effectSs;
     EffectSsOverlay* overlay;
 
-    sEffectSsInfo.dataTable = (EffectSs*)THA_AllocTailAlign16(&play->state.tha, numEntries * sizeof(EffectSs));
-    sEffectSsInfo.searchIndex = 0;
-    sEffectSsInfo.size = numEntries;
+    sEffectSsInfo.table = (EffectSs*)THA_AllocTailAlign16(&play->state.tha, tableSize * sizeof(EffectSs));
+    sEffectSsInfo.searchStartIndex = 0;
+    sEffectSsInfo.tableSize = tableSize;
 
-    for (effectsSs = &sEffectSsInfo.dataTable[0]; effectsSs < &sEffectSsInfo.dataTable[sEffectSsInfo.size];
-         effectsSs++) {
-        EffectSS_ResetEntry(effectsSs);
+    for (effectSs = &sEffectSsInfo.table[0]; effectSs < &sEffectSsInfo.table[sEffectSsInfo.tableSize]; effectSs++) {
+        EffectSs_Reset(effectSs);
     }
 
-    overlay = &gParticleOverlayTable[0];
-    for (i = 0; i < EFFECT_SS_MAX; i++) {
+    overlay = &gEffectSsOverlayTable[0];
+    for (i = 0; i < EFFECT_SS_TYPE_MAX; i++) {
         overlay->loadedRamAddr = NULL;
         overlay++;
     }
 }
 
-void EffectSS_Clear(PlayState* play) {
+void EffectSs_ClearAll(PlayState* play) {
     u32 i;
-    EffectSs* effectsSs;
+    EffectSs* effectSs;
     EffectSsOverlay* overlay;
     void* addr;
 
-    sEffectSsInfo.dataTable = NULL;
-    sEffectSsInfo.searchIndex = 0;
-    sEffectSsInfo.size = 0;
+    sEffectSsInfo.table = NULL;
+    sEffectSsInfo.searchStartIndex = 0;
+    sEffectSsInfo.tableSize = 0;
 
     //! @bug: Effects left in the table are not properly deleted, as dataTable was just set to NULL and size to 0
-    for (effectsSs = &sEffectSsInfo.dataTable[0]; effectsSs < &sEffectSsInfo.dataTable[sEffectSsInfo.size];
-         effectsSs++) {
-        EffectSS_Delete(effectsSs);
+    for (effectSs = &sEffectSsInfo.table[0]; effectSs < &sEffectSsInfo.table[sEffectSsInfo.tableSize]; effectSs++) {
+        EffectSs_Delete(effectSs);
     }
 
-    // Free memory from loaded particle overlays
-    overlay = &gParticleOverlayTable[0];
-    for (i = 0; i < EFFECT_SS_MAX; i++) {
+    // Free memory from loaded effectSs overlays
+    overlay = &gEffectSsOverlayTable[0];
+    for (i = 0; i < EFFECT_SS_TYPE_MAX; i++) {
         addr = overlay->loadedRamAddr;
         if (addr != NULL) {
             ZeldaArena_Free(addr);
@@ -59,11 +57,11 @@ void EffectSS_Clear(PlayState* play) {
     }
 }
 
-EffectSs* EffectSS_GetTable() {
-    return sEffectSsInfo.dataTable;
+EffectSs* EffectSs_GetTable(void) {
+    return sEffectSsInfo.table;
 }
 
-void EffectSS_Delete(EffectSs* effectSs) {
+void EffectSs_Delete(EffectSs* effectSs) {
     if (effectSs->flags & 2) {
         AudioSfx_StopByPos(&effectSs->pos);
     }
@@ -72,97 +70,97 @@ void EffectSS_Delete(EffectSs* effectSs) {
         AudioSfx_StopByPos(&effectSs->vec);
     }
 
-    EffectSS_ResetEntry(effectSs);
+    EffectSs_Reset(effectSs);
 }
 
-void EffectSS_ResetEntry(EffectSs* particle) {
+void EffectSs_Reset(EffectSs* effectSs) {
     u32 i;
 
-    particle->type = EFFECT_SS_MAX;
-    particle->accel.x = particle->accel.y = particle->accel.z = 0;
-    particle->velocity.x = particle->velocity.y = particle->velocity.z = 0;
-    particle->vec.x = particle->vec.y = particle->vec.z = 0;
-    particle->pos.x = particle->pos.y = particle->pos.z = 0;
-    particle->life = -1;
-    particle->flags = 0;
-    particle->priority = 128;
-    particle->draw = NULL;
-    particle->update = NULL;
-    particle->gfx = NULL;
-    particle->actor = NULL;
-
-    for (i = 0; i < ARRAY_COUNT(particle->regs); i++) {
-        particle->regs[i] = 0;
+    effectSs->type = EFFECT_SS_TYPE_MAX;
+    effectSs->accel.x = effectSs->accel.y = effectSs->accel.z = 0;
+    effectSs->velocity.x = effectSs->velocity.y = effectSs->velocity.z = 0;
+    effectSs->vec.x = effectSs->vec.y = effectSs->vec.z = 0;
+    effectSs->pos.x = effectSs->pos.y = effectSs->pos.z = 0;
+    effectSs->life = -1;
+    effectSs->flags = 0;
+    effectSs->priority = 128;
+    effectSs->draw = NULL;
+    effectSs->update = NULL;
+    effectSs->gfx = NULL;
+    effectSs->actor = NULL;
+
+    for (i = 0; i < ARRAY_COUNT(effectSs->regs); i++) {
+        effectSs->regs[i] = 0;
     }
 }
 
-s32 EffectSS_FindFreeSpace(s32 priority, s32* tableEntry) {
+s32 EffectSs_FindSlot(s32 priority, s32* index) {
     s32 foundFree;
     s32 i;
 
-    if (sEffectSsInfo.searchIndex >= sEffectSsInfo.size) {
-        sEffectSsInfo.searchIndex = 0;
+    if (sEffectSsInfo.searchStartIndex >= sEffectSsInfo.tableSize) {
+        sEffectSsInfo.searchStartIndex = 0;
     }
 
     // Search for a unused entry
-    i = sEffectSsInfo.searchIndex;
+    i = sEffectSsInfo.searchStartIndex;
     foundFree = false;
     while (true) {
-        if (sEffectSsInfo.dataTable[i].life == -1) {
+        if (sEffectSsInfo.table[i].life == -1) {
             foundFree = true;
             break;
         }
 
         i++;
 
-        if (i >= sEffectSsInfo.size) {
+        if (i >= sEffectSsInfo.tableSize) {
             i = 0; // Loop around the whole table
         }
 
         // After a full loop, break out
-        if (i == sEffectSsInfo.searchIndex) {
+        if (i == sEffectSsInfo.searchStartIndex) {
             break;
         }
     }
 
     if (foundFree == true) {
-        *tableEntry = i;
-        return false;
+        *index = i;
+        return 0;
     }
 
     // If all slots are in use, search for a slot with a lower priority
     // Note that a lower priority is representend by a higher value
-    i = sEffectSsInfo.searchIndex;
+    i = sEffectSsInfo.searchStartIndex;
     while (true) {
         // Equal priority should only be considered "lower" if flag 0 is set
-        if ((priority <= sEffectSsInfo.dataTable[i].priority) &&
-            !((priority == sEffectSsInfo.dataTable[i].priority) && (sEffectSsInfo.dataTable[i].flags & 1))) {
+        if ((priority <= sEffectSsInfo.table[i].priority) &&
+            !((priority == sEffectSsInfo.table[i].priority) && (sEffectSsInfo.table[i].flags & 1))) {
             break;
         }
 
         i++;
 
-        if (i >= sEffectSsInfo.size) {
+        if (i >= sEffectSsInfo.tableSize) {
             i = 0; // Loop around the whole table
         }
 
         // After a full loop, return 1 to indicate that we failed to find a suitable slot
-        if (i == sEffectSsInfo.searchIndex) {
-            return true;
+        if (i == sEffectSsInfo.searchStartIndex) {
+            return 1;
         }
     }
 
-    *tableEntry = i;
-    return false;
+    *index = i;
+    return 0;
 }
 
-void EffectSS_Copy(PlayState* play, EffectSs* effectsSs) {
+void EffectSs_Insert(PlayState* play, EffectSs* effectSs) {
     s32 index;
 
     if (FrameAdvance_IsEnabled(play) != true) {
-        if (EffectSS_FindFreeSpace(effectsSs->priority, &index) == 0) {
-            sEffectSsInfo.searchIndex = index + 1;
-            sEffectSsInfo.dataTable[index] = *effectsSs;
+        if (EffectSs_FindSlot(effectSs->priority, &index) == 0) {
+            sEffectSsInfo.searchStartIndex = index + 1;
+            sEffectSsInfo.table[index] = *effectSs;
         }
     }
 }
@@ -170,15 +168,15 @@ void EffectSS_Copy(PlayState* play, EffectSs* effectsSs) {
 void EffectSs_Spawn(PlayState* play, s32 type, s32 priority, void* initData) {
     s32 index;
     u32 overlaySize;
-    EffectSsOverlay* overlayEntry = &gParticleOverlayTable[type];
+    EffectSsOverlay* overlayEntry = &gEffectSsOverlayTable[type];
     EffectSsProfile* profile;
 
-    if (EffectSS_FindFreeSpace(priority, &index) != 0) {
+    if (EffectSs_FindSlot(priority, &index) != 0) {
         // Abort because we couldn't find a suitable slot to add this effect in
         return;
     }
 
-    sEffectSsInfo.searchIndex = index + 1;
+    sEffectSsInfo.searchStartIndex = index + 1;
     overlaySize = (uintptr_t)overlayEntry->vramEnd - (uintptr_t)overlayEntry->vramStart;
 
     if (overlayEntry->vramStart == NULL) {
@@ -202,94 +200,102 @@ void EffectSs_Spawn(PlayState* play, s32 type, s32 priority, void* initData) {
                                          : NULL);
     }
 
-    if (profile->init != NULL) {
-        // Delete the previous effect in the slot, in case the slot wasn't free
-        EffectSS_Delete(&sEffectSsInfo.dataTable[index]);
+    if (profile->init == NULL) {
+        return;
+    }
 
-        sEffectSsInfo.dataTable[index].type = type;
-        sEffectSsInfo.dataTable[index].priority = priority;
+    // Delete the previous effect in the slot, in case the slot wasn't free
+    EffectSs_Delete(&sEffectSsInfo.table[index]);
 
-        if (profile->init(play, index, &sEffectSsInfo.dataTable[index], initData) == 0) {
-            EffectSS_ResetEntry(&sEffectSsInfo.dataTable[index]);
-        }
+    sEffectSsInfo.table[index].type = type;
+    sEffectSsInfo.table[index].priority = priority;
+
+    if (profile->init(play, index, &sEffectSsInfo.table[index], initData) == 0) {
+        EffectSs_Reset(&sEffectSsInfo.table[index]);
     }
 }
 
-void EffectSS_UpdateParticle(PlayState* play, s32 index) {
-    EffectSs* particle = &sEffectSsInfo.dataTable[index];
+void EffectSs_Update(PlayState* play, s32 index) {
+    EffectSs* effectSs = &sEffectSsInfo.table[index];
 
-    if (particle->update != NULL) {
-        particle->velocity.x += particle->accel.x;
-        particle->velocity.y += particle->accel.y;
-        particle->velocity.z += particle->accel.z;
+    if (effectSs->update != NULL) {
+        effectSs->velocity.x += effectSs->accel.x;
+        effectSs->velocity.y += effectSs->accel.y;
+        effectSs->velocity.z += effectSs->accel.z;
 
-        particle->pos.x += particle->velocity.x;
-        particle->pos.y += particle->velocity.y;
-        particle->pos.z += particle->velocity.z;
+        effectSs->pos.x += effectSs->velocity.x;
+        effectSs->pos.y += effectSs->velocity.y;
+        effectSs->pos.z += effectSs->velocity.z;
 
-        particle->update(play, index, particle);
+        effectSs->update(play, index, effectSs);
     }
 }
 
-void EffectSS_UpdateAllParticles(PlayState* play) {
+void EffectSs_UpdateAll(PlayState* play) {
     s32 i;
 
-    for (i = 0; i < sEffectSsInfo.size; i++) {
-        if (sEffectSsInfo.dataTable[i].life > -1) {
-            sEffectSsInfo.dataTable[i].life--;
+    for (i = 0; i < sEffectSsInfo.tableSize; i++) {
+        if (sEffectSsInfo.table[i].life > -1) {
+            sEffectSsInfo.table[i].life--;
 
-            if (sEffectSsInfo.dataTable[i].life < 0) {
-                EffectSS_Delete(&sEffectSsInfo.dataTable[i]);
+            if (sEffectSsInfo.table[i].life < 0) {
+                EffectSs_Delete(&sEffectSsInfo.table[i]);
             }
         }
 
-        if (sEffectSsInfo.dataTable[i].life > -1) {
-            EffectSS_UpdateParticle(play, i);
+        if (sEffectSsInfo.table[i].life > -1) {
+            EffectSs_Update(play, i);
         }
     }
 }
 
-void EffectSS_DrawParticle(PlayState* play, s32 index) {
-    EffectSs* entry = &sEffectSsInfo.dataTable[index];
+void EffectSs_Draw(PlayState* play, s32 index) {
+    EffectSs* effectSs = &sEffectSsInfo.table[index];
 
-    if (entry->draw != NULL) {
-        entry->draw(play, index, entry);
+    if (effectSs->draw != NULL) {
+        effectSs->draw(play, index, effectSs);
     }
 }
 
-void EffectSS_DrawAllParticles(PlayState* play) {
+void EffectSs_DrawAll(PlayState* play) {
     Lights* lights = LightContext_NewLights(&play->lightCtx, play->state.gfxCtx);
     s32 i;
 
     Lights_BindAll(lights, play->lightCtx.listHead, NULL, play);
     Lights_Draw(lights, play->state.gfxCtx);
 
-    for (i = 0; i < sEffectSsInfo.size; i++) {
-        if (sEffectSsInfo.dataTable[i].life > -1) {
-            if ((sEffectSsInfo.dataTable[i].pos.x > BGCHECK_Y_MAX) ||
-                (sEffectSsInfo.dataTable[i].pos.x < BGCHECK_Y_MIN) ||
-                (sEffectSsInfo.dataTable[i].pos.y > BGCHECK_Y_MAX) ||
-                (sEffectSsInfo.dataTable[i].pos.y < BGCHECK_Y_MIN) ||
-                (sEffectSsInfo.dataTable[i].pos.z > BGCHECK_Y_MAX) ||
-                (sEffectSsInfo.dataTable[i].pos.z < BGCHECK_Y_MIN)) {
-                EffectSS_Delete(&sEffectSsInfo.dataTable[i]);
+    for (i = 0; i < sEffectSsInfo.tableSize; i++) {
+        if (sEffectSsInfo.table[i].life > -1) {
+            if ((sEffectSsInfo.table[i].pos.x > BGCHECK_Y_MAX) || (sEffectSsInfo.table[i].pos.x < BGCHECK_Y_MIN) ||
+                (sEffectSsInfo.table[i].pos.y > BGCHECK_Y_MAX) || (sEffectSsInfo.table[i].pos.y < BGCHECK_Y_MIN) ||
+                (sEffectSsInfo.table[i].pos.z > BGCHECK_Y_MAX) || (sEffectSsInfo.table[i].pos.z < BGCHECK_Y_MIN)) {
+                EffectSs_Delete(&sEffectSsInfo.table[i]);
             } else {
-                EffectSS_DrawParticle(play, i);
+                EffectSs_Draw(play, i);
             }
         }
     }
 }
 
-s16 func_800B096C(s16 arg0, s16 arg1, s32 arg2) {
-    s16 ret = (arg2 == 0) ? arg1 : arg0 + (s32)((arg1 - arg0) / (f32)arg2);
+/**
+ * Lerp from `a` (weightInv == inf) to `b` (weightInv == 1 or 0).
+ */
+s16 EffectSs_LerpInv(s16 a, s16 b, s32 weightInv) {
+    s16 ret = (weightInv == 0) ? b : (a + (s32)((b - a) / (f32)weightInv));
 
     return ret;
 }
 
-s16 func_800B09D0(s16 arg0, s16 arg1, f32 arg2) {
-    return arg2 * (arg1 - arg0) + arg0;
+/**
+ * Lerp from `a` (weight == 0) to `b` (weight == 1).
+ */
+s16 EffectSs_LerpS16(s16 a, s16 b, f32 weight) {
+    return (b - a) * weight + a;
 }
 
-u8 func_800B0A24(u8 arg0, u8 arg1, f32 arg2) {
-    return arg2 * ((f32)arg1 - (f32)arg0) + arg0;
+/**
+ * Lerp from `a` (weight == 0) to `b` (weight == 1).
+ */
+u8 EffectSs_LerpU8(u8 a, u8 b, f32 weight) {
+    return weight * ((f32)b - (f32)a) + a;
 }
diff --git a/src/code/z_effect_soft_sprite_dlftbls.c b/src/code/z_effect_soft_sprite_dlftbls.c
index e2f6f25ad..46139b0c8 100644
--- a/src/code/z_effect_soft_sprite_dlftbls.c
+++ b/src/code/z_effect_soft_sprite_dlftbls.c
@@ -20,7 +20,7 @@
 
 #define DEFINE_EFFECT_SS_UNSET(_enumValue) { 0 },
 
-EffectSsOverlay gParticleOverlayTable[EFFECT_SS_MAX] = {
+EffectSsOverlay gEffectSsOverlayTable[EFFECT_SS_TYPE_MAX] = {
 #include "tables/effect_ss_table.h"
 };
 
diff --git a/src/code/z_play.c b/src/code/z_play.c
index 52ec6c122..8cb5228d0 100644
--- a/src/code/z_play.c
+++ b/src/code/z_play.c
@@ -403,7 +403,7 @@ void Play_Destroy(GameState* thisx) {
     this->unk_18E64 = NULL;
     this->unk_18E68 = NULL;
     Effect_DestroyAll(this);
-    EffectSS_Clear(this);
+    EffectSs_ClearAll(this);
     CollisionCheck_DestroyContext(this, &this->colChkCtx);
 
     if (gTransitionTileState == TRANS_TILE_READY) {
@@ -1006,7 +1006,7 @@ void Play_UpdateMain(PlayState* this) {
                     Cutscene_UpdateManual(this, &this->csCtx);
                     Cutscene_UpdateScripted(this, &this->csCtx);
                     Effect_UpdateAll(this);
-                    EffectSS_UpdateAllParticles(this);
+                    EffectSs_UpdateAll(this);
                     EffFootmark_Update(this);
                 }
             } else {
@@ -2181,7 +2181,7 @@ void Play_Init(GameState* thisx) {
     SoundSource_InitAll(this);
     EffFootmark_Init(this);
     Effect_Init(this);
-    EffectSS_Init(this, 100);
+    EffectSs_InitInfo(this, 100);
     CollisionCheck_InitContext(this, &this->colChkCtx);
     AnimTaskQueue_Reset(&this->animTaskQueue);
     Cutscene_InitContext(this, &this->csCtx);