grixy 0.6.1

Zero-cost 2D grids for embedded systems and graphics
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//! Defines a trait for generating 2-dimensional patterns, such as for noise generation.

#![allow(missing_docs)]

use grixy::prelude::*;

pub trait Pattern2D {
    /// Generates a 2-dimensional pattern value at the given position.
    fn generate(&self, pos: Pos) -> f32;
}

pub struct Checkerboard {
    pub even: f32,
    pub odd: f32,
}

impl Pattern2D for Checkerboard {
    fn generate(&self, pos: Pos) -> f32 {
        if (pos.x + pos.y).is_multiple_of(2) {
            self.even
        } else {
            self.odd
        }
    }
}

/// Wrapper struct for types implementing [`Pattern2D`].
pub struct Pattern2DGrid<T> {
    pattern: T,
}

impl<T> GridBase for Pattern2DGrid<T> where T: Pattern2D {}

impl<T> GridRead for Pattern2DGrid<T>
where
    T: Pattern2D,
{
    type Element<'a>
        = f32
    where
        Self: 'a;

    type Layout = RowMajor;

    fn get(&self, pos: Pos) -> Option<Self::Element<'_>> {
        Some(self.pattern.generate(pos))
    }
}

fn main() {
    let pattern = Checkerboard {
        even: 1.0,
        odd: 0.0,
    };

    let grid = Pattern2DGrid { pattern };

    // Example usage: print the generated values in a 4x4 grid.
    for y in 0..4 {
        for x in 0..4 {
            let pos = Pos::new(x, y);
            print!("{:.1} ", grid.get(pos).unwrap());
        }
        println!();
    }
}