Update Files

Kha/Kinc/Backends/System/WindowsApp/Sources/kinc/backend/display.c

@@ -0,0 +1,41 @@
+#include <kinc/display.h>
+
+int kinc_primary_display() {
+	return 0;
+}
+
+int kinc_count_displays() {
+	return 1;
+}
+
+void kinc_display_init() {
+
+}
+
+bool kinc_display_available(int display_index) {
+	return display_index == 0;
+}
+
+const char *kinc_display_name(int display_index) {
+	return "Display";
+}
+
+kinc_display_mode_t kinc_display_current_mode(int display_index) {
+	kinc_display_mode_t mode;
+	mode.x = 0;
+	mode.y = 0;
+	mode.width = 800;
+	mode.height = 600;
+	mode.pixels_per_inch = 96;
+	mode.frequency = 60;
+	mode.bits_per_pixel = 32;
+	return mode;
+}
+
+int kinc_display_count_available_modes(int display_index) {
+	return 1;
+}
+
+kinc_display_mode_t kinc_display_available_mode(int display_index, int mode_index) {
+	return kinc_display_current_mode(0);
+}

Kha/Kinc/Backends/System/WindowsApp/Sources/kinc/backend/mouse.c

@@ -0,0 +1,34 @@
+#include <kinc/input/mouse.h>
+
+void kinc_internal_mouse_lock(int window) {
+
+}
+
+void kinc_internal_mouse_unlock(void) {
+
+}
+
+bool kinc_mouse_can_lock(void) {
+	return false;
+}
+
+void kinc_mouse_show() {
+
+}
+
+void kinc_mouse_hide() {
+
+}
+
+void kinc_mouse_set_position(int window, int x, int y) {
+
+}
+
+void kinc_mouse_get_position(int window, int* x, int* y) {
+	*x = 0;
+	*y = 0;
+}
+
+void kinc_mouse_set_cursor(int cursor_index) {
+
+}

Kha/Kinc/Backends/System/WindowsApp/Sources/kinc/backend/system.winrt.cpp

