imgfx.c File Reference

Go to the source code of this file.

Data Structures
union	ImgFXIntVars
union	ImgFXFloatVars
struct	ImgFXState
struct	ImgFXCacheEntry
struct	ImgFXRenderMode
struct	ImgFXIntVars.args
struct	ImgFXIntVars.anim
struct	ImgFXIntVars.wavy
struct	ImgFXIntVars.color
struct	ImgFXIntVars.hologram
struct	ImgFXIntVars.overlay
struct	ImgFXFloatVars.anim
struct	ImgFXFloatVars.wavy
struct	ImgFXFloatVars.overlay

Typedefs
typedef ImgFXState	ImgFXInstanceList[MAX_IMGFX_INSTANCES]

Enumerations
enum	ImgFXAnimFlags { IMGFX_ANIM_FLAG_ABSOLUTE_COORDS = 1 }

Functions
void	imgfx_cache_instance_data (ImgFXState *state)
void	imgfx_clear_instance_data (ImgFXState *state)
void	imgfx_init_instance (ImgFXState *state)
void	imgfx_make_mesh (ImgFXState *state)
void	imgfx_appendGfx_mesh (ImgFXState *state, Matrix4f mtx)
void	imgfx_mesh_make_strip (ImgFXState *state)
void	imgfx_mesh_make_grid (ImgFXState *state)
void	imgfx_mesh_anim_update (ImgFXState *state)
void	imgfx_appendGfx_mesh_basic (ImgFXState *, Matrix4f mtx)
void	imgfx_appendGfx_mesh_grid (ImgFXState *, Matrix4f mtx)
void	imgfx_appendGfx_mesh_anim (ImgFXState *, Matrix4f mtx)
void	imgfx_appendGfx_mesh_strip (ImgFXState *, Matrix4f mtx)
void	imgfx_wavy_init (ImgFXState *state)
void	imgfx_mesh_make_wavy (ImgFXState *state)
void	imgfx_mesh_load_colors (ImgFXState *state)
void	imgfx_set_vtx_buf_capacity (s16 arg0)
void	imgfx_init (void)
void	func_8013A4D0 (void)
void	imgfx_add_to_cache (void *data, s8 usingContextualHeap)
void	imgfx_update_cache_impl (void)
void	imgfx_update_cache (void)
s32	imgfx_get_free_instances (s32 count)
void	imgfx_release_instance (u32 idx)
void	imgfx_release_instance_chain (u32 idx)
s32	imgfx_get_next_instance (s32 idx)
ImgFXState *	imgfx_get_instance (s32 idx)
void	imgfx_update (u32 idx, ImgFXType type, s32 imgfxArg1, s32 imgfxArg2, s32 imgfxArg3, s32 imgfxArg4, s32 flags)
void	imgfx_set_state_flags (s32 idx, u16 flagBits, s32 mode)
s32	imgfx_appendGfx_component (s32 idx, ImgFXTexture *ifxImg, u32 flagBits, Matrix4f mtx)
ImgFXAnimHeader *	imgfx_load_anim (ImgFXState *state)

Variables
HeapNode	heap_spriteHead
BSS ImgFXWorkingTexture	ImgFXCurrentTexture
BSS Vtx *	ImgFXVtxBuffers [2]
BSS Vtx *	imgfx_vtxBuf
BSS ImgFXInstanceList *	ImgFXInstances
BSS ImgFXAnimHeader	ImgFXAnimHeaders [MAX_IMGFX_INSTANCES]
BSS ImgFXCacheEntry	ImgFXDataCache [8]
ImgFXWorkingTexture *	ImgFXCurrentTexturePtr = &ImgFXCurrentTexture
u16	imgfx_vtxCount = 0
Lights2	ImgFXLights = gdSPDefLights2(144, 144, 144, 255, 255, 255, 0, 0, 120, 255, 255, 255, 0, 0, 136)
Vp	D_8014EE40
Vp	D_8014EE50
u16	ImgFXVtxBufferCapacity = 300
Gfx	DefaultImgFXSetupGfx []
ImgFXRenderMode	ImgFXRenderModes []
Addr	shock_header
Addr	shiver_header
Addr	vertical_pipe_curl_header
Addr	horizontal_pipe_curl_header
Addr	startle_header
Addr	flutter_down_header
Addr	unfurl_header
Addr	get_in_bed_header
Addr	spirit_capture_header
Addr	unused_1_header
Addr	unused_2_header
Addr	unused_3_header
Addr	tutankoopa_gather_header
Addr	tutankoopa_swirl_2_header
Addr	tutankoopa_swirl_1_header
Addr	shuffle_cards_header
Addr	flip_card_1_header
Addr	flip_card_2_header
Addr	flip_card_3_header
Addr	cymbal_crush_header
u8 *	ImgFXAnimOffsets []

---

Data Structure Documentation

ImgFXIntVars

union ImgFXIntVars

Data Fields
s32	raw[2][4]
struct ImgFXIntVars.args	args
struct ImgFXIntVars.anim	anim
struct ImgFXIntVars.wavy	wavy
struct ImgFXIntVars.color	color
struct ImgFXIntVars.hologram	hologram
struct ImgFXIntVars.overlay	overlay

ImgFXFloatVars

union ImgFXFloatVars

Data Fields
f32	raw[2][4]
struct ImgFXFloatVars.anim	anim
struct ImgFXFloatVars.wavy	wavy
struct ImgFXFloatVars.overlay	overlay

ImgFXState

struct ImgFXState

Data Fields
u8	arrayIdx
u8	meshType
u8	renderType
u8	subdivX
u8	subdivY
s8	lastAnimCmd
s8	lastColorCmd
char	unk_07[0x1]
u16	firstVtxIdx
u16	lastVtxIdx
u16	unk_0C
s16	unk_0E
s16	nextIdx
s32	flags
char	unk_18[0x4]
ImgFXIntVars	ints
ImgFXFloatVars	floats
Color_RGBA8 *	colorBuf
u16	colorBufCount
char	unk_62[0x2]
u8 *	curAnimOffset
Vtx *	vtxBufs[2]
Gfx *	gfxBufs[2]
s32	otherModeL

ImgFXCacheEntry

struct ImgFXCacheEntry

Data Fields
s32 *	data
u8	staleCooldownTimer
u8	usingContextualHeap
char	unk_06[0x2]

ImgFXRenderMode

struct ImgFXRenderMode

Data Fields
s32	mode1
s32	mode2
u8	flags

ImgFXIntVars.args

struct ImgFXIntVars.args

Data Fields
s32	anim[4]
s32	color[4]

ImgFXIntVars.anim

struct ImgFXIntVars.anim

Data Fields
s32	type
s32	interval
s32	step

ImgFXIntVars.wavy

struct ImgFXIntVars.wavy

Data Fields
Vec3i	mag

ImgFXIntVars.color

struct ImgFXIntVars.color

Data Fields
char	unk_00[0x10]
s32	r
s32	g
s32	b
s32	a

ImgFXIntVars.hologram

struct ImgFXIntVars.hologram

Data Fields
char	unk_00[0x10]
s32	mode
s32	noiseAmt
char	unk_18[4]
s32	alphaAmt

ImgFXIntVars.overlay

struct ImgFXIntVars.overlay

Data Fields
char	unk_00[0x10]
ImgFXOverlayTexture *	pattern
s32	alpha

ImgFXFloatVars.anim

struct ImgFXFloatVars.anim

Data Fields
f32	curFrame
f32	curIdx

ImgFXFloatVars.wavy

struct ImgFXFloatVars.wavy

Data Fields
f32	phase1
f32	phase2
f32	phase3

ImgFXFloatVars.overlay

struct ImgFXFloatVars.overlay

Data Fields
char	unk_00[0x10]
f32	posX
f32	posY

Typedef Documentation

ImgFXInstanceList

typedef ImgFXState ImgFXInstanceList[MAX_IMGFX_INSTANCES]

Definition at line 111 of file imgfx.c.

Enumeration Type Documentation

ImgFXAnimFlags

enum ImgFXAnimFlags

Enumerator
IMGFX_ANIM_FLAG_ABSOLUTE_COORDS

Definition at line 101 of file imgfx.c.

                    {
    IMGFX_ANIM_FLAG_ABSOLUTE_COORDS  = 1, // image-relative (in percent) when unset
};

Function Documentation

imgfx_cache_instance_data()

void imgfx_cache_instance_data

(

ImgFXState *

state

)

Definition at line 420 of file imgfx.c.

                                                  {
    if (state->curAnimOffset != nullptr) {
        state->curAnimOffset = nullptr;
    }
    if (state->vtxBufs[0] != nullptr) {
        imgfx_add_to_cache(state->vtxBufs[0], true);
        state->vtxBufs[0] = nullptr;
    }
    if (state->vtxBufs[1] != nullptr) {
        imgfx_add_to_cache(state->vtxBufs[1], true);
        state->vtxBufs[1] = nullptr;
    }
    if (state->gfxBufs[0] != nullptr) {
        imgfx_add_to_cache(state->gfxBufs[0], true);
        state->gfxBufs[0] = nullptr;
    }
    if (state->gfxBufs[1] != nullptr) {
        imgfx_add_to_cache(state->gfxBufs[1], true);
        state->gfxBufs[1] = nullptr;
    }
}

Referenced by func_8013A4D0(), imgfx_appendGfx_component(), and imgfx_update().

imgfx_clear_instance_data()

void imgfx_clear_instance_data

(

ImgFXState *

state

)

Definition at line 442 of file imgfx.c.

                                                  {
    state->curAnimOffset = nullptr;
    state->vtxBufs[0] = nullptr;
    state->vtxBufs[1] = nullptr;
    state->gfxBufs[0] = nullptr;
    state->gfxBufs[1] = nullptr;
    state->colorBuf = nullptr;
    state->colorBufCount = 0;
}

Referenced by imgfx_init().

imgfx_init_instance()

void imgfx_init_instance

(

ImgFXState *

state

)

Definition at line 452 of file imgfx.c.

                                            {
    s32 i;
    s32 j;
 
    state->nextIdx = -1;
    state->lastAnimCmd = IMGFX_CLEAR;
    state->lastColorCmd = IMGFX_CLEAR;
    state->flags = 0;
    state->meshType = IMGFX_MESH_DEFAULT;
    state->renderType = IMGFX_RENDER_DEFAULT;
    state->firstVtxIdx = 0;
    state->lastVtxIdx = 0;
    state->unk_0C = 0;
    state->unk_0E = 0;
    state->ints.raw[0][3] = 255;
    state->ints.raw[1][3] = 255;
    state->subdivX = 0;
    state->subdivY = 0;
    state->firstVtxIdx = 0;
    state->lastVtxIdx = 0;
 
    for (i = 0; i < ARRAY_COUNT(state->ints.raw); i++) {
        for (j = 0; j < ARRAY_COUNT(state->ints.raw[0]); j++) {
            state->ints.raw[i][j] = 0;
        }
    }
 
    for (i = 0; i < ARRAY_COUNT(state->floats.raw); i++) {
        for (j = 0; j < ARRAY_COUNT(state->floats.raw[0]); j++) {
            state->floats.raw[i][j] = 0;
        }
    }
}

Referenced by func_8013A4D0(), imgfx_get_free_instances(), imgfx_init(), and imgfx_update().

imgfx_make_mesh()

void imgfx_make_mesh

(

ImgFXState *

state

)

Definition at line 760 of file imgfx.c.

                                        {
    switch (state->meshType) {
        case IMGFX_MESH_GRID_UNUSED:
            if (state->ints.raw[1][2] == 0) {
                state->subdivX = 1;
                state->subdivY = 16;
            } else {
                state->subdivX = 1;
                state->subdivY = 1;
            }
            // fallthrough
        case IMGFX_MESH_GRID_WAVY:
            imgfx_mesh_make_grid(state);
            break;
        case IMGFX_MESH_ANIMATED:
            imgfx_mesh_anim_update(state);
            break;
        case IMGFX_MESH_DEFAULT:
        case IMGFX_MESH_STRIP:
            imgfx_mesh_make_strip(state);
            break;
        default:
            return;
    }
 
    if (state->lastAnimCmd == IMGFX_SET_WAVY) {
        imgfx_mesh_make_wavy(state);
    }
 
    switch (state->lastColorCmd) {
        case IMGFX_COLOR_BUF_SET_MULTIPLY:
        case IMGFX_COLOR_BUF_SET_MODULATE:
            imgfx_mesh_load_colors(state);
            break;
        default:
            break;
    }
}

Referenced by imgfx_appendGfx_component().

imgfx_appendGfx_mesh()

void imgfx_appendGfx_mesh	(	ImgFXState *	state,
		Matrix4f	mtx )

