protected override void ShowTwistAngles()
        {
            if (m_deformer == null)
            {
                base.ShowTwistAngles();
                return;
            }

            Handles.color = Color.green;
            int steps = GetStepsPerCurve();

            if (steps <= 0)
            {
                steps = 1;
            }
            else if (steps > 5)
            {
                steps = 5;
            }

            ScaffoldWrapper[] scaffolds = m_deformer.Scaffolds;
            for (int i = 0; i < scaffolds.Length; ++i)
            {
                ScaffoldWrapper scaffold = m_deformer.Scaffolds[i];
                for (int ci = 0; ci < scaffold.CurveIndices.Length; ++ci)
                {
                    int curveIndex = scaffold.CurveIndices[ci];
                    for (int j = 0; j <= steps; j++)
                    {
                        float   t     = (float)j / steps;
                        Vector3 dir   = m_deformer.GetDirection(t, curveIndex);
                        Vector3 point = m_deformer.GetPoint(t, curveIndex);

                        if (scaffold.IsRigid)
                        {
                            t = 1.0f;
                        }
                        float twistAngle = m_deformer.GetTwist(t, curveIndex);

                        Vector3 v3;
                        Vector3 up = GetUpVector();
                        if (Mathf.Abs(Vector3.Dot(dir, up)) < 1.0f)
                        {
                            v3 = Vector3.Cross(dir, up).normalized;
                        }
                        else
                        {
                            v3 = Vector3.Cross(dir, GetSideVector()).normalized;
                        }

                        if (dir == Vector3.zero)
                        {
                            continue;
                        }

                        Handles.DrawLine(point, point + Quaternion.AngleAxis(twistAngle, dir) * Quaternion.LookRotation(v3, up) * Vector3.forward * TwistAngleScale);
                    }
                }
            }
        }
        private void Update()
        {
            if (Input.GetMouseButtonDown(0))
            {
                Ray        ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                RaycastHit hitInfo;
                if (Physics.Raycast(ray, out hitInfo))
                {
                    Scaffold scaffold = hitInfo.collider.gameObject.GetComponent <Scaffold>();
                    if (scaffold)
                    {
                        ScaffoldWrapper scaffoldWrapper = MeshDeformer.Scaffolds.Where(s => s.Obj == scaffold).FirstOrDefault();
                        int             curveIndex      = scaffoldWrapper.CurveIndices[0];
                        if (scaffoldWrapper.CurveIndices.Length > 1)
                        {
                            Debug.LogError("Not Supported");
                            return;
                        }

                        Vector3 hitPoint = hitInfo.point;

                        float t = CurveUtils.GetT(MeshDeformer, curveIndex, hitPoint);
                        Debug.Log(t);

                        GameObject         obj    = Instantiate(ObjPrefab);
                        MeshDeformerFollow follow = obj.GetComponent <MeshDeformerFollow>();
                        follow.Spline = MeshDeformer;
                        follow.T      = t;
                    }
                }
            }
        }
        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 static void RecalculateNormals(MeshDeformer deformer)
        {
            for (int i = 0; i < deformer.Scaffolds.Length; ++i)
            {
                ScaffoldWrapper scaffold = deformer.Scaffolds[i];
                if (scaffold.Obj == null)
                {
                    continue;
                }

                MeshFilter   filter   = scaffold.Obj.GetComponent <MeshFilter>();
                MeshCollider collider = scaffold.Obj.GetComponent <MeshCollider>();

                if (filter != null)
                {
                    Mesh colliderMesh = null;
                    if (collider != null)
                    {
                        collider.sharedMesh      = Object.Instantiate(deformer.ColliderOriginal);
                        collider.sharedMesh.name = deformer.ColliderOriginal.name + " Deformed";
                        colliderMesh             = collider.sharedMesh;
                    }

                    filter.sharedMesh      = Object.Instantiate(deformer.Original);
                    filter.sharedMesh.name = deformer.Original.name + " Deformed";
                    scaffold.Wrap(filter.sharedMesh, colliderMesh, deformer.Axis, scaffold.CurveIndices, scaffold.SliceCount);
                    scaffold.Deform(deformer, deformer.Original, deformer.ColliderOriginal);
                    scaffold.RecalculateNormals();
                }
            }

            ScaffoldWrapper prev = null;

            if (deformer.Loop)
            {
                prev = deformer.Scaffolds[deformer.Scaffolds.Length - 1];
            }

            for (int i = 0; i < deformer.Scaffolds.Length; ++i)
            {
                ScaffoldWrapper scaffold = deformer.Scaffolds[i];
                scaffold.SlerpContacts(deformer, deformer.Original, deformer.ColliderOriginal, prev, null);
                scaffold = prev;
            }
        }
