Demo/Kitty/main.c

   1 #include <intuition/intuition.h>
   2 #include <cybergraphx/cybergraphics.h>
   3
   4 #include <proto/exec.h>
   5 #include <proto/graphics.h>
   6 #include <proto/intuition.h>
   7 #include <proto/cybergraphics.h>
   8 #include <proto/alib.h>
   9
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <stdlib.h>
  13
  14 #include "kittysprite_image.c"
  15
  16 static struct Screen    *scr;
  17 static struct Window    *win;
  18 static struct Region    *shape;
  19 static Object           *draggad;
  20 static BOOL              remapped, truecolor, shape_active = TRUE;
  21 static UBYTE             chunky[KITTYSPRITE_WIDTH * KITTYSPRITE_HEIGHT];
  22 static UBYTE             remaptable[KITTYSPRITE_COLORS];
  23 static ULONG             cgfx_coltab[KITTYSPRITE_COLORS];
  24
  25 static void cleanup(char *msg)
  26 {
  27     if (msg)
  28     {
  29         printf("Kitty: %s\n", msg);
  30     }
  31
  32     if (remapped)
  33     {
  34         WORD i;
  35
  36         for(i = 0; i < KITTYSPRITE_COLORS; i++)
  37         {
  38             ReleasePen(scr->ViewPort.ColorMap, remaptable[i]);
  39         }
  40     }
  41
  42     if (scr) UnlockPubScreen(NULL, scr);
  43     if (draggad) DisposeObject(draggad);
  44     if (win) CloseWindow(win);
  45
  46     exit(0);
  47 }
  48
  49 static void getvisual(void)
  50 {
  51     if (!(scr = LockPubScreen(NULL)))
  52     {
  53         cleanup("Can't lock pub screen!");
  54     }
  55
  56     if (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) > 8)
  57     {
  58         truecolor = TRUE;
  59     }
  60 }
  61
  62 #if KITTYSPRITE_PACKED
  63 static BOOL unpack_byterun1(const UBYTE *source, UBYTE *dest, LONG unpackedsize)
  64 {
  65     UBYTE r;
  66     BYTE c;
  67
  68     for(;;)
  69     {
  70         c = (BYTE)(*source++);
  71         if (c >= 0)
  72         {
  73             while(c-- >= 0)
  74             {
  75                 *dest++ = *source++;
  76                 if (--unpackedsize <= 0) return FALSE;
  77             }
  78         }
  79         else if (c != -128)
  80         {
  81             c = -c;
  82             r = *source++;
  83
  84             while(c-- >= 0)
  85             {
  86                 *dest++ = r;
  87                 if (--unpackedsize <= 0) return FALSE;
  88             }
  89         }
  90     }
  91
  92     return TRUE;
  93 }
  94 #endif
  95
  96 static void makegfx(void)
  97 {
  98     LONG i;
  99
 100 #if KITTYSPRITE_PACKED
 101     unpack_byterun1(kittysprite_data, chunky, KITTYSPRITE_WIDTH * KITTYSPRITE_HEIGHT);
 102 #else
 103     memcpy(chunky, kittysprite_data, KITTYSPRITE_WIDTH * KITTYSPRITE_HEIGHT);
 104 #endif
 105
 106     shape = NewRegion();
 107     if (shape)
 108     {
 109         WORD x, y;
 110
 111         for(y = 0; y < KITTYSPRITE_HEIGHT; y++)
 112         {
 113             struct Rectangle rect = {0, y, 0, y};
 114             BOOL             transp, transpstate = TRUE;
 115
 116             for(x = 0; x < KITTYSPRITE_WIDTH; x++)
 117             {
 118                 transp = chunky[y * KITTYSPRITE_WIDTH + x] == 0;
 119
 120                 if (transpstate)
 121                 {
 122                     if (!transp)
 123                     {
 124                         rect.MaxX = rect.MinX = x;
 125                         transpstate = FALSE;
 126                     }
 127                 }
 128                 else
 129                 {
 130                     if (transp)
 131                     {
 132                         OrRectRegion(shape, &rect);
 133                         transpstate = TRUE;
 134                     }
 135                     else
 136                     {
 137                         rect.MaxX++;
 138                     }
 139                 }
 140             }
 141
 142             if (!transpstate) OrRectRegion(shape, &rect);
 143         }
 144     }
 145
 146     for(i = 0; i < KITTYSPRITE_COLORS; i++)
 147     {
 148         if (truecolor)
 149         {
 150             cgfx_coltab[i] = kittysprite_pal[i];
 151         }
 152         else
 153         {
 154             ULONG r = (kittysprite_pal[i] >> 16) & 0xFF;
 155             ULONG g = (kittysprite_pal[i] >> 8) & 0xFF;
 156             ULONG b = (kittysprite_pal[i]) & 0xFF;
 157
 158             remaptable[i] = ObtainBestPen(scr->ViewPort.ColorMap,
 159                                           r * 0x01010101,
 160                                           g * 0x01010101,
 161                                           b * 0x01010101,
 162                                           OBP_Precision, PRECISION_IMAGE,
 163                                           OBP_FailIfBad, FALSE,
 164                                           TAG_DONE);
 165         }
 166
 167     }
 168
 169     if (!truecolor)
 170     {
 171         remapped = TRUE;
 172
 173         for(i = 0; i < KITTYSPRITE_WIDTH * KITTYSPRITE_HEIGHT; i++)
 174         {
 175             chunky[i] = remaptable[chunky[i]];
 176         }
 177     }
 178
 179 }
 180
 181 static void makedraggad(void)
 182 {
 183     draggad = NewObject(NULL, GADGETCLASS, GA_Left, 0,
 184                                            GA_Top, 0,
 185                                            GA_RelWidth, 0,
 186                                            GA_RelHeight, 0,
 187                                            GA_SysGType, GTYP_WDRAGGING,
 188                                            TAG_DONE);
 189
 190
 191 }
 192
 193 static void makewin(void)
 194 {
 195     win = OpenWindowTags(NULL, WA_CustomScreen, (IPTR)scr,
 196                                WA_Left, 0,
 197                                WA_Top, 0,
 198                                WA_Width, KITTYSPRITE_WIDTH,
 199                                WA_Height, KITTYSPRITE_HEIGHT,
 200                                WA_Borderless, TRUE,
 201                                WA_Activate, TRUE,
 202                                WA_IDCMP, IDCMP_VANILLAKEY,
 203                                WA_Gadgets, (IPTR)draggad,
 204                                WA_ShapeRegion, (IPTR)shape,
 205                                TAG_DONE);
 206
 207     if (!win) cleanup("Can't open window!");
 208 }
 209
 210 static void paintwin(void)
 211 {
 212     if (truecolor)
 213     {
 214         WriteLUTPixelArray(chunky,
 215                            0,
 216                            0,
 217                            KITTYSPRITE_WIDTH,
 218                            win->RPort,
 219                            cgfx_coltab,
 220                            0,
 221                            0,
 222                            KITTYSPRITE_WIDTH,
 223                            KITTYSPRITE_HEIGHT,
 224                            CTABFMT_XRGB8);
 225     }
 226     else
 227     {
 228         WriteChunkyPixels(win->RPort,
 229                           0,
 230                           0,
 231                           KITTYSPRITE_WIDTH - 1,
 232                           KITTYSPRITE_HEIGHT - 1,
 233                           chunky,
 234                           KITTYSPRITE_WIDTH);
 235     }
 236 }
 237
 238 static void handleall(void)
 239 {
 240     struct IntuiMessage *msg;
 241     BOOL                 quitme = FALSE;
 242
 243     while(!quitme)
 244     {
 245         WaitPort(win->UserPort);
 246         while((msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
 247         {
 248             switch(msg->Class)
 249             {
 250                 case IDCMP_VANILLAKEY:
 251                     switch(msg->Code)
 252                     {
 253                         case 'Q':
 254                         case 'q':
 255                         case 'X':
 256                         case 'x':
 257                         case 27:
 258                             quitme = TRUE;
 259                             break;
 260
 261                         case 'F':
 262                         case 'f':
 263                         case 13:
 264                             WindowToFront(win);
 265                             break;
 266
 267                         case 'B':
 268                         case 'b':
 269                         case 8:
 270                             WindowToBack(win);
 271                             break;
 272
 273                         case 'S':
 274                         case 's':
 275                         case 'M':
 276                         case 'm':
 277                         case 32:
 278                             ChangeWindowShape(win, (shape_active ? NULL: shape), NULL);
 279                             shape_active = !shape_active;
 280                             break;
 281                     } /* switch(msg->Code) */
 282                     break;
 283
 284             } /* switch(msg->Class) */
 285
 286             ReplyMsg((struct Message *)msg);
 287
 288         } /* while((msg = (struct IntuiMessage *)GetMsg(win->UserPort))) */
 289
 290     } /* while(!quitme) */
 291 }
 292
 293 int main(void)
 294 {
 295     getvisual();
 296     makegfx();
 297     makedraggad();
 298     makewin();
 299     paintwin();
 300     handleall();
 301     cleanup(0);
 302
 303     return 0;
 304 }