@@ -0,0 +1,459 @@
+#include <kinc/graphics4/graphics.h>
+#include <kinc/input/gamepad.h>
+#include <kinc/input/keyboard.h>
+#include <kinc/input/mouse.h>
+#include <kinc/system.h>
+#include <kinc/threads/thread.h>
+#include <kinc/video.h>
+#include <kinc/window.h>
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#ifndef XINPUT
+#ifdef KINC_WINDOWS
+#define XINPUT 1
+#endif
+
+#ifdef KINC_WINDOWSAPP
+#define XINPUT !(WINAPI_PARTITION_PHONE_APP)
+#endif
+#endif
+#if XINPUT
+#include <Xinput.h>
+#endif
+
+#include <d3d11_1.h>
+#include <d3d11_4.h>
+#include <dxgi1_5.h>
+#include <wrl.h>
+
+#ifdef KINC_WINDOWSAPP
+using namespace ::Microsoft::WRL;
+using namespace Windows::UI::Core;
+using namespace Windows::Foundation;
+#ifdef KINC_HOLOLENS
+using namespace Windows::Graphics::Holographic;
+using namespace Windows::Graphics::DirectX::Direct3D11;
+#endif
+#endif
+
+extern "C" IUnknown *kinc_winapp_internal_get_window(void) {
+	return reinterpret_cast<IUnknown *>(CoreWindow::GetForCurrentThread());
+}
+
+extern "C" void kinc_internal_uwp_installed_location_path(char *path) {
+	Platform::String ^ locationString = Windows::ApplicationModel::Package::Current->InstalledLocation->Path;
+	WideCharToMultiByte(CP_UTF8, 0, locationString->Begin(), -1, path, 1000, nullptr, nullptr);
+}
+
+ref class Win8Application sealed : public Windows::ApplicationModel::Core::IFrameworkView {
+public:
+	Win8Application();
+	virtual void Initialize(Windows::ApplicationModel::Core::CoreApplicationView ^ applicationView);
+	virtual void SetWindow(Windows::UI::Core::CoreWindow ^ window);
+	virtual void Load(Platform::String ^ entryPoint);
+	virtual void Run();
+	virtual void Uninitialize();
+
+protected:
+	void OnWindowSizeChanged(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::WindowSizeChangedEventArgs ^ args);
+	// void OnLogicalDpiChanged(Platform::Object^ sender);
+	void OnActivated(Windows::ApplicationModel::Core::CoreApplicationView ^ applicationView, Windows::ApplicationModel::Activation::IActivatedEventArgs ^ args);
+	void OnSuspending(Platform::Object ^ sender, Windows::ApplicationModel::SuspendingEventArgs ^ args);
+	void OnResuming(Platform::Object ^ sender, Platform::Object ^ args);
+	void OnWindowClosed(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::CoreWindowEventArgs ^ args);
+	void OnPointerPressed(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args);
+	void OnPointerReleased(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args);
+	void OnPointerMoved(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args);
+
+private:
+	// CubeRenderer^ m_renderer;
+	// Windows::ApplicationModel::Core::CoreApplicationView^ view;
+	bool closed;
+	void OnKeyDown(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args);
+	void OnKeyUp(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args);
+};
+
+ref class Win8ApplicationSource : Windows::ApplicationModel::Core::IFrameworkViewSource {
+public:
+	virtual Windows::ApplicationModel::Core::IFrameworkView ^ CreateView();
+};
+
+namespace {
+	int mouseX, mouseY;
+	float axes[12 * 6];
+	float buttons[12 * 16];
+}
+
+using namespace Windows::ApplicationModel;
+using namespace Windows::ApplicationModel::Core;
+using namespace Windows::ApplicationModel::Activation;
+using namespace Windows::UI::Core;
+using namespace Windows::System;
+using namespace Windows::Foundation;
+using namespace Windows::Graphics::Display;
+
+const char *kinc_gamepad_vendor(int gamepad) {
+	return "Microsoft";
+}
+
+const char *kinc_gamepad_product_name(int gamepad) {
+	return "Xbox 360 Controller";
+}
+
+bool kinc_internal_handle_messages(void) {
+	CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
+
+#if XINPUT
+	DWORD dwResult;
+	for (DWORD i = 0; i < XUSER_MAX_COUNT; ++i) {
+		XINPUT_STATE state;
+		ZeroMemory(&state, sizeof(XINPUT_STATE));
+		dwResult = XInputGetState(i, &state);
+
+		if (dwResult == ERROR_SUCCESS) {
+			float newaxes[6];
+			newaxes[0] = state.Gamepad.sThumbLX / 32768.0f;
+			newaxes[1] = state.Gamepad.sThumbLY / 32768.0f;
+			newaxes[2] = state.Gamepad.sThumbRX / 32768.0f;
+			newaxes[3] = state.Gamepad.sThumbRY / 32768.0f;
+			newaxes[4] = state.Gamepad.bLeftTrigger / 255.0f;
+			newaxes[5] = state.Gamepad.bRightTrigger / 255.0f;
+			for (int i2 = 0; i2 < 6; ++i2) {
+				if (axes[i * 6 + i2] != newaxes[i2]) {
+					kinc_internal_gamepad_trigger_axis(i, i2, newaxes[i2]);
+					axes[i * 6 + i2] = newaxes[i2];
+				}
+			}
+			float newbuttons[16];
+			newbuttons[0] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_A) ? 1.0f : 0.0f;
+			newbuttons[1] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_B) ? 1.0f : 0.0f;
+			newbuttons[2] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_X) ? 1.0f : 0.0f;
+			newbuttons[3] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_Y) ? 1.0f : 0.0f;
+			newbuttons[4] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER) ? 1.0f : 0.0f;
+			newbuttons[5] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER) ? 1.0f : 0.0f;
+			newbuttons[6] = state.Gamepad.bLeftTrigger / 255.0f;
+			newbuttons[7] = state.Gamepad.bRightTrigger / 255.0f;
+			newbuttons[8] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_BACK) ? 1.0f : 0.0f;
+			newbuttons[9] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_START) ? 1.0f : 0.0f;
+			newbuttons[10] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_LEFT_THUMB) ? 1.0f : 0.0f;
+			newbuttons[11] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_RIGHT_THUMB) ? 1.0f : 0.0f;
+			newbuttons[12] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_UP) ? 1.0f : 0.0f;
+			newbuttons[13] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_DOWN) ? 1.0f : 0.0f;
+			newbuttons[14] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_LEFT) ? 1.0f : 0.0f;
+			newbuttons[15] = (state.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_RIGHT) ? 1.0f : 0.0f;
+			for (int i2 = 0; i2 < 16; ++i2) {
+				if (buttons[i * 16 + i2] != newbuttons[i2]) {
+					kinc_internal_gamepad_trigger_button(i, i2, newbuttons[i2]);
+					buttons[i * 16 + i2] = newbuttons[i2];
+				}
+			}
+		}
+	}
+#endif
+
+	return true;
+}
+
+// Kore::vec2i Kore::System::mousePos() {
+//	return vec2i(mouseX, mouseY);
+//}
+
+#ifdef KINC_KONG
+extern "C" void kong_init(void);
+#endif
+
+#undef CreateWindow
+
+int kinc_init(const char *name, int width, int height, struct kinc_window_options *win, struct kinc_framebuffer_options *frame) {
+	kinc_window_options_t defaultWin;
+	if (win == NULL) {
+		kinc_window_options_set_defaults(&defaultWin);
+		win = &defaultWin;
+	}
+	win->width = width;
+	win->height = height;
+
+	kinc_framebuffer_options_t defaultFrame;
+	if (frame == NULL) {
+		kinc_framebuffer_options_set_defaults(&defaultFrame);
+		frame = &defaultFrame;
+	}
+
+	kinc_g4_internal_init();
+	kinc_g4_internal_init_window(0, frame->depth_bits, frame->stencil_bits, true);
+
+#ifdef KINC_KONG
+	kong_init();
+#endif
+
+	return 0;
+}
+
+void kinc_set_keep_screen_on(bool on) {}
+
+namespace {
+	bool keyboardshown = false;
+	char language[3] = {0};
+}
+
+void kinc_keyboard_show() {
+	keyboardshown = true;
+}
+
+void kinc_keyboard_hide() {
+	keyboardshown = false;
+}
+
+bool kinc_keyboard_active() {
+	return keyboardshown;
+}
+
+void kinc_load_url(const char *url) {}
+
+void kinc_vibrate(int ms) {}
+
+const char *kinc_language() {
+	wchar_t wlanguage[3] = {0};
+
+	if (GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_SISO639LANGNAME, wlanguage, 3)) {
+		WideCharToMultiByte(CP_UTF8, 0, wlanguage, -1, language, 3, nullptr, nullptr);
+		return language;
+	}
+	return "en";
+}
+
+Win8Application::Win8Application() : closed(false) {}
+
+void Win8Application::Initialize(CoreApplicationView ^ applicationView) {
+	applicationView->Activated += ref new TypedEventHandler<CoreApplicationView ^, IActivatedEventArgs ^>(this, &Win8Application::OnActivated);
+	CoreApplication::Suspending += ref new EventHandler<SuspendingEventArgs ^>(this, &Win8Application::OnSuspending);
+	CoreApplication::Resuming += ref new EventHandler<Platform::Object ^>(this, &Win8Application::OnResuming);
+	// m_renderer = ref new CubeRenderer();
+}
+
+void Win8Application::SetWindow(CoreWindow ^ window) {
+	window->SizeChanged += ref new TypedEventHandler<CoreWindow ^, WindowSizeChangedEventArgs ^>(this, &Win8Application::OnWindowSizeChanged);
+	window->Closed += ref new TypedEventHandler<CoreWindow ^, CoreWindowEventArgs ^>(this, &Win8Application::OnWindowClosed);
+	window->PointerPressed += ref new TypedEventHandler<CoreWindow ^, PointerEventArgs ^>(this, &Win8Application::OnPointerPressed);
+	window->PointerReleased += ref new TypedEventHandler<CoreWindow ^, PointerEventArgs ^>(this, &Win8Application::OnPointerReleased);
+	window->PointerMoved += ref new TypedEventHandler<CoreWindow ^, PointerEventArgs ^>(this, &Win8Application::OnPointerMoved);
+	window->KeyDown +=
+	    ref new Windows::Foundation::TypedEventHandler<Windows::UI::Core::CoreWindow ^, Windows::UI::Core::KeyEventArgs ^>(this, &Win8Application::OnKeyDown);
+	window->KeyUp +=
+	    ref new Windows::Foundation::TypedEventHandler<Windows::UI::Core::CoreWindow ^, Windows::UI::Core::KeyEventArgs ^>(this, &Win8Application::OnKeyUp);
+	// m_renderer->Initialize(CoreWindow::GetForCurrentThread());
+
+#ifdef KINC_HOLOLENS
+	// Create holographics space - needs to be created before window is activated
+	holographicFrameController = std::make_unique<HolographicFrameController>(window);
+
+	// create video frame processor
+	VideoFrameProcessor::createAsync().then([this](std::shared_ptr<VideoFrameProcessor> videoProcessor) { videoFrameProcessor = std::move(videoProcessor); });
+#endif
+}
+
+void Win8Application::Load(Platform::String ^ entryPoint) {}
+
+void Win8Application::Run() {
+	// BasicTimer^ timer = ref new BasicTimer();
+	kickstart(0, nullptr);
+	// while (!closed) {
+	// timer->Update();
+
+	// m_renderer->Update(timer->Total, timer->Delta);
+	// m_renderer->Render();
+	// m_renderer->Present(); // This call is synchronized to the display frame rate.
+	//}
+}
+
+void Win8Application::Uninitialize() {}
+
+int kinc_uwp_window_width;
+int kinc_uwp_window_height;
+
+extern "C" void kinc_internal_resize(int window, int width, int height);
+
+void Win8Application::OnWindowSizeChanged(CoreWindow ^ sender, WindowSizeChangedEventArgs ^ args) {
+	kinc_uwp_window_width = (int)args->Size.Width;
+	kinc_uwp_window_height = (int)args->Size.Height;
+	kinc_internal_resize(0, (int)args->Size.Width, (int)args->Size.Height);
+}
+
+void Win8Application::OnWindowClosed(CoreWindow ^ sender, CoreWindowEventArgs ^ args) {
+	closed = true;
+}
+
+void Win8Application::OnActivated(CoreApplicationView ^ applicationView, IActivatedEventArgs ^ args) {
+	CoreWindow::GetForCurrentThread()->Activate();
+}
+
+void Win8Application::OnSuspending(Platform::Object ^ sender, SuspendingEventArgs ^ args) {
+	// SuspendingDeferral^ deferral = args->SuspendingOperation->GetDeferral();
+	// deferral->Complete();
+}
+
+void Win8Application::OnResuming(Platform::Object ^ sender, Platform::Object ^ args) {}
+
+void Win8Application::OnPointerPressed(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args) {
+	mouseX = static_cast<int>(args->CurrentPoint->Position.X);
+	mouseY = static_cast<int>(args->CurrentPoint->Position.Y);
+	kinc_internal_mouse_trigger_press(0, 0, mouseX, mouseY);
+}
+
+void Win8Application::OnPointerReleased(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args) {
+	mouseX = static_cast<int>(args->CurrentPoint->Position.X);
+	mouseY = static_cast<int>(args->CurrentPoint->Position.Y);
+	kinc_internal_mouse_trigger_release(0, 0, mouseX, mouseY);
+}
+
+void Win8Application::OnPointerMoved(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::PointerEventArgs ^ args) {
+	mouseX = static_cast<int>(args->CurrentPoint->Position.X);
+	mouseY = static_cast<int>(args->CurrentPoint->Position.Y);
+	kinc_internal_mouse_trigger_move(0, mouseX, mouseY);
+}
+
+void Win8Application::OnKeyDown(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args) {
+	switch (args->VirtualKey) {
+	case Windows::System::VirtualKey::Left:
+		kinc_internal_keyboard_trigger_key_down(KINC_KEY_LEFT);
+		break;
+	case Windows::System::VirtualKey::Right:
+		kinc_internal_keyboard_trigger_key_down(KINC_KEY_RIGHT);
+		break;
+	case Windows::System::VirtualKey::Up:
+		kinc_internal_keyboard_trigger_key_down(KINC_KEY_UP);
+		break;
+	case Windows::System::VirtualKey::Down:
+		kinc_internal_keyboard_trigger_key_down(KINC_KEY_DOWN);
+		break;
+	default:
+		if (args->VirtualKey >= Windows::System::VirtualKey::A && args->VirtualKey <= Windows::System::VirtualKey::Z) {
+			kinc_internal_keyboard_trigger_key_down((int)args->VirtualKey);
+		}
+		else if (args->VirtualKey >= Windows::System::VirtualKey::Number0 && args->VirtualKey <= Windows::System::VirtualKey::Number9) {
+			kinc_internal_keyboard_trigger_key_down((int)args->VirtualKey);
+		}
+		break;
+	}
+}
+
+void Win8Application::OnKeyUp(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args) {
+	switch (args->VirtualKey) {
+	case Windows::System::VirtualKey::Left:
+		kinc_internal_keyboard_trigger_key_up(KINC_KEY_LEFT);
+		break;
+	case Windows::System::VirtualKey::Right:
+		kinc_internal_keyboard_trigger_key_up(KINC_KEY_RIGHT);
+		break;
+	case Windows::System::VirtualKey::Up:
+		kinc_internal_keyboard_trigger_key_up(KINC_KEY_UP);
+		break;
+	case Windows::System::VirtualKey::Down:
+		kinc_internal_keyboard_trigger_key_up(KINC_KEY_DOWN);
+		break;
+	default:
+		if (args->VirtualKey >= Windows::System::VirtualKey::A && args->VirtualKey <= Windows::System::VirtualKey::Z) {
+			kinc_internal_keyboard_trigger_key_up((int)args->VirtualKey);
+		}
+		else if (args->VirtualKey >= Windows::System::VirtualKey::Number0 && args->VirtualKey <= Windows::System::VirtualKey::Number9) {
+			kinc_internal_keyboard_trigger_key_up((int)args->VirtualKey);
+		}
+		break;
+	}
+}
+
+IFrameworkView ^ Win8ApplicationSource::CreateView() {
+	return ref new Win8Application;
+}
+
+const char *kinc_internal_save_path() {
+	return "\\";
+}
+
+const char *kinc_system_id() {
+	return "WindowsApp";
+}
+
+namespace {
+	const char *videoFormats[] = {"ogv", nullptr};
+}
+
+const char **kinc_video_formats() {
+	return ::videoFormats;
+}
+
+int kinc_window_width(int window_index) {
+	return kinc_uwp_window_width;
+}
+
+int kinc_window_height(int window_index) {
+	return kinc_uwp_window_height;
+}
+
+double kinc_frequency() {
+	kinc_ticks_t rate;
+	QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER *>(&rate));
+	return (double)rate;
+}
+
+void kinc_internal_shutdown() {}
+
+static kinc_ticks_t start_stamp;
+
+kinc_ticks_t kinc_timestamp() {
+	kinc_ticks_t stamp;
+	QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER *>(&stamp));
+	return stamp - start_stamp;
+}
+
+void kinc_login() {}
+
+void kinc_unlock_achievement(int id) {}
+
+bool kinc_gamepad_connected(int num) {
+	return true;
+}
+
+void kinc_gamepad_rumble(int gamepad, float left, float right){
+
+}
+
+    [Platform::MTAThread] int main(Platform::Array<Platform::String ^> ^) {
+	QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER *>(&start_stamp));
+	CoreApplication::Run(ref new Win8ApplicationSource);
+	return 0;
+}
+
+int kinc_cpu_cores(void) {
+	SYSTEM_LOGICAL_PROCESSOR_INFORMATION info[1024];
+	DWORD returnLength = sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) * 1024;
+	BOOL success = GetLogicalProcessorInformation(&info[0], &returnLength);
+
+	int proper_cpu_count = 0;
+
+	if (success) {
+		DWORD byteOffset = 0;
+		PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = &info[0];
+		while (byteOffset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= returnLength) {
+			if (ptr->Relationship == RelationProcessorCore) {
+				++proper_cpu_count;
+			}
+
+			byteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
+			++ptr;
+		}
+	}
+	else {
+		proper_cpu_count = 1;
+	}
+
+	return proper_cpu_count;
+}
+
+int kinc_hardware_threads(void) {
+	SYSTEM_INFO sysinfo;
+	GetSystemInfo(&sysinfo);
+	return sysinfo.dwNumberOfProcessors;
+}