Definition at line 799 of file imgfx.c.

                                                           {
    s16 skipModeChange = false;
    s32 primAlpha = state->ints.color.a;
    s32 renderType = state->renderType;
    s8 angle1;
    s8 angle2;
    f32 ifxImgAlpha;
    ImgFXRenderMode* renderMode;
    s32 mode1;
    s32 mode2;
    s32 dirX1;
    s32 dirZ2;
 
    gDPPipeSync(gMainGfxPos++);
 
    if (!(state->flags & IMGFX_FLAG_SKIP_GFX_SETUP)) {
        gSPDisplayList(gMainGfxPos++, DefaultImgFXSetupGfx);
        if (state->flags & IMGFX_FLAG_NO_FILTERING) {
            gDPSetTextureFilter(gMainGfxPos++, G_TF_POINT);
        }
        if (state->flags & IMGFX_FLAG_G_CULL_BACK) {
            gSPSetGeometryMode(gMainGfxPos++, G_CULL_BACK);
        }
        if (state->flags & IMGFX_FLAG_G_CULL_FRONT) {
            gSPSetGeometryMode(gMainGfxPos++, G_CULL_FRONT);
        }
 
        renderMode = &ImgFXRenderModes[state->renderType];
 
        mode1 = renderMode->mode1;
        mode2 = renderMode->mode2;
        if (renderMode->flags & IMGFX_RENDER_NO_OVERRIDE) {
            skipModeChange = true;
        }
 
        ifxImgAlpha = (f32) ImgFXCurrentTexturePtr->alphaMultiplier / 255.0;
 
        // some modes dont support alpha < 255 and must be replaced
        if (!skipModeChange && (ImgFXCurrentTexturePtr->alphaMultiplier < 255)) {
            state->ints.color.a = 255;
            switch (state->renderType) {
                case IMGFX_RENDER_DEFAULT:
                case IMGFX_RENDER_ANIM:
                    renderType = IMGFX_RENDER_MULTIPLY_ALPHA;
                    break;
                case IMGFX_RENDER_MULTIPLY_RGB:
                case IMGFX_RENDER_MODULATE_PRIM_RGB:
                    renderType = IMGFX_RENDER_MULTIPLY_RGBA;
                    break;
                case IMGFX_RENDER_MODULATE_SHADE_RGB:
                    renderType = IMGFX_RENDER_MODULATE_SHADE_RGBA;
                    break;
                default:
                    break;
            }
            primAlpha = state->ints.color.a * ifxImgAlpha;
            //TODO figure out bits
            mode1 = 0x404B40;
            mode2 = 0x104B40;
            skipModeChange = true;
        }
 
        if ((state->flags & IMGFX_FLAG_400) && !skipModeChange) {
            mode1 &= ~CVG_DST_FULL;
            mode2 &= ~CVG_DST_FULL;
            mode1 |= (ALPHA_CVG_SEL | IM_RD);
            mode2 |= (ALPHA_CVG_SEL | IM_RD);
        }
 
        if (state->flags & IMGFX_FLAG_40) {
            gSPClearGeometryMode(gMainGfxPos++, G_ZBUFFER);
        } else {
            gSPSetGeometryMode(gMainGfxPos++, G_ZBUFFER);
            if (skipModeChange) {
                mode1 |= Z_CMP;
                mode2 |= Z_CMP;
            } else {
                mode1 |= (Z_CMP | Z_UPD);
                mode2 |= (Z_CMP | Z_UPD);
            }
        }
        state->otherModeL = mode2;
        gDPSetRenderMode(gMainGfxPos++, mode1, mode2);
 
        switch (renderType) {
            case IMGFX_RENDER_MULTIPLY_RGB:
                // color: texture * prim
                // alpha: texture
                gDPSetCombineMode(gMainGfxPos++, G_CC_MODULATEIDECALA_PRIM, G_CC_MODULATEIDECALA_PRIM);
                gDPSetPrimColor(gMainGfxPos++, 0, 0, state->ints.color.r, state->ints.color.g,
                                state->ints.color.b, 0);
                break;
            case IMGFX_RENDER_MULTIPLY_ALPHA:
                // color: texture
                // alpha: texture * prim
                if (primAlpha <= 0) {
                    return;
                }
                gDPSetCombineMode(gMainGfxPos++, PM_CC_02, PM_CC_02);
                gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, primAlpha);
                break;
            case IMGFX_RENDER_MULTIPLY_RGBA:
                // color: texture * prim
                // alpha: texture * prim
                if (primAlpha <= 0) {
                    return;
                }
                gDPSetCombineMode(gMainGfxPos++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
                gDPSetPrimColor(gMainGfxPos++, 0, 0, state->ints.color.r, state->ints.color.g,
                                state->ints.color.b, primAlpha);
                break;
            case IMGFX_RENDER_MODULATE_PRIM_RGB:
                // color: lerp from prim color to 1 based on texture intensity
                // alpha: texture
                gDPSetCombineMode(gMainGfxPos++, PM_CC_5B, PM_CC_5B);
                gDPSetPrimColor(gMainGfxPos++, 0, 0, state->ints.color.r, state->ints.color.g,
                                state->ints.color.b, 0);
                break;
            case IMGFX_RENDER_MODULATE_PRIM_RGBA:
                // color: lerp from prim color to 1 based on texture intensity
                // alpha: texture * vtx
                if (primAlpha <= 0) {
                    return;
                }
                gDPSetCombineMode(gMainGfxPos++, PM_CC_5C, PM_CC_5C);
                gDPSetPrimColor(gMainGfxPos++, 0, 0, state->ints.color.r, state->ints.color.g,
                                state->ints.color.b, primAlpha);
                break;
            case IMGFX_RENDER_MULTIPLY_SHADE_RGB:
                // color: modulate vtx color by texture intensity
                // alpha: texture
                gDPSetCombineMode(gMainGfxPos++, G_CC_MODULATEIDECALA, G_CC_MODULATEIDECALA);
                gSPSetGeometryMode(gMainGfxPos++, G_SHADE | G_SHADING_SMOOTH);
                gSPClearGeometryMode(gMainGfxPos++, G_LIGHTING);
                break;
            case IMGFX_RENDER_MODULATE_SHADE_RGB:
                // color: lerp from vtx color to 1 based on texture intensity
                // alpha: texture
                gDPSetCombineMode(gMainGfxPos++, PM_CC_5D, PM_CC_5D);
                gSPSetGeometryMode(gMainGfxPos++, G_SHADE | G_SHADING_SMOOTH);
                gSPClearGeometryMode(gMainGfxPos++, G_LIGHTING);
                break;
            case IMGFX_RENDER_MULTIPLY_SHADE_ALPHA:
                // color: texture
                // alpha: texture * vtx color
                gDPSetCombineMode(gMainGfxPos++, PM_CC_12, PM_CC_12);
                gSPSetGeometryMode(gMainGfxPos++, G_SHADE | G_SHADING_SMOOTH);
                gSPClearGeometryMode(gMainGfxPos++, G_LIGHTING);
                break;
            case IMGFX_RENDER_MULTIPLY_SHADE_RGBA:
                // color: modulate vtx color by texture intensity
                // alpha: modulate vtx alpha by texture intensity
                gDPSetCombineMode(gMainGfxPos++, G_CC_MODULATEIA, G_CC_MODULATEIA);
                gSPSetGeometryMode(gMainGfxPos++, G_SHADE | G_SHADING_SMOOTH);
                gSPClearGeometryMode(gMainGfxPos++, G_LIGHTING);
                break;
            case IMGFX_RENDER_MODULATE_SHADE_RGBA:
                // color: lerp from vtx color to 1 based on texture intensity
                // alpha: vtx color * texture
                gDPSetCombineMode(gMainGfxPos++, PM_CC_5E, PM_CC_5E);
                gSPSetGeometryMode(gMainGfxPos++, G_SHADE | G_SHADING_SMOOTH);
                gSPClearGeometryMode(gMainGfxPos++, G_LIGHTING);
                break;
            case IMGFX_RENDER_ANIM:
                if (state->flags & (IMGFX_FLAG_2000 | IMGFX_FLAG_8000)) {
                    Camera* currentCam = &gCameras[gCurrentCameraID];
 
                    gDPSetCombineMode(gMainGfxPos++, G_CC_MODULATEIDECALA, G_CC_MODULATEIDECALA);
                    gSPSetGeometryMode(gMainGfxPos++, G_SHADE | G_LIGHTING | G_SHADING_SMOOTH);
 
                    angle1 = cosine(currentCam->curYaw) * 120.0f;
                    angle2 = cosine(currentCam->curYaw + 90.0f) * 120.0f;
                    dirX1 = -angle1;
                    dirZ2 = -angle2;
                    ImgFXLights.l[0].l.dir[0] = dirX1;
                    ImgFXLights.l[1].l.dir[0] = angle1;
                    ImgFXLights.l[0].l.dir[2] = angle2;
                    ImgFXLights.l[1].l.dir[2] = dirZ2;
                    gSPSetLights2(gMainGfxPos++, ImgFXLights);
                    break;
                }
                gDPSetCombineMode(gMainGfxPos++, G_CC_DECALRGBA, G_CC_DECALRGBA);
                break;
            case IMGFX_RENDER_HOLOGRAM:
                if (state->ints.hologram.mode == IMGFX_HOLOGRAM_NOISE) {
                    primAlpha = state->ints.hologram.alphaAmt * ifxImgAlpha;
                    // color: blend texure and noise
                    // alpha: texure * prim
                    gDPSetCombineMode(gMainGfxPos++, PM_CC_IMGFX_HOLOGRAM, PM_CC_IMGFX_HOLOGRAM);
                    gDPSetPrimColor(gMainGfxPos++, 0, 0,
                                    state->ints.hologram.noiseAmt,
                                    state->ints.hologram.noiseAmt,
                                    state->ints.hologram.noiseAmt,
                                    primAlpha);
                } else if (state->ints.hologram.mode == IMGFX_HOLOGRAM_DITHER) {
                    primAlpha = state->ints.hologram.alphaAmt * ifxImgAlpha;
                    // color: texture
                    // alpha: texture * prim
                    gDPSetCombineMode(gMainGfxPos++, PM_CC_02, PM_CC_02);
                    gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, primAlpha);
                    gDPSetAlphaCompare(gMainGfxPos++, G_AC_DITHER);
                } else if (state->ints.hologram.mode == IMGFX_HOLOGRAM_THRESHOLD) {
                    s32 blendAlpha = state->ints.hologram.alphaAmt + state->ints.hologram.noiseAmt;
                    if (blendAlpha > 255) {
                        blendAlpha = 255;
                    }
                    primAlpha = state->ints.hologram.alphaAmt * ifxImgAlpha;
                    // color: texture
                    // alpha: texture * prim
                    gDPSetCombineMode(gMainGfxPos++, PM_CC_02, PM_CC_02);
                    gDPSetAlphaDither(gMainGfxPos++, G_AD_NOISE);
                    gDPSetAlphaCompare(gMainGfxPos++, G_AC_THRESHOLD);
                    gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, primAlpha);
                    gDPSetBlendColor(gMainGfxPos++, 0, 0, 0, blendAlpha);
                }
                break;
            case IMGFX_RENDER_COLOR_FILL:
                // color: prim
                // alpha: texture
                gDPSetCombineMode(gMainGfxPos++, PM_CC_IMGFX_COLOR_FILL, PM_CC_IMGFX_COLOR_FILL);
                gDPSetPrimColor(gMainGfxPos++, 0, 0, state->ints.color.r, state->ints.color.g,
                                state->ints.color.b, 0);
                break;
            case IMGFX_RENDER_DEFAULT:
            case IMGFX_RENDER_OVERLAY_RGB:
            case IMGFX_RENDER_UNUSED:
                // color: texture
                // alpha: texture
                gDPSetCombineMode(gMainGfxPos++, G_CC_DECALRGBA, G_CC_DECALRGBA);
                break;
            case IMGFX_RENDER_OVERLAY_RGBA:
                // color: texture
                // alpha: texture * prim
                gDPSetCombineMode(gMainGfxPos++, PM_CC_02, PM_CC_02);
                gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, state->ints.overlay.alpha);
                break;
        }
    }
 
    switch (state->meshType) {
        case IMGFX_MESH_DEFAULT:
            imgfx_appendGfx_mesh_basic(state, mtx);
            break;
        case IMGFX_MESH_GRID_WAVY:
        case IMGFX_MESH_GRID_UNUSED:
            imgfx_appendGfx_mesh_grid(state, mtx);
            break;
        case IMGFX_MESH_ANIMATED:
            imgfx_appendGfx_mesh_anim(state, mtx);
            break;
        case IMGFX_MESH_STRIP:
            imgfx_appendGfx_mesh_basic(state, mtx);
            gDPPipeSync(gMainGfxPos++);
            imgfx_appendGfx_mesh_strip(state, mtx);
            break;
    }
 
    gDPPipeSync(gMainGfxPos++);
 
    if (state->renderType == IMGFX_RENDER_HOLOGRAM) {
        gDPSetAlphaCompare(gMainGfxPos++, G_AC_NONE);
        gDPSetAlphaDither(gMainGfxPos++, G_AD_DISABLE);
    }
}

Referenced by imgfx_appendGfx_component().

imgfx_mesh_make_strip()

void imgfx_mesh_make_strip

