755 lines
23 KiB
C#
755 lines
23 KiB
C#
|
|
// ReSharper disable All
|
|
// <auto-generated />
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Windows;
|
|
|
|
using WPFDark;
|
|
|
|
#nullable enable
|
|
|
|
namespace WPFDark.Internals
|
|
{
|
|
public readonly struct ImmutableRect_float : IEquatable<ImmutableRect_float>
|
|
{
|
|
public readonly float X;
|
|
public readonly float Y;
|
|
public readonly float Width;
|
|
public readonly float Height;
|
|
|
|
public bool HasArea => Width > 0f && Height > 0f;
|
|
|
|
public float Left => X;
|
|
public float Top => Y;
|
|
public float Right => X + Width;
|
|
public float Bottom => Y + Height;
|
|
|
|
public ImmutableVec2_float TopLeft => new ImmutableVec2_float(Left, Top);
|
|
public ImmutableVec2_float TopRight => new ImmutableVec2_float(Right, Top);
|
|
public ImmutableVec2_float BottomLeft => new ImmutableVec2_float(Left, Bottom);
|
|
public ImmutableVec2_float BottomRight => new ImmutableVec2_float(Right, Bottom);
|
|
|
|
public ImmutableRect_float(float x, float y, float width, float height)
|
|
=> (X, Y, Width, Height) = (x, y, width, height);
|
|
|
|
public ImmutableRect_float(Point pos, Size size)
|
|
=> (X, Y, Width, Height) = ((float)pos.X, (float)pos.Y, (float)size.Width, (float)size.Height);
|
|
|
|
public ImmutableRect_float(Point pos0, Point pos1)
|
|
{
|
|
var (minX, maxX) = (pos0.X, pos1.X).MinMax();
|
|
var (minY, maxY) = (pos0.Y, pos1.Y).MinMax();
|
|
|
|
(X, Y, Width, Height) = (
|
|
(float)minX,
|
|
(float)minY,
|
|
(float)(maxX - minX),
|
|
(float)(maxY - minY)
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_float(in ImmutableVec2_float pos0, in ImmutableVec2_float pos1)
|
|
{
|
|
var (minX, maxX) = (pos0.X, pos1.X).MinMax();
|
|
var (minY, maxY) = (pos0.Y, pos1.Y).MinMax();
|
|
|
|
(X, Y, Width, Height) = (
|
|
(float)minX,
|
|
(float)minY,
|
|
(float)(maxX - minX),
|
|
(float)(maxY - minY)
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_float(Span<Point> points)
|
|
{
|
|
if (points.Length == 0)
|
|
{
|
|
(X, Y, Width, Height) = (0f, 0f, 0f, 0f);
|
|
return;
|
|
}
|
|
|
|
var minX = points[0].X;
|
|
var minY = points[0].Y;
|
|
var maxX = points[0].X;
|
|
var maxY = points[0].Y;
|
|
|
|
for (var i = 1; i < points.Length; ++i)
|
|
{
|
|
minX = (minX, points[i].X).Min();
|
|
maxX = (maxX, points[i].X).Max();
|
|
|
|
minY = (minY, points[i].Y).Min();
|
|
maxY = (maxY, points[i].Y).Max();
|
|
}
|
|
|
|
(X, Y, Width, Height) = (
|
|
(float)minX,
|
|
(float)minY,
|
|
(float)(maxX - minX),
|
|
(float)(maxY - minY)
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_float(ReadOnlySpan<Point> points)
|
|
{
|
|
if (points.Length == 0)
|
|
{
|
|
(X, Y, Width, Height) = (0f, 0f, 0f, 0f);
|
|
return;
|
|
}
|
|
|
|
var minX = points[0].X;
|
|
var minY = points[0].Y;
|
|
var maxX = points[0].X;
|
|
var maxY = points[0].Y;
|
|
|
|
for (var i = 1; i < points.Length; ++i)
|
|
{
|
|
minX = (minX, points[i].X).Min();
|
|
maxX = (maxX, points[i].X).Max();
|
|
|
|
minY = (minY, points[i].Y).Min();
|
|
maxY = (maxY, points[i].Y).Max();
|
|
}
|
|
|
|
(X, Y, Width, Height) = (
|
|
(float)minX,
|
|
(float)minY,
|
|
(float)(maxX - minX),
|
|
(float)(maxY - minY)
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_float(IEnumerable<Point> points)
|
|
{
|
|
var minX = double.MaxValue;
|
|
var minY = double.MaxValue;
|
|
var maxX = double.MinValue;
|
|
var maxY = double.MinValue;
|
|
|
|
var isAny = false;
|
|
|
|
foreach (var point in points)
|
|
{
|
|
isAny = true;
|
|
|
|
minX = (minX, point.X).Min();
|
|
maxX = (maxX, point.X).Max();
|
|
|
|
minY = (minY, point.Y).Min();
|
|
maxY = (maxY, point.Y).Max();
|
|
}
|
|
|
|
if (isAny)
|
|
(X, Y, Width, Height) = (
|
|
(float)minX,
|
|
(float)minY,
|
|
(float)(maxX - minX),
|
|
(float)(maxY - minY)
|
|
);
|
|
else
|
|
(X, Y, Width, Height) = (0f, 0f, 0f, 0f);
|
|
}
|
|
|
|
public ImmutableRect_float(Span<ImmutableVec2_float> points)
|
|
{
|
|
if (points.Length == 0)
|
|
{
|
|
(X, Y, Width, Height) = (0f, 0f, 0f, 0f);
|
|
return;
|
|
}
|
|
|
|
var minX = points[0].X;
|
|
var minY = points[0].Y;
|
|
var maxX = points[0].X;
|
|
var maxY = points[0].Y;
|
|
|
|
for (var i = 1; i < points.Length; ++i)
|
|
{
|
|
minX = (minX, points[i].X).Min();
|
|
maxX = (maxX, points[i].X).Max();
|
|
|
|
minY = (minY, points[i].Y).Min();
|
|
maxY = (maxY, points[i].Y).Max();
|
|
}
|
|
|
|
(X, Y, Width, Height) = (
|
|
minX,
|
|
minY,
|
|
maxX - minX,
|
|
maxY - minY
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_float(ReadOnlySpan<ImmutableVec2_float> points)
|
|
{
|
|
if (points.Length == 0)
|
|
{
|
|
(X, Y, Width, Height) = (0f, 0f, 0f, 0f);
|
|
return;
|
|
}
|
|
|
|
var minX = points[0].X;
|
|
var minY = points[0].Y;
|
|
var maxX = points[0].X;
|
|
var maxY = points[0].Y;
|
|
|
|
for (var i = 1; i < points.Length; ++i)
|
|
{
|
|
minX = (minX, points[i].X).Min();
|
|
maxX = (maxX, points[i].X).Max();
|
|
|
|
minY = (minY, points[i].Y).Min();
|
|
maxY = (maxY, points[i].Y).Max();
|
|
}
|
|
|
|
(X, Y, Width, Height) = (
|
|
minX,
|
|
minY,
|
|
maxX - minX,
|
|
maxY - minY
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_float(IEnumerable<ImmutableVec2_float> points)
|
|
{
|
|
var minX = float.MaxValue;
|
|
var minY = float.MaxValue;
|
|
var maxX = float.MinValue;
|
|
var maxY = float.MinValue;
|
|
|
|
var isAny = false;
|
|
|
|
foreach (var point in points)
|
|
{
|
|
isAny = true;
|
|
|
|
minX = (minX, point.X).Min();
|
|
maxX = (maxX, point.X).Max();
|
|
|
|
minY = (minY, point.Y).Min();
|
|
maxY = (maxY, point.Y).Max();
|
|
}
|
|
|
|
if (isAny)
|
|
(X, Y, Width, Height) = (
|
|
minX,
|
|
minY,
|
|
maxX - minX,
|
|
maxY - minY
|
|
);
|
|
else
|
|
(X, Y, Width, Height) = (0f, 0f, 0f, 0f);
|
|
}
|
|
|
|
public enum CtorPoint4
|
|
{
|
|
};
|
|
|
|
public ImmutableRect_float(ReadOnlySpan<Point> points, CtorPoint4 _)
|
|
{
|
|
var minX = (points[0].X, points[1].X, points[2].X, points[3].X).Min();
|
|
var maxX = (points[0].X, points[1].X, points[2].X, points[3].X).Max();
|
|
var minY = (points[0].Y, points[1].Y, points[2].Y, points[3].Y).Min();
|
|
var maxY = (points[0].Y, points[1].Y, points[2].Y, points[3].Y).Max();
|
|
|
|
(X, Y, Width, Height) = (
|
|
(float)minX,
|
|
(float)minY,
|
|
(float)(maxX - minX),
|
|
(float)(maxY - minY)
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_float(ReadOnlySpan<ImmutableVec2_float> points, CtorPoint4 _)
|
|
{
|
|
var minX = (points[0].X, points[1].X, points[2].X, points[3].X).Min();
|
|
var maxX = (points[0].X, points[1].X, points[2].X, points[3].X).Max();
|
|
var minY = (points[0].Y, points[1].Y, points[2].Y, points[3].Y).Min();
|
|
var maxY = (points[0].Y, points[1].Y, points[2].Y, points[3].Y).Max();
|
|
|
|
(X, Y, Width, Height) = (
|
|
minX,
|
|
minY,
|
|
maxX - minX,
|
|
maxY - minY
|
|
);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public bool IntersectsWith(in ImmutableRect_float target)
|
|
{
|
|
var right = X + Width;
|
|
var bottom = Y + Height;
|
|
var targetRight = target.X + target.Width;
|
|
var targetBottom = target.Y + target.Height;
|
|
|
|
return target.X <= right && targetRight >= X && target.Y <= bottom && targetBottom >= Y;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public bool IntersectsWith(in ImmutableVec2_float target)
|
|
{
|
|
var right = X + Width;
|
|
var bottom = Y + Height;
|
|
|
|
return target.X >= X &&
|
|
target.X < right &&
|
|
target.Y >= bottom &&
|
|
target.Y < bottom;
|
|
}
|
|
|
|
public bool IntersectsWith(in ImmutableCircle_float target)
|
|
{
|
|
var right = X + Width;
|
|
var bottom = Y + Height;
|
|
|
|
if (target.CenterX > X &&
|
|
target.CenterX < right &&
|
|
target.CenterY > Y - target.Radius &&
|
|
target.CenterY < bottom + target.Radius)
|
|
return true;
|
|
|
|
if (target.CenterX > X - target.Radius &&
|
|
target.CenterX < right + target.Radius &&
|
|
target.CenterY > Y &&
|
|
target.CenterY < bottom)
|
|
return true;
|
|
|
|
var rr = target.Radius * target.Radius;
|
|
|
|
var xx1 = (X - target.CenterX) * (X - target.CenterX);
|
|
var yy1 = (Y - target.CenterY) * (Y - target.CenterY);
|
|
|
|
var xx2 = (right - target.CenterX) * (right - target.CenterX);
|
|
var yy2 = (bottom - target.CenterY) * (bottom - target.CenterY);
|
|
|
|
if (xx1 + yy1 < rr)
|
|
return true;
|
|
|
|
if (xx2 + yy1 < rr)
|
|
return true;
|
|
|
|
if (xx1 + yy2 < rr)
|
|
return true;
|
|
|
|
if (xx2 + yy2 < rr)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public bool Contains(Point p)
|
|
=> p.X >= X &&
|
|
p.X < X + Width &&
|
|
p.Y >= Y &&
|
|
p.Y < Y + Height;
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public bool Contains(in ImmutableVec2_float p)
|
|
=> p.X >= X &&
|
|
p.X < X + Width &&
|
|
p.Y >= Y &&
|
|
p.Y < Y + Height;
|
|
|
|
public static bool operator ==(in ImmutableRect_float source1, in ImmutableRect_float source2)
|
|
=> source1.X == source2.X &&
|
|
source1.Y == source2.Y &&
|
|
source1.Width == source2.Width &&
|
|
source1.Height == source2.Height;
|
|
|
|
public static bool operator !=(in ImmutableRect_float source1, in ImmutableRect_float source2)
|
|
=> !(source1 == source2);
|
|
|
|
public bool Equals(ImmutableRect_float other)
|
|
=> this == other;
|
|
|
|
public override bool Equals(object? obj)
|
|
{
|
|
if (obj is ImmutableRect_float other)
|
|
return this == other;
|
|
|
|
return false;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override int GetHashCode()
|
|
=> HashCodeMaker.To32(HashCodeMaker.Make(X, Y, Width, Height));
|
|
}
|
|
public readonly struct ImmutableRect_double : IEquatable<ImmutableRect_double>
|
|
{
|
|
public readonly double X;
|
|
public readonly double Y;
|
|
public readonly double Width;
|
|
public readonly double Height;
|
|
|
|
public bool HasArea => Width > 0d && Height > 0d;
|
|
|
|
public double Left => X;
|
|
public double Top => Y;
|
|
public double Right => X + Width;
|
|
public double Bottom => Y + Height;
|
|
|
|
public ImmutableVec2_double TopLeft => new ImmutableVec2_double(Left, Top);
|
|
public ImmutableVec2_double TopRight => new ImmutableVec2_double(Right, Top);
|
|
public ImmutableVec2_double BottomLeft => new ImmutableVec2_double(Left, Bottom);
|
|
public ImmutableVec2_double BottomRight => new ImmutableVec2_double(Right, Bottom);
|
|
|
|
public ImmutableRect_double(double x, double y, double width, double height)
|
|
=> (X, Y, Width, Height) = (x, y, width, height);
|
|
|
|
public ImmutableRect_double(Point pos, Size size)
|
|
=> (X, Y, Width, Height) = ((double)pos.X, (double)pos.Y, (double)size.Width, (double)size.Height);
|
|
|
|
public ImmutableRect_double(Point pos0, Point pos1)
|
|
{
|
|
var (minX, maxX) = (pos0.X, pos1.X).MinMax();
|
|
var (minY, maxY) = (pos0.Y, pos1.Y).MinMax();
|
|
|
|
(X, Y, Width, Height) = (
|
|
(double)minX,
|
|
(double)minY,
|
|
(double)(maxX - minX),
|
|
(double)(maxY - minY)
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_double(in ImmutableVec2_double pos0, in ImmutableVec2_double pos1)
|
|
{
|
|
var (minX, maxX) = (pos0.X, pos1.X).MinMax();
|
|
var (minY, maxY) = (pos0.Y, pos1.Y).MinMax();
|
|
|
|
(X, Y, Width, Height) = (
|
|
(double)minX,
|
|
(double)minY,
|
|
(double)(maxX - minX),
|
|
(double)(maxY - minY)
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_double(Span<Point> points)
|
|
{
|
|
if (points.Length == 0)
|
|
{
|
|
(X, Y, Width, Height) = (0d, 0d, 0d, 0d);
|
|
return;
|
|
}
|
|
|
|
var minX = points[0].X;
|
|
var minY = points[0].Y;
|
|
var maxX = points[0].X;
|
|
var maxY = points[0].Y;
|
|
|
|
for (var i = 1; i < points.Length; ++i)
|
|
{
|
|
minX = (minX, points[i].X).Min();
|
|
maxX = (maxX, points[i].X).Max();
|
|
|
|
minY = (minY, points[i].Y).Min();
|
|
maxY = (maxY, points[i].Y).Max();
|
|
}
|
|
|
|
(X, Y, Width, Height) = (
|
|
(double)minX,
|
|
(double)minY,
|
|
(double)(maxX - minX),
|
|
(double)(maxY - minY)
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_double(ReadOnlySpan<Point> points)
|
|
{
|
|
if (points.Length == 0)
|
|
{
|
|
(X, Y, Width, Height) = (0d, 0d, 0d, 0d);
|
|
return;
|
|
}
|
|
|
|
var minX = points[0].X;
|
|
var minY = points[0].Y;
|
|
var maxX = points[0].X;
|
|
var maxY = points[0].Y;
|
|
|
|
for (var i = 1; i < points.Length; ++i)
|
|
{
|
|
minX = (minX, points[i].X).Min();
|
|
maxX = (maxX, points[i].X).Max();
|
|
|
|
minY = (minY, points[i].Y).Min();
|
|
maxY = (maxY, points[i].Y).Max();
|
|
}
|
|
|
|
(X, Y, Width, Height) = (
|
|
(double)minX,
|
|
(double)minY,
|
|
(double)(maxX - minX),
|
|
(double)(maxY - minY)
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_double(IEnumerable<Point> points)
|
|
{
|
|
var minX = double.MaxValue;
|
|
var minY = double.MaxValue;
|
|
var maxX = double.MinValue;
|
|
var maxY = double.MinValue;
|
|
|
|
var isAny = false;
|
|
|
|
foreach (var point in points)
|
|
{
|
|
isAny = true;
|
|
|
|
minX = (minX, point.X).Min();
|
|
maxX = (maxX, point.X).Max();
|
|
|
|
minY = (minY, point.Y).Min();
|
|
maxY = (maxY, point.Y).Max();
|
|
}
|
|
|
|
if (isAny)
|
|
(X, Y, Width, Height) = (
|
|
(double)minX,
|
|
(double)minY,
|
|
(double)(maxX - minX),
|
|
(double)(maxY - minY)
|
|
);
|
|
else
|
|
(X, Y, Width, Height) = (0d, 0d, 0d, 0d);
|
|
}
|
|
|
|
public ImmutableRect_double(Span<ImmutableVec2_double> points)
|
|
{
|
|
if (points.Length == 0)
|
|
{
|
|
(X, Y, Width, Height) = (0d, 0d, 0d, 0d);
|
|
return;
|
|
}
|
|
|
|
var minX = points[0].X;
|
|
var minY = points[0].Y;
|
|
var maxX = points[0].X;
|
|
var maxY = points[0].Y;
|
|
|
|
for (var i = 1; i < points.Length; ++i)
|
|
{
|
|
minX = (minX, points[i].X).Min();
|
|
maxX = (maxX, points[i].X).Max();
|
|
|
|
minY = (minY, points[i].Y).Min();
|
|
maxY = (maxY, points[i].Y).Max();
|
|
}
|
|
|
|
(X, Y, Width, Height) = (
|
|
minX,
|
|
minY,
|
|
maxX - minX,
|
|
maxY - minY
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_double(ReadOnlySpan<ImmutableVec2_double> points)
|
|
{
|
|
if (points.Length == 0)
|
|
{
|
|
(X, Y, Width, Height) = (0d, 0d, 0d, 0d);
|
|
return;
|
|
}
|
|
|
|
var minX = points[0].X;
|
|
var minY = points[0].Y;
|
|
var maxX = points[0].X;
|
|
var maxY = points[0].Y;
|
|
|
|
for (var i = 1; i < points.Length; ++i)
|
|
{
|
|
minX = (minX, points[i].X).Min();
|
|
maxX = (maxX, points[i].X).Max();
|
|
|
|
minY = (minY, points[i].Y).Min();
|
|
maxY = (maxY, points[i].Y).Max();
|
|
}
|
|
|
|
(X, Y, Width, Height) = (
|
|
minX,
|
|
minY,
|
|
maxX - minX,
|
|
maxY - minY
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_double(IEnumerable<ImmutableVec2_double> points)
|
|
{
|
|
var minX = double.MaxValue;
|
|
var minY = double.MaxValue;
|
|
var maxX = double.MinValue;
|
|
var maxY = double.MinValue;
|
|
|
|
var isAny = false;
|
|
|
|
foreach (var point in points)
|
|
{
|
|
isAny = true;
|
|
|
|
minX = (minX, point.X).Min();
|
|
maxX = (maxX, point.X).Max();
|
|
|
|
minY = (minY, point.Y).Min();
|
|
maxY = (maxY, point.Y).Max();
|
|
}
|
|
|
|
if (isAny)
|
|
(X, Y, Width, Height) = (
|
|
minX,
|
|
minY,
|
|
maxX - minX,
|
|
maxY - minY
|
|
);
|
|
else
|
|
(X, Y, Width, Height) = (0d, 0d, 0d, 0d);
|
|
}
|
|
|
|
public enum CtorPoint4
|
|
{
|
|
};
|
|
|
|
public ImmutableRect_double(ReadOnlySpan<Point> points, CtorPoint4 _)
|
|
{
|
|
var minX = (points[0].X, points[1].X, points[2].X, points[3].X).Min();
|
|
var maxX = (points[0].X, points[1].X, points[2].X, points[3].X).Max();
|
|
var minY = (points[0].Y, points[1].Y, points[2].Y, points[3].Y).Min();
|
|
var maxY = (points[0].Y, points[1].Y, points[2].Y, points[3].Y).Max();
|
|
|
|
(X, Y, Width, Height) = (
|
|
(double)minX,
|
|
(double)minY,
|
|
(double)(maxX - minX),
|
|
(double)(maxY - minY)
|
|
);
|
|
}
|
|
|
|
public ImmutableRect_double(ReadOnlySpan<ImmutableVec2_double> points, CtorPoint4 _)
|
|
{
|
|
var minX = (points[0].X, points[1].X, points[2].X, points[3].X).Min();
|
|
var maxX = (points[0].X, points[1].X, points[2].X, points[3].X).Max();
|
|
var minY = (points[0].Y, points[1].Y, points[2].Y, points[3].Y).Min();
|
|
var maxY = (points[0].Y, points[1].Y, points[2].Y, points[3].Y).Max();
|
|
|
|
(X, Y, Width, Height) = (
|
|
minX,
|
|
minY,
|
|
maxX - minX,
|
|
maxY - minY
|
|
);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public bool IntersectsWith(in ImmutableRect_double target)
|
|
{
|
|
var right = X + Width;
|
|
var bottom = Y + Height;
|
|
var targetRight = target.X + target.Width;
|
|
var targetBottom = target.Y + target.Height;
|
|
|
|
return target.X <= right && targetRight >= X && target.Y <= bottom && targetBottom >= Y;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public bool IntersectsWith(in ImmutableVec2_double target)
|
|
{
|
|
var right = X + Width;
|
|
var bottom = Y + Height;
|
|
|
|
return target.X >= X &&
|
|
target.X < right &&
|
|
target.Y >= bottom &&
|
|
target.Y < bottom;
|
|
}
|
|
|
|
public bool IntersectsWith(in ImmutableCircle_double target)
|
|
{
|
|
var right = X + Width;
|
|
var bottom = Y + Height;
|
|
|
|
if (target.CenterX > X &&
|
|
target.CenterX < right &&
|
|
target.CenterY > Y - target.Radius &&
|
|
target.CenterY < bottom + target.Radius)
|
|
return true;
|
|
|
|
if (target.CenterX > X - target.Radius &&
|
|
target.CenterX < right + target.Radius &&
|
|
target.CenterY > Y &&
|
|
target.CenterY < bottom)
|
|
return true;
|
|
|
|
var rr = target.Radius * target.Radius;
|
|
|
|
var xx1 = (X - target.CenterX) * (X - target.CenterX);
|
|
var yy1 = (Y - target.CenterY) * (Y - target.CenterY);
|
|
|
|
var xx2 = (right - target.CenterX) * (right - target.CenterX);
|
|
var yy2 = (bottom - target.CenterY) * (bottom - target.CenterY);
|
|
|
|
if (xx1 + yy1 < rr)
|
|
return true;
|
|
|
|
if (xx2 + yy1 < rr)
|
|
return true;
|
|
|
|
if (xx1 + yy2 < rr)
|
|
return true;
|
|
|
|
if (xx2 + yy2 < rr)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public bool Contains(Point p)
|
|
=> p.X >= X &&
|
|
p.X < X + Width &&
|
|
p.Y >= Y &&
|
|
p.Y < Y + Height;
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public bool Contains(in ImmutableVec2_double p)
|
|
=> p.X >= X &&
|
|
p.X < X + Width &&
|
|
p.Y >= Y &&
|
|
p.Y < Y + Height;
|
|
|
|
public static bool operator ==(in ImmutableRect_double source1, in ImmutableRect_double source2)
|
|
=> source1.X == source2.X &&
|
|
source1.Y == source2.Y &&
|
|
source1.Width == source2.Width &&
|
|
source1.Height == source2.Height;
|
|
|
|
public static bool operator !=(in ImmutableRect_double source1, in ImmutableRect_double source2)
|
|
=> !(source1 == source2);
|
|
|
|
public bool Equals(ImmutableRect_double other)
|
|
=> this == other;
|
|
|
|
public override bool Equals(object? obj)
|
|
{
|
|
if (obj is ImmutableRect_double other)
|
|
return this == other;
|
|
|
|
return false;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public override int GetHashCode()
|
|
=> HashCodeMaker.To32(HashCodeMaker.Make(X, Y, Width, Height));
|
|
}
|
|
|
|
}
|
|
|