flo_render_canvas 0.3.1

Converts flo_canvas streams to flo_render streams
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use super::matrix::*;

use flo_canvas as canvas;
use flo_render as render;

///
/// The ways the next path can be filled
///
#[derive(Clone, PartialEq, Debug)]
pub enum FillState {
    ///
    /// Unknown fill state
    ///
    None,

    ///
    /// Fill with a solid colour
    ///
    Color(render::Rgba8),

    ///
    /// Fill with a particular texture
    ///
    Texture(canvas::TextureId, render::Matrix, bool, f32),

    ///
    /// Fill with a particular gradient
    ///
    LinearGradient(canvas::GradientId, render::Matrix, bool, f32)
}

impl FillState {
    ///
    /// Returns a variant of this fill state with all channels set as the alpha channel
    ///
    pub fn all_channel_alpha(&self) -> Self {
        match self {
            FillState::None                         => FillState::None,
            FillState::Color(color)                 => FillState::Color(render::Rgba8([color.0[3], color.0[3], color.0[3], color.0[3]])),
            FillState::Texture(_, _, _, _)          => self.clone(),
            FillState::LinearGradient(_, _, _, _)   => self.clone()
        }
    }

    ///
    /// Returns the flat colour to use for this fill state
    ///
    pub fn flat_color(&self) -> render::Rgba8 {
        match self {
            FillState::None                         => render::Rgba8([0, 0, 0, 255]),
            FillState::Color(color)                 => *color,
            FillState::Texture(_, _, _, _)          => render::Rgba8([0, 0, 0, 255]),
            FillState::LinearGradient(_, _, _, _)   => render::Rgba8([0, 0, 0, 255])
        }
    }

    ///
    /// Creates a texture fill 
    ///
    pub fn texture_fill(texture_id: canvas::TextureId, x1: f32, y1: f32, x2: f32, y2: f32, alpha: f32) -> FillState {
        // Avoid division by zero
        let x2 = if x2 == x1 { x1 + 0.0000001 } else { x2 };
        let y2 = if y2 == y1 { y1 + 0.0000001 } else { y2 };

        // Generate a matrix that transforms x1, y1 to 0,0 and x2, y2 to 1,1
        let a       = 1.0/(x2-x1);
        let b       = 0.0;
        let c       = -x1 * a;

        let d       = 0.0;
        let e       = 1.0/(y2-y1);
        let f       = -y1 * e;

        let matrix  = render::Matrix([
            [a,   b,   0.0, c  ],
            [d,   e,   0.0, f  ],
            [0.0, 0.0, 1.0, 0.0],
            [0.0, 0.0, 0.0, 1.0]
        ]);

        // Create the fill-state for this matrix
        FillState::Texture(texture_id, matrix, true, alpha)
    }

    ///
    /// Creates a linear gradient fill
    ///
    pub fn linear_gradient_fill(gradient_id: canvas::GradientId, x1: f32, y1: f32, x2: f32, y2: f32) -> FillState {
        // Avoid division by zero
        let x2 = if x2 == x1 { x1 + 0.0000001 } else { x2 };
        let y2 = if y2 == y1 { y1 + 0.0000001 } else { y2 };

        let dx      = x2-x1;
        let dy      = y2-y1;

        let theta   = f32::atan2(dy, dx);
        let scale   = 1.0/f32::sqrt(dx*dx + dy*dy);

        let cos     = f32::cos(-theta);
        let sin     = f32::sin(-theta);

        let a       = cos * scale;
        let b       = -sin * scale;
        let d       = sin * scale;
        let e       = cos * scale;

        let c       = -x1 * a - y1 * b;
        let f       = -x1 * d - y1 * e;

        // Assemble into a matrix
        let matrix  = render::Matrix([
            [a,   b,   0.0, c  ],
            [d,   e,   0.0, f  ],
            [0.0, 0.0, 1.0, 0.0],
            [0.0, 0.0, 0.0, 1.0]
        ]);

        // Create the fill-state for this matrix
        FillState::LinearGradient(gradient_id, matrix, false, 1.0)
    }

    ///
    /// Returns the ID of the texture used by this state
    ///
    pub fn texture_id(&self) -> Option<canvas::TextureId> {
        match self {
            FillState::None                         => None,
            FillState::Color(_)                     => None,
            FillState::Texture(texture_id, _, _, _) => Some(*texture_id),
            FillState::LinearGradient(_, _, _, _)   => None
        }
    }

    ///
    /// Updates the fill state with a new texture alpha
    ///
    pub fn with_texture_alpha(&self, new_alpha: f32) -> Self {
        match self {
            FillState::None                                     => self.clone(),
            FillState::Color(_)                                 => self.clone(),
            FillState::Texture(texture_id, matrix, repeat, _)   => FillState::Texture(*texture_id, *matrix, *repeat, new_alpha),
            FillState::LinearGradient(_, _, _, _)               => self.clone()
        }
    }

    ///
    /// Updates the fill state with a transformed matrix
    ///
    pub fn transform(&self, transform_matrix: &canvas::Transform2D) -> Self {
        let transform_matrix = transform_to_matrix(&transform_matrix);

        match self {
            FillState::None                                                 => self.clone(),
            FillState::Color(_)                                             => self.clone(),
            FillState::Texture(texture_id, matrix, repeat, alpha)           => FillState::Texture(*texture_id, (*matrix).multiply(transform_matrix), *repeat, *alpha),
            FillState::LinearGradient(texture_id, matrix, repeat, alpha)    => FillState::LinearGradient(*texture_id, (*matrix).multiply(transform_matrix), *repeat, *alpha)
        }
    }
}