UPD: updated script.

Pharan escribió

...

Thanks! Here's my script for changing materials, per-atlas, per-instance. It's ugly, but does the job.

using System;
using Spine;
using UnityEngine;

namespace Spine{
    [RequireComponent(typeof(SkeletonRenderer))]
    [RequireComponent(typeof(MeshRenderer))]
    [ExecuteInEditMode]
    public class SpineOverrideAtlasMaterials : MonoBehaviour {
        [SerializeField]
        private SkeletonRenderer _skeletonRenderer;

    [SerializeField]
    private bool _updateEachFrame;

    [SerializeField]
    private AtlasMaterialOverride[] _atlasOverrides;

    private AttachmentOverride[] _attachmentOverrides;

    private void OnWillRenderObject() {
        if (_skeletonRenderer == null || _skeletonRenderer.skeleton == null)
            return;

        Spine.ExposedList<Slot> drawOrder = _skeletonRenderer.skeleton.drawOrder;
        bool mustUpdateAttachmentOverrides = _attachmentOverrides == null || _attachmentOverrides.Length != drawOrder.Count;
        if (mustUpdateAttachmentOverrides) { 
            _attachmentOverrides = new AttachmentOverride[drawOrder.Count];
        } else if (!_updateEachFrame)
            return;

        for (int i = 0; i < drawOrder.Count; i++) {
            Slot slot = drawOrder.Items[i];
            Attachment attachment = slot.attachment;
            if (!mustUpdateAttachmentOverrides) {
                if (_attachmentOverrides[i] == null)
                    continue;

                SetAttachmentRendererObject(attachment, _attachmentOverrides[i].OverrideAtlasRegion);
                continue;
            }

            object rendererObject = GetAttachmentRendererObject(attachment);
            if (rendererObject == null)
                continue;

            Material material = (Material)((AtlasRegion)rendererObject).page.rendererObject;
            for (int j = 0; j < _atlasOverrides.Length; j++) {
                AtlasMaterialOverride atlasMaterialOverride = _atlasOverrides[j];
                for (int k = 0; k < atlasMaterialOverride.OriginalMaterials.Length; k++) {
                    Material overrideMaterial = atlasMaterialOverride.OverrideMaterials[k];
                    if (overrideMaterial == null)
                        continue;

                    Material originalMaterial = atlasMaterialOverride.OriginalMaterials[k];
                    if (originalMaterial != material)
                        continue;

                    AtlasRegion atlasRegion = new AtlasRegion();
                    AtlasPage atlasPage = new AtlasPage();
                    atlasPage.rendererObject = overrideMaterial;
                    atlasRegion.page = atlasPage;
                    _attachmentOverrides[i] = new AttachmentOverride();
                    _attachmentOverrides[i].OverrideAtlasRegion = atlasRegion;

                    SetAttachmentRendererObject(attachment, atlasRegion);

                    goto outerLoop;
                }
            }

            outerLoop: { }
        }
    }

    private void SetAttachmentRendererObject(Attachment attachment, object rendererObject) {
        var regionAttachment = attachment as RegionAttachment;
        if (regionAttachment != null) {
            regionAttachment.RendererObject = rendererObject;
        } else {
            var meshAttachment = attachment as MeshAttachment;
            if (meshAttachment != null) {
                meshAttachment.RendererObject = rendererObject;
            } else {
                var skinnedMeshAttachment = attachment as SkinnedMeshAttachment;
                if (skinnedMeshAttachment != null) {
                    skinnedMeshAttachment.RendererObject = rendererObject;
                }
            }
        }
    }

    private object GetAttachmentRendererObject(Attachment attachment) {
        object rendererObject = null;
        var regionAttachment = attachment as RegionAttachment;
        if (regionAttachment != null) {
            rendererObject = regionAttachment.RendererObject;
        } else {
            if (!_skeletonRenderer.renderMeshes)
                return rendererObject;

            var meshAttachment = attachment as MeshAttachment;
            if (meshAttachment != null) {
                rendererObject = meshAttachment.RendererObject;
            } else {
                var skinnedMeshAttachment = attachment as SkinnedMeshAttachment;
                if (skinnedMeshAttachment != null) {
                    rendererObject = skinnedMeshAttachment.RendererObject;
                } else
                    return rendererObject;
            }
        }

        return rendererObject;
    }

    private void Reset() {
        _skeletonRenderer = GetComponent<SkeletonRenderer>();
        if (_skeletonRenderer == null)
            return;

        SkeletonDataAsset skeletonDataAsset = _skeletonRenderer.skeletonDataAsset;
        _atlasOverrides = new AtlasMaterialOverride[skeletonDataAsset.atlasAssets.Length];
        for (int i = 0; i < _atlasOverrides.Length; i++) {
            _atlasOverrides[i] = new AtlasMaterialOverride();
            _atlasOverrides[i].OriginalMaterials = (Material[]) skeletonDataAsset.atlasAssets[i].materials.Clone();
            _atlasOverrides[i].OverrideMaterials = new Material[skeletonDataAsset.atlasAssets[i].materials.Length];
        }
    }

