Struct agb::fixnum::Num

pub struct Num<I, const N: usize>(/* private fields */)
where
    I: FixedWidthUnsignedInteger;

A fixed point number represented using I with N bits of fractional precision

Implementations

impl<I, const N: usize> Num<I, N>

where I: FixedWidthUnsignedInteger,

pub fn change_base<J, const M: usize>(self) -> Num<J, M>

where J: FixedWidthUnsignedInteger + From<I>,

Performs the conversion between two integer types and between two different fractional precisions

pub fn try_change_base<J, const M: usize>(self) -> Option<Num<J, M>>

where J: FixedWidthUnsignedInteger + TryFrom<I>,

Attempts to perform the conversion between two integer types and between two different fractional precisions

let a: Num<i32, 8> = 1.into();
let b: Option<Num<u8, 4>> = a.try_change_base();
assert_eq!(b, Some(1.into()));

let a: Num<i32, 8> = 18.into();
let b: Option<Num<u8, 4>> = a.try_change_base();
assert_eq!(b, None);

Examples found in repository

examples/windows.rs (line 74)

fn main(mut gba: agb::Gba) -> ! {
    let (gfx, mut vram) = gba.display.video.tiled0();

    let mut map = gfx.background(
        agb::display::Priority::P0,
        RegularBackgroundSize::Background32x32,
        TileFormat::FourBpp,
    );
    let mut window = gba.display.window.get();
    window
        .win_in(WinIn::Win0)
        .set_background_enable(map.background(), true)
        .set_position(&Rect::new((10, 10).into(), (64, 64).into()))
        .enable();

    window
        .win_out()
        .enable()
        .set_background_enable(map.background(), true)
        .set_blend_enable(true);

    example_logo::display_logo(&mut map, &mut vram);

    let mut blend = gba.display.blend.get();

    blend
        .set_background_enable(Layer::Top, map.background(), true)
        .set_backdrop_enable(Layer::Bottom, true)
        .set_blend_mode(BlendMode::Normal);

    let mut pos: Vector2D<FNum> = (10, 10).into();
    let mut velocity: Vector2D<FNum> = Vector2D::new(1.into(), 1.into());

    let mut blend_amount: Num<i32, 8> = num!(0.5);
    let mut blend_velocity: Num<i32, 8> = Num::new(1) / 128;

    let vblank = VBlank::get();

    loop {
        pos += velocity;

        if pos.x.floor() > WIDTH - 64 || pos.x.floor() < 0 {
            velocity.x *= -1;
        }

        if pos.y.floor() > HEIGHT - 64 || pos.y.floor() < 0 {
            velocity.y *= -1;
        }

        blend_amount += blend_velocity;
        if blend_amount > num!(0.75) || blend_amount < num!(0.25) {
            blend_velocity *= -1;
        }

        blend_amount = blend_amount.clamp(0.into(), 1.into());

        blend.set_blend_weight(Layer::Top, blend_amount.try_change_base().unwrap());

        window
            .win_in(WinIn::Win0)
            .set_position(&Rect::new(pos.floor(), (64, 64).into()));

        vblank.wait_for_vblank();
        window.commit();
        blend.commit();
    }
}

pub const fn from_raw(n: I) -> Num<I, N>

A bit for bit conversion from a number to a fixed num

pub fn to_raw(self) -> I

The internal representation of the fixed point number

pub fn from_f32(input: f32) -> Num<I, N>

Lossily transforms an f32 into a fixed point representation. This is not const because you cannot currently do floating point operations in const contexts, so you should use the num! macro from agb-macros if you want a const from_f32/f64

pub fn from_f64(input: f64) -> Num<I, N>

Lossily transforms an f64 into a fixed point representation. This is not const because you cannot currently do floating point operations in const contexts, so you should use the num! macro from agb-macros if you want a const from_f32/f64

pub fn trunc(self) -> I

Truncates the fixed point number returning the integral part

