public static void ParseArmtureData(ArmatureEditor armatureEditor, SimpleJSON.JSONClass armtureObj)
{
//parse bone data
if (armtureObj.ContainKey("bone"))
{
SimpleJSON.JSONArray bones = armtureObj["bone"].AsArray;
DragonBoneData.BoneData[] boneDatas = new DragonBoneData.BoneData[bones.Count];
for (int i = 0; i < bones.Count; ++i)
{
SimpleJSON.JSONClass boneObj = bones[i].AsObject;
DragonBoneData.BoneData boneData = new DragonBoneData.BoneData();
if (boneObj.ContainKey("length"))
{
boneData.length = boneObj["length"].AsFloat;
}
if (boneObj.ContainKey("name"))
{
boneData.name = boneObj["name"].ToString().Trim();
}
if (boneObj.ContainKey("parent"))
{
boneData.parent = boneObj["parent"].ToString();
}
if (boneObj.ContainKey("inheritRotation"))
{
boneData.inheritRotation = boneObj["inheritRotation"].AsInt == 1?true:false;
}
if (boneObj.ContainKey("inheritScale"))
{
boneData.inheritScale = boneObj["inheritScale"].AsInt == 1?true:false;
}
if (boneObj.ContainKey("transform"))
{
SimpleJSON.JSONClass transformObj = boneObj["transform"].AsObject;
DragonBoneData.TransformData transData = new DragonBoneData.TransformData();
if (transformObj.ContainKey("x"))
{
transData.x = transformObj["x"].AsFloat * 0.01f;
}
if (transformObj.ContainKey("y"))
{
transData.y = -transformObj["y"].AsFloat * 0.01f;
}
if (transformObj.ContainKey("skX"))
{
transData.rotate = -transformObj["skX"].AsFloat;
}
if (transformObj.ContainKey("scX"))
{
transData.scx = transformObj["scX"].AsFloat;
}
if (transformObj.ContainKey("scY"))
{
transData.scy = transformObj["scY"].AsFloat;
}
boneData.transform = transData;
}
boneDatas[i] = boneData;
armatureEditor.bonesDataKV[boneData.name] = boneData;
}
armatureEditor.armatureData.boneDatas = boneDatas;
}
//parse slot data
if (armtureObj.ContainKey("slot"))
{
SimpleJSON.JSONArray slots = armtureObj["slot"].AsArray;
DragonBoneData.SlotData[] slotDatas = new DragonBoneData.SlotData[slots.Count];
bool isMC = armatureEditor.armatureData.type.Equals("MovieClip");
for (int i = 0; i < slots.Count; ++i)
{
SimpleJSON.JSONClass slotObj = slots[i].AsObject;
DragonBoneData.SlotData slotData = new DragonBoneData.SlotData();
if (slotObj.ContainKey("name"))
{
slotData.name = slotObj["name"].ToString();
}
if (slotObj.ContainKey("parent"))
{
slotData.parent = slotObj["parent"].ToString();
}
if (slotObj.ContainKey("z"))
{
slotData.z = -slotObj["z"].AsFloat * armatureEditor.zoffset;
}
if (!isMC)
{
if (slotObj.ContainKey("displayIndex"))
{
slotData.displayIndex = slotObj["displayIndex"].AsInt;
}
}
if (slotObj.ContainKey("scale"))
{
slotData.scale = slotObj["scale"].AsFloat;
}
if (slotObj.ContainKey("blendMode"))
{
slotData.blendMode = slotObj["blendMode"].ToString();
}
if (slotObj.ContainKey("color"))
{
SimpleJSON.JSONClass colorObj = slotObj["color"].AsObject;
DragonBoneData.ColorData colorData = new DragonBoneData.ColorData();
if (colorObj.ContainKey("aM"))
{
colorData.aM = colorObj["aM"].AsFloat * 0.01f;
}
if (colorObj.ContainKey("a0"))
{
colorData.aM += colorObj["a0"].AsFloat / 255f;
}
if (colorObj.ContainKey("rM"))
{
colorData.rM = colorObj["rM"].AsFloat * 0.01f;
}
if (colorObj.ContainKey("r0"))
{
colorData.rM += colorObj["r0"].AsFloat / 255f;
}
if (colorObj.ContainKey("gM"))
{
colorData.gM = colorObj["gM"].AsFloat * 0.01f;
}
if (colorObj.ContainKey("g0"))
{
colorData.gM += colorObj["g0"].AsFloat / 255f;
}
if (colorObj.ContainKey("bM"))
{
colorData.bM = colorObj["bM"].AsFloat * 0.01f;
}
if (colorObj.ContainKey("b0"))
{
colorData.bM += colorObj["b0"].AsFloat / 255f;
}
slotData.color = colorData;
}
slotDatas[i] = slotData;
armatureEditor.slotsDataKV[slotData.name] = slotData;
}
armatureEditor.armatureData.slotDatas = slotDatas;
}
//parse IK data
if (armtureObj.ContainKey("ik"))
{
SimpleJSON.JSONArray iks = armtureObj["ik"].AsArray;
DragonBoneData.IKData[] ikDatas = new DragonBoneData.IKData[iks.Count];
for (int i = 0; i < iks.Count; ++i)
{
SimpleJSON.JSONClass ikObj = iks[i].AsObject;
DragonBoneData.IKData ikData = new DragonBoneData.IKData();
if (ikObj.ContainKey("name"))
{
ikData.name = ikObj["name"].ToString();
}
if (ikObj.ContainKey("bone"))
{
ikData.bone = ikObj["bone"].ToString();
}
if (ikObj.ContainKey("target"))
{
ikData.target = ikObj["target"].ToString();
}
if (ikObj.ContainKey("bendPositive"))
{
ikData.bendPositive = ikObj["bendPositive"].AsBool;
}
if (ikObj.ContainKey("chain"))
{
ikData.chain = ikObj["chain"].AsInt;
}
if (ikObj.ContainKey("weight"))
{
ikData.weight = ikObj["weight"].AsFloat;
}
ikDatas[i] = ikData;
}
armatureEditor.armatureData.ikDatas = ikDatas;
}
//parse animation file
if (armtureObj.ContainKey("animation"))
{
SimpleJSON.JSONArray anims = armtureObj["animation"].AsArray;
DragonBoneData.AnimationData[] animDatas = new DragonBoneData.AnimationData[anims.Count];
for (int i = 0; i < anims.Count; ++i)
{
SimpleJSON.JSONClass animObj = anims[i].AsObject;
DragonBoneData.AnimationData animData = new DragonBoneData.AnimationData();
if (animObj.ContainKey("name"))
{
animData.name = animObj["name"].ToString().Trim();
}
if (animObj.ContainKey("playTimes"))
{
animData.playTimes = animObj["playTimes"].AsInt;
}
if (animObj.ContainKey("duration"))
{
animData.duration = animObj["duration"].AsInt;
}
if (animData.duration == 0)
{
animData.duration = 1;
}
if (animObj.ContainKey("frame"))
{
ParseAnimFrames(animObj["frame"].AsArray, animData);
}
if (animObj.ContainKey("bone"))
{
SimpleJSON.JSONArray bones = animObj["bone"].AsArray;
animData.boneDatas = new DragonBoneData.AnimSubData[bones.Count];
ParsetAnimBoneSlot(armatureEditor, bones, animData.boneDatas);
}
if (animObj.ContainKey("slot"))
{
SimpleJSON.JSONArray slots = animObj["slot"].AsArray;
animData.slotDatas = new DragonBoneData.AnimSubData[slots.Count];
ParsetAnimBoneSlot(armatureEditor, slots, animData.slotDatas);
}
//ffd
if (animObj.ContainKey("ffd"))
{
SimpleJSON.JSONArray ffds = animObj["ffd"].AsArray;
animData.ffdDatas = new DragonBoneData.AnimSubData[ffds.Count];
ParsetAnimBoneSlot(armatureEditor, ffds, animData.ffdDatas);
}
//zOrder
if (animObj.ContainKey("zOrder"))
{
SimpleJSON.JSONClass zOrders = animObj["zOrder"].AsObject;
ParseAnimSortOrder(armatureEditor, zOrders, animData);
}
animDatas[i] = animData;
}
armatureEditor.armatureData.animDatas = animDatas;
}
//parse skin data
if (armtureObj.ContainKey("skin"))
{
SimpleJSON.JSONArray skins = armtureObj["skin"].AsArray;
DragonBoneData.SkinData[] skinDatas = new DragonBoneData.SkinData[skins.Count];
for (int i = 0; i < skins.Count; ++i)
{
DragonBoneData.SkinData skinData = new DragonBoneData.SkinData();
skinDatas[i] = skinData;
SimpleJSON.JSONClass skinObj = skins[i].AsObject;
string skinName = skinObj["name"].ToString();
skinData.skinName = skinName;
if (skinObj.ContainKey("slot"))
{
SimpleJSON.JSONArray slots = skinObj["slot"].AsArray;
skinData.slots = new DragonBoneData.SkinSlotData[slots.Count];
for (int j = 0; j < slots.Count; ++j)
{
DragonBoneData.SkinSlotData skinSlotData = new DragonBoneData.SkinSlotData();
SimpleJSON.JSONClass slot = slots[j].AsObject;
skinData.slots[j] = skinSlotData;
if (slot.ContainKey("name"))
{
skinSlotData.slotName = slot["name"].ToString();
}
if (slot.ContainKey("display"))
{
SimpleJSON.JSONArray display = slot["display"].AsArray;
skinSlotData.displays = new DragonBoneData.SkinSlotDisplayData[display.Count];
for (int k = 0; k < display.Count; ++k)
{
DragonBoneData.SkinSlotDisplayData displayData = new DragonBoneData.SkinSlotDisplayData();
skinSlotData.displays[k] = displayData;
SimpleJSON.JSONClass displayObj = display[k].AsObject;
if (displayObj.ContainKey("name"))
{
displayData.textureName = displayObj["name"].ToString().Replace('/', '_');
}
if (displayObj.ContainKey("path"))
{
displayData.texturePath = displayObj["path"].ToString();
}
else
{
displayData.texturePath = displayData.textureName;
}
if (displayObj.ContainKey("type"))
{
displayData.type = displayObj["type"].ToString();
}
if (displayObj.ContainKey("subType"))
{
displayData.subType = displayObj["subType"].ToString();
}
if (displayObj.ContainKey("pivot"))
{
displayData.pivot = new Vector2(displayObj["pivot"].AsObject["x"].AsFloat, displayObj["pivot"].AsObject["y"].AsFloat);
}
if (displayObj.ContainKey("transform"))
{
SimpleJSON.JSONClass transformObj = displayObj["transform"].AsObject;
DragonBoneData.TransformData transData = new DragonBoneData.TransformData();
if (transformObj.ContainKey("x"))
{
transData.x = transformObj["x"].AsFloat * 0.01f;
}
if (transformObj.ContainKey("y"))
{
transData.y = -transformObj["y"].AsFloat * 0.01f;
}
if (transformObj.ContainKey("skX"))
{
transData.rotate = -transformObj["skX"].AsFloat;
}
if (transformObj.ContainKey("scX"))
{
transData.scx = transformObj["scX"].AsFloat;
}
if (transformObj.ContainKey("scY"))
{
transData.scy = transformObj["scY"].AsFloat;
}
displayData.transform = transData;
}
//uv
if (displayObj.ContainKey("uvs"))
{
SimpleJSON.JSONArray uvsObj = displayObj["uvs"].AsArray;
int index = 0;
displayData.uvs = new Vector2[uvsObj.Count / 2];
for (int z = 0; z < uvsObj.Count; z += 2)
{
Vector2 uv = new Vector2(uvsObj[z].AsFloat, 1 - uvsObj[z + 1].AsFloat);
displayData.uvs[index] = uv;
++index;
}
}
//weight
if (displayObj.ContainKey("weights"))
{
SimpleJSON.JSONArray weightsObj = displayObj["weights"].AsArray;
displayData.weights = new float[weightsObj.Count];
for (int z = 0; z < weightsObj.Count; ++z)
{
displayData.weights[z] = weightsObj[z].AsFloat;
}
}
//bonepose
if (displayObj.ContainKey("bonePose"))
{
SimpleJSON.JSONArray bonePoseObj = displayObj["bonePose"].AsArray;
displayData.bonePose = new float[bonePoseObj.Count];
for (int z = 0; z < bonePoseObj.Count; z += 7)
{
displayData.bonePose[z] = bonePoseObj[z].AsFloat;
displayData.bonePose[z + 1] = bonePoseObj[z + 1].AsFloat; //a
displayData.bonePose[z + 2] = bonePoseObj[z + 2].AsFloat; //b
displayData.bonePose[z + 3] = bonePoseObj[z + 3].AsFloat; //c
displayData.bonePose[z + 4] = bonePoseObj[z + 4].AsFloat; //d
displayData.bonePose[z + 5] = bonePoseObj[z + 5].AsFloat; //tx
displayData.bonePose[z + 6] = bonePoseObj[z + 6].AsFloat; //ty
Matrix2D m = new Matrix2D(displayData.bonePose[z + 1], displayData.bonePose[z + 2],
displayData.bonePose[z + 3], displayData.bonePose[z + 4], displayData.bonePose[z + 5], displayData.bonePose[z + 6]);
armatureEditor.bonePoseKV[displayData.textureName + armatureEditor.armatureData.boneDatas[(int)displayData.bonePose[z]].name] = m;
}
}
Matrix2D slotPoseMat = null;
//slotpose
if (displayObj.ContainKey("slotPose"))
{
SimpleJSON.JSONArray slotPoseObj = displayObj["slotPose"].AsArray;
slotPoseMat = new Matrix2D(slotPoseObj[0].AsFloat, slotPoseObj[1].AsFloat, slotPoseObj[2].AsFloat,
slotPoseObj[3].AsFloat, slotPoseObj[4].AsFloat, slotPoseObj[5].AsFloat);
}
//vertex
if (displayObj.ContainKey("vertices"))
{
SimpleJSON.JSONArray verticesObj = displayObj["vertices"].AsArray;
displayData.vertices = new Vector3[verticesObj.Count / 2];
for (int z = 0; z < verticesObj.Count; z += 2)
{
int vertexIndex = z / 2;
Vector3 vertex = new Vector3(verticesObj[z].AsFloat, verticesObj[z + 1].AsFloat, 0f);
if (slotPoseMat != null)
{
//slotPose转换
vertex = (Vector3)slotPoseMat.TransformPoint(vertex.x, vertex.y);
}
vertex.x *= 0.01f;
vertex.y *= -0.01f;
displayData.vertices[vertexIndex] = vertex;
}
}
//triangles
if (displayObj.ContainKey("triangles"))
{
SimpleJSON.JSONArray trianglesObj = displayObj["triangles"].AsArray;
displayData.triangles = new int[trianglesObj.Count];
for (int z = 0; z < trianglesObj.Count; z++)
{
displayData.triangles[z] = trianglesObj[z].AsInt;
}
//dragonBone和unity的z相反
for (int z = 0; z < displayData.triangles.Length; z += 3)
{
int f1 = displayData.triangles[z];
int f3 = displayData.triangles[z + 2];
displayData.triangles[z] = f3;
displayData.triangles[z + 2] = f1;
}
}
//edges
//userdeges
}
}
}
}
}
armatureEditor.armatureData.skinDatas = skinDatas;
}
}
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);
}
public Matrix2D Copy(Matrix2D matrix)
{
return(this.SetTo(matrix.a, matrix.b, matrix.c, matrix.d, matrix.tx, matrix.ty));
}
