![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gfxlib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to gfxlib.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * graphics.library emulation
5: *
6: * Copyright 1996 Bernd Schmidt
7: */
8:
9: #include "sysconfig.h"
10: #include "sysdeps.h"
11:
12: #include <assert.h>
13:
14: #include "config.h"
15: #include "options.h"
16: #include "memory.h"
17: #include "custom.h"
18: #include "newcpu.h"
19: #include "xwin.h"
20: #include "autoconf.h"
21: #include "osemu.h"
22:
23: /* Global variables etc. */
24: static ULONG gfxlibname;
25:
26: static int GFX_PointInRectangle(CPTR rect, int x, int y)
27: {
28: WORD minx = get_word(rect);
29: WORD miny = get_word(rect+2);
30: WORD maxx = get_word(rect+4);
31: WORD maxy = get_word(rect+6);
32:
33: if (x < minx || x > maxx || y < miny || y > maxy)
34: return 0;
35: return 1;
36: }
37:
38: static int GFX_Bitmap_WritePixel(CPTR bitmap, int x, int y, CPTR rp)
39: {
40: int i, offs;
41: unsigned int bpr = get_word (bitmap);
42: unsigned int rows = get_word (bitmap + 2);
43: UWORD mask;
44:
45: UBYTE planemask = get_byte(rp + 24);
46: UBYTE fgpen = get_byte(rp + 25);
47: UBYTE bgpen = get_byte(rp + 26);
48: UBYTE drmd = get_byte(rp + 28);
49: UBYTE pen = drmd & 4 ? bgpen : fgpen;
50:
51: if (x < 0 || y < 0 || x >= 8*bpr || y >= rows)
52: return -1;
53:
54: offs = y*bpr + (x & ~15)/8;
55:
56: for (i = 0; i < get_byte (bitmap + 5); i++) {
57: CPTR planeptr;
58: UWORD data;
59:
60: if ((planemask & (1 << i)) == 0)
61: continue;
62:
63: planeptr = get_long(bitmap + 8 + i*4);
64: data = get_word(planeptr + offs);
65:
66: mask = 0x8000 >> (x & 15);
67:
68: if (drmd & 2) {
69: if ((pen & (1 << i)) != 0)
70: data ^=mask;
71: } else {
72: data &= ~mask;
73: if ((pen & (1 << i)) != 0)
74: data |= mask;
75: }
76: put_word(planeptr + offs, data);
77: }
78: return 0;
79: }
80:
81: int GFX_WritePixel(CPTR rp, int x, int y)
82: {
83: CPTR layer = get_long(rp);
84: CPTR bitmap = get_long(rp + 4);
85: CPTR cliprect;
86: int x2, y2;
87:
88: if (bitmap == 0) {
89: fprintf(stderr, "bogus RastPort in WritePixel\n");
90: return -1;
91: }
92:
93: /* Easy case first */
94: if (layer == 0) {
95: return GFX_Bitmap_WritePixel(bitmap, x, y, rp);
96: }
97:
98: /*
99: * Now, in theory we ought to obtain the semaphore.
100: * Since we don't, the programs will happily write into the raster
101: * even though we are currently moving the window around.
102: * Not good.
103: */
104:
105: x2 = x + (WORD)get_word(layer + 16);
106: y2 = y + (WORD)get_word(layer + 18);
107:
108: if (!GFX_PointInRectangle (layer + 16, x2, y2))
109: return -1;
110: /* Find the right ClipRect */
111: cliprect = get_long(layer + 8);
112: while (cliprect != 0 && !GFX_PointInRectangle (cliprect + 16, x2, y2))
113: cliprect = get_long(cliprect);
114: if (cliprect == 0) {
115: /* Don't complain: The "Dots" demo does this all the time. I
116: * suppose if we can't find a ClipRect, we aren't supposed to draw
117: * the dot.
118: */
119: /*fprintf(stderr, "Weirdness in WritePixel\n");*/
120: return -1;
121: }
122: if (get_long(cliprect + 8) == 0)
123: return GFX_Bitmap_WritePixel(bitmap, x2, y2, rp);
124:
125: /* Now come the cases where I don't really know what to do... */
126: if (get_long(cliprect + 12) == 0)
127: return 0;
128:
129: return GFX_Bitmap_WritePixel (get_long(cliprect + 12), x2 - (WORD)get_word(cliprect + 16),
130: y2 - (WORD)get_word(cliprect + 18), rp);
131: }
132:
133:
134: static ULONG gfxl_WritePixel(void) { return GFX_WritePixel(regs.a[1], (WORD)regs.d[0], (WORD)regs.d[1]); }
135:
136: static ULONG gfxl_BltClear(void)
137: {
138: CPTR mem=regs.a[1];
139: UBYTE *mptr = chipmem_bank.xlateaddr(regs.a[1]);
140: ULONG count=regs.d[0];
141: ULONG flags=regs.d[1];
142: unsigned int i;
143: ULONG pattern;
144:
145: if ((flags & 2) == 2){
146: /* count is given in Rows / Bytes per row */
147: count=(count & 0xFFFF) * (count >> 16);
148: }
149:
150: if ((mem & 1) != 0 || (count & 1) != 0)
151: fprintf(stderr, "gfx: BltClear called with odd parameters\n");
152:
153: /* Bit 2 set means use pattern (V36+ only, but we might as well emulate
154: * it always) */
155: if ((flags & 4) == 0)
156: pattern = 0;
157: else
158: pattern= ((flags >> 16) & 0xFFFF) | (flags & 0xFFFF0000);
159:
160: if ((pattern & 0xFF) == ((pattern >> 8) & 0xFF)) {
161: memset(mptr, pattern, count);
162: return 0;
163: }
164:
165: for(i = 0; i < count; i += 4)
166: chipmem_bank.lput(mem+i, pattern);
167:
168: if ((count & 3) != 0)
169: chipmem_bank.wput(mem + i - 4, pattern);
170:
171: return 0;
172: }
173:
174: static ULONG gfxl_BltBitmap(void)
175: {
176: CPTR srcbitmap = regs.a[0], dstbitmap = regs.a[1];
177: int srcx = (WORD)regs.d[0], srcy = (WORD)regs.d[1];
178: int dstx = (WORD)regs.d[2], dsty = (WORD)regs.d[3];
179: int sizex = (WORD)regs.d[4], sizey = (WORD)regs.d[5];
180: UBYTE minterm = (UBYTE)regs.d[6], mask = regs.d[7];
181:
182: }
183:
184: static CPTR amiga_malloc(int len)
185: {
186: regs.d[0] = len;
187: regs.d[1] = 1; /* MEMF_PUBLIC */
188: return CallLib(get_long(4), -198); /* AllocMem */
189: }
190:
191: static void amiga_free(CPTR addr, int len)
192: {
193: regs.a[1] = addr;
194: regs.d[0] = len;
195: CallLib(get_long(4), -210); /* FreeMem */
196: }
197:
198: /*
199: * Region handling code
200: *
201: * The Clear code is untested. And and Or seem to work, Xor is only used
202: * by the 1.3 Prefs program and seems to work, too.
203: */
204:
205: struct Rectangle {
206: WORD MinX, MinY, MaxX, MaxY;
207: };
208:
209: struct RegionRectangle {
210: struct RegionRectangle *Next,*Prev;
211: struct Rectangle bounds;
212: };
213:
214: struct Region {
215: struct Rectangle bounds;
216: struct RegionRectangle *RegionRectangle;
217: };
218:
219: struct RectList {
220: int count;
221: int space;
222: struct Rectangle bounds;
223: struct Rectangle *rects;
224: };
225:
226: struct BandList {
227: int count;
228: int space;
229: int *miny, *maxy;
230: };
231:
232: static void init_bandlist(struct BandList *bl)
233: {
234: bl->count = 0;
235: bl->space = 20;
236: bl->miny = (int *)malloc(20*sizeof(int));
237: bl->maxy = (int *)malloc(20*sizeof(int));
238: }
239:
240: static __inline__ void add_band(struct BandList *bl, int miny, int maxy, int pos)
241: {
242: if (bl->count == bl->space) {
243: bl->space += 20;
244: bl->miny = (int *)realloc(bl->miny, bl->space*sizeof(int));
245: bl->maxy = (int *)realloc(bl->maxy, bl->space*sizeof(int));
246: }
247: memmove(bl->miny + pos + 1, bl->miny + pos, (bl->count - pos) * sizeof(int));
248: memmove(bl->maxy + pos + 1, bl->maxy + pos, (bl->count - pos) * sizeof(int));
249: bl->count++;
250: bl->miny[pos] = miny;
251: bl->maxy[pos] = maxy;
252: }
253:
254: static void init_rectlist(struct RectList *rl)
255: {
256: rl->count = 0;
257: rl->space = 100;
258: rl->bounds.MinX = rl->bounds.MinY = rl->bounds.MaxX = rl->bounds.MaxY = 0;
259: rl->rects = (struct Rectangle *)malloc(100*sizeof(struct Rectangle));
260: }
261:
262: static __inline__ void add_rect(struct RectList *rl, struct Rectangle r)
263: {
264: if (rl->count == 0)
265: rl->bounds = r;
266: else {
267: if (r.MinX < rl->bounds.MinX)
268: rl->bounds.MinX = r.MinX;
269: if (r.MinY < rl->bounds.MinY)
270: rl->bounds.MinY = r.MinY;
271: if (r.MaxX > rl->bounds.MaxX)
272: rl->bounds.MaxX = r.MaxX;
273: if (r.MaxY > rl->bounds.MaxY)
274: rl->bounds.MaxY = r.MaxY;
275: }
276: if (rl->count == rl->space) {
277: rl->space += 100;
278: rl->rects = (struct Rectangle *)realloc(rl->rects, rl->space*sizeof(struct Rectangle));
279: }
280: rl->rects[rl->count++] = r;
281: }
282:
283: static __inline__ void rem_rect(struct RectList *rl, int num)
284: {
285: rl->count--;
286: if (num == rl->count)
287: return;
288: rl->rects[num] = rl->rects[rl->count];
289: }
290:
291: static void free_rectlist(struct RectList *rl)
292: {
293: free(rl->rects);
294: }
295:
296: static void free_bandlist(struct BandList *bl)
297: {
298: free(bl->miny);
299: free(bl->maxy);
300: }
301:
302: static int regionrect_cmpfn(const void *a, const void *b)
303: {
304: struct Rectangle *ra = (struct Rectangle *)a;
305: struct Rectangle *rb = (struct Rectangle *)b;
306:
307: if (ra->MinY < rb->MinY)
308: return -1;
309: if (ra->MinY > rb->MinY)
310: return 1;
311: if (ra->MinX < rb->MinX)
312: return -1;
313: if (ra->MinX > rb->MinX)
314: return 1;
315: if (ra->MaxX < rb->MaxX)
316: return -1;
317: return 1;
318: }
319:
320: static __inline__ int min(int x, int y)
321: {
322: return x < y ? x : y;
323: }
324:
325: static __inline__ int max(int x, int y)
326: {
327: return x > y ? x : y;
328: }
329:
330: static void region_addbands(struct RectList *rl, struct BandList *bl)
331: {
332: int i,j;
333:
334: for (i = 0; i < rl->count; i++) {
335: struct Rectangle tmpr = rl->rects[i];
336:
337: for (j = 0; j < bl->count; j++) {
338: /* Is the current band before the rectangle? */
339: if (bl->maxy[j] < tmpr.MinY)
340: continue;
341: /* Band already present? */
342: if (bl->miny[j] == tmpr.MinY && bl->maxy[j] == tmpr.MaxY)
343: break;
344: /* Completely new band? Add it */
345: if (bl->miny[j] > tmpr.MaxY) {
346: add_band(bl, tmpr.MinY, tmpr.MaxY, j);
347: break;
348: }
349: /* Now we know that the bands are overlapping.
350: * See whether they match in one point */
351: if (bl->miny[j] == tmpr.MinY) {
352: int t;
353: if (bl->maxy[j] < tmpr.MaxY) {
354: /* Rectangle exceeds band */
355: tmpr.MinY = bl->maxy[j]+1;
356: continue;
357: }
358: /* Rectangle splits band */
359: t = bl->maxy[j];
360: bl->maxy[j] = tmpr.MaxY;
361: tmpr.MinY = bl->maxy[j] + 1;
362: tmpr.MaxY = t;
363: continue;
364: } else if (bl->maxy[j] == tmpr.MaxY) {
365: int t;
366: if (bl->miny[j] > tmpr.MinY) {
367: /* Rectangle exceeds band */
368: t = bl->miny[j];
369: bl->miny[j] = tmpr.MinY;
370: bl->maxy[j] = t-1;
371: tmpr.MinY = t;
372: continue;
373: }
374: /* Rectangle splits band */
375: bl->maxy[j] = tmpr.MinY - 1;
376: continue;
377: }
378: /* Bands overlap and match in no points. Get a new band and align */
379: if (bl->miny[j] > tmpr.MinY) {
380: /* Rectangle begins before band, so make a new band before
381: * and adjust rectangle */
382: add_band(bl, tmpr.MinY, bl->miny[j] - 1, j);
383: tmpr.MinY = bl->miny[j+1];
384: } else {
385: /* Rectangle begins in band */
386: add_band(bl, bl->miny[j], tmpr.MinY - 1, j);
387: bl->miny[j+1] = tmpr.MinY;
388: }
389: continue;
390: }
391: if (j == bl->count)
392: add_band(bl, tmpr.MinY, tmpr.MaxY, j);
393: }
394: }
395:
396: static void region_splitrects_band(struct RectList *rl, struct BandList *bl)
397: {
398: int i,j;
399: for (i = 0; i < rl->count; i++) {
400: for (j = 0; j < bl->count; j++) {
401: if (bl->miny[j] == rl->rects[i].MinY && bl->maxy[j] == rl->rects[i].MaxY)
402: break;
403: if (rl->rects[i].MinY > bl->maxy[j])
404: continue;
405: if (bl->miny[j] == rl->rects[i].MinY) {
406: struct Rectangle tmpr;
407: tmpr.MinX = rl->rects[i].MinX;
408: tmpr.MaxX = rl->rects[i].MaxX;
409: tmpr.MinY = bl->maxy[j] + 1;
410: tmpr.MaxY = rl->rects[i].MaxY;
411: add_rect(rl, tmpr); /* will be processed later */
412: rl->rects[i].MaxY = bl->maxy[j];
413: break;
414: }
415: fprintf(stderr, "Foo..\n");
416: }
417: }
418: qsort(rl->rects, rl->count, sizeof (struct Rectangle), regionrect_cmpfn);
419: }
420:
421: static void region_coalesce_rects(struct RectList *rl, int do_2nd_pass)
422: {
423: int i,j;
424:
425: /* First pass: Coalesce horizontally */
426: for (i = j = 0; i < rl->count;) {
427: int offs = 1;
428: while (i + offs < rl->count) {
429: if (rl->rects[i].MinY != rl->rects[i+offs].MinY
430: || rl->rects[i].MaxY != rl->rects[i+offs].MaxY
431: || rl->rects[i].MaxX+1 < rl->rects[i+offs].MinX)
432: break;
433: rl->rects[i].MaxX = rl->rects[i+offs].MaxX;
434: offs++;
435: }
436: rl->rects[j++] = rl->rects[i];
437: i += offs;
438: }
439: rl->count = j;
440:
441: if (!do_2nd_pass)
442: return;
443:
444: /* Second pass: Coalesce bands */
445: for (i = 0; i < rl->count;) {
446: int match = 0;
447: for (j = i + 1; j < rl->count; j++)
448: if (rl->rects[i].MinY != rl->rects[j].MinY)
449: break;
450: if (j < rl->count && rl->rects[i].MaxY + 1 == rl->rects[j].MinY) {
451: int k;
452: match = 1;
453: for (k = 0; i+k < j; k++) {
454: if (j+k >= rl->count
455: || rl->rects[j+k].MinY != rl->rects[j].MinY)
456: {
457: match = 0; break;
458: }
459: if (rl->rects[i+k].MinX != rl->rects[j+k].MinX
460: || rl->rects[i+k].MaxX != rl->rects[j+k].MaxX)
461: {
462: match = 0;
463: break;
464: }
465: }
466: if (j+k < rl->count && rl->rects[j+k].MinY == rl->rects[j].MinY)
467: match = 0;
468: if (match) {
469: for (k = 0; i+k < j; k++)
470: rl->rects[i+k].MaxY = rl->rects[j].MaxY;
471: memmove(rl->rects + j, rl->rects + j + k, (rl->count - j - k)*sizeof(struct Rectangle));
472: rl->count -= k;
473: }
474: }
475: if (!match)
476: i = j;
477: }
478: }
479:
480: static int copy_rects (CPTR region, struct RectList *rl)
481: {
482: CPTR regionrect;
483: int numrects = 0;
484: struct Rectangle b;
485: regionrect = get_long(region+8);
486: b.MinX = get_word(region);
487: b.MinY = get_word(region+2);
488: b.MaxX = get_word(region+4);
489: b.MaxY = get_word(region+6);
490:
491: while (regionrect != 0) {
492: struct Rectangle tmpr;
493:
494: tmpr.MinX = (WORD)get_word(regionrect+8) + b.MinX;
495: tmpr.MinY = (WORD)get_word(regionrect+10) + b.MinY;
496: tmpr.MaxX = (WORD)get_word(regionrect+12) + b.MinX;
497: tmpr.MaxY = (WORD)get_word(regionrect+14) + b.MinY;
498: add_rect(rl, tmpr);
499: regionrect = get_long(regionrect);
500: numrects++;
501: }
502: return numrects;
503: }
504:
505: typedef void (*regionop)(struct RectList *,struct RectList *,struct RectList *);
506:
507: static void region_do_ClearRegionRegion(struct RectList *rl1,struct RectList *rl2,
508: struct RectList *rl3)
509: {
510: int i,j;
511:
512: for (i = j = 0; i < rl2->count && j < rl1->count;) {
513: struct Rectangle tmpr;
514:
515: while ((rl1->rects[j].MinY < rl2->rects[i].MinY
516: || (rl1->rects[j].MinY == rl2->rects[i].MinY
517: && rl1->rects[j].MaxX < rl2->rects[i].MinX))
518: && j < rl1->count)
519: j++;
520: if (j >= rl1->count)
521: break;
522: while ((rl1->rects[j].MinY > rl2->rects[i].MinY
523: || (rl1->rects[j].MinY == rl2->rects[i].MinY
524: && rl1->rects[j].MinX > rl2->rects[i].MaxX))
525: && i < rl2->count)
526: {
527: add_rect(rl3, rl2->rects[i]);
528: i++;
529: }
530: if (i >= rl2->count)
531: break;
532:
533: tmpr = rl2->rects[i];
534:
535: while (i < rl2->count && j < rl1->count
536: && rl1->rects[j].MinY == tmpr.MinY
537: && rl2->rects[i].MinY == tmpr.MinY
538: && rl1->rects[j].MinX <= rl2->rects[i].MaxX
539: && rl1->rects[j].MaxX >= rl2->rects[i].MinX)
540: {
541: int oldmin = tmpr.MinX;
542: int oldmax = tmpr.MaxX;
543: if (tmpr.MinX < rl1->rects[j].MinX) {
544: tmpr.MaxX = rl1->rects[j].MinX - 1;
545: add_rect(rl3, tmpr);
546: }
547: if (oldmax <= rl1->rects[j].MaxX) {
548: i++;
549: if (i < rl2->count && rl2->rects[i].MinY == tmpr.MinY)
550: tmpr = rl2->rects[i];
551: } else {
552: tmpr.MinX = rl1->rects[j].MaxX + 1;
553: tmpr.MaxX = oldmax;
554: j++;
555: }
556: }
557: }
558: for(; i < rl2->count; i++)
559: add_rect(rl3, rl2->rects[i]);
560: }
561:
562: static void region_do_AndRegionRegion(struct RectList *rl1,struct RectList *rl2,
563: struct RectList *rl3)
564: {
565: int i,j;
566:
567: for (i = j = 0; i < rl2->count && j < rl1->count;) {
568: while ((rl1->rects[j].MinY < rl2->rects[i].MinY
569: || (rl1->rects[j].MinY == rl2->rects[i].MinY
570: && rl1->rects[j].MaxX < rl2->rects[i].MinX))
571: && j < rl1->count)
572: j++;
573: if (j >= rl1->count)
574: break;
575: while ((rl1->rects[j].MinY > rl2->rects[i].MinY
576: || (rl1->rects[j].MinY == rl2->rects[i].MinY
577: && rl1->rects[j].MinX > rl2->rects[i].MaxX))
578: && i < rl2->count)
579: i++;
580: if (i >= rl2->count)
581: break;
582: if (rl1->rects[j].MinY == rl2->rects[i].MinY
583: && rl1->rects[j].MinX <= rl2->rects[i].MaxX
584: && rl1->rects[j].MaxX >= rl2->rects[i].MinX)
585: {
586: /* We have an intersection! */
587: struct Rectangle tmpr;
588: tmpr = rl2->rects[i];
589: if (tmpr.MinX < rl1->rects[j].MinX)
590: tmpr.MinX = rl1->rects[j].MinX;
591: if (tmpr.MaxX > rl1->rects[j].MaxX)
592: tmpr.MaxX = rl1->rects[j].MaxX;
593: add_rect(rl3, tmpr);
594: if (rl1->rects[j].MaxX == rl2->rects[i].MaxX)
595: i++, j++;
596: else if (rl1->rects[j].MaxX > rl2->rects[i].MaxX)
597: i++;
598: else
599: j++;
600: }
601: }
602: }
603:
604: static void region_do_OrRegionRegion(struct RectList *rl1,struct RectList *rl2,
605: struct RectList *rl3)
606: {
607: int i,j;
608:
609: for (i = j = 0; i < rl2->count && j < rl1->count;) {
610: while ((rl1->rects[j].MinY < rl2->rects[i].MinY
611: || (rl1->rects[j].MinY == rl2->rects[i].MinY
612: && rl1->rects[j].MaxX < rl2->rects[i].MinX))
613: && j < rl1->count)
614: {
615: add_rect(rl3, rl1->rects[j]);
616: j++;
617: }
618: if (j >= rl1->count)
619: break;
620: while ((rl1->rects[j].MinY > rl2->rects[i].MinY
621: || (rl1->rects[j].MinY == rl2->rects[i].MinY
622: && rl1->rects[j].MinX > rl2->rects[i].MaxX))
623: && i < rl2->count)
624: {
625: add_rect(rl3, rl2->rects[i]);
626: i++;
627: }
628: if (i >= rl2->count)
629: break;
630: if (rl1->rects[j].MinY == rl2->rects[i].MinY
631: && rl1->rects[j].MinX <= rl2->rects[i].MaxX
632: && rl1->rects[j].MaxX >= rl2->rects[i].MinX)
633: {
634: /* We have an intersection! */
635: struct Rectangle tmpr;
636: tmpr = rl2->rects[i];
637: if (tmpr.MinX > rl1->rects[j].MinX)
638: tmpr.MinX = rl1->rects[j].MinX;
639: if (tmpr.MaxX < rl1->rects[j].MaxX)
640: tmpr.MaxX = rl1->rects[j].MaxX;
641: i++; j++;
642: for (;;) {
643: int cont = 0;
644: if (j < rl1->count && rl1->rects[j].MinY == tmpr.MinY
645: && tmpr.MaxX+1 >= rl1->rects[j].MinX) {
646: if (tmpr.MaxX < rl1->rects[j].MaxX)
647: tmpr.MaxX = rl1->rects[j].MaxX;
648: j++; cont = 1;
649: }
650: if (i < rl2->count && rl2->rects[i].MinY == tmpr.MinY
651: && tmpr.MaxX+1 >= rl2->rects[i].MinX) {
652: if (tmpr.MaxX < rl2->rects[i].MaxX)
653: tmpr.MaxX = rl2->rects[i].MaxX;
654: i++; cont = 1;
655: }
656: if (!cont)
657: break;
658: }
659: add_rect(rl3, tmpr);
660: }
661: }
662: for(; i < rl2->count; i++)
663: add_rect(rl3, rl2->rects[i]);
664: for(; j < rl1->count; j++)
665: add_rect(rl3, rl1->rects[j]);
666: }
667:
668: static void region_do_XorRegionRegion(struct RectList *rl1,struct RectList *rl2,
669: struct RectList *rl3)
670: {
671: int i,j;
672:
673: for (i = j = 0; i < rl2->count && j < rl1->count;) {
674: struct Rectangle tmpr1, tmpr2;
675:
676: while ((rl1->rects[j].MinY < rl2->rects[i].MinY
677: || (rl1->rects[j].MinY == rl2->rects[i].MinY
678: && rl1->rects[j].MaxX < rl2->rects[i].MinX))
679: && j < rl1->count)
680: {
681: add_rect(rl3, rl1->rects[j]);
682: j++;
683: }
684: if (j >= rl1->count)
685: break;
686: while ((rl1->rects[j].MinY > rl2->rects[i].MinY
687: || (rl1->rects[j].MinY == rl2->rects[i].MinY
688: && rl1->rects[j].MinX > rl2->rects[i].MaxX))
689: && i < rl2->count)
690: {
691: add_rect(rl3, rl2->rects[i]);
692: i++;
693: }
694: if (i >= rl2->count)
695: break;
696:
697: tmpr2 = rl2->rects[i];
698: tmpr1 = rl1->rects[j];
699:
700: while (i < rl2->count && j < rl1->count
701: && rl1->rects[j].MinY == tmpr1.MinY
702: && rl2->rects[i].MinY == tmpr1.MinY
703: && rl1->rects[j].MinX <= rl2->rects[i].MaxX
704: && rl1->rects[j].MaxX >= rl2->rects[i].MinX)
705: {
706: int oldmin2 = tmpr2.MinX;
707: int oldmax2 = tmpr2.MaxX;
708: int oldmin1 = tmpr1.MinX;
709: int oldmax1 = tmpr1.MaxX;
710: int need_1 = 0, need_2 = 0;
711:
712: if (tmpr2.MinX > tmpr1.MinX && tmpr2.MaxX < tmpr1.MaxX)
713: {
714: /*
715: * ###########
716: * ****
717: */
718: tmpr1.MaxX = tmpr2.MinX - 1;
719: add_rect(rl3, tmpr1);
720: tmpr1.MaxX = oldmax1;
721: tmpr1.MinX = tmpr2.MaxX + 1;
722: add_rect(rl3, tmpr1);
723: need_2 = 1;
724: } else if (tmpr2.MinX > tmpr1.MinX && tmpr2.MaxX > tmpr1.MaxX) {
725: /*
726: * ##########
727: * *********
728: */
729: tmpr1.MaxX = tmpr2.MinX - 1;
730: add_rect(rl3, tmpr1);
731: tmpr2.MinX = oldmax1 + 1;
732: add_rect(rl3, tmpr2);
733: need_1 = 1;
734: } else if (tmpr2.MinX < tmpr1.MinX && tmpr2.MaxX < tmpr1.MaxX) {
735: /*
736: * ##########
737: * *********
738: */
739: tmpr2.MaxX = tmpr1.MinX - 1;
740: add_rect(rl3, tmpr2);
741: tmpr1.MinX = oldmax2 + 1;
742: add_rect(rl3, tmpr1);
743: need_2 = 1;
744: } else if (tmpr2.MinX < tmpr1.MinX && tmpr2.MaxX > tmpr1.MaxX) {
745: /*
746: * ###
747: * *********
748: */
749: tmpr2.MaxX = tmpr1.MinX - 1;
750: add_rect(rl3, tmpr2);
751: tmpr2.MaxX = oldmax2;
752: tmpr2.MinX = tmpr1.MaxX + 1;
753: add_rect(rl3, tmpr2);
754: need_1 = 1;
755: } else if (tmpr1.MinX == tmpr2.MinX && tmpr2.MaxX < tmpr1.MaxX) {
756: /*
757: * #############
758: * *********
759: */
760: tmpr1.MinX = tmpr2.MaxX + 1;
761: need_2 = 1;
762: } else if (tmpr1.MinX == tmpr2.MinX && tmpr2.MaxX > tmpr1.MaxX) {
763: /*
764: * #########
765: * *************
766: */
767: tmpr2.MinX = tmpr1.MaxX + 1;
768: need_1 = 1;
769: } else if (tmpr1.MinX < tmpr2.MinX && tmpr2.MaxX == tmpr1.MaxX) {
770: /*
771: * #############
772: * *********
773: */
774: tmpr1.MaxX = tmpr2.MinX - 1;
775: add_rect(rl3, tmpr1);
776: need_2 = need_1 = 1;
777: } else if (tmpr1.MinX > tmpr2.MinX && tmpr2.MaxX == tmpr1.MaxX) {
778: /*
779: * #########
780: * *************
781: */
782: tmpr2.MaxX = tmpr1.MinX - 1;
783: add_rect(rl3, tmpr2);
784: need_2 = need_1 = 1;
785: } else {
786: assert(tmpr1.MinX == tmpr2.MinX && tmpr2.MaxX == tmpr1.MaxX);
787: need_1 = need_2 = 1;
788: }
789: if (need_1) {
790: j++;
791: if (j < rl1->count && rl1->rects[j].MinY == tmpr1.MinY)
792: tmpr1 = rl1->rects[j];
793: }
794: if (need_2) {
795: i++;
796: if (i < rl2->count && rl2->rects[i].MinY == tmpr2.MinY)
797: tmpr2 = rl2->rects[i];
798: }
799: }
800: }
801: for(; i < rl2->count; i++)
802: add_rect(rl3, rl2->rects[i]);
803: for(; j < rl1->count; j++)
804: add_rect(rl3, rl1->rects[j]);
805: }
806:
807: static ULONG gfxl_perform_regionop(regionop op, int with_rect)
808: {
809: int i,j,k;
810: CPTR reg1;
811: CPTR reg2;
812: CPTR tmp, rpp;
813: struct RectList rl1, rl2, rl3;
814: struct BandList bl;
815:
816: int retval = 0;
817: int numrects2;
818:
819: init_rectlist(&rl1); init_rectlist(&rl2); init_rectlist(&rl3);
820:
821: if (with_rect) {
822: struct Rectangle tmpr;
823: reg2 = regs.a[0];
824: numrects2 = copy_rects(reg2, &rl2);
825: tmpr.MinX = get_word(regs.a[1]);
826: tmpr.MinY = get_word(regs.a[1] + 2);
827: tmpr.MaxX = get_word(regs.a[1] + 4);
828: tmpr.MaxY = get_word(regs.a[1] + 6);
829: add_rect(&rl1, tmpr);
830: } else {
831: reg1 = regs.a[0];
832: reg2 = regs.a[1];
833:
834: copy_rects(reg1, &rl1);
835: numrects2 = copy_rects(reg2, &rl2);
836: }
837:
838: init_bandlist(&bl);
839: region_addbands(&rl1, &bl);
840: region_addbands(&rl2, &bl);
841: region_splitrects_band(&rl1, &bl);
842: region_splitrects_band(&rl2, &bl);
843: region_coalesce_rects(&rl1, 0);
844: region_coalesce_rects(&rl2, 0);
845:
846: (*op)(&rl1, &rl2, &rl3);
847: region_coalesce_rects(&rl3, 1);
848:
849: rpp = reg2 + 8;
850: if (rl3.count < numrects2) {
851: while (numrects2-- != rl3.count) {
852: tmp = get_long(rpp);
853: put_long(rpp, get_long(tmp));
854: amiga_free(tmp, 16);
855: }
856: if (rl3.count > 0)
857: put_long(get_long(rpp) + 4, rpp);
858: } else if (rl3.count > numrects2) {
859: while(numrects2++ != rl3.count) {
860: CPTR prev = get_long(rpp);
861: tmp = amiga_malloc(16);
862: if (tmp == 0)
863: goto done;
864: put_long(tmp, prev);
865: put_long(tmp + 4, rpp);
866: if (prev != 0)
867: put_long(prev + 4, tmp);
868: put_long(rpp, tmp);
869: }
870: }
871:
872: if (rl3.count > 0) {
873: rpp = reg2 + 8;
874: for (i = 0; i < rl3.count; i++) {
875: CPTR rr = get_long(rpp);
876: put_word(rr+8, rl3.rects[i].MinX - rl3.bounds.MinX);
877: put_word(rr+10, rl3.rects[i].MinY - rl3.bounds.MinY);
878: put_word(rr+12, rl3.rects[i].MaxX - rl3.bounds.MinX);
879: put_word(rr+14, rl3.rects[i].MaxY - rl3.bounds.MinY);
880: rpp = rr;
881: }
882: if (get_long(rpp) != 0)
883: fprintf(stderr, "BUG\n");
884: }
885: put_word(reg2+0, rl3.bounds.MinX);
886: put_word(reg2+2, rl3.bounds.MinY);
887: put_word(reg2+4, rl3.bounds.MaxX);
888: put_word(reg2+6, rl3.bounds.MaxY);
889: retval = 1;
890:
891: done:
892: free_rectlist(&rl1); free_rectlist(&rl2); free_rectlist(&rl3);
893: free_bandlist(&bl);
894:
895: return retval;
896: }
897:
898: static ULONG gfxl_AndRegionRegion(void)
899: {
900: /* printf("AndRegionRegion\n");*/
901: return gfxl_perform_regionop(region_do_AndRegionRegion, 0);
902: }
903: static ULONG gfxl_XorRegionRegion(void)
904: {
905: printf("XorRegionRegion\n");
906: return gfxl_perform_regionop(region_do_XorRegionRegion, 0);
907: }
908: static ULONG gfxl_OrRegionRegion(void)
909: {
910: /* printf("OrRegionRegion\n");*/
911: return gfxl_perform_regionop(region_do_OrRegionRegion, 0);
912: }
913:
914: static ULONG gfxl_ClearRectRegion(void)
915: {
916: printf("ClearRectRegion\n");
917: return gfxl_perform_regionop(region_do_ClearRegionRegion, 1);
918: }
919: static ULONG gfxl_OrRectRegion(void)
920: {
921: /* printf("OrRectRegion\n");*/
922: return gfxl_perform_regionop(region_do_OrRegionRegion, 1);
923: }
924:
925: static ULONG gfxl_AndRectRegion(void)
926: {
927: printf("AndRectRegion\n");
928: return gfxl_perform_regionop(region_do_AndRegionRegion, 1);
929: }
930:
931: static ULONG gfxl_XorRectRegion(void)
932: {
933: printf("XorRectRegion\n");
934: return gfxl_perform_regionop(region_do_XorRegionRegion, 1);
935: }
936:
937:
938: /*
939: * Initialization
940: */
941: static ULONG gfxlib_init(void)
942: {
943: ULONG old_arr;
944: CPTR gfxbase;
945: CPTR sysbase=regs.a[6];
946: int i=0;
947:
948: /* Install new routines */
949: /* We have to call SetFunction here instead of writing direktly into the GfxBase,
950: * because of the library checksum ! */
951:
952: regs.d[0]=0;
953: regs.a[1]=gfxlibname;
954: gfxbase=CallLib(sysbase, -408); /* OpenLibrary */
955:
956: libemu_InstallFunction(gfxl_WritePixel, gfxbase, -324);
957: libemu_InstallFunction(gfxl_BltClear, gfxbase, -300);
958: libemu_InstallFunction(gfxl_AndRegionRegion, gfxbase, -624);
959: libemu_InstallFunction(gfxl_OrRegionRegion, gfxbase, -612);
960: libemu_InstallFunction(gfxl_XorRegionRegion, gfxbase, -618);
961: libemu_InstallFunction(gfxl_AndRectRegion, gfxbase, -504);
962: libemu_InstallFunction(gfxl_OrRectRegion, gfxbase, -510);
963: libemu_InstallFunction(gfxl_XorRectRegion, gfxbase, -558);
964: libemu_InstallFunction(gfxl_ClearRectRegion, gfxbase, -522);
965:
966: return 0;
967: }
968:
969: /*
970: * Install the gfx-library-replacement
971: */
972: void gfxlib_install(void)
973: {
974: ULONG begin, end, resname, resid;
975: int i;
976:
977: if(!use_gfxlib) return;
978:
979: fprintf(stderr, "Warning: you enabled the graphics.library replacement with -g\n"
980: "This may be buggy right now, and will not speed things up much.\n");
981:
982: resname = ds("UAEgfxlib.resource");
983: resid = ds("UAE gfxlib 0.1");
984:
985: gfxlibname = ds("graphics.library");
986:
987: begin = here();
988: dw(0x4AFC); /* RTC_MATCHWORD */
989: dl(begin); /* our start address */
990: dl(0); /* Continue scan here */
991: dw(0x0101); /* RTF_COLDSTART; Version 1 */
992: dw(0x0805); /* NT_RESOURCE; pri 5 */
993: dl(resname); /* name */
994: dl(resid); /* ID */
995: dl(here() + 4); /* Init area: directly after this */
996:
997: calltrap(deftrap(gfxlib_init)); dw(RTS);
998:
999: end = here();
1000: org(begin + 6);
1001: dl(end);
1002:
1003: org(end);
1004: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.