Return to image.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / demo / asteroids

Annotation of researchv9/jtools/src/demo/asteroids/image.c, revision 1.1.1.1

1.1       root        1: #include <jerq.h>
                      2: /*
                      3:  * Images are encoded as arrays of characters, and interpreted into
                      4:  * bitmaps by buildimage().  The coordinate system has (0,0) at the
                      5:  * "location" of the object.
                      6:  *
                      7:  * Operators are:
                      8:  *     'R'     minimum enclosing rectangle  (must be first!)
                      9:  *     'p'     point
                     10:  *     'r'     rectf
                     11:  *     's'     segment
                     12:  *     'm'     moveto
                     13:  *     'l'     lineto
                     14:  *     0       end
                     15:  *
                     16:  * All objects are drawn with F_OR.
                     17:  */
                     18: Point
                     19: pscale(p)
                     20:        Point p;
                     21: {
                     22: #define        o       Drect.origin
                     23: #define        c       Drect.corner
                     24:        p.x=muldiv(c.x-o.x, p.x, Drect.corner.x);
                     25:        p.y=muldiv(c.y-o.y, p.y, Drect.corner.y);
                     26: #undef c
                     27: #undef o
                     28:        return p;
                     29: }
                     30: Rectangle
                     31: rscale(r)
                     32:        Rectangle r;
                     33: {
                     34:        r.origin=pscale(r.origin);
                     35:        r.corner=pscale(r.corner);
                     36:        return r;
                     37: }
                     38: /*
                     39:  * Reduce *p to be on the screen
                     40:  */
                     41: onscreen(p)
                     42:        register Point *p;
                     43: {
                     44:        p->x%=Drect.corner.x;
                     45:        p->y%=Drect.corner.y;
                     46:        if(p->x < 0)
                     47:                p->x+=Drect.corner.x;
                     48:        if(p->y < 0)
                     49:                p->y+=Drect.corner.y;
                     50: }
                     51: Bitmap *
                     52: buildimage(s)
                     53:        register char *s;
                     54: {
                     55:        register Bitmap *b=0;
                     56:        Rectangle r;
                     57:        Point p, curpt;
                     58:        if(sext(*s++) != 'R')
                     59:                quit();
                     60:        r.origin.x= sext(*s++);
                     61:        r.origin.y= sext(*s++);
                     62:        r.corner.x= sext(*s++);
                     63:        r.corner.y= sext(*s++);
                     64:        b=balloc(rscale(r));
                     65:        if(b==0)
                     66:                quit();
                     67:        rectf(b, b->rect, F_CLR);
                     68:        for(;;){
                     69:                switch(sext(*s++)){
                     70:                case 'p':
                     71:                        p.x= sext(*s++);
                     72:                        p.y= sext(*s++);
                     73:                        point(b, pscale(p), F_OR);/**/
                     74:                        break;
                     75:                case 'r':
                     76:                        r.origin.x= sext(*s++);
                     77:                        r.origin.y= sext(*s++);
                     78:                        r.corner.x= sext(*s++);
                     79:                        r.corner.y= sext(*s++);
                     80:                        rectf(b, rscale(r), F_OR);/**/
                     81:                        break;
                     82:                case 's':
                     83:                        r.origin.x= sext(*s++);
                     84:                        r.origin.y= sext(*s++);
                     85:                        r.corner.x= sext(*s++);
                     86:                        r.corner.y= sext(*s++);
                     87:                        r=rscale(r);
                     88:                        segment(b, r.origin, r.corner, F_OR);/**/
                     89:                        break;
                     90:                case 'm':
                     91:                        p.x= sext(*s++);
                     92:                        p.y= sext(*s++);
                     93:                        curpt=pscale(p);/**/
                     94:                        break;
                     95:                case 'l':
                     96:                        p.x= sext(*s++);
                     97:                        p.y= sext(*s++);
                     98:                        p=pscale(p);
                     99:                        segment(b, curpt, p, F_OR);/**/
                    100:                        curpt=p;
                    101:                        break;
                    102:                case 0:
                    103:                        return b;
                    104:                }
                    105:        }
                    106: }
                    107: 
                    108: sext(c)
                    109:        register c;
                    110: {
                    111:        if(c&0x80) c |= 0xFFFFFF00;
                    112:        return(c);
                    113: }

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