git.mutantstargoat.com Git - dosdemo/blob - src/greets.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <math.h>
   5 #include <assert.h>
   6 #include "demo.h"
   7 #include "3dgfx.h"
   8 #include "screen.h"
   9 #include "cfgopt.h"
  10 #include "imago2.h"
  11 #include "util.h"
  12 #include "gfxutil.h"
  13 #include "timer.h"
  14
  15 #ifdef MSDOS
  16 #include "dos/gfx.h"    /* for wait_vsync assembly macro */
  17 #else
  18 void wait_vsync(void);
  19 #endif
  20
  21 /* if defined, use bilinear interpolation for dispersion field vectors */
  22 #define BILERP_FIELD
  23 /* if defined randomize field vectors by RAND_FIELD_MAX */
  24 #define RANDOMIZE_FIELD
  25
  26 #define RAND_FIELD_MAX  0.7
  27
  28 #define BLUR_RAD        5
  29
  30 #define PCOUNT          4000
  31 #define MAX_LIFE        7.0f
  32 #define PALPHA          1.0f
  33 #define ZBIAS           0.25
  34 #define DRAG            0.95
  35 #define FORCE           0.07
  36 #define FREQ            0.085
  37 static float wind[] = {-0.0, 0.0, 0.01};
  38
  39
  40 struct vec2 {
  41         float x, y;
  42 };
  43
  44 struct vec3 {
  45         float x, y, z;
  46 };
  47
  48 struct particle {
  49         float x, y, z;
  50         float vx, vy, vz;       /* velocity */
  51         int r, g, b;
  52         float life;
  53 };
  54
  55 struct emitter {
  56         struct particle *plist;
  57         int pcount;
  58 };
  59
  60 struct vfield {
  61         struct vec2 pos, size;
  62
  63         int width, height;
  64         int xshift;
  65         struct vec2 *v;
  66 };
  67
  68
  69 static int init(void);
  70 static void destroy(void);
  71 static void start(long trans_time);
  72 static void draw(void);
  73
  74 int init_emitter(struct emitter *em, int num, unsigned char *map, int xsz, int ysz);
  75 void update_particles(struct emitter *em, float dt);
  76 void draw_particles(struct emitter *em);
  77
  78 int init_vfield_load(struct vfield *vf, const char *fname);
  79 void vfield_eval(struct vfield *vf, float x, float y, struct vec2 *dir);
  80
  81
  82 static struct screen scr = {
  83         "greets",
  84         init,
  85         destroy,
  86         start, 0,
  87         draw
  88 };
  89
  90 static struct emitter em;
  91 static struct vfield vfield;
  92 static struct g3d_vertex *varr;
  93 static long start_time;
  94
  95 static uint16_t *cur_smokebuf, *prev_smokebuf;
  96 static int smokebuf_size;
  97 #define smokebuf_start  (cur_smokebuf < prev_smokebuf ? cur_smokebuf : prev_smokebuf)
  98 #define swap_smoke_buffers() \
  99         do { \
 100                 uint16_t *tmp = cur_smokebuf; \
 101                 cur_smokebuf = prev_smokebuf; \
 102                 prev_smokebuf = tmp; \
 103         } while(0)
 104
 105 static float cam_theta, cam_phi = 25;
 106 static float cam_dist = 3;
 107
 108 struct screen *greets_screen(void)
 109 {
 110         return &scr;
 111 }
 112
 113
 114 static int init(void)
 115 {
 116         int xsz, ysz;
 117         unsigned char *pixels;
 118
 119         if(!(pixels = img_load_pixels("data/greets1.png", &xsz, &ysz, IMG_FMT_GREY8))) {
 120                 fprintf(stderr, "failed to load particle spawn map\n");
 121                 return -1;
 122         }
 123
 124         init_emitter(&em, PCOUNT, pixels, xsz, ysz);
 125         img_free_pixels(pixels);
 126
 127         if(!(varr = malloc(PCOUNT * sizeof *varr))) {
 128                 perror("failed to allocate particle vertex buffer\n");
 129                 return -1;
 130         }
 131
 132         if(init_vfield_load(&vfield, "data/vfield1") == -1) {
 133                 return -1;
 134         }
 135
 136         smokebuf_size = fb_width * fb_height * sizeof *cur_smokebuf;
 137         if(!(cur_smokebuf = malloc(smokebuf_size * 2))) {
 138                 perror("failed to allocate smoke framebuffer");
 139                 return -1;
 140         }
 141         prev_smokebuf = cur_smokebuf + fb_width * fb_height;
 142
 143         return 0;
 144 }
 145
 146 static void destroy(void)
 147 {
 148         free(varr);
 149         free(vfield.v);
 150         free(smokebuf_start);
 151 }
 152
 153 static void start(long trans_time)
 154 {
 155         g3d_matrix_mode(G3D_PROJECTION);
 156         g3d_load_identity();
 157         g3d_perspective(50.0, 1.3333333, 0.5, 100.0);
 158
 159         memset(smokebuf_start, 0, smokebuf_size * 2);
 160
 161         start_time = time_msec;
 162 }
 163
 164 static void update(void)
 165 {
 166         static long prev_msec;
 167         static int prev_mx, prev_my;
 168         static unsigned int prev_bmask;
 169
 170         long msec = time_msec - start_time;
 171         float dt = (msec - prev_msec) / 1000.0f;
 172         prev_msec = msec;
 173
 174         if(mouse_bmask) {
 175                 if((mouse_bmask ^ prev_bmask) == 0) {
 176                         int dx = mouse_x - prev_mx;
 177                         int dy = mouse_y - prev_my;
 178
 179                         if(dx || dy) {
 180                                 if(mouse_bmask & 1) {
 181                                         cam_theta += dx * 1.0;
 182                                         cam_phi += dy * 1.0;
 183
 184                                         if(cam_phi < -90) cam_phi = -90;
 185                                         if(cam_phi > 90) cam_phi = 90;
 186                                 }
 187                                 if(mouse_bmask & 4) {
 188                                         cam_dist += dy * 0.5;
 189
 190                                         if(cam_dist < 0) cam_dist = 0;
 191                                 }
 192                         }
 193                 }
 194         }
 195         prev_mx = mouse_x;
 196         prev_my = mouse_y;
 197         prev_bmask = mouse_bmask;
 198
 199         update_particles(&em, dt);
 200 }
 201
 202 static void draw(void)
 203 {
 204         int i, j;
 205         uint16_t *dest, *src;
 206         unsigned long msec;
 207         static unsigned long last_swap;
 208
 209         update();
 210
 211         g3d_matrix_mode(G3D_MODELVIEW);
 212         g3d_load_identity();
 213         g3d_translate(0, 0, -cam_dist);
 214         if(opt.sball) {
 215                 g3d_mult_matrix(sball_matrix);
 216         } else {
 217                 g3d_rotate(cam_phi, 1, 0, 0);
 218                 g3d_rotate(cam_theta, 0, 1, 0);
 219         }
 220
 221         memcpy(cur_smokebuf, prev_smokebuf, smokebuf_size);
 222
 223         g3d_framebuffer(fb_width, fb_height, cur_smokebuf);
 224         draw_particles(&em);
 225         g3d_framebuffer(fb_width, fb_height, fb_pixels);
 226
 227         dest = fb_pixels;
 228         src = cur_smokebuf;
 229         for(i=0; i<fb_height; i++) {
 230                 for(j=0; j<fb_width; j++) {
 231                         unsigned int alpha = *src++;
 232                         *dest++ = PACK_RGB16(alpha, alpha, alpha);
 233                 }
 234         }
 235
 236         /*perf_start();*/
 237         blur_grey_horiz(prev_smokebuf, cur_smokebuf, fb_width, fb_height, BLUR_RAD, 240);
 238         /*
 239         perf_end();
 240         printf("blur perf: %lu\n", (unsigned long)perf_interval_count);
 241         */
 242         blur_grey_vert(cur_smokebuf, prev_smokebuf, fb_width, fb_height, BLUR_RAD, 240);
 243         swap_smoke_buffers();
 244
 245         msec = get_msec();
 246         if(msec - last_swap < 16) {
 247                 wait_vsync();
 248         }
 249         if(!opt.vsync) {
 250                 wait_vsync();
 251         }
 252         swap_buffers(fb_pixels);
 253         last_swap = get_msec();
 254 }
 255
 256
 257
 258 int init_emitter(struct emitter *em, int num, unsigned char *map, int xsz, int ysz)
 259 {
 260         int i, x, y;
 261         float aspect = (float)xsz / (float)ysz;
 262         struct particle *p;
 263
 264         if(!(em->plist = malloc(num * sizeof *em->plist))) {
 265                 return -1;
 266         }
 267         em->pcount = num;
 268
 269         p = em->plist;
 270         for(i=0; i<num; i++) {
 271                 do {
 272                         x = rand() % xsz;
 273                         y = rand() % ysz;
 274                 } while(map[y * xsz + x] < 128);
 275
 276                 p->x = (float)x / (float)xsz - 0.5;
 277                 p->y = -(float)y / (float)xsz + 0.5 / aspect;
 278                 p->z = ((float)i / (float)num * 2.0 - 1.0) * 0.005;
 279                 p->r = p->g = p->b = 255;
 280                 p->vx = p->vy = p->vz = 0.0f;
 281                 p->life = MAX_LIFE;
 282                 ++p;
 283         }
 284         return 0;
 285 }
 286
 287 void update_particles(struct emitter *em, float dt)
 288 {
 289         int i;
 290         struct vec2 accel;
 291         struct particle *p = em->plist;
 292         struct g3d_vertex *v = varr;
 293
 294         for(i=0; i<em->pcount; i++) {
 295                 vfield_eval(&vfield, p->x, p->y, &accel);
 296                 p->x += p->vx * DRAG * dt;
 297                 p->y += p->vy * DRAG * dt;
 298                 p->z += p->vz * DRAG * dt;
 299                 p->vx += (wind[0] + accel.x * FORCE) * dt;
 300                 p->vy += (wind[1] + accel.y * FORCE) * dt;
 301                 p->vz += (wind[2] + p->z * ZBIAS) * dt;
 302                 p->life -= dt;
 303                 if(p->life < 0.0f) p->life = 0.0f;
 304
 305                 v->x = p->x;
 306                 v->y = p->y;
 307                 v->z = p->z;
 308                 v->w = 1.0f;
 309                 v->a = cround64(p->life * 255.0 / MAX_LIFE);
 310                 v->r = 0;
 311                 v->g = (v->a & 0xe0) >> 3;
 312                 v->b = (v->a & 0x1f) << 3;
 313                 ++v;
 314
 315                 ++p;
 316         }
 317 }
 318
 319 void draw_particles(struct emitter *em)
 320 {
 321         g3d_draw(G3D_POINTS, varr, PCOUNT);
 322 }
 323
 324
 325 int init_vfield_load(struct vfield *vf, const char *fname)
 326 {
 327         FILE *fp;
 328         int tmp;
 329
 330         if(!(fp = fopen(fname, "rb"))) {
 331                 fprintf(stderr, "failed to open vector field: %s\n", fname);
 332                 return -1;
 333         }
 334         if(fread(&vf->width, sizeof vf->width, 1, fp) < 1 ||
 335                         fread(&vf->height, sizeof vf->height, 1, fp) < 1) {
 336                 fprintf(stderr, "init_vfield_load: unexpected end of file while reading header\n");
 337                 fclose(fp);
 338                 return -1;
 339         }
 340
 341         /* assume xsz is pow2 otherwise fuck you */
 342         tmp = vf->width - 1;
 343         vf->xshift = 0;
 344         while(tmp) {
 345                 ++vf->xshift;
 346                 tmp >>= 1;
 347         }
 348
 349         if(!(vf->v = malloc(vf->width * vf->height * sizeof *vf->v))) {
 350                 fprintf(stderr, "failed to allocate %dx%d vector field\n", vf->width, vf->height);
 351                 fclose(fp);
 352                 return -1;
 353         }
 354         if(fread(vf->v, sizeof *vf->v, vf->width * vf->height, fp) < vf->width * vf->height) {
 355                 fprintf(stderr, "init_vfield_load: unexpected end of file while reading %dx%d vector field\n",
 356                                 vf->width, vf->height);
 357                 fclose(fp);
 358                 return -1;
 359         }
 360         fclose(fp);
 361
 362         vf->pos.x = vf->pos.y = 0;
 363         vf->size.x = vf->size.y = 1;
 364         return 0;
 365 }
 366
 367 void vfield_eval(struct vfield *vf, float x, float y, struct vec2 *dir)
 368 {
 369         int px, py;
 370         float tx, ty;
 371         struct vec2 *p1, *p2;
 372         struct vec2 left, right;
 373
 374         x = ((x - vf->pos.x) / vf->size.x + 0.5f) * vf->width;
 375         y = ((y - vf->pos.y) / vf->size.y + 0.5f) * vf->height;
 376         x = floor(x);
 377         y = floor(y);
 378
 379         if(x < 0) x = 0;
 380         if(y < 0) y = 0;
 381         if(x > vf->width - 2) x = vf->width - 2;
 382         if(y > vf->height - 2) y = vf->height - 2;
 383
 384         px = (int)x;
 385         py = (int)y;
 386
 387         p1 = vf->v + (py << vf->xshift) + px;
 388 #ifdef BILERP_FIELD
 389         p2 = p1 + vf->width;
 390
 391         tx = fmod(x, 1.0f);
 392         ty = fmod(y, 1.0f);
 393
 394         left.x = p1->x + (p2->x - p1->x) * ty;
 395         left.y = p1->y + (p2->y - p1->y) * ty;
 396         ++p1;
 397         ++p2;
 398         right.x = p1->x + (p2->x - p1->x) * ty;
 399         right.y = p1->y + (p2->y - p1->y) * ty;
 400
 401         dir->x = left.x + (right.x - left.x) * tx;
 402         dir->y = left.y + (right.y - left.y) * ty;
 403 #else
 404         dir->x = p1->x;
 405         dir->y = p1->y;
 406 #endif
 407
 408 #ifdef RANDOMIZE_FIELD
 409         dir->x += ((float)rand() / RAND_MAX - 0.5) * RAND_FIELD_MAX;
 410         dir->y += ((float)rand() / RAND_MAX - 0.5) * RAND_FIELD_MAX;
 411 #endif
 412 }