armory3d.armortools/base/sources/ts/sys.ts

type sys_callback_t = {
	f?: () => void;
};

type sys_string_callback_t = {
	f?: (s: string) => void;
};

type callback_t = {
	f?: (data?: any) => void;
	data?: any;
};

let _sys_foreground_listeners: sys_callback_t[]        = [];
let _sys_resume_listeners: sys_callback_t[]            = [];
let _sys_pause_listeners: sys_callback_t[]             = [];
let _sys_background_listeners: sys_callback_t[]        = [];
let _sys_shutdown_listeners: sys_callback_t[]          = [];
let _sys_drop_files_listeners: sys_string_callback_t[] = [];

let _sys_start_time: f32;
let _sys_window_title: string;
let _sys_shaders: map_t<string, gpu_shader_t> = map_create();

declare type iron_window_options_t = {
	title?: string;
	x?: i32;
	y?: i32;
	width?: i32;
	height?: i32;
	features?: window_features_t;
	mode?: iron_window_mode_t;
	frequency?: i32;
	vsync?: bool;
	display_index?: i32;
	visible?: bool;
	color_bits?: i32;
	depth_bits?: i32;
};

function sys_start(ops: iron_window_options_t) {
	_iron_init(ops);

	_sys_start_time = iron_time();
	draw_init(iron_load_blob(data_path() + "draw_image.vert" + sys_shader_ext()), iron_load_blob(data_path() + "draw_image.frag" + sys_shader_ext()),
	          iron_load_blob(data_path() + "draw_image_transform.vert" + sys_shader_ext()),
	          iron_load_blob(data_path() + "draw_image_transform.frag" + sys_shader_ext()), iron_load_blob(data_path() + "draw_rect.vert" + sys_shader_ext()),
	          iron_load_blob(data_path() + "draw_rect.frag" + sys_shader_ext()), iron_load_blob(data_path() + "draw_tris.vert" + sys_shader_ext()),
	          iron_load_blob(data_path() + "draw_tris.frag" + sys_shader_ext()), iron_load_blob(data_path() + "draw_text.vert" + sys_shader_ext()),
	          iron_load_blob(data_path() + "draw_text.frag" + sys_shader_ext()));
	_iron_set_update_callback(sys_render);
	_iron_set_drop_files_callback(sys_drop_files_callback);
	iron_set_application_state_callback(sys_foreground_callback, sys_resume_callback, sys_pause_callback, sys_background_callback, sys_shutdown_callback);
	iron_set_keyboard_down_callback(sys_keyboard_down_callback);
	iron_set_keyboard_up_callback(sys_keyboard_up_callback);
	iron_set_mouse_down_callback(sys_mouse_down_callback);
	iron_set_mouse_up_callback(sys_mouse_up_callback);
	iron_set_mouse_move_callback(sys_mouse_move_callback);
	iron_set_mouse_wheel_callback(sys_mouse_wheel_callback);
	iron_set_touch_down_callback(sys_touch_down_callback);
	iron_set_touch_up_callback(sys_touch_up_callback);
	iron_set_touch_move_callback(sys_touch_move_callback);
	iron_set_pen_down_callback(sys_pen_down_callback);
	iron_set_pen_up_callback(sys_pen_up_callback);
	iron_set_pen_move_callback(sys_pen_move_callback);
	/// if WITH_GAMEPAD
	iron_set_gamepad_axis_callback(sys_gamepad_axis_callback);
	iron_set_gamepad_button_callback(sys_gamepad_button_callback);
	/// end
	input_register();
}

function _sys_callback_create(f: () => void): sys_callback_t {
	let cb: sys_callback_t = {};
	cb.f                   = f;
	return cb;
}

function sys_notify_on_app_state(on_foreground: () => void, on_resume: () => void, on_pause: () => void, on_background: () => void, on_shutdown: () => void) {
	if (on_foreground != null) {
		array_push(_sys_foreground_listeners, _sys_callback_create(on_foreground));
	}
	if (on_resume != null) {
		array_push(_sys_resume_listeners, _sys_callback_create(on_resume));
	}
	if (on_pause != null) {
		array_push(_sys_pause_listeners, _sys_callback_create(on_pause));
	}
	if (on_background != null) {
		array_push(_sys_background_listeners, _sys_callback_create(on_background));
	}
	if (on_shutdown != null) {
		array_push(_sys_shutdown_listeners, _sys_callback_create(on_shutdown));
	}
}

function sys_notify_on_drop_files(drop_files_listener: (s: string) => void) {
	let cb: sys_string_callback_t = {};
	cb.f                          = drop_files_listener;
	array_push(_sys_drop_files_listeners, cb);
}

function sys_foreground() {
	for (let i: i32 = 0; i < _sys_foreground_listeners.length; ++i) {
		_sys_foreground_listeners[i].f();
	}
	input_on_foreground();
}

