You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
546 lines
22 KiB
546 lines
22 KiB
/******************************************************************************
|
|
* Spine Runtimes Software License v2.5
|
|
*
|
|
* Copyright (c) 2013-2016, Esoteric Software
|
|
* All rights reserved.
|
|
*
|
|
* You are granted a perpetual, non-exclusive, non-sublicensable, and
|
|
* non-transferable license to use, install, execute, and perform the Spine
|
|
* Runtimes software and derivative works solely for personal or internal
|
|
* use. Without the written permission of Esoteric Software (see Section 2 of
|
|
* the Spine Software License Agreement), you may not (a) modify, translate,
|
|
* adapt, or develop new applications using the Spine Runtimes or otherwise
|
|
* create derivative works or improvements of the Spine Runtimes or (b) remove,
|
|
* delete, alter, or obscure any trademarks or any copyright, trademark, patent,
|
|
* or other intellectual property or proprietary rights notices on or in the
|
|
* Software, including any copy thereof. Redistributions in binary or source
|
|
* form must include this license and terms.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "AS IS" AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
* EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS INTERRUPTION, OR LOSS OF
|
|
* USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
|
|
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*****************************************************************************/
|
|
|
|
#define SPINE_OPTIONAL_RENDEROVERRIDE
|
|
#define SPINE_OPTIONAL_MATERIALOVERRIDE
|
|
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace Spine.Unity {
|
|
|
|
|
|
/// <summary>Renders a skeleton.</summary>
|
|
[ExecuteInEditMode, RequireComponent(typeof(MeshFilter), typeof(MeshRenderer)), DisallowMultipleComponent]
|
|
[HelpURL("http://esotericsoftware.com/spine-unity-documentation#Rendering")]
|
|
public class SkeletonMemoria : MonoBehaviour, ISkeletonComponent, IHasSkeletonDataAsset, ISkeletonAnimation, IAnimationStateComponent {
|
|
|
|
// 2022.07.20 modified by wlt233
|
|
|
|
|
|
#region IAnimationStateComponent
|
|
/// <summary>
|
|
/// This is the Spine.AnimationState object of this SkeletonAnimation. You can control animations through it.
|
|
/// Note that this object, like .skeleton, is not guaranteed to exist in Awake. Do all accesses and caching to it in Start</summary>
|
|
public Spine.AnimationState state;
|
|
/// <summary>
|
|
/// This is the Spine.AnimationState object of this SkeletonAnimation. You can control animations through it.
|
|
/// Note that this object, like .skeleton, is not guaranteed to exist in Awake. Do all accesses and caching to it in Start</summary>
|
|
public Spine.AnimationState AnimationState { get { return this.state; } }
|
|
#endregion
|
|
|
|
#region Bone Callbacks ISkeletonAnimation
|
|
protected event UpdateBonesDelegate _UpdateLocal;
|
|
protected event UpdateBonesDelegate _UpdateWorld;
|
|
protected event UpdateBonesDelegate _UpdateComplete;
|
|
|
|
/// <summary>
|
|
/// Occurs after the animations are applied and before world space values are resolved.
|
|
/// Use this callback when you want to set bone local values.
|
|
/// </summary>
|
|
public event UpdateBonesDelegate UpdateLocal { add { _UpdateLocal += value; } remove { _UpdateLocal -= value; } }
|
|
|
|
/// <summary>
|
|
/// Occurs after the Skeleton's bone world space values are resolved (including all constraints).
|
|
/// Using this callback will cause the world space values to be solved an extra time.
|
|
/// Use this callback if want to use bone world space values, and also set bone local values.</summary>
|
|
public event UpdateBonesDelegate UpdateWorld { add { _UpdateWorld += value; } remove { _UpdateWorld -= value; } }
|
|
|
|
/// <summary>
|
|
/// Occurs after the Skeleton's bone world space values are resolved (including all constraints).
|
|
/// Use this callback if you want to use bone world space values, but don't intend to modify bone local values.
|
|
/// This callback can also be used when setting world position and the bone matrix.</summary>
|
|
public event UpdateBonesDelegate UpdateComplete { add { _UpdateComplete += value; } remove { _UpdateComplete -= value; } }
|
|
#endregion
|
|
|
|
#region Serialized state and Beginner API
|
|
[SerializeField]
|
|
[SpineAnimation]
|
|
private string _animationName;
|
|
|
|
/// <summary>
|
|
/// Setting this property sets the animation of the skeleton. If invalid, it will store the animation name for the next time the skeleton is properly initialized.
|
|
/// Getting this property gets the name of the currently playing animation. If invalid, it will return the last stored animation name set through this property.</summary>
|
|
public string AnimationName {
|
|
get {
|
|
if (!valid) {
|
|
return _animationName;
|
|
} else {
|
|
TrackEntry entry = state.GetCurrent(0);
|
|
return entry == null ? null : entry.Animation.Name;
|
|
}
|
|
}
|
|
set {
|
|
if (_animationName == value)
|
|
return;
|
|
_animationName = value;
|
|
|
|
if (string.IsNullOrEmpty(value)) {
|
|
state.ClearTrack(0);
|
|
} else {
|
|
TrySetAnimation(value, loop);
|
|
}
|
|
}
|
|
}
|
|
|
|
TrackEntry TrySetAnimation (string animationName, bool animationLoop) {
|
|
var animationObject = skeletonDataAsset.GetSkeletonData(false).FindAnimation(animationName);
|
|
if (animationObject != null)
|
|
return state.SetAnimation(0, animationObject, animationLoop);
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Whether or not <see cref="AnimationName"/> should loop. This only applies to the initial animation specified in the inspector, or any subsequent Animations played through .AnimationName. Animations set through state.SetAnimation are unaffected.</summary>
|
|
public bool loop;
|
|
|
|
/// <summary>
|
|
/// The rate at which animations progress over time. 1 means 100%. 0.5 means 50%.</summary>
|
|
/// <remarks>AnimationState and TrackEntry also have their own timeScale. These are combined multiplicatively.</remarks>
|
|
public float timeScale = 1;
|
|
#endregion
|
|
|
|
//#region Runtime Instantiation
|
|
///// <summary>Adds and prepares a SkeletonAnimation component to a GameObject at runtime.</summary>
|
|
///// <returns>The newly instantiated SkeletonAnimation</returns>
|
|
//public static SkeletonAnimation AddToGameObject (GameObject gameObject, SkeletonDataAsset skeletonDataAsset) {
|
|
// return SkeletonRenderer.AddSpineComponent<SkeletonAnimation>(gameObject, skeletonDataAsset);
|
|
//}
|
|
//
|
|
///// <summary>Instantiates a new UnityEngine.GameObject and adds a prepared SkeletonAnimation component to it.</summary>
|
|
///// <returns>The newly instantiated SkeletonAnimation component.</returns>
|
|
//public static SkeletonAnimation NewSkeletonAnimationGameObject (SkeletonDataAsset skeletonDataAsset) {
|
|
// return SkeletonRenderer.NewSpineGameObject<SkeletonAnimation>(skeletonDataAsset);
|
|
//}
|
|
//#endregion
|
|
|
|
/// <summary>
|
|
/// Clears the previously generated mesh, resets the skeleton's pose, and clears all previously active animations.</summary>
|
|
//public override void ClearState () {
|
|
// base.ClearState();
|
|
// if (state != null) state.ClearTracks();
|
|
//}
|
|
|
|
/// <summary>
|
|
/// Initialize this component. Attempts to load the SkeletonData and creates the internal Spine objects and buffers.</summary>
|
|
/// <param name="overwrite">If set to <c>true</c>, force overwrite an already initialized object.</param>
|
|
//public override void Initialize (bool overwrite) {
|
|
// if (valid && !overwrite)
|
|
// return;
|
|
//
|
|
// base.Initialize(overwrite);
|
|
//
|
|
// if (!valid)
|
|
// return;
|
|
//
|
|
// state = new Spine.AnimationState(skeletonDataAsset.GetAnimationStateData());
|
|
//
|
|
// #if UNITY_EDITOR
|
|
// if (!string.IsNullOrEmpty(_animationName)) {
|
|
// if (Application.isPlaying) {
|
|
// TrackEntry startingTrack = TrySetAnimation(_animationName, loop);
|
|
// if (startingTrack != null)
|
|
// Update(0);
|
|
// } else {
|
|
// // Assume SkeletonAnimation is valid for skeletonData and skeleton. Checked above.
|
|
// var animationObject = skeletonDataAsset.GetSkeletonData(false).FindAnimation(_animationName);
|
|
// if (animationObject != null)
|
|
// animationObject.PoseSkeleton(skeleton, 0f);
|
|
// }
|
|
// }
|
|
// #else
|
|
// if (!string.IsNullOrEmpty(_animationName)) {
|
|
// TrackEntry startingTrack = TrySetAnimation(_animationName, loop);
|
|
// if (startingTrack != null)
|
|
// Update(0);
|
|
// }
|
|
// #endif
|
|
//}
|
|
|
|
void Update () {
|
|
Update(Time.deltaTime);
|
|
}
|
|
|
|
/// <summary>Progresses the AnimationState according to the given deltaTime, and applies it to the Skeleton. Use Time.deltaTime to update manually. Use deltaTime 0 to update without progressing the time.</summary>
|
|
public void Update (float deltaTime) {
|
|
if (!valid)
|
|
return;
|
|
|
|
deltaTime *= timeScale;
|
|
skeleton.Update(deltaTime);
|
|
state.Update(deltaTime);
|
|
state.Apply(skeleton);
|
|
|
|
if (_UpdateLocal != null)
|
|
_UpdateLocal(this);
|
|
|
|
skeleton.UpdateWorldTransform();
|
|
|
|
if (_UpdateWorld != null) {
|
|
_UpdateWorld(this);
|
|
skeleton.UpdateWorldTransform();
|
|
}
|
|
|
|
if (_UpdateComplete != null) {
|
|
_UpdateComplete(this);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public delegate void SkeletonMemoriaDelegate (SkeletonMemoria skeletonMemoria);
|
|
public event SkeletonMemoriaDelegate OnRebuild;
|
|
|
|
/// <summary> Occurs after the vertex data is populated every frame, before the vertices are pushed into the mesh.</summary>
|
|
public event Spine.Unity.MeshGeneratorDelegate OnPostProcessVertices;
|
|
|
|
public SkeletonDataAsset skeletonDataAsset;
|
|
public SkeletonDataAsset SkeletonDataAsset { get { return skeletonDataAsset; } } // ISkeletonComponent
|
|
public string initialSkinName;
|
|
public bool initialFlipX, initialFlipY;
|
|
|
|
#region Advanced
|
|
// Submesh Separation
|
|
[UnityEngine.Serialization.FormerlySerializedAs("submeshSeparators")] [SpineSlot] public string[] separatorSlotNames = new string[0];
|
|
[System.NonSerialized] public readonly List<Slot> separatorSlots = new List<Slot>();
|
|
|
|
[Range(-0.1f, 0f)] public float zSpacing;
|
|
//public bool renderMeshes = true;
|
|
public bool useClipping = true;
|
|
public bool immutableTriangles = false;
|
|
public bool pmaVertexColors = true;
|
|
/// <summary>Clears the state when this component or its GameObject is disabled. This prevents previous state from being retained when it is enabled again. When pooling your skeleton, setting this to true can be helpful.</summary>
|
|
public bool clearStateOnDisable = false;
|
|
public bool tintBlack = false;
|
|
public bool singleSubmesh = false;
|
|
|
|
[UnityEngine.Serialization.FormerlySerializedAs("calculateNormals")]
|
|
public bool addNormals = false;
|
|
public bool calculateTangents = false;
|
|
|
|
public bool logErrors = false;
|
|
|
|
#if SPINE_OPTIONAL_RENDEROVERRIDE
|
|
public bool disableRenderingOnOverride = true;
|
|
public delegate void InstructionDelegate (SkeletonRendererInstruction instruction);
|
|
event InstructionDelegate generateMeshOverride;
|
|
public event InstructionDelegate GenerateMeshOverride {
|
|
add {
|
|
generateMeshOverride += value;
|
|
if (disableRenderingOnOverride && generateMeshOverride != null) {
|
|
Initialize(false);
|
|
meshRenderer.enabled = false;
|
|
}
|
|
}
|
|
remove {
|
|
generateMeshOverride -= value;
|
|
if (disableRenderingOnOverride && generateMeshOverride == null) {
|
|
Initialize(false);
|
|
meshRenderer.enabled = true;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if SPINE_OPTIONAL_MATERIALOVERRIDE
|
|
[System.NonSerialized] readonly Dictionary<Material, Material> customMaterialOverride = new Dictionary<Material, Material>();
|
|
public Dictionary<Material, Material> CustomMaterialOverride { get { return customMaterialOverride; } }
|
|
#endif
|
|
|
|
// Custom Slot Material
|
|
[System.NonSerialized] readonly Dictionary<Slot, Material> customSlotMaterials = new Dictionary<Slot, Material>();
|
|
public Dictionary<Slot, Material> CustomSlotMaterials { get { return customSlotMaterials; } }
|
|
#endregion
|
|
|
|
MeshRenderer meshRenderer;
|
|
MeshFilter meshFilter;
|
|
|
|
[System.NonSerialized] public bool valid;
|
|
[System.NonSerialized] public Skeleton skeleton;
|
|
public Skeleton Skeleton {
|
|
get {
|
|
Initialize(false);
|
|
return skeleton;
|
|
}
|
|
}
|
|
|
|
[System.NonSerialized] readonly SkeletonRendererInstruction currentInstructions = new SkeletonRendererInstruction();
|
|
readonly MeshGenerator meshGenerator = new MeshGenerator();
|
|
[System.NonSerialized] readonly MeshRendererBuffers rendererBuffers = new MeshRendererBuffers();
|
|
|
|
#region Runtime Instantiation
|
|
public static T NewSpineGameObject<T> (SkeletonDataAsset skeletonDataAsset) where T : SkeletonMemoria {
|
|
return SkeletonMemoria.AddSpineComponent<T>(new GameObject("New Spine GameObject"), skeletonDataAsset);
|
|
}
|
|
|
|
/// <summary>Add and prepare a Spine component that derives from SkeletonMemoria to a GameObject at runtime.</summary>
|
|
/// <typeparam name="T">T should be SkeletonMemoria or any of its derived classes.</typeparam>
|
|
public static T AddSpineComponent<T> (GameObject gameObject, SkeletonDataAsset skeletonDataAsset) where T : SkeletonMemoria {
|
|
var c = gameObject.AddComponent<T>();
|
|
if (skeletonDataAsset != null) {
|
|
c.skeletonDataAsset = skeletonDataAsset;
|
|
c.Initialize(false);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/// <summary>Applies MeshGenerator settings to the SkeletonMemoria and its internal MeshGenerator.</summary>
|
|
public void SetMeshSettings (MeshGenerator.Settings settings) {
|
|
this.calculateTangents = settings.calculateTangents;
|
|
this.immutableTriangles = settings.immutableTriangles;
|
|
this.pmaVertexColors = settings.pmaVertexColors;
|
|
this.tintBlack = settings.tintBlack;
|
|
this.useClipping = settings.useClipping;
|
|
this.zSpacing = settings.zSpacing;
|
|
|
|
this.meshGenerator.settings = settings;
|
|
}
|
|
#endregion
|
|
|
|
public virtual void Awake () {
|
|
Initialize(false);
|
|
}
|
|
|
|
void OnDisable () {
|
|
if (clearStateOnDisable && valid)
|
|
ClearState();
|
|
}
|
|
|
|
void OnDestroy () {
|
|
rendererBuffers.Dispose();
|
|
valid = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears the previously generated mesh and resets the skeleton's pose.</summary>
|
|
public virtual void ClearState () {
|
|
meshFilter.sharedMesh = null;
|
|
currentInstructions.Clear();
|
|
if (skeleton != null) skeleton.SetToSetupPose();
|
|
// 0base.ClearState();
|
|
if (state != null) state.ClearTracks();
|
|
}
|
|
|
|
public void EnsureMeshGeneratorCapacity (int minimumVertexCount) {
|
|
meshGenerator.EnsureVertexCapacity(minimumVertexCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize this component. Attempts to load the SkeletonData and creates the internal Skeleton object and buffers.</summary>
|
|
/// <param name="overwrite">If set to <c>true</c>, it will overwrite internal objects if they were already generated. Otherwise, the initialized component will ignore subsequent calls to initialize.</param>
|
|
public virtual void Initialize (bool overwrite) {
|
|
if (valid && !overwrite)
|
|
return;
|
|
|
|
// Clear
|
|
{
|
|
if (meshFilter != null)
|
|
meshFilter.sharedMesh = null;
|
|
|
|
meshRenderer = GetComponent<MeshRenderer>();
|
|
if (meshRenderer != null) meshRenderer.sharedMaterial = null;
|
|
|
|
currentInstructions.Clear();
|
|
rendererBuffers.Clear();
|
|
meshGenerator.Begin();
|
|
skeleton = null;
|
|
valid = false;
|
|
}
|
|
|
|
if (!skeletonDataAsset) {
|
|
if (logErrors) Debug.LogError("Missing SkeletonData asset.", this);
|
|
return;
|
|
}
|
|
|
|
SkeletonData skeletonData = skeletonDataAsset.GetSkeletonData(false);
|
|
if (skeletonData == null) return;
|
|
valid = true;
|
|
|
|
meshFilter = GetComponent<MeshFilter>();
|
|
meshRenderer = GetComponent<MeshRenderer>();
|
|
rendererBuffers.Initialize();
|
|
|
|
skeleton = new Skeleton(skeletonData) {
|
|
flipX = initialFlipX,
|
|
flipY = initialFlipY
|
|
};
|
|
|
|
if (!string.IsNullOrEmpty(initialSkinName) && !string.Equals(initialSkinName, "default", System.StringComparison.Ordinal))
|
|
skeleton.SetSkin(initialSkinName);
|
|
|
|
separatorSlots.Clear();
|
|
for (int i = 0; i < separatorSlotNames.Length; i++)
|
|
separatorSlots.Add(skeleton.FindSlot(separatorSlotNames[i]));
|
|
|
|
LateUpdate(); // Generate mesh for the first frame it exists.
|
|
|
|
if (OnRebuild != null)
|
|
OnRebuild(this);
|
|
|
|
//if (valid && !overwrite)
|
|
// return;
|
|
|
|
//base.Initialize(overwrite);
|
|
|
|
//if (!valid)
|
|
// return;
|
|
|
|
state = new Spine.AnimationState(skeletonDataAsset.GetAnimationStateData());
|
|
|
|
#if UNITY_EDITOR
|
|
if (!string.IsNullOrEmpty(_animationName)) {
|
|
if (Application.isPlaying) {
|
|
TrackEntry startingTrack = TrySetAnimation(_animationName, loop);
|
|
if (startingTrack != null)
|
|
Update(0);
|
|
} else {
|
|
// Assume SkeletonAnimation is valid for skeletonData and skeleton. Checked above.
|
|
var animationObject = skeletonDataAsset.GetSkeletonData(false).FindAnimation(_animationName);
|
|
if (animationObject != null)
|
|
animationObject.PoseSkeleton(skeleton, 0f);
|
|
}
|
|
}
|
|
#else
|
|
if (!string.IsNullOrEmpty(_animationName)) {
|
|
TrackEntry startingTrack = TrySetAnimation(_animationName, loop);
|
|
if (startingTrack != null)
|
|
Update(0);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/// <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].materials[0]);
|
|
|
|
// 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);
|
|
}
|
|
}
|
|
}
|