bymsdfgen-core 0.1.0

Pure-Rust msdf generator core: multi-channel signed distance field generation, a data-oriented reimplementation of msdfgen
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

//! Spatial and distance-value transformations.
//! Ports of `Projection`, `DistanceMapping`, `SDFTransformation`.

use crate::math::typed::{PixelPoint, ShapePoint};
use crate::math::{Range, Vector2};

/// Affine transformation between shape space and pixel space.
#[derive(Debug, Clone, Copy)]
pub struct Projection {
    scale: Vector2,
    translate: Vector2,
}

impl Default for Projection {
    fn default() -> Self {
        Projection {
            scale: Vector2::splat(1.0),
            translate: Vector2::ZERO,
        }
    }
}

impl Projection {
    pub fn new(scale: Vector2, translate: Vector2) -> Self {
        Projection { scale, translate }
    }

    /// Shape coordinate → pixel coordinate (typed boundary crossing).
    #[inline]
    pub fn project(&self, coord: ShapePoint) -> PixelPoint {
        PixelPoint::from_raw(self.scale * (coord.raw() + self.translate))
    }

    /// Pixel coordinate → shape coordinate (typed boundary crossing).
    #[inline]
    pub fn unproject(&self, coord: PixelPoint) -> ShapePoint {
        ShapePoint::from_raw(coord.raw() / self.scale - self.translate)
    }

    #[inline]
    pub fn project_vector(&self, v: Vector2) -> Vector2 {
        self.scale * v
    }

    #[inline]
    pub fn unproject_vector(&self, v: Vector2) -> Vector2 {
        v / self.scale
    }

    #[inline]
    pub fn project_x(&self, x: f64) -> f64 {
        self.scale.x * (x + self.translate.x)
    }
    #[inline]
    pub fn project_y(&self, y: f64) -> f64 {
        self.scale.y * (y + self.translate.y)
    }
    #[inline]
    pub fn unproject_x(&self, x: f64) -> f64 {
        x / self.scale.x - self.translate.x
    }
    #[inline]
    pub fn unproject_y(&self, y: f64) -> f64 {
        y / self.scale.y - self.translate.y
    }

    #[inline]
    pub fn scale(&self) -> Vector2 {
        self.scale
    }
    #[inline]
    pub fn translate(&self) -> Vector2 {
        self.translate
    }
}

/// Linear mapping of signed distance values into normalized field values.
#[derive(Debug, Clone, Copy)]
pub struct DistanceMapping {
    scale: f64,
    translate: f64,
}

impl Default for DistanceMapping {
    fn default() -> Self {
        DistanceMapping {
            scale: 1.0,
            translate: 0.0,
        }
    }
}

impl DistanceMapping {
    /// Maps `[range.lower, range.upper]` onto `[0, 1]`.
    pub fn from_range(range: Range) -> Self {
        DistanceMapping {
            scale: 1.0 / (range.upper - range.lower),
            translate: -range.lower,
        }
    }

    /// The inverse mapping that takes a `range` back from normalized values.
    pub fn inverse_of_range(range: Range) -> Self {
        let range_width = range.upper - range.lower;
        DistanceMapping {
            scale: range_width,
            translate: range.lower / if range_width != 0.0 { range_width } else { 1.0 },
        }
    }

    fn raw(scale: f64, translate: f64) -> Self {
        DistanceMapping { scale, translate }
    }

    /// Map an absolute distance.
    #[inline]
    pub fn map(&self, d: f64) -> f64 {
        self.scale * (d + self.translate)
    }

    /// Map a distance *delta* (no translation applied).
    #[inline]
    pub fn map_delta(&self, d: f64) -> f64 {
        self.scale * d
    }

    pub fn inverse(&self) -> Self {
        DistanceMapping::raw(1.0 / self.scale, -self.scale * self.translate)
    }
}

/// Combined spatial + distance-value transformation.
#[derive(Debug, Clone, Copy, Default)]
pub struct SdfTransformation {
    pub projection: Projection,
    pub distance_mapping: DistanceMapping,
}

impl SdfTransformation {
    pub fn new(projection: Projection, distance_mapping: DistanceMapping) -> Self {
        SdfTransformation {
            projection,
            distance_mapping,
        }
    }
}