kc3-lang/SDL/Xcode-iOS/Demos/src/fireworks.c

Branch - branch -v2.28

• Show log

  Commit

• Hash : fb0ce375
  Author :
  Date : 2022-11-27T17:38:43
  

  Cleanup add brace (#6545) * Add braces after if conditions * More add braces after if conditions * Add braces after while() conditions * Fix compilation because of macro being modified * Add braces to for loop * Add braces after if/goto * Move comments up * Remove extra () in the 'return ...;' statements * More remove extra () in the 'return ...;' statements * More remove extra () in the 'return ...;' statements after merge * Fix inconsistent patterns are xxx == NULL vs !xxx * More "{}" for "if() break;" and "if() continue;" * More "{}" after if() short statement * More "{}" after "if () return;" statement * More fix inconsistent patterns are xxx == NULL vs !xxx * Revert some modificaion on SDL_RLEaccel.c * SDL_RLEaccel: no short statement * Cleanup 'if' where the bracket is in a new line * Cleanup 'while' where the bracket is in a new line * Cleanup 'for' where the bracket is in a new line * Cleanup 'else' where the bracket is in a new line (cherry picked from commit 6a2200823c66e53bd3cda4a25f0206b834392652 to reduce conflicts merging between SDL2 and SDL3)

Download

• Xcode-iOS/Demos/src/fireworks.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 =
                      SDL_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, SDL_powf(0.17, exponent));
          speed = SDL_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 * SDL_cos(theta);
          p->yvel = speed * SDL_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 = -SDL_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;
  }
  

Download