mirror/mm
1
0
Fork 0
mirror of https://github.com/zeldaret/mm.git synced 2026-05-23 06:54:14 -04:00
Code Issues Packages Projects Releases Wiki Activity

Actor effect cleanup (#828)

Browse Source 
* Change "particle" to "effect" in most actors

* Undo accidental comment change

* Effect count defines

* Make struct names consistent

* Fix minislime

* Change particle to effect in Demo_Kankyo

* Some tiny things I missed
This commit is contained in:
Tom Overton
2022-06-19 17:11:47 -07:00
committed by GitHub
parent 9682995b04
commit 6d371502e1
27 changed files with 673 additions and 677 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/z64.h
+1 -1
View File
@@ -705,7 +705,7 @@ typedef struct {
/* 0xEC */ u8 unk_EC;
/* 0xED */ u8 unk_ED;
/* 0xEE */ u8 unk_EE[4];
/* 0xF2 */ u8 unk_F2[8]; // [3] is used by both DemoKankyo and ObjectKankyo particle count
/* 0xF2 */ u8 unk_F2[8]; // [3] is used by both DemoKankyo and ObjectKankyo effect count
/* 0xFA */ u8 unk_FA[4];
} EnvironmentContext; // size = 0x100
src/overlays/actors/ovl_Bg_Goron_Oyu/z_bg_goron_oyu.c
+3 -3
View File
@@ -20,7 +20,7 @@ void func_80B40100(BgGoronOyu* this, GlobalContext* globalCtx);
void func_80B400C8(BgGoronOyu* this, GlobalContext* globalCtx);
void func_80B401F8(BgGoronOyu* this, GlobalContext* globalCtx);
void BgGoronOyu_UpdateWaterBoxInfo(BgGoronOyu* this, GlobalContext* globalCtx);
void BgGoronOyu_SpawnParticles(BgGoronOyu* this, GlobalContext* globalCtx);
void BgGoronOyu_SpawnEffects(BgGoronOyu* this, GlobalContext* globalCtx);
void func_80B40160(BgGoronOyu* this, GlobalContext* globalCtx);
const ActorInit Bg_Goron_Oyu_InitVars = {
@@ -108,7 +108,7 @@ void BgGoronOyu_UpdateWaterBoxInfo(BgGoronOyu* this, GlobalContext* globalCtx) {
}
}
void BgGoronOyu_SpawnParticles(BgGoronOyu* this, GlobalContext* globalCtx) {
void BgGoronOyu_SpawnEffects(BgGoronOyu* this, GlobalContext* globalCtx) {
s16 scale;
Vec3f pos1;
Vec3f pos2;
@@ -178,7 +178,7 @@ void BgGoronOyu_Update(Actor* thisx, GlobalContext* globalCtx) {
BgGoronOyu* this = THIS;
this->actionFunc(this, globalCtx);
BgGoronOyu_SpawnParticles(this, globalCtx);
BgGoronOyu_SpawnEffects(this, globalCtx);
}
void BgGoronOyu_Draw(Actor* thisx, GlobalContext* globalCtx) {
src/overlays/actors/ovl_Boss_Hakugin/z_boss_hakugin.h
+5 -3
View File
@@ -7,21 +7,23 @@ struct BossHakugin;
typedef void (*BossHakuginActionFunc)(struct BossHakugin*, GlobalContext*);
typedef struct BossHakuginParticle {
typedef struct BossHakuginEffect {
/* 0x00 */ Vec3f unk_0;
/* 0x0C */ Vec3f unk_C;
/* 0x18 */ s16 unk_18;
/* 0x1A */ s16 unk_1A;
/* 0x1C */ Vec3s unk_1C;
/* 0x24 */ f32 unk_24;
} BossHakuginParticle; // size = 0x28
} BossHakuginEffect; // size = 0x28
#define BOSS_HAKUGIN_EFFECT_COUNT 180
typedef struct BossHakugin {
/* 0x0000 */ Actor actor;
/* 0x0144 */ char unk_0144[0x44];
/* 0x0188 */ BossHakuginActionFunc actionFunc;
/* 0x018C */ char unk_018C[0x86C];
/* 0x09F8 */ BossHakuginParticle unk_9F8[180];
/* 0x09F8 */ BossHakuginEffect unk_9F8[BOSS_HAKUGIN_EFFECT_COUNT];
/* 0x2618 */ char unk_2618[0x11F8];
} BossHakugin; // size = 0x3810
src/overlays/actors/ovl_Demo_Kankyo/z_demo_kankyo.c
+200 -213
View File
@@ -1,7 +1,7 @@
/*
* File: z_demo_kankyo.c
* Overlay: ovl_Demo_Kankyo
* Description: Background Lost Woods/Giant's Chamber/Moon Particles
* Description: Background Lost Woods/Giant's Chamber/Moon Effects
*/
#include "z_demo_kankyo.h"
@@ -44,7 +44,7 @@ void DemoKakyo_LostWoodsSparkleActionFunc(DemoKankyo* this, GlobalContext* globa
s32 pad;
s32 i;
f32 randSkyfishParticleNum;
f32 repositionLimit; // Distance from posCenter when particles are relocated. Always set to 130.0f
f32 repositionLimit; // Distance from posCenter when effects are relocated. Always set to 130.0f
f32 eyeToAtNormX;
f32 eyeToAtNormY;
f32 eyeToAtNormZ;
@@ -61,13 +61,13 @@ void DemoKakyo_LostWoodsSparkleActionFunc(DemoKankyo* this, GlobalContext* globa
} else {
Actor_MarkForDeath(&this->actor);
}
} else if (globalCtx->envCtx.unk_F2[3] < DEMOKANKYO_PARTICLE_COUNT) {
} else if (globalCtx->envCtx.unk_F2[3] < DEMOKANKYO_EFFECT_COUNT) {
globalCtx->envCtx.unk_F2[3] += 16;
}
// note: DemoKankyo can crash if placed in an area that snows (ObjectKankyo)
// because they both use unk_F2 as a particle counter,
// causing DemoKankyo to write beyond its particle array boundry
// because they both use unk_F2 as an effect counter,
// causing DemoKankyo to write beyond its efffect array boundry
// this crash can occur if the two actors are in different scenes connected by an exit
// e.g. if you add DemoKankyo to GoronShrine, you will crash entering/leaving through door
for (i = 0; i < globalCtx->envCtx.unk_F2[3]; i++) {
@@ -81,53 +81,53 @@ void DemoKakyo_LostWoodsSparkleActionFunc(DemoKankyo* this, GlobalContext* globa
eyeToAtNormY = eyeToAt.y / eyeToAtMag;
eyeToAtNormZ = eyeToAt.z / eyeToAtMag;
switch (this->particles[i].state) {
switch (this->effects[i].state) {
case DEMO_KANKYO_STATE_INIT:
this->particles[i].posBase.x = globalCtx->view.eye.x + (eyeToAtNormX * 80.0f);
this->particles[i].posBase.y = globalCtx->view.eye.y + (eyeToAtNormY * 80.0f);
this->particles[i].posBase.z = globalCtx->view.eye.z + (eyeToAtNormZ * 80.0f);
this->effects[i].posBase.x = globalCtx->view.eye.x + (eyeToAtNormX * 80.0f);
this->effects[i].posBase.y = globalCtx->view.eye.y + (eyeToAtNormY * 80.0f);
this->effects[i].posBase.z = globalCtx->view.eye.z + (eyeToAtNormZ * 80.0f);
this->particles[i].posOffset.x = (Rand_ZeroOne() - 0.5f) * 160.0f;
this->particles[i].posOffset.y = 30.0f;
this->particles[i].posOffset.z = (Rand_ZeroOne() - 0.5f) * 160.0f;
this->effects[i].posOffset.x = (Rand_ZeroOne() - 0.5f) * 160.0f;
this->effects[i].posOffset.y = 30.0f;
this->effects[i].posOffset.z = (Rand_ZeroOne() - 0.5f) * 160.0f;
this->particles[i].speedTarget = (Rand_ZeroOne() * 1.6f) + 0.5f;
this->particles[i].alpha = 0;
this->particles[i].alphaClock = Rand_ZeroOne() * 65535; // random 0 to max of u16
this->particles[i].scale = 0.1f;
this->effects[i].speedTarget = (Rand_ZeroOne() * 1.6f) + 0.5f;
this->effects[i].alpha = 0;
this->effects[i].alphaClock = Rand_ZeroOne() * 65535; // random 0 to max of u16
this->effects[i].scale = 0.1f;
// speedClock is angles in radians,
// should have used Rand_ZeroOne() * 2 * M_PI
// however, due to properties of sine waves, this is effectively still random
this->particles[i].speedClock.x = Rand_ZeroOne() * 360.0f;
this->particles[i].speedClock.y = Rand_ZeroOne() * 360.0f;
this->particles[i].speedClock.z = Rand_ZeroOne() * 360.0f;
this->particles[i].pad50 = 0;
this->particles[i].state += DEMO_KANKYO_STATE_SINGLE;
this->effects[i].speedClock.x = Rand_ZeroOne() * 360.0f;
this->effects[i].speedClock.y = Rand_ZeroOne() * 360.0f;
this->effects[i].speedClock.z = Rand_ZeroOne() * 360.0f;
this->effects[i].pad50 = 0;
this->effects[i].state += DEMO_KANKYO_STATE_SINGLE;
break;
case DEMO_KANKYO_STATE_SINGLE:
case DEMO_KANKYO_STATE_SKYFISH:
this->particles[i].alphaClock++;
this->effects[i].alphaClock++;
posCenterX = globalCtx->view.eye.x + (eyeToAtNormX * 80.0f);
posCenterY = globalCtx->view.eye.y + (eyeToAtNormY * 80.0f);
posCenterZ = globalCtx->view.eye.z + (eyeToAtNormZ * 80.0f);
this->particles[i].posOffsetPrev.x = this->particles[i].posOffset.x;
this->particles[i].posOffsetPrev.y = this->particles[i].posOffset.y;
this->particles[i].posOffsetPrev.z = this->particles[i].posOffset.z;
this->effects[i].posOffsetPrev.x = this->effects[i].posOffset.x;
this->effects[i].posOffsetPrev.y = this->effects[i].posOffset.y;
this->effects[i].posOffsetPrev.z = this->effects[i].posOffset.z;
if (this->particles[i].state == DEMO_KANKYO_STATE_SINGLE) {
if (this->effects[i].state == DEMO_KANKYO_STATE_SINGLE) {
// The first 32 particles will become skyfish particles
// The first 32 effects will become skyfish particles
// This block is also init code and only runs once
if (i < 32) {
if (Rand_ZeroOne() < 0.5f) {
this->particles[i].LostWoodsSkyFishSpeedXZ = (s16)(Rand_ZeroOne() * 200.0f) + 200;
this->effects[i].LostWoodsSkyFishSpeedXZ = (s16)(Rand_ZeroOne() * 200.0f) + 200;
} else {
this->particles[i].LostWoodsSkyFishSpeedXZ = -200 - (s16)(Rand_ZeroOne() * 200.0f);
this->effects[i].LostWoodsSkyFishSpeedXZ = -200 - (s16)(Rand_ZeroOne() * 200.0f);
}
this->particles[i].LostWoodsSkyFishPosOffsetMax = (s16)(Rand_ZeroOne() * 50.0f) + 15;
this->particles[i].LostWoodsSkyFishSpeedY = ((Rand_ZeroOne() * 10.0f) + 10.0f) * 0.01f;
this->effects[i].LostWoodsSkyFishPosOffsetMax = (s16)(Rand_ZeroOne() * 50.0f) + 15;
this->effects[i].LostWoodsSkyFishSpeedY = ((Rand_ZeroOne() * 10.0f) + 10.0f) * 0.01f;
// Only the 31st particle matters as sLostWoodsSkyFishParticleNum will be overwritten
// every particle until the last skyfish particle is initialized
@@ -145,147 +145,134 @@ void DemoKakyo_LostWoodsSparkleActionFunc(DemoKankyo* this, GlobalContext* globa
if ((i & sLostWoodsSkyFishParticleNum) == 0) {
// Head particle
this->particles[i].posOffset.y = 0.0f;
this->effects[i].posOffset.y = 0.0f;
}
this->particles[i].state = DEMO_KANKYO_STATE_SKYFISH;
this->particles[i].speedTarget = 0.0f;
this->effects[i].state = DEMO_KANKYO_STATE_SKYFISH;
this->effects[i].speedTarget = 0.0f;
}
Math_SmoothStepToF(&this->particles[i].scale, 0.1, 0.1f, 0.001f, 0.00001f);
Math_SmoothStepToF(&this->particles[i].speed, this->particles[i].speedTarget, 0.5f, 0.2f, 0.02f);
this->particles[i].posOffset.x += sinf(this->particles[i].speedClock.x) * this->particles[i].speed;
this->particles[i].posOffset.y += sinf(this->particles[i].speedClock.y) * this->particles[i].speed;
this->particles[i].posOffset.z += sinf(this->particles[i].speedClock.z) * this->particles[i].speed;
Math_SmoothStepToF(&this->effects[i].scale, 0.1, 0.1f, 0.001f, 0.00001f);
Math_SmoothStepToF(&this->effects[i].speed, this->effects[i].speedTarget, 0.5f, 0.2f, 0.02f);
this->effects[i].posOffset.x += sinf(this->effects[i].speedClock.x) * this->effects[i].speed;
this->effects[i].posOffset.y += sinf(this->effects[i].speedClock.y) * this->effects[i].speed;
this->effects[i].posOffset.z += sinf(this->effects[i].speedClock.z) * this->effects[i].speed;
switch ((i >> 1) & 3) {
case 0:
this->particles[i].speedClock.x += 0.008f;
this->particles[i].speedClock.y += 0.05f * Rand_ZeroOne();
this->particles[i].speedClock.z += 0.015f;
this->effects[i].speedClock.x += 0.008f;
this->effects[i].speedClock.y += 0.05f * Rand_ZeroOne();
this->effects[i].speedClock.z += 0.015f;
break;
case 1:
this->particles[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->particles[i].speedClock.y += 0.05f * Rand_ZeroOne();
this->particles[i].speedClock.z += 0.005f * Rand_ZeroOne();
this->effects[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->effects[i].speedClock.y += 0.05f * Rand_ZeroOne();
this->effects[i].speedClock.z += 0.005f * Rand_ZeroOne();
break;
case 2:
this->particles[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->particles[i].speedClock.y += 0.4f * Rand_ZeroOne();
this->particles[i].speedClock.z += 0.004f * Rand_ZeroOne();
this->effects[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->effects[i].speedClock.y += 0.4f * Rand_ZeroOne();
this->effects[i].speedClock.z += 0.004f * Rand_ZeroOne();
break;
case 3:
this->particles[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->particles[i].speedClock.y += 0.08f * Rand_ZeroOne();
this->particles[i].speedClock.z += 0.05f * Rand_ZeroOne();
this->effects[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->effects[i].speedClock.y += 0.08f * Rand_ZeroOne();
this->effects[i].speedClock.z += 0.05f * Rand_ZeroOne();
break;
}
} else if (this->particles[i].state == DEMO_KANKYO_STATE_SKYFISH) {
} else if (this->effects[i].state == DEMO_KANKYO_STATE_SKYFISH) {
if ((i & sLostWoodsSkyFishParticleNum) == 0) {
// Head particle
Math_SmoothStepToF(&this->particles[i].scale, 0.25f, 0.1f, 0.001f, 0.00001f);
Math_SmoothStepToF(&this->effects[i].scale, 0.25f, 0.1f, 0.001f, 0.00001f);
Math_SmoothStepToF(&this->particles[i].posBase.x, player->actor.world.pos.x, 0.5f, 1.0f, 0.2f);
Math_SmoothStepToF(&this->particles[i].posBase.y, player->actor.world.pos.y + 50.0f, 0.5f, 1.0f,
Math_SmoothStepToF(&this->effects[i].posBase.x, player->actor.world.pos.x, 0.5f, 1.0f, 0.2f);
Math_SmoothStepToF(&this->effects[i].posBase.y, player->actor.world.pos.y + 50.0f, 0.5f, 1.0f,
0.2f);
Math_SmoothStepToF(&this->particles[i].posBase.z, player->actor.world.pos.z, 0.5f, 1.0f, 0.2f);
Math_SmoothStepToF(&this->effects[i].posBase.z, player->actor.world.pos.z, 0.5f, 1.0f, 0.2f);
Math_SmoothStepToF(&this->particles[i].posOffset.x,
Math_SinS(this->particles[i].LostWoodsSkyFishSpeedXZClock - 0x8000) *
this->particles[i].LostWoodsSkyFishPosOffsetMax,
Math_SmoothStepToF(&this->effects[i].posOffset.x,
Math_SinS(this->effects[i].LostWoodsSkyFishSpeedXZClock - 0x8000) *
this->effects[i].LostWoodsSkyFishPosOffsetMax,
0.5f, 2.0f, 0.2f);
Math_SmoothStepToF(&this->particles[i].posOffset.z,
Math_CosS(this->particles[i].LostWoodsSkyFishSpeedXZClock - 0x8000) *
this->particles[i].LostWoodsSkyFishPosOffsetMax,
Math_SmoothStepToF(&this->effects[i].posOffset.z,
Math_CosS(this->effects[i].LostWoodsSkyFishSpeedXZClock - 0x8000) *
this->effects[i].LostWoodsSkyFishPosOffsetMax,
0.5f, 2.0f, 0.2f);
this->particles[i].LostWoodsSkyFishSpeedXZClock += this->particles[i].LostWoodsSkyFishSpeedXZ;
this->particles[i].posOffset.y += sinf(this->particles[i].speedClock.y);
this->particles[i].speedClock.x += 0.2f * Rand_ZeroOne(); // unused calculation
this->particles[i].speedClock.y += this->particles[i].LostWoodsSkyFishSpeedY;
this->particles[i].speedClock.z += 0.1f * Rand_ZeroOne(); // unused calculation
this->effects[i].LostWoodsSkyFishSpeedXZClock += this->effects[i].LostWoodsSkyFishSpeedXZ;
this->effects[i].posOffset.y += sinf(this->effects[i].speedClock.y);
this->effects[i].speedClock.x += 0.2f * Rand_ZeroOne(); // unused calculation
this->effects[i].speedClock.y += this->effects[i].LostWoodsSkyFishSpeedY;
this->effects[i].speedClock.z += 0.1f * Rand_ZeroOne(); // unused calculation
this->particles[i].posOffset.x =
Math_SinS(this->particles[i].LostWoodsSkyFishSpeedXZClock - 0x8000) *
this->particles[i].LostWoodsSkyFishPosOffsetMax;
this->particles[i].posOffset.z =
Math_CosS(this->particles[i].LostWoodsSkyFishSpeedXZClock - 0x8000) *
this->particles[i].LostWoodsSkyFishPosOffsetMax;
this->effects[i].posOffset.x =
Math_SinS(this->effects[i].LostWoodsSkyFishSpeedXZClock - 0x8000) *
this->effects[i].LostWoodsSkyFishPosOffsetMax;
this->effects[i].posOffset.z =
Math_CosS(this->effects[i].LostWoodsSkyFishSpeedXZClock - 0x8000) *
this->effects[i].LostWoodsSkyFishPosOffsetMax;
} else {
// Tail Particles
Math_SmoothStepToF(&this->particles[i].scale, 0.1, 0.1f, 0.001f, 0.00001f);
Math_SmoothStepToF(&this->effects[i].scale, 0.1, 0.1f, 0.001f, 0.00001f);
// Unused calculation, speed only used in posOffset calculations,
// but posOffset gets overwritten for tail particles immediately below
Math_SmoothStepToF(&this->particles[i].speed, 1.5f, 0.5f, 0.1f, 0.0002f);
Math_SmoothStepToF(&this->effects[i].speed, 1.5f, 0.5f, 0.1f, 0.0002f);
// particles in the skyfish's tail are moved to the previous position of the particle directly
// in front
this->particles[i].posOffset.x =
this->particles[i - 1].posOffsetPrev.x +
(this->particles[i - 1].posBase.x - this->particles[i].posBase.x);
this->particles[i].posOffset.y =
this->particles[i - 1].posOffsetPrev.y +
(this->particles[i - 1].posBase.y - this->particles[i].posBase.y);
this->particles[i].posOffset.z =
this->particles[i - 1].posOffsetPrev.z +
(this->particles[i - 1].posBase.z - this->particles[i].posBase.z);
this->effects[i].posOffset.x = this->effects[i - 1].posOffsetPrev.x +
(this->effects[i - 1].posBase.x - this->effects[i].posBase.x);
this->effects[i].posOffset.y = this->effects[i - 1].posOffsetPrev.y +
(this->effects[i - 1].posBase.y - this->effects[i].posBase.y);
this->effects[i].posOffset.z = this->effects[i - 1].posOffsetPrev.z +
(this->effects[i - 1].posBase.z - this->effects[i].posBase.z);
}
}
if ((this->particles[i].state != DEMO_KANKYO_STATE_SKYFISH) &&
((((this->particles[i].posBase.x + this->particles[i].posOffset.x) - posCenterX) >
repositionLimit) ||
(((this->particles[i].posBase.x + this->particles[i].posOffset.x) - posCenterX) <
-repositionLimit) ||
(((this->particles[i].posBase.y + this->particles[i].posOffset.y) - posCenterY) >
repositionLimit) ||
(((this->particles[i].posBase.y + this->particles[i].posOffset.y) - posCenterY) <
-repositionLimit) ||
(((this->particles[i].posBase.z + this->particles[i].posOffset.z) - posCenterZ) >
repositionLimit) ||
(((this->particles[i].posBase.z + this->particles[i].posOffset.z) - posCenterZ) <
-repositionLimit))) {
if (((this->particles[i].posOffset.x + this->particles[i].posBase.x) - posCenterX) >
repositionLimit) {
this->particles[i].posOffset.x = 0.0f;
this->particles[i].posBase.x = posCenterX - repositionLimit;
if ((this->effects[i].state != DEMO_KANKYO_STATE_SKYFISH) &&
((((this->effects[i].posBase.x + this->effects[i].posOffset.x) - posCenterX) > repositionLimit) ||
(((this->effects[i].posBase.x + this->effects[i].posOffset.x) - posCenterX) < -repositionLimit) ||
(((this->effects[i].posBase.y + this->effects[i].posOffset.y) - posCenterY) > repositionLimit) ||
(((this->effects[i].posBase.y + this->effects[i].posOffset.y) - posCenterY) < -repositionLimit) ||
(((this->effects[i].posBase.z + this->effects[i].posOffset.z) - posCenterZ) > repositionLimit) ||
(((this->effects[i].posBase.z + this->effects[i].posOffset.z) - posCenterZ) < -repositionLimit))) {
if (((this->effects[i].posOffset.x + this->effects[i].posBase.x) - posCenterX) > repositionLimit) {
this->effects[i].posOffset.x = 0.0f;
this->effects[i].posBase.x = posCenterX - repositionLimit;
}
if (((this->particles[i].posBase.x + this->particles[i].posOffset.x) - posCenterX) <
-repositionLimit) {
this->particles[i].posOffset.x = 0.0f;
this->particles[i].posBase.x = posCenterX + repositionLimit;
if (((this->effects[i].posBase.x + this->effects[i].posOffset.x) - posCenterX) < -repositionLimit) {
this->effects[i].posOffset.x = 0.0f;
this->effects[i].posBase.x = posCenterX + repositionLimit;
}
if (((this->particles[i].posBase.y + this->particles[i].posOffset.y) - posCenterY) > 50.0f) {
this->particles[i].posOffset.y = 0.0f;
this->particles[i].posBase.y = posCenterY - 50.0f;
if (((this->effects[i].posBase.y + this->effects[i].posOffset.y) - posCenterY) > 50.0f) {
this->effects[i].posOffset.y = 0.0f;
this->effects[i].posBase.y = posCenterY - 50.0f;
}
if (((this->particles[i].posBase.y + this->particles[i].posOffset.y) - posCenterY) < -50.0f) {
this->particles[i].posOffset.y = 0.0f;
this->particles[i].posBase.y = posCenterY + 50.0f;
if (((this->effects[i].posBase.y + this->effects[i].posOffset.y) - posCenterY) < -50.0f) {
this->effects[i].posOffset.y = 0.0f;
this->effects[i].posBase.y = posCenterY + 50.0f;
}
if (((this->particles[i].posBase.z + this->particles[i].posOffset.z) - posCenterZ) >
repositionLimit) {
this->particles[i].posOffset.z = 0.0f;
this->particles[i].posBase.z = posCenterZ - repositionLimit;
if (((this->effects[i].posBase.z + this->effects[i].posOffset.z) - posCenterZ) > repositionLimit) {
this->effects[i].posOffset.z = 0.0f;
this->effects[i].posBase.z = posCenterZ - repositionLimit;
}
if (((this->particles[i].posBase.z + this->particles[i].posOffset.z) - posCenterZ) <
-repositionLimit) {
this->particles[i].posOffset.z = 0.0f;
this->particles[i].posBase.z = posCenterZ + repositionLimit;
if (((this->effects[i].posBase.z + this->effects[i].posOffset.z) - posCenterZ) < -repositionLimit) {
this->effects[i].posOffset.z = 0.0f;
this->effects[i].posBase.z = posCenterZ + repositionLimit;
}
}
break;
case DEMO_KANKYO_STATE_DISABLED:
this->particles[i].state = DEMO_KANKYO_STATE_INIT;
this->effects[i].state = DEMO_KANKYO_STATE_INIT;
break;
}
}
@@ -317,7 +304,7 @@ void DemoKakyo_MoonSparklesActionFunc(DemoKankyo* this, GlobalContext* globalCtx
s32 pad1;
Vec3f worldPos;
if (globalCtx->envCtx.unk_F2[3] < DEMOKANKYO_PARTICLE_COUNT) {
if (globalCtx->envCtx.unk_F2[3] < DEMOKANKYO_EFFECT_COUNT) {
globalCtx->envCtx.unk_F2[3] += 16;
}
@@ -332,38 +319,38 @@ void DemoKakyo_MoonSparklesActionFunc(DemoKankyo* this, GlobalContext* globalCtx
halfScreenHeight = SCREEN_HEIGHT / 2;
for (i = 0; i < globalCtx->envCtx.unk_F2[3]; i++) {
switch (this->particles[i].state) {
switch (this->effects[i].state) {
case DEMO_KANKYO_STATE_INIT:
this->particles[i].posBase.x = globalCtx->view.eye.x + (eyeToAtNormX * halfScreenHeight);
this->particles[i].posBase.y = globalCtx->view.eye.y + (eyeToAtNormY * halfScreenHeight);
this->particles[i].posBase.z = globalCtx->view.eye.z + (eyeToAtNormZ * halfScreenHeight);
this->effects[i].posBase.x = globalCtx->view.eye.x + (eyeToAtNormX * halfScreenHeight);
this->effects[i].posBase.y = globalCtx->view.eye.y + (eyeToAtNormY * halfScreenHeight);
this->effects[i].posBase.z = globalCtx->view.eye.z + (eyeToAtNormZ * halfScreenHeight);
this->particles[i].posOffset.x = (Rand_ZeroOne() - 0.5f) * (2.0f * halfScreenHeight);
this->particles[i].posOffset.y = (Rand_ZeroOne() - 0.5f) * (2.0f * halfScreenHeight);
this->particles[i].posOffset.z = (Rand_ZeroOne() - 0.5f) * (2.0f * halfScreenHeight);
this->effects[i].posOffset.x = (Rand_ZeroOne() - 0.5f) * (2.0f * halfScreenHeight);
this->effects[i].posOffset.y = (Rand_ZeroOne() - 0.5f) * (2.0f * halfScreenHeight);
this->effects[i].posOffset.z = (Rand_ZeroOne() - 0.5f) * (2.0f * halfScreenHeight);
this->particles[i].speedTarget = (Rand_ZeroOne() * 1.6f) + 0.5f;
this->particles[i].alpha = 0;
this->particles[i].alphaClock = (Rand_ZeroOne() * 65535);
this->particles[i].scale = 0.2f;
this->effects[i].speedTarget = (Rand_ZeroOne() * 1.6f) + 0.5f;
this->effects[i].alpha = 0;
this->effects[i].alphaClock = (Rand_ZeroOne() * 65535);
this->effects[i].scale = 0.2f;
// speedClock is angles in radians,
// should have used Rand_ZeroOne() * 2 * M_PI
// however, due to properties of sine waves, this is effectively still random
this->particles[i].speedClock.x = Rand_ZeroOne() * 360.0f;
this->particles[i].speedClock.y = Rand_ZeroOne() * 360.0f;
this->particles[i].speedClock.z = Rand_ZeroOne() * 360.0f;
this->effects[i].speedClock.x = Rand_ZeroOne() * 360.0f;
this->effects[i].speedClock.y = Rand_ZeroOne() * 360.0f;
this->effects[i].speedClock.z = Rand_ZeroOne() * 360.0f;
this->particles[i].pad50 = 0;
this->particles[i].state += DEMO_KANKYO_STATE_SINGLE;
this->effects[i].pad50 = 0;
this->effects[i].state += DEMO_KANKYO_STATE_SINGLE;
break;
case DEMO_KANKYO_STATE_SINGLE:
case DEMO_KANKYO_STATE_SKYFISH:
this->particles[i].alphaClock++;
this->effects[i].alphaClock++;
if (this->actor.params == DEMO_KANKYO_TYPE_MOON) { // this function gets reused for giants too
this->particles[i].posBase.y =
this->effects[i].posBase.y =
globalCtx->view.eye.y + (eyeToAtNormY * halfScreenHeight) + (SCREEN_HEIGHT / 3);
}
@@ -371,76 +358,76 @@ void DemoKakyo_MoonSparklesActionFunc(DemoKankyo* this, GlobalContext* globalCtx
newEye.y = globalCtx->view.eye.y + (eyeToAtNormY * halfScreenHeight);
newEye.z = globalCtx->view.eye.z + (eyeToAtNormZ * halfScreenHeight);
Math_SmoothStepToF(&this->particles[i].scale, 0.2f, 0.1f, 0.001f, 0.00001f);
Math_SmoothStepToF(&this->particles[i].speed, this->particles[i].speedTarget, 0.5f, 0.2f, 0.02f);
Math_SmoothStepToF(&this->effects[i].scale, 0.2f, 0.1f, 0.001f, 0.00001f);
Math_SmoothStepToF(&this->effects[i].speed, this->effects[i].speedTarget, 0.5f, 0.2f, 0.02f);
this->particles[i].posOffset.x += sinf(this->particles[i].speedClock.x) * this->particles[i].speed;
this->particles[i].posOffset.y += sinf(this->particles[i].speedClock.y) * this->particles[i].speed;
this->particles[i].posOffset.z += sinf(this->particles[i].speedClock.z) * this->particles[i].speed;
this->effects[i].posOffset.x += sinf(this->effects[i].speedClock.x) * this->effects[i].speed;
this->effects[i].posOffset.y += sinf(this->effects[i].speedClock.y) * this->effects[i].speed;
this->effects[i].posOffset.z += sinf(this->effects[i].speedClock.z) * this->effects[i].speed;
switch ((i >> 1) & 3) {
case 0:
this->particles[i].speedClock.x += 0.008f;
this->particles[i].speedClock.y += 0.05f * Rand_ZeroOne();
this->particles[i].speedClock.z += 0.015f;
this->effects[i].speedClock.x += 0.008f;
this->effects[i].speedClock.y += 0.05f * Rand_ZeroOne();
this->effects[i].speedClock.z += 0.015f;
break;
case 1:
this->particles[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->particles[i].speedClock.y += 0.05f * Rand_ZeroOne();
this->particles[i].speedClock.z += 0.005f * Rand_ZeroOne();
this->effects[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->effects[i].speedClock.y += 0.05f * Rand_ZeroOne();
this->effects[i].speedClock.z += 0.005f * Rand_ZeroOne();
break;
case 2:
this->particles[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->particles[i].speedClock.y += 0.4f * Rand_ZeroOne();
this->particles[i].speedClock.z += 0.004f * Rand_ZeroOne();
this->effects[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->effects[i].speedClock.y += 0.4f * Rand_ZeroOne();
this->effects[i].speedClock.z += 0.004f * Rand_ZeroOne();
break;
case 3:
this->particles[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->particles[i].speedClock.y += 0.08f * Rand_ZeroOne();
this->particles[i].speedClock.z += 0.05f * Rand_ZeroOne();
this->effects[i].speedClock.x += 0.01f * Rand_ZeroOne();
this->effects[i].speedClock.y += 0.08f * Rand_ZeroOne();
this->effects[i].speedClock.z += 0.05f * Rand_ZeroOne();
break;
}
if (((this->particles[i].posBase.x + this->particles[i].posOffset.x) - newEye.x) > halfScreenHeight) {
this->particles[i].posBase.x = newEye.x - halfScreenHeight;
if (((this->effects[i].posBase.x + this->effects[i].posOffset.x) - newEye.x) > halfScreenHeight) {
this->effects[i].posBase.x = newEye.x - halfScreenHeight;
}
if (((this->particles[i].posBase.x + this->particles[i].posOffset.x) - newEye.x) < -halfScreenHeight) {
this->particles[i].posBase.x = newEye.x + halfScreenHeight;
if (((this->effects[i].posBase.x + this->effects[i].posOffset.x) - newEye.x) < -halfScreenHeight) {
this->effects[i].posBase.x = newEye.x + halfScreenHeight;
}
worldPos.x = this->particles[i].posBase.x + this->particles[i].posOffset.x;
worldPos.y = this->particles[i].posBase.y + this->particles[i].posOffset.y;
worldPos.z = this->particles[i].posBase.z + this->particles[i].posOffset.z;
worldPos.x = this->effects[i].posBase.x + this->effects[i].posOffset.x;
worldPos.y = this->effects[i].posBase.y + this->effects[i].posOffset.y;
worldPos.z = this->effects[i].posBase.z + this->effects[i].posOffset.z;
randZeroOne = Math_Vec3f_DistXZ(&worldPos, &globalCtx->view.eye) / 200.0f;
randZeroOne = CLAMP(randZeroOne, 0.0f, 1.0f);
halfScreenWidth = 100.0f + randZeroOne + 60.0f; // range 160 to 161...? thats about half screen width
// I think this code is shifting the particles 1 frame -> half screen at a time to keep it in-view
if (halfScreenWidth < ((this->particles[i].posBase.y + this->particles[i].posOffset.y) - newEye.y)) {
this->particles[i].posBase.y = newEye.y - halfScreenWidth;
// I think this code is shifting the effects 1 frame -> half screen at a time to keep it in-view
if (halfScreenWidth < ((this->effects[i].posBase.y + this->effects[i].posOffset.y) - newEye.y)) {
this->effects[i].posBase.y = newEye.y - halfScreenWidth;
}
if (((this->particles[i].posBase.y + this->particles[i].posOffset.y) - newEye.y) < -halfScreenWidth) {
this->particles[i].posBase.y = newEye.y + halfScreenWidth;
if (((this->effects[i].posBase.y + this->effects[i].posOffset.y) - newEye.y) < -halfScreenWidth) {
this->effects[i].posBase.y = newEye.y + halfScreenWidth;
}
if (((this->particles[i].posBase.z + this->particles[i].posOffset.z) - newEye.z) > halfScreenHeight) {
this->particles[i].posBase.z = newEye.z - halfScreenHeight;
if (((this->effects[i].posBase.z + this->effects[i].posOffset.z) - newEye.z) > halfScreenHeight) {
this->effects[i].posBase.z = newEye.z - halfScreenHeight;
}
if (((this->particles[i].posBase.z + this->particles[i].posOffset.z) - newEye.z) < -halfScreenHeight) {
this->particles[i].posBase.z = newEye.z + halfScreenHeight;
if (((this->effects[i].posBase.z + this->effects[i].posOffset.z) - newEye.z) < -halfScreenHeight) {
this->effects[i].posBase.z = newEye.z + halfScreenHeight;
}
break;
case DEMO_KANKYO_STATE_DISABLED:
this->particles[i].state = DEMO_KANKYO_STATE_INIT;
this->effects[i].state = DEMO_KANKYO_STATE_INIT;
break;
}
}
@@ -454,7 +441,7 @@ void DemoKankyo_Init(Actor* thisx, GlobalContext* globalCtx) {
// This must be a single line to match, possibly a macro?
// clang-format off
for (i = 0; i < ARRAY_COUNT(this->particles); i++) { this->particles[i].state = DEMO_KANKYO_STATE_INIT; }
for (i = 0; i < ARRAY_COUNT(this->effects); i++) { this->effects[i].state = DEMO_KANKYO_STATE_INIT; }
// clang-format on
if (1) {};
@@ -524,9 +511,9 @@ void DemoKakyo_DrawLostWoodsSparkle(Actor* thisx, GlobalContext* globalCtx2) {
gSPDisplayList(POLY_XLU_DISP++, gameplay_keep_DL_07AB10);
for (i = 0; i < globalCtx->envCtx.unk_F2[3]; i++) {
worldPos.x = this->particles[i].posBase.x + this->particles[i].posOffset.x;
worldPos.y = this->particles[i].posBase.y + this->particles[i].posOffset.y;
worldPos.z = this->particles[i].posBase.z + this->particles[i].posOffset.z;
worldPos.x = this->effects[i].posBase.x + this->effects[i].posOffset.x;
worldPos.y = this->effects[i].posBase.y + this->effects[i].posOffset.y;
worldPos.z = this->effects[i].posBase.z + this->effects[i].posOffset.z;
func_80169474(globalCtx, &worldPos, &screenPos); // unnamed Play_ function, func_800C016C from OoT
@@ -534,52 +521,52 @@ void DemoKakyo_DrawLostWoodsSparkle(Actor* thisx, GlobalContext* globalCtx2) {
if (screenPos.x >= 0.0f && screenPos.x < SCREEN_WIDTH && screenPos.y >= 0.0f &&
screenPos.y < SCREEN_HEIGHT) {
Matrix_Translate(worldPos.x, worldPos.y, worldPos.z, MTXMODE_NEW);
scaleAlpha = this->particles[i].alpha / 50.0f;
scaleAlpha = this->effects[i].alpha / 50.0f;
if (scaleAlpha > 1.0f) {
scaleAlpha = 1.0f;
}
Matrix_Scale(this->particles[i].scale * scaleAlpha, this->particles[i].scale * scaleAlpha,
this->particles[i].scale * scaleAlpha, MTXMODE_APPLY);
Matrix_Scale(this->effects[i].scale * scaleAlpha, this->effects[i].scale * scaleAlpha,
this->effects[i].scale * scaleAlpha, MTXMODE_APPLY);
// adjust transparency of this particle
if (i < 32) {
// Skyfish particles
if (this->particles[i].state != DEMO_KANKYO_STATE_SKYFISH) {
if (this->effects[i].state != DEMO_KANKYO_STATE_SKYFISH) {
// still initializing
if (this->particles[i].alpha > 0) { // NOT DECR
this->particles[i].alpha--;
if (this->effects[i].alpha > 0) { // NOT DECR
this->effects[i].alpha--;
}
} else if (this->particles[i].alpha < 100) {
this->particles[i].alpha++;
} else if (this->effects[i].alpha < 100) {
this->effects[i].alpha++;
}
} else if (this->particles[i].state != DEMO_KANKYO_STATE_SKYFISH) {
if ((this->particles[i].alphaClock & 31) < 16) {
if (this->particles[i].alpha < 235) {
this->particles[i].alpha += 20;
} else if (this->effects[i].state != DEMO_KANKYO_STATE_SKYFISH) {
if ((this->effects[i].alphaClock & 31) < 16) {
if (this->effects[i].alpha < 235) {
this->effects[i].alpha += 20;
}
} else if (this->particles[i].alpha > 20) {
this->particles[i].alpha -= 20;
} else if (this->effects[i].alpha > 20) {
this->effects[i].alpha -= 20;
}
} else if ((this->particles[i].alphaClock & 15) < 8) {
if (this->particles[i].alpha < 255) {
this->particles[i].alpha += 100;
} else if ((this->effects[i].alphaClock & 15) < 8) {
if (this->effects[i].alpha < 255) {
this->effects[i].alpha += 100;
}
} else if (this->particles[i].alpha > 10) {
this->particles[i].alpha -= 10;
} else if (this->effects[i].alpha > 10) {
this->effects[i].alpha -= 10;
}
gDPPipeSync(POLY_XLU_DISP++);
switch (i & 1) {
case 0: // gold particles
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 155, this->particles[i].alpha);
gDPSetEnvColor(POLY_XLU_DISP++, 250, 180, 0, this->particles[i].alpha);
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 155, this->effects[i].alpha);
gDPSetEnvColor(POLY_XLU_DISP++, 250, 180, 0, this->effects[i].alpha);
break;
case 1: // silver particles
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 255, this->particles[i].alpha);
gDPSetEnvColor(POLY_XLU_DISP++, 0, 100, 255, this->particles[i].alpha);
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 255, this->effects[i].alpha);
gDPSetEnvColor(POLY_XLU_DISP++, 0, 100, 255, this->effects[i].alpha);
break;
}
@@ -613,42 +600,42 @@ void DemoKankyo_DrawMoonAndGiant(Actor* thisx, GlobalContext* globalCtx2) {
func_8012C2DC(gfxCtx);
for (i = 0; i < globalCtx->envCtx.unk_F2[3]; i++) {
worldPos.x = this->particles[i].posBase.x + this->particles[i].posOffset.x;
worldPos.y = this->particles[i].posBase.y + this->particles[i].posOffset.y;
worldPos.z = this->particles[i].posBase.z + this->particles[i].posOffset.z;
worldPos.x = this->effects[i].posBase.x + this->effects[i].posOffset.x;
worldPos.y = this->effects[i].posBase.y + this->effects[i].posOffset.y;
worldPos.z = this->effects[i].posBase.z + this->effects[i].posOffset.z;
func_80169474(globalCtx, &worldPos, &screenPos); // unnamed Play_ function, func_800C016C from OoT
// checking if particle is on screen
// checking if effect is on screen
if (screenPos.x >= 0.0f && screenPos.x < SCREEN_WIDTH && screenPos.y >= 0.0f &&
screenPos.y < SCREEN_HEIGHT) {
Matrix_Translate(worldPos.x, worldPos.y, worldPos.z, MTXMODE_NEW);
alphaScale = this->particles[i].alpha / 50.0f;
alphaScale = this->effects[i].alpha / 50.0f;
if (alphaScale > 1.0f) {
alphaScale = 1.0f;
}
Matrix_Scale(this->particles[i].scale * alphaScale, this->particles[i].scale * alphaScale,
this->particles[i].scale * alphaScale, MTXMODE_APPLY);
Matrix_Scale(this->effects[i].scale * alphaScale, this->effects[i].scale * alphaScale,
this->effects[i].scale * alphaScale, MTXMODE_APPLY);
alphaScale = Math_Vec3f_DistXYZ(&worldPos, &globalCtx->view.eye) / 300.0f;
alphaScale = CLAMP(1.0f - alphaScale, 0.0f, 1.0f);
if (this->actor.params == DEMO_KANKYO_TYPE_GIANTS) {
this->particles[i].alpha = 255.0f * alphaScale;
this->effects[i].alpha = 255.0f * alphaScale;
} else {
this->particles[i].alpha = 160.0f * alphaScale;
this->effects[i].alpha = 160.0f * alphaScale;
}
gDPPipeSync(POLY_XLU_DISP++);
switch (i & 1) { // half/half slightly different shades of yellow/tan
case 0:
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 230, 230, 220, this->particles[i].alpha);
gDPSetEnvColor(POLY_XLU_DISP++, 230, 230, 30, this->particles[i].alpha);
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 230, 230, 220, this->effects[i].alpha);
gDPSetEnvColor(POLY_XLU_DISP++, 230, 230, 30, this->effects[i].alpha);
break;
case 1:
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 200, 200, 190, this->particles[i].alpha);
gDPSetEnvColor(POLY_XLU_DISP++, 200, 200, 30, this->particles[i].alpha);
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 200, 200, 190, this->effects[i].alpha);
gDPSetEnvColor(POLY_XLU_DISP++, 200, 200, 30, this->effects[i].alpha);
break;
}
src/overlays/actors/ovl_Demo_Kankyo/z_demo_kankyo.h
+4 -4
View File
@@ -18,18 +18,18 @@ typedef struct {
/* 0x03C */ u16 alphaClock;
/* 0x03E */ u16 LostWoodsSkyFishSpeedXZClock;
/* 0x040 */ u8 alpha;
/* 0x044 */ f32 scale; // size of the particle
/* 0x044 */ f32 scale; // size of the effect
/* 0x048 */ u16 LostWoodsSkyFishSpeedXZ; // the x-z speed (angular velocity) the lost woods skyfish oscillates around player. pos or neg 200-400
/* 0x04A */ u16 LostWoodsSkyFishPosOffsetMax; // The x-z range the lost woods skyfish oscillates around player. random value between 15-65
/* 0x04C */ f32 LostWoodsSkyFishSpeedY; // the y speed (angular velocity) the lost woods skyfish oscillates around player.
/* 0x050 */ u16 pad50; // unused, always assigned to 0, nothing else in this actor uses it
} DemoKankyoParticle; // size = 0x54
} DemoKankyoEffect; // size = 0x54
#define DEMOKANKYO_PARTICLE_COUNT 64
#define DEMOKANKYO_EFFECT_COUNT 64
typedef struct DemoKankyo {
/* 0x0000 */ Actor actor;
/* 0x0144 */ DemoKankyoParticle particles[DEMOKANKYO_PARTICLE_COUNT];
/* 0x0144 */ DemoKankyoEffect effects[DEMOKANKYO_EFFECT_COUNT];
/* 0x1644 */ DemoKankyoActionFunc actionFunc;
/* 0x1648 */ s32 objectId;
/* 0x164C */ u8 isSafeToDrawGiants;
src/overlays/actors/ovl_En_Baguo/z_en_baguo.c
+54 -56
View File
@@ -22,10 +22,9 @@ void EnBaguo_Roll(EnBaguo* this, GlobalContext* globalCtx);
void EnBaguo_SetupRetreatUnderground(EnBaguo* this);
void EnBaguo_RetreatUnderground(EnBaguo* this, GlobalContext* globalCtx);
void EnBaguo_DrawBody(Actor* thisx, GlobalContext* globalCtx);
void EnBaguo_InitializeParticle(EnBaguo* this, Vec3f* position, Vec3f* velocity, Vec3f* acceleration, f32 scale,
s16 timer);
void EnBaguo_UpdateParticles(EnBaguo* this, GlobalContext* globalCtx);
void EnBaguo_DrawRockParticles(EnBaguo* this, GlobalContext* globalCtx);
void EnBaguo_InitializeEffect(EnBaguo* this, Vec3f* pos, Vec3f* velocity, Vec3f* accel, f32 scale, s16 timer);
void EnBaguo_UpdateEffects(EnBaguo* this, GlobalContext* globalCtx);
void EnBaguo_DrawEffects(EnBaguo* this, GlobalContext* globalCtx);
typedef enum {
/* 0x0 */ NEJIRON_ACTION_INACTIVE, // The Nejiron is either underground or emerging from underground
@@ -311,7 +310,7 @@ void EnBaguo_PostDetonation(EnBaguo* this, GlobalContext* globalCtx) {
void EnBaguo_CheckForDetonation(EnBaguo* this, GlobalContext* globalCtx) {
Vec3f velocity = { 0.0f, 0.0f, 0.0f };
Vec3f acceleration = { 0.0f, 0.0f, 0.0f };
Vec3f accel = { 0.0f, 0.0f, 0.0f };
s32 i;
// In order to match, this variable must act as both a boolean to check if
@@ -335,15 +334,15 @@ void EnBaguo_CheckForDetonation(EnBaguo* this, GlobalContext* globalCtx) {
this->actor.speedXZ = 0.0f;
this->actor.shape.shadowScale = 0.0f;
for (i = 0; i < ARRAY_COUNT(this->particles); i++) {
acceleration.x = (Rand_ZeroOne() - 0.5f) * 8.0f;
acceleration.y = -1.0f;
acceleration.z = (Rand_ZeroOne() - 0.5f) * 8.0f;
for (i = 0; i < ARRAY_COUNT(this->effects); i++) {
accel.x = (Rand_ZeroOne() - 0.5f) * 8.0f;
accel.y = -1.0f;
accel.z = (Rand_ZeroOne() - 0.5f) * 8.0f;
velocity.x = (Rand_ZeroOne() - 0.5f) * 14.0f;
velocity.y = Rand_ZeroOne() * 30.0f;
velocity.z = (Rand_ZeroOne() - 0.5f) * 14.0f;
EnBaguo_InitializeParticle(this, &this->actor.focus.pos, &velocity, &acceleration,
(Rand_ZeroFloat(1.0f) * 0.01f) + 0.003f, 90);
EnBaguo_InitializeEffect(this, &this->actor.focus.pos, &velocity, &accel,
(Rand_ZeroFloat(1.0f) * 0.01f) + 0.003f, 90);
}
Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_CLEAR_TAG, this->actor.world.pos.x,
@@ -368,7 +367,7 @@ void EnBaguo_Update(Actor* thisx, GlobalContext* globalCtx) {
EnBaguo* this = THIS;
Actor_SetFocus(&this->actor, 30.0f);
EnBaguo_UpdateParticles(this, globalCtx);
EnBaguo_UpdateEffects(this, globalCtx);
EnBaguo_CheckForDetonation(this, globalCtx);
this->actionFunc(this, globalCtx);
@@ -432,77 +431,76 @@ void EnBaguo_DrawBody(Actor* thisx, GlobalContext* globalCtx) {
CLOSE_DISPS(globalCtx->state.gfxCtx);
EnBaguo_DrawRockParticles(this, globalCtx);
EnBaguo_DrawEffects(this, globalCtx);
}
void EnBaguo_InitializeParticle(EnBaguo* this, Vec3f* position, Vec3f* velocity, Vec3f* acceleration, f32 scale,
s16 timer) {
void EnBaguo_InitializeEffect(EnBaguo* this, Vec3f* pos, Vec3f* velocity, Vec3f* accel, f32 scale, s16 timer) {
s16 i;
NejironParticle* particle = this->particles;
NejironEffect* effect = this->effects;
for (i = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
if (!particle->isVisible) {
particle->isVisible = true;
particle->position = *position;
particle->velocity = *velocity;
particle->acceleration = *acceleration;
particle->scale = scale;
particle->timer = timer;
particle->rotation.x = (s16)randPlusMinusPoint5Scaled(30000.0f);
particle->rotation.y = (s16)randPlusMinusPoint5Scaled(30000.0f);
particle->rotation.z = (s16)randPlusMinusPoint5Scaled(30000.0f);
for (i = 0; i < ARRAY_COUNT(this->effects); i++, effect++) {
if (!effect->isEnabled) {
effect->isEnabled = true;
effect->pos = *pos;
effect->velocity = *velocity;
effect->accel = *accel;
effect->scale = scale;
effect->timer = timer;
effect->rotation.x = (s16)randPlusMinusPoint5Scaled(30000.0f);
effect->rotation.y = (s16)randPlusMinusPoint5Scaled(30000.0f);
effect->rotation.z = (s16)randPlusMinusPoint5Scaled(30000.0f);
return;
}
}
}
void EnBaguo_UpdateParticles(EnBaguo* this, GlobalContext* globalCtx) {
void EnBaguo_UpdateEffects(EnBaguo* this, GlobalContext* globalCtx) {
s32 i;
NejironParticle* particle = this->particles;
NejironEffect* effect = this->effects;
for (i = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
if (particle->isVisible) {
particle->position.x += particle->velocity.x;
particle->position.y += particle->velocity.y;
particle->position.z += particle->velocity.z;
particle->rotation.x += 0xBB8;
particle->rotation.y += 0xBB8;
particle->rotation.z += 0xBB8;
particle->velocity.x += particle->acceleration.x;
particle->velocity.y += particle->acceleration.y;
particle->velocity.z += particle->acceleration.z;
for (i = 0; i < ARRAY_COUNT(this->effects); i++, effect++) {
if (effect->isEnabled) {
effect->pos.x += effect->velocity.x;
effect->pos.y += effect->velocity.y;
effect->pos.z += effect->velocity.z;
effect->rotation.x += 0xBB8;
effect->rotation.y += 0xBB8;
effect->rotation.z += 0xBB8;
effect->velocity.x += effect->accel.x;
effect->velocity.y += effect->accel.y;
effect->velocity.z += effect->accel.z;
if (particle->position.y < (this->actor.world.pos.y - 10.0f)) {
Math_ApproachZeroF(&particle->scale, 0.2f, 0.001f);
if (particle->scale <= 0.0001f) {
particle->timer = 0;
if (effect->pos.y < (this->actor.world.pos.y - 10.0f)) {
Math_ApproachZeroF(&effect->scale, 0.2f, 0.001f);
if (effect->scale <= 0.0001f) {
effect->timer = 0;
}
}
if (particle->timer != 0) {
particle->timer--;
if (effect->timer != 0) {
effect->timer--;
} else {
particle->isVisible = false;
effect->isEnabled = false;
}
}
}
}
void EnBaguo_DrawRockParticles(EnBaguo* this, GlobalContext* globalCtx) {
void EnBaguo_DrawEffects(EnBaguo* this, GlobalContext* globalCtx) {
s16 i;
NejironParticle* particle = this->particles;
NejironEffect* effect = this->effects;
GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
OPEN_DISPS(gfxCtx);
func_8012C28C(globalCtx->state.gfxCtx);
for (i = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
if (particle->isVisible) {
Matrix_Translate(particle->position.x, particle->position.y, particle->position.z, MTXMODE_NEW);
Matrix_RotateXS(particle->rotation.x, MTXMODE_APPLY);
Matrix_RotateYS(particle->rotation.y, MTXMODE_APPLY);
Matrix_RotateZS(particle->rotation.z, MTXMODE_APPLY);
Matrix_Scale(particle->scale, particle->scale, particle->scale, MTXMODE_APPLY);
for (i = 0; i < ARRAY_COUNT(this->effects); i++, effect++) {
if (effect->isEnabled) {
Matrix_Translate(effect->pos.x, effect->pos.y, effect->pos.z, MTXMODE_NEW);
Matrix_RotateXS(effect->rotation.x, MTXMODE_APPLY);
Matrix_RotateYS(effect->rotation.y, MTXMODE_APPLY);
Matrix_RotateZS(effect->rotation.z, MTXMODE_APPLY);
Matrix_Scale(effect->scale, effect->scale, effect->scale, MTXMODE_APPLY);
gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gDPSetPrimColor(POLY_OPA_DISP++, 0, 1, 255, 255, 255, 255);
src/overlays/actors/ovl_En_Baguo/z_en_baguo.h
+8 -6
View File
@@ -12,15 +12,17 @@ typedef void (*EnBaguoActionFunc)(struct EnBaguo*, GlobalContext*);
* When a Nejiron explodes, rock particles fly out from where it exploded.
* This struct governs how these rock particles behave.
*/
typedef struct NejironParticle {
/* 0x00 */ u8 isVisible;
/* 0x04 */ Vec3f position;
typedef struct NejironEffect {
/* 0x00 */ u8 isEnabled;
/* 0x04 */ Vec3f pos;
/* 0x10 */ Vec3f velocity;
/* 0x1C */ Vec3f acceleration;
/* 0x1C */ Vec3f accel;
/* 0x28 */ Vec3s rotation;
/* 0x30 */ f32 scale;
/* 0x34 */ s16 timer;
} NejironParticle; // size = 0x38
} NejironEffect; // size = 0x38
#define EN_BAGUO_EFFECT_COUNT 30
typedef struct EnBaguo {
/* 0x000 */ Actor actor;
@@ -39,7 +41,7 @@ typedef struct EnBaguo {
/* 0x1D0 */ Vec3f targetRotation;
/* 0x1DC */ ColliderJntSph collider;
/* 0x1FC */ ColliderJntSphElement colliderElements[1];
/* 0x23C */ NejironParticle particles[30];
/* 0x23C */ NejironEffect effects[EN_BAGUO_EFFECT_COUNT];
} EnBaguo; // size = 0x8CC
extern const ActorInit En_Baguo_InitVars;
src/overlays/actors/ovl_En_Bigslime/z_en_bigslime.c
+16 -16
View File
@@ -2700,10 +2700,10 @@ void EnBigslime_AddIceShardEffect(EnBigslime* this, GlobalContext* globalCtx) {
iceShardEffect->pos.x = (targetVtx->n.ob[0] * this->actor.scale.x) + this->actor.world.pos.x;
iceShardEffect->pos.y = (targetVtx->n.ob[1] * this->actor.scale.y) + this->actor.world.pos.y;
iceShardEffect->pos.z = (targetVtx->n.ob[2] * this->actor.scale.z) + this->actor.world.pos.z;
iceShardEffect->rotation.x = (s32)Rand_Next() >> 0x10;
iceShardEffect->rotation.y = (s32)Rand_Next() >> 0x10;
iceShardEffect->rotation.z = (s32)Rand_Next() >> 0x10;
iceShardEffect->isActive = true;
iceShardEffect->rot.x = (s32)Rand_Next() >> 0x10;
iceShardEffect->rot.y = (s32)Rand_Next() >> 0x10;
iceShardEffect->rot.z = (s32)Rand_Next() >> 0x10;
iceShardEffect->isEnabled = true;
randPitch = Rand_S16Offset(0x1000, 0x3000);
vtxZ = targetVtx->n.ob[2];
vtxX = targetVtx->n.ob[0];
@@ -2715,9 +2715,9 @@ void EnBigslime_AddIceShardEffect(EnBigslime* this, GlobalContext* globalCtx) {
xzDist = Math_CosS(randPitch) * randFloat;
}
iceShardEffect->vel.x = targetVtx->n.ob[0] * xzDist;
iceShardEffect->vel.y = Math_SinS(randPitch) * randFloat;
iceShardEffect->vel.z = targetVtx->n.ob[2] * xzDist;
iceShardEffect->velocity.x = targetVtx->n.ob[0] * xzDist;
iceShardEffect->velocity.y = Math_SinS(randPitch) * randFloat;
iceShardEffect->velocity.z = targetVtx->n.ob[2] * xzDist;
iceShardEffect->scale = 0.001f * (Rand_ZeroFloat(6.0f) + 2.0f);
}
}
@@ -2736,15 +2736,15 @@ void EnBigslime_UpdateEffects(EnBigslime* this) {
// Update ice shards
for (i = 0; i < BIGSLIME_NUM_ICE_SHARD; i++) {
iceShardEffect = &this->iceShardEffect[i];
if (iceShardEffect->isActive > false) {
iceShardEffect->vel.y += -1.0f;
Math_Vec3f_Sum(&iceShardEffect->pos, &iceShardEffect->vel, &iceShardEffect->pos);
if (iceShardEffect->isEnabled > false) {
iceShardEffect->velocity.y += -1.0f;
Math_Vec3f_Sum(&iceShardEffect->pos, &iceShardEffect->velocity, &iceShardEffect->pos);
if (iceShardEffect->pos.y < (GBT_ROOM_5_MIN_Y - 20.0f)) {
iceShardEffect->isActive = false;
iceShardEffect->isEnabled = false;
}
iceShardEffect->rotation.x += (s16)((Rand_Next() >> 0x17) + 0x700);
iceShardEffect->rotation.y += (s16)((Rand_Next() >> 0x17) + 0x900);
iceShardEffect->rotation.z += (s16)((Rand_Next() >> 0x17) + 0xB00);
iceShardEffect->rot.x += (s16)((Rand_Next() >> 0x17) + 0x700);
iceShardEffect->rot.y += (s16)((Rand_Next() >> 0x17) + 0x900);
iceShardEffect->rot.z += (s16)((Rand_Next() >> 0x17) + 0xB00);
}
}
@@ -3143,9 +3143,9 @@ void EnBigslime_DrawShatteringEffects(EnBigslime* this, GlobalContext* globalCtx
for (i = 0; i < BIGSLIME_NUM_ICE_SHARD; i++) {
iceShardEffect = &this->iceShardEffect[i];
if (iceShardEffect->isActive > false) {
if (iceShardEffect->isEnabled > false) {
Matrix_SetTranslateRotateYXZ(iceShardEffect->pos.x, iceShardEffect->pos.y, iceShardEffect->pos.z,
&iceShardEffect->rotation);
&iceShardEffect->rot);
Matrix_Scale(iceShardEffect->scale, iceShardEffect->scale, iceShardEffect->scale, MTXMODE_APPLY);
gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
src/overlays/actors/ovl_En_Bigslime/z_en_bigslime.h
+3 -3
View File
@@ -42,9 +42,9 @@ typedef struct {
typedef struct {
/* 0x00 */ Vec3f pos;
/* 0x0C */ Vec3f vel;
/* 0x18 */ s16 isActive;
/* 0x1A */ Vec3s rotation;
/* 0x0C */ Vec3f velocity;
/* 0x18 */ s16 isEnabled;
/* 0x1A */ Vec3s rot;
/* 0x20 */ f32 scale;
} EnBigslimeIceShardEffect; // size = 0x24
src/overlays/actors/ovl_En_Clear_Tag/z_en_clear_tag.c
+48 -50
View File
@@ -114,7 +114,7 @@ static TexturePtr sWaterSplashTextures[] = {
* Creates a debris effect.
* Debris effects are spawned by an explosion.
*/
void EnClearTag_CreateDebrisEffect(EnClearTag* this, Vec3f* position, Vec3f* velocity, Vec3f* acceleration, f32 scale,
void EnClearTag_CreateDebrisEffect(EnClearTag* this, Vec3f* pos, Vec3f* velocity, Vec3f* accel, f32 scale,
f32 rotationZ) {
EnClearTagEffect* effect = this->effect;
s16 i;
@@ -124,9 +124,9 @@ void EnClearTag_CreateDebrisEffect(EnClearTag* this, Vec3f* position, Vec3f* vel
if (effect->type == CLEAR_TAG_EFFECT_AVAILABLE) {
effect->type = CLEAR_TAG_EFFECT_DEBRIS;
effect->position = *position;
effect->pos = *pos;
effect->velocity = *velocity;
effect->acceleration = *acceleration;
effect->accel = *accel;
effect->scale = scale;
@@ -149,7 +149,7 @@ void EnClearTag_CreateDebrisEffect(EnClearTag* this, Vec3f* position, Vec3f* vel
* Creates a smoke effect.
* Smoke effects are spawned by an explosion.
*/
void EnClearTag_CreateSmokeEffect(EnClearTag* this, Vec3f* position, f32 scale) {
void EnClearTag_CreateSmokeEffect(EnClearTag* this, Vec3f* pos, f32 scale) {
s16 i;
EnClearTagEffect* effect = this->effect;
@@ -159,9 +159,9 @@ void EnClearTag_CreateSmokeEffect(EnClearTag* this, Vec3f* position, f32 scale)
effect->actionTimer = Rand_ZeroFloat(100.0f);
effect->type = CLEAR_TAG_EFFECT_SMOKE;
effect->position = *position;
effect->pos = *pos;
effect->velocity = sZeroVector;
effect->acceleration = sZeroVector;
effect->accel = sZeroVector;
effect->scale = scale;
effect->maxScale = 2.0f * scale;
@@ -185,7 +185,7 @@ void EnClearTag_CreateSmokeEffect(EnClearTag* this, Vec3f* position, f32 scale)
* Creates an isolated smoke effect without an explosion.
* Smoke effects are spawned directly.
*/
void EnClearTag_CreateIsolatedSmokeEffect(EnClearTag* this, Vec3f* position, f32 scale) {
void EnClearTag_CreateIsolatedSmokeEffect(EnClearTag* this, Vec3f* pos, f32 scale) {
s16 i;
EnClearTagEffect* effect = this->effect;
@@ -195,9 +195,9 @@ void EnClearTag_CreateIsolatedSmokeEffect(EnClearTag* this, Vec3f* position, f32
effect->actionTimer = Rand_ZeroFloat(100.0f);
effect->type = CLEAR_TAG_EFFECT_ISOLATED_SMOKE;
effect->position = *position;
effect->pos = *pos;
effect->velocity = sZeroVector;
effect->acceleration = sZeroVector;
effect->accel = sZeroVector;
effect->scale = scale;
effect->maxScale = 2.0f * scale;
@@ -229,7 +229,7 @@ void EnClearTag_CreateIsolatedSmokeEffect(EnClearTag* this, Vec3f* position, f32
* Flash effects are spawned by an explosion or a pop.
* Flash effects have two components: 1) a billboard flash, and 2) a light effect on the ground.
*/
void EnClearTag_CreateFlashEffect(EnClearTag* this, Vec3f* position, f32 scale, f32 floorHeight) {
void EnClearTag_CreateFlashEffect(EnClearTag* this, Vec3f* pos, f32 scale, f32 floorHeight) {
EnClearTagEffect* effect = this->effect;
s16 i;
@@ -238,9 +238,9 @@ void EnClearTag_CreateFlashEffect(EnClearTag* this, Vec3f* position, f32 scale,
if (effect->type == CLEAR_TAG_EFFECT_AVAILABLE) {
effect->type = CLEAR_TAG_EFFECT_FLASH;
effect->position = *position;
effect->pos = *pos;
effect->velocity = sZeroVector;
effect->acceleration = sZeroVector;
effect->accel = sZeroVector;
effect->scale = 0.0f;
effect->maxScale = scale * 3.0f;
@@ -259,7 +259,7 @@ void EnClearTag_CreateFlashEffect(EnClearTag* this, Vec3f* position, f32 scale,
* Creates a light ray effect.
* Light ray effects are spawned by an explosion or pop.
*/
void EnClearTag_CreateLightRayEffect(EnClearTag* this, Vec3f* position, Vec3f* velocity, Vec3f* acceleration, f32 scale,
void EnClearTag_CreateLightRayEffect(EnClearTag* this, Vec3f* pos, Vec3f* velocity, Vec3f* accel, f32 scale,
f32 maxScaleTarget, s16 alphaDecrementSpeed) {
EnClearTagEffect* effect = this->effect;
s16 i;
@@ -271,9 +271,9 @@ void EnClearTag_CreateLightRayEffect(EnClearTag* this, Vec3f* position, Vec3f* v
effect->type = CLEAR_TAG_EFFECT_LIGHT_RAYS;
effect->position = *position;
effect->pos = *pos;
effect->velocity = *velocity;
effect->acceleration = *acceleration;
effect->accel = *accel;
effect->scale = scale / 1000.0f;
effect->maxScale = 1.0f;
@@ -303,8 +303,8 @@ void EnClearTag_CreateLightRayEffect(EnClearTag* this, Vec3f* position, Vec3f* v
* Creates an isolated light ray effect without an explosion or pop.
* Light ray effects are spawned directly.
*/
void EnClearTag_CreateIsolatedLightRayEffect(EnClearTag* this, Vec3f* position, Vec3f* velocity, Vec3f* acceleration,
f32 scale, f32 maxScaleTarget, s16 colorIndex, s16 alphaDecrementSpeed) {
void EnClearTag_CreateIsolatedLightRayEffect(EnClearTag* this, Vec3f* pos, Vec3f* velocity, Vec3f* accel, f32 scale,
f32 maxScaleTarget, s16 colorIndex, s16 alphaDecrementSpeed) {
EnClearTagEffect* effect = this->effect;
s16 i;
@@ -313,9 +313,9 @@ void EnClearTag_CreateIsolatedLightRayEffect(EnClearTag* this, Vec3f* position,
if (effect->type == CLEAR_TAG_EFFECT_AVAILABLE) {
effect->type = CLEAR_TAG_EFFECT_LIGHT_RAYS;
effect->position = *position;
effect->pos = *pos;
effect->velocity = *velocity;
effect->acceleration = *acceleration;
effect->accel = *accel;
effect->scale = scale / 1000.0f;
effect->maxScale = 1.0f;
@@ -345,7 +345,7 @@ void EnClearTag_CreateIsolatedLightRayEffect(EnClearTag* this, Vec3f* position,
* Creates a shockwave effect
* This effect uses concentric ring floor shadows that travel radially outward along the floor poly
*/
void EnClearTag_CreateShockwaveEffect(EnClearTag* this, Vec3f* position, f32 maxScale, s16 actionTimer) {
void EnClearTag_CreateShockwaveEffect(EnClearTag* this, Vec3f* pos, f32 maxScale, s16 actionTimer) {
EnClearTagEffect* effect = this->effect;
s16 i;
@@ -354,9 +354,9 @@ void EnClearTag_CreateShockwaveEffect(EnClearTag* this, Vec3f* position, f32 max
if (effect->type == CLEAR_TAG_EFFECT_AVAILABLE) {
effect->type = CLEAR_TAG_EFFECT_SHOCKWAVE;
effect->position = *position;
effect->pos = *pos;
effect->velocity = sZeroVector;
effect->acceleration = sZeroVector;
effect->accel = sZeroVector;
effect->maxScale = maxScale;
effect->scale = 0.0f;
@@ -374,7 +374,7 @@ void EnClearTag_CreateShockwaveEffect(EnClearTag* this, Vec3f* position, f32 max
* Creates a splash effect
* This effect is used when EnClearTag is spawned above a waterbox
*/
void EnClearTag_CreateSplashEffect(EnClearTag* this, Vec3f* position, s16 effectsTimer) {
void EnClearTag_CreateSplashEffect(EnClearTag* this, Vec3f* pos, s16 effectsTimer) {
s16 i;
EnClearTagEffect* effect = this->effect;
@@ -385,9 +385,9 @@ void EnClearTag_CreateSplashEffect(EnClearTag* this, Vec3f* position, s16 effect
effect->actionTimer = Rand_ZeroFloat(100.0f);
effect->type = CLEAR_TAG_EFFECT_SPLASH;
effect->position = *position;
effect->pos = *pos;
effect->velocity = sZeroVector;
effect->acceleration = sZeroVector;
effect->accel = sZeroVector;
effect->scale = 0.0f;
effect->maxScale = 0.0f;
@@ -645,13 +645,13 @@ void EnClearTag_UpdateEffects(EnClearTag* this, GlobalContext* globalCtx) {
effect->actionTimer++;
// Perform effect physics.
effect->position.x += effect->velocity.x;
originalYPosition = effect->position.y;
effect->position.y += effect->velocity.y;
effect->position.z += effect->velocity.z;
effect->velocity.x += effect->acceleration.x;
effect->velocity.y += effect->acceleration.y;
effect->velocity.z += effect->acceleration.z;
effect->pos.x += effect->velocity.x;
originalYPosition = effect->pos.y;
effect->pos.y += effect->velocity.y;
effect->pos.z += effect->velocity.z;
effect->velocity.x += effect->accel.x;
effect->velocity.y += effect->accel.y;
effect->velocity.z += effect->accel.z;
if (effect->type == CLEAR_TAG_EFFECT_DEBRIS) {
// Clamp the velocity to -5.0
@@ -661,12 +661,12 @@ void EnClearTag_UpdateEffects(EnClearTag* this, GlobalContext* globalCtx) {
// While the effect is falling check if it has hit the ground.
if (effect->velocity.y < 0.0f) {
sphereCenter = effect->position;
sphereCenter = effect->pos;
sphereCenter.y += 5.0f;
// Check if the debris has hit the ground.
if (BgCheck_SphVsFirstPoly(&globalCtx->colCtx, &sphereCenter, 11.0f)) {
effect->position.y = originalYPosition;
effect->pos.y = originalYPosition;
// Bounce the debris effect.
if (effect->bounces <= 0) {
@@ -675,14 +675,13 @@ void EnClearTag_UpdateEffects(EnClearTag* this, GlobalContext* globalCtx) {
effect->effectsTimer = Rand_ZeroFloat(20.0f) + 25.0f;
} else {
// The Debris effect is done bouncing. Set its velocity and acceleration to 0.
effect->velocity.x = effect->velocity.z = effect->acceleration.y = effect->velocity.y =
0.0f;
effect->velocity.x = effect->velocity.z = effect->accel.y = effect->velocity.y = 0.0f;
}
}
}
// Rotate the debris effect.
if (effect->acceleration.y != 0.0f) {
if (effect->accel.y != 0.0f) {
effect->rotationY += 0.5f;
effect->rotationX += 0.35f;
}
@@ -821,7 +820,7 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
}
// Draw the debris effect.
Matrix_Translate(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
Matrix_Translate(effect->pos.x, effect->pos.y, effect->pos.z, MTXMODE_NEW);
Matrix_Scale(effect->scale, effect->scale, effect->scale, MTXMODE_APPLY);
Matrix_RotateYF(effect->rotationY, MTXMODE_APPLY);
Matrix_RotateXFApply(effect->rotationX);
@@ -839,7 +838,7 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
gDPPipeSync(POLY_XLU_DISP++);
gDPSetEnvColor(POLY_XLU_DISP++, 255, 255, 255, (s8)effect->primColor.a);
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 255, (s8)effect->primColor.a);
func_800C0094(this->actor.floorPoly, effect->position.x, effect->position.y, effect->position.z, &mtxF);
func_800C0094(this->actor.floorPoly, effect->pos.x, effect->pos.y, effect->pos.z, &mtxF);
Matrix_Put(&mtxF);
Matrix_Scale(effect->scale, 1.0f, effect->scale, MTXMODE_APPLY);
gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -863,8 +862,7 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
// Draw the ground flash effect.
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 200, (s8)(effect->primColor.a * 0.7f));
func_800C0094(this->actor.floorPoly, effect->position.x, this->actor.floorHeight, effect->position.z,
&mtxF);
func_800C0094(this->actor.floorPoly, effect->pos.x, this->actor.floorHeight, effect->pos.z, &mtxF);
Matrix_Put(&mtxF);
Matrix_Scale(effect->scale * 3.0f, 1.0f, effect->scale * 3.0f, MTXMODE_APPLY);
gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -893,7 +891,7 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
gSPSegment(
POLY_XLU_DISP++, 0x08,
Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, -effect->actionTimer * 5, 32, 64, 1, 0, 0, 32, 32));
Matrix_Translate(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
Matrix_Translate(effect->pos.x, effect->pos.y, effect->pos.z, MTXMODE_NEW);
Matrix_ReplaceRotation(&globalCtx->billboardMtxF);
Matrix_Scale(effect->smokeScaleX * effect->scale, effect->smokeScaleY * effect->scale, 1.0f, MTXMODE_APPLY);
Matrix_Translate(0.0f, 20.0f, 0.0f, MTXMODE_APPLY);
@@ -919,7 +917,7 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
gSPSegment(
POLY_XLU_DISP++, 0x08,
Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, -effect->actionTimer * 15, 32, 64, 1, 0, 0, 32, 32));
Matrix_Translate(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
Matrix_Translate(effect->pos.x, effect->pos.y, effect->pos.z, MTXMODE_NEW);
Matrix_ReplaceRotation(&globalCtx->billboardMtxF);
Matrix_Scale(effect->scale, effect->scale, 1.0f, MTXMODE_APPLY);
gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -941,7 +939,7 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
// Draw the flash billboard effect.
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 200, (s8)effect->primColor.a);
Matrix_Translate(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
Matrix_Translate(effect->pos.x, effect->pos.y, effect->pos.z, MTXMODE_NEW);
Matrix_ReplaceRotation(&globalCtx->billboardMtxF);
Matrix_Scale(2.0f * effect->scale, 2.0f * effect->scale, 1.0f, MTXMODE_APPLY);
gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -966,7 +964,7 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
// Draw the light ray effect.
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, (u8)effect->primColor.r, (u8)effect->primColor.g,
(u8)effect->primColor.b, (u8)effect->primColor.a);
Matrix_Translate(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
Matrix_Translate(effect->pos.x, effect->pos.y, effect->pos.z, MTXMODE_NEW);
Matrix_RotateYF(effect->rotationY, MTXMODE_APPLY);
Matrix_RotateXFApply(effect->rotationX);
Matrix_RotateZF(effect->rotationZ, MTXMODE_APPLY);
@@ -998,12 +996,12 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
* returns true if point is within the xz boundaries of an active water box, else false
* `ySurface` returns the water box's surface, while `outWaterBox` returns a pointer to the WaterBox
*/
ySurface = effect->position.y;
if (WaterBox_GetSurface1(globalCtx, &globalCtx->colCtx, effect->position.x + vec.x,
effect->position.z + vec.z, &ySurface, &waterBox)) {
if ((effect->position.y - ySurface) < 200.0f) {
ySurface = effect->pos.y;
if (WaterBox_GetSurface1(globalCtx, &globalCtx->colCtx, effect->pos.x + vec.x, effect->pos.z + vec.z,
&ySurface, &waterBox)) {
if ((effect->pos.y - ySurface) < 200.0f) {
// Draw the splash effect.
Matrix_Translate(effect->position.x + vec.x, ySurface, effect->position.z + vec.z, MTXMODE_NEW);
Matrix_Translate(effect->pos.x + vec.x, ySurface, effect->pos.z + vec.z, MTXMODE_NEW);
Matrix_RotateYF(2.0f * (j * M_PI) * (1.0f / 16.0f), MTXMODE_APPLY);
Matrix_RotateXFApply(effect->rotationX);
Matrix_Scale(effect->scale, effect->scale, effect->scale, MTXMODE_APPLY);
src/overlays/actors/ovl_En_Clear_Tag/z_en_clear_tag.h
+5 -3
View File
@@ -8,9 +8,9 @@ struct EnClearTag;
typedef struct EnClearTagEffect {
/* 0x00 */ u8 type;
/* 0x01 */ u8 actionTimer;
/* 0x04 */ Vec3f position;
/* 0x04 */ Vec3f pos;
/* 0x10 */ Vec3f velocity;
/* 0x1C */ Vec3f acceleration;
/* 0x1C */ Vec3f accel;
/* 0x28 */ Color_RGBAf primColor;
/* 0x38 */ Color_RGBAf envColor;
/* 0x48 */ s16 bounces;
@@ -27,9 +27,11 @@ typedef struct EnClearTagEffect {
/* 0x6C */ f32 smokeScaleX;
} EnClearTagEffect; // size = 0x70
#define EN_CLEAR_TAG_EFFECT_COUNT 103
typedef struct EnClearTag {
/* 0x0000 */ Actor actor;
/* 0x0144 */ EnClearTagEffect effect[103];
/* 0x0144 */ EnClearTagEffect effect[EN_CLEAR_TAG_EFFECT_COUNT];
/* 0x2E54 */ u8 cameraState;
/* 0x2E56 */ s16 activeTimer; // Actor Marked for Death when timer runs out
/* 0x2E58 */ UNK_TYPE1 unk2E58[0xC];
src/overlays/actors/ovl_En_Dai/z_en_dai.c
+35 -36
View File
@@ -33,28 +33,27 @@ const ActorInit En_Dai_InitVars = {
static Vec3f D_80B3FBF0 = { 1.0f, 1.0f, 1.0f };
EnDaiParticle* func_80B3DFF0(EnDaiParticle* particle, Vec3f arg1, Vec3f arg2, Vec3f arg3, f32 arg4, f32 arg5,
s32 arg6) {
EnDaiEffect* func_80B3DFF0(EnDaiEffect* effect, Vec3f arg1, Vec3f arg2, Vec3f arg3, f32 arg4, f32 arg5, s32 arg6) {
s32 i;
for (i = 0; i < 32; i++, particle++) {
if (!particle->isEnabled) {
particle->isEnabled = true;
particle->unk_01 = (Rand_ZeroOne() * (2.0f * (arg6 / 3.0f))) + (arg6 / 3.0f);
particle->unk_02 = particle->unk_01;
particle->unk_10 = arg1;
particle->unk_1C = arg2;
particle->unk_28 = arg3;
particle->unk_34 = arg4;
particle->unk_38 = arg5;
return particle;
for (i = 0; i < EN_DAI_EFFECT_COUNT; i++, effect++) {
if (!effect->isEnabled) {
effect->isEnabled = true;
effect->unk_01 = (Rand_ZeroOne() * (2.0f * (arg6 / 3.0f))) + (arg6 / 3.0f);
effect->unk_02 = effect->unk_01;
effect->unk_10 = arg1;
effect->unk_1C = arg2;
effect->unk_28 = arg3;
effect->unk_34 = arg4;
effect->unk_38 = arg5;
return effect;
}
}
return NULL;
}
void func_80B3E168(EnDaiParticle* particle, GlobalContext* globalCtx2) {
void func_80B3E168(EnDaiEffect* effect, GlobalContext* globalCtx2) {
GlobalContext* globalCtx = globalCtx2;
s32 pad;
s32 isDisplayListSet = false;
@@ -65,8 +64,8 @@ void func_80B3E168(EnDaiParticle* particle, GlobalContext* globalCtx2) {
func_8012C2DC(globalCtx->state.gfxCtx);
for (i = 0; i < 32; i++, particle++) {
if (particle->isEnabled == true) {
for (i = 0; i < EN_DAI_EFFECT_COUNT; i++, effect++) {
if (effect->isEnabled == true) {
gDPPipeSync(POLY_XLU_DISP++);
if (!isDisplayListSet) {
@@ -76,18 +75,18 @@ void func_80B3E168(EnDaiParticle* particle, GlobalContext* globalCtx2) {
Matrix_Push();
alpha = (particle->unk_02 / (f32)particle->unk_01);
alpha = (effect->unk_02 / (f32)effect->unk_01);
alpha *= 255.0f;
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 195, 225, 235, (u8)alpha);
gSPSegment(POLY_XLU_DISP++, 0x08,
Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, (particle->unk_02 + (i * 3)) * 3,
(particle->unk_02 + (i * 3)) * 15, 0x20, 0x40, 1, 0, 0, 0x20, 0x20));
Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, (effect->unk_02 + (i * 3)) * 3,
(effect->unk_02 + (i * 3)) * 15, 0x20, 0x40, 1, 0, 0, 0x20, 0x20));
Matrix_Translate(particle->unk_10.x, particle->unk_10.y, particle->unk_10.z, MTXMODE_NEW);
Matrix_Translate(effect->unk_10.x, effect->unk_10.y, effect->unk_10.z, MTXMODE_NEW);
Matrix_ReplaceRotation(&globalCtx->billboardMtxF);
Matrix_Scale(particle->unk_34, particle->unk_34, 1.0f, MTXMODE_APPLY);
Matrix_Scale(effect->unk_34, effect->unk_34, 1.0f, MTXMODE_APPLY);
gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -101,23 +100,23 @@ void func_80B3E168(EnDaiParticle* particle, GlobalContext* globalCtx2) {
}
s32 func_80B3E460(EnDai* this) {
EnDaiParticle* particle = &this->particles[0];
EnDaiEffect* effect = this->effects;
s32 i;
s32 count;
for (i = 0, count = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
if (particle->isEnabled && particle->unk_02) {
particle->unk_10.x += particle->unk_28.x;
particle->unk_02--;
particle->unk_10.y += particle->unk_28.y;
particle->unk_10.z += particle->unk_28.z;
particle->unk_28.x += particle->unk_1C.x;
particle->unk_28.y += particle->unk_1C.y;
particle->unk_28.z += particle->unk_1C.z;
particle->unk_34 += particle->unk_38;
for (i = 0, count = 0; i < ARRAY_COUNT(this->effects); i++, effect++) {
if (effect->isEnabled && effect->unk_02) {
effect->unk_10.x += effect->unk_28.x;
effect->unk_02--;
effect->unk_10.y += effect->unk_28.y;
effect->unk_10.z += effect->unk_28.z;
effect->unk_28.x += effect->unk_1C.x;
effect->unk_28.y += effect->unk_1C.y;
effect->unk_28.z += effect->unk_1C.z;
effect->unk_34 += effect->unk_38;
count++;
} else if (particle->isEnabled) {
particle->isEnabled = false;
} else if (effect->isEnabled) {
effect->isEnabled = false;
}
}
@@ -125,7 +124,7 @@ s32 func_80B3E460(EnDai* this) {
}
s32 func_80B3E5B4(EnDai* this, GlobalContext* globalCtx) {
func_80B3E168(this->particles, globalCtx);
func_80B3E168(this->effects, globalCtx);
return 0;
}
@@ -325,7 +324,7 @@ s32 func_80B3E96C(EnDai* this, GlobalContext* globalCtx) {
sp5C.y = -40.0f;
Lib_Vec3f_TranslateAndRotateY(&this->unk_1E4, this->unk_1D4, &sp50, &sp74);
func_80B3DFF0(this->particles, sp74, sp68, sp5C, 0.03f, 0.04f, 0x10);
func_80B3DFF0(this->effects, sp74, sp68, sp5C, 0.03f, 0.04f, 0x10);
}
return 0;
src/overlays/actors/ovl_En_Dai/z_en_dai.h
+5 -3
View File
@@ -7,7 +7,7 @@ struct EnDai;
typedef void (*EnDaiActionFunc)(struct EnDai*, GlobalContext*);
typedef struct EnDaiParticle {
typedef struct EnDaiEffect {
/* 0x00 */ u8 isEnabled;
/* 0x01 */ u8 unk_01;
/* 0x02 */ u8 unk_02;
@@ -17,7 +17,9 @@ typedef struct EnDaiParticle {
/* 0x28 */ Vec3f unk_28;
/* 0x34 */ f32 unk_34;
/* 0x38 */ f32 unk_38;
} EnDaiParticle; // size = 0x3C
} EnDaiEffect; // size = 0x3C
#define EN_DAI_EFFECT_COUNT 32
typedef struct EnDai {
/* 0x000 */ Actor actor;
@@ -39,7 +41,7 @@ typedef struct EnDai {
/* 0x1FC */ Vec3f unk_1FC;
/* 0x208 */ Vec3s jointTable[19];
/* 0x27A */ Vec3s morphTable[19];
/* 0x2EC */ EnDaiParticle particles[32];
/* 0x2EC */ EnDaiEffect effects[EN_DAI_EFFECT_COUNT];
/* 0xA6C */ s32 unk_A6C;
/* 0xA70 */ s32 unk_A70;
} EnDai; // size = 0xA74
src/overlays/actors/ovl_En_Daiku2/z_en_daiku2.c
+32 -32
View File
@@ -493,19 +493,19 @@ void EnDaiku2_Draw(Actor* thisx, GlobalContext* globalCtx) {
void func_80BE7504(EnDaiku2* this, Vec3f* arg1, Vec3f* arg2, Vec3f* arg3, f32 arg4, s16 arg5) {
s16 i;
EnDaiku2Particle* particle = &this->particles[0];
EnDaiku2Effect* effect = this->effects;
for (i = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
if (!particle->isEnabled) {
particle->isEnabled = true;
particle->unk_04 = *arg1;
particle->unk_10 = *arg2;
particle->unk_1C = *arg3;
particle->unk_30 = arg4;
particle->unk_34 = arg5;
particle->unk_28.x = randPlusMinusPoint5Scaled(30000.0f);
particle->unk_28.y = randPlusMinusPoint5Scaled(30000.0f);
particle->unk_28.z = randPlusMinusPoint5Scaled(30000.0f);
for (i = 0; i < ARRAY_COUNT(this->effects); i++, effect++) {
if (!effect->isEnabled) {
effect->isEnabled = true;
effect->unk_04 = *arg1;
effect->unk_10 = *arg2;
effect->unk_1C = *arg3;
effect->unk_30 = arg4;
effect->unk_34 = arg5;
effect->unk_28.x = randPlusMinusPoint5Scaled(30000.0f);
effect->unk_28.y = randPlusMinusPoint5Scaled(30000.0f);
effect->unk_28.z = randPlusMinusPoint5Scaled(30000.0f);
break;
}
}
@@ -513,20 +513,20 @@ void func_80BE7504(EnDaiku2* this, Vec3f* arg1, Vec3f* arg2, Vec3f* arg3, f32 ar
void func_80BE7600(EnDaiku2* this, GlobalContext* globalCtx) {
s32 i;
EnDaiku2Particle* particle = &this->particles[0];
EnDaiku2Effect* effect = this->effects;
for (i = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
if (particle->isEnabled) {
particle->unk_04.x += particle->unk_10.x;
particle->unk_28.x += 0x100;
particle->unk_28.z += 0x130;
particle->unk_04.y += particle->unk_10.y;
particle->unk_04.z += particle->unk_10.z;
particle->unk_10.y += particle->unk_1C.y;
if (particle->unk_34 != 0) {
particle->unk_34 -= 1;
for (i = 0; i < ARRAY_COUNT(this->effects); i++, effect++) {
if (effect->isEnabled) {
effect->unk_04.x += effect->unk_10.x;
effect->unk_28.x += 0x100;
effect->unk_28.z += 0x130;
effect->unk_04.y += effect->unk_10.y;
effect->unk_04.z += effect->unk_10.z;
effect->unk_10.y += effect->unk_1C.y;
if (effect->unk_34 != 0) {
effect->unk_34 -= 1;
} else {
particle->isEnabled = false;
effect->isEnabled = false;
}
}
}
@@ -535,7 +535,7 @@ void func_80BE7600(EnDaiku2* this, GlobalContext* globalCtx) {
void func_80BE7718(EnDaiku2* this, GlobalContext* globalCtx) {
s32 i;
GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
EnDaiku2Particle* particle = &this->particles[0];
EnDaiku2Effect* effect = this->effects;
s32 objectIdx;
OPEN_DISPS(globalCtx->state.gfxCtx);
@@ -547,14 +547,14 @@ void func_80BE7718(EnDaiku2* this, GlobalContext* globalCtx) {
gDPPipeSync(POLY_OPA_DISP++);
gSPSegment(POLY_OPA_DISP++, 0x06, globalCtx->objectCtx.status[objectIdx].segment);
for (i = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
if (particle->isEnabled) {
for (i = 0; i < ARRAY_COUNT(this->effects); i++, effect++) {
if (effect->isEnabled) {
Matrix_Push();
Matrix_Translate(particle->unk_04.x, particle->unk_04.y, particle->unk_04.z, MTXMODE_NEW);
Matrix_RotateXS(particle->unk_28.x, MTXMODE_APPLY);
Matrix_RotateYS(particle->unk_28.y, MTXMODE_APPLY);
Matrix_RotateZS(particle->unk_28.z, MTXMODE_APPLY);
Matrix_Scale(particle->unk_30, particle->unk_30, particle->unk_30, MTXMODE_APPLY);
Matrix_Translate(effect->unk_04.x, effect->unk_04.y, effect->unk_04.z, MTXMODE_NEW);
Matrix_RotateXS(effect->unk_28.x, MTXMODE_APPLY);
Matrix_RotateYS(effect->unk_28.y, MTXMODE_APPLY);
Matrix_RotateZS(effect->unk_28.z, MTXMODE_APPLY);
Matrix_Scale(effect->unk_30, effect->unk_30, effect->unk_30, MTXMODE_APPLY);
gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPDisplayList(POLY_OPA_DISP++, object_bombiwa_DL_0009E0);
src/overlays/actors/ovl_En_Daiku2/z_en_daiku2.h
+5 -3
View File
@@ -17,7 +17,7 @@ enum {
/* 127 */ ENDAIKU2_GET_7F_127 = 127,
};
typedef struct EnDaiku2Particle {
typedef struct EnDaiku2Effect {
/* 0x00 */ u8 isEnabled;
/* 0x04 */ Vec3f unk_04;
/* 0x10 */ Vec3f unk_10;
@@ -25,7 +25,9 @@ typedef struct EnDaiku2Particle {
/* 0x28 */ Vec3s unk_28;
/* 0x30 */ f32 unk_30;
/* 0x34 */ s16 unk_34;
} EnDaiku2Particle; // size = 0x38
} EnDaiku2Effect; // size = 0x38
#define EN_DAIKU2_EFFECT_COUNT 50
typedef struct EnDaiku2 {
/* 0x000 */ Actor actor;
@@ -47,7 +49,7 @@ typedef struct EnDaiku2 {
/* 0x284 */ f32 unk_284;
/* 0x288 */ s16 unk_288;
/* 0x28A */ s16 unk_28A;
/* 0x28C */ EnDaiku2Particle particles[50];
/* 0x28C */ EnDaiku2Effect effects[EN_DAIKU2_EFFECT_COUNT];
/* 0xD7C */ ColliderCylinder collider;
} EnDaiku2; // size = 0xDC8
src/overlays/actors/ovl_En_Dnb/z_en_dnb.c
+43 -45
View File
@@ -33,50 +33,50 @@ const ActorInit En_Dnb_InitVars = {
(ActorFunc)EnDnb_Draw,
};
void func_80A4FDD0(EnDnbParticle* particle, EnDnb* this, s16* alloc, s32 idx) {
void func_80A4FDD0(EnDnbEffect* effect, EnDnb* this, s16* alloc, s32 idx) {
Vec3f sp1C;
s32 idx2 = idx * 3;
sp1C.x = alloc[idx2 + 0] + this->dyna.actor.world.pos.x;
sp1C.y = alloc[idx2 + 1] + this->dyna.actor.world.pos.y;
sp1C.z = alloc[idx2 + 2] + this->dyna.actor.world.pos.z;
particle->unk_00 = sp1C;
particle->unk_0C = sp1C;
particle->unk_24 = Math_Vec3f_Yaw(&this->dyna.actor.world.pos, &sp1C);
particle->unk_18 = gZeroVec3s;
effect->unk_00 = sp1C;
effect->unk_0C = sp1C;
effect->unk_24 = Math_Vec3f_Yaw(&this->dyna.actor.world.pos, &sp1C);
effect->unk_18 = gZeroVec3s;
}
s32 func_80A4FEBC(EnDnbParticle* particle, f32 arg1) {
s32 func_80A4FEBC(EnDnbEffect* effect, f32 arg1) {
s32 ret = false;
if ((DECR(particle->unk_26) == 0) && (arg1 < particle->unk_0C.y)) {
Math_ApproachF(&particle->unk_30, 1.0f, 0.4f, 1.0f);
particle->unk_2C += particle->unk_34;
particle->unk_0C.x += particle->unk_30 * Math_SinS(particle->unk_24);
particle->unk_0C.z += particle->unk_30 * Math_CosS(particle->unk_24);
particle->unk_0C.y += particle->unk_2C;
if (particle->unk_0C.y <= arg1) {
particle->unk_0C.y = arg1;
if ((DECR(effect->unk_26) == 0) && (arg1 < effect->unk_0C.y)) {
Math_ApproachF(&effect->unk_30, 1.0f, 0.4f, 1.0f);
effect->unk_2C += effect->unk_34;
effect->unk_0C.x += effect->unk_30 * Math_SinS(effect->unk_24);
effect->unk_0C.z += effect->unk_30 * Math_CosS(effect->unk_24);
effect->unk_0C.y += effect->unk_2C;
if (effect->unk_0C.y <= arg1) {
effect->unk_0C.y = arg1;
}
particle->unk_18.x += particle->unk_1E.x;
particle->unk_18.y += particle->unk_1E.y;
particle->unk_18.z += particle->unk_1E.z;
effect->unk_18.x += effect->unk_1E.x;
effect->unk_18.y += effect->unk_1E.y;
effect->unk_18.z += effect->unk_1E.z;
ret = true;
}
return ret;
}
void func_80A4FFE8(EnDnbParticle* particle, s16 arg1) {
particle->unk_0C = particle->unk_00;
particle->unk_1E.x = (Rand_ZeroOne() - 0.5f) * 400.0f;
particle->unk_1E.y = (Rand_ZeroOne() - 0.5f) * 400.0f;
particle->unk_1E.z = (Rand_ZeroOne() - 0.5f) * 400.0f;
particle->unk_18 = gZeroVec3s;
particle->unk_30 = 40.0f;
particle->unk_2C = 0.0f;
particle->unk_26 = arg1;
particle->unk_34 = (Rand_ZeroOne() * -2.0f) - 2.0f;
void func_80A4FFE8(EnDnbEffect* effect, s16 arg1) {
effect->unk_0C = effect->unk_00;
effect->unk_1E.x = (Rand_ZeroOne() - 0.5f) * 400.0f;
effect->unk_1E.y = (Rand_ZeroOne() - 0.5f) * 400.0f;
effect->unk_1E.z = (Rand_ZeroOne() - 0.5f) * 400.0f;
effect->unk_18 = gZeroVec3s;
effect->unk_30 = 40.0f;
effect->unk_2C = 0.0f;
effect->unk_26 = arg1;
effect->unk_34 = (Rand_ZeroOne() * -2.0f) - 2.0f;
}
s32 func_80A500F8(EnDnb* this) {
@@ -108,8 +108,8 @@ void EnDnb_Init(Actor* thisx, GlobalContext* globalCtx) {
DynaPolyActor_LoadMesh(globalCtx, &this->dyna, &object_hanareyama_obj_Colheader_004D8C);
alloc = Lib_SegmentedToVirtual(object_hanareyama_obj_Vec_004710);
for (i = 0; i < ARRAY_COUNT(this->particles); i++) {
func_80A4FDD0(&this->particles[i], this, alloc, i);
for (i = 0; i < ARRAY_COUNT(this->effects); i++) {
func_80A4FDD0(&this->effects[i], this, alloc, i);
}
Actor_SetScale(&this->dyna.actor, 1.0f);
@@ -126,8 +126,8 @@ void EnDnb_Update(Actor* thisx, GlobalContext* globalCtx) {
s32 i;
if (this->unk_0D30 == 0) {
for (i = 0; i < ARRAY_COUNT(this->particles); i++) {
func_80A4FFE8(&this->particles[i], ((53 - i) / 18) * 4);
for (i = 0; i < ARRAY_COUNT(this->effects); i++) {
func_80A4FFE8(&this->effects[i], ((53 - i) / 18) * 4);
}
for (i = 0; i < ARRAY_COUNT(this->unk_0D38); i++) {
@@ -141,8 +141,8 @@ void EnDnb_Update(Actor* thisx, GlobalContext* globalCtx) {
func_80A500F8(this);
}
for (i = 0; i < ARRAY_COUNT(this->particles); i++) {
func_80A4FEBC(&this->particles[i], this->dyna.actor.world.pos.y);
for (i = 0; i < ARRAY_COUNT(this->effects); i++) {
func_80A4FEBC(&this->effects[i], this->dyna.actor.world.pos.y);
}
this->unk_0D30--;
@@ -158,13 +158,12 @@ void func_80A50510(EnDnb* this, GlobalContext* globalCtx) {
func_8012C2DC(globalCtx->state.gfxCtx);
for (i = 0; i < ARRAY_COUNT(this->particles); i++) {
for (i = 0; i < ARRAY_COUNT(this->effects); i++) {
Matrix_Push();
Matrix_Translate(this->particles[i].unk_0C.x, this->particles[i].unk_0C.y, this->particles[i].unk_0C.z,
MTXMODE_NEW);
Matrix_RotateXS(this->particles[i].unk_18.x, MTXMODE_APPLY);
Matrix_RotateYS(this->particles[i].unk_18.y, MTXMODE_APPLY);
Matrix_RotateZS(this->particles[i].unk_18.z, MTXMODE_APPLY);
Matrix_Translate(this->effects[i].unk_0C.x, this->effects[i].unk_0C.y, this->effects[i].unk_0C.z, MTXMODE_NEW);
Matrix_RotateXS(this->effects[i].unk_18.x, MTXMODE_APPLY);
Matrix_RotateYS(this->effects[i].unk_18.y, MTXMODE_APPLY);
Matrix_RotateZS(this->effects[i].unk_18.z, MTXMODE_APPLY);
gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPDisplayList(POLY_XLU_DISP++, gfx[i]);
@@ -183,13 +182,12 @@ void func_80A5063C(EnDnb* this, GlobalContext* globalCtx) {
func_8012C28C(globalCtx->state.gfxCtx);
for (i = 0; i < ARRAY_COUNT(this->particles); i++) {
for (i = 0; i < ARRAY_COUNT(this->effects); i++) {
Matrix_Push();
Matrix_Translate(this->particles[i].unk_0C.x, this->particles[i].unk_0C.y, this->particles[i].unk_0C.z,
MTXMODE_NEW);
Matrix_RotateXS(this->particles[i].unk_18.x, MTXMODE_APPLY);
Matrix_RotateYS(this->particles[i].unk_18.y, MTXMODE_APPLY);
Matrix_RotateZS(this->particles[i].unk_18.z, MTXMODE_APPLY);
Matrix_Translate(this->effects[i].unk_0C.x, this->effects[i].unk_0C.y, this->effects[i].unk_0C.z, MTXMODE_NEW);
Matrix_RotateXS(this->effects[i].unk_18.x, MTXMODE_APPLY);
Matrix_RotateYS(this->effects[i].unk_18.y, MTXMODE_APPLY);
Matrix_RotateZS(this->effects[i].unk_18.z, MTXMODE_APPLY);
gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPDisplayList(POLY_OPA_DISP++, gfx[i]);
src/overlays/actors/ovl_En_Dnb/z_en_dnb.h
+4 -2
View File
@@ -16,7 +16,7 @@ typedef struct {
/* 0x2C */ f32 unk_2C;
/* 0x30 */ f32 unk_30;
/* 0x34 */ f32 unk_34;
} EnDnbParticle; // size = 0x38
} EnDnbEffect; // size = 0x38
typedef struct {
/* 0x00 */ u8 isEnabled;
@@ -29,10 +29,12 @@ typedef struct {
/* 0x24 */ f32 unk_24;
} EnDnbUnkStruct; // size = 0x28
#define EN_DNB_EFFECT_COUNT 54
typedef struct EnDnb {
/* 0x0000 */ DynaPolyActor dyna;
/* 0x015C */ UNK_TYPE1 unk_015C[0x4];
/* 0x0160 */ EnDnbParticle particles[54];
/* 0x0160 */ EnDnbEffect effects[EN_DNB_EFFECT_COUNT];
/* 0x0D30 */ s16 unk_0D30;
/* 0x0D32 */ s16 unk_0D32;
/* 0x0D34 */ s16 unk_0D34;
src/overlays/actors/ovl_En_Encount2/z_en_encount2.c
+31 -31
View File
@@ -21,9 +21,9 @@ void EnEncount2_Idle(EnEncount2* this, GlobalContext* globalCtx);
void EnEncount2_Popped(EnEncount2* this, GlobalContext* globalCtx);
void EnEncount2_Die(EnEncount2* this, GlobalContext* globalCtx);
void EnEncount2_SetIdle(EnEncount2* this);
void EnEncount2_InitParticles(EnEncount2* this, Vec3f* pos, s16 fadeDelay);
void EnEncount2_UpdateParticles(EnEncount2* this, GlobalContext* globalCtx);
void EnEncount2_DrawParticles(EnEncount2* this, GlobalContext* globalCtx);
void EnEncount2_InitEffects(EnEncount2* this, Vec3f* pos, s16 fadeDelay);
void EnEncount2_UpdateEffects(EnEncount2* this, GlobalContext* globalCtx);
void EnEncount2_DrawEffects(EnEncount2* this, GlobalContext* globalCtx);
const ActorInit En_Encount2_InitVars = {
ACTOR_EN_ENCOUNT2,
@@ -166,8 +166,8 @@ void EnEncount2_Popped(EnEncount2* this, GlobalContext* globalCtx) {
Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_CLEAR_TAG, curPos.x, curPos.y, curPos.z, 255, 255, 200,
CLEAR_TAG_LARGE_EXPLOSION);
for (i = 0; i < ARRAY_COUNT(this->particles) / 2; ++i) {
EnEncount2_InitParticles(this, &curPos, 10);
for (i = 0; i < ARRAY_COUNT(this->effects) / 2; ++i) {
EnEncount2_InitEffects(this, &curPos, 10);
}
Actor_PlaySfxAtPos(&this->dyna.actor, NA_SE_EV_MUJURA_BALLOON_BROKEN);
@@ -195,7 +195,7 @@ void EnEncount2_Update(Actor* thisx, GlobalContext* globalCtx) {
Actor_SetScale(&this->dyna.actor, this->scale);
this->actionFunc(this, globalCtx);
Actor_MoveWithGravity(&this->dyna.actor);
EnEncount2_UpdateParticles(this, globalCtx);
EnEncount2_UpdateEffects(this, globalCtx);
if (!this->isPopped) {
Collider_UpdateSpheresElement(&this->collider, 0, &this->dyna.actor);
@@ -210,16 +210,16 @@ void EnEncount2_Draw(Actor* thisx, GlobalContext* globalCtx) {
Gfx_DrawDListOpa(globalCtx, object_fusen_DL_000A00);
Gfx_DrawDListOpa(globalCtx, object_fusen_DL_000D78);
}
EnEncount2_DrawParticles(this, globalCtx);
EnEncount2_DrawEffects(this, globalCtx);
}
void EnEncount2_InitParticles(EnEncount2* this, Vec3f* pos, s16 fadeDelay) {
void EnEncount2_InitEffects(EnEncount2* this, Vec3f* pos, s16 fadeDelay) {
s16 i;
EnEncount2Particle* sPtr = this->particles;
EnEncount2Effect* sPtr = this->effects;
for (i = 0; i < ARRAY_COUNT(this->particles); i++, sPtr++) {
if (!sPtr->enabled) {
sPtr->enabled = true;
for (i = 0; i < ARRAY_COUNT(this->effects); i++, sPtr++) {
if (!sPtr->isEnabled) {
sPtr->isEnabled = true;
sPtr->pos = *pos;
sPtr->alphaFadeDelay = fadeDelay;
sPtr->alpha = 0xFF;
@@ -228,9 +228,9 @@ void EnEncount2_InitParticles(EnEncount2* this, Vec3f* pos, s16 fadeDelay) {
sPtr->accel.y = (Rand_ZeroOne() - 0.5f) * 10.0f;
sPtr->accel.z = (Rand_ZeroOne() - 0.5f) * 10.0f;
sPtr->vel.x = Rand_ZeroOne() - 0.5f;
sPtr->vel.y = Rand_ZeroOne() - 0.5f;
sPtr->vel.z = Rand_ZeroOne() - 0.5f;
sPtr->velocity.x = Rand_ZeroOne() - 0.5f;
sPtr->velocity.y = Rand_ZeroOne() - 0.5f;
sPtr->velocity.z = Rand_ZeroOne() - 0.5f;
sPtr->scale = (Rand_ZeroFloat(1.0f) * 0.5f) + 2.0f;
return;
@@ -238,42 +238,42 @@ void EnEncount2_InitParticles(EnEncount2* this, Vec3f* pos, s16 fadeDelay) {
}
}
void EnEncount2_UpdateParticles(EnEncount2* this, GlobalContext* globalCtx) {
void EnEncount2_UpdateEffects(EnEncount2* this, GlobalContext* globalCtx) {
s32 i;
EnEncount2Particle* sPtr = this->particles;
EnEncount2Effect* sPtr = this->effects;
for (i = 0; i < ARRAY_COUNT(this->particles); i++, sPtr++) {
if (sPtr->enabled) {
sPtr->pos.x += sPtr->vel.x;
sPtr->pos.y += sPtr->vel.y;
sPtr->pos.z += sPtr->vel.z;
sPtr->vel.x += sPtr->accel.x;
sPtr->vel.y += sPtr->accel.y;
sPtr->vel.z += sPtr->accel.z;
for (i = 0; i < ARRAY_COUNT(this->effects); i++, sPtr++) {
if (sPtr->isEnabled) {
sPtr->pos.x += sPtr->velocity.x;
sPtr->pos.y += sPtr->velocity.y;
sPtr->pos.z += sPtr->velocity.z;
sPtr->velocity.x += sPtr->accel.x;
sPtr->velocity.y += sPtr->accel.y;
sPtr->velocity.z += sPtr->accel.z;
if (sPtr->alphaFadeDelay != 0) {
sPtr->alphaFadeDelay--;
} else {
sPtr->alpha -= 10;
if (sPtr->alpha < 10) {
sPtr->enabled = 0;
sPtr->isEnabled = 0;
}
}
}
}
}
void EnEncount2_DrawParticles(EnEncount2* this, GlobalContext* globalCtx) {
void EnEncount2_DrawEffects(EnEncount2* this, GlobalContext* globalCtx) {
s16 i;
EnEncount2Particle* sPtr;
EnEncount2Effect* sPtr;
GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
OPEN_DISPS(gfxCtx);
sPtr = this->particles;
sPtr = this->effects;
func_8012C28C(gfxCtx);
func_8012C2DC(globalCtx->state.gfxCtx);
for (i = 0; i < ARRAY_COUNT(this->particles); i++, sPtr++) {
if (sPtr->enabled) {
for (i = 0; i < ARRAY_COUNT(this->effects); i++, sPtr++) {
if (sPtr->isEnabled) {
Matrix_Translate(sPtr->pos.x, sPtr->pos.y, sPtr->pos.z, MTXMODE_NEW);
Matrix_Scale(sPtr->scale, sPtr->scale, sPtr->scale, MTXMODE_APPLY);
POLY_XLU_DISP = Gfx_CallSetupDL(POLY_XLU_DISP, 20);
src/overlays/actors/ovl_En_Encount2/z_en_encount2.h
+7 -5
View File
@@ -7,16 +7,18 @@ struct EnEncount2;
typedef void (*EnEncount2ActionFunc)(struct EnEncount2*, GlobalContext*);
typedef struct EnEncount2Particle{
/* 0x00 */ u8 enabled;
typedef struct EnEncount2Effect{
/* 0x00 */ u8 isEnabled;
/* 0x04 */ Vec3f pos;
/* 0x10 */ UNK_TYPE4 unk10;
/* 0x14 */ s16 alpha;
/* 0x16 */ s16 alphaFadeDelay; // frame count before alpha fade starts
/* 0x18 */ Vec3f vel;
/* 0x18 */ Vec3f velocity;
/* 0x24 */ Vec3f accel;
/* 0x30 */ f32 scale;
} EnEncount2Particle; // size = 0x34
} EnEncount2Effect; // size = 0x34
#define EN_ENCOUNT2_EFFECT_COUNT 200
typedef struct EnEncount2 {
/* 0x0000 */ DynaPolyActor dyna;
@@ -28,7 +30,7 @@ typedef struct EnEncount2 {
/* 0x016C */ f32 oscillationAngle;
/* 0x0170 */ ColliderJntSph collider;
/* 0x0190 */ ColliderJntSphElement colElement;
/* 0x01D0 */ EnEncount2Particle particles[200];
/* 0x01D0 */ EnEncount2Effect effects[EN_ENCOUNT2_EFFECT_COUNT];
} EnEncount2; // size = 0x2A70
#define GET_ENCOUNT2_SWITCH_FLAG(actor) ((s16)(((Actor*)actor)->params & 0x7F))
src/overlays/actors/ovl_En_Fall/z_en_fall.c
+48 -47
View File
@@ -56,9 +56,11 @@ typedef struct {
Vec3f pos;
Vec3f velocity;
Vec3s rot;
} EnFallDebrisParticle;
} EnFallDebrisEffect;
EnFallDebrisParticle debrisParticles[50];
#define EN_FALL_DEBRIS_EFFECT_COUNT 50
EnFallDebrisEffect debrisEffects[EN_FALL_DEBRIS_EFFECT_COUNT];
const ActorInit En_Fall_InitVars = {
ACTOR_EN_FALL,
@@ -115,13 +117,13 @@ void EnFall_Moon_AdjustScaleAndPosition(EnFall* this, GlobalContext* globalCtx)
}
}
void EnFall_RisingDebris_ResetParticles(EnFall* this) {
void EnFall_RisingDebris_ResetEffects(EnFall* this) {
s32 i;
for (i = 0; i < ARRAY_COUNT(debrisParticles); i++) {
debrisParticles[i].modelIndex = 3;
for (i = 0; i < ARRAY_COUNT(debrisEffects); i++) {
debrisEffects[i].modelIndex = 3;
}
this->activeDebrisParticleCount = 0;
this->activeDebrisEffectCount = 0;
}
void EnFall_Init(Actor* thisx, GlobalContext* globalCtx) {
@@ -252,7 +254,7 @@ void EnFall_Setup(EnFall* this, GlobalContext* globalCtx) {
this->actor.update = EnFall_RisingDebris_Update;
this->actor.draw = EnFall_RisingDebris_Draw;
this->scale = 1.0f;
EnFall_RisingDebris_ResetParticles(this);
EnFall_RisingDebris_ResetEffects(this);
Actor_SetScale(&this->actor, 1.0f);
this->actor.shape.rot.x = 0;
break;
@@ -631,47 +633,47 @@ void EnFall_Fireball_Update(Actor* thisx, GlobalContext* globalCtx) {
Actor_SetScale(&this->actor, this->scale * 1.74f);
}
void EnFall_RisingDebris_UpdateParticles(EnFall* this) {
void EnFall_RisingDebris_UpdateEffects(EnFall* this) {
s32 i;
for (i = 0; i < ARRAY_COUNT(debrisParticles); i++) {
if (debrisParticles[i].modelIndex < 3) {
debrisParticles[i].pos.x += debrisParticles[i].velocity.x;
debrisParticles[i].pos.y += debrisParticles[i].velocity.y;
debrisParticles[i].pos.z += debrisParticles[i].velocity.z;
debrisParticles[i].rot.x += 0x64;
debrisParticles[i].rot.y += 0xC8;
debrisParticles[i].rot.z += 0x12C;
if ((this->actor.world.pos.y + 3000.0f) < debrisParticles[i].pos.y) {
debrisParticles[i].modelIndex = 3;
this->activeDebrisParticleCount--;
for (i = 0; i < ARRAY_COUNT(debrisEffects); i++) {
if (debrisEffects[i].modelIndex < 3) {
debrisEffects[i].pos.x += debrisEffects[i].velocity.x;
debrisEffects[i].pos.y += debrisEffects[i].velocity.y;
debrisEffects[i].pos.z += debrisEffects[i].velocity.z;
debrisEffects[i].rot.x += 0x64;
debrisEffects[i].rot.y += 0xC8;
debrisEffects[i].rot.z += 0x12C;
if ((this->actor.world.pos.y + 3000.0f) < debrisEffects[i].pos.y) {
debrisEffects[i].modelIndex = 3;
this->activeDebrisEffectCount--;
}
}
}
}
s32 EnFall_RisingDebris_InitializeParticles(EnFall* this) {
s32 EnFall_RisingDebris_InitializeEffect(EnFall* this) {
s16 angle;
s32 i;
f32 scale;
for (i = 0; i < ARRAY_COUNT(debrisParticles); i++) {
if (debrisParticles[i].modelIndex >= 3) {
debrisParticles[i].modelIndex = (s32)Rand_ZeroFloat(3.0f);
debrisParticles[i].pos.x = this->actor.world.pos.x;
debrisParticles[i].pos.y = this->actor.world.pos.y;
debrisParticles[i].pos.z = this->actor.world.pos.z;
for (i = 0; i < ARRAY_COUNT(debrisEffects); i++) {
if (debrisEffects[i].modelIndex >= 3) {
debrisEffects[i].modelIndex = (s32)Rand_ZeroFloat(3.0f);
debrisEffects[i].pos.x = this->actor.world.pos.x;
debrisEffects[i].pos.y = this->actor.world.pos.y;
debrisEffects[i].pos.z = this->actor.world.pos.z;
angle = randPlusMinusPoint5Scaled(0x10000);
scale = (1.0f - (Rand_ZeroFloat(1.0f) * Rand_ZeroFloat(1.0f))) * 3000.0f;
debrisParticles[i].pos.x += Math_SinS(angle) * scale;
debrisParticles[i].pos.z += Math_CosS(angle) * scale;
debrisParticles[i].velocity.x = 0.0f;
debrisParticles[i].velocity.z = 0.0f;
debrisParticles[i].velocity.y = 80.0f;
debrisParticles[i].rot.x = randPlusMinusPoint5Scaled(0x10000);
debrisParticles[i].rot.y = randPlusMinusPoint5Scaled(0x10000);
debrisParticles[i].rot.z = randPlusMinusPoint5Scaled(0x10000);
this->activeDebrisParticleCount++;
debrisEffects[i].pos.x += Math_SinS(angle) * scale;
debrisEffects[i].pos.z += Math_CosS(angle) * scale;
debrisEffects[i].velocity.x = 0.0f;
debrisEffects[i].velocity.z = 0.0f;
debrisEffects[i].velocity.y = 80.0f;
debrisEffects[i].rot.x = randPlusMinusPoint5Scaled(0x10000);
debrisEffects[i].rot.y = randPlusMinusPoint5Scaled(0x10000);
debrisEffects[i].rot.z = randPlusMinusPoint5Scaled(0x10000);
this->activeDebrisEffectCount++;
return true;
}
}
@@ -685,14 +687,14 @@ void EnFall_RisingDebris_Update(Actor* thisx, GlobalContext* globalCtx) {
if (Cutscene_CheckActorAction(globalCtx, 451)) {
if (Cutscene_CheckActorAction(globalCtx, 451) &&
globalCtx->csCtx.actorActions[Cutscene_GetActorActionIndex(globalCtx, 451)]->action == 2) {
EnFall_RisingDebris_UpdateParticles(this);
EnFall_RisingDebris_InitializeParticles(this);
} else if (this->activeDebrisParticleCount != 0) {
EnFall_RisingDebris_ResetParticles(this);
EnFall_RisingDebris_UpdateEffects(this);
EnFall_RisingDebris_InitializeEffect(this);
} else if (this->activeDebrisEffectCount != 0) {
EnFall_RisingDebris_ResetEffects(this);
}
} else if (thisx->home.rot.x != 0) {
EnFall_RisingDebris_UpdateParticles(this);
EnFall_RisingDebris_InitializeParticles(this);
EnFall_RisingDebris_UpdateEffects(this);
EnFall_RisingDebris_InitializeEffect(this);
}
}
@@ -868,15 +870,14 @@ void EnFall_RisingDebris_Draw(Actor* thisx, GlobalContext* globalCtx) {
gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, 255, 255, 255, 255);
gDPSetEnvColor(POLY_OPA_DISP++, 0, 0, 0, 255);
for (i = 0; i < ARRAY_COUNT(debrisParticles); i++) {
if (debrisParticles[i].modelIndex < 3) {
Matrix_Translate(debrisParticles[i].pos.x, debrisParticles[i].pos.y, debrisParticles[i].pos.z, MTXMODE_NEW);
for (i = 0; i < ARRAY_COUNT(debrisEffects); i++) {
if (debrisEffects[i].modelIndex < 3) {
Matrix_Translate(debrisEffects[i].pos.x, debrisEffects[i].pos.y, debrisEffects[i].pos.z, MTXMODE_NEW);
Matrix_Scale(scale, scale, scale, MTXMODE_APPLY);
Matrix_RotateZYX(debrisParticles[i].rot.x, debrisParticles[i].rot.y, debrisParticles[i].rot.z,
MTXMODE_APPLY);
Matrix_RotateZYX(debrisEffects[i].rot.x, debrisEffects[i].rot.y, debrisEffects[i].rot.z, MTXMODE_APPLY);
gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPDisplayList(POLY_OPA_DISP++, sDebrisModelDLists[debrisParticles[i].modelIndex]);
gSPDisplayList(POLY_OPA_DISP++, sDebrisModelDLists[debrisEffects[i].modelIndex]);
}
}
src/overlays/actors/ovl_En_Fall/z_en_fall.h
+1 -1
View File
@@ -40,7 +40,7 @@ typedef struct EnFall {
/* 0x154 */ u16 flags;
/* 0x158 */ union {
s32 fireballAlpha;
s32 activeDebrisParticleCount;
s32 activeDebrisEffectCount;
};
/* 0x15C */ union {
s16 fireballYTexScroll1;
src/overlays/actors/ovl_En_Hakurock/z_en_hakurock.c
+20 -20
View File
@@ -94,36 +94,36 @@ void func_80B21BE0(BossHakugin* parent, Vec3f* arg1, s32 arg2) {
s32 i;
for (i = 0; i < ARRAY_COUNT(parent->unk_9F8); i++) {
BossHakuginParticle* gohtParticle = &parent->unk_9F8[i];
if (gohtParticle->unk_18 < 0) {
BossHakuginEffect* gohtEffect = &parent->unk_9F8[i];
if (gohtEffect->unk_18 < 0) {
s16 sp2E;
s16 sp2C;
f32 sp28;
Math_Vec3f_Copy(&gohtParticle->unk_0, arg1);
Math_Vec3f_Copy(&gohtEffect->unk_0, arg1);
sp2C = Rand_S16Offset(0x1000, 0x3000);
sp2E = Rand_Next() >> 0x10;
sp28 = Rand_ZeroFloat(5.0f) + 10.0f;
gohtParticle->unk_C.x = (sp28 * Math_CosS(sp2C)) * Math_SinS(sp2E);
gohtParticle->unk_C.y = (Math_SinS(sp2C) * sp28);
gohtParticle->unk_C.z = (sp28 * Math_CosS(sp2C)) * Math_CosS(sp2E);
gohtEffect->unk_C.x = (sp28 * Math_CosS(sp2C)) * Math_SinS(sp2E);
gohtEffect->unk_C.y = (Math_SinS(sp2C) * sp28);
gohtEffect->unk_C.z = (sp28 * Math_CosS(sp2C)) * Math_CosS(sp2E);
if ((arg2 == 1) || (arg2 == 3)) {
gohtParticle->unk_24 = ((Rand_ZeroFloat(5.0f) + 25.0f) * 0.0012f);
gohtParticle->unk_0.x = ((Rand_ZeroFloat(2.0f) + 9.0f) * gohtParticle->unk_C.x) + arg1->x;
gohtParticle->unk_0.y = ((Rand_ZeroFloat(2.0f) + 3.0f) * gohtParticle->unk_C.y) + arg1->y;
gohtParticle->unk_0.z = ((Rand_ZeroFloat(2.0f) + 9.0f) * gohtParticle->unk_C.z) + arg1->z;
gohtParticle->unk_1A = 1;
gohtEffect->unk_24 = ((Rand_ZeroFloat(5.0f) + 25.0f) * 0.0012f);
gohtEffect->unk_0.x = ((Rand_ZeroFloat(2.0f) + 9.0f) * gohtEffect->unk_C.x) + arg1->x;
gohtEffect->unk_0.y = ((Rand_ZeroFloat(2.0f) + 3.0f) * gohtEffect->unk_C.y) + arg1->y;
gohtEffect->unk_0.z = ((Rand_ZeroFloat(2.0f) + 9.0f) * gohtEffect->unk_C.z) + arg1->z;
gohtEffect->unk_1A = 1;
} else {
gohtParticle->unk_24 = ((Rand_ZeroFloat(5.0f) + 18.0f) * 0.0001f);
gohtParticle->unk_0.x = ((Rand_ZeroFloat(2.0f) + 3.0f) * gohtParticle->unk_C.x) + arg1->x;
gohtParticle->unk_0.y = ((Rand_ZeroFloat(3.0f) + 1.0f) * gohtParticle->unk_C.y) + arg1->y;
gohtParticle->unk_0.z = ((Rand_ZeroFloat(2.0f) + 3.0f) * gohtParticle->unk_C.z) + arg1->z;
gohtParticle->unk_1A = 0;
gohtEffect->unk_24 = ((Rand_ZeroFloat(5.0f) + 18.0f) * 0.0001f);
gohtEffect->unk_0.x = ((Rand_ZeroFloat(2.0f) + 3.0f) * gohtEffect->unk_C.x) + arg1->x;
gohtEffect->unk_0.y = ((Rand_ZeroFloat(3.0f) + 1.0f) * gohtEffect->unk_C.y) + arg1->y;
gohtEffect->unk_0.z = ((Rand_ZeroFloat(2.0f) + 3.0f) * gohtEffect->unk_C.z) + arg1->z;
gohtEffect->unk_1A = 0;
}
gohtParticle->unk_1C.x = (s32)Rand_Next() >> 0x10;
gohtParticle->unk_1C.y = (s32)Rand_Next() >> 0x10;
gohtParticle->unk_1C.z = (s32)Rand_Next() >> 0x10;
gohtParticle->unk_18 = 0x28;
gohtEffect->unk_1C.x = (s32)Rand_Next() >> 0x10;
gohtEffect->unk_1C.y = (s32)Rand_Next() >> 0x10;
gohtEffect->unk_1C.z = (s32)Rand_Next() >> 0x10;
gohtEffect->unk_18 = 0x28;
return;
}
}
src/overlays/actors/ovl_En_Minislime/z_en_minislime.c
+11 -11
View File
@@ -185,18 +185,18 @@ void EnMinislime_AddIceShardEffect(EnMinislime* this) {
for (; i < i_end; i++) {
iceShardEffect = &bigslime->iceShardEffect[i];
vecSph.pitch = Rand_S16Offset(0x1000, 0x3000);
iceShardEffect->vel.x = Math_CosS(vecSph.pitch) * Math_SinS(vecSph.yaw);
iceShardEffect->vel.y = Math_SinS(vecSph.pitch);
iceShardEffect->vel.z = Math_CosS(vecSph.pitch) * Math_CosS(vecSph.yaw);
iceShardEffect->pos.x = this->actor.world.pos.x + (400.0f * this->actor.scale.x) * iceShardEffect->vel.x;
iceShardEffect->velocity.x = Math_CosS(vecSph.pitch) * Math_SinS(vecSph.yaw);
iceShardEffect->velocity.y = Math_SinS(vecSph.pitch);
iceShardEffect->velocity.z = Math_CosS(vecSph.pitch) * Math_CosS(vecSph.yaw);
iceShardEffect->pos.x = this->actor.world.pos.x + (400.0f * this->actor.scale.x) * iceShardEffect->velocity.x;
iceShardEffect->pos.y =
this->actor.world.pos.y + (((iceShardEffect->vel.y * 2.0f) - 1.0f) * 400.0f * this->actor.scale.y);
iceShardEffect->pos.z = this->actor.world.pos.z + (400.0f * this->actor.scale.z) * iceShardEffect->vel.z;
iceShardEffect->rotation.x = (s32)Rand_Next() >> 0x10;
iceShardEffect->rotation.y = (s32)Rand_Next() >> 0x10;
iceShardEffect->rotation.z = (s32)Rand_Next() >> 0x10;
iceShardEffect->isActive = true;
Math_Vec3f_ScaleAndStore(&iceShardEffect->vel, Rand_ZeroFloat(3.0f) + 7.0f, &iceShardEffect->vel);
this->actor.world.pos.y + (((iceShardEffect->velocity.y * 2.0f) - 1.0f) * 400.0f * this->actor.scale.y);
iceShardEffect->pos.z = this->actor.world.pos.z + (400.0f * this->actor.scale.z) * iceShardEffect->velocity.z;
iceShardEffect->rot.x = (s32)Rand_Next() >> 0x10;
iceShardEffect->rot.y = (s32)Rand_Next() >> 0x10;
iceShardEffect->rot.z = (s32)Rand_Next() >> 0x10;
iceShardEffect->isEnabled = true;
Math_Vec3f_ScaleAndStore(&iceShardEffect->velocity, Rand_ZeroFloat(3.0f) + 7.0f, &iceShardEffect->velocity);
iceShardEffect->scale = (Rand_ZeroFloat(6.0f) + 2.0f) * 0.001f;
vecSph.yaw += 0x1999;
}
src/overlays/actors/ovl_En_Raf/z_en_raf.c
+58 -59
View File
@@ -30,9 +30,9 @@ void EnRaf_SetupDissolve(EnRaf* this);
void EnRaf_Dissolve(EnRaf* this, GlobalContext* globalCtx);
void EnRaf_SetupDormant(EnRaf* this);
void EnRaf_Dormant(EnRaf* this, GlobalContext* globalCtx);
void EnRaf_InitializeParticle(EnRaf* this, Vec3f* position, Vec3f* velocity, Vec3f* acceleration, f32 scale, s16 timer);
void EnRaf_UpdateParticles(EnRaf* this, GlobalContext* globalCtx);
void EnRaf_DrawParticles(EnRaf* this, GlobalContext* globalCtx);
void EnRaf_InitializeEffect(EnRaf* this, Vec3f* pos, Vec3f* velocity, Vec3f* accel, f32 scale, s16 timer);
void EnRaf_UpdateEffects(EnRaf* this, GlobalContext* globalCtx);
void EnRaf_DrawEffects(EnRaf* this, GlobalContext* globalCtx);
typedef enum {
/* 0 */ EN_RAF_ANIMATION_IDLE,
@@ -494,11 +494,11 @@ void EnRaf_Throw(EnRaf* this, GlobalContext* globalCtx) {
}
/**
* Creates an explosion effect/sound and spawns particles.
* Creates an explosion effect/sound and spawns effects.
*/
void EnRaf_Explode(EnRaf* this, GlobalContext* globalCtx) {
Vec3f velocity = { 0.0f, 0.0f, 0.0f };
Vec3f acceleration = { 0.0f, 0.0f, 0.0f };
Vec3f accel = { 0.0f, 0.0f, 0.0f };
Vec3f explosionPos;
s32 i;
s32 pad;
@@ -516,14 +516,14 @@ void EnRaf_Explode(EnRaf* this, GlobalContext* globalCtx) {
this->petalScaleType = EN_RAF_PETAL_SCALE_TYPE_DEAD;
for (i = 0; i < BREG(57) + 30; i++) {
acceleration.x = (Rand_ZeroOne() - 0.5f) * 0.5f;
acceleration.y = -0.3f;
acceleration.z = (Rand_ZeroOne() - 0.5f) * 0.5f;
accel.x = (Rand_ZeroOne() - 0.5f) * 0.5f;
accel.y = -0.3f;
accel.z = (Rand_ZeroOne() - 0.5f) * 0.5f;
velocity.x = Rand_ZeroOne() - 0.5f;
velocity.y = Rand_ZeroOne() * 10.0f;
velocity.z = Rand_ZeroOne() - 0.5f;
EnRaf_InitializeParticle(this, &this->dyna.actor.world.pos, &velocity, &acceleration,
(Rand_ZeroFloat(1.0f) / 500.0f) + 0.002f, 90);
EnRaf_InitializeEffect(this, &this->dyna.actor.world.pos, &velocity, &accel,
(Rand_ZeroFloat(1.0f) / 500.0f) + 0.002f, 90);
}
for (i = CARNIVOROUS_LILY_PAD_LIMB_TRAP_1_LOWER_SEGMENT; i <= CARNIVOROUS_LILY_PAD_LIMB_TRAP_3_UPPER_SEGMENT; i++) {
@@ -742,7 +742,7 @@ void EnRaf_Update(Actor* thisx, GlobalContext* globalCtx) {
Math_ApproachZeroF(&this->heightDiffFromPlayer, 0.3f, 2.0f);
if (this->action == EN_RAF_ACTION_EXPLODE) {
EnRaf_UpdateParticles(this, globalCtx);
EnRaf_UpdateEffects(this, globalCtx);
}
for (i = 0; i < ARRAY_COUNT(this->limbScale); i++) {
@@ -875,84 +875,83 @@ void EnRaf_Draw(Actor* thisx, GlobalContext* globalCtx) {
this->skelAnime.dListCount, NULL, NULL, EnRaf_TransformLimbDraw, &this->dyna.actor);
if (this->action == EN_RAF_ACTION_EXPLODE) {
EnRaf_DrawParticles(this, globalCtx);
EnRaf_DrawEffects(this, globalCtx);
}
}
void EnRaf_InitializeParticle(EnRaf* this, Vec3f* position, Vec3f* velocity, Vec3f* acceleration, f32 scale,
s16 timer) {
void EnRaf_InitializeEffect(EnRaf* this, Vec3f* pos, Vec3f* velocity, Vec3f* accel, f32 scale, s16 timer) {
s16 i;
EnRafParticle* particle = this->particles;
EnRafEffect* effect = this->effects;
for (i = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
if (!particle->isVisible) {
particle->isVisible = true;
particle->position = *position;
particle->velocity = *velocity;
particle->acceleration = *acceleration;
particle->scale = scale;
particle->timer = timer;
particle->rotation.x = randPlusMinusPoint5Scaled(30000.0f);
particle->rotation.y = randPlusMinusPoint5Scaled(30000.0f);
particle->rotation.z = randPlusMinusPoint5Scaled(30000.0f);
for (i = 0; i < ARRAY_COUNT(this->effects); i++, effect++) {
if (!effect->isEnabled) {
effect->isEnabled = true;
effect->pos = *pos;
effect->velocity = *velocity;
effect->accel = *accel;
effect->scale = scale;
effect->timer = timer;
effect->rotation.x = randPlusMinusPoint5Scaled(30000.0f);
effect->rotation.y = randPlusMinusPoint5Scaled(30000.0f);
effect->rotation.z = randPlusMinusPoint5Scaled(30000.0f);
return;
}
}
}
void EnRaf_UpdateParticles(EnRaf* this, GlobalContext* globalCtx) {
void EnRaf_UpdateEffects(EnRaf* this, GlobalContext* globalCtx) {
s32 i;
EnRafParticle* particle = this->particles;
EnRafEffect* effect = this->effects;
for (i = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
if (particle->isVisible) {
particle->position.x += particle->velocity.x;
particle->position.y += particle->velocity.y;
particle->position.z += particle->velocity.z;
particle->rotation.x += 0xBB8;
particle->rotation.y += 0xBB8;
particle->rotation.z += 0xBB8;
particle->velocity.x += particle->acceleration.x;
particle->velocity.y += particle->acceleration.y;
particle->velocity.z += particle->acceleration.z;
for (i = 0; i < ARRAY_COUNT(this->effects); i++, effect++) {
if (effect->isEnabled) {
effect->pos.x += effect->velocity.x;
effect->pos.y += effect->velocity.y;
effect->pos.z += effect->velocity.z;
effect->rotation.x += 0xBB8;
effect->rotation.y += 0xBB8;
effect->rotation.z += 0xBB8;
effect->velocity.x += effect->accel.x;
effect->velocity.y += effect->accel.y;
effect->velocity.z += effect->accel.z;
if (this->mainType != EN_RAF_TYPE_NO_WATER_INTERACTIONS) {
if (particle->position.y < (this->dyna.actor.world.pos.y - 10.0f)) {
EffectSsGSplash_Spawn(globalCtx, &particle->position, NULL, NULL, 0, particle->scale * 200000.0f);
SoundSource_PlaySfxAtFixedWorldPos(globalCtx, &particle->position, 50, NA_SE_EV_BOMB_DROP_WATER);
particle->isVisible = false;
if (effect->pos.y < (this->dyna.actor.world.pos.y - 10.0f)) {
EffectSsGSplash_Spawn(globalCtx, &effect->pos, NULL, NULL, 0, effect->scale * 200000.0f);
SoundSource_PlaySfxAtFixedWorldPos(globalCtx, &effect->pos, 50, NA_SE_EV_BOMB_DROP_WATER);
effect->isEnabled = false;
}
} else if (particle->position.y < (this->dyna.actor.world.pos.y - 10.0f)) {
Math_ApproachZeroF(&particle->scale, 0.2f, 0.001f);
if (particle->scale <= 0.0001f) {
particle->timer = 0;
} else if (effect->pos.y < (this->dyna.actor.world.pos.y - 10.0f)) {
Math_ApproachZeroF(&effect->scale, 0.2f, 0.001f);
if (effect->scale <= 0.0001f) {
effect->timer = 0;
}
}
if (particle->timer != 0) {
particle->timer--;
if (effect->timer != 0) {
effect->timer--;
} else {
particle->isVisible = false;
effect->isEnabled = false;
}
}
}
}
void EnRaf_DrawParticles(EnRaf* this, GlobalContext* globalCtx) {
void EnRaf_DrawEffects(EnRaf* this, GlobalContext* globalCtx) {
s16 i;
EnRafParticle* particle = this->particles;
EnRafEffect* effect = this->effects;
GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
OPEN_DISPS(gfxCtx);
func_8012C28C(globalCtx->state.gfxCtx);
for (i = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
if (particle->isVisible) {
Matrix_Translate(particle->position.x, particle->position.y, particle->position.z, MTXMODE_NEW);
Matrix_Scale(particle->scale, particle->scale, particle->scale, MTXMODE_APPLY);
Matrix_RotateXS(particle->rotation.x, MTXMODE_APPLY);
Matrix_RotateYS(particle->rotation.y, MTXMODE_APPLY);
Matrix_RotateZS(particle->rotation.z, MTXMODE_APPLY);
for (i = 0; i < ARRAY_COUNT(this->effects); i++, effect++) {
if (effect->isEnabled) {
Matrix_Translate(effect->pos.x, effect->pos.y, effect->pos.z, MTXMODE_NEW);
Matrix_Scale(effect->scale, effect->scale, effect->scale, MTXMODE_APPLY);
Matrix_RotateXS(effect->rotation.x, MTXMODE_APPLY);
Matrix_RotateYS(effect->rotation.y, MTXMODE_APPLY);
Matrix_RotateZS(effect->rotation.z, MTXMODE_APPLY);
gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPDisplayList(POLY_OPA_DISP++, gCarnivorousLilyPadParticleDL);
src/overlays/actors/ovl_En_Raf/z_en_raf.h
+8 -6
View File
@@ -11,7 +11,7 @@
typedef enum {
/* 0 */ EN_RAF_TYPE_NORMAL,
/* 1 */ EN_RAF_TYPE_DORMANT, // Spawns without trap, so it can't eat bombs/player
/* 2 */ EN_RAF_TYPE_NO_WATER_INTERACTIONS // Won't produce ripples, and particles won't produce splashes
/* 2 */ EN_RAF_TYPE_NO_WATER_INTERACTIONS // Won't produce ripples, and effects won't produce splashes
} EnRafType;
struct EnRaf;
@@ -19,14 +19,16 @@ struct EnRaf;
typedef void (*EnRafActionFunc)(struct EnRaf*, GlobalContext*);
typedef struct {
/* 0x00 */ u8 isVisible;
/* 0x04 */ Vec3f position;
/* 0x00 */ u8 isEnabled;
/* 0x04 */ Vec3f pos;
/* 0x10 */ Vec3f velocity;
/* 0x1C */ Vec3f acceleration;
/* 0x1C */ Vec3f accel;
/* 0x28 */ Vec3s rotation;
/* 0x30 */ f32 scale;
/* 0x34 */ s16 timer;
} EnRafParticle; // size = 0x38
} EnRafEffect; // size = 0x38
#define EN_RAF_EFFECT_COUNT 31
typedef struct EnRaf {
/* 0x000 */ DynaPolyActor dyna;
@@ -59,7 +61,7 @@ typedef struct EnRaf {
/* 0x3CC */ s16 petalClearPixelSecondPassIndex;
/* 0x3CE */ s16 teethClearPixelSecondPassIndex;
/* 0x3D0 */ ColliderCylinder collider;
/* 0x41C */ EnRafParticle particles[31];
/* 0x41C */ EnRafEffect effects[EN_RAF_EFFECT_COUNT];
} EnRaf; // size = 0xAE4
extern const ActorInit En_Raf_InitVars;
src/overlays/actors/ovl_Obj_Chan/z_obj_chan.c
+3 -3
View File
@@ -66,7 +66,7 @@ static InitChainEntry sInitChain[] = {
void ObjChan_InitChandelier(ObjChan* this2, GlobalContext* globalCtx);
void ObjChan_InitPot(ObjChan* this, GlobalContext* globalCtx);
void ObjChan_CreateSmashParticles(ObjChan* this, GlobalContext* globalCtx);
void ObjChan_CreateSmashEffects(ObjChan* this, GlobalContext* globalCtx);
void ObjChan_DrawPot(Actor* thisx, GlobalContext* globalCtx);
void ObjChan_DrawFire(ObjChan* this, GlobalContext* globalCtx);
@@ -305,7 +305,7 @@ void ObjChan_PotAction(ObjChan* this, GlobalContext* globalCtx) {
}
}
if (potBreaks) {
ObjChan_CreateSmashParticles(this, globalCtx);
ObjChan_CreateSmashEffects(this, globalCtx);
((ObjChan*)this->actor.parent)->pots[this->myPotIndex] = NULL;
SoundSource_PlaySfxAtFixedWorldPos(globalCtx, &this->actor.world.pos, 20, NA_SE_EV_CHANDELIER_BROKEN);
func_80BB9A1C((ObjChan*)this->actor.parent, 40.0f);
@@ -321,7 +321,7 @@ void ObjChan_PotAction(ObjChan* this, GlobalContext* globalCtx) {
}
}
void ObjChan_CreateSmashParticles(ObjChan* this, GlobalContext* globalCtx) {
void ObjChan_CreateSmashEffects(ObjChan* this, GlobalContext* globalCtx) {
s16 new_var = 0;
s32 phi_s0;
Vec3f spDC;
tools/disasm/functions.txt
+15 -15
View File
@@ -6523,9 +6523,9 @@
0x808E18A8:("EnEncount2_Die",),
0x808E18F8:("EnEncount2_Update",),
0x808E19C4:("EnEncount2_Draw",),
0x808E1A24:("EnEncount2_InitParticles",),
0x808E1B4C:("EnEncount2_UpdateParticles",),
0x808E1C9C:("EnEncount2_DrawParticles",),
0x808E1A24:("EnEncount2_InitEffects",),
0x808E1B4C:("EnEncount2_UpdateEffects",),
0x808E1C9C:("EnEncount2_DrawEffects",),
0x808E1FE0:("EnFireRock_Init",),
0x808E1FF0:("EnFireRock_Destroy",),
0x808E2000:("EnFireRock_Update",),
@@ -9769,9 +9769,9 @@
0x80A181B4:("EnRaf_Update",),
0x80A1859C:("EnRaf_TransformLimbDraw",),
0x80A18A08:("EnRaf_Draw",),
0x80A18A90:("EnRaf_InitializeParticle",),
0x80A18B8C:("EnRaf_UpdateParticles",),
0x80A18DA0:("EnRaf_DrawParticles",),
0x80A18A90:("EnRaf_InitializeEffect",),
0x80A18B8C:("EnRaf_UpdateEffects",),
0x80A18DA0:("EnRaf_DrawEffects",),
0x80A19740:("ObjFunen_Init",),
0x80A19778:("ObjFunen_Draw",),
0x80A19910:("ObjRaillift_UpdatePosition",),
@@ -10308,9 +10308,9 @@
0x80A3BC88:("EnBaguo_Update",),
0x80A3BE24:("EnBaguo_PostLimbDraw",),
0x80A3BE60:("EnBaguo_DrawBody",),
0x80A3BF0C:("EnBaguo_InitializeParticle",),
0x80A3C008:("EnBaguo_UpdateParticles",),
0x80A3C17C:("EnBaguo_DrawRockParticles",),
0x80A3BF0C:("EnBaguo_InitializeEffect",),
0x80A3C008:("EnBaguo_UpdateEffects",),
0x80A3C17C:("EnBaguo_DrawEffects",),
0x80A3C4E0:("func_80A3C4E0",),
0x80A3C560:("func_80A3C560",),
0x80A3C658:("func_80A3C658",),
@@ -10908,7 +10908,7 @@
0x80A6B3F8:("EnMushi2_Update",),
0x80A6B8D0:("EnMushi2_Draw",),
0x80A6BF90:("EnFall_Moon_AdjustScaleAndPosition",),
0x80A6C1DC:("EnFall_RisingDebris_ResetParticles",),
0x80A6C1DC:("EnFall_RisingDebris_ResetEffects",),
0x80A6C22C:("EnFall_Init",),
0x80A6C39C:("EnFall_Destroy",),
0x80A6C3AC:("EnFall_MoonsTear_GetTerminaFieldMoon",),
@@ -10925,8 +10925,8 @@
0x80A6D0DC:("EnFall_Update",),
0x80A6D100:("EnFall_FireBall_SetPerVertexAlpha",),
0x80A6D220:("EnFall_FireBall_Update",),
0x80A6D444:("EnFall_RisingDebris_UpdateParticles",),
0x80A6D504:("EnFall_RisingDebris_InitializeParticles",),
0x80A6D444:("EnFall_RisingDebris_UpdateEffects",),
0x80A6D504:("EnFall_RisingDebris_InitializeEffect",),
0x80A6D698:("EnFall_RisingDebris_Update",),
0x80A6D75C:("EnFall_FireRing_Update",),
0x80A6D88C:("EnFall_Moon_Draw",),
@@ -13669,8 +13669,8 @@
0x80B40100:("func_80B40100",),
0x80B40160:("func_80B40160",),
0x80B401F8:("func_80B401F8",),
0x80B40308:("func_80B40308",),
0x80B40394:("func_80B40394",),
0x80B40308:("BgGoronOyu_UpdateWaterBoxInfo",),
0x80B40394:("BgGoronOyu_SpawnEffects",),
0x80B4056C:("BgGoronOyu_Init",),
0x80B40628:("BgGoronOyu_Destroy",),
0x80B4065C:("BgGoronOyu_Update",),
@@ -15380,7 +15380,7 @@
0x80BB9F24:("ObjChan_ChandelierAction",),
0x80BBA2FC:("ObjChan_InitPot",),
0x80BBA314:("ObjChan_PotAction",),
0x80BBA488:("ObjChan_CreateSmashParticles",),
0x80BBA488:("ObjChan_CreateSmashEffects",),
0x80BBA738:("ObjChan_Update",),
0x80BBA78C:("ObjChan_Draw",),
0x80BBA894:("ObjChan_DrawPot",),