Example #1
0
    static void MakeHead(Transform _headPoint, Transform _chestPoint, Vector3 _headTop)
    {
        float headScale = Vector3.Distance(_chestPoint.position, _headPoint.position) * .01f;


        Selection.activeObject = GameObject.Find("Spine_05");

        Puppet2D_BoneCreation.CreateBoneTool();
        Puppet2D_BoneCreation.BoneCreationMode(_headPoint.position);
        Puppet2D_BoneCreation.BoneCreationMode(_headTop);

        Puppet2D_BoneCreation.BoneFinishCreation();
        GameObject head = GameObject.Find("bone_1");

        head.name = "Head";
        Selection.activeGameObject = head;
        GameObject headEnd = GameObject.Find("bone_2");

        headEnd.name = "HeadEnd";

        Puppet2D_CreateControls.CreateOrientControl();
        GameObject headControl = GameObject.Find("Head_CTRL");

        headControl.GetComponent <Puppet2D_ParentControl>().ConstrianedPosition = true;
        GameObject headControlParent = GameObject.Find("Head_CTRL_GRP");

        headControlParent.transform.localScale = Vector3.one * headScale * 2f;
        //GameObject.Find ("bone_22").name = ("a");
    }
Example #2
0
    public static void BoneFinishCreation()
    {
        Puppet2D_Editor.BoneCreation = false;
        EditorPrefs.SetBool("Puppet2D_BoneCreation", false);

        Puppet2D_HiddenBone[] hiddenBones = GameObject.FindObjectsOfType <Puppet2D_HiddenBone>();


        SpriteRenderer[] sprites = GameObject.FindObjectsOfType <SpriteRenderer>();
        foreach (SpriteRenderer spr in sprites)
        {
            if (spr.sprite != null && spr.sprite.name == "BoneNoJoint" && spr.transform.parent == null)
            {
                GameObject globalCtrlNew = Puppet2D_CreateControls.CreateGlobalControl();

                spr.transform.parent = globalCtrlNew.transform;
            }
        }


        GameObject globalCtrl = Puppet2D_CreateControls.CreateGlobalControl();

        if (globalCtrl != null)
        {
            foreach (Puppet2D_HiddenBone hiddenBone in hiddenBones)
            {
                if (hiddenBone && hiddenBone.transform.parent && hiddenBone.transform.parent.parent == null)
                {
                    hiddenBone.transform.parent.parent = globalCtrl.transform;
                }
            }
        }
    }
Example #3
0
    static void CreateSpline()
    {
        if (splineStoreData.FFDCtrls.Count > 2 && splineStoreData.FFDCtrls[0] && splineStoreData.FFDCtrls[1] && splineStoreData.FFDCtrls[2])
        {
            GameObject tangentCtrl = new GameObject(Puppet2D_BoneCreation.GetUniqueBoneName("spline_Tangent"));
            Undo.RegisterCreatedObjectUndo(tangentCtrl, "Created splineTangent");
            splineStoreData.FFDCtrls.Add(tangentCtrl.transform);
            tangentCtrl.transform.parent        = splineStoreData.FFDCtrls[splineStoreData.FFDCtrls.Count - 2].transform;
            tangentCtrl.transform.localPosition = Vector3.zero;
            SpriteRenderer spriteRenderer = splineStoreData.FFDCtrls[splineStoreData.FFDCtrls.Count - 2].GetComponent <SpriteRenderer>();
            string         path           = (Puppet2D_Editor._puppet2DPath + "/Textures/GUI/splineControl.psd");
            Sprite         sprite         = AssetDatabase.LoadAssetAtPath(path, typeof(Sprite)) as Sprite;
            spriteRenderer.sprite = sprite;

            splineStoreData.FFDCtrls[1].position += splineStoreData.FFDCtrls[0].position - splineStoreData.FFDCtrls[2].position;

            splineStoreData.FFDCtrls[splineStoreData.FFDCtrls.Count - 1].position += splineStoreData.FFDCtrls[splineStoreData.FFDCtrls.Count - 2].position - splineStoreData.FFDCtrls[splineStoreData.FFDCtrls.Count - 3].position;

            Transform splineCtrlSwap = splineStoreData.FFDCtrls[0];
            splineStoreData.FFDCtrls[0] = splineStoreData.FFDCtrls[1];
            splineStoreData.FFDCtrls[1] = splineCtrlSwap;

            //GameObject OffsetGroup = new GameObject(Puppet2D_BoneCreation.GetUniqueBoneName("spline_GRP"));
            Puppet2D_SplineControl spline = SplineCreationGroup.AddComponent <Puppet2D_SplineControl>();

            spline._splineCTRLS.AddRange(splineStoreData.FFDCtrls);
            spline.numberBones = Puppet2D_Editor.numberSplineJoints;
            List <GameObject> splineBones = spline.Create();
            foreach (GameObject splineBone in splineBones)
            {
                splineBone.GetComponent <SpriteRenderer>().sortingLayerName = Puppet2D_Editor._boneSortingLayer;
            }
            foreach (Transform ctrl in splineStoreData.FFDCtrls)
            {
                if (!ctrl.parent.parent)
                {
                    ctrl.parent.parent = SplineCreationGroup.transform;
                }
            }
            GameObject globalCtrl = Puppet2D_CreateControls.CreateGlobalControl();
            globalCtrl.GetComponent <Puppet2D_GlobalControl>()._SplineControls.Add(spline);
            SplineCreationGroup.transform.parent = globalCtrl.transform;

            globalCtrl.GetComponent <Puppet2D_GlobalControl>().Run();

            Undo.DestroyObjectImmediate(splineStoreData);

            splineStoreData.FFDCtrls.Clear();
        }
    }
