rust/land2d/src/lib.rs
author unC0Rr
Wed, 01 Feb 2023 11:19:45 +0100
branchtransitional_engine
changeset 15914 c571d4b8879c
parent 15913 c5684cc62de8
permissions -rw-r--r--
Fix mapgen
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
15901
f39f0f614dbf Use LandPixels array allocate in hwengine-future library
unC0Rr
parents: 15893
diff changeset
     1
use std::{cmp, ops::Index, ops::IndexMut};
15904
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
     2
use vec2d::Vec2D;
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
     3
use integral_geometry::{ArcPoints, EquidistantPoints, Line, Point, PotSize, Rect, Size, SizeMask};
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13936
diff changeset
     4
15912
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
     5
#[derive(Debug)]
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
     6
pub struct Land2D<T> {
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
     7
    pixels: vec2d::Vec2D<T>,
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
     8
    play_box: Rect,
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
     9
    mask: SizeMask,
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    10
}
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    11
15912
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
    12
impl<T: Copy + PartialEq + Default> Land2D<T> {
15905
022ec6b916b7 Split generation and painting phases, paint by old engine, use template filters
unC0Rr
parents: 15904
diff changeset
    13
    pub fn new(play_size: &Size, fill_value: T) -> Self {
14052
alfadur
parents: 14050 14032
diff changeset
    14
        let real_size = play_size.next_power_of_two();
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
    15
        let top_left = Point::new(
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
    16
            ((real_size.width() - play_size.width) / 2) as i32,
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
    17
            (real_size.height() - play_size.height) as i32,
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
    18
        );
15905
022ec6b916b7 Split generation and painting phases, paint by old engine, use template filters
unC0Rr
parents: 15904
diff changeset
    19
        let play_box = Rect::from_size(top_left, *play_size);
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    20
        Self {
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
    21
            play_box,
15913
c5684cc62de8 Switch to Vec2D in wavefront algorithm
unC0Rr
parents: 15912
diff changeset
    22
            pixels: vec2d::Vec2D::new(&real_size.size(), fill_value),
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
    23
            mask: real_size.to_mask(),
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    24
        }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    25
    }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    26
14121
69db1d2e4cec land_dump app for testing templated landgen
unc0rr
parents: 14101
diff changeset
    27
    pub fn raw_pixels(&self) -> &[T] {
14160
c24a76f131d6 implement basic land texturing
alfadur
parents: 14150
diff changeset
    28
        &self.pixels.as_slice()
14121
69db1d2e4cec land_dump app for testing templated landgen
unc0rr
parents: 14101
diff changeset
    29
    }
69db1d2e4cec land_dump app for testing templated landgen
unc0rr
parents: 14101
diff changeset
    30
14702
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14207
diff changeset
    31
    pub fn raw_pixel_bytes(&self) -> &[u8] {
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
    32
        unsafe { self.pixels.as_bytes() }
14702
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14207
diff changeset
    33
    }
29dbe9ce8b7d add basic map rendering with gl
fkaa
parents: 14207
diff changeset
    34
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    35
    #[inline]
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    36
    pub fn width(&self) -> usize {
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    37
        self.pixels.width()
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    38
    }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    39
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    40
    #[inline]
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    41
    pub fn height(&self) -> usize {
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    42
        self.pixels.height()
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    43
    }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    44
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    45
    #[inline]
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
    46
    pub fn size(&self) -> PotSize {
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
    47
        self.mask.to_size()
14052
alfadur
parents: 14050 14032
diff changeset
    48
    }
alfadur
parents: 14050 14032
diff changeset
    49
alfadur
parents: 14050 14032
diff changeset
    50
    #[inline]
14050
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
    51
    pub fn play_width(&self) -> usize {
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14121
diff changeset
    52
        self.play_box.width()
14050
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
    53
    }
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
    54
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
    55
    #[inline]
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
    56
    pub fn play_height(&self) -> usize {
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14121
diff changeset
    57
        self.play_box.height()
14052
alfadur
parents: 14050 14032
diff changeset
    58
    }
alfadur
parents: 14050 14032
diff changeset
    59
alfadur
parents: 14050 14032
diff changeset
    60
    #[inline]
alfadur
parents: 14050 14032
diff changeset
    61
    pub fn play_size(&self) -> Size {
14135
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity
alfadur
parents: 14121
diff changeset
    62
        self.play_box.size()
14050
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
    63
    }
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
    64
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
    65
    #[inline]
14137
3119d665d3c6 collapse rectangle types back together with consistent usage of size
alfadur
parents: 14135
diff changeset
    66
    pub fn play_box(&self) -> Rect {
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
    67
        self.play_box
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
    68
    }
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
    69
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
    70
    #[inline]
13931
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
    71
    pub fn is_valid_x(&self, x: i32) -> bool {
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
    72
        self.mask.contains_x(x as usize)
13931
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
    73
    }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
    74
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
    75
    #[inline]
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
    76
    pub fn is_valid_y(&self, y: i32) -> bool {
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
    77
        self.mask.contains_y(y as usize)
13931
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
    78
    }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
    79
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
    80
    #[inline]
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
    81
    pub fn is_valid_coordinate(&self, x: i32, y: i32) -> bool {
13931
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
    82
        self.is_valid_x(x) && self.is_valid_y(y)
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    83
    }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    84
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    85
    #[inline]
14170
a4c1a2d0ac24 implement basic land bordering
alfadur
parents: 14160
diff changeset
    86
    pub fn rows(&self) -> impl DoubleEndedIterator<Item = &[T]> {
14030
2ebd505e62c1 make theme editor render some random map lines
alfadur
parents: 13951
diff changeset
    87
        self.pixels.rows()
2ebd505e62c1 make theme editor render some random map lines
alfadur
parents: 13951
diff changeset
    88
    }
2ebd505e62c1 make theme editor render some random map lines
alfadur
parents: 13951
diff changeset
    89
2ebd505e62c1 make theme editor render some random map lines
alfadur
parents: 13951
diff changeset
    90
    #[inline]
13940
1c30793b1cea put back land2d.map accidentally replaced by testing code
alfadur
parents: 13938
diff changeset
    91
    pub fn map<U: Default, F: FnOnce(&mut T) -> U>(&mut self, y: i32, x: i32, f: F) -> U {
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    92
        if self.is_valid_coordinate(x, y) {
13934
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13931
diff changeset
    93
            unsafe {
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13931
diff changeset
    94
                // hey, I just checked that coordinates are valid!
13940
1c30793b1cea put back land2d.map accidentally replaced by testing code
alfadur
parents: 13938
diff changeset
    95
                f(self.pixels.get_unchecked_mut(y as usize, x as usize))
13931
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
    96
            }
13934
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13931
diff changeset
    97
        } else {
13940
1c30793b1cea put back land2d.map accidentally replaced by testing code
alfadur
parents: 13938
diff changeset
    98
            U::default()
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
    99
        }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   100
    }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   101
13944
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13943
diff changeset
   102
    #[inline]
15912
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   103
    pub fn get(&self, y: i32, x: i32) -> T {
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   104
        if self.is_valid_coordinate(x, y) {
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   105
            unsafe {
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   106
                // hey, I just checked that coordinates are valid!
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   107
                *self.pixels.get_unchecked(y as usize, x as usize)
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   108
            }
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   109
        } else {
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   110
            T::default()
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   111
        }
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   112
    }
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   113
6e22f4390b7e Add basics of wavefront collapse algorithm
unC0Rr
parents: 15905
diff changeset
   114
    #[inline]
13944
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13943
diff changeset
   115
    pub fn map_point<U: Default, F: FnOnce(&mut T) -> U>(&mut self, point: Point, f: F) -> U {
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13943
diff changeset
   116
        self.map(point.y, point.x, f)
13934
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13931
diff changeset
   117
    }
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13931
diff changeset
   118
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13936
diff changeset
   119
    pub fn fill_from_iter<I>(&mut self, i: I, value: T) -> usize
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   120
    where
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   121
        I: std::iter::Iterator<Item = Point>,
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13936
diff changeset
   122
    {
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   123
        i.map(|p| {
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   124
            self.map(p.y, p.x, |v| {
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   125
                *v = value;
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   126
                1
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   127
            })
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   128
        })
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   129
        .count()
13938
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13936
diff changeset
   130
    }
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit
alfadur
parents: 13936
diff changeset
   131
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14052
diff changeset
   132
    pub fn draw_line(&mut self, line: Line, value: T) -> usize {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14052
diff changeset
   133
        self.fill_from_iter(line.into_iter(), value)
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   134
    }
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   135
13948
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13946
diff changeset
   136
    pub fn fill(&mut self, start_point: Point, border_value: T, fill_value: T) {
14150
6205a5230d23 make fill point asserts persistent
alfadur
parents: 14149
diff changeset
   137
        assert!(self.is_valid_coordinate(start_point.x - 1, start_point.y));
6205a5230d23 make fill point asserts persistent
alfadur
parents: 14149
diff changeset
   138
        assert!(self.is_valid_coordinate(start_point.x, start_point.y));
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   139
14148
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   140
        let mask = self.mask;
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   141
        let width = self.width();
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   142
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   143
        let mut stack: Vec<(usize, usize, usize, isize)> = Vec::new();
14148
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   144
        fn push(
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   145
            mask: SizeMask,
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   146
            stack: &mut Vec<(usize, usize, usize, isize)>,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   147
            xl: usize,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   148
            xr: usize,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   149
            y: usize,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   150
            dir: isize,
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   151
        ) {
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   152
            let yd = y as isize + dir;
14148
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   153
            if mask.contains_y(yd as usize) {
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   154
                stack.push((xl, xr, yd as usize, dir));
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   155
            }
15893
5b3beb90e1a6 Implement generation of c header from rust interface, adapt qmlfrontend
unC0Rr
parents: 15828
diff changeset
   156
        }
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   157
13948
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13946
diff changeset
   158
        let start_x_l = (start_point.x - 1) as usize;
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13946
diff changeset
   159
        let start_x_r = start_point.x as usize;
14148
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   160
        for dir in [-1, 1].iter().cloned() {
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   161
            push(
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   162
                mask,
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   163
                &mut stack,
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   164
                start_x_l,
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   165
                start_x_r,
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   166
                start_point.y as usize,
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   167
                dir,
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   168
            );
14148
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   169
        }
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   170
14148
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   171
        while let Some((mut xl, mut xr, y, dir)) = stack.pop() {
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   172
            let row = &mut self.pixels[y][..];
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   173
            while xl > 0 && row[xl] != border_value && row[xl] != fill_value {
13951
03e41712eef8 Fix silly loop
unc0rr
parents: 13949
diff changeset
   174
                xl -= 1;
03e41712eef8 Fix silly loop
unc0rr
parents: 13949
diff changeset
   175
            }
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   176
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   177
            while xr < width - 1 && row[xr] != border_value && row[xr] != fill_value {
13951
03e41712eef8 Fix silly loop
unc0rr
parents: 13949
diff changeset
   178
                xr += 1;
03e41712eef8 Fix silly loop
unc0rr
parents: 13949
diff changeset
   179
            }
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   180
13951
03e41712eef8 Fix silly loop
unc0rr
parents: 13949
diff changeset
   181
            while xl < xr {
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   182
                while xl <= xr && (row[xl] == border_value || row[xl] == fill_value) {
13951
03e41712eef8 Fix silly loop
unc0rr
parents: 13949
diff changeset
   183
                    xl += 1;
03e41712eef8 Fix silly loop
unc0rr
parents: 13949
diff changeset
   184
                }
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   185
14148
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   186
                let x = xl;
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   187
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   188
                while xl <= xr && row[xl] != border_value && row[xl] != fill_value {
14148
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   189
                    row[xl] = fill_value;
13951
03e41712eef8 Fix silly loop
unc0rr
parents: 13949
diff changeset
   190
                    xl += 1;
03e41712eef8 Fix silly loop
unc0rr
parents: 13949
diff changeset
   191
                }
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   192
13951
03e41712eef8 Fix silly loop
unc0rr
parents: 13949
diff changeset
   193
                if x < xl {
14148
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   194
                    push(mask, &mut stack, x, xl - 1, y, dir);
d3c9025abd13 seems like about 25% speedup in land filling
alfadur
parents: 14144
diff changeset
   195
                    push(mask, &mut stack, x, xl - 1, y, -dir);
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   196
                }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   197
            }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   198
        }
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   199
    }
13931
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   200
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   201
    #[inline]
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   202
    fn fill_circle_line<F: Fn(&mut T) -> usize>(
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   203
        &mut self,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   204
        y: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   205
        x_from: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   206
        x_to: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   207
        f: &F,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   208
    ) -> usize {
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   209
        let mut result = 0;
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   210
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   211
        if self.is_valid_y(y) {
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   212
            for i in cmp::min(x_from, 0) as usize..cmp::max(x_to as usize, self.width() - 1) {
13934
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13931
diff changeset
   213
                unsafe {
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13931
diff changeset
   214
                    // coordinates are valid at this point
13931
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   215
                    result += f(self.pixels.get_unchecked_mut(y as usize, i));
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   216
                }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   217
            }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   218
        }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   219
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   220
        result
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   221
    }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   222
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   223
    #[inline]
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   224
    fn fill_circle_lines<F: Fn(&mut T) -> usize>(
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   225
        &mut self,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   226
        x: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   227
        y: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   228
        dx: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   229
        dy: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   230
        f: &F,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   231
    ) -> usize {
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   232
        self.fill_circle_line(y + dy, x - dx, x + dx, f)
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   233
            + self.fill_circle_line(y - dy, x - dx, x + dx, f)
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   234
            + self.fill_circle_line(y + dx, x - dy, x + dy, f)
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   235
            + self.fill_circle_line(y - dx, x - dy, x + dy, f)
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   236
    }
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   237
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   238
    pub fn change_round<F: Fn(&mut T) -> usize>(
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   239
        &mut self,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   240
        x: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   241
        y: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   242
        radius: i32,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   243
        f: F,
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   244
    ) -> usize {
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   245
        ArcPoints::new(radius)
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   246
            .map(&mut |p: Point| self.fill_circle_lines(x, y, p.x, p.y, &f))
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   247
            .sum()
13934
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13931
diff changeset
   248
    }
13931
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   249
14031
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   250
    fn fill_row(&mut self, center: Point, offset: Point, value: T) -> usize {
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   251
        let row_index = center.y + offset.y;
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   252
        if self.is_valid_y(row_index) {
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   253
            let from_x = cmp::max(0, center.x - offset.x) as usize;
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   254
            let to_x = cmp::min(self.width() - 1, (center.x + offset.x) as usize);
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   255
            self.pixels[row_index as usize][from_x..=to_x]
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
   256
                .iter_mut()
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
   257
                .for_each(|v| *v = value);
14031
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   258
            to_x - from_x + 1
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   259
        } else {
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   260
            0
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   261
        }
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   262
    }
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   263
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   264
    pub fn fill_circle(&mut self, center: Point, radius: i32, value: T) -> usize {
14078
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
   265
        let transforms = [[0, 1, 1, 0], [0, 1, -1, 0], [1, 0, 0, 1], [1, 0, 0, -1]];
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
   266
        ArcPoints::new(radius)
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
   267
            .map(|vector| {
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
   268
                transforms
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
   269
                    .iter()
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
   270
                    .map(|m| self.fill_row(center, vector.transform(m), value))
bf40b5f938b0 - Add methods to work with Rect as box
unC0Rr
parents: 14076
diff changeset
   271
                    .sum::<usize>()
15828
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   272
            })
44b49f255e31 add type safe power of two sizes
alfadur
parents: 14702
diff changeset
   273
            .sum()
14031
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   274
    }
c47283feafac add circle filling to land2d
alfadur
parents: 14030
diff changeset
   275
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14052
diff changeset
   276
    pub fn draw_thick_line(&mut self, line: Line, radius: i32, value: T) -> usize {
13944
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13943
diff changeset
   277
        let mut result = 0;
13931
9230aed8a32e Implement Land2D::change_round()
unc0rr
parents: 13924
diff changeset
   278
13949
a1895019bb94 change draw_thick_line iteration order to benchmark winner
alfadur
parents: 13948
diff changeset
   279
        for vector in ArcPoints::new(radius) {
a1895019bb94 change draw_thick_line iteration order to benchmark winner
alfadur
parents: 13948
diff changeset
   280
            for delta in EquidistantPoints::new(vector) {
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14052
diff changeset
   281
                for point in line.into_iter() {
13946
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13945
diff changeset
   282
                    self.map_point(point + delta, |p| {
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13945
diff changeset
   283
                        if *p != value {
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13945
diff changeset
   284
                            *p = value;
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13945
diff changeset
   285
                            result += 1;
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13945
diff changeset
   286
                        }
54e2a3698425 revert 2354264ab0b0
alfadur
parents: 13945
diff changeset
   287
                    })
13944
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13943
diff changeset
   288
                }
13943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   289
            }
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   290
        }
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates
unc0rr
parents: 13940
diff changeset
   291
13944
4162ea9ae333 Use integral-geometry iterators to implement Land2D::draw_thick_line, remove no longer unused functions from Land2D
unc0rr
parents: 13943
diff changeset
   292
        result
13934
9c112f2ae02d Raise levels of abstraction to implement draw_thick_line() avoiding code duplication
unc0rr
parents: 13931
diff changeset
   293
    }
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   294
}
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   295
14144
165e43c3ed59 pull land into collision detector
alfadur
parents: 14140
diff changeset
   296
