It seems that transparent colors are badly written to memory (explained)

[Petr]

Hi. Maybe that's just my fault, but this program returns faulty results for _RGBA32 colors. When writing _RGB32 colors, the values return correct. That's why I was sitting at the computer at 3:00 am yesterday and didn't understand what the hell was going on ...

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. test = _NEWIMAGE(1, 1, 32)
3. _DEST test
4. PSET (0, 0), _RGBA32(20, 40, 60, 80)
5. DIM m AS _MEM
6. m = _MEMIMAGE(test)
7. DIM value AS _UNSIGNED LONG
8. _MEMGET m, m.OFFSET, value
9. PRINT value
10. _SOURCE test: PRINT POINT(0, 0)
11. _DEST 0
12. PRINT _RED32(value)
13. PRINT _GREEN32(value)
14. PRINT _BLUE32(value)
15. PRINT _ALPHA32(value)
16.  
17. 'the same results for _RGBA32 if reading 4 * _UNSIGNED _BYTE type...
18.  

[Petr]

Confirm. 32 bit values are writed as _RGB and not as _RGB32.

Bug is between _RGB and RGBA: With _RGB and _RED, _GREEN, _BLUE return corect values, With RGBA it return bad values:

Edit: RGB return bad alpha. Return 255 and not 80. RGBA return bad colors and correct alpha.

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. test = _NEWIMAGE(1, 1, 32)
3. _DEST test
4. PSET (0, 0), _RGB(20, 40, 60, 80) 'Rewrite to _RGBA for BUG show
5. DIM m AS _MEM
6. m = _MEMIMAGE(test)
7. DIM value AS _UNSIGNED LONG
8. _MEMGET m, m.OFFSET, value
9. _SOURCE test:
10. _DEST 0
11. PRINT POINT(0, 0)
12. PRINT value
13. PRINT _RED(value)
14. PRINT _GREEN(value)
15. PRINT _BLUE(value)
16. PRINT _ALPHA(value)
17.  
18. 'the same results for _RGBA32 if reading 4 * _UNSIGNED _BYTE type...
19.  

[FellippeHeitor]

Not to turn down your findings but the syntax for_RGB() doesn't take a fourth alpha parameter. Please check the wiki:

Code: QB64: [Select]

1. _RGB

[Petr]

Yeah I know, in the heat of searching ...

Fellippe, if I write the color value using MEMPUT, it's fine.

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. test = _NEWIMAGE(1, 1, 32)
3. _DEST test
4. 'PSET (0, 0), _RGBA32(20, 40, 60, 80) ' PSET write it bad
5. clr~& = _RGBA32(20, 40, 60, 80)
6. 'PSET (0, 0), clr~& 'also wrong
7.  
8. DIM m AS _MEM
9. m = _MEMIMAGE(test)
10. DIM value AS _UNSIGNED LONG
11. _MEMPUT m, m.OFFSET, clr~& 'MEMPUT write it good
12. _MEMGET m, m.OFFSET, value
13. PRINT value
14. _SOURCE test: PRINT POINT(0, 0)
15. _DEST 0
16. PRINT _RED32(value)
17. PRINT _GREEN32(value)
18. PRINT _BLUE32(value)
19. PRINT _ALPHA32(value)
20.  
21. 'the same results for _RGBA32 if reading 4 * _UNSIGNED _BYTE type...
22.  
23.  
24.  
25.  

[FellippeHeitor]

Maybe this will clear things:

Code: QB64: [Select]

1. col~& = _RGBA32(20, 40, 60, 80)
2.  
3. test = _NEWIMAGE(1, 1, 32)
4. _DEST test
5. PSET (0, 0), col~&
6. _SOURCE test
7. col2~& = POINT(0, 0)
8.  
9. _DEST 0
10. DIM m AS _MEM
11. m = _MEMIMAGE(test)
12. DIM value AS _UNSIGNED LONG
13. _MEMGET m, m.OFFSET, value
14.  
15. PRINT "Size of memory block:"; m.SIZE
16. PRINT "This:"; col~&
17. PRINT "Shouldn't be the same as this: "; col2~&
18. PRINT "But this should be the same as above: "; value
19.  
20. PRINT "These are the original RGBA values:"
21. PRINT _RED32(col~&), _GREEN32(col~&), _BLUE32(col~&), _ALPHA32(col~&)
22. PRINT
23. PRINT "These, though, are the result of the values above *after being PSET/BLENDed on top of black*:"
24. PRINT _RED32(col2~&), _GREEN32(col2~&), _BLUE32(col2~&), _ALPHA32(col2~&)
25. PRINT _RED32(value), _GREEN32(value), _BLUE32(value), _ALPHA32(value)
26.  