Example #4
0
    static void MakeLimb(Transform _thighLPoint, Transform _footLPoint, Transform _kneePoint, Vector3 FootEnd, GameObject parentTo, string controlName, string controlName3, string controlName2, string controlName1, bool flip = false)
    {
        Selection.activeObject = parentTo;

        float   limbScale     = Vector3.Distance(_footLPoint.position, _thighLPoint.position) * .01f;
        Vector3 scaledFootPos = (_footLPoint.position - _thighLPoint.position) / limbScale;

        scaledFootPos += _thighLPoint.position;

        Vector3 scaledKneePos = (_kneePoint.position - _thighLPoint.position) / limbScale;

        scaledKneePos += _thighLPoint.position;

        Puppet2D_BoneCreation.CreateBoneTool();
        Puppet2D_BoneCreation.BoneCreationMode(_thighLPoint.position);

        Puppet2D_BoneCreation.BoneCreationMode(scaledKneePos);
        GameObject endLimbGO = Puppet2D_BoneCreation.BoneCreationMode(scaledFootPos);

        Vector3 scaledFinalEndLimbGO = (FootEnd - _thighLPoint.position) / limbScale;

        scaledFinalEndLimbGO += _thighLPoint.position;

        GameObject finalEndLimbGO = Puppet2D_BoneCreation.BoneCreationMode(scaledFinalEndLimbGO);

        finalEndLimbGO.name = (controlName1 + "End");

        Puppet2D_BoneCreation.BoneFinishCreation();

        Selection.activeGameObject = endLimbGO;
        endLimbGO.name             = controlName1;
        Puppet2D_CreateControls.IKCreateTool(true);
        GameObject limbControlParent = GameObject.Find(controlName1 + "_CTRL_GRP");

        Transform elbow        = endLimbGO.transform.parent;
        Transform shoulderBone = endLimbGO.transform.parent.parent;

        elbow.name        = (controlName2);
        shoulderBone.name = (controlName3);

        Transform limbParent = limbControlParent.transform.parent;

        limbControlParent.transform.parent = shoulderBone;
        shoulderBone.localScale            = shoulderBone.localScale * limbScale;
        limbControlParent.transform.parent = limbParent;
        GameObject.Find(controlName1 + "_CTRL").GetComponent <Puppet2D_IKHandle> ().Flip = flip;
    }
Example #5
0
    public static void ConvertSpriteToMesh(int triIndex)
    {
        GameObject[] selection = Selection.gameObjects;
        foreach (GameObject spriteGO in selection)
        {
            if (spriteGO.GetComponent <SpriteRenderer>())
            {
                string spriteName = spriteGO.GetComponent <SpriteRenderer>().sprite.name;
                if (spriteName.Contains("Bone"))
                {
                    Debug.LogWarning("You can't convert Bones to Mesh");
                    return;
                }
                if ((spriteName == "orientControl") || (spriteName == "parentControl") || (spriteName == "VertexHandleControl") || (spriteName == "IKControl"))
                {
                    Debug.LogWarning("You can't convert Controls to Mesh");
                    return;
                }
                PolygonCollider2D polyCol;
                GameObject        MeshedSprite;
                Quaternion        rot = spriteGO.transform.rotation;
                spriteGO.transform.eulerAngles = Vector3.zero;
                int    layer        = spriteGO.layer;
                string sortingLayer = spriteGO.GetComponent <Renderer>().sortingLayerName;
                int    sortingOrder = spriteGO.GetComponent <Renderer>().sortingOrder;


                if (spriteGO.GetComponent <PolygonCollider2D>() == null)
                {
                    polyCol = Undo.AddComponent <PolygonCollider2D> (spriteGO);
                    Puppet2D_CreatePolygonFromSprite polyFromSprite = ScriptableObject.CreateInstance("Puppet2D_CreatePolygonFromSprite") as Puppet2D_CreatePolygonFromSprite;
                    MeshedSprite = polyFromSprite.Run(spriteGO.transform, true, triIndex);

                    MeshedSprite.name = (spriteGO.name + "_GEO");
                    DestroyImmediate(polyFromSprite);
                    Undo.DestroyObjectImmediate(polyCol);
                }
                else
                {
                    polyCol = spriteGO.GetComponent <PolygonCollider2D>();

                    Puppet2D_CreatePolygonFromSprite polyFromSprite = ScriptableObject.CreateInstance("Puppet2D_CreatePolygonFromSprite") as Puppet2D_CreatePolygonFromSprite;
                    MeshedSprite = polyFromSprite.Run(spriteGO.transform, true, triIndex);

                    MeshedSprite.name = (spriteGO.name + "_GEO");

                    DestroyImmediate(polyFromSprite);
                    Undo.DestroyObjectImmediate(polyCol);
                }
                MeshedSprite.layer = layer;
                MeshedSprite.GetComponent <Renderer>().sortingLayerName = sortingLayer;
                MeshedSprite.GetComponent <Renderer>().sortingOrder     = sortingOrder;
                MeshedSprite.AddComponent <Puppet2D_SortingLayer>();


                MeshedSprite.transform.position = spriteGO.transform.position;
                MeshedSprite.transform.rotation = rot;

                Sprite spriteInfo = spriteGO.GetComponent <SpriteRenderer>().sprite;

                TextureImporter textureImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(spriteInfo)) as TextureImporter;

                MeshedSprite.GetComponent <Renderer>().sharedMaterial.shader = Shader.Find("Unlit/Transparent");

                MeshedSprite.GetComponent <Renderer>().sharedMaterial.SetTexture("_MainTex", spriteInfo.texture);

                textureImporter.textureType = TextureImporterType.Sprite;

                DestroyImmediate(spriteGO);

                GameObject globalCtrl = Puppet2D_CreateControls.CreateGlobalControl();

                if (globalCtrl != null)
                {
                    MeshedSprite.transform.parent = globalCtrl.transform;
                }

                Selection.activeGameObject = MeshedSprite;
            }
            else
            {
                Debug.LogWarning("Object is not a sprite");
                return;
            }
        }
    }