function sys_resume() {
	for (let i: i32 = 0; i < _sys_resume_listeners.length; ++i) {
		_sys_resume_listeners[i].f();
	}
}

function sys_pause() {
	for (let i: i32 = 0; i < _sys_pause_listeners.length; ++i) {
		_sys_pause_listeners[i].f();
	}
}

function sys_background() {
	for (let i: i32 = 0; i < _sys_background_listeners.length; ++i) {
		_sys_background_listeners[i].f();
	}
}

function sys_shutdown() {
	for (let i: i32 = 0; i < _sys_shutdown_listeners.length; ++i) {
		_sys_shutdown_listeners[i].f();
	}
}

function sys_drop_files(file_path: string) {
	for (let i: i32 = 0; i < _sys_drop_files_listeners.length; ++i) {
		_sys_drop_files_listeners[i].f(file_path);
	}
}

function sys_time(): f32 {
	return iron_time() - _sys_start_time;
}

function sys_drop_files_callback(file_path: string) {
	sys_drop_files(file_path);
}

function sys_foreground_callback() {
	sys_foreground();
}

function sys_resume_callback() {
	sys_resume();
}

function sys_pause_callback() {
	sys_pause();
}

function sys_background_callback() {
	sys_background();
}

function sys_shutdown_callback() {
	sys_shutdown();
}

function sys_keyboard_down_callback(code: i32) {
	keyboard_down_listener(code);
}

function sys_keyboard_up_callback(code: i32) {
	keyboard_up_listener(code);
}

function sys_mouse_down_callback(button: i32, x: i32, y: i32) {
	mouse_down_listener(button, x, y);
}

function sys_mouse_up_callback(button: i32, x: i32, y: i32) {
	mouse_up_listener(button, x, y);
}

function sys_mouse_move_callback(x: i32, y: i32, mx: i32, my: i32) {
	mouse_move_listener(x, y, mx, my);
}

function sys_mouse_wheel_callback(delta: f32) {
	mouse_wheel_listener(delta);
}

function sys_touch_down_callback(index: i32, x: i32, y: i32) {
	/// if (arm_android || arm_ios)
	mouse_on_touch_down(index, x, y);
	/// end
}

function sys_touch_up_callback(index: i32, x: i32, y: i32) {
	/// if (arm_android || arm_ios)
	mouse_on_touch_up(index, x, y);
	/// end
}

function sys_touch_move_callback(index: i32, x: i32, y: i32) {
	/// if (arm_android || arm_ios)
	mouse_on_touch_move(index, x, y);
	/// end
}

function sys_pen_down_callback(x: i32, y: i32, pressure: f32) {
	pen_down_listener(x, y, pressure);
}

function sys_pen_up_callback(x: i32, y: i32, pressure: f32) {
	pen_up_listener(x, y, pressure);
}

function sys_pen_move_callback(x: i32, y: i32, pressure: f32) {
	pen_move_listener(x, y, pressure);
}

/// if WITH_GAMEPAD
function sys_gamepad_axis_callback(gamepad: i32, axis: i32, value: f32) {
	gamepad_axis_listener(gamepad, axis, value);
}

function sys_gamepad_button_callback(gamepad: i32, button: i32, value: f32) {
	gamepad_button_listener(gamepad, button, value);
}
/// end

function sys_title(): string {
	return _sys_window_title;
}

function sys_title_set(value: string) {
	iron_window_set_title(value);
	_sys_window_title = value;
}

function sys_display_primary_id(): i32 {
	for (let i: i32 = 0; i < iron_count_displays(); ++i) {
		if (iron_display_is_primary(i)) {
			return i;
		}
	}
	return 0;
}

function sys_display_width(): i32 {
	return iron_display_width(sys_display_primary_id());
}

function sys_display_height(): i32 {
	return iron_display_height(sys_display_primary_id());
}

function sys_display_frequency(): i32 {
	return iron_display_frequency(sys_display_primary_id());
}

function sys_buffer_to_string(b: buffer_t): string {
	let str: string = string_alloc(b.length + 1);
	memcpy(str, b.buffer, b.length);
	return str;
}

function sys_string_to_buffer(str: string): buffer_t {
	let b: u8_array_t = u8_array_create(str.length);
	memcpy(b.buffer, str, str.length);
	return b;
}

function sys_shader_ext(): string {
	/// if arm_vulkan
	return ".spirv";
	/// elseif arm_metal
	return ".metal";
	/// elseif arm_webgpu
	return ".wgsl";
	/// else
	return ".d3d11";
	/// end
}

function sys_get_shader(name: string): gpu_shader_t {
	let shader: gpu_shader_t = map_get(_sys_shaders, name);
	if (shader == null) {
		shader =
		    gpu_create_shader(iron_load_blob(data_path() + name + sys_shader_ext()), ends_with(name, ".frag") ? gpu_shader_type_t.FRAGMENT : gpu_shader_type_t.VERTEX);
		map_set(_sys_shaders, name, shader);
	}
	return shader;
}

