effects.c File Reference

Go to the source code of this file.

Macros
#define	EFFECT_GLOBALS_TLB_IDX   0x10
#define	FX_ENTRY(name, gfx_name)

Typedefs
typedef s8	TlbEntry[0x1000]
typedef TlbEntry	TlbMappablePage[15]

Functions
void	stub_effect_delegate (EffectInstance *effect)
	Used for unbound function points in effect structs.
void	set_effect_pos_offset (EffectInstance *effect, f32 x, f32 y, f32 z)
void	clear_effect_data (void)
void	func_80059D48 (void)
void	update_effects (void)
void	render_effects_scene (void)
void	render_effects_UI (void)
EffectInstance *	create_effect_instance (EffectBlueprint *effectBp)
void	remove_effect (EffectInstance *effectInstance)
void	remove_all_effects (void)
s32	load_effect (s32 effectIndex)

Variables
BSS EffectSharedData	gEffectSharedData [15]
EffectInstance *	gEffectInstances [96]
TlbMappablePage	gEffectDataBuffer
Addr	gEffectGlobals

Macro Definition Documentation

EFFECT_GLOBALS_TLB_IDX

#define EFFECT_GLOBALS_TLB_IDX   0x10

Definition at line 8 of file effects.c.

Referenced by clear_effect_data().

FX_ENTRY

#define FX_ENTRY	(		name,
			gfx_name )

Value:

    { \
    .entryPoint = name##_main, \
    .dmaStart = effect_##name##_ROM_START, \
    .dmaEnd = effect_##name##_ROM_END, \
    .dmaDest = effect_##name##_VRAM, \
    .graphicsDmaStart = gfx_name##_ROM_START, \
    .graphicsDmaEnd = gfx_name##_ROM_END, \
}

Definition at line 16 of file effects.c.

#define FX_ENTRY(name, gfx_name) { \
    .entryPoint = name##_main, \
    .dmaStart = effect_##name##_ROM_START, \
    .dmaEnd = effect_##name##_ROM_END, \
    .dmaDest = effect_##name##_VRAM, \
    .graphicsDmaStart = gfx_name##_ROM_START, \
    .graphicsDmaEnd = gfx_name##_ROM_END, \
}

Typedef Documentation

TlbEntry

typedef s8 TlbEntry[0x1000]

Definition at line 5 of file effects.c.

TlbMappablePage

typedef TlbEntry TlbMappablePage[15]

Definition at line 6 of file effects.c.

Function Documentation

stub_effect_delegate()

void stub_effect_delegate

(

EffectInstance *

effect

)

Used for unbound function points in effect structs.

Definition at line 28 of file effects.c.

                                                  {
}

Referenced by create_effect_instance(), and render_effects_UI().

set_effect_pos_offset()

void set_effect_pos_offset	(	EffectInstance *	effect,
		f32	x,
		f32	y,
		f32	z )

Definition at line 31 of file effects.c.

                                                                        {
    s32* data = effect->data.any;
 
    ((f32*)data)[1] = x;
    ((f32*)data)[2] = y;
    ((f32*)data)[3] = z;
}

clear_effect_data()

void clear_effect_data

(

void

)

Definition at line 39 of file effects.c.

                             {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gEffectSharedData); i++) {
        gEffectSharedData[i].flags = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
        gEffectInstances[i] = nullptr;
    }
 
    osUnmapTLBAll();
    osMapTLB(EFFECT_GLOBALS_TLB_IDX, OS_PM_4K, effect_globals_VRAM, (s32)&gEffectGlobals & 0xFFFFFF, -1, -1);
    DMA_COPY_SEGMENT(effect_globals);
}

Referenced by load_demo_battle(), load_engine_data(), load_map_by_IDs(), state_init_logos(), state_init_title_screen(), state_step_demo(), state_step_intro(), and state_step_startup().

func_80059D48()

void func_80059D48

(

void

)

Definition at line 55 of file effects.c.

                         {
}

update_effects()

void update_effects

(

void

)