Example #6
0
    void OnGUI()
    {
        string path  = ("Assets/Puppet2D/Textures/GUI/BoneNoJoint.psd");
        string path2 = ("Assets/Puppet2D/Textures/GUI/BoneScaled.psd");
        string path3 = ("Assets/Puppet2D/Textures/GUI/BoneJoint.psd");
        string path4 = ("Assets/Puppet2D/Textures/GUI/Bone.psd");

        boneNoJointSprite = AssetDatabase.LoadAssetAtPath(path, typeof(Sprite)) as Sprite;
        boneSprite        = AssetDatabase.LoadAssetAtPath(path2, typeof(Sprite)) as Sprite;
        boneHiddenSprite  = AssetDatabase.LoadAssetAtPath(path3, typeof(Sprite)) as Sprite;
        boneOriginal      = AssetDatabase.LoadAssetAtPath(path4, typeof(Sprite)) as Sprite;
        Texture aTexture         = AssetDatabase.LoadAssetAtPath("Assets/Puppet2D/Textures/GUI/GUI_Bones.png", typeof(Texture)) as Texture;
        Texture puppetManTexture = AssetDatabase.LoadAssetAtPath("Assets/Puppet2D/Textures/GUI/GUI_puppetman.png", typeof(Texture)) as Texture;
        Texture rigTexture       = AssetDatabase.LoadAssetAtPath("Assets/Puppet2D/Textures/GUI/GUI_Rig.png", typeof(Texture)) as Texture;
        Texture ControlTexture   = AssetDatabase.LoadAssetAtPath("Assets/Puppet2D/Textures/GUI/parentControl.psd", typeof(Texture)) as Texture;
        Texture VertexTexture    = AssetDatabase.LoadAssetAtPath("Assets/Puppet2D/Textures/GUI/VertexHandle.psd", typeof(Texture)) as Texture;


        string[] sortingLayers = GetSortingLayerNames();
        Color    bgColor       = GUI.backgroundColor;

        if (currentGUIChoice == GUIChoice.BoneCreation)
        {
            GUI.backgroundColor = Color.green;
        }

        if (GUI.Button(new Rect(0, 0, 80, 20), "Skeleton"))
        {
            currentGUIChoice = GUIChoice.BoneCreation;
        }

        GUI.backgroundColor = bgColor;
        if (currentGUIChoice == GUIChoice.RigginSetup)
        {
            GUI.backgroundColor = Color.green;
        }

        if (GUI.Button(new Rect(80, 0, 80, 20), "Rigging"))
        {
            currentGUIChoice = GUIChoice.RigginSetup;
        }
        GUI.backgroundColor = bgColor;
        if (currentGUIChoice == GUIChoice.Skinning)
        {
            GUI.backgroundColor = Color.green;
        }

        if (GUI.Button(new Rect(160, 0, 80, 20), "Skinning"))
        {
            currentGUIChoice = GUIChoice.Skinning;
        }
        GUI.backgroundColor = bgColor;
        if (currentGUIChoice == GUIChoice.Animation)
        {
            GUI.backgroundColor = Color.green;
        }

        if (GUI.Button(new Rect(240, 0, 80, 20), "Animation"))
        {
            currentGUIChoice = GUIChoice.Animation;
        }
        GUI.backgroundColor = bgColor;

        if (EditSkinWeights || SplineCreation || FFDCreation)
        {
            GUI.backgroundColor = Color.grey;
        }


        GUI.DrawTexture(new Rect(25, 40, 32, 32), boneSprite.texture, ScaleMode.StretchToFill, true, 10.0F);

        EditorGUI.BeginChangeCheck();
        BoneSize = EditorGUI.Slider(new Rect(80, 40, 150, 20), BoneSize, 0F, 0.9999F);
        if (EditorGUI.EndChangeCheck())
        {
            ChangeBoneSize();
            EditorPrefs.SetFloat("Puppet2D_EditorBoneSize", BoneSize);
        }
        EditorGUI.BeginChangeCheck();
        _boneSortingIndex = EditorGUI.Popup(new Rect(80, 60, 150, 30), _boneSortingIndex, sortingLayers);
        if (EditorGUI.EndChangeCheck())
        {
            EditorPrefs.SetInt("Puppet2D_BoneLayer", _boneSortingIndex);
        }
        if (sortingLayers.Length <= _boneSortingIndex)
        {
            _boneSortingIndex = 0;
            EditorPrefs.SetInt("Puppet2D_BoneLayer", _boneSortingIndex);
        }
        _boneSortingLayer = sortingLayers[_boneSortingIndex];


        GUI.DrawTexture(new Rect(25, 100, 32, 32), ControlTexture, ScaleMode.StretchToFill, true, 10.0F);

        EditorGUI.BeginChangeCheck();
        ControlSize = EditorGUI.Slider(new Rect(80, 100, 150, 20), ControlSize, 0F, .9999F);
        if (EditorGUI.EndChangeCheck())
        {
            ChangeControlSize();
            EditorPrefs.SetFloat("Puppet2D_EditorControlSize", ControlSize);
        }
        EditorGUI.BeginChangeCheck();
        _controlSortingIndex = EditorGUI.Popup(new Rect(80, 130, 150, 30), _controlSortingIndex, sortingLayers);
        if (EditorGUI.EndChangeCheck())
        {
            EditorPrefs.SetInt("Puppet2D_ControlLayer", _controlSortingIndex);
        }
        if (sortingLayers.Length <= _controlSortingIndex)
        {
            _controlSortingIndex = 0;
            EditorPrefs.SetInt("Puppet2D_ControlLayer", _controlSortingIndex);
        }
        _controlSortingLayer = sortingLayers[_controlSortingIndex];


        GUI.DrawTexture(new Rect(15, 160, 275, 5), aTexture, ScaleMode.StretchToFill, true, 10.0F);

        int offsetControls = 130;

        if (currentGUIChoice == GUIChoice.BoneCreation)
        {
            //GUILayout.Label("Bone Creation", EditorStyles.boldLabel);

            GUILayout.Space(15);
            GUI.DrawTexture(new Rect(0, 60 + offsetControls, 64, 128), aTexture, ScaleMode.StretchToFill, true, 10.0F);
            GUILayout.Space(15);


            if (BoneCreation)
            {
                GUI.backgroundColor = Color.green;
            }


            if (GUI.Button(new Rect(80, 60 + offsetControls, 150, 30), "Create Bone Tool"))
            {
                BoneCreation      = true;
                currentActiveBone = null;
                EditorPrefs.SetBool("Puppet2D_BoneCreation", BoneCreation);
            }
            if (BoneCreation)
            {
                GUI.backgroundColor = bgColor;
            }


            if (GUI.Button(new Rect(80, 90 + offsetControls, 150, 30), "Finish Bone"))
            {
                Puppet2D_BoneCreation.BoneFinishCreation();
            }

            if (BoneCreation)
            {
                GUI.backgroundColor = Color.grey;
            }



            if (SplineCreation)
            {
                GUI.backgroundColor = Color.green;
            }
            if (GUI.Button(new Rect(80, 150 + offsetControls, 150, 30), "Create Spline Tool"))
            {
                //Puppet2D_Spline.splineStoreData.FFDCtrls.Clear();
                //SplineCreation = true;
                Puppet2D_Spline.CreateSplineTool();
            }
            if (SplineCreation)
            {
                GUI.backgroundColor = bgColor;
            }
            numberSplineJoints = EditorGUI.IntSlider(new Rect(80, 190 + offsetControls, 150, 20), numberSplineJoints, 1, 10);

            if (GUI.Button(new Rect(80, 220 + offsetControls, 150, 30), "Finish Spline"))
            {
                Puppet2D_Spline.SplineFinishCreation();
            }
        }
        if (currentGUIChoice == GUIChoice.RigginSetup)
        {
            // GUILayout.Label("Rigging Setup", EditorStyles.boldLabel);

            GUI.DrawTexture(new Rect(0, 60 + offsetControls, 64, 128), rigTexture, ScaleMode.StretchToFill, true, 10.0F);
            if (GUI.Button(new Rect(80, 60 + offsetControls, 150, 30), "Create IK Control"))
            {
                Puppet2D_CreateControls.IKCreateTool();
            }
            if (GUI.Button(new Rect(80, 90 + offsetControls, 150, 30), "Create Parent Control"))
            {
                Puppet2D_CreateControls.CreateParentControl();
            }
            if (GUI.Button(new Rect(80, 120 + offsetControls, 150, 30), "Create Orient Control"))
            {
                Puppet2D_CreateControls.CreateOrientControl();
            }

            /*if (GUI.Button(new Rect(80, 160+offsetControls, 150, 30), "Create Avatar"))
             * {
             * Puppet2D_CreateControls.CreateAvatar();
             *
             * }*/
        }
        if (currentGUIChoice == GUIChoice.Skinning)
        {
            //GUILayout.Label("Skinning", EditorStyles.boldLabel);

            GUI.DrawTexture(new Rect(0, 50 + offsetControls, 64, 128), puppetManTexture, ScaleMode.StretchToFill, true, 10.0F);

            GUILayout.Space(55 + offsetControls);
            GUIStyle labelNew = EditorStyles.label;
            labelNew.alignment     = TextAnchor.LowerLeft;
            labelNew.contentOffset = new Vector2(80, 0);
            GUILayout.Label("Type of Mesh: ", labelNew);
            labelNew.contentOffset = new Vector2(0, 0);
            string[] TriangulationTypes = { "0", "1", "2", "3" };

            _triangulationIndex = EditorGUI.Popup(new Rect(180, 60 + offsetControls, 50, 30), _triangulationIndex, TriangulationTypes);


            if (GUI.Button(new Rect(80, 80 + offsetControls, 150, 30), "Convert Sprite To Mesh"))
            {
                Puppet2D_Skinning.ConvertSpriteToMesh(_triangulationIndex);
            }
            if (GUI.Button(new Rect(80, 110 + offsetControls, 150, 30), "Parent Object To Bones"))
            {
                Puppet2D_Skinning.BindRigidSkin();
            }
            GUILayout.Space(75);
            labelNew.alignment     = TextAnchor.LowerLeft;
            labelNew.contentOffset = new Vector2(80, 0);
            GUILayout.Label("Num Skin Bones: ", labelNew);
            labelNew.contentOffset = new Vector2(0, 0);
            string[] NumberBonesToSkinTo = { "1", "2", "4 (FFD)" };

            _numberBonesToSkinToIndex = EditorGUI.Popup(new Rect(180, 150 + offsetControls, 50, 30), _numberBonesToSkinToIndex, NumberBonesToSkinTo);

            if (GUI.Button(new Rect(80, 170 + offsetControls, 150, 30), "Bind Smooth Skin"))
            {
                Puppet2D_Skinning.BindSmoothSkin();
            }
            if (EditSkinWeights || SkinWeightsPaint)
            {
                GUI.backgroundColor = Color.green;
            }
            if (SkinWeightsPaint)
            {
                if (GUI.Button(new Rect(80, 200 + offsetControls, 150, 30), "Manually Edit Weights"))
                {
                    // finish paint weights
                    Selection.activeGameObject = currentSelection;
                    if (currentSelection)
                    {
                        if (previousShader)
                        {
                            currentSelection.GetComponent <Renderer>().sharedMaterial.shader = previousShader;
                        }
                        SkinWeightsPaint = false;
                        if (previousVertColors != null && previousVertColors.Length > 0)
                        {
                            currentSelectionMesh.colors = previousVertColors;
                        }
                        currentSelectionMesh = null;
                        currentSelection     = null;
                        previousVertColors   = null;
                    }

                    EditSkinWeights = Puppet2D_Skinning.EditWeights();
                }
            }
            if (!SkinWeightsPaint)
            {
                if (GUI.Button(new Rect(80, 200 + offsetControls, 150, 30), "Paint Weights"))
                {
                    if (EditSkinWeights)
                    {
                        EditSkinWeights = false;
                        Object[] bakedMeshes = Puppet2D_Skinning.FinishEditingWeights();

                        Selection.objects = bakedMeshes;
                    }

                    if (Selection.activeGameObject && Selection.activeGameObject.GetComponent <SkinnedMeshRenderer>() && Selection.activeGameObject.GetComponent <SkinnedMeshRenderer>().sharedMesh)
                    {
                        SkinWeightsPaint = true;
                        SkinnedMeshRenderer smr = Selection.activeGameObject.GetComponent <SkinnedMeshRenderer>();
                        currentSelectionMesh = smr.sharedMesh;
                        currentSelection     = Selection.activeGameObject;
                        previousShader       = currentSelection.GetComponent <Renderer>().sharedMaterial.shader;
                        currentSelection.GetComponent <Renderer>().sharedMaterial.shader = Shader.Find("Puppet2D/vertColor");

                        if (currentSelectionMesh.colors.Length != currentSelectionMesh.vertices.Length)
                        {
                            currentSelectionMesh.colors = new Color[currentSelectionMesh.vertices.Length];
                            EditorUtility.SetDirty(currentSelection);
                            EditorUtility.SetDirty(currentSelectionMesh);
                            AssetDatabase.SaveAssets();
                            EditorApplication.SaveAssets();
                        }
                        else
                        {
                            previousVertColors = currentSelectionMesh.colors;
                        }
                        Selection.activeGameObject = smr.bones[0].gameObject;
                    }
                }
            }



            if (EditSkinWeights || SkinWeightsPaint)
            {
                GUI.backgroundColor = bgColor;
            }

            if (GUI.Button(new Rect(80, 230 + offsetControls, 150, 30), "Finish Edit Skin Weights"))
            {
                if (SkinWeightsPaint)
                {
                    if (currentSelection)
                    {
                        Selection.activeGameObject = currentSelection;

                        if (previousShader)
                        {
                            currentSelection.GetComponent <Renderer>().sharedMaterial.shader = previousShader;
                        }
                        SkinWeightsPaint = false;
                        if (previousVertColors != null && previousVertColors.Length > 0)
                        {
                            currentSelectionMesh.colors = previousVertColors;
                        }
                        currentSelectionMesh = null;
                        currentSelection     = null;
                        previousVertColors   = null;

                        Puppet2D_HiddenBone[] hiddenBones = Transform.FindObjectsOfType <Puppet2D_HiddenBone>();
                        foreach (Puppet2D_HiddenBone hiddenBone in hiddenBones)
                        {
                            hiddenBone.gameObject.GetComponent <SpriteRenderer>().color = Color.white;
                            if (hiddenBone.transform.parent != null)
                            {
                                hiddenBone.transform.parent.GetComponent <SpriteRenderer>().color = Color.white;
                            }
                        }
                    }
                    else
                    {
                        SkinWeightsPaint = false;
                    }
                }
                else
                {
                    EditSkinWeights = false;
                    Puppet2D_Skinning.FinishEditingWeights();
                }
            }
            float SkinWeightsPaintOffset = -80;

            if (EditSkinWeights)
            {
                SkinWeightsPaintOffset = -40;
                GUI.DrawTexture(new Rect(25, 260 + offsetControls, 32, 32), VertexTexture, ScaleMode.StretchToFill, true, 10.0F);
                EditorGUI.BeginChangeCheck();
                VertexHandleSize = EditorGUI.Slider(new Rect(80, 270 + offsetControls, 150, 20), VertexHandleSize, 0F, .9999F);
                if (EditorGUI.EndChangeCheck())
                {
                    ChangeVertexHandleSize();
                    EditorPrefs.SetFloat("Puppet2D_EditorVertexHandleSize", VertexHandleSize);
                }
            }
            if (SkinWeightsPaint)
            {
                SkinWeightsPaintOffset = -20;

                GUILayout.Space(offsetControls - 20);
                GUILayout.Label(" Brush Size", EditorStyles.boldLabel);
                EditSkinWeightRadius = EditorGUI.Slider(new Rect(80, 275 + offsetControls, 150, 20), EditSkinWeightRadius, 0F, 100F);
                GUILayout.Label(" Strength", EditorStyles.boldLabel);
                paintWeightsStrength = EditorGUI.Slider(new Rect(80, 295 + offsetControls, 150, 20), paintWeightsStrength, 0F, 1F);
            }

            if (EditSkinWeights || SkinWeightsPaint)
            {
                GUI.backgroundColor = Color.grey;
            }

            if (FFDCreation)
            {
                GUI.backgroundColor = Color.green;
            }

            if (GUI.Button(new Rect(80, 360 + offsetControls + SkinWeightsPaintOffset, 150, 30), "Create FFD Tool"))
            {
                if (!FFDCreation)
                {
                    FFDCreation = true;
                    if (Selection.activeGameObject && Selection.activeGameObject.GetComponent <SpriteRenderer>() && Selection.activeGameObject.GetComponent <SpriteRenderer>().sprite&& !Selection.activeGameObject.GetComponent <SpriteRenderer>().sprite.name.Contains("bone"))
                    {
                        FFDGameObject = Selection.activeGameObject;
                    }
                    else
                    {
                        Debug.LogWarning("Need to select a sprite to make an FFD mesh, will create a dummy mesh instead");
                    }
                    Puppet2D_FFD.FFDSetFirstPath();
                }
            }
            if (FFDCreation)
            {
                GUI.backgroundColor = bgColor;
            }
            if (GUI.Button(new Rect(80, 390 + offsetControls + SkinWeightsPaintOffset, 150, 30), "Finish FFD"))
            {
                Puppet2D_FFD.FFDFinishCreation();
            }
        }
        if (currentGUIChoice == GUIChoice.Animation)
        {
            //GUILayout.Label("Animation", EditorStyles.boldLabel);

            if (GUI.Button(new Rect(80, 50 + offsetControls, 150, 30), "Bake Animation"))
            {
                Puppet2D_GlobalControl[] globalCtrlScripts = Transform.FindObjectsOfType <Puppet2D_GlobalControl>();
                for (int i = 0; i < globalCtrlScripts.Length; i++)
                {
                    Puppet2D_BakeAnimation BakeAnim = globalCtrlScripts[i].gameObject.AddComponent <Puppet2D_BakeAnimation>();
                    BakeAnim.Run();
                    DestroyImmediate(BakeAnim);
                    globalCtrlScripts[i].enabled = false;
                }
            }
            if (recordPngSequence && !ExportPngAlpha)
            {
                GUI.backgroundColor = Color.green;
            }
            if (GUI.Button(new Rect(80, 100 + offsetControls, 150, 30), "Render Animation"))
            {
                checkPath = EditorUtility.SaveFilePanel("Choose Directory", pngSequPath, "exportedAnim", "");
                if (checkPath != "")
                {
                    pngSequPath       = checkPath;
                    recordPngSequence = true;
                    EditorApplication.ExecuteMenuItem("Edit/Play");
                }
            }
            GUI.backgroundColor = bgColor;
            if (ExportPngAlpha)
            {
                GUI.backgroundColor = Color.green;
            }
            if (GUI.Button(new Rect(80, 130 + offsetControls, 150, 30), "Render Alpha"))
            {
                checkPath = EditorUtility.SaveFilePanel("Choose Directory", pngSequPath, "exportedAnim", "");
                if (checkPath != "")
                {
                    pngSequPath       = checkPath;
                    recordPngSequence = true;
                    ExportPngAlpha    = true;
                    EditorApplication.ExecuteMenuItem("Edit/Play");
                }
            }
            if (ExportPngAlpha || recordPngSequence)
            {
                GUI.backgroundColor = bgColor;
            }
            if (GUI.Button(new Rect(80, 200 + offsetControls, 150, 30), "Save Selection"))
            {
                selectedControls.Add(new List <string>());
                selectedControlsData.Add(new List <string>());

                foreach (GameObject go in Selection.gameObjects)
                {
                    selectedControls[selectedControls.Count - 1].Add(Puppet2D_Selection.GetGameObjectPath(go));
                    selectedControlsData[selectedControlsData.Count - 1].Add(go.transform.localPosition.x + " " + go.transform.localPosition.y + " " + go.transform.localPosition.z + " " + go.transform.localRotation.x + " " + go.transform.localRotation.y + " " + go.transform.localRotation.z + " " + go.transform.localRotation.w + " " + go.transform.localScale.x + " " + go.transform.localScale.y + " " + go.transform.localScale.z + " ");
                }
                Puppet2D_Selection.SetSelectionString();
            }
            if (GUI.Button(new Rect(80, 230 + offsetControls, 150, 30), "Clear Selections"))
            {
                selectedControls.Clear();
                selectedControlsData.Clear();
                Puppet2D_Selection.SetSelectionString();
            }


            for (int i = 0; i < selectedControls.Count; i++)
            {
                int column = i % 3;
                int row    = 0;

                row = i / 3;
                Rect newLoadButtonPosition = new Rect(80 + (50 * column), 265 + offsetControls + row * 30, 50, 30);

                if (Event.current.type == EventType.ContextClick)
                {
                    Vector2 mousePos = Event.current.mousePosition;
                    if ((Event.current.button == 1) && newLoadButtonPosition.Contains(mousePos))
                    {
                        GenericMenu menu = new GenericMenu();

                        menu.AddItem(new GUIContent("Select Objects"), false, Puppet2D_Selection.SaveSelectionLoad, i);
                        menu.AddItem(new GUIContent("Remove Selection"), false, Puppet2D_Selection.SaveSelectionRemove, i);
                        menu.AddItem(new GUIContent("Append Selection"), false, Puppet2D_Selection.SaveSelectionAppend, i);
                        menu.AddItem(new GUIContent("Store Pose"), false, Puppet2D_Selection.StorePose, i);
                        menu.AddItem(new GUIContent("Load Pose"), false, Puppet2D_Selection.LoadPose, i);



                        menu.ShowAsContext();
                        Event.current.Use();
                    }
                }
                GUI.Box(newLoadButtonPosition, "Load");

                /*if (GUI.Button(newLoadButtonPosition, "Load"))
                 * {
                 *  Selection.objects = selectedControls[i].ToArray();
                 * }*/
            }
        }
    }
    public static void FFDFinishCreation()
    {
        if (ffdStoreData == null)
        {
            return;
        }
        Puppet2D_Editor.FFDCreation = false;
        CloseFFDPath();



        Texture spriteTexture = null;

        //GameObject FFDControlsGrp = new GameObject(Puppet2D_BoneCreation.GetUniqueBoneName("FFD_Ctrls_GRP"));

        if (Puppet2D_Editor.FFDGameObject && Puppet2D_Editor.FFDGameObject.GetComponent <SpriteRenderer>() && Puppet2D_Editor.FFDGameObject.GetComponent <SpriteRenderer>().sprite)
        {
            spriteTexture = Puppet2D_Editor.FFDGameObject.GetComponent <SpriteRenderer>().sprite.texture;

            foreach (Transform FFDCtrl in ffdStoreData.FFDCtrls)
            {
                FFDCtrl.transform.position = Puppet2D_Editor.FFDGameObject.transform.InverseTransformPoint(FFDCtrl.transform.position);
            }


            FFDControlsGrp.transform.position   = Puppet2D_Editor.FFDGameObject.transform.position;
            FFDControlsGrp.transform.rotation   = Puppet2D_Editor.FFDGameObject.transform.rotation;
            FFDControlsGrp.transform.localScale = Puppet2D_Editor.FFDGameObject.transform.localScale;

            //Puppet2D_Editor.FFDGameObject.transform.position = Vector3.zero;
            //Puppet2D_Editor.FFDGameObject.transform.rotation = Quaternion.identity;
            //Puppet2D_Editor.FFDGameObject.transform.localScale = Vector3.one;
        }

        if (ffdStoreData.FFDCtrls.Count < 3)
        {
            //Undo.DestroyObjectImmediate(ffdStoreData);
            return;
        }

        Puppet2D_CreatePolygonFromSprite polyFromSprite = ScriptableObject.CreateInstance("Puppet2D_CreatePolygonFromSprite") as Puppet2D_CreatePolygonFromSprite;

        List <Vector3> verts = new List <Vector3>();

        for (int i = 0; i < ffdStoreData.FFDCtrls.Count(); i++)
        {
            if (ffdStoreData.FFDCtrls[i])
            {
                verts.Add(new Vector3(ffdStoreData.FFDCtrls[i].position.x, ffdStoreData.FFDCtrls[i].position.y, 0));
            }
            else
            {
//                Debug.LogWarning("A FFD control point has been removed, no mesh created");
//                Undo.DestroyObjectImmediate(ffdStoreData);
//                return;
            }
        }
        GameObject newMesh;


        if (ffdStoreData.FFDPathNumber.Count > 0 && verts.Count > 2)
        {
            if (Puppet2D_Editor.FFDGameObject == null)
            {
                Puppet2D_Editor.FFDGameObject = new GameObject();
                Undo.RegisterCreatedObjectUndo(Puppet2D_Editor.FFDGameObject, "newGameObject");
            }


            Puppet2D_Editor._numberBonesToSkinToIndex = 0;

            string sortingLayer = "";
            int    sortingOrder = 0;
            if (Puppet2D_Editor.FFDGameObject.GetComponent <Renderer>())
            {
                sortingLayer = Puppet2D_Editor.FFDGameObject.GetComponent <Renderer>().sortingLayerName;
                sortingOrder = Puppet2D_Editor.FFDGameObject.GetComponent <Renderer>().sortingOrder;
            }



            newMesh = polyFromSprite.MakeFromVerts(true, verts.ToArray(), ffdStoreData.FFDPathNumber, Puppet2D_Editor.FFDGameObject);

            if (Puppet2D_Editor.FFDGameObject.GetComponent <Renderer>())
            {
                newMesh.GetComponent <Renderer>().sortingLayerName = sortingLayer;
                newMesh.GetComponent <Renderer>().sortingOrder     = sortingOrder;
            }
            Puppet2D_Editor._numberBonesToSkinToIndex = 1;
        }
        else
        {
            //Undo.DestroyObjectImmediate(ffdStoreData);
            return;
        }



        Undo.DestroyObjectImmediate(polyFromSprite);



        if (Puppet2D_Editor.FFDGameObject)
        {
            if (spriteTexture != null)
            {
                newMesh.GetComponent <Renderer> ().sharedMaterial.mainTexture = spriteTexture;
            }
            else
            {
                newMesh.GetComponent <Renderer> ().sharedMaterial = new Material(Shader.Find("Unlit/Texture"));
            }
            newMesh.name = Puppet2D_Editor.FFDGameObject.name;

            ffdStoreData.FFDCtrls.Add(newMesh.transform);

            Undo.DestroyObjectImmediate(Puppet2D_Editor.FFDGameObject);
        }



        GameObject globalCtrl = Puppet2D_CreateControls.CreateGlobalControl();

        Undo.SetTransformParent(FFDControlsGrp.transform, globalCtrl.transform, "parentToGlobal");
        Undo.SetTransformParent(newMesh.transform, globalCtrl.transform, "parentToGlobal");


        List <Object> newObjs = new List <Object>();

        foreach (Transform tr in ffdStoreData.FFDCtrls)
        {
            if (tr)
            {
                newObjs.Add(tr.gameObject);
            }
        }
        Selection.objects = newObjs.ToArray();

        Puppet2D_Editor._numberBonesToSkinToIndex = 1;


        //Undo.RecordObjects (newObjs.ToArray(), "recordingStuff");
        //Undo.RegisterCompleteObjectUndo (newObjs.ToArray(), "recordingStuff");

        Puppet2D_Skinning.BindSmoothSkin();

        for (int i = 0; i < ffdStoreData.FFDCtrls.Count - 1; i++)
        {
            //Debug.Log(ffdStoreData.FFDCtrls[i]);
            if (ffdStoreData.FFDCtrls [i])
            {
                Puppet2D_FFDLineDisplay ffdLine = ffdStoreData.FFDCtrls [i].GetComponent <Puppet2D_FFDLineDisplay> ();
                ffdLine.outputSkinnedMesh = newMesh.GetComponent <SkinnedMeshRenderer> ();
                for (int j = 0; j < ffdLine.outputSkinnedMesh.sharedMesh.vertices.Length; j++)
                {
                    Vector3 vert = ffdLine.outputSkinnedMesh.sharedMesh.vertices [j];
                    if (Vector3.Distance(vert, ffdStoreData.FFDCtrls [i].transform.position) < .001f)
                    {
                        ffdStoreData.FFDCtrls [i].GetComponent <Puppet2D_FFDLineDisplay> ().vertNumber = j;
                    }
                }
                Undo.SetTransformParent(ffdStoreData.FFDCtrls [i].parent.transform, FFDControlsGrp.transform, "parentFFDControls");

                ffdStoreData.FFDCtrls [i].transform.localPosition = Vector3.zero;
            }
        }
        Selection.activeGameObject = ffdStoreData.FFDCtrls [ffdStoreData.FFDCtrls.Count - 1].gameObject;
        ffdStoreData.FFDCtrls.RemoveAt(ffdStoreData.FFDCtrls.Count - 1);
        Undo.RegisterCompleteObjectUndo(ffdStoreData, "changinEditable");
        ffdStoreData.Editable = false;
//        Undo.DestroyObjectImmediate(ffdStoreData);
        if (globalCtrl.GetComponent <Puppet2D_GlobalControl>().AutoRefresh)
        {
            globalCtrl.GetComponent <Puppet2D_GlobalControl>().Init();
        }
    }