(

ImgFXState *

state

)

Definition at line 1064 of file imgfx.c.

                                              {
    s32 offsetY;
    s32 offsetX;
    s32 stepY;
    s32 rightColor;
    s32 leftColor;
    s32 temp2;
    s32 nextY;
 
    stepY = (128 * 32) / ImgFXCurrentTexturePtr->tex.width;
    if (stepY > ImgFXCurrentTexturePtr->tex.height) {
        stepY = ImgFXCurrentTexturePtr->tex.height;
    }
 
    offsetX = ImgFXCurrentTexturePtr->tex.xOffset;
    offsetY = ImgFXCurrentTexturePtr->tex.yOffset;
    state->firstVtxIdx = imgfx_vtxCount;
 
    // create first pair of vertices to begin the strip
    // 'left' side
    imgfx_vtxBuf[imgfx_vtxCount].v.ob[0] = offsetX;
    imgfx_vtxBuf[imgfx_vtxCount].v.ob[1] = offsetY;
    imgfx_vtxBuf[imgfx_vtxCount].v.ob[2] = 0;
    imgfx_vtxBuf[imgfx_vtxCount].v.tc[0] = (0 + 256) * 32;
    imgfx_vtxBuf[imgfx_vtxCount].v.tc[1] = temp2 = (0 + 256) * 32; // required to match
    imgfx_vtxBuf[imgfx_vtxCount].v.cn[0] = 240;
    imgfx_vtxBuf[imgfx_vtxCount].v.cn[1] = 240;
    imgfx_vtxBuf[imgfx_vtxCount].v.cn[2] = 240;
    // 'right' side
    imgfx_vtxBuf[imgfx_vtxCount + 1].v.ob[0] = ImgFXCurrentTexturePtr->tex.width + offsetX;
    imgfx_vtxBuf[imgfx_vtxCount + 1].v.ob[1] = offsetY;
    imgfx_vtxBuf[imgfx_vtxCount + 1].v.ob[2] = 0;
    imgfx_vtxBuf[imgfx_vtxCount + 1].v.tc[0] = (ImgFXCurrentTexturePtr->tex.width + 256) * 32;
    imgfx_vtxBuf[imgfx_vtxCount + 1].v.tc[1] = temp2;
    imgfx_vtxBuf[imgfx_vtxCount + 1].v.cn[0] = 120;
    imgfx_vtxBuf[imgfx_vtxCount + 1].v.cn[1] = 120;
    imgfx_vtxBuf[imgfx_vtxCount + 1].v.cn[2] = 120;
 
    // create remaining pairs of vertices along the strip
    nextY = stepY;
    while (true) {
        rightColor = (nextY * 120) / ImgFXCurrentTexturePtr->tex.height;
        leftColor = rightColor + 120;
        imgfx_vtxCount += 2;
 
        // 'left' side
        imgfx_vtxBuf[imgfx_vtxCount].v.ob[0] = offsetX;
        imgfx_vtxBuf[imgfx_vtxCount].v.ob[1] = offsetY - stepY;
        imgfx_vtxBuf[imgfx_vtxCount].v.ob[2] = 0;
        imgfx_vtxBuf[imgfx_vtxCount].v.tc[0] = (0 + 256) * 32;
        imgfx_vtxBuf[imgfx_vtxCount].v.tc[1] = (nextY + 256) * 32;
        imgfx_vtxBuf[imgfx_vtxCount].v.cn[0] = leftColor;
        imgfx_vtxBuf[imgfx_vtxCount].v.cn[1] = leftColor;
        imgfx_vtxBuf[imgfx_vtxCount].v.cn[2] = leftColor;
 
        // 'right' side
        imgfx_vtxBuf[imgfx_vtxCount + 1].v.ob[0] = ImgFXCurrentTexturePtr->tex.width + offsetX;
        imgfx_vtxBuf[imgfx_vtxCount + 1].v.ob[1] = offsetY - stepY;
        imgfx_vtxBuf[imgfx_vtxCount + 1].v.ob[2] = 0;
        imgfx_vtxBuf[imgfx_vtxCount + 1].v.tc[0] = (ImgFXCurrentTexturePtr->tex.width + 256) * 32;
        imgfx_vtxBuf[imgfx_vtxCount + 1].v.tc[1] = (nextY + 256) * 32;
        imgfx_vtxBuf[imgfx_vtxCount + 1].v.cn[0] = rightColor;
        imgfx_vtxBuf[imgfx_vtxCount + 1].v.cn[1] = rightColor;
        imgfx_vtxBuf[imgfx_vtxCount + 1].v.cn[2] = rightColor;
 
        if (nextY != ImgFXCurrentTexturePtr->tex.height) {
            offsetY -= stepY;
            if (ImgFXCurrentTexturePtr->tex.height < nextY + stepY) {
                stepY = ImgFXCurrentTexturePtr->tex.height - nextY;
            }
        } else {
            imgfx_vtxCount += 2;
            break;
        }
        nextY += stepY;
    }
 
    state->lastVtxIdx = imgfx_vtxCount - 1;
    state->subdivX = 1;
    state->subdivY = ((state->lastVtxIdx - state->firstVtxIdx) - 1) / 2;
}

Referenced by imgfx_make_mesh().

imgfx_mesh_make_grid()

void imgfx_mesh_make_grid

(

ImgFXState *

state

)

Definition at line 1146 of file imgfx.c.

                                             {
    f32 divSizeX;
    f32 divSizeY;
    f32 posX;
    f32 posY;
    f32 texU;
    f32 texV;
    Vtx* vtx;
    s32 i;
 
    state->firstVtxIdx = imgfx_vtxCount;
    divSizeX = ImgFXCurrentTexturePtr->tex.width / (f32) state->subdivX;
    divSizeY = ImgFXCurrentTexturePtr->tex.height / (f32) state->subdivY;
    posY = ImgFXCurrentTexturePtr->tex.yOffset;
    texV = 0.0f;
    vtx = &imgfx_vtxBuf[imgfx_vtxCount];
 
    for (i = 0; i <= state->subdivY; i++) {
        s32 j;
 
        if (i == state->subdivY) {
            texV = ImgFXCurrentTexturePtr->tex.height;
            posY = ImgFXCurrentTexturePtr->tex.yOffset - ImgFXCurrentTexturePtr->tex.height;
        }
 
        posX = ImgFXCurrentTexturePtr->tex.xOffset;
        texU = 0.0f;
        for (j = 0; j <= state->subdivX; vtx++, j++) {
            if (j == state->subdivX) {
                texU = ImgFXCurrentTexturePtr->tex.width;
                posX = ImgFXCurrentTexturePtr->tex.xOffset + ImgFXCurrentTexturePtr->tex.width;
            }
            vtx->n.ob[0] = posX;
            vtx->n.ob[1] = posY;
            vtx->n.ob[2] = 0;
            vtx->n.tc[0] = ((s32) texU + 256) * 32;
            vtx->n.tc[1] = ((s32) texV + 256) * 32;
            imgfx_vtxCount++;
            posX += divSizeX;
            texU += divSizeX;
        }
        posY -= divSizeY;
        texV += divSizeY;
    }
    state->lastVtxIdx = imgfx_vtxCount - 1;
}

Referenced by imgfx_make_mesh().

imgfx_mesh_anim_update()

void imgfx_mesh_anim_update

(

ImgFXState *

state

)

Definition at line 1260 of file imgfx.c.

                                               {
    s32 absKeyframeInterval;
    s32 nextKeyIdx;
    s32 curKeyIdx;
    ImgFXVtx* curKeyframe = nullptr;
    ImgFXVtx* nextKeyframe = nullptr;
    s32 keyframeInterval = state->ints.anim.interval;
    s32 animStep = state->ints.anim.step;
    s32 curSubframe = state->floats.anim.curFrame;
    ImgFXAnimHeader* header = imgfx_load_anim(state);
    u8* romStart;
    f32 lerpAlpha;
    s32 i;
 
    if (header == nullptr) {
        return;
    }
 
    if (state->flags & IMGFX_FLAG_200) {
        state->flags &= ~IMGFX_FLAG_200;
        if (state->flags & IMGFX_FLAG_REVERSE_ANIM) {
            state->floats.anim.curIdx = header->keyframesCount - 1;
        }
    }
    curKeyIdx = state->floats.anim.curIdx;
    absKeyframeInterval = abs(keyframeInterval);
    if (state->flags & IMGFX_FLAG_4000) {
        nextKeyIdx = curKeyIdx;
    } else {
        if (state->flags & IMGFX_FLAG_REVERSE_ANIM) {
            nextKeyIdx = curKeyIdx - 1;
            if (nextKeyIdx < 0) {
                nextKeyIdx = curKeyIdx;
                if (state->flags & IMGFX_FLAG_LOOP_ANIM) {
                    nextKeyIdx = header->keyframesCount - 1;
                }
            }
        } else {
            nextKeyIdx = curKeyIdx + 1;
            if (nextKeyIdx == header->keyframesCount) {
                nextKeyIdx = curKeyIdx;
                if (state->flags & IMGFX_FLAG_LOOP_ANIM) {
                    nextKeyIdx = 0;
                }
            }
        }
    }
 
    // find the current + next keyframe vertex data
    curKeyframe = heap_malloc(header->vtxCount * sizeof(ImgFXVtx));
    romStart = (u8*)((s32)imgfx_data_ROM_START + (s32) header->keyframesOffset + curKeyIdx * header->vtxCount * sizeof(ImgFXVtx));
    dma_copy(romStart, romStart + header->vtxCount * sizeof(ImgFXVtx), curKeyframe);
    if (keyframeInterval > 1) {
        nextKeyframe = heap_malloc(header->vtxCount * sizeof(*nextKeyframe));
        romStart = (u8*)((s32)imgfx_data_ROM_START + (s32) header->keyframesOffset + nextKeyIdx * header->vtxCount * sizeof(ImgFXVtx));
        dma_copy(romStart, romStart + header->vtxCount * sizeof(ImgFXVtx), nextKeyframe);
    }
 
    lerpAlpha = (f32) curSubframe / (f32) keyframeInterval;
    for (i = 0; i < header->vtxCount; i++) {
        if (state->meshType != IMGFX_MESH_ANIMATED) {
            return;
        }
 
        if (keyframeInterval > 1) {
            // get vertex position, interpolated between keyframes
            if (header->flags & IMGFX_ANIM_FLAG_ABSOLUTE_COORDS) {
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[0] = (s16)(curKeyframe[i].ob[0] + (nextKeyframe[i].ob[0] - curKeyframe[i].ob[0]) * lerpAlpha);
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[1] = (s16)(curKeyframe[i].ob[1] + (nextKeyframe[i].ob[1] - curKeyframe[i].ob[1]) * lerpAlpha);
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[2] = (s16)(curKeyframe[i].ob[2] + (nextKeyframe[i].ob[2] - curKeyframe[i].ob[2]) * lerpAlpha);
            } else {
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[0] = (s16)(curKeyframe[i].ob[0] + (nextKeyframe[i].ob[0] - curKeyframe[i].ob[0]) * lerpAlpha) * 0.01 * ImgFXCurrentTexturePtr->tex.width;
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[1] = (s16)(curKeyframe[i].ob[1] + (nextKeyframe[i].ob[1] - curKeyframe[i].ob[1]) * lerpAlpha) * 0.01 * ImgFXCurrentTexturePtr->tex.height;
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[2] = (s16)(curKeyframe[i].ob[2] + (nextKeyframe[i].ob[2] - curKeyframe[i].ob[2]) * lerpAlpha) * 0.01 * ((ImgFXCurrentTexturePtr->tex.width + ImgFXCurrentTexturePtr->tex.height) / 2);
            }
            // get vertex color
            if (state->flags & (IMGFX_FLAG_2000 | IMGFX_FLAG_8000)) {
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[0] = (s16)(curKeyframe[i].cn[0] + (nextKeyframe[i].cn[0] - curKeyframe[i].cn[0]) * lerpAlpha);
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[1] = (s16)(curKeyframe[i].cn[1] + (nextKeyframe[i].cn[1] - curKeyframe[i].cn[1]) * lerpAlpha);
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[2] = (s16)(curKeyframe[i].cn[2] + (nextKeyframe[i].cn[2] - curKeyframe[i].cn[2]) * lerpAlpha);
            } else {
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[0] =
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[1] =
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[2] = 240.0 - (curKeyframe[i].tc[0] + curKeyframe[i].tc[1]) * 1.2;
            }
        } else {
            // get vertex position
            if (header->flags & IMGFX_ANIM_FLAG_ABSOLUTE_COORDS) {
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[0] = curKeyframe[i].ob[0];
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[1] = curKeyframe[i].ob[1];
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[2] = curKeyframe[i].ob[2];
            } else {
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[0] = curKeyframe[i].ob[0] * 0.01 * ImgFXCurrentTexturePtr->tex.width;
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[1] = curKeyframe[i].ob[1] * 0.01 * ImgFXCurrentTexturePtr->tex.height;
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.ob[2] = curKeyframe[i].ob[2] * 0.01 * ((ImgFXCurrentTexturePtr->tex.width + ImgFXCurrentTexturePtr->tex.height) / 2);
            }
            // get vertex color
            if (state->flags & (IMGFX_FLAG_2000 | IMGFX_FLAG_8000)) {
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[0] = curKeyframe[i].cn[0];
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[1] = curKeyframe[i].cn[1];
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[2] = curKeyframe[i].cn[2];
            } else {
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[0] =
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[1] =
                state->vtxBufs[gCurrentDisplayContextIndex][i].v.cn[2] = 240.0 - (curKeyframe[i].tc[0] + curKeyframe[i].tc[1]) * 1.2;
            }
        }
        // get vertex tex coords
        if (header->flags & IMGFX_ANIM_FLAG_ABSOLUTE_COORDS) {
            state->vtxBufs[gCurrentDisplayContextIndex][i].v.tc[0] = (curKeyframe[i].tc[0] + 256) * 32;
            state->vtxBufs[gCurrentDisplayContextIndex][i].v.tc[1] = (curKeyframe[i].tc[1] + 256) * 32;
        } else {
            state->vtxBufs[gCurrentDisplayContextIndex][i].v.tc[0] = ((s32)(curKeyframe[i].tc[0] * 0.01 * ImgFXCurrentTexturePtr->tex.width) + 256) * 32;
            state->vtxBufs[gCurrentDisplayContextIndex][i].v.tc[1] = ((s32)(curKeyframe[i].tc[1] * 0.01 * ImgFXCurrentTexturePtr->tex.height) + 256) * 32;
        }
    }
 
    state->firstVtxIdx = 0;
    state->lastVtxIdx = header->vtxCount - 1;
 
    heap_free(curKeyframe);
    if (nextKeyframe != nullptr) {
        heap_free(nextKeyframe);
    }
 
    if (animStep == 0 || gGameStatusPtr->frameCounter % animStep != 0) {
        return;
    }
 
    if (keyframeInterval > 0) {
        curSubframe++;
        if (curSubframe >= keyframeInterval) {
            if (state->flags & IMGFX_FLAG_REVERSE_ANIM) {
                curKeyIdx--;
                if (curKeyIdx < 0) {
                    if (state->flags & IMGFX_FLAG_LOOP_ANIM) {
                        curKeyIdx = header->keyframesCount - 1;
                    } else {
                        if (state->flags & IMGFX_FLAG_800) {
                            curKeyIdx = 0;
                            state->flags |= IMGFX_FLAG_4000;
                        } else {
                            state->flags |= IMGFX_FLAG_ANIM_DONE;
                        }
                    }
                }
            } else {
                curKeyIdx++;
                if (curKeyIdx >= header->keyframesCount) {
                    if (state->flags & IMGFX_FLAG_LOOP_ANIM) {
                        curKeyIdx = 0;
                    } else {
                        if (state->flags & IMGFX_FLAG_800) {
                            curKeyIdx--;
                            state->flags |= IMGFX_FLAG_4000;
                        } else {
                            state->flags |= IMGFX_FLAG_ANIM_DONE;
                        }
                    }
                }
            }
            curSubframe = 0;
        }
    } else if (keyframeInterval < 0) {
        if (state->flags & IMGFX_FLAG_REVERSE_ANIM) {
            curKeyIdx -= absKeyframeInterval;
            if (curKeyIdx < 0) {
                if (state->flags & IMGFX_FLAG_LOOP_ANIM) {
                    curKeyIdx += header->keyframesCount;
                } else {
                    if (state->flags & IMGFX_FLAG_800) {
                        curKeyIdx = 0;
                        state->flags |= IMGFX_FLAG_4000;
                    } else {
                        state->flags |= IMGFX_FLAG_ANIM_DONE;
                    }
                }
            }
        } else {
            curKeyIdx += absKeyframeInterval;
            if (curKeyIdx >= header->keyframesCount) {
                if (state->flags & IMGFX_FLAG_LOOP_ANIM) {
                    curKeyIdx %= header->keyframesCount;
                } else {
                    if (state->flags & IMGFX_FLAG_800) {
                        curKeyIdx = header->keyframesCount - 1;
                        state->flags |= IMGFX_FLAG_4000;
                    } else {
                        state->flags |= IMGFX_FLAG_ANIM_DONE;
                    }
                }
            }
        }
    }
 
    state->floats.anim.curFrame = curSubframe;
    state->floats.anim.curIdx = curKeyIdx;
}