let n: Num<i32, 8> = num!(5.67);
assert_eq!(n.trunc(), 5);
let n: Num<i32, 8> = num!(-5.67);
assert_eq!(n.trunc(), -5);

pub fn rem_euclid(self, rhs: Num<I, N>) -> Num<I, N>

Performs the equivalent to the integer rem_euclid, which is modulo numbering.

let n: Num<i32, 8> = num!(5.67);
let r: Num<i32, 8> = num!(4.);
assert_eq!(n.rem_euclid(r), num!(1.67));

let n: Num<i32, 8> = num!(-1.5);
let r: Num<i32, 8> = num!(4.);
assert_eq!(n.rem_euclid(r), num!(2.5));

pub fn floor(self) -> I

Performs rounding towards negative infinity

let n: Num<i32, 8> = num!(5.67);
assert_eq!(n.floor(), 5);
let n: Num<i32, 8> = num!(-5.67);
assert_eq!(n.floor(), -6);

Examples found in repository

examples/windows.rs (line 59)

fn main(mut gba: agb::Gba) -> ! {
    let (gfx, mut vram) = gba.display.video.tiled0();

    let mut map = gfx.background(
        agb::display::Priority::P0,
        RegularBackgroundSize::Background32x32,
        TileFormat::FourBpp,
    );
    let mut window = gba.display.window.get();
    window
        .win_in(WinIn::Win0)
        .set_background_enable(map.background(), true)
        .set_position(&Rect::new((10, 10).into(), (64, 64).into()))
        .enable();

    window
        .win_out()
        .enable()
        .set_background_enable(map.background(), true)
        .set_blend_enable(true);

    example_logo::display_logo(&mut map, &mut vram);

    let mut blend = gba.display.blend.get();

    blend
        .set_background_enable(Layer::Top, map.background(), true)
        .set_backdrop_enable(Layer::Bottom, true)
        .set_blend_mode(BlendMode::Normal);

    let mut pos: Vector2D<FNum> = (10, 10).into();
    let mut velocity: Vector2D<FNum> = Vector2D::new(1.into(), 1.into());

    let mut blend_amount: Num<i32, 8> = num!(0.5);
    let mut blend_velocity: Num<i32, 8> = Num::new(1) / 128;

    let vblank = VBlank::get();

    loop {
        pos += velocity;

        if pos.x.floor() > WIDTH - 64 || pos.x.floor() < 0 {
            velocity.x *= -1;
        }

        if pos.y.floor() > HEIGHT - 64 || pos.y.floor() < 0 {
            velocity.y *= -1;
        }

        blend_amount += blend_velocity;
        if blend_amount > num!(0.75) || blend_amount < num!(0.25) {
            blend_velocity *= -1;
        }

        blend_amount = blend_amount.clamp(0.into(), 1.into());

        blend.set_blend_weight(Layer::Top, blend_amount.try_change_base().unwrap());

        window
            .win_in(WinIn::Win0)
            .set_position(&Rect::new(pos.floor(), (64, 64).into()));

        vblank.wait_for_vblank();
        window.commit();
        blend.commit();
    }
}

examples/dma_effect_circular_window.rs (line 66)

