Vector4 GetRotatedVertex(Axis4D axis, Vector4 v, float s, float c)
    {
        switch (axis)
        {
        case Axis4D.xy:
            return(RotateAroundXY(v, s, c));

        case Axis4D.xz:
            return(RotateAroundXZ(v, s, c));

        case Axis4D.xw:
            return(RotateAroundXW(v, s, c));

        case Axis4D.yz:
            return(RotateAroundYZ(v, s, c));

        case Axis4D.yw:
            return(RotateAroundYW(v, s, c));

        case Axis4D.zw:
            return(RotateAroundZW(v, s, c));
        }

        return(new Vector4(0, 0, 0, 0));
    }
Example #2
0
        /// <summary>
        /// Rotate a vertex v around an axis for an angle theta, in degrees.
        /// </summary>
        /// <param name="v"></param>
        /// <param name="axis"></param>
        /// <param name="theta"></param>
        /// <returns></returns>
        public static Vector4 GetRotatedVertex(this Vector4 v, Axis4D axis, float theta)
        {
            if (theta % 360 == 0)
            {
                return(v);
            }
            switch (axis)
            {
            case Axis4D.xy:
                return(v.rotate(right, up, theta));

            case Axis4D.xz:
                return(v.rotate(right, forward, theta));

            case Axis4D.xw:
                return(v.rotate(right, wPos, theta));

            case Axis4D.yz:
                return(v.rotate(up, forward, theta));

            case Axis4D.yw:
                return(v.rotate(up, wPos, theta));

            case Axis4D.zw:
                return(v.rotate(forward, wPos, theta));

            default:
                return(Vector4.zero);
            }
        }
Example #3
0
    Vector4 GetRotatedVertex(Axis4D axis, Vector4 v, float s, float c)      // Creates a vector 4 that holds the axis from our list of axis's, a vector4, and two floats
    {
        switch (axis)
        {
        // Creates our different cases for each rotations
        case Axis4D.xy:
            return(RotateAroundXY(v, s, c));

        case Axis4D.xz:
            return(RotateAroundXZ(v, s, c));

        case Axis4D.xw:
            return(RotateAroundXW(v, s, c));

        case Axis4D.yz:
            return(RotateAroundYZ(v, s, c));

        case Axis4D.yw:
            return(RotateAroundYW(v, s, c));

        case Axis4D.zw:
            return(RotateAroundZW(v, s, c));
        }

        return(new Vector4(0, 0, 0, 0));         // Returns a Vector 4
    }
Example #4
0
 void AddToRotationDictionary(Axis4D axis, float theta)
 {
     for (int i = 0; i < rotation.Length; i++)
     {
         RotationParams rp = rotation[i];
         if (rp.axis == axis)
         {
             rp.amount += theta;
             if (rp.amount > 360)
             {
                 rp.amount -= 360;
             }
         }
     }
 }
Example #5
0
 public float GetRotation(Axis4D axis)
 {
     return rotation[axis] % 360f;
 }
Example #6
0
 void Rotate(Axis4D axis, float theta)
 {
     AddToRotationDictionary(axis, theta);
     ApplyRotationToVerts();
 }
Example #7
0
    Vector4 GetRotatedVertex(Axis4D axis, Vector4 v, float s, float c)
    {
        switch (axis)
        {
            case Axis4D.xy:
                return RotateAroundXY(v, s, c);
                break;
            case Axis4D.xz:
                return RotateAroundXZ(v, s, c);
                break;
            case Axis4D.xw:
                return RotateAroundXW(v, s, c);
                break;
            case Axis4D.yz:
                return RotateAroundYZ(v, s, c);
                break;
            case Axis4D.yw:
                return RotateAroundYW(v, s, c);
                break;
            case Axis4D.zw:
                return RotateAroundZW(v, s, c);
                break;
        }

        return new Vector4(0, 0, 0, 0);
    }
Example #8
0
 void AddToRotationDictionary(Axis4D axis, float theta)   // Creates our function, requires an axis and a float
 {
     rotation [axis] = (rotation [axis] + theta);         // Makes the rotation value for our axis = to the axis plus our theta float
 }
