![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to line.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / src / lib / j|
Return to line.c CVS log | Up to [Research Unix] / researchv9 / jerq / src / lib / j |
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.