fn main(mut gba: agb::Gba) -> ! {
    let (gfx, mut vram) = gba.display.video.tiled0();

    let mut map = gfx.background(
        agb::display::Priority::P0,
        RegularBackgroundSize::Background32x32,
        TileFormat::FourBpp,
    );
    let mut window = gba.display.window.get();
    window
        .win_in(WinIn::Win0)
        .set_background_enable(map.background(), true)
        .set_position(&Rect::new((10, 10).into(), (64, 64).into()))
        .enable();

    let dmas = gba.dma.dma();

    example_logo::display_logo(&mut map, &mut vram);

    let mut pos: Vector2D<FNum> = (10, 10).into();
    let mut velocity: Vector2D<FNum> = Vector2D::new(1.into(), 1.into());

    let vblank = VBlank::get();

    let circle: Box<[_]> = (1..64i32)
        .map(|i| {
            let y = 32 - i;
            let x = (32 * 32 - y * y).isqrt();
            let x1 = 32 - x;
            let x2 = 32 + x;

            ((x1 as u16) << 8) | (x2 as u16)
        })
        .collect();

    let mut circle_poses = vec![0; 160];

    loop {
        pos += velocity;

        if pos.x.floor() > WIDTH - 64 || pos.x.floor() < 0 {
            velocity.x *= -1;
        }

        if pos.y.floor() > HEIGHT - 64 || pos.y.floor() < 0 {
            velocity.y *= -1;
        }

        let x_pos = pos.x.floor().max(0) as u16;
        let y_pos = pos.y.floor().max(0);
        let x_adjustment = x_pos << 8 | x_pos;
        for (i, value) in circle_poses.iter_mut().enumerate() {
            let i = i as i32;
            if i <= y_pos || i >= y_pos + 64 {
                *value = 0;
                continue;
            }

            *value = circle[(i - y_pos) as usize - 1] + x_adjustment;
        }

        window
            .win_in(WinIn::Win0)
            .set_position(&Rect::new(pos.floor(), (64, 65).into()));
        window.commit();

        let dma_controllable = window.win_in(WinIn::Win0).horizontal_position_dma();
        let _transfer = unsafe { dmas.dma0.hblank_transfer(&dma_controllable, &circle_poses) };

        vblank.wait_for_vblank();
    }
}

pub fn frac(self) -> I

Returns the fractional component of a number as it’s integer representation

let n: Num<i32, 8> = num!(5.5);
assert_eq!(n.frac(), 1 << 7);

pub fn new(integral: I) -> Num<I, N>

Creates an integer represented by a fixed point number

let n: Num<i32, 8> = Num::new(5);
assert_eq!(n.frac(), 0); // no fractional component
assert_eq!(n, num!(5.)); // just equals the number 5

Examples found in repository

examples/windows.rs (line 52)

fn main(mut gba: agb::Gba) -> ! {
    let (gfx, mut vram) = gba.display.video.tiled0();

    let mut map = gfx.background(
        agb::display::Priority::P0,
        RegularBackgroundSize::Background32x32,
        TileFormat::FourBpp,
    );
    let mut window = gba.display.window.get();
    window
        .win_in(WinIn::Win0)
        .set_background_enable(map.background(), true)
        .set_position(&Rect::new((10, 10).into(), (64, 64).into()))
        .enable();

    window
        .win_out()
        .enable()
        .set_background_enable(map.background(), true)
        .set_blend_enable(true);

    example_logo::display_logo(&mut map, &mut vram);

    let mut blend = gba.display.blend.get();

    blend
        .set_background_enable(Layer::Top, map.background(), true)
        .set_backdrop_enable(Layer::Bottom, true)
        .set_blend_mode(BlendMode::Normal);

    let mut pos: Vector2D<FNum> = (10, 10).into();
    let mut velocity: Vector2D<FNum> = Vector2D::new(1.into(), 1.into());

    let mut blend_amount: Num<i32, 8> = num!(0.5);
    let mut blend_velocity: Num<i32, 8> = Num::new(1) / 128;

    let vblank = VBlank::get();

    loop {
        pos += velocity;

        if pos.x.floor() > WIDTH - 64 || pos.x.floor() < 0 {
            velocity.x *= -1;
        }

        if pos.y.floor() > HEIGHT - 64 || pos.y.floor() < 0 {
            velocity.y *= -1;
        }

        blend_amount += blend_velocity;
        if blend_amount > num!(0.75) || blend_amount < num!(0.25) {
            blend_velocity *= -1;
        }

        blend_amount = blend_amount.clamp(0.into(), 1.into());

        blend.set_blend_weight(Layer::Top, blend_amount.try_change_base().unwrap());

        window
            .win_in(WinIn::Win0)
            .set_position(&Rect::new(pos.floor(), (64, 64).into()));

        vblank.wait_for_vblank();
        window.commit();
        blend.commit();
    }
}

