/**
* @private
*/
protected override void _ParseMesh(Dictionary <string, object> rawData, MeshDisplayData mesh)
{
//mesh.offset = (int)rawData[ObjectDataParser.OFFSET];
mesh.offset = int.Parse(rawData[ObjectDataParser.OFFSET].ToString());
var weightOffset = this._intArrayBuffer[mesh.offset + (int)BinaryOffset.MeshWeightOffset];
if (weightOffset >= 0)
{
var weight = BaseObject.BorrowObject <WeightData>();
var vertexCount = this._intArrayBuffer[mesh.offset + (int)BinaryOffset.MeshVertexCount];
var boneCount = this._intArrayBuffer[weightOffset + (int)BinaryOffset.WeigthBoneCount];
weight.offset = weightOffset;
for (var i = 0; i < boneCount; ++i)
{
var boneIndex = this._intArrayBuffer[weightOffset + (int)BinaryOffset.WeigthBoneIndices + i];
weight.AddBone(this._rawBones[boneIndex]);
}
var boneIndicesOffset = weightOffset + (short)BinaryOffset.WeigthBoneIndices + boneCount;
var weightCount = 0;
for (int i = 0, l = vertexCount; i < l; ++i)
{
var vertexBoneCount = this._intArrayBuffer[boneIndicesOffset++];
weightCount += vertexBoneCount;
boneIndicesOffset += vertexBoneCount;
}
weight.count = weightCount;
mesh.weight = weight;
}
}
protected override void _ParseMesh(Dictionary <string, object> rawData, MeshDisplayData mesh)
{
this._ParseVertices(rawData, mesh.vertices);
}
/// <private/>
protected void _UpdateDisplayData()
{
var prevDisplayData = this._displayData;
var prevTextureData = this._textureData;
var prevMeshData = this._meshData;
var rawDisplayData = this._displayIndex >= 0 && this._rawDisplayDatas != null && this._displayIndex < this._rawDisplayDatas.Count ? this._rawDisplayDatas[this._displayIndex] : null;
if (this._displayIndex >= 0 && this._displayIndex < this._displayDatas.Count)
{
this._displayData = this._displayDatas[this._displayIndex];
}
else
{
this._displayData = null;
}
// Update texture and mesh data.
if (this._displayData != null)
{
if (this._displayData.type == DisplayType.Image || this._displayData.type == DisplayType.Mesh)
{
this._textureData = (this._displayData as ImageDisplayData).texture;
if (this._displayData.type == DisplayType.Mesh)
{
this._meshData = this._displayData as MeshDisplayData;
}
else if (rawDisplayData != null && rawDisplayData.type == DisplayType.Mesh)
{
this._meshData = rawDisplayData as MeshDisplayData;
}
else
{
this._meshData = null;
}
}
else
{
this._textureData = null;
this._meshData = null;
}
}
else
{
this._textureData = null;
this._meshData = null;
}
// Update bounding box data.
if (this._displayData != null && this._displayData.type == DisplayType.BoundingBox)
{
this._boundingBoxData = (this._displayData as BoundingBoxDisplayData).boundingBox;
}
else if (rawDisplayData != null && rawDisplayData.type == DisplayType.BoundingBox)
{
this._boundingBoxData = (rawDisplayData as BoundingBoxDisplayData).boundingBox;
}
else
{
this._boundingBoxData = null;
}
if (this._displayData != prevDisplayData || this._textureData != prevTextureData || this._meshData != prevMeshData)
{
// Update pivot offset.
if (this._meshData != null)
{
this._pivotX = 0.0f;
this._pivotY = 0.0f;
}
else if (this._textureData != null)
{
var imageDisplayData = this._displayData as ImageDisplayData;
var scale = this._textureData.parent.scale * this._armature._armatureData.scale;
var frame = this._textureData.frame;
this._pivotX = imageDisplayData.pivot.x;
this._pivotY = imageDisplayData.pivot.y;
var rect = frame != null ? frame : this._textureData.region;
var width = rect.width;
var height = rect.height;
if (this._textureData.rotated && frame == null)
{
width = rect.height;
height = rect.width;
}
this._pivotX *= width * scale;
this._pivotY *= height * scale;
if (frame != null)
{
this._pivotX += frame.x * scale;
this._pivotY += frame.y * scale;
}
}
else
{
this._pivotX = 0.0f;
this._pivotY = 0.0f;
}
// Update mesh bones and ffd vertices.
if (this._meshData != prevMeshData)
{
if (this._meshData != null)// && this._meshData === this._displayData
{
if (this._meshData.weight != null)
{
this._ffdVertices.ResizeList(this._meshData.weight.count * 2);
this._meshBones.ResizeList(this._meshData.weight.bones.Count);
for (int i = 0, l = this._meshBones.Count; i < l; ++i)
{
this._meshBones[i] = this._armature.GetBone(this._meshData.weight.bones[i].name);
}
}
else
{
var vertexCount = this._meshData.parent.parent.parent.intArray[this._meshData.offset + (int)BinaryOffset.MeshVertexCount];
this._ffdVertices.ResizeList(vertexCount * 2);
this._meshBones.Clear();
}
for (int i = 0, l = this._ffdVertices.Count; i < l; ++i)
{
this._ffdVertices[i] = 0.0f;
}
this._meshDirty = true;
}
else
{
this._ffdVertices.Clear();
this._meshBones.Clear();
}
}
else if (this._meshData != null && this._textureData != prevTextureData)
{
// Update mesh after update frame.
this._meshDirty = true;
}
if (this._displayData != null && rawDisplayData != null && this._displayData != rawDisplayData && this._meshData == null)
{
rawDisplayData.transform.ToMatrix(Slot._helpMatrix);
Slot._helpMatrix.Invert();
Slot._helpMatrix.TransformPoint(0.0f, 0.0f, Slot._helpPoint);
this._pivotX -= Slot._helpPoint.x;
this._pivotY -= Slot._helpPoint.y;
this._displayData.transform.ToMatrix(Slot._helpMatrix);
Slot._helpMatrix.Invert();
Slot._helpMatrix.TransformPoint(0.0f, 0.0f, Slot._helpPoint);
this._pivotX += Slot._helpPoint.x;
this._pivotY += Slot._helpPoint.y;
}
// Update original transform.
if (rawDisplayData != null)
{
this.origin = rawDisplayData.transform;
}
else if (this._displayData != null)
{
this.origin = this._displayData.transform;
}
this._displayDirty = true;
this._transformDirty = true;
this._skinedMeshTransformDirty = true;
}
}
/// <summary>
/// 用特定的显示对象数据替换特定插槽当前的显示对象数据。
/// </summary>
/// <param name="dragonBonesName">The DragonBonesData instance cache name</param>
/// <param name="armatureName">The armature data name</param>
/// <param name="slotName">The slot data name</param>
/// <param name="displayName">The display data name</param>
/// <param name="slot">The slot</param>
/// <param name="texture">The new texture</param>
/// <param name="material">The new material</param>
/// <param name="isUGUI">is ugui。</param>
/// <param name="displayIndex">The index of the display data that is replaced. (If it is not set, replaces the current display data)</param>
/// <version>DragonBones 4.5</version>
/// <language>zh_CN</language>
/// <summary>
/// 用特定的显示对象数据替换特定插槽当前的显示对象数据。
/// </summary>
/// <param name="dragonBonesName">指定的龙骨数据名称。</param>
/// <param name="armatureName">指定的骨架名称。</param>
/// <param name="slotName">指定的插槽名称。</param>
/// <param name="displayName">指定的显示对象名称。</param>
/// <param name="slot">指定的插槽实例。</param>
/// <param name="texture">新的贴图。</param>
/// <param name="material">新的材质。</param>
/// <param name="isUGUI">是否为ugui。</param>
/// <param name="displayIndex">被替换的显示对象数据的索引。 （如果未设置，则替换当前的显示对象数据）。</param>
/// <version>DragonBones 4.5</version>
/// <language>zh_CN</language>
public void ReplaceSlotDisplay(
string dragonBonesName, string armatureName, string slotName, string displayName,
Slot slot, Texture2D texture, Material material = null,
bool isUGUI = false, int displayIndex = -1)
{
var armatureData = this.GetArmatureData(armatureName, dragonBonesName);
if (armatureData == null || armatureData.defaultSkin == null)
{
return;
}
var displays = armatureData.defaultSkin.GetDisplays(slotName);
if (displays == null)
{
return;
}
DisplayData prevDispalyData = null;
foreach (var displayData in displays)
{
if (displayData.name == displayName)
{
prevDispalyData = displayData;
break;
}
}
if (prevDispalyData == null || !((prevDispalyData is ImageDisplayData) || (prevDispalyData is MeshDisplayData)))
{
return;
}
TextureData prevTextureData = null;
if (prevDispalyData is ImageDisplayData)
{
prevTextureData = (prevDispalyData as ImageDisplayData).texture;
}
else
{
prevTextureData = (prevDispalyData as MeshDisplayData).texture;
}
UnityTextureData newTextureData = new UnityTextureData();
newTextureData.CopyFrom(prevTextureData);
newTextureData.rotated = false;
newTextureData.region.x = 0.0f;
newTextureData.region.y = 0.0f;
newTextureData.region.width = texture.width;
newTextureData.region.height = texture.height;
newTextureData.frame = newTextureData.region;
newTextureData.name = prevTextureData.name;
newTextureData.parent = new UnityTextureAtlasData();
newTextureData.parent.width = (uint)texture.width;
newTextureData.parent.height = (uint)texture.height;
newTextureData.parent.scale = prevTextureData.parent.scale;
//
if (material == null)
{
if (isUGUI)
{
material = UnityFactoryHelper.GenerateMaterial(defaultUIShaderName, texture.name + "_UI_Mat", texture);
}
else
{
material = UnityFactoryHelper.GenerateMaterial(defaultShaderName, texture.name + "_Mat", texture);
}
}
if (isUGUI)
{
(newTextureData.parent as UnityTextureAtlasData).uiTexture = material;
}
else
{
(newTextureData.parent as UnityTextureAtlasData).texture = material;
}
material.mainTexture = texture;
DisplayData newDisplayData = null;
if (prevDispalyData is ImageDisplayData)
{
newDisplayData = new ImageDisplayData();
newDisplayData.type = prevDispalyData.type;
newDisplayData.name = prevDispalyData.name;
newDisplayData.path = prevDispalyData.path;
newDisplayData.transform.CopyFrom(prevDispalyData.transform);
newDisplayData.parent = prevDispalyData.parent;
(newDisplayData as ImageDisplayData).pivot.CopyFrom((prevDispalyData as ImageDisplayData).pivot);
(newDisplayData as ImageDisplayData).texture = newTextureData;
}
else if (prevDispalyData is MeshDisplayData)
{
newDisplayData = new MeshDisplayData();
newDisplayData.type = prevDispalyData.type;
newDisplayData.name = prevDispalyData.name;
newDisplayData.path = prevDispalyData.path;
newDisplayData.transform.CopyFrom(prevDispalyData.transform);
newDisplayData.parent = prevDispalyData.parent;
(newDisplayData as MeshDisplayData).texture = newTextureData;
(newDisplayData as MeshDisplayData).vertices.inheritDeform = (prevDispalyData as MeshDisplayData).vertices.inheritDeform;
(newDisplayData as MeshDisplayData).vertices.offset = (prevDispalyData as MeshDisplayData).vertices.offset;
(newDisplayData as MeshDisplayData).vertices.data = (prevDispalyData as MeshDisplayData).vertices.data;
(newDisplayData as MeshDisplayData).vertices.weight = (prevDispalyData as MeshDisplayData).vertices.weight;
}
ReplaceDisplay(slot, newDisplayData, displayIndex);
}
/// <inheritDoc/>
protected override void _OnClear()
{
base._OnClear();
var disposeDisplayList = new List <object>();
for (int i = 0, l = _displayList.Count; i < l; ++i)
{
var eachDisplay = _displayList[i];
if (eachDisplay != _rawDisplay && eachDisplay != _meshDisplay && !disposeDisplayList.Contains(eachDisplay))
{
disposeDisplayList.Add(eachDisplay);
}
}
for (int i = 0, l = disposeDisplayList.Count; i < l; ++i)
{
var eachDisplay = disposeDisplayList[i];
if (eachDisplay is Armature)
{
(eachDisplay as Armature).Dispose();
}
else
{
_DisposeDisplay(eachDisplay, false);
}
}
if (this._meshDisplay != null && this._meshDisplay != this._rawDisplay)
{
// May be _meshDisplay and _rawDisplay is the same one.
this._DisposeDisplay(this._meshDisplay, false);
}
if (this._rawDisplay != null)
{
this._DisposeDisplay(this._rawDisplay, false);
}
this.displayController = null;
this._displayDirty = false;
this._zOrderDirty = false;
this._blendModeDirty = false;
this._colorDirty = false;
this._meshDirty = false;
this._transformDirty = false;
this._skinedMeshTransformDirty = false;
this._visible = true;
this._blendMode = BlendMode.Normal;
this._displayIndex = -1;
this._animationDisplayIndex = -1;
this._zOrder = 0;
this._cachedFrameIndex = -1;
this._pivotX = 0.0f;
this._pivotY = 0.0f;
this._localMatrix.Identity();
this._colorTransform.Identity();
this._ffdVertices.Clear();
this._displayList.Clear();
this._displayDatas.Clear();
this._meshBones.Clear();
this._slotData = null; //
this._rawDisplayDatas = null; //
this._displayData = null;
this._textureData = null;
this._meshData = null;
this._boundingBoxData = null;
this._rawDisplay = null;
this._meshDisplay = null;
this._display = null;
this._childArmature = null;
this._cachedFrameIndices = null;
}