Definition at line 58 of file effects.c.

                          {
    if (!(gOverrideFlags & (GLOBAL_OVERRIDES_800 | GLOBAL_OVERRIDES_400))) {
        EffectSharedData* sharedData;
        s32 i;
 
        // reset free delay for each EffectSharedData touched in previous update
        for (i = 0, sharedData = gEffectSharedData; i < ARRAY_COUNT(gEffectSharedData); i++, sharedData++) {
            if (sharedData->flags & FX_SHARED_DATA_LOADED) {
                if (!(sharedData->flags & FX_SHARED_DATA_CAN_FREE)) {
                    sharedData->flags |= FX_SHARED_DATA_CAN_FREE;
                    sharedData->freeDelay = 3;
                }
            }
        }
 
        // update each EffectInstances
        for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
            EffectInstance* effectInstance = gEffectInstances[i];
 
            if (effectInstance != nullptr && (effectInstance->flags & FX_INSTANCE_FLAG_ENABLED)) {
                effectInstance->shared->flags &= ~FX_SHARED_DATA_CAN_FREE;
 
                if (gGameStatusPtr->context != CONTEXT_WORLD) {
                    if (effectInstance->flags & FX_INSTANCE_FLAG_BATTLE) {
                        effectInstance->shared->update(effectInstance);
                        effectInstance->flags |= FX_INSTANCE_FLAG_HAS_UPDATED;
                    }
                } else {
                    if (!(effectInstance->flags & FX_INSTANCE_FLAG_BATTLE)) {
                        effectInstance->shared->update(effectInstance);
                        effectInstance->flags |= FX_INSTANCE_FLAG_HAS_UPDATED;
                    }
                }
            }
        }
 
        // free any EffectSharedData which haven't been used recently
        for (i = 0, sharedData = gEffectSharedData; i < ARRAY_COUNT(gEffectSharedData); i++, sharedData++) {
            if (sharedData->flags & FX_SHARED_DATA_LOADED) {
                if (sharedData->flags & FX_SHARED_DATA_CAN_FREE) {
                    if (sharedData->freeDelay != 0) {
                        sharedData->freeDelay--;
                    } else {
                        if (sharedData->graphics != nullptr) {
                            general_heap_free(sharedData->graphics);
                            sharedData->graphics = nullptr;
                        }
                        sharedData->flags = 0;
                        osUnmapTLB(i);
                    }
                }
            }
        }
    }
}

Referenced by state_step_battle(), state_step_change_map(), state_step_enter_world(), state_step_game_over(), state_step_intro(), state_step_pause(), state_step_unpause(), and state_step_world().

render_effects_scene()

void render_effects_scene

(

void

)

Definition at line 114 of file effects.c.

                                {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
        EffectInstance* effectInstance = gEffectInstances[i];
 
        if (effectInstance != nullptr) {
            if (effectInstance->flags & FX_INSTANCE_FLAG_ENABLED) {
                if (effectInstance->flags & FX_INSTANCE_FLAG_HAS_UPDATED) {
                    if (gGameStatusPtr->context != CONTEXT_WORLD) {
                        if (effectInstance->flags & FX_INSTANCE_FLAG_BATTLE) {
                            effectInstance->shared->renderScene(effectInstance);
                        }
                    } else {
                        if (!(effectInstance->flags & FX_INSTANCE_FLAG_BATTLE)) {
                            effectInstance->shared->renderScene(effectInstance);
                        }
                    }
                }
            }
        }
    }
}

Referenced by render_frame().

render_effects_UI()

void render_effects_UI

(

void

)

