private void _UpdateSortingGroup()
{
//发现骨架有SortingGroup，那么子骨架也都加上，反之删除
_sortingGroup = GetComponent <UnityEngine.Rendering.SortingGroup>();
if (_sortingGroup != null)
{
_sortingMode = SortingMode.SortByOrder;
_sortingLayerName = _sortingGroup.sortingLayerName;
_sortingOrder = _sortingGroup.sortingOrder;
foreach (UnitySlot slot in _armature.GetSlots())
{
if (slot.childArmature != null)
{
var childArmatureProxy = slot.childArmature.proxy as UnityArmatureComponent;
childArmatureProxy._sortingGroup =
childArmatureProxy.GetComponent <UnityEngine.Rendering.SortingGroup>();
if (childArmatureProxy._sortingGroup == null)
{
childArmatureProxy._sortingGroup = childArmatureProxy.gameObject
.AddComponent <UnityEngine.Rendering.SortingGroup>();
}
childArmatureProxy._sortingGroup.sortingLayerName = _sortingLayerName;
childArmatureProxy._sortingGroup.sortingOrder = _sortingOrder;
}
}
}
else
{
_sortingMode = SortingMode.SortByZ;
foreach (UnitySlot slot in _armature.GetSlots())
{
if (slot.childArmature != null)
{
var childArmatureProxy = slot.childArmature.proxy as UnityArmatureComponent;
childArmatureProxy._sortingGroup =
childArmatureProxy.GetComponent <UnityEngine.Rendering.SortingGroup>();
if (childArmatureProxy._sortingGroup != null)
{
DestroyImmediate(childArmatureProxy._sortingGroup);
}
}
}
}
#if UNITY_EDITOR
EditorUtility.SetDirty(this);
#endif
_UpdateSlotsSorting();
}
/// <summary>
/// - Replaces the existing animation data for a specific armature with the animation data for the specific armature data.
/// This enables you to make a armature template so that other armature without animations can share it's animations.
/// </summary>
/// <param name="armature">- The armtaure.</param>
/// <param name="armatureData">- The armature data.</param>
/// <param name="isOverride">- Whether to completely overwrite the original animation. (Default: false)</param>
/// <example>
/// TypeScript style, for reference only.
/// <pre>
/// let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
/// let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
/// if (armatureDataB) {
/// factory.replaceAnimation(armatureA, armatureDataB);
/// }
/// </pre>
/// </example>
/// <see cref="DragonBones.Armature"/>
/// <see cref="DragonBones.ArmatureData"/>
/// <version>DragonBones 5.6</version>
/// <language>en_US</language>
/// <summary>
/// - 用特定骨架数据的动画数据替换特定骨架现有的动画数据。
/// 这样就能实现制作一个骨架动画模板，让其他没有制作动画的骨架共享该动画。
/// </summary>
/// <param name="armature">- 骨架。</param>
/// <param name="armatureData">- 骨架数据。</param>
/// <param name="isOverride">- 是否完全覆盖原来的动画。（默认: false）。</param>
/// <example>
/// TypeScript 风格，仅供参考。
/// <pre>
/// let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
/// let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
/// if (armatureDataB) {
/// factory.replaceAnimation(armatureA, armatureDataB);
/// }
/// </pre>
/// </example>
/// <see cref="DragonBones.Armature"/>
/// <see cref="DragonBones.ArmatureData"/>
/// <version>DragonBones 5.6</version>
/// <language>zh_CN</language>
public bool ReplaceAnimation(Armature armature,
ArmatureData armatureData,
bool isOverride = true)
{
var skinData = armatureData.defaultSkin;
if (skinData == null)
{
return(false);
}
if (isOverride)
{
armature.animation.animations = armatureData.animations;
}
else
{
var rawAnimations = armature.animation.animations;
Dictionary <string, AnimationData> animations = new Dictionary <string, AnimationData>();
foreach (var k in rawAnimations.Keys)
{
animations[k] = rawAnimations[k];
}
foreach (var k in armatureData.animations.Keys)
{
animations[k] = armatureData.animations[k];
}
armature.animation.animations = animations;
}
foreach (var slot in armature.GetSlots())
{
var index = 0;
foreach (var display in slot.displayList)
{
if (display is Armature)
{
var displayDatas = skinData.GetDisplays(slot.name);
if (displayDatas != null && index < displayDatas.Count)
{
var displayData = displayDatas[index];
if (displayData != null && displayData.type == DisplayType.Armature)
{
var childArmatureData = this.GetArmatureData(displayData.path, displayData.parent.parent.parent.name);
if (childArmatureData != null)
{
this.ReplaceAnimation(display as Armature, childArmatureData, isOverride);
}
}
}
}
}
}
return(true);
}
/**
* 更换骨架皮肤。
* @param armature 骨架。
* @param skin 皮肤数据。
* @param exclude 不需要更新的插槽。
* @see dragonBones.Armature
* @see dragonBones.SkinData
* @version DragonBones 5.1
* @language zh_CN
*/
public void ChangeSkin(Armature armature, SkinData skin, List <string> exclude = null)
{
foreach (var slot in armature.GetSlots())
{
if (exclude != null && exclude.Contains(slot.name))
{
continue;
}
var displays = skin.GetDisplays(slot.name);
if (displays == null)
{
continue;
}
var displayCount = displays.Count;
var displayList = slot.displayList; // Copy.
displayList.ResizeList(displayCount); // Modify displayList length.
for (int i = 0, l = displayCount; i < l; ++i)
{
var displayData = displays[i];
if (displayData != null)
{
displayList[i] = this._GetSlotDisplay(null, displayData, null, slot);
}
else
{
displayList[i] = null;
}
}
slot.rawDisplayDatas = displays;
slot.displayList = displayList;
}
}
/**
* @language zh_CN
* 将指定骨架的动画替换成其他骨架的动画。 (通常这些骨架应该具有相同的骨架结构)
* @param toArmature 指定的骨架。
* @param fromArmatreName 其他骨架的名称。
* @param fromSkinName 其他骨架的皮肤名称，如果未设置，则使用默认皮肤。
* @param fromDragonBonesDataName 其他骨架属于的龙骨数据名称，如果未设置，则检索所有的龙骨数据。
* @param ifRemoveOriginalAnimationList 是否移除原有的动画。 [true: 移除, false: 不移除]
* @returns 是否替换成功。 [true: 成功, false: 不成功]
* @see dragonBones.Armature
* @version DragonBones 4.5
*/
public bool CopyAnimationsToArmature(
Armature toArmature, string fromArmatreName, string fromSkinName = null,
string fromDragonBonesDataName = null, bool ifRemoveOriginalAnimationList = true
)
{
var dataPackage = new BuildArmaturePackage();
if (_fillBuildArmaturePackage(fromDragonBonesDataName, fromArmatreName, fromSkinName, dataPackage))
{
var fromArmatureData = dataPackage.armature;
if (ifRemoveOriginalAnimationList)
{
toArmature.animation.animations = fromArmatureData.animations;
}
else
{
var animations = new Dictionary <string, AnimationData>();
foreach (var pair in toArmature.animation.animations)
{
animations[pair.Key] = toArmature.animation.animations[pair.Key];
}
foreach (var pair in fromArmatureData.animations)
{
animations[pair.Key] = fromArmatureData.animations[pair.Key];
}
toArmature.animation.animations = animations;
}
if (dataPackage.skin != null)
{
foreach (var toSlot in toArmature.GetSlots())
{
var toSlotDisplayList = toSlot.displayList;
for (int i = 0, l = toSlotDisplayList.Count; i < l; ++i)
{
var toDisplayObject = toSlotDisplayList[i];
if (toDisplayObject is Armature)
{
var displays = dataPackage.skin.GetSlot(toSlot.name).displays;
if (i < displays.Count)
{
var fromDisplayData = displays[i];
if (fromDisplayData.type == DisplayType.Armature)
{
CopyAnimationsToArmature((Armature)toDisplayObject, fromDisplayData.name, fromSkinName, fromDragonBonesDataName, ifRemoveOriginalAnimationList);
}
}
}
}
}
return(true);
}
}
return(false);
}
/// <summary>
/// - Share specific skin data with specific armature.
/// </summary>
/// <param name="armature">- The armature.</param>
/// <param name="skin">- The skin data.</param>
/// <param name="isOverride">- Whether it completely override the original skin. (Default: false)</param>
/// <param name="exclude">- A list of slot names that do not need to be replace.</param>
/// <example>
/// TypeScript style, for reference only.
/// <pre>
/// let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
/// let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
/// if (armatureDataB && armatureDataB.defaultSkin) {
/// factory.replaceSkin(armatureA, armatureDataB.defaultSkin, false, ["arm_l", "weapon_l"]);
/// }
/// </pre>
/// </example>
/// <see cref="DragonBones.Armature"/>
/// <see cref="DragonBones.SkinData"/>
/// <version>DragonBones 5.6</version>
/// <language>en_US</language>
/// <summary>
/// - 将特定的皮肤数据共享给特定的骨架使用。
/// </summary>
/// <param name="armature">- 骨架。</param>
/// <param name="skin">- 皮肤数据。</param>
/// <param name="isOverride">- 是否完全覆盖原来的皮肤。 （默认: false）</param>
/// <param name="exclude">- 不需要被替换的插槽名称列表。</param>
/// <example>
/// TypeScript 风格，仅供参考。
/// <pre>
/// let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
/// let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
/// if (armatureDataB && armatureDataB.defaultSkin) {
/// factory.replaceSkin(armatureA, armatureDataB.defaultSkin, false, ["arm_l", "weapon_l"]);
/// }
/// </pre>
/// </example>
/// <see cref="DragonBones.Armature"/>
/// <see cref="DragonBones.SkinData"/>
/// <version>DragonBones 5.6</version>
/// <language>zh_CN</language>
public bool ReplaceSkin(Armature armature, SkinData skin, bool isOverride = false, List <string> exclude = null)
{
var success = false;
var defaultSkin = skin.parent.defaultSkin;
foreach (var slot in armature.GetSlots())
{
if (exclude != null && exclude.Contains(slot.name))
{
continue;
}
var displays = skin.GetDisplays(slot.name);
if (displays == null)
{
if (defaultSkin != null && skin != defaultSkin)
{
displays = defaultSkin.GetDisplays(slot.name);
}
if (displays == null)
{
if (isOverride)
{
slot.rawDisplayDatas = null;
slot.displayList.Clear(); //
}
continue;
}
}
var displayCount = displays.Count;
var displayList = slot.displayList; // Copy.
displayList.ResizeList(displayCount); // Modify displayList length.
for (int i = 0, l = displayCount; i < l; ++i)
{
var displayData = displays[i];
if (displayData != null)
{
displayList[i] = this._GetSlotDisplay(null, displayData, null, slot);
}
else
{
displayList[i] = null;
}
}
success = true;
slot.rawDisplayDatas = displays;
slot.displayList = displayList;
}
return(success);
}
private void RestoreArmature(Armature armature)
{
if (armature == null)
{
return;
}
//
foreach (UnitySlot slot in armature.GetSlots())
{
if (slot.childArmature == null)
{
slot.CancelCombineMesh();
}
}
}
static int GetSlots(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 1);
DragonBones.Armature obj = (DragonBones.Armature)ToLua.CheckObject(L, 1, typeof(DragonBones.Armature));
System.Collections.Generic.List <DragonBones.Slot> o = obj.GetSlots();
ToLua.PushObject(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
void ColletSlotData(Armature armature, int sumLevel)
{
var slots = armature.GetSlots();
foreach (UnitySlot slot in slots)
{
var slotItem = new SlotItemData();
slotItem.slot = slot;
slotItem.sumLevel = sumLevel;
slotItem.isSelected = slot.isIgnoreCombineMesh || (slot.renderDisplay != null && slot.renderDisplay.activeSelf);
this._slotItems.Add(slotItem);
if (slot.childArmature != null)
{
this.ColletSlotData(slot.childArmature, sumLevel + 1);
}
}
}
void DisplayEnable(Armature armature, bool flag)
{
foreach (Slot slot in armature.GetSlots())
{
if (slot.childArmature != null)
{
DisplayEnable(slot.childArmature, flag);
}
else if (slot.rawDisplay != null)
{
MeshRenderer mr = (slot.rawDisplay as GameObject).GetComponent <MeshRenderer>();
if (mr)
{
mr.enabled = flag;
}
}
}
}
void CollectMesh(Armature armature, List <List <CombineInstance> > combines, List <Material> mats)
{
List <Slot> slots = new List <Slot>(armature.GetSlots());
foreach (UnitySlot us in slots)
{
if (us.childArmature != null)
{
CollectMesh(us.childArmature, combines, mats);
}
var currentTextureData = us.currentTextureAtlasData;
if (currentTextureData != null && currentTextureData.texture)
{
if (mats.Count == 0 || mats[mats.Count - 1] != currentTextureData.texture)
{
mats.Add(currentTextureData.texture);
}
if (combines.Count < mats.Count)
{
combines.Add(new List <CombineInstance>());
}
if (us != null && us.mesh != null)
{
GameObject go = us.renderDisplay;
if (go != null && go.activeSelf)
{
CombineInstance com = new CombineInstance();
com.mesh = us.mesh;
com.transform = transform.worldToLocalMatrix * go.transform.localToWorldMatrix;
combines[mats.Count - 1].Add(com);
}
}
}
}
}
/**
* @private
*/
internal void _advanceTime(float passedTime)
{
if (!_isPlaying)
{
return;
}
if (passedTime < 0.0f)
{
passedTime = -passedTime;
}
if (_armature.inheritAnimation && _armature._parent != null) // Inherit parent animation timeScale.
{
passedTime *= _armature._parent._armature.animation.timeScale;
}
if (timeScale != 1.0f)
{
passedTime *= timeScale;
}
var animationStateCount = _animationStates.Count;
if (animationStateCount == 1)
{
var animationState = _animationStates[0];
if (animationState._fadeState > 0 && animationState._subFadeState > 0)
{
animationState.ReturnToPool();
_animationStates.Clear();
_animationStateDirty = true;
_lastAnimationState = null;
}
else
{
var animationData = animationState.animationData;
var cacheFrameRate = animationData.cacheFrameRate;
if (_animationStateDirty && cacheFrameRate > 0.0f) // Update cachedFrameIndices.
{
_animationStateDirty = false;
var bones = _armature.GetBones();
for (int i = 0, l = bones.Count; i < l; ++i)
{
var bone = bones[i];
bone._cachedFrameIndices = animationData.GetBoneCachedFrameIndices(bone.name);
}
var slots = _armature.GetSlots();
for (int i = 0, l = slots.Count; i < l; ++i)
{
var slot = slots[i];
slot._cachedFrameIndices = animationData.GetSlotCachedFrameIndices(slot.name);
}
}
if (_timelineStateDirty)
{
animationState._updateTimelineStates();
}
animationState._advanceTime(passedTime, cacheFrameRate);
}
}
else if (animationStateCount > 1)
{
for (int i = 0, r = 0; i < animationStateCount; ++i)
{
var animationState = _animationStates[i];
if (animationState._fadeState > 0 && animationState._fadeProgress <= 0.0f)
{
r++;
animationState.ReturnToPool();
_animationStateDirty = true;
if (_lastAnimationState == animationState) // Update last animation state.
{
_lastAnimationState = null;
}
}
else
{
if (r > 0)
{
_animationStates[i - r] = animationState;
}
if (_timelineStateDirty)
{
animationState._updateTimelineStates();
}
animationState._advanceTime(passedTime, 0.0f);
}
if (i == animationStateCount - 1 && r > 0) // Modify animation states size.
{
DragonBones.ResizeList(_animationStates, animationStateCount - r, null);
if (_lastAnimationState == null && _animationStates.Count > 0)
{
_lastAnimationState = _animationStates[_animationStates.Count - 1];
}
}
}
_cacheFrameIndex = -1;
}
else
{
_cacheFrameIndex = -1;
}
_timelineStateDirty = false;
}
/**
* @language zh_CN
* 淡入播放指定名称的动画。
* @param animationName 动画数据的名称。
* @param playTimes 循环播放的次数。 [-1: 使用数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次]
* @param fadeInTime 淡入的时间。 [-1: 使用数据默认值, [0~N]: N 秒淡入完毕] (以秒为单位)
* @param layer 混合的图层，图层高会优先获取混合权重。
* @param group 混合的组，用于给动画状态编组，方便混合淡出控制。
* @param fadeOutMode 淡出的模式。
* @param additiveBlending 以叠加的形式混合。
* @param displayControl 是否对显示对象属性可控。
* @param pauseFadeOut 暂停需要淡出的动画。
* @param pauseFadeIn 暂停需要淡入的动画，直到淡入结束才开始播放。
* @returns 返回控制这个动画数据的动画状态。
* @see dragonBones.AnimationFadeOutMode
* @see dragonBones.AnimationState
* @version DragonBones 4.5
*/
public AnimationState FadeIn(
string animationName, float fadeInTime = -1.0f, int playTimes = -1,
int layer = 0, string group = null, AnimationFadeOutMode fadeOutMode = AnimationFadeOutMode.SameLayerAndGroup,
bool additiveBlending = false, bool displayControl = true,
bool pauseFadeOut = true, bool pauseFadeIn = true
)
{
if (!_animations.ContainsKey(animationName))
{
_time = 0;
DragonBones.Warn(
"Non-existent animation. " +
" DragonBones: " + _armature.armatureData.parent.name +
" Armature: " + _armature.name +
" Animation: " + animationName
);
return(null);
}
var animationData = _animations[animationName];
if (float.IsNaN(_time))
{
_time = 0.0f;
}
_isPlaying = true;
if (fadeInTime < 0.0f || float.IsNaN(fadeInTime))
{
if (_lastAnimationState != null)
{
fadeInTime = animationData.fadeInTime;
}
else
{
fadeInTime = 0.0f;
}
}
if (playTimes < 0)
{
playTimes = (int)animationData.playTimes;
}
_fadeOut(fadeInTime, layer, group, fadeOutMode, pauseFadeOut);
_lastAnimationState = BaseObject.BorrowObject <AnimationState>();
_lastAnimationState._layer = layer;
_lastAnimationState._group = group;
_lastAnimationState.additiveBlending = additiveBlending;
_lastAnimationState.displayControl = displayControl;
_lastAnimationState._fadeIn(
_armature, animationData.animation != null ? animationData.animation : animationData, animationName,
(uint)playTimes, animationData.position, animationData.duration, _time, 1 / animationData.scale, fadeInTime,
pauseFadeIn
);
_animationStates.Add(_lastAnimationState);
_animationStateDirty = true;
_time = 0.0f;
_armature._cacheFrameIndex = -1;
if (_animationStates.Count > 1)
{
_animationStates.Sort(_sortAnimationState);
}
foreach (var slot in _armature.GetSlots())
{
if (slot.inheritAnimation)
{
var childArmature = slot.childArmature;
if (
childArmature != null &&
childArmature.animation.HasAnimation(animationName) &&
childArmature.animation.GetState(animationName) == null
)
{
childArmature.animation.FadeIn(animationName);
}
}
}
if (fadeInTime <= 0.0f)
{
_armature.AdvanceTime(0.0f); // Blend animation state, update armature. (pass actions and events)
}
return(_lastAnimationState);
}
public void CollectMesh(Armature armature, List <CombineMeshInfo> combineSlots)
{
if (armature == null)
{
return;
}
var slots = new List <Slot>(armature.GetSlots());
if (slots.Count == 0)
{
return;
}
//
var isBreakCombineMesh = false;
var isSameMaterial = false;
var isChildAramture = false;
UnitySlot slotMeshProxy = null;
GameObject slotDisplay = null;
for (var i = 0; i < slots.Count; i++)
{
var slot = slots[i] as UnitySlot;
slot.CancelCombineMesh();
isChildAramture = slot.childArmature != null;
slotDisplay = slot.renderDisplay;
if (slotMeshProxy != null)
{
if (slot._meshBuffer.name == string.Empty)
{
isSameMaterial = true;
}
else
{
isSameMaterial = slotMeshProxy._meshBuffer.name == slot._meshBuffer.name;
}
}
else
{
isSameMaterial = slotMeshProxy == null;
}
//先检查这个slot会不会打断网格合并
isBreakCombineMesh = isChildAramture ||
slot._isIgnoreCombineMesh ||
!isSameMaterial;
//如果会打断，那么先合并一次
if (isBreakCombineMesh)
{
if (combineSlots.Count > 0)
{
if (combineSlots[combineSlots.Count - 1].combines.Count == 1)
{
combineSlots.RemoveAt(combineSlots.Count - 1);
}
}
slotMeshProxy = null;
}
//
if (slotMeshProxy == null && !isBreakCombineMesh && slotDisplay != null && slotDisplay.activeSelf)
{
CombineMeshInfo combineSlot = new CombineMeshInfo();
combineSlot.proxySlot = slot;
combineSlot.combines = new List <CombineInstance>();
combineSlot.slots = new List <UnitySlot>();
combineSlots.Add(combineSlot);
slotMeshProxy = slot;
}
//如果不会合并，检查一下是否是子骨架
if (isChildAramture)
{
continue;
}
if (slotMeshProxy != null && slotDisplay != null && slotDisplay.activeSelf && !slot._isIgnoreCombineMesh)
{
var parentTransfrom = (slot._armature.proxy as UnityArmatureComponent).transform;
CombineInstance com = new CombineInstance();
com.mesh = slot._meshBuffer.sharedMesh;
com.transform = slotMeshProxy._renderDisplay.transform.worldToLocalMatrix * slotDisplay.transform.localToWorldMatrix;
combineSlots[combineSlots.Count - 1].combines.Add(com);
combineSlots[combineSlots.Count - 1].slots.Add(slot);
}
if (i != slots.Count - 1)
{
continue;
}
//
if (combineSlots.Count > 0)
{
if (combineSlots[combineSlots.Count - 1].combines.Count == 1)
{
combineSlots.RemoveAt(combineSlots.Count - 1);
}
}
slotMeshProxy = null;
}
}
/**
* @private
*/
void Awake()
{
#if UNITY_5_6_OR_NEWER
if (!isUGUI)
{
_sortingGroup = GetComponent <UnityEngine.Rendering.SortingGroup>();
if (_sortingGroup)
{
sortingMode = SortingMode.SortByOrder;
_sortingLayerName = _sortingGroup.sortingLayerName;
_sortingOrder = _sortingGroup.sortingOrder;
}
}
#endif
if (slotsRoot == null)
{
GameObject go = new GameObject("Slots");
go.transform.SetParent(transform);
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
go.transform.localScale = Vector3.one;
slotsRoot = go;
go.hideFlags = HideFlags.NotEditable;
}
zorderIsDirty = true;
if (unityData != null && unityData.dragonBonesJSON != null && unityData.textureAtlas != null)
{
var dragonBonesData = UnityFactory.factory.LoadData(unityData, isUGUI);
if (dragonBonesData != null && !string.IsNullOrEmpty(armatureName))
{
UnityFactory.factory.BuildArmatureComponent(armatureName, dragonBonesData.name, null, unityData.dataName, gameObject);
}
}
if (_armature != null)
{
sortingLayerName = sortingLayerName;
sortingOrder = sortingOrder;
_armature.flipX = flipX;
_armature.flipY = flipY;
if (zSpace > 0)
{
foreach (var slot in _armature.GetSlots())
{
var display = slot.display as GameObject;
if (display != null)
{
display.transform.localPosition = new Vector3(display.transform.localPosition.x, display.transform.localPosition.y, -slot._zOrder * (_zSpace + 0.001f));
if (!isUGUI && sortingMode == SortingMode.SortByOrder)
{
UnitySlot us = slot as UnitySlot;
if (us.meshRenderer != null)
{
us.meshRenderer.sortingOrder = slot._zOrder;
}
}
}
}
}
if (!string.IsNullOrEmpty(animationName))
{
_armature.animation.Play(animationName);
}
CollectBones();
}
}
/**
* 将骨架的动画替换成其他骨架的动画。 (通常这些骨架应该具有相同的骨架结构)
* @param toArmature 指定的骨架。
* @param fromArmatreName 其他骨架的名称。
* @param fromSkinName 其他骨架的皮肤名称，如果未设置，则使用默认皮肤。
* @param fromDragonBonesDataName 其他骨架属于的龙骨数据名称，如果未设置，则检索所有的龙骨数据。
* @param replaceOriginalAnimation 是否替换原有的同名动画。
* @returns 是否替换成功。
* @see dragonBones.Armature
* @see dragonBones.ArmatureData
* @version DragonBones 4.5
* @language zh_CN
*/
public bool CopyAnimationsToArmature(Armature toArmature,
string fromArmatreName,
string fromSkinName = null,
string fromDragonBonesDataName = null,
bool replaceOriginalAnimation = true)
{
var dataPackage = new BuildArmaturePackage();
if (this._FillBuildArmaturePackage(dataPackage, fromDragonBonesDataName, fromArmatreName, fromSkinName, ""))
{
var fromArmatureData = dataPackage.armature;
if (replaceOriginalAnimation)
{
toArmature.animation.animations = fromArmatureData.animations;
}
else
{
Dictionary <string, AnimationData> animations = new Dictionary <string, AnimationData>();
foreach (var animationName in toArmature.animation.animations.Keys)
{
animations[animationName] = toArmature.animation.animations[animationName];
}
foreach (var animationName in fromArmatureData.animations.Keys)
{
animations[animationName] = fromArmatureData.animations[animationName];
}
toArmature.animation.animations = animations;
}
if (dataPackage.skin != null)
{
var slots = toArmature.GetSlots();
for (int i = 0, l = slots.Count; i < l; ++i)
{
var toSlot = slots[i];
var toSlotDisplayList = toSlot.displayList;
for (int j = 0, lJ = toSlotDisplayList.Count; j < lJ; ++j)
{
var toDisplayObject = toSlotDisplayList[j];
if (toDisplayObject is Armature)
{
var displays = dataPackage.skin.GetDisplays(toSlot.name);
if (displays != null && j < displays.Count)
{
var fromDisplayData = displays[j];
if (fromDisplayData != null && fromDisplayData.type == DisplayType.Armature)
{
this.CopyAnimationsToArmature(toDisplayObject as Armature, fromDisplayData.path, fromSkinName, fromDragonBonesDataName, replaceOriginalAnimation);
}
}
}
}
}
return(true);
}
}
return(false);
}
/**
* @private
*/
internal void _updateTimelineStates()
{
var time = _time;
if (!_animationData.hasAsynchronyTimeline)
{
time = _timeline._currentTime;
}
var boneTimelineStates = new Dictionary <string, BoneTimelineState>();
var slotTimelineStates = new Dictionary <string, SlotTimelineState>();
foreach (var boneTimelineState in _boneTimelines) // Creat bone timelines map.
{
boneTimelineStates.Add(boneTimelineState.bone.name, boneTimelineState);
}
foreach (var bone in _armature.GetBones())
{
var boneTimelineName = bone.name;
var boneTimelineData = _animationData.GetBoneTimeline(boneTimelineName);
if (boneTimelineData != null && ContainsBoneMask(boneTimelineName))
{
var boneTimelineState = boneTimelineStates.ContainsKey(boneTimelineName) ? boneTimelineStates[boneTimelineName] : null;
if (boneTimelineState != null) // Remove bone timeline from map.
{
boneTimelineStates.Remove(boneTimelineName);
}
else // Create new bone timeline.
{
boneTimelineState = BaseObject.BorrowObject <BoneTimelineState>();
boneTimelineState.bone = bone;
boneTimelineState.FadeIn(_armature, this, boneTimelineData, time);
_boneTimelines.Add(boneTimelineState);
}
}
}
foreach (var boneTimelineState in boneTimelineStates.Values) // Remove bone timelines.
{
boneTimelineState.bone.InvalidUpdate(); //
_boneTimelines.Remove(boneTimelineState);
boneTimelineState.ReturnToPool();
}
foreach (var slotTimelineState in _slotTimelines) // Create slot timelines map.
{
slotTimelineStates[slotTimelineState.slot.name] = slotTimelineState;
}
foreach (var slot in _armature.GetSlots())
{
var slotTimelineName = slot.name;
var parentTimelineName = slot.parent.name;
var slotTimelineData = _animationData.GetSlotTimeline(slotTimelineName);
if (slotTimelineData != null && ContainsBoneMask(parentTimelineName) && _fadeState <= 0)
{
var slotTimelineState = slotTimelineStates.ContainsKey(slotTimelineName) ? slotTimelineStates[slotTimelineName] : null;
if (slotTimelineState != null) // Remove slot timeline from map.
{
slotTimelineStates.Remove(slotTimelineName);
}
else // Create new slot timeline.
{
slotTimelineState = BaseObject.BorrowObject <SlotTimelineState>();
slotTimelineState.slot = slot;
slotTimelineState.FadeIn(_armature, this, slotTimelineData, time);
_slotTimelines.Add(slotTimelineState);
}
}
}
foreach (var slotTimelineState in slotTimelineStates.Values) // Remove slot timelines.
{
_slotTimelines.Remove(slotTimelineState);
slotTimelineState.ReturnToPool();
}
_updateFFDTimelineStates();
}
/**
* @private
*/
internal void _updateTimelineStates()
{
var boneTimelineStates = new Dictionary <string, BoneTimelineState>();
var slotTimelineStates = new Dictionary <string, SlotTimelineState>();
var ffdTimelineStates = new Dictionary <string, FFDTimelineState>();
for (int i = 0, l = _boneTimelines.Count; i < l; ++i) // Creat bone timelines map.
{
var boneTimelineState = _boneTimelines[i];
boneTimelineStates[boneTimelineState.bone.name] = boneTimelineState;
}
var bones = _armature.GetBones();
for (int i = 0, l = bones.Count; i < l; ++i)
{
var bone = bones[i];
var boneTimelineName = bone.name;
if (ContainsBoneMask(boneTimelineName))
{
var boneTimelineData = _animationData.GetBoneTimeline(boneTimelineName);
if (boneTimelineData != null)
{
if (boneTimelineStates.ContainsKey(boneTimelineName)) // Remove bone timeline from map.
{
boneTimelineStates.Remove(boneTimelineName);
}
else // Create new bone timeline.
{
var boneTimelineState = BaseObject.BorrowObject <BoneTimelineState>();
boneTimelineState.bone = bone;
boneTimelineState._init(_armature, this, boneTimelineData);
_boneTimelines.Add(boneTimelineState);
}
}
}
}
foreach (var boneTimelineState in boneTimelineStates.Values) // Remove bone timelines.
{
boneTimelineState.bone.InvalidUpdate(); //
_boneTimelines.Remove(boneTimelineState);
boneTimelineState.ReturnToPool();
}
for (int i = 0, l = _slotTimelines.Count; i < l; ++i) // Creat slot timelines map.
{
var slotTimelineState = _slotTimelines[i];
slotTimelineStates[slotTimelineState.slot.name] = slotTimelineState;
}
for (int i = 0, l = _ffdTimelines.Count; i < l; ++i) // Creat ffd timelines map.
{
var ffdTimelineState = _ffdTimelines[i];
var display = ffdTimelineState._timelineData.display;
var meshName = display.inheritAnimation ? display.mesh.name : display.name;
ffdTimelineStates[meshName] = ffdTimelineState;
}
var slots = _armature.GetSlots();
for (int i = 0, l = slots.Count; i < l; ++i)
{
var slot = slots[i];
var slotTimelineName = slot.name;
var parentTimelineName = slot.parent.name;
var resetFFDVertices = false;
if (ContainsBoneMask(parentTimelineName))
{
var slotTimelineData = _animationData.GetSlotTimeline(slotTimelineName);
if (slotTimelineData != null)
{
if (slotTimelineStates.ContainsKey(slotTimelineName)) // Remove slot timeline from map.
{
slotTimelineStates.Remove(slotTimelineName);
}
else // Create new slot timeline.
{
var slotTimelineState = BaseObject.BorrowObject <SlotTimelineState>();
slotTimelineState.slot = slot;
slotTimelineState._init(_armature, this, slotTimelineData);
_slotTimelines.Add(slotTimelineState);
}
}
var ffdTimelineDatas = _animationData.GetFFDTimeline(_armature._skinData.name, slotTimelineName);
if (ffdTimelineDatas != null)
{
foreach (var pair in ffdTimelineDatas)
{
if (ffdTimelineStates.ContainsKey(pair.Key)) // Remove ffd timeline from map.
{
ffdTimelineStates.Remove(pair.Key);
}
else // Create new ffd timeline.
{
var ffdTimelineState = BaseObject.BorrowObject <FFDTimelineState>();
ffdTimelineState.slot = slot;
ffdTimelineState._init(_armature, this, pair.Value);
_ffdTimelines.Add(ffdTimelineState);
}
}
}
else
{
resetFFDVertices = true;
}
}
else
{
resetFFDVertices = true;
}
if (resetFFDVertices)
{
for (int iA = 0, lA = slot._ffdVertices.Count; iA < lA; ++iA)
{
slot._ffdVertices[iA] = 0.0f;
}
slot._meshDirty = true;
}
}
foreach (var slotTimelineState in slotTimelineStates.Values) // Remove slot timelines.
{
_slotTimelines.Remove(slotTimelineState);
slotTimelineState.ReturnToPool();
}
foreach (var ffdTimelineState in ffdTimelineStates.Values)// Remove ffd timelines.
{
_ffdTimelines.Remove(ffdTimelineState);
ffdTimelineState.ReturnToPool();
}
}
/**
* @private
*/
void Awake()
{
#if UNITY_EDITOR
if (_isPrefab())
{
return;
}
#endif
#if UNITY_5_6_OR_NEWER
if (!isUGUI)
{
_sortingGroup = GetComponent <UnityEngine.Rendering.SortingGroup>();
if (_sortingGroup)
{
sortingMode = SortingMode.SortByOrder;
_sortingLayerName = _sortingGroup.sortingLayerName;
_sortingOrder = _sortingGroup.sortingOrder;
}
}
#endif
zorderIsDirty = true;
//if(unityData != null && (unityData.dragonBonesJSON != null || unityData.dragonBonesBinary != null) && unityData.textureAtlas != null)
if (unityData != null && unityData.dragonBonesJSON != null && unityData.textureAtlas != null)
{
var dragonBonesData = UnityFactory.factory.LoadData(unityData, isUGUI);
if (dragonBonesData != null && !string.IsNullOrEmpty(armatureName))
{
UnityFactory.factory.BuildArmatureComponent(armatureName, dragonBonesData.name, null, unityData.dataName, gameObject, isUGUI);
}
}
if (_armature != null)
{
sortingLayerName = sortingLayerName;
sortingOrder = sortingOrder;
_armature.flipX = flipX;
_armature.flipY = flipY;
_armature.animation.timeScale = _timeScale;
if (zSpace > 0 || sortingMode == SortingMode.SortByOrder)
{
foreach (var slot in _armature.GetSlots())
{
var display = slot.display as GameObject;
if (display != null)
{
display.transform.localPosition = new Vector3(display.transform.localPosition.x, display.transform.localPosition.y, -slot._zOrder * (zSpace + 0.001f));
if (!isUGUI && sortingMode == SortingMode.SortByOrder)
{
UnitySlot us = slot as UnitySlot;
if (us.meshRenderer != null)
{
us.meshRenderer.sortingOrder = slot._zOrder;
}
}
}
}
}
if (!string.IsNullOrEmpty(animationName))
{
_armature.animation.Play(animationName, _playTimes);
}
CollectBones();
}
}
