Rename `Transform2DF` to `Transform2F` and `Transform3DF` to `Transform4F`
This commit is contained in:
Patrick Walton
parent
55825cbc6a
commit
bcac119324
24
c/src/lib.rs
24
c/src/lib.rs
|
|
@ -19,8 +19,8 @@ use pathfinder_content::color::{ColorF, ColorU};
|
|||
use pathfinder_content::outline::ArcDirection;
|
||||
use pathfinder_content::stroke::LineCap;
|
||||
use pathfinder_geometry::rect::{RectF, RectI};
|
||||
use pathfinder_geometry::transform2d::{Matrix2x2F, Transform2DF};
|
||||
use pathfinder_geometry::transform3d::{Perspective, Transform3DF};
|
||||
use pathfinder_geometry::transform2d::{Matrix2x2F, Transform2F};
|
||||
use pathfinder_geometry::transform3d::{Perspective, Transform4F};
|
||||
use pathfinder_geometry::vector::{Vector2F, Vector2I};
|
||||
use pathfinder_gl::{GLDevice, GLVersion};
|
||||
use pathfinder_gpu::resources::{FilesystemResourceLoader, ResourceLoader};
|
||||
|
|
@ -135,13 +135,13 @@ pub struct PFMatrix2x2F {
|
|||
}
|
||||
/// Row-major order.
|
||||
#[repr(C)]
|
||||
pub struct PFTransform2DF {
|
||||
pub struct PFTransform2F {
|
||||
pub matrix: PFMatrix2x2F,
|
||||
pub vector: PFVector2F,
|
||||
}
|
||||
/// Row-major order.
|
||||
#[repr(C)]
|
||||
pub struct PFTransform3DF {
|
||||
pub struct PFTransform4F {
|
||||
pub m00: f32, pub m01: f32, pub m02: f32, pub m03: f32,
|
||||
pub m10: f32, pub m11: f32, pub m12: f32, pub m13: f32,
|
||||
pub m20: f32, pub m21: f32, pub m22: f32, pub m23: f32,
|
||||
|
|
@ -149,7 +149,7 @@ pub struct PFTransform3DF {
|
|||
}
|
||||
#[repr(C)]
|
||||
pub struct PFPerspective {
|
||||
pub transform: PFTransform3DF,
|
||||
pub transform: PFTransform4F,
|
||||
pub window_size: PFVector2I,
|
||||
}
|
||||
|
||||
|
|
@ -610,7 +610,7 @@ pub unsafe extern "C" fn PFMetalDevicePresentDrawable(device: PFMetalDeviceRef)
|
|||
// `renderer`
|
||||
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn PFRenderTransformCreate2D(transform: *const PFTransform2DF)
|
||||
pub unsafe extern "C" fn PFRenderTransformCreate2D(transform: *const PFTransform2F)
|
||||
-> PFRenderTransformRef {
|
||||
Box::into_raw(Box::new(RenderTransform::Transform2D((*transform).to_rust())))
|
||||
}
|
||||
|
|
@ -743,17 +743,17 @@ impl PFMatrix2x2F {
|
|||
}
|
||||
}
|
||||
|
||||
impl PFTransform2DF {
|
||||
impl PFTransform2F {
|
||||
#[inline]
|
||||
pub fn to_rust(&self) -> Transform2DF {
|
||||
Transform2DF { matrix: self.matrix.to_rust(), vector: self.vector.to_rust() }
|
||||
pub fn to_rust(&self) -> Transform2F {
|
||||
Transform2F { matrix: self.matrix.to_rust(), vector: self.vector.to_rust() }
|
||||
}
|
||||
}
|
||||
|
||||
impl PFTransform3DF {
|
||||
impl PFTransform4F {
|
||||
#[inline]
|
||||
pub fn to_rust(&self) -> Transform3DF {
|
||||
Transform3DF::row_major(self.m00, self.m01, self.m02, self.m03,
|
||||
pub fn to_rust(&self) -> Transform4F {
|
||||
Transform4F::row_major(self.m00, self.m01, self.m02, self.m03,
|
||||
self.m10, self.m11, self.m12, self.m13,
|
||||
self.m20, self.m21, self.m22, self.m23,
|
||||
self.m30, self.m31, self.m32, self.m33)
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ use pathfinder_content::stroke::{OutlineStrokeToFill, StrokeStyle};
|
|||
use pathfinder_geometry::line_segment::LineSegment2F;
|
||||
use pathfinder_geometry::vector::Vector2F;
|
||||
use pathfinder_geometry::rect::RectF;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_renderer::paint::{Paint, PaintId};
|
||||
use pathfinder_renderer::scene::{PathObject, Scene};
|
||||
use pathfinder_text::{SceneExt, TextRenderMode};
|
||||
|
|
@ -115,7 +115,7 @@ impl CanvasRenderingContext2D {
|
|||
TextAlign::Center => position.set_x(position.x() - layout.width() * 0.5),
|
||||
}
|
||||
|
||||
let transform = Transform2DF::from_translation(position).post_mul(&self.current_state
|
||||
let transform = Transform2F::from_translation(position).post_mul(&self.current_state
|
||||
.transform);
|
||||
|
||||
// TODO(pcwalton): Report errors.
|
||||
|
|
@ -286,7 +286,7 @@ impl CanvasRenderingContext2D {
|
|||
let paint_id = self.scene.push_paint(&paint);
|
||||
|
||||
let mut outline = outline.clone();
|
||||
outline.transform(&Transform2DF::from_translation(self.current_state.shadow_offset));
|
||||
outline.transform(&Transform2F::from_translation(self.current_state.shadow_offset));
|
||||
self.scene.push_path(PathObject::new(outline, paint_id, String::new()))
|
||||
}
|
||||
|
||||
|
|
@ -296,18 +296,18 @@ impl CanvasRenderingContext2D {
|
|||
// Transformations
|
||||
|
||||
#[inline]
|
||||
pub fn current_transform(&self) -> Transform2DF {
|
||||
pub fn current_transform(&self) -> Transform2F {
|
||||
self.current_state.transform
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn set_current_transform(&mut self, new_transform: &Transform2DF) {
|
||||
pub fn set_current_transform(&mut self, new_transform: &Transform2F) {
|
||||
self.current_state.transform = *new_transform;
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn reset_transform(&mut self) {
|
||||
self.current_state.transform = Transform2DF::default();
|
||||
self.current_state.transform = Transform2F::default();
|
||||
}
|
||||
|
||||
// Compositing
|
||||
|
|
@ -339,7 +339,7 @@ impl CanvasRenderingContext2D {
|
|||
|
||||
#[derive(Clone)]
|
||||
struct State {
|
||||
transform: Transform2DF,
|
||||
transform: Transform2F,
|
||||
font_collection: Arc<FontCollection>,
|
||||
font_size: f32,
|
||||
line_width: f32,
|
||||
|
|
@ -359,7 +359,7 @@ struct State {
|
|||
impl State {
|
||||
fn default(default_font_collection: Arc<FontCollection>) -> State {
|
||||
State {
|
||||
transform: Transform2DF::default(),
|
||||
transform: Transform2F::default(),
|
||||
font_collection: default_font_collection,
|
||||
font_size: DEFAULT_FONT_SIZE,
|
||||
line_width: 1.0,
|
||||
|
|
@ -442,8 +442,8 @@ impl Path2D {
|
|||
start_angle: f32,
|
||||
end_angle: f32,
|
||||
direction: ArcDirection) {
|
||||
let mut transform = Transform2DF::from_scale(Vector2F::splat(radius));
|
||||
transform = transform.post_mul(&Transform2DF::from_translation(center));
|
||||
let mut transform = Transform2F::from_scale(Vector2F::splat(radius));
|
||||
transform = transform.post_mul(&Transform2F::from_translation(center));
|
||||
self.current_contour.push_arc(&transform, start_angle, end_angle, direction);
|
||||
}
|
||||
|
||||
|
|
@ -457,8 +457,8 @@ impl Path2D {
|
|||
let bisector = vu0 + vu1;
|
||||
let center = ctrl + bisector.scale(hypot / bisector.length());
|
||||
|
||||
let mut transform = Transform2DF::from_scale(Vector2F::splat(radius));
|
||||
transform = transform.post_mul(&Transform2DF::from_translation(center));
|
||||
let mut transform = Transform2F::from_scale(Vector2F::splat(radius));
|
||||
transform = transform.post_mul(&Transform2F::from_translation(center));
|
||||
|
||||
let chord = LineSegment2F::new(vu0.yx().scale_xy(Vector2F::new(-1.0, 1.0)),
|
||||
vu1.yx().scale_xy(Vector2F::new(1.0, -1.0)));
|
||||
|
|
@ -484,9 +484,9 @@ impl Path2D {
|
|||
end_angle: f32) {
|
||||
self.flush_current_contour();
|
||||
|
||||
let mut transform = Transform2DF::from_rotation(rotation);
|
||||
transform = transform.post_mul(&Transform2DF::from_scale(axes));
|
||||
transform = transform.post_mul(&Transform2DF::from_translation(center));
|
||||
let mut transform = Transform2F::from_rotation(rotation);
|
||||
transform = transform.post_mul(&Transform2F::from_scale(axes));
|
||||
transform = transform.post_mul(&Transform2F::from_translation(center));
|
||||
self.current_contour.push_arc(&transform, start_angle, end_angle, ArcDirection::CW);
|
||||
|
||||
if end_angle - start_angle >= 2.0 * PI {
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ use crate::orientation::Orientation;
|
|||
use crate::segment::{Segment, SegmentFlags, SegmentKind};
|
||||
use pathfinder_geometry::line_segment::LineSegment2F;
|
||||
use pathfinder_geometry::rect::RectF;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_geometry::transform3d::Perspective;
|
||||
use pathfinder_geometry::unit_vector::UnitVector;
|
||||
use pathfinder_geometry::vector::Vector2F;
|
||||
|
|
@ -134,7 +134,7 @@ impl Outline {
|
|||
self.contours.push(contour);
|
||||
}
|
||||
|
||||
pub fn transform(&mut self, transform: &Transform2DF) {
|
||||
pub fn transform(&mut self, transform: &Transform2F) {
|
||||
if transform.is_identity() {
|
||||
return;
|
||||
}
|
||||
|
|
@ -353,7 +353,7 @@ impl Contour {
|
|||
}
|
||||
|
||||
pub fn push_arc(&mut self,
|
||||
transform: &Transform2DF,
|
||||
transform: &Transform2F,
|
||||
start_angle: f32,
|
||||
end_angle: f32,
|
||||
direction: ArcDirection) {
|
||||
|
|
@ -367,13 +367,13 @@ impl Contour {
|
|||
}
|
||||
|
||||
pub fn push_arc_from_unit_chord(&mut self,
|
||||
transform: &Transform2DF,
|
||||
transform: &Transform2F,
|
||||
mut chord: LineSegment2F,
|
||||
direction: ArcDirection) {
|
||||
let mut direction_transform = Transform2DF::default();
|
||||
let mut direction_transform = Transform2F::default();
|
||||
if direction == ArcDirection::CCW {
|
||||
chord = chord.scale_xy(Vector2F::new(-1.0, 1.0));
|
||||
direction_transform = Transform2DF::from_scale(Vector2F::new(-1.0, 1.0));
|
||||
direction_transform = Transform2F::from_scale(Vector2F::new(-1.0, 1.0));
|
||||
}
|
||||
|
||||
let (mut vector, end_vector) = (UnitVector(chord.from()), UnitVector(chord.to()));
|
||||
|
|
@ -392,7 +392,7 @@ impl Contour {
|
|||
}
|
||||
|
||||
let half_sweep_vector = sweep_vector.halve_angle();
|
||||
let rotation = Transform2DF::from_rotation_vector(half_sweep_vector.rotate_by(vector));
|
||||
let rotation = Transform2F::from_rotation_vector(half_sweep_vector.rotate_by(vector));
|
||||
segment = segment.transform(&direction_transform.post_mul(&rotation)
|
||||
.post_mul(&transform));
|
||||
|
||||
|
|
@ -413,18 +413,18 @@ impl Contour {
|
|||
const EPSILON: f32 = 0.001;
|
||||
}
|
||||
|
||||
pub fn push_ellipse(&mut self, transform: &Transform2DF) {
|
||||
pub fn push_ellipse(&mut self, transform: &Transform2F) {
|
||||
let segment = Segment::quarter_circle_arc();
|
||||
let mut rotation;
|
||||
self.push_segment(&segment.transform(transform),
|
||||
PushSegmentFlags::UPDATE_BOUNDS | PushSegmentFlags::INCLUDE_FROM_POINT);
|
||||
rotation = Transform2DF::from_rotation_vector(UnitVector(Vector2F::new( 0.0, 1.0)));
|
||||
rotation = Transform2F::from_rotation_vector(UnitVector(Vector2F::new( 0.0, 1.0)));
|
||||
self.push_segment(&segment.transform(&rotation.post_mul(&transform)),
|
||||
PushSegmentFlags::UPDATE_BOUNDS);
|
||||
rotation = Transform2DF::from_rotation_vector(UnitVector(Vector2F::new(-1.0, 0.0)));
|
||||
rotation = Transform2F::from_rotation_vector(UnitVector(Vector2F::new(-1.0, 0.0)));
|
||||
self.push_segment(&segment.transform(&rotation.post_mul(&transform)),
|
||||
PushSegmentFlags::UPDATE_BOUNDS);
|
||||
rotation = Transform2DF::from_rotation_vector(UnitVector(Vector2F::new( 0.0, -1.0)));
|
||||
rotation = Transform2F::from_rotation_vector(UnitVector(Vector2F::new( 0.0, -1.0)));
|
||||
self.push_segment(&segment.transform(&rotation.post_mul(&transform)),
|
||||
PushSegmentFlags::UPDATE_BOUNDS);
|
||||
}
|
||||
|
|
@ -528,7 +528,7 @@ impl Contour {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn transform(&mut self, transform: &Transform2DF) {
|
||||
pub fn transform(&mut self, transform: &Transform2F) {
|
||||
if transform.is_identity() {
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
//! Line or curve segments, optimized with SIMD.
|
||||
|
||||
use pathfinder_geometry::line_segment::LineSegment2F;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_geometry::util::{self, EPSILON};
|
||||
use pathfinder_geometry::vector::Vector2F;
|
||||
use pathfinder_simd::default::F32x4;
|
||||
|
|
@ -215,7 +215,7 @@ impl Segment {
|
|||
}
|
||||
|
||||
#[inline]
|
||||
pub fn transform(self, transform: &Transform2DF) -> Segment {
|
||||
pub fn transform(self, transform: &Transform2F) -> Segment {
|
||||
Segment {
|
||||
baseline: transform.transform_line_segment(self.baseline),
|
||||
ctrl: transform.transform_line_segment(self.ctrl),
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ use crate::outline::{ArcDirection, Contour, Outline, PushSegmentFlags};
|
|||
use crate::segment::Segment;
|
||||
use pathfinder_geometry::line_segment::LineSegment2F;
|
||||
use pathfinder_geometry::rect::RectF;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_geometry::vector::Vector2F;
|
||||
use std::f32;
|
||||
|
||||
|
|
@ -138,9 +138,9 @@ impl<'a> OutlineStrokeToFill<'a> {
|
|||
LineCap::Round => {
|
||||
let scale = Vector2F::splat(width * 0.5);
|
||||
let offset = gradient.yx().scale_xy(Vector2F::new(-1.0, 1.0));
|
||||
let mut transform = Transform2DF::from_scale(scale);
|
||||
let mut transform = Transform2F::from_scale(scale);
|
||||
let translation = p1 + offset.scale(width * 0.5);
|
||||
transform = transform.post_mul(&Transform2DF::from_translation(translation));
|
||||
transform = transform.post_mul(&Transform2F::from_translation(translation));
|
||||
let chord = LineSegment2F::new(-offset, offset);
|
||||
contour.push_arc_from_unit_chord(&transform, chord, ArcDirection::CW);
|
||||
}
|
||||
|
|
@ -374,8 +374,8 @@ impl Contour {
|
|||
}
|
||||
LineJoin::Round => {
|
||||
let scale = Vector2F::splat(distance.abs());
|
||||
let mut transform = Transform2DF::from_scale(scale);
|
||||
transform = transform.post_mul(&Transform2DF::from_translation(join_point));
|
||||
let mut transform = Transform2F::from_scale(scale);
|
||||
transform = transform.post_mul(&Transform2F::from_translation(join_point));
|
||||
let chord_from = (prev_tangent.to() - join_point).normalize();
|
||||
let chord_to = (next_tangent.to() - join_point).normalize();
|
||||
let chord = LineSegment2F::new(chord_from, chord_to);
|
||||
|
|
|
|||
|
|
@ -11,19 +11,19 @@
|
|||
//! Utilities for transforming paths.
|
||||
|
||||
use crate::segment::Segment;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_geometry::transform3d::Perspective;
|
||||
|
||||
/// Transforms a path with a SIMD 2D transform.
|
||||
pub struct Transform2DFPathIter<I>
|
||||
pub struct Transform2FPathIter<I>
|
||||
where
|
||||
I: Iterator<Item = Segment>,
|
||||
{
|
||||
iter: I,
|
||||
transform: Transform2DF,
|
||||
transform: Transform2F,
|
||||
}
|
||||
|
||||
impl<I> Iterator for Transform2DFPathIter<I>
|
||||
impl<I> Iterator for Transform2FPathIter<I>
|
||||
where
|
||||
I: Iterator<Item = Segment>,
|
||||
{
|
||||
|
|
@ -47,13 +47,13 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<I> Transform2DFPathIter<I>
|
||||
impl<I> Transform2FPathIter<I>
|
||||
where
|
||||
I: Iterator<Item = Segment>,
|
||||
{
|
||||
#[inline]
|
||||
pub fn new(iter: I, transform: &Transform2DF) -> Transform2DFPathIter<I> {
|
||||
Transform2DFPathIter {
|
||||
pub fn new(iter: I, transform: &Transform2F) -> Transform2FPathIter<I> {
|
||||
Transform2FPathIter {
|
||||
iter,
|
||||
transform: *transform,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,8 +16,8 @@
|
|||
use crate::window::{OcularTransform, View};
|
||||
use pathfinder_geometry::vector::{Vector2F, Vector2I, Vector4F};
|
||||
use pathfinder_geometry::rect::RectF;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform3d::{Perspective, Transform3DF};
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_geometry::transform3d::{Perspective, Transform4F};
|
||||
use std::f32::consts::FRAC_PI_4;
|
||||
|
||||
const NEAR_CLIP_PLANE: f32 = 0.01;
|
||||
|
|
@ -27,7 +27,7 @@ const FAR_CLIP_PLANE: f32 = 10.0;
|
|||
const DEFAULT_EYE_OFFSET: f32 = 0.025;
|
||||
|
||||
pub enum Camera {
|
||||
TwoD(Transform2DF),
|
||||
TwoD(Transform2F),
|
||||
ThreeD {
|
||||
// The ocular transform used for rendering of the scene to the scene framebuffer. If we are
|
||||
// performing stereoscopic rendering, this is then reprojected according to the eye
|
||||
|
|
@ -56,7 +56,7 @@ impl Camera {
|
|||
let scale = i32::min(viewport_size.x(), viewport_size.y()) as f32
|
||||
* scale_factor_for_view_box(view_box);
|
||||
let origin = viewport_size.to_f32().scale(0.5) - view_box.size().scale(scale * 0.5);
|
||||
Camera::TwoD(Transform2DF::from_scale(Vector2F::splat(scale)).post_translate(origin))
|
||||
Camera::TwoD(Transform2F::from_scale(Vector2F::splat(scale)).post_translate(origin))
|
||||
}
|
||||
|
||||
fn new_3d(mode: Mode, view_box: RectF, viewport_size: Vector2I) -> Camera {
|
||||
|
|
@ -65,7 +65,7 @@ impl Camera {
|
|||
let fov_y = FRAC_PI_4;
|
||||
let aspect = viewport_size.x() as f32 / viewport_size.y() as f32;
|
||||
let projection =
|
||||
Transform3DF::from_perspective(fov_y, aspect, NEAR_CLIP_PLANE, FAR_CLIP_PLANE);
|
||||
Transform4F::from_perspective(fov_y, aspect, NEAR_CLIP_PLANE, FAR_CLIP_PLANE);
|
||||
let perspective = Perspective::new(&projection, viewport_size);
|
||||
|
||||
// Create a scene transform by moving the camera back from the center of the eyes so that
|
||||
|
|
@ -73,7 +73,7 @@ impl Camera {
|
|||
let z_offset = Vector4F::new(0.0, 0.0, -DEFAULT_EYE_OFFSET * projection.c0.x(), 1.0);
|
||||
let scene_transform = OcularTransform {
|
||||
perspective,
|
||||
modelview_to_eye: Transform3DF::from_translation(z_offset),
|
||||
modelview_to_eye: Transform4F::from_translation(z_offset),
|
||||
};
|
||||
|
||||
// For now, initialize the eye transforms as copies of the scene transform.
|
||||
|
|
@ -88,7 +88,7 @@ impl Camera {
|
|||
let this_eye_offset = Vector4F::new(this_eye_offset, 0.0, 0.0, 1.0);
|
||||
OcularTransform {
|
||||
perspective,
|
||||
modelview_to_eye: Transform3DF::from_translation(this_eye_offset),
|
||||
modelview_to_eye: Transform4F::from_translation(this_eye_offset),
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
|
|
@ -146,20 +146,20 @@ impl CameraTransform3D {
|
|||
pub fn offset(&mut self, vector: Vector4F) -> bool {
|
||||
let update = !vector.is_zero();
|
||||
if update {
|
||||
let rotation = Transform3DF::from_rotation(-self.yaw, -self.pitch, 0.0);
|
||||
let rotation = Transform4F::from_rotation(-self.yaw, -self.pitch, 0.0);
|
||||
self.position = self.position + rotation.transform_point(vector);
|
||||
}
|
||||
update
|
||||
}
|
||||
|
||||
pub fn to_transform(&self) -> Transform3DF {
|
||||
let mut transform = Transform3DF::from_rotation(self.yaw, self.pitch, 0.0);
|
||||
transform *= Transform3DF::from_uniform_scale(2.0 * self.scale);
|
||||
pub fn to_transform(&self) -> Transform4F {
|
||||
let mut transform = Transform4F::from_rotation(self.yaw, self.pitch, 0.0);
|
||||
transform *= Transform4F::from_uniform_scale(2.0 * self.scale);
|
||||
transform *=
|
||||
Transform3DF::from_translation(self.position * Vector4F::new(-1.0, -1.0, -1.0, 1.0));
|
||||
Transform4F::from_translation(self.position * Vector4F::new(-1.0, -1.0, -1.0, 1.0));
|
||||
|
||||
// Flip Y.
|
||||
transform *= Transform3DF::from_scale(Vector4F::new(1.0, -1.0, 1.0, 1.0));
|
||||
transform *= Transform4F::from_scale(Vector4F::new(1.0, -1.0, 1.0, 1.0));
|
||||
|
||||
transform
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,8 +25,8 @@ use clap::{App, Arg};
|
|||
use pathfinder_content::color::ColorU;
|
||||
use pathfinder_export::{Export, FileFormat};
|
||||
use pathfinder_geometry::rect::RectF;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform3d::Transform3DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_geometry::transform3d::Transform4F;
|
||||
use pathfinder_geometry::vector::{Vector2F, Vector2I, Vector4F};
|
||||
use pathfinder_gpu::resources::ResourceLoader;
|
||||
use pathfinder_gpu::Device;
|
||||
|
|
@ -368,7 +368,7 @@ impl<W> DemoApp<W> where W: Window {
|
|||
scene_transform.perspective.transform.c0.x();
|
||||
let z_offset = Vector4F::new(0.0, 0.0, z_offset, 1.0);
|
||||
scene_transform.modelview_to_eye =
|
||||
Transform3DF::from_translation(z_offset) *
|
||||
Transform4F::from_translation(z_offset) *
|
||||
scene_transform.modelview_to_eye;
|
||||
}
|
||||
}
|
||||
|
|
@ -627,7 +627,7 @@ impl<W> DemoApp<W> where W: Window {
|
|||
}
|
||||
UIAction::ZoomActualSize => {
|
||||
if let Camera::TwoD(ref mut transform) = self.camera {
|
||||
*transform = Transform2DF::default();
|
||||
*transform = Transform2F::default();
|
||||
self.dirty = true;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ use pathfinder_content::color::{ColorF, ColorU};
|
|||
use pathfinder_gpu::{ClearOps, DepthFunc, DepthState, Device, Primitive, RenderOptions};
|
||||
use pathfinder_gpu::{RenderState, RenderTarget, TextureData, TextureFormat, UniformData};
|
||||
use pathfinder_geometry::rect::RectI;
|
||||
use pathfinder_geometry::transform3d::Transform3DF;
|
||||
use pathfinder_geometry::transform3d::Transform4F;
|
||||
use pathfinder_geometry::vector::{Vector2I, Vector4F};
|
||||
use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions};
|
||||
use pathfinder_renderer::gpu::renderer::RenderMode;
|
||||
|
|
@ -165,7 +165,7 @@ impl<W> DemoApp<W> where W: Window {
|
|||
|
||||
let mut quad_scale = self.scene_metadata.view_box.size().to_3d();
|
||||
quad_scale.set_z(1.0);
|
||||
let quad_scale_transform = Transform3DF::from_scale(quad_scale);
|
||||
let quad_scale_transform = Transform4F::from_scale(quad_scale);
|
||||
|
||||
let scene_transform_matrix = scene_transform.perspective *
|
||||
scene_transform.modelview_to_eye *
|
||||
|
|
@ -213,11 +213,11 @@ impl<W> DemoApp<W> where W: Window {
|
|||
let mut offset = self.scene_metadata.view_box.lower_right().to_3d();
|
||||
offset.set_z(ground_scale);
|
||||
offset = offset * Vector4F::new(-0.5, 1.0, -0.5, 1.0);
|
||||
let base_transform = perspective.transform * Transform3DF::from_translation(offset);
|
||||
let base_transform = perspective.transform * Transform4F::from_translation(offset);
|
||||
|
||||
// Fill ground.
|
||||
let transform = base_transform *
|
||||
Transform3DF::from_scale(Vector4F::new(ground_scale, 1.0, ground_scale, 1.0));
|
||||
Transform4F::from_scale(Vector4F::new(ground_scale, 1.0, ground_scale, 1.0));
|
||||
|
||||
// Don't clear the first scene after drawing it.
|
||||
let clear_color = if render_scene_index == 0 {
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
|
||||
use pathfinder_geometry::vector::Vector2I;
|
||||
use pathfinder_geometry::rect::RectI;
|
||||
use pathfinder_geometry::transform3d::{Perspective, Transform3DF};
|
||||
use pathfinder_geometry::transform3d::{Perspective, Transform4F};
|
||||
use pathfinder_gpu::resources::ResourceLoader;
|
||||
use rayon::ThreadPoolBuilder;
|
||||
use std::path::PathBuf;
|
||||
|
|
@ -109,7 +109,7 @@ pub struct OcularTransform {
|
|||
pub perspective: Perspective,
|
||||
|
||||
// The view transform which converts from world coordinates to camera coordinates
|
||||
pub modelview_to_eye: Transform3DF,
|
||||
pub modelview_to_eye: Transform4F,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ use std::io;
|
|||
use pathfinder_geometry::point::Point2DI32;
|
||||
use pathfinder_geometry::rect::RectI32;
|
||||
use pathfinder_geometry::transform3d::Perspective;
|
||||
use pathfinder_geometry::transform3d::Transform3DF32;
|
||||
use pathfinder_geometry::transform3d::Transform4F32;
|
||||
use pathfinder_gl::GLVersion;
|
||||
use pathfinder_gpu::resources::ResourceLoader;
|
||||
|
||||
|
|
@ -36,7 +36,7 @@ pub trait DisplayCamera {
|
|||
type Error: DisplayError;
|
||||
|
||||
fn bounds(&self) -> RectI32;
|
||||
fn view(&self) -> Transform3DF32;
|
||||
fn view(&self) -> Transform4F32;
|
||||
fn perspective(&self) -> Perspective;
|
||||
|
||||
fn make_current(&mut self) -> Result<(), Self::Error>;
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ use crate::display::DisplayError;
|
|||
|
||||
use pathfinder_geometry::point::Point2DI32;
|
||||
use pathfinder_geometry::rect::RectI32;
|
||||
use pathfinder_geometry::transform3d::Transform3DF32;
|
||||
use pathfinder_geometry::transform3d::Transform4F32;
|
||||
use pathfinder_geometry::transform3d::Perspective;
|
||||
use pathfinder_gl::GLVersion;
|
||||
use pathfinder_gpu::resources::FilesystemResourceLoader;
|
||||
|
|
@ -149,15 +149,15 @@ impl DisplayCamera for GlWindowCamera {
|
|||
// TODO: add eye offsets
|
||||
let bounds = self.bounds();
|
||||
let aspect = bounds.size().x() as f32 / bounds.size().y() as f32;
|
||||
let transform = Transform3DF32::from_perspective(FRAC_PI_4, aspect, NEAR_CLIP_PLANE, FAR_CLIP_PLANE);
|
||||
let transform = Transform4F32::from_perspective(FRAC_PI_4, aspect, NEAR_CLIP_PLANE, FAR_CLIP_PLANE);
|
||||
Perspective::new(&transform, bounds.size())
|
||||
}
|
||||
|
||||
fn view(&self) -> Transform3DF32 {
|
||||
fn view(&self) -> Transform4F32 {
|
||||
let duration = Instant::now() - self.start;
|
||||
let rotation = duration.as_millis() as f32 / 1000.0;
|
||||
Transform3DF32::from_rotation(rotation, 0.0, 0.0)
|
||||
.pre_mul(&Transform3DF32::from_translation(0.0, 0.0, -CAMERA_DISTANCE))
|
||||
Transform4F32::from_rotation(rotation, 0.0, 0.0)
|
||||
.pre_mul(&Transform4F32::from_translation(0.0, 0.0, -CAMERA_DISTANCE))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,8 +19,8 @@ use pathfinder_geometry::point::Point2DI32;
|
|||
use pathfinder_geometry::point::Point2DF32;
|
||||
use pathfinder_geometry::point::Point3DF32;
|
||||
use pathfinder_geometry::rect::RectI32;
|
||||
use pathfinder_geometry::transform2d::Transform2DF32;
|
||||
use pathfinder_geometry::transform3d::Transform3DF32;
|
||||
use pathfinder_geometry::transform2d::Transform2F32;
|
||||
use pathfinder_geometry::transform3d::Transform4F32;
|
||||
use pathfinder_geometry::transform3d::Perspective;
|
||||
use pathfinder_gpu::Device;
|
||||
use pathfinder_simd::default::F32x4;
|
||||
|
|
@ -41,7 +41,7 @@ pub struct ImmersiveDemo<D> {
|
|||
renderer: Renderer<GLDevice>,
|
||||
scene_thread_proxy: SceneThreadProxy,
|
||||
svg_size: Point2DF32,
|
||||
svg_to_world: Option<Transform3DF32>,
|
||||
svg_to_world: Option<Transform4F32>,
|
||||
}
|
||||
|
||||
static DEFAULT_SVG_VIRTUAL_PATH: &'static str = "svg/Ghostscript_Tiger.svg";
|
||||
|
|
@ -87,13 +87,13 @@ impl<D: Display> ImmersiveDemo<D> {
|
|||
|
||||
let svg_size = self.svg_size;
|
||||
let svg_to_world = self.svg_to_world.get_or_insert_with(|| {
|
||||
let view: Transform3DF32 = cameras[0].view();
|
||||
let view: Transform4F32 = cameras[0].view();
|
||||
let svg_to_world_scale = f32::max(MAX_SVG_WIDTH / svg_size.x(), MAX_SVG_HEIGHT / svg_size.y());
|
||||
let svg_width = svg_size.x() * svg_to_world_scale;
|
||||
let svg_height = svg_size.y() * svg_to_world_scale;
|
||||
Transform3DF32::from_uniform_scale(svg_to_world_scale)
|
||||
.pre_mul(&Transform3DF32::from_translation(-svg_width / 2.0, -svg_height / 2.0, -DEFAULT_SVG_DISTANCE))
|
||||
.pre_mul(&Transform3DF32::from_scale(1.0, -1.0, 1.0))
|
||||
Transform4F32::from_uniform_scale(svg_to_world_scale)
|
||||
.pre_mul(&Transform4F32::from_translation(-svg_width / 2.0, -svg_height / 2.0, -DEFAULT_SVG_DISTANCE))
|
||||
.pre_mul(&Transform4F32::from_scale(1.0, -1.0, 1.0))
|
||||
.pre_mul(&view.inverse())
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ use pathfinder_demo::window::SVGPath;
|
|||
use pathfinder_geometry::vector::Vector2F;
|
||||
use pathfinder_geometry::vector::Vector2I;
|
||||
use pathfinder_geometry::rect::RectI;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_content::color::ColorF;
|
||||
use pathfinder_gl::GLDevice;
|
||||
use pathfinder_gl::GLVersion;
|
||||
|
|
@ -216,9 +216,9 @@ pub unsafe extern "C" fn magicleap_pathfinder_render(pf: *mut c_void, options: *
|
|||
|
||||
let scale = i32::min(viewport_size.x(), viewport_size.y()) as f32 /
|
||||
f32::max(svg.scene.bounds().size().x(), svg.scene.bounds().size().y());
|
||||
let transform = Transform2DF::from_translation(svg.scene.bounds().size().scale(-0.5))
|
||||
.post_mul(&Transform2DF::from_scale(Vector2F::splat(scale)))
|
||||
.post_mul(&Transform2DF::from_translation(viewport_size.to_f32().scale(0.5)));
|
||||
let transform = Transform2F::from_translation(svg.scene.bounds().size().scale(-0.5))
|
||||
.post_mul(&Transform2F::from_scale(Vector2F::splat(scale)))
|
||||
.post_mul(&Transform2F::from_translation(viewport_size.to_f32().scale(0.5)));
|
||||
|
||||
let render_options = RenderOptions {
|
||||
transform: RenderTransform::Transform2D(transform),
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ use pathfinder_geometry::vector::Vector2F;
|
|||
use pathfinder_geometry::rect::RectF;
|
||||
use pathfinder_geometry::rect::RectI;
|
||||
use pathfinder_geometry::transform3d::Perspective;
|
||||
use pathfinder_geometry::transform3d::Transform3DF;
|
||||
use pathfinder_geometry::transform3d::Transform4F;
|
||||
use pathfinder_geometry::util;
|
||||
use pathfinder_gl::GLVersion;
|
||||
use pathfinder_gpu::resources::FilesystemResourceLoader;
|
||||
|
|
@ -77,7 +77,7 @@ pub struct MagicLeapWindow {
|
|||
graphics_client: MLHandle,
|
||||
size: Vector2I,
|
||||
virtual_camera_array: MLGraphicsVirtualCameraInfoArray,
|
||||
initial_camera_transform: Option<Transform3DF>,
|
||||
initial_camera_transform: Option<Transform4F>,
|
||||
frame_handle: MLHandle,
|
||||
resource_loader: FilesystemResourceLoader,
|
||||
pose_event: Option<Vec<OcularTransform>>,
|
||||
|
|
@ -234,21 +234,21 @@ impl MagicLeapWindow {
|
|||
}
|
||||
let virtual_camera_array = &self.virtual_camera_array;
|
||||
let initial_camera = self.initial_camera_transform.get_or_insert_with(|| {
|
||||
let initial_offset = Transform3DF::from_translation(0.0, 0.0, 1.0);
|
||||
let initial_offset = Transform4F::from_translation(0.0, 0.0, 1.0);
|
||||
let mut camera = virtual_camera_array.virtual_cameras[0].transform;
|
||||
for i in 1..virtual_camera_array.num_virtual_cameras {
|
||||
let next = virtual_camera_array.virtual_cameras[i as usize].transform;
|
||||
camera = camera.lerp(next, 1.0 / (i as f32 + 1.0));
|
||||
}
|
||||
Transform3DF::from(camera).post_mul(&initial_offset)
|
||||
Transform4F::from(camera).post_mul(&initial_offset)
|
||||
});
|
||||
let camera_transforms = (0..virtual_camera_array.num_virtual_cameras)
|
||||
.map(|i| {
|
||||
let camera = &virtual_camera_array.virtual_cameras[i as usize];
|
||||
let projection = Transform3DF::from(camera.projection);
|
||||
let projection = Transform4F::from(camera.projection);
|
||||
let size = RectI::from(virtual_camera_array.viewport).size();
|
||||
let perspective = Perspective::new(&projection, size);
|
||||
let modelview_to_eye = Transform3DF::from(camera.transform).inverse().post_mul(initial_camera);
|
||||
let modelview_to_eye = Transform4F::from(camera.transform).inverse().post_mul(initial_camera);
|
||||
OcularTransform { perspective, modelview_to_eye }
|
||||
})
|
||||
.collect();
|
||||
|
|
@ -355,16 +355,16 @@ impl MLTransform {
|
|||
|
||||
// Impl pathfinder traits for c-api types
|
||||
|
||||
impl From<MLTransform> for Transform3DF {
|
||||
impl From<MLTransform> for Transform4F {
|
||||
fn from(mat: MLTransform) -> Self {
|
||||
Transform3DF::from(mat.rotation)
|
||||
.pre_mul(&Transform3DF::from(mat.position))
|
||||
Transform4F::from(mat.rotation)
|
||||
.pre_mul(&Transform4F::from(mat.position))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<MLVec3f> for Transform3DF {
|
||||
impl From<MLVec3f> for Transform4F {
|
||||
fn from(v: MLVec3f) -> Self {
|
||||
Transform3DF::from_translation(v.x, v.y, v.z)
|
||||
Transform4F::from_translation(v.x, v.y, v.z)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -380,16 +380,16 @@ impl From<MLRectf> for RectI {
|
|||
}
|
||||
}
|
||||
|
||||
impl From<MLQuaternionf> for Transform3DF {
|
||||
impl From<MLQuaternionf> for Transform4F {
|
||||
fn from(q: MLQuaternionf) -> Self {
|
||||
Transform3DF::from_rotation_quaternion(F32x4::new(q.x, q.y, q.z, q.w))
|
||||
Transform4F::from_rotation_quaternion(F32x4::new(q.x, q.y, q.z, q.w))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<MLMat4f> for Transform3DF {
|
||||
impl From<MLMat4f> for Transform4F {
|
||||
fn from(mat: MLMat4f) -> Self {
|
||||
let a = mat.matrix_colmajor;
|
||||
Transform3DF::row_major(a[0], a[4], a[8], a[12],
|
||||
Transform4F::row_major(a[0], a[4], a[8], a[12],
|
||||
a[1], a[5], a[9], a[13],
|
||||
a[2], a[6], a[10], a[14],
|
||||
a[3], a[7], a[11], a[15])
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ use pathfinder_renderer::scene::Scene;
|
|||
use pathfinder_swf::{draw_paths_into_scene, process_swf_tags};
|
||||
use std::env;
|
||||
use std::fs::read;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
|
||||
fn main() {
|
||||
let resource_loader = FilesystemResourceLoader::locate();
|
||||
|
|
@ -118,7 +118,7 @@ fn main() {
|
|||
// Render the canvas to screen.
|
||||
let scene = SceneProxy::from_scene(scene, RayonExecutor);
|
||||
let mut build_options = BuildOptions::default();
|
||||
let scale_transform = Transform2DF::from_scale(
|
||||
let scale_transform = Transform2F::from_scale(
|
||||
Vector2F::new(device_pixel_ratio, device_pixel_ratio)
|
||||
);
|
||||
build_options.transform = RenderTransform::Transform2D(scale_transform);
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
use crate::line_segment::LineSegment2F;
|
||||
use crate::vector::Vector2F;
|
||||
use crate::rect::RectF;
|
||||
use crate::transform3d::Transform3DF;
|
||||
use crate::transform3d::Transform4F;
|
||||
use crate::unit_vector::UnitVector;
|
||||
use pathfinder_simd::default::F32x4;
|
||||
use std::ops::Sub;
|
||||
|
|
@ -114,47 +114,47 @@ impl Sub<Matrix2x2F> for Matrix2x2F {
|
|||
|
||||
/// An affine transform, optimized with SIMD.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct Transform2DF {
|
||||
pub struct Transform2F {
|
||||
// Row-major order.
|
||||
pub matrix: Matrix2x2F,
|
||||
pub vector: Vector2F,
|
||||
}
|
||||
|
||||
impl Default for Transform2DF {
|
||||
impl Default for Transform2F {
|
||||
#[inline]
|
||||
fn default() -> Transform2DF {
|
||||
fn default() -> Transform2F {
|
||||
Self::from_scale(Vector2F::splat(1.0))
|
||||
}
|
||||
}
|
||||
|
||||
impl Transform2DF {
|
||||
impl Transform2F {
|
||||
#[inline]
|
||||
pub fn from_scale(scale: Vector2F) -> Transform2DF {
|
||||
Transform2DF {
|
||||
pub fn from_scale(scale: Vector2F) -> Transform2F {
|
||||
Transform2F {
|
||||
matrix: Matrix2x2F::from_scale(scale),
|
||||
vector: Vector2F::default(),
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_rotation(theta: f32) -> Transform2DF {
|
||||
Transform2DF {
|
||||
pub fn from_rotation(theta: f32) -> Transform2F {
|
||||
Transform2F {
|
||||
matrix: Matrix2x2F::from_rotation(theta),
|
||||
vector: Vector2F::default(),
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_rotation_vector(vector: UnitVector) -> Transform2DF {
|
||||
Transform2DF {
|
||||
pub fn from_rotation_vector(vector: UnitVector) -> Transform2F {
|
||||
Transform2F {
|
||||
matrix: Matrix2x2F::from_rotation_vector(vector),
|
||||
vector: Vector2F::default(),
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_translation(vector: Vector2F) -> Transform2DF {
|
||||
Transform2DF { matrix: Matrix2x2F::default(), vector }
|
||||
pub fn from_translation(vector: Vector2F) -> Transform2F {
|
||||
Transform2F { matrix: Matrix2x2F::default(), vector }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
|
@ -162,15 +162,15 @@ impl Transform2DF {
|
|||
scale: Vector2F,
|
||||
theta: f32,
|
||||
translation: Vector2F,
|
||||
) -> Transform2DF {
|
||||
let rotation = Transform2DF::from_rotation(theta);
|
||||
let translation = Transform2DF::from_translation(translation);
|
||||
Transform2DF::from_scale(scale).post_mul(&rotation).post_mul(&translation)
|
||||
) -> Transform2F {
|
||||
let rotation = Transform2F::from_rotation(theta);
|
||||
let translation = Transform2F::from_translation(translation);
|
||||
Transform2F::from_scale(scale).post_mul(&rotation).post_mul(&translation)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn row_major(m11: f32, m12: f32, m21: f32, m22: f32, m31: f32, m32: f32) -> Transform2DF {
|
||||
Transform2DF {
|
||||
pub fn row_major(m11: f32, m12: f32, m21: f32, m22: f32, m31: f32, m32: f32) -> Transform2F {
|
||||
Transform2F {
|
||||
matrix: Matrix2x2F::row_major(m11, m12, m21, m22),
|
||||
vector: Vector2F::new(m31, m32),
|
||||
}
|
||||
|
|
@ -199,21 +199,21 @@ impl Transform2DF {
|
|||
}
|
||||
|
||||
#[inline]
|
||||
pub fn post_mul(&self, other: &Transform2DF) -> Transform2DF {
|
||||
pub fn post_mul(&self, other: &Transform2F) -> Transform2F {
|
||||
let matrix = self.matrix.post_mul(&other.matrix);
|
||||
let vector = other.transform_point(self.vector);
|
||||
Transform2DF { matrix, vector }
|
||||
Transform2F { matrix, vector }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn pre_mul(&self, other: &Transform2DF) -> Transform2DF {
|
||||
pub fn pre_mul(&self, other: &Transform2F) -> Transform2F {
|
||||
other.post_mul(self)
|
||||
}
|
||||
|
||||
// TODO(pcwalton): Optimize better with SIMD.
|
||||
#[inline]
|
||||
pub fn to_3d(&self) -> Transform3DF {
|
||||
Transform3DF::row_major(
|
||||
pub fn to_3d(&self) -> Transform4F {
|
||||
Transform4F::row_major(
|
||||
self.matrix.0[0],
|
||||
self.matrix.0[1],
|
||||
0.0,
|
||||
|
|
@ -235,7 +235,7 @@ impl Transform2DF {
|
|||
|
||||
#[inline]
|
||||
pub fn is_identity(&self) -> bool {
|
||||
*self == Transform2DF::default()
|
||||
*self == Transform2F::default()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
|
@ -256,18 +256,18 @@ impl Transform2DF {
|
|||
}
|
||||
|
||||
#[inline]
|
||||
pub fn post_translate(&self, vector: Vector2F) -> Transform2DF {
|
||||
self.post_mul(&Transform2DF::from_translation(vector))
|
||||
pub fn post_translate(&self, vector: Vector2F) -> Transform2F {
|
||||
self.post_mul(&Transform2F::from_translation(vector))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn post_rotate(&self, theta: f32) -> Transform2DF {
|
||||
self.post_mul(&Transform2DF::from_rotation(theta))
|
||||
pub fn post_rotate(&self, theta: f32) -> Transform2F {
|
||||
self.post_mul(&Transform2F::from_rotation(theta))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn post_scale(&self, scale: Vector2F) -> Transform2DF {
|
||||
self.post_mul(&Transform2DF::from_scale(scale))
|
||||
pub fn post_scale(&self, scale: Vector2F) -> Transform2F {
|
||||
self.post_mul(&Transform2F::from_scale(scale))
|
||||
}
|
||||
|
||||
/// Returns the translation part of this matrix.
|
||||
|
|
|
|||
|
|
@ -21,17 +21,17 @@ use std::ops::{Add, Mul, MulAssign, Neg};
|
|||
/// In column-major order.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
#[repr(C)]
|
||||
pub struct Transform3DF {
|
||||
pub struct Transform4F {
|
||||
pub c0: F32x4,
|
||||
pub c1: F32x4,
|
||||
pub c2: F32x4,
|
||||
pub c3: F32x4,
|
||||
}
|
||||
|
||||
impl Default for Transform3DF {
|
||||
impl Default for Transform4F {
|
||||
#[inline]
|
||||
fn default() -> Transform3DF {
|
||||
Transform3DF {
|
||||
fn default() -> Transform4F {
|
||||
Transform4F {
|
||||
c0: F32x4::new(1.0, 0.0, 0.0, 0.0),
|
||||
c1: F32x4::new(0.0, 1.0, 0.0, 0.0),
|
||||
c2: F32x4::new(0.0, 0.0, 1.0, 0.0),
|
||||
|
|
@ -40,7 +40,7 @@ impl Default for Transform3DF {
|
|||
}
|
||||
}
|
||||
|
||||
impl Transform3DF {
|
||||
impl Transform4F {
|
||||
#[inline]
|
||||
pub fn row_major(
|
||||
m00: f32,
|
||||
|
|
@ -59,8 +59,8 @@ impl Transform3DF {
|
|||
m31: f32,
|
||||
m32: f32,
|
||||
m33: f32,
|
||||
) -> Transform3DF {
|
||||
Transform3DF {
|
||||
) -> Transform4F {
|
||||
Transform4F {
|
||||
c0: F32x4::new(m00, m10, m20, m30),
|
||||
c1: F32x4::new(m01, m11, m21, m31),
|
||||
c2: F32x4::new(m02, m12, m22, m32),
|
||||
|
|
@ -69,8 +69,8 @@ impl Transform3DF {
|
|||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_scale(scale: Vector4F) -> Transform3DF {
|
||||
Transform3DF {
|
||||
pub fn from_scale(scale: Vector4F) -> Transform4F {
|
||||
Transform4F {
|
||||
c0: F32x4::new(scale.x(), 0.0, 0.0, 0.0),
|
||||
c1: F32x4::new(0.0, scale.y(), 0.0, 0.0),
|
||||
c2: F32x4::new(0.0, 0.0, scale.z(), 0.0),
|
||||
|
|
@ -79,18 +79,18 @@ impl Transform3DF {
|
|||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_uniform_scale(factor: f32) -> Transform3DF {
|
||||
Transform3DF::from_scale(Vector4F::splat(factor))
|
||||
pub fn from_uniform_scale(factor: f32) -> Transform4F {
|
||||
Transform4F::from_scale(Vector4F::splat(factor))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_translation(mut translation: Vector4F) -> Transform3DF {
|
||||
pub fn from_translation(mut translation: Vector4F) -> Transform4F {
|
||||
translation.set_w(1.0);
|
||||
Transform3DF { c3: translation.0, ..Transform3DF::default() }
|
||||
Transform4F { c3: translation.0, ..Transform4F::default() }
|
||||
}
|
||||
|
||||
// TODO(pcwalton): Optimize.
|
||||
pub fn from_rotation(yaw: f32, pitch: f32, roll: f32) -> Transform3DF {
|
||||
pub fn from_rotation(yaw: f32, pitch: f32, roll: f32) -> Transform4F {
|
||||
let (cos_b, sin_b) = (yaw.cos(), yaw.sin());
|
||||
let (cos_c, sin_c) = (pitch.cos(), pitch.sin());
|
||||
let (cos_a, sin_a) = (roll.cos(), roll.sin());
|
||||
|
|
@ -103,7 +103,7 @@ impl Transform3DF {
|
|||
let m20 = -sin_b;
|
||||
let m21 = cos_b * sin_c;
|
||||
let m22 = cos_b * cos_c;
|
||||
Transform3DF::row_major(
|
||||
Transform4F::row_major(
|
||||
m00, m01, m02, 0.0, m10, m11, m12, 0.0, m20, m21, m22, 0.0, 0.0, 0.0, 0.0, 1.0,
|
||||
)
|
||||
}
|
||||
|
|
@ -112,7 +112,7 @@ impl Transform3DF {
|
|||
///
|
||||
/// The quaternion is expected to be packed into a SIMD type (x, y, z, w) corresponding to
|
||||
/// x + yi + zj + wk.
|
||||
pub fn from_rotation_quaternion(q: F32x4) -> Transform3DF {
|
||||
pub fn from_rotation_quaternion(q: F32x4) -> Transform4F {
|
||||
// TODO(pcwalton): Optimize better with more shuffles.
|
||||
let (mut sq, mut w, mut xy_xz_yz) = (q * q, q.wwww() * q, q.xxyy() * q.yzzy());
|
||||
sq += sq;
|
||||
|
|
@ -121,7 +121,7 @@ impl Transform3DF {
|
|||
let diag = F32x4::splat(1.0) - (sq.yxxy() + sq.zzyy());
|
||||
let (wx2, wy2, wz2) = (w.x(), w.y(), w.z());
|
||||
let (xy2, xz2, yz2) = (xy_xz_yz.x(), xy_xz_yz.y(), xy_xz_yz.z());
|
||||
Transform3DF::row_major(
|
||||
Transform4F::row_major(
|
||||
diag.x(),
|
||||
xy2 - wz2,
|
||||
xz2 + wy2,
|
||||
|
|
@ -150,14 +150,14 @@ impl Transform3DF {
|
|||
top: f32,
|
||||
near_val: f32,
|
||||
far_val: f32,
|
||||
) -> Transform3DF {
|
||||
) -> Transform4F {
|
||||
let x_inv = 1.0 / (right - left);
|
||||
let y_inv = 1.0 / (top - bottom);
|
||||
let z_inv = 1.0 / (far_val - near_val);
|
||||
let tx = -(right + left) * x_inv;
|
||||
let ty = -(top + bottom) * y_inv;
|
||||
let tz = -(far_val + near_val) * z_inv;
|
||||
Transform3DF::row_major(
|
||||
Transform4F::row_major(
|
||||
2.0 * x_inv,
|
||||
0.0,
|
||||
0.0,
|
||||
|
|
@ -178,17 +178,17 @@ impl Transform3DF {
|
|||
}
|
||||
|
||||
/// Linearly interpolate between transforms
|
||||
pub fn lerp(&self, weight: f32, other: &Transform3DF) -> Transform3DF {
|
||||
pub fn lerp(&self, weight: f32, other: &Transform4F) -> Transform4F {
|
||||
let c0 = self.c0 * F32x4::splat(weight) + other.c0 * F32x4::splat(1.0 - weight);
|
||||
let c1 = self.c1 * F32x4::splat(weight) + other.c1 * F32x4::splat(1.0 - weight);
|
||||
let c2 = self.c2 * F32x4::splat(weight) + other.c2 * F32x4::splat(1.0 - weight);
|
||||
let c3 = self.c3 * F32x4::splat(weight) + other.c3 * F32x4::splat(1.0 - weight);
|
||||
Transform3DF { c0, c1, c2, c3 }
|
||||
Transform4F { c0, c1, c2, c3 }
|
||||
}
|
||||
|
||||
/// Just like `gluPerspective()`.
|
||||
#[inline]
|
||||
pub fn from_perspective(fov_y: f32, aspect: f32, z_near: f32, z_far: f32) -> Transform3DF {
|
||||
pub fn from_perspective(fov_y: f32, aspect: f32, z_near: f32, z_far: f32) -> Transform4F {
|
||||
let f = 1.0 / (fov_y * 0.5).tan();
|
||||
let z_denom = 1.0 / (z_near - z_far);
|
||||
let m00 = f / aspect;
|
||||
|
|
@ -196,7 +196,7 @@ impl Transform3DF {
|
|||
let m22 = (z_far + z_near) * z_denom;
|
||||
let m23 = 2.0 * z_far * z_near * z_denom;
|
||||
let m32 = -1.0;
|
||||
Transform3DF::row_major(
|
||||
Transform4F::row_major(
|
||||
m00, 0.0, 0.0, 0.0, 0.0, m11, 0.0, 0.0, 0.0, 0.0, m22, m23, 0.0, 0.0, m32, 0.0,
|
||||
)
|
||||
}
|
||||
|
|
@ -211,8 +211,8 @@ impl Transform3DF {
|
|||
b: Matrix2x2F,
|
||||
c: Matrix2x2F,
|
||||
d: Matrix2x2F,
|
||||
) -> Transform3DF {
|
||||
Transform3DF {
|
||||
) -> Transform4F {
|
||||
Transform4F {
|
||||
c0: a.0.concat_xy_xy(c.0),
|
||||
c1: a.0.concat_zw_zw(c.0),
|
||||
c2: b.0.concat_xy_xy(d.0),
|
||||
|
|
@ -253,7 +253,7 @@ impl Transform3DF {
|
|||
//
|
||||
// If A is the upper left submatrix of this matrix, this method assumes that A and the Schur
|
||||
// complement of A are invertible.
|
||||
pub fn inverse(&self) -> Transform3DF {
|
||||
pub fn inverse(&self) -> Transform4F {
|
||||
// Extract submatrices.
|
||||
let (a, b) = (self.upper_left(), self.upper_right());
|
||||
let (c, d) = (self.lower_left(), self.lower_right());
|
||||
|
|
@ -269,10 +269,10 @@ impl Transform3DF {
|
|||
let (c_new, d_new) = ((-y).post_mul(&x), y);
|
||||
|
||||
// Construct inverse.
|
||||
Transform3DF::from_submatrices(a_new, b_new, c_new, d_new)
|
||||
Transform4F::from_submatrices(a_new, b_new, c_new, d_new)
|
||||
}
|
||||
|
||||
pub fn approx_eq(&self, other: &Transform3DF, epsilon: f32) -> bool {
|
||||
pub fn approx_eq(&self, other: &Transform4F, epsilon: f32) -> bool {
|
||||
self.c0.approx_eq(other.c0, epsilon)
|
||||
&& self.c1.approx_eq(other.c1, epsilon)
|
||||
&& self.c2.approx_eq(other.c2, epsilon)
|
||||
|
|
@ -290,13 +290,13 @@ impl Transform3DF {
|
|||
}
|
||||
}
|
||||
|
||||
impl Mul<Transform3DF> for Transform3DF {
|
||||
type Output = Transform3DF;
|
||||
impl Mul<Transform4F> for Transform4F {
|
||||
type Output = Transform4F;
|
||||
|
||||
// https://stackoverflow.com/a/18508113
|
||||
#[inline]
|
||||
fn mul(self, other: Transform3DF) -> Transform3DF {
|
||||
return Transform3DF {
|
||||
fn mul(self, other: Transform4F) -> Transform4F {
|
||||
return Transform4F {
|
||||
c0: mul_col(&self, other.c0),
|
||||
c1: mul_col(&self, other.c1),
|
||||
c2: mul_col(&self, other.c2),
|
||||
|
|
@ -304,14 +304,14 @@ impl Mul<Transform3DF> for Transform3DF {
|
|||
};
|
||||
|
||||
#[inline]
|
||||
fn mul_col(a: &Transform3DF, b_col: F32x4) -> F32x4 {
|
||||
fn mul_col(a: &Transform4F, b_col: F32x4) -> F32x4 {
|
||||
a.c0 * b_col.xxxx() + a.c1 * b_col.yyyy() + a.c2 * b_col.zzzz() + a.c3 * b_col.wwww()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl MulAssign<Transform3DF> for Transform3DF {
|
||||
fn mul_assign(&mut self, other: Transform3DF) {
|
||||
impl MulAssign<Transform4F> for Transform4F {
|
||||
fn mul_assign(&mut self, other: Transform4F) {
|
||||
*self = *self * other
|
||||
}
|
||||
}
|
||||
|
|
@ -334,13 +334,13 @@ impl Neg for Matrix2x2F {
|
|||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Perspective {
|
||||
pub transform: Transform3DF,
|
||||
pub transform: Transform4F,
|
||||
pub window_size: Vector2I,
|
||||
}
|
||||
|
||||
impl Perspective {
|
||||
#[inline]
|
||||
pub fn new(transform: &Transform3DF, window_size: Vector2I) -> Perspective {
|
||||
pub fn new(transform: &Transform4F, window_size: Vector2I) -> Perspective {
|
||||
Perspective {
|
||||
transform: *transform,
|
||||
window_size,
|
||||
|
|
@ -371,10 +371,10 @@ impl Perspective {
|
|||
}
|
||||
}
|
||||
|
||||
impl Mul<Transform3DF> for Perspective {
|
||||
impl Mul<Transform4F> for Perspective {
|
||||
type Output = Perspective;
|
||||
#[inline]
|
||||
fn mul(self, other: Transform3DF) -> Perspective {
|
||||
fn mul(self, other: Transform4F) -> Perspective {
|
||||
Perspective {
|
||||
transform: self.transform * other,
|
||||
window_size: self.window_size,
|
||||
|
|
@ -385,17 +385,17 @@ impl Mul<Transform3DF> for Perspective {
|
|||
#[cfg(test)]
|
||||
mod test {
|
||||
use crate::vector::Vector4F;
|
||||
use crate::transform3d::Transform3DF;
|
||||
use crate::transform3d::Transform4F;
|
||||
|
||||
#[test]
|
||||
fn test_post_mul() {
|
||||
let a = Transform3DF::row_major(
|
||||
let a = Transform4F::row_major(
|
||||
3.0, 1.0, 4.0, 5.0, 9.0, 2.0, 6.0, 5.0, 3.0, 5.0, 8.0, 9.0, 7.0, 9.0, 3.0, 2.0,
|
||||
);
|
||||
let b = Transform3DF::row_major(
|
||||
let b = Transform4F::row_major(
|
||||
3.0, 8.0, 4.0, 6.0, 2.0, 6.0, 4.0, 3.0, 3.0, 8.0, 3.0, 2.0, 7.0, 9.0, 5.0, 0.0,
|
||||
);
|
||||
let c = Transform3DF::row_major(
|
||||
let c = Transform4F::row_major(
|
||||
58.0, 107.0, 53.0, 29.0, 84.0, 177.0, 87.0, 72.0, 106.0, 199.0, 101.0, 49.0, 62.0,
|
||||
152.0, 83.0, 75.0,
|
||||
);
|
||||
|
|
@ -404,13 +404,13 @@ mod test {
|
|||
|
||||
#[test]
|
||||
fn test_pre_mul() {
|
||||
let a = Transform3DF::row_major(
|
||||
let a = Transform4F::row_major(
|
||||
3.0, 1.0, 4.0, 5.0, 9.0, 2.0, 6.0, 5.0, 3.0, 5.0, 8.0, 9.0, 7.0, 9.0, 3.0, 2.0,
|
||||
);
|
||||
let b = Transform3DF::row_major(
|
||||
let b = Transform4F::row_major(
|
||||
3.0, 8.0, 4.0, 6.0, 2.0, 6.0, 4.0, 3.0, 3.0, 8.0, 3.0, 2.0, 7.0, 9.0, 5.0, 0.0,
|
||||
);
|
||||
let c = Transform3DF::row_major(
|
||||
let c = Transform4F::row_major(
|
||||
135.0, 93.0, 110.0, 103.0, 93.0, 61.0, 85.0, 82.0, 104.0, 52.0, 90.0, 86.0, 117.0,
|
||||
50.0, 122.0, 125.0,
|
||||
);
|
||||
|
|
@ -419,7 +419,7 @@ mod test {
|
|||
|
||||
#[test]
|
||||
fn test_transform_point() {
|
||||
let a = Transform3DF::row_major(
|
||||
let a = Transform4F::row_major(
|
||||
3.0, 1.0, 4.0, 5.0, 9.0, 2.0, 6.0, 5.0, 3.0, 5.0, 8.0, 9.0, 7.0, 9.0, 3.0, 2.0,
|
||||
);
|
||||
let p = Vector4F::new(3.0, 8.0, 4.0, 6.0);
|
||||
|
|
@ -430,7 +430,7 @@ mod test {
|
|||
#[test]
|
||||
fn test_inverse() {
|
||||
// Random matrix.
|
||||
let m = Transform3DF::row_major(
|
||||
let m = Transform4F::row_major(
|
||||
0.86277982, 0.15986552, 0.90739898, 0.60066808, 0.17386167, 0.016353, 0.8535783,
|
||||
0.12969608, 0.0946466, 0.43248631, 0.63480505, 0.08154603, 0.50305436, 0.48359687,
|
||||
0.51057162, 0.24812012,
|
||||
|
|
@ -438,7 +438,7 @@ mod test {
|
|||
let p0 = Vector4F::new(0.95536648, 0.80633691, 0.16357357, 0.5477598);
|
||||
let p1 = m.transform_point(p0);
|
||||
let m_inv = m.inverse();
|
||||
let m_inv_exp = Transform3DF::row_major(
|
||||
let m_inv_exp = Transform4F::row_major(
|
||||
-2.47290136,
|
||||
3.48865688,
|
||||
-6.12298336,
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ use crate::resources::ResourceLoader;
|
|||
use image::ImageFormat;
|
||||
use pathfinder_content::color::ColorF;
|
||||
use pathfinder_geometry::rect::RectI;
|
||||
use pathfinder_geometry::transform3d::Transform3DF;
|
||||
use pathfinder_geometry::transform3d::Transform4F;
|
||||
use pathfinder_geometry::vector::Vector2I;
|
||||
use pathfinder_simd::default::{F32x2, F32x4};
|
||||
use std::time::Duration;
|
||||
|
|
@ -286,7 +286,7 @@ pub enum TextureData {
|
|||
|
||||
impl UniformData {
|
||||
#[inline]
|
||||
pub fn from_transform_3d(transform: &Transform3DF) -> UniformData {
|
||||
pub fn from_transform_3d(transform: &Transform4F) -> UniformData {
|
||||
UniformData::Mat4([transform.c0, transform.c1, transform.c2, transform.c3])
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ use crate::post::DefringingKernel;
|
|||
use crate::tiles::{TILE_HEIGHT, TILE_WIDTH};
|
||||
use pathfinder_geometry::vector::{Vector2I, Vector4F};
|
||||
use pathfinder_geometry::rect::RectI;
|
||||
use pathfinder_geometry::transform3d::Transform3DF;
|
||||
use pathfinder_geometry::transform3d::Transform4F;
|
||||
use pathfinder_content::color::ColorF;
|
||||
use pathfinder_gpu::resources::ResourceLoader;
|
||||
use pathfinder_gpu::{BlendState, BufferData, BufferTarget, BufferUploadMode, ClearOps};
|
||||
|
|
@ -468,14 +468,14 @@ where
|
|||
self.buffered_fills.clear();
|
||||
}
|
||||
|
||||
fn tile_transform(&self) -> Transform3DF {
|
||||
fn tile_transform(&self) -> Transform4F {
|
||||
let draw_viewport = self.draw_viewport().size().to_f32();
|
||||
let scale = F32x2::new(2.0 / draw_viewport.x(), -2.0 / draw_viewport.y());
|
||||
let transform = Transform3DF::from_scale(Vector4F::new(2.0 / draw_viewport.x(),
|
||||
let transform = Transform4F::from_scale(Vector4F::new(2.0 / draw_viewport.x(),
|
||||
-2.0 / draw_viewport.y(),
|
||||
1.0,
|
||||
1.0));
|
||||
Transform3DF::from_translation(Vector4F::new(-1.0, 1.0, 0.0, 1.0)) * transform
|
||||
Transform4F::from_translation(Vector4F::new(-1.0, 1.0, 0.0, 1.0)) * transform
|
||||
}
|
||||
|
||||
fn draw_alpha_tiles(&mut self, count: u32) {
|
||||
|
|
@ -738,8 +738,8 @@ where
|
|||
pub fn reproject_texture(
|
||||
&mut self,
|
||||
texture: &D::Texture,
|
||||
old_transform: &Transform3DF,
|
||||
new_transform: &Transform3DF,
|
||||
old_transform: &Transform4F,
|
||||
new_transform: &Transform4F,
|
||||
) {
|
||||
let clear_color = self.clear_color_for_draw_operation();
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
|
||||
use crate::gpu_data::RenderCommand;
|
||||
use pathfinder_geometry::rect::RectF;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_geometry::transform3d::Perspective;
|
||||
use pathfinder_geometry::vector::{Vector2F, Vector4F};
|
||||
use pathfinder_content::clip::PolygonClipper3D;
|
||||
|
|
@ -51,14 +51,14 @@ impl BuildOptions {
|
|||
|
||||
#[derive(Clone)]
|
||||
pub enum RenderTransform {
|
||||
Transform2D(Transform2DF),
|
||||
Transform2D(Transform2F),
|
||||
Perspective(Perspective),
|
||||
}
|
||||
|
||||
impl Default for RenderTransform {
|
||||
#[inline]
|
||||
fn default() -> RenderTransform {
|
||||
RenderTransform::Transform2D(Transform2DF::default())
|
||||
RenderTransform::Transform2D(Transform2F::default())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -140,7 +140,7 @@ pub(crate) type BoundingQuad = [Vector4F; 4];
|
|||
|
||||
pub(crate) enum PreparedRenderTransform {
|
||||
None,
|
||||
Transform2D(Transform2DF),
|
||||
Transform2D(Transform2F),
|
||||
Perspective {
|
||||
perspective: Perspective,
|
||||
clip_polygon: Vec<Vector2F>,
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ use crate::paint::{Paint, PaintId};
|
|||
use hashbrown::HashMap;
|
||||
use pathfinder_geometry::vector::Vector2F;
|
||||
use pathfinder_geometry::rect::RectF;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_content::color::ColorU;
|
||||
use pathfinder_content::outline::Outline;
|
||||
|
||||
|
|
@ -115,12 +115,12 @@ impl Scene {
|
|||
if options.transform.is_2d() || options.subpixel_aa_enabled {
|
||||
let mut transform = match options.transform {
|
||||
PreparedRenderTransform::Transform2D(transform) => transform,
|
||||
PreparedRenderTransform::None => Transform2DF::default(),
|
||||
PreparedRenderTransform::None => Transform2F::default(),
|
||||
PreparedRenderTransform::Perspective { .. } => unreachable!(),
|
||||
};
|
||||
if options.subpixel_aa_enabled {
|
||||
transform = transform
|
||||
.post_mul(&Transform2DF::from_scale(Vector2F::new(3.0, 1.0)))
|
||||
.post_mul(&Transform2F::from_scale(Vector2F::new(3.0, 1.0)))
|
||||
}
|
||||
outline.transform(&transform);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,10 +17,10 @@ use pathfinder_content::color::ColorU;
|
|||
use pathfinder_content::outline::Outline;
|
||||
use pathfinder_content::segment::{Segment, SegmentFlags};
|
||||
use pathfinder_content::stroke::{LineCap, LineJoin, OutlineStrokeToFill, StrokeStyle};
|
||||
use pathfinder_content::transform::Transform2DFPathIter;
|
||||
use pathfinder_content::transform::Transform2FPathIter;
|
||||
use pathfinder_geometry::line_segment::LineSegment2F;
|
||||
use pathfinder_geometry::rect::RectF;
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_geometry::vector::Vector2F;
|
||||
use pathfinder_renderer::paint::Paint;
|
||||
use pathfinder_renderer::scene::{PathObject, Scene};
|
||||
|
|
@ -62,7 +62,7 @@ bitflags! {
|
|||
impl BuiltSVG {
|
||||
// TODO(pcwalton): Allow a global transform to be set.
|
||||
pub fn from_tree(tree: Tree) -> BuiltSVG {
|
||||
let global_transform = Transform2DF::default();
|
||||
let global_transform = Transform2F::default();
|
||||
|
||||
let mut built_svg = BuiltSVG {
|
||||
scene: Scene::new(),
|
||||
|
|
@ -87,7 +87,7 @@ impl BuiltSVG {
|
|||
built_svg
|
||||
}
|
||||
|
||||
fn process_node(&mut self, node: &Node, transform: &Transform2DF) {
|
||||
fn process_node(&mut self, node: &Node, transform: &Transform2F) {
|
||||
let node_transform = usvg_transform_to_transform_2d(&node.transform());
|
||||
let transform = transform.pre_mul(&node_transform);
|
||||
|
||||
|
|
@ -119,7 +119,7 @@ impl BuiltSVG {
|
|||
));
|
||||
|
||||
let path = UsvgPathToSegments::new(path.segments.iter().cloned());
|
||||
let path = Transform2DFPathIter::new(path, &transform);
|
||||
let path = Transform2FPathIter::new(path, &transform);
|
||||
let outline = Outline::from_segments(path);
|
||||
|
||||
let name = format!("Fill({})", node.id());
|
||||
|
|
@ -266,8 +266,8 @@ fn usvg_rect_to_euclid_rect(rect: &UsvgRect) -> RectF {
|
|||
)
|
||||
}
|
||||
|
||||
fn usvg_transform_to_transform_2d(transform: &UsvgTransform) -> Transform2DF {
|
||||
Transform2DF::row_major(
|
||||
fn usvg_transform_to_transform_2d(transform: &UsvgTransform) -> Transform2F {
|
||||
Transform2F::row_major(
|
||||
transform.a as f32,
|
||||
transform.b as f32,
|
||||
transform.c as f32,
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ use font_kit::loader::Loader;
|
|||
use lyon_path::builder::{FlatPathBuilder, PathBuilder};
|
||||
use pathfinder_content::outline::{Contour, Outline};
|
||||
use pathfinder_content::stroke::{OutlineStrokeToFill, StrokeStyle};
|
||||
use pathfinder_geometry::transform2d::Transform2DF;
|
||||
use pathfinder_geometry::transform2d::Transform2F;
|
||||
use pathfinder_geometry::vector::Vector2F;
|
||||
use pathfinder_renderer::paint::PaintId;
|
||||
use pathfinder_renderer::scene::{PathObject, Scene};
|
||||
|
|
@ -27,7 +27,7 @@ pub trait SceneExt {
|
|||
fn push_glyph<F>(&mut self,
|
||||
font: &F,
|
||||
glyph_id: u32,
|
||||
transform: &Transform2DF,
|
||||
transform: &Transform2F,
|
||||
render_mode: TextRenderMode,
|
||||
hinting_options: HintingOptions,
|
||||
paint_id: PaintId)
|
||||
|
|
@ -37,7 +37,7 @@ pub trait SceneExt {
|
|||
fn push_layout(&mut self,
|
||||
layout: &Layout,
|
||||
style: &TextStyle,
|
||||
transform: &Transform2DF,
|
||||
transform: &Transform2F,
|
||||
render_mode: TextRenderMode,
|
||||
hinting_options: HintingOptions,
|
||||
paint_id: PaintId)
|
||||
|
|
@ -47,7 +47,7 @@ pub trait SceneExt {
|
|||
text: &str,
|
||||
style: &TextStyle,
|
||||
collection: &FontCollection,
|
||||
transform: &Transform2DF,
|
||||
transform: &Transform2F,
|
||||
render_mode: TextRenderMode,
|
||||
hinting_options: HintingOptions,
|
||||
paint_id: PaintId)
|
||||
|
|
@ -59,7 +59,7 @@ impl SceneExt for Scene {
|
|||
fn push_glyph<F>(&mut self,
|
||||
font: &F,
|
||||
glyph_id: u32,
|
||||
transform: &Transform2DF,
|
||||
transform: &Transform2F,
|
||||
render_mode: TextRenderMode,
|
||||
hinting_options: HintingOptions,
|
||||
paint_id: PaintId)
|
||||
|
|
@ -82,7 +82,7 @@ impl SceneExt for Scene {
|
|||
fn push_layout(&mut self,
|
||||
layout: &Layout,
|
||||
style: &TextStyle,
|
||||
transform: &Transform2DF,
|
||||
transform: &Transform2F,
|
||||
render_mode: TextRenderMode,
|
||||
hinting_options: HintingOptions,
|
||||
paint_id: PaintId)
|
||||
|
|
@ -94,7 +94,7 @@ impl SceneExt for Scene {
|
|||
let scale = style.size / (font.metrics().units_per_em as f32);
|
||||
let scale = Vector2F::new(scale, -scale);
|
||||
let transform =
|
||||
Transform2DF::from_scale(scale).post_translate(offset).post_mul(transform);
|
||||
Transform2F::from_scale(scale).post_translate(offset).post_mul(transform);
|
||||
self.push_glyph(font,
|
||||
glyph.glyph_id,
|
||||
&transform,
|
||||
|
|
@ -110,7 +110,7 @@ impl SceneExt for Scene {
|
|||
text: &str,
|
||||
style: &TextStyle,
|
||||
collection: &FontCollection,
|
||||
transform: &Transform2DF,
|
||||
transform: &Transform2F,
|
||||
render_mode: TextRenderMode,
|
||||
hinting_options: HintingOptions,
|
||||
paint_id: PaintId)
|
||||
|
|
@ -129,11 +129,11 @@ pub enum TextRenderMode {
|
|||
struct OutlinePathBuilder {
|
||||
outline: Outline,
|
||||
current_contour: Contour,
|
||||
transform: Transform2DF,
|
||||
transform: Transform2F,
|
||||
}
|
||||
|
||||
impl OutlinePathBuilder {
|
||||
fn new(transform: &Transform2DF) -> OutlinePathBuilder {
|
||||
fn new(transform: &Transform2F) -> OutlinePathBuilder {
|
||||
OutlinePathBuilder {
|
||||
outline: Outline::new(),
|
||||
current_contour: Contour::new(),
|
||||
|
|
|
|||
Loading…
Reference in New Issue