scene_management/
graphics_utils.rs

1// Copyright 2019 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::display_metrics::DisplayMetrics;
6use input_pipeline::{Position, Size};
7
8/// [`ScreenCoordinates`] represents a point on the screen. It can be created from pixels, pips, or
9/// millimeters and the coordinate vales can be retrieved in any of those units.
10#[derive(Clone, Copy, Debug)]
11pub struct ScreenCoordinates {
12    x_pixels: f32,
13    y_pixels: f32,
14    display_metrics: DisplayMetrics,
15}
16
17#[allow(dead_code)]
18impl ScreenCoordinates {
19    /// Create a [`ScreenCoordinates`] from the given pixel corrdinates
20    pub fn from_pixels(x: f32, y: f32, display_metrics: DisplayMetrics) -> Self {
21        Self { x_pixels: x, y_pixels: y, display_metrics }
22    }
23
24    /// Create a [`ScreenCoordinates`] from the given pip corrdinates
25    pub fn from_pips(x: f32, y: f32, display_metrics: DisplayMetrics) -> Self {
26        Self {
27            x_pixels: x * display_metrics.pixels_per_pip(),
28            y_pixels: y * display_metrics.pixels_per_pip(),
29            display_metrics,
30        }
31    }
32
33    /// Create a [`ScreenCoordinates`] from the given millimeter corrdinates
34    pub fn from_mm(x: f32, y: f32, display_metrics: DisplayMetrics) -> Self {
35        Self {
36            x_pixels: x * display_metrics.pixels_per_pip() * display_metrics.mm_per_pip(),
37            y_pixels: y * display_metrics.pixels_per_pip() * display_metrics.mm_per_pip(),
38            display_metrics,
39        }
40    }
41
42    /// This takes a Position struct and maps it to ScreenCoordinates
43    pub fn from_position(position: &Position, display_metrics: DisplayMetrics) -> Self {
44        Self { x_pixels: position.x, y_pixels: position.y, display_metrics }
45    }
46
47    /// Retreive the x and y positions as pixel values
48    pub fn pixels(&self) -> (f32, f32) {
49        (self.x_pixels, self.y_pixels)
50    }
51
52    /// Retreive the x and y positions as pip values
53    pub fn pips(&self) -> (f32, f32) {
54        (
55            self.x_pixels / self.display_metrics.pixels_per_pip(),
56            self.y_pixels / self.display_metrics.pixels_per_pip(),
57        )
58    }
59
60    /// Retreive the x and y positions as millimeter values
61    pub fn mm(&self) -> (f32, f32) {
62        let (x_pips, y_pips) = self.pips();
63        (x_pips / self.display_metrics.mm_per_pip(), y_pips / self.display_metrics.mm_per_pip())
64    }
65
66    /// Retreive the x and y positions as a [`Position`]
67    pub fn position(&self) -> Position {
68        Position { x: self.x_pixels, y: self.y_pixels }
69    }
70}
71
72/// [`ScreenSize`] represents a size on the screen. It can be created from pixels, pips, or
73/// millimeters and can be retrieved in any of those units.
74#[derive(Clone, Copy, Debug)]
75pub struct ScreenSize {
76    width_pixels: f32,
77    height_pixels: f32,
78    display_metrics: DisplayMetrics,
79}
80
81#[allow(dead_code)]
82impl ScreenSize {
83    /// Create a [`ScreenSize`] from the given pixel corrdinates
84    pub fn from_pixels(width: f32, height: f32, display_metrics: DisplayMetrics) -> Self {
85        Self { width_pixels: width, height_pixels: height, display_metrics }
86    }
87
88    /// Create a [`ScreenSize`] from the given pip corrdinates
89    pub fn from_pips(width: f32, height: f32, display_metrics: DisplayMetrics) -> Self {
90        Self {
91            width_pixels: width * display_metrics.pixels_per_pip(),
92            height_pixels: height * display_metrics.pixels_per_pip(),
93            display_metrics,
94        }
95    }
96
97    /// Create a [`ScreenSize`] from the given millimeter corrdinates
98    pub fn from_mm(width: f32, height: f32, display_metrics: DisplayMetrics) -> Self {
99        Self {
100            width_pixels: width * display_metrics.pixels_per_pip() * display_metrics.mm_per_pip(),
101            height_pixels: height * display_metrics.pixels_per_pip() * display_metrics.mm_per_pip(),
102            display_metrics,
103        }
104    }
105
106    /// This takes a Position struct and maps it to ScreenSize
107    pub fn from_size(size: &Size, display_metrics: DisplayMetrics) -> Self {
108        Self { width_pixels: size.width, height_pixels: size.height, display_metrics }
109    }
110
111    /// Retreive the width and height as pixel values
112    pub fn pixels(&self) -> (f32, f32) {
113        (self.width_pixels, self.height_pixels)
114    }
115
116    /// Retreive the width and height as pip values
117    pub fn pips(&self) -> (f32, f32) {
118        (
119            self.width_pixels / self.display_metrics.pixels_per_pip(),
120            self.height_pixels / self.display_metrics.pixels_per_pip(),
121        )
122    }
123
124    /// Retreive the width and height as millimeter values
125    pub fn mm(&self) -> (f32, f32) {
126        let (width_pips, height_pips) = self.pips();
127        (
128            width_pips / self.display_metrics.mm_per_pip(),
129            height_pips / self.display_metrics.mm_per_pip(),
130        )
131    }
132
133    /// Retreive the width and height as a [`Size`]
134    pub fn size(&self) -> Size {
135        Size { width: self.width_pixels, height: self.height_pixels }
136    }
137}
138
139#[cfg(test)]
140mod tests {
141    use super::*;
142
143    #[inline]
144    fn assert_close_enough(left: (f32, f32), right: (f32, f32)) {
145        const EPSILON: f32 = 0.0001;
146        assert!(left.0 > right.0 - EPSILON, "Left: {:?} Right: {:?}", left, right);
147        assert!(left.0 < right.0 + EPSILON, "Left: {:?} Right: {:?}", left, right);
148        assert!(left.1 > right.1 - EPSILON, "Left: {:?} Right: {:?}", left, right);
149        assert!(left.1 < right.1 + EPSILON, "Left: {:?} Right: {:?}", left, right);
150    }
151
152    #[inline]
153    fn assert_postion_close_enough(left: Position, right: Position) {
154        assert_close_enough((left.x, left.y), (right.x, right.y));
155    }
156
157    #[test]
158    fn test_pixel_constructor() {
159        let display_metrics =
160            DisplayMetrics::new(Size { width: 1000.0, height: 500.0 }, Some(10.0), None, None);
161        let coords = ScreenCoordinates::from_pixels(100.0, 100.0, display_metrics);
162
163        assert_close_enough(coords.pixels(), (100.0, 100.0));
164        assert_close_enough(coords.pips(), (52.2449, 52.2449));
165        assert_close_enough(coords.mm(), (272.9529, 272.9529));
166        assert_postion_close_enough(coords.position(), Position { x: 100.0, y: 100.0 });
167    }
168
169    #[test]
170    fn test_pip_constructor() {
171        let display_metrics =
172            DisplayMetrics::new(Size { width: 1000.0, height: 500.0 }, Some(10.0), None, None);
173        let coords = ScreenCoordinates::from_pips(52.2449, 52.2449, display_metrics);
174
175        assert_close_enough(coords.pixels(), (100.0, 100.0));
176        assert_close_enough(coords.pips(), (52.2449, 52.2449));
177        assert_close_enough(coords.mm(), (272.9529, 272.9529));
178        assert_postion_close_enough(coords.position(), Position { x: 100.0, y: 100.0 });
179    }
180
181    #[test]
182    fn test_mm_constructor() {
183        let display_metrics =
184            DisplayMetrics::new(Size { width: 1000.0, height: 500.0 }, Some(10.0), None, None);
185        let coords = ScreenCoordinates::from_mm(272.9529, 272.9529, display_metrics);
186
187        assert_close_enough(coords.pixels(), (100.0, 100.0));
188        assert_close_enough(coords.pips(), (52.2449, 52.2449));
189        assert_close_enough(coords.mm(), (272.9529, 272.9529));
190        assert_postion_close_enough(coords.position(), Position { x: 100.0, y: 100.0 });
191    }
192
193    #[test]
194    fn test_position_constructor() {
195        let display_metrics =
196            DisplayMetrics::new(Size { width: 1000.0, height: 500.0 }, Some(10.0), None, None);
197        let coords =
198            ScreenCoordinates::from_position(&Position { x: 100.0, y: 100.0 }, display_metrics);
199
200        assert_close_enough(coords.pixels(), (100.0, 100.0));
201        assert_close_enough(coords.pips(), (52.2449, 52.2449));
202        assert_close_enough(coords.mm(), (272.9529, 272.9529));
203        assert_postion_close_enough(coords.position(), Position { x: 100.0, y: 100.0 });
204    }
205}
scene_management/graphics_utils.rs

scene_management/
graphics_utils.rs
