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

   1 /* thunder. c */
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <math.h>
   6 #include <assert.h>
   7 #include "imago2.h"
   8 #include "demo.h"
   9 #include "screen.h"
  10
  11 /* Render blur in half x half dimenstions. Add one pixel padding in all
  12  * directions (2 pixels horizontally, 2 pixels vertically).
  13  */
  14 #define BLUR_BUFFER_WIDTH (320/2 + 2)
  15 #define BLUR_BUFFER_HEIGHT (240/2 + 2)
  16 #define BLUR_BUFFER_SIZE (BLUR_BUFFER_WIDTH * BLUR_BUFFER_HEIGHT)
  17 static unsigned char *blurBuffer, *blurBuffer2;
  18
  19 #define BLUR_DARKEN 4
  20
  21 #define THUNDER_RECT_SIZE 2
  22 #define THUNDER_RANDOMNESS 16
  23 #define THUNDER_SECONDS 0.1f
  24
  25 #define VERTEX_COUNT 12
  26 #define PERSPECTIVE_NEUTRAL_DEPTH 0.5f
  27 #define NEAR_PLANE 0.01f
  28 #define ROTATION_SPEED 1.5f
  29
  30 #define MESH_RANDOM_SEED 173
  31
  32 #define MIN_FOGGED 40
  33
  34 #define CAMERA_DISTANCE 1.1f
  35
  36 #define PI 3.14159f
  37
  38 /* TODO: Load palette from file */
  39 static unsigned short palette[256];
  40
  41 typedef unsigned int PointSprite;
  42 #define MAX_POINT_SPRITES 1024
  43 static PointSprite pointSprites[MAX_POINT_SPRITES];
  44 int pointSpriteCount = 0;
  45 #define PACK_POINT_SPRITE(x, y, col) ((col << 16) | (x << 8) | y)
  46 #define UNPACK_COLOR(ps) (ps >> 16)
  47 #define UNPACK_X(ps) ((ps >> 8) & 0xFF)
  48 #define UNPACK_Y(ps) (ps & 0xFF)
  49
  50 typedef struct {
  51         float x,y,z;
  52 } MyVertex ;
  53
  54 MyVertex vertexBuffer[VERTEX_COUNT];
  55 MyVertex vertexBufferAnimated[VERTEX_COUNT];
  56 MyVertex vertexBufferProjected[VERTEX_COUNT];
  57
  58 void clearBlurBuffer();
  59 void applyBlur();
  60 void blitEffect();
  61 void thunder(int x0, int y0, int x1, int y1, unsigned char c0, unsigned char c1, int seed, int randomness, int depth);
  62
  63 void initMesh();
  64 void projectMesh();
  65 void animateMesh();
  66 void renderMeshToPointSprites(int seed);
  67 void renderPointSprites();
  68 unsigned char fog(float z);
  69 void sortPointSprites();
  70
  71 static int init(void);
  72 static void destroy(void);
  73 static void start(long trans_time);
  74 static void stop(long trans_time);
  75 static void draw(void);
  76
  77 static unsigned int lastFrameTime = 0;
  78 static float lastFrameDuration = 0.0f;
  79 static struct screen scr = {
  80         "thunder",
  81         init,
  82         destroy,
  83         start,
  84         0,
  85         draw
  86 };
  87
  88 struct screen *thunder_screen(void)
  89 {
  90         return &scr;
  91 }
  92
  93 static int init(void)
  94 {
  95         int i = 0;
  96
  97         blurBuffer = malloc(BLUR_BUFFER_SIZE);
  98         blurBuffer2 = malloc(BLUR_BUFFER_SIZE);
  99
 100         clearBlurBuffer();
 101
 102         /* For now, map to blue */
 103         for (i = 0; i < 256; i++) {
 104                 palette[i] = (i * i) >> 11;
 105         }
 106
 107         initMesh();
 108
 109         return 0;
 110 }
 111
 112 static void destroy(void)
 113 {
 114         free(blurBuffer);
 115         blurBuffer = 0;
 116
 117         free(blurBuffer2);
 118         blurBuffer2 = 0;
 119 }
 120
 121 static void start(long trans_time)
 122 {
 123         lastFrameTime = time_msec;
 124 }
 125
 126
 127 static float remainingThunderDuration = THUNDER_SECONDS;
 128 static int thunderPattern = 0;
 129
 130 static void draw(void)
 131 {
 132         lastFrameDuration = (time_msec - lastFrameTime) / 1000.0f;
 133         lastFrameTime = time_msec;
 134
 135         remainingThunderDuration -= lastFrameDuration;
 136         if (remainingThunderDuration <= 0) {
 137                 thunderPattern++;
 138                 remainingThunderDuration = THUNDER_SECONDS;
 139         }
 140
 141         animateMesh();
 142         projectMesh();
 143         renderMeshToPointSprites(thunderPattern);
 144         sortPointSprites();
 145         renderPointSprites();
 146
 147
 148         applyBlur();
 149         blitEffect();
 150
 151
 152
 153         swap_buffers(0);
 154 }
 155
 156 void clearBlurBuffer() {
 157         /* Clear the whole buffer (including its padding ) */
 158         memset(blurBuffer, 0, BLUR_BUFFER_SIZE);
 159         memset(blurBuffer2, 0, BLUR_BUFFER_SIZE);
 160 }
 161
 162
 163 void applyBlur() {
 164         int i, j;
 165         unsigned char *tmp;
 166         unsigned char *src = blurBuffer + BLUR_BUFFER_WIDTH + 1;
 167         unsigned char *dst = blurBuffer2 + BLUR_BUFFER_WIDTH + 1;
 168
 169         for (j = 0; j < 120; j++) {
 170                 for (i = 0; i < 160; i++) {
 171                         *dst = (*(src - 1) + *(src + 1) + *(src - BLUR_BUFFER_WIDTH) + *(src + BLUR_BUFFER_WIDTH)) >> 2;
 172
 173                         if (*dst > BLUR_DARKEN) *dst -= BLUR_DARKEN;
 174                         else *dst = 0;
 175
 176                         dst++;
 177                         src++;
 178                 }
 179                 /* Just skip the padding since we went through the scanline in the inner loop (except from the padding) */
 180                 src += 2;
 181                 dst += 2;
 182         }
 183
 184         /* Swap blur buffers */
 185         tmp = blurBuffer;
 186         blurBuffer = blurBuffer2;
 187         blurBuffer2 = tmp;
 188 }
 189
 190 void blitEffect() {
 191         unsigned int *dst1 = (unsigned int*) vmem_back;
 192         unsigned int *dst2 = dst1 + 160; /* We're writing two pixels at once */
 193         unsigned char *src1 = blurBuffer + BLUR_BUFFER_WIDTH + 1;
 194         unsigned char *src2 = src1 + BLUR_BUFFER_WIDTH;
 195         unsigned char tl, tr, bl, br;
 196         int i, j;
 197
 198         for (j = 0; j < 120; j++) {
 199                 for (i = 0; i < 160; i++) {
 200                         tl = *src1;
 201                         tr = (*src1 + *(src1 + 1)) >> 1;
 202                         bl = (*src1 + *src2) >> 1;
 203                         br = tr + ((*src2 + *(src2 + 1)) >> 1) >> 1;
 204
 205                         /* Pack 2 pixels in each 32 bit word */
 206                         *dst1 = (palette[tr] << 16) | palette[tl];
 207                         *dst2 = (palette[br] << 16) | palette[bl];
 208
 209                         dst1++;
 210                         src1++;
 211                         dst2++;
 212                         src2++;
 213                 }
 214                 /* Again, skip padding */
 215                 src1 += 2;
 216                 src2 += 2;
 217
 218                 /* For now, skip a scanline */
 219                 dst1 += 160;
 220                 dst2 += 160;
 221         }
 222
 223 }
 224
 225 void thunder(int x0, int y0, int x1, int y1, unsigned char c0, unsigned char c1, int seed, int randomness, int depth) {
 226         int mx, my, i, j;
 227         unsigned char *dst;
 228         unsigned char mc;
 229
 230         if (randomness <= 0) randomness = 1;
 231         mx = ((x0 + x1) >> 1) + rand() % randomness - randomness / 2;
 232         my = ((y0 + y1) >> 1) + rand() % randomness - randomness / 2;
 233         mc = (c0 + c1) >> 1;
 234
 235         if (depth <= 0) return;
 236
 237         /* Insert a new sprite */
 238         if (pointSpriteCount >= MAX_POINT_SPRITES) {
 239                 printf("PROBLEM");
 240                 return;
 241         }
 242         pointSprites[pointSpriteCount++] = PACK_POINT_SPRITE(mx, my, mc);
 243
 244         srand(seed);
 245
 246         thunder(x0, y0, mx, my, c0, mc, rand(), randomness >> 1, depth-1);
 247         thunder(mx, my, x1, y1, mc, c1, rand(), randomness >> 1, depth - 1);
 248 }
 249
 250 MyVertex randomVertex() {
 251         MyVertex ret;
 252         float l;
 253
 254         ret.x = rand() % 200 - 100; if (ret.x == 0) ret.x = 1;
 255         ret.y = rand() % 200 - 100; if (ret.y == 0) ret.y = 1;
 256         ret.z = rand() % 200 - 100; if (ret.z == 0) ret.z = 1;
 257
 258         // Normalize
 259         l = sqrt(ret.x * ret.x + ret.y * ret.y + ret.z * ret.z);
 260         ret.x /= l;
 261         ret.y /= l;
 262         ret.z /= l;
 263
 264         return ret;
 265 }
 266
 267 void initMesh() {
 268         int i;
 269
 270         srand(MESH_RANDOM_SEED);
 271
 272         for (i = 0; i < VERTEX_COUNT; i++) {
 273                 vertexBuffer[i] = randomVertex();
 274         }
 275 }
 276
 277 void animateMesh() {
 278         int i = 0;
 279         MyVertex bx, by, bz;
 280         float yRot;
 281
 282         yRot = ROTATION_SPEED * time_msec / 1000.0f;
 283
 284         /* Create rotated basis */
 285         bx.x = cos(yRot);
 286         bx.y = 0.0f;
 287         bx.z = sin(yRot);
 288
 289         by.x = 0.0f;
 290         by.y = 1.0f;
 291         by.z = 0.0f;
 292
 293         bz.x = cos(yRot + PI/2.0f);
 294         bz.y = 0.0f;
 295         bz.z = sin(yRot + PI/2.0f);
 296
 297         for (i = 0; i < VERTEX_COUNT; i++) {
 298                 MyVertex v1, v2;
 299                 v1 = vertexBuffer[i];
 300
 301                 /* O re panaia mou */
 302
 303                 v2.x = v1.x * bx.x + v1.y * by.x + v1.z * bz.x;
 304                 v2.y = v1.x * bx.y + v1.y * by.y + v1.z * bz.y;
 305                 v2.z = v1.x * bx.z + v1.y * by.z + v1.z * bz.z;
 306
 307                 v2.z += CAMERA_DISTANCE;
 308
 309                 vertexBufferAnimated[i] = v2;
 310         }
 311 }
 312
 313 void projectMesh() {
 314         int i = 0;
 315
 316         for (i = 0; i < VERTEX_COUNT; i++) {
 317
 318                 if (vertexBufferAnimated[i].z <= NEAR_PLANE) {
 319                         vertexBufferProjected[i].x = vertexBufferProjected[i].y = 1000.0f;
 320                         vertexBufferProjected[i].z = -1.0f;
 321                         continue;
 322                 }
 323
 324                 vertexBufferProjected[i].x = vertexBufferAnimated[i].x * PERSPECTIVE_NEUTRAL_DEPTH / vertexBufferAnimated[i].z;
 325                 vertexBufferProjected[i].y = vertexBufferAnimated[i].y * PERSPECTIVE_NEUTRAL_DEPTH / vertexBufferAnimated[i].z;
 326         }
 327 }
 328
 329 void renderMeshToPointSprites(int seed) {
 330         int vertex, j;
 331         int sx, sy;
 332         unsigned char color;
 333         unsigned char *dst;
 334         unsigned char fogAtOrigin;
 335
 336         fogAtOrigin = fog(CAMERA_DISTANCE);
 337
 338         pointSpriteCount = 0;
 339         srand(seed);
 340
 341         for (vertex = 0; vertex < VERTEX_COUNT; vertex++) {
 342                 sx = (int)(vertexBufferProjected[vertex].x * 80) + 80;
 343                 sy = (int)(vertexBufferProjected[vertex].y * 60) + 60;
 344
 345                 thunder(80, 60, sx, sy, fogAtOrigin, fog(vertexBufferAnimated[vertex].z), rand(), THUNDER_RANDOMNESS, 5);
 346         }
 347 }
 348
 349 void renderPointSprites() {
 350         int i,j;
 351         PointSprite sprite;
 352         unsigned char *dst;
 353         int sx, sy;
 354         unsigned char color;
 355
 356         for (i = 0; i < pointSpriteCount; i++) {
 357                 sprite = pointSprites[i];
 358
 359                 sx = UNPACK_X(sprite);
 360                 sy = UNPACK_Y(sprite);
 361
 362                 if (sx < THUNDER_RECT_SIZE || sx >= 160 - THUNDER_RECT_SIZE || sy < THUNDER_RECT_SIZE || sy >= 120 - THUNDER_RECT_SIZE) continue;
 363
 364                 dst = blurBuffer + BLUR_BUFFER_WIDTH + 1 + sx + sy * BLUR_BUFFER_WIDTH;
 365
 366                 color = UNPACK_COLOR(sprite);
 367
 368                 for (j = 0; j < THUNDER_RECT_SIZE; j++) {
 369                         memset(dst, color, THUNDER_RECT_SIZE);
 370                         dst += BLUR_BUFFER_WIDTH;
 371                 }
 372         }
 373 }
 374
 375 unsigned char fog(float z) {
 376         unsigned int ret = (unsigned int) (((-(z - CAMERA_DISTANCE)) * 0.5f + 0.5f) * (255.0f - MIN_FOGGED)) + MIN_FOGGED;
 377         if (ret > 255) ret = 255;
 378         return (unsigned char)ret;
 379 }
 380
 381 void sort(PointSprite *begin, PointSprite *end) {\r
 382         PointSprite pivotValue;\r
 383         size_t sz;\r
 384         PointSprite *left, *right;\r
 385         int leftCond, rightCond;\r
 386         PointSprite tmp;\r
 387 \r
 388         sz = end - begin;\r
 389 \r
 390         if (sz < 2) return; /* already sorted */\r
 391         if (sz == 2) {\r
 392                 /* trivial case */\r
 393                 if (begin[1] < begin[0]) {\r
 394                         tmp = begin[0];\r
 395                         begin[0] = begin[1];\r
 396                         begin[1] = tmp;\r
 397                         return;\r
 398                 }\r
 399         }\r
 400 \r
 401         /* minimum 3 elements from now on */\r
 402 \r
 403         /* choose a pivot near the middle, since we frequently sort already sorted arrays */\r
 404         pivotValue = begin[sz / 2];\r
 405 \r
 406         left = begin;\r
 407         right = end - 1;\r
 408 \r
 409         while (right > left) {\r
 410                 /* check if left and right elements meet the conditions */\r
 411                 leftCond = pivotValue >= *left;\r
 412                 rightCond = pivotValue < *right;\r
 413 \r
 414                 if (!leftCond && !rightCond) {\r
 415                         tmp = *left;\r
 416                         *left = *right;\r
 417                         *right = tmp;\r
 418                         left++;\r
 419                         right--;\r
 420                 }\r
 421                 else if (leftCond && rightCond) {\r
 422                         left++;\r
 423                         right--;\r
 424                 }\r
 425                 else if (leftCond) {\r
 426                         left++;\r
 427                 }\r
 428                 else {\r
 429                         right--;\r
 430                 }\r
 431         }\r
 432 \r
 433         /* recursion */\r
 434         sort(begin, left);\r
 435         sort(left, end);\r
 436 }\r
 437
 438 void sortPointSprites() {
 439         sort(pointSprites, pointSprites + pointSpriteCount);
 440 }
 441