/**
* @private
*/
protected override void _OnClear()
{
base._OnClear();
if (this._meshBuffer != null)
{
this._meshBuffer.Dispose();
}
this._skewed = false;
this._proxy = null;
this._renderDisplay = null;
this._uiDisplay = null;
this._meshBuffer = null;
this._meshRenderer = null;
this._meshFilter = null;
this._isIgnoreCombineMesh = false;
this._isCombineMesh = false;
this._sumMeshIndex = -1;
this._verticeOrder = -1;
this._verticeOffset = -1;
this._combineMesh = null;
this._currentBlendMode = BlendMode.Normal;
this._isActive = false;
}
/**
* @private
*/
protected override void _OnUpdateDisplay()
{
_renderDisplay = (_display != null ? _display : _rawDisplay) as GameObject;
//
_proxy = _armature.proxy as UnityArmatureComponent;
if (_proxy.isUGUI)
{
_uiDisplay = _renderDisplay.GetComponent <UnityUGUIDisplay>();
if (_uiDisplay == null)
{
_uiDisplay = _renderDisplay.AddComponent <UnityUGUIDisplay>();
_uiDisplay.raycastTarget = false;
}
}
else
{
_meshRenderer = _renderDisplay.GetComponent <MeshRenderer>();
if (_meshRenderer == null)
{
_meshRenderer = _renderDisplay.AddComponent <MeshRenderer>();
}
//
_meshFilter = _renderDisplay.GetComponent <MeshFilter>();
if (_meshFilter == null && _renderDisplay.GetComponent <TextMesh>() == null)
{
_meshFilter = _renderDisplay.AddComponent <MeshFilter>();
}
}
//init mesh
if (this._meshBuffer == null)
{
this._meshBuffer = new MeshBuffer();
this._meshBuffer.sharedMesh = MeshBuffer.GenerateMesh();
this._meshBuffer.sharedMesh.name = this.name;
}
}
public void BeginCombineMesh()
{
if (!this._isCanCombineMesh || _unityArmature.isUGUI)
{
return;
}
//
this._verticeOffset = 0;
this._subSlotCount = 0;
this.slotNames.Clear();
//
if (this.meshBuffers != null)
{
for (var i = 0; i < this.meshBuffers.Length; i++)
{
var meshBuffer = this.meshBuffers[i];
meshBuffer.Dispose();
}
this.meshBuffers = null;
}
List <CombineMeshInfo> combineSlots = new List <CombineMeshInfo>();
//
this.CollectMesh(this._unityArmature.armature, combineSlots);
//
//先合并
this.meshBuffers = new MeshBuffer[combineSlots.Count];
for (var i = 0; i < combineSlots.Count; i++)
{
var combineSlot = combineSlots[i];
//
var proxySlot = combineSlot.proxySlot;
MeshBuffer meshBuffer = new MeshBuffer();
meshBuffer.name = proxySlot._meshBuffer.name;
meshBuffer.sharedMesh = MeshBuffer.GenerateMesh();
meshBuffer.sharedMesh.Clear();
meshBuffer.CombineMeshes(combineSlot.combines.ToArray());
meshBuffer.vertexDirty = true;
//
proxySlot._meshFilter.sharedMesh = meshBuffer.sharedMesh;
this.meshBuffers[i] = meshBuffer;
//
this._verticeOffset = 0;
for (int j = 0; j < combineSlot.slots.Count; j++)
{
var slot = combineSlot.slots[j];
slot._isCombineMesh = true;
slot._sumMeshIndex = i;
slot._verticeOrder = j;
slot._verticeOffset = this._verticeOffset;
slot._combineMesh = this;
slot._meshBuffer.enabled = false;
if (slot._renderDisplay != null)
{
slot._renderDisplay.SetActive(false);
slot._renderDisplay.hideFlags = HideFlags.HideInHierarchy;
var transform = slot._renderDisplay.transform;
transform.localPosition = new Vector3(0.0f, 0.0f, transform.localPosition.z);
transform.localEulerAngles = Vector3.zero;
transform.localScale = Vector3.one;
}
//
slot._meshDirty = true;
slot._transformDirty = true;
slot.Update(-1);
//
meshBuffer.combineSlots.Add(slot);
this.slotNames.Add(slot.name);
this._verticeOffset += slot._meshBuffer.vertexBuffers.Length;
this._subSlotCount++;
}
//被合并的显示
if (proxySlot._renderDisplay != null)
{
proxySlot._renderDisplay.SetActive(true);
proxySlot._renderDisplay.hideFlags = HideFlags.None;
}
}
}
protected override void _UpdateMesh()
{
if (this._meshBuffer.sharedMesh == null || this._deformVertices == null)
{
return;
}
var scale = this._armature.armatureData.scale;
var deformVertices = this._deformVertices.vertices;
var bones = this._deformVertices.bones;
var hasDeform = deformVertices.Count > 0;
var verticesData = this._deformVertices.verticesData;
var weightData = verticesData.weight;
var data = verticesData.data;
var intArray = data.intArray;
var floatArray = data.floatArray;
var vertextCount = intArray[verticesData.offset + (int)BinaryOffset.MeshVertexCount];
if (weightData != null)
{
int weightFloatOffset = intArray[weightData.offset + 1 /*(int)BinaryOffset.MeshWeightOffset*/];
if (weightFloatOffset < 0)
{
weightFloatOffset += 65536; // Fixed out of bouds bug.
}
MeshBuffer meshBuffer = null;
if (this._isCombineMesh)
{
meshBuffer = this._combineMesh.meshBuffers[this._sumMeshIndex];
}
int iB = weightData.offset + (int)BinaryOffset.WeigthBoneIndices + weightData.bones.Count, iV = weightFloatOffset, iF = 0;
for (int i = 0; i < vertextCount; ++i)
{
var boneCount = intArray[iB++];
float xG = 0.0f, yG = 0.0f;
for (var j = 0; j < boneCount; ++j)
{
var boneIndex = intArray[iB++];
var bone = bones[boneIndex];
if (bone != null)
{
var matrix = bone.globalTransformMatrix;
var weight = floatArray[iV++];
var xL = floatArray[iV++] * scale;
var yL = floatArray[iV++] * scale;
if (hasDeform)
{
xL += deformVertices[iF++];
yL += deformVertices[iF++];
}
xG += (matrix.a * xL + matrix.c * yL + matrix.tx) * weight;
yG += (matrix.b * xL + matrix.d * yL + matrix.ty) * weight;
}
}
this._meshBuffer.vertexBuffers[i].x = xG;
this._meshBuffer.vertexBuffers[i].y = yG;
if (meshBuffer != null)
{
meshBuffer.vertexBuffers[i + this._verticeOffset].x = xG;
meshBuffer.vertexBuffers[i + this._verticeOffset].y = yG;
}
}
if (meshBuffer != null)
{
meshBuffer.vertexDirty = true;
}
else
{
// if (this._meshRenderer && this._meshRenderer.enabled)
{
this._meshBuffer.UpdateVertices();
}
}
}
else if (deformVertices.Count > 0)
{
int vertexOffset = data.intArray[verticesData.offset + (int)BinaryOffset.MeshFloatOffset];
if (vertexOffset < 0)
{
vertexOffset += 65536; // Fixed out of bouds bug.
}
//
var a = globalTransformMatrix.a;
var b = globalTransformMatrix.b;
var c = globalTransformMatrix.c;
var d = globalTransformMatrix.d;
var tx = globalTransformMatrix.tx;
var ty = globalTransformMatrix.ty;
var index = 0;
var rx = 0.0f;
var ry = 0.0f;
var vx = 0.0f;
var vy = 0.0f;
MeshBuffer meshBuffer = null;
if (this._isCombineMesh)
{
meshBuffer = this._combineMesh.meshBuffers[this._sumMeshIndex];
}
for (int i = 0, iV = 0, iF = 0, l = vertextCount; i < l; ++i)
{
rx = (data.floatArray[vertexOffset + (iV++)] * scale + deformVertices[iF++]);
ry = (data.floatArray[vertexOffset + (iV++)] * scale + deformVertices[iF++]);
this._meshBuffer.rawVertextBuffers[i].x = rx;
this._meshBuffer.rawVertextBuffers[i].y = -ry;
this._meshBuffer.vertexBuffers[i].x = rx;
this._meshBuffer.vertexBuffers[i].y = -ry;
if (meshBuffer != null)
{
index = i + this._verticeOffset;
vx = (rx * a + ry * c + tx);
vy = (rx * b + ry * d + ty);
meshBuffer.vertexBuffers[index].x = vx;
meshBuffer.vertexBuffers[index].y = vy;
}
}
if (meshBuffer != null)
{
meshBuffer.vertexDirty = true;
}
// else if (this._meshRenderer && this._meshRenderer.enabled)
else
{
this._meshBuffer.UpdateVertices();
}
}
}
