QB64.org Forum

Active Forums => QB64 Discussion => Topic started by: Petr on May 01, 2019, 07:39:12 am

Title: It seems that transparent colors are badly written to memory (explained)
Post by: Petr on May 01, 2019, 07:39:12 am

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.  

Title: Re: It seems that transparent colors are badly written to memory
Post by: Petr on May 01, 2019, 07:56:20 am

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.  

Title: Re: It seems that transparent colors are badly written to memory
Post by: FellippeHeitor on May 01, 2019, 08:13:34 am

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

Title: Re: It seems that transparent colors are badly written to memory
Post by: Petr on May 01, 2019, 08:41:09 am

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.  

Title: Re: It seems that transparent colors are badly written to memory
Post by: FellippeHeitor on May 01, 2019, 08:45:56 am

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.  

Title: Re: It seems that transparent colors are badly written to memory
Post by: FellippeHeitor on May 01, 2019, 08:49:42 am

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.

Title: Re: It seems that transparent colors are badly written to memory
Post by: FellippeHeitor on May 01, 2019, 08:55:01 am

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.

Title: Re: It seems that transparent colors are badly written to memory
Post by: FellippeHeitor on May 01, 2019, 08:57:35 am

Also:

Quote

PSET write it bad

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

Title: Re: It seems that transparent colors are badly written to memory
Post by: Petr on May 01, 2019, 09:14:14 am

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.

Title: Re: It seems that transparent colors are badly written to memory
Post by: SMcNeill on May 01, 2019, 09:19:03 am

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.

Title: Re: It seems that transparent colors are badly written to memory (explained)
Post by: Petr on May 01, 2019, 09:23:23 am

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

Title: Re: It seems that transparent colors are badly written to memory (explained)
Post by: Petr on May 10, 2019, 12:48:17 pm

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.  

Title: Re: It seems that transparent colors are badly written to memory (explained)
Post by: Petr on May 10, 2019, 01:23:48 pm

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.  

Title: Re: It seems that transparent colors are badly written to memory (explained)
Post by: Petr on May 10, 2019, 02:35:48 pm

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.  

Text Only | Text with Attachments