Struct Fixed8

Source

pub struct Fixed8(/* private fields */);

Expand description

A signed fixed-point value with $frac_bits bits.

Implementations§

Source §

impl Fixed8

A signed fixed-point type.

Source

pub const INTEGER_BITS: u8 = 8u8

The number of integer bits.

Source

pub const FRACTIONAL_BITS: u8 = 8u8

The number of fractional bits.

Source

pub const ZERO: Self

The fixed-point value representing 0.0.

Source

pub const ONE: Self

The fixed-point value representing 1.0.

Source

pub const MIN: Self

The minimum representable value of this type.

Source

pub const MAX: Self

The maximum representable value of this type.

Source

pub const fn from_bits(n: i16) -> Self

Returns the fixed-point value with the same bit-representation as the given value.

Source

pub const fn get(self) -> i16

Source

pub fn from_f32(n: f32) -> Self

Converts an f32 floating-point value to fixed point.

This conversion may be lossy, with behavior like standard Rust float-to-int casting. Extra precision will be truncated, and the result will be saturated if it doesn’t fit in the underlying type’s range. NaN returns 0.0.

Examples found in repository ?

examples/writing.rs (line 13)

3fn main() {
4    let header = Header {
5        compression: Compression::Zlib,
6        version: 6,
7        stage_size: Rectangle {
8            x_min: Twips::ZERO,
9            x_max: Twips::from_pixels(400.0),
10            y_min: Twips::ZERO,
11            y_max: Twips::from_pixels(400.0),
12        },
13        frame_rate: Fixed8::from_f32(60.0),
14        num_frames: 1,
15    };
16    let tags = [
17        Tag::SetBackgroundColor(Color {
18            r: 255,
19            g: 0,
20            b: 0,
21            a: 255,
22        }),
23        Tag::ShowFrame,
24    ];
25    let file = std::fs::File::create("tests/swfs/SimpleRedBackground.swf").unwrap();
26    let writer = std::io::BufWriter::new(file);
27    swf::write_swf(&header, &tags, writer).unwrap();
28}

Source

pub fn from_f64(n: f64) -> Self

Converts an f64 floating-point value to fixed-point.

This conversion may be lossy, with behavior like standard Rust float-to-int casting. Extra precision will be truncated, and the result will be saturated if it doesn’t fit in the underlying type’s range. NaN returns 0.0.

Source

pub fn to_f32(self) -> f32

Converts this fixed-point value to f32 floating-point.

This conversion may be lossy if f32 does not have enough precision to represent the fixed-point value.

Use From to ensure that the conversion is lossless at compile-time.

Source

pub fn to_f64(self) -> f64

Converts this fixed-point value to f64 floating-point.

This conversion may be lossy if f64 does not have enough precision to represent the fixed-point value.

Use From to ensure that the conversion is lossless at compile-time.

Source

pub const fn is_zero(self) -> bool

Returns true if this is equal to 0.0.

Source

pub const fn is_one(self) -> bool

Returns true if this is equal to 1.0.

Source

pub fn mul_int(self, other: i16) -> i16

Multiplies this fixed-point by an integer, returning the integer result. The result uses full range of the integer. The fractional bits will be truncated.

Source

pub const fn wrapping_neg(self) -> Self

Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type. -Self::MIN is the only case where wrapping occurs.

Source

pub const fn wrapping_add(self, other: Self) -> Self

Wrapping (modular) addition. Computes self + rhs, wrapping around at the boundary of the type.

Source

pub const fn wrapping_sub(self, other: Self) -> Self

Wrapping (modular) subtraction. Computes self - rhs, wrapping around at the boundary of the type.

Source

pub const fn wrapping_mul(self, other: Self) -> Self

Wrapping (modular) multiplication. Computes self * rhs, wrapping around at the boundary of the type.

Source

pub const fn wrapping_div(self, other: Self) -> Self

Wrapping (modular) division. Computes self / rhs, wrapping around at the boundary of the type.

Source

pub const fn wrapping_mul_int(self, other: i16) -> i16

Wrapping (modular) multiplication. Multiplies this fixed-point by an integer, returning the integer result. The result will use the full size of the integer. The fractional bits will be truncated.