2BPP data structure

[computermouth]

Howdy folks, new to wasm, new to wasm4, super cool to be playing with it in a fantasy console, wasm4 is awesome so far!

Anyway, similar to this question #422, I was trying to build a data structure that's as easily drawable in code as the 1BPP binary images. I landed on this using bitfields in C.

#include "wasm4.h"

struct short2bpp {
	uint8_t n0: 2;
	uint8_t n1: 2;
	uint8_t n2: 2;
	uint8_t n3: 2;
	uint8_t n4: 2;
	uint8_t n5: 2;
	uint8_t n6: 2;
	uint8_t n7: 2;
};

void update () {

    *DRAW_COLORS = 0x1234;
    struct short2bpp sprite_bpp[] = {
        {1,1,1,1,1,1,1,1},
        {1,0,0,0,1,1,1,1},
        {1,0,0,0,1,1,1,1},
        {1,0,0,0,1,1,1,1},
        {1,3,3,3,2,2,2,1},
        {1,3,3,3,2,2,2,1},
        {1,3,3,3,2,2,2,1},
        {1,1,1,1,1,1,1,1},
    };
	
    blit((const uint8_t *)sprite_bpp, 64, 64, 8, 8, BLIT_2BPP);
}

I feel like it should work, and it draws something pretty close to what I expect, but not quite. At first I thought that C alignment and packing might be the issue, but the structs are exactly 2 bytes, where each should be a valid 8 pixel line.

Any suggestions?

[computermouth]

I think I've found the issue, for some reason, the way that the wasm-sdk (or maybe C toolchains in general) pack these bitfields is similar to a switch in endianness. This printed test seems to show that

#include <stdio.h>
#include <stdint.h>

typedef union {
    struct {
        uint8_t n0: 2;
        uint8_t n1: 2;
        uint8_t n2: 2;
        uint8_t n3: 2;
        uint8_t n4: 2;
        uint8_t n5: 2;
        uint8_t n6: 2;
        uint8_t n7: 2;
    };
    uint16_t shrt;
} short2bpp;

int main () {
    
    short2bpp sprite_bpp[] = {
    	{{3,1,1,1,1,1,1,1}},
    };
    printf("%u\n", sprite_bpp[0].shrt);
    
    uint16_t shrt = 
          (3 << 14)
        + (1 << 12)
        + (1 << 10)
        + (1 <<  8)
        + (1 <<  6)
        + (1 <<  4)
        + (1 <<  2)
        + (1      );
    printf("%u\n", shrt);
    
    uint16_t shrt2 = 
          (3      )
        + (1 <<  2)
        + (1 <<  4)
        + (1 <<  6)
        + (1 <<  8)
        + (1 << 10)
        + (1 << 12)
        + (1 << 14);
    printf("%u\n", shrt2);
    
    return 0;
}

// output
//
// 21847
// 54613
// 21847

As you can see from the output, the number matches the one with a sort of backwards sorted set of two bit chunks :/

Oh well, maybe I can redo this as a macro to build these in reverse somehow. Or just actually use the image builder tools :P

[computermouth]

It turns out the bit packing was weirder than I expected, in that each nib was in reverse order per each byte. For future readers, this isn't anything specific to wasm4, but I think rather platform and/or toolchain dependent. Here's the solution I landed on, which requires reordering the nibs after creating the struct, but otherwise draws as you would expect:

#include "wasm4.h"

typedef struct {
	uint8_t n0: 2;
	uint8_t n1: 2;
	uint8_t n2: 2;
	uint8_t n3: 2;
	uint8_t n4: 2;
	uint8_t n5: 2;
	uint8_t n6: 2;
	uint8_t n7: 2;
} raw2bpp_t;

void pack2bpp(raw2bpp_t * s, uint32_t width, uint32_t height) {
	for(uint32_t i = 0; i < (width * height) / 8; i++){
		raw2bpp_t tmp = {
			.n0 = s[i].n3,
			.n1 = s[i].n2,
			.n2 = s[i].n1,
			.n3 = s[i].n0,
			.n4 = s[i].n7,
			.n5 = s[i].n6,
			.n6 = s[i].n5,
			.n7 = s[i].n4,
		};
		s[i] = tmp;
	}
}

void update () {
	
	PALETTE[0] = 0x2c2c2c;
	PALETTE[1] = 0xff0000;
	PALETTE[2] = 0x00ff00;
	PALETTE[3] = 0x0000ff;

	*DRAW_COLORS = 0x1234;
	raw2bpp_t sprite_bpp[] = {
		{1,1,1,1,1,1,1,1},
		{1,0,0,0,1,1,1,1},
		{1,0,0,0,1,1,1,1},
		{1,0,0,0,1,1,1,1},
		{1,3,3,3,2,2,2,1},
		{1,3,3,3,2,2,2,1},
		{1,3,3,3,2,2,2,1},
		{1,1,1,1,1,1,1,1},
	};
	pack2bpp(sprite_bpp, 8, 8);
	
    blit((const uint8_t *)sprite_bpp, 76, 76, 8, 8, BLIT_2BPP);
}

[aduros]

Thanks for the info @computermouth, I actually didn't know C had sized bitfield syntax! It might be interesting to compare how this works vs other languages with this feature, eg: zig.

[computermouth]

It's one of my favorite newer (in terms of C-time) features! I took a quick peek around at bitfields in rust, seems like there's a couple crates out there with some macros that looked usable. But I've never used them outside of C, myself.

I'm not sure it's quite worth the trouble, given that you can't really peek/poke into your sprite arrays the same as you would with 1-bit images. You'd have to copy the original data structure, modify, and repack; oorrrrr you could run a de-convert function, modify, repack, unless you wanted to peek/poke with the kind of backwards coordinates.

Anyway I think I might make a little util library to do some of these things, and push it up with a demo cart some time.