Struct PxPosition

pub struct PxPosition {
    pub x: Px,
    pub y: Px,
}

A 2D position in physical pixel space.

This type represents a position with x and y coordinates in physical pixel space. Physical pixels correspond directly to screen pixels and are used internally by the rendering system.

Coordinate System

• Origin (0, 0) is at the top-left corner
• X-axis increases to the right
• Y-axis increases downward
• Negative coordinates are supported for scrolling and off-screen positioning

Examples

use tessera_ui::px::{Px, PxPosition};

// Create a position
let position = PxPosition::new(Px::new(100), Px::new(200));

// Offset the position
let offset_position = position.offset(Px::new(10), Px::new(-5));

// Calculate distance between positions
let other_position = PxPosition::new(Px::new(103), Px::new(196));
let distance = position.distance_to(other_position);

// Arithmetic operations
let sum = position + other_position;
let diff = position - other_position;

Fields

x: Px

The x-coordinate in physical pixels

y: Px

The y-coordinate in physical pixels

Implementations

impl PxPosition

pub const ZERO: Self

A constant representing the zero position (0, 0).

pub const fn new(x: Px, y: Px) -> Self

Creates a new position from x and y coordinates.

Arguments

• x - The x-coordinate in physical pixels
• y - The y-coordinate in physical pixels

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::new(Px::new(100), Px::new(200));
assert_eq!(position.x, Px::new(100));
assert_eq!(position.y, Px::new(200));

pub fn offset(self, dx: Px, dy: Px) -> Self

Offsets the position by the given deltas.

Panics

This function may panic on overflow in debug builds.

Arguments

• dx - The x-axis offset in physical pixels
• dy - The y-axis offset in physical pixels

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::new(Px::new(10), Px::new(20));
let offset_position = position.offset(Px::new(5), Px::new(-3));
assert_eq!(offset_position, PxPosition::new(Px::new(15), Px::new(17)));

pub fn saturating_offset(self, dx: Px, dy: Px) -> Self

Offsets the position with saturating arithmetic.

This prevents overflow by clamping the result to the valid coordinate range.

Arguments

• dx - The x-axis offset in physical pixels
• dy - The y-axis offset in physical pixels

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::new(Px::new(10), Px::new(20));
let offset_position = position.saturating_offset(Px::new(5), Px::new(-3));
assert_eq!(offset_position, PxPosition::new(Px::new(15), Px::new(17)));

// Prevents overflow
let max_position = PxPosition::new(Px::new(i32::MAX), Px::new(i32::MAX));
let safe_offset = max_position.saturating_offset(Px::new(1), Px::new(1));
assert_eq!(safe_offset, max_position);

pub fn distance_to(self, other: Self) -> f32

Calculates the Euclidean distance to another position.

Arguments

• other - The other position to calculate distance to

Returns

The distance as a floating-point value

Examples

use tessera_ui::px::{Px, PxPosition};

let pos1 = PxPosition::new(Px::new(0), Px::new(0));
let pos2 = PxPosition::new(Px::new(3), Px::new(4));
assert_eq!(pos1.distance_to(pos2), 5.0);

pub fn to_f32_arr2(self) -> [f32; 2]

Converts the position to a 2D f32 array.

Returns

An array [x, y] where both coordinates are converted to f32

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::new(Px::new(10), Px::new(20));
assert_eq!(position.to_f32_arr2(), [10.0, 20.0]);

pub fn to_f32_arr3(self) -> [f32; 3]

Converts the position to a 3D f32 array with z=0.

Returns

An array [x, y, 0.0] where x and y are converted to f32 and z is 0.0

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::new(Px::new(10), Px::new(20));
assert_eq!(position.to_f32_arr3(), [10.0, 20.0, 0.0]);

pub fn from_f32_arr2(arr: [f32; 2]) -> Self

Creates a position from a 2D f32 array.

Arguments

• arr - An array [x, y] where both values will be converted to i32

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::from_f32_arr2([10.5, 20.7]);
assert_eq!(position, PxPosition::new(Px::new(10), Px::new(20)));

pub fn from_f32_arr3(arr: [f32; 3]) -> Self

Creates a position from a 3D f32 array, ignoring the z component.

Arguments

• arr - An array [x, y, z] where only x and y are used

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::from_f32_arr3([10.5, 20.7, 30.9]);
assert_eq!(position, PxPosition::new(Px::new(10), Px::new(20)));

pub fn to_f64_arr2(self) -> [f64; 2]

Converts the position to a 2D f64 array.

Returns

An array [x, y] where both coordinates are converted to f64

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::new(Px::new(10), Px::new(20));
assert_eq!(position.to_f64_arr2(), [10.0, 20.0]);

pub fn to_f64_arr3(self) -> [f64; 3]

Converts the position to a 3D f64 array with z=0.

Returns

An array [x, y, 0.0] where x and y are converted to f64 and z is 0.0

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::new(Px::new(10), Px::new(20));
assert_eq!(position.to_f64_arr3(), [10.0, 20.0, 0.0]);

pub fn from_f64_arr2(arr: [f64; 2]) -> Self

Creates a position from a 2D f64 array.

Arguments

• arr - An array [x, y] where both values will be converted to i32

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::from_f64_arr2([10.5, 20.7]);
assert_eq!(position, PxPosition::new(Px::new(10), Px::new(20)));

pub fn from_f64_arr3(arr: [f64; 3]) -> Self

Creates a position from a 3D f64 array, ignoring the z component.

Arguments

• arr - An array [x, y, z] where only x and y are used

Examples

use tessera_ui::px::{Px, PxPosition};

let position = PxPosition::from_f64_arr3([10.5, 20.7, 30.9]);
assert_eq!(position, PxPosition::new(Px::new(10), Px::new(20)));

Trait Implementations

impl Add for PxPosition

type Output = PxPosition

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Clone for PxPosition

fn clone(&self) -> PxPosition

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PxPosition

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<[Px; 2]> for PxPosition

fn from(pos: [Px; 2]) -> Self

Converts to this type from the input type.

impl From<[i32; 2]> for PxPosition

fn from(pos: [i32; 2]) -> Self

Converts to this type from the input type.

impl From<[u32; 2]> for PxPosition

fn from(pos: [u32; 2]) -> Self

Converts to this type from the input type.

impl From<PxPosition> for [Px; 2]

fn from(pos: PxPosition) -> Self

Converts to this type from the input type.

impl From<PxPosition> for [i32; 2]

fn from(pos: PxPosition) -> Self

Converts to this type from the input type.

impl From<PxPosition> for [u32; 2]

fn from(pos: PxPosition) -> Self

Converts to this type from the input type.

impl From<PxPosition> for PhysicalPosition<i32>

fn from(pos: PxPosition) -> Self

Converts to this type from the input type.

impl From<PxPosition> for Position

fn from(pos: PxPosition) -> Self

Converts to this type from the input type.

impl Hash for PxPosition

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PxPosition

fn eq(&self, other: &PxPosition) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub for PxPosition

type Output = PxPosition

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl Copy for PxPosition

impl Eq for PxPosition

impl StructuralPartialEq for PxPosition