rustyray_sys/ffi.rs
1/**********************************************************************************************
2*
3* raylib v5.5 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
4*
5* FEATURES:
6* - NO external dependencies, all required libraries included with raylib
7* - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly,
8* MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5.
9* - Written in plain C code (C99) in PascalCase/camelCase notation
10* - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3, ES2, ES3 - choose at compile)
11* - Unique OpenGL abstraction layer (usable as standalone module): [rlgl]
12* - Multiple Fonts formats supported (TTF, OTF, FNT, BDF, Sprite fonts)
13* - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC)
14* - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more!
15* - Flexible Materials system, supporting classic maps and PBR maps
16* - Animated 3D models supported (skeletal bones animation) (IQM, M3D, GLTF)
17* - Shaders support, including Model shaders and Postprocessing shaders
18* - Powerful math module for Vector, Matrix and Quaternion operations: [raymath]
19* - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, QOA, XM, MOD)
20* - VR stereo rendering with configurable HMD device parameters
21* - Bindings to multiple programming languages available!
22*
23* NOTES:
24* - One default Font is loaded on InitWindow()->LoadFontDefault() [core, text]
25* - One default Texture2D is loaded on rlglInit(), 1x1 white pixel R8G8B8A8 [rlgl] (OpenGL 3.3 or ES2)
26* - One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2)
27* - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2)
28*
29* DEPENDENCIES (included):
30* [rcore][GLFW] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input
31* [rcore][RGFW] rgfw (ColleagueRiley - github.com/ColleagueRiley/RGFW) for window/context management and input
32* [rlgl] glad/glad_gles2 (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading
33* [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management
34*
35* OPTIONAL DEPENDENCIES (included):
36* [rcore] msf_gif (Miles Fogle) for GIF recording
37* [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm
38* [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm
39* [rcore] rprand (Ramon Snatamaria) for pseudo-random numbers generation
40* [rtextures] qoi (Dominic Szablewski - https://phoboslab.org) for QOI image manage
41* [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...)
42* [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG)
43* [rtextures] stb_image_resize2 (Sean Barret) for image resizing algorithms
44* [rtextures] stb_perlin (Sean Barret) for Perlin Noise image generation
45* [rtext] stb_truetype (Sean Barret) for ttf fonts loading
46* [rtext] stb_rect_pack (Sean Barret) for rectangles packing
47* [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation
48* [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL)
49* [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF)
50* [rmodels] m3d (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d)
51* [rmodels] vox_loader (Johann Nadalutti) for models loading (VOX)
52* [raudio] dr_wav (David Reid) for WAV audio file loading
53* [raudio] dr_flac (David Reid) for FLAC audio file loading
54* [raudio] dr_mp3 (David Reid) for MP3 audio file loading
55* [raudio] stb_vorbis (Sean Barret) for OGG audio loading
56* [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading
57* [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading
58* [raudio] qoa (Dominic Szablewski - https://phoboslab.org) for QOA audio manage
59*
60*
61* LICENSE: zlib/libpng
62*
63* raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
64* BSD-like license that allows static linking with closed source software:
65*
66* Copyright (c) 2013-2024 Ramon Santamaria (@raysan5)
67*
68* This software is provided "as-is", without any express or implied warranty. In no event
69* will the authors be held liable for any damages arising from the use of this software.
70*
71* Permission is granted to anyone to use this software for any purpose, including commercial
72* applications, and to alter it and redistribute it freely, subject to the following restrictions:
73*
74* 1. The origin of this software must not be misrepresented; you must not claim that you
75* wrote the original software. If you use this software in a product, an acknowledgment
76* in the product documentation would be appreciated but is not required.
77*
78* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
79* as being the original software.
80*
81* 3. This notice may not be removed or altered from any source distribution.
82*
83**********************************************************************************************/
84
85use libc::{c_char, c_double, c_float, c_int, c_uchar, c_uint, c_void};
86
87use crate::{
88 audio::{AudioCallback, AudioStream, Music, Sound, Wave},
89 color::Color,
90 consts::{
91 ConfigFlag, GamepadAxis, GamepadButton, Gesture, KeyboardKey, MouseButton, MouseCursor,
92 TextureFilter, TextureWrap,
93 },
94 math::Rectangle,
95 math::Vector2,
96 texture::{Image, RenderTexture, RenderTexture2D, Texture},
97};
98
99// Window-related functions
100extern "C" {
101 /// Initialize window and OpenGL context
102 #[link_name = "InitWindow"]
103 pub fn init_window(width: c_int, height: c_int, title: *const c_char);
104 /// Close window and unload OpenGL context
105 #[link_name = "CloseWindow"]
106 pub fn close_window();
107 /// Check if application should close (KEY_ESCAPE pressed or windows close icon clicked)
108 #[link_name = "WindowShouldClose"]
109 pub fn window_should_close() -> bool;
110 /// Check if window has been initialized successfully
111 #[link_name = "IsWindowReady"]
112 pub fn is_window_ready() -> bool;
113 /// Check if window is currently fullscreen
114 #[link_name = "IsWindowFullscreen"]
115 pub fn is_window_fullscreen() -> bool;
116 /// Check if window is currently hidden
117 #[link_name = "IsWindowHidden"]
118 pub fn is_window_hidden() -> bool;
119 /// Check if window is currently minimized
120 #[link_name = "IsWindowMinimized"]
121 pub fn is_window_minimized() -> bool;
122 /// Check if window is currently maximized
123 #[link_name = "IsWindowMaximized"]
124 pub fn is_window_maximized() -> bool;
125 /// Check if window is currently focused
126 #[link_name = "IsWindowFocused"]
127 pub fn is_window_focused() -> bool;
128 /// Check if window has been resized last frame
129 #[link_name = "IsWindowResized"]
130 pub fn is_window_resized() -> bool;
131 /// Check if one specific window flag is enabled
132 ///
133 /// Flags should be of values defined in [ConfigFlag].
134 ///
135 /// Use this value as a bitmask.
136 ///
137 /// # Examples
138 /// ```no_run
139 /// use rustyray_sys::{ffi::is_window_state, consts::ConfigFlag};
140 ///
141 /// unsafe { is_window_state(ConfigFlag::VsyncHint | ConfigFlag::FullscreenMode) };
142 /// ```
143 #[link_name = "IsWindowState"]
144 pub fn is_window_state(flags: ConfigFlag) -> bool;
145 /// Set window configuration state using flags
146 ///
147 /// Flags should be of values defined in [ConfigFlag].
148 ///
149 /// Use this value as a bitmask.
150 ///
151 /// # Examples
152 /// ```no_run
153 /// use rustyray_sys::{ffi::set_window_state, consts::ConfigFlag};
154 ///
155 /// unsafe { set_window_state(ConfigFlag::VsyncHint | ConfigFlag::FullscreenMode); }
156 /// ```
157 #[link_name = "SetWindowState"]
158 pub fn set_window_state(flags: ConfigFlag);
159 /// Clear window configuration state flags
160 ///
161 /// Flags should be of values defined in [ConfigFlag].
162 ///
163 /// Use this value as a bitmask.
164 ///
165 /// # Examples
166 /// ```no_run
167 /// use rustyray_sys::{ffi::clear_window_state, consts::ConfigFlag};
168 ///
169 /// unsafe { clear_window_state(ConfigFlag::VsyncHint | ConfigFlag::FullscreenMode); }
170 /// ```
171 #[link_name = "ClearWindowState"]
172 pub fn clear_window_state(flags: ConfigFlag);
173 /// Toggle window state: fullscreen/windowed, resizes monitor to match window resolution
174 #[link_name = "ToggleFullscreen"]
175 pub fn toggle_fullscreen();
176 /// Toggle window state: borderless windowed, resizes window to match monitor resolution
177 #[link_name = "ToggleBorderlessWindowed"]
178 pub fn toggle_borderless_windowed();
179 /// Set window state: maximized, if resizable
180 #[link_name = "MaximizeWindow"]
181 pub fn maximize_window();
182 /// Set window state: minimized, if resizable
183 #[link_name = "MinimizeWindow"]
184 pub fn minimize_window();
185 /// Set window state: not minimized/maximized
186 #[link_name = "RestoreWindow"]
187 pub fn restore_window();
188 /// Set icon for window (single image, RGBA 32bit)
189 #[link_name = "SetWindowIcon"]
190 pub fn set_window_icon(image: Image);
191 /// Set icon for window (multiple images, RGBA 32bit)
192 #[link_name = "SetWindowIcons"]
193 pub fn set_window_icons(images: *const Image);
194 /// Set title for window
195 #[link_name = "SetWindowTitle"]
196 pub fn set_window_title(images: *const c_char);
197 /// Set window position on screen
198 #[link_name = "SetWindowPosition"]
199 pub fn set_window_position(x: c_int, y: c_int);
200 /// Set monitor for the current window
201 #[link_name = "SetWindowMonitor"]
202 pub fn set_window_monitor(monitor: c_int);
203 /// Set window minimum dimensions (for [ConfigFlag::WindowResizable])
204 #[link_name = "SetWindowMinSize"]
205 pub fn set_window_min_size(width: c_int, height: c_int);
206 /// Set window maximum dimensions (for [ConfigFlag::WindowResizable])
207 #[link_name = "SetWindowMaxSize"]
208 pub fn set_window_max_size(width: c_int, height: c_int);
209 /// Set window dimension
210 #[link_name = "SetWindowSize"]
211 pub fn set_window_size(width: c_int, height: c_int);
212 /// Set window opacity [0.0..1.0]
213 #[link_name = "SetWindowOpacity"]
214 pub fn set_window_opacity(opacity: c_float);
215 /// Set window focused
216 #[link_name = "SetWindowFocused"]
217 pub fn set_window_focused();
218 /// Get current screen width
219 #[link_name = "GetScreenWidth"]
220 pub fn get_screen_width() -> c_int;
221 /// Get current screen height
222 #[link_name = "GetScreenHeight"]
223 pub fn get_screen_height() -> c_int;
224 /// Get current render width (it considers HiDPI)
225 #[link_name = "GetRenderWidth"]
226 pub fn get_render_width() -> c_int;
227 /// Get current render height (it considers HiDPI)
228 #[link_name = "GetRenderHeight"]
229 pub fn get_render_height() -> c_int;
230 /// Get number of connected monitors
231 #[link_name = "GetMonitorCount"]
232 pub fn get_monitor_count() -> c_int;
233 /// Get current monitor where window is placed
234 #[link_name = "GetCurrentMonitor"]
235 pub fn get_current_monitor() -> c_int;
236 /// Get specified monitor position
237 #[link_name = "GetMonitorPosition"]
238 pub fn get_monitor_position(monitor: c_int) -> Vector2;
239 /// Get specified monitor width (current video mode used by monitor)
240 #[link_name = "GetMonitorWidth"]
241 pub fn get_monitor_width(monitor: c_int) -> c_int;
242 /// Get specified monitor height (current video mode used by monitor)
243 #[link_name = "GetMonitorHeight"]
244 pub fn get_monitor_height(monitor: c_int) -> c_int;
245 /// Get specified monitor physical width in millimetres
246 #[link_name = "GetMonitorPhysicalWidth"]
247 pub fn get_monitor_physical_width(monitor: c_int) -> c_int;
248 /// Get specified monitor physical height in millimetres
249 #[link_name = "GetMonitorPhysicalHeight"]
250 pub fn get_monitor_physical_height(monitor: c_int) -> c_int;
251 /// Get specified monitor refresh rate
252 #[link_name = "GetMonitorRefreshRate"]
253 pub fn get_monitor_refresh_rate(monitor: c_int) -> c_int;
254 /// Get position XY on monitor
255 #[link_name = "GetWindowPosition"]
256 pub fn get_window_position() -> Vector2;
257 /// Get window scale DPI factor
258 #[link_name = "GetWindowScaleDPI"]
259 pub fn get_window_scale_dpi() -> Vector2;
260 /// Get the human-readable, UTF-8 encoded name of the specified monitor
261 #[link_name = "GetMonitorName"]
262 pub fn get_monitor_name(monitor: c_int) -> *const c_char;
263 /// Set clipboard text content
264 #[link_name = "SetClipboardText"]
265 pub fn set_clipboard_text(text: *const c_char);
266 /// Get clipboard text content
267 #[link_name = "GetClipboardText"]
268 pub fn get_clipboard_text() -> *const c_char;
269 /// Get clipboard image content
270 #[link_name = "GetClipboardImage"]
271 pub fn get_clipboard_image() -> Image;
272 /// Enable waiting for events on [end_drawing], no automatic event polling
273 #[link_name = "EnableEventWaiting"]
274 pub fn enable_event_waiting();
275 /// Disable waiting for events on [end_drawing], automatic event polling
276 #[link_name = "DisableEventWaiting"]
277 pub fn disable_event_waiting();
278}
279
280// Cursor-related functions
281extern "C" {
282 /// Shows cursor
283 #[link_name = "ShowCursor"]
284 pub fn show_cursor();
285 /// Hides cursor
286 #[link_name = "HideCursor"]
287 pub fn hide_cursor();
288 /// Check if cursor is not visible
289 #[link_name = "IsCursorHidden"]
290 pub fn is_cursor_hidden();
291 /// Enables cursor (unlock cursor)
292 #[link_name = "EnableCursor"]
293 pub fn enable_cursor();
294 /// Disabled cursor (lock cursor)
295 #[link_name = "DisableCursor"]
296 pub fn disable_cursor();
297 /// Check if cursor is on the screen
298 #[link_name = "IsCursorOnScreen"]
299 pub fn is_cursor_on_screen();
300}
301
302// Drawing related functions
303extern "C" {
304 /// Set background color (framebuffer clear color)
305 #[link_name = "ClearBackground"]
306 pub fn clear_background(color: Color);
307 /// Setup canvas (framebuffer) to start drawing
308 #[link_name = "BeginDrawing"]
309 pub fn begin_drawing();
310 /// End canvas drawing and swap buffers (double buffering)
311 #[link_name = "EndDrawing"]
312 pub fn end_drawing();
313 /// Begin drawing to render texture
314 #[link_name = "BeginTextureMode"]
315 pub fn begin_texture_mode(render_texture: RenderTexture2D);
316 /// Ends drawing to render texture
317 #[link_name = "EndTextureMode"]
318 pub fn end_texture_mode();
319}
320
321// Texture loading functions
322// Note: These function require GPU access
323extern "C" {
324 /// Load texture from file into GPU memory (VRAM)
325 #[link_name = "LoadTexture"]
326 pub fn load_texture(path: *const c_char) -> Texture;
327 /// Load texture from image data
328 #[link_name = "LoadTextureFromImage"]
329 pub fn load_texture_from_image(image: Image) -> Texture;
330 /// Load texture for rendering (framebuffer)
331 #[link_name = "LoadRenderTexture"]
332 pub fn load_render_texture(width: c_int, height: c_int) -> RenderTexture;
333 /// Check if a texture is valid (loaded in GPU)
334 #[link_name = "IsTextureValid"]
335 pub fn is_texture_valid(texture: Texture) -> bool;
336 /// Unload texture from GPU memory (VRAM)
337 #[link_name = "UnloadTexture"]
338 pub fn unload_texture(texture: Texture);
339 /// Check if a render texture is valid (loaded in GPU)
340 #[link_name = "IsRenderTextureValid"]
341 pub fn is_render_texture_valid(target: RenderTexture) -> bool;
342 /// Unload render texture from GPU memory (VRAM)
343 #[link_name = "UnloadRenderTexture"]
344 pub fn unload_render_texture(render_texture: RenderTexture);
345 /// Update GPU texture with new data
346 #[link_name = "UpdateTexture"]
347 pub fn update_texture(texture: Texture, pixels: *const c_void);
348 /// Update GPU texture rectangle with new data
349 #[link_name = "UpdateTextureRec"]
350 pub fn update_texture_rec(texture: Texture, rec: Rectangle, pixels: *const c_void);
351}
352
353// Texture configuration function
354extern "C" {
355 /// Generate GPU mipmaps for a texture
356 #[link_name = "GenTextureMipmaps"]
357 pub fn gen_texture_mipmaps(texture: *mut Texture);
358 /// Set texture scaling filter mode
359 #[link_name = "SetTextureFilter"]
360 pub fn set_texture_filter(texture: Texture, filter: TextureFilter);
361 /// Set texture wrapping mode
362 #[link_name = "SetTextureWrap"]
363 pub fn set_texture_wrap(texture: Texture, wrap: TextureWrap);
364}
365
366// Texture drawing functions
367extern "C" {
368 /// Draw a [Texture]
369 #[link_name = "DrawTexture"]
370 pub fn draw_texture(texture: Texture, pos_x: c_int, pos_y: c_int, tint: Color);
371 /// Draw a [Texture] with position defined as [Vector2]
372 #[link_name = "DrawTextureV"]
373 pub fn draw_texture_v(texture: Texture, pos: Vector2, tint: Color);
374 /// Draw a [Texture] with extended parameters
375 #[link_name = "DrawTextureEx"]
376 pub fn draw_texture_ex(
377 texture: Texture,
378 pos: Vector2,
379 rotation: c_float,
380 scale: c_float,
381 tint: Color,
382 );
383 /// Draw a part of a [Texture] defined by a [Rectangle]
384 #[link_name = "DrawTextureRec"]
385 pub fn draw_texture_rec(texture: Texture, source: Rectangle, position: Vector2, tint: Color);
386 /// Draw a part of a [Texture] defined by a [Rectangle] with 'pro' parameters
387 #[link_name = "DrawTexturePro"]
388 pub fn draw_texture_pro(
389 texture: Texture,
390 source: Rectangle,
391 dest: Rectangle,
392 origin: Vector2,
393 rotation: c_float,
394 tint: Color,
395 );
396 // TODO: Add draw_texture_npatch when NPatchInfo is implemented
397}
398
399// Text drawing functions
400extern "C" {
401 /// Draw current FPS
402 #[link_name = "DrawFPS"]
403 pub fn draw_fps(pos_x: c_int, pos_y: c_int);
404 /// Draw text (using default font)
405 #[link_name = "DrawText"]
406 pub fn draw_text(
407 text: *const c_char,
408 pos_x: c_int,
409 pos_y: c_int,
410 font_size: c_int,
411 color: Color,
412 );
413}
414
415// Text font info functions
416extern "C" {
417 /// Measure string width for default font
418 #[link_name = "MeasureText"]
419 pub fn measure_text(text: *const c_char, font_size: c_int);
420}
421
422// Basic shapes drawing functions
423extern "C" {
424 /// Draw a color-filled circle (Vector version)
425 #[link_name = "DrawCircleV"]
426 pub fn draw_circle_v(center: Vector2, radius: c_float, color: Color);
427 /// Draw a color-filled rectangle
428 #[link_name = "DrawRectangleRec"]
429 pub fn draw_rectangle_rec(rec: Rectangle, color: Color);
430 /// Draw rectangle outline
431 #[link_name = "DrawRectangleLines"]
432 pub fn draw_rectangle_lines(
433 pos_x: c_int,
434 pos_y: c_int,
435 width: c_int,
436 height: c_int,
437 color: Color,
438 );
439}
440
441// Input-related functions: keyboard
442extern "C" {
443 /// Check if a key has been pressed once
444 #[link_name = "IsKeyPressed"]
445 pub fn is_key_pressed(key: KeyboardKey) -> bool;
446 /// Check if a key has been pressed again
447 #[link_name = "IsKeyPressedRepeat"]
448 pub fn is_key_pressed_repeat(key: KeyboardKey) -> bool;
449 /// Check if a key is being pressed
450 #[link_name = "IsKeyDown"]
451 pub fn is_key_down(key: KeyboardKey) -> bool;
452 /// Check if a key has been released once
453 #[link_name = "IsKeyReleased"]
454 pub fn is_key_released(key: KeyboardKey) -> bool;
455 /// Check if a key is **NOT** being pressed
456 #[link_name = "IsKeyUp"]
457 pub fn is_key_up(key: KeyboardKey) -> bool;
458 /// Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty
459 #[link_name = "GetKeyPressed"]
460 pub fn get_key_pressed() -> c_int;
461 /// Get char pressed (unicode), call it multiple times for chars queued, return s0 when the queue is empty
462 #[link_name = "GetCharPressed"]
463 pub fn get_char_pressed() -> c_int;
464 /// Set a custom key to exit program (default is [KeyboardKey::Escape])
465 #[link_name = "SetExitKey"]
466 pub fn set_exit_key(key: c_int);
467}
468
469// Input-related functions: gamepads
470extern "C" {
471 /// Check if a gamepad is available
472 #[link_name = "IsGamepadAvailable"]
473 pub fn is_gamepad_available(gamepad: c_int) -> bool;
474 /// Get gamepad internal name id
475 #[link_name = "GetGamepadName"]
476 pub fn get_gamepad_name(gamepad: c_int) -> *const c_char;
477 /// Check if a gamepad button has been pressed once
478 #[link_name = "IsGamepadButtonPressed"]
479 pub fn is_gamepad_button_pressed(gamepad: c_int, button: GamepadButton) -> bool;
480 /// Check if a gamepad button is being pressed
481 #[link_name = "IsGamepadButtonDown"]
482 pub fn is_gamepad_button_down(gamepad: c_int, button: GamepadButton) -> bool;
483 /// Check if a gamepad button has been released once
484 #[link_name = "IsGamepadButtonReleased"]
485 pub fn is_gamepad_button_released(gamepad: c_int, button: GamepadButton) -> bool;
486 /// Check if a gamepad button is **NOT** being pressed
487 #[link_name = "IsGamepadButtonUp"]
488 pub fn is_gamepad_button_up(gamepad: c_int, button: GamepadButton) -> bool;
489 /// Get the last gamepad button pressed
490 #[link_name = "GetGamepadButtonPressed"]
491 pub fn get_gamepad_button_pressed(gamepad: c_int) -> GamepadButton;
492 /// Get gamepad axis count for a gamepad
493 #[link_name = "GetGamepadAxisCount"]
494 pub fn get_gamepad_axis_count(gamepad: c_int) -> c_int;
495 /// Get axis movement value for a gamepad axis
496 #[link_name = "GetGamepadAxisMovement"]
497 pub fn get_gamepad_axis_movement(gamepad: c_int, axis: GamepadAxis) -> c_float;
498 /// Set gamepad vibration for both motors (duration in seconds)
499 #[link_name = "SetGamepadVibration"]
500 pub fn set_gamepad_vibration(
501 gamepad: c_int,
502 left_motor: c_float,
503 right_motor: c_float,
504 duration: c_float,
505 );
506}
507
508// Input-related functions: mouse
509extern "C" {
510 /// Check if a [MouseButton] has been pressed once
511 #[link_name = "IsMouseButtonPressed"]
512 pub fn is_mouse_button_pressed(button: MouseButton) -> bool;
513 /// Check if a [MouseButton] is beening pressed
514 #[link_name = "IsMouseButtonDown"]
515 pub fn is_mouse_button_down(button: MouseButton) -> bool;
516 /// Check if a [MouseButton] has been released once
517 #[link_name = "IsMouseButtonReleased"]
518 pub fn is_mouse_button_released(button: MouseButton) -> bool;
519 /// Check if a [MouseButton] is **NOT** being pressed
520 #[link_name = "IsMouseButtonUp"]
521 pub fn is_mouse_button_up(button: MouseButton) -> bool;
522 /// Get mouse position X
523 #[link_name = "GetMouseX"]
524 pub fn get_mouse_x() -> c_int;
525 /// Get mouse position Y
526 #[link_name = "GetMouseY"]
527 pub fn get_mouse_y() -> c_int;
528 /// Get mouse position XY
529 #[link_name = "GetMousePosition"]
530 pub fn get_mouse_position() -> Vector2;
531 /// Get mouse delta between frames
532 #[link_name = "GetMouseDelta"]
533 pub fn get_mouse_delta() -> Vector2;
534 /// Set mouse position XY
535 #[link_name = "SetMousePosition"]
536 pub fn set_mouse_position(x: c_int, y: c_int);
537 /// Set mouse offset
538 #[link_name = "SetMouseOffset"]
539 pub fn set_mouse_offset(offset_x: c_int, offset_y: c_int);
540 /// Set mouse scaling
541 #[link_name = "SetMouseScale"]
542 pub fn set_mouse_scale(scale_x: c_int, scale_y: c_int);
543 /// Get mouse wheel movement for X or Y, whichever is larger
544 #[link_name = "GetMouseWheelMove"]
545 pub fn get_mouse_wheel_move() -> c_float;
546 /// Get mouse wheel movement for both X or Y
547 #[link_name = "GetMouseWheelMoveV"]
548 pub fn get_mouse_wheel_move_v() -> Vector2;
549 /// Set mouse cursor
550 #[link_name = "SetMouseCursor"]
551 pub fn set_mouse_cursor(cursor: MouseCursor);
552}
553
554// Input-related functions: touch
555extern "C" {
556 /// Get touch position X for touch point 0 (relative to screen size)
557 #[link_name = "GetTouchX"]
558 pub fn get_touch_x() -> c_int;
559 /// Get touch position Y for touch point 0 (relative to screen size)
560 #[link_name = "GetTouchY"]
561 pub fn get_touch_y() -> c_int;
562 /// Get touch position XY for a touch point index (relative to screen size)
563 #[link_name = "GetTouchPosition"]
564 pub fn get_touch_position(index: c_int) -> Vector2;
565 /// Get touch point identifier for given index
566 #[link_name = "GetTouchPointId"]
567 pub fn get_touch_point_id(index: c_int) -> c_int;
568 /// Get number of touch points
569 #[link_name = "GetTouchPointCount"]
570 pub fn get_touch_point_count() -> c_int;
571}
572// Gestures and Touch handling functions
573extern "C" {
574 /// Enable a set of [Gesture] using flags
575 #[link_name = "SetGesturesEnabled"]
576 pub fn set_gestures_enabled(flags: Gesture);
577 /// Check if a [Gesture] have been detected
578 #[link_name = "IsGestureDetected"]
579 pub fn is_gesture_detected(gesture: Gesture);
580 /// Get latest detected [Gesture]
581 #[link_name = "GetGestureDetected"]
582 pub fn get_gesture_detected() -> Gesture;
583 /// Get [Gesture] hold time in seconds
584 #[link_name = "GetGestureHoldDuration"]
585 pub fn get_gesture_hold_duration() -> c_int;
586 /// Get [Gesture] drag [Vector2]
587 #[link_name = "GetGestureDragVector"]
588 pub fn get_gesture_drag_vector() -> Vector2;
589 /// Get [Gesture] drag angle
590 #[link_name = "GetGestureDragAngle"]
591 pub fn get_gesture_drag_angle() -> c_float;
592 /// Get [Gesture] pinch delta
593 #[link_name = "GetGesturePinchVector"]
594 pub fn get_gesture_pinch_vector() -> Vector2;
595 /// Get [Gesture] pinch angle
596 #[link_name = "GetGesturePinchAngle"]
597 pub fn get_gesture_pinch_angle() -> c_float;
598}
599
600// Timing-related functions
601extern "C" {
602 /// Set target FPS (maximum)
603 #[link_name = "SetTargetFPS"]
604 pub fn set_target_fps(fps: c_int);
605 /// Get time in seconds for last frame drawn (delta time)
606 #[link_name = "GetFrameTime"]
607 pub fn get_frame_time() -> c_float;
608 /// Get elapsed time in seconds since InitWindow()
609 #[link_name = "GetTime"]
610 pub fn get_time() -> c_double;
611 /// Get current FPS
612 #[link_name = "GetFPS"]
613 pub fn get_fps() -> c_int;
614}
615
616// Misc functions
617extern "C" {
618 /// Setup init configuration flags
619 ///
620 /// Flags should be of values defined in [ConfigFlag].
621 ///
622 /// Use this value as a bitmask.
623 ///
624 /// # Examples
625 /// ```no_run
626 /// use rustyray_sys::{ffi::set_config_flags, consts::ConfigFlag};
627 ///
628 /// unsafe { set_config_flags(ConfigFlag::VsyncHint | ConfigFlag::FullscreenMode) }
629 /// ```
630 #[link_name = "SetConfigFlags"]
631 pub fn set_config_flags(flags: ConfigFlag);
632}
633
634// Audio device management functions
635extern "C" {
636 /// Initialize audio device and context
637 #[link_name = "InitAudioDevice"]
638 pub fn init_audio_device();
639 /// Close the audio device and context
640 #[link_name = "CloseAudioDevice"]
641 pub fn close_audio_device();
642 /// Check if audio device has been initialized successfully
643 #[link_name = "IsAudioDeviceReady"]
644 pub fn is_audio_device_ready() -> bool;
645 /// Set master volume (listener)
646 #[link_name = "SetMasterVolume"]
647 pub fn set_master_volume(volume: c_float);
648 /// Get master volume (listener)
649 #[link_name = "GetMasterVolume"]
650 pub fn get_master_volume() -> c_float;
651}
652
653// Wave/Sound loading/unloading functions
654extern "C" {
655 /// Load wave data from file
656 #[link_name = "LoadWave"]
657 pub fn load_wave(file_name: *const c_char) -> Wave;
658 /// Load wave from memory buffer, file_type refers to extension: i.e. `.wav`
659 #[link_name = "LoadWaveFromMemory"]
660 pub fn load_wave_from_memory(
661 file_type: *const c_char,
662 file_data: *const c_uchar,
663 data_size: c_int,
664 ) -> Wave;
665 /// Checks if wave data is valid (data loaded and parameters)
666 #[link_name = "IsWaveValid"]
667 pub fn is_wave_valid(wave: Wave) -> bool;
668 /// Load sound from file
669 #[link_name = "LoadSound"]
670 pub fn load_sound(file_name: *const c_char) -> Sound;
671 /// Load sound from wave data
672 #[link_name = "LoadSoundFromWave"]
673 pub fn load_sound_from_wave(wave: Wave) -> Sound;
674 /// Create a new sound that shares the same sample data as the source sound, does not own the sound data
675 #[link_name = "LoadSoundAlias"]
676 pub fn load_sound_alias(source: Sound) -> Sound;
677 /// Checks if sound is valid (data loaded and buffers initialized)
678 #[link_name = "IsSoundValid"]
679 pub fn is_sound_valid(sound: Sound) -> bool;
680 /// Update sound buffer with new data
681 #[link_name = "UpdateSound"]
682 pub fn update_sound(sound: Sound, data: *const c_void, sample_count: c_int);
683 /// Unload wave data
684 #[link_name = "UnloadWave"]
685 pub fn unload_wave(wave: Wave);
686 /// Unload sound
687 #[link_name = "UnloadSound"]
688 pub fn unload_sound(sound: Sound);
689 /// Unload a sound alias (does not deallocate sample data)
690 #[link_name = "UnloadSoundAlias"]
691 pub fn unload_sound_alias(alias: Sound);
692 /// Export wave data to file, returns true on success
693 #[link_name = "ExportWave"]
694 pub fn export_wave(wave: Wave, file_name: *const c_char) -> bool;
695 /// Export wave sample data to code (.h), returns true on success
696 #[link_name = "ExportWaveAsCode"]
697 pub fn export_wave_as_code(wave: Wave, file_name: *const c_char) -> bool;
698}
699
700// Wave/Sound management functions
701extern "C" {
702 /// Play a sound
703 #[link_name = "PlaySound"]
704 pub fn play_sound(sound: Sound);
705 /// Stop playing a sound
706 #[link_name = "StopSound"]
707 pub fn stop_sound(sound: Sound);
708 /// Pause a sound
709 #[link_name = "PauseSound"]
710 pub fn pause_sound(sound: Sound);
711 /// Resume a paused sound
712 #[link_name = "ResumeSound"]
713 pub fn resume_sound(sound: Sound);
714 /// Check if a sound is currently playing
715 #[link_name = "IsSoundPlaying"]
716 pub fn is_sound_playing(sound: Sound) -> bool;
717 /// Set volume for a sound (1.0 is max level)
718 #[link_name = "SetSoundVolume"]
719 pub fn set_sound_volume(sound: Sound, volume: c_float);
720 /// Set pitch for a sound (1.0 is base level)
721 #[link_name = "SetSoundPitch"]
722 pub fn set_sound_pitch(sound: Sound, pitch: c_float);
723 /// Set pan for a sound (0.5 is center)
724 #[link_name = "SetSoundPan"]
725 pub fn set_sound_pan(sound: Sound, pan: c_float);
726 /// Copy the wave to a new wave
727 #[link_name = "WaveCopy"]
728 pub fn wave_copy(wave: Wave);
729 /// Crop a wave to defined frames range
730 #[link_name = "WaveCrop"]
731 pub fn wave_crop(wave: *mut Wave, init_frame: c_int, final_frame: c_int);
732 /// Convert wave data to desired format
733 #[link_name = "WaveFormat"]
734 pub fn wave_format(wave: *mut Wave, sample_rate: c_int, sample_size: c_int, channels: c_int);
735 /// Load samples data from wave as a 32bit float data array
736 #[link_name = "LoadWaveSamples"]
737 pub fn load_wave_samples(wave: Wave) -> *const c_float;
738 /// Unload samples data loaded with LoadWaveSamples()
739 #[link_name = "UnloadWaveSamples"]
740 pub fn unload_wave_samples(samples: *const c_float);
741}
742
743extern "C" {
744 /// Load music stream from file
745 #[link_name = "LoadMusicStream"]
746 pub fn load_music_stream(file_name: *const c_char) -> Music;
747 /// Load music stream from file
748 #[link_name = "LoadMusicStreamFromMemory"]
749 pub fn load_music_stream_from_memory(
750 file_type: *const c_char,
751 data: *const c_uchar,
752 data_size: c_int,
753 ) -> Music;
754 /// Checks if a music stream is valid (context and buffers initialized)
755 #[link_name = "IsMusicValid"]
756 pub fn is_music_valid(music: Music) -> bool;
757 /// Unload music stream
758 #[link_name = "UnloadMusicStream"]
759 pub fn unload_music_stream(music: Music);
760 /// Start music playing
761 #[link_name = "PlayMusicStream"]
762 pub fn play_music_stream(music: Music);
763 /// Checks if music is playing
764 #[link_name = "IsMusicStreamPlaying"]
765 pub fn is_music_stream_playing(music: Music) -> bool;
766 /// Updates buffers for music streaming
767 #[link_name = "UpdateMusicStream"]
768 pub fn update_music_stream(music: Music);
769 /// Stop music playing
770 #[link_name = "StopMusicStream"]
771 pub fn stop_music_stream(music: Music);
772 /// Pause music playing
773 #[link_name = "PauseMusicStream"]
774 pub fn pause_music_stream(music: Music);
775 /// Resume playing paused music
776 #[link_name = "ResumeMusicStream"]
777 pub fn resume_music_stream(music: Music);
778 /// Seek music to a position (in seconds)
779 #[link_name = "SeekMusicStream"]
780 pub fn seek_music_stream(music: Music, position: c_float);
781 /// Set volume for music (1.0 is max level)
782 #[link_name = "SetMusicVolume"]
783 pub fn set_music_volume(music: Music, volume: c_float);
784 /// Set pitch for music (1.0 is base level)
785 #[link_name = "SetMusicPitch"]
786 pub fn set_music_pitch(music: Music, pitch: c_float);
787 /// Set pan for music (0.5 is center)
788 #[link_name = "SetMusicPan"]
789 pub fn set_music_pan(music: Music, pan: c_float);
790 /// Get music time length (in seconds)
791 #[link_name = "GetMusicTimeLength"]
792 pub fn get_music_time_length(music: Music) -> c_float;
793 /// Get current music time played (in seconds)
794 #[link_name = "GetMusicTimePlayed"]
795 pub fn get_music_time_played(music: Music) -> c_float;
796}
797
798// AudioStream management functions
799extern "C" {
800 /// Load audio stream (to stream raw audio pcm data)
801 #[link_name = "LoadAudioStream"]
802 pub fn load_audio_stream(
803 sample_rate: c_uint,
804 sample_size: c_uint,
805 channels: c_uint,
806 ) -> AudioStream;
807 /// Checks if an audio stream is valid (buffers initialized)
808 #[link_name = "IsAudioStreamValid"]
809 pub fn is_audio_stream_valid(stream: AudioStream) -> bool;
810 /// Unload audio stream and free memory
811 #[link_name = "UnloadStreamValid"]
812 pub fn unload_stream_valid(stream: AudioStream);
813 /// Update audio stream buffers with data
814 #[link_name = "UpdateStreamValid"]
815 pub fn update_stream_valid(stream: AudioStream, data: *const c_void, frame_count: c_int);
816 /// Check if any audio stream buffers requires refill
817 #[link_name = "IsAudioStreamProcessed"]
818 pub fn is_audio_stream_processed(stream: AudioStream) -> bool;
819 /// Play audio stream
820 #[link_name = "PlayAudioStream"]
821 pub fn play_audio_stream(stream: AudioStream);
822 /// Pause audio stream
823 #[link_name = "PauseAudioStream"]
824 pub fn pause_audio_stream(stream: AudioStream);
825 /// Resume audio stream
826 #[link_name = "ResumeAudioStream"]
827 pub fn resume_audio_stream(stream: AudioStream);
828 /// Check if audio stream is playing
829 #[link_name = "IsAudioStreamPlaying"]
830 pub fn is_audio_stream_playing(stream: AudioStream) -> bool;
831 /// Stop audio stream
832 #[link_name = "StopAudioStream"]
833 pub fn stop_audio_stream(stream: AudioStream);
834 /// Set volume for audio stream (1.0 is max level)
835 #[link_name = "SetAudioStreamVolume"]
836 pub fn set_audio_stream_volume(stream: AudioStream, volume: c_float);
837 /// Set pitch for audio stream (1.0 is base level)
838 #[link_name = "SetAudioStreamPitch"]
839 pub fn set_audio_stream_pitch(stream: AudioStream, pitch: c_float);
840 /// Set pan for audio stream (0.5 is centered)
841 #[link_name = "SetAudioStreamPan"]
842 pub fn set_audio_stream_pan(stream: AudioStream, pan: c_float);
843 /// Default size for new audio streams
844 #[link_name = "SetAudioStreamBufferSizeDefault"]
845 pub fn set_audio_stream_buffer_size_default(size: c_int);
846 /// Audio thread callback to request new data
847 #[link_name = "SetAudioStreamCallback"]
848 pub fn set_audio_stream_callback(stream: AudioStream, callback: AudioCallback);
849
850 /// Attach audio stream processor to stream, receives the samples as 'float'
851 #[link_name = "AttachAudioStreamProcessor"]
852 pub fn attach_audio_stream_processor(stream: AudioStream, processor: AudioCallback);
853 /// Detach audio stream processor from stream
854 #[link_name = "DetachAudioStreamProcessor"]
855 pub fn detach_audio_stream_processor(stream: AudioStream, processor: AudioCallback);
856 /// Attach audio stream processor to the entire audio pipeline, receives the samples as 'float'
857 #[link_name = "AttachAudioMixedProcessor"]
858 pub fn attach_audio_mixed_processor(processor: AudioCallback);
859 /// Detach audio stream processor from the entire audio pipeline
860 #[link_name = "DetachAudioMixedProcessor"]
861 pub fn detach_audio_mixed_processor(processor: AudioCallback);
862}