summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/SDL2/Xcode-iOS/Demos/src/fireworks.c
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/SDL2/Xcode-iOS/Demos/src/fireworks.c')
-rw-r--r--3rdparty/SDL2/Xcode-iOS/Demos/src/fireworks.c478
1 files changed, 478 insertions, 0 deletions
diff --git a/3rdparty/SDL2/Xcode-iOS/Demos/src/fireworks.c b/3rdparty/SDL2/Xcode-iOS/Demos/src/fireworks.c
new file mode 100644
index 00000000000..a5beada9136
--- /dev/null
+++ b/3rdparty/SDL2/Xcode-iOS/Demos/src/fireworks.c
@@ -0,0 +1,478 @@
+/*
+ * 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 MILLESECONDS_PER_FRAME 16 /* about 60 frames per second */
+#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 ? */
+/*
+ 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(void);
+
+/* 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 MILLESECONDS_PER_FRAME
+*/
+void
+stepParticles(void)
+{
+ 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 * MILLESECONDS_PER_FRAME;
+ curr->xvel += 0.0f;
+ curr->y += curr->yvel * MILLESECONDS_PER_FRAME;
+ curr->x += curr->xvel * MILLESECONDS_PER_FRAME;
+
+ /* 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 * MILLESECONDS_PER_FRAME < speed) {
+ float normx = curr->xvel / speed;
+ float normy = curr->yvel / speed;
+ curr->xvel -=
+ normx * WIND_RESISTANCE * MILLESECONDS_PER_FRAME;
+ curr->yvel -=
+ normy * WIND_RESISTANCE * MILLESECONDS_PER_FRAME;
+ } else {
+ curr->xvel = curr->yvel = 0; /* stop particle */
+ }
+
+ if (curr->color[3] <= MILLESECONDS_PER_FRAME * 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] -= MILLESECONDS_PER_FRAME * 0.1275f;
+ }
+
+ /* if we're a dust particle, shrink our size */
+ if (curr->type == dust)
+ curr->size -= MILLESECONDS_PER_FRAME * 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 = 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;
+ /* 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;
+ 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;
+ 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 w, h;
+ Uint32 startFrame; /* time frame began to process */
+ Uint32 endFrame; /* time frame ended processing */
+ Uint32 delay; /* time to pause waiting to draw next frame */
+ 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, SCREEN_WIDTH, SCREEN_HEIGHT,
+ SDL_WINDOW_OPENGL |
+ SDL_WINDOW_BORDERLESS);
+ context = SDL_GL_CreateContext(window);
+
+ /* 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();
+
+ SDL_GetWindowSize(window, &screen_w, &screen_h);
+ glViewport(0, 0, screen_w, screen_h);
+
+ 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);
+ }
+
+ done = 0;
+ /* enter main loop */
+ while (!done) {
+ startFrame = SDL_GetTicks();
+ SDL_Event event;
+ 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();
+ drawParticles();
+ SDL_GL_SwapWindow(window);
+ endFrame = SDL_GetTicks();
+
+ /* figure out how much time we have left, and then sleep */
+ delay = MILLESECONDS_PER_FRAME - (endFrame - startFrame);
+ if (delay > MILLESECONDS_PER_FRAME) {
+ delay = MILLESECONDS_PER_FRAME;
+ }
+ if (delay > 0) {
+ SDL_Delay(delay);
+ }
+ }
+
+ /* delete textures */
+ glDeleteTextures(1, &particleTextureID);
+ /* shutdown SDL */
+ SDL_Quit();
+
+ return 0;
+}