Demo/Firework/firework.c

   1
   2 #include <dos/dos.h>
   3 #include <intuition/intuition.h>
   4 #include <graphics/gfx.h>
   5 #include <cybergraphx/cybergraphics.h>
   6 #include <proto/exec.h>
   7 #include <proto/dos.h>
   8 #include <proto/graphics.h>
   9 #include <proto/cybergraphics.h>
  10 #include <proto/intuition.h>
  11
  12 #include <math.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <memory.h>
  17
  18
  19 /***********************************************************************************/
  20
  21 struct IntuitionBase    *IntuitionBase;
  22 struct GfxBase          *GfxBase;
  23 struct Library          *CyberGfxBase;
  24 struct Screen           *scr;
  25 struct Window           *win;
  26 struct RastPort         *rp;
  27
  28 ULONG                   cgfx_coltab[256];
  29 UBYTE                   remaptable[256];
  30 UBYTE                   Keys[128];
  31 char                    s[256];
  32 WORD                    winx = -1, winy = -1;
  33 BOOL                    forcescreen, forcewindow;
  34 BOOL                    mustremap, truecolor, remapped, wbscreen = TRUE;
  35
  36 /***********************************************************************************/
  37
  38 #define RANDOM          ((WORD)(rand() & 0xFFFF))
  39
  40 #define W               320
  41 #define H               200
  42 #define PARTICLES       4096
  43
  44 struct Particle
  45 {
  46     WORD speed;
  47     WORD counter;
  48     WORD ypos;
  49     WORD xpos;
  50     UBYTE particlecolor;
  51 };
  52
  53 #define xspeed counter
  54 #define yspeed speed
  55
  56 static UBYTE chunkybufferarray[W * (H + 2)];
  57 static UBYTE *chunkybuffer = &chunkybufferarray[W];
  58
  59 static UBYTE chunkybuffer_remapped[W * H];
  60
  61 struct Particle particles[PARTICLES];
  62
  63 /***********************************************************************************/
  64
  65 static void refresh(void)
  66 {
  67     if (truecolor)
  68     {
  69         WriteLUTPixelArray(chunkybuffer,
  70                 0,
  71                 0,
  72                 W,
  73                 rp,
  74                 cgfx_coltab,
  75                 win->BorderLeft,
  76                 win->BorderTop,
  77                 W,
  78                 H,
  79                 CTABFMT_XRGB8);
  80     }
  81     else if (mustremap)
  82     {
  83         LONG i;
  84         UBYTE *src = chunkybuffer;
  85         UBYTE *dest = chunkybuffer_remapped;
  86
  87         for(i = 0; i < W * H; i++)
  88         {
  89             *dest++ = remaptable[*src++];
  90         }
  91         WriteChunkyPixels(rp,
  92                 win->BorderLeft,
  93                 win->BorderTop,
  94                 win->BorderLeft + W - 1,
  95                 win->BorderTop + H - 1,
  96                 chunkybuffer_remapped,
  97                 W);
  98     }
  99     else
 100     {
 101         WriteChunkyPixels(rp,
 102                 win->BorderLeft,
 103                 win->BorderTop,
 104                 win->BorderLeft + W - 1,
 105                 win->BorderTop + H - 1,
 106                 chunkybuffer,
 107                 W);
 108     }
 109 }
 110
 111 /***********************************************************************************/
 112
 113 static void initpalette(void)
 114 {
 115     static UBYTE pal[256*3];
 116
 117     ULONG ecx = 1024;
 118     ULONG eax = 0xA000;
 119     ULONG temp;
 120     ULONG palindex = 0;
 121
 122     for(ecx = 1024; ecx; ecx--)
 123     {
 124         eax = (eax >> 8) | (eax & 0xFF) << 24;
 125         if ((eax & 255) >= 63)
 126         {
 127             eax &= ~0xFF; eax |= 63;
 128             temp = ((eax & 0xFF00) + 0x400) & 0xFF00;
 129             eax &= ~0xFF00; eax |= temp;
 130         }
 131
 132         if (ecx & 3)
 133         {
 134             pal[palindex++] = (UBYTE)eax;
 135         }
 136     }
 137
 138     for(palindex = 0; palindex < 256; palindex++)
 139     {
 140         ULONG red   = pal[palindex*3] * 4;
 141         ULONG green = pal[palindex*3+1] * 4;
 142         ULONG blue  = pal[palindex*3+2] * 4;
 143
 144         if (truecolor)
 145         {
 146             cgfx_coltab[palindex] = (red << 16) + (green << 8) + blue;
 147         }
 148         else if (mustremap)
 149         {
 150             red   *= 0x01010101;
 151             green *= 0x01010101;
 152             blue  *= 0x01010101;
 153
 154             remaptable[palindex] = ObtainBestPen(scr->ViewPort.ColorMap,
 155                                             red,
 156                                             green,
 157                                             blue,
 158                                             OBP_Precision, PRECISION_IMAGE,
 159                                             OBP_FailIfBad, FALSE,
 160                                             TAG_DONE);
 161             remapped = TRUE;
 162
 163         }
 164         else
 165         {
 166             red   *= 0x01010101;
 167             green *= 0x01010101;
 168             blue  *= 0x01010101;
 169
 170             SetRGB32(&scr->ViewPort, palindex, red, green, blue);
 171
 172         }
 173     }
 174 }
 175
 176 /***********************************************************************************/
 177
 178 static void ticker(void)
 179 {
 180     static ULONG tick;
 181     static ULONG ebx;
 182     static ULONG si = 0x100;
 183
 184     WORD x, y;
 185     ULONG ecx;
 186
 187     tick++;
 188
 189     if (!(tick & 3))
 190     {
 191         /* New explosion */
 192
 193         x = RANDOM / 2;
 194         y = RANDOM / 2;
 195
 196         for(ecx = 256; ecx; ecx--)
 197         {
 198             struct Particle *p;
 199             float f;
 200
 201             WORD xspeed;
 202             WORD yspeed;
 203
 204             p = &particles[ebx];
 205             ebx = (ebx + 1) & (PARTICLES - 1);
 206
 207             p->speed = RANDOM >> 6;
 208             p->counter = ecx;
 209
 210             //f= (float)(*(ULONG *)(&p->speed));
 211             f = (float)((ULONG)p->speed + (ULONG)p->counter * 65536);
 212
 213             p->ypos = y;
 214
 215             xspeed = sin(f) * p->speed;
 216             yspeed = cos(f) * p->speed;
 217
 218             p->xpos = x;
 219
 220             p->particlecolor = 58;
 221             p->yspeed = ((UWORD)yspeed) * 2;
 222             p->xspeed = xspeed;
 223
 224         }
 225     }
 226
 227     /* Draw/move all particles */
 228
 229     for(ecx = PARTICLES; ecx; ecx--)
 230     {
 231         struct Particle *p = &particles[si];
 232         WORD xp, yp;
 233
 234         p->yspeed += 16;
 235         p->ypos += p->yspeed; p->yspeed -= (p->yspeed / 16);
 236         p->xpos += p->xspeed; p->xspeed -= (p->xspeed / 16);
 237
 238         yp = p->ypos / 256;
 239         xp = p->xpos / 128;
 240
 241         if ((yp >= -99) && (yp <= 99) && (xp >= -159) && (xp <= 159))
 242         {
 243             ULONG dest = (yp + 100) * W + xp + 160;
 244
 245             UBYTE col = p->particlecolor--;
 246
 247             if (col > chunkybuffer[dest])
 248             {
 249                 chunkybuffer[dest] = col;
 250             }
 251         }
 252
 253         si = (si + 1) & (PARTICLES - 1);
 254     }
 255
 256     /* blur */
 257
 258     for(ecx = 0; ecx < W * H; ecx++)
 259     {
 260         UBYTE col = chunkybuffer[ecx];
 261
 262         col += chunkybuffer[ecx + 1];
 263         if (ecx >= W)
 264             col += chunkybuffer[ecx - W];
 265         col += chunkybuffer[ecx + W];
 266         col /= 4;
 267
 268         if ((col > 0) && (tick & 1))
 269         {
 270             col--;
 271         }
 272
 273         chunkybuffer[ecx] = col;
 274     }
 275 }
 276
 277 /***********************************************************************************/
 278
 279 static void cleanup(char *msg)
 280 {
 281     if (msg)
 282     {
 283         printf("Firework: %s\n",msg);
 284     }
 285
 286     if (win) CloseWindow(win);
 287
 288     if (remapped)
 289     {
 290         WORD i;
 291
 292         for(i = 0; i < 256; i++)
 293         {
 294             ReleasePen(scr->ViewPort.ColorMap, remaptable[i]);
 295         }
 296     }
 297
 298     if (scr)
 299     {
 300         if (wbscreen)
 301             UnlockPubScreen(0, scr);
 302         else
 303             CloseScreen(scr);
 304     }
 305
 306     if (CyberGfxBase) CloseLibrary(CyberGfxBase);
 307     if (GfxBase) CloseLibrary((struct Library *)GfxBase);
 308     if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
 309
 310     exit(0);
 311 }
 312
 313 /***********************************************************************************/
 314
 315 #define ARG_TEMPLATE "WINPOSX=X/N/K,WINPOSY=Y/N/K,FORCESCREEN=SCR/S,FORCEWINDOW=WIN/S"
 316 #define ARG_X 0
 317 #define ARG_Y 1
 318 #define ARG_SCR 2
 319 #define ARG_WIN 3
 320 #define NUM_ARGS 4
 321
 322 static IPTR args[NUM_ARGS];
 323
 324 static void getarguments(void)
 325 {
 326     struct RDArgs *myargs;
 327
 328     if ((myargs = ReadArgs(ARG_TEMPLATE, args, NULL)))
 329     {
 330         if (args[ARG_SCR])
 331             forcescreen = TRUE;
 332         else if (args[ARG_WIN])
 333             forcewindow = TRUE;
 334
 335         if (args[ARG_X]) winx = *(IPTR *)args[ARG_X];
 336         if (args[ARG_Y]) winy = *(IPTR *)args[ARG_Y];
 337
 338         FreeArgs(myargs);
 339     }
 340 }
 341
 342 /***********************************************************************************/
 343
 344 static void openlibs(void)
 345 {
 346     if (!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 39)))
 347     {
 348         cleanup("Can't open intuition.library V39!");
 349     }
 350
 351     if (!(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 39)))
 352     {
 353         cleanup("Can't open graphics.library V39!");
 354     }
 355
 356     if (!(CyberGfxBase = OpenLibrary("cybergraphics.library",0)))
 357     {
 358         cleanup("Can't open cybergraphics.library!");
 359     }
 360 }
 361
 362 /***********************************************************************************/
 363
 364 static void getvisual(void)
 365 {
 366     if (!(scr = LockPubScreen(NULL)))
 367     {
 368         cleanup("Can't lock pub screen!");
 369     }
 370
 371     if (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) <= 8)
 372     {
 373         if (!forcewindow)
 374         {
 375             wbscreen = FALSE;
 376         }
 377         else
 378         {
 379             mustremap = TRUE;
 380         }
 381     }
 382
 383     if (forcescreen) wbscreen = FALSE;
 384
 385     if (!wbscreen)
 386     {
 387         UnlockPubScreen(NULL, scr);
 388         wbscreen = FALSE;
 389
 390         scr = OpenScreenTags(NULL, SA_Width, W,
 391                    SA_Height, H,
 392                    SA_Depth, 8,
 393                    TAG_DONE);
 394
 395         if (!scr) cleanup("Can't open screen!");
 396     }
 397
 398     truecolor = (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) >= 15) ? TRUE : FALSE;
 399 }
 400
 401 /***********************************************************************************/
 402
 403 static void makewin(void)
 404 {
 405     struct TagItem winonwbtags[] =
 406     {
 407         {WA_DragBar, TRUE           },
 408         {WA_DepthGadget, TRUE       },
 409         {WA_CloseGadget, TRUE       },
 410         {WA_Title, (IPTR)"Firework" },
 411         {TAG_DONE                   }
 412     };
 413
 414     struct TagItem winonscrtags[] =
 415     {
 416         {WA_Borderless, TRUE },
 417         {TAG_DONE            }
 418     };
 419
 420     if (winx == -1) winx = (scr->Width - W - scr->WBorLeft - scr->WBorRight) / 2;
 421     if (winy == -1) winy = (scr->Height - H - scr->WBorTop - scr->WBorTop - scr->Font->ta_YSize - 1) / 2;
 422
 423     win = OpenWindowTags(NULL, WA_CustomScreen, (IPTR)scr,
 424                         WA_Left, winx,
 425                         WA_Top, winy,
 426                         WA_InnerWidth, W,
 427                         WA_InnerHeight, H,
 428                         WA_AutoAdjust, TRUE,
 429                         WA_Activate, TRUE,
 430                         WA_IDCMP, IDCMP_CLOSEWINDOW | IDCMP_RAWKEY,
 431                         TAG_MORE, wbscreen ? winonwbtags : winonscrtags);
 432
 433    if (!win) cleanup("Can't open window");
 434
 435    rp = win->RPort;
 436 }
 437
 438 /***********************************************************************************/
 439
 440 #define KC_LEFT         0x4F
 441 #define KC_RIGHT        0x4E
 442 #define KC_UP           0x4C
 443 #define KC_DOWN         0x4D
 444 #define KC_ESC          0x45
 445
 446 /***********************************************************************************/
 447
 448 static void getevents(void)
 449 {
 450     struct IntuiMessage *msg;
 451
 452     while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
 453     {
 454         switch(msg->Class)
 455         {
 456             case IDCMP_CLOSEWINDOW:
 457                 Keys[KC_ESC] = 1;
 458                 break;
 459
 460             case IDCMP_RAWKEY:
 461                 {
 462                     WORD code = msg->Code & ~IECODE_UP_PREFIX;
 463                     Keys[code] = (code == msg->Code) ? 1 : 0;
 464                 }
 465                 break;
 466         }
 467         ReplyMsg((struct Message *)msg);
 468     }
 469
 470 }
 471
 472 /***********************************************************************************/
 473
 474 static void action(void)
 475 {
 476     initpalette();
 477
 478     while (!Keys[KC_ESC])
 479     {
 480         getevents();
 481
 482         ticker();
 483         refresh();
 484         WaitTOF();
 485     }
 486 }
 487
 488 /***********************************************************************************/
 489
 490 int main(void)
 491 {
 492     getarguments();
 493     openlibs();
 494     getvisual();
 495     makewin();
 496     action();
 497     cleanup(0);
 498
 499     return 0;
 500 }
 501
 502 /***********************************************************************************/