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; }