コード例 #1
0
        public static void FFDCreationMode(Vector3 mousePos)
        {
            string newCtrlName    = "FFD_CTRL";
            string newCtrlGRPName = "FFD_CTRL_GRP";

            if (Puppet2D_Editor.FFDGameObject)
            {
                newCtrlName    = Puppet2D_Editor.FFDGameObject.name + "_Ctrl";
                newCtrlGRPName = Puppet2D_Editor.FFDGameObject.name + "_Ctrl_GRP";
            }

            GameObject newCtrl    = new GameObject(Puppet2D_BoneCreation.GetUniqueBoneName(newCtrlName));
            GameObject newCtrlGRP = new GameObject(Puppet2D_BoneCreation.GetUniqueBoneName(newCtrlGRPName));

            newCtrl.transform.parent = newCtrlGRP.transform;

            Undo.RegisterCreatedObjectUndo(newCtrl, "Created newCtrl");
            Undo.RegisterCreatedObjectUndo(newCtrlGRP, "Created newCtrlGRP");

            Undo.RecordObject(ffdStoreData, "Adding FFD Control");
            ffdStoreData.FFDCtrls.Add(newCtrl.transform);


            Puppet2D_FFDLineDisplay ffdline = newCtrl.AddComponent <Puppet2D_FFDLineDisplay>();

            if (ffdStoreData.FFDCtrls.Count > 1)
            {
                if (ffdStoreData.FFDPathNumber.Count > 0)
                {
                    if (ffdStoreData.FFDCtrls.Count - 1 > ffdStoreData.FFDPathNumber[ffdStoreData.FFDPathNumber.Count - 1])
                    {
                        ffdline.target = ffdStoreData.FFDCtrls[ffdStoreData.FFDCtrls.Count - 2];
                    }
                }
                else
                {
                    ffdline.target = ffdStoreData.FFDCtrls[ffdStoreData.FFDCtrls.Count - 2];
                }
            }



            newCtrlGRP.transform.position = new Vector3(mousePos.x, mousePos.y, 0);

            SpriteRenderer spriteRenderer = newCtrl.AddComponent <SpriteRenderer>();

            spriteRenderer.sortingLayerName = Puppet2D_Editor._controlSortingLayer;
            string path = (Puppet2D_Editor._puppet2DPath + "/Textures/GUI/ffdBone.psd");

            Sprite sprite = AssetDatabase.LoadAssetAtPath(path, typeof(Sprite)) as Sprite;

            spriteRenderer.sprite           = sprite;
            spriteRenderer.sortingLayerName = Puppet2D_Editor._controlSortingLayer;
        }
コード例 #2
0
        public void TraverseHierarchy(Transform root)
        {
            foreach (Transform child in root)
            {
                GameObject     Go             = child.gameObject;
                SpriteRenderer spriteRenderer = Go.transform.GetComponent <SpriteRenderer>();
                if (spriteRenderer && spriteRenderer.sprite)
                {
                    if (spriteRenderer.sprite.name.Contains("Control"))
                    {
                        _Controls.Add(spriteRenderer);
                    }
                    else if (spriteRenderer.sprite.name.Contains("ffd"))
                    {
                        _FFDControls.Add(spriteRenderer);
                    }
                }
                Puppet2D_Bone boneRender = Go.transform.GetComponent <Puppet2D_Bone>();
                if (boneRender)
                {
                    _Bones.Add(boneRender);
                }

                Puppet2D_ParentControl newParentCtrl = Go.transform.GetComponent <Puppet2D_ParentControl>();

                if (newParentCtrl)
                {
                    _ParentControls.Add(newParentCtrl);
                }
                Puppet2D_IKHandle newIKCtrl = Go.transform.GetComponent <Puppet2D_IKHandle>();
                if (newIKCtrl)
                {
                    _Ikhandles.Add(newIKCtrl);
                }

                Puppet2D_FFDLineDisplay ffdCtrl = Go.transform.GetComponent <Puppet2D_FFDLineDisplay>();
                if (ffdCtrl)
                {
                    _ffdControls.Add(ffdCtrl);
                }

                Puppet2D_SplineControl splineCtrl = Go.transform.GetComponent <Puppet2D_SplineControl>();
                if (splineCtrl)
                {
                    _SplineControls.Add(splineCtrl);
                }

                TraverseHierarchy(child);
            }
        }
