rom/graphics/draw.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Graphics function Draw()
   6     Lang: english
   7 */
   8
   9 #include <aros/debug.h>
  10 #include <clib/macros.h>
  11 #include <graphics/rastport.h>
  12 #include <proto/graphics.h>
  13 #include <proto/oop.h>
  14 #include "gfxfuncsupport.h"
  15 #include "graphics_intern.h"
  16 #include "intregions.h"
  17 #include <stdlib.h>
  18
  19 /*****************************************************************************
  20
  21     NAME */
  22
  23         AROS_LH3(void, Draw,
  24
  25 /*  SYNOPSIS */
  26         AROS_LHA(struct RastPort *, rp, A1),
  27         AROS_LHA(LONG             , x, D0),
  28         AROS_LHA(LONG             , y, D1),
  29
  30 /*  LOCATION */
  31         struct GfxBase *, GfxBase, 41, Graphics)
  32
  33 /*  FUNCTION
  34         Draw a line from the current pen position to the given coordinate.
  35
  36     INPUTS
  37         rp  - destination RastPort.
  38         x,y - line end coordinate.
  39
  40     RESULT
  41
  42     NOTES
  43         Not yet implemented:
  44
  45           - handle layer->Scroll_X/Scroll_Y.
  46
  47           - handle FRST_DOT which indicates whether to draw
  48             or to don't draw first pixel of line. Important
  49             for COMPLEMENT drawmode.
  50
  51     EXAMPLE
  52
  53     BUGS
  54
  55     SEE ALSO
  56
  57     INTERNALS
  58
  59     HISTORY
  60         29-10-95    digulla automatically created from
  61                             graphics_lib.fd and clib/graphics_protos.h
  62
  63 *****************************************************************************/
  64 {
  65     AROS_LIBFUNC_INIT
  66     AROS_LIBBASE_EXT_DECL(struct GfxBase *,GfxBase)
  67
  68
  69     struct Rectangle    rr;
  70     OOP_Object          *gc;
  71     struct Layer        *L = rp->Layer;
  72     struct BitMap       *bm = rp->BitMap;
  73     struct Rectangle     rp_clip_rectangle;
  74     BOOL                 have_rp_cliprectangle;
  75     LONG                 dx, dy;
  76     LONG                 x1, y1;
  77
  78     if (!OBTAIN_DRIVERDATA(rp, GfxBase))
  79         return;
  80
  81     FIX_GFXCOORD(x);
  82     FIX_GFXCOORD(y);
  83
  84     x1 = rp->cp_x;
  85     y1 = rp->cp_y;
  86
  87     gc = GetDriverData(rp)->dd_GC;
  88
  89     if (x1 > x)
  90     {
  91         rr.MinX = x;
  92         rr.MaxX = x1;
  93     }
  94     else
  95     {
  96         rr.MinX = x1;
  97         rr.MaxX = x;
  98     }
  99
 100     if (y1 > y)
 101     {
 102         rr.MinY = y;
 103         rr.MaxY = y1;
 104     }
 105     else
 106     {
 107         rr.MinY = y1;
 108         rr.MaxY = y;
 109     }
 110
 111     {
 112         UWORD lineptrn = rp->LinePtrn;
 113
 114         if (rp->DrawMode & INVERSVID) lineptrn = ~lineptrn;
 115
 116         {
 117             struct TagItem gctags[] =
 118             {
 119                 {aHidd_GC_LinePattern   , lineptrn      },
 120                 {aHidd_GC_LinePatternCnt, rp->linpatcnt },
 121                 {TAG_DONE                               }
 122             };
 123
 124             OOP_SetAttrs( gc, gctags);
 125         }
 126     }
 127
 128
 129     if (NULL == L)
 130     {
 131         /* No layer, probably a screen, but may be a user inited bitmap */
 132         OOP_Object *bm_obj;
 133
 134         bm_obj = OBTAIN_HIDD_BM(bm);
 135         if (bm_obj)
 136         {
 137             /* No need for clipping */
 138             HIDD_BM_DrawLine(bm_obj, gc, x1, y1, x, y);
 139
 140             RELEASE_HIDD_BM(bm_obj, bm);
 141         }
 142
 143     }
 144     else
 145     {
 146         struct ClipRect     *CR;
 147         WORD                xrel;
 148         WORD                yrel;
 149         struct Rectangle    torender, intersect;
 150         OOP_Object          *bm_obj;
 151
 152         LockLayerRom(L);
 153
 154         x1 -= L->Scroll_X;
 155         y1 -= L->Scroll_Y;
 156         x  -= L->Scroll_X;
 157         y  -= L->Scroll_Y;
 158
 159         have_rp_cliprectangle = GetRPClipRectangleForLayer(rp, L, &rp_clip_rectangle, GfxBase);
 160
 161         xrel = L->bounds.MinX;
 162         yrel = L->bounds.MinY;
 163
 164         torender.MinX = rr.MinX + xrel - L->Scroll_X;
 165         torender.MinY = rr.MinY + yrel - L->Scroll_Y;
 166         torender.MaxX = rr.MaxX + xrel - L->Scroll_X;
 167         torender.MaxY = rr.MaxY + yrel - L->Scroll_Y;
 168
 169         CR = L->ClipRect;
 170
 171         for (;NULL != CR; CR = CR->Next)
 172         {
 173             D(bug("Cliprect (%d, %d, %d, %d), lobs=%p\n",
 174                 CR->bounds.MinX, CR->bounds.MinY, CR->bounds.MaxX, CR->bounds.MaxY,
 175                 CR->lobs));
 176
 177             /* Does this cliprect intersect with area to rectfill ? */
 178             if (_AndRectRect(&CR->bounds, &torender, &intersect))
 179             {
 180                 if (!have_rp_cliprectangle || _AndRectRect(&rp_clip_rectangle, &intersect, &intersect))
 181                 {
 182                     if (NULL == CR->lobs)
 183                     {
 184                         /* Set clip rectangle */
 185                         HIDD_GC_SetClipRect(gc
 186                             , intersect.MinX
 187                             , intersect.MinY
 188                             , intersect.MaxX
 189                             , intersect.MaxY
 190                         );
 191
 192                         bm_obj = OBTAIN_HIDD_BM(bm);
 193                         if (bm_obj)
 194                         {
 195                             HIDD_BM_DrawLine(bm_obj
 196                                 , gc
 197                                 , x1 + xrel
 198                                 , y1 + yrel
 199                                 , x + xrel
 200                                 , y + yrel
 201                             );
 202
 203                             RELEASE_HIDD_BM(bm_obj, bm);
 204                         }
 205
 206                         HIDD_GC_UnsetClipRect(gc);
 207
 208                     }
 209                     else
 210                     {
 211                         /* Render into offscreen cliprect bitmap */
 212                         if (L->Flags & LAYERSIMPLE)
 213                             continue;
 214                         else if (L->Flags & LAYERSUPER)
 215                         {
 216                             D(bug("do_render_func(): Superbitmap not handled yet\n"));
 217                         }
 218                         else
 219                         {
 220                             LONG bm_rel_minx, bm_rel_miny, bm_rel_maxx, bm_rel_maxy;
 221                             LONG layer_rel_x, layer_rel_y;
 222
 223                             layer_rel_x = intersect.MinX - xrel;
 224                             layer_rel_y = intersect.MinY - yrel;
 225
 226
 227                             bm_rel_minx = intersect.MinX - CR->bounds.MinX;
 228                             bm_rel_miny = intersect.MinY - CR->bounds.MinY;
 229                             bm_rel_maxx = intersect.MaxX - CR->bounds.MinX;
 230                             bm_rel_maxy = intersect.MaxY - CR->bounds.MinY;
 231
 232                             HIDD_GC_SetClipRect(gc
 233                                     , bm_rel_minx + ALIGN_OFFSET(CR->bounds.MinX)
 234                                     , bm_rel_miny
 235                                     , bm_rel_maxx + ALIGN_OFFSET(CR->bounds.MinX)
 236                                     , bm_rel_maxy
 237                             );
 238
 239                             bm_obj = OBTAIN_HIDD_BM(CR->BitMap);
 240                             if (bm_obj)
 241                             {
 242                                 HIDD_BM_DrawLine(bm_obj
 243                                         , gc
 244                                         , bm_rel_minx - (layer_rel_x - x1) + ALIGN_OFFSET(CR->bounds.MinX)
 245                                         , bm_rel_miny - (layer_rel_y - y1)
 246                                         , bm_rel_minx - (layer_rel_x - x) + ALIGN_OFFSET(CR->bounds.MinX)
 247                                         , bm_rel_miny - (layer_rel_y - y)
 248                                 );
 249
 250                                 RELEASE_HIDD_BM(bm_obj, CR->BitMap);
 251                             }
 252                             HIDD_GC_UnsetClipRect(gc);
 253                         }
 254
 255                     } /* if (CR->lobs == NULL) */
 256
 257                 } /* if it also intersects with possible rastport clip rectangle */
 258
 259             } /* if (cliprect intersects with area to render into) */
 260
 261         } /* for (each cliprect in the layer) */
 262
 263         UnlockLayerRom(L);
 264
 265     } /* if (rp->Layer) */
 266
 267     dx = abs(x1 - x);
 268     dy = abs(y1 - y);
 269     if (dy > dx) dx = dy;
 270
 271     rp->linpatcnt = ((LONG)rp->linpatcnt - dx) & 15;
 272
 273     rp->cp_x = x;
 274     rp->cp_y = y;
 275
 276     RELEASE_DRIVERDATA(rp, GfxBase);
 277
 278     AROS_LIBFUNC_EXIT
 279
 280 } /* Draw */