dxgi 0.1.5

Provides a convenient, higher level wrapping of the DXGI APIs. Targetting dxgi 1.2 stuff that works on Windows 7.
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 error::Error;

use std::mem;
use std::slice;

use winapi::shared::dxgiformat::DXGI_FORMAT;
use winapi::shared::dxgi::{IDXGISurface, DXGI_MAPPED_RECT, DXGI_SURFACE_DESC};
use winapi::shared::minwindef::UINT;
use winapi::shared::winerror::SUCCEEDED;
use wio::com::ComPtr;

#[derive(Clone, PartialEq)]
pub struct Surface {
    ptr: ComPtr<IDXGISurface>,
}

impl Surface {
    #[inline]
    pub unsafe fn from_raw(ptr: *mut IDXGISurface) -> Surface {
        Surface {
            ptr: ComPtr::from_raw(ptr),
        }
    }

    #[inline]
    pub unsafe fn get_raw(&self) -> *mut IDXGISurface {
        self.ptr.as_raw()
    }

    #[inline]
    pub fn get_desc(&self) -> SurfaceDesc {
        unsafe {
            let mut desc: SurfaceDesc = mem::uninitialized();
            let hr = self.ptr.GetDesc(&mut desc.desc);
            assert!(SUCCEEDED(hr));
            desc
        }
    }

    #[inline]
    pub unsafe fn map<'a>(
        &'a self,
        read: bool,
        write: bool,
        discard: bool,
    ) -> Result<SurfaceMap<'a>, Error> {
            // TODO: Wait for winapi to be updated with my PR adding these constants
        const DXGI_MAP_READ: UINT = 1;
        const DXGI_MAP_WRITE: UINT = 2;
        const DXGI_MAP_DISCARD: UINT = 4;

        let mut flags = 0;
        if read {
            flags |= DXGI_MAP_READ;
        }
        if write {
            flags |= DXGI_MAP_WRITE;
        }
        if discard {
            flags |= DXGI_MAP_DISCARD;
        }

        let desc = self.get_desc();
        let mut map = mem::uninitialized();
        let hr = self.ptr.Map(&mut map, flags);

        let mut elem_size = 1;
        for i in 2.. {
            if desc.width() * i > map.Pitch as u32 {
                break;
            }
            elem_size = i as usize;
        }

        Error::map_if(hr, || SurfaceMap {
            desc,
            map,
            elem_size,
            surface: &self.ptr,
        })
    }
}

unsafe impl Send for Surface {}
unsafe impl Sync for Surface {}

#[derive(Copy, Clone)]
pub struct SurfaceDesc {
    desc: DXGI_SURFACE_DESC,
}

impl SurfaceDesc {
    #[inline]
    pub fn width(&self) -> u32 {
        self.desc.Width
    }

    #[inline]
    pub fn height(&self) -> u32 {
        self.desc.Height
    }

    #[inline]
    pub fn format(&self) -> DXGI_FORMAT {
        self.desc.Format
    }

    #[inline]
    pub fn sample_count(&self) -> u32 {
        self.desc.SampleDesc.Count
    }

    #[inline]
    pub fn sample_quality(&self) -> u32 {
        self.desc.SampleDesc.Quality
    }
}

pub struct SurfaceMap<'a> {
    pub desc: SurfaceDesc,
    map: DXGI_MAPPED_RECT,
    elem_size: usize,
    surface: &'a IDXGISurface,
}

impl<'a> SurfaceMap<'a> {
    #[inline]
    pub fn row<T>(&self, row: u32) -> &[T]
    where
        T: Copy,
    {
        unsafe {
            assert!(row < self.desc.height());
            let len = (self.desc.width() as usize * self.elem_size) / mem::size_of::<T>();
            slice::from_raw_parts(self.map.pBits as *mut _, len)
        }
    }

    #[inline]
    pub fn row_mut<T>(&mut self, row: u32) -> &mut [T]
    where
        T: Copy,
    {
        unsafe {
            assert!(row < self.desc.height());
            let len = (self.desc.width() as usize * self.elem_size) / mem::size_of::<T>();
            slice::from_raw_parts_mut(self.map.pBits as *mut _, len)
        }
    }
}

impl<'a> Drop for SurfaceMap<'a> {
    #[inline]
    fn drop(&mut self) {
        unsafe {
            self.surface.Unmap();
        }
    }
}