ref: 8dd003eb04aacf13c4a3a3123269a980c03504f9
dir: /sys/src/libmemdraw/line.c/
#include <u.h> #include <libc.h> #include <draw.h> #include <memdraw.h> #include <memlayer.h> enum { Arrow1 = 8, Arrow2 = 10, Arrow3 = 3, }; static int lmin(int a, int b) { if(a < b) return a; return b; } static int lmax(int a, int b) { if(a > b) return a; return b; } #ifdef NOTUSED /* * Rather than line clip, we run the Bresenham loop over the full line, * and clip on each pixel. This is more expensive but means that * lines look the same regardless of how the windowing has tiled them. * For speed, we check for clipping outside the loop and make the * test easy when possible. */ static void horline1(Memimage *dst, Point p0, Point p1, int srcval, Rectangle clipr) { int x, y, dy, deltay, deltax, maxx; int dd, easy, e, bpp, m, m0; uchar *d; deltax = p1.x - p0.x; deltay = p1.y - p0.y; dd = dst->width*sizeof(ulong); dy = 1; if(deltay < 0){ dd = -dd; deltay = -deltay; dy = -1; } maxx = lmin(p1.x, clipr.max.x-1); bpp = dst->depth; m0 = 0xFF^(0xFF>>bpp); m = m0 >> (p0.x&(7/dst->depth))*bpp; easy = ptinrect(p0, clipr) && ptinrect(p1, clipr); e = 2*deltay - deltax; y = p0.y; d = byteaddr(dst, p0); deltay *= 2; deltax = deltay - 2*deltax; for(x=p0.x; x<=maxx; x++){ if(easy || (clipr.min.x<=x && clipr.min.y<=y && y<clipr.max.y)) *d ^= (*d^srcval) & m; if(e > 0){ y += dy; d += dd; e += deltax; }else e += deltay; d++; m >>= bpp; if(m == 0) m = m0; } } static void verline1(Memimage *dst, Point p0, Point p1, int srcval, Rectangle clipr) { int x, y, deltay, deltax, maxy; int easy, e, bpp, m, m0, dd; uchar *d; deltax = p1.x - p0.x; deltay = p1.y - p0.y; dd = 1; if(deltax < 0){ dd = -1; deltax = -deltax; } maxy = lmin(p1.y, clipr.max.y-1); bpp = dst->depth; m0 = 0xFF^(0xFF>>bpp); m = m0 >> (p0.x&(7/dst->depth))*bpp; easy = ptinrect(p0, clipr) && ptinrect(p1, clipr); e = 2*deltax - deltay; x = p0.x; d = byteaddr(dst, p0); deltax *= 2; deltay = deltax - 2*deltay; for(y=p0.y; y<=maxy; y++){ if(easy || (clipr.min.y<=y && clipr.min.x<=x && x<clipr.max.x)) *d ^= (*d^srcval) & m; if(e > 0){ x += dd; d += dd; e += deltay; }else e += deltax; d += dst->width*sizeof(ulong); m >>= bpp; if(m == 0) m = m0; } } static void horliner(Memimage *dst, Point p0, Point p1, Memimage *src, Point dsrc, Rectangle clipr) { int x, y, sx, sy, deltay, deltax, minx, maxx; int bpp, m, m0; uchar *d, *s; deltax = p1.x - p0.x; deltay = p1.y - p0.y; sx = drawreplxy(src->r.min.x, src->r.max.x, p0.x+dsrc.x); minx = lmax(p0.x, clipr.min.x); maxx = lmin(p1.x, clipr.max.x-1); bpp = dst->depth; m0 = 0xFF^(0xFF>>bpp); m = m0 >> (minx&(7/dst->depth))*bpp; for(x=minx; x<=maxx; x++){ y = p0.y + (deltay*(x-p0.x)+deltax/2)/deltax; if(clipr.min.y<=y && y<clipr.max.y){ d = byteaddr(dst, Pt(x, y)); sy = drawreplxy(src->r.min.y, src->r.max.y, y+dsrc.y); s = byteaddr(src, Pt(sx, sy)); *d ^= (*d^*s) & m; } if(++sx >= src->r.max.x) sx = src->r.min.x; m >>= bpp; if(m == 0) m = m0; } } static void verliner(Memimage *dst, Point p0, Point p1, Memimage *src, Point dsrc, Rectangle clipr) { int x, y, sx, sy, deltay, deltax, miny, maxy; int bpp, m, m0; uchar *d, *s; deltax = p1.x - p0.x; deltay = p1.y - p0.y; sy = drawreplxy(src->r.min.y, src->r.max.y, p0.y+dsrc.y); miny = lmax(p0.y, clipr.min.y); maxy = lmin(p1.y, clipr.max.y-1); bpp = dst->depth; m0 = 0xFF^(0xFF>>bpp); for(y=miny; y<=maxy; y++){ if(deltay == 0) /* degenerate line */ x = p0.x; else x = p0.x + (deltax*(y-p0.y)+deltay/2)/deltay; if(clipr.min.x<=x && x<clipr.max.x){ m = m0 >> (x&(7/dst->depth))*bpp; d = byteaddr(dst, Pt(x, y)); sx = drawreplxy(src->r.min.x, src->r.max.x, x+dsrc.x); s = byteaddr(src, Pt(sx, sy)); *d ^= (*d^*s) & m; } if(++sy >= src->r.max.y) sy = src->r.min.y; } } static void horline(Memimage *dst, Point p0, Point p1, Memimage *src, Point dsrc, Rectangle clipr) { int x, y, deltay, deltax, minx, maxx; int bpp, m, m0; uchar *d, *s; deltax = p1.x - p0.x; deltay = p1.y - p0.y; minx = lmax(p0.x, clipr.min.x); maxx = lmin(p1.x, clipr.max.x-1); bpp = dst->depth; m0 = 0xFF^(0xFF>>bpp); m = m0 >> (minx&(7/dst->depth))*bpp; for(x=minx; x<=maxx; x++){ y = p0.y + (deltay*(x-p0.x)+deltay/2)/deltax; if(clipr.min.y<=y && y<clipr.max.y){ d = byteaddr(dst, Pt(x, y)); s = byteaddr(src, addpt(dsrc, Pt(x, y))); *d ^= (*d^*s) & m; } m >>= bpp; if(m == 0) m = m0; } } static void verline(Memimage *dst, Point p0, Point p1, Memimage *src, Point dsrc, Rectangle clipr) { int x, y, deltay, deltax, miny, maxy; int bpp, m, m0; uchar *d, *s; deltax = p1.x - p0.x; deltay = p1.y - p0.y; miny = lmax(p0.y, clipr.min.y); maxy = lmin(p1.y, clipr.max.y-1); bpp = dst->depth; m0 = 0xFF^(0xFF>>bpp); for(y=miny; y<=maxy; y++){ if(deltay == 0) /* degenerate line */ x = p0.x; else x = p0.x + deltax*(y-p0.y)/deltay; if(clipr.min.x<=x && x<clipr.max.x){ m = m0 >> (x&(7/dst->depth))*bpp; d = byteaddr(dst, Pt(x, y)); s = byteaddr(src, addpt(dsrc, Pt(x, y))); *d ^= (*d^*s) & m; } } } #endif /* NOTUSED */ static Memimage* membrush(int radius) { static Memimage *brush; static int brushradius; if(brush==nil || brushradius!=radius){ freememimage(brush); brush = allocmemimage(Rect(0, 0, 2*radius+1, 2*radius+1), memopaque->chan); if(brush != nil){ memfillcolor(brush, DTransparent); /* zeros */ memellipse(brush, Pt(radius, radius), radius, radius, -1, memopaque, Pt(radius, radius), S); } brushradius = radius; } return brush; } static void discend(Point p, int radius, Memimage *dst, Memimage *src, Point dsrc, int op) { Memimage *disc; Rectangle r; disc = membrush(radius); if(disc != nil){ r.min.x = p.x - radius; r.min.y = p.y - radius; r.max.x = p.x + radius+1; r.max.y = p.y + radius+1; memdraw(dst, r, src, addpt(r.min, dsrc), disc, Pt(0,0), op); } } static void arrowend(Point tip, Point *pp, int end, int sin, int cos, int radius) { int x1, x2, x3; /* before rotation */ if(end == Endarrow){ x1 = Arrow1; x2 = Arrow2; x3 = Arrow3; }else{ x1 = (end>>5) & 0x1FF; /* distance along line from end of line to tip */ x2 = (end>>14) & 0x1FF; /* distance along line from barb to tip */ x3 = (end>>23) & 0x1FF; /* distance perpendicular from edge of line to barb */ } /* comments follow track of right-facing arrowhead */ pp->x = tip.x+((2*radius+1)*sin/2-x1*cos); /* upper side of shaft */ pp->y = tip.y-((2*radius+1)*cos/2+x1*sin); pp++; pp->x = tip.x+((2*radius+2*x3+1)*sin/2-x2*cos); /* upper barb */ pp->y = tip.y-((2*radius+2*x3+1)*cos/2+x2*sin); pp++; pp->x = tip.x; pp->y = tip.y; pp++; pp->x = tip.x+(-(2*radius+2*x3+1)*sin/2-x2*cos); /* lower barb */ pp->y = tip.y-(-(2*radius+2*x3+1)*cos/2+x2*sin); pp++; pp->x = tip.x+(-(2*radius+1)*sin/2-x1*cos); /* lower side of shaft */ pp->y = tip.y+((2*radius+1)*cos/2-x1*sin); } void _memimageline(Memimage *dst, Point p0, Point p1, int end0, int end1, int radius, Memimage *src, Point sp, Rectangle clipr, int op) { /* * BUG: We should really really pick off purely horizontal and purely * vertical lines and handle them separately with calls to memimagedraw * on rectangles. */ int hor; int sin, cos, dx, dy, t; Rectangle oclipr, r; Point q, pts[10], *pp, d; if(radius < 0) return; if(rectclip(&clipr, dst->r) == 0) return; if(rectclip(&clipr, dst->clipr) == 0) return; d = subpt(sp, p0); if(rectclip(&clipr, rectsubpt(src->clipr, d)) == 0) return; if((src->flags&Frepl)==0 && rectclip(&clipr, rectsubpt(src->r, d))==0) return; /* this means that only verline() handles degenerate lines (p0==p1) */ hor = (abs(p1.x-p0.x) > abs(p1.y-p0.y)); /* * Clipping is a little peculiar. We can't use Sutherland-Cohen * clipping because lines are wide. But this is probably just fine: * we do all math with the original p0 and p1, but clip when deciding * what pixels to draw. This means the layer code can call this routine, * using clipr to define the region being written, and get the same set * of pixels regardless of the dicing. */ if((hor && p0.x>p1.x) || (!hor && p0.y>p1.y)){ q = p0; p0 = p1; p1 = q; t = end0; end0 = end1; end1 = t; } if((p0.x == p1.x || p0.y == p1.y) && (end0&0x1F) == Endsquare && (end1&0x1F) == Endsquare){ r.min = p0; r.max = p1; if(p0.x == p1.x){ r.min.x -= radius; r.max.x += radius+1; } else{ r.min.y -= radius; r.max.y += radius+1; } oclipr = dst->clipr; sp = addpt(r.min, d); dst->clipr = clipr; memimagedraw(dst, r, src, sp, memopaque, sp, op); dst->clipr = oclipr; return; } /* Hard: */ /* draw thick line using polygon fill */ icossin2(p1.x-p0.x, p1.y-p0.y, &cos, &sin); dx = (sin*(2*radius+1))/2; dy = (cos*(2*radius+1))/2; pp = pts; oclipr = dst->clipr; dst->clipr = clipr; q.x = ICOSSCALE*p0.x+ICOSSCALE/2-cos/2; q.y = ICOSSCALE*p0.y+ICOSSCALE/2-sin/2; switch(end0 & 0x1F){ case Enddisc: discend(p0, radius, dst, src, d, op); /* fall through */ case Endsquare: default: pp->x = q.x-dx; pp->y = q.y+dy; pp++; pp->x = q.x+dx; pp->y = q.y-dy; pp++; break; case Endarrow: arrowend(q, pp, end0, -sin, -cos, radius); _memfillpolysc(dst, pts, 5, ~0, src, addpt(pts[0], mulpt(d, ICOSSCALE)), 1, 10, 1, op); pp[1] = pp[4]; pp += 2; } q.x = ICOSSCALE*p1.x+ICOSSCALE/2+cos/2; q.y = ICOSSCALE*p1.y+ICOSSCALE/2+sin/2; switch(end1 & 0x1F){ case Enddisc: discend(p1, radius, dst, src, d, op); /* fall through */ case Endsquare: default: pp->x = q.x+dx; pp->y = q.y-dy; pp++; pp->x = q.x-dx; pp->y = q.y+dy; pp++; break; case Endarrow: arrowend(q, pp, end1, sin, cos, radius); _memfillpolysc(dst, pp, 5, ~0, src, addpt(pp[0], mulpt(d, ICOSSCALE)), 1, 10, 1, op); pp[1] = pp[4]; pp += 2; } _memfillpolysc(dst, pts, pp-pts, ~0, src, addpt(pts[0], mulpt(d, ICOSSCALE)), 0, 10, 1, op); dst->clipr = oclipr; return; } void memimageline(Memimage *dst, Point p0, Point p1, int end0, int end1, int radius, Memimage *src, Point sp, int op) { _memimageline(dst, p0, p1, end0, end1, radius, src, sp, dst->clipr, op); } /* * Simple-minded conservative code to compute bounding box of line. * Result is probably a little larger than it needs to be. */ static void addbbox(Rectangle *r, Point p) { if(r->min.x > p.x) r->min.x = p.x; if(r->min.y > p.y) r->min.y = p.y; if(r->max.x < p.x+1) r->max.x = p.x+1; if(r->max.y < p.y+1) r->max.y = p.y+1; } int memlineendsize(int end) { int x3; if((end&0x3F) != Endarrow) return 0; if(end == Endarrow) x3 = Arrow3; else x3 = (end>>23) & 0x1FF; return x3; } Rectangle memlinebbox(Point p0, Point p1, int end0, int end1, int radius) { Rectangle r, r1; int extra; r.min.x = 10000000; r.min.y = 10000000; r.max.x = -10000000; r.max.y = -10000000; extra = lmax(memlineendsize(end0), memlineendsize(end1)); r1 = insetrect(canonrect(Rpt(p0, p1)), -(radius+extra)); addbbox(&r, r1.min); addbbox(&r, r1.max); return r; }