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