rom/graphics/drawglist.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Draw the list of gels
   6     Lang: english
   7 */
   8
   9 #include <aros/debug.h>
  10 #include <proto/graphics.h>
  11
  12 #include "graphics_intern.h"
  13 #include "gfxfuncsupport.h"
  14 #include "gels_internal.h"
  15
  16 /*****************************************************************************
  17
  18     NAME */
  19         #include <clib/graphics_protos.h>
  20
  21         AROS_LH2(void, DrawGList,
  22
  23 /*  SYNOPSIS */
  24         AROS_LHA(struct RastPort *, rp, A1),
  25         AROS_LHA(struct ViewPort *, vp, A0),
  26
  27 /*  LOCATION */
  28         struct GfxBase *, GfxBase, 19, Graphics)
  29
  30 /*  FUNCTION
  31         Process the gel list, draw VSprites and Bobs.
  32
  33     INPUTS
  34         rp - RastPort where Bobs will be drawn
  35         vp - ViewPort for VSprites
  36
  37     RESULT
  38
  39     NOTES
  40
  41     EXAMPLE
  42
  43     BUGS
  44
  45     SEE ALSO
  46
  47     INTERNALS
  48
  49     HISTORY
  50
  51 *****************************************************************************/
  52 {
  53         AROS_LIBFUNC_INIT
  54
  55         struct VSprite * CurVSprite = rp->GelsInfo->gelHead;
  56         struct VSprite * AfterPathVSprite = NULL;
  57         int              followdrawpath;
  58         struct VSprite * PrevVSprite = NULL;
  59
  60         /*
  61          * CurVSprite is not a valid VSprite but the "boundary vsprite"
  62          * Should I follow the DrawPath?
  63          */
  64         if (NULL != CurVSprite->IntVSprite &&
  65             NULL != CurVSprite->IntVSprite->DrawPath) {
  66                 followdrawpath = TRUE;
  67                 AfterPathVSprite = CurVSprite->NextVSprite;
  68                 CurVSprite = CurVSprite->IntVSprite->DrawPath;
  69         } else {
  70                 followdrawpath = FALSE;
  71                 CurVSprite = CurVSprite->NextVSprite;
  72         }
  73
  74         /*
  75          * As long as I don't step on the last boundary vsprite
  76          */
  77         while (NULL != CurVSprite->NextVSprite) {
  78                 /*
  79                  * Check a few flags that must not be set.
  80                  * The Bob should not be out of the rastport or already be drawn
  81                  */
  82                 if ( 0 == (CurVSprite->Flags & (GELGONE)) ||
  83                    (NULL != (CurVSprite->VSBob) && 0 == (CurVSprite->VSBob->Flags & BDRAWN))) {
  84                         /*
  85                          * If this VSprite was overlapping with other VSprites
  86                          * the follow the ClearPath first and clear all the
  87                          * VSprites on that path. That routine will also reset
  88                          * the ClearPath variable on all encountered VSprites.
  89                          * If it was not overlapping with other VSprites but
  90                          * was visible before it will either clear or back up
  91                          * the previous background.
  92                          */
  93
  94                         if (NULL != CurVSprite->VSBob)
  95                                 _ClearBobAndFollowClearPath(CurVSprite,rp,GfxBase);
  96
  97                         /*
  98                          * If I am supposed to back up the background then
  99                          * I have to do it now!!
 100                          * This unfortunatley has also to be done if the
 101                          * VSprite/Bob did not move since it could have
 102                          * changed its appearance.
 103                          */
 104                         if (0 != (CurVSprite->Flags & SAVEBACK) && NULL != CurVSprite->VSBob)
 105                         {
 106                                 BltRastPortBitMap(rp,
 107                                                   CurVSprite->X,
 108                                                   CurVSprite->Y,
 109                                                   CurVSprite->IntVSprite->SaveBuffer,
 110                                                   0,
 111                                                   0,
 112                                                   CurVSprite->Width << 4,
 113                                                   CurVSprite->Height,
 114                                                   0x0c0, GfxBase);
 115
 116                                 CurVSprite->Flags |= BACKSAVED;
 117                         }
 118                         else kprintf("NOT SAVING BACKGROUND!\n");
 119
 120                         if (0 == (CurVSprite->Flags & VSPRITE) &&
 121                             BOBSAWAY == (CurVSprite->VSBob->Flags & BOBSAWAY)) {
 122                                 /*
 123                                  * This Bob is to be removed...
 124                                  */
 125                                 CurVSprite->PrevVSprite->NextVSprite = CurVSprite->NextVSprite;
 126                                 CurVSprite->NextVSprite->PrevVSprite = CurVSprite->PrevVSprite;
 127                                 /*
 128                                  * This does not damage the drawpath and clearpath since
 129                                  * the structure is not freed.
 130                                  */
 131                         } else {
 132                                 /*
 133                                  * Now draw the VSprite/Bob at its current location.
 134                                  */
 135                                 _ValidateIntVSprite(CurVSprite->IntVSprite,
 136                                                     rp,
 137                                                     FALSE,
 138                                                     GfxBase);
 139
 140                                 /* FIXME: Wrong minterm is used.
 141                                  * Need to implement mintern '0xe0'.
 142                                  */
 143                                 BltBitMapRastPort(CurVSprite->IntVSprite->ImageData,
 144                                                   0,
 145                                                   0,
 146                                                   rp,
 147                                                   CurVSprite->X,
 148                                                   CurVSprite->Y,
 149                                                   CurVSprite->Width << 4,
 150                                                   CurVSprite->Height,
 151                                                   0x0c0 /* should be 0xe0! */);
 152                                 /*
 153                                  * I will need to know the vsprite's coordinates
 154                                  * that it has now the next time as well for clearing
 155                                  * purposes.
 156                                  */
 157                                 CurVSprite->OldX = CurVSprite->X;
 158                                 CurVSprite->OldY = CurVSprite->Y;
 159
 160                                 if (CurVSprite->VSBob) {
 161                                         /*
 162                                          * it's a bob! mark it as drawn.
 163                                          */
 164                                         CurVSprite->VSBob->Flags |= BDRAWN;
 165                                         CurVSprite->VSBob->Flags &= ~BOBNIX;
 166                                 }
 167                         }
 168                 }
 169
 170                 /*
 171                  * Am I supposed to follow the drawpath.
 172                  * If yes then follow it to its end.
 173                  */
 174
 175                 if (followdrawpath) {
 176                         if (NULL != PrevVSprite)
 177                                 PrevVSprite->ClearPath = CurVSprite;
 178                         PrevVSprite = CurVSprite;
 179
 180                         CurVSprite = CurVSprite->IntVSprite->DrawPath;
 181                         if (NULL == CurVSprite) {
 182                                 followdrawpath = FALSE;
 183                                 PrevVSprite = NULL;
 184                                 CurVSprite = AfterPathVSprite;
 185                         }
 186                 } else {
 187                         if (NULL != PrevVSprite)
 188                                 PrevVSprite->ClearPath = CurVSprite;
 189                         PrevVSprite = CurVSprite;
 190                         CurVSprite = CurVSprite->NextVSprite;
 191                         /*
 192                          * Does a DrawPath start here?
 193                          * If yes, then I will follow the DrawPath
 194                          * after I am done with this VSprite.
 195                          */
 196                         if (NULL != CurVSprite->IntVSprite->DrawPath) {
 197                                 followdrawpath = TRUE;
 198                                 AfterPathVSprite = CurVSprite->NextVSprite;
 199                         }
 200                 }
 201         } /* while not all bobs/vsprites are drawn */
 202
 203         AROS_LIBFUNC_EXIT
 204
 205 } /* DrawGList */