impl<T> Index<usize> for Land2D<T> {
165e43c3ed59 pull land into collision detector
alfadur
parents: 14140
diff changeset
   297
    type Output = [T];
165e43c3ed59 pull land into collision detector
alfadur
parents: 14140
diff changeset
   298
    #[inline]
165e43c3ed59 pull land into collision detector
alfadur
parents: 14140
diff changeset
   299
    fn index(&self, row: usize) -> &[T] {
165e43c3ed59 pull land into collision detector
alfadur
parents: 14140
diff changeset
   300
        &self.pixels[row]
165e43c3ed59 pull land into collision detector
alfadur
parents: 14140
diff changeset
   301
    }
165e43c3ed59 pull land into collision detector
alfadur
parents: 14140
diff changeset
   302
}
165e43c3ed59 pull land into collision detector
alfadur
parents: 14140
diff changeset
   303
15901
f39f0f614dbf Use LandPixels array allocate in hwengine-future library
unC0Rr
parents: 15893
diff changeset
   304
impl<T> IndexMut<usize> for Land2D<T> {
f39f0f614dbf Use LandPixels array allocate in hwengine-future library
unC0Rr
parents: 15893
diff changeset
   305
    #[inline]
f39f0f614dbf Use LandPixels array allocate in hwengine-future library
unC0Rr
parents: 15893
diff changeset
   306
    fn index_mut(&mut self, row: usize) -> &mut [T] {
f39f0f614dbf Use LandPixels array allocate in hwengine-future library
unC0Rr
parents: 15893
diff changeset
   307
        &mut self.pixels[row]
f39f0f614dbf Use LandPixels array allocate in hwengine-future library
unC0Rr
parents: 15893
diff changeset
   308
    }
f39f0f614dbf Use LandPixels array allocate in hwengine-future library
unC0Rr
parents: 15893
diff changeset
   309
}
f39f0f614dbf Use LandPixels array allocate in hwengine-future library
unC0Rr
parents: 15893
diff changeset
   310
