public AxisAlignedBox3f(Vector3F vCenter)
{
Min = Max = vCenter;
}
public Frame3f Translated(Vector3F v)
{
return(new Frame3f(this.origin + v, this.rotation));
}
public AxisAlignedBox3f(float fWidth, float fHeight, float fDepth)
{
Min = new Vector3F(0, 0, 0);
Max = new Vector3F(fWidth, fHeight, fDepth);
}
public AxisAlignedBox3f(Vector3F vCenter, float fHalfWidth, float fHalfHeight, float fHalfDepth)
{
Min = new Vector3F(vCenter.x - fHalfWidth, vCenter.y - fHalfHeight, vCenter.z - fHalfDepth);
Max = new Vector3F(vCenter.x + fHalfWidth, vCenter.y + fHalfHeight, vCenter.z + fHalfDepth);
}
public float Distance(Vector3F v)
{
return((float)Math.Sqrt(DistanceSquared(v)));
}
//! relative translation
public void Translate(Vector3F vTranslate)
{
Min.Add(vTranslate);
Max.Add(vTranslate);
}
public float DistanceToPlaneSigned(Vector3F p, int nNormal)
{
return((p - origin).Dot(GetAxis(nNormal)));
}
public AxisAlignedBox3f(bool bIgnore)
{
Min = new Vector3F(float.MaxValue, float.MaxValue, float.MaxValue);
Max = new Vector3F(float.MinValue, float.MinValue, float.MinValue);
}
public Frame3f Scaled(Vector3F scale)
{
return(new Frame3f(scale * this.origin, this.rotation));
}
public float DistanceToPlane(Vector3F p, int nNormal)
{
return(Math.Abs((p - origin).Dot(GetAxis(nNormal))));
}
public void Scale(Vector3F scale)
{
origin *= scale;
}
public void Scale(float f)
{
origin *= f;
}
public Frame3f(Frame3f copy)
{
this.rotation = copy.rotation;
this.origin = copy.origin;
}
public static Frame3f Interpolate(Frame3f f1, Frame3f f2, float alpha)
{
return(new Frame3f(
Vector3F.Lerp(f1.origin, f2.origin, alpha),
Quaternionf.Slerp(f1.rotation, f2.rotation, alpha)));
}
public Frame3f(Vector3D origin)
{
rotation = Quaternionf.Identity;
this.origin = (Vector3F)origin;
}
public Frame3f(Vector3F origin, Quaternionf orientation)
{
rotation = orientation;
this.origin = origin;
}
///<summary> Map point *into* local coordinates of Frame </summary>
public Vector3F ToFrameP(Vector3F v)
{
v = v - this.origin;
v = Quaternionf.Inverse(this.rotation) * v;
return(v);
}
public bool Contains(Vector3F v)
{
return((Min.x <= v.x) && (Min.y <= v.y) && (Min.z <= v.z) &&
(Max.x >= v.x) && (Max.y >= v.y) && (Max.z >= v.z));
}
/// <summary> Map point *from* local frame coordinates into "world" coordinates </summary>
public Vector3F FromFrameP(Vector3F v)
{
return(this.rotation * v + this.origin);
}
public AxisAlignedBox3f(float xmin, float ymin, float zmin, float xmax, float ymax, float zmax)
{
Min = new Vector3F(xmin, ymin, zmin);
Max = new Vector3F(xmax, ymax, zmax);
}
///<summary> Map vector *into* local coordinates of Frame </summary>
public Vector3F ToFrameV(Vector3F v)
{
return(Quaternionf.Inverse(this.rotation) * v);
}
public AxisAlignedBox3f(float fCubeSize)
{
Min = new Vector3F(0, 0, 0);
Max = new Vector3F(fCubeSize, fCubeSize, fCubeSize);
}
/// <summary> Map vector *from* local frame coordinates into "world" coordinates </summary>
public Vector3F FromFrameV(Vector3F v)
{
return(this.rotation * v);
}
public AxisAlignedBox3f(Vector3F vMin, Vector3F vMax)
{
Min = new Vector3F(Math.Min(vMin.x, vMax.x), Math.Min(vMin.y, vMax.y), Math.Min(vMin.z, vMax.z));
Max = new Vector3F(Math.Max(vMin.x, vMax.x), Math.Max(vMin.y, vMax.y), Math.Max(vMin.z, vMax.z));
}
public Frame3f(Vector3F origin, Vector3F setZ)
{
rotation = Quaternionf.FromTo(Vector3F.AxisZ, setZ);
this.origin = origin;
}
public AxisAlignedBox3f(Vector3F vCenter, float fHalfSize)
{
Min = new Vector3F(vCenter.x - fHalfSize, vCenter.y - fHalfSize, vCenter.z - fHalfSize);
Max = new Vector3F(vCenter.x + fHalfSize, vCenter.y + fHalfSize, vCenter.z + fHalfSize);
}
public Frame3f(Vector3D origin, Vector3D setZ)
{
rotation = Quaternionf.FromTo(Vector3F.AxisZ, (Vector3F)setZ);
this.origin = (Vector3F)origin;
}
public Vector3D(Vector3F copy)
{
x = copy.x; y = copy.y; z = copy.z;
}
public void Translate(Vector3F v)
{
origin += v;
}
