Struct Buf2 

pub struct Buf2<T>(/* private fields */);

A rectangular 2D buffer that owns its elements, backed by a Vec.

Unlike Vec, however, Buf2 cannot be resized after construction without explicitly copying the contents to a new, larger buffer.

Buf2 stores its elements contiguously, in standard row-major order, such that the coordinate pair (x, y) maps to index buf.width() * y + x in the backing vector.

Examples

// Elements initialized with `Default::default()`
let mut buf = Buf2::new((4, 4));
// Indexing with a 2D point (x, y) yields element at row y, column x:
buf[pt2(2, 1)] = 123;
// Indexing with an usize i yields row with index i as a slice:
assert_eq!(buf[1], [0, 0, 123, 0]);
// Thus you can also do this, row first, column second:
assert_eq!(buf[1][2], 123)

Implementations

impl<T> Buf2<T>

pub fn new_from<I>((w, h): Dims, init: I) -> Self

where I: IntoIterator<Item = T>,

Returns a buffer of size w × h, with elements initialized with values yielded by init.

The elements are initialized in row-major order. Does not allocate or consume items from init if w = 0 or h = 0.

Examples

use retrofire_core::util::buf::Buf2;

let buf = Buf2::new_from((3, 3), 1..);

assert_eq!(buf.dims(), (3, 3));
assert_eq!(buf.data(), [1, 2, 3,
                        4, 5, 6,
                        7, 8, 9]);

Panics

• If w * h > isize::MAX, or
• if init has fewer than w * h elements.

pub fn new((w, h): Dims) -> Self

where T: Default + Clone,

Returns a buffer of size w × h, with every element initialized to T::default().

Does not allocate if w = 0 or h = 0.

Examples

use retrofire_core::util::buf::Buf2;

let buf: Buf2<i32> = Buf2::new((3, 3));

assert_eq!(buf.dims(), (3, 3));
assert_eq!(buf.data(), [0, 0, 0,
                        0, 0, 0,
                        0, 0, 0]);

Panics

If w * h > isize::MAX.

Examples found in repository

examples/hello_tri.rs (line 35)

fn main() {
    let verts = [
        vertex(pt3(-1.0, 1.0, 0.0), rgb(1.0, 0.0, 0.0)),
        vertex(pt3(1.0, 1.0, 0.0), rgb(0.0, 0.8, 0.0)),
        vertex(pt3(0.0, -1.0, 0.0), rgb(0.4, 0.4, 1.0)),
    ];

    #[cfg(feature = "fp")]
    let shader = shader::new(
        |v: Vertex3<Color3f>, mvp: &Mat4x4<ModelToProj>| {
            // Transform vertex position from model to projection space
            // Interpolate vertex colors in linear color space
            vertex(mvp.apply(&v.pos), v.attrib.to_linear())
        },
        |frag: Frag<Color3f<_>>| frag.var.to_srgb().to_color4(),
    );
    #[cfg(not(feature = "fp"))]
    let shader = shader::new(
        |v: Vertex3<Color3f>, mvp: &Mat4x4<ModelToProj>| {
            // Transform vertex position from model to projection space
            // Interpolate vertex colors in normal sRGB color space
            vertex(mvp.apply(&v.pos), v.attrib)
        },
        |frag: Frag<Color3f<_>>| frag.var.to_color4(),
    );

    let dims @ (w, h) = (640, 480);
    let modelview = translate3(0.0, 0.0, 2.0).to();
    let project = perspective(1.0, w as f32 / h as f32, 0.1..1000.0);
    let viewport = viewport(pt2(0, h)..pt2(w, 0));

    let mut framebuf = Buf2::<Color4>::new(dims);

    render(
        [tri(0, 1, 2)],
        verts,
        &shader,
        &modelview.then(&project),
        viewport,
        &mut framebuf,
        &Context::default(),
    );

    let center_pixel = framebuf[[w / 2, h / 2]];

    if cfg!(feature = "fp") {
        assert_eq!(center_pixel, rgba(150, 128, 186, 255));
    } else {
        assert_eq!(center_pixel, rgba(114, 102, 127, 255));
    }
    #[cfg(feature = "std")]
    {
        pnm::save_ppm("triangle.ppm", framebuf).unwrap();
    }
}

pub fn new_with<F>((w, h): Dims, init_fn: F) -> Self

where F: FnMut(u32, u32) -> T,

Returns a buffer of size w × h, initialized by repeatedly calling the given function.

For each element, init_fn(x, y) is invoked, where x is the column index and y the row index of the element being initialized. The elements are initialized in row-major order.

Does not allocate or call init_fn if w = 0 or h = 0.

Examples

use retrofire_core::util::buf::Buf2;

let buf = Buf2::new_with((3, 3), |x, y| 10 * y + x);
assert_eq!(buf.data(), [ 0,  1, 2,
                        10, 11, 12,
                        20, 21, 22]);

Panics

If w * h > isize::MAX.

pub fn data(&self) -> &[T]

Returns a view of the backing data of self.

