Clear pixels

[michaelsarr]

So playing around with scrolling some backgrounds one the 3 planes
Is there a clear color in the palates…

The background of my images is overlapping with other layers.

The scrolling is pretty smooth.

[rumbledethumps]

Nice. I think what you need is in the docs. Search for this...

The built-in ANSI color palette has the alpha bit mask set on all colors except color 0 black.

[vruumllc]

maybe
COLOR_FROM_RGB8(r,g,b) & ~COLOR_ALPHA_MASK
for the moon layer?

[michaelsarr]

back in the day i wrote a couple games using the allegro c library and there was some teal color that would always get rendered as clear
so you could use it for the background on images then display them to the screen and they could sit on top of other layers.
im a bit confused here because the screen default defaults to black.. the space between the trees is black so i cant put the moon behind the trees because it wont be visible.
if I make the border any color other than black then display it to the screen the borders of the image would be visible against the black background and not blend it so everything still looks like a square.

seems like I would need to pick a specific color then default the background of any images to that then create 2 or 3 images that repeat in strips to fill the entire canvas then I could have the background of the canvas something other than black
OR make a custom palate where black has opacity on.

it will take some experimentation

[michaelsarr]

anyone know where the ANSI 8 bit color palatte is defined?

[rumbledethumps]

https://en.wikipedia.org/wiki/ANSI_escape_code

[brentward]

Here is my attempt. I used @rumbledethumps python code to convert a PNG. I used a hex editor to manually set the 5th bit on the colors I wanted opaque in the palette at the beginning of the BIN it generates, then I modified the python to make every color but black be opaque, but you could easily pick any color other than black to be transparent. I was running out of vram for my stick figure so I used ansi colors for it. My code is here: https://github.com/brentward/paralax/blob/main/src/hello.c and the bin files are included in the repository.
This is how I modified the python code to make black transparent:

from PIL import Image

def rp6502_rgb(r,g,b):
    if r == 0 and g == 0 and b == 0:
        return 0
    else:
        return ((((b>>3)<<11)|((g>>3)<<6)|(r>>3))|1<<5)

try:
    with open("tree2.bin", "wb") as o:
        with Image.open('tree2.png') as im:
            im2 = im.convert("P", palette=Image.ADAPTIVE, colors=256)
            for r,g,b in zip(*[iter(im2.getpalette())]*3):
                o.write(rp6502_rgb(r,g,b).to_bytes(2, byteorder='little', signed=False))
            for y in range(0, im2.height):
                for x in range(0, im2.width):
                    o.write(im2.getpixel((x,y)).to_bytes(1, byteorder='little', signed=False))
except OSError:
    print("cannot")

IMG_8430.MOV

[rumbledethumps]

Awesome! I took a detour to work on input systems so I haven't even tried to do something like this yet.

Memory will be less of a challenge when tile and character modes get added. I'm sure you've already got both barrels loaded with ideas.

[michaelsarr]

IMG_6250.mp4

you beat me to it ...

i certainly need to work on getting some sprites working
i put in a little bodge in my image converter to set the transparancy bit for black or magic pink ff00ff

[rumbledethumps]

Wow!

[michaelsarr]

did a little work on this today

IMG_6257.mp4

[rumbledethumps]

Direct keyboard input is in main and the docs (as of today). It's a bitfield of all the keys so you can detect when they are being held or released. Perfect for video games like this.

Joysticks are a ways off, so don't be waiting on that.

[brentward]

I noticed with my last scene that when I changed the vga mode from 0 to 1 to prevent letterboxing I started getting the half blue screen meaning I was exceeding the fill rate capabilities. So I started experimenting with 4 bit per pixel stuff which let me get past the fill rate issue and I had more memory to increase the complexity of the animation slightly.

This one was done in 4 bit per pixel mode.

I made another script to truncate an 8 bpp palette to 4 bpp and to pack the pixel data from 8 bpp to 4 bpp. The memory was less constrained using 4 bpp. The scripts is pretty rough and doesn't do color conversion and only works correctly on specific image resolutions. It uses the binary output from the conversion script I posed above and requires that the pixel data itself already only be using 16 colors or less. But I thought it could be helpful to someone.

import argparse
import struct


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("in_file", help="bin file to split")
    parser.add_argument("-op", "--out-palette", dest="out_palette", help="Optional output palette file name")
    parser.add_argument("-od", "--out-data", dest="out_data", help="Optional output data file name")
    args = parser.parse_args()
    if args.out_palette is None:
        out_palette = f"{args.in_file.rsplit('.', 1)[0]}.palette.bin"
    else:
        out_palette = args.out_file
    if args.out_data is None:
        out_data = f"{args.in_file.rsplit('.', 1)[0]}.data.bin"
    else:
        out_data = args.out_file

    try:
        with open(out_palette, "wb") as op:
            with open(out_data, "wb") as od:
                with open(args.in_file, "rb") as bin:
                    op.write(bin.read(0x020))
                    bin.seek(0x200)
                    while True:
                        two_bytes = bin.read(2)
                        if not two_bytes:
                            break
                        one_byte = ((two_bytes[0] & 0xF) << 4)| (two_bytes[1] & 0xF)
                        # if len(two_bytes) > 1:
                        #     one_byte = ((two_bytes[0] & 0xF) << 4)| (two_bytes[1] & 0xF)
                        # else:
                        #     one_byte = (two_bytes[0] & 0xF) << 4
                        od.write(struct.pack("=B",one_byte))
    except OSError:
        print("cannot")

if __name__ == '__main__':
    main()    

IMG_8432.MOV

[rumbledethumps]

Just a heads up that I plan on adding a 4-color mode and renumbering the options to insert it.

[rumbledethumps]

2bpp is done. Docs and examples updated. This should help with memory pressure.

[brentward]

I tried recompiling my 4bpp test demo for Version 0.3 after changing the OPTION setting from 1 to 2 to account for the change extra options. It compiles and runs but I'm now getting a half blue screen on one of the planes so I'm hitting fill rate limits whereas in version 0.2 it ran without hitting a limit. Is it expected that this version will have less fill rate capabilities?

I've pushed the code I'm using here: https://github.com/brentward/paralax/tree/main in case you want to see if you can duplicate it.

[rumbledethumps]

Try making mode3_fill_cols() inline and see if that helps. Just add the inline keyword before static.

The render methods can be greatly optimized in assembly, but that's a huge amount of work there's no funding for. Correctness is the priority right now. Also need a benchmark tool before optimization can be done effectively.

[rumbledethumps]

The inline fixed it for me. I made it permanent for the next release. picocomputer/rp6502@ab89cdd

[michaelsarr]

lots of stuff going on .. ive been down with covid all week, feeling better today going to get in a play around with the 2bpp for the invaders

[brentward]

I just got a chance to try the inline fix and it works for me too, thanks!

The inline fixed it for me. I made it permanent for the next release. picocomputer/rp6502@ab89cdd