Exemple #5
0
        private void Start()
        {
            if (m_deformer == null)
            {
                m_deformer = GetComponentInParent <MeshDeformer>();
            }

#if UNITY_EDITOR
            //Something strange happening when removing MeshDeformerExt obj and then pressing CTRL+Z. (Can't deform recovered object)
            //And now I am unable to find good solution.
            //This needed to fix this behavior...
            ScaffoldWrapper wrapper = m_deformer.Scaffolds.Where(s => s.ObjInstanceId == InstanceId).FirstOrDefault();
            if (wrapper != null)
            {
                wrapper.Obj = this;
            }
#endif
        }
        protected override bool DrawSelectedPointInspectorOverride()
        {
            if (m_deformer == null)
            {
                return(true);
            }

            EditorGUI.BeginChangeCheck();
            int curveIndex = SelectedIndex / 3;

            if (curveIndex == m_deformer.CurveCount)
            {
                if (m_deformer.Loop)
                {
                    curveIndex = 0;
                }
                else
                {
                    curveIndex--;
                }
            }

            ScaffoldWrapper scaffold = m_deformer.FindScaffold(curveIndex);

            if (scaffold == null)
            {
                return(true);
            }

            bool isRigid = EditorGUILayout.Toggle("Is Rigid", scaffold.IsRigid);

            if (EditorGUI.EndChangeCheck())
            {
                Undo.RecordObject(m_deformer, UNDO_CHANGEMODE);
                EditorUtility.SetDirty(m_deformer);

                m_deformer.SetIsRigid(SelectedIndex, isRigid);
            }

            return(!isRigid);
        }
        private void OnDrawGizmosSelected()
        {
            MeshDeformer deformer = m_spline as MeshDeformer;

            if (deformer == null)
            {
                return;
            }

            if (Selection.activeGameObject != gameObject)
            {
                return;
            }

            if (!deformer.DrawGizmos)
            {
                return;
            }
            // Display the explosion radius when selected
            Gizmos.color = Color.white;

            ScaffoldWrapper scaffold = deformer.Scaffolds.Where(s => s.CurveIndices.Contains((Index - 1) / 3)).FirstOrDefault();

            if (scaffold != null && !scaffold.IsEmptySpace)
            {
                if (scaffold.Obj != null)
                {
                    MeshFilter filter = scaffold.Obj.GetComponent <MeshFilter>();
                    if (filter != null)
                    {
                        Mesh mesh = filter.sharedMesh;
                        if (mesh != null)
                        {
                            Gizmos.matrix = deformer.transform.localToWorldMatrix;
                            Gizmos.DrawWireMesh(mesh);
                        }
                    }
                }
            }
        }
        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);
                    }
                }
            }
        }
