private void LazyIntialize()
{
if (this.buffers == null)
{
this.buffers = new MeshRendererBuffers();
this.buffers.Initialize();
if (this.meshGenerator == null)
{
this.meshGenerator = new Spine.Unity.MeshGenerator();
this.meshFilter = base.GetComponent <UnityEngine.MeshFilter>();
this.meshRenderer = base.GetComponent <UnityEngine.MeshRenderer>();
this.currentInstructions.Clear();
}
}
}
static int get_MeshGenerator(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
Spine.Unity.SkeletonGraphic obj = (Spine.Unity.SkeletonGraphic)o;
Spine.Unity.MeshGenerator ret = obj.MeshGenerator;
ToLua.PushObject(L, ret);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o, "attempt to index MeshGenerator on a nil value"));
}
}
/// <summary>
/// Generates a new UnityEngine.Mesh from the internal Skeleton.</summary>
public virtual void LateUpdate()
{
if (!valid)
{
return;
}
#if SPINE_OPTIONAL_RENDEROVERRIDE
bool doMeshOverride = generateMeshOverride != null;
if ((!meshRenderer.enabled) && !doMeshOverride)
{
return;
}
#else
const bool doMeshOverride = false;
if (!meshRenderer.enabled)
{
return;
}
#endif
var currentInstructions = this.currentInstructions;
var workingSubmeshInstructions = currentInstructions.submeshInstructions;
var currentSmartMesh = rendererBuffers.GetNextMesh(); // Double-buffer for performance.
bool updateTriangles;
if (this.singleSubmesh)
{
// STEP 1. Determine a SmartMesh.Instruction. Split up instructions into submeshes. =============================================
MeshGenerator.GenerateSingleSubmeshInstruction(currentInstructions, skeleton, skeletonDataAsset.atlasAssets[0].PrimaryMaterial);
// STEP 1.9. Post-process workingInstructions. ==================================================================================
#if SPINE_OPTIONAL_MATERIALOVERRIDE
if (customMaterialOverride.Count > 0) // isCustomMaterialOverridePopulated
{
MeshGenerator.TryReplaceMaterials(workingSubmeshInstructions, customMaterialOverride);
}
#endif
// STEP 2. Update vertex buffer based on verts from the attachments. ===========================================================
meshGenerator.settings = new MeshGenerator.Settings {
pmaVertexColors = this.pmaVertexColors,
zSpacing = this.zSpacing,
useClipping = this.useClipping,
tintBlack = this.tintBlack,
calculateTangents = this.calculateTangents,
addNormals = this.addNormals
};
meshGenerator.Begin();
updateTriangles = SkeletonRendererInstruction.GeometryNotEqual(currentInstructions, currentSmartMesh.instructionUsed);
if (currentInstructions.hasActiveClipping)
{
meshGenerator.AddSubmesh(workingSubmeshInstructions.Items[0], updateTriangles);
}
else
{
meshGenerator.BuildMeshWithArrays(currentInstructions, updateTriangles);
}
}
else
{
// STEP 1. Determine a SmartMesh.Instruction. Split up instructions into submeshes. =============================================
MeshGenerator.GenerateSkeletonRendererInstruction(currentInstructions, skeleton, customSlotMaterials, separatorSlots, doMeshOverride, this.immutableTriangles);
// STEP 1.9. Post-process workingInstructions. ==================================================================================
#if SPINE_OPTIONAL_MATERIALOVERRIDE
if (customMaterialOverride.Count > 0) // isCustomMaterialOverridePopulated
{
MeshGenerator.TryReplaceMaterials(workingSubmeshInstructions, customMaterialOverride);
}
#endif
#if SPINE_OPTIONAL_RENDEROVERRIDE
if (doMeshOverride)
{
this.generateMeshOverride(currentInstructions);
if (disableRenderingOnOverride)
{
return;
}
}
#endif
updateTriangles = SkeletonRendererInstruction.GeometryNotEqual(currentInstructions, currentSmartMesh.instructionUsed);
// STEP 2. Update vertex buffer based on verts from the attachments. ===========================================================
meshGenerator.settings = new MeshGenerator.Settings {
pmaVertexColors = this.pmaVertexColors,
zSpacing = this.zSpacing,
useClipping = this.useClipping,
tintBlack = this.tintBlack,
calculateTangents = this.calculateTangents,
addNormals = this.addNormals
};
meshGenerator.Begin();
if (currentInstructions.hasActiveClipping)
{
meshGenerator.BuildMesh(currentInstructions, updateTriangles);
}
else
{
meshGenerator.BuildMeshWithArrays(currentInstructions, updateTriangles);
}
}
if (OnPostProcessVertices != null)
{
OnPostProcessVertices.Invoke(this.meshGenerator.Buffers);
}
// STEP 3. Move the mesh data into a UnityEngine.Mesh ===========================================================================
var currentMesh = currentSmartMesh.mesh;
meshGenerator.FillVertexData(currentMesh);
rendererBuffers.UpdateSharedMaterials(workingSubmeshInstructions);
if (updateTriangles) // Check if the triangles should also be updated.
{
meshGenerator.FillTriangles(currentMesh);
meshRenderer.sharedMaterials = rendererBuffers.GetUpdatedSharedMaterialsArray();
}
else if (rendererBuffers.MaterialsChangedInLastUpdate())
{
meshRenderer.sharedMaterials = rendererBuffers.GetUpdatedSharedMaterialsArray();
}
meshGenerator.FillLateVertexData(currentMesh);
// STEP 4. The UnityEngine.Mesh is ready. Set it as the MeshFilter's mesh. Store the instructions used for that mesh. ===========
meshFilter.sharedMesh = currentMesh;
currentSmartMesh.instructionUsed.Set(currentInstructions);
#if BUILT_IN_SPRITE_MASK_COMPONENT
if (meshRenderer != null)
{
AssignSpriteMaskMaterials();
}
#endif
}
/// <summary>
/// Generates a new UnityEngine.Mesh from the internal Skeleton.</summary>
public virtual void LateUpdate()
{
if (!valid)
{
return;
}
#if UNITY_EDITOR && NEW_PREFAB_SYSTEM
// Don't store mesh or material at the prefab, otherwise it will permanently reload
var prefabType = UnityEditor.PrefabUtility.GetPrefabAssetType(this);
if (UnityEditor.PrefabUtility.IsPartOfPrefabAsset(this) &&
(prefabType == UnityEditor.PrefabAssetType.Regular || prefabType == UnityEditor.PrefabAssetType.Variant))
{
return;
}
#endif
if (updateMode != UpdateMode.FullUpdate)
{
return;
}
#if SPINE_OPTIONAL_RENDEROVERRIDE
bool doMeshOverride = generateMeshOverride != null;
if ((!meshRenderer.enabled) && !doMeshOverride)
{
return;
}
#else
const bool doMeshOverride = false;
if (!meshRenderer.enabled)
{
return;
}
#endif
var currentInstructions = this.currentInstructions;
var workingSubmeshInstructions = currentInstructions.submeshInstructions;
var currentSmartMesh = rendererBuffers.GetNextMesh(); // Double-buffer for performance.
bool updateTriangles;
if (this.singleSubmesh)
{
// STEP 1. Determine a SmartMesh.Instruction. Split up instructions into submeshes. =============================================
MeshGenerator.GenerateSingleSubmeshInstruction(currentInstructions, skeleton, skeletonDataAsset.atlasAssets[0].PrimaryMaterial);
// STEP 1.9. Post-process workingInstructions. ==================================================================================
#if SPINE_OPTIONAL_MATERIALOVERRIDE
if (customMaterialOverride.Count > 0) // isCustomMaterialOverridePopulated
{
MeshGenerator.TryReplaceMaterials(workingSubmeshInstructions, customMaterialOverride);
}
#endif
// STEP 2. Update vertex buffer based on verts from the attachments. ===========================================================
meshGenerator.settings = new MeshGenerator.Settings {
pmaVertexColors = this.pmaVertexColors,
zSpacing = this.zSpacing,
useClipping = this.useClipping,
tintBlack = this.tintBlack,
calculateTangents = this.calculateTangents,
addNormals = this.addNormals
};
meshGenerator.Begin();
updateTriangles = SkeletonRendererInstruction.GeometryNotEqual(currentInstructions, currentSmartMesh.instructionUsed);
if (currentInstructions.hasActiveClipping)
{
meshGenerator.AddSubmesh(workingSubmeshInstructions.Items[0], updateTriangles);
}
else
{
meshGenerator.BuildMeshWithArrays(currentInstructions, updateTriangles);
}
}
else
{
// STEP 1. Determine a SmartMesh.Instruction. Split up instructions into submeshes. =============================================
MeshGenerator.GenerateSkeletonRendererInstruction(currentInstructions, skeleton, customSlotMaterials, separatorSlots, doMeshOverride, this.immutableTriangles);
// STEP 1.9. Post-process workingInstructions. ==================================================================================
#if SPINE_OPTIONAL_MATERIALOVERRIDE
if (customMaterialOverride.Count > 0) // isCustomMaterialOverridePopulated
{
MeshGenerator.TryReplaceMaterials(workingSubmeshInstructions, customMaterialOverride);
}
#endif
#if SPINE_OPTIONAL_RENDEROVERRIDE
if (doMeshOverride)
{
this.generateMeshOverride(currentInstructions);
if (disableRenderingOnOverride)
{
return;
}
}
#endif
updateTriangles = SkeletonRendererInstruction.GeometryNotEqual(currentInstructions, currentSmartMesh.instructionUsed);
// STEP 2. Update vertex buffer based on verts from the attachments. ===========================================================
meshGenerator.settings = new MeshGenerator.Settings {
pmaVertexColors = this.pmaVertexColors,
zSpacing = this.zSpacing,
useClipping = this.useClipping,
tintBlack = this.tintBlack,
calculateTangents = this.calculateTangents,
addNormals = this.addNormals
};
meshGenerator.Begin();
if (currentInstructions.hasActiveClipping)
{
meshGenerator.BuildMesh(currentInstructions, updateTriangles);
}
else
{
meshGenerator.BuildMeshWithArrays(currentInstructions, updateTriangles);
}
}
if (OnPostProcessVertices != null)
{
OnPostProcessVertices.Invoke(this.meshGenerator.Buffers);
}
// STEP 3. Move the mesh data into a UnityEngine.Mesh ===========================================================================
var currentMesh = currentSmartMesh.mesh;
meshGenerator.FillVertexData(currentMesh);
rendererBuffers.UpdateSharedMaterials(workingSubmeshInstructions);
bool materialsChanged = rendererBuffers.MaterialsChangedInLastUpdate();
if (updateTriangles) // Check if the triangles should also be updated.
{
meshGenerator.FillTriangles(currentMesh);
meshRenderer.sharedMaterials = rendererBuffers.GetUpdatedSharedMaterialsArray();
}
else if (materialsChanged)
{
meshRenderer.sharedMaterials = rendererBuffers.GetUpdatedSharedMaterialsArray();
}
if (materialsChanged && (this.maskMaterials.AnyMaterialCreated))
{
this.maskMaterials = new SpriteMaskInteractionMaterials();
}
meshGenerator.FillLateVertexData(currentMesh);
// STEP 4. The UnityEngine.Mesh is ready. Set it as the MeshFilter's mesh. Store the instructions used for that mesh. ===========
meshFilter.sharedMesh = currentMesh;
currentSmartMesh.instructionUsed.Set(currentInstructions);
#if BUILT_IN_SPRITE_MASK_COMPONENT
if (meshRenderer != null)
{
AssignSpriteMaskMaterials();
}
#endif
#if PER_MATERIAL_PROPERTY_BLOCKS
if (fixDrawOrder && meshRenderer.sharedMaterials.Length > 2)
{
SetMaterialSettingsToFixDrawOrder();
}
#endif
if (OnMeshAndMaterialsUpdated != null)
{
OnMeshAndMaterialsUpdated(this);
}
}
public virtual void LateUpdate()
{
if (this.valid)
{
bool generateMeshOverride = this.generateMeshOverride != null;
if (this.meshRenderer.enabled || generateMeshOverride)
{
bool flag2;
SkeletonRendererInstruction currentInstructions = this.currentInstructions;
ExposedList <SubmeshInstruction> submeshInstructions = currentInstructions.submeshInstructions;
MeshRendererBuffers.SmartMesh nextMesh = this.rendererBuffers.GetNextMesh();
if (this.singleSubmesh)
{
MeshGenerator.GenerateSingleSubmeshInstruction(currentInstructions, this.skeleton, this.skeletonDataAsset.atlasAssets[0].materials[0]);
if (this.customMaterialOverride.Count > 0)
{
MeshGenerator.TryReplaceMaterials(submeshInstructions, this.customMaterialOverride);
}
MeshGenerator.Settings settings = new MeshGenerator.Settings {
pmaVertexColors = this.pmaVertexColors,
zSpacing = this.zSpacing,
useClipping = this.useClipping,
tintBlack = this.tintBlack,
calculateTangents = this.calculateTangents,
addNormals = this.addNormals
};
this.meshGenerator.settings = settings;
this.meshGenerator.Begin();
flag2 = SkeletonRendererInstruction.GeometryNotEqual(currentInstructions, nextMesh.instructionUsed);
if (currentInstructions.hasActiveClipping)
{
this.meshGenerator.AddSubmesh(submeshInstructions.Items[0], flag2);
}
else
{
this.meshGenerator.BuildMeshWithArrays(currentInstructions, flag2);
}
}
else
{
MeshGenerator.GenerateSkeletonRendererInstruction(currentInstructions, this.skeleton, this.customSlotMaterials, this.separatorSlots, generateMeshOverride, this.immutableTriangles);
if (this.customMaterialOverride.Count > 0)
{
MeshGenerator.TryReplaceMaterials(submeshInstructions, this.customMaterialOverride);
}
if (generateMeshOverride)
{
this.generateMeshOverride(currentInstructions);
if (this.disableRenderingOnOverride)
{
return;
}
}
flag2 = SkeletonRendererInstruction.GeometryNotEqual(currentInstructions, nextMesh.instructionUsed);
MeshGenerator.Settings settings2 = new MeshGenerator.Settings {
pmaVertexColors = this.pmaVertexColors,
zSpacing = this.zSpacing,
useClipping = this.useClipping,
tintBlack = this.tintBlack,
calculateTangents = this.calculateTangents,
addNormals = this.addNormals
};
this.meshGenerator.settings = settings2;
this.meshGenerator.Begin();
if (currentInstructions.hasActiveClipping)
{
this.meshGenerator.BuildMesh(currentInstructions, flag2);
}
else
{
this.meshGenerator.BuildMeshWithArrays(currentInstructions, flag2);
}
}
if (this.OnPostProcessVertices != null)
{
this.OnPostProcessVertices(this.meshGenerator.Buffers);
}
Mesh mesh = nextMesh.mesh;
this.meshGenerator.FillVertexData(mesh);
this.rendererBuffers.UpdateSharedMaterials(submeshInstructions);
if (flag2)
{
this.meshGenerator.FillTriangles(mesh);
this.meshRenderer.sharedMaterials = this.rendererBuffers.GetUpdatedSharedMaterialsArray();
}
else if (this.rendererBuffers.MaterialsChangedInLastUpdate())
{
this.meshRenderer.sharedMaterials = this.rendererBuffers.GetUpdatedSharedMaterialsArray();
}
this.meshGenerator.FillLateVertexData(mesh);
this.meshFilter.sharedMesh = mesh;
nextMesh.instructionUsed.Set(currentInstructions);
}
}
}
public virtual void LateUpdate()
{
if (!valid)
{
return;
}
bool flag = this.generateMeshOverride != null;
if (!meshRenderer.enabled && !flag)
{
return;
}
SkeletonRendererInstruction skeletonRendererInstruction = currentInstructions;
ExposedList <SubmeshInstruction> submeshInstructions = skeletonRendererInstruction.submeshInstructions;
MeshRendererBuffers.SmartMesh nextMesh = rendererBuffers.GetNextMesh();
bool flag2;
if (singleSubmesh)
{
MeshGenerator.GenerateSingleSubmeshInstruction(skeletonRendererInstruction, skeleton, skeletonDataAsset.atlasAssets[0].materials[0]);
if (customMaterialOverride.Count > 0)
{
MeshGenerator.TryReplaceMaterials(submeshInstructions, customMaterialOverride);
}
meshGenerator.settings = new MeshGenerator.Settings
{
pmaVertexColors = pmaVertexColors,
zSpacing = zSpacing,
useClipping = useClipping,
tintBlack = tintBlack,
calculateTangents = calculateTangents,
addNormals = addNormals
};
meshGenerator.Begin();
flag2 = SkeletonRendererInstruction.GeometryNotEqual(skeletonRendererInstruction, nextMesh.instructionUsed);
if (skeletonRendererInstruction.hasActiveClipping)
{
meshGenerator.AddSubmesh(submeshInstructions.Items[0], flag2);
}
else
{
meshGenerator.BuildMeshWithArrays(skeletonRendererInstruction, flag2);
}
}
else
{
MeshGenerator.GenerateSkeletonRendererInstruction(skeletonRendererInstruction, skeleton, customSlotMaterials, separatorSlots, flag, immutableTriangles);
if (customMaterialOverride.Count > 0)
{
MeshGenerator.TryReplaceMaterials(submeshInstructions, customMaterialOverride);
}
if (flag)
{
this.generateMeshOverride(skeletonRendererInstruction);
if (disableRenderingOnOverride)
{
return;
}
}
flag2 = SkeletonRendererInstruction.GeometryNotEqual(skeletonRendererInstruction, nextMesh.instructionUsed);
meshGenerator.settings = new MeshGenerator.Settings
{
pmaVertexColors = pmaVertexColors,
zSpacing = zSpacing,
useClipping = useClipping,
tintBlack = tintBlack,
calculateTangents = calculateTangents,
addNormals = addNormals
};
meshGenerator.Begin();
if (skeletonRendererInstruction.hasActiveClipping)
{
meshGenerator.BuildMesh(skeletonRendererInstruction, flag2);
}
else
{
meshGenerator.BuildMeshWithArrays(skeletonRendererInstruction, flag2);
}
}
if (this.OnPostProcessVertices != null)
{
this.OnPostProcessVertices(meshGenerator.Buffers);
}
Mesh mesh = nextMesh.mesh;
meshGenerator.FillVertexData(mesh);
rendererBuffers.UpdateSharedMaterials(submeshInstructions);
if (flag2)
{
meshGenerator.FillTriangles(mesh);
meshRenderer.sharedMaterials = rendererBuffers.GetUpdatedShaderdMaterialsArray();
}
else if (rendererBuffers.MaterialsChangedInLastUpdate())
{
meshRenderer.sharedMaterials = rendererBuffers.GetUpdatedShaderdMaterialsArray();
}
meshFilter.sharedMesh = mesh;
nextMesh.instructionUsed.Set(skeletonRendererInstruction);
}