public void SlerpContacts(MeshDeformer deformer, Mesh original, Mesh colliderOriginal, ScaffoldWrapper prev, ScaffoldWrapper next) { if (m_isRigid) { return; } if (m_scaffold != null) { Scaffold prevObj = null; if (prev != null) { int contactPointIndex = prev.CurveIndices.Max() * 3 + 3; ControlPointMode mode = deformer.GetControlPointMode(contactPointIndex); if (mode != ControlPointMode.Free) { prevObj = prev.Obj; } } Scaffold nextObj = null; if (next != null) { int contactPointIndex = next.CurveIndices.Min() * 3; ControlPointMode mode = deformer.GetControlPointMode(contactPointIndex); if (mode != ControlPointMode.Free) { nextObj = next.Obj; } } m_scaffold.SlerpContacts(deformer, original, colliderOriginal, prevObj, nextObj, m_isRigid); } }
private void InsertCurve(Vector3[] points, ControlPointSetting setting, ControlPointMode mode, int curveIndex, float length, bool enforceNeighbour) { Array.Resize(ref m_points, m_points.Length + points.Length); Array.Resize(ref m_settings, m_settings.Length + points.Length / 3); Array.Resize(ref m_modes, m_modes.Length + points.Length / 3); int pointIndex = curveIndex * 3; int modeIndex = (pointIndex + 1) / 3; for (int i = m_points.Length - 1; i >= pointIndex + points.Length; --i) { m_points[i] = m_points[i - points.Length]; } for (int i = m_modes.Length - 1; i >= modeIndex + points.Length / 3; --i) { m_settings[i] = m_settings[i - points.Length / 3]; m_modes[i] = m_modes[i - points.Length / 3]; RaiseControlPointModeChanged(i); } for (int i = pointIndex; i < pointIndex + points.Length; ++i) { m_points[i] = points[i - pointIndex]; } for (int i = modeIndex; i < modeIndex + points.Length / 3; ++i) { m_settings[i] = setting; m_modes[i] = mode; RaiseControlPointModeChanged(i); } Vector3 dir = transform.InverseTransformDirection(GetDirection(0.0f, curveIndex)); for (int i = pointIndex - 1; i >= 0; i--) { m_points[i] -= dir * length; } if (enforceNeighbour) { EnforceMode(pointIndex + points.Length + 1); } else { EnforceMode(pointIndex + points.Length - 1); } if (m_loop) { m_points[m_points.Length - 1] = m_points[0]; m_settings[0] = m_settings[m_settings.Length - 1]; m_modes[m_modes.Length - 1] = m_modes[0]; RaiseControlPointModeChanged(m_modes.Length - 1); EnforceMode(1); } SyncCtrlPoints(); }
private void DrawSelectedPointInspector() { GUILayout.Label("Selected Point"); EditorGUI.BeginChangeCheck(); // get the point modified on the inspector // add a Vector3 field Vector3 point = EditorGUILayout.Vector3Field("Position", spline.GetControlPoint(selectedIndex)); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(spline, "Move Point"); EditorUtility.SetDirty(spline); // set the new value if modified through inspector spline.SetControlPoint(selectedIndex, point); } EditorGUI.BeginChangeCheck(); // Add a Pop up field to the inspector ControlPointMode mode = (ControlPointMode) EditorGUILayout.EnumPopup("Mode", spline.GetControlPointMode(selectedIndex)); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(spline, "Change Point Mode"); spline.SetControlPointMode(selectedIndex, mode); EditorUtility.SetDirty(spline); } }
public void AddCurve(int _atIndex, ControlPointMode _defaultMode = ControlPointMode.Mirrored) { Vector3 p1 = points[_atIndex * 3]; Vector3 p2 = points[(_atIndex + 1) * 3]; Vector3 center = (p1 + p2) * 0.5f; Vector3 direction = (p2 - p1).normalized; points.InsertRange((_atIndex * 3) + 2, new Vector3[] { center - direction, center, center + direction }); modes.Insert(_atIndex, _defaultMode); EnforceMode(_atIndex); if (isLooped) { points[points.Count - 1] = points[0]; modes[modes.Count - 1] = modes[0]; EnforceMode(0); } hasChanged = true; }
private void UpdateMaterial() { if (m_renderer != null) { SplineRuntimeEditor runtimeEditor = SplineRuntimeEditor.Instance; if (runtimeEditor != null) { if (m_index % 3 == 0) { m_renderer.sharedMaterial = runtimeEditor.NormalMaterial; } else { if (m_index >= m_spline.ControlPointCount) { return; } ControlPointMode mode = m_spline.GetControlPointMode(m_index); if (mode == ControlPointMode.Mirrored) { m_renderer.sharedMaterial = runtimeEditor.MirroredModeMaterial; } else if (mode == ControlPointMode.Aligned) { m_renderer.sharedMaterial = runtimeEditor.AlignedModeMaterial; } else { m_renderer.sharedMaterial = runtimeEditor.FreeModeMaterial; } } } } }
private void EnforceMode(int index) { int modeIndex = (index + 1) / 3; ControlPointMode mode = modes[modeIndex]; if (mode == ControlPointMode.Free || modeIndex == 0 || modeIndex == modes.Length - 1) { return; } int middleIndex = modeIndex * 3; int fixedIndex, enforcedIndex; if (index <= middleIndex) { fixedIndex = middleIndex - 1; enforcedIndex = middleIndex + 1; } else { fixedIndex = middleIndex + 1; enforcedIndex = middleIndex - 1; } Vector3 middle = points[middleIndex]; Vector3 enforcedTangent = middle - points[fixedIndex]; if (mode == ControlPointMode.Aligned) { enforcedTangent = enforcedTangent.normalized * Vector3.Distance(middle, points[enforcedIndex]); } points[enforcedIndex] = middle + enforcedTangent; }
public void SetControlPointMode(int index, ControlPointMode mode, bool raiseCurveChanged = true) { int modeIndex = (index + 1) / 3; m_modes[modeIndex] = mode; RaiseControlPointModeChanged(modeIndex); if (m_loop) { if (modeIndex == 0) { m_modes[m_modes.Length - 1] = mode; RaiseControlPointModeChanged(m_modes.Length - 1); } else if (modeIndex == m_modes.Length - 1) { m_modes[0] = mode; RaiseControlPointModeChanged(0); } } EnforceMode(index); #if UNITY_EDITOR m_persistentVersions[0]++; OnVersionChanged(); #endif if (raiseCurveChanged) { OnCurveChanged(index, Math.Max(0, (index - 1) / 3)); } }
public void SetControlPointMode(ControlPointMode mode) { for (int i = 0; i <= CurveCount; ++i) { SetControlPointMode(i * 3, mode); } }
protected override SplineBase Read(ContentReader input, SplineBase existingInstance) { SplineBase spline = existingInstance; Setup.SplineMarkerResolution = input.ReadSingle(); int pointLength = input.ReadInt32(); Transform[] points = new Transform[pointLength]; for (int i = 0; i < pointLength; i++) { points[i] = new Transform(input.ReadVector2()); } int pointModeLength = input.ReadInt32(); ControlPointMode[] pointModes = new ControlPointMode[pointModeLength]; for (int i = 0; i < pointModeLength; i++) { pointModes[i] = (ControlPointMode)Enum.Parse(typeof(ControlPointMode), input.ReadString()); } int triggerLength = input.ReadInt32(); Trigger[] trigger = new Trigger[triggerLength]; for (int i = 0; i < triggerLength; i++) { trigger[i] = new Trigger( input.ReadString(), input.ReadSingle(), input.ReadSingle() * Setup.SplineMarkerResolution, input.ReadString()); } Transform[] tangents = null; if (spline.IsHermite) { int tangentLength = input.ReadInt32(); tangents = new Transform[tangentLength]; for (int i = 0; i < tangentLength; i++) { tangents[i] = new Transform(input.ReadVector2()) { UserData = input.ReadObject <HermiteSpline.TangentData>() }; } } spline.LoadSplineData( points, pointModes, trigger, tangents); spline.Loop = input.ReadBoolean(); return(spline); }
private static void SetMode(GameObject selected, bool isRigid, ControlPointMode mode) { MeshDeformer meshDeformer = selected.GetComponentInParent <MeshDeformer>(); if (meshDeformer == null) { return; } Scaffold selectedScaffold = selected.GetComponent <Scaffold>(); ControlPoint selectedControlPoint = selected.GetComponent <ControlPoint>(); Undo.RecordObject(meshDeformer, "Battlehub.MeshDeformer.SetMode"); MeshDeformerEditor.RecordScaffolds(meshDeformer, "Battlehub.MeshDeformer.SetMode"); EditorUtility.SetDirty(meshDeformer); if (selectedScaffold != null && selectedScaffold.gameObject != meshDeformer.gameObject) { ScaffoldWrapper scaffold = meshDeformer.Scaffolds.Where(s => s.Obj == selectedScaffold).FirstOrDefault(); if (scaffold != null) { for (int i = 0; i < scaffold.CurveIndices.Length; ++i) { int curveIndex = scaffold.CurveIndices[i]; if (mode == ControlPointMode.Free) { meshDeformer.SetIsRigid(curveIndex * 3, isRigid); } if (!isRigid) { meshDeformer.SetControlPointMode(curveIndex * 3, mode); meshDeformer.SetControlPointMode(curveIndex * 3 + 3, mode); } } } else { Debug.LogError("scaffold not found"); } } else if (selectedControlPoint != null) { if (mode == ControlPointMode.Free) { meshDeformer.SetIsRigid(selectedControlPoint.Index, isRigid); } if (!isRigid) { meshDeformer.SetControlPointMode(selectedControlPoint.Index, mode); } } else { MeshDeformerEditor.SetMode(meshDeformer, mode, isRigid); } }
public void EnforceMode(int index) { if (index == Setup.CenterSplineIndex) { return; } int modeIndex = (index + 1) / 3; ControlPointMode mode = _Modes[modeIndex]; if (mode == ControlPointMode.Free || !Loop && (modeIndex == 0 || modeIndex == _Modes.Length - 1)) { return; } int middleIndex = modeIndex * 3; int fixedIndex, enforcedIndex; if (index <= middleIndex) { fixedIndex = middleIndex - 1; if (fixedIndex < 0) { fixedIndex = _Points.Length - 2; } enforcedIndex = middleIndex + 1; if (enforcedIndex >= _Points.Length) { enforcedIndex = 1; } } else { fixedIndex = middleIndex + 1; if (fixedIndex >= _Points.Length) { fixedIndex = 1; } enforcedIndex = middleIndex - 1; if (enforcedIndex < 0) { enforcedIndex = _Points.Length - 2; } } Transform middle = _Points[middleIndex]; Vector2 enforcedTangent = middle.Position - _Points[fixedIndex].Position; if (mode == ControlPointMode.Aligned) { enforcedTangent.Normalize(); enforcedTangent *= Vector2.Distance(middle.Position, _Points[enforcedIndex].Position); } _Points[enforcedIndex].SetPosition(middle.Position + enforcedTangent); }
private ControlPointMode[] LoadJsonPointModeData(ControlPointModeDummy[] pointModeData) { ControlPointMode[] modePoints = new ControlPointMode[pointModeData.Length]; for (int i = 0; i < pointModeData.Length; i++) { modePoints[i] = (ControlPointMode)Enum.Parse(typeof(ControlPointMode), pointModeData[i].Mode); } return(modePoints); }
protected override void OnMouseDown(MouseEventArgs e) { base.OnMouseDown(e); if (e.Button == MouseButtons.Right) { if (GetSpline.SelectTransform(new Vector2(e.X, e.Y)) != null && !GetSpline.SelectedTransform.IsCenter) { ControlPointMode nextMode = MySpline.GetControlPointMode(GetSpline.SelectedTransform.Index).Next(); MySpline.SetControlPointMode(GetSpline.SelectedTransform.Index, nextMode); } } }
private void EnforceMode(int _index) { int modeIndex = (_index + 1) / 3; ControlPointMode mode = modes[modeIndex]; if (mode == ControlPointMode.Free || !isLooped && (modeIndex == 0 || modeIndex == modes.Count - 1)) { return; } int middleIndex = modeIndex * 3; int fixedIndex, enforcedIndex; if (_index <= middleIndex) { fixedIndex = middleIndex - 1; if (fixedIndex < 0) { fixedIndex = points.Count - 2; } enforcedIndex = middleIndex + 1; if (enforcedIndex >= points.Count - 2) { enforcedIndex = 1; } } else { fixedIndex = middleIndex + 1; if (fixedIndex >= points.Count) { fixedIndex = 1; } enforcedIndex = middleIndex - 1; if (enforcedIndex < 0) { enforcedIndex = points.Count - 2; } } Vector3 middle = points[middleIndex]; Vector3 enforcedTangent = middle - points[fixedIndex]; if (mode == ControlPointMode.Aligned) { enforcedTangent = enforcedTangent.normalized * Vector3.Distance(middle, points[enforcedIndex]); } points[enforcedIndex] = middle + enforcedTangent; }
private void EnforceMode(int index) { int modeIndex = (index + 1) / 3; ControlPointMode mode = m_modes[modeIndex]; if (mode == ControlPointMode.Free || !m_loop && (modeIndex == 0 || modeIndex == m_modes.Length - 1)) { return; } int middleIndex = modeIndex * 3; int fixedIndex, enforcedIndex; if (index <= middleIndex) { fixedIndex = middleIndex - 1; if (fixedIndex < 0) { fixedIndex = m_points.Length - 2; } enforcedIndex = middleIndex + 1; if (enforcedIndex >= m_points.Length) { enforcedIndex = 1; } } else { fixedIndex = middleIndex + 1; if (fixedIndex >= m_points.Length) { fixedIndex = 1; } enforcedIndex = middleIndex - 1; if (enforcedIndex < 0) { enforcedIndex = m_points.Length - 2; } } Vector3 middle = m_points[middleIndex]; Vector3 enforcedTangent = middle - m_points[fixedIndex]; if (mode == ControlPointMode.Aligned) { enforcedTangent = enforcedTangent.normalized * Vector3.Distance(middle, m_points[enforcedIndex]); } m_points[enforcedIndex] = middle + enforcedTangent; RaiseControlPointChanged(enforcedIndex); }
private void SetControlPointMode(int index, ControlPointMode mode) { if (target is SplineControlPoint) { for (int i = 0; i < targets.Length; ++i) { SplineControlPoint controlPoint = (SplineControlPoint)targets[i]; m_splineBase.SetControlPointMode(controlPoint.Index, mode); } } else { m_splineBase.SetControlPointMode(index, mode); } }
public void SetControlPointMode(int p, ControlPointMode mode) { int modeIndex = (p + 1) / 3; modes[modeIndex] = mode; /* If we are in loop mode, ensure both ends share the same constraint if either changed */ if (loop) { if (modeIndex == 0) { modes[modes.Length - 1] = mode; } else if (modeIndex == modes.Length - 1) { modes[0] = mode; } } EnforceConstraintMode(p); }
private static void SetMode(GameObject selected, ControlPointMode mode) { Spline spline = selected.GetComponentInParent <Spline>(); if (spline == null) { return; } SplineControlPoint selectedControlPoint = selected.GetComponent <SplineControlPoint>(); if (selectedControlPoint != null) { SplineBaseEditor.SetMode(spline, mode, selectedControlPoint.Index); } else { SplineBaseEditor.SetMode(spline, mode); } }
public void SetControlPointMode(int index, ControlPointMode mode) { var modeIndex = (index + 1) / 3; _controlPointModes[modeIndex] = mode; if (_isLoop) { if (modeIndex == 0) { _controlPointModes[_controlPointModes.Length - 1] = mode; } else if (modeIndex == _controlPointModes.Length - 1) { _controlPointModes[0] = mode; } } EnforceMode(index); }
public void SetMode(int _index, ControlPointMode _mode) { int modeIndex = (_index + 1) / 3; modes[modeIndex] = _mode; if (isLooped) { if (modeIndex == 0) { modes[modes.Count - 1] = _mode; } else if (modeIndex == modes.Count - 1) { modes[0] = _mode; } } EnforceMode(_index); hasChanged = true; }
public static void SetMode(MeshDeformer deformer, ControlPointMode mode, bool isRigid) { ScaffoldWrapper[] scaffolds = deformer.Scaffolds; for (int s = 0; s < scaffolds.Length; ++s) { ScaffoldWrapper scaffold = scaffolds[s]; for (int i = 0; i < scaffold.CurveIndices.Length; ++i) { int curveIndex = scaffold.CurveIndices[i]; if (mode == ControlPointMode.Free) { deformer.SetIsRigid(curveIndex * 3, isRigid); } if (!isRigid) { deformer.SetControlPointMode(curveIndex * 3, mode); deformer.SetControlPointMode(curveIndex * 3 + 3, mode); } } } }
public void SetControlPointMode(int index, ControlPointMode mode) { if (index == Setup.CenterSplineIndex) { return; } int modeIndex = (index + 1) / 3; _Modes[modeIndex] = mode; if (_Loop) { if (modeIndex == 0) { _Modes[_Modes.Length - 1] = mode; } else if (modeIndex == _Modes.Length - 1) { _Modes[0] = mode; } } EnforceMode(index); }
private static void SetMode(GameObject selected, ControlPointMode mode) { Spline spline = selected.GetComponentInParent <Spline>(); if (spline == null) { return; } SplineControlPoint selectedControlPoint = selected.GetComponent <SplineControlPoint>(); Undo.RecordObject(spline, "Battlehub.Spline.SetMode"); EditorUtility.SetDirty(spline); if (selectedControlPoint != null) { spline.SetControlPointMode(selectedControlPoint.Index, mode); } else { spline.SetControlPointMode(mode); } }
private void DrawSelectedPointInspector() { GUILayout.Label("Selected Point"); EditorGUI.BeginChangeCheck(); Vector3 point = EditorGUILayout.Vector3Field("Position", spline.GetControlPoint(selectedIndex)); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(spline, "Move Point"); EditorUtility.SetDirty(spline); spline.SetControlPoint(selectedIndex, point); } EditorGUI.BeginChangeCheck(); ControlPointMode mode = (ControlPointMode)EditorGUILayout.EnumPopup("Mode", spline.GetControlPointMode(selectedIndex)); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(spline, "Change Point Mode"); spline.SetControlPointMode(selectedIndex, mode); EditorUtility.SetDirty(spline); } }
protected void AppendCurve(Vector3[] points, ControlPointSetting setting, ControlPointMode mode, bool enforceNeighbour) { Array.Resize(ref m_points, m_points.Length + points.Length); Array.Resize(ref m_settings, m_settings.Length + points.Length / 3); Array.Resize(ref m_modes, m_modes.Length + points.Length / 3); for (int i = 0; i < points.Length; i++) { m_points[m_points.Length - points.Length + i] = points[i]; } for (int i = 0; i < points.Length / 3; i++) { m_settings[m_settings.Length - points.Length / 3 + i] = setting; m_modes[m_modes.Length - points.Length / 3 + i] = mode; RaiseControlPointModeChanged(m_modes.Length - points.Length / 3 + i); } if (enforceNeighbour) { EnforceMode(m_points.Length - points.Length - 2); } else { EnforceMode(m_points.Length - points.Length); } if (m_loop) { m_points[0] = m_points[m_points.Length - 1]; m_settings[0] = m_settings[m_settings.Length - 1]; m_modes[0] = m_modes[m_modes.Length - 1]; RaiseControlPointModeChanged(0); EnforceMode(m_points.Length - 1); } SyncCtrlPoints(); }
protected void SetPoints(int curveIndex, Vector3[] points, ControlPointMode mode, bool raiseCurveChanged) { int index = curveIndex * 3; for (int i = 0; i < points.Length; ++i) { m_points[index] = points[i]; RaiseControlPointChanged(index); SetControlPointMode(index, mode, raiseCurveChanged); index++; } EnforceMode(index); #if UNITY_EDITOR m_persistentVersions[0]++; OnVersionChanged(); #endif if (raiseCurveChanged) { OnCurveChanged(index, Math.Max(0, (index - 1) / 3)); } }
/* * Function which will enforce the constraint between points * To be called when a a point is Set or a mode is Set */ public void EnforceConstraintMode(int index) { // get current mode int curModeIndex = (index + 1) / 3; ControlPointMode mode = modes[curModeIndex]; /* We can only enforce the constraint on points which belong to the union of 2 curves. * We disregard the extreme cases IFF NOT LOOPING (first and last control point and the case on which the mode * is FREE, since there is nothing to adjust */ if (mode == ControlPointMode.FREE || !loop && (curModeIndex == 0 || curModeIndex == modes.Length - 1)) { return; } /* * Find the middle point * 1. if the middle is selected: * a. adjust the one after it * 2. else, adjust the opposite of the currently selected * * 3. LOOPING: * If we are looping, we have to ROLL over indexes. */ int midIndex = curModeIndex * 3, fixIndex, adjustIndex; if (midIndex <= index) { fixIndex = midIndex - 1; if (fixIndex < 0) // loop case { fixIndex = controlPoints.Length - 2; } adjustIndex = midIndex + 1; // this will be the adjusted one if (adjustIndex >= controlPoints.Length) // loop case { adjustIndex = 1; } } else { fixIndex = midIndex + 1; if (fixIndex >= controlPoints.Length) // loop case { fixIndex = 1; } adjustIndex = midIndex - 1; if (adjustIndex < 0) // loop case { adjustIndex = controlPoints.Length - 2; } } Vector3 middlePoint = controlPoints[midIndex]; /* Mirroring */ Vector3 enforcedTangent = middlePoint - controlPoints[fixIndex]; /* Align - respect distance */ if (mode == ControlPointMode.ALIGNED) { enforcedTangent = enforcedTangent.normalized * Vector3.Distance(middlePoint, controlPoints[adjustIndex]); } controlPoints[adjustIndex] = middlePoint + enforcedTangent; }
protected void DrawSelectedPointInspector() { if (DrawSelectedPointInspectorOverride()) { EditorGUI.BeginChangeCheck(); ControlPointMode mode = (ControlPointMode) EditorGUILayout.EnumPopup("Mode", m_splineBase.GetControlPointMode(m_selectedIndex)); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(m_splineBase, UNDO_CHANGEMODE); EditorUtility.SetDirty(m_splineBase); SetControlPointMode(m_selectedIndex, mode); } EditorGUI.BeginChangeCheck(); int index = (m_selectedIndex / 3) * 3; Twist twist = m_splineBase.GetTwist(index); EditorGUI.BeginChangeCheck(); float twistAngle = EditorGUILayout.FloatField("Twist Angle", twist.Data); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(m_splineBase, "Battlehub.MeshDeformer2 Twist Angle"); EditorUtility.SetDirty(m_splineBase); twist.Data = twistAngle; SetTwist(index, twist); } if (m_splineBase.Loop || m_selectedIndex / 3 < m_splineBase.CurveCount) { float t1 = twist.T1; float t2 = twist.T2; EditorGUI.BeginChangeCheck(); EditorGUILayout.MinMaxSlider(new GUIContent("Twist Offset"), ref t1, ref t2, 0.0f, 1.0f); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(m_splineBase, "Battlehub.MeshDeformer2 Twist Offset"); EditorUtility.SetDirty(m_splineBase); twist.T1 = t1; twist.T2 = t2; SetTwist(index, twist); } } Thickness thickness = m_splineBase.GetThickness(index); EditorGUI.BeginChangeCheck(); Vector3 thicknessValue = EditorGUILayout.Vector3Field("Thickness", thickness.Data); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(m_splineBase, "Battlehub.MeshDeformer2 Thickness"); EditorUtility.SetDirty(m_splineBase); thickness.Data = thicknessValue; SetThickness(index, thickness); } if (m_splineBase.Loop || m_selectedIndex / 3 < m_splineBase.CurveCount) { float t1 = thickness.T1; float t2 = thickness.T2; EditorGUI.BeginChangeCheck(); EditorGUILayout.MinMaxSlider(new GUIContent("Thickness Offset"), ref t1, ref t2, 0.0f, 1.0f); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(m_splineBase, "Battlehub.MeshDeformer2 Thickness Offset"); EditorUtility.SetDirty(m_splineBase); thickness.T1 = t1; thickness.T2 = t2; SetThickness(index, thickness); } } Wrap wrap = m_splineBase.GetWrap(index); EditorGUI.BeginChangeCheck(); float wrapValue = EditorGUILayout.FloatField("Wrap Curvature", wrap.Data); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(m_splineBase, "Battlehub.MeshDeformer2 Wrap"); EditorUtility.SetDirty(m_splineBase); wrap.Data = wrapValue; SetWrap(index, wrap); } if (m_splineBase.Loop || m_selectedIndex / 3 < m_splineBase.CurveCount) { float t1 = wrap.T1; float t2 = wrap.T2; EditorGUI.BeginChangeCheck(); EditorGUILayout.MinMaxSlider(new GUIContent("Wrap Offset"), ref t1, ref t2, 0.0f, 1.0f); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(m_splineBase, "Battlehub.MeshDeformer2 Wrap Offset"); EditorUtility.SetDirty(m_splineBase); wrap.T1 = t1; wrap.T2 = t2; SetWrap(index, wrap); } } } else { EditorGUI.BeginChangeCheck(); int index = (m_selectedIndex / 3) * 3; Twist twist = m_splineBase.GetTwist(index); EditorGUI.BeginChangeCheck(); float twistAngle = EditorGUILayout.FloatField("Twist Angle", twist.Data); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(m_splineBase, "Battlehub.MeshDeformer2 Twist Angle"); EditorUtility.SetDirty(m_splineBase); twist.Data = twistAngle; SetTwist(index, twist); } Thickness thickness = m_splineBase.GetThickness(index); EditorGUI.BeginChangeCheck(); Vector3 thicknessValue = EditorGUILayout.Vector3Field("Thickness", thickness.Data); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(m_splineBase, "Battlehub.MeshDeformer2 Thickness"); EditorUtility.SetDirty(m_splineBase); thickness.Data = thicknessValue; SetThickness(index, thickness); } Wrap wrap = m_splineBase.GetWrap(index); EditorGUI.BeginChangeCheck(); float wrapValue = EditorGUILayout.FloatField("Wrap Curvature", wrap.Data); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(m_splineBase, "Battlehub.MeshDeformer2 Wrap"); EditorUtility.SetDirty(m_splineBase); wrap.Data = wrapValue; SetWrap(index, wrap); } } }
public void SetMode(int _index, ControlPointMode _mode) { int modeIndex = (_index + 1) / 3; modes[modeIndex] = _mode; if (isLooped) { if(modeIndex == 0) { modes[modes.Count - 1] = _mode; } else if(modeIndex == modes.Count - 1) { modes[0] = _mode; } } EnforceMode(_index); hasChanged = true; }
public void SetControlPointMode(int index, ControlPointMode mode) { modes[(index + 1) / 3] = mode; EnforceMode(index); }
public static Spline CreateSpline(Vector3 position, Thickness thickness, Twist twist, ControlPointMode mode = ControlPointMode.Mirrored, string undorecord = "Battlehub.Spline.Create") { GameObject spline = new GameObject(); spline.name = "Spline"; if (!FindObjectOfType <GLRenderer>()) { GameObject go = new GameObject(); go.name = "GLRenderer"; go.AddComponent <GLRenderer>(); } Undo.RegisterCreatedObjectUndo(spline, undorecord); Spline splineComponent = spline.AddComponent <Spline>(); splineComponent.SetControlPointMode(mode); splineComponent.SetTwist(0, twist); splineComponent.SetTwist(3, twist); splineComponent.SetThickness(0, thickness); splineComponent.SetThickness(3, thickness); spline.transform.position = position; return(splineComponent); }