Referenced by imgfx_make_mesh().

imgfx_appendGfx_mesh_basic()

void imgfx_appendGfx_mesh_basic	(	ImgFXState *	state,
		Matrix4f	mtx )

Definition at line 1459 of file imgfx.c.

                                                                 {
    s32 i;
 
    if (!(state->flags & IMGFX_FLAG_SKIP_TEX_SETUP)) {
        gDPSetTextureLUT(gMainGfxPos++, G_TT_RGBA16);
        gDPLoadTLUT_pal16(gMainGfxPos++, 0, ImgFXCurrentTexturePtr->tex.palette);
    }
 
    i = state->firstVtxIdx;
 
    while (true) {
        Camera* cam;
        s32 uls = (imgfx_vtxBuf[i + 0].v.tc[0] >> 0x5) - 256;
        s32 ult = (imgfx_vtxBuf[i + 0].v.tc[1] >> 0x5) - 256;
        s32 lrs = (imgfx_vtxBuf[i + 3].v.tc[0] >> 0x5) - 256;
        s32 lrt = (imgfx_vtxBuf[i + 3].v.tc[1] >> 0x5) - 256;
        s32 someFlags = IMGFX_FLAG_100000 | IMGFX_FLAG_80000;
        s32 alpha;
        s32 alpha2;
 
        if (!(state->flags & IMGFX_FLAG_SKIP_TEX_SETUP)) {
            if ((gSpriteShadingProfile->flags & SPR_SHADING_FLAG_ENABLED)
                && (state->arrayIdx != 0)
                && (state->flags & someFlags)
                && (   state->renderType == IMGFX_RENDER_DEFAULT
                    || state->renderType == IMGFX_RENDER_MULTIPLY_ALPHA
                    || state->renderType == IMGFX_RENDER_OVERLAY_RGBA
                    || state->renderType == IMGFX_RENDER_MULTIPLY_SHADE_ALPHA)
            ) {
                gDPScrollMultiTile2_4b(gMainGfxPos++,
                    ImgFXCurrentTexturePtr->tex.raster, G_IM_FMT_CI,
                    ImgFXCurrentTexturePtr->tex.width, ImgFXCurrentTexturePtr->tex.height, // img size
                    uls, ult, // top left
                    lrs - 1, lrt - 1, // bottom right
                    0, // palette
                    G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, // clamp wrap mirror
                    8, 8, // mask
                    G_TX_NOLOD, G_TX_NOLOD, // shift,
                    0x100, 0x100); // scroll
                gDPSetTile(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 4, 0x100, 2, 0,
                            G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP,
                            G_TX_NOMASK, G_TX_NOLOD);
                gDPSetTileSize(gMainGfxPos++, 2, 0, 0, 252, 0);
 
                alpha = 255;
                switch (state->renderType) {
                    case IMGFX_RENDER_DEFAULT:
                        break;
                    case IMGFX_RENDER_MULTIPLY_ALPHA:
                    case IMGFX_RENDER_OVERLAY_RGBA:
                        alpha = state->ints.color.a;
                        break;
                    case IMGFX_RENDER_MULTIPLY_SHADE_ALPHA:
                        alpha = -1;
                        break;
                    default:
                        printf("imgfx: unhandled render type %d for shading palette\n", state->renderType);
                        break;
                }
 
                if ((gSpriteShadingProfile->flags & SPR_SHADING_FLAG_SET_VIEWPORT)
                    && ((*ImgFXInstances)[0].arrayIdx != 0)
                    && (state->flags & someFlags)
                ) {
                    cam = &gCameras[gCurrentCamID];
 
                    if (gGameStatusPtr->context == CONTEXT_PAUSE) {
                        gSPViewport(gMainGfxPos++, &D_8014EE50);
                    } else {
                        gSPViewport(gMainGfxPos++, &cam->vpAlt);
                    }
 
                    gDPSetRenderMode(gMainGfxPos++, G_RM_PASS, state->otherModeL);
 
                    if (alpha == -1) {
                        gDPSetCombineMode(gMainGfxPos++, PM_CC_0D, PM_CC_0C);
                    } else {
                        gDPSetEnvColor(gMainGfxPos++, 0, 0, 0, alpha);
                        gDPSetCombineMode(gMainGfxPos++, PM_CC_0B, PM_CC_0C);
                    }
 
                    gSPVertex(gMainGfxPos++, &imgfx_vtxBuf[i], 4, 0);
                    gSP2Triangles(gMainGfxPos++, 0, 2, 1, 0, 1, 2, 3, 0);
                    gDPPipeSync(gMainGfxPos++);
                }
                create_shading_palette(mtx, uls, ult, lrs, lrt, alpha, state->otherModeL);
            } else {
                gDPScrollTextureTile_4b(gMainGfxPos++,
                    ImgFXCurrentTexturePtr->tex.raster, G_IM_FMT_CI,
                    ImgFXCurrentTexturePtr->tex.width, ImgFXCurrentTexturePtr->tex.height, // img size
                    uls, ult, // top left
                    lrs - 1, lrt - 1, // bottom right
                    0, // palette
                    G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, // clamp wrap mirror
                    8, 8, // mask
                    G_TX_NOLOD, G_TX_NOLOD, // shift,
                    0x100, 0x100); // scroll
 
                if ((gSpriteShadingProfile->flags & SPR_SHADING_FLAG_SET_VIEWPORT)
                    && state->arrayIdx != 0
                    && (state->flags & someFlags)
                ) {
                    alpha2 = 255;
                    cam = &gCameras[gCurrentCamID];
 
                    if (gGameStatusPtr->context == CONTEXT_PAUSE) {
                        gSPViewport(gMainGfxPos++, &D_8014EE50);
                    } else {
                        gSPViewport(gMainGfxPos++, &cam->vpAlt);
                    }
 
                    if (alpha2 == 255) {
                        gDPSetRenderMode(gMainGfxPos++, G_RM_AA_ZB_TEX_EDGE, G_RM_AA_ZB_TEX_EDGE2);
                    } else {
                        gDPSetRenderMode(gMainGfxPos++, G_RM_ZB_XLU_SURF, G_RM_ZB_XLU_SURF2);
                    }
 
                    switch (state->renderType) {
                        case IMGFX_RENDER_DEFAULT:
                            alpha2 = 255;
                            break;
                        case IMGFX_RENDER_MULTIPLY_ALPHA:
                        case IMGFX_RENDER_OVERLAY_RGBA:
                            alpha2 = state->ints.color.a;
                            break;
                        case IMGFX_RENDER_MULTIPLY_SHADE_ALPHA:
                            alpha2 = -1;
                            break;
                        default:
                            printf("imgfx: unhandled render type %d for shading palette\n", state->renderType);
                            break;
                    }
 
                    if (alpha2 == -1) {
                        gDPSetCombineMode(gMainGfxPos++, PM_CC_59, PM_CC_59);
                    } else {
                        gDPSetEnvColor(gMainGfxPos++, 0, 0, 0, alpha2);
                        gDPSetCombineMode(gMainGfxPos++, PM_CC_0A, PM_CC_0A);
                    }
 
                    gSPVertex(gMainGfxPos++, &imgfx_vtxBuf[i], 4, 0);
                    gSP2Triangles(gMainGfxPos++, 0, 2, 1, 0, 1, 2, 3, 0);
                    gDPPipeSync(gMainGfxPos++);
 
                    if (alpha2 == 255) {
                        gDPSetRenderMode(gMainGfxPos++, G_RM_AA_ZB_TEX_EDGE, G_RM_AA_ZB_TEX_EDGE2);
                    } else {
                        gDPSetRenderMode(gMainGfxPos++, G_RM_ZB_XLU_SURF, G_RM_ZB_XLU_SURF2);
                    }
 
                    gDPSetEnvColor(gMainGfxPos++, 100, 100, 100, 255);
                    gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, alpha2);
                    gDPSetCombineMode(gMainGfxPos++, PM_CC_5A, PM_CC_5A);
                    gDPSetColorDither(gMainGfxPos++, G_CD_MAGICSQ);
                }
            }
        }
 
        if ((gSpriteShadingProfile->flags & SPR_SHADING_FLAG_SET_VIEWPORT)
            && (*ImgFXInstances)[0].arrayIdx != 0
            && (state->flags & someFlags)
        ) {
            cam = &gCameras[gCurrentCamID];
            if (gGameStatusPtr->context == CONTEXT_PAUSE) {
                gSPViewport(gMainGfxPos++, &D_8014EE40);
                D_8014EE50.vp.vtrans[0] = D_8014EE40.vp.vtrans[0] + gGameStatusPtr->altViewportOffset.x;
                D_8014EE50.vp.vtrans[1] = D_8014EE40.vp.vtrans[1] + gGameStatusPtr->altViewportOffset.y;
            } else {
                gSPViewport(gMainGfxPos++, &cam->vp);
            }
        }
 
        gSPVertex(gMainGfxPos++, &imgfx_vtxBuf[i], 4, 0);
        gSP2Triangles(gMainGfxPos++, 0, 2, 1, 0, 1, 2, 3, 0);
 
        if (i + 3 >= state->lastVtxIdx) {
            break;
        }
 
        i += 2;
    }
}