[FellippeHeitor]

The thing is: You place a transparent color onto a black image. Pixels will blend with black. Read those back: they are not the same values anymore - because they blended. That's the purpose of transparency and alpha blending: having colors transform upon being applied.

[FellippeHeitor]

To make it even clearer (I hope):

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 400, 32)
2. _PRINTMODE _KEEPBACKGROUND
3.  
4. color1~& = _RGBA32(255, 0, 0, 127)
5. color2~& = _RGBA32(0, 0, 255, 127)
6.  
7. LINE (0, 0)-(300, 300), color1~&, BF
8. LINE (100, 100)-(399, 399), color2~&, BF
9.  
10. PRINT "Color 1 = "; color1~&, _RED32(color1~&), _GREEN32(color1~&), _BLUE32(color1~&), _ALPHA32(color1~&)
11. PRINT "Color 2 = "; color2~&, _RED32(color2~&), _GREEN32(color2~&), _BLUE32(color2~&), _ALPHA32(color2~&)
12.  
13. mix~& = POINT(200, 200)
14.  
15. PRINT "Mix     = "; mix~&, _RED32(mix~&), _GREEN32(mix~&), _BLUE32(mix~&), _ALPHA32(mix~&)
16.  

Just as red and blue merge in the example above to form a new color, your transparent colors will merge with black to form a new color after they are put to the image. That's why you don't get the same values of the original color, because it's not the same color anymore after blending.

[FellippeHeitor]

Also:

PSET write it bad

PSET write is good because it *does* blend. Memory write doesn't blend because it's raw manipulation.

[Petr]

Oh, my God... Now it's clear to me. Thank you. Knowledge + :-D I assumed the background was 0,0,0,0, so it doesn't affect. Basically, a new screen without CLS is transparent. Alpha mixes everything together to create a new color. When I add the mutual transparency between the _SOFTWARE and _HARDWARE layers, that's the power to put this together. I go into the corner and I'll silent sit. :-D



Thank you, Fellippe.

[SMcNeill]

Alpha images blend with the background, by default.  If you have a red background, put a 50% transparent green background onto it, you end up with a faded yellow background.

If you want to maintain that 50% transparent green, and completely overwrite the red with it, use _DONTBLEND.  (Much like you’re doing with the MEM commands.)

************

Personally, since _DONTBLEND runs much faster than when blending is turned on by default, and since a lot of folks never use alpha images, I’ve always felt that it should be our default setting — but it’s not.  QB64 automatically tries to blend all images onto the original canvas, unless _DONTBLEND is invoked manually.

[Petr]

Thank you Steve. I didn't know that. I'll  try it.

[Petr]

If someone was wondering how is the alpha channel calculated, when using MEM, it's easy. See this example.

Code: QB64: [Select]

1.  
2. img = _NEWIMAGE(1, 1, 32)
3. _DEST img
4. CLS 'alpha = 255
5. PSET (0, 0), _RGB32(10, 20, 30, 204) '204 is 80 percent (base 100 percent is 255), 2.55(1 percent) * 80 (80 percent for alpha channel transparency) = 204.
6. '                                     so output RED GREEN BLUE values are: 80 percent from 10 for RED: 0.1 * 80 = 8,
7. '                                                                          80 percent from 20 for GREEN: 0.2 * 80 = 16
8. '                                                                          80 percent from 30 for BLUE: 0.3 * 80 = 24
9. '                                                                          ALPHA is allways 255, because RGB colors already reflect background
10.  
11. DIM m AS _MEM
12. m = _MEMIMAGE(img)
13. DIM k AS _UNSIGNED LONG
14. _MEMGET m, m.OFFSET, k~&
15. _DEST 0
16.  
17. PRINT _RED32(k~&)
18. PRINT _GREEN32(k~&)
19. PRINT _BLUE32(k~&)
20. PRINT _ALPHA32(k~&)
21.  
22.  

[Petr]

Here is sample application with an alpha channel with MEM for a PNG image that has an alpha channel. The purpose of this feature is to rotate the image 90 degrees, no more. It's one of the many subroutines I develop.

Code: QB64: [Select]

