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

//! Fn trait implementations

use quote::{Ident, Tokens};
use codegen::operations::match_values;

static TRAITS: [(&str, &str, &str); 3] = [
    ("FnOnce", "call_once", ""),
    ("FnMut", "call_mut", "&mut"),
    ("Fn", "call", "&"),
];

pub fn impl_fn() -> Vec<Tokens> {
    (1..9u32)
        .flat_map(|size| {
            TRAITS.into_iter()
                .enumerate()
                .map(move |(index, &(trt, func, prefix))| {
                    let trt = Ident::from(trt);
                    let func = Ident::from(func);

                    let deref = Ident::from(prefix.replace("&", "ref "));
                    let prefix = Ident::from(prefix);

                    let idx1 = 0..size;
                    let idx2 = 0..size;

                    let types1: Vec<_> = (0..size).map(|idx| Ident::from(format!("T{}", idx))).collect();
                    let types2 = types1.clone();
                    let types3 = types1.clone();

                    let args1: Vec<_> = (0..size).map(|idx| Ident::from(format!("args_{}", idx))).collect();
                    let args2 = args1.clone();
                    let args3 = args1.clone();

                    let tuple = quote! { ( #( Value<#types1>, )* ) };
                    let output = if index == 0 {
                        quote! { type Output = <T as FnOnce<#tuple>>::Output; }
                    } else {
                        quote!()
                    };

                    let func_impl = match_values(
                        &args1,
                        &quote! {
                            self.thunk.#func(( #( Value::Concrete( #args2 ), )* ))
                        },
                        quote! {
                            let sink = graph.add_node(Node::Call(self.func));
                            #( graph.add_edge(#args3, sink, #idx1); )*

                            drop(graph);
                            
                            let args = (
                                #( self.parameter(#idx2), )*
                            );

                            let #prefix Function { #deref module, func, #deref thunk } = self;
                            let res = thunk.#func(args);
                            Self::ret_impl(&module, func, res);

                            sink
                        },
                    );

                    quote! {
                        #[cfg(feature = "functions")]
                        impl<T, R: IntoValue + Clone, #( #types2: IntoValue + Clone ),*> #trt<#tuple> for Function<T> where T: #trt<#tuple, Output=Value<R>>, #( Function<T>: Parameter<#types3> ),* {
                            #output
                            extern "rust-call" fn #func(#prefix self, ( #( #args1, )* ): #tuple) -> Value<R> {
                                #func_impl
                            }
                        }
                    }
                })
        })
        .collect()
}