Exemple #9
0
        private void OnDrawGizmosSelected()
        {
            if (m_deformer == null)
            {
                return;
            }

            if (Selection.activeGameObject != gameObject)
            {
                return;
            }

            if (!m_deformer.DrawGizmos)
            {
                return;
            }

            Gizmos.color = Color.white;

            ScaffoldWrapper scaffold = m_deformer.Scaffolds.Where(s => s.Obj == this).FirstOrDefault();

            if (scaffold != null && !scaffold.IsEmptySpace)
            {
                if (scaffold.Obj != null)
                {
                    MeshFilter filter = scaffold.Obj.GetComponent <MeshFilter>();
                    if (filter != null)
                    {
                        Mesh mesh = filter.sharedMesh;
                        if (mesh != null)
                        {
                            Gizmos.matrix = m_deformer.transform.localToWorldMatrix;
                            Gizmos.DrawWireMesh(mesh);
                        }
                    }
                }
            }
        }
        public static void Subdivide()
        {
            GameObject   selected   = Selection.activeObject as GameObject;
            MeshDeformer deformer   = selected.GetComponentInParent <MeshDeformer>();
            MeshFilter   meshFilter = null;

            if (deformer != null && deformer.Original != null)
            {
                if (!EditorUtility.DisplayDialog("Are you sure?", "This action is irreversible. Are you sure you want to subdivide mesh?", "Ok", "Cancel"))
                {
                    return;
                }

                string name = deformer.Original.name;
                deformer.Original      = MeshSubdivider.Subdivide4(deformer.Original);
                deformer.Original.name = name;

                if (deformer.ColliderOriginal != null)
                {
                    name = deformer.ColliderOriginal.name;
                    deformer.ColliderOriginal      = MeshSubdivider.Subdivide4(deformer.ColliderOriginal);
                    deformer.ColliderOriginal.name = name;
                }

                for (int i = 0; i < deformer.Scaffolds.Length; ++i)
                {
                    ScaffoldWrapper scaffold = deformer.Scaffolds[i];
                    if (scaffold.Obj == null)
                    {
                        continue;
                    }

                    MeshFilter   filter   = scaffold.Obj.GetComponent <MeshFilter>();
                    MeshCollider collider = scaffold.Obj.GetComponent <MeshCollider>();

                    if (filter != null)
                    {
                        Mesh colliderMesh = null;
                        if (collider != null)
                        {
                            collider.sharedMesh      = Object.Instantiate(deformer.ColliderOriginal);
                            collider.sharedMesh.name = deformer.ColliderOriginal.name + " Deformed";
                            colliderMesh             = collider.sharedMesh;
                        }

                        filter.sharedMesh      = Object.Instantiate(deformer.Original);
                        filter.sharedMesh.name = deformer.Original.name + " Deformed";
                        scaffold.Wrap(filter.sharedMesh, colliderMesh, deformer.Axis, scaffold.CurveIndices, scaffold.SliceCount);
                        scaffold.Deform(deformer, deformer.Original, deformer.ColliderOriginal);
                        scaffold.RecalculateNormals();
                    }
                }

                ScaffoldWrapper prev = null;
                if (deformer.Loop)
                {
                    prev = deformer.Scaffolds[deformer.Scaffolds.Length - 1];
                }

                for (int i = 0; i < deformer.Scaffolds.Length; ++i)
                {
                    ScaffoldWrapper scaffold = deformer.Scaffolds[i];
                    scaffold.SlerpContacts(deformer, deformer.Original, deformer.ColliderOriginal, prev, null);
                    scaffold = prev;
                }
            }
            else
            {
                meshFilter = selected.GetComponent <MeshFilter>();
                Mesh mesh = meshFilter.sharedMesh;
                Undo.RecordObject(selected, "Battlehub.MeshDeformer Subdivide");
                Undo.RecordObject(meshFilter, "Battlehub.MeshDeformer Subdivide");
                meshFilter.sharedMesh      = MeshSubdivider.Subdivide4(mesh);
                meshFilter.sharedMesh.name = mesh.name;

                MeshCollider collider = selected.GetComponent <MeshCollider>();
                if (collider != null)
                {
                    Mesh colliderMesh = collider.sharedMesh;
                    Undo.RecordObject(selected, "Battlehub.MeshDeformer Subdivide");
                    Undo.RecordObject(collider, "Battlehub.MeshDeformer Subdivide");
                    collider.sharedMesh      = MeshSubdivider.Subdivide4(colliderMesh);
                    collider.sharedMesh.name = colliderMesh.name;
                }
            }
        }