impl<const N: usize> Num<i32, N>

pub fn sqrt(self) -> Num<i32, N>

Returns the square root of a number, it is calculated a digit at a time.

let n: Num<i32, 8> = num!(16.);
assert_eq!(n.sqrt(), num!(4.));
let n: Num<i32, 8> = num!(2.25);
assert_eq!(n.sqrt(), num!(1.5));

impl<I, const N: usize> Num<I, N>

where I: FixedWidthSignedInteger,

pub fn abs(self) -> Num<I, N>

Returns the absolute value of a fixed point number

let n: Num<i32, 8> = num!(5.5);
assert_eq!(n.abs(), num!(5.5));
let n: Num<i32, 8> = num!(-5.5);
assert_eq!(n.abs(), num!(5.5));

pub fn cos(self) -> Num<I, N>

Calculates the cosine of a fixed point number with the domain of [0, 1]. Uses a fifth order polynomial.

let n: Num<i32, 8> = num!(0.);   // 0 radians
assert_eq!(n.cos(), num!(1.));
let n: Num<i32, 8> = num!(0.25); // pi / 2 radians
assert_eq!(n.cos(), num!(0.));
let n: Num<i32, 8> = num!(0.5);  // pi radians
assert_eq!(n.cos(), num!(-1.));
let n: Num<i32, 8> = num!(0.75); // 3pi/2 radians
assert_eq!(n.cos(), num!(0.));
let n: Num<i32, 8> = num!(1.);   // 2 pi radians (whole rotation)
assert_eq!(n.cos(), num!(1.));

pub fn sin(self) -> Num<I, N>

Calculates the sine of a number with domain of [0, 1].

let n: Num<i32, 8> = num!(0.);   // 0 radians
assert_eq!(n.sin(), num!(0.));
let n: Num<i32, 8> = num!(0.25); // pi / 2 radians
assert_eq!(n.sin(), num!(1.));
let n: Num<i32, 8> = num!(0.5);  // pi radians
assert_eq!(n.sin(), num!(0.));
let n: Num<i32, 8> = num!(0.75); // 3pi/2 radians
assert_eq!(n.sin(), num!(-1.));
let n: Num<i32, 8> = num!(1.);   // 2 pi radians (whole rotation)
assert_eq!(n.sin(), num!(0.));

Trait Implementations

impl<I, T, const N: usize> Add<T> for Num<I, N>

where I: FixedWidthUnsignedInteger, T: Into<Num<I, N>>,

type Output = Num<I, N>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> <Num<I, N> as Add<T>>::Output

Performs the + operation.

impl<I, T, const N: usize> AddAssign<T> for Num<I, N>

where I: FixedWidthUnsignedInteger, T: Into<Num<I, N>>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<I, const N: usize> Clone for Num<I, N>

where I: Clone + FixedWidthUnsignedInteger,

fn clone(&self) -> Num<I, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, const N: usize> Debug for Num<I, N>

where I: FixedWidthUnsignedInteger,

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

Formats the value using the given formatter.

impl<I, const N: usize> Default for Num<I, N>

where I: FixedWidthUnsignedInteger,

fn default() -> Num<I, N>

Returns the “default value” for a type.

impl<I, const N: usize> Display for Num<I, N>

where I: FixedWidthUnsignedInteger,

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

Formats the value using the given formatter.

impl<I, const N: usize> Div<I> for Num<I, N>

where I: FixedWidthUnsignedInteger,

type Output = Num<I, N>

The resulting type after applying the / operator.

fn div(self, rhs: I) -> <Num<I, N> as Div<I>>::Output

Performs the / operation.

impl<I, const N: usize> Div for Num<I, N>

where I: FixedWidthUnsignedInteger,

type Output = Num<I, N>

The resulting type after applying the / operator.

fn div(self, rhs: Num<I, N>) -> <Num<I, N> as Div>::Output

Performs the / operation.

impl<I, T, const N: usize> DivAssign<T> for Num<I, N>

