private void LoadButton_Click(object sender, EventArgs e)
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter = "XML file | *.xml";
if (dialog.ShowDialog() == DialogResult.OK)
{
var serializer = new XmlSerializer(typeof(List <Point>));
using (var stream = File.OpenRead(dialog.FileName))
{
var points = (List <Point>)(serializer.Deserialize(stream));
ControlPoints.Clear();
foreach (Point p in points)
{
ControlPoints.Add(new Vertex(p.X, p.Y));
}
Start = ControlPoints[0];
End = ControlPoints[ControlPoints.Count - 1];
Start.Size = 11;
End.Size = 11;
Start.Color = Color.DarkRed;
End.Color = Color.DarkRed;
RefreshCanvas();
}
}
}
private void CalculatePath()
{
calculatedPath.Clear();
// Sliders may consist of various subpaths separated by two consecutive vertices
// with the same position. The following loop parses these subpaths and computes
// their shape independently, consecutively appending them to calculatedPath.
int start = 0;
int end = 0;
for (int i = 0; i < ControlPoints.Length(); ++i)
{
end++;
if (i == ControlPoints.Length() - 1 || ControlPoints[i] == ControlPoints[i + 1] && i != ControlPoints.Length() - 2)
{
List <Vector2> cpSpan = ControlPoints.GetRange(start, end - start);
foreach (Vector2 t in CalculateSubpath(cpSpan))
{
if (calculatedPath.Count == 0 || calculatedPath.Last() != t)
{
calculatedPath.Add(t);
}
}
start = end;
}
}
}
internal override void load()
{
base.load();
Music.sharedInstance.play(GameMusic.MusicType.menu);
gameWorld.loadStars();
PlayerData playerData = MemoryCard.current.playerData;
buttonBack = new Button("button_55x55", 8, 604, HorizontalAlignment.left, VerticalAlignment.bottom);
buttonBack.setIcon("Back");
buttonBack.set(GameColors.controlBlue, BlendState.Additive);
addChild(buttonBack);
control = new Control("box_xx89", 0.0f, -2.0f);
control.size = new Vector2(currentSize.X, control.size.Y);
addChild(control);
ControlPremiumPoints controlPremiumPoints = new ControlPremiumPoints(8, 15);
controlPremiumPoints.setLabelText(playerData.premiumPoints);
addChild(controlPremiumPoints);
ControlPoints controlPoints = new ControlPoints(223, 15);
controlPoints.setLabelText(playerData.points);
addChild(controlPoints);
}
private List <Vector2> CalculateSubpath(List <Vector2> subControlPoints)
{
switch (Type)
{
case PathType.Linear:
return(PathApproximator.ApproximateLinear(subControlPoints));
case PathType.PerfectCurve:
//we can only use CircularArc iff we have exactly three control points and no dissection.
if (ControlPoints.Length() != 3 || subControlPoints.Length() != 3)
{
break;
}
// Here we have exactly 3 control points. Attempt to fit a circular arc.
List <Vector2> subpath = PathApproximator.ApproximateCircularArc(subControlPoints);
// If for some reason a circular arc could not be fit to the 3 given points, fall back to a numerically stable bezier approximation.
if (subpath.Count == 0)
{
break;
}
return(subpath);
case PathType.Catmull:
return(PathApproximator.ApproximateCatmull(subControlPoints));
}
return(PathApproximator.ApproximateBezier(subControlPoints));
}
/// <summary>
/// Adds the given point to the shape.
/// </summary>
/// <param name="point">The new <c>SKPoint</c> to add.</param>
public void AddPoint(SKPoint point)
{
// is this the first point added?
if (Points.Count > 0)
{
// No, grab first point
var firstPoint = Points[0];
// Is the new point within five pixels of the first point?
if (point.X > (firstPoint.X - 5) && point.X < (firstPoint.X + 5) &&
point.Y > (firstPoint.Y - 5) && point.Y < (firstPoint.Y + 5))
{
// Yes, close the shape and complete editing
point = firstPoint;
State = KimonoShapeState.Finalizing;
}
}
// Add point and recalculate bounds
Points.Add(point);
RecalculateVectorBounds();
// Are we in the editing mode?
if (State == KimonoShapeState.Editing || State == KimonoShapeState.Finalizing)
{
// Add a new drag handle for the new point
ControlPoints.Add(new KimonoHandle(point.X - KimonoHandle.DrawOffset, point.Y - KimonoHandle.DrawOffset));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Evaluator1D"/> class.
/// </summary>
/// <param name="points">The points.</param>
public Evaluator1D(int points)
{
// Create a single line of points.
ControlPoints.CreateGrid(points, 1);
Name = "1D Evaluator (Bezier Curve)";
Transformation.RotateX = 180;
}
/// <summary>
/// Calculates the partial v derivation of the <see cref="BSplineSurface"/>.
/// </summary>
/// <param name="u">Parameter u.</param>
/// <param name="v">Parameter v.</param>
/// <returns>The partial v derivation.</returns>
public override xyz vDerivation(double u, double v)
{
if ((UKnots == null) || (VKnots == null))
{
return(new xyz(0, 0, 0));
}
Utils.SplineExValue[] VCoeffs = Utils.CoeffSplineEx(VKnots, ControlPoints.GetLength(1), VDegree, VPeriodicity, v);
double[] UCoeffs = Utils.CoeffSpline(UKnots, ControlPoints.GetLength(0), UDegree, UPeriodicity, u);
double WDerived = 0;
double W = 0;
for (int i = 0; i < UCoeffs.Length; i++)
{
for (int j = 0; j < VCoeffs.Length; j++)
{
W = W + Weights[i, j] * UCoeffs[i] * VCoeffs[j].Value;
WDerived = WDerived + Weights[i, j] * UCoeffs[i] * VCoeffs[j].Derivation;
}
}
xyz Result = new xyz();
for (int i = 0; i < ControlPoints.GetLength(0); i++)
{
for (int k = 0; k < ControlPoints.GetLength(1); k++)
{
Result = Result + ControlPoints[i, k] * (Weights[i, k] * UCoeffs[i] * (VCoeffs[k].Derivation * W - WDerived * VCoeffs[k].Value) / (W * W));
}
}
return(Base.Absolut(Result) - Base.BaseO);
}
/// <summary>
/// Render to the provided instance of OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="renderMode">The render mode.</param>
public override void Render(OpenGL gl, Core.RenderMode renderMode)
{
base.Render(gl, renderMode);
// Begin drawing a NURBS surface.
gl.BeginSurface(nurbsRenderer);
// Draw the surface.
gl.NurbsSurface(nurbsRenderer, // The internal nurbs object.
sKnots.Length, // Number of s-knots.
sKnots, // The s-knots themselves.
tKnots.Length, // The number of t-knots.
tKnots, // The t-knots themselves.
ControlPoints.Width * 3, // The size of a row of control points.
3, // The size of a control points.
ControlPoints.ToFloatArray(), // The control points.
ControlPoints.Width, // The order, i.e degree + 1.
ControlPoints.Height, // The order, i.e degree + 1.
OpenGL.GL_MAP2_VERTEX_3); // Type of data to generate.
// End the surface.
gl.EndSurface(nurbsRenderer);
// Draw the control points.
ControlPoints.Draw(gl, DrawControlPoints, DrawControlGrid);
}
/// <summary>
/// Removes a control point and its data.
/// </summary>
/// <param name="controlId"></param>
public void RemoveDragPoint(int controlId)
{
var idx = ControlPoints.FindIndex(controlPoint => controlPoint.ControlId == controlId);
if (idx < 0)
{
return;
}
var removalOk = !ControlPoints[idx].DragPoint.IsLocked;
if (!removalOk)
{
removalOk = EditorUtility.DisplayDialog("Locked DragPoint Removal", "This drag point is locked!\nAre you really sure you want to remove it?", "Yes", "No");
}
if (!removalOk)
{
return;
}
var dragPoints = DragPointInspector.DragPoints.ToList();
dragPoints.RemoveAt(idx);
DragPointInspector.DragPoints = dragPoints.ToArray();
RebuildControlPoints();
}
/// <summary>
/// Render to the provided instance of OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="renderMode">The render mode.</param>
public override void Render(OpenGL gl, RenderMode renderMode)
{
// Create the evaluator.
gl.Map1(OpenGL.GL_MAP1_VERTEX_3, // Use and produce 3D points.
0, // Low order value of 'u'.
1, // High order value of 'u'.
3, // Size (bytes) of a control point.
ControlPoints.Width, // Order (i.e degree plus one).
ControlPoints.ToFloatArray()); // The control points.
// Enable the type of evaluator we wish to use.
gl.Enable(OpenGL.GL_MAP1_VERTEX_3);
// Beging drawing a line strip.
gl.Begin(OpenGL.GL_LINE_STRIP);
// Now draw it.
for (int i = 0; i <= segments; i++)
{
gl.EvalCoord1((float)i / segments);
}
gl.End();
// Draw the control points.
ControlPoints.Draw(gl, DrawControlPoints, DrawControlGrid);
}
/// <summary>
/// Adds a new control point to the scene view and its drag point data
/// to the game object.
/// </summary>
public void AddDragPointOnTraveller()
{
if (CurveTravellerControlPointIdx < 0 || CurveTravellerControlPointIdx >= ControlPoints.Count)
{
return;
}
var dragPoint = new DragPointData(DragPointEditable.GetDragPoints()[CurveTravellerControlPointIdx])
{
IsLocked = false
};
var newIdx = CurveTravellerControlPointIdx + 1;
float ratio = (float)newIdx / (DragPointEditable.GetDragPoints().Length - 1);
var dragPointPosition = Transform.worldToLocalMatrix.MultiplyPoint(CurveTravellerPosition);
dragPointPosition -= DragPointEditable.GetEditableOffset();
dragPointPosition -= DragPointEditable.GetDragPointOffset(ratio);
dragPoint.Vertex = dragPointPosition.ToVertex3D();
var dragPoints = DragPointEditable.GetDragPoints().ToList();
dragPoints.Insert(newIdx, dragPoint);
DragPointEditable.SetDragPoints(dragPoints.ToArray());
ControlPoints.Insert(newIdx,
new ControlPoint(
DragPointEditable.GetDragPoints()[newIdx],
GUIUtility.GetControlID(FocusType.Passive),
newIdx,
ratio
));
RebuildControlPoints();
}
protected override DxfEntity PostParse()
{
Debug.Assert((_controlPointX.Count == _controlPointY.Count) && (_controlPointX.Count == _controlPointZ.Count));
for (int i = 0; i < _controlPointX.Count; i++)
{
var weight = _controlPointX.Count == _weights.Count ? _weights[i] : 1.0;
ControlPoints.Add(new DxfControlPoint(new DxfPoint(_controlPointX[i], _controlPointY[i], _controlPointZ[i]), weight));
}
_controlPointX.Clear();
_controlPointY.Clear();
_controlPointZ.Clear();
Debug.Assert((_fitPointX.Count == _fitPointY.Count) && (_fitPointX.Count == _fitPointZ.Count));
for (int i = 0; i < _fitPointX.Count; i++)
{
FitPoints.Add(new DxfPoint(_fitPointX[i], _fitPointY[i], _fitPointZ[i]));
}
_fitPointX.Clear();
_fitPointY.Clear();
_fitPointZ.Clear();
return(this);
}
protected void CalculateAngle()
{
//Create line from the base of the whisker to the point on the whisker
IWhiskerPoint baseWhiskerPoint = ControlPoints.Last();
BasePoint = new Point(baseWhiskerPoint.XRatio * VideoWidth, baseWhiskerPoint.YRatio * VideoHeight);
Point anglePoint;
Vector gradient;
if (TValue == 1)
{
//If TValue == 1 (Point on whisker == base), calculate gradient at TValue = 1
gradient = GetBezierGradientVideoSize();
gradient *= -1;
anglePoint = BasePoint;
anglePoint.X += gradient.X;
anglePoint.Y += gradient.Y;
}
else
{
anglePoint = GetTValuePoint();
gradient = new Vector(anglePoint.X - BasePoint.X, anglePoint.Y - BasePoint.Y);
}
//Create line which will determine angle
gradient.Normalize();
TargetPoint = anglePoint;
AngleLine = gradient;
Angle = AngleType.CalculateAngle(AngleLine);
}
public void CalculateCurve()
{
if (ControlPoints.Count == 0)
{
BezierPoints = null;
return;
}
var n = ControlPoints.Count - 1;
var controlPointArray = ControlPoints.ToArray();
BezierPoints = new BezierPoint[Count];
BezierPoints[0] = controlPointArray[0];
var calcs = 1;
for (var t = 1 / (decimal)Count; t <= ((decimal)Count - 1) / Count; t += 1 / (decimal)Count)
{
var result = new BezierPoint();
for (var i = 0; i <= n; i++)
{
result += (CalculateBinomial(n, i) * Math.Pow((double)t, i) * Math.Pow(1 - (double)t, n - i)) * controlPointArray[i];
}
BezierPoints[calcs++] = result;
}
BezierPoints[Count - 1] = controlPointArray[n];
}
public override string ToString()
{
var sb = new StringBuilder(); //stringbuilder for performance
sb.Append(base.ToString());
sb.Append(",");
sb.Append(SliderType.ToString().Substring(0, 1));
sb.Append("|");
sb.Append(ControlPoints.Skip(1).Select(c => $"{c.XForHitobject}:{c.YForHitobject}").ToString("|"));
sb.Append(",");
sb.Append(SegmentCount);
sb.Append(",");
sb.Append(Length);
//TODO check if additions should be added
if (PointHitsounds.All(p => p.IsDefault()))
{
return(sb.ToString());
}
sb.Append(",");
sb.Append(PointHitsounds.Select(p => (int)p.SoundType).ToString("|"));
sb.Append(",");
sb.Append(PointHitsounds.Select(p => "" + (int)p.SampleSet + ":" + (int)p.AdditionSampleSet).ToString("|"));
sb.Append(",");
sb.Append(AdditionsForString);
return(sb.ToString());
}
// Create the control points for this Skin2D
public void CreateControlPoints(SkinnedMeshRenderer skin)
{
if (skin.sharedMesh != null)
{
controlPoints = new ControlPoints.Point[skin.sharedMesh.vertices.Length];
if (points == null)
{
points = gameObject.GetComponent <ControlPoints>();
if (points == null)
{
points = gameObject.AddComponent <ControlPoints>();
}
}
for (int i = 0; i < skin.sharedMesh.vertices.Length; i++)
{
Vector3 originalPos = skin.sharedMesh.vertices[i];
controlPoints[i] = new ControlPoints.Point(originalPos);
controlPoints[i].index = i;
points.SetPoint(controlPoints[i]);
}
}
else
{
Debug.LogError("There is no shared mesh for this Skin2D: " + name);
}
}
public void Interpolate(List <Vector2> segmentPoints, float curvatureScale)
{
ControlPoints.Clear();
if (segmentPoints.Count == 0)
{
segmentPoints.Add(Vector2.zero);
}
if (segmentPoints.Count == 1)
{
segmentPoints.Add(segmentPoints[0]);
}
Vector3 p0;
Vector3 p1;
Vector3 p2;
Vector3 q0;
Vector3 q1;
Vector3 tangent;
for (int i = 0; i < segmentPoints.Count; i++)
{
if (i == 0)
{
p1 = segmentPoints[i];
p2 = segmentPoints[i + 1];
tangent = (p2 - p1);
q1 = p1 + curvatureScale * tangent;
ControlPoints.Add(p1);
ControlPoints.Add(q1);
}
else if (i == segmentPoints.Count - 1)
{
p0 = segmentPoints[i - 1];
p1 = segmentPoints[i];
tangent = (p1 - p0);
q0 = p1 - curvatureScale * tangent;
ControlPoints.Add(q0);
ControlPoints.Add(p1);
}
else
{
p0 = segmentPoints[i - 1];
p1 = segmentPoints[i];
p2 = segmentPoints[i + 1];
tangent = (p2 - p0).normalized;
q0 = p1 - curvatureScale * tangent * (p1 - p0).magnitude;
q1 = p1 + curvatureScale * tangent * (p2 - p1).magnitude;
ControlPoints.Add(q0);
ControlPoints.Add(p1);
ControlPoints.Add(q1);
}
}
CurveCount = (ControlPoints.Count - 1) / 3;
}
/// <summary>
/// Adds the handles for the given bezier point.
/// </summary>
/// <param name="index">The index of the <c>KimonoBezierPoint</c> that handles are
/// being created for.</param>
/// <param name="bezierPoint">The <c>KimonoBezierPoint</c> that is getting handles.</param>
public void AddHandlesForPoint(int index, KimonoBezierPoint bezierPoint)
{
// Add new control point handle
var controlPoint = new KimonoHandle(bezierPoint.ControlPoint.X - KimonoHandle.DrawOffset,
bezierPoint.ControlPoint.Y - KimonoHandle.DrawOffset)
{
Index = index,
HandleType = KimonoHandleType.BezierControlPoint
};
controlPoint.Moved += (pt) =>
{
// Move attached point
Points[controlPoint.Index].ControlPoint = pt;
};
ControlPoints.Add(controlPoint);
// Add new end point handle
var endPoint = new KimonoHandle(bezierPoint.EndPoint.X - KimonoHandle.DrawOffset,
bezierPoint.EndPoint.Y - KimonoHandle.DrawOffset)
{
Index = index
};
endPoint.Moved += (pt) =>
{
// Move attached point
Points[endPoint.Index].EndPoint = pt;
};
ControlPoints.Add(endPoint);
}
public override void GenerateControlPoints(OpenGL gl)
{
Point point1 = new Point(Start.X, Start.Y);
Point point2 = new Point(End.X, End.Y);
ControlPoints.Add(point1);
ControlPoints.Add(point2);
}
public ICurve ToCurve()
{
var propsDouble = PropsDouble;
var knots = KnotVectorU;
var ctrlPtCoords = ControlPoints.SelectMany(p => p.ToDoubles()).ToArray();
return((ICurve)SwAddinBase.Active.Modeler.CreateBsplineCurve(propsDouble, knots, ctrlPtCoords));
}
internal override void WriteParameters(List <object> parameters, IgesWriterBinder binder)
{
Debug.Assert(Weights != null);
Debug.Assert(ControlPoints != null);
Debug.Assert(Weights.GetLength(0) == ControlPoints.GetLength(0));
Debug.Assert(Weights.GetLength(1) == ControlPoints.GetLength(1));
var k1 = Weights.GetLength(0) - 1;
var k2 = Weights.GetLength(1) - 1;
var a = FirstKnotValueSequence.Count - 1;
var b = SecondKnotValueSequence.Count - 1;
var m1 = a - 1 - k1;
var m2 = b - 1 - k2;
parameters.Add(k1);
parameters.Add(k2);
parameters.Add(m1);
parameters.Add(m2);
parameters.Add(IsClosedInFirstParametricVariable ? 1 : 0);
parameters.Add(IsClosedInSecondParametricVariable ? 1 : 0);
parameters.Add(IsPolynomial ? 1 : 0);
parameters.Add(IsPeriodicInFirstParametricVariable ? 1 : 0);
parameters.Add(IsPeriodicInSecondParametricVariable ? 1 : 0);
for (int i = 0; i < FirstKnotValueSequence.Count; i++)
{
parameters.Add(FirstKnotValueSequence[i]);
}
for (int i = 0; i < SecondKnotValueSequence.Count; i++)
{
parameters.Add(SecondKnotValueSequence[i]);
}
for (int j = 0; j < k2 + 1; j++)
{
for (int i = 0; i < k1 + 1; i++)
{
parameters.Add(Weights[i, j]);
}
}
for (int j = 0; j < k2 + 1; j++)
{
for (int i = 0; i < k1 + 1; i++)
{
var point = ControlPoints[i, j];
parameters.Add(point.X);
parameters.Add(point.Y);
parameters.Add(point.Z);
}
}
parameters.Add(FirstParametricStartingValue);
parameters.Add(FirstParametricEndingValue);
parameters.Add(SecondParametricStartingValue);
parameters.Add(SecondParametricEndingValue);
}
protected virtual void OnResizingDelta(ResizingDirection direction, double horizontalChange, double verticalChange)
{
var selectedPoints = ControlPoints.Where(c => c.IsSelected).ToList();
foreach (IResizingTarget c in selectedPoints)
{
c.OnResizingDelta(direction, horizontalChange, verticalChange);
}
}
protected virtual void OnResizingStarted(ResizingDirection direction)
{
var selectedPoints = ControlPoints.Where(c => c.IsSelected).ToList();
foreach (IResizingTarget c in selectedPoints)
{
c.OnResizingStarted(direction);
}
}
public TestPattern(Vector2 startPosition, float speed) : base(startPosition, speed)
{
ControlPoints.Add(new Vector2(75, 300));
ControlPoints.Add(new Vector2(400, 200));
ControlPoints.Add(new Vector2(400, 400));
ControlPoints.Add(new Vector2(100, 100));
ControlPoints.Add(new Vector2(500, 600));
ControlPoints.Add(new Vector2(500, 600));
}
/// <summary>
/// Removes a Control Point from this connection
/// </summary>
/// <param name="controlPoint">the Control Point to remove</param>
/// <param name="destroySelfIfEmpty">whether the connection should be destroyed when empty afterwards</param>
public void RemoveControlPoint(CurvySplineSegment controlPoint, bool destroySelfIfEmpty = true)
{
controlPoint.Connection = null;
ControlPoints.Remove(controlPoint);
if (ControlPoints.Count == 0 && destroySelfIfEmpty)
{
Delete();
}
}
//public int NewNo { get; set; }
// Display Info of the RFEM Objects on Panels
// Parameters are separated by ";". The component split text can be used to break the string down into a list.
public override string ToString()
{
return(string.Format($"RFEM-Line;No:{No};Length:{Length}[m];Type:{Type};NodeList:{((NodeList == "") ? "-" : NodeList)};" +
$"NodeCount:{NodeCount};Nodes:{ControlPoints.ToLabelString()};Tag:{((Tag == "") ? "-" : Tag)};" +
$"IsValid:{IsValid};IsGenerated:{IsGenerated};ID:{((ID == "") ? "-" : ID)};RotationAngle:{RotationAngle}[rad];" +
$"RotationHelpNodeNo:{RotationHelpNodeNo};RotationPlane:{RotationPlane};RotationType:{RotationType};" +
$"Order:{((Order == 0) ? "-" : Order.ToString())};" +
$"Weights:{(Weights.ToLabelString())};Knots:{(Knots.ToLabelString())};" +
$"ToModify:{ToModify};ToDelete:{ToDelete};Comment:{((Comment == "") ? "-" : Comment)};"));
}
public ControlPoint AddControlPoint(Point point)
{
var controlPoint = new ControlPoint(ControlPoints.Count + 1, point);
ControlPoints.Add(controlPoint);
CalculateCurve();
return(controlPoint);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = ControlPoints.Cast <Vector3>().GetHashCode(v => v.GetHashCode());
hashCode = (hashCode * 397) ^ KnotVectorU.GetHashCode(v => v.GetHashCode());
hashCode = (hashCode * 397) ^ Order;
return(hashCode);
}
}
public MultiplierControlPoint ControlPointAt(double time)
{
int result = ControlPoints.BinarySearch(new MultiplierControlPoint(time));
if (result < 0)
{
result = Math.Clamp(~result - 1, 0, ControlPoints.Count);
}
return(ControlPoints[result]);
}
//--------------------------------------------------------------------------
public GraphNodeDataLink(GraphReferenceItem item) : base(item)
{
LinkNoEvent = GraphReferenceItem.WrappedItem?.GraphNode;
GraphReferenceItem.PropertyChanged += (e, args) =>
{
if (args.PropertyName == "WrappedItem")
{
Link = GraphReferenceItem.WrappedItem?.GraphNode;
}
else if (args.PropertyName == "TextBrush")
{
RaisePropertyChangedEvent("FontBrush");
}
else if (args.PropertyName == "Name")
{
RaisePropertyChangedEvent("Title");
}
else if (args.PropertyName == "IsVisible")
{
RaisePropertyChangedEvent("Link");
}
};
if (GraphReferenceItem.Parent is StructItem && GraphReferenceItem.ReferenceDef.UseParentDescription)
{
GraphReferenceItem.Parent.PropertyChanged += (e, args) =>
{
if (args.PropertyName == "Description")
{
RaisePropertyChangedEvent("Title");
}
else if (args.PropertyName == "TextBrush")
{
RaisePropertyChangedEvent("FontBrush");
}
};
}
foreach (var controlPoint in GraphReferenceItem.ControlPoints)
{
ControlPoints.Add(new LinkControlPoint(this, controlPoint));
}
PropertyChanged += (e, args) =>
{
if (args.PropertyName == "Node")
{
if (Link != null)
{
Link.ParentNodes.Add(Node);
}
}
};
}
public void RemoveControlPoints()
{
controlPoints = null;
if (points != null) {
DestroyImmediate(points);
}
points = null;
}
public void CreateControlPoints(SkinnedMeshRenderer skin)
{
if (skin.sharedMesh != null)
{
controlPoints = new ControlPoints.Point[skin.sharedMesh.vertices.Length];
if (points == null) {
points = gameObject.AddComponent<ControlPoints>();
}
for (int i = 0; i < skin.sharedMesh.vertices.Length; i++) {
Vector3 originalPos = skin.sharedMesh.vertices[i];
controlPoints[i] = new ControlPoints.Point(originalPos);
controlPoints[i].index = i;
points.SetPoint(controlPoints[i]);
}
}
}
