starfield

linux_starfield.c (17721B)

---

 #include "linux_starfield.h"
 
 internal struct linux_state state;
 
 int
 main(int argc, char **argv, char **envp)
 {
 	/* TODO: parse out commandline arguments for debug behaviour? */
 	(void) argc;
 	(void) envp;
 
 	state.platform_api = load_platform_api();
 	state.render_api = load_render_api();
 
 	/* NOTE: we expect the library to be alongside our platform-specific
 	 * executable. the unix loader does not search this path by default,
 	 * so we build the absolute path to the library here as a workaround
 	 */
 	char starfield_library_path[PATH_MAX];
 	strcpy(starfield_library_path, argv[0]);
 	strcpy(strrchr(starfield_library_path, '/'), "/starfield.so");
 
 	if (!load_starfield_api(starfield_library_path, &state.starfield_api)) {
 		fprintf(stderr, "Failed to load starfield library: %s\n", starfield_library_path);
 		_exit(1);
 	}
 
 	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");
 	}
 
 	char *display_name = NULL;
 	if (!init_video(&state.platform_arena, &state.video, display_name)) {
 		fprintf(stderr, "Failed to initialise platform video\n");
 		_exit(1);
 	}
 
 	if (!init_vulkan(&state.renderer_arena, &state.vulkan,
 			 state.video.display, state.video.surface,
 			 state.video.width, state.video.height)) {
 		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,
 	};
 
 	if (!state.starfield_api.init(&thread, &starfield_memory, &state.platform_api)) {
 		fprintf(stderr, "Failed to initialise starfield\n");
 		_exit(1);
 	}
 
 	state.running = 1;
 
 	f32 dt = 1.0f / target_render_rate;
 	while (state.running) {
 		struct timespec start_nanos, end_nanos;
 		clock_gettime(CLOCK_MONOTONIC, &start_nanos);
 
 		fprintf(stderr, "Timings: ");
 
 		struct timespec update_start, update_end;
 		clock_gettime(CLOCK_MONOTONIC, &update_start);
 
 		struct starfield_input input = {
 			0,
 		};
 
 		state.starfield_api.update(&thread, &starfield_memory,
 					   &state.platform_api, &input, dt);
 
 		clock_gettime(CLOCK_MONOTONIC, &update_end);
 		fprintf(stderr, "update: %" PRIu64 " ns, ",
 				linux_elapsed_ns(&update_start, &update_end));
 
 		if (state.audio.enabled) {
 			struct timespec sample_start, sample_end;
 			clock_gettime(CLOCK_MONOTONIC, &sample_start);
 			state.starfield_api.sample(&thread, &starfield_memory,
 						   &state.platform_api, &state.audio.buffer, dt);
 
 #ifdef STARFIELD_DEBUG
 			/* TODO: temporary test tone */
 			s32 tone_hz = 256;
 			s32 tone_volume = INT32_MAX / 16;
 			func_local f32 tone_t = 0.0f;
 
 			const f32 PI = 3.1415926535f;
 			const u32 wave_period = state.audio.buffer.sample_rate / tone_hz;
 
 			s32 *sample = state.audio.buffer.buffer;
 			for (u32 i = 0; i < state.audio.buffer.expected_frames; i++) {
 				f32 v = sinf(tone_t);
 
 				int32_t sample_value = (int32_t) (v * tone_volume);
 				for (u32 j = 0; j < state.audio.buffer.channels; j++)
 					*sample++ = sample_value;
 
 				tone_t += 2 * PI / wave_period;
 				if (tone_t >= 2 * PI)
 					tone_t -= 2 * PI;
 			}
 #endif
 
 			play_audio(&state.audio);
 
 			clock_gettime(CLOCK_MONOTONIC, &sample_end);
 			fprintf(stderr, "sample: %" PRIu64 " ns, ",
 					linux_elapsed_ns(&sample_start, &sample_end));
 		}
 
 		struct timespec render_start, render_end;
 		clock_gettime(CLOCK_MONOTONIC, &render_start);
 		state.starfield_api.render(&thread, &starfield_memory, &state.platform_api,
 					   &state.render_api, state.vulkan.renderer,
 					   state.video.width, state.video.height, dt);
 
 		draw_frame(&state.video);
 
 		clock_gettime(CLOCK_MONOTONIC, &render_end);
 		fprintf(stderr, "render: %" PRIu64 " ns, ",
 				linux_elapsed_ns(&render_start, &render_end));
 
 		clock_gettime(CLOCK_MONOTONIC, &end_nanos);
 
 		u64 elapsed_us = linux_elapsed_ns(&start_nanos, &end_nanos) / 1000;
 		if (elapsed_us < target_us_per_frame) {
 			struct timespec req = {
 				.tv_sec = 0,
 				.tv_nsec = (target_us_per_frame - elapsed_us) * 1000,
 			};
 
 			while (nanosleep(&req, &req) < 0);
 
 			clock_gettime(CLOCK_MONOTONIC, &end_nanos);
 			elapsed_us = linux_elapsed_ns(&start_nanos, &end_nanos) / 1000;
 		} else {
 			/* TODO: missed frame */
 		}
 
 		dt = (f32) elapsed_us / USECS;
 
 		fprintf(stderr, "total: %f\n", dt);
 	}
 
 	state.starfield_api.free(&thread, &starfield_memory, &state.platform_api);
 
 	free_vulkan(&state.vulkan);
 
 	_exit(0);
 }
 
 internal u64
 linux_elapsed_ns(struct timespec *restrict start, struct timespec *restrict end)
 {
 	return ((end->tv_sec - start->tv_sec) * NSECS + (end->tv_nsec - start->tv_nsec));
 }
 
 #define LOAD_SYMBOL(loc, T, sym) \
 	((loc) = (T *) dlsym(library, sym))
 
 internal b32
 load_starfield_api(char const *filename, struct starfield_api *api)
 {
 	void *library = dlopen(filename, RTLD_NOW);
 	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 len = platform_capacity + renderer_capacity + starfield_capacity;
 
 	int prot = PROT_READ | PROT_WRITE;
 	int flags = MAP_PRIVATE | MAP_ANONYMOUS;
 
 #ifdef STARFIELD_DEBUG
 	flags |= MAP_FIXED;
 #endif
 
 	void *ptr = mmap(base_addr, len, prot, flags | MAP_HUGETLB | MAP_HUGE_2MB, -1, 0);
 	if (ptr == MAP_FAILED)
 		ptr = mmap(base_addr, len, prot, flags, -1, 0);
 
 	if (ptr == MAP_FAILED)
 		return false;
 
 	/* TODO: can we make this faster? can we avoid this entirely? */
 	memset(base_addr, 0, len);
 
 	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 linux_audio *audio, u32 period_us, u32 buffered_periods)
 {
 	audio->enabled = false;
 
 	int err;
 	if ((err = snd_pcm_open(&audio->handle, "default", SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
 		fprintf(stderr, "snd_pcm_open: %s\n", snd_strerror(err));
 		return false;
 	}
 
 	snd_pcm_hw_params_t *hw_params = alloca(snd_pcm_hw_params_sizeof());
 	assert(hw_params);
 
 	snd_pcm_hw_params_any(audio->handle, hw_params);
 	snd_pcm_hw_params_set_access(audio->handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
 	snd_pcm_hw_params_set_format(audio->handle, hw_params, SND_PCM_FORMAT_S32_LE);
 	snd_pcm_hw_params_set_channels(audio->handle, hw_params, STARFIELD_AUDIO_CHANNELS);
 	snd_pcm_hw_params_set_rate(audio->handle, hw_params, STARFIELD_AUDIO_SAMPLE_RATE, 0);
 	snd_pcm_hw_params_set_periods(audio->handle, hw_params, buffered_periods, 0);
 	snd_pcm_hw_params_set_period_time(audio->handle, hw_params, period_us, 0);
 
 	if ((err = snd_pcm_hw_params(audio->handle, hw_params)) < 0) {
 		fprintf(stderr, "and_pcm_hw_params: %s\n", snd_strerror(err));
 		return false;
 	}
 
 	u64 frames = (period_us * STARFIELD_AUDIO_SAMPLE_RATE * STARFIELD_AUDIO_FRAME_BYTES) / USECS;
 
 	fprintf(stderr, "Audio buffer period (us): %" PRIu32 "\n", period_us);
 	fprintf(stderr, "Audio buffer frames: %" PRIu64 "\n", frames);
 
 	audio->buffer.buffer = PUSH_ARRAY(arena, s32, frames);
 	assert(audio->buffer.buffer);
 
 	audio->buffer.channels = STARFIELD_AUDIO_CHANNELS;
 	audio->buffer.sample_rate = STARFIELD_AUDIO_SAMPLE_RATE;
 	audio->buffer.sample_bits = STARFIELD_AUDIO_SAMPLE_BITS;
 	audio->buffer.expected_frames = frames;
 
 	audio->enabled = true;
 
 	return true;
 }
 
 internal void
 play_audio(struct linux_audio *audio)
 {
 	void *buf = audio->buffer.buffer;
 	u32 frames = audio->buffer.expected_frames;
 
 	int err;
 	if ((err = snd_pcm_writei(audio->handle, buf, frames)) < 0) {
 		fprintf(stderr, "snd_pcm_write: %s\n", snd_strerror(err));
 	}
 }
 
 internal void
 xdg_wm_base_handle_ping(void *data, struct xdg_wm_base *wm_base, u32 serial)
 {
 	(void) data;
 
 	xdg_wm_base_pong(wm_base, serial);
 }
 
 internal const struct xdg_wm_base_listener xdg_wm_base_listener = {
 	.ping = xdg_wm_base_handle_ping,
 };
 
 internal void
 xdg_surface_handle_configure(void *data, struct xdg_surface *xdg_surface, u32 serial)
 {
 	(void) data;
 
 	xdg_surface_ack_configure(xdg_surface, serial);
 }
 
 internal const struct xdg_surface_listener xdg_surface_listener = {
 	.configure = xdg_surface_handle_configure,
 };
 
 internal void
 xdg_toplevel_handle_configure(void *data, struct xdg_toplevel *toplevel, s32 width, s32 height, struct wl_array *states)
 {
 	(void) toplevel;
 	(void) states;
 
 	struct linux_video *video = data;
 	video->width = width ? width : STARFIELD_VIDEO_HRES;
 	video->height = height ? height : STARFIELD_VIDEO_HRES;
 }
 
 internal void
 xdg_toplevel_handle_close(void *data, struct xdg_toplevel *toplevel)
 {
 	(void) data;
 	(void) toplevel;
 
 	state.running = false;
 }
 
 internal void
 xdg_toplevel_handle_configure_bounds(void *data, struct xdg_toplevel *toplevel, s32 width, s32 height)
 {
 	(void) toplevel;
 
 	struct linux_video *video = data;
 	video->width = width ? width : STARFIELD_VIDEO_HRES;
 	video->height = height ? height : STARFIELD_VIDEO_HRES;
 }
 
 internal void
 xdg_toplevel_handle_wm_capabilities(void *data, struct xdg_toplevel *toplevel, struct wl_array *caps)
 {
 	(void) data;
 	(void) toplevel;
 	(void) caps;
 
 	// TODO: handle me, do we care about any special capabilities?
 }
 
 internal const struct xdg_toplevel_listener xdg_toplevel_listener = {
 	.configure = xdg_toplevel_handle_configure,
 	.close = xdg_toplevel_handle_close,
 	.configure_bounds = xdg_toplevel_handle_configure_bounds,
 	.wm_capabilities = xdg_toplevel_handle_wm_capabilities,
 };
 
 internal void
 wl_registry_handle_global(void *data, struct wl_registry *registry, u32 name, char const *interface, u32 version)
 {
 	struct linux_video *video = data;
 
 	fprintf(stderr, "wl: interface: %u, name: %s, version: %u\n", name, interface, version);
 
 	if (strcmp(interface, wl_compositor_interface.name) == 0) {
 		video->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 6);
 	} else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
 		video->wm_base = wl_registry_bind(registry, name, &xdg_wm_base_interface, 6);
 		xdg_wm_base_add_listener(video->wm_base, &xdg_wm_base_listener, data);
 	}
 }
 
 internal void
 wl_registry_handle_global_remove(void *data, struct wl_registry *registry, u32 name)
 {
 	(void) data;
 	(void) registry;
 	(void) name;
 }
 
 internal const struct wl_registry_listener wl_registry_listener = {
 	.global = wl_registry_handle_global,
 	.global_remove = wl_registry_handle_global_remove,
 };
 
 internal b32
 init_video(struct arena *arena, struct linux_video *video, char const *display_name)
 {
 	(void) arena;
 
 	if (!(video->display = wl_display_connect(display_name))) {
 		fprintf(stderr, "wl_display_connect: could not connect to %s\n", display_name);
 		return false;
 	}
 
 	video->registry = wl_display_get_registry(video->display);
 
 	wl_registry_add_listener(video->registry, &wl_registry_listener, video);
 
 	wl_display_roundtrip(video->display);
 
 	assert(video->compositor);
 	assert(video->wm_base);
 
 	video->surface = wl_compositor_create_surface(video->compositor);
 
 	video->xdg_surface = xdg_wm_base_get_xdg_surface(video->wm_base, video->surface);
 	xdg_surface_add_listener(video->xdg_surface, &xdg_surface_listener, video);
 
 	video->xdg_toplevel = xdg_surface_get_toplevel(video->xdg_surface);
 	xdg_toplevel_add_listener(video->xdg_toplevel, &xdg_toplevel_listener, video);
 
 	xdg_toplevel_set_app_id(video->xdg_toplevel, "starfield");
 	xdg_toplevel_set_title(video->xdg_toplevel, "starfield");
 
 	wl_surface_commit(video->surface);
 	wl_display_roundtrip(video->display);
 
 	return true;
 }
 
 internal void
 draw_frame(struct linux_video *video)
 {
 	wl_display_dispatch_pending(video->display);
 }
 
 internal VKAPI_ATTR VkBool32 VKAPI_CALL
 vk_debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
 		  VkDebugUtilsMessageTypeFlagsEXT type,
 		  const VkDebugUtilsMessengerCallbackDataEXT *callback_data,
 		  void *user_data)
 {
 	(void) severity;
 	(void) type;
 	(void) user_data;
 
 	fprintf(stderr, "vk: validation: %s\n", callback_data->pMessage);
 
 	return VK_FALSE;
 }
 
 internal b32
 init_vulkan(struct arena *arena, struct linux_vulkan *vulkan,
 	    struct wl_display *display, struct wl_surface *surface,
 	    u32 width, u32 height)
 {
 	VkApplicationInfo app_info = {
 		.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
 		.pApplicationName = "starfield",
 		.applicationVersion = VK_MAKE_VERSION(1, 0, 0),
 		.pEngineName = "No Engine",
 		.engineVersion = VK_MAKE_VERSION(1, 0, 0),
 		.apiVersion = VK_API_VERSION_1_0,
 	};
 
 	const char *instance_extensions[] = {
 		VK_KHR_SURFACE_EXTENSION_NAME,
 		VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
 		VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
 		VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
 	};
 
 	const char *instance_layers[] = {
 		"VK_LAYER_KHRONOS_validation",
 	};
 
 	uint32_t debug_severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT
 				| VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT
 				| VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT
 				| VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
 
 	uint32_t debug_type = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
 			    | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT
 			    | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
 
 	VkDebugUtilsMessengerCreateInfoEXT debug_info = {
 		.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
 		.messageSeverity = debug_severity,
 		.messageType = debug_type,
 		.pfnUserCallback = vk_debug_callback,
 		.pUserData = NULL,
 	};
 
 	VkInstanceCreateInfo instance_info = {
 		.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
 		.pApplicationInfo = &app_info,
 		.enabledExtensionCount = ARRLEN(instance_extensions),
 		.ppEnabledExtensionNames = instance_extensions,
 		.enabledLayerCount = ARRLEN(instance_layers),
 		.ppEnabledLayerNames = instance_layers,
 		.pNext = &debug_info,
 	};
 
 	if (vkCreateInstance(&instance_info, NULL, &vulkan->instance) != VK_SUCCESS) {
 		fprintf(stderr, "Failed to create Vulkan instance!\n");
 		return false;
 	}
 
 	PFN_vkCreateDebugUtilsMessengerEXT vk_create_debug_utils_messenger_ext =
 		(PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(vulkan->instance,
 									   "vkCreateDebugUtilsMessengerEXT");
 	if (!vk_create_debug_utils_messenger_ext) {
 		fprintf(stderr, "Failed to get proc address of vkCreateDebugUtilsMessengerEXT!\n");
 		return false;
 	}
 
 	if (vk_create_debug_utils_messenger_ext(vulkan->instance,
 						&debug_info, NULL,
 						&vulkan->debug_messenger) != VK_SUCCESS) {
 		fprintf(stderr, "Failed to create Vulkan debug messenger!\n");
 		return false;
 	}
 
 	VkWaylandSurfaceCreateInfoKHR surface_info = {
 		.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR,
 		.display = display,
 		.surface = surface,
 	};
 
 	if (vkCreateWaylandSurfaceKHR(vulkan->instance, &surface_info, NULL, &vulkan->surface) != VK_SUCCESS) {
 		fprintf(stderr, "Failed to create Vulkan surface!\n");
 		return false;
 	}
 
 	if (!(vulkan->renderer = create_renderer(arena, vulkan->instance, vulkan->surface, width, height))) {
 		fprintf(stderr, "Failed to create Vulkan renderer\n");
 		return false;
 	}
 
 	return true;
 }
 
 internal void
 free_vulkan(struct linux_vulkan *vulkan)
 {
 	destroy_renderer(vulkan->renderer);
 
 	vkDestroySurfaceKHR(vulkan->instance, vulkan->surface, NULL);
 
 	PFN_vkDestroyDebugUtilsMessengerEXT vk_destroy_debug_utils_messenger_ext =
 		(PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(vulkan->instance,
 									    "vkDestroyDebugUtilsMessengerEXT");
 	if (!vk_destroy_debug_utils_messenger_ext) {
 		fprintf(stderr, "Failed to get proc address of vkDestroyDebugUtilsMessengerEXT!\n");
 		return;
 	}
 
 	vk_destroy_debug_utils_messenger_ext(vulkan->instance, vulkan->debug_messenger, NULL);
 
 	vkDestroyInstance(vulkan->instance, NULL);
 }
 
 /* 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 true;
 }
 
 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
  * ===========================================================================
  */
 
 #include "utils.c"
 #include "renderer.c"