Example #9
0
 void Rotate(Axis4D axis, float theta)     // Creates our Rotate function, that requires an axis and a float (theta)
 {
     AddToRotationDictionary(axis, theta); // Calls our AddToRotationDictionary function
     ApplyRotationToVerts();               // Calls our ApplyRotationToVerts Function
 }
Example #10
0
    /// <summary>
    /// Gets a 64-bit integer that represents the number of elements in the specified dimension of the array.
    /// </summary>
    /// <typeparam name="T">The type of values stored in the array.</typeparam>
    /// <param name="array">The array.</param>
    /// <param name="dimension">The dimension whose length needs to be determined.</param>
    /// <returns>A 64-bit integer that represents the number of elements in the specified dimension.</returns>
    public static long GetLongLength <T>(this T[,,,] array, Axis4D dimension)
    {
        Contracts.Requires.That(array != null);

        return(array.GetLongLength((int)dimension));
    }
 void AddToRotationDictionary(Axis4D axis, float theta)
 {
     rotation [axis] = (rotation [axis] + theta);
 }
 void Rotate(Axis4D axis, float theta)
 {
     AddToRotationDictionary(axis, theta);
     ApplyRotationToVerts();
 }
Example #13
0
 public RotationParams(Axis4D axis, float amount)
 {
     this.axis   = axis;
     this.amount = amount;
 }
Example #14
0
    /// <summary>
    /// Gets the index of the last element of the specified dimension in the array.
    /// </summary>
    /// <typeparam name="T">The type of values stored in the array.</typeparam>
    /// <param name="array">The array.</param>
    /// <param name="dimension">The dimension whose upper bound needs to be determined.</param>
    /// <returns>
    /// The index of the last element of the specified dimension in the array, or -1 if the specified dimension is empty.
    /// </returns>
    public static int GetUpperBound <T>(this T[,,,] array, Axis4D dimension)
    {
        Contracts.Requires.That(array != null);

        return(array.GetUpperBound((int)dimension));
    }
Example #15
0
 void AddToRotationDictionary(Axis4D axis, float theta)
 {
     rotation[axis] = (rotation[axis] + theta);
 }
Example #16
0
 /// <summary>
 /// Rotate around a single plane
 /// </summary>
 /// <param name="rotationPlane">The plane that stays constant</param>
 /// <param name="degrees">The amount of degrees to rotate by</param>
 public void Rotate(Axis4D rotationPlane, float degrees)
 {
     rotation.Add((int)rotationPlane, degrees);
 }
	/// <summary>
	/// Gets the current index of the last slot of the specified dimension within the specified bounds.
	/// </summary>
	/// <param name="bounds">The bounds to check against.</param>
	/// <param name="axis">The axis of the dimension whose ending index needs to be determined.</param>
	/// <returns>
	/// The current index of the last slot of the specified dimension.
	/// </returns>
	public static int GetCurrentUpperBound(this IDynamicIndexingBounds<Index4D> bounds, Axis4D axis)
	{
		Contracts.Requires.That(bounds != null);

		return bounds.GetCurrentUpperBound((int)axis);
	}
Example #18
0
 /// <summary>
 /// Gets the coordinate value or index of a particular dimension.
 /// </summary>
 /// <param name="axis">The axis of the dimension whose coordinate needs to be determined.</param>
 /// <returns>The value of the dimensional coordinate.</returns>
 public int this[Axis4D axis] => this[(int)axis];
Example #19
0
    /// <summary>
    /// Gets the index of the first valid slot of the specified dimension within the specified bounds.
    /// </summary>
    /// <param name="bounds">The bounds to check against.</param>
    /// <param name="axis">The axis of the dimension whose starting index needs to be determined.</param>
    /// <returns>
    /// The index of the first slot of the specified dimension.
    /// </returns>
    public static int GetLowerBound(this IIndexingBounds <Index4D> bounds, Axis4D axis)
    {
        Contracts.Requires.That(bounds != null);

        return(bounds.GetLowerBound((int)axis));
    }