public List<OwnVector3> createCornerSegment(OwnVector3 centerPoint, OwnVector3 previousPoint, OwnVector3 nextPoint)
{
OwnVector3 direction = centerPoint - previousPoint;
OwnVector3 norDirection = direction / direction.Length();
OwnVector3 direction2 = centerPoint - nextPoint;
OwnVector3 norDirection2 = direction2 / direction2.Length();
OwnVector3 startPoint = OwnVector3.Lerp(centerPoint, previousPoint, 0.5f);
OwnVector3 endPoint = OwnVector3.Lerp(centerPoint, nextPoint, 0.5f);
List<OwnVector3> ret = new List<OwnVector3>();
OwnVector2 vector1 = new OwnVector2(previousPoint.X, previousPoint.Y) - new OwnVector2(centerPoint.X, centerPoint.Y);
OwnVector2 vector2 = new OwnVector2(nextPoint.X, nextPoint.Y) - new OwnVector2(centerPoint.X, centerPoint.Y);
float angle = MathHelper.ToDegrees((float)MathUtils.VectorAngle(ref vector1, ref vector2));
if (105 < angle || angle < -150)
{
OwnVector3 p1 = DrawTools.MoveForward(startPoint, DrawTools.TurnLeft(90, norDirection), distance);
OwnVector3 p2 = DrawTools.MoveForward(endPoint, DrawTools.TurnRight(90, norDirection2), distance);
OwnVector3 temp = OwnVector3.Lerp(p1, p2, 0.5f);
OwnVector3 tempDirection = temp - p1;
OwnVector3 tempNorDirection = tempDirection / tempDirection.Length();
OwnVector3 p3 = DrawTools.MoveForward(temp, DrawTools.TurnRight(90, tempNorDirection), distance * 2);
ret.Add(p1);
ret.Add(p3);
ret.Add(p3);
ret.Add(p2);
}
else if (angle < 0)
{
OwnVector3 p1, p2, p3, p4;
p1 = DrawTools.MoveForward(startPoint, DrawTools.TurnLeft(90, norDirection), distance);
p2 = DrawTools.MoveForward(centerPoint, DrawTools.TurnRight(90, norDirection), distance);
p3 = DrawTools.MoveForward(centerPoint, DrawTools.TurnLeft(90, norDirection2), distance);
p4 = DrawTools.MoveForward(endPoint, DrawTools.TurnRight(90, norDirection2), distance);
ret.Add(p1);
ret.Add(p2);
ret.Add(p2);
ret.Add(p3);
ret.Add(p3);
ret.Add(p4);
}
else
{
OwnVector3 p1, p2;
p1 = DrawTools.MoveForward(startPoint, DrawTools.TurnLeft(90, norDirection), distance);
p2 = DrawTools.MoveForward(endPoint, DrawTools.TurnRight(90, norDirection2), distance);
ret.Add(p1);
ret.Add(p2);
}
return ret;
}
public static float DistanceBetweenPointAndLineSegment(ref OwnVector2 point, ref OwnVector2 start, ref OwnVector2 end)
{
if (start == end)
return OwnVector2.Distance(point, start);
OwnVector2 v = OwnVector2.Subtract(end, start);
OwnVector2 w = OwnVector2.Subtract(point, start);
float c1 = OwnVector2.Dot(w, v);
if (c1 <= 0) return OwnVector2.Distance(point, start);
float c2 = OwnVector2.Dot(v, v);
if (c2 <= c1) return OwnVector2.Distance(point, end);
float b = c1 / c2;
OwnVector2 pointOnLine = OwnVector2.Add(start, OwnVector2.Multiply(v, b));
return OwnVector2.Distance(point, pointOnLine);
}
//
// Summary:
// Multiplies the components of two vectors by each other.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Source vector.
//
// result:
// [OutAttribute] The result of the multiplication.
public static void Multiply(ref OwnVector2 value1, ref OwnVector2 value2, out OwnVector2 result)
{
result = new OwnVector2(Vector2.Multiply(value1.vector, value2.vector));
}
//
// Summary:
// Calculates the distance between two vectors squared.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Source vector.
//
// result:
// [OutAttribute] The distance between the vectors squared.
public static void DistanceSquared(ref OwnVector2 value1, ref OwnVector2 value2, out float result)
{
result = Vector2.DistanceSquared(value1.vector, value2.vector);
}
//
// Summary:
// Multiplies a vector by a scalar value.
//
// Parameters:
// value1:
// Source vector.
//
// scaleFactor:
// Scalar value.
//
// result:
// [OutAttribute] The result of the multiplication.
public static void Multiply(ref OwnVector2 value1, float scaleFactor, out OwnVector2 result)
{
result = new OwnVector2(Vector2.Multiply(value1.vector, scaleFactor));
}
//
// Summary:
// Interpolates between two values using a cubic equation.
//
// Parameters:
// value1:
// Source value.
//
// value2:
// Source value.
//
// amount:
// Weighting value.
//
// result:
// [OutAttribute] The interpolated value.
public static void SmoothStep(ref OwnVector2 value1, ref OwnVector2 value2, float amount, out OwnVector2 result)
{
result = new OwnVector2(Vector2.SmoothStep(value1.vector, value2.vector, amount));
}
//
// Summary:
// Subtracts a vector from a vector.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Source vector.
//
// result:
// [OutAttribute] The result of the subtraction.
public static void Subtract(ref OwnVector2 value1, ref OwnVector2 value2, out OwnVector2 result)
{
result = new OwnVector2(Vector2.Subtract(value1.vector, value2.vector));
}
//
// Summary:
// Creates a unit vector from the specified vector, writing the result to a
// user-specified variable. The result is a vector one unit in length pointing
// in the same direction as the original vector.
//
// Parameters:
// value:
// Source vector.
//
// result:
// [OutAttribute] Normalized vector.
public static void Normalize(ref OwnVector2 value, out OwnVector2 result)
{
result = new OwnVector2(Vector2.Normalize(value.vector));
}
//
// Summary:
// Determines the reflect vector of the given vector and normal.
//
// Parameters:
// vector:
// Source vector.
//
// normal:
// Normal of vector.
//
// result:
// [OutAttribute] The created reflect vector.
public static void Reflect(ref OwnVector2 vector, ref OwnVector2 normal, out OwnVector2 result)
{
result = new OwnVector2(Vector2.Reflect(vector.vector, normal.vector));
}
//
// Summary:
// Calculates the dot product of two vectors and writes the result to a user-specified
// variable. If the two vectors are unit vectors, the dot product returns a
// floating point value between -1 and 1 that can be used to determine some
// properties of the angle between two vectors. For example, it can show whether
// the vectors are orthogonal, parallel, or have an acute or obtuse angle between
// them.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Source vector.
//
// result:
// [OutAttribute] The dot product of the two vectors.
public static void Dot(ref OwnVector2 value1, ref OwnVector2 value2, out float result)
{
result = Vector2.Dot(value1.vector, value2.vector);
}
//
// Summary:
// Performs a Hermite spline interpolation.
//
// Parameters:
// value1:
// Source position vector.
//
// tangent1:
// Source tangent vector.
//
// value2:
// Source position vector.
//
// tangent2:
// Source tangent vector.
//
// amount:
// Weighting factor.
public static OwnVector2 Hermite(OwnVector2 value1, OwnVector2 tangent1, OwnVector2 value2, OwnVector2 tangent2, float amount)
{
return new OwnVector2(Vector2.Hermite(value1.vector, tangent1.vector, value2.vector, tangent2.vector, amount));
}
//
// Summary:
// Divides the components of a vector by the components of another vector.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// The divisor.
//
// result:
// [OutAttribute] The result of the division.
public static void Divide(ref OwnVector2 value1, ref OwnVector2 value2, out OwnVector2 result)
{
result = new OwnVector2(Vector2.Divide(value1.vector, value2.vector));
}
//
// Summary:
// Calculates the dot product of two vectors. If the two vectors are unit vectors,
// the dot product returns a floating point value between -1 and 1 that can
// be used to determine some properties of the angle between two vectors. For
// example, it can show whether the vectors are orthogonal, parallel, or have
// an acute or obtuse angle between them.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Source vector.
public static float Dot(OwnVector2 value1, OwnVector2 value2)
{
return Vector2.Dot(value1.vector, value2.vector);
}
//
// Summary:
// Divides a vector by a scalar value.
//
// Parameters:
// value1:
// Source vector.
//
// divider:
// The divisor.
//
// result:
// [OutAttribute] The result of the division.
public static void Divide(ref OwnVector2 value1, float divider, out OwnVector2 result)
{
result = new OwnVector2(Vector2.Divide(value1.vector, divider));
}
//
// Summary:
// Divides the components of a vector by the components of another vector.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Divisor vector.
public static OwnVector2 Divide(OwnVector2 value1, OwnVector2 value2)
{
return new OwnVector2(Vector2.Divide(value1.vector, value2.vector));
}
//
// Summary:
// Divides a vector by a scalar value.
//
// Parameters:
// value1:
// Source vector.
//
// divider:
// The divisor.
public static OwnVector2 Divide(OwnVector2 value1, float divider)
{
return new OwnVector2(Vector2.Divide(value1.vector, divider));
}
//
// Summary:
// Returns a vector pointing in the opposite direction.
//
// Parameters:
// value:
// Source vector.
public static OwnVector2 Negate(OwnVector2 value)
{
return new OwnVector2(Vector2.Negate(value.vector));
}
//
// Summary:
// Performs a Hermite spline interpolation.
//
// Parameters:
// value1:
// Source position vector.
//
// tangent1:
// Source tangent vector.
//
// value2:
// Source position vector.
//
// tangent2:
// Source tangent vector.
//
// amount:
// Weighting factor.
//
// result:
// [OutAttribute] The result of the Hermite spline interpolation.
public static void Hermite(ref OwnVector2 value1, ref OwnVector2 tangent1, ref OwnVector2 value2, ref OwnVector2 tangent2, float amount, out OwnVector2 result)
{
result = new OwnVector2(Vector2.Hermite(value1.vector, tangent1.vector, value2.vector, tangent2.vector, amount));
}
//
// Summary:
// Creates a unit vector from the specified vector. The result is a vector one
// unit in length pointing in the same direction as the original vector.
//
// Parameters:
// value:
// Source Vector2.
public static OwnVector2 Normalize(OwnVector2 value)
{
return new OwnVector2(Vector2.Normalize(value.vector));
}
//
// Summary:
// Performs a linear interpolation between two vectors.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Source vector.
//
// amount:
// Value between 0 and 1 indicating the weight of value2.
public static OwnVector2 Lerp(OwnVector2 value1, OwnVector2 value2, float amount)
{
return new OwnVector2(Vector2.Lerp(value1.vector, value2.vector, amount));
}
//
// Summary:
// Determines the reflect vector of the given vector and normal.
//
// Parameters:
// vector:
// Source vector.
//
// normal:
// Normal of vector.
public static OwnVector2 Reflect(OwnVector2 vector, OwnVector2 normal)
{
return new OwnVector2(Vector2.Reflect(vector.vector, normal.vector));
}
//
// Summary:
// Returns a vector that contains the lowest value from each matching pair of
// components.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Source vector.
public static OwnVector2 Min(OwnVector2 value1, OwnVector2 value2)
{
return new OwnVector2(Vector2.Min(value1.vector, value2.vector));
}
//
// Summary:
// Interpolates between two values using a cubic equation.
//
// Parameters:
// value1:
// Source value.
//
// value2:
// Source value.
//
// amount:
// Weighting value.
public static OwnVector2 SmoothStep(OwnVector2 value1, OwnVector2 value2, float amount)
{
return new OwnVector2(Vector2.SmoothStep(value1.vector, value2.vector, amount));
}
public static bool PointInTriangle(OwnVector2 A, OwnVector2 B, OwnVector2 C, OwnVector2 P)
{
// Compute vectors
OwnVector2 v0 = C - A;
OwnVector2 v1 = B - A;
OwnVector2 v2 = P - A;
// Compute dot products
float dot00 = OwnVector2.Dot(v0, v0);
float dot01 = OwnVector2.Dot(v0, v1);
float dot02 = OwnVector2.Dot(v0, v2);
float dot11 = OwnVector2.Dot(v1, v1);
float dot12 = OwnVector2.Dot(v1, v2);
// Compute barycentric coordinates
float invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
float u = (dot11 * dot02 - dot01 * dot12) * invDenom;
float v = (dot00 * dot12 - dot01 * dot02) * invDenom;
// Check if point is in triangle
return (u >= 0) && (v >= 0) && (u + v < 1);
}
//
// Summary:
// Subtracts a vector from a vector.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Source vector.
public static OwnVector2 Subtract(OwnVector2 value1, OwnVector2 value2)
{
return new OwnVector2(Vector2.Subtract(value1.vector, value2.vector));
}
//
// Summary:
// Restricts a value to be within a specified range.
//
// Parameters:
// value1:
// The value to clamp.
//
// min:
// The minimum value.
//
// max:
// The maximum value.
//
// result:
// [OutAttribute] The clamped value.
public static void Clamp(ref OwnVector2 value1, ref OwnVector2 min, ref OwnVector2 max, out OwnVector2 result)
{
result = new OwnVector2(Vector2.Clamp(value1.vector, min.vector, max.vector));
}
//
// Summary:
// Multiplies a vector by a scalar value.
//
// Parameters:
// value1:
// Source vector.
//
// scaleFactor:
// Scalar value.
public static OwnVector2 Multiply(OwnVector2 value1, float scaleFactor)
{
return new OwnVector2(Vector2.Multiply(value1.vector, scaleFactor));
}
//
// Summary:
// Calculates the distance between two vectors squared.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Source vector.
public static float DistanceSquared(OwnVector2 value1, OwnVector2 value2)
{
return Vector2.DistanceSquared(value1.vector, value2.vector);
}
private List<OwnVector3> createCorner2(OwnVector3 centerPoint, OwnVector3 previousPoint, OwnVector3 nextPoint)
{
OwnVector2 vector1 = new OwnVector2(previousPoint.X, previousPoint.Y) - new OwnVector2(centerPoint.X, centerPoint.Y);
OwnVector2 vector2 = new OwnVector2(nextPoint.X, nextPoint.Y) - new OwnVector2(centerPoint.X, centerPoint.Y);
float angle = (float)MathUtils.VectorAngle(ref vector1, ref vector2);
List<OwnVector3> ret = new List<OwnVector3>();
OwnVector3 direction = centerPoint - previousPoint;
OwnVector3 norDirection = direction / direction.Length();
OwnVector3 direction2 = centerPoint - nextPoint;
OwnVector3 norDirection2 = direction2 / direction2.Length();
OwnVector3 startPoint = OwnVector3.Lerp(centerPoint, previousPoint, 0.5f);
OwnVector3 endPoint = OwnVector3.Lerp(centerPoint, nextPoint, 0.5f);
OwnVector3 upper1, upper2, upper3, lower1, lower2, intersectionPoint, intersectionPoint2;
if (angle > 0)
{
upper2 = DrawTools.MoveForward(startPoint, DrawTools.TurnLeft(90, norDirection), distance * 2);
upper3 = DrawTools.MoveForward(endPoint, DrawTools.TurnRight(90, norDirection2), distance * 2);
intersectionPoint = new OwnVector3(LineTools.LineIntersect(
new Point2D(upper2.X, upper2.Y),
new Point2D(upper2.X + norDirection.X, upper2.Y + norDirection.Y),
new Point2D(upper3.X, upper3.Y),
new Point2D(upper3.X + norDirection2.X, upper3.Y + norDirection2.Y)), 0);
if (OwnVector3.Distance(centerPoint, intersectionPoint) > distance * 3)
{
upper1 = DrawTools.MoveForward(centerPoint, DrawTools.TurnLeft(MathHelper.ToDegrees(angle / 2), norDirection), distance * 3);
}
else
{
upper1 = intersectionPoint;
}
lower1 = DrawTools.MoveBackward(startPoint, DrawTools.TurnLeft(90, norDirection), distance * 2);
lower2 = DrawTools.MoveBackward(endPoint, DrawTools.TurnRight(90, norDirection2), distance * 2);
intersectionPoint2 = new OwnVector3(LineTools.LineIntersect(
new Point2D(lower1.X, lower1.Y),
new Point2D(lower1.X + norDirection.X, lower1.Y + norDirection.Y),
new Point2D(lower2.X, lower2.Y),
new Point2D(lower2.X + norDirection2.X, lower2.Y + norDirection2.Y)), 0);
}
else
{
upper1 =
upper2 = DrawTools.MoveForward(startPoint, DrawTools.TurnRight(90, norDirection), distance * 2);
upper3 = DrawTools.MoveForward(endPoint, DrawTools.TurnLeft(90, norDirection2), distance * 2);
intersectionPoint = new OwnVector3(LineTools.LineIntersect(
new Point2D(upper2.X, upper2.Y),
new Point2D(upper2.X + norDirection.X, upper2.Y + norDirection.Y),
new Point2D(upper3.X, upper3.Y),
new Point2D(upper3.X + norDirection2.X, upper3.Y + norDirection2.Y)), 0);
if (OwnVector3.Distance(centerPoint, intersectionPoint) > distance * 3)
{
upper1 = DrawTools.MoveForward(centerPoint, DrawTools.TurnLeft(MathHelper.ToDegrees(angle / 2), norDirection), distance * 3);
}
else
{
upper1 = intersectionPoint;
}
lower1 = DrawTools.MoveBackward(startPoint, DrawTools.TurnRight(90, norDirection), distance * 2);
lower2 = DrawTools.MoveBackward(endPoint, DrawTools.TurnLeft(90, norDirection2), distance * 2);
intersectionPoint2 = new OwnVector3(LineTools.LineIntersect(
new Point2D(lower1.X, lower1.Y),
new Point2D(lower1.X + norDirection.X, lower1.Y + norDirection.Y),
new Point2D(lower2.X, lower2.Y),
new Point2D(lower2.X + norDirection2.X, lower2.Y + norDirection2.Y)), 0);
}
ret.Add(upper2);
ret.Add(upper1);
ret.Add(upper1);
ret.Add(upper3);
bool testValue = (OwnVector3.Distance(intersectionPoint2, centerPoint) <= Math.Sqrt(Math.Pow(distance * 2, 2) + Math.Pow(OwnVector3.Distance(startPoint, centerPoint), 2)));
if (testValue)
{
ret.Add(lower1);
ret.Add(intersectionPoint2);
ret.Add(intersectionPoint2);
ret.Add(lower2);
}
OwnVector3 start2 = OwnVector3.Lerp(startPoint, centerPoint, 0.5f);
OwnVector3 end2 = OwnVector3.Lerp(endPoint, centerPoint, 0.5f);
OwnVector3 p1, p2, p3, p4, p5, p6;
if (angle > 0)
{
p3 = DrawTools.MoveForward(centerPoint, DrawTools.TurnLeft(MathHelper.ToDegrees(angle / 2), norDirection), OwnVector3.Distance(centerPoint, upper1) / 2);
p6 = DrawTools.MoveBackward(centerPoint, DrawTools.TurnLeft(MathHelper.ToDegrees(angle / 2), norDirection), OwnVector3.Distance(centerPoint, intersectionPoint2) / 2);
}
else
{
p3 = DrawTools.MoveBackward(centerPoint, DrawTools.TurnLeft(MathHelper.ToDegrees(angle / 2), norDirection), OwnVector3.Distance(centerPoint, intersectionPoint2) / 2);
p6 = DrawTools.MoveForward(centerPoint, DrawTools.TurnLeft(MathHelper.ToDegrees(angle / 2), norDirection), OwnVector3.Distance(centerPoint, upper1) / 2);
}
if (testValue)
{
p1 = DrawTools.MoveForward(start2, DrawTools.TurnLeft(90, norDirection), distance);
p2 = DrawTools.MoveForward(start2, DrawTools.TurnRight(90, norDirection), distance);
ret.Add(p1);
ret.Add(p2);
ret.Add(previousPoint - (startPoint - previousPoint));
ret.Add(OwnVector3.Lerp(p1,p2, 0.5f));
p4 = DrawTools.MoveForward(end2, DrawTools.TurnLeft(90, norDirection2), distance);
p5 = DrawTools.MoveForward(end2, DrawTools.TurnRight(90, norDirection2), distance);
ret.Add(p4);
ret.Add(p5);
ret.Add(nextPoint + (nextPoint - endPoint));
ret.Add(OwnVector3.Lerp(p4, p5, 0.5f));
ret.Add(p1);
ret.Add(p3);
ret.Add(p3);
ret.Add(p5);
ret.Add(p2);
ret.Add(p6);
ret.Add(p6);
ret.Add(p4);
ret.Add(DrawTools.MoveBackward(upper2, norDirection, OwnVector3.Distance(previousPoint, startPoint) * 2));
ret.Add(upper2);
ret.Add(DrawTools.MoveBackward(lower1, norDirection, OwnVector3.Distance(previousPoint, startPoint) * 2));
ret.Add(lower1);
ret.Add(DrawTools.MoveBackward(upper3, norDirection2, OwnVector3.Distance(endPoint, nextPoint) * 2));
ret.Add(upper3);
ret.Add(DrawTools.MoveBackward(lower2, norDirection2, OwnVector3.Distance(endPoint, nextPoint) * 2));
ret.Add(lower2);
}
else
{
ret.Add(DrawTools.MoveBackward(upper2, norDirection, OwnVector3.Distance(previousPoint, startPoint) * 2));
ret.Add(upper2);
ret.Add(DrawTools.MoveBackward(lower1, norDirection, OwnVector3.Distance(previousPoint, startPoint) * 2));
ret.Add(intersectionPoint2);
ret.Add(DrawTools.MoveBackward(upper3, norDirection2, OwnVector3.Distance(endPoint, nextPoint) * 2));
ret.Add(upper3);
ret.Add(DrawTools.MoveBackward(lower2, norDirection2, OwnVector3.Distance(endPoint, nextPoint) * 2));
ret.Add(intersectionPoint2);
if (angle > 0)
{
p1 = DrawTools.MoveForward(start2, DrawTools.TurnLeft(90, norDirection), distance);
p2 = DrawTools.MoveForward(end2, DrawTools.TurnRight(90, norDirection2), distance);
OwnVector2 intersect = LineTools.LineIntersect(new Point2D(p1.X, p1.Y), new Point2D(p6.X, p6.Y), new Point2D(startPoint.X, startPoint.Y), new Point2D(centerPoint.X, centerPoint.Y));
ret.Add(previousPoint - (startPoint - previousPoint));
ret.Add(new OwnVector3(intersect.X, intersect.Y, 0));
intersect = LineTools.LineIntersect(new Point2D(p2.X, p2.Y), new Point2D(p6.X, p6.Y), new Point2D(endPoint.X, endPoint.Y), new Point2D(centerPoint.X, centerPoint.Y));
ret.Add(nextPoint + (nextPoint - endPoint));
ret.Add(new OwnVector3(intersect.X, intersect.Y, 0));
ret.Add(p1);
ret.Add(p6);
ret.Add(p6);
ret.Add(p2);
ret.Add(p1);
ret.Add(p3);
ret.Add(p3);
ret.Add(p2);
}
else
{
p1 = DrawTools.MoveForward(start2, DrawTools.TurnRight(90, norDirection), distance);
p2 = DrawTools.MoveForward(end2, DrawTools.TurnLeft(90, norDirection2), distance);
OwnVector2 intersect = LineTools.LineIntersect(new Point2D(p1.X, p1.Y), new Point2D(p3.X, p3.Y), new Point2D(startPoint.X, startPoint.Y), new Point2D(centerPoint.X, centerPoint.Y));
ret.Add(previousPoint - (startPoint - previousPoint));
ret.Add(new OwnVector3(intersect.X, intersect.Y, 0));
intersect = LineTools.LineIntersect(new Point2D(p2.X, p2.Y), new Point2D(p3.X, p3.Y), new Point2D(endPoint.X, endPoint.Y), new Point2D(centerPoint.X, centerPoint.Y));
ret.Add(nextPoint + (nextPoint - endPoint));
ret.Add(new OwnVector3(intersect.X, intersect.Y, 0));
ret.Add(DrawTools.MoveForward(start2, DrawTools.TurnRight(90, norDirection), distance));
ret.Add(p3);
ret.Add(p3);
ret.Add(DrawTools.MoveForward(end2, DrawTools.TurnLeft(90, norDirection2), distance));
ret.Add(DrawTools.MoveForward(start2, DrawTools.TurnRight(90, norDirection), distance));
ret.Add(p6);
ret.Add(p6);
ret.Add(DrawTools.MoveForward(end2, DrawTools.TurnLeft(90, norDirection2), distance));
}
}
return ret;
}
//
// Summary:
// Multiplies the components of two vectors by each other.
//
// Parameters:
// value1:
// Source vector.
//
// value2:
// Source vector.
public static OwnVector2 Multiply(OwnVector2 value1, OwnVector2 value2)
{
return new OwnVector2(Vector2.Multiply(value1.vector, value2.vector));
}
