rasen-dsl 0.2.0

Wrapper for the Rasen compiler to write SPIR-V shaders in Rust
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

//! Type metadata providers

use quote::Ident;

const INTS: [(&'static str, &'static str, &'static str); 3] = [
    ("Bool", "b", "bool"),
    ("Int", "i", "i32"),
    ("UInt", "u", "u32"),
];
const FLOATS: [(&'static str, &'static str, &'static str); 2] = [
    ("Float", "", "f32"),
    ("Double", "d", "f64"),
];

#[derive(Copy, Clone, Eq, PartialEq)]
pub enum Category {
    SCALAR,
    VECTOR,
    MATRIX,
}

#[derive(Clone)]
pub struct Type {
    pub name: Ident,
    pub category: Category,
    pub component: Option<Box<Type>>,
    pub size: Option<u32>,
    pub ty: &'static str,
}

fn scalar_type(name: &str, ty: &'static str) -> Type {
    Type {
        name: Ident::from(name),
        category: Category::SCALAR,
        component: None,
        size: None,
        ty: ty,
    }
}

fn vector_type(name: &str, scalar: &str, ty: &'static str, size: u32) -> Type {
    Type {
        name: Ident::from(name),
        category: Category::VECTOR,
        component: Some(Box::new(scalar_type(scalar, ty))),
        size: Some(size),
        ty: ty,
    }
}

fn matrix_type(name: &str, vec: &str, scalar: &str, ty: &'static str, size: u32) -> Type {
    Type {
        name: Ident::from(name),
        category: Category::MATRIX,
        component: Some(Box::new(vector_type(vec, scalar, ty, size))),
        size: Some(size),
        ty: ty,
    }
}

pub fn all_types() -> Vec<Type> {
    let mut res = Vec::new();

    for &(res_name, _, ty) in INTS.iter().chain(FLOATS.iter()) {
        res.push(scalar_type(res_name, ty));
    }

    for size in 2u32..=4u32 {
        for &(scalar_name, prefix, ty) in &INTS {
            let vec_name = format!("{}Vec{}", prefix.to_string().to_uppercase(), size);
            res.push(vector_type(&vec_name, scalar_name, ty, size));
        }

        for &(scalar_name, prefix, ty) in &FLOATS {
            let vec_name = format!("{}Vec{}", prefix.to_string().to_uppercase(), size);
            res.push(vector_type(&vec_name, scalar_name, ty, size));

            let mat_name = format!("{}Mat{}", prefix.to_string().to_uppercase(), size);
            res.push(matrix_type(&mat_name, &vec_name, scalar_name, ty, size));
        }
    }

    res
}

#[derive(Clone)]
pub struct Node {
    pub name: Ident,
    pub args: Option<Vec<Type>>,
    pub result: Type,
}

pub fn all_nodes() -> Vec<Node> {
    let mut res = Vec::new();

    for result in all_types() {
        res.push(Node {
            name: result.name.clone(),
            args: None,
            result: result.clone(),
        });

        res.push(Node {
            name: Ident::from("Value"),
            args: Some(vec![
                result.clone(),
            ]),
            result: result.clone(),
        });
    }

    res
}