fireworks.c File Reference

#include "SDL.h"
#include "SDL_opengles.h"
#include "common.h"
#include <math.h>
#include <time.h>

Include dependency graph for fireworks.c:

Go to the source code of this file.

Data Structures
struct	particle

Macros
#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 */

Enumerations
enum	particleType {   emitter = 0,   trail,   dust }

Functions
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)
int	main (int argc, char *argv[])

Variables
static GLuint	particleTextureID
static SDL_bool	pointSizeExtensionSupported
static float	pointSizeScale
struct particle	particles [MAX_PARTICLES]
static int	num_active_particles
static int	screen_w
static int	screen_h

Macro Definition Documentation

ACCEL

#define ACCEL   0.0001f /* acceleration due to gravity, units in pixels per millesecond squared */

Definition at line 13 of file fireworks.c.

Referenced by spawnEmitterParticle(), and stepParticles().

MAX_PARTICLES

#define MAX_PARTICLES   2000 /* maximum number of particles displayed at once */

Definition at line 15 of file fireworks.c.

Referenced by explodeEmitter(), spawnEmitterParticle(), and spawnTrailFromEmitter().

WIND_RESISTANCE

#define WIND_RESISTANCE   0.00005f /* acceleration per unit velocity due to wind resistance */

Definition at line 14 of file fireworks.c.

Referenced by stepParticles().

Enumeration Type Documentation

particleType

enum particleType

Enumerator
emitter
trail
dust

Definition at line 26 of file fireworks.c.

{
    emitter = 0,
    trail,
    dust
};

Function Documentation

drawParticles()

void drawParticles

(

)

Definition at line 158 of file fireworks.c.

References GL_COLOR_BUFFER_BIT, GL_FLOAT, GL_POINTS, GL_UNSIGNED_BYTE, glClear(), glColorPointer(), glDrawArrays(), glVertexPointer(), num_active_particles, particles, and pointSizeExtensionSupported.

Referenced by main().