Referenced by imgfx_appendGfx_mesh().

imgfx_appendGfx_mesh_grid()

void imgfx_appendGfx_mesh_grid	(	ImgFXState *	state,
		Matrix4f	mtx )

Definition at line 1642 of file imgfx.c.

                                                                {
    s32 i, j;
    s32 firstVtxIdx;
 
    if (!(state->flags & IMGFX_FLAG_SKIP_TEX_SETUP)) {
        gDPSetTextureLUT(gMainGfxPos++, G_TT_RGBA16);
        gDPLoadTLUT_pal16(gMainGfxPos++, 0, ImgFXCurrentTexturePtr->tex.palette);
    }
 
    firstVtxIdx = state->firstVtxIdx;
    for (i = 0; i < state->subdivY; i++) {
        for (j = 0; j < state->subdivX; j++) {
            s32 ulIdx = firstVtxIdx + i * (state->subdivX + 1) + j;
            s32 urIdx = firstVtxIdx + i * (state->subdivX + 1) + j + 1;
            s32 llIdx = firstVtxIdx + (i + 1) * (state->subdivX + 1) + j;
            s32 lrIdx = firstVtxIdx + (i + 1) * (state->subdivX + 1) + j + 1;
            if (!(state->flags & IMGFX_FLAG_SKIP_TEX_SETUP)) {
                if ((gSpriteShadingProfile->flags & SPR_SHADING_FLAG_ENABLED)
                    && (*ImgFXInstances)[0].arrayIdx != 0
                    && (state->flags & (IMGFX_FLAG_100000 | IMGFX_FLAG_80000))
                    && (state->renderType == IMGFX_RENDER_DEFAULT
                        || state->renderType == IMGFX_RENDER_MULTIPLY_ALPHA
                        || state->renderType == IMGFX_RENDER_MULTIPLY_SHADE_ALPHA)
                ) {
                    s32 alpha = 255;
                    gDPScrollMultiTile2_4b(gMainGfxPos++,
                        ImgFXCurrentTexturePtr->tex.raster, G_IM_FMT_CI,
                        ImgFXCurrentTexturePtr->tex.width, ImgFXCurrentTexturePtr->tex.height, // img size
                        (imgfx_vtxBuf[ulIdx].v.tc[0] >> 5) - 0x100, (imgfx_vtxBuf[ulIdx].v.tc[1] >> 5) - 0x100, // top left
                        (imgfx_vtxBuf[lrIdx].v.tc[0] >> 5) - 0x100 - 1, (imgfx_vtxBuf[lrIdx].v.tc[1] >> 5) - 0x100 - 1, // bottom right
                        0, // palette
                        G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, // clamp wrap mirror
                        8, 8, // mask
                        G_TX_NOLOD, G_TX_NOLOD, // shift,
                        0x100, 0x100); // scroll
                    gDPSetTile(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 4, 0x0100, 2, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
                    gDPSetTileSize(gMainGfxPos++, 2, 0, 0, 63 << 2, 0);
                    switch (state->renderType) {
                        case IMGFX_RENDER_DEFAULT:
                            alpha = 255;
                            break;
                        case IMGFX_RENDER_MULTIPLY_ALPHA:
                            alpha = state->ints.color.a;
                            break;
                        case IMGFX_RENDER_MULTIPLY_SHADE_ALPHA:
                            alpha = -1;
                            break;
                        default:
                            printf("imgfx: unhandled render type %d for shading palette\n", state->renderType);
                            break;
                    }
                    create_shading_palette(mtx,
                                           (imgfx_vtxBuf[ulIdx].v.tc[0] >> 5) - 0x100, (imgfx_vtxBuf[ulIdx].v.tc[1] >> 5) - 0x100,
                                           (imgfx_vtxBuf[lrIdx].v.tc[0] >> 5) - 0x100, (imgfx_vtxBuf[lrIdx].v.tc[1] >> 5) - 0x100,
                                           alpha, state->otherModeL);
                } else {
                    gDPScrollTextureTile_4b(gMainGfxPos++,
                        ImgFXCurrentTexturePtr->tex.raster, G_IM_FMT_CI,
                        ImgFXCurrentTexturePtr->tex.width, ImgFXCurrentTexturePtr->tex.height, // img size
                        (imgfx_vtxBuf[ulIdx].v.tc[0] >> 5) - 0x100, (imgfx_vtxBuf[ulIdx].v.tc[1] >> 5) - 0x100, // top left
                        (imgfx_vtxBuf[lrIdx].v.tc[0] >> 5) - 0x100 - 1, (imgfx_vtxBuf[lrIdx].v.tc[1] >> 5) - 0x100 - 1, // bottom right
                        0, // palette
                        G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, // clamp wrap mirror
                        8, 8, // mask
                        G_TX_NOLOD, G_TX_NOLOD, // shift,
                        0x100, 0x100); // scroll
                }
            }
 
            gSPVertex(gMainGfxPos++, &imgfx_vtxBuf[ulIdx], 1, 0);
            gSPVertex(gMainGfxPos++, &imgfx_vtxBuf[urIdx], 1, 1);
            gSPVertex(gMainGfxPos++, &imgfx_vtxBuf[llIdx], 1, 2);
            gSPVertex(gMainGfxPos++, &imgfx_vtxBuf[lrIdx], 1, 3);
            gSP2Triangles(gMainGfxPos++, 0, 2, 1, 0, 1, 2, 3, 0);
        }
    }
}

Referenced by imgfx_appendGfx_mesh().

imgfx_appendGfx_mesh_anim()

void imgfx_appendGfx_mesh_anim	(	ImgFXState *	state,
		Matrix4f	mtx )

Definition at line 1720 of file imgfx.c.

                                                                {
    if (state->vtxBufs[gCurrentDisplayContextIndex] == nullptr || state->gfxBufs[gCurrentDisplayContextIndex] == nullptr) {
        return;
    }
 
    guScale(&gDisplayContext->matrixStack[gMatrixListPos], 0.1f, 0.1f, 0.1f);
    gSPMatrix(gMainGfxPos++, VIRTUAL_TO_PHYSICAL(&gDisplayContext->matrixStack[gMatrixListPos++]), G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
 
    if (!(state->flags & IMGFX_FLAG_SKIP_TEX_SETUP)) {
        gDPSetTextureLUT(gMainGfxPos++, G_TT_RGBA16);
        gDPLoadTLUT_pal16(gMainGfxPos++, 0, ImgFXCurrentTexturePtr->tex.palette);
        if ((gSpriteShadingProfile->flags & SPR_SHADING_FLAG_ENABLED)
            && (state->flags & (IMGFX_FLAG_100000 | IMGFX_FLAG_80000))
            && (state->renderType == IMGFX_RENDER_DEFAULT
                || state->renderType == IMGFX_RENDER_MULTIPLY_ALPHA
                || state->renderType == IMGFX_RENDER_MULTIPLY_SHADE_ALPHA
                || state->renderType == IMGFX_RENDER_ANIM)
        ) {
            s32 alpha = 255;
            gDPScrollMultiTile2_4b(gMainGfxPos++, ImgFXCurrentTexturePtr->tex.raster, G_IM_FMT_CI,
                                    ImgFXCurrentTexturePtr->tex.width, ImgFXCurrentTexturePtr->tex.height,
                                    0, 0, ImgFXCurrentTexturePtr->tex.width - 1, ImgFXCurrentTexturePtr->tex.height - 1, 0,
                                    G_TX_CLAMP, G_TX_CLAMP, 8, 8, G_TX_NOLOD, G_TX_NOLOD,
                                    256, 256);
            gDPSetTile(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 4, 0x0100, 2, 0,
                            G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
            gDPSetTileSize(gMainGfxPos++, 2, 0, 0, 252, 0);
 
            switch (state->renderType) {
                case IMGFX_RENDER_DEFAULT:
                case IMGFX_RENDER_ANIM:
                    alpha = 255;
                    break;
                case IMGFX_RENDER_MULTIPLY_ALPHA:
                    alpha = state->ints.color.a;
                    break;
                case IMGFX_RENDER_MULTIPLY_SHADE_ALPHA:
                    alpha = -1;
                    break;
                default: // unreachable due to above `if`
                    printf("imgfx: unhandled render type %d for shading palette\n", state->renderType);
                    break;
            }
            create_shading_palette(mtx, 0, 0, ImgFXCurrentTexturePtr->tex.width, ImgFXCurrentTexturePtr->tex.height, alpha, state->otherModeL);
        } else {
            gDPScrollTextureTile_4b(gMainGfxPos++, ImgFXCurrentTexturePtr->tex.raster, G_IM_FMT_CI,
                                    ImgFXCurrentTexturePtr->tex.width, ImgFXCurrentTexturePtr->tex.height,
                                    0, 0, ImgFXCurrentTexturePtr->tex.width - 1, ImgFXCurrentTexturePtr->tex.height - 1, 0,
                                    G_TX_CLAMP, G_TX_CLAMP, 8, 8, G_TX_NOLOD, G_TX_NOLOD,
                                    256, 256);
        }
    }
    gSPDisplayList(gMainGfxPos++, state->gfxBufs[gCurrentDisplayContextIndex]);
    gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
}

Referenced by imgfx_appendGfx_mesh().

imgfx_appendGfx_mesh_strip()

void imgfx_appendGfx_mesh_strip	(	ImgFXState *	state,
		Matrix4f	mtx )

Definition at line 1776 of file imgfx.c.

                                                                 {
    ImgFXOverlayTexture* ufs = state->ints.overlay.pattern;
    s32 shifts = integer_log(ufs->width, 2);
    s32 shiftt = integer_log(ufs->height, 2);
    s32 uls, ult;
    s32 lrs, lrt;
 
    guScale(&gDisplayContext->matrixStack[gMatrixListPos], (f32)ImgFXCurrentTexturePtr->tex.width / 100.0, (f32)ImgFXCurrentTexturePtr->tex.height / 100.0, 1.0f);
    gSPMatrix(gMainGfxPos++, VIRTUAL_TO_PHYSICAL(&gDisplayContext->matrixStack[gMatrixListPos++]), G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
    gDPSetRenderMode(gMainGfxPos++, G_RM_ZB_XLU_DECAL, G_RM_ZB_XLU_DECAL2);
 
    if (state->renderType == IMGFX_RENDER_OVERLAY_RGBA) {
        s32 alpha = state->ints.overlay.alpha;
        gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, alpha);
        gDPSetCombineMode(gMainGfxPos++, PM_CC_05, PM_CC_05);
    } else {
        gDPSetCombineMode(gMainGfxPos++, G_CC_MODULATEIA, G_CC_MODULATEIA);
    }
    gDPSetTextureLUT(gMainGfxPos++, G_TT_RGBA16);
    gDPLoadTLUT_pal16(gMainGfxPos++, 0, ufs->palette);
    gDPScrollTextureTile_4b(gMainGfxPos++, ufs->raster, G_IM_FMT_CI, ufs->width, ufs->height,
                          0, 0, ufs->width - 1, ufs->height - 1, 0,
                          G_TX_WRAP, G_TX_WRAP, shifts, shiftt, G_TX_NOLOD, G_TX_NOLOD,
                          256, 256);
 
    uls = state->floats.overlay.posX;
    ult = state->floats.overlay.posY;
    lrs = ufs->width * 4 + state->floats.overlay.posX;
    lrt = ufs->height * 4 + state->floats.overlay.posY;
    gDPSetTileSize(gMainGfxPos++, G_TX_RENDERTILE, uls, ult, lrs, lrt);
 
    state->floats.overlay.posX = (s32)(state->floats.overlay.posX + ufs->offsetX) % (ufs->width * 4);
    state->floats.overlay.posY = (s32)(state->floats.overlay.posY + ufs->offsetY) % (ufs->height * 4);
    gSPDisplayList(gMainGfxPos++, ufs->displayList);
    gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
}

Referenced by imgfx_appendGfx_mesh().

imgfx_wavy_init()

void imgfx_wavy_init

(

ImgFXState *

state

)

Definition at line 1813 of file imgfx.c.

                                        {
    state->floats.wavy.phase1 = 0.0f;
    state->floats.wavy.phase2 = 50.0f;
    state->floats.wavy.phase3 = 30.0f;
}

Referenced by imgfx_update().

imgfx_mesh_make_wavy()

void imgfx_mesh_make_wavy

(

ImgFXState *

state

)

Definition at line 1819 of file imgfx.c.

                                             {
    Vtx* v1;
    Vtx* v2;
    Vtx* v3;
    f32 vx;
    f32 vy;
    f32 vz;
    f32 angle1;
    f32 angle2;
    f32 angle3;
    f32 phase1;
    f32 phase2;
    f32 phase3;
    s32 angleInc;
    s32 amt;
    s32 sign;
    s32 i;
 
    phase1 = (f32) gGameStatusPtr->frameCounter / 10.3;
    while (phase1 > 360.0) {
        phase1 -= 360.0;
    }
 
    phase2 = (f32) (gGameStatusPtr->frameCounter + 40) / 11.2;
    while (phase2 > 360.0) {
        phase2 -= 360.0;
    }
 
    phase3 = (f32) (gGameStatusPtr->frameCounter + 25) / 10.8;
    while (phase3 > 360.0) {
        phase3 -= 360.0;
    }
 
    state->floats.wavy.phase1 = phase1;
    state->floats.wavy.phase2 = phase2;
    state->floats.wavy.phase3 = phase3;
 
    if (state->floats.wavy.phase1 >= 360.0) {
        state->floats.wavy.phase1-= 360.0;
    }
 
    if (state->floats.wavy.phase2 >= 360.0) {
        state->floats.wavy.phase2 -= 360.0;
    }
 
    if (state->floats.wavy.phase3 >= 360.0) {
        state->floats.wavy.phase3 -= 360.0;
    }
 
    sign = 0;
    angleInc = 0;
    amt = (state->lastVtxIdx - state->firstVtxIdx) - state->subdivX;
 
    for (i = 0; i < amt; i++) {
        angle1 = state->floats.wavy.phase1 + (angleInc * 45) + (sign * 180);
        angle2 = state->floats.wavy.phase2 + (angleInc * 45) + (sign * 180);
        angle3 = state->floats.wavy.phase3 + (angleInc * 45) + (sign * 180);
 
        //TODO find better match
        v1 = (Vtx*)((state->firstVtxIdx + i) * sizeof(Vtx) + (s32)imgfx_vtxBuf);
        vx = v1->v.ob[0];
        v1->v.ob[0] = (vx + (sin_deg(angle1) * state->ints.wavy.mag.x));
 
        v2 = (Vtx*)((state->firstVtxIdx + i) * sizeof(Vtx) + (s32)imgfx_vtxBuf);
        vy = v2->v.ob[1];
        v2->v.ob[1] = (vy + (sin_deg(angle2) * state->ints.wavy.mag.y));
 
        v3 = (Vtx*)((state->firstVtxIdx + i) * sizeof(Vtx) + (s32)imgfx_vtxBuf);
        vz = v3->v.ob[2];
        v3->v.ob[2] = (vz + (sin_deg(angle3) * state->ints.wavy.mag.z));
 
        angleInc++;
        if (i % (state->subdivX + 1) == 0) {
            angleInc = 0;
            sign = !sign;
        }
    }
}

Referenced by imgfx_make_mesh().

imgfx_mesh_load_colors()

void imgfx_mesh_load_colors

(

ImgFXState *

state

)

Definition at line 1898 of file imgfx.c.

                                               {
    f32 alpha = (f32)ImgFXCurrentTexturePtr->alphaMultiplier / 255.0;
    s32 vtxCount = state->lastVtxIdx - state->firstVtxIdx;
    s32 i;
 
    for (i = 0; i <= vtxCount; i++) {
        imgfx_vtxBuf[state->firstVtxIdx + i].v.cn[0] = state->colorBuf[i].r;
        imgfx_vtxBuf[state->firstVtxIdx + i].v.cn[1] = state->colorBuf[i].g;
        imgfx_vtxBuf[state->firstVtxIdx + i].v.cn[2] = state->colorBuf[i].b;
        imgfx_vtxBuf[state->firstVtxIdx + i].v.cn[3] = state->colorBuf[i].a * alpha;
    }
}

Referenced by imgfx_make_mesh().

imgfx_set_vtx_buf_capacity()

void imgfx_set_vtx_buf_capacity

(

s16

arg0

)

Definition at line 238 of file imgfx.c.

                                          {
    ImgFXVtxBufferCapacity = arg0;
}

imgfx_init()

void imgfx_init

(

void

)

Definition at line 242 of file imgfx.c.

                      {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(ImgFXVtxBuffers); i++) {
        ImgFXVtxBuffers[i] = _heap_malloc(&heap_spriteHead, ImgFXVtxBufferCapacity * sizeof(Vtx));
    }
 
    ImgFXInstances = (ImgFXInstanceList*)_heap_malloc(&heap_spriteHead, sizeof(ImgFXInstanceList));
 
    for (i = 0; i < ARRAY_COUNT(*ImgFXInstances); i++) {
        imgfx_init_instance(&(*ImgFXInstances)[i]);
        imgfx_clear_instance_data(&(*ImgFXInstances)[i]);
    }
 
    for (i = 0; i < ARRAY_COUNT(ImgFXDataCache); i++) {
        ImgFXDataCache[i].data = nullptr;
        ImgFXDataCache[i].staleCooldownTimer = 0;
        ImgFXDataCache[i].usingContextualHeap = false;
    }
 
    imgfx_vtxCount = 0;
    imgfx_vtxBuf = ImgFXVtxBuffers[gCurrentDisplayContextIndex];
}

Referenced by spr_init_sprites().

func_8013A4D0()

void func_8013A4D0

(

void

)

Definition at line 266 of file imgfx.c.

                         {
    s32 i;
 
    imgfx_vtxBuf = ImgFXVtxBuffers[gCurrentDisplayContextIndex];
    imgfx_vtxCount = 0;
    imgfx_init_instance(&(*ImgFXInstances)[0]);
 
    (*ImgFXInstances)[0].flags |= IMGFX_FLAG_VALID;
 
    for (i = 1; i < ARRAY_COUNT(*ImgFXInstances); i++) {
        if (((*ImgFXInstances)[i].flags & IMGFX_FLAG_VALID) && (*ImgFXInstances)[i].lastAnimCmd != IMGFX_SET_ANIM) {
            imgfx_cache_instance_data(&(*ImgFXInstances)[i]);
        }
    }
 
    for (i = 1; i < ARRAY_COUNT(*ImgFXInstances); i++) {
        if (((*ImgFXInstances)[i].flags & IMGFX_FLAG_VALID) && (*ImgFXInstances)[i].colorBuf != nullptr) {
            if ((*ImgFXInstances)[i].lastColorCmd == IMGFX_COLOR_BUF_SET_MULTIPLY) {
                continue;
            }
            if ((*ImgFXInstances)[i].lastColorCmd == IMGFX_COLOR_BUF_SET_MODULATE) {
                continue;
            }
            general_heap_free((*ImgFXInstances)[i].colorBuf);
            (*ImgFXInstances)[i].colorBuf = nullptr;
            (*ImgFXInstances)[i].colorBufCount = 0;
        }
    }
}

Referenced by spr_update_player_raster_cache().

imgfx_add_to_cache()

void imgfx_add_to_cache	(	void *	data,
		s8	usingContextualHeap )

Definition at line 296 of file imgfx.c.

                                                            {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(ImgFXDataCache); i++) {
        if (ImgFXDataCache[i].data == nullptr) {
            ImgFXDataCache[i].data = data;
            ImgFXDataCache[i].staleCooldownTimer = 4;
            ImgFXDataCache[i].usingContextualHeap = usingContextualHeap;
            return;
        }
    }
}

Referenced by imgfx_cache_instance_data(), and imgfx_load_anim().

imgfx_update_cache_impl()

void imgfx_update_cache_impl

(

void

)

Definition at line 309 of file imgfx.c.

                                   {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(ImgFXDataCache); i++) {
        if (ImgFXDataCache[i].data != nullptr) {
            ImgFXDataCache[i].staleCooldownTimer--;
 
            if (ImgFXDataCache[i].staleCooldownTimer == 0) {
                if (ImgFXDataCache[i].usingContextualHeap) {
                    heap_free(ImgFXDataCache[i].data);
                    ImgFXDataCache[i].data = nullptr;
                } else {
                    general_heap_free(ImgFXDataCache[i].data);
                    ImgFXDataCache[i].data = nullptr;
                }
 
                ImgFXDataCache[i].staleCooldownTimer = 0;
                ImgFXDataCache[i].usingContextualHeap = false;
            }
        }
    }
}

