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

use
    std::
        {
            ops::
                {
                    Add,
                    Sub,
                    Mul,
                    Div
                }
        };

pub
    use
        std::
            ops::
                Deref;

mod macros;
mod clamp;

#[
    cfg(
        test
    )
]

mod tests;
    
#[
    derive(
        Debug
    )
]

#[
    repr(
        transparent
    )
]

pub
    struct VulkanInt {
        value:
            i8
    }

impl
    VulkanInt {
        fn new(
            value:
                isize
        ) ->
            VulkanInt {
                VulkanInt {
                    value:
                        clamp::
                            clamp(
                                value,
                                
                                -54 ..= 54
                            )
                                as i8
                }
            }
    }

impl
    Deref for
        VulkanInt {
            type Target =
                i8;
            
            fn deref(
                self:
                    &VulkanInt
            ) ->
                &Self::Target {
                    &self
                        .value
                }
        }

vulkan_int_operation_impl!(
    Add, add, +
);

vulkan_int_operation_impl!(
    Sub, sub, -
);

vulkan_int_operation_impl!(
    Mul, mul, *
);

vulkan_int_operation_impl!(
    Div, div, /
);