1.  
2. img = _LOADIMAGE("cat.png", 32)
3. SCREEN MEM_ROTO_90(img)
4.  
5. FUNCTION MEM_ROTO_90 (img AS LONG)
6.     DIM W AS LONG, H AS LONG
7.     W = _WIDTH(img)
8.     H = _HEIGHT(img)
9.     MEM_ROTO_90 = _NEWIMAGE(H, W, 32)
10.     DIM m AS _MEM, m2 AS _MEM, k AS _UNSIGNED LONG, X AS LONG, Y AS LONG, R AS _UNSIGNED _BYTE, G AS _UNSIGNED _BYTE, B AS _UNSIGNED _BYTE, A AS _UNSIGNED _BYTE, nR AS _UNSIGNED _BYTE, nG AS _UNSIGNED _BYTE, nB AS _UNSIGNED _BYTE
11.     m = _MEMIMAGE(img)
12.     m2 = _MEMIMAGE(MEM_ROTO_90)
13.     FOR Y = 0 TO H - 1
14.         FOR X = W - 1 TO 1 STEP -1
15.             _MEMGET m, m.OFFSET + (4 * (W - X + _WIDTH(img) * Y)), k
16.             R = _RED32(k)
17.             G = _GREEN32(k)
18.             B = _BLUE32(k)
19.             A = _ALPHA32(k)
20.             nA = A / 2.55
21.  
22.             nR = R / 100 * nA
23.             nG = G / 100 * nA
24.             nB = B / 100 * nA
25.  
26.             k = _RGBA32(nR, nG, nB, 255)
27.  
28.             _MEMPUT m2, m2.OFFSET + (4 * (Y + _WIDTH(MEM_ROTO_90) * X)), k
29.     NEXT X, Y
30.     _MEMFREE m
31.     _MEMFREE m2
32. END FUNCTION
33.  

[Petr]

Previous source is just for black background. This one is for all background colors:

Code: QB64: [Select]

1.  
2. img = _LOADIMAGE("cat.png", 32)
3. SCREEN _NEWIMAGE(800, 600, 32)
4. CLS , _RGB32(255, 25, 125)
5. a = MEM_ROTO_90(img)
6. _PUTIMAGE (10, 10), a
7.  
8.  
9.  
10. FUNCTION MEM_ROTO_90 (img AS LONG)
11.     DIM W AS LONG, H AS LONG
12.     W = _WIDTH(img)
13.     H = _HEIGHT(img)
14.     MEM_ROTO_90 = _NEWIMAGE(H, W, 32)
15.     DIM m AS _MEM, m2 AS _MEM, m3 AS _MEM, k AS _UNSIGNED LONG, k3 AS _UNSIGNED LONG, X AS LONG, Y AS LONG, R AS _UNSIGNED _BYTE, G AS _UNSIGNED _BYTE, B AS _UNSIGNED _BYTE, A AS _UNSIGNED _BYTE, nR AS _UNSIGNED _BYTE, nG AS _UNSIGNED _BYTE, nB AS _UNSIGNED _BYTE
16.     m = _MEMIMAGE(img)
17.     m2 = _MEMIMAGE(MEM_ROTO_90)
18.     m3 = _MEMIMAGE(0)
19.     FOR Y = 0 TO H - 1
20.         FOR X = W - 1 TO 1 STEP -1
21.             _MEMGET m, m.OFFSET + (4 * (W - X + _WIDTH(img) * Y)), k
22.             _MEMGET m3, m3.OFFSET + (4 * (W - X + _WIDTH(img) * Y)), k3
23.  
24.             R = _RED32(k)
25.             G = _GREEN32(k)
26.             B = _BLUE32(k)
27.             A = _ALPHA32(k)
28.             nA = A / 2.55
29.  
30.             R3 = _RED32(k3)
31.             G3 = _GREEN32(k3)
32.             B3 = _BLUE32(k3)
33.  
34.             '            nR = R / 100 * nA
35.             '            nG = G / 100 * nA
36.             '            nB = B / 100 * nA
37.  
38.  
39.             nR = NColor(R3, R, nA)
40.             nG = NColor(G3, G, nA)
41.             nB = NColor(B3, B, nA)
42.             k = _RGBA32(nR, nG, nB, 255)
43.             _MEMPUT m2, m2.OFFSET + (4 * (Y + _WIDTH(MEM_ROTO_90) * X)), k
44.     NEXT X, Y
45.     _MEMFREE m
46.     _MEMFREE m2
47.     _MEMFREE m3
48. END FUNCTION
49.  
50. FUNCTION NColor~& (Background AS _UNSIGNED _BYTE, Foreground AS _UNSIGNED _BYTE, Alpha AS SINGLE)
51.     NColor = Background - ((Background - Foreground) / 100) * Alpha
52. END FUNCTION
53.