Definition at line 138 of file effects.c.

                             {
    s32 cond = true;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
        EffectInstance* effectInstance = gEffectInstances[i];
 
        if (effectInstance != nullptr) {
            if (effectInstance->flags & FX_INSTANCE_FLAG_ENABLED) {
                if (effectInstance->flags & FX_INSTANCE_FLAG_HAS_UPDATED) {
                    void (*renderUI)(EffectInstance* effect);
 
                    if (gGameStatusPtr->context != CONTEXT_WORLD && !(effectInstance->flags & FX_INSTANCE_FLAG_BATTLE)) {
                        continue;
                    }
 
                    if (gGameStatusPtr->context == CONTEXT_WORLD && effectInstance->flags & FX_INSTANCE_FLAG_BATTLE) {
                        continue;
                    }
 
                    renderUI = effectInstance->shared->renderUI;
                    if (renderUI != stub_effect_delegate) {
                        if (cond) {
                            Camera* camera = &gCameras[gCurrentCameraID];
 
                            gDPPipeSync(gMainGfxPos++);
                            gSPViewport(gMainGfxPos++, &camera->vp);
                            gSPClearGeometryMode(gMainGfxPos++, G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG |
                                                G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD |
                                                G_SHADING_SMOOTH | G_CLIPPING | 0x40F9FA);
                            gSPSetGeometryMode(gMainGfxPos++, G_ZBUFFER | G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH);
                            gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE,
                                              camera->viewportStartX,
                                              camera->viewportStartY,
                                              camera->viewportStartX + camera->viewportW,
                                              camera->viewportStartY + camera->viewportH);
                            gSPClipRatio(gMainGfxPos++, FRUSTRATIO_2);
 
                            cond = false;
                            if (!(camera->flags & CAMERA_FLAG_ORTHO)) {
                                gSPPerspNormalize(gMainGfxPos++, camera->perspNorm);
                                gSPMatrix(gMainGfxPos++, &gDisplayContext->camPerspMatrix[gCurrentCameraID],
                                          G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
                            }
                        }
 
                        renderUI(effectInstance);
                    }
                }
            }
        }
    }
}

Referenced by gfx_draw_frame().

create_effect_instance()

EffectInstance * create_effect_instance

(

EffectBlueprint *

effectBp

)

Definition at line 192 of file effects.c.

                                                                  {
    EffectInstance* newEffectInst;
    EffectSharedData* sharedData;
    s32 i;
 
    // Search for an unused instance
    for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
        if (gEffectInstances[i] == nullptr) {
            break;
        }
    }
 
    ASSERT(i < ARRAY_COUNT(gEffectInstances));
 
    // Allocate space for the new instance
    gEffectInstances[i] = newEffectInst = general_heap_malloc(sizeof(*newEffectInst));
    ASSERT(newEffectInst != nullptr);
 
    sharedData = &gEffectSharedData[0];
    newEffectInst->effectID = effectBp->effectID;
    newEffectInst->flags = FX_INSTANCE_FLAG_ENABLED;
 
    // Look for a loaded effect of the proper index
    for (i = 0; i < ARRAY_COUNT(gEffectSharedData); i++) {
        if ((sharedData->flags & FX_SHARED_DATA_LOADED) && (sharedData->effectIndex == effectBp->effectID)) {
            break;
        }
        sharedData++;
    }
 
    ASSERT(i < ARRAY_COUNT(gEffectSharedData));
 
    // If this is the first new instance of the effect, initialize the function pointers
    if (sharedData->instanceCounter == 0) {
        sharedData->update = effectBp->update;
        if (sharedData->update == nullptr) {
            sharedData->renderScene = stub_effect_delegate;
        }
 
        sharedData->renderScene = effectBp->renderScene;
        if (sharedData->renderScene == nullptr) {
            sharedData->renderScene = stub_effect_delegate;
        }
 
        sharedData->renderUI = effectBp->renderUI;
        if (sharedData->renderUI == nullptr) {
            sharedData->renderUI = stub_effect_delegate;
        }
    }
 
    sharedData->instanceCounter++;
    newEffectInst->shared = sharedData;
 
    if (effectBp->init != nullptr) {
        effectBp->init(newEffectInst);
    }
 
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        newEffectInst->flags |= FX_INSTANCE_FLAG_BATTLE;
    }
    return newEffectInst;
}

remove_effect()

void remove_effect

(

EffectInstance *

effectInstance

)

