pixman 0.2.1

Pixman is a low-level software library for pixel manipulation, providing features such as image compositing and trapezoid rasterization.
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

use pixman_sys as ffi;

/// Fixed-point value
#[derive(Debug, Clone, Copy)]
#[repr(transparent)]
pub struct Fixed(ffi::pixman_fixed_t);

impl Fixed {
    /// One
    pub const ONE: Fixed = Fixed::from_int(1);
    /// Zero
    pub const ZERO: Fixed = Fixed::from_raw(0);

    /// Initialize this fixed-point from a raw value
    #[inline]
    pub const fn from_raw(value: ffi::pixman_fixed_t) -> Self {
        Self(value)
    }

    /// Initialize this fixed-point from an integer
    #[inline]
    pub const fn from_int(value: i32) -> Self {
        Self(((value as u32) << 16) as ffi::pixman_fixed_t)
    }

    /// Initialize this fixed-point from an `f64`
    #[inline]
    pub fn from_double(value: f64) -> Self {
        Self((value * 65536.0) as ffi::pixman_fixed_t)
    }

    /// Get the int value of this fixed point
    #[inline]
    pub const fn to_int(self) -> i32 {
        self.0 >> 16
    }

    /// Access the raw fixed-point value
    #[inline]
    pub fn into_raw(self) -> ffi::pixman_fixed_t {
        self.0
    }
}

impl std::ops::Add for Fixed {
    type Output = Fixed;

    fn add(self, rhs: Self) -> Self::Output {
        Self(self.0 + rhs.0)
    }
}

impl From<i32> for Fixed {
    #[inline]
    fn from(value: i32) -> Self {
        Self::from_int(value)
    }
}

impl From<f32> for Fixed {
    #[inline]
    fn from(value: f32) -> Self {
        Self::from_double(value as f64)
    }
}

impl From<f64> for Fixed {
    #[inline]
    fn from(value: f64) -> Self {
        Self::from_double(value)
    }
}