Return to hide.c CVS log

Up to [Research Unix] / researchv10no / cmd / view2d

Annotation of researchv10no/cmd/view2d/hide.c, revision 1.1.1.1

1.1       root        1: #include       <jerq.h>
                      2: 
                      3: #define                ONE             512
                      4: 
                      5: Point buf1[128], buf2[128], *old = buf2, *new = buf1;
                      6: 
                      7: jdraw(b)
                      8:        Bitmap *b;
                      9: {
                     10: }
                     11: #ifdef AGH
                     12: /*
                     13:        for(j = nx+ny-3; j > 0; j--)
                     14:        {
                     15:                y = min(ny-1, j);
                     16:                lasty = x = j-y;
                     17:                while(y != lasty)
                     18:                {
                     19:                        POLY(x, y, x, y-1, x+1, y-1, x+1, y);
                     20:                        x++;
                     21:                        y--;
                     22:                }
                     23:                wait(CPU);
                     24:        }
                     25: */
                     26:        Point left, right, p, *np, *op;
                     27:        int wleft;
                     28: 
                     29:        old[0].y = -1;
                     30:        np = new;
                     31:        op = old;
                     32:        nextpt(np++);
                     33:        nextpt(np++);
                     34:        left = np[-1];
                     35:        segment(b, new[0], new[1], F_OR);
                     36: 
                     37:        while(nextpt(&right))
                     38:        {
                     39:                if(left.x > right.x)
                     40:                {
                     41:                        left = right;
                     42:                        np->y = -1;
                     43:                        np = old; old = new; new = np; op = old;
                     44:                        continue;
                     45:                }
                     46:                if(left.x < op->x)
                     47:                {
                     48:                        *np++ = left;
                     49:                        *np++ = right;
                     50:                        segment(b, left, right, F_OR);
                     51:                }
                     52:                else if(left.x > op->x)
                     53:                        *np++ = *op++;
                     54:                else
                     55:                {
                     56:                        
                     57:                }
                     58:                left = right;
                     59:        }
                     60: }
                     61: 
                     62: addseg(b, l, ls, r, rs)
                     63:        Bitmap *b;
                     64:        Point l, r;
                     65:        register Segment *ls, *rs;
                     66: {
                     67:        register Segment *s;
                     68: 
                     69:        if(l.x != ls->l.x)
                     70:        {
                     71:                s = newseg(l, ls->r);
                     72:                ls->r = l;
                     73:                s->next = ls->next;
                     74:                ls->next = s;
                     75:                if(ls == rs) rs = s;
                     76:        }
                     77:        else
                     78:                ls->l.y = l.y;
                     79:        recalc(ls);
                     80:        if(r.x != rs->r.x)
                     81:        {
                     82:                s = newseg(r, rs->r);
                     83:                rs->r = r;
                     84:                s->next = rs->next;
                     85:                rs->next = s;
                     86:        }
                     87:        else
                     88:                rs->r.y = r.y;
                     89:        recalc(rs);
                     90:        segment(b, l, r, F_OR);
                     91: }
                     92: 
                     93: static Segment *
                     94: newseg(l, r)
                     95:        Point l, r;
                     96: {
                     97:        register Segment *s;
                     98: 
                     99:        s = (Segment *)alloc(sizeof *s);
                    100:        s->next = 0;
                    101:        s->l = l;
                    102:        s->r = r;
                    103:        recalc(s);
                    104:        return(s);
                    105: }
                    106: 
                    107: recalc(s)
                    108:        register Segment *s;
                    109: {
                    110:        s->m = muldiv(s->r.y-s->l.y, ONE, s->r.x-s->l.x);
                    111:        s->b = s->l.y - muldiv(s->m, s->l.x, ONE);
                    112: }
                    113: 
                    114: crosses(s, l, r, p)
                    115:        Segment *s;
                    116:        Point l, r, *p;
                    117: {
                    118:        register m, b;
                    119: 
                    120:        m = muldiv(r.y-l.y, ONE, r.x-l.x);
                    121:        if(m == s->m) return(0);
                    122:        b = l.y - s->m*l.x;
                    123:        p->x = muldiv(s->b-b, ONE, m-s->m);
                    124:        p->y = m*p->x + b;
                    125:        return((p->x >= s->l.x) && (p->x <= s->r.x) && (p->x >= l.x) && (p->x <= r.x));
                    126: }
                    127: 
                    128: ptrels(p, s)
                    129:        Point p;
                    130:        Segment *s;
                    131: {
                    132:        register Segment *s;
                    133: 
                    134:        if((s->l.y < 0) || (s->r.y < 0)) return(1);
                    135:        return((muldiv(s->m, p.x, ONE)+s->b) - p.y);
                    136: }
                    137: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.