m_fbdemo* OK (#223)

* m_fbdemo OK

* m_fbdemo_wipe1 OK

* fix play

* m_fbdemo_triforce OK

* link triforce

* m_fbdemo_fade OK

* typo

* newline

* format

4 files changed, 517 insertions, 0 deletions

diff --git a/src/code/m_fbdemo.c b/src/code/m_fbdemo.c
new file mode 100644
index 0000000..1b60b94
--- /dev/null
+++ b/src/code/m_fbdemo.c
@@ -0,0 +1,223 @@
+#include "m_fbdemo.h"
+#include "libc64/sleep.h"
+#include "libc64/malloc.h"
+#include "attributes.h"
+
+Gfx fbdemo_gfx_init[] = {
+    gsDPPipeSync(),
+    gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON),
+    gsSPClearGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN |
+                          G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
+    gsDPSetCombineMode(G_CC_DECALRGB, G_CC_DECALRGB),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_1PRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_AA_OPA_SURF | G_RM_AA_OPA_SURF2),
+    gsSPEndDisplayList(),
+};
+
+#define SET_VERTEX(vtx, x, y, z, s, t, nx, ny, nz, alpha) \
+    {                                                     \
+        Vtx_tn* vtxn = &(vtx)->n;                         \
+        vtxn->ob[0] = (x);                                \
+        vtxn->ob[1] = (y);                                \
+        vtxn->ob[2] = (z);                                \
+        vtxn->flag = 0;                                   \
+        vtxn->tc[0] = (s);                                \
+        vtxn->tc[1] = (t);                                \
+        vtxn->n[0] = (nx);                                \
+        vtxn->n[1] = (ny);                                \
+        vtxn->n[2] = (nz);                                \
+        vtxn->a = (alpha);                                \
+    }
+
+void fbdemo_init_gfx(fbDemo* this) {
+    s32 col;
+    s32 col2;
+    s32 colTex;
+    s32 rowTex;
+    s32 row;
+    s32 frame;
+    Vtx* vtx;
+    Gfx* gfx;
+
+    guMtxIdent(&this->modelView1);
+    guMtxIdent(&this->modelView2);
+    guOrtho(&this->projection, 0.0f, 320, 240, 0.0f, -1000.0f, 1000.0f, 1.0f);
+
+    for (frame = 0; frame < 2; frame++) {
+        this->frame = frame;
+        vtx = (this->frame == 0) ? this->vtxFrame1 : this->vtxFrame2;
+        for (rowTex = 0, row = 0; row < (this->rows + 1); rowTex += 0x20, row++) {
+            for (colTex = 0, col = 0; col < (this->cols + 1); col++, colTex += 0x20) {
+                SET_VERTEX(vtx++, col * 0x20, row * 0x20, -5, colTex << 6, rowTex << 6, 0, 0, 120, 255);
+            }
+        }
+    }
+
+    gfx = this->gfxtbl;
+
+    for (rowTex = 0, row = 0; row < this->rows; rowTex += 0x20, row++) {
+        gSPVertex(gfx++, SEGMENT_ADDR(G_MWO_SEGMENT_A, (u32)row * (this->cols + 1) * sizeof(Vtx)), 2 * (this->cols + 1),
+                  0);
+
+        colTex = 0;
+        col = 0;
+        col2 = 0;
+        while (col < this->cols) {
+            gDPPipeSync(gfx++);
+
+            gDPLoadTextureTile(gfx++, SEGMENT_ADDR(G_MWO_SEGMENT_B, 0), G_IM_FMT_RGBA, G_IM_SIZ_16b, 320, 240, colTex,
+                               rowTex, colTex + 0x20, rowTex + 0x20, 0, G_TX_NOMIRROR | G_TX_WRAP,
+                               G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
+
+            gSP1Quadrangle(gfx++, col2, col2 + 1, col2 + (this->cols) + 2, this->cols + 1 + col2, 0);
+
+            colTex += 0x20;
+            col2++;
+            col++;
+        }
+    }
+
+    gDPPipeSync(gfx++);
+    gSPEndDisplayList(gfx++);
+}
+
+void fbdemo_init_data(fbDemo* this) {
+    s32 col;
+    s32 row;
+
+    for (row = 0; row < this->rows + 1; row++) {
+        for (col = 0; col < this->cols + 1; col++) {
+            (this->vtxData + col + row * (this->cols + 1))->x = col * 0x20;
+            (this->vtxData + col + row * (this->cols + 1))->y = row * 0x20;
+        }
+    }
+}
+
+void fbdemo_cleanup(fbDemo* this) {
+    msleep(100);
+
+    if (this->vtxData != NULL) {
+        free(this->vtxData);
+        this->vtxData = NULL;
+    }
+    if (this->vtxFrame1 != NULL) {
+        free(this->vtxFrame1);
+        this->vtxFrame1 = NULL;
+    }
+    if (this->vtxFrame2 != NULL) {
+        free(this->vtxFrame2);
+        this->vtxFrame2 = NULL;
+    }
+    if (this->gfxtbl != NULL) {
+        free(this->gfxtbl);
+        this->gfxtbl = NULL;
+    }
+}
+
+fbDemo* fbdemo_init(fbDemo* this, s32 cols, s32 rows) {
+    bzero(this, sizeof(fbDemo));
+
+    this->cols = cols;
+    this->rows = rows;
+
+    this->frame = 0;
+    this->vtxData = malloc((cols + 1) * sizeof(xy_t) * (rows + 1));
+
+    this->vtxFrame1 = malloc((cols + 1) * sizeof(Vtx) * (rows + 1));
+    this->vtxFrame2 = malloc((cols + 1) * sizeof(Vtx) * (rows + 1));
+
+    this->gfxtbl = malloc((this->rows * (this->cols * 9 + 1) + 2) * sizeof(Gfx));
+
+    if ((this->vtxData == NULL) || (this->vtxFrame1 == NULL) || (this->vtxFrame2 == NULL) || (this->gfxtbl == NULL)) {
+        if (this->vtxData != NULL) {
+            free(this->vtxData);
+            this->vtxData = NULL;
+        }
+
+        if (this->vtxFrame1 != NULL) {
+            free(this->vtxFrame1);
+            this->vtxFrame1 = NULL;
+        }
+
+        if (this->vtxFrame2 != NULL) {
+            free(this->vtxFrame2);
+            this->vtxFrame2 = NULL;
+        }
+
+        if (this->gfxtbl != NULL) {
+            free(this->gfxtbl);
+            this->gfxtbl = NULL;
+        }
+
+        return NULL;
+    }
+
+    fbdemo_init_gfx(this);
+    fbdemo_init_data(this);
+    this->frame = 0;
+
+    return this;
+}
+
+void fbdemo_update(fbDemo* this) {
+    s32 col;
+    s32 row;
+    Vtx* vtx;
+
+    for (row = 0; row < this->rows + 1; row++) {
+        for (col = 0; col < this->cols + 1; col++) {
+            vtx = (this->frame == 0) ? this->vtxFrame1 : this->vtxFrame2;
+            (vtx + col + row * (this->cols + 1))->n.ob[0] = (this->vtxData + col + row * (this->cols + 1))->x;
+
+            vtx = (this->frame == 0) ? this->vtxFrame1 : this->vtxFrame2;
+            (vtx + col + row * (this->cols + 1))->n.ob[1] = (this->vtxData + col + row * (this->cols + 1))->y;
+        }
+    }
+}
+
+void fbdemo_draw(fbDemo* this, Gfx** gfxP) {
+    Gfx* gfx = *gfxP;
+
+    gSPDisplayList(gfx++, fbdemo_gfx_init);
+    fbdemo_update(this);
+    gSPMatrix(gfx++, &this->projection, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+    gSPMatrix(gfx++, &this->modelView1, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+    gSPSegment(gfx++, G_MWO_SEGMENT_A, this->frame == 0 ? this->vtxFrame1 : this->vtxFrame2);
+    gSPSegment(gfx++, G_MWO_SEGMENT_B, this->zBuffer);
+    gSPDisplayList(gfx++, fbdemo_gfx_init);
+    gSPDisplayList(gfx++, this->gfxtbl);
+    gDPPipeSync(gfx++);
+    this->frame ^= 1;
+    *gfxP = gfx;
+}
+
+void fbdemo_move_type_A(fbDemo* this) {
+    s32 row;
+    s32 col;
+    f32 diffX;
+    f32 diffY;
+    f32 scale;
+
+    for (row = 0; row < this->rows + 1; row++) {
+        for (col = 0; col < this->cols + 1; col++) {
+            diffX = (this->vtxData + col + row * (this->cols + 1))->x - (this->vtxData + 5 + 4 * (this->cols + 1))->x;
+            diffY = (this->vtxData + col + row * (this->cols + 1))->y - (this->vtxData + 5 + 4 * (this->cols + 1))->y;
+            scale = (SQ(diffX) + SQ(diffY)) / 100.0f;
+            if (scale != 0.0f) {
+                if (scale < 1.0f) {
+                    scale = 1.0f;
+                }
+                (this->vtxData + col + row * (this->cols + 1))->x -= diffX / scale;
+                (this->vtxData + col + row * (this->cols + 1))->y -= diffY / scale;
+            }
+        }
+    }
+}
+
+void fbdemo_move(UNUSED fbDemo* this) {
+}
+
+s32 fbdemo_is_finish(UNUSED fbDemo* this) {
+    return FALSE;
+}
diff --git a/src/code/m_fbdemo_fade.c b/src/code/m_fbdemo_fade.c
new file mode 100644
index 0000000..4229859
--- /dev/null
+++ b/src/code/m_fbdemo_fade.c
@@ -0,0 +1,91 @@
+#include "m_fbdemo_fade.h"
+#include "m_common_data.h"
+#include "macros.h"
+
+Gfx fbdemo_fade_gfx_init[] = {
+    gsDPPipeSync(),
+    gsSPClearGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN |
+                          G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
+    gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
+                         G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_1PRIMITIVE,
+                     G_AC_NONE | G_ZS_PIXEL | G_RM_CLD_SURF | G_RM_CLD_SURF2),
+    gsDPSetCombineMode(G_CC_PRIMITIVE, G_CC_PRIMITIVE),
+    gsSPEndDisplayList(),
+};
+
+fbDemoFade* fbdemo_fade_init(fbDemoFade* this) {
+    bzero(this, sizeof(fbDemoFade));
+    return this;
+}
+
+void fbdemo_fade_move(fbDemoFade* this, s32 rate) {
+    f32 ftimer;
+    s32 alpha;
+
+    if (this->timer != 0) {
+        this->timer -= 1;
+        return;
+    }
+
+    if (this->type != 7) {
+        this->frame += rate;
+        if (this->frame >= common_data.fadeRate) {
+            this->frame = common_data.fadeRate;
+            this->isDone = 1;
+        }
+        ftimer = (f32)this->frame;
+        if (ftimer < 0.0f) {
+            ftimer = 0.0f;
+        }
+
+        alpha = (255.0f * ftimer) / common_data.fadeRate;
+        if (this->type == 1) {
+            this->color.a = 255 - alpha;
+        } else {
+            this->color.a = alpha;
+        }
+    }
+}
+
+void fbdemo_fade_draw(fbDemoFade* this, Gfx** gfxP) {
+    Gfx* gfx;
+    Color_RGBA8_u32* color = &this->color;
+
+    if (color->a != 0) {
+        gfx = *gfxP;
+        gSPDisplayList(gfx++, fbdemo_fade_gfx_init);
+        gDPSetPrimColor(gfx++, 0, 0, color->r, color->g, color->b, color->a);
+        gDPFillRectangle(gfx++, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+        gDPPipeSync(gfx++);
+        *gfxP = gfx;
+    }
+}
+
+void fbdemo_fade_startup(fbDemoFade* this) {
+    static s16 start_frame[] = { 0x0000, 0xFFFA, 0x0000, 0x0000, 0x0000, 0x0000,
+                                 0xFFAB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 };
+
+    static s32 start_color[] = { 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+    u8 type = this->type;
+
+    this->color.a = start_color[type];
+    this->frame = start_frame[type];
+
+    this->isDone = 0;
+    if (this->type == 1) {
+        this->timer = 5;
+    }
+}
+
+void fbdemo_fade_settype(fbDemoFade* this, int type) {
+    this->type = type;
+}
+
+void fbdemo_fade_setcolor_rgba8888(fbDemoFade* this, u32 color) {
+    this->color.rgba = color;
+}
+
+u8 fbdemo_fade_is_finish(fbDemoFade* this) {
+    return this->isDone;
+}
diff --git a/src/code/m_fbdemo_triforce.c b/src/code/m_fbdemo_triforce.c
new file mode 100644
index 0000000..48137e6
--- /dev/null
+++ b/src/code/m_fbdemo_triforce.c
@@ -0,0 +1,109 @@
+#include "m_fbdemo_triforce.h"
+#include "gfxalloc.h"
+#include "m_rcp.h"
+#include "attributes.h"
+
+extern u8 ef_wipe1_modelT[];
+extern u8 ef_wipe2_modelT[];
+extern u8 ef_wipe3_modelT[];
+
+void fbdemo_triforce_startup(fbDemoTriforce* this) {
+    this->finished = 0;
+    this->frame = 16;
+
+    if (this->direction != 0) {
+        this->txt = 0;
+    } else {
+        this->txt = 0x224;
+    }
+
+    guPerspective(&this->perspMtx, &this->normal, 60.0f, 4.0f / 3.0f, 10.0f, 12800.0f, 1.0f);
+    guLookAt(&this->lookAtMtx, 0.0f, 0.0f, 400.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
+}
+
+fbDemoTriforce* fbdemo_triforce_init(fbDemoTriforce* this) {
+    bzero(this, sizeof(fbDemoTriforce));
+    return this;
+}
+
+void fbdemo_triforce_setrate(s32* rate, f32 scale) {
+    *rate = 548.0f * scale;
+}
+
+void fbdemo_triforce_move(fbDemoTriforce* this, s32 rate) {
+    s32 moveRate;
+    UNUSED s32 txt = this->txt;
+    f32 temp = (1.0f - (this->txt / 548.0f));
+
+    moveRate = this->frame + (s32)(12.0f * temp);
+
+    if (this->direction != 0) {
+
+        this->txt += (moveRate << 1) / rate;
+        if (this->txt >= 548) {
+            this->txt = 548;
+            this->finished = TRUE;
+        }
+    } else {
+        this->txt -= (moveRate << 1) / rate;
+        if (this->txt <= 0) {
+            this->txt = 0;
+            this->finished = TRUE;
+        }
+    }
+}
+
+void fbdemo_triforce_draw(fbDemoTriforce* this, Gfx** gfxP) {
+    Gfx* gfx = *gfxP;
+    Gfx* scroll;
+    f32 scale;
+
+    gDPPipeSync(gfx++);
+    scroll = gfx_tex_scroll2(&gfx, this->txt, 0, 16, 4);
+    gSPSegment(gfx++, G_MWO_SEGMENT_9, scroll);
+    gSPMatrix(gfx++, &this->perspMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+    gSPPerspNormalize(gfx++, this->normal);
+    gSPMatrix(gfx++, &this->lookAtMtx, G_MTX_MUL | G_MTX_PROJECTION);
+
+    scale = 0.019f;
+
+    if (1.0f != scale) {
+        Mtx* mtxBuf;
+
+        mtxBuf = gfxalloc(&gfx, sizeof(Mtx));
+
+        guScale(mtxBuf, 0.019f, 0.019f, 1.0f);
+        gSPMatrix(gfx++, mtxBuf, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+    }
+
+    switch (this->textureNo) {
+        case 0:
+            gSPDisplayList(gfx++, ef_wipe1_modelT);
+            break;
+        case 1:
+            gSPDisplayList(gfx++, ef_wipe2_modelT);
+            break;
+        case 2:
+            gSPDisplayList(gfx++, ef_wipe3_modelT);
+            break;
+    }
+    gDPPipeSync(gfx++);
+    *gfxP = gfx;
+}
+
+u8 fbdemo_triforce_is_finish(fbDemoTriforce* this) {
+    return this->finished;
+}
+
+void fbdemo_triforce_settype(fbDemoTriforce* this, s32 type) {
+    this->textureNo = ((type & 0x80) != 0) ? 1 : ((type & 0x40) != 0 ? 2 : 0);
+
+    if ((type & 0xF) == 1) {
+        this->direction = 0;
+    } else {
+        this->direction = 1;
+    }
+}
+
+void fbdemo_triforce_setcolor_rgba8888(UNUSED fbDemoTriforce* this, UNUSED u32* rgba) {
+}
diff --git a/src/code/m_fbdemo_wipe1.c b/src/code/m_fbdemo_wipe1.c
new file mode 100644
index 0000000..3fc67f2
--- /dev/null
+++ b/src/code/m_fbdemo_wipe1.c
@@ -0,0 +1,94 @@
+#include "m_fbdemo_wipe1.h"
+#include "m_common_data.h"
+#include "m_rcp.h"
+
+extern Gfx wipe1_modelT[]; // TODO: extract
+
+fbDemoWipe1* fbdemo_wipe1_init(fbDemoWipe1* this) {
+    bzero(this, sizeof(fbDemoWipe1));
+    return this;
+}
+
+void fbdemo_wipe1_move(fbDemoWipe1* this, s32 rate) {
+    if (this->direction != 0) {
+        this->texY += (common_data.wipeRate * 3) / rate;
+        if (this->texY >= (s32)(153.0f * (1 << 2))) {
+            this->texY = (s32)(153.0f * (1 << 2));
+            this->finished = TRUE;
+        }
+    } else {
+        this->texY -= (common_data.wipeRate * 3) / rate;
+        if (this->texY <= (s32)(83.25f * (1 << 2))) {
+            this->texY = (s32)(83.25f * (1 << 2));
+            this->finished = TRUE;
+        }
+    }
+}
+
+void fbdemo_wipe1_draw(fbDemoWipe1* this, Gfx** gfxP) {
+    Gfx* gfx = *gfxP;
+    Mtx* modelView;
+    UNUSED s32 pad[5];
+
+    Gfx* texScroll;
+
+    modelView = this->modelView[this->frame];
+    this->frame ^= 1;
+
+    guScale(&modelView[0], 0.56f, 0.56f, 1.0f);
+    guRotate(&modelView[1], 0.0f, 0.0f, 0.0f, 1.0f);
+    guTranslate(&modelView[2], 0.0f, 0.0f, 0.0f);
+    gDPPipeSync(gfx++);
+
+    texScroll = gfx_tex_scroll2(&gfx, this->texX, this->texY, 0, 0);
+    gSPSegment(gfx++, 8, texScroll);
+
+    gDPSetPrimColor(gfx++, 0, 0x80, this->color.r, this->color.g, this->color.b, 255);
+
+    gSPMatrix(gfx++, &this->projection, G_MTX_LOAD | G_MTX_PROJECTION);
+    gSPPerspNormalize(gfx++, this->normal);
+
+    gSPMatrix(gfx++, &this->lookAt, G_MTX_MUL | G_MTX_PROJECTION);
+    gSPMatrix(gfx++, &modelView[0], G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+    gSPMatrix(gfx++, &modelView[1], G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
+    gSPMatrix(gfx++, &modelView[2], G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
+
+    gSPDisplayList(gfx++, wipe1_modelT);
+    gDPPipeSync(gfx++);
+    *gfxP = gfx;
+}
+
+void fbdemo_wipe1_startup(fbDemoWipe1* this) {
+    this->finished = 0;
+
+    if (this->direction != 0) {
+        this->texY = (s32)(83.25f * (1 << 2));
+    } else {
+        this->texY = (s32)(153.0f * (1 << 2));
+    }
+
+    guPerspective(&this->projection, &this->normal, 60.0f, 4.0f / 3.0f, 10.0f, 12800.0f, 1.0f);
+    guLookAt(&this->lookAt, 0.0f, 0.0f, 400.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
+}
+
+void fbdemo_wipe1_settype(fbDemoWipe1* this, s32 type) {
+    if (type == 1) {
+        this->direction = 1;
+        this->texY = 0x14D;
+        return;
+    }
+    this->direction = 0;
+    this->texY = 0x264;
+}
+
+void fbdemo_wipe1_setcolor_rgba8888(fbDemoWipe1* this, u32 color) {
+    this->color.rgba = color;
+}
+
+void fbdemo_wipe1_setaltcolor_rgba8888(fbDemoWipe1* this, u32 color) {
+    this->altColor.rgba = color;
+}
+
+u8 fbdemo_wipe1_is_finish(fbDemoWipe1* this) {
+    return this->finished;
+}