コード例 #3
0
        void CombineAllMeshes()
        {
            Vector3    originalScale = transform.localScale;
            Quaternion originalRot   = transform.rotation;
            Vector3    originalPos   = transform.position;

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

            SkinnedMeshRenderer[]  smRenderers      = GetComponentsInChildren <SkinnedMeshRenderer>();
            List <Transform>       bones            = new List <Transform>();
            List <BoneWeight>      boneWeights      = new List <BoneWeight>();
            List <CombineInstance> combineInstances = new List <CombineInstance>();
            List <Texture2D>       textures         = new List <Texture2D>();

            Material currentMaterial = null;

            int numSubs         = 0;
            var smRenderersDict = new Dictionary <SkinnedMeshRenderer, float>(smRenderers.Length);

            bool updateWhenOffscreen = false;

            foreach (SkinnedMeshRenderer smr in smRenderers)
            {
                smRenderersDict.Add(smr, smr.transform.position.z);
                updateWhenOffscreen = smr.updateWhenOffscreen;
            }


            var items = from pair in smRenderersDict
                        orderby pair.Key.sortingOrder ascending
                        select pair;

            items = from pair in items
                    orderby pair.Value descending
                    select pair;

            foreach (KeyValuePair <SkinnedMeshRenderer, float> pair in items)
            {
                //Debug.Log(pair.Key.name + " " + pair.Value);
                numSubs += pair.Key.sharedMesh.subMeshCount;
            }


            int[] meshIndex  = new int[numSubs];
            int   boneOffset = 0;

            int s = 0;

            foreach (KeyValuePair <SkinnedMeshRenderer, float> pair in items)
            {
                SkinnedMeshRenderer smr = pair.Key;

                if (currentMaterial == null)
                {
                    currentMaterial = smr.sharedMaterial;
                }
                else if (currentMaterial.mainTexture && smr.sharedMaterial.mainTexture && currentMaterial.mainTexture != smr.sharedMaterial.mainTexture)
                {
                    continue;
                }

                bool ffdMesh = false;
                foreach (Transform boneToCheck in smr.bones)
                {
                    Puppet2D_FFDLineDisplay ffdLine = boneToCheck.GetComponent <Puppet2D_FFDLineDisplay>();
                    if (ffdLine && ffdLine.outputSkinnedMesh != smr)
                    {
                        ffdMesh = true;
                    }
                }
                if (ffdMesh)
                {
                    continue;
                }
                BoneWeight[] meshBoneweight = smr.sharedMesh.boneWeights;

                foreach (BoneWeight bw in meshBoneweight)
                {
                    BoneWeight bWeight = bw;

                    bWeight.boneIndex0 += boneOffset;
                    bWeight.boneIndex1 += boneOffset;
                    bWeight.boneIndex2 += boneOffset;
                    bWeight.boneIndex3 += boneOffset;

                    boneWeights.Add(bWeight);
                }
                boneOffset += smr.bones.Length;

                Transform[] meshBones = smr.bones;
                foreach (Transform bone in meshBones)
                {
                    bones.Add(bone);
                }

                if (smr.material.mainTexture != null)
                {
                    textures.Add(smr.GetComponent <Renderer>().material.mainTexture as Texture2D);
                }



                CombineInstance ci = new CombineInstance();
                ci.mesh      = smr.sharedMesh;
                meshIndex[s] = ci.mesh.vertexCount;
                ci.transform = smr.transform.localToWorldMatrix;
                combineInstances.Add(ci);

                Object.Destroy(smr.gameObject);
                s++;
            }


            List <Matrix4x4> bindposes = new List <Matrix4x4>();

            for (int b = 0; b < bones.Count; b++)
            {
                if (bones[b].GetComponent <Puppet2D_FFDLineDisplay>())
                {
                    Vector3    boneparentPos = bones[b].transform.parent.parent.position;
                    Quaternion boneparentRot = bones[b].transform.parent.parent.rotation;
                    bones[b].transform.parent.parent.position = Vector3.zero;
                    bones[b].transform.parent.parent.rotation = Quaternion.identity;
                    bindposes.Add(bones[b].worldToLocalMatrix * transform.worldToLocalMatrix);
                    bones[b].transform.parent.parent.position = boneparentPos;
                    bones[b].transform.parent.parent.rotation = boneparentRot;
                }
                else
                {
                    bindposes.Add(bones[b].worldToLocalMatrix * transform.worldToLocalMatrix);
                }
            }

            SkinnedMeshRenderer r = gameObject.AddComponent <SkinnedMeshRenderer>();

            r.updateWhenOffscreen = updateWhenOffscreen;
            r.sharedMesh          = new Mesh();
            r.sharedMesh.CombineMeshes(combineInstances.ToArray(), true, true);

            Material combinedMat;

            if (currentMaterial != null)
            {
                combinedMat = currentMaterial;
            }
            else
            {
                combinedMat = new Material(Shader.Find("Unlit/Transparent"));
            }

            combinedMat.mainTexture = textures[0];
            r.sharedMesh.uv         = r.sharedMesh.uv;
            r.sharedMaterial        = combinedMat;

            r.bones = bones.ToArray();
            r.sharedMesh.boneWeights = boneWeights.ToArray();
            r.sharedMesh.bindposes   = bindposes.ToArray();
            r.sharedMesh.RecalculateBounds();


            transform.localScale = originalScale;
            transform.rotation   = originalRot;
            transform.position   = originalPos;
        }
コード例 #4
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 && 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(1);

            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;
                }
            }
            FFDControlsGrp.transform.position = new Vector3(FFDControlsGrp.transform.position.x, FFDControlsGrp.transform.position.y, ffdStoreData.OriginalSpritePosition.z);


            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();
            }
        }