swsurface 0.1.4

Software-rendered surface for winit
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

use std::{
    alloc::{alloc, dealloc, handle_alloc_error, realloc, Layout, LayoutErr},
    ptr::NonNull,
    slice::{from_raw_parts, from_raw_parts_mut},
};

#[derive(Debug)]
pub struct Buffer {
    ptr: NonNull<u8>,
    layout: Layout,
}

impl Buffer {
    pub fn new(layout: Layout) -> Self {
        let ptr = if let Some(ptr) = NonNull::new(unsafe { alloc(layout) }) {
            ptr
        } else {
            // Abort the process
            handle_alloc_error(layout);
        };

        unsafe { ptr.as_ptr().write_bytes(0, layout.size()) };

        Self { ptr, layout }
    }

    pub fn from_size_align(size: usize, align: usize) -> Result<Self, LayoutErr> {
        Layout::from_size_align(size, align).map(Self::new)
    }

    pub fn resize(&mut self, new_size: usize) {
        let new_layout = Layout::from_size_align(new_size, self.layout.align()).unwrap();

        let new_ptr = unsafe { realloc(self.ptr.as_ptr(), self.layout, new_layout.size()) };

        let ptr = if let Some(ptr) = NonNull::new(new_ptr) {
            ptr
        } else {
            // Abort the process
            handle_alloc_error(new_layout);
        };

        if new_layout.size() > self.layout.size() {
            unsafe {
                ptr.as_ptr()
                    .offset(self.layout.size() as isize)
                    .write_bytes(0, new_layout.size() - self.layout.size())
            };
        }

        self.ptr = ptr;
        self.layout = new_layout;
    }
}

impl Drop for Buffer {
    fn drop(&mut self) {
        unsafe {
            dealloc(self.ptr.as_ptr(), self.layout);
        }
    }
}

impl std::ops::Deref for Buffer {
    type Target = [u8];

    fn deref(&self) -> &[u8] {
        unsafe { from_raw_parts(self.ptr.as_ptr(), self.layout.size()) }
    }
}

impl std::ops::DerefMut for Buffer {
    fn deref_mut(&mut self) -> &mut [u8] {
        unsafe { from_raw_parts_mut(self.ptr.as_ptr(), self.layout.size()) }
    }
}