Something went wrong. Try again.
Monorepo for Aesthetic.Computer aesthetic.computer
Something went wrong. Try again.
21 kB · 600 lines
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601// BUILD_TARGET: CGB#include <gb/gb.h>#include <gb/cgb.h>#include <stdio.h>#include <gbdk/console.h>#include <string.h>#include <rand.h>
#include "aesthetic_boot.h"
// Canvas settings - tile it 32 tiles wide for smooth 256-pixel wrap#define CANVAS_TILE_X 0 // Start at left edge#define CANVAS_TILE_Y 0 // Start at top#define CANVAS_TILE_WIDTH 32 // 32 tiles wide (256 pixels -> wraps nicely)#define CANVAS_TILE_COLS 16 // Unique tile columns (16 × 8px = 128px) - divides 32 evenly!#define CANVAS_TILE_ROWS 16 // Unique tile rows (16 × 8px = 128px) - divides 32 evenly!#define VIEW_TILE_HEIGHT 18 // Visible tile rows (144px)#define BG_MAP_TILE_WIDTH 32 // Full background map width (tiles)#define BG_MAP_TILE_HEIGHT 32 // Full background map height (tiles)#define CANVAS_UNIQUE_WIDTH (CANVAS_TILE_COLS * 8) // 128px of unique data#define CANVAS_UNIQUE_HEIGHT (CANVAS_TILE_ROWS * 8) // 128px of unique data#define CANVAS_WORLD_WIDTH (CANVAS_TILE_WIDTH * 8) // 256 pixels displayed before wrap#define BG_WORLD_HEIGHT (BG_MAP_TILE_HEIGHT * 8) // 256px tall background#define VIEW_HEIGHT (VIEW_TILE_HEIGHT * 8) // 144px visible window#define CANVAS_WIDTH CANVAS_WORLD_WIDTH // For legacy checks#define CANVAS_HEIGHT BG_WORLD_HEIGHT#define CANVAS_FIRST_TILE 0 // Use entire tile index range#define CANVAS_NUM_TILES (CANVAS_TILE_ROWS * CANVAS_TILE_COLS) // 16 columns × 16 rows = 256 tiles#define WORLD_SCROLL_MASK 0x0FFF#define BG_SCROLL_MASK (BG_WORLD_HEIGHT - 1)#define TILE_BANK_THRESHOLD 256
// Canvas tile data - all tiles stored in one arrayuint8_t canvas_tiles[CANVAS_NUM_TILES * 16]; // 256 tiles * 16 bytes each
// Current drawing color (0-3)uint8_t current_color = 3;uint8_t last_color = 0; // Track last color to avoid repeatsuint8_t current_palette = 0; // Which palette we're currently using
// Rolling wavetable bufferuint8_t wave_buffer[16]; // 16 bytes = 32 4-bit samplesuint16_t last_scroll_x = 0; // Track when to shift buffer
// Incremental line drawing statetypedef struct { int16_t x, y; // Current position int16_t x1, y1; // End position int16_t dx, dy; int16_t sx, sy; int16_t err; uint8_t active; uint16_t pixels_drawn; // Track how many pixels have been drawn} line_state_t;
static line_state_t line_state;
// Forward declarationsvoid plot_pixel(int16_t x, int16_t y);void upload_tile_to_vram(uint16_t tile_idx);
// Function to sample pixels from visible region and create wavetablevoid update_sound_from_pixels(uint16_t scroll_x, uint16_t scroll_y) { // STRIP-BASED APPROACH: Divide 144 pixels into 4 horizontal strips // Strip 0 (y: 0-35): CH1 (Pulse with sweep) // Strip 1 (y: 36-71): CH2 (Pulse) // Strip 2 (y: 72-107): CH3 (Wavetable) // Strip 3 (y: 108-143): CH4 (Noise) // Sample from center of screen (x = 80, middle of 160 pixel width) uint16_t sample_x = (scroll_x + 80) & (CANVAS_WIDTH - 1); uint16_t unique_x = sample_x % CANVAS_UNIQUE_WIDTH; uint8_t sample_tile_x = unique_x >> 3; uint8_t sample_pixel_x = unique_x & 7; uint8_t ch1_count = 0, ch2_count = 0, ch3_count = 0, ch4_count = 0; uint16_t ch1_y_sum = 0, ch2_y_sum = 0, ch3_y_sum = 0, ch4_y_sum = 0; // Clear wave buffer for CH3 for(uint8_t i = 0; i < 16; i++) { wave_buffer[i] = 0x00; } // Sample every pixel in center column, assign to strips for(uint8_t y_offset = 0; y_offset < 144; y_offset++) { uint16_t y = (scroll_y + y_offset) & BG_SCROLL_MASK; uint16_t unique_y = y % CANVAS_UNIQUE_HEIGHT; uint8_t canvas_tile_y = unique_y >> 3; uint8_t pixel_y = unique_y & 7; uint16_t tile_idx = (canvas_tile_y * CANVAS_TILE_COLS) + sample_tile_x; uint8_t byte0 = canvas_tiles[tile_idx * 16 + (pixel_y * 2)]; uint8_t byte1 = canvas_tiles[tile_idx * 16 + (pixel_y * 2) + 1]; uint8_t bit_mask = 0x80 >> sample_pixel_x; uint8_t color = ((byte0 & bit_mask) ? 1 : 0) | ((byte1 & bit_mask) ? 2 : 0); if(color > 0) { // Determine which strip (36 pixels each) if(y_offset < 36) { // Strip 0: CH1 ch1_count++; ch1_y_sum += y_offset; } else if(y_offset < 72) { // Strip 1: CH2 ch2_count++; ch2_y_sum += y_offset; } else if(y_offset < 108) { // Strip 2: CH3 (build wavetable) ch3_count++; ch3_y_sum += y_offset; // Build wavetable from pixel patterns (2 grains per pixel) uint8_t base_sample = ((y_offset - 72) * 32) / 36; for(uint8_t grain = 0; grain < 2; grain++) { uint8_t sample_idx = (base_sample + grain) & 0x1F; uint8_t byte_idx = sample_idx >> 1; uint8_t nibble_idx = sample_idx & 1; uint8_t add_val = 2; if(nibble_idx == 0) { uint8_t current = (wave_buffer[byte_idx] >> 4) & 0x0F; uint8_t new_val = current + add_val; if(new_val > 0xF) new_val = 0xF; wave_buffer[byte_idx] = (new_val << 4) | (wave_buffer[byte_idx] & 0x0F); } else { uint8_t current = wave_buffer[byte_idx] & 0x0F; uint8_t new_val = current + add_val; if(new_val > 0xF) new_val = 0xF; wave_buffer[byte_idx] = (wave_buffer[byte_idx] & 0xF0) | new_val; } } } else { // Strip 3: CH4 ch4_count++; ch4_y_sum += y_offset; } } } // CH1 & CH2: Disabled (wavetable only) NR12_REG = 0x00; NR22_REG = 0x00; // CH3 (Strips 0 & 1: wavetable synth) uint8_t total_count = ch1_count + ch2_count; if(total_count > 0) { // Combine pixels from both top strips uint16_t combined_y = 0; if(ch1_count > 0) combined_y += ch1_y_sum / ch1_count; if(ch2_count > 0) combined_y += (ch2_y_sum / ch2_count); uint8_t avg_y = combined_y / ((ch1_count > 0 ? 1 : 0) + (ch2_count > 0 ? 1 : 0)); // Update wavetable based on pixel density NR30_REG = 0x00; for(uint8_t i = 0; i < 16; i++) { *(uint8_t*)(0xFF30 + i) = wave_buffer[i]; } NR30_REG = 0x80; NR32_REG = (total_count > 10) ? 0x40 : 0x60; // Y position controls pitch (0-71 range) uint16_t freq = 0x700 - (avg_y << 3); if(freq < 0x400) freq = 0x400; if(freq > 0x750) freq = 0x750; NR33_REG = freq & 0xFF; NR34_REG = 0x80 | ((freq >> 8) & 0x07); } else { NR30_REG = 0x00; } // CH4 (Strips 2 & 3: noise channel for rhythmic texture) total_count = ch3_count + ch4_count; if(total_count > 0) { // Combine pixels from both bottom strips uint16_t combined_y = 0; if(ch3_count > 0) combined_y += (ch3_y_sum / ch3_count) - 72; if(ch4_count > 0) combined_y += (ch4_y_sum / ch4_count) - 72; uint8_t avg_y = combined_y / ((ch3_count > 0 ? 1 : 0) + (ch4_count > 0 ? 1 : 0)); uint8_t vol = (total_count > 8) ? 0x0D : 0x08; // Y position controls noise character (0-71 normalized range) uint8_t noise_param = avg_y >> 3; // 0-8 range NR41_REG = 0x10; // Medium length NR42_REG = (vol << 4) | 0x05; NR43_REG = 0x20 | (noise_param & 0x0F); NR44_REG = 0xC0; } else { NR42_REG = 0x00; } // Stereo panning: assign each strip to different channels uint8_t pan = 0x00; if(ch1_count > 0) pan |= 0x11; // CH1 both if(ch2_count > 0) pan |= 0x22; // CH2 both if(ch3_count > 0) pan |= 0x44; // CH3 both if(ch4_count > 0) pan |= 0x88; // CH4 both NR51_REG = pan ? pan : 0xFF;}
void upload_tile_to_vram(uint16_t tile_idx) { uint8_t tile_bank = (tile_idx >= TILE_BANK_THRESHOLD) ? 1 : 0; uint8_t tile_id = tile_idx & 0xFF; VBK_REG = tile_bank; set_bkg_data(tile_id, 1, &canvas_tiles[tile_idx * 16]); VBK_REG = 0;}
void build_canvas_background_map(void) { uint8_t tile_row[BG_MAP_TILE_WIDTH]; uint8_t attr_row[BG_MAP_TILE_WIDTH];
for(uint8_t ty = 0; ty < BG_MAP_TILE_HEIGHT; ty++) { for(uint8_t tx = 0; tx < BG_MAP_TILE_WIDTH; tx++) { // Calculate which unique canvas tile this screen position maps to uint8_t canvas_x = tx % CANVAS_TILE_COLS; // 0-15 uint8_t canvas_y = ty % CANVAS_TILE_ROWS; // 0-15 uint16_t tile_idx = (canvas_y * CANVAS_TILE_COLS) + canvas_x; tile_row[tx] = tile_idx; attr_row[tx] = current_palette; // Use current palette for whole canvas }
set_bkg_tiles(0, ty, BG_MAP_TILE_WIDTH, 1, tile_row);
VBK_REG = 1; set_bkg_tiles(0, ty, BG_MAP_TILE_WIDTH, 1, attr_row); VBK_REG = 0; }}
void seed_canvas_tiles(void) { // Initialize all tiles to black (empty) memset(canvas_tiles, 0, sizeof(canvas_tiles)); // Create regular patterns across all 4 strips with spacing // Strip 0 (y: 0-35) - horizontal lines with gaps for(uint16_t x = 0; x < CANVAS_UNIQUE_WIDTH; x += 8) { for(uint16_t len = 0; len < 4; len++) { plot_pixel(x + len, 10); plot_pixel(x + len, 25); } } // Strip 1 (y: 36-71) - diagonal lines for(uint16_t x = 0; x < CANVAS_UNIQUE_WIDTH; x += 12) { for(uint8_t d = 0; d < 6; d++) { plot_pixel(x + d, 45 + d); } } // Strip 2 (y: 72-107) - vertical dashes for(uint16_t x = 5; x < CANVAS_UNIQUE_WIDTH; x += 10) { for(uint16_t y = 80; y < 100; y += 4) { plot_pixel(x, y); plot_pixel(x, y + 1); } } // Strip 3 (y: 108-143) - scattered grid for(uint16_t x = 0; x < CANVAS_UNIQUE_WIDTH; x += 15) { for(uint16_t y = 110; y < 140; y += 10) { plot_pixel(x, y); plot_pixel(x + 1, y); plot_pixel(x, y + 1); plot_pixel(x + 1, y + 1); } }}
// Plot a pixel in the canvas with current colorvoid plot_pixel(int16_t x, int16_t y) { if(y < 0 || y >= CANVAS_HEIGHT) return; // Only draw in the visible canvas area if(x < 0) return; // Wrap visible world coordinates into the unique tile data footprint uint16_t world_x = (uint16_t)x & (CANVAS_WIDTH - 1); uint16_t unique_x = world_x % CANVAS_UNIQUE_WIDTH; uint16_t unique_y = ((uint16_t)y) % CANVAS_UNIQUE_HEIGHT; // Calculate which canvas tile this pixel belongs to uint8_t canvas_tile_x = unique_x >> 3; // Divide by 8 (0-13) uint8_t canvas_tile_y = unique_y >> 3; // Divide by 8 (0-17) uint8_t pixel_x = unique_x & 7; // Modulo 8 uint8_t pixel_y = unique_y & 7; // Calculate the tile index in our canvas array (14 tiles wide × 18 tiles high) uint16_t tile_idx = (canvas_tile_y * CANVAS_TILE_COLS) + canvas_tile_x; // Calculate the byte offset in the canvas_tiles array uint16_t byte_offset = tile_idx * 16 + (pixel_y * 2); // Set the pixel color using bit planes // Color 0 = 00 (white), 1 = 01 (light), 2 = 10 (dark), 3 = 11 (black) uint8_t bit_mask = 0x80 >> pixel_x; if(current_color & 1) { canvas_tiles[byte_offset] |= bit_mask; // Bit plane 0 } else { canvas_tiles[byte_offset] &= ~bit_mask; } if(current_color & 2) { canvas_tiles[byte_offset + 1] |= bit_mask; // Bit plane 1 } else { canvas_tiles[byte_offset + 1] &= ~bit_mask; } // Write the modified tile back to the correct VRAM bank upload_tile_to_vram(tile_idx);}
// Bresenham line algorithm (now uses canvas coordinates 0-159, 0-119)void draw_line(int16_t x0, int16_t y0, int16_t x1, int16_t y1) { int16_t dx = x1 - x0; int16_t dy = y1 - y0; int16_t sx = (dx > 0) ? 1 : -1; int16_t sy = (dy > 0) ? 1 : -1; if(dx < 0) dx = -dx; if(dy < 0) dy = -dy; int16_t err = dx - dy; int16_t e2; while(1) { plot_pixel(x0, y0); if(x0 == x1 && y0 == y1) break; e2 = 2 * err; if(e2 > -dy) { err -= dy; x0 += sx; } if(e2 < dx) { err += dx; y0 += sy; } }}
// Draw horizontal guide lines to show the 4 voice stripsvoid draw_strip_guides(void) { // Draw thin horizontal lines at y = 36, 72, 108 to divide the 4 strips // Each strip is 36 pixels tall (144 / 4) for(uint16_t x = 0; x < CANVAS_UNIQUE_WIDTH; x++) { // Draw at y = 35 (bottom of strip 0) plot_pixel(x, 35); // Draw at y = 71 (bottom of strip 1) plot_pixel(x, 71); // Draw at y = 107 (bottom of strip 2) plot_pixel(x, 107); }}
// Bresenham circle algorithm (now uses canvas coordinates)void draw_circle(int16_t center_x, int16_t center_y, int16_t radius) { int16_t x = 0; int16_t y = radius; int16_t d = 3 - 2 * radius; while(y >= x) { // Plot 8 symmetric points (bounds checking done in plot_pixel) plot_pixel(center_x + x, center_y + y); plot_pixel(center_x - x, center_y + y); plot_pixel(center_x + x, center_y - y); plot_pixel(center_x - x, center_y - y); plot_pixel(center_x + y, center_y + x); plot_pixel(center_x - y, center_y + x); plot_pixel(center_x + y, center_y - x); plot_pixel(center_x - y, center_y - x); if(d <= 0) { d = d + 4 * x + 6; } else { d = d + 4 * (x - y) + 10; y--; } x++; }}
// Start drawing a line (sets up state for incremental drawing)void start_line(int16_t x0, int16_t y0, int16_t x1, int16_t y1) { line_state.x = x0; line_state.y = y0; line_state.x1 = x1; line_state.y1 = y1; line_state.dx = x1 - x0; line_state.dy = y1 - y0; line_state.sx = (line_state.dx >= 0) ? 1 : -1; line_state.sy = (line_state.dy >= 0) ? 1 : -1; if(line_state.dx < 0) line_state.dx = -line_state.dx; if(line_state.dy < 0) line_state.dy = -line_state.dy; line_state.err = line_state.dx - line_state.dy; line_state.active = 1; line_state.pixels_drawn = 0;}
// Draw one pixel of the current line (call each frame)// Returns 1 if line is complete, 0 if still drawinguint8_t step_line(uint8_t being_dragged) { if(!line_state.active) return 1; plot_pixel(line_state.x, line_state.y); line_state.pixels_drawn++; // End line if we've drawn enough pixels (max ~120 pixels) // or if we reached the endpoint while not being dragged if(line_state.pixels_drawn >= 120 || (!being_dragged && line_state.x == line_state.x1 && line_state.y == line_state.y1)) { line_state.active = 0; return 1; } int16_t e2 = line_state.err << 1; if(e2 > -line_state.dy) { line_state.err -= line_state.dy; line_state.x += line_state.sx; } if(e2 < line_state.dx) { line_state.err += line_state.dx; line_state.y += line_state.sy; } return 0;}
void main(void) { uint8_t delay_counter = 0; uint8_t direction_counter = 0; uint16_t speed_oscillator = 0; // For sine-wave-like speed variation int16_t scroll_vx = 64; // Much slower auto-scroll (0.25 in 8.8 fixed point = 0.25 pixel/frame) int16_t scroll_vy = 0; // Velocity Y int16_t target_vx = 64; // Much slower constant horizontal scroll int16_t target_vy = 0; // Target velocity Y uint16_t scroll_x = 0; uint16_t scroll_y = 0; // Read uninitialized stack memory for entropy (random on real hardware) uint8_t stack_entropy[16]; uint16_t seed = 0; // Sample some "random" bytes from uninitialized stack for(uint8_t i = 0; i < 16; i++) { seed ^= stack_entropy[i]; seed = (seed << 1) | (seed >> 15); // Rotate } // Mix with DIV_REG seed ^= DIV_REG; seed ^= (uint16_t)DIV_REG << 8; // If seed ended up as 0, use a default if(seed == 0) seed = 0xABCD; initrand(seed); // Advance the RNG by a variable amount based on DIV_REG uint16_t advance_count = ((uint16_t)DIV_REG << 8) | DIV_REG; for(uint16_t i = 0; i < advance_count; i++) { rand(); }
if(_cpu != CGB_TYPE) { printf("CGB ONLY\nPLEASE USE COLOR MODE\n"); while(1) { wait_vbl_done(); } } // Show Aesthetic Computer boot logo show_aesthetic_boot(120); // 2 seconds DISPLAY_OFF; // Simple black and white palette BCPS_REG = 0x80; // Palette 0: Black background, white foreground BCPD_REG = 0x00; BCPD_REG = 0x00; // Black background BCPD_REG = 0xFF; BCPD_REG = 0x7F; // White BCPD_REG = 0xFF; BCPD_REG = 0x7F; // White BCPD_REG = 0xFF; BCPD_REG = 0x7F; // White current_palette = 0; // Only use palette 0 // Initialize canvas tiles for drawing seed_canvas_tiles(); // Don't draw strip guides - they cause constant sound // draw_strip_guides(); for(uint16_t tile_idx = 0; tile_idx < CANVAS_NUM_TILES; tile_idx++) { upload_tile_to_vram(tile_idx); } // Set up the entire 32×32 background map to wrap the canvas pattern build_canvas_background_map(); // Initialize sound NR52_REG = 0x80; // Enable sound NR51_REG = 0xFF; // Enable all channels on both speakers NR50_REG = 0x77; // Max volume // Initialize all channels NR10_REG = 0x00; // CH1: No sweep NR11_REG = 0x80; // CH1: 50% duty NR12_REG = 0x00; // CH1: Start silent NR21_REG = 0x80; // CH2: 50% duty NR22_REG = 0x00; // CH2: Start silent // Channel 3: Initialize with triangle wave NR30_REG = 0x00; // Disable to write wave RAM for(uint8_t i = 0; i < 16; i++) { uint8_t sample = (i < 8) ? (i * 2) : ((15 - i) * 2); wave_buffer[i] = (sample << 4) | sample; *(uint8_t*)(0xFF30 + i) = wave_buffer[i]; } NR30_REG = 0x80; // Enable channel 3 DAC NR32_REG = 0x00; // Start silent // Set up sprite for center line indicator (1 pixel wide) // Create a thin vertical line sprite (1 pixel wide in center of 8x8 tile) uint8_t sprite_tile[16]; for(uint8_t i = 0; i < 16; i++) { sprite_tile[i] = 0x10; // Single pixel in center (bit 4) } set_sprite_data(0, 1, sprite_tile); // Set up sprite palette - make it red uint16_t red_palette = 0x001F; // Red color (RGB555: 0,0,31) set_sprite_palette(0, 1, &red_palette); // Place sprites to create a vertical line at center (x=80) // Sprites are positioned at x+8, y+16 due to GameBoy screen offset for(uint8_t i = 0; i < 18; i++) { // 18 sprites to cover 144 pixels set_sprite_tile(i, 0); // Use tile 0 move_sprite(i, 88, 16 + (i * 8)); // x=88 (80+8), y offset by sprite number set_sprite_prop(i, 0); // Use palette 0 } SHOW_BKG; SHOW_SPRITES; DISPLAY_ON; uint8_t sound_update_counter = 0; uint16_t last_pixel_x = 0xFFFF; // Track last pixel position uint16_t last_pixel_y = 0xFFFF; // to avoid re-processing
while(1) { vsync(); // Use vsync() instead of wait_vbl_done() for better input handling // Calculate center pixel position uint16_t center_x = (scroll_x + 80) & WORLD_SCROLL_MASK; uint16_t center_y = (scroll_y + 72) & BG_SCROLL_MASK; // Only update sound if the pixel position changed if(center_x != last_pixel_x || center_y != last_pixel_y) { update_sound_from_pixels(scroll_x, scroll_y); last_pixel_x = center_x; last_pixel_y = center_y; }
// Read joypad input for manual scroll control uint8_t joy = joypad(); // Check if any d-pad button is pressed uint8_t manual_control = joy & (J_RIGHT | J_LEFT | J_DOWN | J_UP); // Manual scroll control with D-pad (faster scroll) if(manual_control) { // Manual control - user is pressing d-pad - scroll faster if(joy & J_RIGHT) scroll_x = (scroll_x + 4) & WORLD_SCROLL_MASK; if(joy & J_LEFT) scroll_x = (scroll_x - 4) & WORLD_SCROLL_MASK; if(joy & J_DOWN) scroll_y = (scroll_y + 4) & BG_SCROLL_MASK; if(joy & J_UP) scroll_y = (scroll_y - 4) & BG_SCROLL_MASK; } // Update hardware scroll registers SCX_REG = (uint8_t)scroll_x; SCY_REG = (uint8_t)scroll_y; }}