sky_renderer 0.5.1

[DEPRECATED: use wilhelm_renderer instead] A minimalist 2D data rendering engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use std::ffi::{c_float, CString};
use std::ffi::c_void;
use std::os::raw::c_char;
use std::os::raw::c_double;
use std::os::raw::c_int;

pub const GLFW_SAMPLES: i32 = 0x0002100D;

pub const GLFW_PLATFORM_WIN32: i32 = 0x00060001;
pub const GLFW_PLATFORM_COCOA: i32 = 0x00060002;
pub const GLFW_PLATFORM_WAYLAND: i32 = 0x00060003;
pub const GLFW_PLATFORM_X11: i32 = 0x00060004;
pub const GLFW_PLATFORM_NULL: i32 = 0x00060005;

pub enum GLFWwindow {}

pub type GLFWframebuffersizefun =
    Option<extern "C" fn(window: *const GLFWwindow, width: i32, height: i32)>;

pub type GLFWwindowsizefun =
Option<extern "C" fn(window: *const GLFWwindow, width: i32, height: i32)>;

pub type GLFWscrollfun =
    Option<extern "C" fn(window: *const GLFWwindow, xoffset: f64, yoffset: f64)>;

pub type GLFWcursorposfun = Option<extern "C" fn(window: *const GLFWwindow, xpos: f64, ypos: f64)>;

unsafe extern "C" {
    fn _glfwCreateWindow(
        title: *const c_char,
        width: c_int,
        height: c_int,
        callback: GLFWframebuffersizefun,
    ) -> *const GLFWwindow;

    fn _glfwGetWindowContentScale(window: *const GLFWwindow, xscale: *mut c_float, yscale: *mut c_float);

    fn _glfwWindowHint(hint: c_int, value:c_int);

    fn _glfwSetWindowUserPointer(window: *const GLFWwindow, pointer: *const c_void);
    fn _glfwGetWindowUserPointer(window: *const GLFWwindow) -> *const c_void;

    fn _glfwWindowShouldClose(window: *const GLFWwindow) -> c_int;
    fn _glfwDestroyWindow(window: *const GLFWwindow);
    fn _glfwSwapBuffers(window: *const GLFWwindow);

    fn _glfwPollEvents();
    fn _glfwTerminate();

    fn _glfwGetTime() -> c_double;
    fn _glfwSetFramebufferSizeCallback(window: *const GLFWwindow, callback: GLFWframebuffersizefun);
    fn _glfwSetWindowSizeCallback(window: *const GLFWwindow, callback: GLFWwindowsizefun);
    fn _glfwSetScrollCallback(window: *const GLFWwindow, callback: GLFWscrollfun);
    fn _glfwSetCursorPosCallback(window: *const GLFWwindow, callback: GLFWcursorposfun);
    fn _glfwGetWindowSize(window: *const GLFWwindow, width: *mut c_int, height: *mut c_int);

    fn _glfwGetPlatform() -> c_int;
}

pub fn glfw_get_time() -> f64 {
    unsafe { _glfwGetTime() }
}

pub fn glfw_create_window(
    title: &str,
    width: i32,
    height: i32,
    callback: GLFWframebuffersizefun,
) -> *const GLFWwindow {
    let window_pointer: *const GLFWwindow;
    let title_c_string = CString::new(title).expect("Failed to create title");
    unsafe {
        window_pointer = _glfwCreateWindow(title_c_string.as_ptr(), width, height, callback);
    }
    window_pointer
}

pub fn glfw_get_window_content_scale(window: *const GLFWwindow)->(f32, f32){
    unsafe {
        let mut xs: f32 = 0.0;
        let mut ys: f32 = 0.0;
        _glfwGetWindowContentScale(window, &mut xs, &mut ys);
        (xs, ys)
    }
}

pub fn glfw_window_hint(hint: i32, value: i32){
    unsafe{
        _glfwWindowHint(hint, value);
    }
}

pub fn glfw_set_window_user_pointer(window: *const GLFWwindow, pointer: *mut c_void) {
    unsafe {
        _glfwSetWindowUserPointer(window, pointer);
    }
}

pub fn glfw_get_window_user_pointer(window: *const GLFWwindow) -> *const c_void {
    unsafe { _glfwGetWindowUserPointer(window) }
}

pub fn glfw_window_should_close(window: *const GLFWwindow) -> bool {
    let result: i32;
    unsafe {
        result = _glfwWindowShouldClose(window);
    }
    result != 0
}

pub fn glfw_set_scroll_callback(window: *const GLFWwindow, callback: GLFWscrollfun) {
    unsafe {
        _glfwSetScrollCallback(window, callback);
    }
}

pub fn glfw_set_cursor_pos_callback(window: *const GLFWwindow, callback: GLFWcursorposfun) {
    unsafe {
        _glfwSetCursorPosCallback(window, callback);
    }
}

pub fn glfw_set_window_size_callback(window: *const GLFWwindow, callback: GLFWwindowsizefun){
    unsafe{
        _glfwSetWindowSizeCallback(window, callback);
    }
}

pub fn glfw_get_window_size(window: *const GLFWwindow, width: *mut c_int, height: *mut c_int) {
    unsafe {
        _glfwGetWindowSize(window, width, height);
    }
}

pub fn glfw_poll_events() {
    unsafe { _glfwPollEvents() }
}

pub fn glfw_swap_buffers(window: *const GLFWwindow) {
    unsafe { _glfwSwapBuffers(window) }
}

pub fn glfw_destroy_window(window: *const GLFWwindow) {
    unsafe { _glfwDestroyWindow(window) }
}

pub fn glfw_terminate() {
    unsafe { _glfwTerminate() };
}

/// Returns the currently selected platform.
///
/// Returns one of: `GLFW_PLATFORM_WIN32`, `GLFW_PLATFORM_COCOA`,
/// `GLFW_PLATFORM_WAYLAND`, `GLFW_PLATFORM_X11`, or `GLFW_PLATFORM_NULL`.
///
/// Must be called after GLFW initialization (window creation).
pub fn glfw_get_platform() -> i32 {
    unsafe { _glfwGetPlatform() }
}