function video_unload(self: video_t) {}

/// if arm_audio
function sound_create(sound_: any): sound_t {
	let raw: sound_t = {};
	raw.sound_       = sound_;
	return raw;
}

function sound_unload(raw: sound_t) {
	iron_a1_sound_destroy(raw.sound_);
}
/// end

type color_t = i32;

type video_t = {
	video_?: any;
};

type sound_t = {
	sound_?: any;
};

enum window_features_t {
	NONE        = 0,
	RESIZABLE   = 1,
	MINIMIZABLE = 2,
	MAXIMIZABLE = 4,
}

declare enum iron_window_mode_t {
	WINDOW,
	FULLSCREEN,
}

let _sys_on_next_frames: callback_t[]  = [];
let _sys_on_end_frames: callback_t[]   = [];
let _sys_on_updates: callback_t[]      = [];
let _sys_on_renders: callback_t[]      = [];
let _sys_lastw: i32                    = -1;
let _sys_lasth: i32                    = -1;
let sys_on_resize: () => void  = null;
let sys_on_w: () => i32  = null;
let sys_on_h: () => i32  = null;
let sys_on_x: () => i32  = null;
let sys_on_y: () => i32 = null;

function sys_w(): i32 {
	if (sys_on_w != null) {
		return sys_on_w();
	}
	return iron_window_width();
}

function sys_h(): i32 {
	if (sys_on_h != null) {
		return sys_on_h();
	}
	return iron_window_height();
}

function sys_x(): i32 {
	if (sys_on_x != null) {
		return sys_on_x();
	}
	return 0;
}

function sys_y(): i32 {
	if (sys_on_y != null) {
		return sys_on_y();
	}
	return 0;
}

function _sys_run_callbacks(cbs: callback_t[]) {
	for (let i: i32 = 0; i < cbs.length; ++i) {
		let cb: callback_t = cbs[i];
		cb.f(cb.data);
	}
}

let _sys_time_last: f32       = 0.0;
let _sys_time_real_delta: f32 = 0.0;
let _sys_time_frequency: i32  = -1;

function sys_delta(): f32 {
	if (_sys_time_frequency < 0) {
		_sys_time_frequency = sys_display_frequency();
	}
	return (1 / _sys_time_frequency);
}

function sys_real_delta(): f32 {
	return _sys_time_real_delta;
}

function sys_render() {
	if (_sys_on_next_frames.length > 0) {
		_sys_run_callbacks(_sys_on_next_frames);
		array_splice(_sys_on_next_frames, 0, _sys_on_next_frames.length);
	}

	_sys_run_callbacks(_sys_on_updates);

	if (iron_window_width() > 0 && iron_window_height() > 0) {
		scene_render_frame();
		_sys_run_callbacks(_sys_on_renders);
	}

	if (_sys_on_end_frames.length > 0) {
		_sys_run_callbacks(_sys_on_end_frames);
		array_splice(_sys_on_end_frames, 0, _sys_on_end_frames.length);
	}

	input_end_frame();

	// Rebuild projection on window resize
	if (_sys_lastw == -1) {
		_sys_lastw = sys_w();
		_sys_lasth = sys_h();
	}
	if (_sys_lastw != sys_w() || _sys_lasth != sys_h()) {
		if (sys_on_resize != null) {
			sys_on_resize();
		}
	}
	_sys_lastw           = sys_w();
	_sys_lasth           = sys_h();
	_sys_time_real_delta = sys_time() - _sys_time_last;
	_sys_time_last       = sys_time();
}

function _callback_create(f: (data?: any) => void, data: any): callback_t {
	let cb: callback_t = {};
	cb.f               = f;
	cb.data            = data;
	return cb;
}

// Hooks
function sys_notify_on_update(f: (data?: any) => void, data: any = null) {
	array_push(_sys_on_updates, _callback_create(f, data));
}

function sys_notify_on_render(f: (data?: any) => void, data: any = null) {
	array_push(_sys_on_renders, _callback_create(f, data));
}

function sys_notify_on_next_frame(f: (data?: any) => void, data: any = null) {
	array_push(_sys_on_next_frames, _callback_create(f, data));
}

function sys_notify_on_end_frame(f: (data?: any) => void, data: any = null) {
	array_push(_sys_on_end_frames, _callback_create(f, data));
}

function _sys_remove_callback(ar: callback_t[], f: (data?: any) => void) {
	for (let i: i32 = 0; i < ar.length; ++i) {
		if (ar[i].f == f) {
			array_splice(ar, i, 1);
			break;
		}
	}
}

function sys_remove_update(f: (data?: any) => void) {
	_sys_remove_callback(_sys_on_updates, f);
}

function sys_remove_render(f: (data?: any) => void) {
	_sys_remove_callback(_sys_on_renders, f);
}

function sys_remove_end_frame(f: (data?: any) => void) {
	_sys_remove_callback(_sys_on_end_frames, f);
}