public void Add(ref BoundsF v)
{
if (v.Minimum.X < Minimum.X)
{
Minimum.X = v.Minimum.X;
}
if (v.Minimum.Y < Minimum.Y)
{
Minimum.Y = v.Minimum.Y;
}
if (v.Minimum.Z < Minimum.Z)
{
Minimum.Z = v.Minimum.Z;
}
if (v.Maximum.X > Maximum.X)
{
Maximum.X = v.Maximum.X;
}
if (v.Maximum.Y > Maximum.Y)
{
Maximum.Y = v.Maximum.Y;
}
if (v.Maximum.Z > Maximum.Z)
{
Maximum.Z = v.Maximum.Z;
}
}
public static BoundsF Subtract(ref Vector3F v, ref BoundsF b)
{
BoundsF result;
Vector3F.Subtract(ref v, ref b.Minimum, out result.Minimum);
Vector3F.Subtract(ref v, ref b.Maximum, out result.Maximum);
return(result);
}
public static BoundsF Add(ref BoundsF b, ref Vector3F v)
{
BoundsF result;
Vector3F.Add(ref b.Minimum, ref v, out result.Minimum);
Vector3F.Add(ref b.Maximum, ref v, out result.Maximum);
return(result);
}
public BoundsF ToBounds()
{
BoundsF result = new BoundsF(Point1);
result.Add(Point2);
result.Expand(Radius);
return(result);
}
public void ToBounds(out BoundsF result)
{
result.Minimum.X = Origin.X - Radius;
result.Minimum.Y = Origin.Y - Radius;
result.Minimum.Z = Origin.Z - Radius;
result.Maximum.X = Origin.X + Radius;
result.Maximum.Y = Origin.Y + Radius;
result.Maximum.Z = Origin.Z + Radius;
}
public bool Intersects(ref BoundsF v)
{
if (v.Maximum.X < Minimum.X || v.Maximum.Y < Minimum.Y || v.Maximum.Z < Minimum.Z ||
v.Minimum.X > Maximum.X || v.Minimum.Y > Maximum.Y || v.Minimum.Z > Maximum.Z)
{
return(false);
}
return(true);
}
public bool Contains(BoundsF v)
{
if (v.Minimum.X < Minimum.X || v.Minimum.Y < Minimum.Y || v.Minimum.Z < Minimum.Z ||
v.Maximum.X > Maximum.X || v.Maximum.Y > Maximum.Y || v.Maximum.Z > Maximum.Z)
{
return(false);
}
return(true);
}
public void Intersection(ref BoundsF v, out BoundsF result)
{
result.Minimum.X = (v.Minimum.X > Minimum.X) ? v.Minimum.X : Minimum.X;
result.Minimum.Y = (v.Minimum.Y > Minimum.Y) ? v.Minimum.Y : Minimum.Y;
result.Minimum.Z = (v.Minimum.Z > Minimum.Z) ? v.Minimum.Z : Minimum.Z;
result.Maximum.X = (v.Maximum.X < Maximum.X) ? v.Maximum.X : Maximum.X;
result.Maximum.Y = (v.Maximum.Y < Maximum.Y) ? v.Maximum.Y : Maximum.Y;
result.Maximum.Z = (v.Maximum.Z < Maximum.Z) ? v.Maximum.Z : Maximum.Z;
}
public void Write(BoundsF source)
{
Write(source.Minimum.X);
Write(source.Minimum.Y);
Write(source.Minimum.Z);
Write(source.Maximum.X);
Write(source.Maximum.Y);
Write(source.Maximum.Z);
}
public BoundsF Intersection(BoundsF v)
{
BoundsF result;
result.Minimum.X = (v.Minimum.X > Minimum.X) ? v.Minimum.X : Minimum.X;
result.Minimum.Y = (v.Minimum.Y > Minimum.Y) ? v.Minimum.Y : Minimum.Y;
result.Minimum.Z = (v.Minimum.Z > Minimum.Z) ? v.Minimum.Z : Minimum.Z;
result.Maximum.X = (v.Maximum.X < Maximum.X) ? v.Maximum.X : Maximum.X;
result.Maximum.Y = (v.Maximum.Y < Maximum.Y) ? v.Maximum.Y : Maximum.Y;
result.Maximum.Z = (v.Maximum.Z < Maximum.Z) ? v.Maximum.Z : Maximum.Z;
return(result);
}
public bool Equals(BoundsF v, float epsilon)
{
if (!Minimum.Equals(ref v.Minimum, epsilon))
{
return(false);
}
if (!Maximum.Equals(ref v.Maximum, epsilon))
{
return(false);
}
return(true);
}
/// <summary>
/// Returns side of the plane that the given box lies on.
/// The box is defined as bounds.
/// </summary>
/// <param name="bounds">The given bounds.</param>
/// <returns>The resulting side.</returns>
public Side GetSide(ref BoundsF bounds)
{
Vector3F boundsCenter;
bounds.GetCenter(out boundsCenter);
//Vec3 boundsHalfSize = boundsCenter - bounds.Minimum;
Vector3F boundsHalfSize;
Vector3F.Subtract(ref boundsCenter, ref bounds.Minimum, out boundsHalfSize);
return(GetSide(ref boundsCenter, ref boundsHalfSize));
}
public void ToBounds(out BoundsF result)
{
Vector3F a = Point2 - Point1;
var dotA = Vector3F.Dot(a, a);
if (dotA == 0)
{
dotA = MathEx.Epsilon;
}
Vector3F e = new Vector3F(
Radius * MathEx.Sqrt(1.0f - a.X * a.X / dotA),
Radius * MathEx.Sqrt(1.0f - a.Y * a.Y / dotA),
Radius * MathEx.Sqrt(1.0f - a.Z * a.Z / dotA));
result = new BoundsF(Vector3F.Min(Point1 - e, Point2 - e), Vector3F.Max(Point1 + e, Point2 + e));
}
public bool Intersects(ref BoundsF bounds)
{
float distanceSqr = 0;
if (Origin.X < bounds.Minimum.X)
{
float s = Origin.X - bounds.Minimum.X;
distanceSqr += s * s;
}
else if (Origin.X > bounds.Maximum.X)
{
float s = Origin.X - bounds.Maximum.X;
distanceSqr += s * s;
}
if (Origin.Y < bounds.Minimum.Y)
{
float s = Origin.Y - bounds.Minimum.Y;
distanceSqr += s * s;
}
else if (Origin.Y > bounds.Maximum.Y)
{
float s = Origin.Y - bounds.Maximum.Y;
distanceSqr += s * s;
}
if (Origin.Z < bounds.Minimum.Z)
{
float s = Origin.Z - bounds.Minimum.Z;
distanceSqr += s * s;
}
else if (Origin.Z > bounds.Maximum.Z)
{
float s = Origin.Z - bounds.Maximum.Z;
distanceSqr += s * s;
}
return(distanceSqr <= Radius * Radius);
}
public bool Contains(Vector3F point)
{
if (Point1 != Point2)
{
float radiusSquared = Radius * Radius;
if ((Point1 - point).LengthSquared() <= radiusSquared)
{
return(true);
}
if ((Point2 - point).LengthSquared() <= radiusSquared)
{
return(true);
}
Vector3F projectPoint;
MathAlgorithms.ProjectPointToLine(ref Point1, ref Point2, ref point, out projectPoint);
BoundsF pointsBounds = new BoundsF(Point1);
pointsBounds.Add(Point2);
if (pointsBounds.Contains(projectPoint))
{
if ((projectPoint - point).LengthSquared() <= radiusSquared)
{
return(true);
}
}
return(false);
}
else
{
return(new SphereF(Point1, Radius).Contains(point));
}
}
//
static SimpleTypes()
{
//string
RegisterType(typeof(string), delegate(string value)
{
if (value == null)
{
return("");
//throw new Exception( "GetSimpleTypeValue: string type, value = null" );
}
return(value);
}, "");
//bool
RegisterType(typeof(bool), delegate(string value)
{
string lower = value.ToLower();
if (value == "1" || lower == "yes" || lower == "true")
{
return(true);
}
else if (value == "0" || lower == "no" || lower == "false")
{
return(false);
}
else
{
return(bool.Parse(value));
}
}, false);
//sbyte
RegisterType(typeof(sbyte), delegate(string value) { return(sbyte.Parse(value)); }, 0);
//byte
RegisterType(typeof(byte), delegate(string value) { return(byte.Parse(value)); }, 0);
//char
RegisterType(typeof(char), delegate(string value) { return(char.Parse(value)); }, 0);
//short
RegisterType(typeof(short), delegate(string value) { return(short.Parse(value)); }, 0);
//ushort
RegisterType(typeof(ushort), delegate(string value) { return(ushort.Parse(value)); }, 0);
//int
RegisterType(typeof(int), delegate(string value) { return(int.Parse(value)); }, 0);
//uint
RegisterType(typeof(uint), delegate(string value) { return(uint.Parse(value)); }, (uint)0);
//long
RegisterType(typeof(long), delegate(string value) { return(long.Parse(value)); }, (long)0);
//ulong
RegisterType(typeof(ulong), delegate(string value) { return(ulong.Parse(value)); }, (ulong)0);
//float
RegisterType(typeof(float), delegate(string value) { return(float.Parse(value)); }, 0.0f);
//double
RegisterType(typeof(double), delegate(string value) { return(double.Parse(value)); }, 0.0);
//decimal
RegisterType(typeof(decimal), delegate(string value) { return(decimal.Parse(value)); }, (decimal)0.0);
//Vec2
RegisterType(typeof(Vector2F), delegate(string value) { return(Vector2F.Parse(value)); }, Vector2F.Zero);
//Range
RegisterType(typeof(RangeF), delegate(string value) { return(RangeF.Parse(value)); }, RangeF.Zero);
//Vec3
RegisterType(typeof(Vector3F), delegate(string value) { return(Vector3F.Parse(value)); }, Vector3F.Zero);
//Vec4
RegisterType(typeof(Vector4F), delegate(string value) { return(Vector4F.Parse(value)); }, Vector4F.Zero);
//Bounds
RegisterType(typeof(BoundsF), delegate(string value) { return(BoundsF.Parse(value)); }, BoundsF.Zero);
//Quat
RegisterType(typeof(QuaternionF), delegate(string value) { return(QuaternionF.Parse(value)); }, QuaternionF.Identity);
//ColorValue
RegisterType(typeof(ColorValue), delegate(string value) { return(ColorValue.Parse(value)); }, ColorValue.Zero);
//ColorValuePowered
RegisterType(typeof(ColorValuePowered), delegate(string value) { return(ColorValuePowered.Parse(value)); }, ColorValuePowered.Zero);
//ColorPacked
RegisterType(typeof(ColorByte), delegate(string value) { return(ColorByte.Parse(value)); }, ColorByte.Zero);
//SphereDir
RegisterType(typeof(SphericalDirectionF), delegate(string value) { return(SphericalDirectionF.Parse(value)); }, SphericalDirectionF.Zero);
//Vec2I
RegisterType(typeof(Vector2I), delegate(string value) { return(Vector2I.Parse(value)); }, Vector2I.Zero);
//Vec3I
RegisterType(typeof(Vector3I), delegate(string value) { return(Vector3I.Parse(value)); }, Vector3I.Zero);
//Vec4I
RegisterType(typeof(Vector4I), delegate(string value) { return(Vector4I.Parse(value)); }, Vector4I.Zero);
//Rect
RegisterType(typeof(RectangleF), delegate(string value) { return(RectangleF.Parse(value)); }, RectangleF.Zero);
//RectI
RegisterType(typeof(RectangleI), delegate(string value) { return(RectangleI.Parse(value)); }, RectangleI.Zero);
//Degree
RegisterType(typeof(DegreeF), delegate(string value) { return(DegreeF.Parse(value)); }, DegreeF.Zero);
//Radian
RegisterType(typeof(RadianF), delegate(string value) { return(RadianF.Parse(value)); }, RadianF.Zero);
//Vec2D
RegisterType(typeof(Vector2), delegate(string value) { return(Vector2.Parse(value)); }, Vector2.Zero);
//RangeD
RegisterType(typeof(Range), delegate(string value) { return(Range.Parse(value)); }, Range.Zero);
//RangeI
RegisterType(typeof(RangeI), delegate(string value) { return(RangeI.Parse(value)); }, RangeI.Zero);
//Vec3D
RegisterType(typeof(Vector3), delegate(string value) { return(Vector3.Parse(value)); }, Vector3.Zero);
//Vec4D
RegisterType(typeof(Vector4), delegate(string value) { return(Vector4.Parse(value)); }, Vector4.Zero);
//BoundsD
RegisterType(typeof(Bounds), delegate(string value) { return(Bounds.Parse(value)); }, Bounds.Zero);
//QuatD
RegisterType(typeof(Quaternion), delegate(string value) { return(Quaternion.Parse(value)); }, Quaternion.Identity);
//SphereDirD
RegisterType(typeof(SphericalDirection), delegate(string value) { return(SphericalDirection.Parse(value)); }, SphericalDirection.Zero);
//RectD
RegisterType(typeof(Rectangle), delegate(string value) { return(Rectangle.Parse(value)); }, Rectangle.Zero);
//DegreeD
RegisterType(typeof(Degree), delegate(string value) { return(Degree.Parse(value)); }, Degree.Zero);
//RadianD
RegisterType(typeof(Radian), delegate(string value) { return(Radian.Parse(value)); }, Radian.Zero);
//Angles
RegisterType(typeof(AnglesF), delegate(string value) { return(AnglesF.Parse(value)); }, AnglesF.Zero);
//AnglesD
RegisterType(typeof(Angles), delegate(string value) { return(Angles.Parse(value)); }, Angles.Zero);
//Mat2F
RegisterType(typeof(Matrix2F), delegate(string value) { return(Matrix2F.Parse(value)); }, Matrix2F.Zero);
//Mat2D
RegisterType(typeof(Matrix2), delegate(string value) { return(Matrix2.Parse(value)); }, Matrix2.Zero);
//Mat3F
RegisterType(typeof(Matrix3F), delegate(string value) { return(Matrix3F.Parse(value)); }, Matrix3F.Zero);
//Mat3D
RegisterType(typeof(Matrix3), delegate(string value) { return(Matrix3.Parse(value)); }, Matrix3.Zero);
//Mat4F
RegisterType(typeof(Matrix4F), delegate(string value) { return(Matrix4F.Parse(value)); }, Matrix4F.Zero);
//Mat4D
RegisterType(typeof(Matrix4), delegate(string value) { return(Matrix4.Parse(value)); }, Matrix4.Zero);
//PlaneF
RegisterType(typeof(PlaneF), delegate(string value) { return(PlaneF.Parse(value)); }, PlaneF.Zero);
//PlaneD
RegisterType(typeof(Plane), delegate(string value) { return(Plane.Parse(value)); }, Plane.Zero);
//Transform
RegisterType(typeof(Transform), delegate(string value) { return(Transform.Parse(value)); }, Transform.Identity);
//UIMeasureValueDouble
RegisterType(typeof(UIMeasureValueDouble), delegate(string value) { return(UIMeasureValueDouble.Parse(value)); }, new UIMeasureValueDouble());
//UIMeasureValueVec2
RegisterType(typeof(UIMeasureValueVector2), delegate(string value) { return(UIMeasureValueVector2.Parse(value)); }, new UIMeasureValueVector2());
//UIMeasureValueRect
RegisterType(typeof(UIMeasureValueRectangle), delegate(string value) { return(UIMeasureValueRectangle.Parse(value)); }, new UIMeasureValueRectangle());
RegisterType(typeof(RangeVector3F), delegate(string value) { return(RangeVector3F.Parse(value)); }, RangeVector3F.Zero);
RegisterType(typeof(RangeColorValue), delegate(string value) { return(RangeColorValue.Parse(value)); }, RangeColorValue.Zero);
//no Parse methods. This is complex structures. This is not simple types? or just can't parse?
//Box
//Capsule
//Cone
//Line3
//Line2
//Ray
//Frustum?
RegisterConvertDoubleToFloatTypes();
}
public void ToBounds(out BoundsF result)
{
result = new BoundsF(Point1);
result.Add(Point2);
result.Expand(Radius);
}
public static void Add(ref BoundsF b, ref Vector3F v, out BoundsF result)
{
Vector3F.Add(ref b.Minimum, ref v, out result.Minimum);
Vector3F.Add(ref b.Maximum, ref v, out result.Maximum);
}
public static void Subtract(ref Vector3F v, ref BoundsF b, out BoundsF result)
{
Vector3F.Subtract(ref v, ref b.Minimum, out result.Minimum);
Vector3F.Subtract(ref v, ref b.Maximum, out result.Maximum);
}
public bool Intersects(BoundsF bounds)
{
return(Intersects(ref bounds));
}
/// <summary>
/// Returns side of the plane that the given box lies on.
/// The box is defined as bounds.
/// </summary>
/// <param name="bounds">The given bounds.</param>
/// <returns>The resulting side.</returns>
public Side GetSide(BoundsF bounds)
{
return(GetSide(ref bounds));
}
public Bounds(BoundsF source)
{
Minimum = source.Minimum.ToVector3();
Maximum = source.Maximum.ToVector3();
}
public BoundsF(BoundsF source)
{
Minimum = source.Minimum;
Maximum = source.Maximum;
}