15904
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   311
impl<T> From<Vec2D<T>> for Land2D<T> {
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   312
    fn from(vec: Vec2D<T>) -> Self {
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   313
        let actual_size = vec.size();
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   314
        let pot_size = actual_size.next_power_of_two();
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   315
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   316
        assert_eq!(actual_size, pot_size.size());
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   317
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   318
        let top_left = Point::new(0, 0);
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   319
        let play_box = Rect::from_size(top_left, actual_size);
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   320
        Self {
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   321
            play_box,
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   322
            pixels: vec,
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   323
            mask: pot_size.to_mask(),
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   324
        }
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   325
    }
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   326
}
33798b649d9c Use rust land generator in hwengine
unC0Rr
parents: 15901
diff changeset
   327
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   328
#[cfg(test)]
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   329
mod tests {
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   330
    use super::*;
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   331
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   332
    #[test]
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   333
    fn basics() {
14052
alfadur
parents: 14050 14032
diff changeset
   334
        let l: Land2D<u8> = Land2D::new(Size::new(30, 50), 0);
14050
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
   335
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
   336
        assert_eq!(l.play_width(), 30);
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
   337
        assert_eq!(l.play_height(), 50);
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
   338
        assert_eq!(l.width(), 32);
4b40bdd214df Use next_power_of_two() just like hedgewars engine does, expose original and real dimensions
unc0rr
parents: 13951
diff changeset
   339
        assert_eq!(l.height(), 64);
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   340
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   341
        assert!(l.is_valid_coordinate(0, 0));
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   342
        assert!(!l.is_valid_coordinate(-1, -1));
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   343
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   344
        assert!(l.is_valid_coordinate(31, 63));
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   345
        assert!(!l.is_valid_coordinate(32, 63));
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   346
        assert!(!l.is_valid_coordinate(31, 64));
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   347
    }
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   348
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   349
    #[test]
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   350
    fn fill() {
14032
2869c2ccb1b8 extract size struct for common usage
alfadur
parents: 14031
diff changeset
   351
        let mut l: Land2D<u8> = Land2D::new(Size::square(128), 0);
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   352
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14052
diff changeset
   353
        l.draw_line(Line::new(Point::new(0, 0), Point::new(32, 96)), 1);
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14052
diff changeset
   354
        l.draw_line(Line::new(Point::new(32, 96), Point::new(64, 32)), 1);
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14052
diff changeset
   355
        l.draw_line(Line::new(Point::new(64, 32), Point::new(96, 80)), 1);
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14052
diff changeset
   356
        l.draw_line(Line::new(Point::new(96, 80), Point::new(128, 0)), 1);
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   357
14076
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14052
diff changeset
   358
        l.draw_line(Line::new(Point::new(0, 128), Point::new(64, 96)), 1);
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring
unC0Rr
parents: 14052
diff changeset
   359
        l.draw_line(Line::new(Point::new(128, 128), Point::new(64, 96)), 1);
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   360
13948
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13946
diff changeset
   361
        l.fill(Point::new(32, 32), 1, 2);
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13946
diff changeset
   362
        l.fill(Point::new(16, 96), 1, 3);
c6e1769ac9aa Change Land2D::fill() arguments a bit
unc0rr
parents: 13946
diff changeset
   363
        l.fill(Point::new(60, 100), 1, 4);
13924
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   364
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   365
        assert_eq!(l.pixels[0][0], 1);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   366
        assert_eq!(l.pixels[96][64], 1);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   367
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   368
        assert_eq!(l.pixels[40][32], 2);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   369
        assert_eq!(l.pixels[40][96], 2);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   370
        assert_eq!(l.pixels[5][0], 3);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   371
        assert_eq!(l.pixels[120][0], 3);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   372
        assert_eq!(l.pixels[5][127], 3);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   373
        assert_eq!(l.pixels[120][127], 3);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   374
        assert_eq!(l.pixels[35][64], 3);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   375
        assert_eq!(l.pixels[120][20], 4);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   376
        assert_eq!(l.pixels[120][100], 4);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   377
        assert_eq!(l.pixels[100][64], 4);
a140f28decc4 Implement Land2D::fill() + tests
unc0rr
parents: 13917
diff changeset
   378
    }
13917
a83ba9ba1566 Start land2d library implementation: draw_line() method
unc0rr
parents:
diff changeset
   379
}