Kha/Kinc/Backends/System/WindowsApp/Sources/kinc/backend/video.c

@@ -0,0 +1,57 @@
+#include <kinc/video.h>
+
+void kinc_video_init(kinc_video_t *video, const char *filename) {}
+
+void kinc_video_destroy(kinc_video_t *video) {}
+
+void kinc_video_play(kinc_video_t *video, bool loop) {}
+
+void kinc_video_pause(kinc_video_t *video) {}
+
+void kinc_video_stop(kinc_video_t *video) {}
+
+int kinc_video_width(kinc_video_t *video) {
+	return 256;
+}
+
+int kinc_video_height(kinc_video_t *video) {
+	return 256;
+}
+
+kinc_g4_texture_t *kinc_video_current_image(kinc_video_t *video) {
+	return NULL;
+}
+
+double kinc_video_duration(kinc_video_t *video) {
+	return 0.0;
+}
+
+double kinc_video_position(kinc_video_t *video) {
+	return 0.0;
+}
+
+bool kinc_video_finished(kinc_video_t *video) {
+	return false;
+}
+
+bool kinc_video_paused(kinc_video_t *video) {
+	return false;
+}
+
+void kinc_video_update(kinc_video_t *video, double time) {}
+
+void kinc_internal_video_sound_stream_init(kinc_internal_video_sound_stream_t *stream, int channel_count, int frequency) {}
+
+void kinc_internal_video_sound_stream_destroy(kinc_internal_video_sound_stream_t *stream) {}
+
+void kinc_internal_video_sound_stream_insert_data(kinc_internal_video_sound_stream_t *stream, float *data, int sample_count) {}
+
+static float samples[2] = {0};
+
+float *kinc_internal_video_sound_stream_next_frame(kinc_internal_video_sound_stream_t *stream) {
+	return samples;
+}
+
+bool kinc_internal_video_sound_stream_ended(kinc_internal_video_sound_stream_t *stream) {
+	return true;
+}

