Author Topic: Xor Magic ^2 (Read 14795 times)

bplus · « **on:** April 09, 2021, 09:37:55 pm »

Code: QB64: [Select]

_Title "XOR Magic ^2" ' b+ revisit 2021-04-09
Screen _NewImage(768, 512, 32)
_Delay .25
_ScreenMove _Middle
 
For y = 0 To _Height
    For x = 0 To _Width
        PSet (x, y), _RGB(x Mod 256, (x Mod 256 Xor y) Mod 256, y Mod 256)
    Next
Next
Do
    red = Rnd * 255 \ 1
    green = Rnd * 255 \ 1
    blue = Rnd * 255 \ 1
    _Title "XOR Magic ^2 " + Str$(red) + Str$(green) + Str$(blue)
    For y = 0 To _Height
        For x = 0 To _Width
            c~& = Point(x, y)
            cAnalysis c~&, r, g, b, a
            PSet (x, y), _RGB32(r Xor red, g Xor green, b Xor blue, a)
        Next
    Next
    _Limit 3
Loop
 
Sub cAnalysis (c As _Unsigned Long, outRed, outGrn, outBlu, outAlp)
    outRed = _Red32(c): outGrn = _Green32(c): outBlu = _Blue32(c): outAlp = _Alpha32(c)
End Sub
 
 

euklides · « **Reply #1 on:** April 10, 2021, 11:29:47 am »

Very useful for making Scottish kilts !!! :)

Ashish · « **Reply #2 on:** April 10, 2021, 11:31:48 am »

Hi @bplus
Nice graphics! I like it! :)
I modified your a code a little and I have used _MEM instead of POINT for getting color (_MEM is faster than POINT )

Code: QB64: [Select]

_Title "XOR Magic ^2" ' b+ revisit 2021-04-09
'MEM mod by Ashish
Screen _NewImage(768, 512, 32)
_Delay .25
_ScreenMove _Middle
 
For y = 0 To _Height
    For x = 0 To _Width
        PSet (x, y), _RGB(x Mod 256, (x Mod 256 Xor y) Mod 256, y Mod 256)
    Next
Next
Dim m As _MEM
m = _MemImage(0)
 
Do
    red = Rnd * 255 \ 1
    green = Rnd * 255 \ 1
    blue = Rnd * 255 \ 1
    _Title "XOR Magic ^2 " + Str$(red) + Str$(green) + Str$(blue)
    For y = 0 To _Height - 1
        For x = 0 To _Width - 1
            b = _MemGet(m, m.OFFSET + (y * _Width + x) * 4, _Unsigned _Byte)
            g = _MemGet(m, m.OFFSET + (y * _Width + x) * 4 + 1, _Unsigned _Byte)
            r = _MemGet(m, m.OFFSET + (y * _Width + x) * 4 + 2, _Unsigned _Byte)
            a = _MemGet(m, m.OFFSET + (y * _Width + x) * 4 + 3, _Unsigned _Byte)
            'c~& = Point(x, y)
            'cAnalysis c~&, r, g, b, a
            PSet (x, y), _RGB32(r Xor red, g Xor green, b Xor blue, a)
        Next
    Next
    _Limit 10
Loop
 
Sub cAnalysis (c As _Unsigned Long, outRed, outGrn, outBlu, outAlp)
    outRed = _Red32(c): outGrn = _Green32(c): outBlu = _Blue32(c): outAlp = _Alpha32(c)
End Sub
 
 
 
 

bplus · « **Reply #3 on:** April 10, 2021, 12:56:32 pm »

Thanks!

@Ashish that is very nice demo for getting colors and using mem techniques.

SMcNeill · « **Reply #4 on:** April 10, 2021, 04:45:54 pm »

Quote from: Ashish on April 10, 2021, 11:31:48 am

Hi @bplus
Nice graphics! I like it! :)
I modified your a code a little and I have used _MEM instead of POINT for getting color (_MEM is faster than POINT )
Code: QB64: [Select]
_Title "XOR Magic ^2" ' b+ revisit 2021-04-09
'MEM mod by Ashish
Screen _NewImage(768, 512, 32)
_Delay .25
_ScreenMove _Middle

For y = 0 To _Height
For x = 0 To _Width
PSet (x, y), _RGB(x Mod 256, (x Mod 256 Xor y) Mod 256, y Mod 256)
Next
Next
Dim m As _MEM
m = _MemImage(0)

