Return to line.c CVS log

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

Annotation of researchv9/jerq/src/lib/j/line.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * _line - draw a line from x0 to x1
        !             3:  *     assumes already clipped, so no checking, just GO!
        !             4:  *     the line is closed w.r.t. the endpoints
        !             5:  */
        !             6: /*
        !             7:  * From ACM Nov 1973 V16, #11, I thought, but look in Newman & Sproull
        !             8:  */
        !             9: #define        LINE_C          /* This file "owns" the header file line.h */
        !            10: #define        LEFT    1024    /* line will be drawn right to left */
        !            11: #include <jerq.h>
        !            12: #include <line.h>
        !            13: _line(b, x0, x1, fun)
        !            14:        register Bitmap *b;
        !            15:        Point x0, x1;
        !            16:        Code fun;
        !            17: {
        !            18:        register d, yincr;
        !            19:        short deltax, deltay;
        !            20:        short /*unsigned*/ x, y;
        !            21:        register UWord bit;
        !            22:        register Word *screenp;
        !            23:        register long screenincr;
        !            24:        register d1;
        !            25:        int d2;
        !            26:        register count;
        !            27:        Point temp;
        !            28: 
        !            29:        if(Jxmajor==0){
        !            30:                if(x0.y>x1.y){
        !            31:                        temp=x0;
        !            32:                        x0=x1;
        !            33:                        x1=temp;
        !            34:                }
        !            35:                if(x0.x>x1.x)
        !            36:                        fun|=LEFT;
        !            37:        }
        !            38:        else if(x0.x>x1.x){
        !            39:                temp=x0;
        !            40:                x0=x1;
        !            41:                x1=temp;
        !            42:        }
        !            43:        x=x0.x;
        !            44:        y=x0.y;
        !            45:        deltax=x1.x-x;
        !            46:        deltay=x1.y-y;
        !            47:        yincr=(deltay>0)? 1 : -1;
        !            48:        screenp=addr(b,x0);
        !            49:        screenincr=yincr*(int)b->width; /* signed product please */
        !            50:        bit=LASTBIT<<(WORDSIZE-1-(x&WORDMASK)); /* don't sign extend */
        !            51:        deltax=abs(deltax);
        !            52:        deltay=abs(deltay);
        !            53:        if(Jxmajor==0)
        !            54:     goto Steepline;
        !            55:        count=deltax+1; /* so we can say --count (faster) */
        !            56:        if(deltay==0){                  /* easy and fast */
        !            57:                y=x+count;      /* sorry about overusing the variables */
        !            58:                if(x&WORDMASK){
        !            59:                        d=topbits[x&WORDMASK];
        !            60:                        switch(fun){
        !            61:                        case F_STORE:
        !            62:                        case F_OR:
        !            63:                                if((x&~WORDMASK)==(y&~WORDMASK)){  /* same word */
        !            64:                                        d^=topbits[y&WORDMASK];
        !            65:                                        *screenp|=d;
        !            66:                                        return;
        !            67:                                }
        !            68:                                *screenp++|=~d;
        !            69:                                x=(x|WORDMASK)+1;
        !            70:                                break;
        !            71:                        case F_CLR:
        !            72:                                if((x&~WORDMASK)==(y&~WORDMASK)){  /* same word */
        !            73:                                        d^=topbits[y&WORDMASK];
        !            74:                                        *screenp&=~d;
        !            75:                                        return;
        !            76:                                }
        !            77:                                *screenp++&=d;
        !            78:                                x=(x|WORDMASK)+1;
        !            79:                                break;
        !            80:                        case F_XOR:
        !            81:                                if((x&~WORDMASK)==(y&~WORDMASK)){  /* same word */
        !            82:                                        d^=topbits[y&WORDMASK];
        !            83:                                        *screenp^=d;
        !            84:                                        return;
        !            85:                                }
        !            86:                                *screenp++^=~d;
        !            87:                                x=(x|WORDMASK)+1;
        !            88:                                break;
        !            89:                        }
        !            90:                }
        !            91:                switch(fun){
        !            92:                case F_STORE:
        !            93:                case F_OR:
        !            94:                        while((x+=WORDSIZE)<=y)
        !            95:                                *screenp++=ONES;
        !            96:                        if(y&WORDMASK)
        !            97:                                *screenp|=topbits[y&WORDMASK];
        !            98:                        break;
        !            99:                case F_CLR:
        !           100:                        while((x+=WORDSIZE)<=y)
        !           101:                                *screenp++=0;
        !           102:                        if(y&WORDMASK)
        !           103:                                *screenp&=~topbits[y&WORDMASK];
        !           104:                        break;
        !           105:                case F_XOR:
        !           106:                        while((x+=WORDSIZE)<=y)
        !           107:                                *screenp++^=ONES;
        !           108:                        if(y&WORDMASK)
        !           109:                                *screenp^=topbits[y&WORDMASK];
        !           110:                        break;
        !           111:                }
        !           112:                return;
        !           113:        }
        !           114:        /* else */
        !           115:        d=Jsetdda(x);
        !           116:        d1=2*Jdminor;
        !           117:        d2=d1-2*Jdmajor;
        !           118:        switch(fun){
        !           119:        case F_STORE:
        !           120:        case F_OR:
        !           121:                for(;;){
        !           122:                        *screenp|=bit;
        !           123:                        if(--count==0)
        !           124:                                return;
        !           125:                        if((bit>>=1)==0){
        !           126:                                screenp++;
        !           127:                                bit=FIRSTBIT;
        !           128:                        }
        !           129:                        if(d<0)
        !           130:                                d+=d1;
        !           131:                        else{
        !           132:                                d+=d2;
        !           133:                                screenp+=screenincr;
        !           134:                        }
        !           135:                }
        !           136:        case F_CLR:
        !           137:                for(;;){
        !           138:                        *screenp&=~bit;
        !           139:                        if(--count==0)
        !           140:                                return;
        !           141:                        if((bit>>=1)==0){
        !           142:                                screenp++;
        !           143:                                bit=FIRSTBIT;
        !           144:                        }
        !           145:                        if(d<0)
        !           146:                                d+=d1;
        !           147:                        else{
        !           148:                                d+=d2;
        !           149:                                screenp+=screenincr;
        !           150:                        }
        !           151:                }
        !           152:        case F_XOR:
        !           153:                for(;;){
        !           154:                        *screenp^=bit;
        !           155:                        if(--count==0)
        !           156:                                return;
        !           157:                        if((bit>>=1)==0){
        !           158:                                screenp++;
        !           159:                                bit=FIRSTBIT;
        !           160:                        }
        !           161:                        if(d<0)
        !           162:                                d+=d1;
        !           163:                        else{
        !           164:                                d+=d2;
        !           165:                                screenp+=screenincr;
        !           166:                        }
        !           167:                }
        !           168:        }
        !           169:     Steepline:
        !           170:        count=deltay+1;
        !           171:        if(deltax==0){                  /* easy and fast */
        !           172:                switch(fun){
        !           173:                case F_STORE:
        !           174:                case F_OR:
        !           175:                        for(;;screenp+=screenincr){
        !           176:                                *screenp|=bit;
        !           177:                                if(--count==0)
        !           178:                                        return;
        !           179:                        }
        !           180:                case F_CLR:
        !           181:                        bit= ~bit;
        !           182:                        for(;;screenp+=screenincr){
        !           183:                                *screenp&=bit;
        !           184:                                if(--count==0)
        !           185:                                        return;
        !           186:                        }
        !           187:                case F_XOR:
        !           188:                        for(;;screenp+=screenincr){
        !           189:                                *screenp^=bit;
        !           190:                                if(--count==0)
        !           191:                                        return;
        !           192:                        }
        !           193:                }
        !           194:        }
        !           195:        /* else */
        !           196:        d=Jsetdda(y);
        !           197:        d1=2*Jdminor;
        !           198:        d2=d1-2*Jdmajor;
        !           199:        switch(fun){
        !           200:        case F_STORE:
        !           201:        case F_OR:
        !           202:                for(;;screenp+=screenincr){
        !           203:                        *screenp|=bit;
        !           204:                        if(--count==0)
        !           205:                                return;
        !           206:                        if(d<0)
        !           207:                                d+=d1;
        !           208:                        else{
        !           209:                                d+=d2;
        !           210:                                if((bit>>=1)==0){
        !           211:                                        screenp++;
        !           212:                                        bit=FIRSTBIT;
        !           213:                                }
        !           214:                        }
        !           215:                }
        !           216:        case F_STORE|LEFT:
        !           217:        case F_OR|LEFT:
        !           218:                for(;;screenp+=screenincr){
        !           219:                        *screenp|=bit;
        !           220:                        if(--count==0)
        !           221:                                return;
        !           222:                        if(d<0)
        !           223:                                d+=d1;
        !           224:                        else{
        !           225:                                d+=d2;
        !           226:                                if((bit<<=1)==0){
        !           227:                                        screenp--;
        !           228:                                        bit=LASTBIT;
        !           229:                                }
        !           230:                        }
        !           231:                }
        !           232:        case F_CLR:
        !           233:                for(;;screenp+=screenincr){
        !           234:                        *screenp&=~bit;
        !           235:                        if(--count==0)
        !           236:                                return;
        !           237:                        if(d<0)
        !           238:                                d+=d1;
        !           239:                        else{
        !           240:                                d+=d2;
        !           241:                                if((bit>>=1)==0){
        !           242:                                        screenp++;
        !           243:                                        bit=FIRSTBIT;
        !           244:                                }
        !           245:                        }
        !           246:                }
        !           247:        case F_CLR|LEFT:
        !           248:                for(;;screenp+=screenincr){
        !           249:                        *screenp&=~bit;
        !           250:                        if(--count==0)
        !           251:                                return;
        !           252:                        if(d<0)
        !           253:                                d+=d1;
        !           254:                        else{
        !           255:                                d+=d2;
        !           256:                                if((bit<<=1)==0){
        !           257:                                        screenp--;
        !           258:                                        bit=LASTBIT;
        !           259:                                }
        !           260:                        }
        !           261:                }
        !           262:        case F_XOR:
        !           263:                for(;;screenp+=screenincr){
        !           264:                        *screenp^=bit;
        !           265:                        if(--count==0)
        !           266:                                return;
        !           267:                        if(d<0)
        !           268:                                d+=d1;
        !           269:                        else{
        !           270:                                d+=d2;
        !           271:                                if((bit>>=1)==0){
        !           272:                                        screenp++;
        !           273:                                        bit=FIRSTBIT;
        !           274:                                }
        !           275:                        }
        !           276:                }
        !           277:        case F_XOR|LEFT:
        !           278:                for(;;screenp+=screenincr){
        !           279:                        *screenp^=bit;
        !           280:                        if(--count==0)
        !           281:                                return;
        !           282:                        if(d<0)
        !           283:                                d+=d1;
        !           284:                        else{
        !           285:                                d+=d2;
        !           286:                                if((bit<<=1)==0){
        !           287:                                        screenp--;
        !           288:                                        bit=LASTBIT;
        !           289:                                }
        !           290:                        }
        !           291:                }
        !           292:        }
        !           293: }

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