platform.h

Go to the documentation of this file.

 
#pragma once
 
#include "defines.h"
#include "input_types.h"
#include "logger.h"
 
typedef u64 kunix_time_ns;
 
typedef struct platform_system_config {
    const char* application_name;
} platform_system_config;
 
typedef struct dynamic_library_function {
    const char* name;
    void* pfn;
} dynamic_library_function;
 
typedef struct dynamic_library {
    const char* name;
    const char* filename;
    u64 internal_data_size;
    void* internal_data;
    u32 watch_id;
 
    // darray
    dynamic_library_function* functions;
} dynamic_library;
 
typedef enum platform_error_code {
    PLATFORM_ERROR_SUCCESS = 0,
    PLATFORM_ERROR_UNKNOWN = 1,
    PLATFORM_ERROR_FILE_NOT_FOUND = 2,
    PLATFORM_ERROR_FILE_LOCKED = 3,
    PLATFORM_ERROR_FILE_EXISTS = 4
} platform_error_code;
 
struct platform_state;
 
typedef struct kwindow_config {
    i32 position_x;
    i32 position_y;
    u32 width;
    u32 height;
    const char* title;
    const char* name;
} kwindow_config;
 
struct kwindow_platform_state;
struct kwindow_renderer_state;
 
typedef struct kwindow {
    const char* name;
    const char* title;
 
    u16 width;
    u16 height;
 
    f32 device_pixel_ratio;
 
    b8 resizing;
    u16 frames_since_resize;
 
    struct kwindow_platform_state* platform_state;
 
    struct kwindow_renderer_state* renderer_state;
} kwindow;
 
typedef enum ksystem_info_flags {
    KSYSTEM_INFO_FLAGS_NONE = 0,
    KSYSTEM_INFO_FLAGS_IS_64_BIT_BIT = 1 << 0,
    KSYSTEM_INFO_FLAGS_IS_VITRUALIZED_BIT = 1 << 1,
    KSYSTEM_INFO_FLAGS_DEBUGGER_ATTACHED_BIT = 1 << 2,
} ksystem_info_flags;
 
typedef u32 ksystem_info_flag_bits;
 
typedef enum kcpu_feature_flags {
    KCPU_FEATURE_FLAGS_NONE = 0,
    KCPU_FEATURE_FLAG_SSE_BIT = 1 << 0,
    KCPU_FEATURE_FLAG_SSE2_BIT = 1 << 1,
    KCPU_FEATURE_FLAG_SSE3_BIT = 1 << 2,
    KCPU_FEATURE_FLAG_SSSE3_BIT = 1 << 3,
    KCPU_FEATURE_FLAG_SSE41_BIT = 1 << 4,
    KCPU_FEATURE_FLAG_SSE42_BIT = 1 << 5,
    KCPU_FEATURE_FLAG_AVX_BIT = 1 << 6,
    KCPU_FEATURE_FLAG_AVX2_BIT = 1 << 7,
    KCPU_FEATURE_FLAG_NEON_BIT = 1 << 8
} kcpu_feature_flags;
 
typedef u32 kcpu_feature_flag_bits;
 
#define KMAX_STORAGE_DEVICES 32
#define KMAX_PATH_LEN 256
 
typedef enum kdrive_type {
    KDRIVE_TYPE_UNKNOWN = 0,
    KDRIVE_TYPE_NO_ROOT_DIR = 1,
    KDRIVE_TYPE_REMOVABLE = 2,
    KDRIVE_TYPE_FIXED = 3,
    KDRIVE_TYPE_REMOTE = 4,
    KDRIVE_TYPE_CDROM = 5,
    KDRIVE_TYPE_RAMDISK = 6
} kdrive_type;
 
KINLINE const char* kdrive_type_to_string(kdrive_type type) {
    switch (type) {
    default:
    case KDRIVE_TYPE_UNKNOWN:
    case KDRIVE_TYPE_NO_ROOT_DIR:
        return "KDRIVE_TYPE_UNKNOWN";
    case KDRIVE_TYPE_REMOVABLE:
        return "KDRIVE_TYPE_REMOVABLE";
    case KDRIVE_TYPE_FIXED:
        return "KDRIVE_TYPE_FIXED";
    case KDRIVE_TYPE_REMOTE:
        return "KDRIVE_TYPE_REMOTE";
    case KDRIVE_TYPE_CDROM:
        return "KDRIVE_TYPE_CDROM";
    case KDRIVE_TYPE_RAMDISK:
        return "KDRIVE_TYPE_RAMDISK";
    }
}
 
typedef struct kstorage_info {
    char name[KMAX_PATH_LEN];
    char mount_point[KMAX_PATH_LEN];
    u64 total_bytes;
    u64 free_bytes;
    kdrive_type type;
    b8 is_ssd;
} kstorage_info;
 