Do
red = Rnd * 255 \ 1
green = Rnd * 255 \ 1
blue = Rnd * 255 \ 1
_Title "XOR Magic ^2 " + Str$(red) + Str$(green) + Str$(blue)
For y = 0 To _Height - 1
For x = 0 To _Width - 1
b = _MemGet(m, m.OFFSET + (y * _Width + x) * 4, _Unsigned _Byte)
g = _MemGet(m, m.OFFSET + (y * _Width + x) * 4 + 1, _Unsigned _Byte)
r = _MemGet(m, m.OFFSET + (y * _Width + x) * 4 + 2, _Unsigned _Byte)
a = _MemGet(m, m.OFFSET + (y * _Width + x) * 4 + 3, _Unsigned _Byte)
'c~& = Point(x, y)
'cAnalysis c~&, r, g, b, a
PSet (x, y), _RGB32(r Xor red, g Xor green, b Xor blue, a)
Next
Next
_Limit 10
Loop

Sub cAnalysis (c As _Unsigned Long, outRed, outGrn, outBlu, outAlp)
outRed = _Red32(c): outGrn = _Green32(c): outBlu = _Blue32(c): outAlp = _Alpha32(c)
End Sub

If you’re looking for speed, move as much math as possible outside your loop.

For y = 0 To (_Height -1) * 4 * _WIDTH STEP 4 * _WIDTH
For x = 0 To (_Width - 1) * 4 STEP 4
t = y + x
b = _MemGet(m, m.OFFSET + t, _Unsigned _Byte)
g = _MemGet(m, m.OFFSET + t + 1, _Unsigned _Byte)
r = _MemGet(m, m.OFFSET + t + 2, _Unsigned _Byte)
a = _MemGet(m, m.OFFSET + t + 3, _Unsigned _Byte)
'c~& = Point(x, y)
'cAnalysis c~&, r, g, b, a
PSet (x, y), _RGB32(r Xor red, g Xor green, b Xor blue, a)
Next
Next

The fewer math calculations you do inside your loop, the faster it can process — which can really affect performance with _MEM.

Personally, since this checks the whole screen, I’d just make it a simple DO...LOOP

t = 0
DO UNTIL t >= m.size
b = _MemGet(m, m.OFFSET + t, _Unsigned _Byte)
g = _MemGet(m, m.OFFSET + t + 1, _Unsigned _Byte)
r = _MemGet(m, m.OFFSET + t + 2, _Unsigned _Byte)
_MEMPUT m, m.OFFSET + t, _RGB32(r Xor red, g Xor green, b Xor blue) AS STRING * 3
t = t + 4
LOOP

Once it’s right, $CHECKING:OFF before it and $CHECKING:ON after it, and you’re not going to get it any faster. (And since you’re not changing alpha levels at all, I don’t think you’re going to need to read or write them either, unless I’m missing something.)

bplus · « **Reply #5 on:** April 10, 2021, 05:21:36 pm »

Code: QB64: [Select]

  _Limit 10

Really don't need speed, the above is already too fast to appreciate the varieties of color combinations.

I am sure in a 3D Game it would be different story.

SMcNeill · « **Reply #6 on:** April 10, 2021, 08:04:43 pm »

Quote from: bplus on April 10, 2021, 05:21:36 pm

Code: QB64: [Select]
_Limit 10

Really don't need speed, the above is already too fast to appreciate the varieties of color combinations.

I am sure in a 3D Game it would be different story.

Aye. With a limit 10, POINT would be sufficient enough. I just mentioned the difference with _MEM for: “ that is very nice demo for getting colors and using mem techniques”.

I figured an example of how to optimize those MEM techniques might be useful as well. ;D

NOVARSEG · « **Reply #7 on:** April 11, 2021, 04:30:11 am »

With MEM, the for next loops are not needed because _MEMIMAGE does all the work.

Slight mod on Steve's code example

Ya I like to DIM everything. If T is DIMed as an INTEGER the code crashes so that's why it is DIMed as a _UNSIGNED LONG

If T is DIMed as a SINGLE it works too, but I think the _UNSIGNED LONG is faster?

That is another reason why DEFINT A-Z is bad practice.

DEFINT A-Z is just like buying a set of tools with one missing.

Code: QB64: [Select]

DIM T AS _UNSIGNED LONG
DIM Handle AS LONG
 
Handle = _NEWIMAGE(500, 500, 32)
 
SCREEN Handle
 
DIM M AS _MEM
M = _MEMIMAGE(Handle)
 
 
DIM r AS _UNSIGNED _BYTE
DIM g AS _UNSIGNED _BYTE
DIM b AS _UNSIGNED _BYTE
DIM a AS _UNSIGNED _BYTE
 
