475 lines
15 KiB
C
475 lines
15 KiB
C
|
/*
|
||
|
|
* fireworks.c
|
||
|
|
* written by Holmes Futrell
|
||
|
|
* use however you want
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "SDL.h"
|
||
|
|
#include "SDL_opengles.h"
|
||
|
|
#include "common.h"
|
||
|
|
#include <math.h>
|
||
|
|
#include <time.h>
|
||
|
|
|
||
|
|
#define ACCEL 0.0001f /* acceleration due to gravity, units in pixels per millesecond squared */
|
||
|
|
#define WIND_RESISTANCE 0.00005f /* acceleration per unit velocity due to wind resistance */
|
||
|
|
#define MAX_PARTICLES 2000 /* maximum number of particles displayed at once */
|
||
|
|
|
||
|
|
static GLuint particleTextureID; /* OpenGL particle texture id */
|
||
|
|
static SDL_bool pointSizeExtensionSupported; /* is GL_OES_point_size_array supported ? */
|
||
|
|
static float pointSizeScale;
|
||
|
|
/*
|
||
|
|
used to describe what type of particle a given struct particle is.
|
||
|
|
emitter - this particle flies up, shooting off trail particles, then finally explodes into dust particles.
|
||
|
|
trail - shoots off, following emitter particle
|
||
|
|
dust - radiates outwards from emitter explosion
|
||
|
|
*/
|
||
|
|
enum particleType
|
||
|
|
{
|
||
|
|
emitter = 0,
|
||
|
|
trail,
|
||
|
|
dust
|
||
|
|
};
|
||
|
|
/*
|
||
|
|
struct particle is used to describe each particle displayed on screen
|
||
|
|
*/
|
||
|
|
struct particle
|
||
|
|
{
|
||
|
|
GLfloat x; /* x position of particle */
|
||
|
|
GLfloat y; /* y position of particle */
|
||
|
|
GLubyte color[4]; /* rgba color of particle */
|
||
|
|
GLfloat size; /* size of particle in pixels */
|
||
|
|
GLfloat xvel; /* x velocity of particle in pixels per milesecond */
|
||
|
|
GLfloat yvel; /* y velocity of particle in pixels per millescond */
|
||
|
|
int isActive; /* if not active, then particle is overwritten */
|
||
|
|
enum particleType type; /* see enum particleType */
|
||
|
|
} particles[MAX_PARTICLES]; /* this array holds all our particles */
|
||
|
|
|
||
|
|
static int num_active_particles; /* how many members of the particle array are actually being drawn / animated? */
|
||
|
|
static int screen_w, screen_h;
|
||
|
|
|
||
|
|
/* function declarations */
|
||
|
|
void spawnTrailFromEmitter(struct particle *emitter);
|
||
|
|
void spawnEmitterParticle(GLfloat x, GLfloat y);
|
||
|
|
void explodeEmitter(struct particle *emitter);
|
||
|
|
void initializeParticles(void);
|
||
|
|
void initializeTexture();
|
||
|
|
int nextPowerOfTwo(int x);
|
||
|
|
void drawParticles();
|
||
|
|
void stepParticles(double deltaTime);
|
||
|
|
|
||
|
|
/* helper function (used in texture loading)
|
||
|
|
returns next power of two greater than or equal to x
|
||
|
|
*/
|
||
|
|
int
|
||
|
|
nextPowerOfTwo(int x)
|
||
|
|
{
|
||
|
|
int val = 1;
|
||
|
|
while (val < x) {
|
||
|
|
val *= 2;
|
||
|
|
}
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
steps each active particle by timestep deltaTime
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
stepParticles(double deltaTime)
|
||
|
|
{
|
||
|
|
float deltaMilliseconds = deltaTime * 1000;
|
||
|
|
int i;
|
||
|
|
struct particle *slot = particles;
|
||
|
|
struct particle *curr = particles;
|
||
|
|
for (i = 0; i < num_active_particles; i++) {
|
||
|
|
/* is the particle actually active, or is it marked for deletion? */
|
||
|
|
if (curr->isActive) {
|
||
|
|
/* is the particle off the screen? */
|
||
|
|
if (curr->y > screen_h)
|
||
|
|
curr->isActive = 0;
|
||
|
|
else if (curr->y < 0)
|
||
|
|
curr->isActive = 0;
|
||
|
|
if (curr->x > screen_w)
|
||
|
|
curr->isActive = 0;
|
||
|
|
else if (curr->x < 0)
|
||
|
|
curr->isActive = 0;
|
||
|
|
|
||
|
|
/* step velocity, then step position */
|
||
|
|
curr->yvel += ACCEL * deltaMilliseconds;
|
||
|
|
curr->xvel += 0.0f;
|
||
|
|
curr->y += curr->yvel * deltaMilliseconds;
|
||
|
|
curr->x += curr->xvel * deltaMilliseconds;
|
||
|
|
|
||
|
|
/* particle behavior */
|
||
|
|
if (curr->type == emitter) {
|
||
|
|
/* if we're an emitter, spawn a trail */
|
||
|
|
spawnTrailFromEmitter(curr);
|
||
|
|
/* if we've reached our peak, explode */
|
||
|
|
if (curr->yvel > 0.0) {
|
||
|
|
explodeEmitter(curr);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
float speed =
|
||
|
|
sqrt(curr->xvel * curr->xvel + curr->yvel * curr->yvel);
|
||
|
|
/* if wind resistance is not powerful enough to stop us completely,
|
||
|
|
then apply winde resistance, otherwise just stop us completely */
|
||
|
|
if (WIND_RESISTANCE * deltaMilliseconds < speed) {
|
||
|
|
float normx = curr->xvel / speed;
|
||
|
|
float normy = curr->yvel / speed;
|
||
|
|
curr->xvel -=
|
||
|
|
normx * WIND_RESISTANCE * deltaMilliseconds;
|
||
|
|
curr->yvel -=
|
||
|
|
normy * WIND_RESISTANCE * deltaMilliseconds;
|
||
|
|
} else {
|
||
|
|
curr->xvel = curr->yvel = 0; /* stop particle */
|
||
|
|
}
|
||
|
|
|
||
|
|
if (curr->color[3] <= deltaMilliseconds * 0.1275f) {
|
||
|
|
/* if this next step will cause us to fade out completely
|
||
|
|
then just mark for deletion */
|
||
|
|
curr->isActive = 0;
|
||
|
|
} else {
|
||
|
|
/* otherwise, let's fade a bit more */
|
||
|
|
curr->color[3] -= deltaMilliseconds * 0.1275f;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* if we're a dust particle, shrink our size */
|
||
|
|
if (curr->type == dust)
|
||
|
|
curr->size -= deltaMilliseconds * 0.010f;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/* if we're still active, pack ourselves in the array next
|
||
|
|
to the last active guy (pack the array tightly) */
|
||
|
|
if (curr->isActive)
|
||
|
|
*(slot++) = *curr;
|
||
|
|
} /* endif (curr->isActive) */
|
||
|
|
curr++;
|
||
|
|
}
|
||
|
|
/* the number of active particles is computed as the difference between
|
||
|
|
old number of active particles, where slot points, and the
|
||
|
|
new size of the array, where particles points */
|
||
|
|
num_active_particles = (int) (slot - particles);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
This draws all the particles shown on screen
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
drawParticles()
|
||
|
|
{
|
||
|
|
|
||
|
|
/* draw the background */
|
||
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
||
|
|
|
||
|
|
/* set up the position and color pointers */
|
||
|
|
glVertexPointer(2, GL_FLOAT, sizeof(struct particle), particles);
|
||
|
|
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(struct particle),
|
||
|
|
particles[0].color);
|
||
|
|
|
||
|
|
if (pointSizeExtensionSupported) {
|
||
|
|
/* pass in our array of point sizes */
|
||
|
|
glPointSizePointerOES(GL_FLOAT, sizeof(struct particle),
|
||
|
|
&(particles[0].size));
|
||
|
|
}
|
||
|
|
|
||
|
|
/* draw our particles! */
|
||
|
|
glDrawArrays(GL_POINTS, 0, num_active_particles);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
This causes an emitter to explode in a circular bloom of dust particles
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
explodeEmitter(struct particle *emitter)
|
||
|
|
{
|
||
|
|
/* first off, we're done with this particle, so turn active off */
|
||
|
|
emitter->isActive = 0;
|
||
|
|
int i;
|
||
|
|
for (i = 0; i < 200; i++) {
|
||
|
|
|
||
|
|
if (num_active_particles >= MAX_PARTICLES)
|
||
|
|
return;
|
||
|
|
|
||
|
|
/* come up with a random angle and speed for new particle */
|
||
|
|
float theta = randomFloat(0, 2.0f * 3.141592);
|
||
|
|
float exponent = 3.0f;
|
||
|
|
float speed = randomFloat(0.00, powf(0.17, exponent));
|
||
|
|
speed = powf(speed, 1.0f / exponent);
|
||
|
|
|
||
|
|
/* select the particle at the end of our array */
|
||
|
|
struct particle *p = &particles[num_active_particles];
|
||
|
|
|
||
|
|
/* set the particles properties */
|
||
|
|
p->xvel = speed * cos(theta);
|
||
|
|
p->yvel = speed * sin(theta);
|
||
|
|
p->x = emitter->x + emitter->xvel;
|
||
|
|
p->y = emitter->y + emitter->yvel;
|
||
|
|
p->isActive = 1;
|
||
|
|
p->type = dust;
|
||
|
|
p->size = 15 * pointSizeScale;
|
||
|
|
/* inherit emitter's color */
|
||
|
|
p->color[0] = emitter->color[0];
|
||
|
|
p->color[1] = emitter->color[1];
|
||
|
|
p->color[2] = emitter->color[2];
|
||
|
|
p->color[3] = 255;
|
||
|
|
/* our array has expanded at the end */
|
||
|
|
num_active_particles++;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
This spawns a trail particle from an emitter
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
spawnTrailFromEmitter(struct particle *emitter)
|
||
|
|
{
|
||
|
|
|
||
|
|
if (num_active_particles >= MAX_PARTICLES)
|
||
|
|
return;
|
||
|
|
|
||
|
|
/* select the particle at the slot at the end of our array */
|
||
|
|
struct particle *p = &particles[num_active_particles];
|
||
|
|
|
||
|
|
/* set position and velocity to roughly that of the emitter */
|
||
|
|
p->x = emitter->x + randomFloat(-3.0, 3.0);
|
||
|
|
p->y = emitter->y + emitter->size / 2.0f;
|
||
|
|
p->xvel = emitter->xvel + randomFloat(-0.005, 0.005);
|
||
|
|
p->yvel = emitter->yvel + 0.1;
|
||
|
|
|
||
|
|
/* set the color to a random-ish orangy type color */
|
||
|
|
p->color[0] = (0.8f + randomFloat(-0.1, 0.0)) * 255;
|
||
|
|
p->color[1] = (0.4f + randomFloat(-0.1, 0.1)) * 255;
|
||
|
|
p->color[2] = (0.0f + randomFloat(0.0, 0.2)) * 255;
|
||
|
|
p->color[3] = (0.7f) * 255;
|
||
|
|
|
||
|
|
/* set other attributes */
|
||
|
|
p->size = 10 * pointSizeScale;
|
||
|
|
p->type = trail;
|
||
|
|
p->isActive = 1;
|
||
|
|
|
||
|
|
/* our array has expanded at the end */
|
||
|
|
num_active_particles++;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
spawns a new emitter particle at the bottom of the screen
|
||
|
|
destined for the point (x,y).
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
spawnEmitterParticle(GLfloat x, GLfloat y)
|
||
|
|
{
|
||
|
|
|
||
|
|
if (num_active_particles >= MAX_PARTICLES)
|
||
|
|
return;
|
||
|
|
|
||
|
|
/* find particle at endpoint of array */
|
||
|
|
struct particle *p = &particles[num_active_particles];
|
||
|
|
|
||
|
|
/* set the color randomly */
|
||
|
|
switch (rand() % 4) {
|
||
|
|
case 0:
|
||
|
|
p->color[0] = 255;
|
||
|
|
p->color[1] = 100;
|
||
|
|
p->color[2] = 100;
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
p->color[0] = 100;
|
||
|
|
p->color[1] = 255;
|
||
|
|
p->color[2] = 100;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
p->color[0] = 100;
|
||
|
|
p->color[1] = 100;
|
||
|
|
p->color[2] = 255;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
p->color[0] = 255;
|
||
|
|
p->color[1] = 150;
|
||
|
|
p->color[2] = 50;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
p->color[3] = 255;
|
||
|
|
/* set position to (x, screen_h) */
|
||
|
|
p->x = x;
|
||
|
|
p->y = screen_h;
|
||
|
|
/* set velocity so that terminal point is (x,y) */
|
||
|
|
p->xvel = 0;
|
||
|
|
p->yvel = -sqrt(2 * ACCEL * (screen_h - y));
|
||
|
|
/* set other attributes */
|
||
|
|
p->size = 10 * pointSizeScale;
|
||
|
|
p->type = emitter;
|
||
|
|
p->isActive = 1;
|
||
|
|
/* our array has expanded at the end */
|
||
|
|
num_active_particles++;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* just sets the endpoint of the particle array to element zero */
|
||
|
|
void
|
||
|
|
initializeParticles(void)
|
||
|
|
{
|
||
|
|
num_active_particles = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
loads the particle texture
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
initializeTexture()
|
||
|
|
{
|
||
|
|
|
||
|
|
int bpp; /* texture bits per pixel */
|
||
|
|
Uint32 Rmask, Gmask, Bmask, Amask; /* masks for pixel format passed into OpenGL */
|
||
|
|
SDL_Surface *bmp_surface; /* the bmp is loaded here */
|
||
|
|
SDL_Surface *bmp_surface_rgba8888; /* this serves as a destination to convert the BMP
|
||
|
|
to format passed into OpenGL */
|
||
|
|
|
||
|
|
bmp_surface = SDL_LoadBMP("stroke.bmp");
|
||
|
|
if (bmp_surface == NULL) {
|
||
|
|
fatalError("could not load stroke.bmp");
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Grab info about format that will be passed into OpenGL */
|
||
|
|
SDL_PixelFormatEnumToMasks(SDL_PIXELFORMAT_ABGR8888, &bpp, &Rmask, &Gmask,
|
||
|
|
&Bmask, &Amask);
|
||
|
|
/* Create surface that will hold pixels passed into OpenGL */
|
||
|
|
bmp_surface_rgba8888 =
|
||
|
|
SDL_CreateRGBSurface(0, bmp_surface->w, bmp_surface->h, bpp, Rmask,
|
||
|
|
Gmask, Bmask, Amask);
|
||
|
|
/* Blit to this surface, effectively converting the format */
|
||
|
|
SDL_BlitSurface(bmp_surface, NULL, bmp_surface_rgba8888, NULL);
|
||
|
|
|
||
|
|
glGenTextures(1, &particleTextureID);
|
||
|
|
glBindTexture(GL_TEXTURE_2D, particleTextureID);
|
||
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
|
||
|
|
nextPowerOfTwo(bmp_surface->w),
|
||
|
|
nextPowerOfTwo(bmp_surface->h),
|
||
|
|
0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
||
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||
|
|
/* this is where we actually pass in the pixel data */
|
||
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bmp_surface->w, bmp_surface->h, 0,
|
||
|
|
GL_RGBA, GL_UNSIGNED_BYTE, bmp_surface_rgba8888->pixels);
|
||
|
|
|
||
|
|
/* free bmp surface and converted bmp surface */
|
||
|
|
SDL_FreeSurface(bmp_surface);
|
||
|
|
SDL_FreeSurface(bmp_surface_rgba8888);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
int
|
||
|
|
main(int argc, char *argv[])
|
||
|
|
{
|
||
|
|
SDL_Window *window; /* main window */
|
||
|
|
SDL_GLContext context;
|
||
|
|
int drawableW, drawableH;
|
||
|
|
int done; /* should we clean up and exit? */
|
||
|
|
|
||
|
|
/* initialize SDL */
|
||
|
|
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
|
||
|
|
fatalError("Could not initialize SDL");
|
||
|
|
}
|
||
|
|
/* seed the random number generator */
|
||
|
|
srand(time(NULL));
|
||
|
|
/*
|
||
|
|
request some OpenGL parameters
|
||
|
|
that may speed drawing
|
||
|
|
*/
|
||
|
|
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
|
||
|
|
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
|
||
|
|
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
|
||
|
|
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
|
||
|
|
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
|
||
|
|
SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, 0);
|
||
|
|
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
|
||
|
|
|
||
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
|
||
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
|
||
|
|
|
||
|
|
/* create main window and renderer */
|
||
|
|
window = SDL_CreateWindow(NULL, 0, 0, 320, 480,
|
||
|
|
SDL_WINDOW_OPENGL | SDL_WINDOW_BORDERLESS | SDL_WINDOW_ALLOW_HIGHDPI);
|
||
|
|
context = SDL_GL_CreateContext(window);
|
||
|
|
|
||
|
|
/* The window size and drawable size may be different when highdpi is enabled,
|
||
|
|
* due to the increased pixel density of the drawable. */
|
||
|
|
SDL_GetWindowSize(window, &screen_w, &screen_h);
|
||
|
|
SDL_GL_GetDrawableSize(window, &drawableW, &drawableH);
|
||
|
|
|
||
|
|
/* In OpenGL, point sizes are always in pixels. We don't want them looking
|
||
|
|
* tiny on a retina screen. */
|
||
|
|
pointSizeScale = (float) drawableH / (float) screen_h;
|
||
|
|
|
||
|
|
/* load the particle texture */
|
||
|
|
initializeTexture();
|
||
|
|
|
||
|
|
/* check if GL_POINT_SIZE_ARRAY_OES is supported
|
||
|
|
this is used to give each particle its own size
|
||
|
|
*/
|
||
|
|
pointSizeExtensionSupported =
|
||
|
|
SDL_GL_ExtensionSupported("GL_OES_point_size_array");
|
||
|
|
|
||
|
|
/* set up some OpenGL state */
|
||
|
|
glDisable(GL_DEPTH_TEST);
|
||
|
|
glDisable(GL_CULL_FACE);
|
||
|
|
|
||
|
|
glMatrixMode(GL_MODELVIEW);
|
||
|
|
glLoadIdentity();
|
||
|
|
|
||
|
|
glViewport(0, 0, drawableW, drawableH);
|
||
|
|
|
||
|
|
glMatrixMode(GL_PROJECTION);
|
||
|
|
glLoadIdentity();
|
||
|
|
glOrthof((GLfloat) 0,
|
||
|
|
(GLfloat) screen_w,
|
||
|
|
(GLfloat) screen_h,
|
||
|
|
(GLfloat) 0, 0.0, 1.0);
|
||
|
|
|
||
|
|
glEnable(GL_TEXTURE_2D);
|
||
|
|
glEnable(GL_BLEND);
|
||
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
|
||
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
||
|
|
glEnableClientState(GL_COLOR_ARRAY);
|
||
|
|
|
||
|
|
glEnable(GL_POINT_SPRITE_OES);
|
||
|
|
glTexEnvi(GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, 1);
|
||
|
|
|
||
|
|
if (pointSizeExtensionSupported) {
|
||
|
|
/* we use this to set the sizes of all the particles */
|
||
|
|
glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
|
||
|
|
} else {
|
||
|
|
/* if extension not available then all particles have size 10 */
|
||
|
|
glPointSize(10 * pointSizeScale);
|
||
|
|
}
|
||
|
|
|
||
|
|
done = 0;
|
||
|
|
/* enter main loop */
|
||
|
|
while (!done) {
|
||
|
|
SDL_Event event;
|
||
|
|
double deltaTime = updateDeltaTime();
|
||
|
|
while (SDL_PollEvent(&event)) {
|
||
|
|
if (event.type == SDL_QUIT) {
|
||
|
|
done = 1;
|
||
|
|
}
|
||
|
|
if (event.type == SDL_MOUSEBUTTONDOWN) {
|
||
|
|
int x, y;
|
||
|
|
SDL_GetMouseState(&x, &y);
|
||
|
|
spawnEmitterParticle(x, y);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
stepParticles(deltaTime);
|
||
|
|
drawParticles();
|
||
|
|
SDL_GL_SwapWindow(window);
|
||
|
|
SDL_Delay(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* delete textures */
|
||
|
|
glDeleteTextures(1, &particleTextureID);
|
||
|
|
/* shutdown SDL */
|
||
|
|
SDL_Quit();
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|