{

    /* 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);

}

explodeEmitter()

void explodeEmitter

(

struct particle *

emitter

)

Definition at line 184 of file fireworks.c.

References particle::color, cos(), dust, i, particle::isActive, MAX_PARTICLES, num_active_particles, particles, pointSizeScale, randomFloat(), sin(), particle::size, particle::type, particle::x, particle::xvel, particle::y, and particle::yvel.

Referenced by stepParticles().

{
    /* 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++;
    }

}

initializeParticles()

void initializeParticles

(

void

)

Definition at line 311 of file fireworks.c.

References num_active_particles.

{
    num_active_particles = 0;
}

initializeTexture()

void initializeTexture

(

)

Definition at line 320 of file fireworks.c.

References fatalError(), GL_LINEAR, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_UNSIGNED_BYTE, glBindTexture(), glGenTextures(), glTexImage2D, glTexParameteri(), SDL_Surface::h, nextPowerOfTwo(), NULL, particleTextureID, SDL_Surface::pixels, SDL_BlitSurface, SDL_CreateRGBSurface, SDL_FreeSurface, SDL_LoadBMP, SDL_PIXELFORMAT_ABGR8888, SDL_PixelFormatEnumToMasks, and SDL_Surface::w.

Referenced by main().

{

    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);

}

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 363 of file fireworks.c.

References context, done, drawParticles(), fatalError(), GL_BLEND, GL_COLOR_ARRAY, GL_CULL_FACE, GL_DEPTH_TEST, GL_MODELVIEW, GL_ONE, GL_PROJECTION, GL_SRC_ALPHA, GL_TEXTURE_2D, GL_VERTEX_ARRAY, glBlendFunc(), glDeleteTextures(), glDisable(), glEnable(), glEnableClientState(), glLoadIdentity(), glMatrixMode(), glPointSize(), glTexEnvi(), glViewport(), initializeTexture(), NULL, particleTextureID, pointSizeExtensionSupported, pointSizeScale, screen_h, screen_w, SDL_CreateWindow, SDL_Delay, SDL_GetMouseState, SDL_GetWindowSize, SDL_GL_ACCELERATED_VISUAL, SDL_GL_ALPHA_SIZE, SDL_GL_BLUE_SIZE, SDL_GL_CONTEXT_MAJOR_VERSION, SDL_GL_CONTEXT_MINOR_VERSION, SDL_GL_CreateContext, SDL_GL_DEPTH_SIZE, SDL_GL_ExtensionSupported, SDL_GL_GetDrawableSize, SDL_GL_GREEN_SIZE, SDL_GL_RED_SIZE, SDL_GL_RETAINED_BACKING, SDL_GL_SetAttribute, SDL_GL_SwapWindow, SDL_Init, SDL_INIT_VIDEO, SDL_MOUSEBUTTONDOWN, SDL_PollEvent, SDL_Quit, SDL_QUIT, SDL_WINDOW_ALLOW_HIGHDPI, SDL_WINDOW_BORDERLESS, SDL_WINDOW_OPENGL, spawnEmitterParticle(), stepParticles(), SDL_Event::type, updateDeltaTime(), particle::x, and particle::y.

{
    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;
}

nextPowerOfTwo()

int nextPowerOfTwo

(

int

x

)

Definition at line 64 of file fireworks.c.

Referenced by initializeTexture().

{
    int val = 1;
    while (val < x) {
        val *= 2;
    }
    return val;
}

spawnEmitterParticle()

void spawnEmitterParticle	(	GLfloat	x,
		GLfloat	y
	)

Definition at line 262 of file fireworks.c.

References ACCEL, particle::color, emitter, particle::isActive, MAX_PARTICLES, num_active_particles, particles, pointSizeScale, screen_h, particle::size, particle::type, particle::x, particle::xvel, particle::y, and particle::yvel.

Referenced by main().

{

    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++;
}

spawnTrailFromEmitter()

void spawnTrailFromEmitter

(

struct particle *

emitter

)

Definition at line 226 of file fireworks.c.

References particle::color, particle::isActive, MAX_PARTICLES, num_active_particles, particles, pointSizeScale, randomFloat(), particle::size, trail, particle::type, particle::x, particle::xvel, particle::y, and particle::yvel.

Referenced by stepParticles().

{

    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++;

}

stepParticles()

void stepParticles

(

double

deltaTime

)

Definition at line 77 of file fireworks.c.

References ACCEL, particle::color, dust, emitter, explodeEmitter(), i, particle::isActive, num_active_particles, particles, screen_h, screen_w, particle::size, spawnTrailFromEmitter(), particle::type, WIND_RESISTANCE, particle::x, particle::xvel, particle::y, and particle::yvel.

Referenced by main().

{
    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);
}

Variable Documentation

num_active_particles

int num_active_particles

static

Definition at line 47 of file fireworks.c.

Referenced by drawParticles(), explodeEmitter(), initializeParticles(), spawnEmitterParticle(), spawnTrailFromEmitter(), and stepParticles().

particles

struct particle particles[MAX_PARTICLES]

Referenced by drawParticles(), explodeEmitter(), spawnEmitterParticle(), spawnTrailFromEmitter(), and stepParticles().

particleTextureID

GLuint particleTextureID

static

Definition at line 17 of file fireworks.c.

Referenced by initializeTexture(), and main().

pointSizeExtensionSupported

SDL_bool pointSizeExtensionSupported

static

Definition at line 18 of file fireworks.c.

Referenced by drawParticles(), and main().

pointSizeScale

float pointSizeScale

static

Definition at line 19 of file fireworks.c.

Referenced by explodeEmitter(), main(), spawnEmitterParticle(), and spawnTrailFromEmitter().

screen_h

int screen_h

static

Definition at line 48 of file fireworks.c.

Referenced by main(), spawnEmitterParticle(), and stepParticles().

screen_w

int screen_w

static

Definition at line 48 of file fireworks.c.

Referenced by main(), and stepParticles().