ona/source/ona/ona.zig

pub const canvas = @import("./canvas.zig");

const coral = @import("coral");

const ext = @import("./ext.zig");

pub const files = @import("./files.zig");

pub const App = opaque {
	pub fn Starter(comptime errors: type) type {
		return fn (app_state: *App) errors!void;
	}

	const State = struct {
		base_file_sandbox: files.FileSandbox,
		window: *ext.SDL_Window,
		renderer: *ext.SDL_Renderer,
		last_tick: u64,
		tick_rate: u64 = 16,
		canvas_items: coral.slots.Dense(coral.slots.addressable_key, canvas.Item),

		fn cast(self: *App) *State {
			return @ptrCast(*State, @alignCast(@alignOf(State), self));
		}
	};

	pub fn data_fs(self: *App) files.FileAccessor {
		return files.FileAccessor.bind(files.FileSandbox, &State.cast(self).base_file_sandbox);
	}

	pub fn loop(self: *App) void {
		const state = State.cast(self);

		while (true) {
			const current_tick = ext.SDL_GetTicks64();
			var event = @as(ext.SDL_Event, undefined);

			while (ext.SDL_PollEvent(&event) != 0) {
				switch (event.type) {
					ext.SDL_QUIT => return,
					else => {},
				}
			}

			if ((current_tick - state.last_tick) >= state.tick_rate) {
				// TODO: Perform game updates.
				if (ext.SDL_SetRenderDrawColor(state.renderer, 255, 255, 255, 255) != 0) {
					return log_error(&.{.{.string = coral.io.slice_sentineled(u8, 0, ext.SDL_GetError())}});
				}

				if (ext.SDL_RenderClear(state.renderer) != 0) {
					return log_error(&.{.{.string = coral.io.slice_sentineled(u8, 0, ext.SDL_GetError())}});
				}

				for (state.canvas_items.values) |canvas_item| {
					switch (canvas_item.options) {
						.sprite => {},
					}
				}

				ext.SDL_RenderPresent(state.renderer);

				state.last_tick = current_tick;
			}
		}
	}

	pub fn run(comptime errors: type, start: *const Starter(errors)) errors!void {
		if (ext.SDL_Init(ext.SDL_INIT_EVERYTHING) != 0) {
			return log_error(&.{.{.string = coral.io.slice_sentineled(u8, 0, ext.SDL_GetError())}});
		}

		const base_prefix = ext.SDL_GetBasePath() orelse {
			return log_error(&.{.{.string = coral.io.slice_sentineled(u8, 0, ext.SDL_GetError())}});
		};

		defer ext.SDL_free(base_prefix);

		const window_flags = 0;

		const window = ext.SDL_CreateWindow("ona", -1, -1, 640, 480, window_flags) orelse {
			return log_error(&.{.{.string = coral.io.slice_sentineled(u8, 0, ext.SDL_GetError())}});
		};

		defer ext.SDL_DestroyWindow(window);

		const renderer_flags = 0;

		const renderer = ext.SDL_CreateRenderer(window, -1, renderer_flags) orelse {
			return log_error(&.{.{.string = coral.io.slice_sentineled(u8, 0, ext.SDL_GetError())}});
		};

		defer ext.SDL_DestroyRenderer(renderer);

		return start(@ptrCast(*App, &App.State{
			.window = window,
			.renderer = renderer,
			.last_tick = 0,
			.canvas_items = .{},

			.base_file_sandbox = .{
				.prefix = coral.io.slice_sentineled(u8, 0, base_prefix),

				.flags = .{
					.is_readable = true,
					.is_queryable = true,
				}
			},
		}));
	}
};

pub const allocator = coral.io.Allocator.bind(&heap, @TypeOf(heap).reallocate);

var heap = struct {
	live_allocations: usize = 0,

	const Self = @This();

	pub fn reallocate(self: *Self, options: coral.io.AllocationOptions) ?[]u8 {
		if (options.size == 0) {
			if (options.allocation) |allocation| {
				ext.SDL_free(allocation.ptr);

				self.live_allocations -= 1;
			}

			return null;
		}

		if (options.allocation) |allocation| {
			if (ext.SDL_realloc(allocation.ptr, options.size)) |reallocation| {
				self.live_allocations += 1;

				return @ptrCast([*]u8, reallocation)[0 .. options.size];
			}
		}

		if (ext.SDL_malloc(options.size)) |allocation| {
			self.live_allocations += 1;

			return @ptrCast([*]u8, allocation)[0 .. options.size];
		}

		return null;
	}
}{};

pub const CanvasItem = struct {
	app: *App,
	id: coral.slots.Slot(coral.slots.addressable_key),

	pub fn deinit(self: *CanvasItem) void {
		coral.debug.assert(App.State.cast(self.app).canvas_items.remove(self.id));
	}

	pub fn init(app: *App, canvas_item: canvas.Item) coral.io.AllocationError!CanvasItem {
		const slot = try App.State.cast(app).canvas_items.insert(allocator, canvas_item);

		return CanvasItem{
			.app = app,
			.id = slot,
		};
	}
};

pub fn log_debug(values: []const coral.format.Value) void {
	var message_memory = [_]u8{0} ** 4096;
	var message_buffer = coral.buffer.Fixed{.data = &message_memory};
	const message_length = coral.format.print(message_buffer.as_writer(), values) catch return;

	ext.SDL_LogDebug(ext.SDL_LOG_CATEGORY_APPLICATION, "%.*s\n", message_length, &message_buffer);
}

pub fn log_error(values: []const coral.format.Value) void {
	var message_memory = [_]u8{0} ** 4096;
	var message_buffer = coral.buffer.Fixed{.data = &message_memory};
	const message_length = coral.format.print(message_buffer.as_writer(), values) catch return;

	ext.SDL_LogError(ext.SDL_LOG_CATEGORY_APPLICATION, "%.*s\n", message_length, &message_buffer);
}