    [Serializable]
    public class AtlasMaterialOverride {
        public Material[] OriginalMaterials;
        public Material[] OverrideMaterials;
    }

    public class AttachmentOverride {
        public int AttachmentIndex;
        public AtlasRegion OverrideAtlasRegion;
    }
}
}

Pharan escribió

So it generates its own attachment object per modified attachment for each skeleton so it doesn't affect the others?
In what situation is it helpful for this to run every frame?
And how do other classes interface with it? There doesn't seem to be any publics. Is it an inspector thing?

Yes, it does generate new attachment objects for each skeleton instance. It isn't actually run each frame by default - the AttachmentOverride[] is generated once and just applied then. Yeah, it's currently set up entirely from Inspector, had no need for interfacing with other classes yet.

Pharan escribió

Does MaterialPropertyBlock even work for MeshRenderers with multiple materials?

It works, but in a way that makes it useless for this case. With MaterialPropertyBlock, you can only override a texture per-Renderer by it's property name in shader, so if you have two materials on the same renderer... Well, nothing good will happen. You'll probably have the same texture on all materials.
And yeah, even if that did work, it'd be pretty limited.

As it turned out, my script wasn't actually making modifications per skeleton instance. I've assumed that a unique SkeletonData instance is used per SkeletonRenderer, bit it seems like they all use the same shared instance. Do I have to deep copy SkeletonData for each SkeletonRenderer now?..

It's quite astonishing through how many hoops do we have to jump to change the material... I'm still not sure how to execute such a seemingly simple thing.

Okay, so I've made a simpler script for simple atlas overrides, it doess material replacement post-fast in MeshRenderer, works good enough:

using System;
using Spine;
using UnityEngine;

namespace Raycord {
    [RequireComponent(typeof(SkeletonRenderer))]
    [RequireComponent(typeof(MeshRenderer))]
    [ExecuteInEditMode]
    public class SpineOverrideMaterials : MonoBehaviour {
        [SerializeField]
        private SkeletonRenderer _skeletonRenderer;

    [SerializeField]
    private AtlasMaterialOverride[] _atlasOverrides;

    private Renderer _renderer;

    private void OnEnable() {
        _renderer = GetComponent<Renderer>();
    }

    private void OnWillRenderObject() {
        if (_skeletonRenderer == null || _skeletonRenderer.skeleton == null)
            return;

        Material[] sharedMaterials = _renderer.sharedMaterials;
        foreach (AtlasMaterialOverride atlasOverride in _atlasOverrides) {
            for (int i = 0; i < atlasOverride.OriginalMaterials.Length; i++) {
                for (int j = 0; j < sharedMaterials.Length; j++) {
                    if (sharedMaterials[j] == atlasOverride.OriginalMaterials[i]) {
                        sharedMaterials[j] = atlasOverride.OverrideMaterials[i];
                    }
                }
            }
        }

        _renderer.sharedMaterials = sharedMaterials;
    }

    private void Reset() {
        _skeletonRenderer = GetComponent<SkeletonRenderer>();
        if (_skeletonRenderer == null)
            return;

        SkeletonDataAsset skeletonDataAsset = _skeletonRenderer.skeletonDataAsset;
        _atlasOverrides = new AtlasMaterialOverride[skeletonDataAsset.atlasAssets.Length];
        for (int i = 0; i < _atlasOverrides.Length; i++) {
            _atlasOverrides[i] = new AtlasMaterialOverride();
            _atlasOverrides[i].OriginalMaterials = (Material[]) skeletonDataAsset.atlasAssets[i].materials.Clone();
            _atlasOverrides[i].OverrideMaterials = new Material[skeletonDataAsset.atlasAssets[i].materials.Length];
        }
    }

    [Serializable]
    public class AtlasMaterialOverride {
        public Material[] OriginalMaterials;
        public Material[] OverrideMaterials;
    }
}
}

Per-attachment changes that are shared across Skeleton instances can be done with the script I've posted before. But now what about per-instance per-attachment changes? Even if I do deep copy of Attachments, they will be shared across all Skeleton instances... Is there any way except manually deep copying SkeletonData?

Yes, extending SkeletonRenderer is the first thing that came to my mind, actually. Thing is, I generally avoid any changes to Spine runtime, so I can safely update to newer versions without having to figure out all the changes in case they interfere with my modifications. Though perhaps this is something that's worth integrating in the official runtime as well?