?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed missing fprintf argument.
[AROS.git] / rom / graphics / gfxfuncsupport.c
blobbdbd4ca5537d5040d0b6de9fbe665ce041d3ee7b
1 /*
2 Copyright © 1995-2001, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 /* !!!! ONLY USE THE BELOW MACROS IF YOU ARE 100% SURE
7 THAT IT IS A HIDD BITMAP AND NOT ONE THE USER
8 HAS CREATED BY HAND !!!. You can use IS_HIDD_BM(bitmap) to test
9 if it is a HIDD bitmap
10 */
11
12 /****************************************************************************************/
13
14 #include <cybergraphx/cybergraphics.h>
15 #include <graphics/rpattr.h>
16 #include <proto/exec.h>
17 #include <proto/graphics.h>
18 #include <proto/layers.h>
19 #include <proto/cybergraphics.h>
20 #include <proto/oop.h>
21 #include <clib/macros.h>
22
23 #include "graphics_intern.h"
24 #include "objcache.h"
25 #include "intregions.h"
26 #include "gfxfuncsupport.h"
27
28 #define DEBUG 0
29 #include <aros/debug.h>
30
31 /****************************************************************************************/
32
33 OOP_Object *get_planarbm_object(struct BitMap *bitmap, struct GfxBase *GfxBase)
34 {
35 OOP_Object *pbm_obj;
36
37 D(bug("get_planarbm_object()\n"));
38 pbm_obj = obtain_cache_object(SDD(GfxBase)->planarbm_cache, GfxBase);
39
40 if (NULL != pbm_obj)
41 {
42
43 D(bug("Got cache object %p, class=%s, domethod=%p, instoffset=%d\n"
44 , pbm_obj
45 , OOP_OCLASS(pbm_obj)->ClassNode.ln_Name
46 , OOP_OCLASS(pbm_obj)->DoMethod
47 , OOP_OCLASS(pbm_obj)->InstOffset
48 ));
49
50 if (!HIDD_PlanarBM_SetBitMap(pbm_obj, bitmap))
51 {
52 D(bug("!!! get_planarbm_object: HIDD_PlanarBM_SetBitMap FAILED !!!\n"));
53 release_cache_object(SDD(GfxBase)->planarbm_cache, pbm_obj, GfxBase);
54 pbm_obj = NULL;
55 }
56
57 }
58 else
59 {
60 D(bug("!!! get_planarbm_object: obtain_cache_object FAILED !!!\n"));
61 }
62
63 return pbm_obj;
64 }
65
66 /****************************************************************************************/
67
68 ULONG do_render_func(struct RastPort *rp
69 , Point *src
70 , struct Rectangle *rr
71 , ULONG (*render_func)(APTR, LONG, LONG, OOP_Object *, OOP_Object *, LONG, LONG, LONG, LONG, struct GfxBase *)
72 , APTR funcdata
73 , BOOL get_special_info
74 , struct GfxBase *GfxBase)
75 {
76
77 struct BitMap *bm = rp->BitMap;
78 struct Layer *L = rp->Layer;
79 OOP_Object *gc;
80 struct Rectangle rp_clip_rectangle;
81 BOOL have_rp_cliprectangle;
82 ULONG width, height;
83 LONG srcx, srcy;
84 LONG pixwritten = 0;
85
86 gc = GetDriverData(rp)->dd_GC;
87
88 width = rr->MaxX - rr->MinX + 1;
89 height = rr->MaxY - rr->MinY + 1;
90
91 if (NULL != src)
92 {
93 srcx = src->x;
94 srcy = src->y;
95 } else
96 {
97 srcx = 0;
98 srcy = 0;
99 }
100
101 if (NULL == L)
102 {
103 /* No layer, probably a screen, but may be a user inited bitmap */
104 OOP_Object *bm_obj;
105
106 bm_obj = OBTAIN_HIDD_BM(bm);
107 if (NULL == bm_obj)
108 return 0;
109
110 if (get_special_info)
111 {
112 RSI(funcdata)->curbm = rp->BitMap;
113 RSI(funcdata)->onscreen = TRUE;
114 RSI(funcdata)->layer_rel_srcx = srcx;
115 RSI(funcdata)->layer_rel_srcy = srcy;
116 }
117
118 pixwritten = render_func(funcdata
119 , srcx, srcy
120 , bm_obj, gc
121 , rr->MinX, rr->MinY
122 , rr->MaxX, rr->MaxY
123 , GfxBase
124 );
125
126 RELEASE_HIDD_BM(bm_obj, bm);
127
128 }
129 else
130 {
131 struct ClipRect *CR;
132 WORD xrel;
133 WORD yrel;
134 struct Rectangle torender, intersect;
135
136 LockLayerRom(L);
137
138 have_rp_cliprectangle = GetRPClipRectangleForLayer(rp, L, &rp_clip_rectangle, GfxBase);
139
140 xrel = L->bounds.MinX;
141 yrel = L->bounds.MinY;
142
143 torender.MinX = rr->MinX + xrel - L->Scroll_X;
144 torender.MinY = rr->MinY + yrel - L->Scroll_Y;
145 torender.MaxX = rr->MaxX + xrel - L->Scroll_X;
146 torender.MaxY = rr->MaxY + yrel - L->Scroll_Y;
147
148
149 CR = L->ClipRect;
150
151 for (;NULL != CR; CR = CR->Next)
152 {
153 D(bug("Cliprect (%d, %d, %d, %d), lobs=%p\n",
154 CR->bounds.MinX, CR->bounds.MinY, CR->bounds.MaxX, CR->bounds.MaxY,
155 CR->lobs));
156
157 /* Does this cliprect intersect with area to rectfill ? */
158 if (_AndRectRect(&CR->bounds, &torender, &intersect))
159 {
160 if (!have_rp_cliprectangle || _AndRectRect(&rp_clip_rectangle, &intersect, &intersect))
161 {
162 LONG xoffset, yoffset;
163
164 xoffset = intersect.MinX - torender.MinX;
165 yoffset = intersect.MinY - torender.MinY;
166
167 if (get_special_info) {
168 RSI(funcdata)->layer_rel_srcx = intersect.MinX - L->bounds.MinX + L->Scroll_X;
169 RSI(funcdata)->layer_rel_srcy = intersect.MinY - L->bounds.MinY + L->Scroll_Y;
170 }
171
172 if (NULL == CR->lobs)
173 {
174 if (get_special_info)
175 {
176 RSI(funcdata)->curbm = bm;
177 RSI(funcdata)->onscreen = TRUE;
178 }
179
180 pixwritten += render_func(funcdata
181 , srcx + xoffset
182 , srcy + yoffset
183 , HIDD_BM_OBJ(bm)
184 , gc
185 , intersect.MinX
186 , intersect.MinY
187 , intersect.MaxX
188 , intersect.MaxY
189 , GfxBase
190 );
191
192
193 }
194 else
195 {
196 /* Render into offscreen cliprect bitmap */
197 if (L->Flags & LAYERSIMPLE)
198 continue;
199 else if (L->Flags & LAYERSUPER)
200 {
201 D(bug("do_render_func(): Superbitmap not handled yet\n"));
202 }
203 else
204 {
205
206 if (get_special_info)
207 {
208 RSI(funcdata)->curbm = CR->BitMap;
209 RSI(funcdata)->onscreen = FALSE;
210 }
211 pixwritten += render_func(funcdata
212 , srcx + xoffset, srcy + yoffset
213 , HIDD_BM_OBJ(CR->BitMap)
214 , gc
215 , intersect.MinX - CR->bounds.MinX + ALIGN_OFFSET(CR->bounds.MinX)
216 , intersect.MinY - CR->bounds.MinY
217 , intersect.MaxX - CR->bounds.MinX + ALIGN_OFFSET(CR->bounds.MinX)
218 , intersect.MaxY - CR->bounds.MinY
219 , GfxBase
220 );
221 }
222
223 } /* if (CR->lobs == NULL) */
224
225 } /* if it also intersects with possible rastport clip rectangle */
226
227 } /* if (cliprect intersects with area to render into) */
228
229 } /* for (each cliprect in the layer) */
230
231 UnlockLayerRom(L);
232 } /* if (rp->Layer) */
233
234
235 return pixwritten;
236
237 }
238
239 /****************************************************************************************/
240
241 ULONG do_pixel_func(struct RastPort *rp
242 , LONG x, LONG y
243 , LONG (*render_func)(APTR, OOP_Object *, OOP_Object *, LONG, LONG, struct GfxBase *)
244 , APTR funcdata
245 , struct GfxBase *GfxBase)
246 {
247 struct BitMap *bm = rp->BitMap;
248 struct Layer *L = rp->Layer;
249 OOP_Object *gc;
250 struct Rectangle rp_clip_rectangle;
251 BOOL have_rp_cliprectangle;
252 ULONG retval = -1;
253
254 gc = GetDriverData(rp)->dd_GC;
255
256 if (NULL == L)
257 {
258 OOP_Object *bm_obj;
259 ULONG width, height;
260
261 bm_obj = OBTAIN_HIDD_BM(bm);
262 if (NULL == bm_obj)
263 return -1;
264
265 OOP_GetAttr(bm_obj, aHidd_BitMap_Width, &width);
266 OOP_GetAttr(bm_obj, aHidd_BitMap_Height, &height);
267
268 /* Check whether we it is inside the rastport */
269 if ( x < 0
270 || x >= width
271 || y < 0
272 || y >= height)
273 {
274
275 RELEASE_HIDD_BM(bm_obj, bm);
276 return -1;
277
278 }
279
280 /* This is a screen */
281 retval = render_func(funcdata, bm_obj, gc, x, y, GfxBase);
282
283 RELEASE_HIDD_BM(bm_obj, bm);
284
285 }
286 else
287 {
288 struct ClipRect *CR;
289 LONG absx, absy;
290
291 LockLayerRom( L );
292
293 have_rp_cliprectangle = GetRPClipRectangleForLayer(rp, L, &rp_clip_rectangle, GfxBase);
294
295 CR = L->ClipRect;
296
297 absx = x + L->bounds.MinX - L->Scroll_X;
298 absy = y + L->bounds.MinY - L->Scroll_Y;
299
300 for (;NULL != CR; CR = CR->Next)
301 {
302
303 if ( absx >= CR->bounds.MinX
304 && absy >= CR->bounds.MinY
305 && absx <= CR->bounds.MaxX
306 && absy <= CR->bounds.MaxY )
307 {
308
309 if (!have_rp_cliprectangle || _IsPointInRect(&rp_clip_rectangle, absx, absy))
310 {
311 if (NULL == CR->lobs)
312 {
313 retval = render_func(funcdata
314 , HIDD_BM_OBJ(bm), gc
315 , absx, absy
316 , GfxBase
317 );
318 }
319 else
320 {
321 /* This is the tricky one: render into offscreen cliprect bitmap */
322 if (L->Flags & LAYERSIMPLE)
323 {
324 /* We cannot do anything */
325 retval = 0;
326
327 }
328 else if (L->Flags & LAYERSUPER)
329 {
330 D(bug("driver_WriteRGBPixel(): Superbitmap not handled yet\n"));
331 }
332 else
333 {
334 retval = render_func(funcdata
335 , HIDD_BM_OBJ(CR->BitMap), gc
336 , absx - CR->bounds.MinX + ALIGN_OFFSET(CR->bounds.MinX)
337 , absy - CR->bounds.MinY
338 , GfxBase
339 );
340
341
342 } /* If (SMARTREFRESH cliprect) */
343
344
345 } /* if (intersecton inside hidden cliprect) */
346
347 } /* if point is also inside possible rastport clip rectangle */
348
349 /* The pixel was found and put inside one of the cliprects, just exit */
350 break;
351
352 } /* if (cliprect intersects with area we want to draw to) */
353
354 } /* while (cliprects to examine) */
355
356 UnlockLayerRom( L );
357
358 }
359
360 return retval;
361 }
362
363 /****************************************************************************************/
364
365 static ULONG fillrect_render(APTR funcdata, LONG srcx, LONG srcy,
366 OOP_Object *dstbm_obj, OOP_Object *dst_gc,
367 LONG x1, LONG y1, LONG x2, LONG y2,
368 struct GfxBase *GfxBase)
369 {
370
371 HIDD_BM_FillRect(dstbm_obj, dst_gc, x1, y1, x2, y2);
372
373 return (x2 - x1 + 1) * (y2 - y1 + 1);
374 }
375
376 /****************************************************************************************/
377
378 LONG fillrect_pendrmd(struct RastPort *rp, LONG x1, LONG y1, LONG x2, LONG y2,
379 HIDDT_Pixel pix, HIDDT_DrawMode drmd, struct GfxBase *GfxBase)
380 {
381 LONG pixwritten = 0;
382
383 HIDDT_DrawMode old_drmd;
384 HIDDT_Pixel old_fg;
385 OOP_Object *gc;
386 struct Rectangle rr;
387
388 struct TagItem gc_tags[] =
389 {
390 { aHidd_GC_DrawMode , drmd },
391 { aHidd_GC_Foreground , pix },
392 { TAG_DONE }
393 };
394
395
396 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
397 return 0;
398
399 gc = GetDriverData(rp)->dd_GC;
400
401 OOP_GetAttr(gc, aHidd_GC_DrawMode, (IPTR *)&old_drmd);
402 OOP_GetAttr(gc, aHidd_GC_Foreground,(IPTR *)&old_fg);
403
404 OOP_SetAttrs(gc, gc_tags);
405
406 rr.MinX = x1;
407 rr.MinY = y1;
408 rr.MaxX = x2;
409 rr.MaxY = y2;
410
411 pixwritten = do_render_func(rp, NULL, &rr, fillrect_render, NULL, FALSE, GfxBase);
412
413 /* Restore old GC values */
414 gc_tags[0].ti_Data = (IPTR)old_drmd;
415 gc_tags[1].ti_Data = (IPTR)old_fg;
416 OOP_SetAttrs(gc, gc_tags);
417
418 RELEASE_DRIVERDATA(rp, GfxBase);
419
420 return pixwritten;
421 }
422
423 /****************************************************************************************/
424
425 BOOL int_bltbitmap(struct BitMap *srcBitMap, OOP_Object *srcbm_obj, LONG xSrc, LONG ySrc,
426 struct BitMap *dstBitMap, OOP_Object *dstbm_obj, LONG xDest, LONG yDest,
427 LONG xSize, LONG ySize, ULONG minterm, OOP_Object *gc, struct GfxBase *GfxBase)
428 {
429 HIDDT_DrawMode drmd;
430
431 ULONG srcflags = 0;
432 ULONG dstflags = 0;
433
434 BOOL src_colmap_set = FALSE;
435 BOOL dst_colmap_set = FALSE;
436 BOOL success = TRUE;
437 BOOL colmaps_ok = TRUE;
438
439 drmd = MINTERM_TO_GCDRMD(minterm);
440
441 /* We must lock any HIDD_BM_SetColorMap calls */
442 LOCK_BLIT
443
444 /* Try to get a CLUT for the bitmaps */
445 if (IS_HIDD_BM(srcBitMap))
446 {
447 //bug("driver_intbltbitmap: source is hidd bitmap\n");
448 if (NULL != HIDD_BM_COLMAP(srcBitMap))
449 {
450 //bug("driver_intbltbitmap: source has colormap\n");
451 srcflags |= FLG_HASCOLMAP;
452 }
453 srcflags |= GET_COLMOD_FLAGS(srcBitMap);
454 }
455 else
456 {
457 //bug("driver_intbltbitmap: source is amiga bitmap\n");
458 /* Amiga BM */
459 srcflags |= FLG_PALETTE;
460 }
461
462 if (IS_HIDD_BM(dstBitMap))
463 {
464 //bug("driver_intbltbitmap: dest is hidd bitmap\n");
465 if (NULL != HIDD_BM_COLMAP(dstBitMap))
466 {
467 //bug("driver_intbltbitmap: dest has colormap\n");
468 dstflags |= FLG_HASCOLMAP;
469 }
470 dstflags |= GET_COLMOD_FLAGS(dstBitMap);
471 }
472 else
473 {
474 //bug("driver_intbltbitmap: dest is amiga bitmap\n");
475 /* Amiga BM */
476 dstflags |= FLG_PALETTE;
477 }
478
479 if ( (srcflags == FLG_PALETTE || srcflags == FLG_STATICPALETTE))
480 {
481 /* palettized with no colmap. Neew to get a colmap from dest*/
482 if (dstflags == FLG_TRUECOLOR)
483 {
484
485 D(bug("!!! NO WAY GETTING PALETTE FOR src IN BltBitMap\n"));
486 colmaps_ok = FALSE;
487 success = FALSE;
488
489 }
490 else if (dstflags == (FLG_TRUECOLOR | FLG_HASCOLMAP))
491 {
492
493 /* Use the dest colmap for src */
494 HIDD_BM_SetColorMap(srcbm_obj, HIDD_BM_COLMAP(dstBitMap));
495
496 src_colmap_set = TRUE;
497
498 /*
499 bug("Colormap:\n");
500 {
501 ULONG idx;
502 for (idx = 0; idx < 256; idx ++)
503 bug("[%d]=%d ", idx, HIDD_CM_GetPixel(HIDD_BM_COLMAP(dstBitMap), idx));
504 }
505 */
506 }
507 }
508
509 if ( (dstflags == FLG_PALETTE || dstflags == FLG_STATICPALETTE))
510 {
511 /* palettized with no pixtab. Nees to get a pixtab from dest*/
512 if (srcflags == FLG_TRUECOLOR)
513 {
514 D(bug("!!! NO WAY GETTING PALETTE FOR dst IN BltBitMap\n"));
515 colmaps_ok = FALSE;
516 success = FALSE;
517
518 }
519 else if (srcflags == (FLG_TRUECOLOR | FLG_HASCOLMAP))
520 {
521
522 /* Use the src colmap for dst */
523 HIDD_BM_SetColorMap(dstbm_obj, HIDD_BM_COLMAP(srcBitMap));
524
525 dst_colmap_set = TRUE;
526 }
527 }
528
529 if (colmaps_ok)
530 {
531 /* We need special treatment with drawmode Clear and
532 truecolor bitmaps, in order to set it to
533 colormap[0] instead of just 0
534 */
535 if ( (drmd == vHidd_GC_DrawMode_Clear)
536 && ( (dstflags & (FLG_TRUECOLOR | FLG_HASCOLMAP)) == (FLG_TRUECOLOR | FLG_HASCOLMAP) ))
537 {
538
539 HIDDT_DrawMode old_drmd;
540 HIDDT_Pixel old_fg;
541
542 struct TagItem frtags[] =
543 {
544 { aHidd_GC_Foreground , 0 },
545 { aHidd_GC_DrawMode , vHidd_GC_DrawMode_Copy },
546 { TAG_DONE }
547 };
548
549 OOP_GetAttr(gc, aHidd_GC_DrawMode, &old_drmd);
550 OOP_GetAttr(gc, aHidd_GC_Foreground, &old_fg);
551
552 frtags[0].ti_Data = HIDD_BM_PIXTAB(dstBitMap)[0];
553 frtags[1].ti_Data = vHidd_GC_DrawMode_Copy;
554
555 OOP_SetAttrs(gc, frtags);
556
557 HIDD_BM_FillRect(dstbm_obj, gc
558 , xDest, yDest
559 , xDest + xSize - 1
560 , yDest + ySize - 1
561 );
562
563 frtags[0].ti_Data = old_fg;
564 frtags[1].ti_Data = old_drmd;
565
566 }
567 else
568 {
569 HIDDT_DrawMode old_drmd;
570
571 struct TagItem cbtags[] =
572 {
573 { aHidd_GC_DrawMode, 0 },
574 { TAG_DONE }
575 };
576
577 OOP_GetAttr(gc, aHidd_GC_DrawMode, &old_drmd);
578
579 cbtags[0].ti_Data = drmd;
580
581 OOP_SetAttrs(gc, cbtags);
582 HIDD_Gfx_CopyBox(SDD(GfxBase)->gfxhidd
583 , srcbm_obj
584 , xSrc, ySrc
585 , dstbm_obj
586 , xDest, yDest
587 , xSize, ySize
588 , gc
589 );
590
591 cbtags[0].ti_Data = drmd;
592 OOP_SetAttrs(gc, cbtags);
593 }
594
595 } /* if (colmaps_ok) */
596
597 if (src_colmap_set)
598 HIDD_BM_SetColorMap(srcbm_obj, NULL);
599
600 if (dst_colmap_set)
601 HIDD_BM_SetColorMap(dstbm_obj, NULL);
602
603 ULOCK_BLIT
604
605 return success;
606
607 }
608
609 /****************************************************************************************/
610
611 struct wp8_render_data
612 {
613 UBYTE *array;
614 ULONG modulo;
615 HIDDT_PixelLUT *pixlut;
616 };
617
618 static ULONG wp8_render(APTR wp8r_data, LONG srcx, LONG srcy, OOP_Object *dstbm_obj,
619 OOP_Object *dst_gc, LONG x1, LONG y1, LONG x2, LONG y2,
620 struct GfxBase *GfxBase)
621 {
622 struct wp8_render_data *wp8rd;
623 ULONG width, height;
624
625 wp8rd = (struct wp8_render_data *)wp8r_data;
626
627 width = x2 - x1 + 1;
628 height = y2 - y1 + 1;
629
630 HIDD_BM_PutImageLUT(dstbm_obj
631 , dst_gc
632 , wp8rd->array + CHUNKY8_COORD_TO_BYTEIDX(srcx, srcy, wp8rd->modulo)
633 , wp8rd->modulo
634 , x1, y1
635 , width, height
636 , wp8rd->pixlut
637 );
638
639 return width * height;
640 }
641 /****************************************************************************************/
642
643 LONG write_pixels_8(struct RastPort *rp, UBYTE *array, ULONG modulo,
644 LONG xstart, LONG ystart, LONG xstop, LONG ystop,
645 HIDDT_PixelLUT *pixlut, struct GfxBase *GfxBase)
646 {
647
648 LONG pixwritten = 0;
649
650 struct wp8_render_data wp8rd;
651 struct Rectangle rr;
652
653 OOP_Object *gc;
654 HIDDT_DrawMode old_drmd;
655
656 struct TagItem gc_tags[] =
657 {
658 { aHidd_GC_DrawMode, vHidd_GC_DrawMode_Copy},
659 { TAG_DONE, 0}
660 };
661
662
663 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
664 return 0;
665
666 gc = GetDriverData(rp)->dd_GC;
667
668 OOP_GetAttr(gc, aHidd_GC_DrawMode, &old_drmd);
669 OOP_SetAttrs(gc, gc_tags);
670
671 wp8rd.modulo = modulo;
672 wp8rd.array = array;
673 wp8rd.pixlut = pixlut;
674
675 rr.MinX = xstart;
676 rr.MinY = ystart;
677 rr.MaxX = xstop;
678 rr.MaxY = ystop;
679
680 pixwritten = do_render_func(rp, NULL, &rr, wp8_render, &wp8rd, FALSE, GfxBase);
681
682 /* Reset to preserved drawmode */
683 gc_tags[0].ti_Data = old_drmd;
684 OOP_SetAttrs(gc, gc_tags);
685
686 RELEASE_DRIVERDATA(rp, GfxBase);
687
688 return pixwritten;
689
690 }
691
692 /****************************************************************************************/
693
694 /*
695 ** General functions for moving blocks of data to or from HIDDs, be it pixelarrays
696 ** or bitmaps. They use a callback-function to get data from amiga/put data to amiga
697 ** bitmaps/pixelarrays
698 */
699
700 /****************************************************************************************/
701
702 #if 0
703
704 void amiga2hidd_fast(APTR src_info, OOP_Object *hidd_gc, LONG x_src , LONG y_src,
705 struct BitMap *hidd_bm, LONG x_dest, LONG y_dest,
706 ULONG xsize, ULONG ysize, VOID (*fillbuf_hook)(),
707 struct GfxBase * GfxBase)
708 {
709
710
711 ULONG tocopy_w,
712 tocopy_h;
713
714 LONG pixels_left_to_process = xsize * ysize;
715
716 LONG current_x, current_y, next_x, next_y;
717 OOP_Object *bm_obj;
718
719 next_x = 0;
720 next_y = 0;
721
722 bm_obj = OBTAIN_HIDD_BM(hidd_bm);
723 if (NULL == bm_obj)
724 return;
725
726 LOCK_PIXBUF
727
728 while (pixels_left_to_process)
729 {
730
731 /* Get some more pixels from the HIDD */
732
733 current_x = next_x;
734 current_y = next_y;
735
736 if (NUMPIX < xsize)
737 {
738 /* buffer can't hold a single horizontal line, and must
739 divide each line into several copy-operations */
740 tocopy_w = xsize - current_x;
741 if (tocopy_w > NUMPIX)
742 {
743 /* Not quite finished with current horizontal pixel line */
744 tocopy_w = NUMPIX;
745 next_x += NUMPIX;
746 }
747 else
748 { /* Start at a new line */
749 next_x = 0;
750 next_y ++;
751 }
752 tocopy_h = 1;
753
754 }
755 else /* We can copy one or several whole horizontal lines at a time */
756 {
757 tocopy_h = MIN(NUMPIX / xsize, ysize - current_y);
758
759 tocopy_w = xsize;
760
761 next_x = 0;
762 next_y += tocopy_h;
763
764
765 }
766
767
768 /* Get data */
769 fillbuf_hook(src_info
770 , current_x + x_src
771 , current_y + y_src
772 , current_x + x_dest
773 , current_y + y_dest
774 , tocopy_w, tocopy_h
775 , PrivGBase(GfxBase)->pixel_buf
776 , bm_obj
777 , IS_HIDD_BM(hidd_bm) ? HIDD_BM_PIXTAB(hidd_bm) : NULL
778 , GfxBase
779 );
780
781 /* Put it to the HIDD */
782 D(bug("Putting box\n"));
783
784 HIDD_BM_PutImage(bm_obj
785 , hidd_gc
786 , (UBYTE*)PrivGBase(GfxBase)->pixel_buf
787 , tocopy_w * sizeof (HIDDT_Pixel)
788 , x_dest + current_x
789 , y_dest + current_y
790 , tocopy_w, tocopy_h
791 , vHidd_StdPixFmt_Native32
792 );
793
794 D(bug("Box put\n"));
795
796 pixels_left_to_process -= (tocopy_w * tocopy_h);
797
798
799 } /* while (pixels left to copy) */
800
801 ULOCK_PIXBUF
802
803 RELEASE_HIDD_BM(bm_obj, hidd_bm);
804
805 return;
806
807 }
808
809 #endif
810
811 /****************************************************************************************/
812
813 void hidd2buf_fast(struct BitMap *hidd_bm, LONG x_src , LONG y_src, APTR dest_info,
814 LONG x_dest, LONG y_dest, ULONG xsize, ULONG ysize, VOID (*putbuf_hook)(),
815 struct GfxBase * GfxBase)
816 {
817
818 ULONG tocopy_w, tocopy_h;
819
820 LONG pixels_left_to_process = xsize * ysize;
821 ULONG current_x, current_y, next_x, next_y;
822
823 #warning Src bitmap migh be user initialized so we should not use HIDD_BM_PIXTAB() below
824
825 OOP_Object *bm_obj;
826
827 next_x = 0;
828 next_y = 0;
829
830 bm_obj = OBTAIN_HIDD_BM(hidd_bm);
831 if (NULL == bm_obj)
832 return;
833
834 LOCK_PIXBUF
835
836 while (pixels_left_to_process)
837 {
838
839 current_x = next_x;
840 current_y = next_y;
841
842 if (NUMPIX < xsize)
843 {
844 /* buffer cant hold a single horizontal line, and must
845 divide each line into copies */
846 tocopy_w = xsize - current_x;
847 if (tocopy_w > NUMPIX)
848 {
849 /* Not quite finished with current horizontal pixel line */
850 tocopy_w = NUMPIX;
851 next_x += NUMPIX;
852 }
853 else
854 { /* Start at a new line */
855
856 next_x = 0;
857 next_y ++;
858 }
859 tocopy_h = 1;
860
861 }
862 else
863 {
864 tocopy_h = MIN(NUMPIX / xsize, ysize - current_y);
865 tocopy_w = xsize;
866
867 next_x = 0;
868 next_y += tocopy_h;
869
870 }
871
872
873 /* Get some more pixels from the HIDD */
874 HIDD_BM_GetImage(bm_obj
875 , (UBYTE *)PrivGBase(GfxBase)->pixel_buf
876 , tocopy_w
877 , x_src + current_x
878 , y_src + current_y
879 , tocopy_w, tocopy_h
880 , vHidd_StdPixFmt_Native32);
881
882
883 /* Write pixels to the destination */
884 putbuf_hook(dest_info
885 , current_x + x_src
886 , current_y + y_src
887 , current_x + x_dest
888 , current_y + y_dest
889 , tocopy_w, tocopy_h
890 , (HIDDT_Pixel *)PrivGBase(GfxBase)->pixel_buf
891 , bm_obj
892 , IS_HIDD_BM(hidd_bm) ? HIDD_BM_PIXTAB(hidd_bm) : NULL
893 );
894
895 pixels_left_to_process -= (tocopy_w * tocopy_h);
896
897 }
898
899 ULOCK_PIXBUF
900
901 RELEASE_HIDD_BM(bm_obj, hidd_bm);
902
903 return;
904
905 }
906
907 /****************************************************************************************/
908
909 UWORD hidd2cyber_pixfmt(HIDDT_StdPixFmt stdpf, struct GfxBase *GfxBase)
910 {
911 UWORD cpf = (UWORD)-1;
912
913 bug("hidd2cyber stdpf = %d [%d]\n", stdpf, vHidd_StdPixFmt_BGR032);
914
915 switch (stdpf)
916 {
917 case vHidd_StdPixFmt_RGB15:
918 cpf = PIXFMT_RGB15;
919 break;
920
921 case vHidd_StdPixFmt_RGB15_LE:
922 cpf = PIXFMT_RGB15PC;
923 break;
924
925 case vHidd_StdPixFmt_BGR15:
926 cpf = PIXFMT_BGR15;
927 break;
928
929 case vHidd_StdPixFmt_BGR15_LE:
930 cpf = PIXFMT_BGR15PC;
931 break;
932
933 case vHidd_StdPixFmt_RGB16:
934 cpf = PIXFMT_RGB16;
935 break;
936
937 case vHidd_StdPixFmt_RGB16_LE:
938 cpf = PIXFMT_RGB16PC;
939 break;
940
941 case vHidd_StdPixFmt_BGR16:
942 cpf = PIXFMT_BGR16;
943 break;
944
945 case vHidd_StdPixFmt_BGR16_LE:
946 cpf = PIXFMT_BGR16PC;
947 break;
948
949 case vHidd_StdPixFmt_RGB24:
950 cpf = PIXFMT_RGB24;
951 break;
952
953 case vHidd_StdPixFmt_BGR24:
954 cpf = PIXFMT_BGR24;
955 break;
956
957 case vHidd_StdPixFmt_0RGB32:
958 case vHidd_StdPixFmt_ARGB32:
959 cpf = PIXFMT_ARGB32;
960 break;
961
962 case vHidd_StdPixFmt_RGB032:
963 case vHidd_StdPixFmt_RGBA32:
964 cpf = PIXFMT_RGBA32;
965 break;
966
967 case vHidd_StdPixFmt_BGRA32:
968 case vHidd_StdPixFmt_BGR032:
969 cpf = PIXFMT_BGRA32;
970 break;
971
972 case vHidd_StdPixFmt_ABGR32:
973 case vHidd_StdPixFmt_0BGR32:
974 cpf = PIXFMT_ABGR32;
975 break;
976
977 case vHidd_StdPixFmt_LUT8:
978 cpf = PIXFMT_LUT8;
979 break;
980
981 default:
982 D(bug("UNKNOWN CYBERGRAPHICS PIXFMT IN cyber2hidd_pixfmt\n"));
983 break;
984
985 }
986
987 return cpf;
988
989 }
990
991 /****************************************************************************************/
992
993 HIDDT_StdPixFmt cyber2hidd_pixfmt(UWORD cpf, struct GfxBase *GfxBase)
994 {
995 HIDDT_StdPixFmt stdpf = vHidd_StdPixFmt_Unknown;
996
997 switch (cpf)
998 {
999 case PIXFMT_RGB15:
1000 stdpf = vHidd_StdPixFmt_RGB15;
1001 break;
1002
1003 case PIXFMT_RGB15PC:
1004 stdpf = vHidd_StdPixFmt_RGB15_LE;
1005 break;
1006
1007 case PIXFMT_BGR15:
1008 stdpf = vHidd_StdPixFmt_BGR15;
1009 break;
1010
1011 case PIXFMT_BGR15PC:
1012 stdpf = vHidd_StdPixFmt_BGR15_LE;
1013 break;
1014
1015 case PIXFMT_RGB16:
1016 stdpf = vHidd_StdPixFmt_RGB16;
1017 break;
1018
1019 case PIXFMT_RGB16PC:
1020 stdpf = vHidd_StdPixFmt_RGB16_LE;
1021 break;
1022
1023 case PIXFMT_BGR16:
1024 stdpf = vHidd_StdPixFmt_BGR16;
1025 break;
1026
1027 case PIXFMT_BGR16PC:
1028 stdpf = vHidd_StdPixFmt_BGR16_LE;
1029 break;
1030
1031 case PIXFMT_RGB24:
1032 stdpf = vHidd_StdPixFmt_RGB24;
1033 break;
1034
1035 case PIXFMT_BGR24:
1036 stdpf = vHidd_StdPixFmt_BGR24;
1037 break;
1038
1039 case PIXFMT_ARGB32:
1040 stdpf = vHidd_StdPixFmt_ARGB32;
1041 break;
1042
1043 case PIXFMT_RGBA32:
1044 stdpf = vHidd_StdPixFmt_RGBA32;
1045 break;
1046
1047 case PIXFMT_BGRA32:
1048 stdpf = vHidd_StdPixFmt_BGRA32;
1049 break;
1050
1051 case PIXFMT_ABGR32:
1052 stdpf = vHidd_StdPixFmt_ABGR32;
1053 break;
1054
1055 case PIXFMT_LUT8:
1056 stdpf = vHidd_StdPixFmt_LUT8;
1057 break;
1058
1059 default:
1060 D(bug("UNKNOWN CYBERGRAPHICS PIXFMT IN cyber2hidd_pixfmt\n"));
1061 break;
1062 }
1063
1064 return stdpf;
1065 }
1066
1067 /****************************************************************************************/
1068
1069 #define ENABLE_PROFILING 0
1070 #define USE_OLD_MoveRaster 0
1071
1072 #define rdtscll(val) \
1073 __asm__ __volatile__("rdtsc" : "=A" (val))
1074
1075 #if ENABLE_PROFILING && defined(__i386__)
1076
1077
1078 #define AROS_BEGIN_PROFILING(context) \
1079 { \
1080 unsigned long long _time1, _time2; \
1081 char *_text = #context; \
1082 rdtscll(_time1); \
1083 {
1084
1085 #define AROS_END_PROFILING \
1086 } \
1087 rdtscll(_time2); \
1088 kprintf("%s: Ticks count: %u\n", _text, (unsigned long)(_time2 - _time1)); \
1089 }
1090
1091 #else
1092
1093 #define AROS_BEGIN_PROFILING(context)
1094 #define AROS_END_PROFILING
1095
1096 #endif
1097
1098 BOOL MoveRaster (struct RastPort * rp, LONG dx, LONG dy, LONG x1, LONG y1,
1099 LONG x2, LONG y2, BOOL UpdateDamageList, struct GfxBase * GfxBase)
1100 {
1101 struct Layer *L = rp->Layer;
1102 struct Rectangle ScrollRect;
1103 struct Rectangle Rect;
1104
1105 if (0 == dx && 0 == dy)
1106 return TRUE;
1107
1108 if (!OBTAIN_DRIVERDATA(rp, GfxBase))
1109 return FALSE;
1110
1111 ScrollRect.MinX = x1;
1112 ScrollRect.MinY = y1;
1113 ScrollRect.MaxX = x2;
1114 ScrollRect.MaxY = y2;
1115
1116 if (!L)
1117 {
1118 Rect = ScrollRect;
1119 TranslateRect(&Rect, -dx, -dy);
1120 if (_AndRectRect(&ScrollRect, &Rect, &Rect))
1121 {
1122 BltBitMap(rp->BitMap,
1123 Rect.MinX + dx,
1124 Rect.MinY + dy,
1125 rp->BitMap,
1126 Rect.MinX,
1127 Rect.MinY,
1128 Rect.MaxX - Rect.MinX + 1,
1129 Rect.MaxY - Rect.MinY + 1,
1130 0xc0, /* copy */
1131 0xff,
1132 NULL );
1133 }
1134 }
1135 else
1136 {
1137 struct ClipRect *SrcCR;
1138
1139 LockLayerRom(L);
1140
1141 if (L->Flags & LAYERSIMPLE && UpdateDamageList)
1142 {
1143 /* Scroll the old damagelist within the scroll area */
1144 ScrollRegion(L->DamageList, &ScrollRect, -dx, -dy);
1145 }
1146
1147 /* The scrolling area is relative to the Layer, so make it relative to the screen */
1148 TranslateRect(&ScrollRect, MinX(L), MinY(L));
1149
1150 /* The damage list will be formed by the now hidden layer's parts that will become visible due
1151 to the scrolling procedure, thus we procede this way:
1152
1153 1) Calculate the invisible region out of the visible one, subtracting it from the
1154 scrolling area
1155
1156 2) Scroll the invisible region by (-dx, -dy) and then subtract from it the not scrolled equivalent
1157
1158 The regions that we obtain after (2) is the new damage list
1159 */
1160
1161 if (L->Flags & LAYERSIMPLE && UpdateDamageList)
1162 {
1163 Rect = ScrollRect;
1164 TranslateRect(&Rect, dx, dy);
1165
1166 if (_AndRectRect(&ScrollRect, &Rect, &Rect))
1167 {
1168 struct Region *Damage;
1169
1170 Damage = NewRectRegion(Rect.MinX, Rect.MinY, Rect.MaxX, Rect.MaxY);
1171 if (Damage)
1172 {
1173 if
1174 (
1175 ClearRegionRegion(L->VisibleRegion, Damage)
1176 &&
1177 Damage->RegionRectangle
1178 )
1179 {
1180 struct Region Tmp;
1181 /*
1182 We play sort of dirty here, by making assumptions about the internals of the
1183 Region structure and the region handling functions, but we are allowed to do that,
1184 aren't we? ;-)
1185 */
1186
1187 Tmp = *Damage;
1188
1189 TranslateRect(Bounds(Damage), -dx, -dy);
1190
1191 if
1192 (
1193 ClearRegionRegion(&Tmp, Damage)
1194 &&
1195 Damage->RegionRectangle
1196 )
1197 {
1198 /* Join the new damage list with the old one */
1199 TranslateRect(Bounds(Damage), -MinX(L), -MinY(L));
1200 OrRegionRegion(Damage, L->DamageList);
1201
1202 L->Flags |= LAYERREFRESH;
1203 }
1204 }
1205
1206 DisposeRegion(Damage);
1207 }
1208 }
1209 }
1210
1211 AROS_BEGIN_PROFILING(SortLayerCR)
1212
1213 #define LayersBase (struct LayersBase *)(GfxBase->gb_LayersBase)
1214 SortLayerCR(L, dx, dy);
1215 #undef LayersBase
1216
1217 AROS_END_PROFILING
1218
1219 AROS_BEGIN_PROFILING(Blitting loop)
1220
1221 #if USE_OLDMoveRaster
1222
1223 {
1224 struct ClipRect *LastHiddenCR;
1225
1226 for (LastHiddenCR = NULL, SrcCR = L->ClipRect; SrcCR; SrcCR = SrcCR->Next)
1227 {
1228 SrcCR->_p1 = LastHiddenCR;
1229
1230 if (SrcCR->lobs)
1231 LastHiddenCR = SrcCR;
1232 }
1233 }
1234
1235
1236 for (SrcCR = L->ClipRect; SrcCR; SrcCR = SrcCR->Next)
1237 {
1238 int cando = 0;
1239
1240 if (SrcCR->lobs && (L->Flags & LAYERSIMPLE))
1241 {
1242 continue;
1243 }
1244
1245 if (_AndRectRect(&ScrollRect, Bounds(SrcCR), &Rect))
1246 {
1247 TranslateRect(&Rect, -dx, -dy);
1248
1249 if (_AndRectRect(&ScrollRect, &Rect, &Rect))
1250 cando = 1;
1251 }
1252
1253 if (cando)
1254 {
1255 /* Rect.Min(X|Y) are the coordinates to wich the rectangle has to be moved
1256 Rect.Max(X|Y) - Rect.Max(X|Y) - 1 are the dimensions of this rectangle */
1257 if (!SrcCR->_p1 && !SrcCR->lobs)
1258 {
1259 /* there are no hidden/obscured rectangles this recrtangle has to deal with*/
1260 BltBitMap
1261 (
1262 rp->BitMap,
1263 Rect.MinX + dx,
1264 Rect.MinY + dy,
1265 rp->BitMap,
1266 Rect.MinX,
1267 Rect.MinY,
1268 Rect.MaxX - Rect.MinX + 1,
1269 Rect.MaxY - Rect.MinY + 1,
1270 0xc0, /* copy */
1271 0xff,
1272 NULL
1273 );
1274 }
1275 else
1276 {
1277 struct BitMap *srcbm;
1278 struct RegionRectangle *rr;
1279 struct Region *RectRegion;
1280 struct Rectangle Tmp;
1281 struct ClipRect *HiddCR;
1282 WORD corrsrcx, corrsrcy;
1283 BOOL dosrcsrc;
1284
1285 RectRegion = NewRectRegion(Rect.MinX, Rect.MinY, Rect.MaxX, Rect.MaxY);
1286 if (!RectRegion)
1287 goto failexit;
1288
1289 if (SrcCR->lobs)
1290 {
1291 if (L->Flags & LAYERSUPER)
1292 {
1293 corrsrcx = - MinX(L) - L->Scroll_X;
1294 corrsrcy = - MinY(L) - L->Scroll_Y;
1295 }
1296 else
1297 {
1298 corrsrcx = - MinX(SrcCR) + ALIGN_OFFSET(MinX(SrcCR));
1299 corrsrcy = - MinY(SrcCR);
1300 }
1301 srcbm = SrcCR->BitMap;
1302 }
1303 else
1304 {
1305 corrsrcx = 0;
1306 corrsrcy = 0;
1307 srcbm = rp->BitMap;
1308 }
1309
1310 for (HiddCR = SrcCR->_p1; HiddCR; HiddCR = HiddCR->_p1)
1311 {
1312 if (_AndRectRect(Bounds(RectRegion), Bounds(HiddCR), &Tmp))
1313 {
1314 if (!(L->Flags & LAYERSIMPLE))
1315 {
1316 WORD corrdstx, corrdsty;
1317
1318 if (L->Flags & LAYERSUPER)
1319 {
1320 corrdstx = - MinX(L) - L->Scroll_X;
1321 corrdsty = - MinY(L) - L->Scroll_Y;
1322 }
1323 else
1324 {
1325 /* Smart layer */
1326 corrdstx = - MinX(HiddCR) + ALIGN_OFFSET(MinX(HiddCR));
1327 corrdsty = - MinY(HiddCR);
1328 }
1329
1330
1331 BltBitMap
1332 (
1333 srcbm,
1334 Tmp.MinX + corrsrcx + dx,
1335 Tmp.MinY + corrsrcy + dy,
1336 HiddCR->BitMap,
1337 Tmp.MinX + corrdstx,
1338 Tmp.MinY + corrdsty,
1339 Tmp.MaxX - Tmp.MinX + 1,
1340 Tmp.MaxY - Tmp.MinY + 1,
1341 0xc0, /* copy */
1342 0xff,
1343 NULL
1344 );
1345 }
1346
1347 if (!ClearRectRegion(RectRegion, &Tmp))
1348 {
1349 DisposeRegion(RectRegion);
1350 goto failexit;
1351 }
1352 }
1353 }
1354
1355 if ((dosrcsrc = _AndRectRect(Bounds(SrcCR), &Rect, &Tmp)))
1356 {
1357 if (!ClearRectRegion(RectRegion, &Tmp))
1358 {
1359 DisposeRegion(RectRegion);
1360 goto failexit;
1361 }
1362 }
1363
1364 for (rr = RectRegion->RegionRectangle; rr; rr = rr->Next)
1365 {
1366 BltBitMap
1367 (
1368 srcbm,
1369 MinX(rr) + MinX(RectRegion) + corrsrcx + dx,
1370 MinY(rr) + MinY(RectRegion) + corrsrcy + dy,
1371 rp->BitMap,
1372 MinX(rr) + MinX(RectRegion),
1373 MinY(rr) + MinY(RectRegion),
1374 Width(rr),
1375 Height(rr),
1376 0xc0, /* copy */
1377 0xff,
1378 NULL
1379 );
1380 }
1381
1382 if (dosrcsrc)
1383 {
1384 BltBitMap
1385 (
1386 srcbm,
1387 Tmp.MinX + corrsrcx + dx,
1388 Tmp.MinY + corrsrcy + dy,
1389 srcbm,
1390 Tmp.MinX + corrsrcx,
1391 Tmp.MinY + corrsrcy,
1392 Tmp.MaxX - Tmp.MinX + 1,
1393 Tmp.MaxY - Tmp.MinY + 1,
1394 0xc0, /* copy */
1395 0xff,
1396 NULL
1397 );
1398
1399 }
1400
1401 DisposeRegion(RectRegion);
1402 }
1403 }
1404 }
1405
1406 #else
1407
1408 for (SrcCR = L->ClipRect; SrcCR; SrcCR = SrcCR->Next)
1409 {
1410 if (_AndRectRect(&ScrollRect, Bounds(SrcCR), &Rect))
1411 {
1412 TranslateRect(&Rect, -dx, -dy);
1413
1414 if (_AndRectRect(&ScrollRect, &Rect, &Rect))
1415 {
1416 struct BitMap *srcbm;
1417 struct ClipRect *DstCR;
1418 LONG corrsrcx, corrsrcy;
1419 ULONG area;
1420
1421 if (SrcCR->lobs)
1422 {
1423 if (L->Flags & LAYERSIMPLE) continue;
1424
1425 if (L->Flags & LAYERSUPER)
1426 {
1427 corrsrcx = - MinX(L) - L->Scroll_X;
1428 corrsrcy = - MinY(L) - L->Scroll_Y;
1429 }
1430 else
1431 {
1432 corrsrcx = - MinX(SrcCR) + ALIGN_OFFSET(MinX(SrcCR));
1433 corrsrcy = - MinY(SrcCR);
1434 }
1435 srcbm = SrcCR->BitMap;
1436 }
1437 else
1438 {
1439 corrsrcx = 0;
1440 corrsrcy = 0;
1441 srcbm = rp->BitMap;
1442 }
1443
1444 area = (ULONG)(Rect.MaxX - Rect.MinX + 1) * (ULONG)(Rect.MaxY - Rect.MinY + 1);
1445
1446 for (DstCR = L->ClipRect ; area && DstCR; DstCR = DstCR->Next)
1447 {
1448 struct Rectangle Rect2;
1449
1450 if (_AndRectRect(Bounds(DstCR), &Rect, &Rect2))
1451 {
1452 struct BitMap *dstbm;
1453 LONG corrdstx, corrdsty;
1454
1455 area -= (ULONG)(Rect2.MaxX - Rect2.MinX + 1) * (ULONG)(Rect2.MaxY - Rect2.MinY + 1);
1456
1457 if (DstCR->lobs)
1458 {
1459 if (L->Flags & LAYERSIMPLE) continue;
1460
1461 if (L->Flags & LAYERSUPER)
1462 {
1463 corrdstx = - MinX(L) - L->Scroll_X;
1464 corrdsty = - MinY(L) - L->Scroll_Y;
1465 }
1466 else
1467 {
1468 corrdstx = - MinX(DstCR) + ALIGN_OFFSET(MinX(DstCR));
1469 corrdsty = - MinY(DstCR);
1470 }
1471 dstbm = DstCR->BitMap;
1472 }
1473 else
1474 {
1475 corrdstx = 0;
1476 corrdsty = 0;
1477 dstbm = rp->BitMap;
1478 }
1479
1480 BltBitMap
1481 (
1482 srcbm,
1483 Rect2.MinX + corrsrcx + dx,
1484 Rect2.MinY + corrsrcy + dy,
1485 dstbm,
1486 Rect2.MinX + corrdstx,
1487 Rect2.MinY + corrdsty,
1488 Rect2.MaxX - Rect2.MinX + 1,
1489 Rect2.MaxY - Rect2.MinY + 1,
1490 0xC0,
1491 0xFF,
1492 NULL
1493 );
1494 }
1495 }
1496 }
1497 }
1498 }
1499 #endif
1500 AROS_END_PROFILING
1501
1502 UnlockLayerRom(L);
1503 }
1504
1505 RELEASE_DRIVERDATA(rp, GfxBase);
1506
1507 return TRUE;
1508 }
1509
1510 /****************************************************************************************/
1511
1512 BOOL GetRPClipRectangleForLayer(struct RastPort *rp, struct Layer *lay,
1513 struct Rectangle *r, struct GfxBase *GfxBase)
1514 {
1515 (void)GfxBase;
1516
1517 if (RP_DRIVERDATA(rp)->dd_ClipRectangleFlags & RPCRF_VALID)
1518 {
1519 *r = RP_DRIVERDATA(rp)->dd_ClipRectangle;
1520
1521 if (RP_DRIVERDATA(rp)->dd_ClipRectangleFlags & RPCRF_RELRIGHT)
1522 {
1523 r->MaxX += (lay->bounds.MaxX - lay->bounds.MinX + 1) - 1;
1524 }
1525
1526 if (RP_DRIVERDATA(rp)->dd_ClipRectangleFlags & RPCRF_RELBOTTOM)
1527 {
1528 r->MaxY += (lay->bounds.MaxY - lay->bounds.MinY + 1) - 1;
1529 }
1530
1531 r->MinX += lay->bounds.MinX;
1532 r->MinY += lay->bounds.MinY;
1533 r->MaxX += lay->bounds.MinX;
1534 r->MaxY += lay->bounds.MinY;
1535
1536 return TRUE;
1537 }
1538
1539 return FALSE;
1540 }
1541
1542 /****************************************************************************************/
1543
1544 BOOL GetRPClipRectangleForBitMap(struct RastPort *rp, struct BitMap *bm,
1545 struct Rectangle *r, struct GfxBase *GfxBase)
1546 {
1547 if (RP_DRIVERDATA(rp)->dd_ClipRectangleFlags & RPCRF_VALID)
1548 {
1549
1550 *r = RP_DRIVERDATA(rp)->dd_ClipRectangle;
1551
1552 if (RP_DRIVERDATA(rp)->dd_ClipRectangleFlags & RPCRF_RELRIGHT)
1553 {
1554 LONG width = GetBitMapAttr(bm, BMA_WIDTH);
1555
1556 r->MaxX += width - 1;
1557 }
1558
1559 if (RP_DRIVERDATA(rp)->dd_ClipRectangleFlags & RPCRF_RELBOTTOM)
1560 {
1561 LONG height = GetBitMapAttr(bm, BMA_HEIGHT);
1562
1563 r->MaxY += height - 1;
1564 }
1565
1566 return TRUE;
1567 }
1568
1569 return FALSE;
1570 }
1571
1572 /****************************************************************************************/
Mirror of AROS' svn.