Exemple #1
0
 public void GetTranslation(ref Vector3F translation)
 {
     translation.X = Values[12];
     translation.Y = Values[13];
     translation.Z = Values[14];
 }
Exemple #2
0
 /// <summary>
 ///     Establece las componentes del vector parámetro a los valores del vector unitario Y de esta matriz.
 /// </summary>
 /// <param Name="up"></param>
 public void GetUp(ref Vector3F up)
 {
     up.X = Values[4];
     up.Y = Values[5];
     up.Z = Values[6];
 }
Exemple #3
0
 /// <summary>
 ///     Establece las componentes del vector parámetro a los valores del vector unitario Z de esta matriz.
 /// </summary>
 /// <param Name="up"></param>
 public void GetForward(ref Vector3F forward)
 {
     forward.X = Values[8];
     forward.Y = Values[9];
     forward.Z = Values[10];
 }
Exemple #4
0
        };              // Translation  (values[12]..values[15]

        /// <summary>
        ///     Establece los ejes unitarios de esta matriz según la rotación dada por los grados alto ejes indicados.
        /// </summary>
        /// <param name="grados"></param>
        /// <param name="ejeRotacion"></param>
        public virtual void Rotation(float grados, Vector3F ejeRotacion)
        {
            Rotation(grados, ejeRotacion.X, ejeRotacion.Y, ejeRotacion.Z);
        }
Exemple #5
0
 /// <summary>
 ///     Establece las componentes del vector parámetro a los valores del vector unitario X de esta matriz.
 /// </summary>
 /// <param Name="up"></param>
 public void GetRight(ref Vector3F right)
 {
     right.X = Values[0];
     right.Y = Values[1];
     right.Z = Values[2];
 }
 /// <summary>
 ///     Caclulate the cross (vector) product of two vectors
 /// </summary>
 /// <param name="tempLeft">First operand</param>
 /// <param name="tempRight">Second operand</param>
 /// <returns>The cross product of the two inputs</returns>
 /// <param name="result">The cross product of the two inputs</param>
 public static void Cross(Vector3F left, Vector3F right, ref Vector3F result)
 {
     result.X = left.Y * right.Z - left.Z * right.Y;
     result.Y = left.Z * right.X - left.X * right.Z;
     result.Z = left.X * right.Y - left.Y * right.X;
 }
 public static Quaternion4F FromRadiansAxis(float radianes, Vector3F axis)
 {
     return(FromRadiansAxis(radianes, axis.X, axis.Y, axis.Z));
 }
 /// <summary>
 ///     Devuelve el ángulo (en grados) entre este vector y el vector parámetro.
 ///     <para>Ambos vectores se normalizan y quedan modificados.</para>
 ///     <para>Si uno de los vectores o los dos valen cero, devuelve 90º.</para>
 ///     <para>El ángulo devuelto varia entre 0 y 180 grados</para>
 /// </summary>
 /// <param name="other"></param>
 /// <returns></returns>
 public double Angle(Vector3F other)
 {
     return(Angle(this, other));
 }
 public void Rotation(float radians, Vector3F axis)
 {
     Rotation(radians, axis.X, axis.Y, axis.Z);
 }
 /// <summary>
 ///     Resta este vector con el vector argumento, el resultado es este mismo vector.
 ///     this -= v3
 /// </summary>
 /// <param name="v3"></param>
 public void Subtract(Vector3F v3)
 {
     X -= v3.X;
     Y -= v3.Y;
     Z -= v3.Z;
 }
 public double Distance(Vector3F other)
 {
     return(Distance(this, other));
 }
 /// <summary>
 ///     Suma este vector con el vector argumento, el resultado es este mismo vector.
 ///     this += v3
 /// </summary>
 /// <param name="v3"></param>
 public void Sum(Vector3F v3)
 {
     X += v3.X;
     Y += v3.Y;
     Z += v3.Z;
 }
 /// <summary>
 ///     Calculates a reflection vector to the plane with the given normal.
 /// </summary>
 /// <remarks>
 ///     Assumes this vector is pointing AWAY from the plane, invert if not.
 /// </remarks>
 /// <param name="normal">Normal vector on which this vector will be reflected.</param>
 /// <returns></returns>
 public Vector3F Reflect(Vector3F normal)
 {
     return(this - (2 * Dot(normal) * normal));
 }
 public void CopyFrom(Vector3F v3Source)
 {
     X = v3Source.X;
     Y = v3Source.Y;
     Z = v3Source.Z;
 }
Exemple #15
0
 /// <summary>
 ///     Multiplica esta (this) matriz por la matriz de escalado dada por el vector pasado como parámetro.
 ///     <para>this = this * MatEscalado(Vector3f)</para>
 /// </summary>
 /// <param name="vEscala"></param>
 public virtual void Scale(Vector3F vEscala)
 {
     Scale(vEscala.X, vEscala.Y, vEscala.Z);
 }
 public static Quaternion4F FromDegreesAxis(float degrees, Vector3F axis)
 {
     return(FromRadiansAxis(MathHelp.RadiansFromDegrees(degrees), axis.X, axis.Y, axis.Z));
 }
Exemple #17
0
 /// <summary>
 ///     Establece la porción de escala de esta matriz.
 /// </summary>
 /// <param name="ancho"></param>
 /// <param name="alto"></param>
 /// <param name="Z"></param>
 public virtual void SetScalation(Vector3F v3Scale)
 {
     SetScalation(v3Scale.X, v3Scale.Y, v3Scale.Z);
 }
Exemple #18
0
 public static void CalculateBasicFaceNormal(Vector3F v1, Vector3F v2, Vector3F v3, ref Vector3F result)
 {
     TempLeft.CopyFrom(v2);
     TempRight.CopyFrom(v3);
     TempLeft.Subtract(v1);
     TempRight.Subtract(v1);
     Vector3F.Cross(TempLeft, TempRight, ref result);
     result.Normalize();
 }