nvgx 0.3.3

Pure-rust implementation of NanoVG
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum BlendFactor {
    Zero,
    One,
    SrcColor,
    OneMinusSrcColor,
    DstColor,
    OneMinusDstColor,
    SrcAlpha,
    OneMinusSrcAlpha,
    DstAlpha,
    OneMinusDstAlpha,
    SrcAlphaSaturate,
}

#[derive(Debug, Copy, Clone)]
pub enum BasicCompositeOperation {
    SrcOver,
    SrcIn,
    SrcOut,
    Atop,
    DstOver,
    DstIn,
    DstOut,
    DstAtop,
    Lighter,
    Copy,
    Xor,
}

#[derive(Debug, Copy, Clone)]
pub enum CompositeOperation {
    Basic(BasicCompositeOperation),
    BlendFunc {
        src: BlendFactor,
        dst: BlendFactor,
    },
    BlendFuncSeparate {
        src_rgb: BlendFactor,
        dst_rgb: BlendFactor,
        src_alpha: BlendFactor,
        dst_alpha: BlendFactor,
    },
}

impl Into<CompositeOperationState> for CompositeOperation {
    fn into(self) -> CompositeOperationState {
        match self {
            CompositeOperation::Basic(op) => {
                let (src_factor, dst_factor) = match op {
                    BasicCompositeOperation::SrcOver => {
                        (BlendFactor::One, BlendFactor::OneMinusSrcAlpha)
                    }
                    BasicCompositeOperation::SrcIn => (BlendFactor::DstAlpha, BlendFactor::Zero),
                    BasicCompositeOperation::SrcOut => {
                        (BlendFactor::OneMinusDstAlpha, BlendFactor::Zero)
                    }
                    BasicCompositeOperation::Atop => {
                        (BlendFactor::DstAlpha, BlendFactor::OneMinusSrcAlpha)
                    }
                    BasicCompositeOperation::DstOver => {
                        (BlendFactor::OneMinusDstAlpha, BlendFactor::One)
                    }
                    BasicCompositeOperation::DstIn => (BlendFactor::Zero, BlendFactor::SrcAlpha),
                    BasicCompositeOperation::DstOut => {
                        (BlendFactor::Zero, BlendFactor::OneMinusSrcAlpha)
                    }
                    BasicCompositeOperation::DstAtop => {
                        (BlendFactor::OneMinusDstAlpha, BlendFactor::SrcAlpha)
                    }
                    BasicCompositeOperation::Lighter => (BlendFactor::One, BlendFactor::One),
                    BasicCompositeOperation::Copy => (BlendFactor::One, BlendFactor::Zero),
                    BasicCompositeOperation::Xor => {
                        (BlendFactor::OneMinusDstAlpha, BlendFactor::OneMinusSrcAlpha)
                    }
                };

                CompositeOperationState {
                    src_rgb: src_factor,
                    dst_rgb: dst_factor,
                    src_alpha: src_factor,
                    dst_alpha: dst_factor,
                }
            }
            CompositeOperation::BlendFunc { src, dst } => CompositeOperationState {
                src_rgb: src,
                dst_rgb: dst,
                src_alpha: src,
                dst_alpha: dst,
            },
            CompositeOperation::BlendFuncSeparate {
                src_rgb,
                dst_rgb,
                src_alpha,
                dst_alpha,
            } => CompositeOperationState {
                src_rgb,
                dst_rgb,
                src_alpha,
                dst_alpha,
            },
        }
    }
}

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct CompositeOperationState {
    pub src_rgb: BlendFactor,
    pub dst_rgb: BlendFactor,
    pub src_alpha: BlendFactor,
    pub dst_alpha: BlendFactor,
}

impl AsRef<CompositeOperationState> for &CompositeOperationState {
    fn as_ref(&self) -> &CompositeOperationState {
        return self;
    }
}

impl Default for CompositeOperationState {
    fn default() -> Self {
        return CompositeOperation::Basic(BasicCompositeOperation::SrcOver).into();
    }
}