![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gsegment.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / libgnot|
Return to gsegment.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / libgnot |
1.1 root 1: #include <u.h>
2: #include <libg.h>
3: #include <gnot.h>
4:
5: #define PSHIFT(x, y) {if(LENDIAN) x <<= y; else x >>= y;}
6:
7: int
8: _setdda(int x, int y, Linedesc *l)
9: {
10: int e;
11:
12: /*
13: * Unfold all the symmetry folded out in gsetline()
14: */
15: if(l->slopeneg == 0)
16: e = ((2*(x-l->x0)+2)*l->dminor
17: -(2*(y-l->y0)+1)*l->dmajor);
18: else{
19: if(l->xmajor)
20: e = ((2*(x-l->x0)+2)*l->dminor
21: +(2*(l->y0+y)-1)*l->dmajor);
22: else
23: e = ((2*(l->x0-x)+2)*l->dminor
24: -(2*(l->y0+y)+1)*l->dmajor)-1;
25: }
26: return e;
27: }
28:
29: /*
30: * Strange, usually fast line code.
31: * Based on the observation that given src and f, src is constant
32: * for the call, so we can reduce f by that symmetry. Then we can
33: * reduce it again by choosing the src we actually run with; thus
34: * src, f -> src', f'
35: * In the code, src is replicated through the register m.
36: * The f's we choose (they are somewhat arbitrary) are
37: * f(0) = S & D
38: * and
39: * f(1) = S | ~D,
40: * chosen by the bits of the incoming f. In particular, if
41: * src == 0
42: * we select
43: * f' = f&1, src' = (f&2) >> 1
44: * else
45: * f' = (f>>2)&1, src' = ((f>>2)&2) >> 1
46: * If src is all 1's or all 0's (guaranteed true on a 1-bit display),
47: * this is all we need; otherwise (the slower case) we insert into the dest
48: * twice: once for the 1 bits in src, once for the 0 bits, using f' and src'
49: * each computed as above.
50: */
51:
52: void
53: gsegment(GBitmap *b, Point p, Point q, int src, Fcode f)
54: {
55: int i, dw, dx, dy;
56: int e, e1, e2;
57: uchar m, m1, k, k0, k1, f0, f1, lom, him, him0, him1, t, *dest;
58: int ld, bpp, xshift;
59: int m0, lo, lo0, lo1, kk, kk0, kk1;
60: Linedesc l;
61:
62: if(!_clipline(b->clipr, &p, &q, &l))
63: return;
64: /* line is now clipped and closed */
65: dx = q.x - p.x;
66: dy = q.y - p.y;
67: if(dx < 0) /* can't happen, but breaks code if it does */
68: return;
69:
70: ld = b->ldepth;
71: bpp = 8>>(3-ld);
72: lom = ((1<<bpp)-1);
73: him = lom<<(8-bpp);
74: xshift = (p.x&(7>>ld))<<ld;
75: if(LENDIAN)
76: xshift = 8-bpp - xshift;
77: k = him>>xshift; /* mask */
78: lo = src&lom;
79:
80: if(lo==lom || lo==0){
81: /*
82: * set new f, new src
83: */
84: if(lo)
85: f >>= 2;
86: f &= 3;
87: if(f & 2)
88: lo = lom;
89: else
90: lo = 0;
91: f &= 1;
92: /*
93: * develop m as a register full of pixels containing 'lo1'
94: */
95: m = lo;
96: for(i=1<<ld; i<8; i+=i)
97: m |= m<<i;
98: }else{
99: /*
100: * set *1 for 1 bits; *0 for 0 bits
101: */
102: f1 = (f>>2)&3;
103: if(f1 & 2)
104: lo1 = lom & lo;
105: else
106: lo1 = 0;
107: f1 &= 1;
108: him1 = (lom&lo)<<(8-bpp);
109: k1 = him1>>xshift; /* mask */
110: f0 = f&3;
111: if(f0 & 2)
112: lo0 = lom & ~lo;
113: else
114: lo0 = 0;
115: f0 &= 1;
116: him0 = (lom&~lo)<<(8-bpp);
117: k0 = him0>>xshift; /* mask */
118: /*
119: * develop m0, m1 as a register full of pixels containing 'lo1'
120: */
121: m0 = lo0;
122: m1 = lo1;
123: for(i=1<<ld; i<8; i+=i){
124: m0 |= m0<<i;
125: m1 |= m1<<i;
126: }
127: f = 2;
128: }
129:
130: if(LENDIAN){
131: him >>= 8-bpp;
132: him0 >>= 8-bpp;
133: him1 >>= 8-bpp;
134: }
135:
136: dw = b->width*sizeof(ulong);
137: if(dy < 0){
138: dw = -dw;
139: dy = -dy;
140: }
141: dest = (uchar*)gaddr(b, p) + ((p.x&(31>>ld))>>(3-ld));
142: e1 = 2*l.dminor;
143: e2 = e1 - 2*l.dmajor;
144: if(l.xmajor == 0)
145: goto majory;
146:
147: majorx:
148: e = _setdda(p.x, p.y, &l);
149: switch(f){
150: case 0:
151: kk = 0;
152: for(i=dx; i>=0; i--){
153: kk |= k;
154: PSHIFT(k, bpp);
155: if(e >= 0){
156: *dest &= m|~kk;
157: dest += dw;
158: e += e2;
159: kk = 0;
160: if(k == 0){
161: k = him;
162: dest++;
163: }
164: continue;
165: }
166: e += e1;
167: if(k == 0){
168: k = him;
169: *dest &= m|~kk;
170: dest++;
171: kk = 0;
172: }
173: }
174: if(kk)
175: *dest &= m|~kk;
176: return;
177:
178: case 1:
179: kk = 0;
180: for(i=dx; i>=0; i--){
181: kk |= k;
182: PSHIFT(k, bpp);
183: if(e >= 0){
184: t = *dest;
185: *dest = (kk ^ t) | (t & m);
186: dest += dw;
187: e += e2;
188: kk = 0;
189: if(k == 0){
190: k = him;
191: dest++;
192: }
193: continue;
194: }
195: e += e1;
196: if(k == 0){
197: t = *dest;
198: *dest = (kk ^ t) | (t & m);
199: dest++;
200: k = him;
201: kk = 0;
202: }
203: }
204: if(kk){
205: t = *dest;
206: *dest = (kk ^ t) | (t & m);
207: }
208: return;
209:
210: case 2:
211: kk = 0;
212: kk0 = 0;
213: kk1 = 0;
214: for(i=dx; i>=0; i--){
215: kk |= k;
216: kk0 |= k0;
217: kk1 |= k1;
218: PSHIFT(k, bpp);
219: PSHIFT(k0, bpp);
220: PSHIFT(k1, bpp);
221: if(e >= 0){
222: t = *dest;
223: if(f0 == 0)
224: t &= m0|~kk0;
225: else
226: t = (kk0 ^ t) | (t & m0);
227: if(f1 == 0)
228: *dest = t & (m1|~kk1);
229: else
230: *dest = (kk1 ^ t) | (t & m1);
231: dest += dw;
232: e += e2;
233: kk = 0;
234: kk0 = 0;
235: kk1 = 0;
236: if(k == 0){
237: k = him;
238: k0 = him0;
239: k1 = him1;
240: dest++;
241: }
242: continue;
243: }
244: e += e1;
245: if(k == 0){
246: t = *dest;
247: if(f0 == 0)
248: t &= m0|~kk0;
249: else
250: t = (kk0 ^ t) | (t & m0);
251: if(f1 == 0)
252: *dest = t & (m1|~kk1);
253: else
254: *dest = (kk1 ^ t) | (t & m1);
255: dest++;
256: k = him;
257: k0 = him0;
258: k1 = him1;
259: kk = 0;
260: kk0 = 0;
261: kk1 = 0;
262: }
263: }
264: if(kk){
265: t = *dest;
266: if(f0 == 0)
267: t &= m0|~kk0;
268: else
269: t = (kk0 ^ t) | (t & m0);
270: if(f1 == 0)
271: *dest = t & (m1|~kk1);
272: else
273: *dest = (kk1 ^ t) | (t & m1);
274: }
275: return;
276: }
277: return;
278:
279: majory:
280: e = _setdda(p.y, p.x, &l);
281: switch (f){
282: case 0:
283: for(i=dy; i>=0; --i){
284: *dest &= m|~k;
285: dest += dw;
286: if(e >= 0){
287: PSHIFT(k, bpp);
288: if(k == 0){
289: dest++;
290: k = him;
291: }
292: e += e2;
293: }else
294: e += e1;
295: }
296: return;
297:
298: case 1:
299: for(i=dy; i>=0; --i){
300: t = *dest;
301: *dest = (k ^ t) | (t & m);
302: dest += dw;
303: if(e >= 0){
304: PSHIFT(k, bpp);
305: if(k == 0){
306: dest++;
307: k = him;
308: }
309: e += e2;
310: }else
311: e += e1;
312: }
313: return;
314:
315: case 2:
316: for(i=dy; i>=0; --i){
317: t = *dest;
318: if(f0 == 0)
319: t &= m0|~k0;
320: else
321: t = (k0 ^ t) | (t & m0);
322: if(f1 == 0)
323: *dest = t & (m1|~k1);
324: else
325: *dest = (k1 ^ t) | (t & m1);
326: dest += dw;
327: if(e >= 0){
328: PSHIFT(k, bpp);
329: PSHIFT(k0, bpp);
330: PSHIFT(k1, bpp);
331: if(k == 0){
332: dest++;
333: k = him;
334: k0 = him0;
335: k1 = him1;
336: }
337: e += e2;
338: }else
339: e += e1;
340: }
341: }
342: return;
343: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.