where I: FixedWidthUnsignedInteger, Num<I, N>: Div<T, Output = Num<I, N>>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<I, const N: usize> From<I> for Num<I, N>

where I: FixedWidthUnsignedInteger,

fn from(value: I) -> Num<I, N>

Converts to this type from the input type.

impl<I, const N: usize> Hash for Num<I, N>

where I: Hash + FixedWidthUnsignedInteger,

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

where __H: Hasher,

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<I, const N: usize> Mul<I> for Num<I, N>

where I: FixedWidthUnsignedInteger,

type Output = Num<I, N>

The resulting type after applying the * operator.

fn mul(self, rhs: I) -> <Num<I, N> as Mul<I>>::Output

Performs the * operation.

impl<I, const N: usize> Mul for Num<I, N>

where I: FixedWidthUnsignedInteger,

type Output = Num<I, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Num<I, N>) -> <Num<I, N> as Mul>::Output

Performs the * operation.

impl<I, T, const N: usize> MulAssign<T> for Num<I, N>

where I: FixedWidthUnsignedInteger, Num<I, N>: Mul<T, Output = Num<I, N>>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<I, const N: usize> Neg for Num<I, N>

where I: FixedWidthSignedInteger,

type Output = Num<I, N>

The resulting type after applying the - operator.

fn neg(self) -> <Num<I, N> as Neg>::Output

Performs the unary - operation.

impl<I, const N: usize> Num for Num<I, N>

where I: FixedWidthUnsignedInteger + Num,

type FromStrRadixErr = <f64 as Num>::FromStrRadixErr

fn from_str_radix( str: &str, radix: u32 ) -> Result<Num<I, N>, <Num<I, N> as Num>::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl<I, const N: usize> One for Num<I, N>

where I: FixedWidthUnsignedInteger,

fn one() -> Num<I, N>

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<I, const N: usize> Ord for Num<I, N>

where I: Ord + FixedWidthUnsignedInteger,

fn cmp(&self, other: &Num<I, N>) -> Ordering

This method returns an [Ordering] between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<I, const N: usize> PartialEq for Num<I, N>

where I: PartialEq + FixedWidthUnsignedInteger,

fn eq(&self, other: &Num<I, N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<I, const N: usize> PartialOrd for Num<I, N>

where I: PartialOrd + FixedWidthUnsignedInteger,

fn partial_cmp(&self, other: &Num<I, N>) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<I, T, const N: usize> Rem<T> for Num<I, N>

where I: FixedWidthUnsignedInteger, T: Into<Num<I, N>>,

type Output = Num<I, N>

The resulting type after applying the % operator.

fn rem(self, modulus: T) -> <Num<I, N> as Rem<T>>::Output

Performs the % operation.

impl<I, T, const N: usize> RemAssign<T> for Num<I, N>

where I: FixedWidthUnsignedInteger, T: Into<Num<I, N>>,

fn rem_assign(&mut self, modulus: T)

Performs the %= operation.

impl<I, T, const N: usize> Sub<T> for Num<I, N>

where I: FixedWidthUnsignedInteger, T: Into<Num<I, N>>,

type Output = Num<I, N>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> <Num<I, N> as Sub<T>>::Output

Performs the - operation.

impl<I, T, const N: usize> SubAssign<T> for Num<I, N>

where I: FixedWidthUnsignedInteger, T: Into<Num<I, N>>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<I, const N: usize> Zero for Num<I, N>

where I: FixedWidthUnsignedInteger,

fn zero() -> Num<I, N>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<I, const N: usize> Copy for Num<I, N>

where I: Copy + FixedWidthUnsignedInteger,

impl<I, const N: usize> Eq for Num<I, N>

where I: Eq + FixedWidthUnsignedInteger,

impl<I, const N: usize> Number for Num<I, N>

where I: FixedWidthUnsignedInteger,

impl<I, const N: usize> StructuralPartialEq for Num<I, N>

where I: FixedWidthUnsignedInteger,