Example #8
0
    public static void FFDFinishCreation()
    {
        if (ffdStoreData == null)
        {
            return;
        }
        Puppet2D_Editor.FFDCreation = false;
        CloseFFDPath();

        Texture spriteTexture = null;

        //GameObject FFDControlsGrp = new GameObject(Puppet2D_BoneCreation.GetUniqueBoneName("FFD_Ctrls_GRP"));

        if (Puppet2D_Editor.FFDGameObject)
        {
            spriteTexture = Puppet2D_Editor.FFDGameObject.GetComponent <SpriteRenderer>().sprite.texture;


            //            FFDControlsGrp.name = Puppet2D_Editor.GetUniqueBoneName(Puppet2D_Editor.FFDGameObject.GetComponent<SpriteRenderer>().sprite.texture.name);

            foreach (Transform FFDCtrl in ffdStoreData.FFDCtrls)
            {
                FFDCtrl.transform.position = Puppet2D_Editor.FFDGameObject.transform.InverseTransformPoint(FFDCtrl.transform.position);
            }


            FFDControlsGrp.transform.position   = Puppet2D_Editor.FFDGameObject.transform.position;
            FFDControlsGrp.transform.rotation   = Puppet2D_Editor.FFDGameObject.transform.rotation;
            FFDControlsGrp.transform.localScale = Puppet2D_Editor.FFDGameObject.transform.localScale;


            //            FFDControlsGrp.transform.position = Vector3.zero;
            //            FFDControlsGrp.transform.rotation = Quaternion.identity;
            //            FFDControlsGrp.transform.localScale = Vector3.one;


            Puppet2D_Editor.FFDGameObject.transform.position   = Vector3.zero;
            Puppet2D_Editor.FFDGameObject.transform.rotation   = Quaternion.identity;
            Puppet2D_Editor.FFDGameObject.transform.localScale = Vector3.one;
        }

        if (ffdStoreData.FFDCtrls.Count < 3)
        {
            Undo.DestroyObjectImmediate(ffdStoreData);
            return;
        }

        Puppet2D_CreatePolygonFromSprite polyFromSprite = ScriptableObject.CreateInstance("Puppet2D_CreatePolygonFromSprite") as Puppet2D_CreatePolygonFromSprite;

        List <Vector3> verts = new List <Vector3>();

        for (int i = 0; i < ffdStoreData.FFDCtrls.Count(); i++)
        {
            if (ffdStoreData.FFDCtrls[i])
            {
                verts.Add(new Vector3(ffdStoreData.FFDCtrls[i].position.x, ffdStoreData.FFDCtrls[i].position.y, 0));
            }
            else
            {
                Debug.LogWarning("A FFD control point has been removed, no mesh created");
                Undo.DestroyObjectImmediate(ffdStoreData);
                return;
            }
        }

        GameObject newMesh;

        if (ffdStoreData.FFDPathNumber.Count > 0 && verts.Count > 2)
        {
            if (Puppet2D_Editor.FFDGameObject == null)
            {
                Puppet2D_Editor.FFDGameObject = new GameObject();
            }


            Puppet2D_Editor._numberBonesToSkinToIndex = 0;

            string sortingLayer = "";
            int    sortingOrder = 0;
            if (Puppet2D_Editor.FFDGameObject.GetComponent <Renderer>())
            {
                sortingLayer = Puppet2D_Editor.FFDGameObject.GetComponent <Renderer>().sortingLayerName;
                sortingOrder = Puppet2D_Editor.FFDGameObject.GetComponent <Renderer>().sortingOrder;
            }
            newMesh = polyFromSprite.MakeFromVerts(true, verts.ToArray(), ffdStoreData.FFDPathNumber, Puppet2D_Editor.FFDGameObject);
            if (Puppet2D_Editor.FFDGameObject.GetComponent <Renderer>())
            {
                newMesh.GetComponent <Renderer>().sortingLayerName = sortingLayer;
                newMesh.GetComponent <Renderer>().sortingOrder     = sortingOrder;
            }
            Puppet2D_Editor._numberBonesToSkinToIndex = 1;
        }
        else
        {
            Undo.DestroyObjectImmediate(ffdStoreData);
            return;
        }
        DestroyImmediate(polyFromSprite);

        if (Puppet2D_Editor.FFDGameObject)
        {
            newMesh.GetComponent <Renderer>().sharedMaterial.mainTexture = spriteTexture;

            newMesh.name = Puppet2D_Editor.FFDGameObject.name;

            ffdStoreData.FFDCtrls.Add(newMesh.transform);


            Undo.DestroyObjectImmediate(Puppet2D_Editor.FFDGameObject);
        }

        GameObject globalCtrl = Puppet2D_CreateControls.CreateGlobalControl();

        FFDControlsGrp.transform.parent = globalCtrl.transform;

        List <Object> newObjs = new List <Object>();

        foreach (Transform tr in ffdStoreData.FFDCtrls)
        {
            newObjs.Add(tr.gameObject);
        }
        Selection.objects = newObjs.ToArray();

        Puppet2D_Editor._numberBonesToSkinToIndex = 1;
        Puppet2D_Skinning.BindSmoothSkin();


        for (int i = 0; i < ffdStoreData.FFDCtrls.Count - 1; i++)
        {
            //Debug.Log(ffdStoreData.FFDCtrls[i]);
            ffdStoreData.FFDCtrls[i].GetComponent <Puppet2D_FFDLineDisplay>().outputSkinnedMesh = newMesh.GetComponent <SkinnedMeshRenderer>();
            ffdStoreData.FFDCtrls[i].parent.transform.parent = FFDControlsGrp.transform;
            ffdStoreData.FFDCtrls[i].transform.localPosition = Vector3.zero;
        }


        Undo.DestroyObjectImmediate(ffdStoreData);
        if (globalCtrl.GetComponent <Puppet2D_GlobalControl>().AutoRefresh)
        {
            globalCtrl.GetComponent <Puppet2D_GlobalControl>().Init();
        }
    }