NES MMMM logo display with shimmer palette animation using https://github.com/kassane/zig-mos-bootstrap

mmmm-logo.zig

//! NES MMMM logo display with shimmer palette animation.
const neslib = @import("neslib");

/// Nametable address for tile at column `col`, row `row` on nametable A ($2000).
fn ntadr(col: u8, row: u8) u16 {
    return 0x2000 | (@as(u16, row) << 5) | col;
}

/// 16×16 tile map for the mark, anchored at (logo_col, logo_row).
/// Generated from mmmm-mark.chr (CHR plane 0 only).
const logo_col: u8 = 11;
const logo_row: u8 = 8;
const logo: [16][16]u8 = .{
    .{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F },
    .{ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F },
    .{ 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F },
    .{ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F },
    .{ 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F },
    .{ 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F },
    .{ 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F },
    .{ 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F },
    .{ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F },
    .{ 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F },
    .{ 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF },
    .{ 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF },
    .{ 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF },
    .{ 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF },
    .{ 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF },
    .{ 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF },
};

/// Shimmer sequence: palette slot 1 cycle (~8 frames each).
const shimmer: [8]u8 = .{ 0x19, 0x1A, 0x1A, 0x19, 0x19, 0x1A, 0x1A, 0x19 };

export fn main() callconv(.c) void {
    const bg_palette: [16]u8 = .{
        0x0f, 0x00, 0x27, 0x30,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
    };

    neslib.ppu_off();
    neslib.pal_bg(&bg_palette);

    for (logo, 0..) |row, ty| {
        const y: u8 = @intCast(ty);

        neslib.vram_adr(ntadr(logo_col, logo_row + y));
        neslib.vram_write(&row, 11);
    }

    neslib.ppu_on_all();

    var frame: u8 = 0;

    while (true) {
        neslib.ppu_wait_nmi();
        neslib.pal_col(1, shimmer[(frame >> 4) & 7]);
        frame +%= 1;
    }
}

chr-converter.go

package main

import (
	"errors"
	"flag"
	"fmt"
	"image"
	"image/color"
	"image/png"
	"log"
	"os"
	"path/filepath"
	"strings"
)

const (
	ImageWidth  = 128
	ImageHeight = 128
	NumSprites  = 256
	SpriteSize  = 8
	CHRSize     = 4096
)

func indexesFromImage(img *image.Paletted, spriteIdx int) ([]uint8, error) {
	if spriteIdx < 0 || spriteIdx >= NumSprites {
		return nil, fmt.Errorf("invalid sprite index: %d", spriteIdx)
	}

	spriteX := (spriteIdx % 16) * SpriteSize
	spriteY := (spriteIdx / 16) * SpriteSize

	values := make([]uint8, 64)

	for y := range SpriteSize {
		for x := range SpriteSize {
			idx := img.ColorIndexAt(spriteX+x, spriteY+y)

			if idx > 3 {
				return nil, fmt.Errorf("palette index out of range: %d", idx)
			}

			values[y*8+x] = idx
		}
	}

	return values, nil
}

func pixelValuesToCHR(values []uint8) ([]byte, error) {
	if len(values) != 64 {
		return nil, errors.New("expected 64 pixel values")
	}

	out := make([]byte, 16)

	for row := range 8 {
		var plane0 byte
		var plane1 byte

		for col := range 8 {
			v := values[row*8+col]

			plane0 |= (v & 0x01) << (7 - col)
			plane1 |= ((v >> 1) & 0x01) << (7 - col)
		}

		out[row] = plane0
		out[row+8] = plane1
	}

	return out, nil
}

func pngToCHR(pngFile, chrFile string) error {
	fmt.Printf("PNG to CHR: %s -> %s\n", pngFile, chrFile)

	f, err := os.Open(pngFile)
	if err != nil {
		return err
	}
	defer f.Close()

	imgDecoded, err := png.Decode(f)
	if err != nil {
		return err
	}

	paletted, ok := imgDecoded.(*image.Paletted)
	if !ok {
		return errors.New("expected indexed PNG (paletted image)")
	}

	bounds := paletted.Bounds()
	if bounds.Dx() != ImageWidth || bounds.Dy() != ImageHeight {
		return fmt.Errorf(
			"expected %dx%d image, got %dx%d",
			ImageWidth,
			ImageHeight,
			bounds.Dx(),
			bounds.Dy(),
		)
	}

	var chrData []byte

	for spriteIdx := range NumSprites {
		values, err := indexesFromImage(paletted, spriteIdx)
		if err != nil {
			return err
		}

		chrBytes, err := pixelValuesToCHR(values)
		if err != nil {
			return err
		}

		chrData = append(chrData, chrBytes...)
	}

	if len(chrData) != CHRSize {
		return fmt.Errorf("generated CHR data size mismatch: %d", len(chrData))
	}

	return os.WriteFile(chrFile, chrData, 0644)
}

