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
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

//! Mul trait implementation

use quote::{Ident, Tokens};
use codegen::defs::{Category, Node, all_nodes};
use codegen::mul::impl_mul_variant;
use codegen::operations::match_values;

pub fn construct_type(ty: Node) -> Tokens {
    let Node { name, args, .. } = ty;
    match args {
        Some(list) => {
            let value = list.into_iter()
                .map(|ty| ty.name);

            quote! {
                #name < #( #value ),* >
            }
        },

        None => quote! { #name },
    }
}

#[cfg_attr(feature="clippy", allow(match_same_arms))]
fn impl_math_variant((trait_id, node_id, operator): (Ident, Ident, Ident), left_type: Node, right_type: Node) -> Option<Tokens> {
    let left_res = left_type.result.clone();
    let right_res = right_type.result.clone();

    let (result, op_impl) = match (left_res.category, left_res.ty, right_res.category, right_res.ty) {
        (_, "bool", _, _) |
        (_, _, _, "bool") |
        (Category::MATRIX, _, _, _) |
        (_, _, Category::MATRIX, _) |
        (Category::SCALAR, _, Category::SCALAR, _) => return None,

        (lc, lt, rc, rt) if lc == rc && lt == rt && left_res.size == right_res.size => (
            left_res.name.clone(),
            match lc {
                Category::MATRIX => unreachable!(),
                Category::SCALAR => quote! {
                    (lhs #operator rhs).into()
                },
                Category::VECTOR => {
                    let result = left_res.name.clone();
                    let l_fields: Vec<_> = {
                        (0..left_res.size.unwrap())
                            .map(|i| Ident::from(format!("l_{}", i)))
                            .collect()
                    };
                    let r_fields: Vec<_> = {
                        (0..left_res.size.unwrap())
                            .map(|i| Ident::from(format!("r_{}", i)))
                            .collect()
                    };
                    let res_fields: Vec<_> = {
                        l_fields.iter()
                            .zip(r_fields.iter())
                            .map(|(l_f, r_f)| {
                                quote! { #l_f #operator #r_f }
                            })
                            .collect()
                    };

                    quote! {
                        let #result( #( #l_fields ),* ) = lhs;
                        let #result( #( #r_fields ),* ) = rhs;
                        #result( #( #res_fields ),* ).into()
                    }
                },
            }
        ),

        _ => return None,
    };

    let left_type = construct_type(left_type);
    let right_type = construct_type(right_type);
    let method = Ident::from(trait_id.to_string().to_lowercase());

    let method_impl = match_values(
        &[Ident::from("lhs"), Ident::from("rhs")],
        &op_impl,
        quote! {
            let index = graph.add_node(Node::#node_id);
            graph.add_edge(lhs, index, 0);
            graph.add_edge(rhs, index, 1);
            index
        },
    );

    let tokens = quote! {
        impl #trait_id<#right_type> for #left_type {
            type Output = Value<#result>;

            #[inline]
            fn #method(self, rhs: #right_type) -> Self::Output {
                let lhs = self;
                #method_impl
            }
        }
    };

    Some(tokens)
}

const MATH_OPS: [(&str, &str, &str); 4] = [
    ("Add", "Add", "+"),
    ("Sub", "Subtract", "-"),
    ("Div", "Divide", "/"),
    ("Rem", "Modulus", "%"),
];

pub fn impl_math() -> Vec<Tokens> {
    all_nodes().into_iter()
        .flat_map(|left_type| {
            all_nodes().into_iter()
                .flat_map(|right_type| {
                    MATH_OPS.into_iter()
                        .filter_map(|&(trait_name, node, operator)| {
                            impl_math_variant(
                                (Ident::from(trait_name), Ident::from(node), Ident::from(operator)),
                                left_type.clone(),
                                right_type.clone(),
                            )
                        })
                        .chain(
                            impl_mul_variant(
                                left_type.clone(),
                                right_type.clone(),
                            )
                            .into_iter()
                        )
                        .collect::<Vec<_>>()
                })
                .collect::<Vec<_>>()
        })
        .collect()
}