pub fn data_mut(&mut self) -> &mut [T]

Returns a mutable view of the backing data of self.

pub fn reshape(&mut self, dims: Dims)

Reinterprets self as a buffer of different dimensions but same area.

Panics

If nw * nh != cw * ch for the new dimensions (nw, nh) and current dimensions (cw, ch).

Methods from Deref<Target = Inner<T, Vec<T>>>

pub fn width(&self) -> u32

Returns the width of self.

pub fn height(&self) -> u32

Returns the height of self.

pub fn dims(&self) -> Dims

Returns the width and height of self.

pub fn stride(&self) -> u32

Returns the stride of self.

pub fn is_contiguous(&self) -> bool

Returns whether the rows of self are stored as one contiguous slice, without gaps between rows.

Buf2 instances are always contiguous. A Slice2 or MutSlice2 instance is contiguous if its width equals its stride, if its height is 1, or if it is empty.

pub fn is_empty(&self) -> bool

Returns whether self contains no elements.

pub fn as_slice2(&self) -> Slice2<'_, T>

Borrows self as a Slice2.

pub fn slice(&self, rect: impl Into<Rect>) -> Slice2<'_, T>

Returns a borrowed rectangular slice of self.

Panics

If any part of rect is outside the bounds of self.

pub fn get(&self, pos: impl Into<Point2u>) -> Option<&T>

Returns a reference to the element at pos, or None if pos is out of bounds.

pub fn rows(&self) -> impl Iterator<Item = &[T]>

Returns an iterator over the rows of self as &[T] slices.

The length of each slice equals self.width().

pub fn iter(&self) -> impl Iterator<Item = &T>

Returns an iterator over the elements of self in row-major order.

First returns the elements on row 0 from left to right, followed by the elements on row 1, and so on.

pub fn as_mut_slice2(&mut self) -> MutSlice2<'_, T>

Returns a mutably borrowed rectangular slice of self.

pub fn rows_mut(&mut self) -> impl Iterator<Item = &mut [T]>

Returns an iterator over the rows of this buffer as &mut [T].

The length of each slice equals self.width().

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

Returns a mutable iterator over all the elements of self, yielded in row-major order.

pub fn fill(&mut self, val: T)

where T: Clone,

Fills self with clones of the value.

pub fn fill_with<F>(&mut self, fill_fn: F)

where F: FnMut(u32, u32) -> T,

Fills self by calling a function for each element.

Calls f(x, y) for every element, where x and y are the column and row indices of the element. Proceeds in row-major order.

pub fn copy_from(&mut self, other: impl AsSlice2<T>)

where T: Copy,

Copies each element in other to the same position in self.

This operation is often called “blitting”.

Panics

if the dimensions of self and other do not match.

pub fn get_mut(&mut self, pos: impl Into<Point2u>) -> Option<&mut T>

Returns a mutable reference to the element at pos, or None if pos is out of bounds.

pub fn slice_mut(&mut self, rect: impl Into<Rect>) -> MutSlice2<'_, T>

Returns a mutably borrowed rectangular slice of self.

Panics

If any part of rect is outside the bounds of self.

Trait Implementations

impl<T> AsMutSlice2<T> for &mut Buf2<T>

fn as_mut_slice2(&mut self) -> MutSlice2<'_, T>

Returns a mutably borrowed MutSlice2 view of Self.

impl<T> AsMutSlice2<T> for Buf2<T>

fn as_mut_slice2(&mut self) -> MutSlice2<'_, T>

Returns a mutably borrowed MutSlice2 view of Self.

impl<T> AsSlice2<T> for &Buf2<T>

fn as_slice2(&self) -> Slice2<'_, T>

Returns a borrowed Slice2 view of Self.

impl<T> AsSlice2<T> for Buf2<T>

fn as_slice2(&self) -> Slice2<'_, T>

Returns a borrowed Slice2 view of Self.

impl<T: Clone> Clone for Buf2<T>

fn clone(&self) -> Buf2<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Buf2<T>

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

Formats the value using the given formatter.

impl<T> Deref for Buf2<T>

type Target = Inner<T, Vec<T>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Buf2<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<C> From<Buf2<C>> for Texture<Buf2<C>>

fn from(data: Buf2<C>) -> Self

Creates a new texture from owned pixel data.

impl<T: PartialEq> PartialEq for Buf2<T>

fn eq(&self, other: &Buf2<T>) -> 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 Target for Buf2<Color3>

fn rasterize<V: Vary, Fs: FragmentShader<V>>( &mut self, sl: Scanline<V>, fs: &Fs, ctx: &Context, ) -> Throughput

Writes a single scanline into self.

impl Target for Buf2<Color4>

fn rasterize<V: Vary, Fs: FragmentShader<V>>( &mut self, sl: Scanline<V>, fs: &Fs, ctx: &Context, ) -> Throughput

Writes a single scanline into self.

impl<T: Eq> Eq for Buf2<T>

impl<T> StructuralPartialEq for Buf2<T>