LOCATE 10, 20: PRINT "SIZE OF IMAGE IS "; M.SIZE; "BYTES"
 
 
LL1:
T = 0
DO UNTIL T >= M.SIZE
    b = _MEMGET(M, M.OFFSET + T, _UNSIGNED _BYTE)
    b = b XOR 255
    _MEMPUT M, M.OFFSET + T, b
 
    g = _MEMGET(M, M.OFFSET + T + 1, _UNSIGNED _BYTE)
    g = g XOR 255
    _MEMPUT M, M.OFFSET + T + 1, g
 
    r = _MEMGET(M, M.OFFSET + T + 2, _UNSIGNED _BYTE)
    r = r XOR 0
    _MEMPUT M, M.OFFSET + T + 2, r
 
    T = T + 4
LOOP
 
DO
    i$ = INKEY$
    IF i$ = CHR$(27) THEN EXIT DO
    _DELAY 1: GOTO LL1
LOOP
 
END
 

TempodiBasic · « **Reply #8 on:** April 11, 2021, 06:05:08 am »

@bplus
your squared pattern of colors have ipnotized me!

Cool!

bplus · « **Reply #9 on:** April 11, 2021, 12:33:58 pm »

Quote from: NOVARSEG on April 11, 2021, 04:30:11 am

With MEM, the for next loops are not needed because _MEMIMAGE does all the work.

Slight mod on Steve's code example

Ya I like to DIM everything. If T is DIMed as an INTEGER the code crashes so that's why it is DIMed as a _UNSIGNED LONG

If T is DIMed as a SINGLE it works too, but I think the _UNSIGNED LONG is faster?

That is another reason why DEFINT A-Z is bad practice.

DEFINT A-Z is just like buying a set of tools with one missing.

Code: QB64: [Select]
DIM T AS _UNSIGNED LONG
DIM Handle AS LONG

Handle = _NEWIMAGE(500, 500, 32)

SCREEN Handle

DIM M AS _MEM
M = _MEMIMAGE(Handle)

DIM r AS _UNSIGNED _BYTE
DIM g AS _UNSIGNED _BYTE
DIM b AS _UNSIGNED _BYTE
DIM a AS _UNSIGNED _BYTE

LOCATE 10, 20: PRINT "SIZE OF IMAGE IS "; M.SIZE; "BYTES"

LL1:
T = 0
DO UNTIL T >= M.SIZE
b = _MEMGET(M, M.OFFSET + T, _UNSIGNED _BYTE)
b = b XOR 255
_MEMPUT M, M.OFFSET + T, b

g = _MEMGET(M, M.OFFSET + T + 1, _UNSIGNED _BYTE)
g = g XOR 255
_MEMPUT M, M.OFFSET + T + 1, g

r = _MEMGET(M, M.OFFSET + T + 2, _UNSIGNED _BYTE)
r = r XOR 0
_MEMPUT M, M.OFFSET + T + 2, r

T = T + 4
LOOP

DO
i$ = INKEY$
IF i$ = CHR$(27) THEN EXIT DO
_DELAY 1: GOTO LL1
LOOP

END

Yes, good practice to Dim or ReDIM everything.

@NOVARSEG can you see why T as INTEGER is bad idea?

Quote

DEFINT A-Z is just like buying a set of tools with one missing.

These days we should use DefLng A-Z where we used DEFINT in old days, because Longs may actually be faster certainly wont be significantly slower and gives you much more range.

Missing a tool? Only if you expect that to cover everything. On the other hand, it could serve as a crack filler, automatically dimensioning variables you haven't formally dimensioned.

SMcNeill · « **Reply #10 on:** April 11, 2021, 05:45:07 pm »

T as an integer works fine, as long as your image is less than 32767 bytes. As a long, it works for images less than 2,147,483,647 bytes.

I’d suggest making T an OFFSET, since you’re working with _MEM.

NOVARSEG · « **Reply #11 on:** April 11, 2021, 10:09:41 pm »

A possible bug in QB64??

So I'm running this code

Code: QB64: [Select]

DIM T AS _UNSIGNED LONG
DIM Handle AS LONG
 
Handle = _NEWIMAGE(500, 50, 32)
 
SCREEN Handle
 
DIM M AS _MEM
M = _MEMIMAGE(Handle)
 
 
DIM r AS _UNSIGNED _BYTE
DIM g AS _UNSIGNED _BYTE
DIM b AS _UNSIGNED _BYTE
DIM a AS _UNSIGNED _BYTE
 
