Struct style::values::computed::font::FixedPoint

#[repr(C)]
pub struct FixedPoint<T, const FRACTION_BITS: u16> {
    pub value: T,
}

Generic template for font property type classes that use a fixed-point internal representation with FRACTION_BITS for the fractional part.

Values are constructed from and exposed as floating-point, but stored internally as fixed point, so there will be a quantization effect on fractional values, depending on the number of fractional bits used.

Using (16-bit) fixed-point types rather than floats for these style attributes reduces the memory footprint of gfxFontEntry and gfxFontStyle; it will also tend to reduce the number of distinct font instances that get created, particularly when styles are animated or set to arbitrary values (e.g. by sliders in the UI), which should reduce pressure on graphics resources and improve cache hit rates.

cbindgen:derive-lt cbindgen:derive-lte cbindgen:derive-gt cbindgen:derive-gte

Fields

value: T

The actual representation.

Implementations

impl<T, const FRACTION_BITS: u16> FixedPoint<T, FRACTION_BITS>

where T: AsPrimitive<f32>, f32: AsPrimitive<T>, u16: AsPrimitive<T>,

const SCALE: u16 = _

const INVERSE_SCALE: f32 = _

pub fn from_float(v: f32) -> Self

Returns a fixed-point bit from a floating-point context.

pub fn to_float(&self) -> f32

Returns the floating-point representation.

Trait Implementations

impl<T: Clone, const FRACTION_BITS: u16> Clone for FixedPoint<T, FRACTION_BITS>

fn clone(&self) -> FixedPoint<T, FRACTION_BITS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const FRACTION_BITS: u16> ComputeSquaredDistance for FixedPoint<T, FRACTION_BITS>

where T: ComputeSquaredDistance,

fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()>

Computes the squared distance between two animatable values.

impl<T: Debug, const FRACTION_BITS: u16> Debug for FixedPoint<T, FRACTION_BITS>

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

Formats the value using the given formatter.

impl<'de, T, const FRACTION_BITS: u16> Deserialize<'de> for FixedPoint<T, FRACTION_BITS>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const FRACTION_BITS: u16> Div for FixedPoint<u16, FRACTION_BITS>

type Output = FixedPoint<u16, FRACTION_BITS>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs the / operation.

impl<T: Hash, const FRACTION_BITS: u16> Hash for FixedPoint<T, FRACTION_BITS>

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<T, const FRACTION_BITS: u16> MallocSizeOf for FixedPoint<T, FRACTION_BITS>

where T: MallocSizeOf,

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl<const FRACTION_BITS: u16> Mul for FixedPoint<u16, FRACTION_BITS>

type Output = FixedPoint<u16, FRACTION_BITS>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl<T: PartialEq, const FRACTION_BITS: u16> PartialEq for FixedPoint<T, FRACTION_BITS>

fn eq(&self, other: &FixedPoint<T, FRACTION_BITS>) -> 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<T: PartialOrd, const FRACTION_BITS: u16> PartialOrd for FixedPoint<T, FRACTION_BITS>

fn partial_cmp(&self, other: &FixedPoint<T, FRACTION_BITS>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, const FRACTION_BITS: u16> Serialize for FixedPoint<T, FRACTION_BITS>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, const FRACTION_BITS: u16> ToResolvedValue for FixedPoint<T, FRACTION_BITS>

where T: ToResolvedValue,

type ResolvedValue = FixedPoint<<T as ToResolvedValue>::ResolvedValue, FRACTION_BITS>

The resolved value type we’re going to be converted to.

fn from_resolved_value(from: Self::ResolvedValue) -> Self

Convert a resolved value to resolved value form.

fn to_resolved_value(self, context: &Context<'_>) -> Self::ResolvedValue

Convert a resolved value to a resolved value.

impl<T: Copy, const FRACTION_BITS: u16> Copy for FixedPoint<T, FRACTION_BITS>

impl<T: Eq, const FRACTION_BITS: u16> Eq for FixedPoint<T, FRACTION_BITS>

impl<T, const FRACTION_BITS: u16> StructuralPartialEq for FixedPoint<T, FRACTION_BITS>