Referenced by imgfx_update_cache().

imgfx_update_cache()

void imgfx_update_cache

(

void

)

Definition at line 332 of file imgfx.c.

                              {
    imgfx_update_cache_impl();
}

Referenced by state_drawUI_world().

imgfx_get_free_instances()

s32 imgfx_get_free_instances

(

s32

count

)

Definition at line 337 of file imgfx.c.

                                        {
    s32 numAssigned;
    s32 foundAny;
    s32 iPrev;
    s32 firstIdx;
    s32 i;
 
    numAssigned = 0;
    for (i = 1; i < ARRAY_COUNT(*ImgFXInstances); i++) {
        if (!((*ImgFXInstances)[i].flags & IMGFX_FLAG_VALID)) {
            numAssigned++;
        }
    }
 
    if (numAssigned < count) {
        return -1;
    }
 
    firstIdx = 0;
    foundAny = false;
    numAssigned = 0;
    iPrev = -1;
    for (i = 1; i < ARRAY_COUNT(*ImgFXInstances); i++) {
        if ((*ImgFXInstances)[i].flags & IMGFX_FLAG_VALID) {
            continue;
        }
 
        if (!foundAny) {
            firstIdx = i;
            foundAny = true;
        } else {
            (*ImgFXInstances)[iPrev].nextIdx = i;
        }
 
        (*ImgFXInstances)[i].arrayIdx = i;
        imgfx_init_instance(&(*ImgFXInstances)[i]);
        numAssigned++;
        (*ImgFXInstances)[i].flags |= IMGFX_FLAG_VALID;
        iPrev = i;
        if (numAssigned == count) {
            (*ImgFXInstances)[i].nextIdx = -1;
            break;
        }
    }
 
    return firstIdx;
}

Referenced by hud_element_create_transform_A(), spr_load_npc_sprite(), and spr_update_player_sprite().

imgfx_release_instance()

void imgfx_release_instance

(

u32

idx

)

Definition at line 385 of file imgfx.c.

                                     {
    if (idx < MAX_IMGFX_INSTANCES) {
        (*ImgFXInstances)[idx].flags = 0;
        (*ImgFXInstances)[idx].nextIdx = -1;
    }
}

Referenced by hud_element_free_transform(), imgfx_release_instance_chain(), and spr_free_sprite().

imgfx_release_instance_chain()

void imgfx_release_instance_chain

(

u32

idx

)

Definition at line 392 of file imgfx.c.

                                           {
    if (idx < MAX_IMGFX_INSTANCES) {
        s32 next;
 
        do {
            next = (*ImgFXInstances)[idx].nextIdx;
            imgfx_release_instance(idx);
            idx = next;
        } while (next != -1);
    }
}

imgfx_get_next_instance()

s32 imgfx_get_next_instance

(

s32

idx

)

Definition at line 404 of file imgfx.c.

                                     {
    if (idx < 0 || idx >= MAX_IMGFX_INSTANCES) {
        return -1;
    }
 
    if (idx >= MAX_IMGFX_INSTANCES) {
        return 0xFF;
    } else {
        return (*ImgFXInstances)[idx].nextIdx;
    }
}

imgfx_get_instance()

ImgFXState * imgfx_get_instance

(

s32

idx

)

Definition at line 416 of file imgfx.c.

                                        {
    return &(*ImgFXInstances)[idx];
}

imgfx_update()

void imgfx_update	(	u32	idx,
		ImgFXType	type,
		s32	imgfxArg1,
		s32	imgfxArg2,
		s32	imgfxArg3,
		s32	imgfxArg4,
		s32	flags )

