hedgewars: rust/integral-geometry/src/lib.rs@58a0f2a6527b (annotated)

15214 58a0f2a6527b optimize sqrts alfadur parents: 15182 diff changeset	1	use fpnum::{fp, integral_sqrt, FPNum, FPPoint};
14134 09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	2	use std::{
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	3	cmp::{max, min},
15025 dc4a12a84c92 remove RangeContains in favor of standard contains alfadur parents: 14726 diff changeset	4	ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, RangeInclusive, Sub, SubAssign},
14134 09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	5	};
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	6
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	7	#[derive(PartialEq, Eq, Clone, Copy, Debug)]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	8	pub struct Point {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	9	pub x: i32,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	10	pub y: i32,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	11	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	12
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	13	impl Point {
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	14	pub const ZERO: Self = Self::new(0, 0);
2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	15
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	16	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	17	pub const fn new(x: i32, y: i32) -> Self {
13941 3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	18	Self { x, y }
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	19	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	20
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	21	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	22	pub const fn diag(v: i32) -> Self {
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	23	Self::new(v, v)
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	24	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	25
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	26	#[inline]
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	27	pub fn signum(self) -> Self {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	28	Self::new(self.x.signum(), self.y.signum())
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	29	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	30
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	31	#[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	32	pub fn abs(self) -> Self {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	33	Self::new(self.x.abs(), self.y.abs())
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	34	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	35
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	36	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	37	pub const fn dot(self, other: Point) -> i32 {
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	38	self.x * other.x + self.y * other.y
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	39	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	40
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	41	#[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	42	pub fn max_norm(self) -> i32 {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	43	std::cmp::max(self.x.abs(), self.y.abs())
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	44	}
14031 c47283feafac add circle filling to land2d alfadur parents: 13950 diff changeset	45
c47283feafac add circle filling to land2d alfadur parents: 13950 diff changeset	46	#[inline]
14081 5d42204ac35e Start convertion of FindPoint() unC0Rr parents: 14078 diff changeset	47	pub fn integral_norm(self) -> u32 {
15214 58a0f2a6527b optimize sqrts alfadur parents: 15182 diff changeset	48	let sqr = (self.x as u64).pow(2) + (self.y as u64).pow(2);
58a0f2a6527b optimize sqrts alfadur parents: 15182 diff changeset	49	integral_sqrt(sqr) as u32
14081 5d42204ac35e Start convertion of FindPoint() unC0Rr parents: 14078 diff changeset	50	}
5d42204ac35e Start convertion of FindPoint() unC0Rr parents: 14078 diff changeset	51
5d42204ac35e Start convertion of FindPoint() unC0Rr parents: 14078 diff changeset	52	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	53	pub const fn transform(self, matrix: &[i32; 4]) -> Self {
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	54	Point::new(
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	55	matrix[0] * self.x + matrix[1] * self.y,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	56	matrix[2] * self.x + matrix[3] * self.y,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	57	)
14031 c47283feafac add circle filling to land2d alfadur parents: 13950 diff changeset	58	}
14106 5c1ce63114a5 a bit of simplification alfadur parents: 14096 diff changeset	59
5c1ce63114a5 a bit of simplification alfadur parents: 14096 diff changeset	60	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	61	pub const fn rotate90(self) -> Self {
14107 6a3bcb7c2981 swap coordinate system alfadur parents: 14106 diff changeset	62	Point::new(self.y, -self.x)
14106 5c1ce63114a5 a bit of simplification alfadur parents: 14096 diff changeset	63	}
14108 36b792842d5b a bit more simplification alfadur parents: 14107 diff changeset	64
36b792842d5b a bit more simplification alfadur parents: 14107 diff changeset	65	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	66	pub const fn cross(self, other: Point) -> i32 {
14108 36b792842d5b a bit more simplification alfadur parents: 14107 diff changeset	67	self.dot(other.rotate90())
36b792842d5b a bit more simplification alfadur parents: 14107 diff changeset	68	}
14125 376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	69
376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	70	#[inline]
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	71	pub fn clamp(self, rect: &Rect) -> Point {
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	72	Point::new(rect.x_range().clamp(self.x), rect.y_range().clamp(self.y))
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	73	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	74
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	75	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	76	pub const fn line_to(self, end: Point) -> Line {
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	77	Line::new(self, end)
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	78	}
14125 376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	79
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	80	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	81	pub const fn ray_with_dir(self, direction: Point) -> Ray {
14141 477faa7b8a48 fix ray construction alfadur parents: 14140 diff changeset	82	Ray::new(self, direction)
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	83	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	84
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	85	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	86	pub const fn tangent_mul(self, x: i32) -> i32 {
14142 11202097584f fix tangents alfadur parents: 14141 diff changeset	87	x * self.y / self.x
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	88	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	89
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	90	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	91	pub const fn cotangent_mul(self, y: i32) -> i32 {
14142 11202097584f fix tangents alfadur parents: 14141 diff changeset	92	y * self.x / self.y
14125 376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	93	}
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	94
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	95	#[inline]
14144 165e43c3ed59 pull land into collision detector alfadur parents: 14142 diff changeset	96	pub fn to_fppoint(self) -> FPPoint {
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	97	FPPoint::new(self.x.into(), self.y.into())
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	98	}
14144 165e43c3ed59 pull land into collision detector alfadur parents: 14142 diff changeset	99
165e43c3ed59 pull land into collision detector alfadur parents: 14142 diff changeset	100	#[inline]
165e43c3ed59 pull land into collision detector alfadur parents: 14142 diff changeset	101	pub fn from_fppoint(p: &FPPoint) -> Self {
165e43c3ed59 pull land into collision detector alfadur parents: 14142 diff changeset	102	Self::new(p.x().round(), p.y().round())
165e43c3ed59 pull land into collision detector alfadur parents: 14142 diff changeset	103	}
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	104	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	105
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	106	#[derive(PartialEq, Eq, Clone, Copy, Debug)]
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	107	pub struct Size {
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	108	pub width: usize,
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	109	pub height: usize,
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	110	}
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	111
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	112	impl Size {
14717 16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	113	pub const EMPTY: Self = Self::square(0);
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	114
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	115	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	116	pub const fn new(width: usize, height: usize) -> Self {
2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	117	Self { width, height }
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	118	}
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	119
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	120	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	121	pub const fn square(size: usize) -> Self {
2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	122	Self {
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	123	width: size,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	124	height: size,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	125	}
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	126	}
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	127
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	128	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	129	pub const fn area(&self) -> usize {
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	130	self.width * self.height
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	131	}
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	132
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	133	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	134	pub const fn linear_index(&self, x: usize, y: usize) -> usize {
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	135	y * self.width + x
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	136	}
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	137
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	138	#[inline]
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	139	pub fn is_power_of_two(&self) -> bool {
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	140	self.width.is_power_of_two() && self.height.is_power_of_two()
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	141	}
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	142
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	143	#[inline]
14052 9c817b2eedae merge alfadur parents: 14051 14032 diff changeset	144	pub fn next_power_of_two(&self) -> Self {
9c817b2eedae merge alfadur parents: 14051 14032 diff changeset	145	Self {
9c817b2eedae merge alfadur parents: 14051 14032 diff changeset	146	width: self.width.next_power_of_two(),
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	147	height: self.height.next_power_of_two(),
14052 9c817b2eedae merge alfadur parents: 14051 14032 diff changeset	148	}
9c817b2eedae merge alfadur parents: 14051 14032 diff changeset	149	}
9c817b2eedae merge alfadur parents: 14051 14032 diff changeset	150
9c817b2eedae merge alfadur parents: 14051 14032 diff changeset	151	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	152	pub const fn transpose(&self) -> Self {
14175 76a52e8149e3 add some texture transforms alfadur parents: 14155 diff changeset	153	Self::new(self.height, self.width)
76a52e8149e3 add some texture transforms alfadur parents: 14155 diff changeset	154	}
76a52e8149e3 add some texture transforms alfadur parents: 14155 diff changeset	155
76a52e8149e3 add some texture transforms alfadur parents: 14155 diff changeset	156	#[inline]
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	157	pub fn to_mask(&self) -> SizeMask {
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	158	SizeMask::new(*self)
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	159	}
14059 c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	160
14125 376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	161	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	162	pub fn to_square(&self) -> Self {
2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	163	Self::square(max(self.width, self.height))
14125 376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	164	}
376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	165
14059 c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	166	pub fn to_grid_index(&self) -> GridIndex {
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	167	GridIndex::new(*self)
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	168	}
14717 16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	169
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	170	#[inline]
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	171	pub fn contains(&self, other: Self) -> bool {
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	172	self.width >= other.width && self.height >= other.height
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	173	}
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	174	}
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	175
14148 d3c9025abd13 seems like about 25% speedup in land filling alfadur parents: 14146 diff changeset	176	#[derive(PartialEq, Eq, Clone, Copy, Debug)]
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	177	pub struct SizeMask {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	178	size: Size,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	179	}
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	180
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	181	impl SizeMask {
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	182	#[inline]
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	183	pub fn new(size: Size) -> Self {
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	184	debug_assert!(size.is_power_of_two());
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	185	let size = Size {
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	186	width: !(size.width - 1),
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	187	height: !(size.height - 1),
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	188	};
14059 c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	189	Self { size }
14032 2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	190	}
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	191
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	192	#[inline]
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	193	pub fn contains_x<T: Into<usize>>(&self, x: T) -> bool {
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	194	(self.size.width & x.into()) == 0
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	195	}
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	196
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	197	#[inline]
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	198	pub fn contains_y<T: Into<usize>>(&self, y: T) -> bool {
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	199	(self.size.height & y.into()) == 0
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	200	}
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	201
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	202	#[inline]
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	203	pub fn contains(&self, point: Point) -> bool {
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	204	self.contains_x(point.x as usize) && self.contains_y(point.y as usize)
2869c2ccb1b8 extract size struct for common usage alfadur parents: 14031 diff changeset	205	}
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	206	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	207
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	208	pub struct GridIndex {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	209	shift: Point,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	210	}
14059 c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	211
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	212	impl GridIndex {
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	213	pub fn new(size: Size) -> Self {
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	214	assert!(size.is_power_of_two());
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	215	let shift = Point::new(
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	216	size.width.trailing_zeros() as i32,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	217	size.height.trailing_zeros() as i32,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	218	);
14059 c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	219	Self { shift }
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	220	}
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	221
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	222	pub fn map(&self, position: Point) -> Point {
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	223	Point::new(position.x >> self.shift.x, position.y >> self.shift.y)
14059 c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	224	}
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	225	}
c6745a1c827a start a physics engine to try out this data oriented thing everyone seems to be talking about alfadur parents: 14054 diff changeset	226
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	227	macro_rules! bin_op_impl {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	228	($op: ty, $name: tt) => {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	229	impl $op for Point {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	230	type Output = Self;
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	231
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	232	#[inline]
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	233	fn $name(self, rhs: Self) -> Self::Output {
13941 3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	234	Self::new(self.x.$name(rhs.x), self.y.$name(rhs.y))
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	235	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	236	}
13941 3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	237	};
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	238	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	239
14088 f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	240	macro_rules! scalar_bin_op_impl {
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	241	($($op: tt)::+, $name: tt) => {
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	242	impl $($op)::+<i32> for Point {
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	243	type Output = Self;
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	244
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	245	#[inline]
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	246	fn $name(self, rhs: i32) -> Self::Output {
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	247	Self::new(self.x.$name(rhs), self.y.$name(rhs))
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	248	}
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	249	}
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	250	};
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	251	}
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	252
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	253	macro_rules! bin_assign_op_impl {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	254	($op: ty, $name: tt) => {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	255	impl $op for Point {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	256	#[inline]
13941 3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	257	fn $name(&mut self, rhs: Self) {
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	258	self.x.$name(rhs.x);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	259	self.y.$name(rhs.y);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	260	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	261	}
13941 3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	262	};
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	263	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	264
14146 4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	265	macro_rules! fp_scalar_bin_op_impl {
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	266	($($op: tt)::+, $name: tt) => {
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	267	impl $($op)::+<FPNum> for Point {
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	268	type Output = FPPoint;
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	269
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	270	#[inline]
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	271	fn $name(self, rhs: FPNum) -> Self::Output {
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	272	FPPoint::new(rhs.$name(self.x), rhs.$name(self.y))
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	273	}
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	274	}
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	275	};
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	276	}
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	277
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	278	macro_rules! left_fp_scalar_bin_op_impl {
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	279	($($op: tt)::+, $name: tt) => {
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	280	impl $($op)::+<Point> for FPNum {
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	281	type Output = FPPoint;
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	282
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	283	#[inline]
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	284	fn $name(self, rhs: Point) -> Self::Output {
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	285	FPPoint::new(self.$name(rhs.x), self.$name(rhs.y))
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	286	}
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	287	}
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	288	};
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	289	}
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	290
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	291	bin_op_impl!(Add, add);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	292	bin_op_impl!(Sub, sub);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	293	bin_op_impl!(Mul, mul);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	294	bin_op_impl!(Div, div);
14088 f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	295	scalar_bin_op_impl!(Mul, mul);
f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	296	scalar_bin_op_impl!(Div, div);
14146 4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	297	fp_scalar_bin_op_impl!(Mul, mul);
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	298	fp_scalar_bin_op_impl!(Div, div);
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	299	left_fp_scalar_bin_op_impl!(Mul, mul);
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	300	left_fp_scalar_bin_op_impl!(Div, div);
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	301	bin_assign_op_impl!(AddAssign, add_assign);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	302	bin_assign_op_impl!(SubAssign, sub_assign);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	303	bin_assign_op_impl!(MulAssign, mul_assign);
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	304	bin_assign_op_impl!(DivAssign, div_assign);
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	305
14051 8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen unc0rr parents: 13950 diff changeset	306	#[derive(PartialEq, Eq, Clone, Copy, Debug)]
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen unc0rr parents: 13950 diff changeset	307	pub struct Rect {
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	308	top_left: Point,
3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	309	bottom_right: Point,
14051 8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen unc0rr parents: 13950 diff changeset	310	}
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen unc0rr parents: 13950 diff changeset	311
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen unc0rr parents: 13950 diff changeset	312	impl Rect {
14717 16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	313	pub const EMPTY: Self = Self {
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	314	top_left: Point::ZERO,
14725 19d30d96d7d6 fix atlas.insert alfadur parents: 14717 diff changeset	315	bottom_right: Point::diag(-1),
14717 16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	316	};
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	317
14051 8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen unc0rr parents: 13950 diff changeset	318	#[inline]
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	319	pub fn new(top_left: Point, bottom_right: Point) -> Self {
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	320	debug_assert!(top_left.x <= bottom_right.x + 1);
2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	321	debug_assert!(top_left.y <= bottom_right.y + 1);
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	322	Self {
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	323	top_left,
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	324	bottom_right,
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	325	}
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	326	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	327
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	328	pub fn from_box(left: i32, right: i32, top: i32, bottom: i32) -> Self {
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	329	Self::new(Point::new(left, top), Point::new(right, bottom))
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	330	}
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	331
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	332	pub fn from_size(top_left: Point, size: Size) -> Self {
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	333	Self::new(
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	334	top_left,
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	335	top_left + Point::new(size.width as i32 - 1, size.height as i32 - 1),
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	336	)
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	337	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	338
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	339	pub fn from_size_coords(x: i32, y: i32, width: usize, height: usize) -> Self {
3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	340	Self::from_size(Point::new(x, y), Size::new(width, height))
3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	341	}
3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	342
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	343	pub fn at_origin(size: Size) -> Self {
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	344	Self::from_size(Point::ZERO, size)
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	345	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	346
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	347	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	348	pub const fn width(&self) -> usize {
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	349	(self.right() - self.left() + 1) as usize
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	350	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	351
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	352	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	353	pub const fn height(&self) -> usize {
14207 bb2f301d4fe0 2018ize everything alfadur parents: 14175 diff changeset	354	(self.bottom() - self.top() + 1) as usize
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	355	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	356
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	357	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	358	pub const fn size(&self) -> Size {
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	359	Size::new(self.width(), self.height())
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	360	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	361
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	362	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	363	pub const fn area(&self) -> usize {
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	364	self.size().area()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	365	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	366
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	367	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	368	pub const fn left(&self) -> i32 {
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	369	self.top_left().x
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	370	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	371
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	372	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	373	pub const fn top(&self) -> i32 {
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	374	self.top_left().y
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	375	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	376
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	377	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	378	pub const fn right(&self) -> i32 {
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	379	self.bottom_right().x
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	380	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	381
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	382	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	383	pub const fn bottom(&self) -> i32 {
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	384	self.bottom_right().y
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	385	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	386
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	387	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	388	pub const fn top_left(&self) -> Point {
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	389	self.top_left
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	390	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	391
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	392	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	393	pub const fn bottom_right(&self) -> Point {
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	394	self.bottom_right
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	395	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	396
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	397	#[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	398	pub fn center(&self) -> Point {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	399	(self.top_left() + self.bottom_right()) / 2
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	400	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	401
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	402	#[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	403	pub fn with_margin(&self, margin: i32) -> Self {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	404	let offset = Point::diag(margin);
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	405	Self::new(self.top_left() + offset, self.bottom_right() - offset)
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	406	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	407
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	408	#[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	409	pub fn x_range(&self) -> RangeInclusive<i32> {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	410	self.left()..=self.right()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	411	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	412
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	413	#[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	414	pub fn y_range(&self) -> RangeInclusive<i32> {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	415	self.top()..=self.bottom()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	416	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	417
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	418	#[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	419	pub fn contains(&self, point: Point) -> bool {
15025 dc4a12a84c92 remove RangeContains in favor of standard contains alfadur parents: 14726 diff changeset	420	self.x_range().contains(&point.x) && self.y_range().contains(&point.y)
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	421	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	422
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	423	#[inline]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	424	pub fn contains_inside(&self, point: Point) -> bool {
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	425	point.x > self.left()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	426	&& point.x < self.right()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	427	&& point.y > self.top()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	428	&& point.y < self.bottom()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	429	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	430
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	431	#[inline]
14717 16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	432	pub fn contains_rect(&self, other: &Self) -> bool {
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	433	self.contains(other.top_left()) && self.contains(other.bottom_right())
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	434	}
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	435
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	436	#[inline]
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	437	pub fn intersects(&self, other: &Rect) -> bool {
14726 75ff5c643004 actually atlas tests were also broken alfadur parents: 14725 diff changeset	438	self.left() <= other.right()
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	439	&& self.right() >= other.left()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	440	&& self.top() <= other.bottom()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	441	&& self.bottom() >= other.top()
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	442	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	443
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	444	#[inline]
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	445	pub fn split_at(&self, point: Point) -> [Rect; 4] {
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	446	assert!(self.contains_inside(point));
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	447	[
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	448	Self::from_box(self.left(), point.x, self.top(), point.y),
3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	449	Self::from_box(point.x, self.right(), self.top(), point.y),
3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	450	Self::from_box(point.x, self.right(), point.y, self.bottom()),
3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	451	Self::from_box(self.left(), point.x, point.y, self.bottom()),
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	452	]
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	453	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	454
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	455	#[inline]
14717 16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	456	pub fn with_margins(&self, left: i32, right: i32, top: i32, bottom: i32) -> Self {
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	457	Self::from_box(
14725 19d30d96d7d6 fix atlas.insert alfadur parents: 14717 diff changeset	458	self.left() - left,
14717 16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	459	self.right() + right,
14725 19d30d96d7d6 fix atlas.insert alfadur parents: 14717 diff changeset	460	self.top() - top,
14717 16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	461	self.bottom() + bottom,
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	462	)
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	463	}
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	464
16024046d458 rescue the atlas alfadur parents: 14627 diff changeset	465	#[inline]
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	466	pub fn quotient(self, x: usize, y: usize) -> Point {
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	467	self.top_left() + Point::new((x % self.width()) as i32, (y % self.height()) as i32)
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	468	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	469	}
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	470
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	471	trait RangeClamp<T> {
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	472	fn clamp(&self, value: T) -> T;
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	473	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	474
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	475	impl<T: Ord + Copy> RangeClamp<T> for RangeInclusive<T> {
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	476	fn clamp(&self, value: T) -> T {
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	477	if value < *self.start() {
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	478	*self.start()
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	479	} else if value > *self.end() {
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	480	*self.end()
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	481	} else {
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	482	value
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	483	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	484	}
14051 8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen unc0rr parents: 13950 diff changeset	485	}
8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen unc0rr parents: 13950 diff changeset	486
14094 d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	487	pub struct Polygon {
14125 376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	488	vertices: Vec<Point>,
14094 d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	489	}
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	490
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	491	impl Polygon {
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	492	pub fn new(vertices: &[Point]) -> Self {
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	493	let mut v = Vec::with_capacity(vertices.len() + 1);
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	494	v.extend_from_slice(vertices);
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	495	if !v.is_empty() {
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	496	let start = v[0];
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	497	v.push(start);
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	498	}
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	499	Self { vertices: v }
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	500	}
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	501
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	502	pub fn edges_count(&self) -> usize {
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	503	self.vertices.len() - 1
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	504	}
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	505
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	506	pub fn get_edge(&self, index: usize) -> Line {
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	507	Line::new(self.vertices[index], self.vertices[index + 1])
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	508	}
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	509
14124 6e0be42d0a8f polygonize OutlinePoints alfadur parents: 14112 diff changeset	510	pub fn split_edge(&mut self, edge_index: usize, vertex: Point) {
6e0be42d0a8f polygonize OutlinePoints alfadur parents: 14112 diff changeset	511	self.vertices.insert(edge_index + 1, vertex);
6e0be42d0a8f polygonize OutlinePoints alfadur parents: 14112 diff changeset	512	}
6e0be42d0a8f polygonize OutlinePoints alfadur parents: 14112 diff changeset	513
6e0be42d0a8f polygonize OutlinePoints alfadur parents: 14112 diff changeset	514	pub fn iter<'a>(&'a self) -> impl Iterator<Item = &Point> + 'a {
6e0be42d0a8f polygonize OutlinePoints alfadur parents: 14112 diff changeset	515	(&self.vertices[..self.edges_count()]).iter()
6e0be42d0a8f polygonize OutlinePoints alfadur parents: 14112 diff changeset	516	}
6e0be42d0a8f polygonize OutlinePoints alfadur parents: 14112 diff changeset	517
14134 09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	518	pub fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &mut Point> + 'a {
14155 8f82d87d223f save edges_count alfadur parents: 14152 diff changeset	519	let edges_count = self.edges_count();
14134 09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	520	let start = self.vertices.as_mut_ptr();
14155 8f82d87d223f save edges_count alfadur parents: 14152 diff changeset	521	let end = unsafe { start.add(edges_count) };
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	522	PolygonPointsIteratorMut {
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	523	source: self,
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	524	start,
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	525	end,
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	526	}
14094 d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	527	}
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	528
14134 09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	529	fn force_close(&mut self) {
14133 a65b60f36b96 fix polygons getting unclosed on mirroring alfadur parents: 14131 diff changeset	530	if !self.vertices.is_empty() {
14208 87f1054c2333 fix polygon closure alfadur parents: 14207 diff changeset	531	let edges_count = self.edges_count();
87f1054c2333 fix polygon closure alfadur parents: 14207 diff changeset	532	self.vertices[edges_count] = self.vertices[0];
14133 a65b60f36b96 fix polygons getting unclosed on mirroring alfadur parents: 14131 diff changeset	533	}
a65b60f36b96 fix polygons getting unclosed on mirroring alfadur parents: 14131 diff changeset	534	}
a65b60f36b96 fix polygons getting unclosed on mirroring alfadur parents: 14131 diff changeset	535
14094 d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	536	pub fn iter_edges<'a>(&'a self) -> impl Iterator<Item = Line> + 'a {
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	537	(&self.vertices[0..self.edges_count()])
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	538	.iter()
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	539	.zip(&self.vertices[1..])
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	540	.map(\|(s, e)\| Line::new(s, e))
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	541	}
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	542
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	543	pub fn bezierize(&mut self, segments_number: u32) {
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	544	fn calc_point(p1: Point, p2: Point, p3: Point) -> FPPoint {
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	545	let diff13 = (p1 - p3).to_fppoint();
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	546	let diff13_norm = diff13.distance();
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	547
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	548	if diff13_norm.is_zero() {
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	549	diff13
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	550	} else {
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	551	let diff12_norm = (p1 - p2).to_fppoint().distance();
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	552	let diff23_norm = (p2 - p3).to_fppoint().distance();
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	553	let min_distance = min(diff13_norm, min(diff12_norm, diff23_norm));
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	554
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	555	diff13 * min_distance / diff13_norm / 3
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	556	}
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	557	}
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	558
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	559	if self.vertices.len() < 4 {
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	560	return;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	561	}
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	562
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	563	let delta = fp!(1 / segments_number);
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	564	let mut bezierized_vertices = Vec::new();
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	565	let mut pi = 0;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	566	let mut i = 1;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	567	let mut ni = 2;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	568	let mut right_point = calc_point(self.vertices[pi], self.vertices[i], self.vertices[ni]);
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	569	let mut left_point;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	570
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	571	pi += 1;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	572	while pi != 0 {
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	573	pi = i;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	574	i = ni;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	575	ni += 1;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	576	if ni >= self.vertices.len() {
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	577	ni = 0;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	578	}
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	579
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	580	left_point = right_point;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	581	right_point = calc_point(self.vertices[pi], self.vertices[i], self.vertices[ni]);
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	582
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	583	bezierized_vertices.extend(BezierCurveSegments::new(
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	584	Line::new(self.vertices[pi], self.vertices[i]),
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	585	left_point,
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	586	-right_point,
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	587	delta,
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	588	));
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	589	}
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	590
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	591	self.vertices = bezierized_vertices;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	592	}
14094 d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	593	}
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	594
14134 09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	595	struct PolygonPointsIteratorMut<'a> {
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	596	source: &'a mut Polygon,
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	597	start: *mut Point,
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	598	end: *mut Point,
14134 09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	599	}
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	600
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	601	impl<'a> Iterator for PolygonPointsIteratorMut<'a> {
14134 09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	602	type Item = &'a mut Point;
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	603
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	604	fn next(&mut self) -> Option<<Self as Iterator>::Item> {
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	605	if self.start == self.end {
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	606	None
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	607	} else {
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	608	unsafe {
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	609	let result = &mut *self.start;
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	610	self.start = self.start.add(1);
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	611	Some(result)
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	612	}
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	613	}
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	614	}
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	615	}
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	616
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	617	impl<'a> Drop for PolygonPointsIteratorMut<'a> {
14134 09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	618	fn drop(&mut self) {
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	619	self.source.force_close();
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	620	}
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	621	}
09f62bb046ef actually there is a way to preserve mutable polygon iterator alfadur parents: 14133 diff changeset	622
14094 d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	623	impl From<Vec<Point>> for Polygon {
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	624	fn from(mut v: Vec<Point>) -> Self {
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	625	if !v.is_empty() && v[0] != v[v.len() - 1] {
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	626	let start = v[0];
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	627	v.push(start)
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	628	}
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	629	Self { vertices: v }
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	630	}
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	631	}
d0b0d61b7d5e add polygons alfadur parents: 14092 diff changeset	632
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	633	#[derive(PartialEq, Eq, Clone, Copy, Debug)]
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	634	pub struct Ray {
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	635	pub start: Point,
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	636	pub direction: Point,
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	637	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	638
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	639	impl Ray {
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	640	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	641	pub const fn new(start: Point, direction: Point) -> Ray {
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	642	Self { start, direction }
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	643	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	644
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	645	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	646	pub const fn tangent_mul(&self, x: i32) -> i32 {
14142 11202097584f fix tangents alfadur parents: 14141 diff changeset	647	self.direction.tangent_mul(x)
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	648	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	649
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	650	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	651	pub const fn cotangent_mul(&self, y: i32) -> i32 {
14142 11202097584f fix tangents alfadur parents: 14141 diff changeset	652	self.direction.cotangent_mul(y)
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	653	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	654
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	655	#[inline]
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	656	pub fn orientation(&self, point: Point) -> i32 {
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	657	(point - self.start).cross(self.direction).signum()
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	658	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	659	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	660
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	661	#[derive(PartialEq, Eq, Clone, Copy, Debug)]
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	662	pub struct Line {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	663	pub start: Point,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	664	pub end: Point,
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	665	}
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	666
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	667	impl Line {
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	668	pub const ZERO: Self = Self::new(Point::ZERO, Point::ZERO);
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	669
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	670	#[inline]
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	671	pub const fn new(start: Point, end: Point) -> Self {
2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	672	Self { start, end }
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	673	}
14077 5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	674
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	675	#[inline]
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	676	pub fn center(&self) -> Point {
14088 f483f844da98 component-wise division is actually useful sometimes alfadur parents: 14081 diff changeset	677	(self.start + self.end) / 2
14077 5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	678	}
14106 5c1ce63114a5 a bit of simplification alfadur parents: 14096 diff changeset	679
5c1ce63114a5 a bit of simplification alfadur parents: 14096 diff changeset	680	#[inline]
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	681	pub fn scaled_direction(&self) -> Point {
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	682	self.end - self.start
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	683	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	684
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	685	#[inline]
14106 5c1ce63114a5 a bit of simplification alfadur parents: 14096 diff changeset	686	pub fn scaled_normal(&self) -> Point {
14131 c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	687	self.scaled_direction().rotate90()
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	688	}
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	689
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	690	#[inline]
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	691	pub fn to_ray(&self) -> Ray {
c416d32764b7 organize landgen a bit more alfadur parents: 14126 diff changeset	692	Ray::new(self.start, self.scaled_direction())
14106 5c1ce63114a5 a bit of simplification alfadur parents: 14096 diff changeset	693	}
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	694	}
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	695
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	696	impl IntoIterator for Line {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	697	type Item = Point;
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	698	type IntoIter = LinePoints;
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	699
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	700	fn into_iter(self) -> Self::IntoIter {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	701	LinePoints::new(self)
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	702	}
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	703	}
14051 8a0d69c16cad Implement OutlinePoints for land generators, some ground work for template based landgen unc0rr parents: 13950 diff changeset	704
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	705	pub struct LinePoints {
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	706	accumulator: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	707	direction: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	708	sign: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	709	current: Point,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	710	total_steps: i32,
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	711	step: i32,
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	712	}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	713
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	714	impl LinePoints {
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	715	pub fn new(line: Line) -> Self {
e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	716	let dir = line.end - line.start;
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	717
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	718	Self {
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	719	accumulator: Point::ZERO,
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	720	direction: dir.abs(),
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	721	sign: dir.signum(),
14076 e5904ead4864 Introduce OutlineSegmentsIterator, some refactoring unC0Rr parents: 14059 diff changeset	722	current: line.start,
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	723	total_steps: dir.max_norm(),
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	724	step: 0,
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	725	}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	726	}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	727	}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	728
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	729	impl Iterator for LinePoints {
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	730	type Item = Point;
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	731
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	732	fn next(&mut self) -> Option<Self::Item> {
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	733	if self.step <= self.total_steps {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	734	self.accumulator += self.direction;
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	735
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	736	if self.accumulator.x > self.total_steps {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	737	self.accumulator.x -= self.total_steps;
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	738	self.current.x += self.sign.x;
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	739	}
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	740	if self.accumulator.y > self.total_steps {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	741	self.accumulator.y -= self.total_steps;
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	742	self.current.y += self.sign.y;
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	743	}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	744
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	745	self.step += 1;
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	746
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	747	Some(self.current)
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	748	} else {
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	749	None
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	750	}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	751	}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	752	}
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	753
13941 3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	754	pub struct ArcPoints {
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	755	point: Point,
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	756	step: i32,
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	757	}
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	758
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	759	impl ArcPoints {
14627 2e2b31cf0871 make stuff const alfadur parents: 14208 diff changeset	760	pub const fn new(radius: i32) -> Self {
13941 3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	761	Self {
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	762	point: Point::new(0, radius),
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	763	step: 3 - 2 * radius,
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	764	}
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	765	}
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	766	}
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	767
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	768	impl Iterator for ArcPoints {
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	769	type Item = Point;
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	770
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	771	fn next(&mut self) -> Option<Self::Item> {
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	772	if self.point.x < self.point.y {
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	773	let result = self.point;
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	774
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	775	if self.step < 0 {
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	776	self.step += self.point.x * 4 + 6;
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	777	} else {
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	778	self.step += (self.point.x - self.point.y) * 4 + 10;
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	779	self.point.y -= 1;
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	780	}
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	781
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	782	self.point.x += 1;
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	783
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	784	Some(result)
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	785	} else if self.point.x == self.point.y {
13947 85645992bc8a Fix ArcPoints never finishing unc0rr parents: 13943 diff changeset	786	self.point.x += 1;
13950 48796bef9e69 Add --protocol option to engine unc0rr parents: 13947 diff changeset	787
13941 3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	788	Some(self.point)
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	789	} else {
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	790	None
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	791	}
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	792	}
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	793	}
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	794
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	795	pub struct EquidistantPoints {
15182 decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	796	vector: Vec<Point>,
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	797	}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	798
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	799	impl EquidistantPoints {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	800	pub fn new(vector: Point) -> Self {
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	801	Self {
15182 decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	802	vector: if vector.x == vector.y {
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	803	vec![
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	804	Point::new(vector.x, vector.x),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	805	Point::new(vector.x, -vector.x),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	806	Point::new(-vector.x, -vector.x),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	807	Point::new(-vector.x, vector.x),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	808	]
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	809	} else {
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	810	vec![
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	811	Point::new(vector.x, vector.y),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	812	Point::new(vector.x, -vector.y),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	813	Point::new(-vector.x, -vector.y),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	814	Point::new(-vector.x, vector.y),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	815	Point::new(vector.y, vector.x),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	816	Point::new(vector.y, -vector.x),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	817	Point::new(-vector.y, -vector.x),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	818	Point::new(-vector.y, vector.x),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	819	]
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	820	},
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	821	}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	822	}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	823	}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	824
15182 decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	825	impl IntoIterator for EquidistantPoints {
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	826	type Item = Point;
15182 decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	827	type IntoIter = std::vec::IntoIter<Point>;
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	828
15182 decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	829	fn into_iter(self) -> Self::IntoIter {
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	830	self.vector.into_iter()
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	831	}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	832	}
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	833
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	834	pub struct BezierCurveSegments {
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	835	segment: Line,
14146 4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	836	control_point1: FPPoint,
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	837	control_point2: FPPoint,
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	838	offset: FPNum,
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	839	max_offset: FPNum,
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	840	delta: FPNum,
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	841	have_finished: bool,
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	842	}
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	843
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	844	impl BezierCurveSegments {
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	845	pub fn new(segment: Line, p1: FPPoint, p2: FPPoint, delta: FPNum) -> Self {
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	846	Self {
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	847	segment,
14146 4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	848	control_point1: segment.start.to_fppoint() - p1,
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	849	control_point2: segment.end.to_fppoint() - p2,
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	850	offset: fp!(0),
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	851	max_offset: fp!(4095 / 4096),
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	852	delta,
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	853	have_finished: false,
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	854	}
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	855	}
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	856	}
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	857
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	858	impl Iterator for BezierCurveSegments {
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	859	type Item = Point;
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	860
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	861	fn next(&mut self) -> Option<Self::Item> {
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	862	if self.offset < self.max_offset {
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	863	let offset_sq = self.offset * self.offset;
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	864	let offset_cub = offset_sq * self.offset;
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	865
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	866	let r1 = fp!(1) - self.offset * 3 + offset_sq * 3 - offset_cub;
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	867	let r2 = self.offset * 3 - offset_sq * 6 + offset_cub * 3;
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	868	let r3 = offset_sq * 3 - offset_cub * 3;
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	869
14146 4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	870	let p = r1 * self.segment.start
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	871	+ r2 * self.control_point1
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	872	+ r3 * self.control_point2
4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	873	+ offset_cub * self.segment.end;
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	874
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	875	self.offset += self.delta;
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	876
14146 4791c9a7d5e8 add more point operators alfadur parents: 14144 diff changeset	877	Some(Point::from_fppoint(&p))
14140 3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	878	} else if !self.have_finished {
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	879	self.have_finished = true;
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	880
3078123e84ea Bezierize land outline unc0rr parents: 14139 diff changeset	881	Some(self.segment.end)
14139 37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	882	} else {
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	883	None
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	884	}
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	885	}
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	886	}
37c99587825d Implement BeizerCurveSegments, no tests unc0rr parents: 14137 diff changeset	887
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	888	#[cfg(test)]
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	889	mod tests {
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	890	use super::*;
75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	891
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	892	fn get_points(coords: &[(i32, i32)]) -> Vec<Point> {
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	893	coords.iter().map(\|(x, y)\| Point::new(x, y)).collect()
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	894	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	895
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	896	#[test]
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	897	fn line_basic() {
14077 5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	898	let line: Vec<Point> = Line::new(Point::new(0, 0), Point::new(3, 3))
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	899	.into_iter()
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	900	.collect();
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	901	let v = get_points(&[(0, 0), (1, 1), (2, 2), (3, 3)]);
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	902
14077 5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	903	assert_eq!(line, v);
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	904	}
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	905
1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	906	#[test]
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	907	fn line_skewed() {
14077 5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	908	let line: Vec<Point> = Line::new(Point::new(0, 0), Point::new(5, -7))
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	909	.into_iter()
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	910	.collect();
13941 3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	911	let v = get_points(&[
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	912	(0, 0),
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	913	(1, -1),
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	914	(2, -2),
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	915	(2, -3),
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	916	(3, -4),
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	917	(4, -5),
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	918	(4, -6),
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	919	(5, -7),
3f69a70063a5 Implement ArcPoints iterator for circles unc0rr parents: 13938 diff changeset	920	]);
13938 1fa905aa4cdb move point struct into integral-geometry and use it to refactor a bit alfadur parents: 13937 diff changeset	921
14077 5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	922	assert_eq!(line, v);
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	923	}
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	924
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	925	#[test]
13943 a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates unc0rr parents: 13942 diff changeset	926	fn equidistant_full() {
15182 decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	927	let n: Vec<Point> = EquidistantPoints::new(Point::new(1, 3))
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	928	.into_iter()
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	929	.collect();
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	930	let v = get_points(&[
15182 decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	931	(1, 3),
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	932	(1, -3),
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	933	(-1, -3),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	934	(-1, 3),
15182 decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	935	(3, 1),
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	936	(3, -1),
15182 decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	937	(-3, -1),
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	938	(-3, 1),
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	939	]);
7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	940
14077 5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	941	assert_eq!(n, v);
13942 7e7a03e85ac4 Add EquidistantPoints iterator to help iterating over all points of circles unc0rr parents: 13941 diff changeset	942	}
13943 a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates unc0rr parents: 13942 diff changeset	943
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates unc0rr parents: 13942 diff changeset	944	#[test]
a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates unc0rr parents: 13942 diff changeset	945	fn equidistant_half() {
15182 decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	946	let n: Vec<Point> = EquidistantPoints::new(Point::new(2, 2))
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	947	.into_iter()
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	948	.collect();
decb2f1c682b Rework EquidistantPoints unc0rr parents: 15025 diff changeset	949	let v = get_points(&[(2, 2), (2, -2), (-2, -2), (-2, 2)]);
14077 5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	950
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	951	assert_eq!(n, v);
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	952	}
13943 a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates unc0rr parents: 13942 diff changeset	953
14077 5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	954	#[test]
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	955	fn line() {
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	956	let l = Line::new(Point::new(1, 1), Point::new(5, 6));
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	957
5ade484f3351 Refactor tests, add fn center() for Line unC0Rr parents: 14076 diff changeset	958	assert_eq!(l.center(), Point::new(3, 3));
13943 a325ed57ebfe Don't generate unnecessary duplication in case of equal coordinates unc0rr parents: 13942 diff changeset	959	}
14078 bf40b5f938b0 - Add methods to work with Rect as box unC0Rr parents: 14077 diff changeset	960
bf40b5f938b0 - Add methods to work with Rect as box unC0Rr parents: 14077 diff changeset	961	#[test]
bf40b5f938b0 - Add methods to work with Rect as box unC0Rr parents: 14077 diff changeset	962	fn rect() {
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	963	let r = Rect::from_box(10, 100, 0, 70);
14078 bf40b5f938b0 - Add methods to work with Rect as box unC0Rr parents: 14077 diff changeset	964
14081 5d42204ac35e Start convertion of FindPoint() unC0Rr parents: 14078 diff changeset	965	assert!(r.contains_inside(Point::new(99, 69)));
5d42204ac35e Start convertion of FindPoint() unC0Rr parents: 14078 diff changeset	966	assert!(!r.contains_inside(Point::new(100, 70)));
5d42204ac35e Start convertion of FindPoint() unC0Rr parents: 14078 diff changeset	967
14078 bf40b5f938b0 - Add methods to work with Rect as box unC0Rr parents: 14077 diff changeset	968	assert_eq!(r.top_left(), Point::new(10, 0));
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	969	assert_eq!(r.with_margin(12), Rect::from_box(22, 88, 12, 58));
14078 bf40b5f938b0 - Add methods to work with Rect as box unC0Rr parents: 14077 diff changeset	970	}
14125 376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	971
376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	972	#[test]
376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	973	fn fit() {
14137 3119d665d3c6 collapse rectangle types back together with consistent usage of size alfadur parents: 14135 diff changeset	974	let r = Rect::from_box(10, 100, 0, 70);
14125 376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	975
14135 7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	976	assert_eq!(Point::new(0, -10).clamp(&r), Point::new(10, 0));
7f5a591e1c43 separate rectangle types based on right/bottom edge inclusivity alfadur parents: 14134 diff changeset	977	assert_eq!(Point::new(1000, 1000).clamp(&r), Point::new(100, 70));
14125 376a0551b00a - Add distance-divider option to land_dump unc0rr parents: 14124 diff changeset	978	}
13935 75eaf7c71789 Introduce integral-geometry crate, implement LinePoints iterator unc0rr parents: diff changeset	979	}

author	alfadur
	Fri, 05 Jul 2019 21:16:33 +0300
changeset 15214	58a0f2a6527b
parent 15182	decb2f1c682b
child 15215	13041ae61ac5
permissions	-rw-r--r--