Exemple #11
0
        protected override void OnInspectorGUIOverride()
        {
            if (m_meshDeformer == null)
            {
                m_meshDeformer = (MeshDeformer)GetTarget();
            }

            if (m_meshDeformer == null)
            {
                return;
            }

            Scaffold        scaffold        = (Scaffold)target;
            ScaffoldWrapper scaffoldWrapper = null;
            int             scaffoldIndex   = -1;

            for (int i = 0; i < m_meshDeformer.Scaffolds.Length; ++i)
            {
                if (scaffold == m_meshDeformer.Scaffolds[i].Obj)
                {
                    scaffoldIndex   = i;
                    scaffoldWrapper = m_meshDeformer.Scaffolds[i];
                    break;
                }
            }

            if (scaffoldWrapper != null)
            {
                EditorGUI.BeginChangeCheck();
                Mesh altMesh = (Mesh)EditorGUILayout.ObjectField("Alt Mesh", scaffold.AltMesh, typeof(Mesh), false);
                if (EditorGUI.EndChangeCheck())
                {
                    EditorUtility.SetDirty(scaffold);
                    scaffold.AltMesh = altMesh;
                    m_meshDeformer.WrapAndDeform(scaffoldWrapper, altMesh);
                }

                if (GUILayout.Button("Reload Mesh"))
                {
                    EditorUtility.SetDirty(scaffold);
                    scaffold.AltMesh = altMesh;
                    m_meshDeformer.WrapAndDeform(scaffoldWrapper, altMesh);
                }

                if (GUILayout.Button("Invert Mesh"))
                {
                    Mesh invertedMesh = ScaleMesh(scaffold.transform, new Vector3(-1, 1, 1), scaffold.SourceMesh);
                    scaffold.AltMesh = invertedMesh;
                    m_meshDeformer.WrapAndDeform(scaffoldWrapper, invertedMesh);
                }

                EditorGUI.BeginChangeCheck();
                bool isRigid = EditorGUILayout.Toggle("Is Rigid", scaffoldWrapper.IsRigid);
                if (EditorGUI.EndChangeCheck())
                {
                    Undo.RecordObject(m_meshDeformer, UNDO_CHANGEMODE);
                    RecordScaffolds(m_meshDeformer, "Battlehub.MeshDeformer.Prepend");
                    EditorUtility.SetDirty(m_meshDeformer);

                    for (int i = 0; i < scaffoldWrapper.CurveIndices.Length; ++i)
                    {
                        int curveIndex = scaffoldWrapper.CurveIndices[i];
                        m_meshDeformer.SetIsRigid(curveIndex * 3, isRigid);
                    }
                }
            }

            if (scaffold.gameObject != m_meshDeformer.gameObject)
            {
                GUILayout.BeginHorizontal();
                {
                    if (scaffoldIndex == 0)
                    {
                        if (GUILayout.Button("Prepend"))
                        {
                            Undo.RecordObject(m_meshDeformer, "Battlehub.MeshDeformer.Prepend");
                            RecordScaffolds(m_meshDeformer, "Battlehub.MeshDeformer.Prepend");
                            Undo.RegisterCreatedObjectUndo(m_meshDeformer.Prepend(), "Battlehub.MeshDeformer.Prepend");
                            EditorUtility.SetDirty(m_meshDeformer);
                            Selection.activeGameObject = m_meshDeformer.GetComponentsInChildren <ControlPoint>(true).First().gameObject;
                        }
                    }

                    if (scaffoldWrapper != null)
                    {
                        if (GUILayout.Button("Insert"))
                        {
                            int curveIndex = scaffoldWrapper.CurveIndices.Min();

                            Undo.RecordObject(m_meshDeformer, "Battlehub.MeshDeformer.Insert");
                            Undo.RegisterCreatedObjectUndo(m_meshDeformer.Insert(curveIndex), "Battlehub.MeshDeformer.Insert");
                            EditorUtility.SetDirty(m_meshDeformer);
                            Selection.activeGameObject = m_meshDeformer.GetComponentsInChildren <ControlPoint>(true).ElementAt(curveIndex + 3).gameObject;
                        }
                    }

                    if (scaffoldIndex == m_meshDeformer.Scaffolds.Length - 1)
                    {
                        if (GUILayout.Button("Append"))
                        {
                            Undo.RecordObject(m_meshDeformer, "Battlehub.MeshDeformer.Append");
                            Undo.RegisterCreatedObjectUndo(m_meshDeformer.Append(), "Battlehub.MeshDeformer.Append");
                            EditorUtility.SetDirty(m_meshDeformer);
                            Selection.activeGameObject = m_meshDeformer.GetComponentsInChildren <ControlPoint>(true).Last().gameObject;
                        }
                    }
                }
                GUILayout.EndHorizontal();
            }

            if (scaffoldWrapper != null)
            {
                if (GUILayout.Button("Straighten"))
                {
                    Undo.RecordObject(m_meshDeformer, "Battlehub.MeshDeformer.Straighten");
                    RecordScaffolds(m_meshDeformer, "Battlehub.MeshDeformer.Straighten");
                    EditorUtility.SetDirty(m_meshDeformer);
                    m_meshDeformer.Straighten(scaffoldWrapper.CurveIndices.Min() * 3 + 1);
                }
            }
        }
