static void Main(string[] args) { string root = System.IO.Path.Combine("..", "..", "..", "Numerics"); var integer_path = System.IO.Path.Combine(root, "Integer.cs"); System.IO.File.Delete(integer_path); foreach (var size in Integer.Sizes) { var integer = new Integer(size, true); integer.Generate(); System.IO.File.AppendAllText(integer_path, integer.Text); Console.WriteLine("Done - " + integer.Name); var uinteger = new Integer(size, false); uinteger.Generate(); System.IO.File.AppendAllText(integer_path, uinteger.Text); Console.WriteLine("Done - " + uinteger.Name); } foreach (var type in Color.Types) { var color = new Color(type); color.Generate(); var path = System.IO.Path.Combine(root, color.Name + ".cs"); System.IO.File.WriteAllText(path, color.Text); Console.WriteLine("Done - " + color.Name); } foreach (var type in Quaternion.Types) { var quaternion = new Quaternion(type); quaternion.Generate(); var path = System.IO.Path.Combine(root, "Geometry", quaternion.Name + ".cs"); System.IO.File.WriteAllText(path, quaternion.Text); Console.WriteLine("Done - " + quaternion.Name); } foreach (var type in Plane.Types) { var plane = new Plane(type); plane.Generate(); var path = System.IO.Path.Combine(root, "Geometry", plane.Name + ".cs"); System.IO.File.WriteAllText(path, plane.Text); Console.WriteLine("Done - " + plane.Name); } foreach (int dimension in Vector.Sizes) { foreach (var type in Vector.Types) { var vector = new Vector(type, dimension); vector.Generate(); var path = System.IO.Path.Combine(root, "Vectors", vector.Name + ".cs"); System.IO.File.WriteAllText(path, vector.Text); Console.WriteLine("Done - " + vector.Name); } } foreach (int rows in Matrix.Sizes) { foreach (int columns in Matrix.Sizes) { foreach (var type in Matrix.Types) { var matrix = new Matrix(type, rows, columns); matrix.Generate(); var path = System.IO.Path.Combine(root, "Matrices", matrix.Name + ".cs"); System.IO.File.WriteAllText(path, matrix.Text); Console.WriteLine("Done - " + matrix.Name); } } } foreach (var type in Shapes.Types) { var rpath = System.IO.Path.Combine(root, "Geometry"); var line1 = new Line(type, 1); line1.Generate(); System.IO.File.WriteAllText(System.IO.Path.Combine(rpath, line1.Name + ".cs"), line1.Text); Console.WriteLine("Done - " + line1.Name); foreach (int dimension in Shapes.Sizes) { var point = new Point(type, dimension); point.Generate(); System.IO.File.WriteAllText(System.IO.Path.Combine(rpath, point.Name + ".cs"), point.Text); Console.WriteLine("Done - " + point.Name); var size = new Size(type, dimension); size.Generate(); System.IO.File.WriteAllText(System.IO.Path.Combine(rpath, size.Name + ".cs"), size.Text); Console.WriteLine("Done - " + size.Name); var polygon = new Polygon(type, dimension); polygon.Generate(); System.IO.File.WriteAllText(System.IO.Path.Combine(rpath, polygon.Name + ".cs"), polygon.Text); Console.WriteLine("Done - " + polygon.Name); var line = new Line(type, dimension); line.Generate(); System.IO.File.WriteAllText(System.IO.Path.Combine(rpath, line.Name + ".cs"), line.Text); Console.WriteLine("Done - " + line.Name); } var rectangle = new Rectangle(type); rectangle.Generate(); System.IO.File.WriteAllText(System.IO.Path.Combine(rpath, rectangle.Name + ".cs"), rectangle.Text); Console.WriteLine("Done - " + rectangle.Name); var box = new Box(type); box.Generate(); System.IO.File.WriteAllText(System.IO.Path.Combine(rpath, box.Name + ".cs"), box.Text); Console.WriteLine("Done - " + box.Name); var ellipse = new Ellipse(type); ellipse.Generate(); System.IO.File.WriteAllText(System.IO.Path.Combine(rpath, ellipse.Name + ".cs"), ellipse.Text); Console.WriteLine("Done - " + ellipse.Name); var circle = new Circle(type); circle.Generate(); System.IO.File.WriteAllText(System.IO.Path.Combine(rpath, circle.Name + ".cs"), circle.Text); Console.WriteLine("Done - " + circle.Name); var sphere = new Sphere(type); sphere.Generate(); System.IO.File.WriteAllText(System.IO.Path.Combine(rpath, sphere.Name + ".cs"), sphere.Text); Console.WriteLine("Done - " + sphere.Name); } foreach (var type in Ray.Types) { var ray = new Ray(type); ray.Generate(); var path = System.IO.Path.Combine(root, "Geometry", ray.Name + ".cs"); System.IO.File.WriteAllText(path, ray.Text); Console.WriteLine("Done - " + ray.Name); } }
void Conversions() { WriteLine("#region Conversions"); foreach (var type in Types) { string imex = type.IsImplicitlyConvertibleTo(Type) ? "implicit" : "explicit"; if (type != Type) { Quaternion other = new Quaternion(type); var casts = string.Join(", ", Components.Select(component => string.Format("({0})value.{1}", Type, component))); WriteLine("/// <summary>"); WriteLine("/// Defines an {0} conversion of a {1} value to a {2}.", imex, other, Name); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">The value to convert to a {0}.</param>", Name); WriteLine("/// <returns>A {0} that has all components equal to value.</returns>", Name); if (Type.IsCLSCompliant && !type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } WriteLine("public static {0} operator {1}({2} value)", imex, Name, other); WriteLine("{"); Indent(); WriteLine("return new {0}({1});", Name, casts); Dedent(); WriteLine("}"); } WriteLine("/// <summary>"); WriteLine("/// Defines an {0} conversion of a {1} value to a {2}.", imex, type, Name); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">The value to convert to a {0}.</param>", Name); WriteLine("/// <returns>A {0} that has all a real component equal to value.</returns>", Name); if (Type.IsCLSCompliant && !type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } WriteLine("public static {0} operator {1}({2} value)", imex, Name, type); WriteLine("{"); Indent(); WriteLine("return new {0}(({1})value, 0, 0, 0);", Name, Type); Dedent(); WriteLine("}"); } WriteLine("#endregion"); }
void Functions() { WriteLine("/// <summary>"); WriteLine("/// Provides static methods for quaternion functions."); WriteLine("/// </summary>"); WriteLine("public static partial class Quaternion"); WriteLine("{"); Indent(); var result = new Quaternion(Type.PositiveType); #region Factory WriteLine("#region Factory"); WriteLine("/// <summary>"); WriteLine("/// Initializes a new instance of the <see cref=\"{0}\"/> structure given a rotation and an axis.", Name); WriteLine("/// </summary>"); WriteLine("/// <param name=\"axis\">The axis of rotation.</param>"); WriteLine("/// <param name=\"angle\">The angle of rotation.</param>"); WriteLine("/// <returns>The newly created quaternion.</returns>"); WriteLine("public static {0} FromRotationAxis({1} axis, {2} angle)", Name, new Vector(Type, 3), Type); Indent("{"); WriteLine("axis = Vector.Normalize(axis);"); WriteLine("var half = angle * 0.5f;"); WriteLine("var sin = Functions.Sin(half);"); WriteLine("var cos = Functions.Cos(half);"); WriteLine("return new {0}(cos, axis.X * sin, axis.Y * sin, axis.Z * sin);", Name); Dedent("}"); WriteLine("/// <summary>"); WriteLine("/// Initializes a new instance of the <see cref=\"{0}\"/> structure given a yaw, pitch, and roll value.", Name); WriteLine("/// </summary>"); WriteLine("/// <param name=\"yaw\">The yaw of rotation.</param>"); WriteLine("/// <param name=\"pitch\">The pitch of rotation.</param>"); WriteLine("/// <param name=\"roll\">The roll of rotation.</param>"); WriteLine("/// <returns>The newly created quaternion.</returns>"); WriteLine("public static {0} FromRotationAngles({1} yaw, {1} pitch, {1} roll)", Name, Type); Indent("{"); WriteLine("var halfRoll = roll * 0.5f;"); WriteLine("var sinRoll = Functions.Sin(halfRoll);"); WriteLine("var cosRoll = Functions.Cos(halfRoll);"); WriteLine("var halfPitch = pitch * 0.5f;"); WriteLine("var sinPitch = Functions.Sin(halfPitch);"); WriteLine("var cosPitch = Functions.Cos(halfPitch);"); WriteLine("var halfYaw = yaw * 0.5f;"); WriteLine("var sinYaw = Functions.Sin(halfYaw);"); WriteLine("var cosYaw = Functions.Cos(halfYaw);"); WriteLine("return new {0}(", Name); WriteLine("\t(cosYaw * cosPitch * cosRoll) + (sinYaw * sinPitch * sinRoll),"); WriteLine("\t(cosYaw * sinPitch * cosRoll) + (sinYaw * cosPitch * sinRoll),"); WriteLine("\t(sinYaw * cosPitch * cosRoll) - (cosYaw * sinPitch * sinRoll),"); WriteLine("\t(cosYaw * cosPitch * sinRoll) - (sinYaw * sinPitch * cosRoll));"); Dedent("}"); WriteLine("/// <summary>"); WriteLine("/// Initializes a new instance of the <see cref=\"{0}\"/> structure given a rotation matrix.", Name); WriteLine("/// </summary>"); WriteLine("/// <param name=\"matrix\">The rotation matrix.</param>"); WriteLine("/// <returns>The newly created quaternion.</returns>"); WriteLine("public static {0} FromMatrix({1} matrix)", Name, new Matrix(Type, 3,3)); Indent("{"); WriteLine("var a = Functions.Sqrt(Functions.Max(0, 1 + matrix[0, 0] + matrix[1, 1] + matrix[2, 2])) / 2;"); WriteLine("var b = Functions.Sqrt(Functions.Max(0, 1 + matrix[0, 0] - matrix[1, 1] - matrix[2, 2])) / 2;"); WriteLine("var c = Functions.Sqrt(Functions.Max(0, 1 - matrix[0, 0] + matrix[1, 1] - matrix[2, 2])) / 2;"); WriteLine("var d = Functions.Sqrt(Functions.Max(0, 1 - matrix[0, 0] - matrix[1, 1] + matrix[2, 2])) / 2;"); WriteLine("b *= Functions.Sign(b * (matrix[2, 1] - matrix[1, 2]));"); WriteLine("c *= Functions.Sign(c * (matrix[0, 2] - matrix[2, 0]));"); WriteLine("d *= Functions.Sign(d * (matrix[1, 0] - matrix[0, 1]));"); WriteLine("return new {0}(a, b, c, d);", Name); Dedent("}"); WriteLine("/// <summary>"); WriteLine("/// Initializes a new instance of the <see cref=\"{0}\"/> structure given a direction and up axis.", Name); WriteLine("/// </summary>"); WriteLine("/// <param name=\"direction\">The direction vector.</param>"); WriteLine("/// <param name=\"up\">The up axis.</param>"); WriteLine("/// <returns>The newly created quaternion.</returns>"); WriteLine("public static {0} FromOrientation({1} direction, {1} up)", Name, new Vector(Type, 3)); Indent("{"); WriteLine("var zaxis = Vector.Normalize(direction);"); WriteLine("var xaxis = Vector.Normalize(Vector.Cross(up, zaxis));"); WriteLine("var yaxis = Vector.Cross(zaxis, xaxis);"); WriteLine("var a = Functions.Sqrt(Functions.Max(0, 1 + xaxis.X + yaxis.Y + zaxis.Z)) / 2;"); WriteLine("var b = Functions.Sqrt(Functions.Max(0, 1 + xaxis.X - yaxis.Y - zaxis.Z)) / 2;"); WriteLine("var c = Functions.Sqrt(Functions.Max(0, 1 - xaxis.X + yaxis.Y - zaxis.Z)) / 2;"); WriteLine("var d = Functions.Sqrt(Functions.Max(0, 1 - xaxis.X - yaxis.Y + zaxis.Z)) / 2;"); WriteLine("b *= Functions.Sign(b * (yaxis.Z - zaxis.Y));"); WriteLine("c *= Functions.Sign(c * (zaxis.X - xaxis.Z));"); WriteLine("d *= Functions.Sign(d * (xaxis.Y - yaxis.X));"); WriteLine("return new {0}(a, b, c, d);", Name); Dedent("}"); WriteLine("#endregion"); #endregion #region Binary WriteLine("#region Binary"); WriteLine("/// <summary>"); WriteLine("/// Writes the given <see cref=\"{0}\"/> to an <see cref=\"Ibasa.IO.BinaryWriter\">.", Name); WriteLine("/// </summary>"); WriteLine("public static void Write(this Ibasa.IO.BinaryWriter writer, {0} quaternion)", Name); WriteLine("{"); Indent(); foreach(var component in Components) { WriteLine("writer.Write(quaternion.{0});", component); } Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Reads a <see cref=\"{0}\"/> from an <see cref=\"Ibasa.IO.BinaryReader\">.", Name); WriteLine("/// </summary>"); WriteLine("public static {0} Read{0}(this Ibasa.IO.BinaryReader reader)", Name); WriteLine("{"); Indent(); WriteLine("return new {0}({1});", Name, string.Join(", ", Components.Select(c => string.Format("reader.Read{0}()", Type.CLRName)))); Dedent(); WriteLine("}"); WriteLine("#endregion"); #endregion #region Operations WriteLine("#region Operations"); if (Type.NegativeType != NumberType.Invalid) { var negQuaternion = new Quaternion(Type.NegativeType); WriteLine("/// <summary>"); WriteLine("/// Returns the additive inverse of a quaternion."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The negative of value.</returns>"); WriteLine("public static {0} Negative({1} value)", negQuaternion, Name); WriteLine("{"); Indent(); WriteLine("return new {0}({1});", negQuaternion, string.Join(", ", Components.Select(component => "-value." + component))); Dedent(); WriteLine("}"); } WriteLine("/// <summary>"); WriteLine("/// Adds two quaternions and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"left\">The first value to add.</param>"); WriteLine("/// <param name=\"right\">The second value to add.</param>"); WriteLine("/// <returns>The sum of left and right.</returns>"); WriteLine("public static {0} Add({1} left, {1} right)", result, Name); WriteLine("{"); Indent(); WriteLine("return new {0}({1});", result, string.Join(", ", Components.Select(component => string.Format("left.{0} + right.{0}", component)))); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Subtracts one quaternion from another and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"left\">The value to subtract from (the minuend).</param>"); WriteLine("/// <param name=\"right\">The value to subtract (the subtrahend).</param>"); WriteLine("/// <returns>The result of subtracting right from left (the difference).</returns>"); WriteLine("public static {0} Subtract({1} left, {1} right)", result, Name); WriteLine("{"); Indent(); WriteLine("return new {0}({1});", result, string.Join(", ", Components.Select(component => string.Format("left.{0} - right.{0}", component)))); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Returns the product of two quaternions."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"left\">The first value to add.</param>"); WriteLine("/// <param name=\"right\">The second value to add.</param>"); WriteLine("/// <returns>The product of the left and right parameters.</returns>"); WriteLine("public static {0} Multiply({1} left, {1} right)", result, Name); WriteLine("{"); Indent(); WriteLine("return new {0}(", Name); WriteLine("\t(left.A * right.A) - ((left.B * right.B) + (left.C * right.C) + (left.D * right.D)),"); WriteLine("\t(left.A * right.B) + (left.B * right.A) + (left.D * right.C) - (left.C * right.D),"); WriteLine("\t(left.A * right.C) + (left.C * right.A) + (left.B * right.D) - (left.D * right.B),"); WriteLine("\t(left.A * right.D) + (left.D * right.A) + (left.C * right.B) - (left.B * right.C));"); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Divides one quaternion by another and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"left\">The quaternion to be divided (the dividend).</param>"); WriteLine("/// <param name=\"right\">The quaternion to divide by (the divisor).</param>"); WriteLine("/// <returns>The result of dividing left by right (the quotient).</returns>"); WriteLine("public static {0} Divide({1} left, {1} right)", result, Name); WriteLine("{"); Indent(); WriteLine("return new {0}(", Name); WriteLine("\t(left.A * right.A) - ((left.B * -right.B) + (left.C * -right.C) + (left.D * -right.D)) / AbsoluteSquared(right),"); WriteLine("\t((left.A * -right.B) + (left.B * right.A) + (left.D * -right.C) - (left.C * -right.D)) / AbsoluteSquared(right),"); WriteLine("\t((left.A * -right.C) + (left.C * right.A) + (left.B * -right.D) - (left.D * -right.B)) / AbsoluteSquared(right),"); WriteLine("\t((left.A * -right.D) + (left.D * right.A) + (left.C * -right.B) - (left.B * -right.C)) / AbsoluteSquared(right));"); Dedent(); WriteLine("}"); WriteLine("#endregion"); #endregion #region Equatable WriteLine("#region Equatable"); WriteLine("/// <summary>"); WriteLine("/// Returns a value that indicates whether two quaternions are equal."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"left\">The first quaternion to compare.</param>"); WriteLine("/// <param name=\"right\">The second quaternion to compare.</param>"); WriteLine("/// <returns>true if the left and right are equal; otherwise, false.</returns>"); WriteLine("public static bool Equals({0} left, {0} right)", Name); WriteLine("{"); Indent(); WriteLine("return left == right;"); Dedent(); WriteLine("}"); WriteLine("#endregion"); #endregion #region Test WriteLine("#region Test"); WriteLine("/// <summary>"); WriteLine("/// Determines whether all components of a quaternion are non-zero."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>true if all components are non-zero; false otherwise.</returns>"); if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } WriteLine("public static bool All({0} value)", Name); WriteLine("{"); Indent(); WriteLine("return {0};", string.Join(" && ", Components.Select(component => string.Format("value.{0} != 0", component)))); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Determines whether all components of a quaternion satisfy a condition."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <param name=\"predicate\">A function to test each component for a condition.</param>"); WriteLine("/// <returns>true if every component of the quaternion passes the test in the specified"); WriteLine("/// predicate; otherwise, false.</returns>"); if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } WriteLine("public static bool All({0} value, Predicate<{1}> predicate)", Name, Type); WriteLine("{"); Indent(); WriteLine("return {0};", string.Join(" && ", Components.Select(component => string.Format("predicate(value.{0})", component)))); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Determines whether any component of a quaternion is non-zero."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>true if any components are non-zero; false otherwise.</returns>"); if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } WriteLine("public static bool Any({0} value)", Name); WriteLine("{"); Indent(); WriteLine("return {0};", string.Join(" || ", Components.Select(component => string.Format("value.{0} != 0", component)))); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Determines whether any components of a quaternion satisfy a condition."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <param name=\"predicate\">A function to test each component for a condition.</param>"); WriteLine("/// <returns>true if any component of the quaternion passes the test in the specified"); WriteLine("/// predicate; otherwise, false.</returns>"); if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } WriteLine("public static bool Any({0} value, Predicate<{1}> predicate)", Name, Type); WriteLine("{"); Indent(); WriteLine("return {0};", string.Join(" || ", Components.Select(component => string.Format("predicate(value.{0})", component)))); Dedent(); WriteLine("}"); WriteLine("#endregion"); #endregion #region Properties WriteLine("#region Properties"); WriteLine("/// <summary>"); WriteLine("/// Return the axis angle representation of a unit quaternion."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A unit quaternion.</param>"); WriteLine("/// <returns>The axis angle of a quaternion.</returns>"); WriteLine("public static Tuple<{0}, {1}> AxisAngle({2} value)", new Vector(Type, 3), Type, Name); WriteLine("{"); Indent(); WriteLine("var s = Functions.Sqrt(1 - value.A - value.A);"); WriteLine("return Tuple.Create("); WriteLine("\tnew {0}(value.B / s, value.C / s, value.D / s),", new Vector(Type, 3)); WriteLine("\t2 * Functions.Acos(value.A));"); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Return real part of a quaternion."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The real part of a quaternion.</returns>"); WriteLine("public static {0} Real({0} value)", Name); WriteLine("{"); Indent(); WriteLine("return new {0}(value.A, 0, 0, 0);", Name); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Return imaginary part of a quaternion."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The imaginary part of a quaternion.</returns>"); WriteLine("public static {0} Imaginary({0} value)", Name); WriteLine("{"); Indent(); WriteLine("return new {0}(0, value.B, value.C, value.D);", Name); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Computes the absolute squared value of a quaternion and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The absolute squared value of value.</returns>"); WriteLine("public static {0} AbsoluteSquared({1} value)", Type.PositiveType, Name); WriteLine("{"); Indent(); WriteLine("return (value.A * value.A + value.B * value.B + value.C * value.C + value.D * value.D);"); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Computes the absolute value (or modulus or magnitude) of a quaternion and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The absolute value of value.</returns>"); WriteLine("public static {0} Absolute({1} value)", Type.RealType, Name); WriteLine("{"); Indent(); WriteLine("return Functions.Sqrt(value.A * value.A + value.B * value.B + value.C * value.C + value.D * value.D);"); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Computes the normalized value (or unit) of a quaternion."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The normalized value of value.</returns>"); WriteLine("public static {0} Normalize({0} value)", Name); WriteLine("{"); Indent(); WriteLine("var absolute = Absolute(value);"); WriteLine("if(absolute <= {0}.Epsilon)", Type.RealType); WriteLine("{"); Indent(); WriteLine("return {0}.Zero;", Name); Dedent(); WriteLine("}"); WriteLine("return value / absolute;"); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Returns the multiplicative inverse of a quaternion."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The reciprocal of value.</returns>"); WriteLine("public static {0} Reciprocal({0} value)", Name); WriteLine("{"); Indent(); WriteLine("var absoluteSquared = AbsoluteSquared(value);"); WriteLine("return new {0}(", Name); WriteLine("\tvalue.A / absoluteSquared,"); WriteLine("\t-value.B / absoluteSquared,"); WriteLine("\t-value.C / absoluteSquared,"); WriteLine("\t-value.D / absoluteSquared);"); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Computes the conjugate of a quaternion and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The conjugate of value.</returns>"); WriteLine("public static {0} Conjugate({0} value)", Name); WriteLine("{"); Indent(); WriteLine("return new {0}(value.A, -value.B, -value.C, -value.D);", Name); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Computes the argument of a quaternion and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The argument of value.</returns>"); WriteLine("public static {0} Argument({1} value)", Type.RealType, Name); WriteLine("{"); Indent(); WriteLine("return Functions.Atan2(Absolute(Imaginary(value)), value.A);"); Dedent(); WriteLine("}"); WriteLine("#endregion"); #endregion #region Product WriteLine("#region Product"); WriteLine("/// <summary>"); WriteLine("/// Calculates the dot product (inner product) of two quaternions."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"left\">First source quaternion.</param>"); WriteLine("/// <param name=\"right\">Second source quaternion.</param>"); WriteLine("/// <returns>The dot product of the two quaternions.</returns>"); WriteLine("public static {0} Dot({1} left, {1} right)", Type, Name); Indent("{"); WriteLine("return left.A * right.A + left.B * right.B + left.C * right.C + left.D * right.D;"); Dedent("}"); WriteLine("#endregion"); #endregion #region Interpolation WriteLine("#region Interpolation"); WriteLine("/// <summary>"); WriteLine("/// Performs a linear interpolation between two quaternions."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"start\">Start quaternion.</param>"); WriteLine("/// <param name=\"end\">End quaternion.</param>"); WriteLine("/// <param name=\"amount\">Value between 0 and 1 indicating the weight of <paramref name=\"end\"/>.</param>"); WriteLine("/// <returns>The linear interpolation of the two quaternions.</returns>"); WriteLine("/// <remarks>"); WriteLine("/// This method performs the linear interpolation based on the following formula."); WriteLine("/// <code>start + (end - start) * amount</code>"); WriteLine("/// Passing <paramref name=\"amount\"/> a value of 0 will cause <paramref name=\"start\"/> to be returned; a value of 1 will cause <paramref name=\"end\"/> to be returned. "); WriteLine("/// </remarks>"); WriteLine("public static {0} Lerp({0} start, {0} end, {1} amount)", Name, Type); Indent("{"); WriteLine("return new {0}(", Name); WriteLine("\tFunctions.Lerp(start.A, end.A, amount),"); WriteLine("\tFunctions.Lerp(start.B, end.B, amount),"); WriteLine("\tFunctions.Lerp(start.C, end.C, amount),"); WriteLine("\tFunctions.Lerp(start.D, end.D, amount));"); Dedent("}"); WriteLine("/// <summary>"); WriteLine("/// Interpolates between two unit quaternions, using spherical linear interpolation."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"start\">Start quaternion.</param>"); WriteLine("/// <param name=\"end\">End quaternion.</param>"); WriteLine("/// <param name=\"amount\">Value between 0 and 1 indicating the weight of <paramref name=\"end\"/>.</param>"); WriteLine("/// <returns>The spherical linear interpolation of the two quaternions.</returns>"); WriteLine("/// <remarks>"); WriteLine("/// Passing <paramref name=\"amount\"/> a value of 0 will cause <paramref name=\"start\"/> to be returned; a value of 1 will cause <paramref name=\"end\"/> to be returned. "); WriteLine("/// </remarks>"); WriteLine("public static {0} Slerp({0} start, {0} end, {1} amount)", Name, Type); Indent("{"); WriteLine("var cosTheta = Dot(start, end);"); WriteLine("//Cannot use slerp, use lerp instead"); WriteLine("if (Functions.Abs(cosTheta) - 1 < {0}.Epsilon)", Type); Indent("{"); WriteLine("return Lerp(start, end, amount);"); Dedent("}"); WriteLine("var theta = Functions.Acos(cosTheta);"); WriteLine("var sinTheta = Functions.Sin(theta);"); WriteLine("var t0 = Functions.Sin((1 - amount) * theta) / sinTheta;"); WriteLine("var t1 = Functions.Sin(amount * theta) / sinTheta;"); WriteLine("return t0 * start + t1 * end;"); Dedent("}"); WriteLine("#endregion"); #endregion #region Transform WriteLine("#region Transform"); var vector4 = new Vector(Type, 4); WriteLine("public static {0} Transform({0} vector, {1} rotation)", vector4, Name); Indent("{"); WriteLine("var v = rotation * new {0}(vector.X, vector.Y, vector.Z, 0) * Conjugate(rotation);", Name); WriteLine("return new {0}(v.A, v.B, v.C, vector.W);", vector4); Dedent("}"); var vector3 = new Vector(Type, 3); WriteLine("public static {0} Transform({0} vector, {1} rotation)", vector3, Name); Indent("{"); WriteLine("var v = rotation * new {0}(vector.X, vector.Y, vector.Z, 0) * Conjugate(rotation);", Name); WriteLine("return new {0}(v.A, v.B, v.C);", vector3); Dedent("}"); WriteLine("#endregion"); #endregion #region Old //#region Per component //WriteLine("#region Per component"); //WriteLine("#region Transform"); //foreach (var type in Types) //{ // var transform = new Quaternion(type, Dimension); // WriteLine("/// <summary>"); // WriteLine("/// Transforms the components of a quaternion and returns the result."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">The quaternion to transform.</param>"); // WriteLine("/// <param name=\"transformer\">A transform function to apply to each component.</param>"); // WriteLine("/// <returns>The result of transforming each component of value.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Transform({1} value, Func<{2}, {3}> transformer)", transform, Name, Type, transform.Type); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", transform, // string.Join(", ", Components.Select(component => string.Format("transformer(value.{0})", component)))); // Dedent(); // WriteLine("}"); //} //WriteLine("#endregion"); //WriteLine("/// <summary>"); //WriteLine("/// Multiplys the components of two quaternions and returns the result."); //WriteLine("/// </summary>"); //WriteLine("/// <param name=\"left\">The first quaternion to modulate.</param>"); //WriteLine("/// <param name=\"right\">The second quaternion to modulate.</param>"); //WriteLine("/// <returns>The result of multiplying each component of left by the matching component in right.</returns>"); //if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } //WriteLine("public static {0} Modulate({1} left, {1} right)", result, Name); //WriteLine("{"); //Indent(); //WriteLine("return new {0}({1});", result, // string.Join(", ", Components.Select(component => string.Format("left.{0} * right.{0}", component)))); //Dedent(); //WriteLine("}"); //WriteLine("/// <summary>"); //WriteLine("/// Returns the absolute value (per component)."); //WriteLine("/// </summary>"); //WriteLine("/// <param name=\"value\">A quaternion.</param>"); //WriteLine("/// <returns>The absolute value (per component) of value.</returns>"); //if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } //WriteLine("public static {0} Abs({0} value)", Name); //WriteLine("{"); //Indent(); //WriteLine("return new {0}({1});", Name, // string.Join(", ", Components.Select(component => string.Format("Functions.Abs(value.{0})", component)))); //Dedent(); //WriteLine("}"); //WriteLine("/// <summary>"); //WriteLine("/// Returns a quaternion that contains the lowest value from each pair of components."); //WriteLine("/// </summary>"); //WriteLine("/// <param name=\"value1\">The first quaternion.</param>"); //WriteLine("/// <param name=\"value2\">The second quaternion.</param>"); //WriteLine("/// <returns>The lowest of each component in left and the matching component in right.</returns>"); //if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } //WriteLine("public static {0} Min({0} value1, {0} value2)", Name); //WriteLine("{"); //Indent(); //WriteLine("return new {0}({1});", Name, // string.Join(", ", Components.Select(component => string.Format("Functions.Min(value1.{0}, value2.{0})", component)))); //Dedent(); //WriteLine("}"); //WriteLine("/// <summary>"); //WriteLine("/// Returns a quaternion that contains the highest value from each pair of components."); //WriteLine("/// </summary>"); //WriteLine("/// <param name=\"value1\">The first quaternion.</param>"); //WriteLine("/// <param name=\"value2\">The second quaternion.</param>"); //WriteLine("/// <returns>The highest of each component in left and the matching component in right.</returns>"); //if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } //WriteLine("public static {0} Max({0} value1, {0} value2)", Name); //WriteLine("{"); //Indent(); //WriteLine("return new {0}({1});", Name, // string.Join(", ", Components.Select(component => string.Format("Functions.Max(value1.{0}, value2.{0})", component)))); //Dedent(); //WriteLine("}"); //WriteLine("/// <summary>"); //WriteLine("/// Constrains each component to a given range."); //WriteLine("/// </summary>"); //WriteLine("/// <param name=\"value\">A quaternion to constrain.</param>"); //WriteLine("/// <param name=\"min\">The minimum values for each component.</param>"); //WriteLine("/// <param name=\"max\">The maximum values for each component.</param>"); //WriteLine("/// <returns>A quaternion with each component constrained to the given range.</returns>"); //if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } //WriteLine("public static {0} Clamp({0} value, {0} min, {0} max)", Name); //WriteLine("{"); //Indent(); //WriteLine("return new {0}({1});", Name, // string.Join(", ", Components.Select(component => string.Format("Functions.Clamp(value.{0}, min.{0}, max.{0})", component)))); //Dedent(); //WriteLine("}"); //if (Type.IsReal) //{ // WriteLine("/// <summary>"); // WriteLine("/// Constrains each component to the range 0 to 1."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">A quaternion to saturate.</param>"); // WriteLine("/// <returns>A quaternion with each component constrained to the range 0 to 1.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Saturate({0} value)", Name); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", Name, // string.Join(", ", Components.Select(component => string.Format("Functions.Saturate(value.{0})", component)))); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Returns a quaternion where each component is the smallest integral value that"); // WriteLine("/// is greater than or equal to the specified component."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">A quaternion.</param>"); // WriteLine("/// <returns>The ceiling of value.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Ceiling({1} value)", result, Name); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", result, // string.Join(", ", Components.Select(component => string.Format("Functions.Ceiling(value.{0})", component)))); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Returns a quaternion where each component is the largest integral value that"); // WriteLine("/// is less than or equal to the specified component."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">A quaternion.</param>"); // WriteLine("/// <returns>The floor of value.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Floor({1} value)", result, Name); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", result, // string.Join(", ", Components.Select(component => string.Format("Functions.Floor(value.{0})", component)))); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Returns a quaternion where each component is the integral part of the specified component."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">A quaternion.</param>"); // WriteLine("/// <returns>The integral of value.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Truncate({1} value)", result, Name); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", result, // string.Join(", ", Components.Select(component => string.Format("Functions.Truncate(value.{0})", component)))); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Returns a quaternion where each component is the fractional part of the specified component."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">A quaternion.</param>"); // WriteLine("/// <returns>The fractional of value.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Fractional({1} value)", result, Name); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", result, // string.Join(", ", Components.Select(component => string.Format("Functions.Fractional(value.{0})", component)))); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Returns a quaternion where each component is rounded to the nearest integral value."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">A quaternion.</param>"); // WriteLine("/// <returns>The result of rounding value.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Round({1} value)", result, Name); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", result, // string.Join(", ", Components.Select(component => string.Format("Functions.Round(value.{0})", component)))); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Returns a quaternion where each component is rounded to the nearest integral value."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">A quaternion.</param>"); // WriteLine("/// <param name=\"digits\">The number of fractional digits in the return value.</param>"); // WriteLine("/// <returns>The result of rounding value.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Round({1} value, int digits)", result, Name); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", result, // string.Join(", ", Components.Select(component => string.Format("Functions.Round(value.{0}, digits)", component)))); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Returns a quaternion where each component is rounded to the nearest integral value."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">A quaternion.</param>"); // WriteLine("/// <param name=\"mode\">Specification for how to round value if it is midway between two other numbers.</param>"); // WriteLine("/// <returns>The result of rounding value.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Round({1} value, MidpointRounding mode)", result, Name); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", result, // string.Join(", ", Components.Select(component => string.Format("Functions.Round(value.{0}, mode)", component)))); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Returns a quaternion where each component is rounded to the nearest integral value."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">A quaternion.</param>"); // WriteLine("/// <param name=\"digits\">The number of fractional digits in the return value.</param>"); // WriteLine("/// <param name=\"mode\">Specification for how to round value if it is midway between two other numbers.</param>"); // WriteLine("/// <returns>The result of rounding value.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Round({1} value, int digits, MidpointRounding mode)", result, Name); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", result, // string.Join(", ", Components.Select(component => string.Format("Functions.Round(value.{0}, digits, mode)", component)))); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Calculates the reciprocal of each component in the quaternion."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value\">A quaternion.</param>"); // WriteLine("/// <returns>A quaternion with the reciprocal of each of values components.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Reciprocal({1} value)", result, Name); // WriteLine("{"); // Indent(); // WriteLine("return new {0}({1});", result, // string.Join(", ", Components.Select(component => string.Format("1 / value.{0}", component)))); // Dedent(); // WriteLine("}"); //} //WriteLine("#endregion"); //#endregion //#region Barycentric, Reflect, Refract //if (Type.IsReal) //{ // WriteLine("#region Barycentric, Reflect, Refract"); // WriteLine("/// <summary>"); // WriteLine("/// Returns the Cartesian coordinate for one axis of a point that is defined"); // WriteLine("/// by a given triangle and two normalized barycentric (areal) coordinates."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value1\">The coordinate of vertex 1 of the defining triangle.</param>"); // WriteLine("/// <param name=\"value2\">The coordinate of vertex 2 of the defining triangle.</param>"); // WriteLine("/// <param name=\"value3\">The coordinate of vertex 3 of the defining triangle.</param>"); // WriteLine("/// <param name=\"amount1\">The normalized barycentric (areal) coordinate b2, equal to the weighting"); // WriteLine("/// factor for vertex 2, the coordinate of which is specified in value2.</param>"); // WriteLine("/// <param name=\"amount2\">The normalized barycentric (areal) coordinate b3, equal to the weighting"); // WriteLine("/// factor for vertex 3, the coordinate of which is specified in value3.</param>"); // WriteLine("/// <returns>Cartesian coordinate of the specified point.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Barycentric({1} value1, {1} value2, {1} value3, {2} amount1, {2} amount2)", result, Name, result.Type); // WriteLine("{"); // Indent(); // WriteLine("return ((1 - amount1 - amount2) * value1) + (amount1 * value2) + (amount2 * value3);"); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Returns the reflection of a quaternion off a surface that has the specified normal."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"quaternion\">The source quaternion.</param>"); // WriteLine("/// <param name=\"normal\">Normal of the surface.</param>"); // WriteLine("/// <returns>The reflected quaternion.</returns>"); // WriteLine("/// <remarks>Reflect only gives the direction of a reflection off a surface, it does not determine"); // WriteLine("/// whether the original quaternion was close enough to the surface to hit it.</remarks>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Reflect({1} quaternion, {1} normal)", result, Name); // WriteLine("{"); // Indent(); // WriteLine("return quaternion - ((2 * Dot(quaternion, normal)) * normal);"); // Dedent(); // WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Returns the refraction of a quaternion off a surface that has the specified normal, and refractive index."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"quaternion\">The source quaternion.</param>"); // WriteLine("/// <param name=\"normal\">Normal of the surface.</param>"); // WriteLine("/// <param name=\"index\">The refractive index, destination index over source index.</param>"); // WriteLine("/// <returns>The refracted quaternion.</returns>"); // WriteLine("/// <remarks>Refract only gives the direction of a refraction off a surface, it does not determine"); // WriteLine("/// whether the original quaternion was close enough to the surface to hit it.</remarks>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Refract({1} quaternion, {1} normal, {2} index)", result, Name, result.Type); // WriteLine("{"); // Indent(); // WriteLine("var cos1 = Dot(quaternion, normal);"); // WriteLine("var radicand = 1 - (index * index) * (1 - (cos1 * cos1));"); // WriteLine("if (radicand < 0)"); // WriteLine("{"); // Indent(); // WriteLine("return {0}.Zero;", result); // Dedent(); // WriteLine("}"); // WriteLine("return (index * quaternion) + ((Functions.Sqrt(radicand) - index * cos1) * normal);"); // Dedent(); // WriteLine("}"); // WriteLine("#endregion"); //} //#endregion //#region Interpolation //if (Type.IsReal) //{ // WriteLine("#region Interpolation"); // //WriteLine("/// <summary>"); // //WriteLine("/// Performs a Hermite spline interpolation."); // //WriteLine("/// </summary>"); // //WriteLine("/// <param name=\"value1\">First source position.</param>"); // //WriteLine("/// <param name=\"tangent1\">First source tangent.</param>"); // //WriteLine("/// <param name=\"value2\">Second source position.</param>"); // //WriteLine("/// <param name=\"tangent2\">Second source tangent.</param>"); // //WriteLine("/// <param name=\"amount\">Weighting factor.</param>"); // //WriteLine("/// <returns>The result of the Hermite spline interpolation.</returns>"); // //if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // //WriteLine("public static {0} Hermite({1} value1, {1} tangent1, {1} value2, {1} tangent2, {2} amount)", result, Name, result.Type); // //WriteLine("{"); // //Indent(); // //WriteLine("var amount2 = amount * amount;"); // //WriteLine("var amount3 = amount2 * amount;"); // //WriteLine("var h00 = 2 * amount3 - 3 * amount2 + 1;"); // //WriteLine("var h10 = amount3 - 2 * amount2 + amount;"); // //WriteLine("var h01 = -2 * amount3 + 3 * amount2;"); // //WriteLine("var h11 = amount3 - amount2;"); // //WriteLine("return h00 * value1 + h10 * tangent1 + h01 * value2 + h11 * tangent2;"); // //Dedent(); // //WriteLine("}"); // //WriteLine("/// <summary>"); // //WriteLine("/// Performs a Catmull-Rom interpolation using the specified positions."); // //WriteLine("/// </summary>"); // //WriteLine("/// <param name=\"value1\">The first position in the interpolation.</param>"); // //WriteLine("/// <param name=\"value2\">The second position in the interpolation.</param>"); // //WriteLine("/// <param name=\"value3\">The third position in the interpolation.</param>"); // //WriteLine("/// <param name=\"value4\">The fourth position in the interpolation.</param>"); // //WriteLine("/// <param name=\"amount\">Weighting factor.</param>"); // //WriteLine("/// <returns>A quaternion that is the result of the Catmull-Rom interpolation.</returns>"); // //if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // //WriteLine("public static {0} CatmullRom({1} value1, {1} value2, {1} value3, {1} value4, {2} amount)", result, Name, result.Type); // //WriteLine("{"); // //Indent(); // //WriteLine("var tangent0 = (value3 - value1) / 2;"); // //WriteLine("var tangent1 = (value4 - value2) / 2;"); // //WriteLine("return Hermite(value2, tangent0, value3, tangent1, amount);"); // //Dedent(); // //WriteLine("}"); // //WriteLine("/// <summary>"); // //WriteLine("/// Performs a cubic interpolation between two values."); // //WriteLine("/// </summary>"); // //WriteLine("/// <param name=\"value1\">First values.</param>"); // //WriteLine("/// <param name=\"value2\">Second values.</param>"); // //WriteLine("/// <param name=\"amount\">Value between 0 and 1 indicating the weight of <paramref name=\"value2\"/>.</param>"); // //WriteLine("/// <returns>The cubic interpolation of the two quaternions.</returns>"); // //if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // //WriteLine("public static {0} SmoothStep({1} value1, {1} value2, {2} amount)", result, Name, result.Type); // //WriteLine("{"); // //Indent(); // //WriteLine("amount = Functions.Saturate(amount);"); // //WriteLine("amount = amount * amount * (3 - 2 * amount);"); // //WriteLine("return Lerp(value1, value2, amount);"); // //Dedent(); // //WriteLine("}"); // WriteLine("/// <summary>"); // WriteLine("/// Performs a linear interpolation between two values."); // WriteLine("/// </summary>"); // WriteLine("/// <param name=\"value1\">First value.</param>"); // WriteLine("/// <param name=\"value2\">Second value.</param>"); // WriteLine("/// <param name=\"amount\">Value between 0 and 1 indicating the weight of <paramref name=\"value2\"/>.</param>"); // WriteLine("/// <returns>The linear interpolation of the two values.</returns>"); // if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // WriteLine("public static {0} Lerp({1} value1, {1} value2, {2} amount)", result, Name, result.Type); // WriteLine("{"); // Indent(); // WriteLine("return (1 - amount) * value1 + amount * value2;"); // Dedent(); // WriteLine("}"); // //WriteLine("/// <summary>"); // //WriteLine("/// Performs a quadratic interpolation between three values."); // //WriteLine("/// </summary>"); // //WriteLine("/// <param name=\"value1\">First value.</param>"); // //WriteLine("/// <param name=\"value2\">Second value.</param>"); // //WriteLine("/// <param name=\"value3\">Third value.</param>"); // //WriteLine("/// <param name=\"amount\">Value between 0 and 1 indicating the weight towards <paramref name=\"value3\"/>.</param>"); // //WriteLine("/// <returns>The quadratic interpolation of the three values.</returns>"); // //if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // //WriteLine("public static {0} Qerp({1} value1, {1} value2, {1} value3, {2} amount)", result, Name, result.Type); // //WriteLine("{"); // //Indent(); // //WriteLine("var p = 2 * value1 - value2 + 2 * value3;"); // //WriteLine("var q = value2 - value3 - 3 * value1;"); // //WriteLine("var r = value1;"); // //WriteLine("var amount2 = amount * amount;"); // //WriteLine("return (p * amount * amount2) + (q * amount) + (r);"); // //Dedent(); // //WriteLine("}"); // //WriteLine("/// <summary>"); // //WriteLine("/// Performs a cubic interpolation between four values."); // //WriteLine("/// </summary>"); // //WriteLine("/// <param name=\"value1\">First value.</param>"); // //WriteLine("/// <param name=\"value2\">Second value.</param>"); // //WriteLine("/// <param name=\"value3\">Third value.</param>"); // //WriteLine("/// <param name=\"value4\">Fourth value.</param>"); // //WriteLine("/// <param name=\"amount\">Value between 0 and 1 indicating the weight towards <paramref name=\"value4\"/>.</param>"); // //WriteLine("/// <returns>The cubic interpolation of the four values.</returns>"); // //if (!Type.IsCLSCompliant) { WriteLine("[CLSCompliant(false)]"); } // //WriteLine("public static {0} Cerp({1} value1, {1} value2, {1} value3, {1} value4, {2} amount)", result, Name, result.Type); // //WriteLine("{"); // //Indent(); // //WriteLine("var p = (value4 - value3) - (value1 - value2);"); // //WriteLine("var q = (value1 - value2) - p;"); // //WriteLine("var r = value3 - value1;"); // //WriteLine("var s = value2;"); // //WriteLine("var amount2 = amount * amount;"); // //WriteLine("return (p * amount * amount2) + (q * amount2) + (r * amount) + (s);"); // //Dedent(); // //WriteLine("}"); // WriteLine("#endregion"); //} //#endregion #endregion Dedent(); WriteLine("}"); }
void Operations() { var result = new Quaternion(Type.PositiveType); WriteLine("#region Operations"); WriteLine("/// <summary>"); WriteLine("/// Returns the identity of a specified quaternion."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The identity of value.</returns>"); WriteLine("public static {0} operator +({1} value)", result, Name); WriteLine("{"); Indent(); WriteLine("return value;"); Dedent(); WriteLine("}"); if (Type.NegativeType != NumberType.Invalid) { var negQuaternion = new Quaternion(Type.NegativeType); WriteLine("/// <summary>"); WriteLine("/// Returns the additive inverse of a specified quaternion."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"value\">A quaternion.</param>"); WriteLine("/// <returns>The negative of value.</returns>"); WriteLine("public static {0} operator -({1} value)", negQuaternion, Name); WriteLine("{"); Indent(); WriteLine("return Quaternion.Negative(value);"); Dedent(); WriteLine("}"); } WriteLine("/// <summary>"); WriteLine("/// Adds two quaternions and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"left\">The first value to add.</param>"); WriteLine("/// <param name=\"right\">The second value to add.</param>"); WriteLine("/// <returns>The sum of left and right.</returns>"); WriteLine("public static {0} operator +({1} left, {1} right)", result, Name); WriteLine("{"); Indent(); WriteLine("return Quaternion.Add(left, right);"); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Subtracts one quaternion from another and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"left\">The value to subtract from (the minuend).</param>"); WriteLine("/// <param name=\"right\">The value to subtract (the subtrahend).</param>"); WriteLine("/// <returns>The result of subtracting right from left (the difference).</returns>"); WriteLine("public static {0} operator -({1} left, {1} right)", result, Name); WriteLine("{"); Indent(); WriteLine("return Quaternion.Subtract(left, right);"); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Multiplies one quaternion by another and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"left\">The first value to add.</param>"); WriteLine("/// <param name=\"right\">The second value to add.</param>"); WriteLine("/// <returns>The product of the left and right parameters.</returns>"); WriteLine("public static {0} operator *({1} left, {1} right)", result, Name); WriteLine("{"); Indent(); WriteLine("return Quaternion.Multiply(left, right);"); Dedent(); WriteLine("}"); WriteLine("/// <summary>"); WriteLine("/// Divides one quaternion by another and returns the result."); WriteLine("/// </summary>"); WriteLine("/// <param name=\"left\">The quaternion to be divided (the dividend).</param>"); WriteLine("/// <param name=\"right\">The quaternion to divide by (the divisor).</param>"); WriteLine("/// <returns>The result of dividing left by right (the quotient).</returns>"); WriteLine("public static {0} operator /({1} left, {1} right)", result, Name); WriteLine("{"); Indent(); WriteLine("return Quaternion.Divide(left, right);"); Dedent(); WriteLine("}"); WriteLine("#endregion"); }