public Box3D(float xMin, float yMin, float zMin, float xMax, float yMax, float zMax) { MinEdge = new Vector3D(); MaxEdge = new Vector3D(); MinEdge.Set(xMin, yMin, zMin); MaxEdge.Set(xMax, yMax, zMax); }
public Vertex3D(Vector3D position, Vector3D normal, Color color, Vector2D tcoord) : this() { Position = position; Normal = normal; Color = color; TCoords = tcoord; }
public Vector3D GetCollisionResultPoint(TriangleSelector selector, Vector3D ellipsoidPosition, Vector3D ellipsoidRadius, Vector3D ellipsoidDirectionAndSpeed, out Triangle3D outTriangle, out bool outFalling, float slidingSpeed, Vector3D gravityDirectionAndSpeed) { float[] outtri = new float[9]; float[] outpos = new float[3]; outFalling = false; SceneCollisionManager_GetCollisionResultPoint(_raw, selector.Raw, ellipsoidPosition.ToUnmanaged(), ellipsoidRadius.ToUnmanaged(), ellipsoidDirectionAndSpeed.ToUnmanaged(), outtri, ref outFalling, slidingSpeed, gravityDirectionAndSpeed.ToUnmanaged(), outpos); outTriangle = Triangle3D.FromUnmanaged(outtri); return Vector3D.FromUnmanaged(outpos); }
public bool GetCollisionPoint(Line3D ray, TriangleSelector selector, out Vector3D collisionPoint, out Triangle3D collisionTriangle) { float[] colp = new float[3]; float[] coltri = new float[9]; bool toR = SceneCollisionManager_GetCollisionPoint(_raw, ray.ToUnmanaged(), selector.Raw, colp, coltri); collisionPoint = Vector3D.FromUnmanaged(colp); collisionTriangle = Triangle3D.FromUnmanaged(coltri); return toR; }
public Vector3D GetClosestPoint(Vector3D point) { Vector3D c = point - Start; Vector3D v = End - Start; float d = v.Length; v = v / d; float t = v.DotProduct(c); if (t < 0.0f) return Start; if (t > d) return End; v = v * t; return Start + v; }
public TextSceneNode AddBillboardTextSceneNodeW(GUIFont font, string text, SceneNode parent, Dimension2Df size, Vector3D position, int id, Color shade_top, Color shade_down) { #if !LINUX return (TextSceneNode) NativeElement.GetObject(SceneManager_AddTextSceneNode2W(_raw, font.Raw, text, GetPtr(parent), size.ToUnmanaged(), position.ToUnmanaged(), id, shade_top.ToUnmanaged(), shade_down.ToUnmanaged()), typeof(TextSceneNode)); #else return (TextSceneNode) NativeElement.GetObject(SceneManager_AddTextSceneNode2(_raw, font.Raw, text, GetPtr(parent), size.ToUnmanaged(), position.ToUnmanaged(), id, shade_top.ToUnmanaged(), shade_down.ToUnmanaged()), typeof(TextSceneNode)); #endif }
public bool GetIntersectionWithSphere(Vector3D sorigin, float sradius, out double outdistance) { outdistance = 0.0; Vector3D q = sorigin - Start; double c = q.Length; Vector3D vv = Vector; vv.Normalize(); double v = q.DotProduct(vv); double d = sradius * sradius - (c * c - v * v); if (d < 0.0) return false; outdistance = v - Math.Sqrt(d); return true; }
public Position2D GetScreenCoordinatesFrom3DPosition(Vector3D position, CameraSceneNode camera) { int[] sc = new int[2]; SceneCollisionManager_GetScreenCoordinatesFrom3DPosition(_raw, position.ToUnmanaged(), GetPtr(camera), sc); return Position2D.FromUnmanaged(sc); }
public Vector3D TransformVect(ref Vector3D vect) { float[] vector = { 0, 0, 0 }; vector[0] = vect.X * M[0] + vect.Y * M[4] + vect.Z * M[8] + M[12]; vector[1] = vect.X * M[1] + vect.Y * M[5] + vect.Z * M[9] + M[13]; vector[2] = vect.X * M[2] + vect.Y * M[6] + vect.Z * M[10] + M[14]; vect.X = vector[0]; vect.Y = vector[1]; vect.Z = vector[2]; return vect; }
public double DistanceFrom(Vector3D what) { return Math.Sqrt(DistanceFromSQ(what)); }
public double DistanceFromSQ(Vector3D what) { return (NewMath.Sqr(X - what.X) + NewMath.Sqr(Y - what.Y) + +NewMath.Sqr(Z - what.Z)); }
public ParticleEmitter CreatePointEmitter(Vector3D direction, uint minPPS, uint maxPPS, Color minSC, Color maxSC, uint minLT, uint maxLT, int maxAngleDegrees) { return (ParticleEmitter) NativeElement.GetObject(Particle_CreatePointEmitter(_raw, direction.ToUnmanaged(), minPPS, maxPPS, minSC.ToUnmanaged(), maxSC.ToUnmanaged(), minLT, maxLT, maxAngleDegrees), typeof(ParticleEmitter)); }
/// <summary> /// Scales the whole mesh. /// </summary> /// <param name="mesh">Mesh on which the operation is performed. </param> /// <param name="scale">Scale factor. </param> public void ScaleMesh(Mesh mesh, Vector3D scale) { MeshManipulator_ScaleMesh(_raw, mesh.Raw, scale.ToUnmanaged()); }
/// <summary> Builds a right-handed look-at matrix.</summary> public void BuildCameraLookAtMatrixRH(Vector3D position, Vector3D target, Vector3D upVector) { Vector3D zaxis = position - target; zaxis.Normalize(); Vector3D xaxis = upVector.CrossProduct(zaxis); xaxis.Normalize(); Vector3D yaxis = zaxis.CrossProduct(xaxis); SetMInsecure(0, 0, xaxis.X); SetMInsecure(1, 0, yaxis.X); SetMInsecure(2, 0, zaxis.X); SetMInsecure(3, 0, 0); SetMInsecure(0, 1, xaxis.Y); SetMInsecure(1, 1, yaxis.Y); SetMInsecure(2, 1, zaxis.Y); SetMInsecure(3, 1, 0); SetMInsecure(0, 2, xaxis.Z); SetMInsecure(1, 2, yaxis.Z); SetMInsecure(2, 2, zaxis.Z); SetMInsecure(3, 2, 0); SetMInsecure(0, 3, -xaxis.DotProduct(position)); SetMInsecure(1, 3, -yaxis.DotProduct(position)); SetMInsecure(2, 3, -zaxis.DotProduct(position)); SetMInsecure(3, 3, 1.0f); }
public Vector3D CrossProduct(Vector3D p) { return new Vector3D(Y * p.Z - Z * p.Y, Z * p.X - X * p.Z, X * p.Y - Y * p.X); }
/// <summary> /// Adds a point to the bounding box, causing it to grow bigger, /// if point is outside of the box /// </summary> /// <param name="p"> Point to add into the box.</param> public void AddInternalPoint(Vector3D p) { AddInternalPoint(p.X, p.Y, p.Z); }
public Vector3D GetInterpolated_Quadratic(Vector3D v2, Vector3D v3, float d) { float inv = 1.0f - d; float mul0 = inv * inv; float mul1 = (float)2.0 * d * inv; float mul2 = d * d; return new Vector3D(X * mul0 + v2.X * mul1 + v3.X * mul2, Y * mul0 + v2.Y * mul1 + v3.Y * mul2, Z * mul0 + v2.Z * mul1 + v3.Z * mul2); }
public Box3D(Vector3D min, Vector3D max) { MinEdge = min; MaxEdge = max; }
/// <summary> /// Stores all 8 edges of the box into a array /// </summary> /// <param name="edges">Aray of 8 edges</param> public void GetEdges(out Vector3D[] edges) { edges = new Vector3D[8]; Vector3D middle = (MinEdge + MaxEdge) / 2; Vector3D diag = middle - MaxEdge; /* Edges are stored in this way: Hey, am I an ascii artist, or what? :) niko. /1--------/3 / | / | / | / | 5---------7 | | 0- - - | -2 | / | / |/ | / 4---------6/ */ edges[0].Set(middle.X + diag.X, middle.Y + diag.Y, middle.Z + diag.Z); edges[1].Set(middle.X + diag.X, middle.Y - diag.Y, middle.Z + diag.Z); edges[2].Set(middle.X + diag.X, middle.Y + diag.Y, middle.Z - diag.Z); edges[3].Set(middle.X + diag.X, middle.Y - diag.Y, middle.Z - diag.Z); edges[4].Set(middle.X - diag.X, middle.Y + diag.Y, middle.Z + diag.Z); edges[5].Set(middle.X - diag.X, middle.Y - diag.Y, middle.Z + diag.Z); edges[6].Set(middle.X - diag.X, middle.Y + diag.Y, middle.Z - diag.Z); edges[7].Set(middle.X - diag.X, middle.Y - diag.Y, middle.Z - diag.Z); }
/// <summary> /// Determinates if a point is within this box and its borders. /// </summary> /// <param name="p"> Point to check.</param> /// <returns> Returns true if the point is withing the box, and false if it is not.</returns> public bool IsPointTotalInside(Vector3D p) { return (p.X > MinEdge.X && p.X < MaxEdge.X && p.Y > MinEdge.Y && p.Y < MaxEdge.Y && p.Z > MinEdge.Z && p.Z < MaxEdge.Z); }
public void Draw3DLine(Vector3D start, Vector3D end, Color color) { VideoDriver_Draw3DLine(_raw, start.ToUnmanaged(), end.ToUnmanaged(), color.ToUnmanaged()); }
public bool IsBetweenPoints(Vector3D begin, Vector3D end) { float f = ((end - begin).LengthSQ); return DistanceFromSQ(begin) < f && DistanceFromSQ(end) < f; }
public Vertex3DTangents(Vector3D position, Vector3D normal, Color color, Vector2D tcoord, Vector3D binormal, Vector3D tangent) : this() { Position = position; Normal = normal; Color = color; TCoords = tcoord; Binormal = binormal; Tangent = tangent; }
//! axis must be unit length //! The Quaternion representing the rotation is //! q = cos(A/2)+sin(A/2)*(x*i+y*j+z*k) public void fromAngleAxis(float angle, Vector3D axis) { float fHalfAngle = 0.5f * angle; float fSin = (float)Math.Sin(fHalfAngle); m_w = (float)Math.Cos(fHalfAngle); m_x = fSin * axis.X; m_y = fSin * axis.Y; m_z = fSin * axis.Z; }
public Vector3D RotateVect(ref Vector3D vect) { Vector3D tmp = new Vector3D(vect.X, vect.Y, vect.Z); vect.X = tmp.X * M[0] + tmp.Y * M[4] + tmp.Z * M[8]; vect.Y = tmp.X * M[1] + tmp.Y * M[5] + tmp.Z * M[9]; vect.Z = tmp.X * M[2] + tmp.Y * M[6] + tmp.Z * M[10]; return vect; }
public float DotProduct(Vector3D other) { return X * other.X + Y * other.Y + Z * other.Z; }
//! multiplication operator by a vector public static Vector3D operator *(Vector3D lhs, Quaternion rhs) { Vector3D qvec = new Vector3D(rhs.X, rhs.Y, rhs.Z); Vector3D uv = qvec.CrossProduct(lhs); Vector3D uuv = qvec.CrossProduct(uv); uv *= (2.0f * rhs.W); uuv *= 2.0f; return lhs + uv + uuv; }
/// <summary> /// Determinates if a point is within this box. /// </summary> /// <param name="p">: Point to check.</param> /// <returns> Returns true if the point is withing the box, and false if it is not.</returns> public bool IsPointInside(Vector3D p) { return (p.X >= MinEdge.X && p.X <= MaxEdge.X && p.Y >= MinEdge.Y && p.Y <= MaxEdge.Y && p.Z >= MinEdge.Z && p.Z <= MaxEdge.Z); }
/// <summary> /// Returns an Euler Angles vector. Angles in radiants /// </summary> /// <param name="euler">vector to put the result into</param> /// <returns></returns> public Vector3D toEuler(out Vector3D euler) { double sqw = m_w * m_w; double sqx = m_x * m_x; double sqy = m_y * m_y; double sqz = m_z * m_z; // heading = rotation about z-axis euler.Z = (float)(Math.Atan2(2.0 * (m_x * m_y + m_z * m_w), (sqx - sqy - sqz + sqw))); // bank = rotation about x-axis euler.X = (float)(Math.Atan2(2.0 * (m_y * m_z + m_x * m_w), (-sqx - sqy + sqz + sqw))); // attitude = rotation about y-axis euler.Y = (float)(Math.Asin(-2.0 * (m_x * m_z - m_y * m_w))); return euler; }
public ParticleAffector CreateGravityAffector(Vector3D gravity, uint timeForceLost) { return (ParticleAffector) NativeElement.GetObject(Particle_CreateGravityAffector(_raw, gravity.ToUnmanaged(), timeForceLost), typeof(ParticleAffector)); }