Return to op CVS log

Up to [Research Unix] / researchv9 / jerq / src / lib / jj

Annotation of researchv9/jerq/src/lib/jj/op, revision 1.1.1.1

1.1       root        1: #include       <jerq.h>
                      2: 
                      3: static emax(a,b) { return((a<b)? b:a); }
                      4: static emin(a,b) { return((a>b)? b:a); }
                      5: static ycmp(), xcmp(), xcut();
                      6: 
                      7: typedef struct Edge
                      8: {
                      9:        Point p1, p2;
                     10:        short dolow;
                     11: } Edge;
                     12: static Edge edges[300];
                     13: static Edge *canon();
                     14: 
                     15: polyture(bp, pts, n, t, mode)
                     16:        Bitmap *bp;
                     17:        Point *pts;
                     18:        Texture *t;
                     19: {
                     20:        register Edge *eend, *e, *estart;
                     21:        register y;
                     22:        int ymin, ymax, flag;
                     23:        Point p;
                     24:        int xcuts[64], *xp, *x;
                     25: 
                     26:        eend = canon(pts, n, &ymax);
                     27:        qsort(edges, eend-edges, sizeof(edges[0]), ycmp);
                     28:        ymin = edges->p1.y;
                     29:        eend->p1.y = eend->p2.y = ymax+1;
                     30:        /*
                     31:                traditional scanline
                     32:        */
                     33:        for(estart = eend = edges, y = ymin; y <= ymax; y++)
                     34:        {
                     35:                while(estart->p2.y < y) estart++;
                     36:                while(eend->p1.y <= y) eend++;
                     37:                for(e = estart, xp = xcuts; e < eend; e++)
                     38:                        if((y < e->p2.y) || (e->dolow && (y == e->p2.y)))
                     39:                                *xp++ = xcut(y, e);
                     40:                qsort(xcuts, xp-xcuts, sizeof(*xp), xcmp);
                     41:                for(x = xcuts; x < xp; x += 2)
                     42:                        texture(bp, Rect(*x, y, x[1]+1, y+1), t, mode);
                     43:        }
                     44: }
                     45: 
                     46: static Edge *
                     47: canon(pts, n, ymax)
                     48:        register Point *pts;
                     49:        register *ymax;
                     50: {
                     51:        register Edge *le, *e;
                     52:        register Point *p, *lp, pt;
                     53:        int vert;
                     54: 
                     55:        /*
                     56:                delete horizontal edges; compact vertical edges into one
                     57:        */
                     58:        p = pts;
                     59:        lp = p+n;
                     60:        e = edges;
                     61:        *ymax = p->y;
                     62:        e->p1 = *p++;
                     63:        for(vert = 0; p < lp; p++)
                     64:        {
                     65:                if(*ymax < p->y) *ymax = p->y;
                     66:                if(p->y == p[-1].y)
                     67:                {
                     68:                        vert = 0;
                     69:                        e->p1 = *p;
                     70:                        continue;
                     71:                }
                     72:                if(vert && (p->x == p[-1].x))
                     73:                        e->p2.y = p->y;
                     74:                else
                     75:                {
                     76:                        if(vert)
                     77:                                e[1].p1 = e->p2, e++;
                     78:                        e++->p2 = *p;
                     79:                        e->p1 = *p;
                     80:                        if(vert = p->x == p[-1].x) e--;
                     81:                }
                     82:        }
                     83:        if(vert) e++;
                     84:        le = e;
                     85:        *le = edges[0];
                     86:        le[1] = edges[1];
                     87:        for(e = edges+1; e <= le; e++)
                     88:        {
                     89:                if(e->p1.y < e->p2.y)   /* going down */
                     90:                        e->dolow = (e[1].p1.y-e[1].p2.y) > 0;
                     91:                else
                     92:                        e->dolow = (e[-1].p1.y-e[-1].p2.y) < 0;
                     93:        }
                     94:        edges[0] = *le;
                     95:        /*
                     96:                canonise the edges so that p1.y < p2.y
                     97:                or if p1.y == p2.y then p1.x < p2.x.
                     98:        */
                     99:        for(e = edges; e < le; e++)
                    100:        {
                    101:                if((e->p1.y > e->p2.y) || ((e->p1.y == e->p2.y)&&(e->p1.x > e->p2.x)))
                    102:                        pt = e->p1, e->p1 = e->p2, e->p2 = pt;
                    103:        }
                    104:        return(le);
                    105: }
                    106: 
                    107: static
                    108: ycmp(a, b)
                    109:        register Edge *a, *b;
                    110: {
                    111:        register k;
                    112: 
                    113:        if(k = a->p1.y - b->p1.y)
                    114:                return(k);
                    115:        return(a->p2.y - b->p2.y);
                    116: }
                    117: 
                    118: static
                    119: xcmp(a, b)
                    120:        register int *a, *b;
                    121: {
                    122:        return(*a - *b);
                    123: }
                    124: 
                    125: static
                    126: xcut(y, e)
                    127:        register Edge *e;
                    128: {
                    129:        return(e->p1.x + muldiv(e->p2.x-e->p1.x, y-e->p1.y, e->p2.y-e->p1.y));
                    130: }
                    131: 

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