public void OnWizardCreate()
{
if (dragonBoneRoot)
{
foreach (Renderer render in dragonBoneRoot.GetComponentsInChildren <Renderer>(true))
{
render.sortingLayerName = sortingLayerName;
render.sortingOrder = sortingOrder;
SpriteFrame sf = render.GetComponent <SpriteFrame>();
if (sf)
{
sf.sortingLayerName = sortingLayerName;
sf.soringOrder = sortingOrder;
EditorUtility.SetDirty(sf);
}
else
{
SpriteMesh sm = render.GetComponent <SpriteMesh>();
if (sm)
{
sm.sortingLayerName = sortingLayerName;
sm.soringOrder = sortingOrder;
EditorUtility.SetDirty(sm);
}
}
}
}
}
/// <summary>
/// Changes the sprite mesh.
/// </summary>
/// <param name="sm">Will replace SpriteMesh</param>
/// <param name="texture">new Texture.</param>
/// <param name="mat">Mat.</param>
public void ChangeSpriteMesh(SpriteMesh sm, Texture texture, Material mat = null)
{
if (!sm || !texture)
{
return;
}
if (mat)
{
sm.atlasMat = mat;
}
sm.atlasMat.mainTexture = texture;
sm.frame.material = sm.atlasMat;
sm.frame.texture = texture;
sm.frame.isRotated = false;
sm.frame.rect.x = 0;
sm.frame.rect.y = 0;
sm.frame.rect.width = texture.width;
sm.frame.rect.height = texture.height;
sm.frame.frameSize = new Rect(0, 0, texture.width, texture.height);
sm.frame.atlasTextureSize.x = texture.width;
sm.frame.atlasTextureSize.y = texture.height;
sm.UpdateUV();
}
/// <summary>
/// Changes the sprite mesh.
/// </summary>
/// <param name="spriteMeshName">Will replace SpriteMesh'name.</param>
/// <param name="texture">new Texture.</param>
/// <param name="mat">Mat.</param>
public void ChangeSpriteMesh(string spriteMeshName, Texture texture, Material mat = null)
{
Renderer attachment = GetAttachmentByName(spriteMeshName);
if (!attachment)
{
return;
}
SpriteMesh sm = attachment.GetComponent <SpriteMesh>();
ChangeSpriteMesh(sm, texture, mat);
}
void UpdateCurrentDisplay()
{
if (__displayIndex > -1 && transform.childCount > 0)
{
m_SpriteFrame = null;
m_SpriteMesh = null;
m_SpriteRenderer = null;
Transform child = transform.GetChild(__displayIndex);
m_SpriteFrame = child.GetComponent <SpriteFrame>();
m_SpriteMesh = child.GetComponent <SpriteMesh>();
m_SpriteRenderer = child.GetComponent <SpriteRenderer>();
}
}
/// <summary>
/// Changes the sprite mesh.
/// </summary>
/// <param name="spriteMeshName">Sprite mesh name.</param>
/// <param name="newTextureFrameName">New texture frame name.</param>
public void ChangeSpriteMesh(string spriteMeshName, string newTextureFrameName)
{
Renderer attachment = GetAttachmentByName(spriteMeshName);
if (!attachment)
{
return;
}
SpriteMesh sm = attachment.GetComponent <SpriteMesh>();
TextureFrame frame = GetTextureFrameByName(newTextureFrameName);
if (sm != null && frame != null)
{
sm.atlasMat = frame.material;
attachment.sharedMaterial = frame.material;
sm.frame = frame;
sm.UpdateUV();
}
}
/// <summary>
/// update
/// </summary>
public void UpdateArmature(){
int len = updateFrames.Length;
for(int i=0;i<len;++i){
SpriteFrame frame = updateFrames[i];
if(frame&&frame.isActiveAndEnabled) frame.UpdateFrame();
}
len = updateMeshs.Length;
for(int i=0;i<len;++i){
SpriteMesh mesh = updateMeshs[i];
if(mesh&&mesh.isActiveAndEnabled) mesh.UpdateMesh();
}
len = slots.Length;
for(int i=0;i<len;++i){
Slot slot = slots[i];
if(slot && slot.isActiveAndEnabled){
slot.UpdateSlot();
}
}
}
/// <summary>
/// update
/// </summary>
public void UpdateArmature()
{
int len = updateFrames.Length;
for (int i = 0; i < len; ++i)
{
SpriteFrame frame = updateFrames[i];
if (frame && frame.isActiveAndEnabled)
{
frame.UpdateFrame();
}
}
len = updateMeshs.Length;
for (int i = 0; i < len; ++i)
{
SpriteMesh mesh = updateMeshs[i];
if (mesh && mesh.isActiveAndEnabled)
{
mesh.UpdateMesh();
}
}
}
static void ShowSpriteMesh(TextureFrame frame, Material mat, DragonBoneData.SkinSlotDisplayData displayData, Transform slot, ArmatureEditor armatureEditor, DragonBoneData.SlotData slotData)
{
armatureEditor.spriteMeshUsedMatKV[mat] = true;
GameObject go = new GameObject(displayData.textureName);
SpriteMesh sm = go.AddComponent <SpriteMesh>();
sm.atlasMat = mat;
sm.vertices = displayData.vertices;
sm.frame = frame;
sm.uvs = displayData.uvs;
sm.triangles = displayData.triangles;
sm.colors = new Color[sm.vertices.Length];
for (int i = 0; i < sm.colors.Length; ++i)
{
sm.colors[i] = Color.white;
}
if (displayData.weights != null && displayData.weights.Length > 0)
{
sm.CreateMesh(true);
if (armatureEditor.ffdKV.ContainsKey(displayData.textureName))
{
//Vertex controller
sm.vertControlTrans = new Transform[sm.vertices.Length];
for (int i = 0; i < sm.vertices.Length; ++i)
{
GameObject gov = new GameObject(go.name + "_v" + i);
gov.transform.parent = go.transform;
gov.transform.localPosition = sm.vertices[i];
gov.transform.localScale = Vector3.zero;
sm.vertControlTrans[i] = gov.transform;
}
}
}
else
{
sm.CreateMesh(false);
if (displayData.bonePose == null)
{
//Vertex controller
sm.vertControlTrans = new Transform[sm.vertices.Length];
for (int i = 0; i < sm.vertices.Length; ++i)
{
GameObject gov = new GameObject(go.name + "_v" + i);
gov.transform.parent = go.transform;
gov.transform.localPosition = sm.vertices[i];
gov.transform.localScale = Vector3.zero;
sm.vertControlTrans[i] = gov.transform;
}
}
}
sm.transform.parent = slot;
if (displayData.bonePose != null)
{
SkinnedMeshRenderer skinnedMesh = sm.GetComponent <SkinnedMeshRenderer>();
if (skinnedMesh)
{
skinnedMesh.quality = SkinQuality.Bone4;
if (displayData.weights != null && displayData.weights.Length > 0)
{
Transform[] bones = new Transform[displayData.bonePose.Length / 7];
for (int i = 0; i < displayData.bonePose.Length; i += 7)
{
int index = i / 7;
int boneIndex = (int)displayData.bonePose[i];
bones[index] = armatureEditor.bones[boneIndex];
}
List <BoneWeight> boneWeights = new List <BoneWeight>();
for (int i = 0; i < displayData.weights.Length; ++i)
{
int boneCount = (int)displayData.weights[i]; //骨骼数量
List <KeyValuePair <int, float> > boneWeightList = new List <KeyValuePair <int, float> >();
for (int j = 0; j < boneCount * 2; j += 2)
{
int boneIdx = (int)displayData.weights[i + j + 1];
float weight = displayData.weights[i + j + 2];
boneWeightList.Add(new KeyValuePair <int, float>(boneIdx, weight));
}
//sort boneWeightList，desc
boneWeightList.Sort(delegate(KeyValuePair <int, float> x, KeyValuePair <int, float> y) {
if (x.Value == y.Value)
{
return(0);
}
return(x.Value < y.Value? 1: -1);
});
BoneWeight bw = new BoneWeight();
for (int j = 0; j < boneWeightList.Count; ++j)
{
if (j == 0)
{
bw.boneIndex0 = GlobalBoneIndexToLocalBoneIndex(armatureEditor, boneWeightList[j].Key, bones);
bw.weight0 = boneWeightList[j].Value;
}
else if (j == 1)
{
bw.boneIndex1 = GlobalBoneIndexToLocalBoneIndex(armatureEditor, boneWeightList[j].Key, bones);
bw.weight1 = boneWeightList[j].Value;
}
else if (j == 2)
{
bw.boneIndex2 = GlobalBoneIndexToLocalBoneIndex(armatureEditor, boneWeightList[j].Key, bones);
bw.weight2 = boneWeightList[j].Value;
}
else if (j == 3)
{
bw.boneIndex3 = GlobalBoneIndexToLocalBoneIndex(armatureEditor, boneWeightList[j].Key, bones);
bw.weight3 = boneWeightList[j].Value;
}
}
boneWeights.Add(bw);
i += boneCount * 2;
}
Matrix4x4[] matrixArray = new Matrix4x4[bones.Length];
for (int i = 0; i < matrixArray.Length; ++i)
{
Transform bone = bones[i];
Vector3 bonePos = bone.localPosition;
Quaternion boneRotate = bone.localRotation;
Matrix2D m2d = armatureEditor.bonePoseKV[displayData.textureName + bone.name];
bone.position = new Vector3(m2d.tx * 0.01f, -m2d.ty * 0.01f, bone.position.z);
bone.rotation = Quaternion.Euler(0f, 0f, -m2d.GetAngle());
matrixArray[i] = bone.worldToLocalMatrix * armatureEditor.armature.localToWorldMatrix;
matrixArray[i] *= Matrix4x4.TRS(slot.localPosition, slot.localRotation, slot.localScale);
bone.localPosition = bonePos;
bone.localRotation = boneRotate;
}
skinnedMesh.bones = bones;
skinnedMesh.sharedMesh.boneWeights = boneWeights.ToArray();
skinnedMesh.sharedMesh.bindposes = matrixArray;
skinnedMesh.rootBone = slot;
sm.bindposes = matrixArray;
SpriteMesh.BoneWeightClass[] bwcs = new SpriteMesh.BoneWeightClass[boneWeights.Count];
for (int i = 0; i < boneWeights.Count; ++i)
{
SpriteMesh.BoneWeightClass bwc = new SpriteMesh.BoneWeightClass();
BoneWeight bw = boneWeights[i];
bwc.boneIndex0 = bw.boneIndex0;
bwc.boneIndex1 = bw.boneIndex1;
bwc.boneIndex2 = bw.boneIndex2;
bwc.boneIndex3 = bw.boneIndex3;
bwc.weight0 = bw.weight0;
bwc.weight1 = bw.weight1;
bwc.weight2 = bw.weight2;
bwc.weight3 = bw.weight3;
bwcs[i] = bwc;
}
sm.weights = bwcs;
}
}
}
DragonBoneData.TransformData tranform = displayData.transform;
Vector3 localPos = Vector3.zero;
if (!float.IsNaN(tranform.x))
{
localPos.x = tranform.x;
}
if (!float.IsNaN(tranform.y))
{
localPos.y = tranform.y;
}
sm.transform.localPosition = localPos;
Vector3 localSc = Vector3.one;
if (!float.IsNaN(tranform.scx))
{
localSc.x = tranform.scx;
}
if (!float.IsNaN(tranform.scy))
{
localSc.y = tranform.scy;
}
sm.transform.localScale = localSc;
sm.color = slot.GetComponent <Slot>().color;
sm.transform.localRotation = Quaternion.Euler(0, 0, tranform.rotate);
}
//init
public void InitShow()
{
ShowArmature.AddBones(this);
ShowArmature.AddSlot(this);
ShowArmature.ShowBones(this);
ShowArmature.ShowSlots(this);
ShowArmature.ShowSkins(this);
ShowArmature.SetIKs(this);
AnimFile.CreateAnimFile(this);
DragonBoneArmature dba = _armature.GetComponent <DragonBoneArmature>();
//update slot display
for (int s = 0; s < slots.Count; ++s)
{
slots[s].displayIndex = slots[s].displayIndex;
}
Renderer[] renders = _armature.GetComponentsInChildren <Renderer>(true);
foreach (Renderer r in renders)
{
if (r.GetComponent <SpriteFrame>())
{
//optimize memory
SpriteFrame sf = r.GetComponent <SpriteFrame>();
TextureFrame tf = sf.frame;
sf.frames = new TextureFrame[] { tf };
}
}
dba.attachments = renders;
dba.slots = slots.ToArray();
dba.bones = bones.ToArray();
dba.zSpace = zoffset;
dba.ResetSlotZOrder();
string path = AssetDatabase.GetAssetPath(animTextAsset);
path = path.Substring(0, path.LastIndexOf('/')) + "/" + _armature.name;
//create pose data
PoseData poseData = ScriptableObject.CreateInstance <PoseData>();
poseData.slotDatas = new PoseData.SlotData[slots.Count];
for (int i = 0; i < slots.Count; ++i)
{
poseData.slotDatas[i] = new PoseData.SlotData();
poseData.slotDatas[i].color = slots[i].color;
poseData.slotDatas[i].displayIndex = slots[i].displayIndex;
poseData.slotDatas[i].zorder = slots[i].z;
}
poseData.boneDatas = new PoseData.TransformData[bones.Count];
for (int i = 0; i < bones.Count; ++i)
{
poseData.boneDatas[i] = new PoseData.TransformData();
poseData.boneDatas[i].x = bones[i].localPosition.x;
poseData.boneDatas[i].y = bones[i].localPosition.y;
poseData.boneDatas[i].sx = bones[i].localScale.x;
poseData.boneDatas[i].sy = bones[i].localScale.y;
poseData.boneDatas[i].rotation = bones[i].localEulerAngles.z;
}
poseData.displayDatas = new PoseData.DisplayData[dba.attachments.Length];
for (int i = 0; i < dba.attachments.Length; ++i)
{
poseData.displayDatas[i] = new PoseData.DisplayData();
Renderer render = dba.attachments[i];
SpriteFrame sf = render.GetComponent <SpriteFrame>();
if (sf)
{
poseData.displayDatas[i].type = PoseData.AttachmentType.IMG;
poseData.displayDatas[i].color = sf.color;
}
else
{
SpriteMesh sm = render.GetComponent <SpriteMesh>();
if (sm)
{
poseData.displayDatas[i].type = PoseData.AttachmentType.MESH;
poseData.displayDatas[i].color = sm.color;
poseData.displayDatas[i].vertex = sm.vertices;
}
else
{
SpriteRenderer sr = render.GetComponent <SpriteRenderer>();
if (sr)
{
poseData.displayDatas[i].type = PoseData.AttachmentType.IMG;
poseData.displayDatas[i].color = sr.color;
}
else
{
poseData.displayDatas[i].type = PoseData.AttachmentType.BOX;
}
}
}
poseData.displayDatas[i].transform = new PoseData.TransformData();
poseData.displayDatas[i].transform.x = render.transform.localPosition.x;
poseData.displayDatas[i].transform.y = render.transform.localPosition.y;
poseData.displayDatas[i].transform.sx = render.transform.localScale.x;
poseData.displayDatas[i].transform.sy = render.transform.localScale.y;
poseData.displayDatas[i].transform.rotation = render.transform.localEulerAngles.z;
}
AssetDatabase.CreateAsset(poseData, path + "_Pose.asset");
dba.poseData = poseData;
string prefabPath = path + ".prefab";
GameObject prefab = AssetDatabase.LoadAssetAtPath <GameObject>(prefabPath);
if (!prefab)
{
PrefabUtility.CreatePrefab(prefabPath, _armature.gameObject, ReplacePrefabOptions.ConnectToPrefab);
}
else
{
PrefabUtility.ReplacePrefab(_armature.gameObject, prefab, ReplacePrefabOptions.ConnectToPrefab);
}
}
public override void OnInspectorGUI()
{
DragonBoneArmature armature = target as DragonBoneArmature;
if (armature == null)
{
return;
}
selectedOption = EditorGUILayout.Popup("Sorting Layer", selectedOption, sortingLayerNames);
if (sortingLayerNames[selectedOption] != armature.sortingLayerName)
{
Undo.RecordObject(armature, "Sorting Layer");
armature.sortingLayerName = sortingLayerNames[selectedOption];
EditorUtility.SetDirty(armature);
}
int newSortingLayerOrder = EditorGUILayout.IntField("Order in Layer", armature.sortingOrder);
if (newSortingLayerOrder != armature.sortingOrder)
{
Undo.RecordObject(armature, "Edit Sorting Order");
armature.sortingOrder = newSortingLayerOrder;
EditorUtility.SetDirty(armature);
}
if (GUILayout.Button("Update All Sorting Order", GUILayout.Height(20)))
{
foreach (Renderer render in armature.GetComponentsInChildren <Renderer>(true))
{
render.sortingLayerName = armature.sortingLayerName;
render.sortingOrder = armature.sortingOrder;
EditorUtility.SetDirty(render);
SpriteFrame sf = render.GetComponent <SpriteFrame>();
if (sf)
{
sf.sortingLayerName = armature.sortingLayerName;
sf.sortingOrder = armature.sortingOrder;
}
else
{
SpriteMesh sm = render.GetComponent <SpriteMesh>();
if (sm)
{
sm.sortingLayerName = armature.sortingLayerName;
sm.sortingOrder = armature.sortingOrder;
}
}
}
EditorUtility.SetDirty(armature);
if (!string.IsNullOrEmpty(armature.gameObject.scene.name))
{
UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene());
}
}
serializedObject.Update();
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_FlipX"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_FlipY"), true);
if (!Application.isPlaying)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty("zSpace"), true);
}
EditorGUILayout.PropertyField(serializedObject.FindProperty("poseData"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("slots"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("bones"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("attachments"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("materials"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("textureFrames"), true);
serializedObject.ApplyModifiedProperties();
if (!Application.isPlaying)
{
if (armature.flipX != flipX)
{
armature.flipX = armature.flipX;
flipX = armature.flipX;
if (!string.IsNullOrEmpty(armature.gameObject.scene.name))
{
UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene());
}
}
if (armature.flipY != flipY)
{
armature.flipY = armature.flipY;
flipY = armature.flipY;
if (!string.IsNullOrEmpty(armature.gameObject.scene.name))
{
UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene());
}
}
if (armature.zSpace != zspace)
{
zspace = armature.zSpace;
armature.ResetSlotZOrder();
if (!string.IsNullOrEmpty(armature.gameObject.scene.name))
{
UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene());
}
}
}
}
/// <summary>
/// Sets to pose.
/// </summary>
public void SetToPose()
{
if (poseData)
{
for (int i = 0; i < poseData.boneDatas.Length && i < bones.Length; ++i)
{
Transform bone = bones[i];
if (bone)
{
PoseData.TransformData transData = poseData.boneDatas[i];
bone.localPosition = new Vector3(transData.x, transData.y, bone.localPosition.z);
bone.localScale = new Vector3(transData.sx, transData.sy, bone.localScale.z);
bone.localEulerAngles = new Vector3(bone.localEulerAngles.x, bone.localEulerAngles.y, transData.rotation);
}
}
for (int i = 0; i < poseData.slotDatas.Length && i < slots.Length; ++i)
{
Slot slot = slots[i];
if (slot)
{
slot.color = poseData.slotDatas[i].color;
slot.displayIndex = poseData.slotDatas[i].displayIndex;
slot.z = poseData.slotDatas[i].zorder;
}
}
for (int i = 0; i < poseData.displayDatas.Length && i < attachments.Length; ++i)
{
Renderer r = attachments[i];
if (r)
{
Transform trans = r.transform;
PoseData.TransformData transData = poseData.displayDatas[i].transform;
trans.localPosition = new Vector3(transData.x, transData.y, trans.localPosition.z);
trans.localScale = new Vector3(transData.sx, transData.sy, trans.localScale.z);
trans.localEulerAngles = new Vector3(trans.localEulerAngles.x, trans.localEulerAngles.y, transData.rotation);
PoseData.DisplayData displayData = poseData.displayDatas[i];
switch (displayData.type)
{
case PoseData.AttachmentType.IMG:
SpriteFrame sf = r.GetComponent <SpriteFrame>();
if (sf)
{
sf.color = displayData.color;
}
else
{
SpriteRenderer sr = r.GetComponent <SpriteRenderer>();
if (sr)
{
sr.color = displayData.color;
}
}
break;
case PoseData.AttachmentType.MESH:
SpriteMesh sm = r.GetComponent <SpriteMesh>();
sm.vertices = displayData.vertex;
for (int j = 0; j < sm.vertControlTrans.Length && j < sm.vertices.Length; ++j)
{
Transform vctr = sm.vertControlTrans[j];
if (vctr)
{
vctr.localPosition = sm.vertices[j];
}
}
break;
}
}
}
}
ResetSlotZOrder();
}