'LOCATE 10, 20: PRINT "SIZE OF IMAGE IS "; M.SIZE; "BYTES"
PRINT "SIZE OF IMAGE IS "; M.SIZE; "BYTES"
 
LL1:
T = 0
DO UNTIL T >= M.SIZE
    b = _MEMGET(M, M.OFFSET + T, _UNSIGNED _BYTE)
    b = b XOR 255
    _MEMPUT M, M.OFFSET + T, b
 
    g = _MEMGET(M, M.OFFSET + T + 1, _UNSIGNED _BYTE)
    g = g XOR 255
    _MEMPUT M, M.OFFSET + T + 1, g
 
    r = _MEMGET(M, M.OFFSET + T + 2, _UNSIGNED _BYTE)
    r = r XOR 0
    _MEMPUT M, M.OFFSET + T + 2, r
 
    T = T + 4
LOOP
 
DO
    i$ = INKEY$
    IF i$ = CHR$(27) THEN EXIT DO
    _DELAY 1: GOTO LL1
LOOP
 
END

and can see the text display on screen

when I change
Handle = _NEWIMAGE(500, 50, 32)

to

Handle = _NEWIMAGE(500, 40, 32)

The text no longer displays, why?

more tests
Handle = _NEWIMAGE(500, 48, 32) displays text

Handle = _NEWIMAGE(500, 47, 32) does not display text

NOVARSEG · « **Reply #12 on:** April 11, 2021, 11:23:54 pm »

more tests

changing line

PRINT "SIZE OF IMAGE IS "; M.SIZE; "BYTES"
to
PRINT "SIZE OF IMAGE IS "; M.SIZE; "BYTES";

works.

Handle = _NEWIMAGE(500, 16, 32) displays text

Handle = _NEWIMAGE(500, 15, 32) does not display text

It looks like text is 16 pixels high. Without the semi colon there is an additional 2 lines of what looks to be line feeds

NOVARSEG · « **Reply #13 on:** April 12, 2021, 03:31:26 am »

Blinking cursor with MEM

The lines with MEMGET can be commented out and it still works.

Code: QB64: [Select]

DIM T AS _UNSIGNED LONG
DIM Handle AS LONG
DIM curWidth AS INTEGER
DIM curPosX AS INTEGER
DIM curOffset AS _UNSIGNED LONG
DIM Text AS STRING
 
Text = "Blinking cursor with MEM"
 
Handle = _NEWIMAGE(500, 300, 32)
 
SCREEN Handle
 
DIM M AS _MEM
M = _MEMIMAGE(Handle)
 
 
DIM r AS _UNSIGNED _BYTE
DIM g AS _UNSIGNED _BYTE
DIM b AS _UNSIGNED _BYTE
'DIM a AS _UNSIGNED _BYTE
_FULLSCREEN
curWidth = (_PRINTWIDTH(CHR$(a)) - 2) * 4
 
curPosX = _PRINTWIDTH(Text) * 4
 
PRINT
PRINT Text
 
curOffset = 4 * _WIDTH * (14 + 16) + curPosX
LL1:
 
FOR T = curOffset TO curOffset + curWidth STEP 4
 
    b = _MEMGET(M, M.OFFSET + T, _UNSIGNED _BYTE)
    b = 255
    _MEMPUT M, M.OFFSET + T, b
 
    g = _MEMGET(M, M.OFFSET + T + 1, _UNSIGNED _BYTE)
    g = 255
    _MEMPUT M, M.OFFSET + T + 1, g
 
    r = _MEMGET(M, M.OFFSET + T + 2, _UNSIGNED _BYTE)
    r = 0
    _MEMPUT M, M.OFFSET + T + 2, r
NEXT T
 
_DELAY .3
 
FOR T = curOffset TO curOffset + curWidth STEP 4
 
    b = _MEMGET(M, M.OFFSET + T, _UNSIGNED _BYTE)
    b = 0
    _MEMPUT M, M.OFFSET + T, b
 
    g = _MEMGET(M, M.OFFSET + T + 1, _UNSIGNED _BYTE)
    g = 0
    _MEMPUT M, M.OFFSET + T + 1, g
 
    r = _MEMGET(M, M.OFFSET + T + 2, _UNSIGNED _BYTE)
    r = 0
    _MEMPUT M, M.OFFSET + T + 2, r
NEXT T
 
_DELAY .3
i$ = INKEY$
IF i$ = CHR$(27) THEN END
GOTO LL1
 

NOVARSEG · « **Reply #14 on:** April 12, 2021, 04:30:25 am »