typedef struct ksystem_info {
    char cpu_name[128];
    u32 cpu_mhz;
    u32 logical_cores;
    u32 physical_cores;
    char cpu_arch[10];
 
    u64 ram_total_bytes;
    u64 ram_available_bytes;
    u32 ram_speed_mhz; // 0 if unknown
 
    char os_name[64];
    char os_version[64];
    char os_build[64];
    char kernel_version[256];
    char distro[64]; // linux only
 
    ksystem_info_flag_bits flags;
 
    kcpu_feature_flag_bits features;
 
    kstorage_info storage[KMAX_STORAGE_DEVICES];
    u32 storage_count;
} ksystem_info;
 
typedef enum kclipboard_content_type {
    KCLIPBOARD_CONTENT_TYPE_STRING,
    KCLIPBOARD_CONTENT_TYPE_IMAGE,
    KCLIPBOARD_CONTENT_TYPE_BINARY
} kclipboard_content_type;
 
typedef struct kclipboard_context {
    kclipboard_content_type content_type;
    kwindow* requesting_window;
    u64 size;
    const void* content;
} kclipboard_context;
 
typedef void (*platform_filewatcher_file_deleted_callback)(u32 watcher_id, void* context);
typedef void (*platform_filewatcher_file_written_callback)(u32 watcher_id, const char* file_path, b8 is_binary, void* context);
typedef void (*platform_window_closed_callback)(const struct kwindow* window);
typedef void (*platform_window_resized_callback)(const struct kwindow* window);
typedef void (*platform_process_key)(keys key, b8 pressed, b8 is_repeat);
typedef void (*platform_process_mouse_button)(mouse_buttons button, b8 pressed);
typedef void (*platform_process_mouse_move)(i16 x, i16 y);
typedef void (*platform_process_mouse_wheel)(i8 z_delta);
typedef void (*platform_clipboard_on_paste_callback)(kclipboard_context context);
 
KAPI b8 platform_system_startup(u64* memory_requirement, struct platform_state* state, platform_system_config* config);
 
KAPI void platform_system_shutdown(struct platform_state* state);
 
KAPI b8 platform_window_create(const kwindow_config* config, struct kwindow* window, b8 show_immediately);
 
KAPI void platform_window_destroy(struct kwindow* window);
 
KAPI b8 platform_window_show(struct kwindow* window);
 
KAPI b8 platform_window_hide(struct kwindow* window);
 
KAPI const char* platform_window_title_get(const struct kwindow* window);
 
KAPI b8 platform_window_title_set(struct kwindow* window, const char* title);
 
KAPI b8 platform_pump_messages(void);
 
KAPI void* platform_allocate(u64 size, b8 aligned);
 
KAPI void platform_free(void* block, b8 aligned);
 
KAPI void* platform_zero_memory(void* block, u64 size);
 
KAPI void* platform_copy_memory(void* dest, const void* source, u64 size);
 
KAPI void* platform_set_memory(void* dest, i32 value, u64 size);
 
KAPI void platform_console_write(struct platform_state* platform, log_level level, const char* message);
 
KAPI f64 platform_get_absolute_time(void);
 
KAPI void platform_sleep(u64 ms);
 
KAPI i32 platform_get_processor_count(void);
 
KAPI void platform_get_handle_info(u64* out_size, void* memory);
 
KAPI f32 platform_device_pixel_ratio(const struct kwindow* window);
 
KAPI b8 platform_dynamic_library_load(const char* name, dynamic_library* out_library);
 
KAPI b8 platform_dynamic_library_unload(dynamic_library* library);
 
KAPI void* platform_dynamic_library_load_function(const char* name, dynamic_library* library);
 
KAPI const char* platform_dynamic_library_extension(void);
 
KAPI const char* platform_dynamic_library_prefix(void);
 
KAPI platform_error_code platform_copy_file(const char* source, const char* dest, b8 overwrite_if_exists);
 
KAPI void platform_register_window_closed_callback(platform_window_closed_callback callback);
 
KAPI void platform_register_window_resized_callback(platform_window_resized_callback callback);
 
KAPI void platform_register_process_key(platform_process_key callback);
 
KAPI void platform_register_process_mouse_button_callback(platform_process_mouse_button callback);
 
KAPI void platform_register_process_mouse_move_callback(platform_process_mouse_move callback);
 
KAPI void platform_register_process_mouse_wheel_callback(platform_process_mouse_wheel callback);
 
KAPI void platform_register_clipboard_paste_callback(platform_clipboard_on_paste_callback callback);
 
KAPI b8 platform_watch_file(
    const char* file_path,
    b8 is_binary,
    platform_filewatcher_file_written_callback watcher_written_callback,
    void* watcher_written_context,
    platform_filewatcher_file_deleted_callback watcher_deleted_callback,
    void* watcher_deleted_context,
    u32* out_watch_id);
KAPI b8 platform_unwatch_file(u32 watch_id);
 
KAPI kunix_time_ns platform_get_file_mtime(const char* path);
 
KAPI b8 platform_system_info_collect(ksystem_info* out_info);
 
// Used for pasting into the application.
KAPI void platform_request_clipboard_content(kwindow* window);
 
// Used for copying from the application.
KAPI void platform_clipboard_content_set(kwindow* window, kclipboard_content_type type, u32 size, void* content);