Definition at line 486 of file imgfx.c.

                                                                                                                  {
    ImgFXState* state = &(*ImgFXInstances)[idx];
    s32 oldFlags;
    u8 r, g, b, a;
 
    if (!(state->flags & IMGFX_FLAG_VALID) || (idx >= MAX_IMGFX_INSTANCES)) {
        return;
    }
 
    switch (type) {
        case IMGFX_CLEAR:
        case IMGFX_RESET:
            oldFlags = state->flags;
            imgfx_cache_instance_data(state);
            imgfx_init_instance(state);
            state->flags = oldFlags;
            state->lastAnimCmd = IMGFX_CLEAR;
            state->lastColorCmd = IMGFX_CLEAR;
            state->meshType = IMGFX_MESH_DEFAULT;
            state->renderType = IMGFX_RENDER_DEFAULT;
            state->ints.raw[0][0] = -1;
            state->ints.raw[1][0] = -1;
 
            state->flags &= IMGFX_FLAG_VALID;
            if (flags != 0) {
                state->flags |= flags;
            } else {
                state->flags |= 0; // required to match
            }
            return;
        case IMGFX_UNK_1:
            state->lastAnimCmd = IMGFX_CLEAR;
            state->renderType = IMGFX_RENDER_DEFAULT;
            state->ints.raw[0][0] = -1;
            return;
        case IMGFX_UNK_2:
            state->lastColorCmd = IMGFX_CLEAR;
            state->meshType = IMGFX_MESH_DEFAULT;
            state->ints.raw[1][0] = -1;
            return;
        case IMGFX_ALLOC_COLOR_BUF:
            if (state->colorBuf != nullptr) {
                heap_free(state->colorBuf);
            }
            state->colorBufCount = imgfxArg1 * 4;
            state->colorBuf = heap_malloc(state->colorBufCount);
            return;
        case IMGFX_OVERLAY:
        case IMGFX_OVERLAY_XLU:
            if (type == state->lastColorCmd
                && imgfxArg1 == (s32) state->ints.overlay.pattern
                && imgfxArg2 == state->ints.overlay.alpha
            ) {
                // no paramaters have changed
                return;
            }
            break;
        case IMGFX_SET_ANIM:
            if (state->lastAnimCmd == type
                && state->ints.anim.type == imgfxArg1
                && state->ints.anim.interval == imgfxArg2
                && state->ints.anim.step == imgfxArg3
            ) {
                // no paramaters have changed
                return;
            }
            break;
        default:
            if (type != IMGFX_HOLOGRAM && state->lastColorCmd == IMGFX_HOLOGRAM) {
                state->meshType = IMGFX_MESH_DEFAULT;
                state->subdivX = 1;
                state->subdivY = 1;
            }
            break;
    }
 
    if (type != IMGFX_SET_ANIM && state->lastAnimCmd == IMGFX_SET_ANIM) {
        state->lastAnimCmd = IMGFX_CLEAR;
    }
 
    if (type == IMGFX_SET_WAVY || type == IMGFX_SET_ANIM) {
        state->lastAnimCmd = type;
        state->ints.args.anim[0] = imgfxArg1;
        state->ints.args.anim[1] = imgfxArg2;
        state->ints.args.anim[2] = imgfxArg3;
        state->ints.args.anim[3] = imgfxArg4;
    } else if (type >= IMGFX_SET_COLOR && type <= IMGFX_OVERLAY_XLU) {
        state->lastColorCmd = type;
        state->ints.args.color[0] = imgfxArg1;
        state->ints.args.color[1] = imgfxArg2;
        state->ints.args.color[2] = imgfxArg3;
        state->ints.args.color[3] = imgfxArg4;
    }
 
    state->flags &= IMGFX_FLAG_VALID;
    if (flags != 0) {
        state->flags |= flags;
    }
    state->meshType = IMGFX_MESH_DEFAULT;
 
    switch (type) {
        case IMGFX_RESET:
            state->meshType = IMGFX_MESH_DEFAULT;
            state->renderType = IMGFX_RENDER_DEFAULT;
            break;
        case IMGFX_SET_WAVY:
            state->subdivX = 4;
            state->subdivY = 4;
            state->meshType = IMGFX_MESH_GRID_WAVY;
            imgfx_wavy_init(state);
            break;
        case IMGFX_SET_ANIM:
            state->meshType = IMGFX_MESH_ANIMATED;
            state->renderType = IMGFX_RENDER_ANIM;
            state->floats.anim.curFrame = 0.0f;
            state->floats.anim.curIdx = 0.0f;
            state->flags |= IMGFX_FLAG_200;
            break;
        case IMGFX_SET_COLOR:
        case IMGFX_SET_ALPHA:
        case IMGFX_SET_TINT:
            if (imgfxArg1 >= 255 && imgfxArg2 >= 255 && imgfxArg3 >= 255 && imgfxArg4 >= 255) {
                // no color + no transparency
                state->renderType = IMGFX_RENDER_DEFAULT;
            } else if (imgfxArg4 >= 255) {
                // some color + no transparency
                state->renderType = IMGFX_RENDER_MULTIPLY_RGB;
            } else if (imgfxArg1 >= 255 && imgfxArg2 >= 255 && imgfxArg3 >= 255) {
                // no color + transparency
                state->renderType = IMGFX_RENDER_MULTIPLY_ALPHA;
            } else {
                // some color + transparency
                state->renderType = IMGFX_RENDER_MULTIPLY_RGBA;
            }
            break;
        case IMGFX_SET_WHITE_FADE:
        case IMGFX_SET_CREDITS_FADE:
            if (imgfxArg4 == 255.0) {
                state->renderType = IMGFX_RENDER_MODULATE_PRIM_RGB;
            } else {
                state->renderType = IMGFX_RENDER_MODULATE_PRIM_RGBA;
            }
            break;
        case IMGFX_COLOR_BUF_SET_MULTIPLY:
            if (imgfxArg1 < state->colorBufCount) {
                // unpack and store color
                r = (imgfxArg2 & 0xFF000000) >> 24;
                g = (imgfxArg2 & 0xFF0000) >> 16;
                b = (imgfxArg2 & 0xFF00) >> 8;
                a = (imgfxArg2 & 0xFF);
                state->colorBuf[imgfxArg1].r = r;
                state->colorBuf[imgfxArg1].g = g;
                state->colorBuf[imgfxArg1].b = b;
                state->colorBuf[imgfxArg1].a = a;
 
                state->meshType = IMGFX_MESH_DEFAULT;
 
                if (a == 255) {
                    state->renderType = IMGFX_RENDER_MULTIPLY_SHADE_RGB;
                } else {
                    state->renderType = IMGFX_RENDER_MULTIPLY_SHADE_RGBA;
                }
            }
            break;
        case IMGFX_COLOR_BUF_SET_MODULATE:
            if (imgfxArg1 < state->colorBufCount) {
                // unpack and store color
                r = (imgfxArg2 & 0xFF000000) >> 24;
                g = (imgfxArg2 & 0xFF0000) >> 16;
                b = (imgfxArg2 & 0xFF00) >> 8;
                a = (imgfxArg2 & 0xFF);
                state->colorBuf[imgfxArg1].r = r;
                state->colorBuf[imgfxArg1].g = g;
                state->colorBuf[imgfxArg1].b = b;
                state->colorBuf[imgfxArg1].a = a;
 
                state->meshType = IMGFX_MESH_DEFAULT;
 
                if (a == 255) {
                    state->renderType = IMGFX_RENDER_MODULATE_SHADE_RGB;
                } else {
                    state->renderType = IMGFX_RENDER_MODULATE_SHADE_RGBA;
                }
            }
            break;
        case IMGFX_HOLOGRAM:
            state->renderType = IMGFX_RENDER_HOLOGRAM;
            break;
        case IMGFX_FILL_COLOR:
            state->renderType = IMGFX_RENDER_COLOR_FILL;
            break;
        case IMGFX_OVERLAY:
        case IMGFX_OVERLAY_XLU:
            state->meshType = IMGFX_MESH_STRIP;
            if (imgfxArg2 >= 255) {
                state->renderType = IMGFX_RENDER_OVERLAY_RGB;
            } else {
                state->renderType = IMGFX_RENDER_OVERLAY_RGBA;
            }
            state->floats.overlay.posX = 0.0f;
            state->floats.overlay.posY = 0.0f;
            break;
        case IMGFX_CLEAR:
            break;
        default:
            break;
    }
}

Referenced by appendGfx_interact_prompt(), appendGfx_ispy_icon(), appendGfx_speech_bubble(), render_complex_hud_element(), set_npc_imgfx_comp(), and set_player_imgfx_comp().

imgfx_set_state_flags()

void imgfx_set_state_flags	(	s32	idx,
		u16	flagBits,
		s32	mode )

Definition at line 695 of file imgfx.c.

                                                            {
    if ((*ImgFXInstances)[idx].flags & IMGFX_FLAG_VALID) {
        if (mode) {
            (*ImgFXInstances)[idx].flags |= flagBits;
        } else {
            (*ImgFXInstances)[idx].flags &= ~flagBits;
        }
    }
}

imgfx_appendGfx_component()

s32 imgfx_appendGfx_component	(	s32	idx,
		ImgFXTexture *	ifxImg,
		u32	flagBits,
		Matrix4f	mtx )

Definition at line 705 of file imgfx.c.

                                                                                         {
    ImgFXState* state = &(*ImgFXInstances)[idx];
    s32 ret = 0;
 
    if (ifxImg->alpha == 0) {
        return 0;
    }
 
    state->arrayIdx = idx;
    state->flags |= flagBits;
    ImgFXCurrentTexturePtr->tex.raster  = ifxImg->raster;
    ImgFXCurrentTexturePtr->tex.palette = ifxImg->palette;
    ImgFXCurrentTexturePtr->tex.width   = ifxImg->width;
    ImgFXCurrentTexturePtr->tex.height  = ifxImg->height;
    ImgFXCurrentTexturePtr->tex.xOffset = ifxImg->xOffset;
    ImgFXCurrentTexturePtr->tex.yOffset = ifxImg->yOffset;
    ImgFXCurrentTexturePtr->unk_18  = 0;
    ImgFXCurrentTexturePtr->unk_1E  = 0;
    ImgFXCurrentTexturePtr->alphaMultiplier = ifxImg->alpha;
 
    if (idx < 0 || idx >= MAX_IMGFX_INSTANCES) {
        return 0;
    }
 
    if (idx >= MAX_IMGFX_INSTANCES || state == nullptr) {
        return 0;
    }
 
    imgfx_make_mesh(state);
    imgfx_appendGfx_mesh(state, mtx);
 
    if (state->flags & IMGFX_FLAG_ANIM_DONE) {
        state->ints.raw[0][0] = -1;
        state->ints.raw[1][0] = -1;
        state->lastAnimCmd = IMGFX_CLEAR;
        state->meshType = 0;
        state->renderType = IMGFX_RENDER_DEFAULT;
        state->flags &= ~(IMGFX_FLAG_ANIM_DONE | IMGFX_FLAG_800 | IMGFX_FLAG_REVERSE_ANIM | IMGFX_FLAG_LOOP_ANIM);
        imgfx_cache_instance_data(state);
        ret = 1;
    } else if (state->flags & IMGFX_FLAG_4000) {
        ret = 2;
    } else if (state->flags & IMGFX_FLAG_20000) {
        state->lastAnimCmd = IMGFX_CLEAR;
        state->lastColorCmd = IMGFX_CLEAR;
        state->meshType = IMGFX_MESH_DEFAULT;
        state->renderType = IMGFX_RENDER_DEFAULT;
        state->ints.raw[0][0] = -1;
        state->ints.raw[1][0] = -1;
        state->flags &= IMGFX_FLAG_VALID;
        ret = 1;
    }
    return ret;
}

Referenced by appendGfx_entity_model(), appendGfx_interact_prompt(), appendGfx_ispy_icon(), appendGfx_pulse_stone_icon(), appendGfx_speech_bubble(), draw_coin_sparkles(), draw_entity_model_E(), gfx_build_knocked_down_player(), render_complex_hud_element(), and spr_appendGfx_component().

imgfx_load_anim()

ImgFXAnimHeader * imgfx_load_anim

(

ImgFXState *

state

)

Definition at line 1193 of file imgfx.c.

                                                    {
    u8* romStart = (s32) ImgFXAnimOffsets[state->ints.anim.type] + imgfx_data_ROM_START;
    ImgFXAnimHeader* anim = &ImgFXAnimHeaders[state->arrayIdx];
 
    if (state->curAnimOffset != romStart) {
        u8* romEnd;
        s32 i;
 
        state->curAnimOffset = romStart;
 
        dma_copy(state->curAnimOffset, state->curAnimOffset + sizeof(*anim), anim);
 
        if (state->vtxBufs[0] != nullptr) {
            imgfx_add_to_cache(state->vtxBufs[0], 1);
            state->vtxBufs[0] = nullptr;
        }
        if (state->vtxBufs[1] != nullptr) {
            imgfx_add_to_cache(state->vtxBufs[1], 1);
            state->vtxBufs[1] = nullptr;
        }
        if (state->gfxBufs[0] != nullptr) {
            imgfx_add_to_cache(state->gfxBufs[0], 1);
            state->gfxBufs[0] = nullptr;
        }
        if (state->gfxBufs[1] != nullptr) {
            // imgfx_add_to_cache(state->gfxBufs[1], 1);
            romEnd = (u8*) state->gfxBufs[1]; // required to match
            imgfx_add_to_cache(state->gfxBufs[1], 1);
            state->gfxBufs[1] = nullptr;
        }
        state->vtxBufs[0] = heap_malloc(anim->vtxCount * sizeof(Vtx));
        state->vtxBufs[1] = heap_malloc(anim->vtxCount * sizeof(Vtx));
        state->gfxBufs[0] = heap_malloc(anim->gfxCount * sizeof(Gfx));
        state->gfxBufs[1] = heap_malloc(anim->gfxCount * sizeof(Gfx));
 
        romStart = imgfx_data_ROM_START + (s32)anim->gfxOffset;
        romEnd = romStart + anim->gfxCount * sizeof(Gfx);
        dma_copy(romStart, romEnd, state->gfxBufs[0]);
        dma_copy(romStart, romEnd, state->gfxBufs[1]);
 
        // Search through the state's displaylists for vertex commands
        // and adjust their addresses to point into the vertex buffers
        for (i = 0; i < ARRAY_COUNT(state->gfxBufs); i++) {
            Gfx* gfxBuffer = state->gfxBufs[i];
            s32 j = 0;
            u32 cmd;
 
            // Loop over the displaylist commands until we hit an ENDDL
            do {
                u32 w0 = gfxBuffer[j++].words.w0;
                cmd = w0 >> 0x18;
 
                // If this command is a vertex command, adjust the vertex buffer address
                if (cmd == G_VTX) {
                    // ImgFXVtx structs are 0xC bytes while Vtx are 0x10, so we need a (4/3) scaling factor
                    // to compute a new, equivalent Vtx[i] address for an existing ImgFXVtx[i] address.
                    // Unfortunately, using sizeof here does not match.
                    gfxBuffer[j-1].words.w1 = ((((s32) gfxBuffer[j-1].words.w1 - (s32) anim->keyframesOffset) / 3) * 4) +
                                              (s32) state->vtxBufs[i];
                }
            } while (cmd != G_ENDDL);
        }
    }
 
    return anim;
}

