123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486 |
- #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;
- }
|