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

author	unC0Rr
	Tue, 28 Jan 2025 15:49:45 +0100
changeset 16073	5d302b12d837
parent 16052	6633961698ad
permissions	-rw-r--r--