d3d11 0.2.0

Safe(r) bindings to the D3D11 API
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

use std::ffi::CString;

use d3d11_ffi::core::PCSTR;

// Helper for working with DX11 methods that return results as HRESULT and out parameters as an Option<T>
pub fn wrap_option_out_result<T, F>(f: F) -> d3d11_ffi::core::Result<T>
where
    F: FnOnce(Option<*mut Option<T>>) -> d3d11_ffi::core::Result<()>,
{
    let mut result = None;
    f(Some(&raw mut result))?;
    Ok(result.unwrap())
}

pub fn wrap_out_result<T, F>(f: F) -> d3d11_ffi::core::Result<T>
where
    F: FnOnce(*mut Option<T>) -> d3d11_ffi::core::Result<()>,
{
    let mut result = None;
    f(&raw mut result)?;
    Ok(result.unwrap())
}

pub fn wrap_out_ptr<T: Default, F>(f: F) -> d3d11_ffi::core::Result<T>
where
    F: FnOnce(*mut T) -> d3d11_ffi::core::Result<()>,
{
    let mut result = T::default();
    f(&raw mut result)?;
    Ok(result)
}

/// Verifies that the given struct has the same size as the corresponding FFI struct, and generates an `as_ffi` method that returns a pointer to the FFI struct.
#[macro_export]
macro_rules! verify_ffi_struct {
    ($struct:ident, $ffi:ident) => {
        static_assertions::assert_eq_size!($struct, $ffi);

        impl $struct {
            #[allow(dead_code)]
            pub(crate) fn as_ffi(&self) -> *const $ffi {
                self as *const _ as _
            }
        }
    };
}

pub fn to_pcstr<S>(s: S) -> (CString, PCSTR)
where
    S: AsRef<str>,
{
    let cstr = CString::new(s.as_ref()).expect("Failed to convert string to CString");
    let pcstr = cstr.as_ptr();
    (cstr, PCSTR::from_raw(pcstr as _))
}

// pub fn to_pcwstr<S>(s: S) -> (Vec<u16>, PCWSTR)
// where
//     S: AsRef<str>,
// {
//     let wstr: Vec<u16> = s.as_ref().encode_utf16().chain(Some(0)).collect();
//     let pwstr = wstr.as_ptr();
//     (wstr, PCWSTR::from_raw(pwstr))
// }

pub trait OptionalParam: Sized {
    type Output;

    fn as_option(&self) -> Option<&Self::Output>;
}

impl<T> OptionalParam for &T {
    type Output = T;

    fn as_option(&self) -> Option<&Self::Output> {
        Some(self)
    }
}

impl<T> OptionalParam for Option<&T> {
    type Output = T;
    fn as_option(&self) -> Option<&Self::Output> {
        *self
    }
}