Exemple #12
0
        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);
            }
        }
Exemple #13
0
        protected override void OnInspectorGUIOverride()
        {
            if (m_meshDeformer == null)
            {
                m_meshDeformer = (MeshDeformer)GetTarget();
            }

            if (m_meshDeformer == null)
            {
                return;
            }

            Scaffold        scaffold        = (Scaffold)target;
            ScaffoldWrapper scaffoldWrapper = null;
            int             scaffoldIndex   = -1;

            for (int i = 0; i < m_meshDeformer.Scaffolds.Length; ++i)
            {
                if (scaffold == m_meshDeformer.Scaffolds[i].Obj)
                {
                    scaffoldIndex   = i;
                    scaffoldWrapper = m_meshDeformer.Scaffolds[i];
                    break;
                }
            }

            if (scaffoldWrapper != null)
            {
                EditorGUI.BeginChangeCheck();
                bool isRigid = EditorGUILayout.Toggle("Is Rigid", scaffoldWrapper.IsRigid);
                if (EditorGUI.EndChangeCheck())
                {
                    Undo.RecordObject(m_meshDeformer, UNDO_CHANGEMODE);
                    RecordScaffolds(m_meshDeformer, "Battlehub.MeshDeformer.Prepend");
                    EditorUtility.SetDirty(m_meshDeformer);

                    for (int i = 0; i < scaffoldWrapper.CurveIndices.Length; ++i)
                    {
                        int curveIndex = scaffoldWrapper.CurveIndices[i];
                        m_meshDeformer.SetIsRigid(curveIndex * 3, isRigid);
                    }
                }
            }

            if (scaffold.gameObject != m_meshDeformer.gameObject)
            {
                GUILayout.BeginHorizontal();
                {
                    if (scaffoldIndex == m_meshDeformer.Scaffolds.Length - 1)
                    {
                        if (GUILayout.Button("Append"))
                        {
                            Undo.RecordObject(m_meshDeformer, "Battlehub.MeshDeformer.Append");
                            Undo.RegisterCreatedObjectUndo(m_meshDeformer.Extend(), "Battlehub.MeshDeformer.Append");
                            EditorUtility.SetDirty(m_meshDeformer);
                            Selection.activeGameObject = m_meshDeformer.GetComponentsInChildren <ControlPoint>(true).Last().gameObject;
                        }
                    }

                    if (scaffoldIndex == 0)
                    {
                        if (GUILayout.Button("Prepend"))
                        {
                            Undo.RecordObject(m_meshDeformer, "Battlehub.MeshDeformer.Prepend");
                            RecordScaffolds(m_meshDeformer, "Battlehub.MeshDeformer.Prepend");
                            Undo.RegisterCreatedObjectUndo(m_meshDeformer.Extend(true), "Battlehub.MeshDeformer.Prepend");
                            EditorUtility.SetDirty(m_meshDeformer);
                            Selection.activeGameObject = m_meshDeformer.GetComponentsInChildren <ControlPoint>(true).First().gameObject;
                        }
                    }
                }
                GUILayout.EndHorizontal();
            }

            if (scaffoldWrapper != null)
            {
                if (GUILayout.Button("Straighten"))
                {
                    Undo.RecordObject(m_meshDeformer, "Battlehub.MeshDeformer.Straighten");
                    RecordScaffolds(m_meshDeformer, "Battlehub.MeshDeformer.Straighten");
                    EditorUtility.SetDirty(m_meshDeformer);
                    m_meshDeformer.Straighten(scaffoldWrapper.CurveIndices.Min() * 3 + 1);
                }
            }
        }