2 Copyright © 2011-2013, The AROS Development Team.
6 #include <aros/debug.h>
8 #include <intuition/imageclass.h>
9 #include <graphics/rpattr.h>
10 #include <libraries/cybergraphics.h>
11 #include <proto/arossupport.h>
12 #include <proto/graphics.h>
13 #include <proto/cybergraphics.h>
14 #include <proto/layers.h>
15 #include <proto/exec.h>
17 #include <hidd/graphics.h>
21 #include "drawfuncs.h"
24 #define GET_A(rgb) ((rgb >> 24) & 0xff)
25 #define GET_R(rgb) ((rgb >> 16) & 0xff)
26 #define GET_G(rgb) ((rgb >> 8) & 0xff)
27 #define GET_B(rgb) (rgb & 0xff)
28 #define SET_ARGB(a, r, g, b) a << 24 | r << 16 | g << 8 | b
30 #define GET_A(rgb) (rgb & 0xff)
31 #define GET_R(rgb) ((rgb >> 8) & 0xff)
32 #define GET_G(rgb) ((rgb >> 16) & 0xff)
33 #define GET_B(rgb) ((rgb >> 24) & 0xff)
34 #define SET_ARGB(a, r, g, b) b << 24 | g << 16 | r << 8 | a
37 /* This function provides a number of ways to blit a NewImage onto RastPort. Please take great care when modifying it.
39 * The number of combinations of arguments is quite high. Please take time to understand it.
42 * ni - a NewImage that is to be blitted
43 * subimageCol, subimageRow - define the initial read offset in source image based on assumption that image contains
44 * a number of subimages drawn in rows or columns
45 * xSrc, ySrc - define additional read offset in the source image subimage
46 * destRP - destination RastPort to blit the image to
47 * xDest, yDest - coordinates on the destination RastPort to where the imatge will be blitted
48 * widthSrc, heightSrc - width/height of region to be read from, if -1 then use the width/height of subimage
49 * widthDest, heightDest - width/height of blit on destination RastPort, if -1 then use widthSrc/heightSrc
52 static void BltScaleNewImageSubImageRastPort(struct NewImage
* ni
, ULONG subimageCol
, ULONG subimageRow
,
53 LONG xSrc
, LONG ySrc
, struct RastPort
* destRP
, LONG xDest
, LONG yDest
,
54 LONG widthSrc
, LONG heightSrc
, LONG widthDest
, LONG heightDest
)
56 ULONG subimagewidth
= ni
->w
/ ni
->subimagescols
;
57 ULONG subimageheight
= ni
->h
/ ni
->subimagesrows
;
59 if (subimageCol
>= ni
->subimagescols
) return;
60 if (subimageRow
>= ni
->subimagesrows
) return;
62 /* If source size not provided, use subimage size */
63 if (widthSrc
< 0) widthSrc
= (LONG
)subimagewidth
;
64 if (heightSrc
< 0) heightSrc
= (LONG
)subimageheight
;
66 /* If destination size not provided, use source */
67 if (widthDest
< 0) widthDest
= widthSrc
;
68 if (heightDest
< 0) heightDest
= heightSrc
;
70 /* If source and destination sizes do not match, scale */
71 if ((widthSrc
!= widthDest
) || (heightSrc
!= heightDest
))
73 /* FIXME: The scaled blitting needs similar optimized code paths as non-scaled */
74 ULONG
* srcptr
= (ni
->data
) + (((subimageheight
* subimageRow
) + ySrc
) * ni
->w
) +
75 ((subimagewidth
* subimageCol
) + xSrc
); /* Go to (0,0) of source rect */
77 ULONG
* scaleddata
= ScaleBuffer(srcptr
, ni
->w
, widthSrc
, heightSrc
, widthDest
, heightDest
);
79 D(bug("[Decoration] SCALED %d,%d -> %d,%d!\n", widthSrc
, heightSrc
, widthDest
, heightDest
));
81 WritePixelArrayAlpha(scaleddata
, 0, 0, widthDest
* 4, destRP
, xDest
, yDest
, widthDest
, heightDest
, 0xffffffff);
85 else /* ((widthSrc != widthDest) || (heightSrc != heightDest)) */
87 /* Detect if image can be drawn using blitting instead of alpha draw */
88 if ((!ni
->subimageinbm
) || (!(ni
->subimageinbm
[subimageCol
+ (subimageRow
* ni
->subimagescols
)])))
90 WritePixelArrayAlpha(ni
->data
, (subimagewidth
* subimageCol
) + xSrc
,
91 (subimageheight
* subimageRow
) + ySrc
, ni
->w
* 4, destRP
,
92 xDest
, yDest
, widthSrc
, heightSrc
, 0xffffffff);
97 if (ni
->bitmap
!= NULL
)
101 BltMaskBitMapRastPort(ni
->bitmap
, (subimagewidth
* subimageCol
) + xSrc
,
102 (subimageheight
* subimageRow
) + ySrc
, destRP
, xDest
, yDest
,
103 widthSrc
, heightSrc
, 0xe0, (PLANEPTR
) ni
->mask
);
107 BltBitMapRastPort(ni
->bitmap
, (subimagewidth
* subimageCol
) + xSrc
,
108 (subimageheight
* subimageRow
) + ySrc
, destRP
, xDest
, yDest
,
109 widthSrc
, heightSrc
, 0xc0);
114 if (ni
->bitmap2
!= NULL
)
116 BltBitMapRastPort(ni
->bitmap2
, (subimagewidth
* subimageCol
) + xSrc
,
117 (subimageheight
* subimageRow
) + ySrc
, destRP
, xDest
, yDest
,
118 widthSrc
, heightSrc
, 0xc0);
124 /* HELPER WRAPPERS */
125 static inline void BltNewImageSubImageRastPort(struct NewImage
* ni
, ULONG subimageCol
, ULONG subimageRow
,
126 LONG xSrc
, LONG ySrc
, struct RastPort
* destRP
, LONG xDest
, LONG yDest
, LONG widthSrc
, LONG heightSrc
)
128 BltScaleNewImageSubImageRastPort(ni
, subimageCol
, subimageRow
, xSrc
, ySrc
, destRP
,
129 xDest
, yDest
, widthSrc
, heightSrc
, -1, -1);
132 static inline void BltNewImageSubImageRastPortSimple(struct NewImage
* ni
, ULONG subimageCol
, ULONG subimageRow
,
133 struct RastPort
* destRP
, LONG xDest
, LONG yDest
)
135 BltNewImageSubImageRastPort(ni
, subimageCol
, subimageRow
, 0, 0, destRP
,
136 xDest
, yDest
, -1, -1);
139 static inline void BltScaleNewImageSubImageRastPortSimple(struct NewImage
* ni
, ULONG subimageCol
, ULONG subimageRow
,
140 struct RastPort
* destRP
, LONG xDest
, LONG yDest
, LONG widthDest
, LONG heightDest
)
142 BltScaleNewImageSubImageRastPort(ni
, subimageCol
, subimageRow
, 0, 0, destRP
,
143 xDest
, yDest
, -1, -1, widthDest
, heightDest
);
145 /* HELPER WRAPPERS */
147 static void DrawTileToImage(struct NewImage
*src
, struct NewImage
*dest
, UWORD _sx
, UWORD _sy
, UWORD _sw
, UWORD _sh
, UWORD _dx
, UWORD _dy
, UWORD _dw
, UWORD _dh
)
151 LONG dh
, height
, dw
, width
;
153 if (src
== NULL
) return;
154 if (dest
== NULL
) return;
162 if ((height
-dh
)<0) dh
= height
;
169 if ((width
-dw
)<0) dw
= width
;
171 DrawPartToImage(src
, dest
, _sx
, _sy
, dw
, dh
, dx
, dy
);
178 static void TileImageToImageMenuBar(struct NewImage
*src
, struct TileInfo
* srcti
, struct NewImage
*dest
)
182 if (dest
== NULL
) return;
183 if (src
== NULL
) return;
184 if (srcti
== NULL
) return;
189 if ((srcti
->TileTop
+ srcti
->TileBottom
) > dest
->h
) return;
190 if (srcti
->TileRight
> dest
->w
) return;
192 DrawTileToImage(src
, dest
, srcti
->TileLeft
, y
, src
->w
- srcti
->TileLeft
- srcti
->TileRight
, srcti
->TileTop
, 0, 0, dest
->w
- srcti
->TileRight
, srcti
->TileTop
);
193 DrawTileToImage(src
, dest
, srcti
->TileLeft
, y
+ h
- srcti
->TileBottom
, src
->w
- srcti
->TileLeft
- srcti
->TileRight
, srcti
->TileBottom
, 0, dest
->h
- srcti
->TileBottom
, dest
->w
- srcti
->TileRight
, srcti
->TileBottom
);
194 DrawTileToImage(src
, dest
, srcti
->TileLeft
, y
+ srcti
->TileTop
, src
->w
- srcti
->TileLeft
- srcti
->TileRight
, h
- srcti
->TileBottom
- srcti
->TileTop
, 0, srcti
->TileTop
+ 0, dest
->w
- srcti
->TileRight
, dest
->h
- srcti
->TileTop
- srcti
->TileBottom
- 0);
197 DrawTileToImage(src
, dest
, src
->w
- srcti
->TileRight
, y
, srcti
->TileRight
, srcti
->TileTop
, dest
->w
- srcti
->TileRight
, 0, srcti
->TileRight
, srcti
->TileTop
);
198 DrawTileToImage(src
, dest
, src
->w
- srcti
->TileRight
, y
+ h
- srcti
->TileBottom
, srcti
->TileRight
, srcti
->TileBottom
, dest
->w
- srcti
->TileRight
, dest
->h
- srcti
->TileBottom
, srcti
->TileRight
, srcti
->TileBottom
);
199 DrawTileToImage(src
, dest
, src
->w
- srcti
->TileRight
, y
+ srcti
->TileTop
, srcti
->TileRight
, h
- srcti
->TileBottom
- srcti
->TileTop
, dest
->w
- srcti
->TileRight
, srcti
->TileTop
+ 0, srcti
->TileRight
, dest
->h
- srcti
->TileTop
- srcti
->TileBottom
- 0);
203 static void TileImageToImage(struct NewImage
*src
, struct TileInfo
* srcti
, struct NewImage
*dest
)
207 if (dest
== NULL
) return;
208 if (src
== NULL
) return;
209 if (srcti
== NULL
) return;
214 if ((srcti
->TileTop
+ srcti
->TileBottom
) > dest
->h
) return;
215 if ((srcti
->TileLeft
+ srcti
->TileRight
) > dest
->w
) return;
217 DrawTileToImage(src
, dest
, 0, y
, srcti
->TileLeft
, srcti
->TileTop
, 0 , 0, srcti
->TileLeft
, srcti
->TileTop
);
218 DrawTileToImage(src
, dest
, 0, y
+ h
- srcti
->TileBottom
, srcti
->TileLeft
, srcti
->TileBottom
, 0 , dest
->h
- srcti
->TileBottom
, srcti
->TileLeft
, srcti
->TileBottom
);
219 DrawTileToImage(src
, dest
, src
->w
- srcti
->TileRight
, y
, srcti
->TileRight
, srcti
->TileTop
, dest
->w
- srcti
->TileRight
, 0, srcti
->TileRight
, srcti
->TileTop
);
220 DrawTileToImage(src
, dest
, src
->w
- srcti
->TileRight
, y
+ h
- srcti
->TileBottom
, srcti
->TileRight
, srcti
->TileBottom
, dest
->w
- srcti
->TileRight
, dest
->h
- srcti
->TileBottom
, srcti
->TileRight
, srcti
->TileBottom
);
222 DrawTileToImage(src
, dest
, srcti
->TileLeft
, y
, src
->w
- srcti
->TileLeft
- srcti
->TileRight
, srcti
->TileTop
, srcti
->TileLeft
, 0, dest
->w
- srcti
->TileLeft
- srcti
->TileRight
, srcti
->TileTop
);
223 DrawTileToImage(src
, dest
, srcti
->TileLeft
, y
+ h
- srcti
->TileBottom
, src
->w
- srcti
->TileLeft
- srcti
->TileRight
, srcti
->TileBottom
, srcti
->TileLeft
, dest
->h
- srcti
->TileBottom
, dest
->w
- srcti
->TileLeft
- srcti
->TileRight
, srcti
->TileBottom
);
224 DrawTileToImage(src
, dest
, 0, y
+ srcti
->TileTop
, srcti
->TileLeft
, h
- srcti
->TileBottom
- srcti
->TileTop
, 0 , srcti
->TileTop
+ 0, srcti
->TileLeft
, dest
->h
- srcti
->TileTop
- srcti
->TileBottom
- 0);
225 DrawTileToImage(src
, dest
, src
->w
- srcti
->TileRight
, y
+ srcti
->TileTop
, srcti
->TileRight
, h
- srcti
->TileBottom
- srcti
->TileTop
, dest
->w
- srcti
->TileRight
, srcti
->TileTop
+ 0, srcti
->TileRight
, dest
->h
- srcti
->TileTop
- srcti
->TileBottom
- 0);
226 DrawTileToImage(src
, dest
, srcti
->TileLeft
, y
+ srcti
->TileTop
, src
->w
- srcti
->TileLeft
- srcti
->TileRight
, h
- srcti
->TileBottom
- srcti
->TileTop
, srcti
->TileLeft
, srcti
->TileTop
+ 0, dest
->w
- srcti
->TileLeft
- srcti
->TileRight
, dest
->h
- srcti
->TileTop
- srcti
->TileBottom
- 0);
229 static void MixImage(struct NewImage
*dst
, struct NewImage
*src
, struct TileInfo
*srcti
, UWORD ratio
, UWORD w
, UWORD h
, UWORD dx
, UWORD dy
)
234 UBYTE as
, rs
, gs
, bs
, rd
, gd
, bd
;
238 if (src
== NULL
) return;
239 if (dst
== NULL
) return;
244 if (srcti
) tiled
= TRUE
;
246 for (y
= 0; y
< h
; y
++)
248 for (x
= 0; x
< w
; x
++)
250 rgba
= s
[x
+y
*src
->w
];
255 rgb
= d
[x
+dx
+ (y
+dy
) * dst
->w
];
261 r
= ((rs
* ratio
) >> 8) + ((rd
* (255 - ratio
)) >> 8);
262 g
= ((gs
* ratio
) >> 8) + ((gd
* (255 - ratio
)) >> 8);
263 b
= ((bs
* ratio
) >> 8) + ((bd
* (255 - ratio
)) >> 8);
266 r
= ((r
* as
) >> 8) + ((rd
* (255 - as
)) >> 8);
267 g
= ((g
* as
) >> 8) + ((gd
* (255 - as
)) >> 8);
268 b
= ((b
* as
) >> 8) + ((bd
* (255 - as
)) >> 8);
275 d
[x
+dx
+ (y
+dy
) * dst
->w
] = SET_ARGB(as
, r
, g
, b
);
281 static void BlurSourceAndMixTexture(struct NewImage
*pic
, struct NewImage
*texture
, struct TileInfo
* textureti
, UWORD ratio
)
283 int x
, y
, ytw
, t1
, t2
, b1
, b2
, l1
, l2
, r1
, r2
;
284 UWORD red
, green
, blue
, alpha
= 0, rs
, gs
, bs
, as
;
286 int width
, w
, height
, ah
, aw
, xpos
, ypos
;
290 if (pic
== NULL
) return;
291 if (pic
->data
== NULL
) return;
294 if (textureti
) tiled
= TRUE
;
302 for (y
= 0; y
< th
; y
++)
308 if (y
== 0) t1
= t2
= 0;
309 else if (y
== 1) t2
= t1
;
311 if (y
== (th
-1)) b1
= b2
= 0;
312 else if (y
== (th
-2)) b2
= b1
;
316 for (x
= 0; x
< tw
; x
++)
323 if (x
== 0) l1
= r1
= 0;
324 else if (x
== 1) l2
= l1
;
326 if (x
== (tw
-1)) r1
= r2
= 0;
327 else if (x
== (tw
-2)) r2
= r1
;
339 rgb
= raw
[x
+ytw
-l1
-t1
];
354 rgb
= raw
[x
+ytw
-t1
+r1
];
379 rgb
= raw
[x
+ytw
+b1
-l1
];
389 rgb
= raw
[x
+ytw
+b1
+r1
];
407 as
= 255 - GET_A(texture
->data
[x
+ y
* texture
->w
]);
412 red
= ((rs
* as
) >> 8) + ((red
* (255 - as
)) >> 8);
413 green
= ((gs
* as
) >> 8) + ((green
* (255 - as
)) >> 8);
414 blue
= ((bs
* as
) >> 8) + ((blue
* (255 - as
)) >> 8);
416 raw
[x
+ytw
] = SET_ARGB(as
, red
, green
, blue
);
421 raw
[x
+ytw
] = SET_ARGB(alpha
, red
, green
, blue
);
434 if (ah
> height
) ah
= height
;
441 MixImage(pic
, texture
, textureti
, 255 - (2.55 * ratio
), aw
, ah
, xpos
, ypos
);
452 static void RenderBackgroundTiled(struct NewImage
*pic
, struct NewImage
*texture
, struct TileInfo
*textureti
,
453 UWORD ratio
, VOID (*TileImageToImageFunc
)(struct NewImage
*src
, struct TileInfo
* srcti
, struct NewImage
*dest
))
459 ni
= NewImageContainer(pic
->w
, pic
->h
);
464 TileImageToImageFunc(texture
, textureti
, ni
);
465 BlurSourceAndMixTexture(pic
, ni
, textureti
, ratio
);
467 else BlurSourceAndMixTexture(pic
, texture
, textureti
, ratio
);
469 DisposeImageContainer(ni
);
471 else BlurSourceAndMixTexture(pic
, texture
, textureti
, ratio
);
473 else BlurSourceAndMixTexture(pic
, NULL
, NULL
, ratio
);
476 static void DrawMapTileToRP(struct NewImage
*src
, struct RastPort
*rp
, UWORD _sx
, UWORD _sy
, UWORD _sw
, UWORD _sh
, UWORD _dx
, UWORD _dy
, UWORD _dw
, UWORD _dh
)
480 LONG dh
, height
, dw
, width
;
482 if (src
== NULL
) return;
483 if (rp
== NULL
) return;
489 if (!src
->ok
) return;
493 if ((height
-dh
)<0) dh
= height
;
500 if ((width
-dw
)<0) dw
= width
;
505 BltMaskBitMapRastPort(src
->bitmap
, _sx
, _sy
, rp
, dx
, dy
, dw
, dh
, 0xe0, (PLANEPTR
) src
->mask
);
507 else BltBitMapRastPort(src
->bitmap
, _sx
, _sy
, rp
, dx
, dy
, dw
, dh
, 0xc0);
515 /******************************************************************************/
516 /******************************************************************************/
517 /******************************************************************************/
518 /******************************************************************************/
519 /******************************************************************************/
521 void DrawPartImageToRP(struct RastPort
*rp
, struct NewImage
*ni
, UWORD x
, UWORD y
, UWORD sx
, UWORD sy
, UWORD sw
, UWORD sh
)
525 if (ni
->bitmap
== NULL
)
527 WritePixelArray(ni
->data
, sx
, sy
, ni
->w
*4, rp
, x
, y
, sw
, sh
, RECTFMT_ARGB
);
531 BltBitMapRastPort(ni
->bitmap
, sx
, sy
, rp
, x
, y
, sw
, sh
, 0xc0);
536 void DrawPartToImage(struct NewImage
*src
, struct NewImage
*dest
, UWORD sx
, UWORD sy
, UWORD sw
, UWORD sh
, UWORD dx
, UWORD dy
)
540 for (y
= 0; y
< sh
; y
++)
542 for (x
= 0; x
< sw
; x
++)
544 dest
->data
[dx
+ x
+ (dy
+ y
) * dest
->w
] = src
->data
[sx
+ x
+ (sy
+ y
) * src
->w
];
549 void RenderMenuBackground(struct NewImage
*pic
, struct NewImage
*texture
, struct TileInfo
*textureti
, UWORD ratio
)
553 if (textureti
) RenderBackgroundTiled(pic
, texture
, textureti
, ratio
, TileImageToImage
);
554 else BlurSourceAndMixTexture(pic
, texture
, textureti
, ratio
);
556 else BlurSourceAndMixTexture(pic
, NULL
, NULL
, ratio
);
559 void RenderMenuBarBackground(struct NewImage
*pic
, struct NewImage
*texture
, struct TileInfo
*textureti
, UWORD ratio
)
561 if (texture
&& textureti
)
564 /* Fill the image with the center tile */
565 DrawTileToImage(texture
, pic
,
566 textureti
->TileLeft
, textureti
->TileTop
,
567 texture
->w
- textureti
->TileLeft
- textureti
->TileRight
, texture
->h
- textureti
->TileBottom
- textureti
->TileTop
,
568 0, 0, pic
->w
, pic
->h
);
570 RenderBackgroundTiled(pic
, texture
, textureti
, ratio
, TileImageToImageMenuBar
);
574 void WriteAlphaPixelArray(struct NewImage
*src
, struct NewLUT8Image
*dst
, LONG sx
, LONG sy
, LONG dx
, LONG dy
, LONG w
, LONG h
)
576 ULONG
*s
= src
->data
;
578 UBYTE
*d
= dst
->data
;
581 for (y
= 0; y
< h
; y
++)
583 for (x
= 0; x
< w
; x
++)
585 argb
= s
[sx
+ x
+ (sy
+ y
) * src
->w
];
586 d
[dx
+ x
+ (dy
+ y
) * dst
->w
] = GET_A(argb
);
591 void SetImageTint(struct NewImage
*dst
, UWORD ratio
, ULONG argb
)
597 UBYTE rs
, gs
, bs
, rd
, gd
, bd
;
600 if (dst
== NULL
) return;
607 rs
= (argb
>> 16) & 0xff;
608 gs
= (argb
>> 8) & 0xff;
611 for (y
= 0; y
< h
; y
++)
613 for (x
= 0; x
< w
; x
++)
619 r
= ((rs
* ratio
) >> 8) + ((rd
* (255 - ratio
)) >> 8);
620 g
= ((gs
* ratio
) >> 8) + ((gd
* (255 - ratio
)) >> 8);
621 b
= ((bs
* ratio
) >> 8) + ((bd
* (255 - ratio
)) >> 8);
627 d
[x
+ y
* w
] = SET_ARGB(255, r
, g
, b
);
633 * offx - offset between start of ni and place where image should be sample from
634 * offy - offset between start of ni and place where image should be sample from
635 * x, y, w, h - coords in rastport rp
637 void HorizVertRepeatNewImage(struct NewImage
*ni
, ULONG color
, UWORD offx
, UWORD offy
, struct RastPort
*rp
, UWORD x
, UWORD y
, WORD w
, WORD h
)
639 ULONG ow
, oh
, sy
, sx
, dy
, dx
;
640 LONG dh
, height
, dw
, width
;
642 if ((w
<= 0) || (h
<= 0)) return;
646 FillPixelArray(rp
, x
, y
, w
, h
, color
);
659 if ((height
-dh
)<0) dh
= height
;
668 if ((width
-dw
)<0) dw
= width
;
671 BltNewImageSubImageRastPort(ni
, 0, 0, sx
, sy
, rp
, dx
, dy
, dw
, dh
);
683 /* NOTE: fill parameter is ignored, previously it was forcing a no-alpha blit, but
684 this is already handled in BltNewImageSubImageRastPort */
685 /* dh - destination height to which subimage will be scaled to */
686 LONG
WriteTiledImageTitle(BOOL fill
, struct Window
*win
,
687 struct RastPort
*rp
, struct NewImage
*ni
, LONG sx
, LONG sy
, LONG sw
,
688 LONG sh
, LONG xp
, LONG yp
, LONG dw
, LONG dh
)
694 if (!ni
->ok
) return x
;
696 if ((sw
== 0) || (dw
== 0)) return xp
;
700 if (x
> win
->Width
) return xp
;
701 if ((x
+ w
) > win
->Width
) w
= win
->Width
- x
;
707 if (w
< ddw
) ddw
= w
;
709 BltScaleNewImageSubImageRastPort(ni
, 0, 0, sx
, sy
, rp
, x
, yp
, ddw
, -1, -1, dh
);
718 * dh - destination height to scale to, -1 to use subimage height
720 LONG
WriteVerticalScaledTiledImageHorizontal(struct RastPort
*rp
, struct NewImage
*ni
, ULONG subimage
,
721 LONG sx
, LONG sw
, LONG xp
, LONG yp
, LONG sh
, LONG dw
, LONG dh
)
727 if (!ni
->ok
) return xp
;
729 if ((sw
== 0) || (dw
== 0)) return xp
;
734 if (w
< ddw
) ddw
= w
;
736 BltScaleNewImageSubImageRastPort(ni
, 0, subimage
, sx
, 0, rp
, x
, yp
, ddw
, sh
, -1, dh
);
745 LONG
WriteTiledImageHorizontal(struct RastPort
*rp
, struct NewImage
*ni
, ULONG subimage
, LONG sx
, LONG sw
, LONG xp
, LONG yp
, LONG dw
)
747 return WriteVerticalScaledTiledImageHorizontal(rp
, ni
, subimage
, sx
, sw
, xp
, yp
, -1, dw
, -1);
750 LONG
WriteTiledImageVertical(struct RastPort
*rp
, struct NewImage
*ni
, ULONG subimage
, LONG sy
, LONG sh
, LONG xp
, LONG yp
, LONG dh
)
756 if (!ni
->ok
) return y
;
758 if ((sh
== 0) || (dh
== 0)) return yp
;
763 if (h
< ddh
) ddh
= h
;
765 BltNewImageSubImageRastPort(ni
, subimage
, 0, 0, sy
, rp
, xp
, y
, -1, ddh
);
778 void FillMemoryBufferRGBGradient(UBYTE
* buf
, LONG pen
, LONG xt
, LONG yt
, LONG xb
, LONG yb
, LONG xp
, LONG yp
, LONG w
, LONG h
, ULONG start_rgb
, ULONG end_rgb
, LONG angle
)
780 /* The basic idea of this algorithm is to calc the intersection between the
781 * diagonal of the rectangle (xs,ys) with dimension (xw,yw) a with the line starting
782 * at (x,y) (every pixel inside the rectangle) and angle angle with direction vector (vx,vy).
784 * Having the intersection point we then know the color of the pixel.
786 * TODO: Turn the algorithm into a incremental one
787 * Remove the use of floating point variables
789 double rad
= angle
*M_PI
/180;
790 double cosarc
= cos(rad
);
791 double sinarc
= sin(rad
);
793 struct myrgb startRGB
,endRGB
;
795 int diffR
, diffG
, diffB
;
797 int r
,t
; /* some helper variables to short the code */
799 int y1
; /* The intersection point */
800 int incr_y1
; /* increment of y1 */
802 int xadd
,ystart
,yadd
;
803 // double vx = -cosarc;
804 // double vy = sinarc;
805 int vx
= (int)(-cosarc
*0xff);
806 int vy
= (int)(sinarc
*0xff);
808 int width
= xb
- xt
+ 1;
809 int height
= yb
- yt
+ 1;
811 if (buf
== NULL
) return;
813 startRGB
.red
= (start_rgb
>> 16) & 0xff;
814 startRGB
.green
= (start_rgb
>> 8) & 0xff;
815 startRGB
.blue
= start_rgb
& 0xff;
817 endRGB
.red
= (end_rgb
>> 16) & 0xff;
818 endRGB
.green
= (end_rgb
>> 8) & 0xff;
819 endRGB
.blue
= end_rgb
& 0xff;
821 diffR
= endRGB
.red
- startRGB
.red
;
822 diffG
= endRGB
.green
- startRGB
.green
;
823 diffB
= endRGB
.blue
- startRGB
.blue
;
825 /* Normalize the angle */
826 if (angle
< 0) angle
= 360 - ((-angle
)%360);
827 if (angle
>= 0) angle
= angle
% 360;
829 if (angle
<= 90 || (angle
> 180 && angle
<= 270))
831 /* The to be intersected diagonal goes from the top left edge to the bottom right edge */
838 /* The to be intersected diagonal goes from the bottom left edge to the top right edge */
845 if (angle
> 90 && angle
<= 270)
847 /* for these angle we have y1 = height - y1. Instead of
849 * y1 = height - (-vy*(yw* xs -xw* ys) + yw*(vy* x -vx* y)) /(-yw*vx + xw*vy);
853 * y1 = (-vy*(yw*(-xs)-xw*(-ys+height)) + yw*(vy*(-x)-vx*(-y+height)))/(-yw*vx + xw*vy);
855 * so height - y1 can be expressed with the normal formular adapting some parameters.
857 * Note that if one would exchanging startRGB/endRGB the values would only work
858 * for linear color gradients
874 r
= -vy
*(yw
*xs
-xw
*ys
);
877 /* The formular as shown above is
879 * y1 = ((-vy*(yw*xs-xw*ys) + yw*(vy*x-vx*y)) /(-yw*vx + xw*vy));
881 * We see that only yw*(vy*x-vx*y) changes during the loop.
885 * Current Pixel: y1(x,y) = (r + yw*(vy*x-vx*y))/t = r/t + yw*(vy*x-vx*y)/t
886 * Next Pixel: y1(x+xadd,y) = (r + vw*(vy*(x+xadd)-vx*y))/t
888 * t*(y1(x+xadd,y) - y1(x,y)) = yw*(vy*(x+xadd)-vx*y) - yw*(vy*x-vx*y) = yw*vy*xadd;
892 incr_y1
= yw
*vy
*xadd
;
894 for (l
= 0, y
= ystart
+ ((yp
- yt
)* yadd
); l
< h
; l
++, y
+=yadd
)
897 /* Calculate initial y1 accu, can be brought out of the loop as well (x=0). It's probably a
898 * a good idea to add here also a value of (t-1)/2 to ensure the correct rounding
899 * This (and for r) is also a place were actually a overflow can happen |yw|=16 |y|=16. So for
900 * vx nothing is left, currently 9 bits are used for vx or vy */
901 int y1_mul_t_accu
= r
- yw
*vx
*y
;
905 for (c
= 0, x
= ((xp
- xt
) * xadd
); c
< w
; c
++, x
+=xadd
)
909 /* Calculate the intersection of two lines, this is not the fastet way to do but
910 * it is intuitive. Note: very slow! Will be optimzed later (remove FFP usage
911 * and making it incremental)...update: it's now incremental and no FFP is used
912 * but it probably can be optimized more by removing some more of the divisions and
913 * further specialize the stuff here (use of three accus). */
914 /* y1 = (int)((-vy*(yw*xs-xw*ys) + yw*(vy*x-vx*y)) /(-yw*vx + xw*vy));*/
915 y1
= y1_mul_t_accu
/ t
;
917 red
= startRGB
.red
+ (int)(diffR
*y1
/height
);
918 green
= startRGB
.green
+ (int)(diffG
*y1
/height
);
919 blue
= startRGB
.blue
+ (int)(diffB
*y1
/height
);
920 /* By using full 32 bits this can be made faster as well */
925 y1_mul_t_accu
+= incr_y1
;
931 void FillPixelArrayGradient(LONG pen
, BOOL tc
, struct RastPort
*rp
, LONG xt
, LONG yt
, LONG xb
, LONG yb
, LONG xp
, LONG yp
, LONG w
, LONG h
, ULONG start_rgb
, ULONG end_rgb
, LONG angle
, LONG dx
, LONG dy
)
935 if ((w
<= 0) || (h
<= 0)) return;
937 /* By bringing building the gradient array in the same format as the RastPort BitMap a call
938 to WritePixelArray() can be made also faster */
939 buf
= AllocVec(1 * yb
* 3, 0);
941 FillMemoryBufferRGBGradient(buf
, pen
, xt
, yt
, xb
, yb
, xp
, yp
, 1, yb
, start_rgb
, end_rgb
, angle
);
943 HorizRepeatBuffer(buf
, dy
, pen
, tc
, rp
, xp
, yp
, w
, h
);
948 void HorizRepeatBuffer(UBYTE
* buf
, LONG offy
, LONG pen
, BOOL tc
, struct RastPort
*rp
, LONG x
, LONG y
, LONG w
, LONG h
)
950 UBYTE
* bufblit
= NULL
;
955 if ((w
<= 0) || (h
<= 0)) return;
958 if (pen
!= -1) SetAPen(rp
, pen
); else SetAPen(rp
, 2);
959 RectFill(rp
, x
, y
, x
+ w
- 1, y
+ h
- 1);
963 /* By bringing building the gradient array in the same format as the RastPort BitMap a call
964 to WritePixelArray() can be made also faster */
965 bufblit
= AllocVec(w
* h
* 3, MEMF_ANY
);
967 /* Copy one column buffer into blit buffer */
968 for (yi
= 0; yi
< h
; yi
++)
970 idxs
= (offy
+ yi
) * 3; /* source index */
971 idxd
= yi
* 3 * w
; /* dest index */
972 for (xi
= 0; xi
< w
; xi
++)
975 bufblit
[idxd
++] = buf
[idxs
+ 0];
976 bufblit
[idxd
++] = buf
[idxs
+ 1];
977 bufblit
[idxd
++] = buf
[idxs
+ 2];
981 WritePixelArray(bufblit
, 0, 0, w
* 3, rp
, x
, y
, w
, h
, RECTFMT_RGB
);
986 void TileMapToBitmap(struct NewImage
*src
, struct TileInfo
*srcti
, struct BitMap
*map
, UWORD dw
, UWORD dh
)
990 if (map
== NULL
) return;
991 if (src
== NULL
) return;
992 if (srcti
== NULL
) return;
997 if ((srcti
->TileTop
+ srcti
->TileBottom
) > dh
) return;
998 if ((srcti
->TileLeft
+ srcti
->TileRight
) > dw
) return;
1000 struct RastPort
*dest
= CreateRastPort();
1006 DrawMapTileToRP(src
, dest
, 0, y
, srcti
->TileLeft
, srcti
->TileTop
, 0 , 0, srcti
->TileLeft
, srcti
->TileTop
);
1007 DrawMapTileToRP(src
, dest
, 0, y
+ h
- srcti
->TileBottom
, srcti
->TileLeft
, srcti
->TileBottom
, 0 , dh
- srcti
->TileBottom
, srcti
->TileLeft
, srcti
->TileBottom
);
1008 DrawMapTileToRP(src
, dest
, src
->w
- srcti
->TileRight
, y
, srcti
->TileRight
, srcti
->TileTop
, dw
- srcti
->TileRight
, 0, srcti
->TileRight
, srcti
->TileTop
);
1009 DrawMapTileToRP(src
, dest
, src
->w
- srcti
->TileRight
, y
+ h
- srcti
->TileBottom
, srcti
->TileRight
, srcti
->TileBottom
, dw
- srcti
->TileRight
, dh
- srcti
->TileBottom
, srcti
->TileRight
, srcti
->TileBottom
);
1011 DrawMapTileToRP(src
, dest
, srcti
->TileLeft
, y
, src
->w
- srcti
->TileLeft
- srcti
->TileRight
, srcti
->TileTop
, srcti
->TileLeft
, 0, dw
- srcti
->TileLeft
- srcti
->TileRight
, srcti
->TileTop
);
1012 DrawMapTileToRP(src
, dest
, srcti
->TileLeft
, y
+ h
- srcti
->TileBottom
, src
->w
- srcti
->TileLeft
- srcti
->TileRight
, srcti
->TileBottom
, srcti
->TileLeft
, dh
- srcti
->TileBottom
, dw
- srcti
->TileLeft
- srcti
->TileRight
, srcti
->TileBottom
);
1013 DrawMapTileToRP(src
, dest
, 0, y
+ srcti
->TileTop
, srcti
->TileLeft
, h
- srcti
->TileBottom
- srcti
->TileTop
, 0 , srcti
->TileTop
+ 0, srcti
->TileLeft
, dh
- srcti
->TileTop
- srcti
->TileBottom
- 0);
1014 DrawMapTileToRP(src
, dest
, src
->w
- srcti
->TileRight
, y
+ srcti
->TileTop
, srcti
->TileRight
, h
- srcti
->TileBottom
- srcti
->TileTop
, dw
- srcti
->TileRight
, srcti
->TileTop
+ 0, srcti
->TileRight
, dh
- srcti
->TileTop
- srcti
->TileBottom
- 0);
1015 DrawMapTileToRP(src
, dest
, srcti
->TileLeft
, y
+ srcti
->TileTop
, src
->w
- srcti
->TileLeft
- srcti
->TileRight
, h
- srcti
->TileBottom
- srcti
->TileTop
, srcti
->TileLeft
, srcti
->TileTop
+ 0, dw
- srcti
->TileLeft
- srcti
->TileRight
, dh
- srcti
->TileTop
- srcti
->TileBottom
- 0);
1020 struct NewImage
*GetImageFromRP(struct RastPort
*rp
, UWORD x
, UWORD y
, UWORD w
, UWORD h
)
1022 struct NewImage
*ni
;
1024 ni
= NewImageContainer(w
, h
);
1027 ReadPixelArray(ni
->data
, 0, 0, w
*4, rp
, x
, y
, w
, h
, RECTFMT_ARGB
);
1032 void PutImageToRP(struct RastPort
*rp
, struct NewImage
*ni
, UWORD x
, UWORD y
) {
1036 if (ni
->data
) WritePixelArray(ni
->data
, 0, 0, ni
->w
*4, rp
, x
, y
, ni
->w
, ni
->h
, RECTFMT_ARGB
);
1037 DisposeImageContainer(ni
);
1043 struct NewImage
*ni
;
1045 /* RectList for UnLockBitMap */
1048 struct Rectangle rl_rect
;
1054 /* struct Rectangle rect; (replaced by the next line!) */
1055 WORD MinX
, MinY
, MaxX
, MaxY
;
1056 LONG OffsetX
, OffsetY
;
1059 ULONG
CalcShade(ULONG base
, UWORD fact
)
1063 c0
= (base
>> 24) & 0xff;
1064 c1
= (base
>> 16) & 0xff;
1065 c2
= (base
>> 8) & 0xff;
1076 if (c0
> 255) c0
= 255;
1077 if (c1
> 255) c1
= 255;
1078 if (c2
> 255) c2
= 255;
1079 if (c3
> 255) c3
= 255;
1081 return (ULONG
)((c0
<< 24) | (c1
<< 16) | (c2
<< 8) | c3
);
1084 AROS_UFH3(void, RectShadeFunc
,
1085 AROS_UFHA(struct Hook
* , h
, A0
),
1086 AROS_UFHA(struct RastPort
* , rp
, A2
),
1087 AROS_UFHA(struct layerhookmsg
*, msg
, A1
))
1092 ULONG bm_bytesperrow
;
1093 IPTR bm_baseaddress
;
1100 struct ShadeData
*data
= h
->h_Data
;
1102 bm_handle
= LockBitMapTags(rp
->BitMap
,
1103 LBMI_BYTESPERROW
, &bm_bytesperrow
,
1104 LBMI_BASEADDRESS
, &bm_baseaddress
,
1107 if (msg
->MinX
== msg
->MaxX
)
1109 x
= (msg
->MinX
- rp
->Layer
->bounds
.MinX
) % data
->ni
->w
;
1110 for (py
= msg
->MinY
; py
< (msg
->MaxY
+ 1); py
++)
1112 y
= (py
- rp
->Layer
->bounds
.MinY
) % data
->ni
->h
;
1113 color
= CalcShade(data
->ni
->data
[x
+ y
* data
->ni
->w
], data
->fact
);
1117 col
.alpha
= (HIDDT_ColComp
)((color
>> 16) & 0x0000FF00);
1118 col
.red
= (HIDDT_ColComp
)((color
>> 8) & 0x0000FF00);
1119 col
.green
= (HIDDT_ColComp
)(color
& 0x0000FF00);
1120 col
.blue
= (HIDDT_ColComp
)((color
<< 8) & 0x0000FF00);
1122 HIDD_BM_PutPixel(HIDD_BM_OBJ(rp
->BitMap
), msg
->MinX
, py
, HIDD_BM_MapColor(HIDD_BM_OBJ(rp
->BitMap
), &col
));
1126 WriteRGBPixel(rp
, msg
->OffsetX
, py
+ msg
->OffsetY
- msg
->MinY
, color
);
1132 y
= (msg
->MinY
- rp
->Layer
->bounds
.MinY
) % data
->ni
->h
;
1133 for (px
= msg
->MinX
; px
< (msg
->MaxX
+ 1); px
++) {
1134 x
= (px
- rp
->Layer
->bounds
.MinX
) % data
->ni
->h
;
1135 color
= CalcShade(data
->ni
->data
[x
+ y
* data
->ni
->w
], data
->fact
);
1139 col
.alpha
= (HIDDT_ColComp
)((color
>> 16) & 0x0000FF00);
1140 col
.red
= (HIDDT_ColComp
)((color
>> 8) & 0x0000FF00);
1141 col
.green
= (HIDDT_ColComp
)(color
& 0x0000FF00);
1142 col
.blue
= (HIDDT_ColComp
)((color
<< 8) & 0x0000FF00);
1144 HIDD_BM_PutPixel(HIDD_BM_OBJ(rp
->BitMap
), px
, msg
->MinY
, HIDD_BM_MapColor(HIDD_BM_OBJ(rp
->BitMap
), &col
));
1148 WriteRGBPixel(rp
, px
+ msg
->OffsetX
- msg
->MinX
, msg
->OffsetY
, color
);
1155 struct TagItem bm_ultags
[3] =
1157 {UBMI_REALLYUNLOCK
, TRUE
},
1158 {UBMI_UPDATERECTS
, (IPTR
)&data
->rl_num
},
1162 data
->rl_rect
.MinX
= msg
->MinX
;
1163 data
->rl_rect
.MinY
= msg
->MinY
;
1164 data
->rl_rect
.MaxX
= msg
->MaxX
;
1165 data
->rl_rect
.MaxY
= msg
->MaxY
;
1167 UnLockBitMapTagList(bm_handle
, bm_ultags
);
1170 UpdateBitMap(rp
->BitMap
, msg
->MinX
, msg
->MinY
, msg
->MaxX
- msg
->MinX
+ 1, msg
->MaxY
- msg
->MinY
+ 1);
1175 void ShadeLine(LONG pen
, BOOL tc
, BOOL usegradients
, struct RastPort
*rp
, struct NewImage
*ni
, ULONG basecolor
, UWORD fact
, UWORD _offy
, UWORD x0
, UWORD y0
, UWORD x1
, UWORD y1
)
1179 if ((x1
< x0
) || (y1
< y0
)) return;
1189 color
= CalcShade(basecolor
, fact
);
1190 SetRPAttrs(rp
, RPTAG_PenMode
, FALSE
, RPTAG_FgColor
, color
, TAG_DONE
);
1196 struct ShadeData shadeParams
;
1197 struct Hook shadeHook
;
1198 struct Rectangle shadeRect
;
1200 shadeRect
.MinX
= x0
;
1201 shadeRect
.MaxX
= x1
;
1202 shadeRect
.MinY
= y0
;
1203 shadeRect
.MaxY
= y1
;
1205 shadeParams
.ni
= ni
;
1206 shadeParams
.fact
= fact
;
1207 shadeParams
.rl_num
= 1;
1208 shadeParams
.rl_next
= (IPTR
)NULL
;
1210 shadeHook
.h_Entry
= (HOOKFUNC
)AROS_ASMSYMNAME(RectShadeFunc
);
1211 shadeHook
.h_Data
= &shadeParams
;
1213 DoHookClipRects(&shadeHook
, rp
, &shadeRect
);
1222 void DrawScaledStatefulGadgetImageToRP(struct RastPort
*rp
, struct NewImage
*ni
, ULONG state
, UWORD xp
, UWORD yp
,
1223 WORD scaledwidth
, WORD scaledheight
)
1226 UWORD subimagecol
= 0;
1227 UWORD subimagerow
= 0;
1238 case IDS_INACTIVENORMAL
:
1243 BltScaleNewImageSubImageRastPortSimple(ni
, subimagecol
, subimagerow
, rp
, xp
, yp
, scaledwidth
, scaledheight
);
1247 void DrawStatefulGadgetImageToRP(struct RastPort
*rp
, struct NewImage
*ni
, ULONG state
, UWORD xp
, UWORD yp
)
1249 DrawScaledStatefulGadgetImageToRP(rp
, ni
, state
, xp
, yp
, -1, -1);