Referenced by imgfx_mesh_anim_update().

Variable Documentation

heap_spriteHead

HeapNode heap_spriteHead

extern

Definition at line 4 of file heaps3.c.

Referenced by imgfx_init().

ImgFXCurrentTexture

BSS ImgFXWorkingTexture ImgFXCurrentTexture

Definition at line 115 of file imgfx.c.

ImgFXVtxBuffers

BSS Vtx* ImgFXVtxBuffers[2]

Definition at line 116 of file imgfx.c.

Referenced by func_8013A4D0(), and imgfx_init().

imgfx_vtxBuf

BSS Vtx* imgfx_vtxBuf

Definition at line 117 of file imgfx.c.

Referenced by func_8013A4D0(), imgfx_appendGfx_mesh_basic(), imgfx_appendGfx_mesh_grid(), imgfx_init(), imgfx_mesh_load_colors(), imgfx_mesh_make_grid(), imgfx_mesh_make_strip(), and imgfx_mesh_make_wavy().

ImgFXInstances

BSS ImgFXInstanceList* ImgFXInstances

Definition at line 118 of file imgfx.c.

Referenced by func_8013A4D0(), imgfx_appendGfx_mesh_basic(), imgfx_get_free_instances(), imgfx_get_next_instance(), imgfx_init(), and imgfx_set_state_flags().

ImgFXAnimHeaders

BSS ImgFXAnimHeader ImgFXAnimHeaders[MAX_IMGFX_INSTANCES]

Definition at line 119 of file imgfx.c.

Referenced by imgfx_load_anim().

ImgFXDataCache

BSS ImgFXCacheEntry ImgFXDataCache[8]

Definition at line 120 of file imgfx.c.

Referenced by imgfx_add_to_cache(), imgfx_init(), and imgfx_update_cache_impl().

ImgFXCurrentTexturePtr

ImgFXWorkingTexture* ImgFXCurrentTexturePtr = &ImgFXCurrentTexture

Definition at line 123 of file imgfx.c.

Referenced by imgfx_appendGfx_component(), imgfx_appendGfx_mesh(), imgfx_appendGfx_mesh_anim(), imgfx_appendGfx_mesh_basic(), imgfx_appendGfx_mesh_grid(), imgfx_appendGfx_mesh_strip(), imgfx_mesh_anim_update(), imgfx_mesh_load_colors(), imgfx_mesh_make_grid(), and imgfx_mesh_make_strip().

imgfx_vtxCount

u16 imgfx_vtxCount = 0

Definition at line 125 of file imgfx.c.

Referenced by func_8013A4D0(), imgfx_init(), imgfx_mesh_make_grid(), and imgfx_mesh_make_strip().

ImgFXLights

Lights2 ImgFXLights = gdSPDefLights2(144, 144, 144, 255, 255, 255, 0, 0, 120, 255, 255, 255, 0, 0, 136)

Definition at line 127 of file imgfx.c.

Referenced by imgfx_appendGfx_mesh().

D_8014EE40

Vp D_8014EE40

Initial value:

= {
    .vp = {
        .vscale = { 640, 480, 511, 0 },
        .vtrans = { 640, 480, 511, 0 },
    }
}

Definition at line 129 of file imgfx.c.

                {
    .vp = {
        .vscale = { 640, 480, 511, 0 },
        .vtrans = { 640, 480, 511, 0 },
    }
};

Referenced by imgfx_appendGfx_mesh_basic().

D_8014EE50

Vp D_8014EE50

Initial value:

= {
    .vp = {
        .vscale = { 640, 480, 511, 0 },
        .vtrans = { 640, 480, 512, 0 },
    }
}

Definition at line 136 of file imgfx.c.

                {
    .vp = {
        .vscale = { 640, 480, 511, 0 },
        .vtrans = { 640, 480, 512, 0 },
    }
};

Referenced by imgfx_appendGfx_mesh_basic().

ImgFXVtxBufferCapacity

u16 ImgFXVtxBufferCapacity = 300

Definition at line 143 of file imgfx.c.

Referenced by imgfx_init(), and imgfx_set_vtx_buf_capacity().

DefaultImgFXSetupGfx

Gfx DefaultImgFXSetupGfx[]

Initial value:

= {
    gsSPClearGeometryMode(G_CULL_BOTH | G_LIGHTING),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_ON),
    gsDPSetAlphaCompare(G_AC_NONE),
    gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18,
                     G_AD_DISABLE | G_CD_DISABLE | G_TC_FILT | G_TF_BILERP | G_TP_PERSP),
    gsSPEndDisplayList(),
}

Definition at line 145 of file imgfx.c.

                             {
    gsSPClearGeometryMode(G_CULL_BOTH | G_LIGHTING),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_ON),
    gsDPSetAlphaCompare(G_AC_NONE),
    gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18,
                     G_AD_DISABLE | G_CD_DISABLE | G_TC_FILT | G_TF_BILERP | G_TP_PERSP),
    gsSPEndDisplayList(),
};

Referenced by imgfx_appendGfx_mesh().

ImgFXRenderModes

ImgFXRenderMode ImgFXRenderModes[]

Initial value:

= {
    [IMGFX_RENDER_DEFAULT]               { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_MULTIPLY_RGB]          { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_MULTIPLY_ALPHA]        { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_MULTIPLY_RGBA]         { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_MODULATE_PRIM_RGB]     { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_MODULATE_PRIM_RGBA]    { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_MULTIPLY_SHADE_RGB]    { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_MULTIPLY_SHADE_ALPHA]  { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_MULTIPLY_SHADE_RGBA]   { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_MODULATE_SHADE_RGB]    { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_MODULATE_SHADE_RGBA]   { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_ANIM]                  { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_HOLOGRAM]              { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_COLOR_FILL]            { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_OVERLAY_RGB]           { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_OVERLAY_RGBA]          { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_UNUSED]                { 0x00441208, 0x00111208, 0 },
}

Definition at line 156 of file imgfx.c.

                                     {
    [IMGFX_RENDER_DEFAULT]               { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_MULTIPLY_RGB]          { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_MULTIPLY_ALPHA]        { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_MULTIPLY_RGBA]         { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_MODULATE_PRIM_RGB]     { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_MODULATE_PRIM_RGBA]    { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_MULTIPLY_SHADE_RGB]    { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_MULTIPLY_SHADE_ALPHA]  { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_MULTIPLY_SHADE_RGBA]   { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_MODULATE_SHADE_RGB]    { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_MODULATE_SHADE_RGBA]   { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_ANIM]                  { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_HOLOGRAM]              { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_COLOR_FILL]            { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_OVERLAY_RGB]           { 0x00441208, 0x00111208, 0 },
    [IMGFX_RENDER_OVERLAY_RGBA]          { 0x00404B40, 0x00104B40, IMGFX_RENDER_NO_OVERRIDE },
    [IMGFX_RENDER_UNUSED]                { 0x00441208, 0x00111208, 0 },
};

Referenced by imgfx_appendGfx_mesh().

shock_header

Addr shock_header

extern

shiver_header

Addr shiver_header

extern

vertical_pipe_curl_header

Addr vertical_pipe_curl_header

extern

horizontal_pipe_curl_header

Addr horizontal_pipe_curl_header

extern

startle_header

Addr startle_header

extern

flutter_down_header

Addr flutter_down_header

extern

unfurl_header

Addr unfurl_header

extern

get_in_bed_header

Addr get_in_bed_header

extern

spirit_capture_header

Addr spirit_capture_header

extern

unused_1_header

Addr unused_1_header

extern

unused_2_header

Addr unused_2_header

extern

unused_3_header

Addr unused_3_header

extern

tutankoopa_gather_header

Addr tutankoopa_gather_header

extern

tutankoopa_swirl_2_header

Addr tutankoopa_swirl_2_header

extern

tutankoopa_swirl_1_header

Addr tutankoopa_swirl_1_header

extern

shuffle_cards_header

Addr shuffle_cards_header

extern

flip_card_1_header

Addr flip_card_1_header

extern

flip_card_2_header

Addr flip_card_2_header

extern

flip_card_3_header

Addr flip_card_3_header

extern

cymbal_crush_header

Addr cymbal_crush_header

extern

ImgFXAnimOffsets

u8* ImgFXAnimOffsets[]

Initial value:

= {
    [IMGFX_ANIM_SHOCK]                 shock_header,
    [IMGFX_ANIM_SHIVER]                shiver_header,
    [IMGFX_ANIM_VERTICAL_PIPE_CURL]    vertical_pipe_curl_header,
    [IMGFX_ANIM_HORIZONTAL_PIPE_CURL]  horizontal_pipe_curl_header,
    [IMGFX_ANIM_STARTLE]               startle_header,
    [IMGFX_ANIM_FLUTTER_DOWN]          flutter_down_header,
    [IMGFX_ANIM_UNFURL]                unfurl_header,
    [IMGFX_ANIM_GET_IN_BED]            get_in_bed_header,
    [IMGFX_ANIM_SPIRIT_CAPTURE]        spirit_capture_header,
    [IMGFX_ANIM_UNUSED_1]              unused_1_header,
    [IMGFX_ANIM_UNUSED_2]              unused_2_header,
    [IMGFX_ANIM_UNUSED_3]              unused_3_header,
    [IMGFX_ANIM_TUTANKOOPA_GATHER]     tutankoopa_gather_header,
    [IMGFX_ANIM_TUTANKOOPA_SWIRL_2]    tutankoopa_swirl_2_header,
    [IMGFX_ANIM_TUTANKOOPA_SWIRL_1]    tutankoopa_swirl_1_header,
    [IMGFX_ANIM_SHUFFLE_CARDS]         shuffle_cards_header,
    [IMGFX_ANIM_FLIP_CARD_1]           flip_card_1_header,
    [IMGFX_ANIM_FLIP_CARD_2]           flip_card_2_header,
    [IMGFX_ANIM_FLIP_CARD_3]           flip_card_3_header,
    [IMGFX_ANIM_CYMBAL_CRUSH]          cymbal_crush_header,
}

Definition at line 198 of file imgfx.c.

                         {
    [IMGFX_ANIM_SHOCK]                 shock_header,
    [IMGFX_ANIM_SHIVER]                shiver_header,
    [IMGFX_ANIM_VERTICAL_PIPE_CURL]    vertical_pipe_curl_header,
    [IMGFX_ANIM_HORIZONTAL_PIPE_CURL]  horizontal_pipe_curl_header,
    [IMGFX_ANIM_STARTLE]               startle_header,
    [IMGFX_ANIM_FLUTTER_DOWN]          flutter_down_header,
    [IMGFX_ANIM_UNFURL]                unfurl_header,
    [IMGFX_ANIM_GET_IN_BED]            get_in_bed_header,
    [IMGFX_ANIM_SPIRIT_CAPTURE]        spirit_capture_header,
    [IMGFX_ANIM_UNUSED_1]              unused_1_header,
    [IMGFX_ANIM_UNUSED_2]              unused_2_header,
    [IMGFX_ANIM_UNUSED_3]              unused_3_header,
    [IMGFX_ANIM_TUTANKOOPA_GATHER]     tutankoopa_gather_header,
    [IMGFX_ANIM_TUTANKOOPA_SWIRL_2]    tutankoopa_swirl_2_header,
    [IMGFX_ANIM_TUTANKOOPA_SWIRL_1]    tutankoopa_swirl_1_header,
    [IMGFX_ANIM_SHUFFLE_CARDS]         shuffle_cards_header,
    [IMGFX_ANIM_FLIP_CARD_1]           flip_card_1_header,
    [IMGFX_ANIM_FLIP_CARD_2]           flip_card_2_header,
    [IMGFX_ANIM_FLIP_CARD_3]           flip_card_3_header,
    [IMGFX_ANIM_CYMBAL_CRUSH]          cymbal_crush_header,
};

Referenced by imgfx_load_anim().