Kha/Kinc/Backends/System/WindowsApp/Sources/kinc/backend/video.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+	int nothing;
+} kinc_video_impl_t;
+
+typedef struct kinc_internal_video_sound_stream {
+	int nothing;
+} kinc_internal_video_sound_stream_t;
+
+void kinc_internal_video_sound_stream_init(kinc_internal_video_sound_stream_t *stream, int channel_count, int frequency);
+
+void kinc_internal_video_sound_stream_destroy(kinc_internal_video_sound_stream_t *stream);
+
+void kinc_internal_video_sound_stream_insert_data(kinc_internal_video_sound_stream_t *stream, float *data, int sample_count);
+
+float *kinc_internal_video_sound_stream_next_frame(kinc_internal_video_sound_stream_t *stream);
+
+bool kinc_internal_video_sound_stream_ended(kinc_internal_video_sound_stream_t *stream);
+
+#ifdef __cplusplus
+}
+#endif

Kha/Kinc/Backends/System/WindowsApp/Sources/kinc/backend/window.c

@@ -0,0 +1,55 @@
+#include <kinc/display.h>
+#include <kinc/graphics4/graphics.h>
+#include <kinc/window.h>
+
+int kinc_window_create(kinc_window_options_t *win, kinc_framebuffer_options_t *frame) {
+	return 0;
+}
+
+void kinc_window_destroy(int window_index) {}
+
+int kinc_count_windows(void) {
+	return 1;
+}
+
+void kinc_window_resize(int window_index, int width, int height) {}
+
+void kinc_window_move(int window_index, int x, int y) {}
+
+void kinc_window_change_mode(int window_index, kinc_window_mode_t mode) {}
+
+void kinc_window_change_features(int window_index, int features) {}
+
+void kinc_internal_change_framebuffer(int window, kinc_framebuffer_options_t *frame);
+
+void kinc_window_change_framebuffer(int window_index, kinc_framebuffer_options_t *frame) {
+	kinc_internal_change_framebuffer(0, frame);
+}
+
+int kinc_window_x(int window_index) {
+	return 0;
+}
+
+int kinc_window_y(int window_index) {
+	return 0;
+}
+
+int kinc_window_display(int window_index) {
+	return 0;
+}
+
+kinc_window_mode_t kinc_window_get_mode(int window_index) {
+	return KINC_WINDOW_MODE_WINDOW;
+}
+
+void kinc_window_show(int window_index) {}
+
+void kinc_window_hide(int window_index) {}
+
+void kinc_window_set_title(int window_index, const char *title) {}
+
+void kinc_window_set_resize_callback(int window_index, void (*callback)(int x, int y, void *data), void *data) {}
+
+void kinc_window_set_ppi_changed_callback(int window_index, void (*callback)(int ppi, void *data), void *data) {}
+
+void kinc_window_set_close_callback(int window, bool (*callback)(void *), void *data) {}

Kha/Kinc/Backends/System/WindowsApp/Sources/kinc/backend/windowdata.h

@@ -0,0 +1,5 @@
+#pragma once
+
+typedef struct {
+	int nothing;
+} WindowData;