starfield

win_starfield.c (6127B)

---

 #include "win_starfield.h"
 
 internal struct win_starfield_state state;
 
 int WINAPI
 WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmdline, int cmdshow)
 {
 	/* TODO: parse out commandline arguments for debug behaviour? */
 	(void) instance;
 	(void) prev_instance;
 	(void) cmdline;
 	(void) cmdshow;
 
 	/* NOTE: the windows dll loader checks the parent directory of our
 	 * instance when loading libraries, so no need to do anything fancy
 	 */
 	char starfield_library_path[] = "starfield.dll";
 
 	if (!load_starfield_api(starfield_library_path, &state.starfield_api)) {
 		fprintf(stderr, "Failed to load starfield library: %s\n", starfield_library_path);
 		_exit(1);
 	}
 
 	state.platform_api = load_platform_api();
 
 	struct starfield_thread thread = {
 		.id = 0,
 	};
 
 	if (!init_memory(&state.platform_arena, 32 * MiB,
 			 &state.renderer_arena, 32 * MiB,
 			 &state.starfield_arena, 64 * MiB)) {
 		fprintf(stderr, "Failed to initialise memory\n");
 		_exit(1);
 	}
 
 	f32 target_render_rate = 60.0, target_physics_rate = 60.0;
 
 	u32 target_us_per_frame = USECS / target_render_rate;
 	u32 target_us_per_tick = USECS / target_physics_rate;
 
 	(void) target_us_per_tick;
 
 	u32 period_us = target_us_per_frame, buffered_periods = 2;
 	if (!init_audio(&state.platform_arena, &state.audio, period_us, buffered_periods)) {
 		fprintf(stderr, "Failed to initialise platform audio\n");
 	}
 
 	if (!init_video(&state.platform_arena, &state.video, instance)) {
 		fprintf(stderr, "Failed to initialise platform video\n");
 		_exit(1);
 	}
 
 	if (!init_vulkan(&state.renderer_arena, &state.vulkan)) {
 		fprintf(stderr, "Failed to initialise platform renderer\n");
 		_exit(1);
 	}
 
 	struct starfield_memory starfield_memory = {
 		.ptr = state.starfield_arena.ptr,
 		.cap = state.starfield_arena.cap,
 		.len = state.starfield_arena.len,
 	};
 
 	state.starfield_api.init(&thread, &starfield_memory, &state.platform_api);
 
 	state.running = 1;
 
 	f32 dt = 0;
 	while (state.running) {
 		struct starfield_input input = {
 			0,
 		};
 
 		state.starfield_api.update(&thread, &starfield_memory,
 					    &state.platform_api, &input, dt);
 
 		if (state.audio.enabled) {
 			state.starfield_api.sample(&thread, &starfield_memory,
 						   &state.platform_api, &state.audio.buffer, dt);
 
 			play_audio(&state.audio);
 		}
 
 		state.starfield_api.render(&thread, &starfield_memory,
 					   &state.platform_api, &state.renderer_api,
 					   state.video.width, state.video.height, dt);
 
 		draw_frame(&state.video);
 
 		Sleep(1000);
 	}
 
 	state.starfield_api.free(&thread, &state.starfield_memory, &state.platform_api);
 
 	free_vulkan(&state.vulkan);
 
 	_exit(0);
 }
 
 #define LOAD_SYMBOL(loc, T, sym) \
 	((loc) = (T *) GetProcAddress(library, sym))
 
 internal b32
 load_starfield_api(char const *filename, struct starfield_api *api)
 {
 	HMODULE library = LoadLibraryA(filename);
 	if (!library) return false;
 
 	LOAD_SYMBOL(api->init, starfield_api_init_t, "starfield_init");
 	LOAD_SYMBOL(api->update, starfield_api_update_t, "starfield_update");
 	LOAD_SYMBOL(api->render, starfield_api_render_t, "starfield_render");
 	LOAD_SYMBOL(api->sample, starfield_api_sample_t, "starfield_sample");
 	LOAD_SYMBOL(api->free, starfield_api_free_t, "starfield_free");
 
 	return true;
 }
 
 internal b32
 init_memory(struct arena *platform_arena, u64 platform_capacity,
 	    struct arena *renderer_arena, u64 renderer_capacity,
 	    struct arena *starfield_arena, u64 starfield_capacity)
 {
 #ifdef STARFIELD_DEBUG
 	void *base_addr = (void *) (2 * TiB);
 #else
 	void *base_addr = NULL;
 #endif
 
 	u64 huge_page_alignment = GetLargePageMinimum();
 	u64 len = ALIGN_NEXT(platform_capacity + renderer_capacity + starfield_capacity,
 			     huge_page_alignment);
 
 	/* TODO: add hugetlb support?
 	 * https://learn.microsoft.com/en-us/windows/win32/memory/large-page-support
 	 */
 	DWORD alloc_type = MEM_RESERVE | MEM_COMMIT;
 	void *ptr = VirtualAlloc(base_addr, len,
 				 alloc_type | MEM_LARGE_PAGES,
 				 PAGE_READWRITE);
 
 	if (!ptr)
 		ptr = VirtualAlloc(base_addr, len, alloc_type, PAGE_READWRITE);
 
 	if (!ptr)
 		return false;
 
 	/* NOTE: windows guarantees that the memory returned by VirtualAlloc
 	 * is zero-ed, so no need to memset it here
 	 */
 
 	platform_arena->ptr = ptr;
 	platform_arena->cap = platform_capacity;
 	platform_arena->len = 0;
 
 	renderer_arena->ptr = (u8 *) ptr + platform_capacity;
 	renderer_arena->cap = renderer_capacity;
 	renderer_arena->len = 0;
 
 	starfield_arena->ptr = (u8 *) ptr + platform_capacity + renderer_capacity;
 	starfield_arena->cap = starfield_capacity;
 	starfield_arena->len = 0;
 
 	return true;
 }
 
 internal b32
 init_audio(struct arena *arena, struct win_audio *audio, u64 period_us, u32 buffered_periods)
 {
 	(void) arena;
 	(void) audio;
 	(void) period_us;
 	(void) buffered_periods;
 
 	return false;
 }
 
 internal void
 play_audio(struct win_audio *audio)
 {
 	(void) audio;
 }
 
 internal b32
 init_video(struct arena *arena, struct win_video *video, HINSTANCE instance)
 {
 	(void) arena;
 	(void) video;
 	(void) instance;
 
 	return false;
 }
 
 internal void
 draw_frame(struct win_video *video)
 {
 	(void) video;
 }
 
 internal b32
 init_vulkan(struct arena *arena, struct win_vulkan *vulkan)
 {
 	(void) arena;
 	(void) vulkan;
 
 	return false;
 }
 
 internal void
 free_vulkan(struct win_vulkan *vulkan)
 {
 	(void) vulkan;
 }
 
 /* platform implementation
  * ===========================================================================
  */
 
 #ifdef STARFIELD_DEBUG
 
 DEBUG_PLATFORM_READ_FILE(DEBUG_platform_read_file)
 {
 	(void) filename;
 
 	return (struct DEBUG_platform_read_file_result) {0};
 }
 
 DEBUG_PLATFORM_WRITE_FILE(DEBUG_platform_write_file)
 {
 	(void) filename;
 	(void) buf;
 	(void) len;
 
 	return false;
 }
 
 DEBUG_PLATFORM_FREE_FILE_MEMORY(DEBUG_platform_free_file_memory)
 {
 	(void) ptr;
 }
 
 #endif
 
 internal struct platform_api
 load_platform_api(void)
 {
 	return (struct platform_api) {
 #ifdef STARFIELD_DEBUG
 		.DEBUG_read_file = DEBUG_platform_read_file,
 		.DEBUG_write_file = DEBUG_platform_write_file,
 		.DEBUG_free_file_memory = DEBUG_platform_free_file_memory,
 #endif
 	};
 }
 
 /* utils
  * ===========================================================================
  */
 
 // TODO: implement renderer