Definition at line 255 of file effects.c.

                                                   {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
        if (gEffectInstances[i] == effectInstance) {
            break;
        }
    }
 
    ASSERT(i < ARRAY_COUNT(gEffectInstances));
 
    if (effectInstance->data.any == nullptr) {
        general_heap_free(effectInstance);
        gEffectInstances[i] = nullptr;
    } else {
        general_heap_free(effectInstance->data.any);
        general_heap_free(effectInstance);
        gEffectInstances[i] = nullptr;
    }
}

remove_all_effects()

void remove_all_effects

(

void

)

Definition at line 276 of file effects.c.

                              {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
        EffectInstance* effect = gEffectInstances[i];
 
        if (effect != nullptr && effect->flags & FX_INSTANCE_FLAG_BATTLE) {
            if (effect->data.any != nullptr) {
                general_heap_free(effect->data.any);
            }
            general_heap_free(effect);
            gEffectInstances[i] = nullptr;
        }
    }
}

Referenced by btl_state_update_end_battle(), and btl_state_update_end_demo_battle().

load_effect()

s32 load_effect

(

s32

effectIndex

)

Definition at line 292 of file effects.c.

                                 {
    EffectTableEntry* effectEntry = &gEffectTable[effectIndex];
    EffectSharedData* sharedData;
    s32 i;
 
    // Look for a loaded effect matching the desired index
    for (i = 0, sharedData = &gEffectSharedData[0]; i < ARRAY_COUNT(gEffectSharedData); i++) {
        if (sharedData->flags & FX_SHARED_DATA_LOADED && sharedData->effectIndex == effectIndex) {
            break;
        }
        sharedData++;
    }
 
    // If an effect was found within the table, initialize it and return
    if (i < ARRAY_COUNT(gEffectSharedData)) {
        sharedData->effectIndex = effectIndex;
        sharedData->instanceCounter = 0;
        sharedData->flags = FX_SHARED_DATA_LOADED;
        return 1;
    }
 
    // If a loaded effect wasn't found, look for the first empty space
    for (i = 0, sharedData = &gEffectSharedData[0]; i < ARRAY_COUNT(gEffectSharedData); i++) {
        if (!(sharedData->flags & FX_SHARED_DATA_LOADED)) {
            break;
        }
        sharedData++;
    }
 
    // If no empty space was found, panic
    ASSERT(i < ARRAY_COUNT(gEffectSharedData));
 
    // Map space for the effect
    osMapTLB(i, OS_PM_4K, effectEntry->dmaDest, (s32)(gEffectDataBuffer[i]) & 0xFFFFFF, -1, -1);
 
    // Copy the effect into the newly mapped space
    dma_copy(effectEntry->dmaStart, effectEntry->dmaEnd, effectEntry->dmaDest);
 
    // If there's graphics data for the effect, allocate space and copy into the new space
    if (effectEntry->graphicsDmaStart != nullptr) {
        void* graphics = general_heap_malloc(effectEntry->graphicsDmaEnd - effectEntry->graphicsDmaStart);
        sharedData->graphics = graphics;
        ASSERT(graphics != nullptr);
        dma_copy(effectEntry->graphicsDmaStart, effectEntry->graphicsDmaEnd, sharedData->graphics);
    }
 
    // Initialize the newly loaded effect data
    sharedData->effectIndex = effectIndex;
    sharedData->instanceCounter = 0;
    sharedData->flags = FX_SHARED_DATA_LOADED;
    return 1;
}

Variable Documentation

gEffectSharedData

BSS EffectSharedData gEffectSharedData[15]

Definition at line 10 of file effects.c.

Referenced by clear_effect_data(), create_effect_instance(), load_effect(), and update_effects().

gEffectInstances

EffectInstance* gEffectInstances[96]

Definition at line 11 of file effects.c.

Referenced by clear_effect_data(), create_effect_instance(), remove_all_effects(), remove_effect(), render_effects_scene(), render_effects_UI(), and update_effects().

gEffectDataBuffer

TlbMappablePage gEffectDataBuffer

extern

Referenced by load_effect().

gEffectGlobals

BSS u8 gEffectGlobals

extern

Referenced by clear_effect_data().