wrend 0.3.6

A WebGL2 rendering library for Rust/Wasm & JS
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
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

use std::{ops::Deref, rc::Rc};

/// Enables accepting either a single item or many items when taking function arguments
pub struct Bridge<Item>(Vec<Item>);

impl<Item> Deref for Bridge<Item> {
    type Target = [Item];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<Item> From<Bridge<Item>> for Vec<Item> {
    fn from(bridge: Bridge<Item>) -> Self {
        bridge.0
    }
}

impl<Item: Clone> From<&Bridge<Item>> for Vec<Item> {
    fn from(bridge: &Bridge<Item>) -> Self {
        bridge.0.to_owned()
    }
}

impl<Item> From<(Item, Item)> for Bridge<Item> {
    fn from(items: (Item, Item)) -> Self {
        Bridge(vec![items.0, items.1])
    }
}

impl<Item> From<(Item, Item, Item)> for Bridge<Item> {
    fn from(items: (Item, Item, Item)) -> Self {
        Bridge(vec![items.0, items.1, items.2])
    }
}

impl<Item> From<(Item, Item, Item, Item)> for Bridge<Item> {
    fn from(items: (Item, Item, Item, Item)) -> Self {
        Bridge(vec![items.0, items.1, items.2, items.3])
    }
}

impl<Item> From<(Item, Item, Item, Item, Item)> for Bridge<Item> {
    fn from(items: (Item, Item, Item, Item, Item)) -> Self {
        Bridge(vec![items.0, items.1, items.2, items.3, items.4])
    }
}

impl<Item> From<Item> for Bridge<Item> {
    fn from(items: Item) -> Self {
        Bridge(vec![items])
    }
}

impl<Item: Clone> From<&Item> for Bridge<Item> {
    fn from(items: &Item) -> Self {
        Bridge(vec![items.to_owned()])
    }
}

impl<Item> From<Vec<Item>> for Bridge<Item> {
    fn from(items: Vec<Item>) -> Self {
        Bridge(items)
    }
}

impl<Item: Clone> From<&Vec<Item>> for Bridge<Item> {
    fn from(items: &Vec<Item>) -> Self {
        Bridge(items.to_owned())
    }
}

impl<Item: Clone> From<&[Item]> for Bridge<Item> {
    fn from(items: &[Item]) -> Self {
        Bridge(items.to_vec())
    }
}

impl<Item: Clone> From<Rc<[Item]>> for Bridge<Item> {
    fn from(items: Rc<[Item]>) -> Self {
        Bridge(items.to_vec())
    }
}

impl<Item> From<Box<[Item]>> for Bridge<Item> {
    fn from(items: Box<[Item]>) -> Self {
        Bridge(Vec::from(items))
    }
}

impl<Item> From<Box<Vec<Item>>> for Bridge<Item> {
    fn from(items: Box<Vec<Item>>) -> Self {
        Bridge(*items)
    }
}

impl<Item: Clone> From<Rc<Vec<Item>>> for Bridge<Item> {
    fn from(items: Rc<Vec<Item>>) -> Self {
        Bridge((*items).to_owned())
    }
}

// enables any sized array to be used as a bridge
impl<const U: usize, Item> From<[Item; U]> for Bridge<Item> {
    fn from(items: [Item; U]) -> Self {
        Bridge(Vec::from(items))
    }
}