raylib 1.0.0

Safe Rust bindings for Raylib.
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

//! File manipulation functions. Should be parity with std::fs except on emscripten
use crate::ffi;

use std::ffi::{CStr, CString};
use std::path::Path;

/// Check if file exists
/// ```rust
/// use raylib::prelude::*;
/// fn main() {
///     let check = file_exists("resources/just_exists.txt");
///     assert!(check, "file doesn't exist");
/// }
pub fn file_exists(file_name: impl AsRef<Path>) -> bool {
    if let Some(s) = file_name.as_ref().to_str() {
        if let Ok(c) = CString::new(s) {
            return unsafe { ffi::FileExists(c.as_ptr()) };
        }
    }
    return false;
}

// Check file extension
/// ```rust
/// use raylib::prelude::*;
/// fn main() {
///     let check = is_file_extension("resources/just_exists.txt", ".txt");
///     assert!(check, "extension mismatch");
/// }
pub fn is_file_extension(filename: &str, ext: &str) -> bool {
    let c_filename = CString::new(filename).unwrap();
    let c_ext = CString::new(ext).unwrap();
    unsafe { ffi::IsFileExtension(c_filename.as_ptr(), c_ext.as_ptr()) }
}

/// Gets the extension for a `filename` string.
/// ```rust
/// use raylib::prelude::*;
/// fn main() {
///     let check = get_extension("resources/just_exists.txt");
///     assert_eq!(check, "txt", "extension mismatch");
/// }
pub fn get_extension(filename: &str) -> String {
    let c_filename = CString::new(filename).unwrap();
    unsafe {
        let ext = ffi::GetExtension(c_filename.as_ptr());
        CStr::from_ptr(ext).to_str().unwrap().to_owned()
    }
}

/// Gets the filename for a path string.
/// ```rust
/// use raylib::prelude::*;
/// fn main() {
///     let check = get_file_name("resources/just_exists.txt");
///     assert_eq!(check, "just_exists.txt", "extension mismatch");
/// }
pub fn get_file_name(file_path: &str) -> String {
    let c_file_path = CString::new(file_path).unwrap();
    unsafe {
        let filename = ffi::GetFileName(c_file_path.as_ptr());
        CStr::from_ptr(filename).to_str().unwrap().to_owned()
    }
}

/// Gets full path for a given `filename`.
/// ```rust
/// use raylib::prelude::*;
/// fn main() {
///     let check = get_directory_path("resources/just_exists.txt");
///     assert_eq!(check, "resources", "extension mismatch");
/// }
pub fn get_directory_path(filename: &str) -> String {
    let c_filename = CString::new(filename).unwrap();
    unsafe {
        let dirpath = ffi::GetDirectoryPath(c_filename.as_ptr());
        CStr::from_ptr(dirpath).to_str().unwrap().to_owned()
    }
}

/// Gets all the files in a Directory
pub fn get_directory_files(dir: &str) -> Vec<String> {
    let c_dir = CString::new(dir).unwrap();
    let mut count = 0;
    let files = unsafe { ffi::GetDirectoryFiles(c_dir.as_ptr(), &mut count) };
    let mut f_vec = Vec::with_capacity(count as usize);
    for i in 0..count {
        unsafe {
            f_vec.push(
                CString::from_raw(*files.offset(i as isize))
                    .to_str()
                    .unwrap()
                    .to_owned(),
            );
        }
    }
    unsafe {
        libc::free(files as *mut libc::c_void);
    }
    f_vec
}

/// Gets current working directory.
/// ```rust
/// use raylib::prelude::*;
/// fn main() {
///     let check = get_working_directory();
///     let current = std::env::current_dir().unwrap().to_str().unwrap().to_owned();
///     assert_eq!(check, current, "extension mismatch");
/// }
pub fn get_working_directory() -> String {
    unsafe {
        let workdir = ffi::GetWorkingDirectory();
        CStr::from_ptr(workdir).to_str().unwrap().to_owned()
    }
}

/// Changes working directory, returns true on success.
pub fn change_directory(dir: &str) -> bool {
    let c_dir = CString::new(dir).unwrap();
    unsafe { ffi::ChangeDirectory(c_dir.as_ptr()) }
}

/// Checks if a file has been dropped into the window.
pub fn is_file_dropped() -> bool {
    unsafe { ffi::IsFileDropped() }
}

/// Gets dropped filenames.
pub fn get_dropped_files() -> Vec<String> {
    let mut v = Vec::new();
    unsafe {
        let mut count: i32 = 0;
        let dropfiles = ffi::GetDroppedFiles(&mut count);
        for i in 0..count {
            let filestr = CStr::from_ptr(*dropfiles.offset(i as isize))
                .to_str()
                .unwrap();
            let file = String::from(filestr);
            v.push(file);
        }
    }
    v
}

/// Clears dropped files paths buffer.
#[inline]
pub fn clear_dropped_files() {
    unsafe {
        ffi::ClearDroppedFiles();
    }
}