rokol 0.4.0

Rust bindings to Sokol
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

/*!
Wrapper of [Sokol] libraries

[Sokol]: https://github.com/floooh/sokol

# Features (specified in `Cargo.toml`)

Example settings:

```toml
rokol = { features = ["sdl", "impl-gfx", "glcore33", "fontstash"] }
```

* `impl-app`: implements `sokol_app.h` and enables `app` module
* `sdl2`: generates [`glue`] code for `sdl2`
* `impl-gfx`: implements `sokol_gfx.h` and enables `gfx` module
  * `glcore33`: uses OpenGL backend
  * `metal`: uses Metal backend
  * `d3d11`: uses DirectX11 backend
* `fontstash`: implements `fontstash.h` and enables `fons` module

# Tips

* Checkout [The Brain Dump]
  * Sokol [considers] zero-initizialized structures to be in default state. It means
    [`Default::default`] is ensured to make sense!
* use `bytemuck` to cast types to `&[u8]`.

[The Brain Dump]: https://floooh.github.io/
[considers]: https://floooh.github.io/2017/08/06/sokol-api-update.html
*/

pub use rokol_ffi as ffi;

/// Creates an `enum` from FFI enum type (output of bindgen as a rustified enum)
macro_rules! ffi_enum {
    (
        $(#[$outer:meta])*
        $vis:vis enum $Enum:ident around $Ffi:ty {
            $(
                $(#[$attr:ident $($args:tt)*])*
                $variant:ident = $ffi_variant:ident,
            )*
        }

        $($t:tt)*
    ) => {
        $(#[$outer])*
        #[repr(u32)]
        $vis enum $Enum {
            $(
                $(#[$attr $($args)*])*
                $variant = <$Ffi>::$ffi_variant as u32,
            )*
        }

        impl $Enum {
            pub fn from_ffi(ffi_variant: $Ffi) -> Self {
                match ffi_variant {
                    $(
                        <$Ffi>::$ffi_variant => Self::$variant,
                    )*
                    _ => panic!("Bug: not convered FFI enum!"),
                }
            }

            pub fn to_ffi(self) -> $Ffi {
                match self {
                    $(
                        <Self>::$variant => <$Ffi>::$ffi_variant,
                    )*
                }
            }
        }

        impl From<$Ffi> for $Enum {
            fn from(ffi_variant: $Ffi) -> Self {
                Self::from_ffi(ffi_variant)
            }
        }

        impl Into<$Ffi> for $Enum {
            fn into(self) -> $Ffi {
                Self::to_ffi(self)
            }
        }
    };
}

#[cfg(feature = "impl-app")]
pub mod app;

#[cfg(feature = "impl-gfx")]
pub mod gfx;

#[cfg(feature = "impl-gfx")]
pub mod glue;

#[cfg(all(feature = "impl-gfx", feature = "fontstash"))]
pub mod fons;