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

author	unC0Rr
	Sun, 12 Feb 2023 14:19:02 +0100
branch	transitional_engine
changeset 15918	9bd828451d77
parent 15828	44b49f255e31
permissions	-rw-r--r--