Rtch/Lephisto
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
21ca77d439
Lephisto/src/spfx.c

317 lines
8.2 KiB
C
Raw Blame History

#include <SDL.h>
#include "lephisto.h"
#include "log.h"
#include "pilot.h"
#include "physics.h"
#include "opengl.h"
#include "pause.h"
#include "rng.h"
#include "spfx.h"
#define SPFX_GFX "../gfx/spfx/" /* Graphics location. */
#define SPFX_CHUNK 32 /* Chunk to allocate when needed. */
/* Special hardcoded effects.. */
/* Shake, AKA RUMBLE! */
static double shake_rad = 0.;
Vec2 shake_pos = { .x = 0., .y = 0. }; /* Used in nebulae.c */
static Vec2 shake_vel = { .x = 0., .y = 0. };
static int shake_off = 1;
/* Generic SPFX template. */
typedef struct SPFX_Base_ {
char* name;
double ttl; /* Time to live. */
double anim; /* Total duration in ms. */
glTexture* gfx; /* Will use each sprite as a frame. */
} SPFX_Base;
static SPFX_Base* spfx_effects = NULL;
static int spfx_neffects = 0;
typedef struct SPFX_ {
Vec2 pos, vel; /* They don't accelerate. */
int lastframe; /* Need when pausing. */
int effect; /* Actual effect. */
double timer; /* Time left. */
} SPFX;
/* Front stack is for effects on player. */
/* Back is for everything else. */
static SPFX* spfx_stack_front = NULL;
static int spfx_nstack_front = 0;
static int spfx_mstack_front = 0;
static SPFX* spfx_stack_back = NULL;
static int spfx_nstack_back = 0;
static int spfx_mstack_back = 0;
static int spfx_base_load(char* name, int ttl, int anim, char* gfx, int sx, int sy);
static void spfx_base_free(SPFX_Base* effect);
static void spfx_destroy(SPFX* layer, int* nlayer, int spfx);
static void spfx_update_layer(SPFX* layer, int* nlayer, const double dt);
/* Load the SPFX_Base. */
static int spfx_base_load(char* name, int ttl, int anim, char* gfx, int sx, int sy) {
SPFX_Base* cur;
char buf[PATH_MAX];
/* Create new effect. */
spfx_effects = realloc(spfx_effects, ++spfx_neffects*sizeof(SPFX_Base));
cur = &spfx_effects[spfx_neffects-1];
/* Fill it with the data. */
cur->name = strdup(name);
cur->anim = (double)anim / 1000.;
cur->ttl = (double)ttl / 1000.;
sprintf(buf, SPFX_GFX"%s", gfx);
cur->gfx = gl_newSprite(buf, sx, sy);
return 0;
}
static void spfx_base_free(SPFX_Base* effect) {
if(effect->name != NULL) free(effect->name);
if(effect->gfx != NULL) gl_freeTexture(effect->gfx);
}
int spfx_get(char* name) {
int i;
for(i = 0; i < spfx_neffects; i++)
if(strcmp(spfx_effects[i].name, name)==0)
return i;
WARN("SPFX '%s' not found!", name);
return 0;
}
/* Load/Unload.
* TODO: make it customizable?
*/
int spfx_load(void) {
/* Standard explosion effects. */
spfx_base_load("ExpS", 400, 400, "exps.png", 6, 5);
spfx_base_load("ExpM", 450, 450, "expm.png", 6, 5);
spfx_base_load("ExpL", 500, 500, "expl.png", 6, 5);
spfx_base_load("cargo", 15000, 5000, "cargo.png", 6, 6);
return 0;
}
void spfx_free(void) {
int i;
/* Get rid of all the particles and free the stacks. */
spfx_clear();
if(spfx_stack_front) free(spfx_stack_front);
spfx_stack_front = NULL;
spfx_mstack_front = 0;
if(spfx_stack_back) free(spfx_stack_back);
spfx_stack_back = NULL;
spfx_mstack_back = 0;
for(i = 0; i < spfx_neffects; i++)
spfx_base_free(&spfx_effects[i]);
free(spfx_effects);
spfx_effects = NULL;
spfx_neffects = 0;
}
void spfx_add(int effect,
const double px, const double py,
const double vx, const double vy,
const int layer) {
SPFX* cur_spfx;
double ttl, anim;
/* Select the layer. */
if(layer == SPFX_LAYER_FRONT) {
/* Front layer. */
if(spfx_mstack_front < spfx_nstack_front+1) {
/* We need more memory. */
spfx_mstack_front += SPFX_CHUNK;
spfx_stack_front = realloc(spfx_stack_front, spfx_mstack_front*sizeof(SPFX));
}
cur_spfx = &spfx_stack_front[spfx_nstack_front];
spfx_nstack_front++;
}
else if(layer == SPFX_LAYER_BACK) {
/* Back layer. */
if(spfx_mstack_back < spfx_nstack_back+1) {
/* Need more memory. */
spfx_mstack_back += SPFX_CHUNK;
spfx_stack_back = realloc(spfx_stack_back, spfx_mstack_back*sizeof(SPFX));
}
cur_spfx = &spfx_stack_back[spfx_nstack_back];
spfx_nstack_back++;
}
/* The actualy adding of the spfx. */
cur_spfx->effect = effect;
vect_csetmin(&cur_spfx->pos, px, py);
vect_csetmin(&cur_spfx->vel, vx, vy);
/* timer magic if ttl != anim. */
ttl = spfx_effects[effect].ttl;
anim = spfx_effects[effect].anim;
if(ttl != anim)
cur_spfx->timer = ttl + RNGF()*anim;
else
cur_spfx->timer = ttl;
}
void spfx_clear(void) {
int i;
/* Clear front layer. */
for(i = spfx_nstack_front-1; i >= 0; i--)
spfx_destroy(spfx_stack_front, &spfx_nstack_front, i);
/* Clear back layer. */
for(i = spfx_nstack_back-1; i >= 0; i--)
spfx_destroy(spfx_stack_back, &spfx_nstack_back, i);
/* Clear rumble. */
shake_rad = 0;
}
static void spfx_destroy(SPFX* layer, int* nlayer, int spfx) {
(*nlayer)--;
memmove(&layer[spfx], &layer[spfx+1], (*nlayer-spfx)*sizeof(SPFX));
}
void spfx_update(const double dt) {
spfx_update_layer(spfx_stack_front, &spfx_nstack_front, dt);
spfx_update_layer(spfx_stack_back, &spfx_nstack_back, dt);
}
static void spfx_update_layer(SPFX* layer, int* nlayer, const double dt) {
int i;
for(i = 0; i < *nlayer; i++) {
layer[i].timer -= dt; /* Less time to live. */
/* Time to die!!! */
if(layer[i].timer < 0.) {
spfx_destroy(layer, nlayer, i);
i--;
continue;
}
/* Mkay. Update it now. */
vect_cadd(&layer[i].pos, dt*VX(layer[i].vel), dt*VY(layer[i].vel));
}
}
/* Prepare the rendering for special affects. */
void spfx_start(double dt) {
GLdouble bx, by, x, y;
double inc;
if(shake_off == 1) return; /* Save the cycles. */
bx = SCREEN_W / 2;
by = SCREEN_H / 2;
if(!paused) {
inc = dt*100000.;
/* Calculate new position. */
if(shake_rad > 0.01) {
vect_cadd(&shake_pos, shake_vel.x * inc, shake_vel.y * inc);
if(VMOD(shake_pos) > shake_rad) {
/* Change direction. */
vect_pset(&shake_pos, shake_rad, VANGLE(shake_pos));
vect_pset(&shake_vel, shake_rad,
-VANGLE(shake_pos) + (RNGF()-0.5) * M_PI);
}
/* The shake decays over time. */
shake_rad -= SHAKE_DECAY * dt;
if(shake_rad < 0.) shake_rad = 0.;
x = shake_pos.x;
y = shake_pos.y;
} else {
shake_rad = 0.;
shake_off = 1;
x = 0.;
y = 0.;
}
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-bx+x, bx+x, -by+y, by+y, -1., 1.);
}
/* Add ruuumble!! */
void spfx_shake(double mod) {
shake_rad += mod/5.;
if(shake_rad > SHAKE_MAX) shake_rad = SHAKE_MAX;
shake_off = 0;
vect_pset(&shake_vel, shake_rad, RNGF() * 2. * M_PI);
}
void spfx_cinematic(void) {
glMatrixMode(GL_MODELVIEW);
glPushMatrix(); /* Translation matrix. */
glTranslated(-(double)SCREEN_W/2., -(double)SCREEN_H/2., 0);
COLOUR(cBlack);
glBegin(GL_QUADS);
glVertex2d(0., 0.);
glVertex2d(0., SCREEN_H*0.2);
glVertex2d(SCREEN_W, SCREEN_H*0.2);
glVertex2d(SCREEN_W, 0.);
glVertex2d(0., SCREEN_H);
glVertex2d(SCREEN_W, SCREEN_H);
glVertex2d(SCREEN_W, SCREEN_H*0.8);
glVertex2d(0., SCREEN_H*0.8);
glEnd();
glPopMatrix(); /* Translation matrix. */
}
void spfx_render(const int layer) {
SPFX* spfx_stack;
int i, spfx_nstack;
SPFX_Base* effect;
int sx, sy;
double time;
/* Get the appropriate layer. */
switch(layer) {
case SPFX_LAYER_FRONT:
spfx_stack = spfx_stack_front;
spfx_nstack = spfx_nstack_front;
break;
case SPFX_LAYER_BACK:
spfx_stack = spfx_stack_back;
spfx_nstack = spfx_nstack_back;
break;
}
/* Now render the layer. */
for(i = 0; i < spfx_nstack; i++) {
effect = &spfx_effects[spfx_stack[i].effect];
/* Simplifies. */
sx = (int)effect->gfx->sx;
sy = (int)effect->gfx->sy;
if(!paused) { /* Don't calculate frame if paused. */
time = fmod(spfx_stack[i].timer, effect->anim) / effect->anim;
spfx_stack[i].lastframe = sx * sy * MIN(time, 1.);
}
/* Render. */
gl_blitSprite(effect->gfx,
VX(spfx_stack[i].pos), VY(spfx_stack[i].pos),
spfx_stack[i].lastframe % sx,
spfx_stack[i].lastframe / sx,
NULL);
}
}
Reference in New Issue View Git Blame Copy Permalink