rom/graphics/areaend.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Graphics function AreaEnd()
   6     Lang: english
   7 */
   8 #include <exec/types.h>
   9 #include <graphics/rastport.h>
  10 #include "graphics_intern.h"
  11
  12 /*****************************************************************************
  13
  14     NAME */
  15 #include <proto/graphics.h>
  16
  17         AROS_LH1(LONG, AreaEnd,
  18
  19 /*  SYNOPSIS */
  20         AROS_LHA(struct RastPort *, rp, A1),
  21
  22 /*  LOCATION */
  23         struct GfxBase *, GfxBase, 44, Graphics)
  24
  25 /*  FUNCTION
  26         Process the filled vector buffer.
  27         After the operation the buffer is reinitialized for
  28         processing of further Area functions.
  29         Makes use of the raster given by the TmpRas structure that
  30         is linked to the rastport.
  31
  32     INPUTS
  33         rp - pointer to a valid RastPort structure with a pointer to
  34              the previously initialized AreaInfo structure.
  35
  36
  37     RESULT
  38         error -  0 for success
  39                 -1 a error occurred
  40
  41     NOTES
  42
  43     EXAMPLE
  44
  45     BUGS
  46         There is still a problem when some polygons are filled that
  47         pixels are missing. This could be due to the way lines are
  48         drawn. All lines should be drawn from lower
  49         y coordinates to higher y coordinates since this is the
  50         way the algorithm calculates lines here. For example, it
  51         might make a difference whether a line is drawn from lower
  52         to higher y coordinates. Examples for two same lines with
  53         different layout:
  54
  55              ****              *****
  56         *****              ****
  57
  58
  59     SEE ALSO
  60         InitArea(), AreaDraw(), AreaEllipse(), AreaCircle()
  61         graphics/rastport.h
  62
  63     INTERNALS
  64
  65     HISTORY
  66
  67 *****************************************************************************/
  68 {
  69     AROS_LIBFUNC_INIT
  70
  71     struct AreaInfo * areainfo = rp->AreaInfo;
  72
  73     /* is there anything in the matrix at all ? And do we have a TmpRas in the rastport? */
  74     if (areainfo->Count && rp->TmpRas)
  75     {
  76         WORD first_idx = 0;
  77         WORD last_idx  = -1;
  78         ULONG BytesPerRow;
  79         UWORD * CurVctr  = areainfo -> VctrTbl;
  80         BYTE  * CurFlag  = areainfo -> FlagTbl;
  81         UWORD Count;
  82         UWORD Rem_APen   = GetAPen(rp);
  83         /* I don't know whether this function may corrupt the
  84            cursor position of the rastport. So I save it for later.*/
  85
  86         UWORD Rem_cp_x   = rp->cp_x;
  87         UWORD Rem_cp_y   = rp->cp_y;
  88         /* This rectangle serves as a "frame" for the tmpras for filling */
  89         struct Rectangle bounds;
  90
  91
  92         areaclosepolygon(areainfo);
  93
  94         Count = areainfo->Count;
  95
  96         //kprintf("%d coord to process\n",Count);
  97
  98         /* process the list of vectors */
  99         while (Count > 0)
 100         {
 101             //kprintf("\n******** Flags:%d Coord: (%d,%d)\n",CurFlag[0], CurVctr[0],CurVctr[1]);
 102
 103             last_idx ++;
 104             switch((unsigned char)CurFlag[0])
 105             {
 106                 case AREAINFOFLAG_MOVE:
 107                     /* set the graphical cursor to a starting position */
 108                     Move(rp, CurVctr[0], CurVctr[1]);
 109
 110                     bounds.MinX = CurVctr[0];
 111                     bounds.MaxX = CurVctr[0];
 112                     bounds.MinY = CurVctr[1];
 113                     bounds.MaxY = CurVctr[1];
 114
 115                     CurVctr = &CurVctr[2];
 116                     CurFlag = &CurFlag[1];
 117                     break;
 118
 119                 case AREAINFOFLAG_CLOSEDRAW:
 120                     /* this indicates that this Polygon is closed with this coordinate */
 121                     /*
 122                      * Must draw from lower y's to higher ones otherwise
 123                      * the fill algo does not work nicely.
 124                      */
 125 #if 1
 126                     if (rp->cp_y <= CurVctr[1]) {
 127                       Draw(rp, CurVctr[0], CurVctr[1]);
 128                     } else {
 129                       int _x = rp->cp_x;
 130                       int _y = rp->cp_y;
 131                       rp->cp_x = CurVctr[0];
 132                       rp->cp_y = CurVctr[1];
 133                       Draw(rp, _x, _y);
 134                       rp->cp_x = CurVctr[0];
 135                       rp->cp_y = CurVctr[1];
 136                     }
 137 #endif
 138                     CurVctr = &CurVctr[2];
 139                     CurFlag = &CurFlag[1];
 140                     /*
 141                        no need to set the bundaries here like in case above as
 142                        this coord closes the polygon and therefore is the same
 143                        one as the first coordinate of the polygon.
 144                     */
 145                     /* check whether there's anything to fill at all. I cannot
 146                        fill a line (=3 coordinates) */
 147                     if (first_idx+2 <= last_idx)
 148                     {
 149                         /* BytesPerRow must be a multiple of 2 bytes */
 150
 151                         BytesPerRow = bounds.MaxX - bounds.MinX + 1;
 152                         if (0 != (BytesPerRow & 0x0f ))
 153                             BytesPerRow =((BytesPerRow >> 3) & 0xfffe )+ 2;
 154                         else
 155                             BytesPerRow = (BytesPerRow >> 3) & 0xfffe;
 156
 157                         if ((ULONG)rp->TmpRas->Size < BytesPerRow * (bounds.MaxY - bounds.MinY + 1))
 158                             return -1;
 159
 160           /*
 161                         kprintf("first: %d, last: %d\n",first_idx,last_idx);
 162                         kprintf("(%d,%d)-(%d,%d)\n",bounds.MinX,bounds.MinY,
 163                                                     bounds.MaxX,bounds.MaxY);
 164                         kprintf("width: %d, bytesperrow: %d\n",bounds.MaxX-bounds.MinX+1,
 165                                                                BytesPerRow);
 166           */
 167 #if 1
 168                         if (areafillpolygon(rp,
 169                                                     &bounds,
 170                                                     first_idx,
 171                                                     last_idx,
 172                                                     BytesPerRow,
 173                                                     GfxBase))
 174                         {
 175                             /*
 176                              Blit the area fill pattern through the mask provided
 177                              by rp->TmpRas.
 178                             */
 179
 180                             BltPattern(
 181                                rp,
 182                                rp->TmpRas->RasPtr,
 183                                bounds.MinX,
 184                                bounds.MinY,
 185                                bounds.MaxX,
 186                                bounds.MaxY,
 187                                BytesPerRow
 188                             );
 189
 190                             if  (rp->Flags & AREAOUTLINE)
 191                             {
 192                                 SetAPen(rp, GetOutlinePen(rp));
 193                                 PolyDraw(rp, last_idx - first_idx + 1, &areainfo->VctrTbl[first_idx]);
 194                                 SetAPen(rp, Rem_APen);
 195                             }
 196
 197                         }
 198 #endif
 199                     }
 200                     /* set first_idx for a possible next polygon to draw */
 201                     first_idx = last_idx + 1;
 202                     break;
 203
 204                 case AREAINFOFLAG_DRAW:
 205                     /* Draw a line to new position */
 206 #if 1
 207                     /*
 208                      * Must draw from lower y's to higher ones otherwise
 209                      * the fill algo does not work nicely.
 210                      */
 211                     if (rp->cp_y <= CurVctr[1]) {
 212                       Draw(rp, CurVctr[0], CurVctr[1]);
 213                     } else {
 214                       int _x = rp->cp_x;
 215                       int _y = rp->cp_y;
 216                       rp->cp_x = CurVctr[0];
 217                       rp->cp_y = CurVctr[1];
 218                       Draw(rp, _x, _y);
 219                       rp->cp_x = CurVctr[0];
 220                       rp->cp_y = CurVctr[1];
 221                     }
 222 #endif
 223                     if (bounds.MinX > CurVctr[0])
 224                         bounds.MinX = CurVctr[0];
 225                     if (bounds.MaxX < CurVctr[0])
 226                         bounds.MaxX = CurVctr[0];
 227                     if (bounds.MinY > CurVctr[1])
 228                         bounds.MinY = CurVctr[1];
 229                     if (bounds.MaxY < CurVctr[1])
 230                         bounds.MaxY = CurVctr[1];
 231                     CurVctr = &CurVctr[2];
 232                     CurFlag = &CurFlag[1];
 233                     break;
 234
 235                 case AREAINFOFLAG_ELLIPSE:
 236                     bounds.MinX = CurVctr[0] - CurVctr[2];
 237                     bounds.MaxX = CurVctr[0] + CurVctr[2];
 238                     bounds.MinY = CurVctr[1] - CurVctr[3];
 239                     bounds.MaxY = CurVctr[1] + CurVctr[3];
 240                     BytesPerRow = bounds.MaxX - bounds.MinX + 1;
 241
 242                     if (0 != (BytesPerRow & 0x0f ))
 243                         BytesPerRow =((BytesPerRow >> 3) & 0xfffe )+ 2;
 244                     else
 245                         BytesPerRow = (BytesPerRow >> 3) & 0xfffe;
 246
 247                     if ((ULONG)rp->TmpRas->Size < BytesPerRow * (bounds.MaxY - bounds.MinY + 1))
 248                         return -1;
 249
 250                     /* Draw an Ellipse and fill it */
 251                     /* see how the data are stored by the second entry */
 252                     /* I get cx,cy,cx+a,cy+b*/
 253
 254                     DrawEllipse(rp,CurVctr[0],
 255                                    CurVctr[1],
 256                                    CurVctr[2],
 257                                    CurVctr[3]);
 258
 259                     /* area-fill the ellipse with the pattern given
 260                        in rp->AreaPtrn , AreaPtSz */
 261
 262                     areafillellipse(rp,
 263                                     &bounds,
 264                                     CurVctr,
 265                                     BytesPerRow,
 266                                     GfxBase);
 267                       /*
 268                         Blit the area fill pattern through the mask provided
 269                         by rp->TmpRas.
 270                       */
 271
 272                     BltPattern(
 273                            rp,
 274                            rp->TmpRas->RasPtr,
 275                            bounds.MinX,
 276                            bounds.MinY,
 277                            bounds.MaxX,
 278                            bounds.MaxY,
 279                            BytesPerRow
 280                         );
 281
 282                     if (rp->Flags & AREAOUTLINE)
 283                     {
 284                         SetAPen(rp, GetOutlinePen(rp));
 285
 286                         DrawEllipse(rp,CurVctr[0],
 287                                        CurVctr[1],
 288                                        CurVctr[2],
 289                                        CurVctr[3]);
 290
 291                         SetAPen(rp, Rem_APen);
 292                     }
 293
 294                     CurVctr = &CurVctr[4];
 295                     CurFlag = &CurFlag[2];
 296                     Count--;
 297                     last_idx++; /* there were two coords here! */
 298
 299                     /* set first_idx for a possible next polygon to draw */
 300                     first_idx = last_idx + 1;
 301                     break;
 302
 303                 default:
 304                     /* this is an error */
 305                     SetAPen(rp, Rem_APen);
 306                     /* also restore old graphics cursor position */
 307                     rp->cp_x = Rem_cp_x;
 308                     rp->cp_y = Rem_cp_y;
 309                     return -1;
 310
 311             } /* switch((unsigned char)CurFlag[0]) */
 312             Count--;
 313
 314         } /* while (Count > 0) */
 315
 316         /* restore areainfo structure for a new beginning */
 317         areainfo->VctrPtr = areainfo->VctrTbl;
 318         areainfo->FlagPtr = areainfo->FlagTbl;
 319         areainfo->Count   = 0;
 320
 321         /* restore old APen */
 322         SetAPen(rp, Rem_APen);
 323         /* also restore old graphics cursor position */
 324         rp->cp_x = Rem_cp_x;
 325         rp->cp_y = Rem_cp_y;
 326
 327     } /* if vectorlist is not empty and rastport has a tmpras */
 328
 329     return 0;
 330
 331     AROS_LIBFUNC_EXIT
 332
 333 } /* AreaEnd */