Moving cursor with MEM

Code: QB64: [Select]

DIM T AS _UNSIGNED LONG
DIM Handle AS LONG
DIM curWidth AS INTEGER
DIM curPosX AS INTEGER
DIM curOffset AS _UNSIGNED LONG
DIM Text AS STRING
 
Text = "Moving cursor with MEM"
 
Handle = _NEWIMAGE(400, 400, 32)
 
SCREEN Handle
 
DIM M AS _MEM
M = _MEMIMAGE(Handle)
 
DIM r AS _UNSIGNED _BYTE
DIM g AS _UNSIGNED _BYTE
DIM b AS _UNSIGNED _BYTE
'DIM a AS _UNSIGNED _BYTE
_FULLSCREEN
curWidth = (_PRINTWIDTH(CHR$(a)) - 2) * 4
 
curPosX = _PRINTWIDTH(Text) * 4
 
PRINT
PRINT "  l to move left, r to move right"
PRINT Text
 
curOffset = 4 * _WIDTH * (15 + 32) + curPosX
FOR T = curOffset TO curOffset + curWidth STEP 4
 
    'b = _MEMGET(M, M.OFFSET + T, _UNSIGNED _BYTE)
    b = 255
    _MEMPUT M, M.OFFSET + T, b
 
    'g = _MEMGET(M, M.OFFSET + T + 1, _UNSIGNED _BYTE)
    g = 255
    _MEMPUT M, M.OFFSET + T + 1, g
 
    ' r = _MEMGET(M, M.OFFSET + T + 2, _UNSIGNED _BYTE)
    r = 0
    _MEMPUT M, M.OFFSET + T + 2, r
NEXT T
 
DO
    i$ = INKEY$
    IF i$ = CHR$(27) THEN END
 
    IF i$ = "l" AND curPosX > 0 THEN
        GOSUB curoff
        curPosX = curPosX - _PRINTWIDTH(CHR$(a)) * 4
        curOffset = 4 * _WIDTH * (15 + 32) + curPosX
        GOSUB curon
    END IF
 
    IF i$ = "r" AND curPosX + _PRINTWIDTH(CHR$(a)) * 4 < _WIDTH * 4 THEN
        GOSUB curoff
        curPosX = curPosX + _PRINTWIDTH(CHR$(a)) * 4
        curOffset = 4 * _WIDTH * (15 + 32) + curPosX
        GOSUB curon
    END IF
LOOP
 
curon:
FOR T = curOffset TO curOffset + curWidth STEP 4
 
    'b = _MEMGET(M, M.OFFSET + T, _UNSIGNED _BYTE)
    b = 255
    _MEMPUT M, M.OFFSET + T, b
 
    'g = _MEMGET(M, M.OFFSET + T + 1, _UNSIGNED _BYTE)
    g = 255
    _MEMPUT M, M.OFFSET + T + 1, g
 
    ' r = _MEMGET(M, M.OFFSET + T + 2, _UNSIGNED _BYTE)
    r = 0
    _MEMPUT M, M.OFFSET + T + 2, r
NEXT T
 
RETURN
 
 
curoff:
 
FOR T = curOffset TO curOffset + curWidth STEP 4
 
    'b = _MEMGET(M, M.OFFSET + T, _UNSIGNED _BYTE)
    b = 0
    _MEMPUT M, M.OFFSET + T, b
 
    ' g = _MEMGET(M, M.OFFSET + T + 1, _UNSIGNED _BYTE)
    g = 0
    _MEMPUT M, M.OFFSET + T + 1, g
 
    'r = _MEMGET(M, M.OFFSET + T + 2, _UNSIGNED _BYTE)
    r = 0
    _MEMPUT M, M.OFFSET + T + 2, r
NEXT T
RETURN
 

News:

Author Topic: Xor Magic ^2 (Read 14795 times)

bplus

Xor Magic ^2

euklides

Re: Xor Magic ^2

Ashish

Re: Xor Magic ^2

bplus

Re: Xor Magic ^2

SMcNeill

Re: Xor Magic ^2

bplus

Re: Xor Magic ^2

SMcNeill

Re: Xor Magic ^2

NOVARSEG

Re: Xor Magic ^2

TempodiBasic

Re: Xor Magic ^2

bplus

Re: Xor Magic ^2

SMcNeill

Re: Xor Magic ^2

NOVARSEG

Re: Xor Magic ^2

NOVARSEG

Re: Xor Magic ^2

NOVARSEG

Re: Xor Magic ^2

NOVARSEG

Re: Xor Magic ^2