func chrToPixelValues(chrData []byte) ([]uint8, error) {
	if len(chrData) != 16 {
		return nil, errors.New("expected 16 bytes of CHR data")
	}

	values := make([]uint8, 64)

	for pixelID := range 64 {
		byteID1 := pixelID / 8
		byteID2 := byteID1 + 8

		bitID := 7 - (pixelID % 8)

		bit1 := (chrData[byteID1] >> bitID) & 0x01
		bit2 := (chrData[byteID2] >> bitID) & 0x01

		values[pixelID] = (bit1 << 1) | bit2
	}

	return values, nil
}

func addIndexesToImage(img *image.Paletted, values []uint8, spriteIdx int) error {
	if len(values) != 64 {
		return errors.New("expected 64 pixel values")
	}

	if spriteIdx < 0 || spriteIdx >= NumSprites {
		return fmt.Errorf("invalid sprite index: %d", spriteIdx)
	}

	spriteX := (spriteIdx % 16) * SpriteSize
	spriteY := (spriteIdx / 16) * SpriteSize

	for y := range SpriteSize {
		for x := range SpriteSize {
			img.SetColorIndex(
				spriteX+x,
				spriteY+y,
				values[y*8+x],
			)
		}
	}

	return nil
}

func chrToPNG(chrFile, pngFile string) error {
	data, err := os.ReadFile(chrFile)
	if err != nil {
		return err
	}

	// Accept 4KB or 8KB, but ALWAYS use only bank 0
	if len(data) != 4096 && len(data) != 8192 {
		return fmt.Errorf(
			"expected 4096 or 8192 bytes in %s, got %d",
			chrFile,
			len(data),
		)
	}

	// Always truncate to first bank (256 sprites)
	data = data[:4096]

	palette := color.Palette{
		color.RGBA{0x00, 0x00, 0x00, 0xff},
		color.RGBA{0x7c, 0x7c, 0x7c, 0xff},
		color.RGBA{0xbc, 0xbc, 0xbc, 0xff},
		color.RGBA{0xfc, 0xfc, 0xfc, 0xff},
	}

	img := image.NewPaletted(
		image.Rect(0, 0, ImageWidth, ImageHeight),
		palette,
	)

	for spriteIdx := range NumSprites {
		start := spriteIdx * 16
		end := start + 16

		values, err := chrToPixelValues(data[start:end])
		if err != nil {
			return err
		}

		if err := addIndexesToImage(img, values, spriteIdx); err != nil {
			return err
		}
	}

	outFile, err := os.Create(pngFile)
	if err != nil {
		return err
	}
	defer outFile.Close()

	return png.Encode(outFile, img)
}

func run(args []string) error {
	var output string

	fs := flag.NewFlagSet(args[0], flag.ContinueOnError)

	fs.StringVar(&output, "output", "", "output filename")

	if err := fs.Parse(args[1:]); err != nil {
		return err
	}

	if fs.NArg() != 1 {
		return fmt.Errorf("usage: %s [options] INPUT", args[0])
	}

	input := fs.Arg(0)

	if strings.HasSuffix(strings.ToLower(input), ".png") {
		if output == "" {
			output = strings.TrimSuffix(input, filepath.Ext(input)) + ".chr"
		}

		return pngToCHR(input, output)
	}

	if output == "" {
		output = strings.TrimSuffix(input, filepath.Ext(input)) + ".png"
	}

	return chrToPNG(input, output)
}

func main() {
	if err := run(os.Args); err != nil {
		log.Fatal(err)
	}
}

Zig examples targeting MOS 6502 platforms via zig-mos-bootstrap and llvm-mos-sdk