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     ! 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.