/// <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);
         }
     }
 }
        /// <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();
            }


            // 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);
        }
示例#4
0
        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);
        }