Match all FX render functions (#540)

* match most fx_XX_render functions

* match the rest of the fx render functions

* resolve data migration issues

* resolve issues

* Update effect_117.c

include/effects_internal.h

@@ -20,5 +20,6 @@ void shim_guRotateF(float mf[4][4], float a, float x, float y, float z);
 void shim_guTranslateF(float mf[4][4], float x, float y, float z);
 void shim_guPositionF(float mf[4][4], float r, float p, float h, float s, float x, float y, float z);
 void shim_mem_clear(s8* data, s32 numBytes);
+void shim_transform_point(Matrix4f mtx, f32 inX, f32 inY, f32 inZ, f32 inS, f32* outX, f32* outY, f32* outZ, f32* outS);
     
 #endif

include/enums.h

@@ -1710,6 +1710,7 @@ enum RenderMode {
     RENDER_MODE_SURFACE_XLU_NO_ZB                = 0x00000014,
     RENDER_MODE_SURFXLU_ZB_ZUPD                  = 0x00000015,
     RENDER_MODE_SURFACE_XLU_LAYER2               = 0x00000016,
+    RENDER_MODE_17                               = 0x00000017,
     RENDER_MODE_DECAL_XLU                        = 0x0000001A,
     RENDER_MODE_DECAL_XLU_NOAA                   = 0x0000001C,
     RENDER_MODE_SHADOW                           = 0x00000020,

src/190B20.c

@@ -1069,6 +1069,8 @@ s32 bActorMessages[] = {
 
 s32 D_802838F8 = 0;
 
+extern Gfx D_80293970[];
+
 extern Bytecode D_80293820[];
 
 void create_target_list(Actor* actor, s32 arg1);
@@ -2078,14 +2080,11 @@ void remove_player_buffs(s32 buffs) {
 
 INCLUDE_ASM(s32, "190B20", btl_update_ko_status);
 
-#ifdef NON_EQUIVALENT
-extern s32 D_80293970;
-
-void btl_appendGfx_prim_quad(s32 arg0, s32 arg1, s32 arg2, s32 arg3, s16 arg4, s16 arg5, s16 arg6, s16 arg7) {
+void btl_appendGfx_prim_quad(u8 r, u8 g, u8 b, u8 a, u16 left, u16 top, u16 right, u16 bottom) {
     gDPPipeSync(gMasterGfxPos++);
-    gSPDisplayList(gMasterGfxPos++, &D_80293970);
+    gSPDisplayList(gMasterGfxPos++, D_80293970);
 
-    if ((arg3 & 0xFF) == 0xFF) {
+    if (a == 255) {
         gDPSetRenderMode(gMasterGfxPos++, G_RM_OPA_SURF, G_RM_OPA_SURF2);
         gDPSetCombineLERP(gMasterGfxPos++, 0, 0, 0, PRIMITIVE, 0, 0, 0, 1, 0, 0, 0, PRIMITIVE, 0, 0, 0, 1);
     } else {
@@ -2093,17 +2092,13 @@ void btl_appendGfx_prim_quad(s32 arg0, s32 arg1, s32 arg2, s32 arg3, s16 arg4, s
         gDPSetCombineMode(gMasterGfxPos++, G_CC_PRIMITIVE, G_CC_PRIMITIVE);
     }
 
-    gDPSetPrimColor(gMasterGfxPos++, 0, 0, arg0, arg1, arg2, arg3);
-    gDPFillRectangle(gMasterGfxPos++, arg4, arg5, arg6, arg7);
-    gDPPipeSync(gMasterGfxPos++);
+    gDPSetPrimColor(gMasterGfxPos++, 0, 0, r, g, b, a);
+    gDPFillRectangle(gMasterGfxPos++, left, top, right, bottom);
 
+    gDPPipeSync(gMasterGfxPos++);
     gDPSetRenderMode(gMasterGfxPos++, G_RM_TEX_EDGE, G_RM_TEX_EDGE2);
     gDPSetCombineMode(gMasterGfxPos++, G_CC_DECALRGBA, G_CC_DECALRGBA);
 }
-#else
-void btl_appendGfx_prim_quad(u8 arg0, u8 arg1, u8 arg2, u8 arg3, u16 arg4, u16 arg5, u16 arg6, u16 arg7);
-INCLUDE_ASM(s32, "190B20", btl_appendGfx_prim_quad, u8 arg0, u8 arg1, u8 arg2, u8 arg3, u16 arg4, u16 arg5, u16 arg6, u16 arg7);
-#endif
 
 void btl_draw_prim_quad(s32 arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6, s32 arg7) {
     u16 new_var = arg4 + arg6;

src/43F0.c

@@ -796,7 +796,6 @@ void appendGfx_startup_prim_rect(u8 r, u8 g, u8 b, u8 a, u16 left, u16 top, u16
     gDPPipeSync(gMasterGfxPos++);
     gDPSetRenderMode(gMasterGfxPos++, G_RM_TEX_EDGE, G_RM_TEX_EDGE2);
     gDPSetCombineMode(gMasterGfxPos++, G_CC_DECALRGBA, G_CC_DECALRGBA);
-
 }
 
 void startup_draw_prim_rect_COPY(s16 left, s16 top, s16 right, s16 bottom, u16 r, u16 g, u16 b, u16 a) {

src/effects/effect_100.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_100_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_100", fx_100_main);
 
@@ -7,7 +10,18 @@ void fx_100_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_100", fx_100_update);
 
-INCLUDE_ASM(s32, "effects/effect_100", fx_100_render);
+void fx_100_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_100_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E00C844C(void) {
 }

src/effects/effect_101.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_101_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_101", fx_101_main);
 
@@ -7,6 +10,17 @@ void fx_101_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_101", fx_101_update);
 
-INCLUDE_ASM(s32, "effects/effect_101", fx_101_render);
+void fx_101_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_101_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_101", fx_101_appendGfx);

src/effects/effect_102.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_102_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_102", fx_102_main);
 
@@ -7,7 +10,18 @@ void fx_102_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_102", fx_102_update);
 
-INCLUDE_ASM(s32, "effects/effect_102", fx_102_render);
+void fx_102_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_102_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E00CC9C8(void) {
 }

src/effects/effect_103.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_103_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_103", fx_103_main);
 
@@ -7,7 +10,18 @@ void fx_103_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_103", fx_103_update);
 
-INCLUDE_ASM(s32, "effects/effect_103", fx_103_render);
+void fx_103_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_103_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E00CE470(void) {
 }

src/effects/effect_104.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_104_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_104", fx_104_main);
 
@@ -7,6 +10,17 @@ void fx_104_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_104", fx_104_update);
 
-INCLUDE_ASM(s32, "effects/effect_104", fx_104_render);
+void fx_104_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_104_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_104", fx_104_appendGfx);

src/effects/effect_105.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_105_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_105", fx_105_main);
 
@@ -7,7 +10,18 @@ void fx_105_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_105", fx_105_update);
 
-INCLUDE_ASM(s32, "effects/effect_105", fx_105_render);
+void fx_105_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_105_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E00D227C(void) {
 }

src/effects/effect_107.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_107_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_107", fx_107_main);
 
@@ -7,7 +10,17 @@ void fx_107_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_107", fx_107_update);
 
-INCLUDE_ASM(s32, "effects/effect_107", fx_107_render);
+void fx_107_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_107_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 void func_E00D6978(void) {
 }

src/effects/effect_108.c

@@ -1,4 +1,5 @@
 #include "common.h"
+#include "effects_internal.h"
 
 INCLUDE_ASM(s32, "effects/effect_108", fx_108_main);
 

src/effects/effect_109.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_109_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_109", fx_109_main);
 
@@ -7,7 +10,18 @@ void fx_109_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_109", fx_109_update);
 
-INCLUDE_ASM(s32, "effects/effect_109", fx_109_render);
+void fx_109_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_109_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E00DA228(void) {
 }

src/effects/effect_11.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_11_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_11", fx_11_main);
 
@@ -7,6 +10,17 @@ void fx_11_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_11", fx_11_update);
 
-INCLUDE_ASM(s32, "effects/effect_11", fx_11_render);
+void fx_11_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_11_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_11", fx_11_appendGfx);

src/effects/effect_110.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_110_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_110", fx_110_main);
 
@@ -7,7 +10,17 @@ void fx_110_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_110", fx_110_update);
 
-INCLUDE_ASM(s32, "effects/effect_110", fx_110_render);
+void fx_110_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_110_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 void func_E00DC2FC(void) {
 }

src/effects/effect_111.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_111_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_111", fx_111_main);
 
@@ -7,6 +10,17 @@ void fx_111_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_111", fx_111_update);
 
-INCLUDE_ASM(s32, "effects/effect_111", fx_111_render);
+void fx_111_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_111_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 6;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_111", fx_111_appendGfx);

src/effects/effect_112.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_112_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_112", fx_112_main);
 
@@ -7,7 +10,18 @@ void fx_112_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_112", fx_112_update);
 
-INCLUDE_ASM(s32, "effects/effect_112", fx_112_render);
+void fx_112_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_112_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E00E05F8(void) {
 }

src/effects/effect_113.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_113_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_113", fx_113_main);
 
@@ -7,7 +10,18 @@ void fx_113_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_113", fx_113_update);
 
-INCLUDE_ASM(s32, "effects/effect_113", fx_113_render);
+void fx_113_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_113_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E00E2210(void) {
 }

src/effects/effect_114.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_114_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_114", fx_114_main);
 
@@ -7,7 +10,18 @@ void fx_114_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_114", fx_114_update);
 
-INCLUDE_ASM(s32, "effects/effect_114", fx_114_render);
+void fx_114_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_114_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 7;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E00E4954(void) {
 }

src/effects/effect_115.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_115_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_115", fx_115_main);
 
@@ -7,7 +10,18 @@ void fx_115_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_115", fx_115_update);
 
-INCLUDE_ASM(s32, "effects/effect_115", fx_115_render);
+void fx_115_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_115_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_SURFACE_OPA;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E00E651C(void) {
 }

src/effects/effect_116.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_116_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_116", fx_116_main);
 
@@ -7,6 +10,17 @@ void fx_116_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_116", fx_116_update);
 
-INCLUDE_ASM(s32, "effects/effect_116", fx_116_render);
+void fx_116_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_116_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_116", fx_116_appendGfx);

src/effects/effect_117.c

@@ -1,4 +1,18 @@
 #include "common.h"
+#include "effects_internal.h"
+
+typedef struct Effect117 {
+    /* 0x00 */ s32 unk_00;
+    /* 0x04 */ f32 unk_04;
+    /* 0x08 */ f32 unk_08;
+    /* 0x0C */ f32 unk_0C;
+} Effect117; // size = 0x??
+
+void fx_117_appendGfx(EffectInstance* effect);
+
+s32 D_E00EAA50[2] = { 0x09001A00, 0x09001A20 };
+
+s32 D_E00EAA58[2] = { 0x09001910, 0x00000000 };
 
 INCLUDE_ASM(s32, "effects/effect_117", fx_117_main);
 
@@ -7,7 +21,38 @@ void fx_117_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_117", fx_117_update);
 
-INCLUDE_ASM(s32, "effects/effect_117", fx_117_render);
+void fx_117_render(EffectInstance* effect) {
+    Effect117* effect117 = effect->data;
+    RenderTask renderTask;
+    RenderTask* renderTaskPtr = &renderTask;
+    RenderTask* retTask;
+    s32 outDist;
+    f32 outX;
+    f32 outY;
+    f32 outZ;
+    f32 outS;
+
+    shim_transform_point(gCameras[gCurrentCameraID].perspectiveMatrix[0], effect117->unk_04, effect117->unk_08, effect117->unk_0C, 1.0f, &outX, &outY, &outZ, &outS);
+    
+    outDist = outZ + 5000;
+    if (outDist < 0) {
+        outDist = 0;
+    } else if (outDist > 10000) {
+        outDist = 10000;
+    }
+
+    if (outS < 0.01 && -0.01 < outS) {
+        outDist = 0;
+    }
+    
+    renderTaskPtr->appendGfx = fx_117_appendGfx;
+    renderTaskPtr->distance = -outDist;
+    renderTaskPtr->appendGfxArg = effect;
+    renderTaskPtr->renderMode = RENDER_MODE_SURFACE_XLU_LAYER1;
+
+    retTask = shim_queue_render_task(renderTaskPtr);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E00EA664(void) {
 }

src/effects/effect_119.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_119_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_119", fx_119_main);
 
@@ -7,6 +10,17 @@ void fx_119_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_119", fx_119_update);
 
-INCLUDE_ASM(s32, "effects/effect_119", fx_119_render);
+void fx_119_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_119_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 700;
+    renderTask.renderMode =  RENDER_MODE_SURFACE_OPA;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_119", fx_119_appendGfx);

src/effects/effect_12.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_12_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_12", func_E0018000);
 
@@ -9,7 +12,18 @@ void fx_12_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_12", fx_12_update);
 
-INCLUDE_ASM(s32, "effects/effect_12", fx_12_render);
+void fx_12_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_12_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_12", func_E00183BC);
 

src/effects/effect_120.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_120_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_120", fx_120_main);
 
@@ -7,6 +10,17 @@ void fx_120_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_120", fx_120_update);
 
-INCLUDE_ASM(s32, "effects/effect_120", fx_120_render);
+void fx_120_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_120_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_120", fx_120_appendGfx);

src/effects/effect_121.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_121_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_121", func_E010E000);
 
@@ -9,6 +12,17 @@ void fx_121_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_121", fx_121_update);
 
-INCLUDE_ASM(s32, "effects/effect_121", fx_121_render);
+void fx_121_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_121_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_121", fx_121_appendGfx);

src/effects/effect_122.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_122_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_122", fx_122_main);
 
@@ -7,6 +10,17 @@ void fx_122_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_122", fx_122_update);
 
-INCLUDE_ASM(s32, "effects/effect_122", fx_122_render);
+void fx_122_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_122_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_122", fx_122_appendGfx);

src/effects/effect_123.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_123_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_123", fx_123_main);
 
@@ -7,7 +10,18 @@ void fx_123_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_123", fx_123_update);
 
-INCLUDE_ASM(s32, "effects/effect_123", fx_123_render);
+void fx_123_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_123_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_SURFACE_XLU_LAYER1;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_123", func_E0112330);
 

src/effects/effect_124.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_124_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_124", fx_124_main);
 
@@ -7,6 +10,17 @@ void fx_124_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_124", fx_124_update);
 
-INCLUDE_ASM(s32, "effects/effect_124", fx_124_render);
+void fx_124_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_124_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_124", fx_124_appendGfx);

src/effects/effect_125.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_125_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_125", fx_125_main);
 
@@ -7,7 +10,18 @@ void fx_125_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_125", fx_125_update);
 
-INCLUDE_ASM(s32, "effects/effect_125", fx_125_render);
+void fx_125_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_125_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_SURFACE_XLU_LAYER1;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_125", func_E01166E8);
 

src/effects/effect_126.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_126_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_126", fx_126_main);
 
@@ -7,6 +10,17 @@ void fx_126_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_126", fx_126_update);
 
-INCLUDE_ASM(s32, "effects/effect_126", fx_126_render);
+void fx_126_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_126_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_126", fx_126_appendGfx);

src/effects/effect_127.c

@@ -1,4 +1,5 @@
 #include "common.h"
+#include "effects_internal.h"
 
 INCLUDE_ASM(s32, "effects/effect_127", fx_127_main);
 

src/effects/effect_128.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_128_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_128", fx_128_main);
 
@@ -7,6 +10,17 @@ void fx_128_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_128", fx_128_update);
 
-INCLUDE_ASM(s32, "effects/effect_128", fx_128_render);
+void fx_128_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_128_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_128", fx_128_appendGfx);

src/effects/effect_129.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_129_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_129", fx_129_main);
 
@@ -7,6 +10,17 @@ void fx_129_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_129", fx_129_update);
 
-INCLUDE_ASM(s32, "effects/effect_129", fx_129_render);
+void fx_129_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_129_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 5;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_129", fx_129_appendGfx);

src/effects/effect_13.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_13_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_13", fx_13_main);
 
@@ -7,6 +10,17 @@ void fx_13_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_13", fx_13_update);
 
-INCLUDE_ASM(s32, "effects/effect_13", fx_13_render);
+void fx_13_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_13_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_13", fx_13_appendGfx);

src/effects/effect_130.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_130_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_130", fx_130_main);
 
@@ -7,6 +10,17 @@ void fx_130_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_130", fx_130_update);
 
-INCLUDE_ASM(s32, "effects/effect_130", fx_130_render);
+void fx_130_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_130_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_130", fx_130_appendGfx);

src/effects/effect_131.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_131_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_131", fx_131_main);
 
@@ -7,6 +10,17 @@ void fx_131_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_131", fx_131_update);
 
-INCLUDE_ASM(s32, "effects/effect_131", fx_131_render);
+void fx_131_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_131_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_131", fx_131_appendGfx);

src/effects/effect_132.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_132_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_132", fx_132_main);
 
@@ -7,6 +10,16 @@ void fx_132_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_132", fx_132_update);
 
-INCLUDE_ASM(s32, "effects/effect_132", fx_132_render);
+void fx_132_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_132_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 INCLUDE_ASM(s32, "effects/effect_132", fx_132_appendGfx);

src/effects/effect_133.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_133_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_133", fx_133_main);
 
@@ -7,6 +10,17 @@ void fx_133_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_133", fx_133_update);
 
-INCLUDE_ASM(s32, "effects/effect_133", fx_133_render);
+void fx_133_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_133_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_133", fx_133_appendGfx);

src/effects/effect_134.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_134_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_134", fx_134_main);
 
@@ -7,6 +10,17 @@ void fx_134_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_134", fx_134_update);
 
-INCLUDE_ASM(s32, "effects/effect_134", fx_134_render);
+void fx_134_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_134_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_134", fx_134_appendGfx);

src/effects/effect_14.c

@@ -1,4 +1,13 @@
 #include "common.h"
+#include "effects_internal.h"
+
+typedef struct Effect14 {
+    /* 0x00 */ f32 xPos; //xPos
+    /* 0x04 */ f32 yPos; //yPos
+    /* 0x08 */ f32 zPos; //zPos
+} Effect14; // size = 0x??
+
+void fx_14_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_14", fx_14_main);
 
@@ -7,6 +16,40 @@ void fx_14_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_14", fx_14_update);
 
-INCLUDE_ASM(s32, "effects/effect_14", fx_14_render);
+void fx_14_render(EffectInstance* effect) {
+    PlayerStatus* playerStatus = &gPlayerStatus;
+    Effect14* effect14 = effect->data;
+    RenderTask renderTask;
+    RenderTask* renderTaskPtr = &renderTask;
+    RenderTask* retTask;
+    f32 effectPos = effect14->xPos;
+    f32 playerPos = playerStatus->position.x;
+    
+    if (effectPos - playerPos > 200) {
+        effect14->xPos = effectPos - 400;
+    } else {
+        if (playerPos - effectPos > 200) {
+            effect14->xPos = effectPos + 400;
+        }
+    }
+
+    effectPos = effect14->zPos;
+    playerPos = playerStatus->position.z;
+    if (effectPos - playerPos > 200) {
+        effect14->zPos = effectPos - 400;
+    } else {
+        if (playerPos - effectPos > 200) {
+            effect14->zPos = effectPos + 400;
+        }
+    }
+
+    renderTaskPtr->appendGfx = &fx_14_appendGfx;
+    renderTaskPtr->appendGfxArg = effect;
+    renderTaskPtr->distance = 0;
+    renderTaskPtr->renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(renderTaskPtr);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_14", fx_14_appendGfx);

src/effects/effect_15.c

@@ -1,4 +1,12 @@
 #include "common.h"
+#include "effects_internal.h"
+
+typedef struct Effect15 {
+    /* 0x00 */ char unk_00[0x38];
+    /* 0x38 */ s32 unk_38;
+} Effect15; // size = 0x??
+
+void fx_15_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_15", fx_15_main);
 
@@ -7,6 +15,24 @@ void fx_15_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_15", fx_15_update);
 
-INCLUDE_ASM(s32, "effects/effect_15", fx_15_render);
+void fx_15_render(EffectInstance* effect) {
+    Effect15* effect15 = effect->data;
+    RenderTask renderTask;
+    RenderTask* renderTaskPtr = &renderTask;
+    RenderTask* retTask;
+    s32 renderModeTemp;
+
+    renderTask.appendGfxArg = effect;
+    renderTask.appendGfx = fx_15_appendGfx;
+    renderTask.distance = 0;
+    if (effect15->unk_38 != 0) {
+        renderModeTemp = RENDER_MODE_2D;
+    } else {
+        renderModeTemp = RENDER_MODE_SURF_SOLID_AA_ZB_LAYER0;
+    }
+    renderTaskPtr->renderMode = renderModeTemp;
+    
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 INCLUDE_ASM(s32, "effects/effect_15", fx_15_appendGfx);

src/effects/effect_16.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_16_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_16", func_E0020000);
 
@@ -9,6 +12,17 @@ void fx_16_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_16", fx_16_update);
 
-INCLUDE_ASM(s32, "effects/effect_16", fx_16_render);
+void fx_16_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_16_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_16", fx_16_appendGfx);

src/effects/effect_17.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_17_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_17", fx_17_main);
 
@@ -7,6 +10,16 @@ void fx_17_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_17", fx_17_update);
 
-INCLUDE_ASM(s32, "effects/effect_17", fx_17_render);
+void fx_17_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_17_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 INCLUDE_ASM(s32, "effects/effect_17", fx_17_appendGfx);

src/effects/effect_18.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_18_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_18", fx_18_main);
 
@@ -7,7 +10,18 @@ void fx_18_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_18", fx_18_update);
 
-INCLUDE_ASM(s32, "effects/effect_18", fx_18_render);
+void fx_18_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_18_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_18", func_E0024324);
 

src/effects/effect_19.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_19_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_19", fx_19_main);
 
@@ -7,6 +10,17 @@ void fx_19_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_19", fx_19_update);
 
-INCLUDE_ASM(s32, "effects/effect_19", fx_19_render);
+void fx_19_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_19_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_19", fx_19_appendGfx);

src/effects/effect_20.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_20_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_20", fx_20_main);
 
@@ -7,6 +10,17 @@ void fx_20_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_20", fx_20_update);
 
-INCLUDE_ASM(s32, "effects/effect_20", fx_20_render);
+void fx_20_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_20_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_20", fx_20_appendGfx);

src/effects/effect_21.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_21_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_21", fx_21_main);
 
@@ -7,6 +10,17 @@ void fx_21_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_21", fx_21_update);
 
-INCLUDE_ASM(s32, "effects/effect_21", fx_21_render);
+void fx_21_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_21_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_SURFACE_XLU_LAYER1;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_21", fx_21_appendGfx);

src/effects/effect_22.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_22_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_22", fx_22_main);
 
@@ -7,6 +10,17 @@ void fx_22_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_22", fx_22_update);
 
-INCLUDE_ASM(s32, "effects/effect_22", fx_22_render);
+void fx_22_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_22_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_22", fx_22_appendGfx);

src/effects/effect_23.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_23_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_23", fx_23_main);
 
@@ -7,6 +10,16 @@ void fx_23_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_23", fx_23_update);
 
-INCLUDE_ASM(s32, "effects/effect_23", fx_23_render);
+void fx_23_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_23_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 INCLUDE_ASM(s32, "effects/effect_23", fx_23_appendGfx);

src/effects/effect_24.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_24_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_24", fx_24_main);
 
@@ -7,6 +10,17 @@ void fx_24_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_24", fx_24_update);
 
-INCLUDE_ASM(s32, "effects/effect_24", fx_24_render);
+void fx_24_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_24_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_24", fx_24_appendGfx);

src/effects/effect_25.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_25_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_25", fx_25_main);
 
@@ -7,6 +10,16 @@ void fx_25_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_25", fx_25_update);
 
-INCLUDE_ASM(s32, "effects/effect_25", fx_25_render);
+void fx_25_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_25_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 INCLUDE_ASM(s32, "effects/effect_25", fx_25_appendGfx);

src/effects/effect_26.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_26_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_26", fx_26_main);
 
@@ -7,6 +10,17 @@ void fx_26_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_26", fx_26_update);
 
-INCLUDE_ASM(s32, "effects/effect_26", fx_26_render);
+void fx_26_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_26_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 20;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_26", fx_26_appendGfx);

src/effects/effect_27.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_27_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_27", fx_27_main);
 
@@ -7,7 +10,18 @@ void fx_27_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_27", fx_27_update);
 
-INCLUDE_ASM(s32, "effects/effect_27", fx_27_render);
+void fx_27_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_27_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E003621C(void) {
 }

src/effects/effect_28.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_28_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_28", fx_28_main);
 
@@ -7,6 +10,17 @@ void fx_28_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_28", fx_28_update);
 
-INCLUDE_ASM(s32, "effects/effect_28", fx_28_render);
+void fx_28_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_28_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_28", fx_28_appendGfx);

src/effects/effect_29.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_29_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_29", fx_29_main);
 
@@ -7,6 +10,17 @@ void fx_29_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_29", fx_29_update);
 
-INCLUDE_ASM(s32, "effects/effect_29", fx_29_render);
+void fx_29_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_29_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_29", fx_29_appendGfx);

src/effects/effect_30.c

@@ -1,4 +1,5 @@
 #include "common.h"
+#include "effects_internal.h"
 
 INCLUDE_ASM(s32, "effects/effect_30", fx_30_main);
 

src/effects/effect_31.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_31_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_31", fx_31_main);
 
@@ -7,6 +10,17 @@ void fx_31_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_31", fx_31_update);
 
-INCLUDE_ASM(s32, "effects/effect_31", fx_31_render);
+void fx_31_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_31_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_31", fx_31_appendGfx);

src/effects/effect_32.c

@@ -1,4 +1,20 @@
 #include "common.h"
+#include "effects_internal.h"
+
+typedef struct Effect32 {
+    /* 0x00 */ s32 unk_00;
+    /* 0x04 */ f32 unk_04;
+    /* 0x08 */ f32 unk_08;
+    /* 0x0C */ f32 unk_0C;
+} Effect32; // size = 0x??
+
+void fx_32_appendGfx(EffectInstance* effect);
+
+u32 D_E0040840[2] = { 0xFF6DFF5C, 0x66BFFF4B };
+
+s8 D_E0040848[56] = { 0x32, 0x00, 0x00, 0x00, 0x09, 0x00, 0x08, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0x20, 0x00, 0x4B, 0x64, 0x00, 0x00, 0x00, 0x09, 0x00, 0x08, 0x00, 0xFF, 0x00, 0xFF, 0x5C, 0x6B, 0xA8, 0xFF, 0x4B, 0x0A, 0x00, 0x00, 0x00, 0x09, 0x00, 0x08, 0x00, 0xFF, 0xFF, 0xFF, 0xF4, 0xF7, 0xAF, 0xAF, 0x16, 0x1E, 0x00, 0x00, 0x00, 0x09, 0x00, 0x08, 0x00 };
+
+s32 D_E0040880[4] = { 0, 0, 0, 0 };
 
 INCLUDE_ASM(s32, "effects/effect_32", fx_32_main);
 
@@ -7,6 +23,36 @@ void fx_32_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_32", fx_32_update);
 
-INCLUDE_ASM(s32, "effects/effect_32", fx_32_render);
+void fx_32_render(EffectInstance* effect) {
+    Effect32* effect32 = effect->data;
+    RenderTask renderTask;
+    RenderTask* renderTaskPtr = &renderTask;
+    RenderTask* retTask;
+    s32 outDist;
+    f32 outX;
+    f32 outY;
+    f32 outZ;
+    f32 outS;
+
+    shim_transform_point(gCameras[gCurrentCameraID].perspectiveMatrix[0], effect32->unk_04, effect32->unk_08, effect32->unk_0C, 1.0f, &outX, &outY, &outZ, &outS);
+    
+    outDist = outZ + 5000;
+    if (outDist < 0) {
+        outDist = 0;
+    } else if (outDist > 10000) {
+        outDist = 10000;
+    }
+
+    if (outS < 0.01 && -0.01 < outS) {
+        outDist = 0;
+    }
+    
+    renderTaskPtr->appendGfx = fx_32_appendGfx;
+    renderTaskPtr->distance = -outDist;
+    renderTaskPtr->appendGfxArg = effect;
+    renderTaskPtr->renderMode = RENDER_MODE_SURFACE_XLU_LAYER1;
+
+    shim_queue_render_task(renderTaskPtr);
+}
 
 INCLUDE_ASM(s32, "effects/effect_32", fx_32_appendGfx);

src/effects/effect_33.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_33_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_33", fx_33_main);
 
@@ -7,6 +10,17 @@ void fx_33_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_33", fx_33_update);
 
-INCLUDE_ASM(s32, "effects/effect_33", fx_33_render);
+void fx_33_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_33_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_33", fx_33_appendGfx);

src/effects/effect_34.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_34_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_34", fx_34_main);
 
@@ -7,6 +10,16 @@ void fx_34_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_34", fx_34_update);
 
-INCLUDE_ASM(s32, "effects/effect_34", fx_34_render);
+void fx_34_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_34_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 INCLUDE_ASM(s32, "effects/effect_34", fx_34_appendGfx);

src/effects/effect_35.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_35_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_35", fx_35_main);
 
@@ -7,6 +10,17 @@ void fx_35_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_35", fx_35_update);
 
-INCLUDE_ASM(s32, "effects/effect_35", fx_35_render);
+void fx_35_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_35_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_35", fx_35_appendGfx);

src/effects/effect_36.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_36_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_36", fx_36_main);
 
@@ -7,6 +10,17 @@ void fx_36_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_36", fx_36_update);
 
-INCLUDE_ASM(s32, "effects/effect_36", fx_36_render);
+void fx_36_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_36_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_36", fx_36_appendGfx);

src/effects/effect_37.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_37_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_37", fx_37_main);
 
@@ -7,6 +10,17 @@ void fx_37_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_37", fx_37_update);
 
-INCLUDE_ASM(s32, "effects/effect_37", fx_37_render);
+void fx_37_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_37_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_37", fx_37_appendGfx);

src/effects/effect_38.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_38_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_38", fx_38_main);
 
@@ -7,6 +10,17 @@ void fx_38_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_38", fx_38_update);
 
-INCLUDE_ASM(s32, "effects/effect_38", fx_38_render);
+void fx_38_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_38_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_38", fx_38_appendGfx);

src/effects/effect_39.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_39_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_39", fx_39_main);
 
@@ -7,6 +10,17 @@ void fx_39_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_39", fx_39_update);
 
-INCLUDE_ASM(s32, "effects/effect_39", fx_39_render);
+void fx_39_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_39_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_39", fx_39_appendGfx);

src/effects/effect_40.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_40_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_40", fx_40_main);
 
@@ -7,6 +10,17 @@ void fx_40_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_40", fx_40_update);
 
-INCLUDE_ASM(s32, "effects/effect_40", fx_40_render);
+void fx_40_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_40_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_40", fx_40_appendGfx);

src/effects/effect_41.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_41_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_41", fx_41_main);
 
@@ -7,6 +10,17 @@ void fx_41_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_41", fx_41_update);
 
-INCLUDE_ASM(s32, "effects/effect_41", fx_41_render);
+void fx_41_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_41_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_41", fx_41_appendGfx);

src/effects/effect_43.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_43_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_43", fx_43_main);
 
@@ -7,6 +10,17 @@ void fx_43_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_43", fx_43_update);
 
-INCLUDE_ASM(s32, "effects/effect_43", fx_43_render);
+void fx_43_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_43_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_43", fx_43_appendGfx);

src/effects/effect_44.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_44_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_44", fx_44_main);
 
@@ -7,6 +10,17 @@ void fx_44_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_44", fx_44_update);
 
-INCLUDE_ASM(s32, "effects/effect_44", fx_44_render);
+void fx_44_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_44_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_44", fx_44_appendGfx);

src/effects/effect_45.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_45_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_45", fx_45_main);
 
@@ -7,6 +10,17 @@ void fx_45_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_45", fx_45_update);
 
-INCLUDE_ASM(s32, "effects/effect_45", fx_45_render);
+void fx_45_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_45_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_45", fx_45_appendGfx);

src/effects/effect_46.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_46_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_46", fx_46_main);
 
@@ -7,6 +10,17 @@ void fx_46_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_46", fx_46_update);
 
-INCLUDE_ASM(s32, "effects/effect_46", fx_46_render);
+void fx_46_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_46_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_46", fx_46_appendGfx);

src/effects/effect_47.c

@@ -1,4 +1,5 @@
 #include "common.h"
+#include "effects_internal.h"
 
 INCLUDE_ASM(s32, "effects/effect_47", fx_47_main);
 

src/effects/effect_48.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_48_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_48", fx_48_main);
 
@@ -7,6 +10,17 @@ void fx_48_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_48", fx_48_update);
 
-INCLUDE_ASM(s32, "effects/effect_48", fx_48_render);
+void fx_48_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_48_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_48", fx_48_appendGfx);

src/effects/effect_49.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_49_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_49", fx_49_main);
 
@@ -7,6 +10,17 @@ void fx_49_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_49", fx_49_update);
 
-INCLUDE_ASM(s32, "effects/effect_49", fx_49_render);
+void fx_49_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_49_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_49", fx_49_appendGfx);

src/effects/effect_50.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_50_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_50", fx_50_main);
 
@@ -7,6 +10,16 @@ void fx_50_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_50", fx_50_update);
 
-INCLUDE_ASM(s32, "effects/effect_50", fx_50_render);
+void fx_50_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_50_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 INCLUDE_ASM(s32, "effects/effect_50", fx_50_appendGfx);

src/effects/effect_51.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_51_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_51", fx_51_main);
 
@@ -7,6 +10,17 @@ void fx_51_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_51", fx_51_update);
 
-INCLUDE_ASM(s32, "effects/effect_51", fx_51_render);
+void fx_51_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_51_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_51", fx_51_appendGfx);

src/effects/effect_52.c

@@ -1,4 +1,11 @@
 #include "common.h"
+#include "effects_internal.h"
+
+typedef struct Effect52 {
+    /* 0x00 */ s32 unk_00;
+} Effect52; // size = 0x??
+
+void fx_52_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_52", fx_52_main);
 
@@ -7,6 +14,23 @@ void fx_52_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_52", fx_52_update);
 
-INCLUDE_ASM(s32, "effects/effect_52", fx_52_render);
+void fx_52_render(EffectInstance* effect) {
+    Effect52* effect52 = effect->data;
+    RenderTask renderTask;
+    RenderTask* renderTaskPtr = &renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfxArg = effect;
+    renderTask.appendGfx = fx_52_appendGfx;
+    renderTask.distance = 10;
+    if (effect52->unk_00 == 0) {
+        renderTaskPtr->renderMode = RENDER_MODE_SURFACE_OPA;
+    } else {
+        renderTaskPtr->renderMode = RENDER_MODE_2D;
+    }
+    
+    retTask = shim_queue_render_task(renderTaskPtr);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_52", fx_52_appendGfx);

src/effects/effect_53.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_53_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_53", func_E006A000);
 
@@ -13,7 +16,18 @@ INCLUDE_ASM(s32, "effects/effect_53", func_E006A464);
 
 INCLUDE_ASM(s32, "effects/effect_53", fx_53_update);
 
-INCLUDE_ASM(s32, "effects/effect_53", fx_53_render);
+void fx_53_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_53_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_53", func_E006A85C);
 

src/effects/effect_54.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_54_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_54", fx_54_main);
 
@@ -7,6 +10,17 @@ void fx_54_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_54", fx_54_update);
 
-INCLUDE_ASM(s32, "effects/effect_54", fx_54_render);
+void fx_54_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_54_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_SURFACE_XLU_LAYER3;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_54", fx_54_appendGfx);

src/effects/effect_55.c

@@ -1,4 +1,12 @@
 #include "common.h"
+#include "effects_internal.h"
+
+typedef struct Effect55 {
+    /* 0x00 */ char unk_00[0x14];
+    /* 0x14 */ f32 unk_14;
+} Effect55; // size = 0x??
+
+void fx_55_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_55", fx_55_main);
 
@@ -7,6 +15,23 @@ void fx_55_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_55", fx_55_update);
 
-INCLUDE_ASM(s32, "effects/effect_55", fx_55_render);
+void fx_55_render(EffectInstance *effect) {
+    Effect55* effect55 = effect->data;
+    RenderTask renderTask;
+    RenderTask* retTask;
+    RenderTask* renderTaskPointer = &renderTask;
+
+    renderTask.appendGfx = fx_55_appendGfx;
+    renderTask.appendGfxArg = effect;
+    if (gGameStatusPtr->isBattle == 1) {
+        renderTask.distance = effect55->unk_14 + 1000.0f;
+    } else {
+        renderTask.distance = 0;
+    }
+
+    renderTaskPointer->renderMode = RENDER_MODE_2D;
+    retTask = shim_queue_render_task(renderTaskPointer);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_55", fx_55_appendGfx);

src/effects/effect_56.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_56_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_56", fx_56_main);
 
@@ -7,7 +10,18 @@ void fx_56_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_56", fx_56_update);
 
-INCLUDE_ASM(s32, "effects/effect_56", fx_56_render);
+void fx_56_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_56_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E0070738(void) {
 }

src/effects/effect_57.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_57_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_57", fx_57_main);
 
@@ -7,6 +10,17 @@ void fx_57_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_57", fx_57_update);
 
-INCLUDE_ASM(s32, "effects/effect_57", fx_57_render);
+void fx_57_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_57_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_SURFACE_XLU_LAYER3;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_57", fx_57_appendGfx);

src/effects/effect_58.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_58_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_58", fx_58_main);
 
@@ -7,6 +10,17 @@ void fx_58_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_58", fx_58_update);
 
-INCLUDE_ASM(s32, "effects/effect_58", fx_58_render);
+void fx_58_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_58_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_58", fx_58_appendGfx);

src/effects/effect_59.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_59_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_59", fx_59_main);
 
@@ -7,7 +10,18 @@ void fx_59_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_59", fx_59_update);
 
-INCLUDE_ASM(s32, "effects/effect_59", fx_59_render);
+void fx_59_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_59_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E007684C(void) {
 }

src/effects/effect_60.c

@@ -1,4 +1,11 @@
 #include "common.h"
+#include "effects_internal.h"
+
+typedef struct Effect60 {
+    /* 0x00 */ s32 unk_00;
+} Effect60; // size = 0x??
+
+void fx_60_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_60", fx_60_main);
 
@@ -7,7 +14,25 @@ void fx_60_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_60", fx_60_update);
 
-INCLUDE_ASM(s32, "effects/effect_60", fx_60_render);
+void fx_60_render(EffectInstance* effect) {
+    Effect60* effect60 = effect->data;
+    RenderTask renderTask;
+    RenderTask* renderTaskPtr = &renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfxArg = effect;
+    renderTask.appendGfx = fx_60_appendGfx;
+    if (effect60->unk_00 == 5) {
+        renderTask.distance = 0;
+        renderTaskPtr->renderMode = RENDER_MODE_SURFACE_OPA;
+    } else {
+        renderTask.distance = -100;
+        renderTaskPtr->renderMode = RENDER_MODE_2D;
+    }
+    
+    retTask = shim_queue_render_task(renderTaskPtr);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E0078274(void) {
 }

src/effects/effect_61.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_61_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_61", fx_61_main);
 
@@ -7,7 +10,18 @@ void fx_61_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_61", fx_61_update);
 
-INCLUDE_ASM(s32, "effects/effect_61", fx_61_render);
+void fx_61_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_61_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 void func_E007A884(void) {
 }

src/effects/effect_62.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_62_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_62", fx_62_main);
 
@@ -7,6 +10,17 @@ void fx_62_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_62", fx_62_update);
 
-INCLUDE_ASM(s32, "effects/effect_62", fx_62_render);
+void fx_62_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_62_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_62", fx_62_appendGfx);

src/effects/effect_63.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_63_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_63", fx_63_main);
 
@@ -7,6 +10,17 @@ void fx_63_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_63", fx_63_update);
 
-INCLUDE_ASM(s32, "effects/effect_63", fx_63_render);
+void fx_63_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_63_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_63", fx_63_appendGfx);

src/effects/effect_64.c

@@ -1,4 +1,5 @@
 #include "common.h"
+#include "effects_internal.h"
 
 INCLUDE_ASM(s32, "effects/effect_64", fx_64_main);
 

src/effects/effect_65.c

@@ -1,4 +1,5 @@
 #include "common.h"
+#include "effects_internal.h"
 
 INCLUDE_ASM(s32, "effects/effect_65", fx_65_main);
 

src/effects/effect_66.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_66_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_66", func_E0084000);
 
@@ -13,6 +16,17 @@ void fx_66_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_66", fx_66_update);
 
-INCLUDE_ASM(s32, "effects/effect_66", fx_66_render);
+void fx_66_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_66_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_28;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_66", fx_66_appendGfx);

src/effects/effect_67.c

@@ -1,4 +1,5 @@
 #include "common.h"
+#include "effects_internal.h"
 
 INCLUDE_ASM(s32, "effects/effect_67", fx_67_main);
 

src/effects/effect_68.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_68_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_68", func_E0088000);
 
@@ -9,6 +12,16 @@ void fx_68_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_68", fx_68_update);
 
-INCLUDE_ASM(s32, "effects/effect_68", fx_68_render);
+void fx_68_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_68_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 INCLUDE_ASM(s32, "effects/effect_68", fx_68_appendGfx);

src/effects/effect_69.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_69_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_69", func_E008A000);
 
@@ -11,6 +14,17 @@ INCLUDE_ASM(s32, "effects/effect_69", func_E008A290);
 
 INCLUDE_ASM(s32, "effects/effect_69", fx_69_update);
 
-INCLUDE_ASM(s32, "effects/effect_69", fx_69_render);
+void fx_69_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_69_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_69", fx_69_appendGfx);

src/effects/effect_70.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_70_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_70", fx_70_main);
 
@@ -7,6 +10,17 @@ void fx_70_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_70", fx_70_update);
 
-INCLUDE_ASM(s32, "effects/effect_70", fx_70_render);
+void fx_70_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_70_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 0;
+    renderTask.renderMode = RENDER_MODE_2D;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_70", fx_70_appendGfx);

src/effects/effect_71.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_71_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_71", fx_71_main);
 
@@ -7,6 +10,17 @@ void fx_71_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_71", fx_71_update);
 
-INCLUDE_ASM(s32, "effects/effect_71", fx_71_render);
+void fx_71_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_71_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_SURFACE_XLU_LAYER3;
+
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_71", fx_71_appendGfx);

src/effects/effect_72.c

@@ -1,4 +1,5 @@
 #include "common.h"
+#include "effects_internal.h"
 
 INCLUDE_ASM(s32, "effects/effect_72", fx_72_main);
 

src/effects/effect_74.c

@@ -1,4 +1,7 @@
 #include "common.h"
+#include "effects_internal.h"
+
+void fx_74_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_74", fx_74_main);
 
@@ -7,6 +10,16 @@ void fx_74_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_74", fx_74_update);
 
-INCLUDE_ASM(s32, "effects/effect_74", fx_74_render);
+void fx_74_render(EffectInstance* effect) {
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_74_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = 10;
+    renderTask.renderMode = RENDER_MODE_SURFACE_XLU_LAYER3;
+
+    retTask = shim_queue_render_task(&renderTask);
+}
 
 INCLUDE_ASM(s32, "effects/effect_74", fx_74_appendGfx);

src/effects/effect_76.c

@@ -1,4 +1,12 @@
 #include "common.h"
+#include "effects_internal.h"
+
+typedef struct Effect76 {
+    /* 0x00 */ char unk_00[0xC];
+    /* 0x0C */ f32 unk_0C;
+} Effect76; // size = 0x??
+
+void fx_76_appendGfx(EffectInstance* effect);
 
 INCLUDE_ASM(s32, "effects/effect_76", fx_76_main);
 
@@ -7,6 +15,18 @@ void fx_76_init(void) {
 
 INCLUDE_ASM(s32, "effects/effect_76", fx_76_update);
 
-INCLUDE_ASM(s32, "effects/effect_76", fx_76_render);
+void fx_76_render(EffectInstance *effect) {
+    Effect76* effect76 = effect->data;
+    RenderTask renderTask;
+    RenderTask* retTask;
+
+    renderTask.appendGfx = fx_76_appendGfx;
+    renderTask.appendGfxArg = effect;
+    renderTask.distance = effect76->unk_0C;
+    renderTask.renderMode = RENDER_MODE_2D;
+    
+    retTask = shim_queue_render_task(&renderTask);
+    retTask->renderMode |= RENDER_MODE_2;
+}
 
 INCLUDE_ASM(s32, "effects/effect_76", fx_76_appendGfx);