rom/graphics/areaend.c

   1 /*
   2     Copyright © 1995-2013, 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         UWORD Rem_Flags = rp->Flags;
  84         /* I don't know whether this function may corrupt the
  85            cursor position of the rastport. So I save it for later.*/
  86
  87         UWORD Rem_cp_x   = rp->cp_x;
  88         UWORD Rem_cp_y   = rp->cp_y;
  89         /* This rectangle serves as a "frame" for the tmpras for filling */
  90         struct Rectangle bounds;
  91
  92
  93         areaclosepolygon(areainfo);
  94
  95         Count = areainfo->Count;
  96
  97         //kprintf("%d coord to process\n",Count);
  98
  99         /* process the list of vectors */
 100         while (Count > 0)
 101         {
 102             //kprintf("\n******** Flags:%d Coord: (%d,%d)\n",CurFlag[0], CurVctr[0],CurVctr[1]);
 103
 104             last_idx ++;
 105             switch((unsigned char)CurFlag[0])
 106             {
 107                 case AREAINFOFLAG_MOVE:
 108                     /* set the graphical cursor to a starting position */
 109                     Move(rp, CurVctr[0], CurVctr[1]);
 110
 111                     bounds.MinX = CurVctr[0];
 112                     bounds.MaxX = CurVctr[0];
 113                     bounds.MinY = CurVctr[1];
 114                     bounds.MaxY = CurVctr[1];
 115
 116                     CurVctr = &CurVctr[2];
 117                     CurFlag = &CurFlag[1];
 118                     break;
 119
 120                 case AREAINFOFLAG_CLOSEDRAW:
 121                     /* this indicates that this Polygon is closed with this coordinate */
 122                     /*
 123                      * Must draw from lower y's to higher ones otherwise
 124                      * the fill algo does not work nicely.
 125                      */
 126 #if 1
 127                     if (rp->cp_y <= CurVctr[1]) {
 128                       Draw(rp, CurVctr[0], CurVctr[1]);
 129                     } else {
 130                       int _x = rp->cp_x;
 131                       int _y = rp->cp_y;
 132                       rp->cp_x = CurVctr[0];
 133                       rp->cp_y = CurVctr[1];
 134                       Draw(rp, _x, _y);
 135                       rp->cp_x = CurVctr[0];
 136                       rp->cp_y = CurVctr[1];
 137                     }
 138 #endif
 139                     CurVctr = &CurVctr[2];
 140                     CurFlag = &CurFlag[1];
 141                     /*
 142                        no need to set the boundaries here like in case above as
 143                        this coord closes the polygon and therefore is the same
 144                        one as the first coordinate of the polygon.
 145                     */
 146                     /* check whether there's anything to fill at all. I cannot
 147                        fill a line (=3 coordinates) */
 148                     if (first_idx+2 <= last_idx)
 149                     {
 150                         /* BytesPerRow must be a multiple of 2 bytes */
 151
 152                         BytesPerRow = bounds.MaxX - bounds.MinX + 1;
 153                         if (0 != (BytesPerRow & 0x0f ))
 154                             BytesPerRow =((BytesPerRow >> 3) & 0xfffe )+ 2;
 155                         else
 156                             BytesPerRow = (BytesPerRow >> 3) & 0xfffe;
 157
 158                         if ((ULONG)rp->TmpRas->Size < BytesPerRow * (bounds.MaxY - bounds.MinY + 1))
 159                             return -1;
 160
 161           /*
 162                         kprintf("first: %d, last: %d\n",first_idx,last_idx);
 163                         kprintf("(%d,%d)-(%d,%d)\n",bounds.MinX,bounds.MinY,
 164                                                     bounds.MaxX,bounds.MaxY);
 165                         kprintf("width: %d, bytesperrow: %d\n",bounds.MaxX-bounds.MinX+1,
 166                                                                BytesPerRow);
 167           */
 168 #if 1
 169                         if (areafillpolygon(rp,
 170                                                     &bounds,
 171                                                     first_idx,
 172                                                     last_idx,
 173                                                     BytesPerRow,
 174                                                     GfxBase))
 175                         {
 176                             /*
 177                              Blit the area fill pattern through the mask provided
 178                              by rp->TmpRas.
 179                             */
 180
 181                             BltPattern(
 182                                rp,
 183                                rp->TmpRas->RasPtr,
 184                                bounds.MinX,
 185                                bounds.MinY,
 186                                bounds.MaxX,
 187                                bounds.MaxY,
 188                                BytesPerRow
 189                             );
 190
 191                             if  (rp->Flags & AREAOUTLINE)
 192                             {
 193                                 SetAPen(rp, GetOutlinePen(rp));
 194                                 PolyDraw(rp, last_idx - first_idx + 1, &areainfo->VctrTbl[first_idx * 2]);
 195                                 SetAPen(rp, Rem_APen);
 196                                 rp->Flags = Rem_Flags;
 197                             }
 198
 199                         }
 200 #endif
 201                     }
 202                     /* set first_idx for a possible next polygon to draw */
 203                     first_idx = last_idx + 1;
 204                     break;
 205
 206                 case AREAINFOFLAG_DRAW:
 207                     /* Draw a line to new position */
 208 #if 1
 209                     /*
 210                      * Must draw from lower y's to higher ones otherwise
 211                      * the fill algo does not work nicely.
 212                      */
 213                     if (rp->cp_y <= CurVctr[1]) {
 214                       Draw(rp, CurVctr[0], CurVctr[1]);
 215                     } else {
 216                       int _x = rp->cp_x;
 217                       int _y = rp->cp_y;
 218                       rp->cp_x = CurVctr[0];
 219                       rp->cp_y = CurVctr[1];
 220                       Draw(rp, _x, _y);
 221                       rp->cp_x = CurVctr[0];
 222                       rp->cp_y = CurVctr[1];
 223                     }
 224 #endif
 225                     if (bounds.MinX > CurVctr[0])
 226                         bounds.MinX = CurVctr[0];
 227                     if (bounds.MaxX < CurVctr[0])
 228                         bounds.MaxX = CurVctr[0];
 229                     if (bounds.MinY > CurVctr[1])
 230                         bounds.MinY = CurVctr[1];
 231                     if (bounds.MaxY < CurVctr[1])
 232                         bounds.MaxY = CurVctr[1];
 233                     CurVctr = &CurVctr[2];
 234                     CurFlag = &CurFlag[1];
 235                     break;
 236
 237                 case AREAINFOFLAG_ELLIPSE:
 238                     bounds.MinX = CurVctr[0] - CurVctr[2];
 239                     bounds.MaxX = CurVctr[0] + CurVctr[2];
 240                     bounds.MinY = CurVctr[1] - CurVctr[3];
 241                     bounds.MaxY = CurVctr[1] + CurVctr[3];
 242                     BytesPerRow = bounds.MaxX - bounds.MinX + 1;
 243
 244                     if (0 != (BytesPerRow & 0x0f ))
 245                         BytesPerRow =((BytesPerRow >> 3) & 0xfffe )+ 2;
 246                     else
 247                         BytesPerRow = (BytesPerRow >> 3) & 0xfffe;
 248
 249                     if ((ULONG)rp->TmpRas->Size < BytesPerRow * (bounds.MaxY - bounds.MinY + 1))
 250                         return -1;
 251
 252                     /* Draw an Ellipse and fill it */
 253                     /* see how the data are stored by the second entry */
 254                     /* I get cx,cy,cx+a,cy+b*/
 255
 256                     DrawEllipse(rp,CurVctr[0],
 257                                    CurVctr[1],
 258                                    CurVctr[2],
 259                                    CurVctr[3]);
 260
 261                     /* area-fill the ellipse with the pattern given
 262                        in rp->AreaPtrn , AreaPtSz */
 263
 264                     areafillellipse(rp,
 265                                     &bounds,
 266                                     CurVctr,
 267                                     BytesPerRow,
 268                                     GfxBase);
 269                       /*
 270                         Blit the area fill pattern through the mask provided
 271                         by rp->TmpRas.
 272                       */
 273
 274                     BltPattern(
 275                            rp,
 276                            rp->TmpRas->RasPtr,
 277                            bounds.MinX,
 278                            bounds.MinY,
 279                            bounds.MaxX,
 280                            bounds.MaxY,
 281                            BytesPerRow
 282                         );
 283
 284                     if (rp->Flags & AREAOUTLINE)
 285                     {
 286                         SetAPen(rp, GetOutlinePen(rp));
 287
 288                         DrawEllipse(rp,CurVctr[0],
 289                                        CurVctr[1],
 290                                        CurVctr[2],
 291                                        CurVctr[3]);
 292
 293                         SetAPen(rp, Rem_APen);
 294                         rp->Flags = Rem_Flags;
 295                     }
 296
 297                     CurVctr = &CurVctr[4];
 298                     CurFlag = &CurFlag[2];
 299                     Count--;
 300                     last_idx++; /* there were two coords here! */
 301
 302                     /* set first_idx for a possible next polygon to draw */
 303                     first_idx = last_idx + 1;
 304                     break;
 305
 306                 default:
 307                     /* this is an error */
 308                     SetAPen(rp, Rem_APen);
 309                     rp->Flags = Rem_Flags;
 310
 311                     /* also restore old graphics cursor position */
 312                     rp->cp_x = Rem_cp_x;
 313                     rp->cp_y = Rem_cp_y;
 314                     return -1;
 315
 316             } /* switch((unsigned char)CurFlag[0]) */
 317             Count--;
 318
 319         } /* while (Count > 0) */
 320
 321         /* restore areainfo structure for a new beginning */
 322         areainfo->VctrPtr = areainfo->VctrTbl;
 323         areainfo->FlagPtr = areainfo->FlagTbl;
 324         areainfo->Count   = 0;
 325
 326         /* restore old graphics cursor position */
 327         rp->cp_x = Rem_cp_x;
 328         rp->cp_y = Rem_cp_y;
 329
 330     } /* if vectorlist is not empty and rastport has a tmpras */
 331
 332     return 0;
 333
 334     AROS_LIBFUNC_EXIT
 335
 336 } /* AreaEnd */