Demo/DawaFire/dawafire.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 ULONG                   cgfx_coltab[256];
  28 UBYTE                   remaptable[256];
  29 UBYTE                   Keys[128];
  30 char                    s[256];
  31 WORD                    winx = -1, winy = -1;
  32 BOOL                    forcescreen, forcewindow;
  33 BOOL                    mustremap, truecolor, remapped, wbscreen = TRUE;
  34
  35 static void cleanup(char *msg);
  36
  37 /***********************************************************************************/
  38
  39 #define random          rand
  40
  41 #define W               320
  42 #define H               200
  43
  44 /***********************************************************************************/
  45
  46 unsigned char * buffy256, *buffy256_remapped;
  47 unsigned int pal[256];
  48
  49 struct particle {
  50   int X0,Y0;
  51   int V0x,V0y;
  52   int power;
  53   int time;
  54   struct particle *next;
  55 };
  56
  57 typedef struct particle particle;
  58
  59 particle * firstparticle;
  60
  61 void initdawafire(void)
  62 {
  63   int i;
  64
  65   /* 8bpp buffer */
  66
  67   for ( i=0 ; i<256 ; i++ ) {
  68
  69     int r,g,b;
  70
  71     r = g = b = 0 ;
  72
  73     if ( (i > 7) && (i < 32) )
  74       r = 10 * ( i - 7 );
  75     if ( i > 31 )
  76       r = 255;
  77
  78     if ( (i > 32 ) && (i < 57 ) )
  79       g = 10 * ( i - 32 );
  80     if ( i > 56 )
  81       g = 255;
  82
  83     if ( i < 8 )
  84       b = 8 * i;
  85     if ( (i > 7) && (i < 17) )
  86       b = 8 * ( 16 - i );
  87     if ( (i > 57) && (i < 82) )
  88       b = 10 * ( i - 57 );
  89     if ( i > 81 )
  90       b = 255;
  91
  92     if (truecolor)
  93     {
  94       cgfx_coltab[i] = (r<<16) + (g<<8) + (b);
  95     }
  96     else if (mustremap)
  97     {
  98       ULONG red   = r * 0x01010101;
  99       ULONG green = g * 0x01010101;
 100       ULONG blue  = b * 0x01010101;
 101
 102       remaptable[i] = ObtainBestPen(scr->ViewPort.ColorMap,
 103                                     red,
 104                                     green,
 105                                     blue,
 106                                     OBP_Precision, PRECISION_IMAGE,
 107                                     OBP_FailIfBad, FALSE,
 108                                     TAG_DONE);
 109       remapped = TRUE;
 110     }
 111     else
 112     {
 113
 114       ULONG red   = r * 0x01010101;
 115       ULONG green = g * 0x01010101;
 116       ULONG blue  = b * 0x01010101;
 117
 118       SetRGB32(&scr->ViewPort, i, red, green, blue);
 119     }
 120
 121   }
 122
 123   buffy256 = (unsigned char *) calloc ( W*H , 1 );
 124   if (!buffy256) cleanup("Out of memory!");
 125
 126   if (mustremap)
 127   {
 128     buffy256_remapped = (unsigned char *) calloc ( W*H , 1 );
 129     if (!buffy256_remapped) cleanup("Out of memory!");
 130   }
 131
 132 }
 133
 134 void refresh () {
 135
 136   /* B G R X */
 137
 138   static double k=0;
 139   int i;
 140
 141   unsigned char * blur = buffy256;
 142
 143   particle * precurrentparticle;
 144   particle * currentparticle;
 145
 146   /* Add new particles */
 147
 148   for (i=0; i<8; i++) {
 149
 150     int ii;
 151
 152     for (ii=0; ii<8; ii++) {
 153
 154       precurrentparticle = (particle *) malloc (sizeof(particle));
 155
 156       precurrentparticle->V0x = (random() & 31) - 16;
 157       precurrentparticle->V0y = (random() & 31);
 158
 159       precurrentparticle->X0 = W/2+
 160         W/2.5*
 161         sin((20*sin(k/20))+i*70)*
 162         (sin(10+k/(10+i))+0.2)*
 163         cos((k+i*25)/10);
 164       precurrentparticle->Y0 = H/2+
 165         H/2.5*
 166         cos((20*sin(k/(20+i)))+i*70)*
 167         (sin(10+k/10)+0.2)*
 168         cos((k+i*25)/10);
 169
 170       precurrentparticle->power = 110+50*sin(k/3);
 171       precurrentparticle->time = 0;
 172       precurrentparticle->next = firstparticle;
 173
 174       firstparticle = precurrentparticle;
 175
 176     }
 177
 178     k += 0.02;
 179
 180   }
 181
 182   /*
 183    *  Physics:
 184    *
 185    *  Vx(t) = V0x
 186    *  Vy(t) = V0y - G.t
 187    *
 188    *  X(t) = X0 + V0x.t
 189    *  Y(t) = Y0 + V0y.t - G.t^2
 190    *
 191    */
 192
 193   currentparticle = firstparticle->next;
 194
 195   while (currentparticle != NULL) {
 196
 197     int dawa;
 198     int tx,ty;
 199     int time;
 200
 201     time = currentparticle->time / 16;
 202
 203     tx =
 204       (currentparticle->X0) +
 205       time*(currentparticle->V0x);
 206     ty =
 207       (currentparticle->Y0) +
 208       time*(currentparticle->V0y) -
 209       time*time*2;
 210
 211     ty = H-ty;
 212
 213     if ((tx<W) && (ty>3) && (ty<H)) {
 214       dawa = buffy256 [ty*W+tx];
 215       dawa += currentparticle->power;
 216       if (dawa>255)
 217         dawa = 255;
 218       buffy256 [ty*W+tx] = dawa;
 219     }
 220
 221     currentparticle->time += 1;
 222
 223     currentparticle->power -= ((currentparticle->power >> 4) + 1);
 224
 225     if (currentparticle->power <= 1) {
 226       precurrentparticle->next = currentparticle->next;
 227       free (currentparticle);
 228     } else
 229       precurrentparticle = currentparticle;
 230
 231     currentparticle = precurrentparticle->next;
 232
 233   }
 234
 235   /*
 236    * Blur :
 237    *
 238    *  &&&
 239    *  &@&
 240    *   &
 241    */
 242
 243   blur += 2*W;
 244
 245   for (i=0; i<W*(H-3); i++)
 246   {
 247     * (blur) =
 248         ( * (blur-W-1)     +
 249           * (blur-W)       +
 250           * (blur-W+1)     +
 251           * (blur-1)       +
 252           * (blur)         +
 253           ( (*blur) >> 1 ) +
 254           ( (*blur) >> 2 ) +
 255           * (blur+1)       +
 256           * (blur+W) ) >> 3;
 257
 258      blur++;
 259   }
 260     if (truecolor)
 261     {
 262         WriteLUTPixelArray(buffy256,
 263                            0,
 264                            0,
 265                            W,
 266                            rp,
 267                            cgfx_coltab,
 268                            win->BorderLeft,
 269                            win->BorderTop,
 270                            W,
 271                            H,
 272                            CTABFMT_XRGB8);
 273     }
 274     else if (mustremap)
 275     {
 276         LONG i;
 277         UBYTE *src = buffy256;
 278         UBYTE *dest = buffy256_remapped;
 279
 280         for(i = 0; i < W * H; i++)
 281         {
 282             *dest++ = remaptable[*src++];
 283         }
 284         WriteChunkyPixels(rp,
 285                           win->BorderLeft,
 286                           win->BorderTop,
 287                           win->BorderLeft + W - 1,
 288                           win->BorderTop + H - 1,
 289                           buffy256_remapped,
 290                           W);
 291
 292     }
 293     else
 294     {
 295         WriteChunkyPixels(rp,
 296                           win->BorderLeft,
 297                           win->BorderTop,
 298                           win->BorderLeft + W - 1,
 299                           win->BorderTop + H - 1,
 300                           buffy256,
 301                           W);
 302     }
 303
 304 }
 305
 306 /***********************************************************************************/
 307
 308 static void cleanup(char *msg)
 309 {
 310
 311     if (msg)
 312     {
 313         printf("DawaFire: %s\n",msg);
 314     }
 315
 316     if (win) CloseWindow(win);
 317
 318     if (remapped)
 319     {
 320         WORD i;
 321
 322         for(i = 0; i < 256; i++)
 323         {
 324             ReleasePen(scr->ViewPort.ColorMap, remaptable[i]);
 325         }
 326     }
 327
 328     if (scr)
 329     {
 330         if (wbscreen)
 331             UnlockPubScreen(0, scr);
 332         else
 333             CloseScreen(scr);
 334     }
 335
 336     if (CyberGfxBase) CloseLibrary(CyberGfxBase);
 337     if (GfxBase) CloseLibrary((struct Library *)GfxBase);
 338     if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
 339
 340     exit(0);
 341 }
 342
 343 /***********************************************************************************/
 344
 345 #define ARG_TEMPLATE "WINPOSX=X/N/K,WINPOSY=Y/N/K,FORCESCREEN=SCR/S,FORCEWINDOW=WIN/S"
 346 #define ARG_X 0
 347 #define ARG_Y 1
 348 #define ARG_SCR 2
 349 #define ARG_WIN 3
 350 #define NUM_ARGS 4
 351
 352 static IPTR args[NUM_ARGS];
 353
 354 static void getarguments(void)
 355 {
 356     struct RDArgs *myargs;
 357
 358     if ((myargs = ReadArgs(ARG_TEMPLATE, args, NULL)))
 359     {
 360         if (args[ARG_SCR])
 361             forcescreen = TRUE;
 362         else if (args[ARG_WIN])
 363             forcewindow = TRUE;
 364
 365         if (args[ARG_X]) winx = *(IPTR *)args[ARG_X];
 366         if (args[ARG_Y]) winy = *(IPTR *)args[ARG_Y];
 367
 368         FreeArgs(myargs);
 369     }
 370 }
 371
 372 /***********************************************************************************/
 373
 374 static void openlibs(void)
 375 {
 376     if (!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 39)))
 377     {
 378         cleanup("Can't open intuition.library V39!");
 379     }
 380
 381     if (!(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 39)))
 382     {
 383         cleanup("Can't open graphics.library V39!");
 384     }
 385
 386     if (!(CyberGfxBase = OpenLibrary("cybergraphics.library",0)))
 387     {
 388         cleanup("Can't open cybergraphics.library!");
 389     }
 390 }
 391
 392
 393 /***********************************************************************************/
 394
 395 static void getvisual(void)
 396 {
 397     if (forcescreen)
 398                 wbscreen = FALSE;
 399
 400     if (!wbscreen)
 401     {
 402         scr = OpenScreenTags(NULL, SA_Width     , W     ,
 403                                    SA_Height    , H     ,
 404                                    SA_Depth     , 8     ,
 405                                    TAG_DONE);
 406         if (!scr) cleanup("Failed to open specified screen!");
 407     }
 408         else if (!(scr = LockPubScreen(NULL)))
 409     {
 410         cleanup("Failed to lock pub screen (workbench)!");
 411     }
 412
 413     truecolor = (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) >= 15) ? TRUE : FALSE;
 414
 415         if ((!truecolor) && (wbscreen))
 416                 mustremap = TRUE;
 417 }
 418
 419 /***********************************************************************************/
 420
 421 static void makewin(void)
 422 {
 423     struct TagItem winonwbtags[] =
 424     {
 425         {WA_DragBar     , TRUE              },
 426         {WA_DepthGadget , TRUE              },
 427         {WA_CloseGadget , TRUE              },
 428         {WA_Title       , (IPTR)"DawaFire"  },
 429         {TAG_DONE                           }
 430     };
 431
 432     struct TagItem winonscrtags[] =
 433     {
 434         {WA_Borderless, TRUE },
 435         {TAG_DONE            }
 436     };
 437
 438     if (winx == -1) winx = (scr->Width - W - scr->WBorLeft - scr->WBorRight) / 2;
 439     if (winy == -1) winy = (scr->Height - H - scr->WBorTop - scr->WBorTop - scr->Font->ta_YSize - 1) / 2;
 440
 441     win = OpenWindowTags(NULL, WA_CustomScreen  , (IPTR)scr,
 442                                WA_Left          , winx,
 443                                WA_Top           , winy,
 444                                WA_InnerWidth    , W,
 445                                WA_InnerHeight   , H,
 446                                WA_AutoAdjust    , TRUE,
 447                                WA_Activate      , TRUE,
 448                                WA_IDCMP         , IDCMP_CLOSEWINDOW |
 449                                                   IDCMP_RAWKEY,
 450                                TAG_MORE         , wbscreen ? winonwbtags : winonscrtags);
 451
 452    if (!win) cleanup("Can't open window");
 453
 454    rp = win->RPort;
 455 }
 456
 457 /***********************************************************************************/
 458
 459 #define KC_LEFT         0x4F
 460 #define KC_RIGHT        0x4E
 461 #define KC_UP           0x4C
 462 #define KC_DOWN         0x4D
 463 #define KC_ESC          0x45
 464
 465 /***********************************************************************************/
 466
 467 static void getevents(void)
 468 {
 469     struct IntuiMessage *msg;
 470
 471     while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
 472     {
 473         switch(msg->Class)
 474         {
 475             case IDCMP_CLOSEWINDOW:
 476                 Keys[KC_ESC] = 1;
 477                 break;
 478
 479             case IDCMP_RAWKEY:
 480                 {
 481                     WORD code = msg->Code & ~IECODE_UP_PREFIX;
 482
 483                     Keys[code] = (code == msg->Code) ? 1 : 0;
 484
 485                 }
 486                 break;
 487
 488         }
 489         ReplyMsg((struct Message *)msg);
 490     }
 491
 492 }
 493
 494 /***********************************************************************************/
 495
 496 static void action(void)
 497 {
 498     initdawafire();
 499
 500     /* Init Particle */
 501
 502     firstparticle = NULL;
 503
 504     /* Init FPS */
 505
 506     //init_fps ();
 507
 508     while (!Keys[KC_ESC])
 509     {
 510         getevents();
 511
 512         refresh();
 513
 514         WaitTOF();
 515         //next_fps();
 516     }
 517
 518     /* Aff FPS */
 519
 520     //aff_fps (NAME);
 521
 522 }
 523
 524 /***********************************************************************************/
 525
 526 int main(void)
 527 {
 528     getarguments();
 529     openlibs();
 530     getvisual();
 531     makewin();
 532     action();
 533     cleanup(0);
 534
 535     return 0;
 536 }
 537
 538 /***********************************************************************************/
 539