michael/pathfinder
michael
/
pathfinder
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add convenience constructors: `vec2f`, `vec2i`, `Vector2F::zero()`, 

`Vector2I::zero()`
This commit is contained in:
Patrick Walton 2020-03-31 11:28:34 -07:00
parent d83f54457c
commit 93f5fbc6d2
37 changed files with 473 additions and 550 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
canvas/src/lib.rs
View File

@ -21,9 +21,9 @@ use pathfinder_content::render_target::RenderTargetId;
use pathfinder_content::stroke::{LineCap, LineJoin as StrokeLineJoin}; use pathfinder_content::stroke::{LineCap, LineJoin as StrokeLineJoin};
use pathfinder_content::stroke::{OutlineStrokeToFill, StrokeStyle}; use pathfinder_content::stroke::{OutlineStrokeToFill, StrokeStyle};
use pathfinder_geometry::line_segment::LineSegment2F; use pathfinder_geometry::line_segment::LineSegment2F;
use pathfinder_geometry::vector::Vector2F;
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::vector::{Vector2F, vec2f};
use pathfinder_renderer::paint::{Paint, PaintId}; use pathfinder_renderer::paint::{Paint, PaintId};
use pathfinder_renderer::scene::{ClipPath, ClipPathId, DrawPath, RenderTarget, Scene}; use pathfinder_renderer::scene::{ClipPath, ClipPathId, DrawPath, RenderTarget, Scene};
use skribo::FontCollection; use skribo::FontCollection;
@ -75,7 +75,7 @@ impl CanvasRenderingContext2D {
#[inline] #[inline]
pub fn new(font_context: CanvasFontContext, size: Vector2F) -> CanvasRenderingContext2D { pub fn new(font_context: CanvasFontContext, size: Vector2F) -> CanvasRenderingContext2D {
let mut scene = Scene::new(); let mut scene = Scene::new();
scene.set_view_box(RectF::new(Vector2F::default(), size)); scene.set_view_box(RectF::new(Vector2F::zero(), size));
CanvasRenderingContext2D::from_scene(font_context, scene) CanvasRenderingContext2D::from_scene(font_context, scene)
} }
@ -454,7 +454,7 @@ impl State {
stroke_paint: Paint::black(), stroke_paint: Paint::black(),
shadow_paint: Paint::transparent_black(), shadow_paint: Paint::transparent_black(),
shadow_blur: 0.0, shadow_blur: 0.0,
shadow_offset: Vector2F::default(), shadow_offset: Vector2F::zero(),
text_align: TextAlign::Left, text_align: TextAlign::Left,
text_baseline: TextBaseline::Alphabetic, text_baseline: TextBaseline::Alphabetic,
image_smoothing_enabled: true, image_smoothing_enabled: true,
@ -561,8 +561,8 @@ impl Path2D {
let transform = Transform2F::from_scale(Vector2F::splat(radius)).translate(center); let transform = Transform2F::from_scale(Vector2F::splat(radius)).translate(center);
let chord = LineSegment2F::new(vu0.yx().scale_xy(Vector2F::new(-1.0, 1.0)), let chord = LineSegment2F::new(vu0.yx().scale_xy(vec2f(-1.0, 1.0)),
vu1.yx().scale_xy(Vector2F::new(1.0, -1.0))); vu1.yx().scale_xy(vec2f( 1.0, -1.0)));
// FIXME(pcwalton): Is clockwise direction correct? // FIXME(pcwalton): Is clockwise direction correct?
self.current_contour.push_arc_from_unit_chord(&transform, chord, ArcDirection::CW); self.current_contour.push_arc_from_unit_chord(&transform, chord, ArcDirection::CW);

8
canvas/src/tests.rs
View File

@ -3,16 +3,16 @@
// For this file only, any copyright is dedicated to the Public Domain. // For this file only, any copyright is dedicated to the Public Domain.
// https://creativecommons.org/publicdomain/zero/1.0/ // https://creativecommons.org/publicdomain/zero/1.0/
use pathfinder_geometry::vector::Vector2F; use pathfinder_geometry::vector::{Vector2F, vec2f};
use super::Path2D; use super::Path2D;
#[test] #[test]
pub fn test_path2d_formatting() { pub fn test_path2d_formatting() {
let mut path = Path2D::new(); let mut path = Path2D::new();
path.move_to(Vector2F::new(0.0, 1.0)); path.move_to(vec2f(0.0, 1.0));
path.line_to(Vector2F::new(2.0, 3.0)); path.line_to(vec2f(2.0, 3.0));
assert_eq!(format!("{:?}", path), "M 0 1 L 2 3"); assert_eq!(format!("{:?}", path), "M 0 1 L 2 3");
path.line_to(Vector2F::new(4.0, 5.0)); path.line_to(vec2f(4.0, 5.0));
assert_eq!(format!("{:?}", path), "M 0 1 L 2 3 L 4 5"); assert_eq!(format!("{:?}", path), "M 0 1 L 2 3 L 4 5");
path.close_path(); path.close_path();
assert_eq!(format!("{:?}", path), "M 0 1 L 2 3 L 4 5 z"); assert_eq!(format!("{:?}", path), "M 0 1 L 2 3 L 4 5 z");

8
content/src/dilation.rs
View File

@ -10,7 +10,7 @@
use crate::orientation::Orientation; use crate::orientation::Orientation;
use crate::outline::Contour; use crate::outline::Contour;
use pathfinder_geometry::vector::Vector2F; use pathfinder_geometry::vector::{Vector2F, vec2f};
pub struct ContourDilator<'a> { pub struct ContourDilator<'a> {
contour: &'a mut Contour, contour: &'a mut Contour,
@ -34,8 +34,8 @@ impl<'a> ContourDilator<'a> {
pub fn dilate(&mut self) { pub fn dilate(&mut self) {
// Determine orientation. // Determine orientation.
let scale = self.amount.scale_xy(match self.orientation { let scale = self.amount.scale_xy(match self.orientation {
Orientation::Ccw => Vector2F::new(1.0, -1.0), Orientation::Ccw => vec2f( 1.0, -1.0),
Orientation::Cw => Vector2F::new(-1.0, 1.0), Orientation::Cw => vec2f(-1.0, 1.0),
}); });
// Find the starting and previous positions. // Find the starting and previous positions.
@ -84,7 +84,7 @@ impl<'a> ContourDilator<'a> {
let bisector = prev_vector.yx() + next_vector.yx(); let bisector = prev_vector.yx() + next_vector.yx();
let bisector_length = bisector.length(); let bisector_length = bisector.length();
let scaled_bisector = if bisector_length == 0.0 { let scaled_bisector = if bisector_length == 0.0 {
Vector2F::default() Vector2F::zero()
} else { } else {
bisector.scale_xy(scale).scale(1.0 / bisector_length) bisector.scale_xy(scale).scale(1.0 / bisector_length)
}; };

16
content/src/outline.rs
View File

@ -19,7 +19,7 @@ use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::transform3d::Perspective; use pathfinder_geometry::transform3d::Perspective;
use pathfinder_geometry::unit_vector::UnitVector; use pathfinder_geometry::unit_vector::UnitVector;
use pathfinder_geometry::vector::Vector2F; use pathfinder_geometry::vector::{Vector2F, vec2f};
use std::f32::consts::PI; use std::f32::consts::PI;
use std::fmt::{self, Debug, Formatter}; use std::fmt::{self, Debug, Formatter};
use std::mem; use std::mem;
@ -408,8 +408,8 @@ impl Contour {
if end_angle - start_angle >= PI * 2.0 { if end_angle - start_angle >= PI * 2.0 {
self.push_ellipse(transform); self.push_ellipse(transform);
} else { } else {
let start = Vector2F::new(f32::cos(start_angle), f32::sin(start_angle)); let start = vec2f(start_angle.cos(), start_angle.sin());
let end = Vector2F::new(f32::cos(end_angle), f32::sin(end_angle)); let end = vec2f(end_angle.cos(), end_angle.sin());
self.push_arc_from_unit_chord(transform, LineSegment2F::new(start, end), direction); self.push_arc_from_unit_chord(transform, LineSegment2F::new(start, end), direction);
} }
} }
@ -421,7 +421,7 @@ impl Contour {
let mut direction_transform = Transform2F::default(); let mut direction_transform = Transform2F::default();
if direction == ArcDirection::CCW { if direction == ArcDirection::CCW {
chord = chord.reversed(); chord = chord.reversed();
direction_transform = Transform2F::from_scale(Vector2F::new(1.0, -1.0)); direction_transform = Transform2F::from_scale(vec2f(1.0, -1.0));
} }
let (mut vector, end_vector) = (UnitVector(chord.from()), UnitVector(chord.to())); let (mut vector, end_vector) = (UnitVector(chord.from()), UnitVector(chord.to()));
@ -433,7 +433,7 @@ impl Contour {
let mut segment; let mut segment;
if !last { if !last {
sweep_vector = UnitVector(Vector2F::new(0.0, 1.0)); sweep_vector = UnitVector(vec2f(0.0, 1.0));
segment = Segment::quarter_circle_arc(); segment = Segment::quarter_circle_arc();
} else { } else {
segment = Segment::arc_from_cos(sweep_vector.0.x()); segment = Segment::arc_from_cos(sweep_vector.0.x());
@ -465,13 +465,13 @@ impl Contour {
let mut rotation; let mut rotation;
self.push_segment(&segment.transform(transform), self.push_segment(&segment.transform(transform),
PushSegmentFlags::UPDATE_BOUNDS | PushSegmentFlags::INCLUDE_FROM_POINT); PushSegmentFlags::UPDATE_BOUNDS | PushSegmentFlags::INCLUDE_FROM_POINT);
rotation = Transform2F::from_rotation_vector(UnitVector(Vector2F::new( 0.0, 1.0))); rotation = Transform2F::from_rotation_vector(UnitVector(vec2f( 0.0, 1.0)));
self.push_segment(&segment.transform(&(*transform * rotation)), self.push_segment(&segment.transform(&(*transform * rotation)),
PushSegmentFlags::UPDATE_BOUNDS); PushSegmentFlags::UPDATE_BOUNDS);
rotation = Transform2F::from_rotation_vector(UnitVector(Vector2F::new(-1.0, 0.0))); rotation = Transform2F::from_rotation_vector(UnitVector(vec2f(-1.0, 0.0)));
self.push_segment(&segment.transform(&(*transform * rotation)), self.push_segment(&segment.transform(&(*transform * rotation)),
PushSegmentFlags::UPDATE_BOUNDS); PushSegmentFlags::UPDATE_BOUNDS);
rotation = Transform2F::from_rotation_vector(UnitVector(Vector2F::new( 0.0, -1.0))); rotation = Transform2F::from_rotation_vector(UnitVector(vec2f( 0.0, -1.0)));
self.push_segment(&segment.transform(&(*transform * rotation)), self.push_segment(&segment.transform(&(*transform * rotation)),
PushSegmentFlags::UPDATE_BOUNDS); PushSegmentFlags::UPDATE_BOUNDS);
} }

4
content/src/pattern.rs
View File

@ -14,7 +14,7 @@ use crate::render_target::RenderTargetId;
use crate::util; use crate::util;
use pathfinder_color::{self as color, ColorU}; use pathfinder_color::{self as color, ColorU};
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::vector::Vector2I; use pathfinder_geometry::vector::{Vector2I, vec2i};
use std::collections::hash_map::DefaultHasher; use std::collections::hash_map::DefaultHasher;
use std::fmt::{self, Debug, Formatter}; use std::fmt::{self, Debug, Formatter};
use std::hash::{Hash, Hasher}; use std::hash::{Hash, Hasher};
@ -79,7 +79,7 @@ impl Image {
pub fn from_image_buffer(image_buffer: RgbaImage) -> Image { pub fn from_image_buffer(image_buffer: RgbaImage) -> Image {
let (width, height) = image_buffer.dimensions(); let (width, height) = image_buffer.dimensions();
let pixels = color::u8_vec_to_color_vec(image_buffer.into_raw()); let pixels = color::u8_vec_to_color_vec(image_buffer.into_raw());
Image::new(Vector2I::new(width as i32, height as i32), pixels) Image::new(vec2i(width as i32, height as i32), pixels)
} }
#[inline] #[inline]

13
content/src/segment.rs
View File

@ -13,7 +13,7 @@
use pathfinder_geometry::line_segment::LineSegment2F; use pathfinder_geometry::line_segment::LineSegment2F;
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::util::{self, EPSILON}; use pathfinder_geometry::util::{self, EPSILON};
use pathfinder_geometry::vector::Vector2F; use pathfinder_geometry::vector::{Vector2F, vec2f};
use pathfinder_simd::default::F32x4; use pathfinder_simd::default::F32x4;
use std::f32::consts::SQRT_2; use std::f32::consts::SQRT_2;
@ -52,7 +52,7 @@ impl Segment {
pub fn quadratic(baseline: LineSegment2F, ctrl: Vector2F) -> Segment { pub fn quadratic(baseline: LineSegment2F, ctrl: Vector2F) -> Segment {
Segment { Segment {
baseline, baseline,
ctrl: LineSegment2F::new(ctrl, Vector2F::default()), ctrl: LineSegment2F::new(ctrl, Vector2F::zero()),
kind: SegmentKind::Quadratic, kind: SegmentKind::Quadratic,
flags: SegmentFlags::empty(), flags: SegmentFlags::empty(),
} }
@ -97,8 +97,8 @@ impl Segment {
#[inline] #[inline]
pub fn quarter_circle_arc() -> Segment { pub fn quarter_circle_arc() -> Segment {
let p0 = Vector2F::splat(SQRT_2 * 0.5); let p0 = Vector2F::splat(SQRT_2 * 0.5);
let p1 = Vector2F::new(-SQRT_2 / 6.0 + 4.0 / 3.0, 7.0 * SQRT_2 / 6.0 - 4.0 / 3.0); let p1 = vec2f(-SQRT_2 / 6.0 + 4.0 / 3.0, 7.0 * SQRT_2 / 6.0 - 4.0 / 3.0);
let flip = Vector2F::new(1.0, -1.0); let flip = vec2f(1.0, -1.0);
let (p2, p3) = (p1.scale_xy(flip), p0.scale_xy(flip)); let (p2, p3) = (p1.scale_xy(flip), p0.scale_xy(flip));
Segment::cubic(LineSegment2F::new(p3, p0), LineSegment2F::new(p2, p1)) Segment::cubic(LineSegment2F::new(p3, p0), LineSegment2F::new(p2, p1))
} }
@ -145,9 +145,8 @@ impl Segment {
let mut new_segment = *self; let mut new_segment = *self;
let p1_2 = self.ctrl.from() + self.ctrl.from(); let p1_2 = self.ctrl.from() + self.ctrl.from();
new_segment.ctrl = new_segment.ctrl = LineSegment2F::new(self.baseline.from() + p1_2,
LineSegment2F::new(self.baseline.from() + p1_2, p1_2 + self.baseline.to()) p1_2 + self.baseline.to()).scale(1.0 / 3.0);
.scale(1.0 / 3.0);
new_segment.kind = SegmentKind::Cubic; new_segment.kind = SegmentKind::Cubic;
new_segment new_segment
} }

25
demo/android/rust/src/lib.rs
View File

@ -16,7 +16,7 @@ use jni::{JNIEnv, JavaVM};
use pathfinder_demo::window::{Event, SVGPath, View, Window, WindowSize}; use pathfinder_demo::window::{Event, SVGPath, View, Window, WindowSize};
use pathfinder_demo::DemoApp; use pathfinder_demo::DemoApp;
use pathfinder_demo::Options; use pathfinder_demo::Options;
use pathfinder_geometry::vector::Vector2I; use pathfinder_geometry::vector::{Vector2I, vec2i};
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_gl::GLVersion; use pathfinder_gl::GLVersion;
use pathfinder_resources::ResourceLoader; use pathfinder_resources::ResourceLoader;
@ -48,7 +48,7 @@ pub unsafe extern "system" fn Java_graphics_pathfinder_pathfinderdemo_Pathfinder
width: i32, width: i32,
height: i32, height: i32,
) { ) {
let logical_size = Vector2I::new(width, height); let logical_size = vec2i(width, height);
let window_size = WindowSize { let window_size = WindowSize {
logical_size, logical_size,
backing_scale_factor: 1.0, backing_scale_factor: 1.0,
@ -119,7 +119,7 @@ pub unsafe extern "system" fn Java_graphics_pathfinder_pathfinderdemo_Pathfinder
.lock() .lock()
.unwrap() .unwrap()
.push(Event::WindowResized(WindowSize { .push(Event::WindowResized(WindowSize {
logical_size: Vector2I::new(width, height), logical_size: vec2i(width, height),
backing_scale_factor: 1.0, backing_scale_factor: 1.0,
})) }))
} }
@ -131,10 +131,7 @@ pub unsafe extern "system" fn Java_graphics_pathfinder_pathfinderdemo_Pathfinder
x: i32, x: i32,
y: i32, y: i32,
) { ) {
EVENT_QUEUE EVENT_QUEUE.lock().unwrap().push(Event::MouseDown(vec2i(x, y)))
.lock()
.unwrap()
.push(Event::MouseDown(Vector2I::new(x, y)))
} }
#[no_mangle] #[no_mangle]
@ -144,10 +141,7 @@ pub unsafe extern "system" fn Java_graphics_pathfinder_pathfinderdemo_Pathfinder
x: i32, x: i32,
y: i32, y: i32,
) { ) {
EVENT_QUEUE EVENT_QUEUE.lock().unwrap().push(Event::MouseDragged(vec2i(x, y)))
.lock()
.unwrap()
.push(Event::MouseDragged(Vector2I::new(x, y)))
} }
#[no_mangle] #[no_mangle]
@ -158,10 +152,7 @@ pub unsafe extern "system" fn Java_graphics_pathfinder_pathfinderdemo_Pathfinder
center_x: i32, center_x: i32,
center_y: i32, center_y: i32,
) { ) {
EVENT_QUEUE EVENT_QUEUE.lock().unwrap().push(Event::Zoom(factor, vec2i(center_x, center_y)))
.lock()
.unwrap()
.push(Event::Zoom(factor, Vector2I::new(center_x, center_y)))
} }
#[no_mangle] #[no_mangle]
@ -204,8 +195,8 @@ impl Window for WindowImpl {
width = width / 2; width = width / 2;
offset_x = (index as i32) * width; offset_x = (index as i32) * width;
} }
let size = Vector2I::new(width, height); let size = vec2i(width, height);
let offset = Vector2I::new(offset_x, 0); let offset = vec2i(offset_x, 0);
RectI::new(offset, size) RectI::new(offset, size)
} }

17
demo/common/src/lib.rs
View File

@ -28,7 +28,7 @@ use pathfinder_export::{Export, FileFormat};
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::transform3d::Transform4F; use pathfinder_geometry::transform3d::Transform4F;
use pathfinder_geometry::vector::{Vector2F, Vector2I, Vector4F}; use pathfinder_geometry::vector::{Vector2F, Vector2I, Vector4F, vec2f, vec2i};
use pathfinder_gpu::Device; use pathfinder_gpu::Device;
use pathfinder_renderer::concurrent::scene_proxy::{RenderCommandStream, SceneProxy}; use pathfinder_renderer::concurrent::scene_proxy::{RenderCommandStream, SceneProxy};
use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions}; use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions};
@ -256,9 +256,9 @@ impl<W> DemoApp<W> where W: Window {
dilation: if self.ui_model.stem_darkening_effect_enabled { dilation: if self.ui_model.stem_darkening_effect_enabled {
let font_size = APPROX_FONT_SIZE * self.window_size.backing_scale_factor; let font_size = APPROX_FONT_SIZE * self.window_size.backing_scale_factor;
let (x, y) = (STEM_DARKENING_FACTORS[0], STEM_DARKENING_FACTORS[1]); let (x, y) = (STEM_DARKENING_FACTORS[0], STEM_DARKENING_FACTORS[1]);
Vector2F::new(x, y).scale(font_size) vec2f(x, y).scale(font_size)
} else { } else {
Vector2F::default() Vector2F::zero()
}, },
subpixel_aa_enabled: self.ui_model.subpixel_aa_effect_enabled, subpixel_aa_enabled: self.ui_model.subpixel_aa_effect_enabled,
}; };
@ -279,10 +279,9 @@ impl<W> DemoApp<W> where W: Window {
Event::WindowResized(new_size) => { Event::WindowResized(new_size) => {
self.window_size = new_size; self.window_size = new_size;
let viewport = self.window.viewport(self.ui_model.mode.view(0)); let viewport = self.window.viewport(self.ui_model.mode.view(0));
self.scene_proxy.set_view_box(RectF::new(Vector2F::default(), self.scene_proxy.set_view_box(RectF::new(Vector2F::zero(),
viewport.size().to_f32())); viewport.size().to_f32()));
self.renderer self.renderer.set_main_framebuffer_size(self.window_size.device_size());
.set_main_framebuffer_size(self.window_size.device_size());
self.dirty = true; self.dirty = true;
} }
Event::MouseDown(new_position) => { Event::MouseDown(new_position) => {
@ -776,8 +775,8 @@ fn build_svg_tree(tree: &Tree, viewport_size: Vector2I, effects: Option<Effects>
None => None, None => None,
Some(effects) => { Some(effects) => {
let scale = match effects.filter { let scale = match effects.filter {
Filter::Text { defringing_kernel: Some(_), .. } => Vector2I::new(3, 1), Filter::Text { defringing_kernel: Some(_), .. } => vec2i(3, 1),
_ => Vector2I::splat(1), _ => vec2i(1, 1),
}; };
let name = "Text".to_owned(); let name = "Text".to_owned();
let render_target = RenderTarget::new(viewport_size.scale_xy(scale), name); let render_target = RenderTarget::new(viewport_size.scale_xy(scale), name);
@ -873,7 +872,7 @@ impl SceneMetadata {
// Can we simplify this? // Can we simplify this?
fn new_clipping_view_box(scene: &mut Scene, viewport_size: Vector2I) -> SceneMetadata { fn new_clipping_view_box(scene: &mut Scene, viewport_size: Vector2I) -> SceneMetadata {
let view_box = scene.view_box(); let view_box = scene.view_box();
scene.set_view_box(RectF::new(Vector2F::default(), viewport_size.to_f32())); scene.set_view_box(RectF::new(Vector2F::zero(), viewport_size.to_f32()));
SceneMetadata { view_box } SceneMetadata { view_box }
} }
} }

86
demo/common/src/ui.rs
View File

@ -13,7 +13,7 @@ use crate::window::Window;
use crate::{BackgroundColor, Options}; use crate::{BackgroundColor, Options};
use pathfinder_color::ColorU; use pathfinder_color::ColorU;
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::vector::Vector2I; use pathfinder_geometry::vector::{Vector2I, vec2i};
use pathfinder_gpu::Device; use pathfinder_gpu::Device;
use pathfinder_renderer::gpu::debug::DebugUIPresenter; use pathfinder_renderer::gpu::debug::DebugUIPresenter;
use pathfinder_resources::ResourceLoader; use pathfinder_resources::ResourceLoader;
@ -165,9 +165,9 @@ where
// Draw button strip. // Draw button strip.
let bottom = debug_ui_presenter.ui_presenter.framebuffer_size().y() - PADDING; let bottom = debug_ui_presenter.ui_presenter.framebuffer_size().y() - PADDING;
let mut position = Vector2I::new(PADDING, bottom - BUTTON_HEIGHT); let mut position = vec2i(PADDING, bottom - BUTTON_HEIGHT);
let button_size = Vector2I::new(BUTTON_WIDTH, BUTTON_HEIGHT); let button_size = vec2i(BUTTON_WIDTH, BUTTON_HEIGHT);
// Draw effects button. // Draw effects button.
if debug_ui_presenter.ui_presenter.draw_button(device, position, &self.effects_texture) { if debug_ui_presenter.ui_presenter.draw_button(device, position, &self.effects_texture) {
@ -180,7 +180,7 @@ where
RectI::new(position, button_size), RectI::new(position, button_size),
); );
} }
position += Vector2I::new(button_size.x() + PADDING, 0); position += vec2i(button_size.x() + PADDING, 0);
// Draw open button. // Draw open button.
if debug_ui_presenter.ui_presenter.draw_button(device, position, &self.open_texture) { if debug_ui_presenter.ui_presenter.draw_button(device, position, &self.open_texture) {
@ -191,7 +191,7 @@ where
debug_ui_presenter.ui_presenter.draw_tooltip(device, debug_ui_presenter.ui_presenter.draw_tooltip(device,
"Open SVG", "Open SVG",
RectI::new(position, button_size)); RectI::new(position, button_size));
position += Vector2I::new(BUTTON_WIDTH + PADDING, 0); position += vec2i(BUTTON_WIDTH + PADDING, 0);
// Draw screenshot button. // Draw screenshot button.
if debug_ui_presenter.ui_presenter.draw_button(device, if debug_ui_presenter.ui_presenter.draw_button(device,
@ -209,7 +209,7 @@ where
// Draw screenshot panel, if necessary. // Draw screenshot panel, if necessary.
self.draw_screenshot_panel(device, window, debug_ui_presenter, position.x(), action); self.draw_screenshot_panel(device, window, debug_ui_presenter, position.x(), action);
position += Vector2I::new(button_size.x() + PADDING, 0); position += vec2i(button_size.x() + PADDING, 0);
// Draw mode switch. // Draw mode switch.
let new_mode = debug_ui_presenter.ui_presenter.draw_text_switch( let new_mode = debug_ui_presenter.ui_presenter.draw_text_switch(
@ -227,13 +227,13 @@ where
} }
let mode_switch_width = debug_ui_presenter.ui_presenter.measure_segmented_control(3); let mode_switch_width = debug_ui_presenter.ui_presenter.measure_segmented_control(3);
let mode_switch_size = Vector2I::new(mode_switch_width, BUTTON_HEIGHT); let mode_switch_size = vec2i(mode_switch_width, BUTTON_HEIGHT);
debug_ui_presenter.ui_presenter.draw_tooltip( debug_ui_presenter.ui_presenter.draw_tooltip(
device, device,
"2D/3D/VR Mode", "2D/3D/VR Mode",
RectI::new(position, mode_switch_size), RectI::new(position, mode_switch_size),
); );
position += Vector2I::new(mode_switch_width + PADDING, 0); position += vec2i(mode_switch_width + PADDING, 0);
// Draw background switch. // Draw background switch.
if debug_ui_presenter.ui_presenter.draw_button(device, if debug_ui_presenter.ui_presenter.draw_button(device,
@ -251,7 +251,7 @@ where
// Draw background panel, if necessary. // Draw background panel, if necessary.
self.draw_background_panel(device, debug_ui_presenter, position.x(), action, model); self.draw_background_panel(device, debug_ui_presenter, position.x(), action, model);
position += Vector2I::new(button_size.x() + PADDING, 0); position += vec2i(button_size.x() + PADDING, 0);
// Draw effects panel, if necessary. // Draw effects panel, if necessary.
self.draw_effects_panel(device, debug_ui_presenter, model, action); self.draw_effects_panel(device, debug_ui_presenter, model, action);
@ -270,7 +270,7 @@ where
RectI::new(position, button_size)); RectI::new(position, button_size));
} }
self.draw_rotate_panel(device, debug_ui_presenter, position.x(), action, model); self.draw_rotate_panel(device, debug_ui_presenter, position.x(), action, model);
position += Vector2I::new(BUTTON_WIDTH + PADDING, 0); position += vec2i(BUTTON_WIDTH + PADDING, 0);
// Draw zoom control. // Draw zoom control.
self.draw_zoom_control(device, debug_ui_presenter, position, action); self.draw_zoom_control(device, debug_ui_presenter, position, action);
@ -286,7 +286,7 @@ where
let zoom_segmented_control_width = let zoom_segmented_control_width =
debug_ui_presenter.ui_presenter.measure_segmented_control(3); debug_ui_presenter.ui_presenter.measure_segmented_control(3);
let zoom_segmented_control_rect = let zoom_segmented_control_rect =
RectI::new(position, Vector2I::new(zoom_segmented_control_width, BUTTON_HEIGHT)); RectI::new(position, vec2i(zoom_segmented_control_width, BUTTON_HEIGHT));
debug_ui_presenter.ui_presenter.draw_tooltip(device, "Zoom", zoom_segmented_control_rect); debug_ui_presenter.ui_presenter.draw_tooltip(device, "Zoom", zoom_segmented_control_rect);
let zoom_textures = &[ let zoom_textures = &[
@ -315,8 +315,8 @@ where
} }
let message_size = debug_ui_presenter.ui_presenter.measure_text(&model.message); let message_size = debug_ui_presenter.ui_presenter.measure_text(&model.message);
let window_origin = Vector2I::new(PADDING, PADDING); let window_origin = vec2i(PADDING, PADDING);
let window_size = Vector2I::new(PADDING * 2 + message_size, TOOLTIP_HEIGHT); let window_size = vec2i(PADDING * 2 + message_size, TOOLTIP_HEIGHT);
debug_ui_presenter.ui_presenter.draw_solid_rounded_rect( debug_ui_presenter.ui_presenter.draw_solid_rounded_rect(
device, device,
RectI::new(window_origin, window_size), RectI::new(window_origin, window_size),
@ -325,7 +325,7 @@ where
debug_ui_presenter.ui_presenter.draw_text( debug_ui_presenter.ui_presenter.draw_text(
device, device,
&model.message, &model.message,
window_origin + Vector2I::new(PADDING, PADDING + FONT_ASCENT), window_origin + vec2i(PADDING, PADDING + FONT_ASCENT),
false, false,
); );
} }
@ -343,10 +343,8 @@ where
let effects_panel_y = bottom - (BUTTON_HEIGHT + PADDING + EFFECTS_PANEL_HEIGHT); let effects_panel_y = bottom - (BUTTON_HEIGHT + PADDING + EFFECTS_PANEL_HEIGHT);
debug_ui_presenter.ui_presenter.draw_solid_rounded_rect( debug_ui_presenter.ui_presenter.draw_solid_rounded_rect(
device, device,
RectI::new( RectI::new(vec2i(PADDING, effects_panel_y),
Vector2I::new(PADDING, effects_panel_y), vec2i(EFFECTS_PANEL_WIDTH, EFFECTS_PANEL_HEIGHT)),
Vector2I::new(EFFECTS_PANEL_WIDTH, EFFECTS_PANEL_HEIGHT),
),
WINDOW_COLOR, WINDOW_COLOR,
); );
@ -390,13 +388,10 @@ where
let bottom = debug_ui_presenter.ui_presenter.framebuffer_size().y() - PADDING; let bottom = debug_ui_presenter.ui_presenter.framebuffer_size().y() - PADDING;
let panel_y = bottom - (BUTTON_HEIGHT + PADDING + SCREENSHOT_PANEL_HEIGHT); let panel_y = bottom - (BUTTON_HEIGHT + PADDING + SCREENSHOT_PANEL_HEIGHT);
let panel_position = Vector2I::new(panel_x, panel_y); let panel_position = vec2i(panel_x, panel_y);
debug_ui_presenter.ui_presenter.draw_solid_rounded_rect( debug_ui_presenter.ui_presenter.draw_solid_rounded_rect(
device, device,
RectI::new( RectI::new(panel_position, vec2i(SCREENSHOT_PANEL_WIDTH, SCREENSHOT_PANEL_HEIGHT)),
panel_position,
Vector2I::new(SCREENSHOT_PANEL_WIDTH, SCREENSHOT_PANEL_HEIGHT),
),
WINDOW_COLOR, WINDOW_COLOR,
); );
@ -432,13 +427,10 @@ where
let bottom = debug_ui_presenter.ui_presenter.framebuffer_size().y() - PADDING; let bottom = debug_ui_presenter.ui_presenter.framebuffer_size().y() - PADDING;
let panel_y = bottom - (BUTTON_HEIGHT + PADDING + BACKGROUND_PANEL_HEIGHT); let panel_y = bottom - (BUTTON_HEIGHT + PADDING + BACKGROUND_PANEL_HEIGHT);
let panel_position = Vector2I::new(panel_x, panel_y); let panel_position = vec2i(panel_x, panel_y);
debug_ui_presenter.ui_presenter.draw_solid_rounded_rect( debug_ui_presenter.ui_presenter.draw_solid_rounded_rect(
device, device,
RectI::new( RectI::new(panel_position, vec2i(BACKGROUND_PANEL_WIDTH, BACKGROUND_PANEL_HEIGHT)),
panel_position,
Vector2I::new(BACKGROUND_PANEL_WIDTH, BACKGROUND_PANEL_HEIGHT),
),
WINDOW_COLOR, WINDOW_COLOR,
); );
@ -482,8 +474,8 @@ where
let bottom = debug_ui_presenter.ui_presenter.framebuffer_size().y() - PADDING; let bottom = debug_ui_presenter.ui_presenter.framebuffer_size().y() - PADDING;
let rotate_panel_y = bottom - (BUTTON_HEIGHT + PADDING + ROTATE_PANEL_HEIGHT); let rotate_panel_y = bottom - (BUTTON_HEIGHT + PADDING + ROTATE_PANEL_HEIGHT);
let rotate_panel_origin = Vector2I::new(rotate_panel_x, rotate_panel_y); let rotate_panel_origin = vec2i(rotate_panel_x, rotate_panel_y);
let rotate_panel_size = Vector2I::new(ROTATE_PANEL_WIDTH, ROTATE_PANEL_HEIGHT); let rotate_panel_size = vec2i(ROTATE_PANEL_WIDTH, ROTATE_PANEL_HEIGHT);
debug_ui_presenter.ui_presenter.draw_solid_rounded_rect( debug_ui_presenter.ui_presenter.draw_solid_rounded_rect(
device, device,
RectI::new(rotate_panel_origin, rotate_panel_size), RectI::new(rotate_panel_origin, rotate_panel_size),
@ -491,10 +483,8 @@ where
); );
let (widget_x, widget_y) = (rotate_panel_x + PADDING, rotate_panel_y + PADDING); let (widget_x, widget_y) = (rotate_panel_x + PADDING, rotate_panel_y + PADDING);
let widget_rect = RectI::new( let widget_rect = RectI::new(vec2i(widget_x, widget_y),
Vector2I::new(widget_x, widget_y), vec2i(SLIDER_WIDTH, SLIDER_KNOB_HEIGHT));
Vector2I::new(SLIDER_WIDTH, SLIDER_KNOB_HEIGHT),
);
if let Some(position) = debug_ui_presenter if let Some(position) = debug_ui_presenter
.ui_presenter .ui_presenter
.event_queue .event_queue
@ -506,17 +496,13 @@ where
let slider_track_y = let slider_track_y =
rotate_panel_y + PADDING + SLIDER_KNOB_HEIGHT / 2 - SLIDER_TRACK_HEIGHT / 2; rotate_panel_y + PADDING + SLIDER_KNOB_HEIGHT / 2 - SLIDER_TRACK_HEIGHT / 2;
let slider_track_rect = RectI::new( let slider_track_rect = RectI::new(vec2i(widget_x, slider_track_y),
Vector2I::new(widget_x, slider_track_y), vec2i(SLIDER_WIDTH, SLIDER_TRACK_HEIGHT));
Vector2I::new(SLIDER_WIDTH, SLIDER_TRACK_HEIGHT),
);
debug_ui_presenter.ui_presenter.draw_rect_outline(device, slider_track_rect, TEXT_COLOR); debug_ui_presenter.ui_presenter.draw_rect_outline(device, slider_track_rect, TEXT_COLOR);
let slider_knob_x = widget_x + model.rotation - SLIDER_KNOB_WIDTH / 2; let slider_knob_x = widget_x + model.rotation - SLIDER_KNOB_WIDTH / 2;
let slider_knob_rect = RectI::new( let slider_knob_rect = RectI::new(vec2i(slider_knob_x, widget_y),
Vector2I::new(slider_knob_x, widget_y), vec2i(SLIDER_KNOB_WIDTH, SLIDER_KNOB_HEIGHT));
Vector2I::new(SLIDER_KNOB_WIDTH, SLIDER_KNOB_HEIGHT),
);
debug_ui_presenter.ui_presenter.draw_solid_rect(device, slider_knob_rect, TEXT_COLOR); debug_ui_presenter.ui_presenter.draw_solid_rect(device, slider_knob_rect, TEXT_COLOR);
} }
@ -532,8 +518,8 @@ where
let index = screenshot_type as i32; let index = screenshot_type as i32;
let text = format!("Save as {}...", screenshot_type.as_str()); let text = format!("Save as {}...", screenshot_type.as_str());
let widget_size = Vector2I::new(BACKGROUND_PANEL_WIDTH, BUTTON_HEIGHT); let widget_size = vec2i(BACKGROUND_PANEL_WIDTH, BUTTON_HEIGHT);
let widget_origin = panel_position + Vector2I::new(0, widget_size.y() * index); let widget_origin = panel_position + vec2i(0, widget_size.y() * index);
let widget_rect = RectI::new(widget_origin, widget_size); let widget_rect = RectI::new(widget_origin, widget_size);
if self.draw_menu_item(device, if self.draw_menu_item(device,
@ -561,8 +547,8 @@ where
) { ) {
let (text, index) = (color.as_str(), color as i32); let (text, index) = (color.as_str(), color as i32);
let widget_size = Vector2I::new(BACKGROUND_PANEL_WIDTH, BUTTON_HEIGHT); let widget_size = vec2i(BACKGROUND_PANEL_WIDTH, BUTTON_HEIGHT);
let widget_origin = panel_position + Vector2I::new(0, widget_size.y() * index); let widget_origin = panel_position + vec2i(0, widget_size.y() * index);
let widget_rect = RectI::new(widget_origin, widget_size); let widget_rect = RectI::new(widget_origin, widget_size);
let selected = color == model.background_color; let selected = color == model.background_color;
@ -590,7 +576,7 @@ where
} }
let (text_x, text_y) = (PADDING * 2, BUTTON_TEXT_OFFSET); let (text_x, text_y) = (PADDING * 2, BUTTON_TEXT_OFFSET);
let text_position = widget_rect.origin() + Vector2I::new(text_x, text_y); let text_position = widget_rect.origin() + vec2i(text_x, text_y);
debug_ui_presenter.ui_presenter.draw_text(device, text, text_position, selected); debug_ui_presenter.ui_presenter.draw_text(device, text, text_position, selected);
debug_ui_presenter.ui_presenter debug_ui_presenter.ui_presenter
@ -610,14 +596,12 @@ where
value: &mut bool) { value: &mut bool) {
let text_x = PADDING * 2; let text_x = PADDING * 2;
let text_y = window_y + PADDING + BUTTON_TEXT_OFFSET + (BUTTON_HEIGHT + PADDING) * index; let text_y = window_y + PADDING + BUTTON_TEXT_OFFSET + (BUTTON_HEIGHT + PADDING) * index;
debug_ui_presenter debug_ui_presenter.ui_presenter.draw_text(device, text, vec2i(text_x, text_y), false);
.ui_presenter
.draw_text(device, text, Vector2I::new(text_x, text_y), false);
let switch_width = debug_ui_presenter.ui_presenter.measure_segmented_control(2); let switch_width = debug_ui_presenter.ui_presenter.measure_segmented_control(2);
let switch_x = PADDING + EFFECTS_PANEL_WIDTH - (switch_width + PADDING); let switch_x = PADDING + EFFECTS_PANEL_WIDTH - (switch_width + PADDING);
let switch_y = window_y + PADDING + (BUTTON_HEIGHT + PADDING) * index; let switch_y = window_y + PADDING + (BUTTON_HEIGHT + PADDING) * index;
let switch_position = Vector2I::new(switch_x, switch_y); let switch_position = vec2i(switch_x, switch_y);
let new_value = let new_value =
debug_ui_presenter debug_ui_presenter

13
demo/magicleap/src/lib.rs
View File

@ -29,10 +29,11 @@ use pathfinder_demo::BackgroundColor;
use pathfinder_demo::Mode; use pathfinder_demo::Mode;
use pathfinder_demo::window::Event; use pathfinder_demo::window::Event;
use pathfinder_demo::window::SVGPath; use pathfinder_demo::window::SVGPath;
use pathfinder_geometry::vector::Vector2F;
use pathfinder_geometry::vector::Vector2I;
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::vector::Vector2F;
use pathfinder_geometry::vector::Vector2I;
use pathfinder_geometry::vector::vec2i;
use pathfinder_color::ColorF; use pathfinder_color::ColorF;
use pathfinder_gl::GLDevice; use pathfinder_gl::GLDevice;
use pathfinder_gl::GLVersion; use pathfinder_gl::GLVersion;
@ -191,10 +192,10 @@ pub unsafe extern "C" fn magicleap_pathfinder_render(pf: *mut c_void, options: *
let mut height = 0; let mut height = 0;
egl::query_surface(options.display, options.surface, egl::EGL_WIDTH, &mut width); egl::query_surface(options.display, options.surface, egl::EGL_WIDTH, &mut width);
egl::query_surface(options.display, options.surface, egl::EGL_HEIGHT, &mut height); egl::query_surface(options.display, options.surface, egl::EGL_HEIGHT, &mut height);
let size = Vector2I::new(width, height); let size = vec2i(width, height);
let viewport_origin = Vector2I::new(options.viewport[0] as i32, options.viewport[1] as i32); let viewport_origin = vec2i(options.viewport[0] as i32, options.viewport[1] as i32);
let viewport_size = Vector2I::new(options.viewport[2] as i32, options.viewport[3] as i32); let viewport_size = vec2i(options.viewport[2] as i32, options.viewport[3] as i32);
let viewport = RectI::new(viewport_origin, viewport_size); let viewport = RectI::new(viewport_origin, viewport_size);
let bg_color = ColorF(F32x4::new(options.bg_color[0], options.bg_color[1], options.bg_color[2], options.bg_color[3])); let bg_color = ColorF(F32x4::new(options.bg_color[0], options.bg_color[1], options.bg_color[2], options.bg_color[3]));
@ -222,7 +223,7 @@ pub unsafe extern "C" fn magicleap_pathfinder_render(pf: *mut c_void, options: *
let render_options = RenderOptions { let render_options = RenderOptions {
transform: RenderTransform::Transform2D(transform), transform: RenderTransform::Transform2D(transform),
dilation: Vector2F::default(), dilation: Vector2F::zero(),
subpixel_aa_enabled: false, subpixel_aa_enabled: false,
}; };

9
demo/magicleap/src/magicleap.rs
View File

@ -48,13 +48,14 @@ use pathfinder_demo::window::OcularTransform;
use pathfinder_demo::window::View; use pathfinder_demo::window::View;
use pathfinder_demo::window::Window; use pathfinder_demo::window::Window;
use pathfinder_demo::window::WindowSize; use pathfinder_demo::window::WindowSize;
use pathfinder_geometry::vector::Vector2I;
use pathfinder_geometry::vector::Vector2F;
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::transform3d::Perspective; use pathfinder_geometry::transform3d::Perspective;
use pathfinder_geometry::transform3d::Transform4F; use pathfinder_geometry::transform3d::Transform4F;
use pathfinder_geometry::util; use pathfinder_geometry::util;
use pathfinder_geometry::vector::Vector2I;
use pathfinder_geometry::vector::Vector2F;
use pathfinder_geometry::vector::vec2i;
use pathfinder_gl::GLVersion; use pathfinder_gl::GLVersion;
use pathfinder_resources::ResourceLoader; use pathfinder_resources::ResourceLoader;
use pathfinder_resources::fs::FilesystemResourceLoader; use pathfinder_resources::fs::FilesystemResourceLoader;
@ -117,7 +118,7 @@ impl Window for MagicLeapWindow {
} }
fn viewport(&self, _view: View) -> RectI { fn viewport(&self, _view: View) -> RectI {
RectI::new(Vector2I::default(), self.size) RectI::new(Vector2I::zero(), self.size)
} }
fn make_current(&mut self, view: View) { fn make_current(&mut self, view: View) {
@ -184,7 +185,7 @@ impl MagicLeapWindow {
MagicLeapWindow { MagicLeapWindow {
framebuffer_id, framebuffer_id,
graphics_client, graphics_client,
size: Vector2I::new(max_width, max_height), size: vec2i(max_width, max_height),
frame_handle: ML_HANDLE_INVALID, frame_handle: ML_HANDLE_INVALID,
virtual_camera_array, virtual_camera_array,
initial_camera_transform: None, initial_camera_transform: None,

12
demo/native/src/main.rs
View File

@ -13,8 +13,8 @@
use nfd::Response; use nfd::Response;
use pathfinder_demo::window::{Event, Keycode, SVGPath, View, Window, WindowSize}; use pathfinder_demo::window::{Event, Keycode, SVGPath, View, Window, WindowSize};
use pathfinder_demo::{DemoApp, Options}; use pathfinder_demo::{DemoApp, Options};
use pathfinder_geometry::vector::Vector2I;
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::vector::vec2i;
use pathfinder_resources::ResourceLoader; use pathfinder_resources::ResourceLoader;
use pathfinder_resources::fs::FilesystemResourceLoader; use pathfinder_resources::fs::FilesystemResourceLoader;
use sdl2::event::{Event as SDLEvent, WindowEvent}; use sdl2::event::{Event as SDLEvent, WindowEvent};
@ -125,7 +125,7 @@ impl Window for WindowImpl {
width = width / 2; width = width / 2;
x_offset = width * (index as i32); x_offset = width * (index as i32);
} }
RectI::new(Vector2I::new(x_offset, 0), Vector2I::new(width, height)) RectI::new(vec2i(x_offset, 0), vec2i(width, height))
} }
#[cfg(any(not(target_os = "macos"), feature = "pf-gl"))] #[cfg(any(not(target_os = "macos"), feature = "pf-gl"))]
@ -279,7 +279,7 @@ impl WindowImpl {
let (logical_width, logical_height) = self.window().size(); let (logical_width, logical_height) = self.window().size();
let (drawable_width, _) = self.window().drawable_size(); let (drawable_width, _) = self.window().drawable_size();
WindowSize { WindowSize {
logical_size: Vector2I::new(logical_width as i32, logical_height as i32), logical_size: vec2i(logical_width as i32, logical_height as i32),
backing_scale_factor: drawable_width as f32 / logical_width as f32, backing_scale_factor: drawable_width as f32 / logical_width as f32,
} }
} }
@ -311,11 +311,11 @@ impl WindowImpl {
message_type: type_, message_type: type_,
message_data: code as u32, message_data: code as u32,
}), }),
SDLEvent::MouseButtonDown { x, y, .. } => Some(Event::MouseDown(Vector2I::new(x, y))), SDLEvent::MouseButtonDown { x, y, .. } => Some(Event::MouseDown(vec2i(x, y))),
SDLEvent::MouseMotion { SDLEvent::MouseMotion {
x, y, mousestate, .. x, y, mousestate, ..
} => { } => {
let position = Vector2I::new(x, y); let position = vec2i(x, y);
if mousestate.left() { if mousestate.left() {
Some(Event::MouseDragged(position)) Some(Event::MouseDragged(position))
} else { } else {
@ -337,7 +337,7 @@ impl WindowImpl {
} => self.convert_sdl_keycode(sdl_keycode).map(Event::KeyUp), } => self.convert_sdl_keycode(sdl_keycode).map(Event::KeyUp),
SDLEvent::MultiGesture { d_dist, .. } => { SDLEvent::MultiGesture { d_dist, .. } => {
let mouse_state = self.event_pump.mouse_state(); let mouse_state = self.event_pump.mouse_state();
let center = Vector2I::new(mouse_state.x(), mouse_state.y()); let center = vec2i(mouse_state.x(), mouse_state.y());
Some(Event::Zoom(d_dist, center)) Some(Event::Zoom(d_dist, center))
} }
_ => None, _ => None,

14
examples/canvas_glutin_minimal/src/main.rs
View File

@ -18,7 +18,7 @@ use glutin::window::WindowBuilder;
use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, Path2D}; use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, Path2D};
use pathfinder_color::ColorF; use pathfinder_color::ColorF;
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2f, vec2i};
use pathfinder_gl::{GLDevice, GLVersion}; use pathfinder_gl::{GLDevice, GLVersion};
use pathfinder_resources::fs::FilesystemResourceLoader; use pathfinder_resources::fs::FilesystemResourceLoader;
use pathfinder_renderer::concurrent::rayon::RayonExecutor; use pathfinder_renderer::concurrent::rayon::RayonExecutor;
@ -30,7 +30,7 @@ use pathfinder_renderer::options::BuildOptions;
fn main() { fn main() {
// Calculate the right logical size of the window. // Calculate the right logical size of the window.
let event_loop = EventLoop::new(); let event_loop = EventLoop::new();
let window_size = Vector2I::new(640, 480); let window_size = vec2i(640, 480);
let physical_window_size = PhysicalSize::new(window_size.x() as f64, window_size.y() as f64); let physical_window_size = PhysicalSize::new(window_size.x() as f64, window_size.y() as f64);
// Open a window. // Open a window.
@ -61,16 +61,16 @@ fn main() {
canvas.set_line_width(10.0); canvas.set_line_width(10.0);
// Draw walls. // Draw walls.
canvas.stroke_rect(RectF::new(Vector2F::new(75.0, 140.0), Vector2F::new(150.0, 110.0))); canvas.stroke_rect(RectF::new(vec2f(75.0, 140.0), vec2f(150.0, 110.0)));
// Draw door. // Draw door.
canvas.fill_rect(RectF::new(Vector2F::new(130.0, 190.0), Vector2F::new(40.0, 60.0))); canvas.fill_rect(RectF::new(vec2f(130.0, 190.0), vec2f(40.0, 60.0)));
// Draw roof. // Draw roof.
let mut path = Path2D::new(); let mut path = Path2D::new();
path.move_to(Vector2F::new(50.0, 140.0)); path.move_to(vec2f(50.0, 140.0));
path.line_to(Vector2F::new(150.0, 60.0)); path.line_to(vec2f(150.0, 60.0));
path.line_to(Vector2F::new(250.0, 140.0)); path.line_to(vec2f(250.0, 140.0));
path.close_path(); path.close_path();
canvas.stroke_path(path); canvas.stroke_path(path);

14
examples/canvas_metal_minimal/src/main.rs
View File

@ -12,7 +12,7 @@ use foreign_types::ForeignTypeRef;
use metal::{CAMetalLayer, CoreAnimationLayerRef}; use metal::{CAMetalLayer, CoreAnimationLayerRef};
use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, Path2D}; use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, Path2D};
use pathfinder_color::ColorF; use pathfinder_color::ColorF;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2f, vec2i};
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_metal::MetalDevice; use pathfinder_metal::MetalDevice;
use pathfinder_renderer::concurrent::rayon::RayonExecutor; use pathfinder_renderer::concurrent::rayon::RayonExecutor;
@ -33,7 +33,7 @@ fn main() {
let video = sdl_context.video().unwrap(); let video = sdl_context.video().unwrap();
// Open a window. // Open a window.
let window_size = Vector2I::new(640, 480); let window_size = vec2i(640, 480);
let window = video.window("Minimal example", window_size.x() as u32, window_size.y() as u32) let window = video.window("Minimal example", window_size.x() as u32, window_size.y() as u32)
.opengl() .opengl()
.build() .build()
@ -59,16 +59,16 @@ fn main() {
canvas.set_line_width(10.0); canvas.set_line_width(10.0);
// Draw walls. // Draw walls.
canvas.stroke_rect(RectF::new(Vector2F::new(75.0, 140.0), Vector2F::new(150.0, 110.0))); canvas.stroke_rect(RectF::new(vec2f(75.0, 140.0), vec2f(150.0, 110.0)));
// Draw door. // Draw door.
canvas.fill_rect(RectF::new(Vector2F::new(130.0, 190.0), Vector2F::new(40.0, 60.0))); canvas.fill_rect(RectF::new(vec2f(130.0, 190.0), vec2f(40.0, 60.0)));
// Draw roof. // Draw roof.
let mut path = Path2D::new(); let mut path = Path2D::new();
path.move_to(Vector2F::new(50.0, 140.0)); path.move_to(vec2f(50.0, 140.0));
path.line_to(Vector2F::new(150.0, 60.0)); path.line_to(vec2f(150.0, 60.0));
path.line_to(Vector2F::new(250.0, 140.0)); path.line_to(vec2f(250.0, 140.0));
path.close_path(); path.close_path();
canvas.stroke_path(path); canvas.stroke_path(path);

14
examples/canvas_minimal/src/main.rs
View File

@ -11,7 +11,7 @@
use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, Path2D}; use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, Path2D};
use pathfinder_color::ColorF; use pathfinder_color::ColorF;
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2i};
use pathfinder_gl::{GLDevice, GLVersion}; use pathfinder_gl::{GLDevice, GLVersion};
use pathfinder_renderer::concurrent::rayon::RayonExecutor; use pathfinder_renderer::concurrent::rayon::RayonExecutor;
use pathfinder_renderer::concurrent::scene_proxy::SceneProxy; use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
@ -34,7 +34,7 @@ fn main() {
gl_attributes.set_context_version(3, 3); gl_attributes.set_context_version(3, 3);
// Open a window. // Open a window.
let window_size = Vector2I::new(640, 480); let window_size = vec2i(640, 480);
let window = video.window("Minimal example", window_size.x() as u32, window_size.y() as u32) let window = video.window("Minimal example", window_size.x() as u32, window_size.y() as u32)
.opengl() .opengl()
.build() .build()
@ -59,16 +59,16 @@ fn main() {
canvas.set_line_width(10.0); canvas.set_line_width(10.0);
// Draw walls. // Draw walls.
canvas.stroke_rect(RectF::new(Vector2F::new(75.0, 140.0), Vector2F::new(150.0, 110.0))); canvas.stroke_rect(RectF::new(vec2f(75.0, 140.0), vec2f(150.0, 110.0)));
// Draw door. // Draw door.
canvas.fill_rect(RectF::new(Vector2F::new(130.0, 190.0), Vector2F::new(40.0, 60.0))); canvas.fill_rect(RectF::new(vec2f(130.0, 190.0), vec2f(40.0, 60.0)));
// Draw roof. // Draw roof.
let mut path = Path2D::new(); let mut path = Path2D::new();
path.move_to(Vector2F::new(50.0, 140.0)); path.move_to(vec2f(50.0, 140.0));
path.line_to(Vector2F::new(150.0, 60.0)); path.line_to(vec2f(150.0, 60.0));
path.line_to(Vector2F::new(250.0, 140.0)); path.line_to(vec2f(250.0, 140.0));
path.close_path(); path.close_path();
canvas.stroke_path(path); canvas.stroke_path(path);

11
examples/canvas_moire/src/main.rs
View File

@ -10,7 +10,7 @@
use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, FillStyle, Path2D}; use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, FillStyle, Path2D};
use pathfinder_color::{ColorF, ColorU}; use pathfinder_color::{ColorF, ColorU};
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2i};
use pathfinder_gl::{GLDevice, GLVersion}; use pathfinder_gl::{GLDevice, GLVersion};
use pathfinder_renderer::concurrent::rayon::RayonExecutor; use pathfinder_renderer::concurrent::rayon::RayonExecutor;
use pathfinder_renderer::concurrent::scene_proxy::SceneProxy; use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
@ -47,7 +47,7 @@ fn main() {
gl_attributes.set_context_version(3, 3); gl_attributes.set_context_version(3, 3);
// Open a window. // Open a window.
let window_size = Vector2I::new(1067, 800); let window_size = vec2i(1067, 800);
let window = video.window("Moire example", window_size.x() as u32, window_size.y() as u32) let window = video.window("Moire example", window_size.x() as u32, window_size.y() as u32)
.opengl() .opengl()
.allow_highdpi() .allow_highdpi()
@ -57,7 +57,7 @@ fn main() {
// Get the real window size (for HiDPI). // Get the real window size (for HiDPI).
let (drawable_width, drawable_height) = window.drawable_size(); let (drawable_width, drawable_height) = window.drawable_size();
let drawable_size = Vector2I::new(drawable_width as i32, drawable_height as i32); let drawable_size = vec2i(drawable_width as i32, drawable_height as i32);
// Create the GL context, and make it current. // Create the GL context, and make it current.
let gl_context = window.gl_create_context().unwrap(); let gl_context = window.gl_create_context().unwrap();
@ -120,9 +120,8 @@ impl MoireRenderer {
// Calculate outer and inner circle centers (circle and Leminscate of Gerono respectively). // Calculate outer and inner circle centers (circle and Leminscate of Gerono respectively).
let window_center = self.window_size.to_f32().scale(0.5); let window_center = self.window_size.to_f32().scale(0.5);
let outer_center = window_center + Vector2F::new(sin_time, cos_time).scale(OUTER_RADIUS); let outer_center = window_center + vec2f(sin_time, cos_time).scale(OUTER_RADIUS);
let inner_center = window_center + let inner_center = window_center + vec2f(1.0, sin_time).scale(cos_time * INNER_RADIUS);
Vector2F::new(1.0, sin_time).scale(cos_time * INNER_RADIUS);
// Clear to background color. // Clear to background color.
self.renderer.set_options(RendererOptions { background_color: Some(background_color) }); self.renderer.set_options(RendererOptions { background_color: Some(background_color) });

391
examples/canvas_nanovg/src/main.rs
View File

@ -23,7 +23,7 @@ use pathfinder_geometry::line_segment::LineSegment2F;
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::util; use pathfinder_geometry::util;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, vec2f, vec2i};
use pathfinder_gl::{GLDevice, GLVersion}; use pathfinder_gl::{GLDevice, GLVersion};
use pathfinder_renderer::concurrent::rayon::RayonExecutor; use pathfinder_renderer::concurrent::rayon::RayonExecutor;
use pathfinder_renderer::concurrent::scene_proxy::SceneProxy; use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
@ -42,6 +42,7 @@ use std::time::Instant;
// TODO(pcwalton): See if we can reduce the amount of code by using the canvas shadow feature. // TODO(pcwalton): See if we can reduce the amount of code by using the canvas shadow feature.
const PI_2: f32 = PI * 2.0; const PI_2: f32 = PI * 2.0;
const FRAC_PI_2_3: f32 = PI * 2.0 / 3.0;
static PARAGRAPH_TEXT: &'static str = "This is a longer chunk of text. static PARAGRAPH_TEXT: &'static str = "This is a longer chunk of text.
@ -54,76 +55,67 @@ fn render_demo(canvas: &mut CanvasRenderingContext2D,
time: f32, time: f32,
data: &DemoData) { data: &DemoData) {
draw_eyes(canvas, draw_eyes(canvas,
RectF::new(Vector2F::new(window_size.x() - 250.0, 50.0), RectF::new(vec2f(window_size.x() - 250.0, 50.0), vec2f(150.0, 100.0)),
Vector2F::new(150.0, 100.0)),
mouse_position, mouse_position,
time); time);
draw_paragraph(canvas, draw_paragraph(canvas, RectF::new(vec2f(window_size.x() - 450.0, 50.0), vec2f(150.0, 100.0)));
RectF::new(Vector2F::new(window_size.x() - 450.0, 50.0),
Vector2F::new(150.0, 100.0)));
draw_graph(canvas, draw_graph(canvas,
RectF::new(window_size.scale_xy(Vector2F::new(0.0, 0.5)), RectF::new(window_size.scale_xy(vec2f(0.0, 0.5)),
window_size.scale_xy(Vector2F::new(1.0, 0.5))), window_size.scale_xy(vec2f(1.0, 0.5))),
time); time);
draw_color_wheel(canvas, draw_color_wheel(canvas,
RectF::new(window_size - Vector2F::splat(300.0), Vector2F::splat(250.0)), RectF::new(window_size - vec2f(300.0, 300.0), vec2f(250.0, 250.0)),
time); time);
draw_lines(canvas, draw_lines(canvas, RectF::new(vec2f(120.0, window_size.y() - 50.0), vec2f(600.0, 50.0)), time);
RectF::new(Vector2F::new(120.0, window_size.y() - 50.0), draw_caps(canvas, RectF::new(vec2f(10.0, 300.0), vec2f(30.0, 40.0)));
Vector2F::new(600.0, 50.0)), draw_clip(canvas, vec2f(50.0, window_size.y() - 80.0), time);
time);
draw_caps(canvas, RectF::new(Vector2F::new(10.0, 300.0), Vector2F::new(30.0, 40.0)));
draw_clip(canvas, Vector2F::new(50.0, window_size.y() - 80.0), time);
canvas.save(); canvas.save();
// Draw widgets. // Draw widgets.
draw_window(canvas, draw_window(canvas, "Widgets & Stuff", RectF::new(vec2f(50.0, 50.0), vec2f(300.0, 400.0)));
"Widgets & Stuff", let mut position = vec2f(60.0, 95.0);
RectF::new(Vector2F::splat(50.0), Vector2F::new(300.0, 400.0))); draw_search_box(canvas, "Search", RectF::new(position, vec2f(280.0, 25.0)));
let mut position = Vector2F::new(60.0, 95.0); position += vec2f(0.0, 40.0);
draw_search_box(canvas, "Search", RectF::new(position, Vector2F::new(280.0, 25.0))); draw_dropdown(canvas, "Effects", RectF::new(position, vec2f(280.0, 28.0)));
position += Vector2F::new(0.0, 40.0); let popup_position = position + vec2f(0.0, 14.0);
draw_dropdown(canvas, "Effects", RectF::new(position, Vector2F::new(280.0, 28.0))); position += vec2f(0.0, 45.0);
let popup_position = position + Vector2F::new(0.0, 14.0);
position += Vector2F::new(0.0, 45.0);
// Draw login form. // Draw login form.
draw_label(canvas, "Login", RectF::new(position, Vector2F::new(280.0, 20.0))); draw_label(canvas, "Login", RectF::new(position, vec2f(280.0, 20.0)));
position += Vector2F::new(0.0, 25.0); position += vec2f(0.0, 25.0);
draw_text_edit_box(canvas, "E-mail address", RectF::new(position, Vector2F::new(280.0, 28.0))); draw_text_edit_box(canvas, "E-mail address", RectF::new(position, vec2f(280.0, 28.0)));
position += Vector2F::new(0.0, 35.0); position += vec2f(0.0, 35.0);
draw_text_edit_box(canvas, "Password", RectF::new(position, Vector2F::new(280.0, 28.0))); draw_text_edit_box(canvas, "Password", RectF::new(position, vec2f(280.0, 28.0)));
position += Vector2F::new(0.0, 38.0); position += vec2f(0.0, 38.0);
draw_check_box(canvas, "Remember me", RectF::new(position, Vector2F::new(140.0, 28.0))); draw_check_box(canvas, "Remember me", RectF::new(position, vec2f(140.0, 28.0)));
draw_button(canvas, draw_button(canvas,
"Sign In", "Sign In",
RectF::new(position + Vector2F::new(138.0, 0.0), Vector2F::new(140.0, 28.0)), RectF::new(position + vec2f(138.0, 0.0), vec2f(140.0, 28.0)),
ColorU::new(0, 96, 128, 255)); ColorU::new(0, 96, 128, 255));
position += Vector2F::new(0.0, 45.0); position += vec2f(0.0, 45.0);
// Draw slider form. // Draw slider form.
draw_label(canvas, "Diameter", RectF::new(position, Vector2F::new(280.0, 20.0))); draw_label(canvas, "Diameter", RectF::new(position, vec2f(280.0, 20.0)));
position += Vector2F::new(0.0, 25.0); position += vec2f(0.0, 25.0);
draw_numeric_edit_box(canvas, "123.00", "px", RectF::new(position + Vector2F::new(180.0, 0.0), draw_numeric_edit_box(canvas, "123.00", "px", RectF::new(position + vec2f(180.0, 0.0),
Vector2F::new(100.0, 28.0))); vec2f(100.0, 28.0)));
draw_slider(canvas, 0.4, RectF::new(position, Vector2F::new(170.0, 28.0))); draw_slider(canvas, 0.4, RectF::new(position, vec2f(170.0, 28.0)));
position += Vector2F::new(0.0, 55.0); position += vec2f(0.0, 55.0);
// Draw dialog box buttons. // Draw dialog box buttons.
draw_button(canvas, draw_button(canvas,
"Delete", "Delete",
RectF::new(position, Vector2F::new(160.0, 28.0)), RectF::new(position, vec2f(160.0, 28.0)),
ColorU::new(128, 16, 8, 255)); ColorU::new(128, 16, 8, 255));
draw_button(canvas, draw_button(canvas,
"Cancel", "Cancel",
RectF::new(position + Vector2F::new(170.0, 0.0), Vector2F::new(110.0, 28.0)), RectF::new(position + vec2f(170.0, 0.0), vec2f(110.0, 28.0)),
ColorU::transparent_black()); ColorU::transparent_black());
// Draw thumbnails. // Draw thumbnails.
draw_thumbnails(canvas, draw_thumbnails(canvas,
RectF::new(Vector2F::new(365.0, popup_position.y() - 30.0), RectF::new(vec2f(365.0, popup_position.y() - 30.0), vec2f(160.0, 300.0)),
Vector2F::new(160.0, 300.0)),
time, time,
12, 12,
&data.image); &data.image);
@ -135,29 +127,26 @@ fn draw_eyes(canvas: &mut CanvasRenderingContext2D,
rect: RectF, rect: RectF,
mouse_position: Vector2F, mouse_position: Vector2F,
time: f32) { time: f32) {
let eyes_radii = rect.size().scale_xy(Vector2F::new(0.23, 0.5)); let eyes_radii = rect.size().scale_xy(vec2f(0.23, 0.5));
let eyes_left_position = rect.origin() + eyes_radii; let eyes_left_position = rect.origin() + eyes_radii;
let eyes_right_position = rect.origin() + Vector2F::new(rect.width() - eyes_radii.x(), let eyes_right_position = rect.origin() + vec2f(rect.width() - eyes_radii.x(), eyes_radii.y());
eyes_radii.y());
let eyes_center = f32::min(eyes_radii.x(), eyes_radii.y()) * 0.5; let eyes_center = f32::min(eyes_radii.x(), eyes_radii.y()) * 0.5;
let blink = 1.0 - f32::powf(f32::sin(time * 0.5), 200.0) * 0.8; let blink = 1.0 - f32::powf(f32::sin(time * 0.5), 200.0) * 0.8;
let mut gradient = let mut gradient = Gradient::linear(
Gradient::linear(LineSegment2F::new(Vector2F::new(0.0, rect.height() * 0.5), LineSegment2F::new(vec2f(0.0, rect.height() * 0.5),
rect.size().scale_xy(Vector2F::new(0.1, 1.0))) + rect.size().scale_xy(vec2f(0.1, 1.0))) + rect.origin());
rect.origin());
gradient.add_color_stop(ColorU::new(0, 0, 0, 32), 0.0); gradient.add_color_stop(ColorU::new(0, 0, 0, 32), 0.0);
gradient.add_color_stop(ColorU::new(0, 0, 0, 16), 1.0); gradient.add_color_stop(ColorU::new(0, 0, 0, 16), 1.0);
let mut path = Path2D::new(); let mut path = Path2D::new();
path.ellipse(eyes_left_position + Vector2F::new(3.0, 16.0), eyes_radii, 0.0, 0.0, PI_2); path.ellipse(eyes_left_position + vec2f(3.0, 16.0), eyes_radii, 0.0, 0.0, PI_2);
path.ellipse(eyes_right_position + Vector2F::new(3.0, 16.0), eyes_radii, 0.0, 0.0, PI_2); path.ellipse(eyes_right_position + vec2f(3.0, 16.0), eyes_radii, 0.0, 0.0, PI_2);
canvas.set_fill_style(gradient); canvas.set_fill_style(gradient);
canvas.fill_path(path, FillRule::Winding); canvas.fill_path(path, FillRule::Winding);
let mut gradient = let mut gradient = Gradient::linear(
Gradient::linear(LineSegment2F::new(Vector2F::new(0.0, rect.height() * 0.25), LineSegment2F::new(vec2f(0.0, rect.height() * 0.25),
rect.size().scale_xy(Vector2F::new(0.1, 1.0))) + rect.size().scale_xy(vec2f(0.1, 1.0))) + rect.origin());
rect.origin());
gradient.add_color_stop(ColorU::new(220, 220, 220, 255), 0.0); gradient.add_color_stop(ColorU::new(220, 220, 220, 255), 0.0);
gradient.add_color_stop(ColorU::new(128, 128, 128, 255), 1.0); gradient.add_color_stop(ColorU::new(128, 128, 128, 255), 1.0);
let mut path = Path2D::new(); let mut path = Path2D::new();
@ -171,26 +160,22 @@ fn draw_eyes(canvas: &mut CanvasRenderingContext2D,
if distance > 1.0 { if distance > 1.0 {
delta = delta.scale(1.0 / distance); delta = delta.scale(1.0 / distance);
} }
delta = delta.scale_xy(eyes_radii).scale_xy(Vector2F::new(0.4, 0.5)); delta = delta.scale_xy(eyes_radii).scale_xy(vec2f(0.4, 0.5));
let mut path = Path2D::new(); let mut path = Path2D::new();
path.ellipse(eyes_left_position + path.ellipse(eyes_left_position + delta + vec2f(0.0, eyes_radii.y() * 0.25 * (1.0 - blink)),
delta + vec2f(eyes_center, eyes_center * blink),
Vector2F::new(0.0, eyes_radii.y() * 0.25 * (1.0 - blink)),
Vector2F::new(eyes_center, eyes_center * blink),
0.0, 0.0,
0.0, 0.0,
PI_2); PI_2);
path.ellipse(eyes_right_position + path.ellipse(eyes_right_position + delta + vec2f(0.0, eyes_radii.y() * 0.25 * (1.0 - blink)),
delta + vec2f(eyes_center, eyes_center * blink),
Vector2F::new(0.0, eyes_radii.y() * 0.25 * (1.0 - blink)),
Vector2F::new(eyes_center, eyes_center * blink),
0.0, 0.0,
0.0, 0.0,
PI_2); PI_2);
canvas.set_fill_style(ColorU::new(32, 32, 32, 255)); canvas.set_fill_style(ColorU::new(32, 32, 32, 255));
canvas.fill_path(path, FillRule::Winding); canvas.fill_path(path, FillRule::Winding);
let gloss_position = eyes_left_position - eyes_radii.scale_xy(Vector2F::new(0.25, 0.5)); let gloss_position = eyes_left_position - eyes_radii.scale_xy(vec2f(0.25, 0.5));
let gloss_radii = F32x2::new(0.1, 0.75) * F32x2::splat(eyes_radii.x()); let gloss_radii = F32x2::new(0.1, 0.75) * F32x2::splat(eyes_radii.x());
let mut gloss = Gradient::radial(gloss_position, gloss_radii); let mut gloss = Gradient::radial(gloss_position, gloss_radii);
gloss.add_color_stop(ColorU::new(255, 255, 255, 128), 0.0); gloss.add_color_stop(ColorU::new(255, 255, 255, 128), 0.0);
@ -200,7 +185,7 @@ fn draw_eyes(canvas: &mut CanvasRenderingContext2D,
path.ellipse(eyes_left_position, eyes_radii, 0.0, 0.0, PI_2); path.ellipse(eyes_left_position, eyes_radii, 0.0, 0.0, PI_2);
canvas.fill_path(path, FillRule::Winding); canvas.fill_path(path, FillRule::Winding);
let gloss_position = eyes_right_position - eyes_radii.scale_xy(Vector2F::new(0.25, 0.5)); let gloss_position = eyes_right_position - eyes_radii.scale_xy(vec2f(0.25, 0.5));
let mut gloss = Gradient::radial(gloss_position, gloss_radii); let mut gloss = Gradient::radial(gloss_position, gloss_radii);
gloss.add_color_stop(ColorU::new(255, 255, 255, 128), 0.0); gloss.add_color_stop(ColorU::new(255, 255, 255, 128), 0.0);
gloss.add_color_stop(ColorU::new(255, 255, 255, 0), 1.0); gloss.add_color_stop(ColorU::new(255, 255, 255, 0), 1.0);
@ -236,13 +221,13 @@ fn draw_paragraph(canvas: &mut CanvasRenderingContext2D, rect: RectF) {
if cursor.x() + space_width + word_width > rect.max_x() { if cursor.x() + space_width + word_width > rect.max_x() {
next_line(canvas, &mut cursor, rect); next_line(canvas, &mut cursor, rect);
} else if cursor.x() > rect.min_x() { } else if cursor.x() > rect.min_x() {
cursor = cursor + Vector2F::new(space_width, 0.0); cursor = cursor + vec2f(space_width, 0.0);
} }
canvas.set_fill_style(ColorU::white()); canvas.set_fill_style(ColorU::white());
canvas.fill_text(word, cursor); canvas.fill_text(word, cursor);
cursor = cursor + Vector2F::new(word_width, 0.0); cursor = cursor + vec2f(word_width, 0.0);
} }
} }
@ -252,9 +237,9 @@ fn draw_paragraph(canvas: &mut CanvasRenderingContext2D, rect: RectF) {
cursor.set_x(rect.min_x()); cursor.set_x(rect.min_x());
canvas.set_fill_style(ColorU::new(255, 255, 255, 16)); canvas.set_fill_style(ColorU::new(255, 255, 255, 16));
canvas.fill_rect(RectF::new(*cursor, Vector2F::new(rect.width(), LINE_HEIGHT))); canvas.fill_rect(RectF::new(*cursor, vec2f(rect.width(), LINE_HEIGHT)));
*cursor = *cursor + Vector2F::new(0.0, LINE_HEIGHT); *cursor += vec2f(0.0, LINE_HEIGHT);
} }
} }
@ -270,21 +255,20 @@ fn draw_graph(canvas: &mut CanvasRenderingContext2D, rect: RectF, time: f32) {
(1.0 + f32::sin(time * 0.345 + f32::cos(time * 0.03) * 0.6)) * 0.5, (1.0 + f32::sin(time * 0.345 + f32::cos(time * 0.03) * 0.6)) * 0.5,
]; ];
let sample_scale = Vector2F::new(sample_spread, rect.height() * 0.8); let sample_scale = vec2f(sample_spread, rect.height() * 0.8);
let sample_points: ArrayVec<[Vector2F; 6]> = samples.iter() let sample_points: ArrayVec<[Vector2F; 6]> = samples.iter()
.enumerate() .enumerate()
.map(|(index, &sample)| { .map(|(index, &sample)| {
rect.origin() + Vector2F::new(index as f32, sample).scale_xy(sample_scale) rect.origin() + vec2f(index as f32, sample).scale_xy(sample_scale)
}).collect(); }).collect();
// Draw graph background. // Draw graph background.
let mut background = Gradient::linear(LineSegment2F::new(Vector2F::default(), let mut background = Gradient::linear(
Vector2F::new(0.0, rect.height())) + LineSegment2F::new(vec2f(0.0, 0.0), vec2f(0.0, rect.height())) + rect.origin());
rect.origin());
background.add_color_stop(ColorU::new(0, 160, 192, 0), 0.0); background.add_color_stop(ColorU::new(0, 160, 192, 0), 0.0);
background.add_color_stop(ColorU::new(0, 160, 192, 64), 1.0); background.add_color_stop(ColorU::new(0, 160, 192, 64), 1.0);
canvas.set_fill_style(background); canvas.set_fill_style(background);
let mut path = create_graph_path(&sample_points, sample_spread, Vector2F::default()); let mut path = create_graph_path(&sample_points, sample_spread, Vector2F::zero());
path.line_to(rect.lower_right()); path.line_to(rect.lower_right());
path.line_to(rect.lower_left()); path.line_to(rect.lower_left());
canvas.fill_path(path, FillRule::Winding); canvas.fill_path(path, FillRule::Winding);
@ -292,37 +276,36 @@ fn draw_graph(canvas: &mut CanvasRenderingContext2D, rect: RectF, time: f32) {
// Draw graph line shadow. // Draw graph line shadow.
canvas.set_stroke_style(ColorU::new(0, 0, 0, 32)); canvas.set_stroke_style(ColorU::new(0, 0, 0, 32));
canvas.set_line_width(3.0); canvas.set_line_width(3.0);
let path = create_graph_path(&sample_points, sample_spread, Vector2F::new(0.0, 2.0)); let path = create_graph_path(&sample_points, sample_spread, vec2f(0.0, 2.0));
canvas.stroke_path(path); canvas.stroke_path(path);
// Draw graph line. // Draw graph line.
canvas.set_stroke_style(ColorU::new(0, 160, 192, 255)); canvas.set_stroke_style(ColorU::new(0, 160, 192, 255));
canvas.set_line_width(3.0); canvas.set_line_width(3.0);
let path = create_graph_path(&sample_points, sample_spread, Vector2F::default()); let path = create_graph_path(&sample_points, sample_spread, Vector2F::zero());
canvas.stroke_path(path); canvas.stroke_path(path);
// Draw sample position highlights. // Draw sample position highlights.
for &sample_point in &sample_points { for &sample_point in &sample_points {
let gradient_center = sample_point + Vector2F::new(0.0, 2.0); let gradient_center = sample_point + vec2f(0.0, 2.0);
let mut background = Gradient::radial(gradient_center, F32x2::new(3.0, 8.0)); let mut background = Gradient::radial(gradient_center, F32x2::new(3.0, 8.0));
background.add_color_stop(ColorU::new(0, 0, 0, 32), 0.0); background.add_color_stop(ColorU::new(0, 0, 0, 32), 0.0);
background.add_color_stop(ColorU::transparent_black(), 1.0); background.add_color_stop(ColorU::transparent_black(), 1.0);
canvas.set_fill_style(background); canvas.set_fill_style(background);
canvas.fill_rect(RectF::new(sample_point + Vector2F::new(-10.0, -10.0 + 2.0), canvas.fill_rect(RectF::new(sample_point + vec2f(-10.0, -10.0 + 2.0), vec2f(20.0, 20.0)));
Vector2F::splat(20.0)));
} }
// Draw sample positions. // Draw sample positions.
canvas.set_fill_style(ColorU::new(0, 160, 192, 255)); canvas.set_fill_style(ColorU::new(0, 160, 192, 255));
let mut path = Path2D::new(); let mut path = Path2D::new();
for &sample_point in &sample_points { for &sample_point in &sample_points {
path.ellipse(sample_point, Vector2F::splat(4.0), 0.0, 0.0, PI_2); path.ellipse(sample_point, vec2f(4.0, 4.0), 0.0, 0.0, PI_2);
} }
canvas.fill_path(path, FillRule::Winding); canvas.fill_path(path, FillRule::Winding);
canvas.set_fill_style(ColorU::new(220, 220, 220, 255)); canvas.set_fill_style(ColorU::new(220, 220, 220, 255));
let mut path = Path2D::new(); let mut path = Path2D::new();
for &sample_point in &sample_points { for &sample_point in &sample_points {
path.ellipse(sample_point, Vector2F::splat(2.0), 0.0, 0.0, PI_2); path.ellipse(sample_point, vec2f(2.0, 2.0), 0.0, 0.0, PI_2);
} }
canvas.fill_path(path, FillRule::Winding); canvas.fill_path(path, FillRule::Winding);
@ -346,8 +329,8 @@ fn draw_color_wheel(canvas: &mut CanvasRenderingContext2D, rect: RectF, time: f3
for segment in 0..6 { for segment in 0..6 {
let start_angle = segment as f32 / 6.0 * PI_2 - half_arc_len; let start_angle = segment as f32 / 6.0 * PI_2 - half_arc_len;
let end_angle = (segment + 1) as f32 / 6.0 * PI_2 + half_arc_len; let end_angle = (segment + 1) as f32 / 6.0 * PI_2 + half_arc_len;
let line = LineSegment2F::new(Vector2F::new(f32::cos(start_angle), f32::sin(start_angle)), let line = LineSegment2F::new(vec2f(f32::cos(start_angle), f32::sin(start_angle)),
Vector2F::new(f32::cos(end_angle), f32::sin(end_angle))); vec2f(f32::cos(end_angle), f32::sin(end_angle)));
let scale = util::lerp(inner_radius, outer_radius, 0.5); let scale = util::lerp(inner_radius, outer_radius, 0.5);
let mut gradient = Gradient::linear(line.scale(scale) + center); let mut gradient = Gradient::linear(line.scale(scale) + center);
let start_color = ColorF::from_hsl(start_angle, 1.0, 0.55).to_u8(); let start_color = ColorF::from_hsl(start_angle, 1.0, 0.55).to_u8();
@ -377,20 +360,18 @@ fn draw_color_wheel(canvas: &mut CanvasRenderingContext2D, rect: RectF, time: f3
canvas.set_stroke_style(ColorU::new(255, 255, 255, 192)); canvas.set_stroke_style(ColorU::new(255, 255, 255, 192));
canvas.set_line_width(2.0); canvas.set_line_width(2.0);
canvas.stroke_rect(RectF::new(Vector2F::new(inner_radius - 1.0, -3.0), canvas.stroke_rect(RectF::new(vec2f(inner_radius - 1.0, -3.0),
Vector2F::new(outer_radius - inner_radius + 2.0, 6.0))); vec2f(outer_radius - inner_radius + 2.0, 6.0)));
// TODO(pcwalton): Marker fill with box gradient // TODO(pcwalton): Marker fill with box gradient
// Draw center triangle. // Draw center triangle.
let triangle_radius = inner_radius - 6.0; let triangle_radius = inner_radius - 6.0;
let triangle_vertex_a = Vector2F::new(triangle_radius, 0.0); let triangle_vertex_a = vec2f(triangle_radius, 0.0);
let triangle_vertex_b = Vector2F::new(f32::cos(PI * 2.0 / 3.0), let triangle_vertex_b = vec2f(FRAC_PI_2_3.cos(), FRAC_PI_2_3.sin()).scale(triangle_radius);
f32::sin(PI * 2.0 / 3.0)).scale(triangle_radius); let triangle_vertex_c = vec2f((-FRAC_PI_2_3).cos(),
let triangle_vertex_c = Vector2F::new(f32::cos(PI * -2.0 / 3.0), (-FRAC_PI_2_3).sin()).scale(triangle_radius);
f32::sin(PI * -2.0 / 3.0)).scale(triangle_radius); let mut gradient_0 = Gradient::linear_from_points(triangle_vertex_a, triangle_vertex_b);
let mut gradient_0 = Gradient::linear(LineSegment2F::new(triangle_vertex_a,
triangle_vertex_b));
gradient_0.add_color_stop(ColorF::from_hsl(hue, 1.0, 0.5).to_u8(), 0.0); gradient_0.add_color_stop(ColorF::from_hsl(hue, 1.0, 0.5).to_u8(), 0.0);
gradient_0.add_color_stop(ColorU::white(), 1.0); gradient_0.add_color_stop(ColorU::white(), 1.0);
let mut gradient_1 = let mut gradient_1 =
@ -412,25 +393,22 @@ fn draw_color_wheel(canvas: &mut CanvasRenderingContext2D, rect: RectF, time: f3
// Stroke the selection circle on the triangle. // Stroke the selection circle on the triangle.
let selection_circle_center = let selection_circle_center =
Vector2F::new(f32::cos(PI_2 / 3.0), vec2f(FRAC_PI_2_3.cos(), FRAC_PI_2_3.sin()).scale(triangle_radius)
f32::sin(PI_2 / 3.0)).scale(triangle_radius) .scale_xy(vec2f(0.3, 0.4));
.scale_xy(Vector2F::new(0.3, 0.4));
canvas.set_stroke_style(ColorU::new(255, 255, 255, 192)); canvas.set_stroke_style(ColorU::new(255, 255, 255, 192));
canvas.set_line_width(2.0); canvas.set_line_width(2.0);
let mut path = Path2D::new(); let mut path = Path2D::new();
path.ellipse(selection_circle_center, Vector2F::splat(5.0), 0.0, 0.0, PI_2); path.ellipse(selection_circle_center, vec2f(5.0, 5.0), 0.0, 0.0, PI_2);
canvas.stroke_path(path); canvas.stroke_path(path);
// Fill the selection circle. // Fill the selection circle.
let mut gradient = Gradient::radial(LineSegment2F::new(selection_circle_center, let mut gradient = Gradient::radial(selection_circle_center, F32x2::new(7.0, 9.0));
selection_circle_center),
F32x2::new(7.0, 9.0));
gradient.add_color_stop(ColorU::new(0, 0, 0, 64), 0.0); gradient.add_color_stop(ColorU::new(0, 0, 0, 64), 0.0);
gradient.add_color_stop(ColorU::transparent_black(), 1.0); gradient.add_color_stop(ColorU::transparent_black(), 1.0);
canvas.set_fill_style(gradient); canvas.set_fill_style(gradient);
let mut path = Path2D::new(); let mut path = Path2D::new();
path.rect(RectF::new(selection_circle_center - Vector2F::splat(20.0), Vector2F::splat(40.0))); path.rect(RectF::new(selection_circle_center - vec2f(20.0, 20.0), vec2f(40.0, 40.0)));
path.ellipse(selection_circle_center, Vector2F::splat(7.0), 0.0, 0.0, PI_2); path.ellipse(selection_circle_center, vec2f(7.0, 7.0), 0.0, 0.0, PI_2);
canvas.fill_path(path, FillRule::EvenOdd); canvas.fill_path(path, FillRule::EvenOdd);
canvas.restore(); canvas.restore();
@ -445,11 +423,11 @@ fn draw_lines(canvas: &mut CanvasRenderingContext2D, rect: RectF, time: f32) {
canvas.save(); canvas.save();
let points = [ let points = [
Vector2F::new(-spacing * 0.25 + f32::cos(time * 0.3) * spacing * 0.5, vec2f(-spacing * 0.25 + f32::cos(time * 0.3) * spacing * 0.5,
f32::sin(time * 0.3) * spacing * 0.5), f32::sin(time * 0.3) * spacing * 0.5),
Vector2F::new(-spacing * 0.25, 0.0), vec2f(-spacing * 0.25, 0.0),
Vector2F::new( spacing * 0.25, 0.0), vec2f( spacing * 0.25, 0.0),
Vector2F::new( spacing * 0.25 + f32::cos(time * -0.3) * spacing * 0.5, vec2f( spacing * 0.25 + f32::cos(time * -0.3) * spacing * 0.5,
f32::sin(time * -0.3) * spacing * 0.5), f32::sin(time * -0.3) * spacing * 0.5),
]; ];
@ -458,9 +436,9 @@ fn draw_lines(canvas: &mut CanvasRenderingContext2D, rect: RectF, time: f32) {
LineJoin::Miter, LineJoin::Miter /* FIXME(pcwalton): Round crashes */, LineJoin::Bevel LineJoin::Miter, LineJoin::Miter /* FIXME(pcwalton): Round crashes */, LineJoin::Bevel
].iter().enumerate() { ].iter().enumerate() {
let origin = rect.origin() + let origin = rect.origin() +
Vector2F::new(spacing, -spacing).scale(0.5) + vec2f(spacing, -spacing).scale(0.5) +
Vector2F::new((cap_index * 3 + join_index) as f32 / 9.0 * rect.width(), 0.0) + vec2f((cap_index * 3 + join_index) as f32 / 9.0 * rect.width(), 0.0) +
Vector2F::splat(PADDING); vec2f(PADDING, PADDING);
canvas.set_line_cap(cap); canvas.set_line_cap(cap);
canvas.set_line_join(join); canvas.set_line_join(join);
@ -492,7 +470,7 @@ fn draw_caps(canvas: &mut CanvasRenderingContext2D, rect: RectF) {
canvas.save(); canvas.save();
canvas.set_fill_style(ColorU::new(255, 255, 255, 32)); canvas.set_fill_style(ColorU::new(255, 255, 255, 32));
canvas.fill_rect(rect.dilate(Vector2F::new(LINE_WIDTH / 2.0, 0.0))); canvas.fill_rect(rect.dilate(vec2f(LINE_WIDTH / 2.0, 0.0)));
canvas.fill_rect(rect); canvas.fill_rect(rect);
canvas.set_line_width(LINE_WIDTH); canvas.set_line_width(LINE_WIDTH);
@ -501,8 +479,8 @@ fn draw_caps(canvas: &mut CanvasRenderingContext2D, rect: RectF) {
canvas.set_stroke_style(ColorU::black()); canvas.set_stroke_style(ColorU::black());
let offset = cap_index as f32 * 10.0 + 5.0; let offset = cap_index as f32 * 10.0 + 5.0;
let mut path = Path2D::new(); let mut path = Path2D::new();
path.move_to(rect.origin() + Vector2F::new(0.0, offset)); path.move_to(rect.origin() + vec2f(0.0, offset));
path.line_to(rect.upper_right() + Vector2F::new(0.0, offset)); path.line_to(rect.upper_right() + vec2f(0.0, offset));
canvas.stroke_path(path); canvas.stroke_path(path);
} }
@ -518,15 +496,15 @@ fn draw_clip(canvas: &mut CanvasRenderingContext2D, origin: Vector2F, time: f32)
canvas.set_current_transform(&transform_a); canvas.set_current_transform(&transform_a);
canvas.set_fill_style(ColorU::new(255, 0, 0, 255)); canvas.set_fill_style(ColorU::new(255, 0, 0, 255));
let mut clip_path = Path2D::new(); let mut clip_path = Path2D::new();
clip_path.rect(RectF::new(Vector2F::splat(-20.0), Vector2F::new(60.0, 40.0))); clip_path.rect(RectF::new(vec2f(-20.0, -20.0), vec2f(60.0, 40.0)));
canvas.fill_path(clip_path.clone(), FillRule::Winding); canvas.fill_path(clip_path.clone(), FillRule::Winding);
// Draw second rectangle with no clip. // Draw second rectangle with no clip.
let transform_b = transform_a * Transform2F::from_translation(Vector2F::new(40.0, 0.0)) * let transform_b = transform_a * Transform2F::from_translation(vec2f(40.0, 0.0)) *
Transform2F::from_rotation(time); Transform2F::from_rotation(time);
canvas.set_current_transform(&transform_b); canvas.set_current_transform(&transform_b);
canvas.set_fill_style(ColorU::new(255, 128, 0, 64)); canvas.set_fill_style(ColorU::new(255, 128, 0, 64));
let fill_rect = RectF::new(Vector2F::new(-20.0, -10.0), Vector2F::new(60.0, 30.0)); let fill_rect = RectF::new(vec2f(-20.0, -10.0), vec2f(60.0, 30.0));
canvas.fill_rect(fill_rect); canvas.fill_rect(fill_rect);
// Draw second rectangle with clip. // Draw second rectangle with clip.
@ -546,26 +524,25 @@ fn draw_window(canvas: &mut CanvasRenderingContext2D, title: &str, rect: RectF)
// Draw window with shadow. // Draw window with shadow.
canvas.set_fill_style(ColorU::new(28, 30, 34, 192)); canvas.set_fill_style(ColorU::new(28, 30, 34, 192));
canvas.set_shadow_offset(Vector2F::new(0.0, 2.0)); canvas.set_shadow_offset(vec2f(0.0, 2.0));
canvas.set_shadow_blur(10.0); canvas.set_shadow_blur(10.0);
canvas.set_shadow_color(ColorU::new(0, 0, 0, 128)); canvas.set_shadow_color(ColorU::new(0, 0, 0, 128));
canvas.fill_path(create_rounded_rect_path(rect, CORNER_RADIUS), FillRule::Winding); canvas.fill_path(create_rounded_rect_path(rect, CORNER_RADIUS), FillRule::Winding);
canvas.set_shadow_color(ColorU::transparent_black()); canvas.set_shadow_color(ColorU::transparent_black());
// Header. // Header.
let mut header_gradient = Gradient::linear(LineSegment2F::new(Vector2F::default(), let mut header_gradient =
Vector2F::new(0.0, 15.0)) + Gradient::linear(LineSegment2F::new(Vector2F::zero(), vec2f(0.0, 15.0)) + rect.origin());
rect.origin());
header_gradient.add_color_stop(ColorU::new(0, 0, 0, 128), 0.0); header_gradient.add_color_stop(ColorU::new(0, 0, 0, 128), 0.0);
header_gradient.add_color_stop(ColorU::transparent_black(), 1.0); header_gradient.add_color_stop(ColorU::transparent_black(), 1.0);
canvas.set_fill_style(header_gradient); canvas.set_fill_style(header_gradient);
canvas.fill_path(create_rounded_rect_path(RectF::new(rect.origin() + Vector2F::splat(1.0), canvas.fill_path(create_rounded_rect_path(RectF::new(rect.origin() + vec2f(1.0, 1.0),
Vector2F::new(rect.width() - 2.0, 30.0)), vec2f(rect.width() - 2.0, 30.0)),
CORNER_RADIUS - 1.0), CORNER_RADIUS - 1.0),
FillRule::Winding); FillRule::Winding);
let mut path = Path2D::new(); let mut path = Path2D::new();
path.move_to(rect.origin() + Vector2F::new(0.5, 30.5)); path.move_to(rect.origin() + vec2f(0.5, 30.5));
path.line_to(rect.origin() + Vector2F::new(rect.width() - 0.5, 30.5)); path.line_to(rect.origin() + vec2f(rect.width() - 0.5, 30.5));
canvas.set_stroke_style(ColorU::new(0, 0, 0, 32)); canvas.set_stroke_style(ColorU::new(0, 0, 0, 32));
canvas.stroke_path(path); canvas.stroke_path(path);
@ -575,9 +552,9 @@ fn draw_window(canvas: &mut CanvasRenderingContext2D, title: &str, rect: RectF)
canvas.set_text_baseline(TextBaseline::Middle); canvas.set_text_baseline(TextBaseline::Middle);
canvas.set_fill_style(ColorU::new(220, 220, 220, 160)); canvas.set_fill_style(ColorU::new(220, 220, 220, 160));
canvas.set_shadow_blur(2.0); canvas.set_shadow_blur(2.0);
canvas.set_shadow_offset(Vector2F::new(0.0, 1.0)); canvas.set_shadow_offset(vec2f(0.0, 1.0));
canvas.set_shadow_color(ColorU::new(0, 0, 0, 128)); canvas.set_shadow_color(ColorU::new(0, 0, 0, 128));
canvas.fill_text(title, rect.origin() + Vector2F::new(rect.width() * 0.5, 16.0)); canvas.fill_text(title, rect.origin() + vec2f(rect.width() * 0.5, 16.0));
canvas.restore(); canvas.restore();
} }
@ -588,7 +565,7 @@ fn draw_search_box(canvas: &mut CanvasRenderingContext2D, text: &str, rect: Rect
fill_path_with_box_gradient(canvas, fill_path_with_box_gradient(canvas,
create_rounded_rect_path(rect, corner_radius), create_rounded_rect_path(rect, corner_radius),
FillRule::Winding, FillRule::Winding,
rect + Vector2F::new(0.0, 1.5), rect + vec2f(0.0, 1.5),
rect.height() * 0.5, rect.height() * 0.5,
5.0, 5.0,
ColorU::new(0, 0, 0, 16), ColorU::new(0, 0, 0, 16),
@ -598,8 +575,7 @@ fn draw_search_box(canvas: &mut CanvasRenderingContext2D, text: &str, rect: Rect
canvas.set_fill_style(ColorU::new(255, 255, 255, 64)); canvas.set_fill_style(ColorU::new(255, 255, 255, 64));
canvas.set_text_align(TextAlign::Left); canvas.set_text_align(TextAlign::Left);
canvas.set_text_baseline(TextBaseline::Middle); canvas.set_text_baseline(TextBaseline::Middle);
canvas.fill_text(text, canvas.fill_text(text, rect.origin() + Vector2F::splat(rect.height()) * vec2f(1.05, 0.5));
rect.origin() + Vector2F::splat(rect.height()) * Vector2F::new(1.05, 0.5));
} }
fn draw_dropdown(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF) { fn draw_dropdown(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF) {
@ -609,20 +585,18 @@ fn draw_dropdown(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF)
background_gradient.add_color_stop(ColorU::new(255, 255, 255, 16), 0.0); background_gradient.add_color_stop(ColorU::new(255, 255, 255, 16), 0.0);
background_gradient.add_color_stop(ColorU::new(0, 0, 0, 16), 1.0); background_gradient.add_color_stop(ColorU::new(0, 0, 0, 16), 1.0);
canvas.set_fill_style(background_gradient); canvas.set_fill_style(background_gradient);
canvas.fill_path(create_rounded_rect_path(rect.contract(Vector2F::splat(1.0)), canvas.fill_path(create_rounded_rect_path(rect.contract(vec2f(1.0, 1.0)), CORNER_RADIUS - 1.0),
CORNER_RADIUS - 1.0),
FillRule::Winding); FillRule::Winding);
canvas.set_stroke_style(ColorU::new(0, 0, 0, 48)); canvas.set_stroke_style(ColorU::new(0, 0, 0, 48));
canvas.stroke_path(create_rounded_rect_path(rect.contract(Vector2F::splat(0.5)), canvas.stroke_path(create_rounded_rect_path(rect.contract(vec2f(0.5, 0.5)),
CORNER_RADIUS - 0.5)); CORNER_RADIUS - 0.5));
canvas.set_font_size(17.0); canvas.set_font_size(17.0);
canvas.set_fill_style(ColorU::new(255, 255, 255, 160)); canvas.set_fill_style(ColorU::new(255, 255, 255, 160));
canvas.set_text_align(TextAlign::Left); canvas.set_text_align(TextAlign::Left);
canvas.set_text_baseline(TextBaseline::Middle); canvas.set_text_baseline(TextBaseline::Middle);
canvas.fill_text(text, canvas.fill_text(text, rect.origin() + Vector2F::splat(rect.height()) * vec2f(0.3, 0.5));
rect.origin() + Vector2F::splat(rect.height()) * Vector2F::new(0.3, 0.5));
} }
fn draw_label(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF) { fn draw_label(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF) {
@ -630,24 +604,24 @@ fn draw_label(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF) {
canvas.set_fill_style(ColorU::new(255, 255, 255, 128)); canvas.set_fill_style(ColorU::new(255, 255, 255, 128));
canvas.set_text_align(TextAlign::Left); canvas.set_text_align(TextAlign::Left);
canvas.set_text_baseline(TextBaseline::Middle); canvas.set_text_baseline(TextBaseline::Middle);
canvas.fill_text(text, rect.origin() + Vector2F::new(0.0, rect.height() * 0.5)); canvas.fill_text(text, rect.origin() + vec2f(0.0, rect.height() * 0.5));
} }
fn draw_edit_box(canvas: &mut CanvasRenderingContext2D, rect: RectF) { fn draw_edit_box(canvas: &mut CanvasRenderingContext2D, rect: RectF) {
const CORNER_RADIUS: f32 = 4.0; const CORNER_RADIUS: f32 = 4.0;
fill_path_with_box_gradient(canvas, fill_path_with_box_gradient(canvas,
create_rounded_rect_path(rect.contract(Vector2F::splat(1.0)), create_rounded_rect_path(rect.contract(vec2f(1.0, 1.0)),
CORNER_RADIUS - 1.0), CORNER_RADIUS - 1.0),
FillRule::Winding, FillRule::Winding,
rect.contract(Vector2F::splat(1.0)) + Vector2F::new(0.0, 1.5), rect.contract(vec2f(1.0, 1.0)) + vec2f(0.0, 1.5),
3.0, 3.0,
4.0, 4.0,
ColorU::new(255, 255, 255, 32), ColorU::new(255, 255, 255, 32),
ColorU::new(32, 32, 32, 32)); ColorU::new(32, 32, 32, 32));
canvas.set_stroke_style(ColorU::new(0, 0, 0, 48)); canvas.set_stroke_style(ColorU::new(0, 0, 0, 48));
canvas.stroke_path(create_rounded_rect_path(rect.contract(Vector2F::splat(0.5)), canvas.stroke_path(create_rounded_rect_path(rect.contract(vec2f(0.5, 0.5)),
CORNER_RADIUS - 0.5)); CORNER_RADIUS - 0.5));
} }
@ -658,8 +632,7 @@ fn draw_text_edit_box(canvas: &mut CanvasRenderingContext2D, text: &str, rect: R
canvas.set_fill_style(ColorU::new(255, 255, 255, 64)); canvas.set_fill_style(ColorU::new(255, 255, 255, 64));
canvas.set_text_align(TextAlign::Left); canvas.set_text_align(TextAlign::Left);
canvas.set_text_baseline(TextBaseline::Middle); canvas.set_text_baseline(TextBaseline::Middle);
canvas.fill_text(text, canvas.fill_text(text, rect.origin() + Vector2F::splat(rect.height()) * vec2f(0.3, 0.5));
rect.origin() + Vector2F::splat(rect.height()) * Vector2F::new(0.3, 0.5));
} }
fn draw_numeric_edit_box(canvas: &mut CanvasRenderingContext2D, fn draw_numeric_edit_box(canvas: &mut CanvasRenderingContext2D,
@ -674,16 +647,13 @@ fn draw_numeric_edit_box(canvas: &mut CanvasRenderingContext2D,
canvas.set_fill_style(ColorU::new(255, 255, 255, 64)); canvas.set_fill_style(ColorU::new(255, 255, 255, 64));
canvas.set_text_align(TextAlign::Right); canvas.set_text_align(TextAlign::Right);
canvas.set_text_baseline(TextBaseline::Middle); canvas.set_text_baseline(TextBaseline::Middle);
canvas.fill_text( canvas.fill_text(unit, rect.upper_right() + vec2f(-0.3, 0.5) * Vector2F::splat(rect.height()));
unit,
rect.upper_right() + Vector2F::new(-0.3, 0.5) * Vector2F::splat(rect.height()));
canvas.set_font_size(17.0); canvas.set_font_size(17.0);
canvas.set_fill_style(ColorU::new(255, 255, 255, 128)); canvas.set_fill_style(ColorU::new(255, 255, 255, 128));
canvas.set_text_align(TextAlign::Right); canvas.set_text_align(TextAlign::Right);
canvas.set_text_baseline(TextBaseline::Middle); canvas.set_text_baseline(TextBaseline::Middle);
canvas.fill_text(value, canvas.fill_text(value, rect.upper_right() + vec2f(-unit_width - rect.height() * 0.5,
rect.upper_right() + Vector2F::new(-unit_width - rect.height() * 0.5,
rect.height() * 0.5)); rect.height() * 0.5));
} }
@ -694,15 +664,14 @@ fn draw_check_box(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF
canvas.set_fill_style(ColorU::new(255, 255, 255, 160)); canvas.set_fill_style(ColorU::new(255, 255, 255, 160));
canvas.set_text_align(TextAlign::Left); canvas.set_text_align(TextAlign::Left);
canvas.set_text_baseline(TextBaseline::Middle); canvas.set_text_baseline(TextBaseline::Middle);
canvas.fill_text(text, rect.origin() + Vector2F::new(28.0, rect.height() * 0.5)); canvas.fill_text(text, rect.origin() + vec2f(28.0, rect.height() * 0.5));
let check_box_rect = let check_box_rect = RectF::new(vec2f(rect.origin_x(), rect.center().y().floor() - 9.0),
RectF::new(Vector2F::new(rect.origin_x(), rect.center().y().floor() - 9.0), vec2f(20.0, 20.0)).contract(Vector2F::splat(1.0));
Vector2F::splat(20.0)).contract(Vector2F::splat(1.0));
fill_path_with_box_gradient(canvas, fill_path_with_box_gradient(canvas,
create_rounded_rect_path(check_box_rect, CORNER_RADIUS), create_rounded_rect_path(check_box_rect, CORNER_RADIUS),
FillRule::Winding, FillRule::Winding,
check_box_rect + Vector2F::new(0.0, 1.0), check_box_rect + vec2f(0.0, 1.0),
CORNER_RADIUS, CORNER_RADIUS,
3.0, 3.0,
ColorU::new(0, 0, 0, 32), ColorU::new(0, 0, 0, 32),
@ -714,7 +683,7 @@ fn draw_check_box(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF
fn draw_button(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF, color: ColorU) { fn draw_button(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF, color: ColorU) {
const CORNER_RADIUS: f32 = 4.0; const CORNER_RADIUS: f32 = 4.0;
let path = create_rounded_rect_path(rect.contract(Vector2F::splat(1.0)), CORNER_RADIUS - 1.0); let path = create_rounded_rect_path(rect.contract(vec2f(1.0, 1.0)), CORNER_RADIUS - 1.0);
if color != ColorU::transparent_black() { if color != ColorU::transparent_black() {
canvas.set_fill_style(color); canvas.set_fill_style(color);
canvas.fill_path(path.clone(), FillRule::Winding); canvas.fill_path(path.clone(), FillRule::Winding);
@ -727,7 +696,7 @@ fn draw_button(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF, c
canvas.fill_path(path, FillRule::Winding); canvas.fill_path(path, FillRule::Winding);
canvas.set_stroke_style(ColorU::new(0, 0, 0, 48)); canvas.set_stroke_style(ColorU::new(0, 0, 0, 48));
canvas.stroke_path(create_rounded_rect_path(rect.contract(Vector2F::splat(0.5)), canvas.stroke_path(create_rounded_rect_path(rect.contract(vec2f(0.5, 0.5)),
CORNER_RADIUS - 0.5)); CORNER_RADIUS - 0.5));
// TODO(pcwalton): Bold font. // TODO(pcwalton): Bold font.
@ -737,11 +706,11 @@ fn draw_button(canvas: &mut CanvasRenderingContext2D, text: &str, rect: RectF, c
let icon_width = 0.0; let icon_width = 0.0;
canvas.set_font_size(17.0); canvas.set_font_size(17.0);
let text_origin = rect.center() + Vector2F::new(icon_width * 0.25 - text_width * 0.5, 0.0); let text_origin = rect.center() + vec2f(icon_width * 0.25 - text_width * 0.5, 0.0);
canvas.set_fill_style(ColorU::new(0, 0, 0, 160)); canvas.set_fill_style(ColorU::new(0, 0, 0, 160));
canvas.set_text_align(TextAlign::Left); canvas.set_text_align(TextAlign::Left);
canvas.set_text_baseline(TextBaseline::Middle); canvas.set_text_baseline(TextBaseline::Middle);
canvas.fill_text(text, text_origin - Vector2F::new(0.0, 1.0)); canvas.fill_text(text, text_origin - vec2f(0.0, 1.0));
canvas.set_fill_style(ColorU::new(255, 255, 255, 160)); canvas.set_fill_style(ColorU::new(255, 255, 255, 160));
canvas.fill_text(text, text_origin); canvas.fill_text(text, text_origin);
} }
@ -753,36 +722,34 @@ fn draw_slider(canvas: &mut CanvasRenderingContext2D, value: f32, rect: RectF) {
// Draw track. // Draw track.
// TODO(pcwalton): Box gradient. // TODO(pcwalton): Box gradient.
let track_rect = RectF::new(Vector2F::new(rect.origin_x(), center_y - 2.0), let track_rect = RectF::new(vec2f(rect.origin_x(), center_y - 2.0), vec2f(rect.width(), 4.0));
Vector2F::new(rect.width(), 4.0));
fill_path_with_box_gradient(canvas, fill_path_with_box_gradient(canvas,
create_rounded_rect_path(track_rect, 2.0), create_rounded_rect_path(track_rect, 2.0),
FillRule::Winding, FillRule::Winding,
track_rect + Vector2F::new(0.0, 1.0), track_rect + vec2f(0.0, 1.0),
2.0, 2.0,
2.0, 2.0,
ColorU::new(0, 0, 0, 32), ColorU::new(0, 0, 0, 32),
ColorU::new(0, 0, 0, 128)); ColorU::new(0, 0, 0, 128));
// Draw knob shadow. // Draw knob shadow.
let knob_position = Vector2F::new(rect.origin_x() + (value * rect.width()).floor(), center_y); let knob_position = vec2f(rect.origin_x() + (value * rect.width()).floor(), center_y);
let mut background_gradient = let mut background_gradient =
Gradient::radial(LineSegment2F::new(knob_position, Gradient::radial(LineSegment2F::new(knob_position, knob_position) + vec2f(0.0, 1.0),
knob_position) + Vector2F::new(0.0, 1.0),
F32x2::splat(knob_radius) * F32x2::new(-3.0, 3.0)); F32x2::splat(knob_radius) * F32x2::new(-3.0, 3.0));
background_gradient.add_color_stop(ColorU::new(0, 0, 0, 64), 0.0); background_gradient.add_color_stop(ColorU::new(0, 0, 0, 64), 0.0);
background_gradient.add_color_stop(ColorU::transparent_black(), 1.0); background_gradient.add_color_stop(ColorU::transparent_black(), 1.0);
canvas.set_fill_style(background_gradient); canvas.set_fill_style(background_gradient);
let mut path = Path2D::new(); let mut path = Path2D::new();
path.rect(RectF::new(knob_position, path.rect(RectF::new(knob_position,
Vector2F::default()).dilate(Vector2F::splat(knob_radius + 5.0))); Vector2F::zero()).dilate(Vector2F::splat(knob_radius + 5.0)));
path.ellipse(knob_position, Vector2F::splat(knob_radius), 0.0, 0.0, PI_2); path.ellipse(knob_position, Vector2F::splat(knob_radius), 0.0, 0.0, PI_2);
canvas.fill_path(path, FillRule::EvenOdd); canvas.fill_path(path, FillRule::EvenOdd);
// Fill knob. // Fill knob.
let mut background_gradient = let mut background_gradient =
Gradient::linear_from_points(knob_position - Vector2F::new(0.0, knob_radius), Gradient::linear_from_points(knob_position - vec2f(0.0, knob_radius),
knob_position + Vector2F::new(0.0, knob_radius)); knob_position + vec2f(0.0, knob_radius));
background_gradient.add_color_stop(ColorU::new(255, 255, 255, 16), 0.0); background_gradient.add_color_stop(ColorU::new(255, 255, 255, 16), 0.0);
background_gradient.add_color_stop(ColorU::new(0, 0, 0, 16), 1.0); background_gradient.add_color_stop(ColorU::new(0, 0, 0, 16), 1.0);
let mut path = Path2D::new(); let mut path = Path2D::new();
@ -821,12 +788,11 @@ fn draw_thumbnails(canvas: &mut CanvasRenderingContext2D,
// Draw drop shadow. // Draw drop shadow.
let mut path = create_rounded_rect_path(rect, CORNER_RADIUS); let mut path = create_rounded_rect_path(rect, CORNER_RADIUS);
path.rect(RectF::new(rect.origin() - Vector2F::splat(10.0), path.rect(RectF::new(rect.origin() - vec2f(10.0, 10.0), rect.size() + vec2f(20.0, 30.0)));
rect.size() + Vector2F::new(20.0, 30.0)));
fill_path_with_box_gradient(canvas, fill_path_with_box_gradient(canvas,
path, path,
FillRule::EvenOdd, FillRule::EvenOdd,
rect + Vector2F::new(0.0, 4.0), rect + vec2f(0.0, 4.0),
CORNER_RADIUS * 2.0, CORNER_RADIUS * 2.0,
20.0, 20.0,
ColorU::new(0, 0, 0, 128), ColorU::new(0, 0, 0, 128),
@ -834,9 +800,9 @@ fn draw_thumbnails(canvas: &mut CanvasRenderingContext2D,
// Draw window. // Draw window.
let mut path = create_rounded_rect_path(rect, CORNER_RADIUS); let mut path = create_rounded_rect_path(rect, CORNER_RADIUS);
path.move_to(rect.origin() + Vector2F::new(-10.0, ARROW_Y_POSITION)); path.move_to(rect.origin() + vec2f(-10.0, ARROW_Y_POSITION));
path.line_to(rect.origin() + Vector2F::new(1.0, ARROW_Y_POSITION - 11.0)); path.line_to(rect.origin() + vec2f(1.0, ARROW_Y_POSITION - 11.0));
path.line_to(rect.origin() + Vector2F::new(1.0, ARROW_Y_POSITION + 11.0)); path.line_to(rect.origin() + vec2f(1.0, ARROW_Y_POSITION + 11.0));
canvas.set_fill_style(ColorU::new(200, 200, 200, 255)); canvas.set_fill_style(ColorU::new(200, 200, 200, 255));
canvas.fill_path(path, FillRule::Winding); canvas.fill_path(path, FillRule::Winding);
@ -847,12 +813,12 @@ fn draw_thumbnails(canvas: &mut CanvasRenderingContext2D,
clip_path.rect(rect); clip_path.rect(rect);
canvas.clip_path(clip_path, FillRule::Winding); canvas.clip_path(clip_path, FillRule::Winding);
canvas.set_current_transform(&Transform2F::from_translation( canvas.set_current_transform(&Transform2F::from_translation(
Vector2F::new(0.0, -scroll_y * (stack_height - rect.height())))); vec2f(0.0, -scroll_y * (stack_height - rect.height()))));
for image_index in 0..image_count { for image_index in 0..image_count {
let image_origin = rect.origin() + Vector2F::splat(10.0) + let image_origin = rect.origin() + vec2f(10.0, 10.0) +
Vector2I::new(image_index as i32 % 2, vec2i(image_index as i32 % 2, image_index as i32 / 2).to_f32()
image_index as i32 / 2).to_f32().scale(THUMB_HEIGHT + 10.0); .scale(THUMB_HEIGHT + 10.0);
let image_rect = RectF::new(image_origin, Vector2F::splat(THUMB_HEIGHT)); let image_rect = RectF::new(image_origin, Vector2F::splat(THUMB_HEIGHT));
let image_y = image_index as f32 * image_y_scale; let image_y = image_index as f32 * image_y_scale;
@ -863,10 +829,10 @@ fn draw_thumbnails(canvas: &mut CanvasRenderingContext2D,
let image_path = create_rounded_rect_path(image_rect, 5.0); let image_path = create_rounded_rect_path(image_rect, 5.0);
let pattern_transform = Transform2F::from_translation( let pattern_transform = Transform2F::from_translation(
image_rect.origin() - image_rect.origin() - vec2i(
Vector2I::new((image_index % IMAGES_ACROSS) as i32, (image_index % IMAGES_ACROSS) as i32,
(image_index / IMAGES_ACROSS) as i32).to_f32().scale(THUMB_HEIGHT)) * (image_index / IMAGES_ACROSS) as i32).to_f32().scale(THUMB_HEIGHT)) *
Transform2F::from_scale(Vector2F::splat(0.5)); Transform2F::from_scale(vec2f(0.5, 0.5));
let pattern = Pattern::new(PatternSource::Image((*image).clone()), let pattern = Pattern::new(PatternSource::Image((*image).clone()),
pattern_transform, pattern_transform,
PatternFlags::empty()); PatternFlags::empty());
@ -874,14 +840,14 @@ fn draw_thumbnails(canvas: &mut CanvasRenderingContext2D,
canvas.fill_path(image_path, FillRule::Winding); canvas.fill_path(image_path, FillRule::Winding);
let mut shadow_path = create_rounded_rect_path(image_rect, 6.0); let mut shadow_path = create_rounded_rect_path(image_rect, 6.0);
shadow_path.rect(image_rect.dilate(Vector2F::splat(5.0))); shadow_path.rect(image_rect.dilate(vec2f(5.0, 5.0)));
// TODO(pcwalton): Union clip paths. // TODO(pcwalton): Union clip paths.
/* /*
fill_path_with_box_gradient( fill_path_with_box_gradient(
canvas, canvas,
shadow_path, shadow_path,
FillRule::EvenOdd, FillRule::EvenOdd,
image_rect.dilate(Vector2F::splat(1.0)) + Vector2F::new(0.0, 1.0), image_rect.dilate(Vector2F::splat(1.0)) + vec2f(0.0, 1.0),
5.0, 5.0,
3.0, 3.0,
ColorU::new(0, 0, 0, 128), ColorU::new(0, 0, 0, 128),
@ -897,43 +863,40 @@ fn draw_thumbnails(canvas: &mut CanvasRenderingContext2D,
// Draw fade-away gradients. // Draw fade-away gradients.
let mut fade_gradient = Gradient::linear_from_points(rect.origin(), let mut fade_gradient = Gradient::linear_from_points(rect.origin(),
rect.origin() + Vector2F::new(0.0, 6.0)); rect.origin() + vec2f(0.0, 6.0));
fade_gradient.add_color_stop(ColorU::new(200, 200, 200, 255), 0.0); fade_gradient.add_color_stop(ColorU::new(200, 200, 200, 255), 0.0);
fade_gradient.add_color_stop(ColorU::new(200, 200, 200, 0), 1.0); fade_gradient.add_color_stop(ColorU::new(200, 200, 200, 0), 1.0);
canvas.set_fill_style(fade_gradient); canvas.set_fill_style(fade_gradient);
canvas.fill_rect(RectF::new(rect.origin() + Vector2F::new(4.0, 0.0), canvas.fill_rect(RectF::new(rect.origin() + vec2f(4.0, 0.0), vec2f(rect.width() - 8.0, 6.0)));
Vector2F::new(rect.width() - 8.0, 6.0)));
let mut fade_gradient = let mut fade_gradient = Gradient::linear_from_points(rect.lower_left(),
Gradient::linear(LineSegment2F::new(rect.lower_left(), rect.lower_left() - vec2f(0.0, 6.0));
rect.lower_left() - Vector2F::new(0.0, 6.0)));
fade_gradient.add_color_stop(ColorU::new(200, 200, 200, 255), 0.0); fade_gradient.add_color_stop(ColorU::new(200, 200, 200, 255), 0.0);
fade_gradient.add_color_stop(ColorU::new(200, 200, 200, 0), 1.0); fade_gradient.add_color_stop(ColorU::new(200, 200, 200, 0), 1.0);
canvas.set_fill_style(fade_gradient); canvas.set_fill_style(fade_gradient);
canvas.fill_rect(RectF::new(rect.lower_left() + Vector2F::new(4.0, -6.0), canvas.fill_rect(RectF::new(rect.lower_left() + vec2f(4.0, -6.0),
Vector2F::new(rect.width() - 8.0, 6.0))); vec2f(rect.width() - 8.0, 6.0)));
// Draw scroll bar. // Draw scroll bar.
let scroll_bar_rect = RectF::new(rect.upper_right() + Vector2F::new(-12.0, 4.0), let scroll_bar_rect = RectF::new(rect.upper_right() + vec2f(-12.0, 4.0),
Vector2F::new(8.0, rect.height() - 8.0)); vec2f(8.0, rect.height() - 8.0));
fill_path_with_box_gradient(canvas, fill_path_with_box_gradient(canvas,
create_rounded_rect_path(scroll_bar_rect, CORNER_RADIUS), create_rounded_rect_path(scroll_bar_rect, CORNER_RADIUS),
FillRule::Winding, FillRule::Winding,
scroll_bar_rect + Vector2F::new(0.0, 1.0), scroll_bar_rect + vec2f(0.0, 1.0),
CORNER_RADIUS, CORNER_RADIUS,
4.0, 4.0,
ColorU::new(0, 0, 0, 32), ColorU::new(0, 0, 0, 32),
ColorU::new(0, 0, 0, 92)); ColorU::new(0, 0, 0, 92));
let knob_rect = let knob_rect = RectF::new(
RectF::new(rect.upper_right() + rect.upper_right() + vec2f(-11.0, 5.0 + (rect.height() - 8.0 - scroll_height) * scroll_y),
Vector2F::new(-11.0, 5.0 + (rect.height() - 8.0 - scroll_height) * scroll_y), vec2f(6.0, scroll_height - 2.0));
Vector2F::new(6.0, scroll_height - 2.0));
fill_path_with_box_gradient(canvas, fill_path_with_box_gradient(canvas,
create_rounded_rect_path(knob_rect, 2.0), create_rounded_rect_path(knob_rect, 2.0),
FillRule::Winding, FillRule::Winding,
knob_rect.dilate(Vector2F::splat(2.0)) + Vector2F::new(0.0, 1.0), knob_rect.dilate(vec2f(2.0, 2.0)) + vec2f(0.0, 1.0),
3.0, 3.0,
4.0, 4.0,
ColorU::new(220, 220, 220, 255), ColorU::new(220, 220, 220, 255),
@ -955,8 +918,8 @@ fn draw_spinner(canvas: &mut CanvasRenderingContext2D, center: Vector2F, radius:
path.close_path(); path.close_path();
set_linear_gradient_fill_style( set_linear_gradient_fill_style(
canvas, canvas,
center + Vector2F::new(outer_radius.cos(), outer_radius.sin()).scale(average_radius), center + vec2f(outer_radius.cos(), outer_radius.sin()).scale(average_radius),
center + Vector2F::new(inner_radius.cos(), inner_radius.sin()).scale(average_radius), center + vec2f(inner_radius.cos(), inner_radius.sin()).scale(average_radius),
ColorU::transparent_black(), ColorU::transparent_black(),
ColorU::new(0, 0, 0, 128)); ColorU::new(0, 0, 0, 128));
canvas.fill_path(path, FillRule::Winding); canvas.fill_path(path, FillRule::Winding);
@ -974,7 +937,7 @@ fn fill_path_with_box_gradient(canvas: &mut CanvasRenderingContext2D,
outer_color: ColorU) { outer_color: ColorU) {
// TODO(pcwalton): Fill the corners with radial gradients. // TODO(pcwalton): Fill the corners with radial gradients.
let window_rect = RectF::new(Vector2F::default(), Vector2F::new(800.0, 600.0)); let window_rect = RectF::new(Vector2F::zero(), vec2f(800.0, 600.0));
let inner_rect = rect.contract(Vector2F::splat(blur_radius)); let inner_rect = rect.contract(Vector2F::splat(blur_radius));
let outer_rect = rect.dilate(Vector2F::splat(blur_radius)); let outer_rect = rect.dilate(Vector2F::splat(blur_radius));
@ -994,7 +957,7 @@ fn fill_path_with_box_gradient(canvas: &mut CanvasRenderingContext2D,
section.close_path(); section.close_path();
set_linear_gradient_fill_style(canvas, set_linear_gradient_fill_style(canvas,
outer_rect.origin(), outer_rect.origin(),
Vector2F::new(inner_rect.min_x(), outer_rect.min_y()), vec2f(inner_rect.min_x(), outer_rect.min_y()),
outer_color, outer_color,
inner_color); inner_color);
canvas.fill_path(section, FillRule::Winding); canvas.fill_path(section, FillRule::Winding);
@ -1011,7 +974,7 @@ fn fill_path_with_box_gradient(canvas: &mut CanvasRenderingContext2D,
section.close_path(); section.close_path();
set_linear_gradient_fill_style(canvas, set_linear_gradient_fill_style(canvas,
outer_rect.origin(), outer_rect.origin(),
Vector2F::new(outer_rect.min_x(), inner_rect.min_y()), vec2f(outer_rect.min_x(), inner_rect.min_y()),
outer_color, outer_color,
inner_color); inner_color);
canvas.fill_path(section, FillRule::Winding); canvas.fill_path(section, FillRule::Winding);
@ -1028,7 +991,7 @@ fn fill_path_with_box_gradient(canvas: &mut CanvasRenderingContext2D,
section.close_path(); section.close_path();
set_linear_gradient_fill_style(canvas, set_linear_gradient_fill_style(canvas,
outer_rect.upper_right(), outer_rect.upper_right(),
Vector2F::new(inner_rect.max_x(), outer_rect.min_y()), vec2f(inner_rect.max_x(), outer_rect.min_y()),
outer_color, outer_color,
inner_color); inner_color);
canvas.fill_path(section, FillRule::Winding); canvas.fill_path(section, FillRule::Winding);
@ -1045,7 +1008,7 @@ fn fill_path_with_box_gradient(canvas: &mut CanvasRenderingContext2D,
section.close_path(); section.close_path();
set_linear_gradient_fill_style(canvas, set_linear_gradient_fill_style(canvas,
outer_rect.lower_left(), outer_rect.lower_left(),
Vector2F::new(outer_rect.min_x(), inner_rect.max_y()), vec2f(outer_rect.min_x(), inner_rect.max_y()),
outer_color, outer_color,
inner_color); inner_color);
canvas.fill_path(section, FillRule::Winding); canvas.fill_path(section, FillRule::Winding);
@ -1066,10 +1029,10 @@ fn set_linear_gradient_fill_style(canvas: &mut CanvasRenderingContext2D,
fn create_graph_path(sample_points: &[Vector2F], sample_spread: f32, offset: Vector2F) -> Path2D { fn create_graph_path(sample_points: &[Vector2F], sample_spread: f32, offset: Vector2F) -> Path2D {
let mut path = Path2D::new(); let mut path = Path2D::new();
path.move_to(sample_points[0] + Vector2F::new(0.0, 2.0)); path.move_to(sample_points[0] + vec2f(0.0, 2.0));
for pair in sample_points.windows(2) { for pair in sample_points.windows(2) {
path.bezier_curve_to(pair[0] + offset + Vector2F::new(sample_spread * 0.5, 0.0), path.bezier_curve_to(pair[0] + offset + vec2f(sample_spread * 0.5, 0.0),
pair[1] + offset - Vector2F::new(sample_spread * 0.5, 0.0), pair[1] + offset - vec2f(sample_spread * 0.5, 0.0),
pair[1] + offset); pair[1] + offset);
} }
path path
@ -1077,11 +1040,11 @@ fn create_graph_path(sample_points: &[Vector2F], sample_spread: f32, offset: Vec
fn create_rounded_rect_path(rect: RectF, radius: f32) -> Path2D { fn create_rounded_rect_path(rect: RectF, radius: f32) -> Path2D {
let mut path = Path2D::new(); let mut path = Path2D::new();
path.move_to(rect.origin() + Vector2F::new(radius, 0.0)); path.move_to(rect.origin() + vec2f(radius, 0.0));
path.arc_to(rect.upper_right(), rect.upper_right() + Vector2F::new(0.0, radius), radius); path.arc_to(rect.upper_right(), rect.upper_right() + vec2f(0.0, radius), radius);
path.arc_to(rect.lower_right(), rect.lower_right() + Vector2F::new(-radius, 0.0), radius); path.arc_to(rect.lower_right(), rect.lower_right() + vec2f(-radius, 0.0), radius);
path.arc_to(rect.lower_left(), rect.lower_left() + Vector2F::new(0.0, -radius), radius); path.arc_to(rect.lower_left(), rect.lower_left() + vec2f(0.0, -radius), radius);
path.arc_to(rect.origin(), rect.origin() + Vector2F::new(radius, 0.0), radius); path.arc_to(rect.origin(), rect.origin() + vec2f(radius, 0.0), radius);
path.close_path(); path.close_path();
path path
} }
@ -1110,7 +1073,7 @@ fn main() {
gl_attributes.set_context_version(3, 3); gl_attributes.set_context_version(3, 3);
// Open a window. // Open a window.
let window_size = Vector2I::new(800, 600); let window_size = vec2i(800, 600);
let window = let window =
video.window("NanoVG example port", window_size.x() as u32, window_size.y() as u32) video.window("NanoVG example port", window_size.x() as u32, window_size.y() as u32)
.opengl() .opengl()
@ -1136,7 +1099,7 @@ fn main() {
// Initialize state. // Initialize state.
let mut event_pump = sdl_context.event_pump().unwrap(); let mut event_pump = sdl_context.event_pump().unwrap();
let mut mouse_position = Vector2F::default(); let mut mouse_position = Vector2F::zero();
let start_time = Instant::now(); let start_time = Instant::now();
let font_context = CanvasFontContext::from_system_source(); let font_context = CanvasFontContext::from_system_source();
@ -1157,9 +1120,7 @@ fn main() {
for event in event_pump.poll_iter() { for event in event_pump.poll_iter() {
match event { match event {
Event::Quit {..} | Event::KeyDown { keycode: Some(Keycode::Escape), .. } => return, Event::Quit {..} | Event::KeyDown { keycode: Some(Keycode::Escape), .. } => return,
Event::MouseMotion { x, y, .. } => { Event::MouseMotion { x, y, .. } => mouse_position = vec2i(x, y).to_f32(),
mouse_position = Vector2I::new(x, y).to_f32();
}
_ => {} _ => {}
} }
} }

8
examples/canvas_text/src/main.rs
View File

@ -11,7 +11,7 @@
use font_kit::handle::Handle; use font_kit::handle::Handle;
use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, TextAlign}; use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, TextAlign};
use pathfinder_color::ColorF; use pathfinder_color::ColorF;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2f, vec2i};
use pathfinder_gl::{GLDevice, GLVersion}; use pathfinder_gl::{GLDevice, GLVersion};
use pathfinder_renderer::concurrent::rayon::RayonExecutor; use pathfinder_renderer::concurrent::rayon::RayonExecutor;
use pathfinder_renderer::concurrent::scene_proxy::SceneProxy; use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
@ -37,7 +37,7 @@ fn main() {
gl_attributes.set_context_version(3, 3); gl_attributes.set_context_version(3, 3);
// Open a window. // Open a window.
let window_size = Vector2I::new(640, 480); let window_size = vec2i(640, 480);
let window = video.window("Text example", window_size.x() as u32, window_size.y() as u32) let window = video.window("Text example", window_size.x() as u32, window_size.y() as u32)
.opengl() .opengl()
.build() .build()
@ -66,9 +66,9 @@ fn main() {
// Draw the text. // Draw the text.
canvas.set_font_by_postscript_name("Overpass-Regular"); canvas.set_font_by_postscript_name("Overpass-Regular");
canvas.set_font_size(32.0); canvas.set_font_size(32.0);
canvas.fill_text("Hello Pathfinder!", Vector2F::new(32.0, 48.0)); canvas.fill_text("Hello Pathfinder!", vec2f(32.0, 48.0));
canvas.set_text_align(TextAlign::Right); canvas.set_text_align(TextAlign::Right);
canvas.stroke_text("Goodbye Pathfinder!", Vector2F::new(608.0, 464.0)); canvas.stroke_text("Goodbye Pathfinder!", vec2f(608.0, 464.0));
// Render the canvas to screen. // Render the canvas to screen.
let scene = SceneProxy::from_scene(canvas.into_scene(), RayonExecutor); let scene = SceneProxy::from_scene(canvas.into_scene(), RayonExecutor);

24
examples/swf_basic/src/main.rs
View File

@ -8,8 +8,9 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use pathfinder_geometry::vector::{Vector2F, Vector2I};
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::vector::{Vector2F, vec2f, vec2i};
use pathfinder_gl::{GLDevice, GLVersion}; use pathfinder_gl::{GLDevice, GLVersion};
use pathfinder_renderer::concurrent::rayon::RayonExecutor; use pathfinder_renderer::concurrent::rayon::RayonExecutor;
use pathfinder_renderer::concurrent::scene_proxy::SceneProxy; use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
@ -25,7 +26,6 @@ use pathfinder_renderer::scene::Scene;
use pathfinder_swf::{draw_paths_into_scene, process_swf_tags}; use pathfinder_swf::{draw_paths_into_scene, process_swf_tags};
use std::env; use std::env;
use std::fs::read; use std::fs::read;
use pathfinder_geometry::transform2d::Transform2F;
fn main() { fn main() {
let resource_loader = FilesystemResourceLoader::locate(); let resource_loader = FilesystemResourceLoader::locate();
@ -64,7 +64,8 @@ fn main() {
swf_bytes = Vec::from(&default_tiger[..]); swf_bytes = Vec::from(&default_tiger[..]);
} }
let (_, movie): (_, swf_types::Movie) = swf_parser::streaming::movie::parse_movie(&swf_bytes[..]).unwrap(); let (_, movie): (_, swf_types::Movie) =
swf_parser::streaming::movie::parse_movie(&swf_bytes[..]).unwrap();
// Set up SDL2. // Set up SDL2.
let sdl_context = sdl2::init().unwrap(); let sdl_context = sdl2::init().unwrap();
@ -81,17 +82,14 @@ fn main() {
let (library, stage) = process_swf_tags(&movie); let (library, stage) = process_swf_tags(&movie);
// Open a window. // Open a window.
let window_size = Vector2I::new(stage.width(), stage.height()); let window_size = vec2i(stage.width(), stage.height());
let window = video.window("Minimal example", window_size.x() as u32, window_size.y() as u32) let window = video.window("Minimal example", window_size.x() as u32, window_size.y() as u32)
.opengl() .opengl()
.allow_highdpi() .allow_highdpi()
.build() .build()
.unwrap(); .unwrap();
let pixel_size = Vector2I::new( let pixel_size = vec2i(window.drawable_size().0 as i32, window.drawable_size().1 as i32);
window.drawable_size().0 as i32,
window.drawable_size().1 as i32
);
let device_pixel_ratio = pixel_size.x() as f32 / window_size.x() as f32; let device_pixel_ratio = pixel_size.x() as f32 / window_size.x() as f32;
// Create the GL context, and make it current. // Create the GL context, and make it current.
@ -109,19 +107,15 @@ fn main() {
// Clear to swf stage background color. // Clear to swf stage background color.
let mut scene = Scene::new(); let mut scene = Scene::new();
scene.set_view_box(RectF::new( scene.set_view_box(RectF::new(
Vector2F::default(), Vector2F::zero(),
Vector2F::new( vec2f(stage.width() as f32, stage.height() as f32).scale(device_pixel_ratio)
stage.width() as f32 * device_pixel_ratio,
stage.height() as f32 * device_pixel_ratio)
)); ));
draw_paths_into_scene(&library, &mut scene); draw_paths_into_scene(&library, &mut scene);
// Render the canvas to screen. // Render the canvas to screen.
let scene = SceneProxy::from_scene(scene, RayonExecutor); let scene = SceneProxy::from_scene(scene, RayonExecutor);
let mut build_options = BuildOptions::default(); let mut build_options = BuildOptions::default();
let scale_transform = Transform2F::from_scale( let scale_transform = Transform2F::from_scale(Vector2F::splat(device_pixel_ratio));
Vector2F::new(device_pixel_ratio, device_pixel_ratio)
);
build_options.transform = RenderTransform::Transform2D(scale_transform); build_options.transform = RenderTransform::Transform2D(scale_transform);
scene.build_and_render(&mut renderer, build_options); scene.build_and_render(&mut renderer, build_options);

4
export/src/lib.rs
View File

@ -12,7 +12,7 @@ use pathfinder_content::outline::ContourIterFlags;
use pathfinder_content::segment::SegmentKind; use pathfinder_content::segment::SegmentKind;
use pathfinder_renderer::paint::Paint; use pathfinder_renderer::paint::Paint;
use pathfinder_renderer::scene::Scene; use pathfinder_renderer::scene::Scene;
use pathfinder_geometry::vector::Vector2F; use pathfinder_geometry::vector::{Vector2F, vec2f};
use std::fmt; use std::fmt;
use std::io::{self, Write}; use std::io::{self, Write};
@ -73,7 +73,7 @@ fn export_pdf<W: Write>(scene: &Scene, writer: &mut W) -> io::Result<()> {
let height = view_box.size().y(); let height = view_box.size().y();
let tr = |v: Vector2F| -> Vector2F { let tr = |v: Vector2F| -> Vector2F {
let r = v - view_box.origin(); let r = v - view_box.origin();
Vector2F::new(r.x(), height - r.y()) vec2f(r.x(), height - r.y())
}; };
for (paint, outline, _) in scene.paths() { for (paint, outline, _) in scene.paths() {

12
geometry/src/transform2d.rs
View File

@ -14,7 +14,7 @@ use crate::line_segment::LineSegment2F;
use crate::rect::RectF; use crate::rect::RectF;
use crate::transform3d::Transform4F; use crate::transform3d::Transform4F;
use crate::unit_vector::UnitVector; use crate::unit_vector::UnitVector;
use crate::vector::Vector2F; use crate::vector::{Vector2F, vec2f};
use pathfinder_simd::default::F32x4; use pathfinder_simd::default::F32x4;
use std::ops::{Mul, MulAssign, Sub}; use std::ops::{Mul, MulAssign, Sub};
@ -25,7 +25,7 @@ pub struct Matrix2x2F(pub F32x4);
impl Default for Matrix2x2F { impl Default for Matrix2x2F {
#[inline] #[inline]
fn default() -> Matrix2x2F { fn default() -> Matrix2x2F {
Self::from_scale(Vector2F::splat(1.0)) Self::from_scale(vec2f(1.0, 1.0))
} }
} }
@ -131,7 +131,7 @@ pub struct Transform2F {
impl Default for Transform2F { impl Default for Transform2F {
#[inline] #[inline]
fn default() -> Transform2F { fn default() -> Transform2F {
Self::from_scale(Vector2F::splat(1.0)) Self::from_scale(vec2f(1.0, 1.0))
} }
} }
@ -140,7 +140,7 @@ impl Transform2F {
pub fn from_scale(scale: Vector2F) -> Transform2F { pub fn from_scale(scale: Vector2F) -> Transform2F {
Transform2F { Transform2F {
matrix: Matrix2x2F::from_scale(scale), matrix: Matrix2x2F::from_scale(scale),
vector: Vector2F::default(), vector: Vector2F::zero(),
} }
} }
@ -153,7 +153,7 @@ impl Transform2F {
pub fn from_rotation(theta: f32) -> Transform2F { pub fn from_rotation(theta: f32) -> Transform2F {
Transform2F { Transform2F {
matrix: Matrix2x2F::from_rotation(theta), matrix: Matrix2x2F::from_rotation(theta),
vector: Vector2F::default(), vector: Vector2F::zero(),
} }
} }
@ -161,7 +161,7 @@ impl Transform2F {
pub fn from_rotation_vector(vector: UnitVector) -> Transform2F { pub fn from_rotation_vector(vector: UnitVector) -> Transform2F {
Transform2F { Transform2F {
matrix: Matrix2x2F::from_rotation_vector(vector), matrix: Matrix2x2F::from_rotation_vector(vector),
vector: Vector2F::default(), vector: Vector2F::zero(),
} }
} }

4
geometry/src/transform3d.rs
View File

@ -10,9 +10,9 @@
//! 3D transforms that can be applied to paths. //! 3D transforms that can be applied to paths.
use crate::vector::{Vector2F, Vector2I, Vector3F, Vector4F};
use crate::rect::RectF; use crate::rect::RectF;
use crate::transform2d::Matrix2x2F; use crate::transform2d::Matrix2x2F;
use crate::vector::{Vector2F, Vector2I, Vector3F, Vector4F, vec2f};
use pathfinder_simd::default::F32x4; use pathfinder_simd::default::F32x4;
use std::ops::{Add, Mul, MulAssign, Neg}; use std::ops::{Add, Mul, MulAssign, Neg};
@ -407,7 +407,7 @@ impl Mul<Vector2F> for Perspective {
#[inline] #[inline]
fn mul(self, vector: Vector2F) -> Vector2F { fn mul(self, vector: Vector2F) -> Vector2F {
let point = (self.transform * vector.to_4d()).to_2d() * Vector2F::new(1.0, -1.0); let point = (self.transform * vector.to_4d()).to_2d() * Vector2F::new(1.0, -1.0);
(point + Vector2F::splat(1.0)) * self.window_size.to_f32().scale(0.5) (point + vec2f(1.0, 1.0)) * self.window_size.to_f32().scale(0.5)
} }
} }

24
geometry/src/vector.rs
View File

@ -29,6 +29,11 @@ impl Vector2F {
Vector2F(F32x2::splat(value)) Vector2F(F32x2::splat(value))
} }
#[inline]
pub fn zero() -> Vector2F {
Vector2F::default()
}
#[inline] #[inline]
pub fn to_3d(self) -> Vector3F { pub fn to_3d(self) -> Vector3F {
Vector3F(self.0.to_f32x4().concat_xy_zw(F32x4::new(0.0, 0.0, 0.0, 0.0))) Vector3F(self.0.to_f32x4().concat_xy_zw(F32x4::new(0.0, 0.0, 0.0, 0.0)))
@ -147,7 +152,7 @@ impl Vector2F {
#[inline] #[inline]
pub fn is_zero(self) -> bool { pub fn is_zero(self) -> bool {
self == Vector2F::default() self == Vector2F::zero()
} }
#[inline] #[inline]
@ -161,6 +166,12 @@ impl Vector2F {
} }
} }
/// A convenience alias for `Vector2F::new()`.
#[inline]
pub fn vec2f(x: f32, y: f32) -> Vector2F {
Vector2F::new(x, y)
}
impl PartialEq for Vector2F { impl PartialEq for Vector2F {
#[inline] #[inline]
fn eq(&self, other: &Vector2F) -> bool { fn eq(&self, other: &Vector2F) -> bool {
@ -230,6 +241,11 @@ impl Vector2I {
Vector2I(I32x2::splat(value)) Vector2I(I32x2::splat(value))
} }
#[inline]
pub fn zero() -> Vector2I {
Vector2I::default()
}
#[inline] #[inline]
pub fn x(self) -> i32 { pub fn x(self) -> i32 {
self.0[0] self.0[0]
@ -276,6 +292,12 @@ impl Vector2I {
} }
} }
/// A convenience alias for `Vector2I::new()`.
#[inline]
pub fn vec2i(x: i32, y: i32) -> Vector2I {
Vector2I::new(x, y)
}
impl Add<Vector2I> for Vector2I { impl Add<Vector2I> for Vector2I {
type Output = Vector2I; type Output = Vector2I;
#[inline] #[inline]

4
gpu/src/lib.rs
View File

@ -18,7 +18,7 @@ use image::ImageFormat;
use pathfinder_color::ColorF; use pathfinder_color::ColorF;
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::transform3d::Transform4F; use pathfinder_geometry::transform3d::Transform4F;
use pathfinder_geometry::vector::Vector2I; use pathfinder_geometry::vector::{Vector2I, vec2i};
use pathfinder_resources::ResourceLoader; use pathfinder_resources::ResourceLoader;
use pathfinder_simd::default::{F32x2, F32x4}; use pathfinder_simd::default::{F32x2, F32x4};
use std::os::raw::c_void; use std::os::raw::c_void;
@ -99,7 +99,7 @@ pub trait Device: Sized {
let image = image::load_from_memory_with_format(&data, ImageFormat::Png) let image = image::load_from_memory_with_format(&data, ImageFormat::Png)
.unwrap() .unwrap()
.to_luma(); .to_luma();
let size = Vector2I::new(image.width() as i32, image.height() as i32); let size = vec2i(image.width() as i32, image.height() as i32);
self.create_texture_from_data(TextureFormat::R8, size, TextureDataRef::U8(&image)) self.create_texture_from_data(TextureFormat::R8, size, TextureDataRef::U8(&image))
} }

6
metal/src/lib.rs
View File

@ -42,7 +42,7 @@ use metal::{StructTypeRef, TextureDescriptor, Texture, TextureRef, VertexAttribu
use metal::{VertexAttributeRef, VertexDescriptor, VertexDescriptorRef}; use metal::{VertexAttributeRef, VertexDescriptor, VertexDescriptorRef};
use objc::runtime::{Class, Object}; use objc::runtime::{Class, Object};
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::vector::Vector2I; use pathfinder_geometry::vector::{Vector2I, vec2i};
use pathfinder_gpu::{BlendFactor, BlendOp, BufferData, BufferTarget, BufferUploadMode, DepthFunc}; use pathfinder_gpu::{BlendFactor, BlendOp, BufferData, BufferTarget, BufferUploadMode, DepthFunc};
use pathfinder_gpu::{Device, Primitive, RenderState, RenderTarget, ShaderKind, StencilFunc}; use pathfinder_gpu::{Device, Primitive, RenderState, RenderTarget, ShaderKind, StencilFunc};
use pathfinder_gpu::{TextureData, TextureDataRef, TextureFormat, TextureSamplingFlags}; use pathfinder_gpu::{TextureData, TextureDataRef, TextureFormat, TextureSamplingFlags};
@ -123,7 +123,7 @@ impl MetalDevice {
}).collect(); }).collect();
let main_color_texture = drawable.texture(); let main_color_texture = drawable.texture();
let framebuffer_size = Vector2I::new(main_color_texture.width() as i32, let framebuffer_size = vec2i(main_color_texture.width() as i32,
main_color_texture.height() as i32); main_color_texture.height() as i32);
let main_depth_stencil_texture = device.create_depth_stencil_texture(framebuffer_size); let main_depth_stencil_texture = device.create_depth_stencil_texture(framebuffer_size);
@ -486,7 +486,7 @@ impl Device for MetalDevice {
} }
fn texture_size(&self, texture: &MetalTexture) -> Vector2I { fn texture_size(&self, texture: &MetalTexture) -> Vector2I {
Vector2I::new(texture.texture.width() as i32, texture.texture.height() as i32) vec2i(texture.texture.width() as i32, texture.texture.height() as i32)
} }
fn set_texture_sampling_mode(&self, texture: &MetalTexture, flags: TextureSamplingFlags) { fn set_texture_sampling_mode(&self, texture: &MetalTexture, flags: TextureSamplingFlags) {

20
renderer/src/allocator.rs
View File

@ -12,7 +12,7 @@
use crate::gpu_data::{TextureLocation, TexturePageId}; use crate::gpu_data::{TextureLocation, TexturePageId};
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2f, vec2i};
const ATLAS_TEXTURE_LENGTH: u32 = 1024; const ATLAS_TEXTURE_LENGTH: u32 = 1024;
@ -98,7 +98,7 @@ impl TextureAllocator {
} }
pub fn page_scale(&self, page_index: TexturePageId) -> Vector2F { pub fn page_scale(&self, page_index: TexturePageId) -> Vector2F {
Vector2F::splat(1.0) / self.page_size(page_index).to_f32() vec2f(1.0, 1.0) / self.page_size(page_index).to_f32()
} }
#[inline] #[inline]
@ -179,20 +179,18 @@ impl TreeNode {
if let Some(origin) = kids[0].allocate(this_origin, kid_size, requested_size) { if let Some(origin) = kids[0].allocate(this_origin, kid_size, requested_size) {
return Some(origin); return Some(origin);
} }
if let Some(origin) = if let Some(origin) = kids[1].allocate(this_origin + vec2i(kid_size as i32, 0),
kids[1].allocate(this_origin + Vector2I::new(kid_size as i32, 0),
kid_size, kid_size,
requested_size) { requested_size) {
return Some(origin); return Some(origin);
} }
if let Some(origin) = if let Some(origin) = kids[2].allocate(this_origin + vec2i(0, kid_size as i32),
kids[2].allocate(this_origin + Vector2I::new(0, kid_size as i32),
kid_size, kid_size,
requested_size) { requested_size) {
return Some(origin); return Some(origin);
} }
if let Some(origin) = if let Some(origin) = kids[3].allocate(
kids[3].allocate(this_origin + Vector2I::splat(kid_size as i32), this_origin + Vector2I::splat(kid_size as i32),
kid_size, kid_size,
requested_size) { requested_size) {
return Some(origin); return Some(origin);
@ -229,12 +227,12 @@ impl TreeNode {
child_index = 0; child_index = 0;
} else { } else {
child_index = 1; child_index = 1;
child_origin = child_origin + Vector2I::new(child_size as i32, 0); child_origin += vec2i(child_size as i32, 0);
} }
} else { } else {
if requested_origin.x() < this_center.x() { if requested_origin.x() < this_center.x() {
child_index = 2; child_index = 2;
child_origin = child_origin + Vector2I::new(0, child_size as i32); child_origin += vec2i(0, child_size as i32);
} else { } else {
child_index = 3; child_index = 3;
child_origin = this_center; child_origin = this_center;
@ -291,7 +289,7 @@ mod test {
let mut allocator = TextureAtlasAllocator::with_length(length); let mut allocator = TextureAtlasAllocator::with_length(length);
let mut locations = vec![]; let mut locations = vec![];
for &(width, height) in &sizes { for &(width, height) in &sizes {
let size = Vector2I::new(width as i32, height as i32); let size = vec2i(width as i32, height as i32);
if let Some(location) = allocator.allocate(size) { if let Some(location) = allocator.allocate(size) {
locations.push(location); locations.push(location);
} }

30
renderer/src/builder.rs
View File

@ -28,7 +28,7 @@ use pathfinder_geometry::line_segment::{LineSegment2F, LineSegmentU4, LineSegmen
use pathfinder_geometry::rect::{RectF, RectI}; use pathfinder_geometry::rect::{RectF, RectI};
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::util; use pathfinder_geometry::util;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2f, vec2i};
use pathfinder_gpu::TextureSamplingFlags; use pathfinder_gpu::TextureSamplingFlags;
use pathfinder_simd::default::{F32x4, I32x4}; use pathfinder_simd::default::{F32x4, I32x4};
use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::atomic::{AtomicUsize, Ordering};
@ -269,11 +269,11 @@ impl<'a> SceneBuilder<'a> {
let tile_rect = tiles::round_rect_out_to_tile_bounds(effective_view_box); let tile_rect = tiles::round_rect_out_to_tile_bounds(effective_view_box);
let layer_z_buffer = layer_z_buffers_stack.last().unwrap(); let layer_z_buffer = layer_z_buffers_stack.last().unwrap();
let mut tiles = vec![]; let mut tiles = vec![];
let uv_scale = Vector2F::splat(1.0) / tile_rect.lower_right().to_f32(); let uv_scale = vec2f(1.0, 1.0) / tile_rect.lower_right().to_f32();
let metadata = &render_target_metadata[render_target.0 as usize]; let metadata = &render_target_metadata[render_target.0 as usize];
for tile_y in tile_rect.min_y()..tile_rect.max_y() { for tile_y in tile_rect.min_y()..tile_rect.max_y() {
for tile_x in tile_rect.min_x()..tile_rect.max_x() { for tile_x in tile_rect.min_x()..tile_rect.max_x() {
let tile_coords = Vector2I::new(tile_x, tile_y); let tile_coords = vec2i(tile_x, tile_y);
if !layer_z_buffer.test(tile_coords, current_depth) { if !layer_z_buffer.test(tile_coords, current_depth) {
continue; continue;
} }
@ -716,8 +716,8 @@ impl ObjectBuilder {
tile_coords: Vector2I, tile_coords: Vector2I,
) { ) {
let tile_origin_y = (tile_coords.y() * TILE_HEIGHT as i32) as f32; let tile_origin_y = (tile_coords.y() * TILE_HEIGHT as i32) as f32;
let left = Vector2F::new(left, tile_origin_y); let left = vec2f(left, tile_origin_y);
let right = Vector2F::new(right, tile_origin_y); let right = vec2f(right, tile_origin_y);
let segment = if winding < 0 { let segment = if winding < 0 {
LineSegment2F::new(left, right) LineSegment2F::new(left, right)
@ -792,7 +792,7 @@ impl ObjectBuilder {
} }
let fill_segment = LineSegment2F::new(fill_from, fill_to); let fill_segment = LineSegment2F::new(fill_from, fill_to);
let fill_tile_coords = Vector2I::new(subsegment_tile_x, tile_y); let fill_tile_coords = vec2i(subsegment_tile_x, tile_y);
self.add_fill(scene_builder, fill_segment, fill_tile_coords); self.add_fill(scene_builder, fill_segment, fill_tile_coords);
} }
} }
@ -825,28 +825,28 @@ impl<'a> PackedTile<'a> {
fill_tile_backdrop, fill_tile_backdrop,
clip_tile_index, clip_tile_index,
clip_tile_backdrop, clip_tile_backdrop,
Vector2I::default(), Vector2I::zero(),
draw_tiling_path_info), draw_tiling_path_info),
upper_right: TileVertex::new_alpha(self.tile_coords, upper_right: TileVertex::new_alpha(self.tile_coords,
fill_tile_index, fill_tile_index,
fill_tile_backdrop, fill_tile_backdrop,
clip_tile_index, clip_tile_index,
clip_tile_backdrop, clip_tile_backdrop,
Vector2I::new(1, 0), vec2i(1, 0),
draw_tiling_path_info), draw_tiling_path_info),
lower_left: TileVertex::new_alpha(self.tile_coords, lower_left: TileVertex::new_alpha(self.tile_coords,
fill_tile_index, fill_tile_index,
fill_tile_backdrop, fill_tile_backdrop,
clip_tile_index, clip_tile_index,
clip_tile_backdrop, clip_tile_backdrop,
Vector2I::new(0, 1), vec2i(0, 1),
draw_tiling_path_info), draw_tiling_path_info),
lower_right: TileVertex::new_alpha(self.tile_coords, lower_right: TileVertex::new_alpha(self.tile_coords,
fill_tile_index, fill_tile_index,
fill_tile_backdrop, fill_tile_backdrop,
clip_tile_index, clip_tile_index,
clip_tile_backdrop, clip_tile_backdrop,
Vector2I::splat(1), vec2i(1, 1),
draw_tiling_path_info), draw_tiling_path_info),
}); });
} }
@ -886,20 +886,20 @@ impl TileVertex {
#[inline] #[inline]
pub fn tile_position(&self) -> Vector2I { pub fn tile_position(&self) -> Vector2I {
Vector2I::new(self.tile_x as i32, self.tile_y as i32) vec2i(self.tile_x as i32, self.tile_y as i32)
} }
} }
fn calculate_mask_uv(tile_index: u16, tile_offset: Vector2I) -> Vector2F { fn calculate_mask_uv(tile_index: u16, tile_offset: Vector2I) -> Vector2F {
let mask_u = tile_index as i32 % MASK_TILES_ACROSS as i32; let mask_u = tile_index as i32 % MASK_TILES_ACROSS as i32;
let mask_v = tile_index as i32 / MASK_TILES_ACROSS as i32; let mask_v = tile_index as i32 / MASK_TILES_ACROSS as i32;
let scale = Vector2F::new(1.0 / MASK_TILES_ACROSS as f32, 1.0 / MASK_TILES_DOWN as f32); let scale = vec2f(1.0 / MASK_TILES_ACROSS as f32, 1.0 / MASK_TILES_DOWN as f32);
(Vector2I::new(mask_u, mask_v) + tile_offset).to_f32().scale_xy(scale) (vec2i(mask_u, mask_v) + tile_offset).to_f32().scale_xy(scale)
} }
fn calculate_opacity_uv(draw_tiling_path_info: &DrawTilingPathInfo) -> Vector2F { fn calculate_opacity_uv(draw_tiling_path_info: &DrawTilingPathInfo) -> Vector2F {
let DrawTilingPathInfo { opacity_tile_transform, opacity, .. } = *draw_tiling_path_info; let DrawTilingPathInfo { opacity_tile_transform, opacity, .. } = *draw_tiling_path_info;
let texel_coord = (Vector2I::new((opacity % 16) as i32, (opacity / 16) as i32).to_f32() + let texel_coord = (vec2i((opacity % 16) as i32, (opacity / 16) as i32).to_f32() +
Vector2F::splat(0.5)).scale(1.0 / 16.0); vec2f(0.5, 0.5)).scale(1.0 / 16.0);
opacity_tile_transform * texel_coord opacity_tile_transform * texel_coord
} }

34
renderer/src/gpu/debug.rs
View File

@ -16,7 +16,7 @@
//! The debug font atlas was generated using: https://evanw.github.io/font-texture-generator/ //! The debug font atlas was generated using: https://evanw.github.io/font-texture-generator/
use crate::gpu::renderer::{RenderStats, RenderTime}; use crate::gpu::renderer::{RenderStats, RenderTime};
use pathfinder_geometry::vector::Vector2I; use pathfinder_geometry::vector::{Vector2I, vec2i};
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_gpu::Device; use pathfinder_gpu::Device;
use pathfinder_resources::ResourceLoader; use pathfinder_resources::ResourceLoader;
@ -85,16 +85,14 @@ where
let framebuffer_size = self.ui_presenter.framebuffer_size(); let framebuffer_size = self.ui_presenter.framebuffer_size();
let bottom = framebuffer_size.y() - PADDING; let bottom = framebuffer_size.y() - PADDING;
let window_rect = RectI::new( let window_rect = RectI::new(
Vector2I::new( vec2i(framebuffer_size.x() - PADDING - STATS_WINDOW_WIDTH,
framebuffer_size.x() - PADDING - STATS_WINDOW_WIDTH, bottom - PERFORMANCE_WINDOW_HEIGHT - PADDING - STATS_WINDOW_HEIGHT),
bottom - PERFORMANCE_WINDOW_HEIGHT - PADDING - STATS_WINDOW_HEIGHT, vec2i(STATS_WINDOW_WIDTH, STATS_WINDOW_HEIGHT),
),
Vector2I::new(STATS_WINDOW_WIDTH, STATS_WINDOW_HEIGHT),
); );
self.ui_presenter.draw_solid_rounded_rect(device, window_rect, WINDOW_COLOR); self.ui_presenter.draw_solid_rounded_rect(device, window_rect, WINDOW_COLOR);
let origin = window_rect.origin() + Vector2I::new(PADDING, PADDING + FONT_ASCENT); let origin = window_rect.origin() + vec2i(PADDING, PADDING + FONT_ASCENT);
self.ui_presenter.draw_text( self.ui_presenter.draw_text(
device, device,
&format!("Paths: {}", mean_cpu_sample.stats.path_count), &format!("Paths: {}", mean_cpu_sample.stats.path_count),
@ -104,19 +102,19 @@ where
self.ui_presenter.draw_text( self.ui_presenter.draw_text(
device, device,
&format!("Solid Tiles: {}", mean_cpu_sample.stats.solid_tile_count), &format!("Solid Tiles: {}", mean_cpu_sample.stats.solid_tile_count),
origin + Vector2I::new(0, LINE_HEIGHT * 1), origin + vec2i(0, LINE_HEIGHT * 1),
false, false,
); );
self.ui_presenter.draw_text( self.ui_presenter.draw_text(
device, device,
&format!("Alpha Tiles: {}", mean_cpu_sample.stats.alpha_tile_count), &format!("Alpha Tiles: {}", mean_cpu_sample.stats.alpha_tile_count),
origin + Vector2I::new(0, LINE_HEIGHT * 2), origin + vec2i(0, LINE_HEIGHT * 2),
false, false,
); );
self.ui_presenter.draw_text( self.ui_presenter.draw_text(
device, device,
&format!("Fills: {}", mean_cpu_sample.stats.fill_count), &format!("Fills: {}", mean_cpu_sample.stats.fill_count),
origin + Vector2I::new(0, LINE_HEIGHT * 3), origin + vec2i(0, LINE_HEIGHT * 3),
false, false,
); );
} }
@ -125,16 +123,14 @@ where
let framebuffer_size = self.ui_presenter.framebuffer_size(); let framebuffer_size = self.ui_presenter.framebuffer_size();
let bottom = framebuffer_size.y() - PADDING; let bottom = framebuffer_size.y() - PADDING;
let window_rect = RectI::new( let window_rect = RectI::new(
Vector2I::new( vec2i(framebuffer_size.x() - PADDING - PERFORMANCE_WINDOW_WIDTH,
framebuffer_size.x() - PADDING - PERFORMANCE_WINDOW_WIDTH, bottom - PERFORMANCE_WINDOW_HEIGHT),
bottom - PERFORMANCE_WINDOW_HEIGHT, vec2i(PERFORMANCE_WINDOW_WIDTH, PERFORMANCE_WINDOW_HEIGHT),
),
Vector2I::new(PERFORMANCE_WINDOW_WIDTH, PERFORMANCE_WINDOW_HEIGHT),
); );
self.ui_presenter.draw_solid_rounded_rect(device, window_rect, WINDOW_COLOR); self.ui_presenter.draw_solid_rounded_rect(device, window_rect, WINDOW_COLOR);
let origin = window_rect.origin() + Vector2I::new(PADDING, PADDING + FONT_ASCENT); let origin = window_rect.origin() + vec2i(PADDING, PADDING + FONT_ASCENT);
self.ui_presenter.draw_text( self.ui_presenter.draw_text(
device, device,
&format!( &format!(
@ -152,7 +148,7 @@ where
"Stage 0 GPU: {:.3} ms", "Stage 0 GPU: {:.3} ms",
duration_to_ms(mean_gpu_sample.time.stage_0) duration_to_ms(mean_gpu_sample.time.stage_0)
), ),
origin + Vector2I::new(0, LINE_HEIGHT * 1), origin + vec2i(0, LINE_HEIGHT * 1),
false, false,
); );
self.ui_presenter.draw_text( self.ui_presenter.draw_text(
@ -161,7 +157,7 @@ where
"Stage 1 GPU: {:.3} ms", "Stage 1 GPU: {:.3} ms",
duration_to_ms(mean_gpu_sample.time.stage_1) duration_to_ms(mean_gpu_sample.time.stage_1)
), ),
origin + Vector2I::new(0, LINE_HEIGHT * 2), origin + vec2i(0, LINE_HEIGHT * 2),
false, false,
); );
@ -171,7 +167,7 @@ where
self.ui_presenter.draw_text( self.ui_presenter.draw_text(
device, device,
&format!("Wallclock: {:.3} ms", wallclock_time), &format!("Wallclock: {:.3} ms", wallclock_time),
origin + Vector2I::new(0, LINE_HEIGHT * 3), origin + vec2i(0, LINE_HEIGHT * 3),
false, false,
); );
} }

12
renderer/src/gpu/renderer.rs
View File

@ -25,7 +25,7 @@ use pathfinder_content::render_target::RenderTargetId;
use pathfinder_geometry::line_segment::LineSegment2F; use pathfinder_geometry::line_segment::LineSegment2F;
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::transform3d::Transform4F; use pathfinder_geometry::transform3d::Transform4F;
use pathfinder_geometry::vector::{Vector2F, Vector2I, Vector4F}; use pathfinder_geometry::vector::{Vector2F, Vector2I, Vector4F, vec2f, vec2i};
use pathfinder_gpu::{BlendFactor, BlendState, BufferData, BufferTarget, BufferUploadMode}; use pathfinder_gpu::{BlendFactor, BlendState, BufferData, BufferTarget, BufferUploadMode};
use pathfinder_gpu::{ClearOps, DepthFunc, DepthState, Device, Primitive, RenderOptions}; use pathfinder_gpu::{ClearOps, DepthFunc, DepthState, Device, Primitive, RenderOptions};
use pathfinder_gpu::{RenderState, RenderTarget, StencilFunc, StencilState, TextureDataRef}; use pathfinder_gpu::{RenderState, RenderTarget, StencilFunc, StencilState, TextureDataRef};
@ -213,8 +213,7 @@ where
&quad_vertex_indices_buffer, &quad_vertex_indices_buffer,
); );
let fill_framebuffer_size = let fill_framebuffer_size = vec2i(MASK_FRAMEBUFFER_WIDTH, MASK_FRAMEBUFFER_HEIGHT);
Vector2I::new(MASK_FRAMEBUFFER_WIDTH, MASK_FRAMEBUFFER_HEIGHT);
let fill_framebuffer_texture = let fill_framebuffer_texture =
device.create_texture(TextureFormat::R16F, fill_framebuffer_size); device.create_texture(TextureFormat::R16F, fill_framebuffer_size);
let fill_framebuffer = device.create_framebuffer(fill_framebuffer_texture); let fill_framebuffer = device.create_framebuffer(fill_framebuffer_texture);
@ -907,8 +906,8 @@ where
let gauss_coeff_z = gauss_coeff_y * gauss_coeff_y; let gauss_coeff_z = gauss_coeff_y * gauss_coeff_y;
let src_offset = match direction { let src_offset = match direction {
BlurDirection::X => Vector2F::new(1.0, 0.0), BlurDirection::X => vec2f(1.0, 0.0),
BlurDirection::Y => Vector2F::new(0.0, 1.0), BlurDirection::Y => vec2f(0.0, 1.0),
}; };
let support = f32::ceil(1.5 * sigma) * 2.0; let support = f32::ceil(1.5 * sigma) * 2.0;
@ -1016,8 +1015,7 @@ where
} }
fn mask_viewport(&self) -> RectI { fn mask_viewport(&self) -> RectI {
RectI::new(Vector2I::default(), RectI::new(Vector2I::zero(), vec2i(MASK_FRAMEBUFFER_WIDTH, MASK_FRAMEBUFFER_HEIGHT))
Vector2I::new(MASK_FRAMEBUFFER_WIDTH, MASK_FRAMEBUFFER_HEIGHT))
} }
fn render_target_location(&self, render_target_id: RenderTargetId) -> TextureLocation { fn render_target_location(&self, render_target_id: RenderTargetId) -> TextureLocation {

18
renderer/src/paint.rs
View File

@ -22,7 +22,7 @@ use pathfinder_geometry::line_segment::LineSegment2F;
use pathfinder_geometry::rect::{RectF, RectI}; use pathfinder_geometry::rect::{RectF, RectI};
use pathfinder_geometry::transform2d::{Matrix2x2F, Transform2F}; use pathfinder_geometry::transform2d::{Matrix2x2F, Transform2F};
use pathfinder_geometry::util; use pathfinder_geometry::util;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2f, vec2i};
use pathfinder_gpu::TextureSamplingFlags; use pathfinder_gpu::TextureSamplingFlags;
use pathfinder_simd::default::{F32x2, F32x4}; use pathfinder_simd::default::{F32x2, F32x4};
use std::fmt::{self, Debug, Formatter}; use std::fmt::{self, Debug, Formatter};
@ -314,7 +314,7 @@ impl Palette {
let texture_origin_uv = rect_to_uv(metadata.location.rect, let texture_origin_uv = rect_to_uv(metadata.location.rect,
texture_scale).lower_left(); texture_scale).lower_left();
Transform2F::from_translation(texture_origin_uv) * Transform2F::from_translation(texture_origin_uv) *
Transform2F::from_scale(texture_scale.scale_xy(Vector2F::new(1.0, -1.0))) * Transform2F::from_scale(texture_scale.scale_xy(vec2f(1.0, -1.0))) *
transform.inverse() transform.inverse()
} }
} }
@ -400,7 +400,7 @@ impl Palette {
// 1. Calculate ∇t up front and use differencing in the inner loop. // 1. Calculate ∇t up front and use differencing in the inner loop.
// 2. Go four pixels at a time with SIMD. // 2. Go four pixels at a time with SIMD.
for x in 0..(GRADIENT_TILE_LENGTH as i32) { for x in 0..(GRADIENT_TILE_LENGTH as i32) {
let point = tex_rect.origin() + Vector2I::new(x, 0); let point = tex_rect.origin() + vec2i(x, 0);
let t = (x as f32 + 0.5) / GRADIENT_TILE_LENGTH as f32; let t = (x as f32 + 0.5) / GRADIENT_TILE_LENGTH as f32;
texels.put_texel(point, gradient.sample(t)); texels.put_texel(point, gradient.sample(t));
} }
@ -409,7 +409,7 @@ impl Palette {
fn render_image(&self, image: &Image, tex_rect: RectI, texels: &mut Texels) { fn render_image(&self, image: &Image, tex_rect: RectI, texels: &mut Texels) {
let image_size = image.size(); let image_size = image.size();
for y in 0..image_size.y() { for y in 0..image_size.y() {
let dest_origin = tex_rect.origin() + Vector2I::new(0, y); let dest_origin = tex_rect.origin() + vec2i(0, y);
let src_start_index = y as usize * image_size.x() as usize; let src_start_index = y as usize * image_size.x() as usize;
let src_end_index = src_start_index + image_size.x() as usize; let src_end_index = src_start_index + image_size.x() as usize;
texels.blit_scanline(dest_origin, &image.pixels()[src_start_index..src_end_index]); texels.blit_scanline(dest_origin, &image.pixels()[src_start_index..src_end_index]);
@ -420,7 +420,7 @@ impl Palette {
impl PaintMetadata { impl PaintMetadata {
// TODO(pcwalton): Apply clamp/repeat to tile rect. // TODO(pcwalton): Apply clamp/repeat to tile rect.
pub(crate) fn calculate_tex_coords(&self, tile_position: Vector2I) -> Vector2F { pub(crate) fn calculate_tex_coords(&self, tile_position: Vector2I) -> Vector2F {
let tile_size = Vector2I::new(TILE_WIDTH as i32, TILE_HEIGHT as i32); let tile_size = vec2i(TILE_WIDTH as i32, TILE_HEIGHT as i32);
let position = tile_position.scale_xy(tile_size).to_f32(); let position = tile_position.scale_xy(tile_size).to_f32();
let tex_coords = self.texture_transform * position; let tex_coords = self.texture_transform * position;
tex_coords tex_coords
@ -501,7 +501,7 @@ impl OpacityTileBuilder {
for y in 0..16 { for y in 0..16 {
for x in 0..16 { for x in 0..16 {
let color = ColorU::new(0xff, 0xff, 0xff, y * 16 + x); let color = ColorU::new(0xff, 0xff, 0xff, y * 16 + x);
let coords = self.tile_location.rect.origin() + Vector2I::new(x as i32, y as i32); let coords = self.tile_location.rect.origin() + vec2i(x as i32, y as i32);
texels.put_texel(coords, color); texels.put_texel(coords, color);
} }
} }
@ -542,7 +542,7 @@ impl SolidColorTileBuilder {
let (location, tile_full); let (location, tile_full);
{ {
let mut data = self.0.as_mut().unwrap(); let mut data = self.0.as_mut().unwrap();
let subtile_origin = Vector2I::new((data.next_index % SOLID_COLOR_TILE_LENGTH) as i32, let subtile_origin = vec2i((data.next_index % SOLID_COLOR_TILE_LENGTH) as i32,
(data.next_index / SOLID_COLOR_TILE_LENGTH) as i32); (data.next_index / SOLID_COLOR_TILE_LENGTH) as i32);
location = TextureLocation { location = TextureLocation {
page: data.tile_location.page, page: data.tile_location.page,
@ -589,8 +589,8 @@ impl GradientTileBuilder {
let mut data = self.0.as_mut().unwrap(); let mut data = self.0.as_mut().unwrap();
location = TextureLocation { location = TextureLocation {
page: data.page, page: data.page,
rect: RectI::new(Vector2I::new(0, data.next_index as i32), rect: RectI::new(vec2i(0, data.next_index as i32),
Vector2I::new(GRADIENT_TILE_LENGTH as i32, 1)), vec2i(GRADIENT_TILE_LENGTH as i32, 1)),
}; };
data.next_index += 1; data.next_index += 1;
tile_full = data.next_index == GRADIENT_TILE_LENGTH; tile_full = data.next_index == GRADIENT_TILE_LENGTH;

6
renderer/src/scene.rs
View File

@ -19,9 +19,9 @@ use pathfinder_content::effects::{BlendMode, Effects};
use pathfinder_content::fill::FillRule; use pathfinder_content::fill::FillRule;
use pathfinder_content::outline::Outline; use pathfinder_content::outline::Outline;
use pathfinder_content::render_target::RenderTargetId; use pathfinder_content::render_target::RenderTargetId;
use pathfinder_geometry::vector::{Vector2F, Vector2I};
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::vector::{Vector2I, vec2f};
#[derive(Clone)] #[derive(Clone)]
pub struct Scene { pub struct Scene {
@ -156,7 +156,7 @@ impl Scene {
PreparedRenderTransform::Perspective { .. } => unreachable!(), PreparedRenderTransform::Perspective { .. } => unreachable!(),
}; };
if options.subpixel_aa_enabled { if options.subpixel_aa_enabled {
transform *= Transform2F::from_scale(Vector2F::new(3.0, 1.0)) transform *= Transform2F::from_scale(vec2f(3.0, 1.0))
} }
outline.transform(&transform); outline.transform(&transform);
} }
@ -177,7 +177,7 @@ impl Scene {
#[inline] #[inline]
pub(crate) fn effective_view_box(&self, render_options: &PreparedBuildOptions) -> RectF { pub(crate) fn effective_view_box(&self, render_options: &PreparedBuildOptions) -> RectF {
if render_options.subpixel_aa_enabled { if render_options.subpixel_aa_enabled {
self.view_box.scale_xy(Vector2F::new(3.0, 1.0)) self.view_box.scale_xy(vec2f(3.0, 1.0))
} else { } else {
self.view_box self.view_box
} }

4
renderer/src/tile_map.rs
View File

@ -8,8 +8,8 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use pathfinder_geometry::vector::Vector2I;
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::vector::{Vector2I, vec2i};
#[derive(Debug)] #[derive(Debug)]
pub struct DenseTileMap<T> { pub struct DenseTileMap<T> {
@ -65,6 +65,6 @@ impl<T> DenseTileMap<T> {
#[inline] #[inline]
pub fn index_to_coords(&self, index: usize) -> Vector2I { pub fn index_to_coords(&self, index: usize) -> Vector2I {
let (width, index) = (self.rect.size().x(), index as i32); let (width, index) = (self.rect.size().x(), index as i32);
self.rect.origin() + Vector2I::new(index % width, index / width) self.rect.origin() + vec2i(index % width, index / width)
} }
} }

15
renderer/src/tiles.rs
View File

@ -19,7 +19,7 @@ use pathfinder_content::sorted_vector::SortedVector;
use pathfinder_geometry::line_segment::LineSegment2F; use pathfinder_geometry::line_segment::LineSegment2F;
use pathfinder_geometry::rect::{RectF, RectI}; use pathfinder_geometry::rect::{RectF, RectI};
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2f, vec2i};
use std::cmp::Ordering; use std::cmp::Ordering;
use std::mem; use std::mem;
@ -223,7 +223,7 @@ impl<'a> Tiler<'a> {
let current_x = let current_x =
(i32::from(current_tile_x) * TILE_WIDTH as i32) as f32 + current_subtile_x; (i32::from(current_tile_x) * TILE_WIDTH as i32) as f32 + current_subtile_x;
let tile_right_x = ((i32::from(current_tile_x) + 1) * TILE_WIDTH as i32) as f32; let tile_right_x = ((i32::from(current_tile_x) + 1) * TILE_WIDTH as i32) as f32;
let current_tile_coords = Vector2I::new(current_tile_x, tile_y); let current_tile_coords = vec2i(current_tile_x, tile_y);
self.object_builder.add_active_fill( self.object_builder.add_active_fill(
self.scene_builder, self.scene_builder,
current_x, current_x,
@ -241,7 +241,7 @@ impl<'a> Tiler<'a> {
"... emitting backdrop {} @ tile {}", "... emitting backdrop {} @ tile {}",
current_winding, current_tile_x current_winding, current_tile_x
); );
let current_tile_coords = Vector2I::new(current_tile_x, tile_y); let current_tile_coords = vec2i(current_tile_x, tile_y);
if let Some(tile_index) = self.object_builder if let Some(tile_index) = self.object_builder
.tile_coords_to_local_index(current_tile_coords) { .tile_coords_to_local_index(current_tile_coords) {
// FIXME(pcwalton): Handle winding overflow. // FIXME(pcwalton): Handle winding overflow.
@ -260,7 +260,7 @@ impl<'a> Tiler<'a> {
if segment_subtile_x > current_subtile_x { if segment_subtile_x > current_subtile_x {
let current_x = let current_x =
(i32::from(current_tile_x) * TILE_WIDTH as i32) as f32 + current_subtile_x; (i32::from(current_tile_x) * TILE_WIDTH as i32) as f32 + current_subtile_x;
let current_tile_coords = Vector2I::new(current_tile_x, tile_y); let current_tile_coords = vec2i(current_tile_x, tile_y);
self.object_builder.add_active_fill( self.object_builder.add_active_fill(
self.scene_builder, self.scene_builder,
current_x, current_x,
@ -499,12 +499,7 @@ impl<'a> PackedTile<'a> {
} }
pub fn round_rect_out_to_tile_bounds(rect: RectF) -> RectI { pub fn round_rect_out_to_tile_bounds(rect: RectF) -> RectI {
rect.scale_xy(Vector2F::new( rect.scale_xy(vec2f(1.0 / TILE_WIDTH as f32, 1.0 / TILE_HEIGHT as f32)).round_out().to_i32()
1.0 / TILE_WIDTH as f32,
1.0 / TILE_HEIGHT as f32,
))
.round_out()
.to_i32()
} }
fn process_active_segment( fn process_active_segment(

17
renderer/src/z_buffer.rs
View File

@ -17,7 +17,7 @@ use crate::tile_map::DenseTileMap;
use crate::tiles; use crate::tiles;
use pathfinder_content::effects::{BlendMode, Effects}; use pathfinder_content::effects::{BlendMode, Effects};
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2i};
use vec_map::VecMap; use vec_map::VecMap;
pub(crate) struct ZBuffer { pub(crate) struct ZBuffer {
@ -116,14 +116,11 @@ impl Tile {
-> Tile { -> Tile {
Tile { Tile {
upper_left: TileVertex::new_solid_from_paint_metadata(tile_position, paint_metadata), upper_left: TileVertex::new_solid_from_paint_metadata(tile_position, paint_metadata),
upper_right: TileVertex::new_solid_from_paint_metadata(tile_position + upper_right: TileVertex::new_solid_from_paint_metadata(tile_position + vec2i(1, 0),
Vector2I::new(1, 0),
paint_metadata), paint_metadata),
lower_left: TileVertex::new_solid_from_paint_metadata(tile_position + lower_left: TileVertex::new_solid_from_paint_metadata(tile_position + vec2i(0, 1),
Vector2I::new(0, 1),
paint_metadata), paint_metadata),
lower_right: TileVertex::new_solid_from_paint_metadata(tile_position + lower_right: TileVertex::new_solid_from_paint_metadata(tile_position + vec2i(1, 1),
Vector2I::new(1, 1),
paint_metadata), paint_metadata),
} }
} }
@ -132,11 +129,11 @@ impl Tile {
-> Tile { -> Tile {
Tile { Tile {
upper_left: TileVertex::new_solid_from_uv(tile_position, texture_rect.origin()), upper_left: TileVertex::new_solid_from_uv(tile_position, texture_rect.origin()),
upper_right: TileVertex::new_solid_from_uv(tile_position + Vector2I::new(1, 0), upper_right: TileVertex::new_solid_from_uv(tile_position + vec2i(1, 0),
texture_rect.upper_right()), texture_rect.upper_right()),
lower_left: TileVertex::new_solid_from_uv(tile_position + Vector2I::new(0, 1), lower_left: TileVertex::new_solid_from_uv(tile_position + vec2i(0, 1),
texture_rect.lower_left()), texture_rect.lower_left()),
lower_right: TileVertex::new_solid_from_uv(tile_position + Vector2I::new(1, 1), lower_right: TileVertex::new_solid_from_uv(tile_position + vec2i(1, 1),
texture_rect.lower_right()), texture_rect.lower_right()),
} }
} }

28
svg/src/lib.rs
View File

@ -23,7 +23,7 @@ use pathfinder_content::transform::Transform2FPathIter;
use pathfinder_geometry::line_segment::LineSegment2F; use pathfinder_geometry::line_segment::LineSegment2F;
use pathfinder_geometry::rect::RectF; use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::transform2d::Transform2F; use pathfinder_geometry::transform2d::Transform2F;
use pathfinder_geometry::vector::Vector2F; use pathfinder_geometry::vector::{Vector2F, vec2f};
use pathfinder_renderer::paint::Paint; use pathfinder_renderer::paint::Paint;
use pathfinder_renderer::scene::{ClipPath, ClipPathId, DrawPath, Scene}; use pathfinder_renderer::scene::{ClipPath, ClipPathId, DrawPath, Scene};
use std::fmt::{Display, Formatter, Result as FormatResult}; use std::fmt::{Display, Formatter, Result as FormatResult};
@ -312,10 +312,8 @@ impl PaintExt for Paint {
} }
fn usvg_rect_to_euclid_rect(rect: &UsvgRect) -> RectF { fn usvg_rect_to_euclid_rect(rect: &UsvgRect) -> RectF {
RectF::new( RectF::new(vec2f(rect.x() as f32, rect.y() as f32),
Vector2F::new(rect.x() as f32, rect.y() as f32), vec2f(rect.width() as f32, rect.height() as f32))
Vector2F::new(rect.width() as f32, rect.height() as f32),
)
} }
fn usvg_transform_to_transform_2d(transform: &UsvgTransform) -> Transform2F { fn usvg_transform_to_transform_2d(transform: &UsvgTransform) -> Transform2F {
@ -346,8 +344,8 @@ where
fn new(iter: I) -> UsvgPathToSegments<I> { fn new(iter: I) -> UsvgPathToSegments<I> {
UsvgPathToSegments { UsvgPathToSegments {
iter, iter,
first_subpath_point: Vector2F::default(), first_subpath_point: Vector2F::zero(),
last_subpath_point: Vector2F::default(), last_subpath_point: Vector2F::zero(),
just_moved: false, just_moved: false,
} }
} }
@ -362,14 +360,14 @@ where
fn next(&mut self) -> Option<Segment> { fn next(&mut self) -> Option<Segment> {
match self.iter.next()? { match self.iter.next()? {
UsvgPathSegment::MoveTo { x, y } => { UsvgPathSegment::MoveTo { x, y } => {
let to = Vector2F::new(x as f32, y as f32); let to = vec2f(x as f32, y as f32);
self.first_subpath_point = to; self.first_subpath_point = to;
self.last_subpath_point = to; self.last_subpath_point = to;
self.just_moved = true; self.just_moved = true;
self.next() self.next()
} }
UsvgPathSegment::LineTo { x, y } => { UsvgPathSegment::LineTo { x, y } => {
let to = Vector2F::new(x as f32, y as f32); let to = vec2f(x as f32, y as f32);
let mut segment = Segment::line(LineSegment2F::new(self.last_subpath_point, to)); let mut segment = Segment::line(LineSegment2F::new(self.last_subpath_point, to));
if self.just_moved { if self.just_moved {
segment.flags.insert(SegmentFlags::FIRST_IN_SUBPATH); segment.flags.insert(SegmentFlags::FIRST_IN_SUBPATH);
@ -386,13 +384,11 @@ where
x, x,
y, y,
} => { } => {
let ctrl0 = Vector2F::new(x1 as f32, y1 as f32); let ctrl0 = vec2f(x1 as f32, y1 as f32);
let ctrl1 = Vector2F::new(x2 as f32, y2 as f32); let ctrl1 = vec2f(x2 as f32, y2 as f32);
let to = Vector2F::new(x as f32, y as f32); let to = vec2f(x as f32, y as f32);
let mut segment = Segment::cubic( let mut segment = Segment::cubic(LineSegment2F::new(self.last_subpath_point, to),
LineSegment2F::new(self.last_subpath_point, to), LineSegment2F::new(ctrl0, ctrl1));
LineSegment2F::new(ctrl0, ctrl1),
);
if self.just_moved { if self.just_moved {
segment.flags.insert(SegmentFlags::FIRST_IN_SUBPATH); segment.flags.insert(SegmentFlags::FIRST_IN_SUBPATH);
} }

11
swf/src/lib.rs
View File

@ -13,7 +13,7 @@ use pathfinder_color::{ColorF, ColorU};
use pathfinder_content::fill::FillRule; use pathfinder_content::fill::FillRule;
use pathfinder_content::outline::{Outline, Contour}; use pathfinder_content::outline::{Outline, Contour};
use pathfinder_content::stroke::{OutlineStrokeToFill, StrokeStyle}; use pathfinder_content::stroke::{OutlineStrokeToFill, StrokeStyle};
use pathfinder_geometry::vector::Vector2F; use pathfinder_geometry::vector::{Vector2F, vec2f};
use pathfinder_renderer::scene::{DrawPath, Scene}; use pathfinder_renderer::scene::{DrawPath, Scene};
use swf_types::tags::SetBackgroundColor; use swf_types::tags::SetBackgroundColor;
@ -161,19 +161,16 @@ pub fn draw_paths_into_scene(library: &SymbolLibrary, scene: &mut Scene) {
for shape in style_layer.shapes() { for shape in style_layer.shapes() {
let mut contour = Contour::new(); let mut contour = Contour::new();
let Point2 { x, y } = shape.outline.first().unwrap().from.as_f32(); let Point2 { x, y } = shape.outline.first().unwrap().from.as_f32();
contour.push_endpoint(Vector2F::new(x, y)); contour.push_endpoint(vec2f(x, y));
for segment in &shape.outline { for segment in &shape.outline {
let Point2 { x, y } = segment.to.as_f32(); let Point2 { x, y } = segment.to.as_f32();
match segment.ctrl { match segment.ctrl {
Some(ctrl) => { Some(ctrl) => {
let Point2 { x: ctrl_x, y: ctrl_y } = ctrl.as_f32(); let Point2 { x: ctrl_x, y: ctrl_y } = ctrl.as_f32();
contour.push_quadratic( contour.push_quadratic(vec2f(ctrl_x, ctrl_y), vec2f(x, y));
Vector2F::new(ctrl_x, ctrl_y),
Vector2F::new(x, y)
);
} }
None => { None => {
contour.push_endpoint(Vector2F::new(x, y)); contour.push_endpoint(vec2f(x, y));
}, },
} }
} }

51
ui/src/lib.rs
View File

@ -19,7 +19,7 @@ extern crate serde_derive;
use hashbrown::HashMap; use hashbrown::HashMap;
use pathfinder_color::ColorU; use pathfinder_color::ColorU;
use pathfinder_geometry::rect::RectI; use pathfinder_geometry::rect::RectI;
use pathfinder_geometry::vector::{Vector2F, Vector2I}; use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2i};
use pathfinder_gpu::{BlendFactor, BlendState, BufferData, BufferTarget, BufferUploadMode, Device}; use pathfinder_gpu::{BlendFactor, BlendState, BufferData, BufferTarget, BufferUploadMode, Device};
use pathfinder_gpu::{Primitive, RenderOptions, RenderState, RenderTarget, UniformData}; use pathfinder_gpu::{Primitive, RenderOptions, RenderState, RenderTarget, UniformData};
use pathfinder_gpu::{VertexAttrClass, VertexAttrDescriptor, VertexAttrType}; use pathfinder_gpu::{VertexAttrClass, VertexAttrDescriptor, VertexAttrType};
@ -98,7 +98,7 @@ impl<D> UIPresenter<D> where D: Device {
UIPresenter { UIPresenter {
event_queue: UIEventQueue::new(), event_queue: UIEventQueue::new(),
mouse_position: Vector2F::default(), mouse_position: Vector2F::zero(),
framebuffer_size, framebuffer_size,
@ -205,10 +205,9 @@ impl<D> UIPresenter<D> where D: Device {
let info = &self.font.characters[&character]; let info = &self.font.characters[&character];
let position_rect = let position_rect =
RectI::new(Vector2I::new(next.x() - info.origin_x, next.y() - info.origin_y), RectI::new(vec2i(next.x() - info.origin_x, next.y() - info.origin_y),
Vector2I::new(info.width as i32, info.height as i32)); vec2i(info.width as i32, info.height as i32));
let tex_coord_rect = RectI::new(Vector2I::new(info.x, info.y), let tex_coord_rect = RectI::new(vec2i(info.x, info.y), vec2i(info.width, info.height));
Vector2I::new(info.width, info.height));
let first_vertex_index = vertex_data.len(); let first_vertex_index = vertex_data.len();
vertex_data.extend_from_slice(&[ vertex_data.extend_from_slice(&[
DebugTextureVertex::new(position_rect.origin(), tex_coord_rect.origin()), DebugTextureVertex::new(position_rect.origin(), tex_coord_rect.origin()),
@ -429,11 +428,11 @@ impl<D> UIPresenter<D> where D: Device {
} }
pub fn draw_button(&mut self, device: &D, origin: Vector2I, texture: &D::Texture) -> bool { pub fn draw_button(&mut self, device: &D, origin: Vector2I, texture: &D::Texture) -> bool {
let button_rect = RectI::new(origin, Vector2I::new(BUTTON_WIDTH, BUTTON_HEIGHT)); let button_rect = RectI::new(origin, vec2i(BUTTON_WIDTH, BUTTON_HEIGHT));
self.draw_solid_rounded_rect(device, button_rect, WINDOW_COLOR); self.draw_solid_rounded_rect(device, button_rect, WINDOW_COLOR);
self.draw_rounded_rect_outline(device, button_rect, OUTLINE_COLOR); self.draw_rounded_rect_outline(device, button_rect, OUTLINE_COLOR);
self.draw_texture(device, self.draw_texture(device,
origin + Vector2I::new(PADDING, PADDING), origin + vec2i(PADDING, PADDING),
texture, texture,
BUTTON_ICON_COLOR); BUTTON_ICON_COLOR);
self.event_queue.handle_mouse_down_in_rect(button_rect).is_some() self.event_queue.handle_mouse_down_in_rect(button_rect).is_some()
@ -452,15 +451,15 @@ impl<D> UIPresenter<D> where D: Device {
value = new_value; value = new_value;
} }
origin = origin + Vector2I::new(0, BUTTON_TEXT_OFFSET); origin = origin + vec2i(0, BUTTON_TEXT_OFFSET);
for (segment_index, segment_label) in segment_labels.iter().enumerate() { for (segment_index, segment_label) in segment_labels.iter().enumerate() {
let label_width = self.measure_text(segment_label); let label_width = self.measure_text(segment_label);
let offset = SEGMENT_SIZE / 2 - label_width / 2; let offset = SEGMENT_SIZE / 2 - label_width / 2;
self.draw_text(device, self.draw_text(device,
segment_label, segment_label,
origin + Vector2I::new(offset, 0), origin + vec2i(offset, 0),
segment_index as u8 == value); segment_index as u8 == value);
origin += Vector2I::new(SEGMENT_SIZE + 1, 0); origin += vec2i(SEGMENT_SIZE + 1, 0);
} }
value value
@ -485,7 +484,7 @@ impl<D> UIPresenter<D> where D: Device {
for (segment_index, segment_texture) in segment_textures.iter().enumerate() { for (segment_index, segment_texture) in segment_textures.iter().enumerate() {
let texture_width = device.texture_size(segment_texture).x(); let texture_width = device.texture_size(segment_texture).x();
let offset = Vector2I::new(SEGMENT_SIZE / 2 - texture_width / 2, PADDING); let offset = vec2i(SEGMENT_SIZE / 2 - texture_width / 2, PADDING);
let color = if Some(segment_index as u8) == value { let color = if Some(segment_index as u8) == value {
WINDOW_COLOR WINDOW_COLOR
} else { } else {
@ -493,7 +492,7 @@ impl<D> UIPresenter<D> where D: Device {
}; };
self.draw_texture(device, origin + offset, segment_texture, color); self.draw_texture(device, origin + offset, segment_texture, color);
origin += Vector2I::new(SEGMENT_SIZE + 1, 0); origin += vec2i(SEGMENT_SIZE + 1, 0);
} }
clicked_segment clicked_segment
@ -506,7 +505,7 @@ impl<D> UIPresenter<D> where D: Device {
segment_count: u8) segment_count: u8)
-> Option<u8> { -> Option<u8> {
let widget_width = self.measure_segmented_control(segment_count); let widget_width = self.measure_segmented_control(segment_count);
let widget_rect = RectI::new(origin, Vector2I::new(widget_width, BUTTON_HEIGHT)); let widget_rect = RectI::new(origin, vec2i(widget_width, BUTTON_HEIGHT));
let mut clicked_segment = None; let mut clicked_segment = None;
if let Some(position) = self.event_queue.handle_mouse_down_in_rect(widget_rect) { if let Some(position) = self.event_queue.handle_mouse_down_in_rect(widget_rect) {
@ -521,15 +520,14 @@ impl<D> UIPresenter<D> where D: Device {
self.draw_rounded_rect_outline(device, widget_rect, OUTLINE_COLOR); self.draw_rounded_rect_outline(device, widget_rect, OUTLINE_COLOR);
if let Some(value) = value { if let Some(value) = value {
let highlight_size = Vector2I::new(SEGMENT_SIZE, BUTTON_HEIGHT); let highlight_size = vec2i(SEGMENT_SIZE, BUTTON_HEIGHT);
let x_offset = value as i32 * SEGMENT_SIZE + (value as i32 - 1); let x_offset = value as i32 * SEGMENT_SIZE + (value as i32 - 1);
self.draw_solid_rounded_rect(device, self.draw_solid_rounded_rect(device,
RectI::new(origin + Vector2I::new(x_offset, 0), RectI::new(origin + vec2i(x_offset, 0), highlight_size),
highlight_size),
TEXT_COLOR); TEXT_COLOR);
} }
let mut segment_origin = origin + Vector2I::new(SEGMENT_SIZE + 1, 0); let mut segment_origin = origin + vec2i(SEGMENT_SIZE + 1, 0);
for next_segment_index in 1..segment_count { for next_segment_index in 1..segment_count {
let prev_segment_index = next_segment_index - 1; let prev_segment_index = next_segment_index - 1;
match value { match value {
@ -537,11 +535,11 @@ impl<D> UIPresenter<D> where D: Device {
_ => { _ => {
self.draw_line(device, self.draw_line(device,
segment_origin, segment_origin,
segment_origin + Vector2I::new(0, BUTTON_HEIGHT), segment_origin + vec2i(0, BUTTON_HEIGHT),
TEXT_COLOR); TEXT_COLOR);
} }
} }
segment_origin = segment_origin + Vector2I::new(SEGMENT_SIZE + 1, 0); segment_origin += vec2i(SEGMENT_SIZE + 1, 0);
} }
clicked_segment clicked_segment
@ -553,14 +551,11 @@ impl<D> UIPresenter<D> where D: Device {
} }
let text_size = self.measure_text(string); let text_size = self.measure_text(string);
let window_size = Vector2I::new(text_size + PADDING * 2, TOOLTIP_HEIGHT); let window_size = vec2i(text_size + PADDING * 2, TOOLTIP_HEIGHT);
let origin = rect.origin() - Vector2I::new(0, window_size.y() + PADDING); let origin = rect.origin() - vec2i(0, window_size.y() + PADDING);
self.draw_solid_rounded_rect(device, RectI::new(origin, window_size), WINDOW_COLOR); self.draw_solid_rounded_rect(device, RectI::new(origin, window_size), WINDOW_COLOR);
self.draw_text(device, self.draw_text(device, string, origin + vec2i(PADDING, PADDING + FONT_ASCENT), false);
string,
origin + Vector2I::new(PADDING, PADDING + FONT_ASCENT),
false);
} }
} }
@ -722,8 +717,8 @@ impl CornerRects {
let size = device.texture_size(texture); let size = device.texture_size(texture);
CornerRects { CornerRects {
upper_left: RectI::new(rect.origin(), size), upper_left: RectI::new(rect.origin(), size),
upper_right: RectI::new(rect.upper_right() - Vector2I::new(size.x(), 0), size), upper_right: RectI::new(rect.upper_right() - vec2i(size.x(), 0), size),
lower_left: RectI::new(rect.lower_left() - Vector2I::new(0, size.y()), size), lower_left: RectI::new(rect.lower_left() - vec2i(0, size.y()), size),
lower_right: RectI::new(rect.lower_right() - size, size), lower_right: RectI::new(rect.lower_right() - size, size),
} }
} }