mirror/mm
1
0
Fork 0
mirror of https://github.com/zeldaret/mm.git synced 2026-07-09 13:45:23 -04:00
Code Issues Packages Projects Releases Wiki Activity

Decompile and clean up some effect files (#342)

Browse Source 
* Decompile various effect files and cleanup z_effect.c

* Decompile z_eff_tire_mark.c and cleanup structs

* Small cleanups

* Apply most review suggestions

* Apply more review suggestions

* Change eff_shield_particle vertices to be extracted as an asset

* Add relevant effect functions to actorfixer.py
This commit is contained in:
Roman971
2021-12-27 03:51:16 +01:00
committed by GitHub
parent 6fba9aa388
commit 6c2f521373
23 changed files with 2198 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/code/z_collision_check.c
+32 -32
View File
@@ -27,12 +27,12 @@ Vec3f D_801EE1C0;
Vec3f D_801EE1D0;
Vec3f D_801EE1E0;
Vec3f D_801EE1F0;
EffSparkParams D_801EE200;
EffectSparkInit D_801EE200;
TriNorm D_801EE6C8;
TriNorm D_801EE700;
EffSparkParams D_801EE738;
EffSparkParams D_801EEC00;
EffSparkParams D_801EF0C8;
EffectSparkInit D_801EE738;
EffectSparkInit D_801EEC00;
EffectSparkInit D_801EF0C8;
TriNorm D_801EF590;
TriNorm D_801EF5C8;
TriNorm D_801EF600;
@@ -1382,14 +1382,14 @@ void CollisionCheck_NoBlood(GlobalContext* globalCtx, Collider* collider, Vec3f*
#ifdef NON_MATCHING
// needs in-function static bss
void CollisionCheck_BlueBlood(GlobalContext* globalCtx, Collider* collider, Vec3f* v) {
static EffSparkParams D_801EEC00;
static EffectSparkInit D_801EEC00;
s32 effectIndex;
D_801EEC00.position.x = v->x;
D_801EEC00.position.x = v->y;
D_801EEC00.position.x = v->z;
D_801EEC00.particleFactor1 = 5;
D_801EEC00.particleFactor2 = 5;
D_801EEC00.uDiv = 5;
D_801EEC00.vDiv = 5;
D_801EEC00.colorStart[0].r = 10;
D_801EEC00.colorStart[0].g = 10;
D_801EEC00.colorStart[0].b = 200;
@@ -1422,12 +1422,12 @@ void CollisionCheck_BlueBlood(GlobalContext* globalCtx, Collider* collider, Vec3
D_801EEC00.colorEnd[3].g = 0;
D_801EEC00.colorEnd[3].b = 64;
D_801EEC00.colorEnd[3].a = 0;
D_801EEC00.age = 0;
D_801EEC00.timer = 0;
D_801EEC00.duration = 16;
D_801EEC00.velocity = 8.0f;
D_801EEC00.speed = 8.0f;
D_801EEC00.gravity = -1.0f;
Effect_Add(globalCtx, &effectIndex, 0, 0, 1, &D_801EEC00);
Effect_Add(globalCtx, &effectIndex, EFFECT_SPARK, 0, 1, &D_801EEC00);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/CollisionCheck_BlueBlood.s")
@@ -1440,14 +1440,14 @@ void CollisionCheck_BlueBlood(GlobalContext* globalCtx, Collider* collider, Vec3
#ifdef NON_MATCHING
// needs in-function static bss
void CollisionCheck_GreenBlood(GlobalContext* globalCtx, Collider* collider, Vec3f* v) {
static EffSparkParams D_801EF0C8;
static EffectSparkInit D_801EF0C8;
s32 effectIndex;
D_801EF0C8.position.x = v->x;
D_801EF0C8.position.x = v->y;
D_801EF0C8.position.x = v->z;
D_801EF0C8.particleFactor1 = 5;
D_801EF0C8.particleFactor2 = 5;
D_801EF0C8.uDiv = 5;
D_801EF0C8.vDiv = 5;
D_801EF0C8.colorStart[0].r = 10;
D_801EF0C8.colorStart[0].g = 200;
D_801EF0C8.colorStart[0].b = 10;
@@ -1480,11 +1480,11 @@ void CollisionCheck_GreenBlood(GlobalContext* globalCtx, Collider* collider, Vec
D_801EF0C8.colorEnd[3].g = 64;
D_801EF0C8.colorEnd[3].b = 0;
D_801EF0C8.colorEnd[3].a = 0;
D_801EF0C8.age = 0;
D_801EF0C8.timer = 0;
D_801EF0C8.duration = 16;
D_801EF0C8.velocity = 8.0f;
D_801EF0C8.speed = 8.0f;
D_801EF0C8.gravity = -1.0f;
Effect_Add(globalCtx, &effectIndex, 0, 0, 1, &D_801EF0C8);
Effect_Add(globalCtx, &effectIndex, EFFECT_SPARK, 0, 1, &D_801EF0C8);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/CollisionCheck_GreenBlood.s")
@@ -3751,14 +3751,14 @@ void Collider_UpdateSphere(s32 limb, ColliderSphere* collider) {
#ifdef NON_MATCHING
// needs in-function static bss
void CollisionCheck_SpawnRedBlood(GlobalContext* globalCtx, Vec3f* v) {
static EffSparkParams D_801EE200;
static EffectSparkInit D_801EE200;
s32 effectIndex;
D_801EE200.position.x = v->x;
D_801EE200.position.x = v->y;
D_801EE200.position.x = v->z;
D_801EE200.particleFactor1 = 5;
D_801EE200.particleFactor2 = 5;
D_801EE200.uDiv = 5;
D_801EE200.vDiv = 5;
D_801EE200.colorStart[0].r = 128;
D_801EE200.colorStart[0].g = 0;
D_801EE200.colorStart[0].b = 64;
@@ -3791,12 +3791,12 @@ void CollisionCheck_SpawnRedBlood(GlobalContext* globalCtx, Vec3f* v) {
D_801EE200.colorEnd[3].g = 0;
D_801EE200.colorEnd[3].b = 64;
D_801EE200.colorEnd[3].a = 0;
D_801EE200.age = 0;
D_801EE200.timer = 0;
D_801EE200.duration = 16;
D_801EE200.velocity = 8.0f;
D_801EE200.speed = 8.0f;
D_801EE200.gravity = -1.0f;
Effect_Add(globalCtx, &effectIndex, 0, 0, 1, &D_801EE200);
Effect_Add(globalCtx, &effectIndex, EFFECT_SPARK, 0, 1, &D_801EE200);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/CollisionCheck_SpawnRedBlood.s")
@@ -3809,14 +3809,14 @@ void CollisionCheck_SpawnRedBlood(GlobalContext* globalCtx, Vec3f* v) {
#ifdef NON_MATCHING
// needs in-function static bss
void CollisionCheck_SpawnWaterDroplets(GlobalContext* globalCtx, Vec3f* v) {
static EffSparkParams D_801EE738;
static EffectSparkInit D_801EE738;
s32 effectIndex;
D_801EE738.position.x = v->x;
D_801EE738.position.x = v->y;
D_801EE738.position.x = v->z;
D_801EE738.particleFactor1 = 5;
D_801EE738.particleFactor2 = 5;
D_801EE738.uDiv = 5;
D_801EE738.vDiv = 5;
D_801EE738.colorStart[0].r = 255;
D_801EE738.colorStart[0].g = 255;
D_801EE738.colorStart[0].b = 255;
@@ -3849,12 +3849,12 @@ void CollisionCheck_SpawnWaterDroplets(GlobalContext* globalCtx, Vec3f* v) {
D_801EE738.colorEnd[3].g = 0;
D_801EE738.colorEnd[3].b = 0;
D_801EE738.colorEnd[3].a = 0;
D_801EE738.age = 0;
D_801EE738.timer = 0;
D_801EE738.duration = 16;
D_801EE738.velocity = 8.0f;
D_801EE738.speed = 8.0f;
D_801EE738.gravity = -1.0f;
Effect_Add(globalCtx, &effectIndex, 0, 0, 1, &D_801EE738);
Effect_Add(globalCtx, &effectIndex, EFFECT_SPARK, 0, 1, &D_801EE738);
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/z_collision_check/CollisionCheck_SpawnWaterDroplets.s")
@@ -3864,7 +3864,7 @@ void CollisionCheck_SpawnWaterDroplets(GlobalContext* globalCtx, Vec3f* v) {
* Spawns streaks of light from hits against solid objects
*/
void CollisionCheck_SpawnShieldParticles(GlobalContext* globalCtx, Vec3f* v) {
static EffShieldParticleInit shieldParticleInitMetal = {
static EffectShieldParticleInit shieldParticleInitMetal = {
16,
{ 0, 0, 0 },
{ 0, 200, 255, 255 },
@@ -3889,7 +3889,7 @@ void CollisionCheck_SpawnShieldParticles(GlobalContext* globalCtx, Vec3f* v) {
shieldParticleInitMetal.lightPoint.y = shieldParticleInitMetal.position.y;
shieldParticleInitMetal.lightPoint.z = shieldParticleInitMetal.position.z;
Effect_Add(globalCtx, &effectIndex, 3, 0, 1, &shieldParticleInitMetal);
Effect_Add(globalCtx, &effectIndex, EFFECT_SHIELD_PARTICLE, 0, 1, &shieldParticleInitMetal);
}
/**
@@ -3919,7 +3919,7 @@ void CollisionCheck_SpawnShieldParticlesMetal2(GlobalContext* globalCtx, Vec3f*
* Spawns streaks of light and makes a wooden sound
*/
void CollisionCheck_SpawnShieldParticlesWood(GlobalContext* globalCtx, Vec3f* v, Vec3f* pos) {
static EffShieldParticleInit shieldParticleInitWood = {
static EffectShieldParticleInit shieldParticleInitWood = {
16,
{ 0, 0, 0 },
{ 0, 200, 255, 255 },
@@ -3944,7 +3944,7 @@ void CollisionCheck_SpawnShieldParticlesWood(GlobalContext* globalCtx, Vec3f* v,
shieldParticleInitWood.lightPoint.y = shieldParticleInitWood.position.y;
shieldParticleInitWood.lightPoint.z = shieldParticleInitWood.position.z;
Effect_Add(globalCtx, &effectIndex, 3, 0, 1, &shieldParticleInitWood);
Effect_Add(globalCtx, &effectIndex, EFFECT_SHIELD_PARTICLE, 0, 1, &shieldParticleInitWood);
func_8019F1C0(pos, NA_SE_IT_REFLECTION_WOOD);
}
src/code/z_eff_blure.c
+975 -36
View File
File diff suppressed because it is too large Load Diff
src/code/z_eff_shield_particle.c
+201 -5
View File
@@ -1,11 +1,207 @@
#include "global.h"
#include "vt.h"
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/EffectShieldParticle_Init.s")
#include "assets/code/eff_shield_particle/eff_shield_particle.c"
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/EffectShieldParticle_Destroy.s")
void EffectShieldParticle_Init(void* thisx, void* initParamsx) {
EffectShieldParticle* this = (EffectShieldParticle*)thisx;
EffectShieldParticleInit* initParams = (EffectShieldParticleInit*)initParamsx;
EffectShieldParticleElement* elem;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/EffectShieldParticle_Update.s")
if ((this != NULL) && (initParams != NULL)) {
this->numElements = initParams->numElements;
if (this->numElements > ARRAY_COUNT(this->elements)) {
return;
}
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/EffectShieldParticle_CalculateColors.s")
this->position = initParams->position;
this->primColorStart = initParams->primColorStart;
this->envColorStart = initParams->envColorStart;
this->primColorMid = initParams->primColorMid;
this->envColorMid = initParams->envColorMid;
this->primColorEnd = initParams->primColorEnd;
this->envColorEnd = initParams->envColorEnd;
this->deceleration = initParams->deceleration;
this->maxInitialSpeed = initParams->maxInitialSpeed;
this->lengthCutoff = initParams->lengthCutoff;
this->duration = initParams->duration;
this->timer = 0;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_shield_particle/EffectShieldParticle_Draw.s")
for (elem = &this->elements[0]; elem < &this->elements[this->numElements]; elem++) {
elem->initialSpeed = (Rand_ZeroOne() * (this->maxInitialSpeed * 0.5f)) + (this->maxInitialSpeed * 0.5f);
elem->endX = 0.0f;
elem->startXChange = 0.0f;
elem->startX = 0.0f;
elem->endXChange = elem->initialSpeed;
elem->yaw = Rand_ZeroOne() * 65534.0f;
elem->pitch = Rand_ZeroOne() * 65534.0f;
}
this->lightDecay = initParams->lightDecay;
if (this->lightDecay == true) {
this->lightInfo.type = LIGHT_POINT_NOGLOW;
this->lightInfo.params.point = initParams->lightPoint;
this->lightNode =
LightContext_InsertLight(Effect_GetGlobalCtx(), &Effect_GetGlobalCtx()->lightCtx, &this->lightInfo);
} else {
this->lightNode = NULL;
}
}
}
void EffectShieldParticle_Destroy(void* thisx) {
EffectShieldParticle* this = (EffectShieldParticle*)thisx;
if ((this != NULL) && (this->lightDecay == true)) {
if (this->lightNode == Effect_GetGlobalCtx()->lightCtx.listHead) {
Effect_GetGlobalCtx()->lightCtx.listHead = this->lightNode->next;
}
LightContext_RemoveLight(Effect_GetGlobalCtx(), &Effect_GetGlobalCtx()->lightCtx, this->lightNode);
}
}
s32 EffectShieldParticle_Update(void* thisx) {
EffectShieldParticle* this = (EffectShieldParticle*)thisx;
EffectShieldParticleElement* elem;
if (this == NULL) {
return 0;
}
for (elem = &this->elements[0]; elem < &this->elements[this->numElements]; elem++) {
elem->endXChange -= this->deceleration;
if (elem->endXChange < 0.0f) {
elem->endXChange = 0.0f;
}
if (elem->startXChange > 0.0f) {
elem->startXChange -= this->deceleration;
if (elem->startXChange < 0.0f) {
elem->startXChange = 0.0f;
}
}
elem->endX += elem->endXChange;
elem->startX += elem->startXChange;
if ((elem->startXChange == 0.0f) && (this->lengthCutoff < (elem->endX - elem->startX))) {
elem->startXChange = elem->initialSpeed;
}
}
if (this->lightDecay == true) {
this->lightInfo.params.point.radius /= 2;
}
this->timer++;
if (this->duration < this->timer) {
return 1;
}
return 0;
}
void EffectShieldParticle_GetColors(EffectShieldParticle* this, Color_RGBA8* primColor, Color_RGBA8* envColor) {
s32 halfDuration = this->duration * 0.5f;
if (halfDuration == 0) {
primColor->r = this->primColorStart.r;
primColor->g = this->primColorStart.g;
primColor->b = this->primColorStart.b;
primColor->a = this->primColorStart.a;
envColor->r = this->envColorStart.r;
envColor->g = this->envColorStart.g;
envColor->b = this->envColorStart.b;
envColor->a = this->envColorStart.a;
} else if (this->timer < halfDuration) {
f32 ratio = this->timer / (f32)halfDuration;
primColor->r = LERPIMP(this->primColorStart.r, this->primColorMid.r, ratio);
primColor->g = LERPIMP(this->primColorStart.g, this->primColorMid.g, ratio);
primColor->b = LERPIMP(this->primColorStart.b, this->primColorMid.b, ratio);
primColor->a = LERPIMP(this->primColorStart.a, this->primColorMid.a, ratio);
envColor->r = LERPIMP(this->envColorStart.r, this->envColorMid.r, ratio);
envColor->g = LERPIMP(this->envColorStart.g, this->envColorMid.g, ratio);
envColor->b = LERPIMP(this->envColorStart.b, this->envColorMid.b, ratio);
envColor->a = LERPIMP(this->envColorStart.a, this->envColorMid.a, ratio);
} else {
f32 ratio = (this->timer - halfDuration) / (f32)halfDuration;
primColor->r = LERPIMP(this->primColorMid.r, this->primColorEnd.r, ratio);
primColor->g = LERPIMP(this->primColorMid.g, this->primColorEnd.g, ratio);
primColor->b = LERPIMP(this->primColorMid.b, this->primColorEnd.b, ratio);
primColor->a = LERPIMP(this->primColorMid.a, this->primColorEnd.a, ratio);
envColor->r = LERPIMP(this->envColorMid.r, this->envColorEnd.r, ratio);
envColor->g = LERPIMP(this->envColorMid.g, this->envColorEnd.g, ratio);
envColor->b = LERPIMP(this->envColorMid.b, this->envColorEnd.b, ratio);
envColor->a = LERPIMP(this->envColorMid.a, this->envColorEnd.a, ratio);
}
}
void EffectShieldParticle_Draw(void* thisx, GraphicsContext* gfxCtx) {
EffectShieldParticle* this = (EffectShieldParticle*)thisx;
EffectShieldParticleElement* elem;
Color_RGBA8 primColor;
Color_RGBA8 envColor;
OPEN_DISPS(gfxCtx);
if (this != NULL) {
POLY_XLU_DISP = Gfx_CallSetupDL(POLY_XLU_DISP, 0x26);
gDPSetCycleType(POLY_XLU_DISP++, G_CYC_2CYCLE);
gDPPipeSync(POLY_XLU_DISP++);
gSPTexture(POLY_XLU_DISP++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
gDPLoadTextureBlock(POLY_XLU_DISP++, D_04054F20, G_IM_FMT_I, G_IM_SIZ_8b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD);
gDPSetCombineLERP(POLY_XLU_DISP++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, PRIMITIVE, 0, TEXEL0, 0, 0, 0,
0, COMBINED, 0, 0, 0, COMBINED);
gDPSetRenderMode(POLY_XLU_DISP++, G_RM_PASS, G_RM_ZB_CLD_SURF2);
gSPClearGeometryMode(POLY_XLU_DISP++, G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR);
gSPSetGeometryMode(POLY_XLU_DISP++, G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH);
EffectShieldParticle_GetColors(this, &primColor, &envColor);
gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, primColor.r, primColor.g, primColor.b, primColor.a);
gDPSetEnvColor(POLY_XLU_DISP++, envColor.r, envColor.g, envColor.b, envColor.a);
gDPPipeSync(POLY_XLU_DISP++);
for (elem = &this->elements[0]; elem < &this->elements[this->numElements]; elem++) {
Mtx* mtx;
MtxF sp104;
MtxF spC4;
MtxF sp84;
f32 temp1 = (elem->endX + elem->startX) * 0.5f;
f32 temp2 = elem->endX - elem->startX;
f32 temp3 = (temp2 * (1.0f / 64.0f)) / 0.02f;
if (temp3 < 1.0f) {
temp3 = 1.0f;
}
SkinMatrix_SetTranslate(&spC4, this->position.x, this->position.y, this->position.z);
SkinMatrix_SetRotateRPY(&sp104, 0, elem->yaw, 0);
SkinMatrix_MtxFMtxFMult(&spC4, &sp104, &sp84);
SkinMatrix_SetRotateRPY(&sp104, 0, 0, elem->pitch);
SkinMatrix_MtxFMtxFMult(&sp84, &sp104, &spC4);
SkinMatrix_SetTranslate(&sp104, temp1, 0.0f, 0.0f);
SkinMatrix_MtxFMtxFMult(&spC4, &sp104, &sp84);
SkinMatrix_SetScale(&sp104, temp3 * 0.02f, 0.02f, 0.02f);
SkinMatrix_MtxFMtxFMult(&sp84, &sp104, &spC4);
mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &spC4);
if (mtx == NULL) {
break;
}
gSPMatrix(POLY_XLU_DISP++, mtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPVertex(POLY_XLU_DISP++, sEffShieldParticleVtx, 4, 0);
gSP2Triangles(POLY_XLU_DISP++, 0, 1, 2, 0, 0, 3, 1, 0);
}
}
CLOSE_DISPS(gfxCtx);
}
src/code/z_eff_spark.c
+260 -4
View File
@@ -1,9 +1,265 @@
#include "global.h"
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/EffectSpark_Init.s")
void EffectSpark_Init(void* thisx, void* initParamsx) {
EffectSpark* this = (EffectSpark*)thisx;
EffectSparkInit* initParams = (EffectSparkInit*)initParamsx;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/EffectSpark_Destroy.s")
f32 velocityNorm;
s32 i;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/EffectSpark_Update.s")
if ((this != NULL) && (initParams != NULL)) {
if ((initParams->uDiv == 0) || (initParams->vDiv == 0)) {
return;
}
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_spark/EffectSpark_Draw.s")
this->position = initParams->position;
this->speed = initParams->speed;
this->gravity = initParams->gravity;
this->uDiv = initParams->uDiv;
this->vDiv = initParams->vDiv;
this->colorStart[0].r = initParams->colorStart[0].r;
this->colorStart[0].g = initParams->colorStart[0].g;
this->colorStart[0].b = initParams->colorStart[0].b;
this->colorStart[0].a = initParams->colorStart[0].a;
this->colorStart[1].r = initParams->colorStart[1].r;
this->colorStart[1].g = initParams->colorStart[1].g;
this->colorStart[1].b = initParams->colorStart[1].b;
this->colorStart[1].a = initParams->colorStart[1].a;
this->colorStart[2].r = initParams->colorStart[2].r;
this->colorStart[2].g = initParams->colorStart[2].g;
this->colorStart[2].b = initParams->colorStart[2].b;
this->colorStart[2].a = initParams->colorStart[2].a;
this->colorStart[3].r = initParams->colorStart[3].r;
this->colorStart[3].g = initParams->colorStart[3].g;
this->colorStart[3].b = initParams->colorStart[3].b;
this->colorStart[3].a = initParams->colorStart[3].a;
this->colorEnd[0].r = initParams->colorEnd[0].r;
this->colorEnd[0].g = initParams->colorEnd[0].g;
this->colorEnd[0].b = initParams->colorEnd[0].b;
this->colorEnd[0].a = initParams->colorEnd[0].a;
this->colorEnd[1].r = initParams->colorEnd[1].r;
this->colorEnd[1].g = initParams->colorEnd[1].g;
this->colorEnd[1].b = initParams->colorEnd[1].b;
this->colorEnd[1].a = initParams->colorEnd[1].a;
this->colorEnd[2].r = initParams->colorEnd[2].r;
this->colorEnd[2].g = initParams->colorEnd[2].g;
this->colorEnd[2].b = initParams->colorEnd[2].b;
this->colorEnd[2].a = initParams->colorEnd[2].a;
this->colorEnd[3].r = initParams->colorEnd[3].r;
this->colorEnd[3].g = initParams->colorEnd[3].g;
this->colorEnd[3].b = initParams->colorEnd[3].b;
this->colorEnd[3].a = initParams->colorEnd[3].a;
this->duration = initParams->duration;
this->numElements = (this->uDiv * this->vDiv) + 2;
if (this->numElements > ARRAY_COUNT(this->elements)) {
return;
}
for (i = 0; i < this->numElements; i++) {
EffectSparkElement* elem = &this->elements[i];
elem->position.x = this->position.x;
elem->position.y = this->position.y;
elem->position.z = this->position.z;
elem->velocity.x = Rand_ZeroOne() - 0.5f;
elem->velocity.y = Rand_ZeroOne() - 0.5f;
elem->velocity.z = Rand_ZeroOne() - 0.5f;
velocityNorm = sqrtf(SQXYZ(elem->velocity));
if (!(fabsf(velocityNorm) < 0.008f)) {
elem->velocity.x *= this->speed * (1.0f / velocityNorm);
elem->velocity.y *= this->speed * (1.0f / velocityNorm);
elem->velocity.z *= this->speed * (1.0f / velocityNorm);
} else {
elem->velocity.x = elem->velocity.z = 0.0f;
elem->velocity.y = this->speed;
}
elem->unkVelocity.x = 30000.0f - Rand_ZeroOne() * 15000.0f;
elem->unkVelocity.y = 30000.0f - Rand_ZeroOne() * 15000.0f;
elem->unkVelocity.z = 30000.0f - Rand_ZeroOne() * 15000.0f;
elem->unkPosition.x = Rand_ZeroOne() * 65534.0f;
elem->unkPosition.y = Rand_ZeroOne() * 65534.0f;
elem->unkPosition.z = Rand_ZeroOne() * 65534.0f;
}
this->timer = 0;
}
}
void EffectSpark_Destroy(void* thisx) {
}
s32 EffectSpark_Update(void* thisx) {
EffectSpark* this = (EffectSpark*)thisx;
EffectSparkElement* elem;
s32 i;
for (i = 0; i < this->numElements; i++) {
elem = &this->elements[i];
elem->position.x += elem->velocity.x;
elem->position.y += elem->velocity.y;
elem->position.z += elem->velocity.z;
elem->velocity.y += this->gravity;
elem->unkPosition.x += elem->unkVelocity.x;
elem->unkPosition.y += elem->unkVelocity.y;
elem->unkPosition.z += elem->unkVelocity.z;
}
this->timer++;
if (this->duration < this->timer) {
return 1;
} else {
return 0;
}
}
void EffectSpark_Draw(void* thisx, GraphicsContext* gfxCtx) {
Vtx* vertices;
EffectSpark* this = (EffectSpark*)thisx;
GlobalContext* globalCtx = Effect_GetGlobalCtx();
s32 i;
s32 j;
u8 sp1D3;
u8 sp1D2;
u8 sp1D1;
u8 sp1D0;
u8 sp1CF;
u8 sp1CE;
u8 sp1CD;
u8 sp1CC;
u8 sp1CB;
u8 sp1CA;
u8 sp1C9;
u8 sp1C8;
u8 sp1C7;
u8 sp1C6;
u8 sp1C5;
u8 sp1C4;
f32 ratio;
OPEN_DISPS(gfxCtx);
if (this != NULL) {
gSPMatrix(POLY_XLU_DISP++, &D_801D1DE0, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
POLY_XLU_DISP = Gfx_CallSetupDL(POLY_XLU_DISP, 0x26);
gDPSetCycleType(POLY_XLU_DISP++, G_CYC_2CYCLE);
gDPPipeSync(POLY_XLU_DISP++);
gSPTexture(POLY_XLU_DISP++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
gDPLoadTextureBlock(POLY_XLU_DISP++, D_04054F20, G_IM_FMT_I, G_IM_SIZ_8b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD);
gDPSetCombineMode(POLY_XLU_DISP++, G_CC_SHADEDECALA, G_CC_PASS2);
gDPSetRenderMode(POLY_XLU_DISP++, G_RM_PASS, G_RM_ZB_CLD_SURF2);
gSPClearGeometryMode(POLY_XLU_DISP++, G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR);
gSPSetGeometryMode(POLY_XLU_DISP++, G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH);
gDPPipeSync(POLY_XLU_DISP++);
vertices = GRAPH_ALLOC(gfxCtx, ALIGN16(this->numElements * sizeof(Vtx[4])));
if (vertices == NULL) {
goto end;
}
j = 0;
ratio = (f32)this->timer / (f32)this->duration;
sp1D3 = F32_LERPIMP(this->colorStart[0].r, this->colorEnd[0].r, ratio);
sp1D2 = F32_LERPIMP(this->colorStart[0].g, this->colorEnd[0].g, ratio);
sp1D1 = F32_LERPIMP(this->colorStart[0].b, this->colorEnd[0].b, ratio);
sp1D0 = F32_LERPIMP(this->colorStart[0].a, this->colorEnd[0].a, ratio);
sp1CF = F32_LERPIMP(this->colorStart[1].r, this->colorEnd[1].r, ratio);
sp1CE = F32_LERPIMP(this->colorStart[1].g, this->colorEnd[1].g, ratio);
sp1CD = F32_LERPIMP(this->colorStart[1].b, this->colorEnd[1].b, ratio);
sp1CC = F32_LERPIMP(this->colorStart[1].a, this->colorEnd[1].a, ratio);
sp1CB = F32_LERPIMP(this->colorStart[2].r, this->colorEnd[2].r, ratio);
sp1CA = F32_LERPIMP(this->colorStart[2].g, this->colorEnd[2].g, ratio);
sp1C9 = F32_LERPIMP(this->colorStart[2].b, this->colorEnd[2].b, ratio);
sp1C8 = F32_LERPIMP(this->colorStart[2].a, this->colorEnd[2].a, ratio);
sp1C7 = F32_LERPIMP(this->colorStart[3].r, this->colorEnd[3].r, ratio);
sp1C6 = F32_LERPIMP(this->colorStart[3].g, this->colorEnd[3].g, ratio);
sp1C5 = F32_LERPIMP(this->colorStart[3].b, this->colorEnd[3].b, ratio);
sp1C4 = F32_LERPIMP(this->colorStart[3].a, this->colorEnd[3].a, ratio);
for (i = 0; i < this->numElements; i++) {
MtxF sp12C;
MtxF spEC;
MtxF spAC;
MtxF sp6C;
EffectSparkElement* elem = &this->elements[i];
Mtx* mtx;
f32 temp;
SkinMatrix_SetTranslate(&spEC, elem->position.x, elem->position.y, elem->position.z);
temp = ((Rand_ZeroOne() * 2.5f) + 1.5f) / 64.0f;
SkinMatrix_SetScale(&spAC, temp, temp, 1.0f);
SkinMatrix_MtxFMtxFMult(&spEC, &globalCtx->billboardMtxF, &sp6C);
SkinMatrix_MtxFMtxFMult(&sp6C, &spAC, &sp12C);
vertices[j].v.ob[0] = -32;
vertices[j].v.ob[1] = -32;
vertices[j].v.ob[2] = 0;
vertices[j].v.cn[0] = sp1D3;
vertices[j].v.cn[1] = sp1D2;
vertices[j].v.cn[2] = sp1D1;
vertices[j].v.cn[3] = sp1D0;
vertices[j].v.tc[0] = 0;
vertices[j].v.tc[1] = 1024;
vertices[j].v.flag = 0;
vertices[j + 1].v.ob[0] = 32;
vertices[j + 1].v.ob[1] = 32;
vertices[j + 1].v.ob[2] = 0;
vertices[j + 1].v.cn[0] = sp1CF;
vertices[j + 1].v.cn[1] = sp1CE;
vertices[j + 1].v.cn[2] = sp1CD;
vertices[j + 1].v.cn[3] = sp1CC;
vertices[j + 1].v.tc[0] = 1024;
vertices[j + 1].v.tc[1] = 0;
vertices[j + 1].v.flag = 0;
vertices[j + 2].v.ob[0] = -32;
vertices[j + 2].v.ob[1] = 32;
vertices[j + 2].v.ob[2] = 0;
vertices[j + 2].v.cn[0] = sp1CB;
vertices[j + 2].v.cn[1] = sp1CA;
vertices[j + 2].v.cn[2] = sp1C9;
vertices[j + 2].v.cn[3] = sp1C8;
vertices[j + 2].v.tc[0] = 0;
vertices[j + 2].v.tc[1] = 0;
vertices[j + 2].v.flag = 0;
vertices[j + 3].v.ob[0] = 32;
vertices[j + 3].v.ob[1] = -32;
vertices[j + 3].v.ob[2] = 0;
vertices[j + 3].v.cn[0] = sp1C7;
vertices[j + 3].v.cn[1] = sp1C6;
vertices[j + 3].v.cn[2] = sp1C5;
vertices[j + 3].v.cn[3] = sp1C4;
vertices[j + 3].v.tc[0] = 1024;
vertices[j + 3].v.tc[1] = 1024;
vertices[j + 3].v.flag = 0;
j += 4;
mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &sp12C);
if (mtx == NULL) {
goto end;
}
gSPMatrix(POLY_XLU_DISP++, mtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPVertex(POLY_XLU_DISP++, &vertices[4 * i], 4, 0);
gSP2Triangles(POLY_XLU_DISP++, 2, 0, 3, 0, 2, 3, 1, 0);
}
gDPPipeSync(POLY_XLU_DISP++);
}
end:
CLOSE_DISPS(gfxCtx);
}
src/code/z_eff_ss_dead.c
+104 -6
View File
@@ -1,13 +1,111 @@
#include "global.h"
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE2A0.s")
void func_800AE2A0(GlobalContext* globalCtx, Color_RGBA8* color, s16 arg2, s16 arg3) {
f32 cos;
Gfx* displayListHead;
f32 absCos;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE434.s")
OPEN_DISPS(globalCtx->state.gfxCtx);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE5A0.s")
displayListHead = POLY_OPA_DISP;
cos = Math_CosS((0x8000 / arg3) * arg2);
absCos = fabsf(cos);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE5E4.s")
gDPPipeSync(displayListHead++);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE778.s")
if (color == NULL) {
gDPSetFogColor(displayListHead++, 255, 0, 0, 0);
} else {
gDPSetFogColor(displayListHead++, color->r, color->g, color->b, color->a);
}
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_ss_dead/func_800AE8EC.s")
gSPFogPosition(displayListHead++, 0, (s16)(absCos * 3000.0f) + 1500);
POLY_OPA_DISP = displayListHead;
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
void func_800AE434(GlobalContext* globalCtx, Color_RGBA8* color, s16 arg2, s16 arg3) {
Gfx* displayListHead;
f32 cos;
OPEN_DISPS(globalCtx->state.gfxCtx);
cos = Math_CosS((0x4000 / arg3) * arg2);
displayListHead = POLY_OPA_DISP;
gDPPipeSync(displayListHead++);
gDPSetFogColor(displayListHead++, color->r, color->g, color->b, color->a);
gSPFogPosition(displayListHead++, 0, (s16)(2800.0f * fabsf(cos)) + 1700);
POLY_OPA_DISP = displayListHead;
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
void func_800AE5A0(GlobalContext* globalCtx) {
s32 pad;
OPEN_DISPS(globalCtx->state.gfxCtx);
gDPPipeSync(POLY_OPA_DISP++);
POLY_OPA_DISP = func_801660B8(globalCtx, POLY_OPA_DISP);
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
void func_800AE5E4(GlobalContext* globalCtx, Color_RGBA8* color, s16 arg2, s16 arg3) {
f32 cos;
Gfx* displayListHead;
f32 absCos;
OPEN_DISPS(globalCtx->state.gfxCtx);
displayListHead = POLY_XLU_DISP;
cos = Math_CosS((0x8000 / arg3) * arg2);
absCos = fabsf(cos);
gDPPipeSync(displayListHead++);
if (color == NULL) {
gDPSetFogColor(displayListHead++, 255, 0, 0, 0);
} else {
gDPSetFogColor(displayListHead++, color->r, color->g, color->b, color->a);
}
gSPFogPosition(displayListHead++, 0, (s16)(absCos * 3000.0f) + 1500);
POLY_XLU_DISP = displayListHead;
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
void func_800AE778(GlobalContext* globalCtx, Color_RGBA8* color, s16 arg2, s16 arg3) {
f32 cos;
Gfx* displayListHead;
OPEN_DISPS(globalCtx->state.gfxCtx);
displayListHead = POLY_XLU_DISP;
cos = Math_CosS((0x4000 / arg3) * arg2);
gDPPipeSync(displayListHead++);
gDPSetFogColor(displayListHead++, color->r, color->g, color->b, color->a);
gSPFogPosition(displayListHead++, 0, (s16)(2800.0f * fabsf(cos)) + 1700);
POLY_XLU_DISP = displayListHead;
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
void func_800AE8EC(GlobalContext* globalCtx) {
s32 pad;
OPEN_DISPS(globalCtx->state.gfxCtx);
gDPPipeSync(POLY_XLU_DISP++);
POLY_XLU_DISP = func_801660B8(globalCtx, POLY_XLU_DISP);
CLOSE_DISPS(globalCtx->state.gfxCtx);
}
src/code/z_eff_tire_mark.c
+278 -8
View File
@@ -1,17 +1,287 @@
#include "global.h"
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/func_800AE930.s")
void func_800AE930(CollisionContext* colCtx, EffectTireMark* this, Vec3f* pos, f32 arg3, s16 arg4,
CollisionPoly* colPoly, s32 arg6) {
Vec3s spB8;
Vec3s spB0;
EffectTireMarkElement* spAC;
EffectTireMarkElement* spA8;
u32 spA4;
u32 spA0;
Vec3s* vtxList = colCtx->colHeader->vtxList;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/func_800AEF44.s")
if ((arg6 != 50) || (this->numElements >= (ARRAY_COUNT(this->elements) - 1)) || (colPoly == NULL)) {
func_800AEF44(this);
return;
}
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_InitParticle.s")
spB8.x = (Math_SinS(arg4 - 0x4000) * arg3) + pos->x;
spB8.z = (Math_CosS(arg4 - 0x4000) * arg3) + pos->z;
spB8.y = func_800BFD84(colPoly, spB8.x, spB8.z) + 2.0f;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_Init.s")
spB0.x = (Math_SinS(arg4 + 0x4000) * arg3) + pos->x;
spB0.z = (Math_CosS(arg4 + 0x4000) * arg3) + pos->z;
spB0.y = func_800BFD84(colPoly, spB0.x, spB0.z) + 2.0f;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_Destroy.s")
spAC = &this->elements[this->numElements - 1];
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_Update.s")
if ((this->numElements != 0) && (spAC->colPoly != NULL) && (colPoly != spAC->colPoly) &&
(func_800BFDEC(spAC->colPoly, colPoly, &spA4, &spA0) == 2)) {
Vec3f sp90;
Vec3f sp84;
Vec3f sp78;
Vec3f sp6C;
Vec3f sp60;
Vec3f sp54;
Vec3f sp48;
Vec3f sp3C;
Vec3f sp30;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_InitVertices.s")
sp84.x = vtxList[spA4].x;
sp84.y = vtxList[spA4].y;
sp84.z = vtxList[spA4].z;
sp90.x = vtxList[spA0].x;
sp90.y = vtxList[spA0].y;
sp90.z = vtxList[spA0].z;
sp54.x = spAC->p1.x;
sp54.y = spAC->p1.y;
sp54.z = spAC->p1.z;
sp60.x = spB0.x;
sp60.y = spB0.y;
sp60.z = spB0.z;
sp3C.x = spAC->p2.x;
sp3C.y = spAC->p2.y;
sp3C.z = spAC->p2.z;
sp48.x = spB8.x;
sp48.y = spB8.y;
sp48.z = spB8.z;
#pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_tire_mark/EffectTireMark_Draw.s")
if ((func_80179798(&sp84, &sp90, &sp54, &sp60, &sp6C, &sp30) != 0) &&
(func_80179798(&sp84, &sp90, &sp3C, &sp48, &sp78, &sp30) != 0)) {
if (!(spAC->flags & 2)) {
spAC->flags |= 1;
}
spA8 = &this->elements[this->numElements];
spA8->flags = 0;
spA8->p1.x = sp6C.x;
spA8->p1.y = sp6C.y;
spA8->p1.z = sp6C.z;
spA8->p2.x = sp78.x;
spA8->p2.y = sp78.y;
spA8->p2.z = sp78.z;
spA8->life = this->elemDuration;
spA8->colPoly = NULL;
this->numElements++;
spAC = &this->elements[this->numElements - 1];
if (!(spAC->flags & 2)) {
spAC->flags |= 1;
}
if (spA8) {} // Necessary to match
spA8 = &this->elements[this->numElements];
spA8->flags = 0;
spA8->p1 = spB0;
spA8->p2 = spB8;
spA8->life = this->elemDuration;
spA8->colPoly = colPoly;
this->numElements++;
return;
}
if (!(spAC->flags & 2)) {
spAC->flags |= 1;
}
spA8 = &this->elements[this->numElements];
spA8->flags = 0;
spA8->p1 = spB0;
spA8->p2 = spB8;
spA8->life = this->elemDuration;
spA8->colPoly = colPoly;
this->numElements++;
return;
}
if (!(spAC->flags & 2)) {
spAC->flags |= 1;
}
spA8 = &this->elements[this->numElements];
spA8->flags = 0;
spA8->p1 = spB0;
spA8->p2 = spB8;
spA8->life = this->elemDuration;
spA8->colPoly = colPoly;
this->numElements++;
}
void func_800AEF44(EffectTireMark* this) {
EffectTireMarkElement* elem = &this->elements[this->numElements - 1];
elem->flags |= 2;
}
void EffectTireMark_InitElement(EffectTireMarkElement* elem) {
elem->flags = 0;
elem->life = 0;
elem->colPoly = NULL;
elem->p1.x = elem->p1.y = elem->p1.z = elem->p2.x = elem->p2.y = elem->p2.z = 0;
}
void EffectTireMark_Init(void* thisx, void* initParamsx) {
EffectTireMark* this = (EffectTireMark*)thisx;
EffectTireMarkInit* initParams = (EffectTireMarkInit*)initParamsx;
s32 i;
for (i = 0; i < ARRAY_COUNT(this->elements); i++) {
EffectTireMark_InitElement(&this->elements[i]);
}
this->unk600 = initParams->unk0;
this->numElements = 0;
if (initParams->elemDuration > 62) {
this->elemDuration = 62;
} else {
this->elemDuration = initParams->elemDuration;
}
this->color = initParams->color;
}
void EffectTireMark_Destroy(void* thisx) {
}
s32 EffectTireMark_Update(void* thisx) {
EffectTireMark* this = (EffectTireMark*)thisx;
s32 i;
s32 j;
if (this->numElements == 0) {
return 0;
}
for (i = 0; i < this->numElements; i++) {
this->elements[i].life--;
}
if (this->elements[0].life <= 0) {
for (j = 0; j < ARRAY_COUNT(this->elements) - 1; j++) {
this->elements[j] = this->elements[j + 1];
}
EffectTireMark_InitElement(&this->elements[j]);
this->numElements--;
if (this->numElements < 0) {
this->numElements = 0;
}
return 0;
}
return 0;
}
void EffectTireMark_SetVertices(Vtx* vtx, EffectTireMarkElement* elem, s32 i, s32 alpha) {
s32 i1 = i * 2;
s32 i2 = i * 2 + 1;
vtx[i1].v.ob[0] = elem->p1.x;
vtx[i1].v.ob[1] = elem->p1.y;
vtx[i1].v.ob[2] = elem->p1.z;
vtx[i1].v.tc[0] = 2048;
vtx[i1].v.tc[1] = 0;
vtx[i1].v.cn[0] = 255;
vtx[i1].v.cn[1] = 255;
vtx[i1].v.cn[2] = 255;
vtx[i1].v.cn[3] = alpha;
vtx[i2].v.ob[0] = elem->p2.x;
vtx[i2].v.ob[1] = elem->p2.y;
vtx[i2].v.ob[2] = elem->p2.z;
vtx[i2].v.tc[0] = 2048;
vtx[i2].v.tc[1] = 1024;
vtx[i2].v.cn[0] = 255;
vtx[i2].v.cn[1] = 255;
vtx[i2].v.cn[2] = 255;
vtx[i2].v.cn[3] = alpha;
}
void EffectTireMark_Draw(void* thisx, GraphicsContext* gfxCtx) {
EffectTireMark* this = (EffectTireMark*)thisx;
EffectTireMarkElement* elem;
Vtx* vtx;
s32 pad;
f32 sp34;
s32 i;
sp34 = 1.0f / this->elemDuration;
OPEN_DISPS(gfxCtx);
if (this->numElements >= 2) {
vtx = GRAPH_ALLOC(gfxCtx, ALIGN16(this->numElements * sizeof(Vtx[2])));
if (vtx != NULL) {
gSPMatrix(POLY_OPA_DISP++, &D_801D1DE0, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
POLY_OPA_DISP = Gfx_CallSetupDL(POLY_OPA_DISP++, 0x2C);
gDPSetRenderMode(POLY_OPA_DISP++, G_RM_PASS, G_RM_ZB_CLD_SURF2);
gDPLoadTextureBlock(POLY_OPA_DISP++, D_04014570, G_IM_FMT_I, G_IM_SIZ_8b, 64, 32, 0,
G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_WRAP, 6, 5, G_TX_NOLOD, G_TX_NOLOD);
gDPSetCombineLERP(POLY_OPA_DISP++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0, COMBINED, 0, 0, 0,
COMBINED);
gSPSetGeometryMode(POLY_OPA_DISP++, G_SHADE | G_SHADING_SMOOTH);
gSPClearGeometryMode(POLY_OPA_DISP++, G_CULL_BACK | G_LIGHTING);
EffectTireMark_SetVertices(vtx, &this->elements[0], 0, 255);
vtx[0].v.tc[0] = 0;
vtx[0].v.tc[1] = 0;
vtx[1].v.tc[0] = 0;
vtx[1].v.tc[1] = 1024;
for (i = 1; i < this->numElements; i++) {
elem = &this->elements[i];
EffectTireMark_SetVertices(vtx, elem, i, 255);
if ((elem - 1)->flags & 1) {
if (!(elem->flags & 1)) {
vtx[i * 2 + 0].v.tc[0] = 0;
vtx[i * 2 + 0].v.tc[1] = 0;
vtx[i * 2 + 1].v.tc[0] = 0;
vtx[i * 2 + 1].v.tc[1] = 1024;
dummy_label:;
} else if ((i >= 2) && !((elem - 2)->flags & 1)) {
vtx[i * 2 - 2].v.tc[0] = 0;
vtx[i * 2 - 2].v.tc[1] = 0;
vtx[i * 2 - 1].v.tc[0] = 0;
vtx[i * 2 - 1].v.tc[1] = 1024;
}
if (i == (this->numElements - 1)) {
vtx[i * 2 + 0].v.tc[0] = 0;
vtx[i * 2 + 0].v.tc[1] = 0;
vtx[i * 2 + 1].v.tc[0] = 0;
vtx[i * 2 + 1].v.tc[1] = 1024;
}
gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, this->color.r, this->color.g, this->color.b,
(s32)((f32)this->color.a * (f32)elem->life * sp34));
gSPVertex(POLY_OPA_DISP++, &vtx[i * 2 - 2], 4, 0);
gSP2Triangles(POLY_OPA_DISP++, 0, 1, 3, 0, 0, 3, 2, 0);
}
}
}
}
CLOSE_DISPS(gfxCtx);
}
src/code/z_effect.c
+116 -116
View File
@@ -1,55 +1,57 @@
#include "global.h"
EffInfo sEffInfoTable[] = {
EffectContext sEffectContext;
EffectInfo sEffectInfoTable[] = {
{
sizeof(EffSparkParams),
(eff_init_func)EffectSpark_Init,
(eff_destroy_func)EffectSpark_Destroy,
(eff_update_func)EffectSpark_Update,
(eff_draw_func)EffectSpark_Draw,
sizeof(EffectSpark),
EffectSpark_Init,
EffectSpark_Destroy,
EffectSpark_Update,
EffectSpark_Draw,
},
{
sizeof(EffectBlure),
(eff_init_func)EffectBlure_Init1,
(eff_destroy_func)EffectBlure_Destroy,
(eff_update_func)EffectBlure_Update,
(eff_draw_func)EffectBlure_Draw,
EffectBlure_Init1,
EffectBlure_Destroy,
EffectBlure_Update,
EffectBlure_Draw,
},
{
sizeof(EffectBlure),
(eff_init_func)EffectBlure_Init2,
(eff_destroy_func)EffectBlure_Destroy,
(eff_update_func)EffectBlure_Update,
(eff_draw_func)EffectBlure_Draw,
EffectBlure_Init2,
EffectBlure_Destroy,
EffectBlure_Update,
EffectBlure_Draw,
},
{
sizeof(EffShieldParticleParams),
(eff_init_func)EffectShieldParticle_Init,
(eff_destroy_func)EffectShieldParticle_Destroy,
(eff_update_func)EffectShieldParticle_Update,
(eff_draw_func)EffectShieldParticle_Draw,
sizeof(EffectShieldParticle),
EffectShieldParticle_Init,
EffectShieldParticle_Destroy,
EffectShieldParticle_Update,
EffectShieldParticle_Draw,
},
{
sizeof(EffTireMarkParams),
(eff_init_func)EffectTireMark_Init,
(eff_destroy_func)EffectTireMark_Destroy,
(eff_update_func)EffectTireMark_Update,
(eff_draw_func)EffectTireMark_Draw,
sizeof(EffectTireMark),
EffectTireMark_Init,
EffectTireMark_Destroy,
EffectTireMark_Update,
EffectTireMark_Draw,
},
};
GlobalContext* Effect_GetContext(void) {
return sEffTable.globalCtx;
GlobalContext* Effect_GetGlobalCtx(void) {
return sEffectContext.globalCtx;
}
void* Effect_GetParams(s32 index) {
void* Effect_GetByIndex(s32 index) {
if (index == TOTAL_EFFECT_COUNT) {
return NULL;
}
if (index < SPARK_COUNT) {
if (sEffTable.sparks[index].base.active == 1) {
return &sEffTable.sparks[index].params;
if (sEffectContext.sparks[index].status.active == true) {
return &sEffectContext.sparks[index].effect;
} else {
return NULL;
}
@@ -57,8 +59,8 @@ void* Effect_GetParams(s32 index) {
index -= SPARK_COUNT;
if (index < BLURE_COUNT) {
if (sEffTable.blures[index].base.active == 1) {
return &sEffTable.blures[index].params;
if (sEffectContext.blures[index].status.active == true) {
return &sEffectContext.blures[index].effect;
} else {
return NULL;
}
@@ -66,8 +68,8 @@ void* Effect_GetParams(s32 index) {
index -= BLURE_COUNT;
if (index < SHIELD_PARTICLE_COUNT) {
if (sEffTable.shieldParticles[index].base.active == 1) {
return &sEffTable.shieldParticles[index].params;
if (sEffectContext.shieldParticles[index].status.active == true) {
return &sEffectContext.shieldParticles[index].effect;
} else {
return NULL;
}
@@ -75,8 +77,8 @@ void* Effect_GetParams(s32 index) {
index -= SHIELD_PARTICLE_COUNT;
if (index < TIRE_MARK_COUNT) {
if (sEffTable.tireMarks[index].base.active == 1) {
return &sEffTable.tireMarks[index].params;
if (sEffectContext.tireMarks[index].status.active == true) {
return &sEffectContext.tireMarks[index].effect;
} else {
return NULL;
}
@@ -85,89 +87,87 @@ void* Effect_GetParams(s32 index) {
return NULL;
}
void Effect_InitCommon(EffCommon* common) {
common->active = 0;
common->unk1 = 0;
common->unk2 = 0;
void Effect_InitStatus(EffectStatus* status) {
status->active = false;
status->unk1 = 0;
status->unk2 = 0;
}
void Effect_Init(GlobalContext* globalCtx) {
s32 i;
for (i = 0; i < SPARK_COUNT; i++) {
Effect_InitCommon(&sEffTable.sparks[i].base);
Effect_InitStatus(&sEffectContext.sparks[i].status);
}
for (i = 0; i < BLURE_COUNT; i++) {
Effect_InitCommon(&sEffTable.blures[i].base);
Effect_InitStatus(&sEffectContext.blures[i].status);
}
//! @bug This is probably supposed to loop over shieldParticles, not blures again
for (i = 0; i < SHIELD_PARTICLE_COUNT; i++) {
Effect_InitCommon(&sEffTable.blures[i].base);
//! @bug This is probably supposed to initialize shieldParticles, not blures again
Effect_InitStatus(&sEffectContext.blures[i].status);
}
for (i = 0; i < TIRE_MARK_COUNT; i++) {
Effect_InitCommon(&sEffTable.tireMarks[i].base);
Effect_InitStatus(&sEffectContext.tireMarks[i].status);
}
sEffTable.globalCtx = globalCtx;
sEffectContext.globalCtx = globalCtx;
}
void Effect_Add(GlobalContext* globalCtx, s32* index, s32 type, u8 param_4, u8 param_5, void* initParams) {
void Effect_Add(GlobalContext* globalCtx, s32* pIndex, s32 type, u8 arg3, u8 arg4, void* initParams) {
u32 slotFound;
s32 i;
void* params;
EffCommon* common;
void* effect = NULL;
EffectStatus* status = NULL;
params = NULL;
*index = TOTAL_EFFECT_COUNT;
common = NULL;
*pIndex = TOTAL_EFFECT_COUNT;
if (FrameAdvance_IsEnabled(globalCtx) != true) {
slotFound = 0;
slotFound = false;
switch (type) {
case 0:
case EFFECT_SPARK:
for (i = 0; i < SPARK_COUNT; i++) {
if (sEffTable.sparks[i].base.active == 0) {
slotFound = 1;
*index = i;
params = &sEffTable.sparks[i].params;
common = &sEffTable.sparks[i].base;
if (sEffectContext.sparks[i].status.active == false) {
slotFound = true;
*pIndex = i;
effect = &sEffectContext.sparks[i].effect;
status = &sEffectContext.sparks[i].status;
break;
}
}
break;
case 1:
case 2:
case EFFECT_BLURE1:
case EFFECT_BLURE2:
for (i = 0; i < BLURE_COUNT; i++) {
if (sEffTable.blures[i].base.active == 0) {
slotFound = 1;
*index = i + 3;
params = &sEffTable.blures[i].params;
common = &sEffTable.blures[i].base;
if (sEffectContext.blures[i].status.active == false) {
slotFound = true;
*pIndex = i + SPARK_COUNT;
effect = &sEffectContext.blures[i].effect;
status = &sEffectContext.blures[i].status;
break;
}
}
break;
case 3:
case EFFECT_SHIELD_PARTICLE:
for (i = 0; i < SHIELD_PARTICLE_COUNT; i++) {
if (sEffTable.shieldParticles[i].base.active == 0) {
slotFound = 1;
*index = i + 28;
params = &sEffTable.shieldParticles[i].params;
common = &sEffTable.shieldParticles[i].base;
if (sEffectContext.shieldParticles[i].status.active == false) {
slotFound = true;
*pIndex = i + SPARK_COUNT + BLURE_COUNT;
effect = &sEffectContext.shieldParticles[i].effect;
status = &sEffectContext.shieldParticles[i].status;
break;
}
}
break;
case 4:
case EFFECT_TIRE_MARK:
for (i = 0; i < TIRE_MARK_COUNT; i++) {
if (sEffTable.tireMarks[i].base.active == 0) {
slotFound = 1;
*index = i + 31;
params = &sEffTable.tireMarks[i].params;
common = &sEffTable.tireMarks[i].base;
if (sEffectContext.tireMarks[i].status.active == false) {
slotFound = true;
*pIndex = i + SPARK_COUNT + BLURE_COUNT + SHIELD_PARTICLE_COUNT;
effect = &sEffectContext.tireMarks[i].effect;
status = &sEffectContext.tireMarks[i].status;
break;
}
}
@@ -175,10 +175,10 @@ void Effect_Add(GlobalContext* globalCtx, s32* index, s32 type, u8 param_4, u8 p
}
if (slotFound) {
sEffInfoTable[type].init(params, initParams);
common->unk2 = param_4;
common->unk1 = param_5;
common->active = 1;
sEffectInfoTable[type].init(effect, initParams);
status->unk2 = arg3;
status->unk1 = arg4;
status->active = true;
}
}
}
@@ -188,8 +188,8 @@ void Effect_DrawAll(GraphicsContext* gfxCtx) {
for (i = 0; i < SPARK_COUNT; i++) {
if (1) {} // necessary to match
if (sEffTable.sparks[i].base.active) {
sEffInfoTable[0].draw(&sEffTable.sparks[i].params, gfxCtx);
if (sEffectContext.sparks[i].status.active) {
sEffectInfoTable[EFFECT_SPARK].draw(&sEffectContext.sparks[i].effect, gfxCtx);
}
}
@@ -197,22 +197,22 @@ void Effect_DrawAll(GraphicsContext* gfxCtx) {
if (1) {
if (gfxCtx) {}
} // necessary to match
if (sEffTable.blures[i].base.active) {
sEffInfoTable[1].draw(&sEffTable.blures[i].params, gfxCtx);
if (sEffectContext.blures[i].status.active) {
sEffectInfoTable[EFFECT_BLURE1].draw(&sEffectContext.blures[i].effect, gfxCtx);
}
}
for (i = 0; i < SHIELD_PARTICLE_COUNT; i++) {
if (1) {} // necessary to match
if (sEffTable.shieldParticles[i].base.active) {
sEffInfoTable[3].draw(&sEffTable.shieldParticles[i].params, gfxCtx);
if (sEffectContext.shieldParticles[i].status.active) {
sEffectInfoTable[EFFECT_SHIELD_PARTICLE].draw(&sEffectContext.shieldParticles[i].effect, gfxCtx);
}
}
if (1) {} // necessary to match
for (i = 0; i < TIRE_MARK_COUNT; i++) {
if (sEffTable.tireMarks[i].base.active) {
sEffInfoTable[4].draw(&sEffTable.tireMarks[i].params, gfxCtx);
if (sEffectContext.tireMarks[i].status.active) {
sEffectInfoTable[EFFECT_TIRE_MARK].draw(&sEffectContext.tireMarks[i].effect, gfxCtx);
}
}
}
@@ -222,8 +222,8 @@ void Effect_UpdateAll(GlobalContext* globalCtx) {
for (i = 0; i < SPARK_COUNT; i++) {
if (1) {} // necessary to match
if (sEffTable.sparks[i].base.active) {
if (sEffInfoTable[0].update(&sEffTable.sparks[i].params) == 1) {
if (sEffectContext.sparks[i].status.active) {
if (sEffectInfoTable[EFFECT_SPARK].update(&sEffectContext.sparks[i].effect) == 1) {
Effect_Destroy(globalCtx, i);
}
}
@@ -231,27 +231,27 @@ void Effect_UpdateAll(GlobalContext* globalCtx) {
for (i = 0; i < BLURE_COUNT; i++) {
if (1) {} // necessary to match
if (sEffTable.blures[i].base.active) {
if (sEffInfoTable[1].update(&sEffTable.blures[i].params) == 1) {
Effect_Destroy(globalCtx, i + 3);
if (sEffectContext.blures[i].status.active) {
if (sEffectInfoTable[EFFECT_BLURE1].update(&sEffectContext.blures[i].effect) == 1) {
Effect_Destroy(globalCtx, i + SPARK_COUNT);
}
}
}
for (i = 0; i < SHIELD_PARTICLE_COUNT; i++) {
if (1) {} // necessary to match
if (sEffTable.shieldParticles[i].base.active) {
if (sEffInfoTable[3].update(&sEffTable.shieldParticles[i].params) == 1) {
Effect_Destroy(globalCtx, i + 28);
if (sEffectContext.shieldParticles[i].status.active) {
if (sEffectInfoTable[EFFECT_SHIELD_PARTICLE].update(&sEffectContext.shieldParticles[i].effect) == 1) {
Effect_Destroy(globalCtx, i + SPARK_COUNT + BLURE_COUNT);
}
}
}
for (i = 0; i < TIRE_MARK_COUNT; i++) {
if (1) {} // necessary to match
if (sEffTable.tireMarks[i].base.active) {
if (sEffInfoTable[4].update(&sEffTable.tireMarks[i].params) == 1) {
Effect_Destroy(globalCtx, i + 31);
if (sEffectContext.tireMarks[i].status.active) {
if (sEffectInfoTable[EFFECT_TIRE_MARK].update(&sEffectContext.tireMarks[i].effect) == 1) {
Effect_Destroy(globalCtx, i + SPARK_COUNT + BLURE_COUNT + SHIELD_PARTICLE_COUNT);
}
}
}
@@ -263,29 +263,29 @@ void Effect_Destroy(GlobalContext* globalCtx, s32 index) {
}
if (index < SPARK_COUNT) {
sEffTable.sparks[index].base.active = 0;
sEffInfoTable[0].destroy(&sEffTable.sparks[index].params);
sEffectContext.sparks[index].status.active = false;
sEffectInfoTable[EFFECT_SPARK].destroy(&sEffectContext.sparks[index].effect);
return;
}
index -= SPARK_COUNT;
if (index < BLURE_COUNT) {
sEffTable.blures[index].base.active = 0;
sEffInfoTable[1].destroy(&sEffTable.blures[index].params);
sEffectContext.blures[index].status.active = false;
sEffectInfoTable[EFFECT_BLURE1].destroy(&sEffectContext.blures[index].effect);
return;
}
index -= BLURE_COUNT;
if (index < SHIELD_PARTICLE_COUNT) {
sEffTable.shieldParticles[index].base.active = 0;
sEffInfoTable[3].destroy(&sEffTable.shieldParticles[index].params);
sEffectContext.shieldParticles[index].status.active = false;
sEffectInfoTable[EFFECT_SHIELD_PARTICLE].destroy(&sEffectContext.shieldParticles[index].effect);
return;
}
index -= SHIELD_PARTICLE_COUNT;
if (index < TIRE_MARK_COUNT) {
sEffTable.tireMarks[index].base.active = 0;
sEffInfoTable[4].destroy(&sEffTable.tireMarks[index].params);
sEffectContext.tireMarks[index].status.active = false;
sEffectInfoTable[EFFECT_TIRE_MARK].destroy(&sEffectContext.tireMarks[index].effect);
return;
}
}
@@ -294,22 +294,22 @@ void Effect_DestroyAll(GlobalContext* globalCtx) {
s32 i;
for (i = 0; i < SPARK_COUNT; i++) {
sEffTable.sparks[i].base.active = 0;
sEffInfoTable[0].destroy(&sEffTable.sparks[i].params);
sEffectContext.sparks[i].status.active = false;
sEffectInfoTable[EFFECT_SPARK].destroy(&sEffectContext.sparks[i].effect);
}
for (i = 0; i < BLURE_COUNT; i++) {
sEffTable.blures[i].base.active = 0;
sEffInfoTable[1].destroy(&sEffTable.blures[i].params);
sEffectContext.blures[i].status.active = false;
sEffectInfoTable[EFFECT_BLURE1].destroy(&sEffectContext.blures[i].effect);
}
for (i = 0; i < SHIELD_PARTICLE_COUNT; i++) {
sEffTable.shieldParticles[i].base.active = 0;
sEffInfoTable[3].destroy(&sEffTable.shieldParticles[i].params);
sEffectContext.shieldParticles[i].status.active = false;
sEffectInfoTable[EFFECT_SHIELD_PARTICLE].destroy(&sEffectContext.shieldParticles[i].effect);
}
for (i = 0; i < TIRE_MARK_COUNT; i++) {
sEffTable.tireMarks[i].base.active = 0;
sEffInfoTable[4].destroy(&sEffTable.tireMarks[i].params);
sEffectContext.tireMarks[i].status.active = false;
sEffectInfoTable[EFFECT_TIRE_MARK].destroy(&sEffectContext.tireMarks[i].effect);
}
}