crystal-api 0.0.6

Crystal API is a unified GPU API's wrapper
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

use crate::{
    debug::error,
    errors::{GraphicsError, GraphicsResult},
};

#[allow(missing_docs)]
#[derive(Debug)]
pub enum ShaderStage {
    Vertex,
    Fragment,
    Geometry,
    Tesselate,
    Compute,
}

#[allow(missing_docs)]
pub struct Shader {
    pub(crate) stage: ShaderStage,
    pub(crate) code: Vec<u32>,
}

impl Shader {
    /// Creates new shader from words and specified stage
    pub fn from_words(words: &[u32], stage: ShaderStage) -> GraphicsResult<Self> {
        Ok(Shader {
            stage,
            code: words.to_vec(),
        })
    }

    /// Creates new shader from bytes and specified stage
    pub fn from_bytes(bytes: &[u8], stage: ShaderStage) -> GraphicsResult<Self> {
        let shader_code = unsafe {
            let ptr = std::alloc::alloc(std::alloc::Layout::from_size_align_unchecked(
                bytes.len(),
                0x10,
            ));

            if ptr.is_null() {
                error!("failed to allocate memory for shader code");
                return Err(GraphicsError::ShaderError);
            }

            std::slice::from_raw_parts_mut(ptr, bytes.len())
                .copy_from_slice(std::slice::from_raw_parts(bytes.as_ptr(), bytes.len()));

            let len = bytes.len() / 4;

            Vec::from_raw_parts(ptr as *mut u32, len, len)
        };

        Ok(Shader {
            stage,
            code: shader_code,
        })
    }
}