rom/graphics/gels_internal.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Internal function for improved gels handling.
   6     Lang: english
   7 */
   8 #include <graphics/gels.h>
   9 #include <graphics/rastport.h>
  10 #include <exec/memory.h>
  11 #include <proto/graphics.h>
  12 #include <proto/exec.h>
  13 #include "gels_internal.h"
  14 #include "graphics_intern.h"
  15
  16 #define DEBUG 1
  17 #include <aros/debug.h>
  18
  19 struct IntVSprite * _CreateIntVSprite(struct VSprite * vs,
  20                                       struct RastPort * rp,
  21                                       struct GfxBase * GfxBase)
  22 {
  23         struct IntVSprite * ivs = AllocMem(sizeof(struct IntVSprite),
  24                                            MEMF_CLEAR);
  25         if (NULL != ivs) {
  26                 ivs -> VSprite = vs;
  27                 vs->IntVSprite = ivs;
  28
  29                 /*
  30                  * Don't call the validate function when rp=NULL, i.e. when
  31                  * called by InitGels().
  32                  */
  33                 if (NULL != rp)
  34                         _ValidateIntVSprite(ivs,
  35                                             rp,
  36                                             FALSE,
  37                                             GfxBase);
  38         }
  39         return ivs;
  40 }
  41
  42
  43 VOID _DeleteIntVSprite(struct VSprite * vs,
  44                        struct GfxBase * GfxBase)
  45 {
  46         struct IntVSprite * ivs = vs->IntVSprite;
  47
  48         if (NULL != ivs) {
  49                 if (NULL != ivs->ImageData)
  50                         FreeBitMap(ivs->ImageData);
  51
  52                 if (NULL != ivs->SaveBuffer)
  53                         FreeBitMap(ivs->SaveBuffer);
  54
  55                 FreeMem(ivs, sizeof(struct IntVSprite));
  56                 vs->IntVSprite = NULL;
  57         }
  58 }
  59
  60
  61 /*
  62  * Check whether the appearance of the VSprite has been changed
  63  * somehow. If for example the Image Data has changed, then
  64  * I will try to update the BitMap of the IntVSprite structure
  65  * to the new image data.
  66  */
  67 BOOL _ValidateIntVSprite(struct IntVSprite * ivs,
  68                          struct RastPort * rp,
  69                          BOOL force_change,
  70                          struct GfxBase * GfxBase)
  71 {
  72         struct VSprite * vs = ivs->VSprite;
  73         /*
  74          * Check whether the ImageData pointer has changed
  75          */
  76         if (vs->ImageData != ivs->OrigImageData ||
  77             force_change) {
  78                 struct BitMap bm;
  79
  80 #if 0
  81 kprintf("%s: Imagedata has changed (old:%p-new:%p)!\n",
  82         __FUNCTION__,
  83         vs->ImageData,
  84         ivs->OrigImageData);
  85 kprintf("PlanePick: %02x, rp->BitMap:%p\n",vs->PlanePick,rp->BitMap);
  86 #endif
  87                 /*
  88                  * Only need to get a new bitmap if
  89                  * something in the size of the bob has changed.
  90                  */
  91                 if ((ivs->Width  != vs->Width )  ||
  92                     (ivs->Height != vs->Height)  ||
  93                     (ivs->Depth  != vs->Depth )    ) {
  94                         if (NULL != ivs->ImageData)
  95                                 FreeBitMap(ivs->ImageData);
  96
  97                         if (NULL != ivs->SaveBuffer)
  98                                 FreeBitMap(ivs->SaveBuffer);
  99                         /*
 100                          * Now get a new bitmap
 101                          */
 102
 103                         ivs->ImageData = AllocBitMap(vs->Width<<4,
 104                                                      vs->Height,
 105                                                      vs->Depth,
 106                                                      BMF_CLEAR,
 107                                                      rp->BitMap);
 108
 109                         ivs->SaveBuffer = AllocBitMap(vs->Width<<4,
 110                                                       vs->Height,
 111                                                       vs->Depth,
 112                                                       0,
 113                                                       rp->BitMap);
 114                         ivs->Width  = vs->Width;
 115                         ivs->Height = vs->Height;
 116                         ivs->Depth  = vs->Depth;
 117                 }
 118
 119                 ivs->OrigImageData = vs->ImageData;
 120
 121                 /*
 122                  * Blit the image data from the VSprite into the
 123                  * ImageData (BitMap) of the IntVSprite
 124                  */
 125                 InitBitMap(&bm,
 126                            ivs->Depth,
 127                            ivs->Width<<4,
 128                            ivs->Height);
 129
 130                 {
 131                     UBYTE *imagedata = (UBYTE *)vs->ImageData;
 132                     WORD  d, shift;
 133
 134                     for (d = 0, shift = 1; d < 8; d++, shift *= 2)
 135                     {
 136                         if (vs->PlanePick & shift)
 137                         {
 138                             bm.Planes[d] = imagedata;
 139                             imagedata += (bm.Rows * bm.BytesPerRow);
 140                         }
 141                         else
 142                         {
 143                             bm.Planes[d] = (vs->PlaneOnOff & shift) ? (PLANEPTR)-1 : NULL;
 144                         }
 145                     }
 146
 147                 }
 148
 149                 BltBitMap(&bm,
 150                           0,
 151                           0,
 152                           ivs->ImageData,
 153                           0,
 154                           0,
 155                           ivs->Width << 4,
 156                           ivs->Height,
 157                           0x0c0,
 158                           vs->PlanePick,
 159                           NULL);
 160
 161         }
 162
 163         return TRUE;
 164 }
 165
 166 /*
 167  * Erase the VSprite from the list and follow the clear path
 168  * first, if necessary! This way of organizing the ClearPath
 169  * makes it easy to implement RemIBob but it leads to a recursion!
 170  * RemIBob could simply call this function here and then redraw
 171  * all cleared Bobs.
 172  * If a recursion is not what we want this can be easily
 173  * changed.
 174  */
 175
 176 void _ClearBobAndFollowClearPath(struct VSprite * CurVSprite,
 177                                  struct RastPort * rp,
 178                                  struct GfxBase * GfxBase)
 179 {
 180         /*
 181          * If the bob has not been drawn, yet, then don't do anything.
 182          * If the bob has already been cleared, then also leave here!
 183          * It does happen that this routine gets called for
 184          * a sprite that has been cleared already.
 185          */
 186         if (0 != (CurVSprite->VSBob->Flags & (BWAITING|BOBNIX))) {
 187                 CurVSprite->VSBob->Flags &= ~BWAITING;
 188                 return;
 189         }
 190
 191         if (NULL != CurVSprite->ClearPath) {
 192                 /*
 193                  * Clear the next one first. (recursion!!!)
 194                  */
 195                 _ClearBobAndFollowClearPath(CurVSprite->ClearPath,
 196                                             rp,
 197                                             GfxBase);
 198                 CurVSprite->ClearPath = NULL;
 199         }
 200
 201
 202         /*
 203          * Only restore the background if the bob image
 204          * that is currently there is to be replaced by
 205          * the background. If SAVEBOB is set the user
 206          * might want some kind of a brush effect.
 207          */
 208
 209         if (0 == (CurVSprite->Flags & SAVEBOB)) {
 210                 if (0 != (CurVSprite->Flags & BACKSAVED)) {
 211                         BltBitMapRastPort(CurVSprite->IntVSprite->SaveBuffer,
 212                                           0,
 213                                           0,
 214                                           rp,
 215                                           CurVSprite->OldX,
 216                                           CurVSprite->OldY,
 217                                           CurVSprite->Width << 4,
 218                                           CurVSprite->Height,
 219                                           0x0c0);
 220                         CurVSprite->Flags &= ~BACKSAVED;
 221
 222                 } /* if (0 != (CurVSprite->Flags & BACKSAVED)) */
 223                   else {
 224                         /*
 225                          * No background was saved. So let's restore the
 226                          * standard background!
 227                          */
 228                         EraseRect(rp,
 229                                   CurVSprite->OldX,
 230                                   CurVSprite->OldY,
 231                                   CurVSprite->OldX + ( CurVSprite->Width << 4 ) - 1,
 232                                   CurVSprite->OldY +   CurVSprite->Height       - 1);
 233                 }
 234                 /*
 235                  * Mark the BOB as cleared.
 236                  */
 237                 CurVSprite->VSBob->Flags |= BOBNIX;
 238         } /* if (0 == (CurVSprite->Flags & SAVEBOB)) */
 239 }