From d83dfd2194186ffd1c9574f41118ff34a727e8e1 Mon Sep 17 00:00:00 2001 From: Harald Csaszar Date: Wed, 17 Sep 2025 18:25:11 +0200 Subject: [PATCH] [unity] Added Spine Preferences atlas texture PMA/straight-alpha workflow switching buttons. See #2928. --- .../spine-unity/Editor/Utility/Preferences.cs | 73 ++++++++++----- .../Editor/Windows/SpinePreferences.cs | 90 ++++++++++++++++--- 2 files changed, 131 insertions(+), 32 deletions(-) diff --git a/spine-unity/Assets/Spine/Editor/spine-unity/Editor/Utility/Preferences.cs b/spine-unity/Assets/Spine/Editor/spine-unity/Editor/Utility/Preferences.cs index 2db5f87d7..1da70717a 100644 --- a/spine-unity/Assets/Spine/Editor/spine-unity/Editor/Utility/Preferences.cs +++ b/spine-unity/Assets/Spine/Editor/spine-unity/Editor/Utility/Preferences.cs @@ -146,10 +146,23 @@ namespace Spine.Unity.Editor { public static string blendModeMaterialMultiply = ""; public static string blendModeMaterialScreen = ""; public static string blendModeMaterialAdditive = ""; + + public const string DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_STRAIGHT = SpinePreferences.DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_STRAIGHT; + public const string DEFAULT_BLEND_MODE_SCREEN_MATERIAL_STRAIGHT = SpinePreferences.DEFAULT_BLEND_MODE_SCREEN_MATERIAL_STRAIGHT; + public const string DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_STRAIGHT = SpinePreferences.DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_STRAIGHT; + + public const string DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_PMA = SpinePreferences.DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_PMA; + public const string DEFAULT_BLEND_MODE_SCREEN_MATERIAL_PMA = SpinePreferences.DEFAULT_BLEND_MODE_SCREEN_MATERIAL_PMA; + public const string DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_PMA = SpinePreferences.DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_PMA; + public const string DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL = SpinePreferences.DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL; public const string DEFAULT_BLEND_MODE_SCREEN_MATERIAL = SpinePreferences.DEFAULT_BLEND_MODE_SCREEN_MATERIAL; public const string DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL = SpinePreferences.DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL; + public const string DEFAULT_TEXTURE_TEMPLATE_STRAIGHT = "StraightAlphaPresetTemplate"; + public const string DEFAULT_TEXTURE_TEMPLATE_PMA = "PMAPresetTemplate"; + public const string DEFAULT_TEXTURE_TEMPLATE = DEFAULT_TEXTURE_TEMPLATE_STRAIGHT; + public static Material BlendModeMaterialMultiply { get { return AssetDatabase.LoadAssetAtPath(blendModeMaterialMultiply); } } @@ -303,38 +316,36 @@ namespace Spine.Unity.Editor { if (EditorGUI.EndChangeCheck()) EditorPrefs.SetString(DEFAULT_SHADER_KEY, defaultShader); + EditorGUILayout.Space(); + using (new GUILayout.HorizontalScope()) { + EditorGUILayout.PrefixLabel("Switch Texture Workflow"); + if (GUILayout.Button("Straight Alpha", GUILayout.Width(96))) + SwitchToStraightAlphaDefaults(); + if (GUILayout.Button("PMA", GUILayout.Width(64))) + SwitchToPMADefaults(); + } + SpineEditorUtilities.BoolPrefsField(ref setTextureImporterSettings, SET_TEXTUREIMPORTER_SETTINGS_KEY, new GUIContent("Apply Atlas Texture Settings", "Apply the recommended settings for Texture Importers.")); - SpineEditorUtilities.Texture2DPrefsField(ref textureSettingsReference, TEXTURE_SETTINGS_REFERENCE_KEY, new GUIContent("Atlas Texture Reference Settings", "Apply the selected reference texture import settings at newly imported atlas textures.\n\n" + - "When exporting atlas textures from Spine with \"Premultiply alpha\" enabled (the default, requires Gamma color space), assign \"PMAPresetTemplate\". If you have disabled \"Premultiply alpha\", leave it at \"StraightAlphaPresetTemplate\".\n\n" + - "You can also create your own reference texture asset and assign it here.")); + SpineEditorUtilities.Texture2DPrefsField(ref textureSettingsReference, TEXTURE_SETTINGS_REFERENCE_KEY, new GUIContent("Atlas Texture Reference Settings", + string.Format("Apply the selected reference texture import settings at newly imported atlas textures.\n\n" + + "When exporting atlas textures from Spine with \"Premultiply alpha\" enabled (the default, requires Gamma color space), assign \"{0}\". If you have disabled \"Premultiply alpha\", leave it at \"{1}\".\n\n" + + "You can also create your own reference texture asset and assign it here.", + DEFAULT_TEXTURE_TEMPLATE_PMA, DEFAULT_TEXTURE_TEMPLATE_STRAIGHT))); if (string.IsNullOrEmpty(textureSettingsReference)) { - string[] pmaTextureSettingsReferenceGUIDS = AssetDatabase.FindAssets("StraightAlphaPresetTemplate"); - if (pmaTextureSettingsReferenceGUIDS.Length > 0) { - textureSettingsReference = AssetDatabase.GUIDToAssetPath(pmaTextureSettingsReferenceGUIDS[0]); - EditorPrefs.SetString(TEXTURE_SETTINGS_REFERENCE_KEY, textureSettingsReference); - } + AssignEditorPrefsAssetReference(ref textureSettingsReference, TEXTURE_SETTINGS_REFERENCE_KEY, DEFAULT_TEXTURE_TEMPLATE); } SpineEditorUtilities.MaterialPrefsField(ref blendModeMaterialAdditive, BLEND_MODE_MATERIAL_ADDITIVE_KEY, new GUIContent("Additive Material", "Additive blend mode Material template.")); if (string.IsNullOrEmpty(blendModeMaterialAdditive)) { - string[] blendModeMaterialAdditiveGUIDS = AssetDatabase.FindAssets(DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL); - if (blendModeMaterialAdditiveGUIDS.Length > 0) { - blendModeMaterialAdditive = AssetDatabase.GUIDToAssetPath(blendModeMaterialAdditiveGUIDS[0]); - } + AssignEditorPrefsAssetReference(ref blendModeMaterialAdditive, BLEND_MODE_MATERIAL_ADDITIVE_KEY, DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL); } SpineEditorUtilities.MaterialPrefsField(ref blendModeMaterialMultiply, BLEND_MODE_MATERIAL_MULTIPLY_KEY, new GUIContent("Multiply Material", "Multiply blend mode Material template.")); if (string.IsNullOrEmpty(blendModeMaterialMultiply)) { - string[] blendModeMaterialMultiplyGUIDS = AssetDatabase.FindAssets(DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL); - if (blendModeMaterialMultiplyGUIDS.Length > 0) { - blendModeMaterialMultiply = AssetDatabase.GUIDToAssetPath(blendModeMaterialMultiplyGUIDS[0]); - } + AssignEditorPrefsAssetReference(ref blendModeMaterialMultiply, BLEND_MODE_MATERIAL_MULTIPLY_KEY, DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL); } SpineEditorUtilities.MaterialPrefsField(ref blendModeMaterialScreen, BLEND_MODE_MATERIAL_SCREEN_KEY, new GUIContent("Screen Material", "Screen blend mode Material template.")); if (string.IsNullOrEmpty(blendModeMaterialScreen)) { - string[] blendModeMaterialScreenGUIDS = AssetDatabase.FindAssets(DEFAULT_BLEND_MODE_SCREEN_MATERIAL); - if (blendModeMaterialScreenGUIDS.Length > 0) { - blendModeMaterialScreen = AssetDatabase.GUIDToAssetPath(blendModeMaterialScreenGUIDS[0]); - } + AssignEditorPrefsAssetReference(ref blendModeMaterialScreen, BLEND_MODE_MATERIAL_SCREEN_KEY, DEFAULT_BLEND_MODE_SCREEN_MATERIAL); } } @@ -418,9 +429,31 @@ namespace Spine.Unity.Editor { SpineEditorUtilities.BoolPrefsField(ref timelineUseBlendDuration, TIMELINE_USE_BLEND_DURATION_KEY, new GUIContent("Use Blend Duration", "When enabled, MixDuration will be synced with timeline clip transition duration 'Ease In Duration'.")); } } + + static void SwitchToStraightAlphaDefaults () { + AssignEditorPrefsAssetReference(ref textureSettingsReference, TEXTURE_SETTINGS_REFERENCE_KEY, DEFAULT_TEXTURE_TEMPLATE_STRAIGHT); + AssignEditorPrefsAssetReference(ref blendModeMaterialAdditive, BLEND_MODE_MATERIAL_ADDITIVE_KEY, DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_STRAIGHT); + AssignEditorPrefsAssetReference(ref blendModeMaterialMultiply, BLEND_MODE_MATERIAL_MULTIPLY_KEY, DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_STRAIGHT); + AssignEditorPrefsAssetReference(ref blendModeMaterialScreen, BLEND_MODE_MATERIAL_SCREEN_KEY, DEFAULT_BLEND_MODE_SCREEN_MATERIAL_STRAIGHT); + } + + static void SwitchToPMADefaults () { + AssignEditorPrefsAssetReference(ref textureSettingsReference, TEXTURE_SETTINGS_REFERENCE_KEY, DEFAULT_TEXTURE_TEMPLATE_PMA); + AssignEditorPrefsAssetReference(ref blendModeMaterialAdditive, BLEND_MODE_MATERIAL_ADDITIVE_KEY, DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_PMA); + AssignEditorPrefsAssetReference(ref blendModeMaterialMultiply, BLEND_MODE_MATERIAL_MULTIPLY_KEY, DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_PMA); + AssignEditorPrefsAssetReference(ref blendModeMaterialScreen, BLEND_MODE_MATERIAL_SCREEN_KEY, DEFAULT_BLEND_MODE_SCREEN_MATERIAL_PMA); + } #endif // !NEW_PREFERENCES_SETTINGS_PROVIDER } + static void AssignEditorPrefsAssetReference (ref string textureSettingsReference, string editorPrefsKey, string assetName) { + string[] guids = AssetDatabase.FindAssets(assetName); + if (guids.Length > 0) { + textureSettingsReference = AssetDatabase.GUIDToAssetPath(guids[0]); + EditorPrefs.SetString(editorPrefsKey, textureSettingsReference); + } + } + static void BoolPrefsField (ref bool currentValue, string editorPrefsKey, GUIContent label) { EditorGUI.BeginChangeCheck(); currentValue = EditorGUILayout.Toggle(label, currentValue); diff --git a/spine-unity/Assets/Spine/Editor/spine-unity/Editor/Windows/SpinePreferences.cs b/spine-unity/Assets/Spine/Editor/spine-unity/Editor/Windows/SpinePreferences.cs index 09d5deb9c..50b3be96c 100644 --- a/spine-unity/Assets/Spine/Editor/spine-unity/Editor/Windows/SpinePreferences.cs +++ b/spine-unity/Assets/Spine/Editor/spine-unity/Editor/Windows/SpinePreferences.cs @@ -125,9 +125,21 @@ namespace Spine.Unity.Editor { return true; } - public const string DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL = "SkeletonStraightMultiply"; - public const string DEFAULT_BLEND_MODE_SCREEN_MATERIAL = "SkeletonStraightScreen"; - public const string DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL = "SkeletonStraightAdditive"; + public const string DEFAULT_TEXTURE_PRESET_STRAIGHT = "StraightAlphaPreset"; + public const string DEFAULT_TEXTURE_PRESET_PMA = "PMATexturePreset"; + public const string DEFAULT_TEXTURE_PRESET = DEFAULT_TEXTURE_PRESET_STRAIGHT; + + public const string DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_STRAIGHT = "SkeletonStraightMultiply"; + public const string DEFAULT_BLEND_MODE_SCREEN_MATERIAL_STRAIGHT = "SkeletonStraightScreen"; + public const string DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_STRAIGHT = "SkeletonStraightAdditive"; + + public const string DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_PMA = "SkeletonPMAMultiply"; + public const string DEFAULT_BLEND_MODE_SCREEN_MATERIAL_PMA = "SkeletonPMAScreen"; + public const string DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_PMA = "SkeletonPMAAdditive"; + + public const string DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL = DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_STRAIGHT; + public const string DEFAULT_BLEND_MODE_SCREEN_MATERIAL = DEFAULT_BLEND_MODE_SCREEN_MATERIAL_STRAIGHT; + public const string DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL = DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_STRAIGHT; public Material blendModeMaterialMultiply = null; public Material blendModeMaterialScreen = null; @@ -292,23 +304,39 @@ namespace Spine.Unity.Editor { SpineEditorUtilities.ShaderPropertyField(settings.FindProperty("defaultShader"), new GUIContent("Default Shader"), SpinePreferences.DEFAULT_DEFAULT_SHADER); - EditorGUILayout.PropertyField(settings.FindProperty("setTextureImporterSettings"), new GUIContent("Apply Atlas Texture Settings", "Apply reference settings for Texture Importers.")); SerializedProperty textureSettingsRef = settings.FindProperty("textureSettingsReference"); - SpineEditorUtilities.PresetAssetPropertyField(textureSettingsRef, new GUIContent("Atlas Texture Settings", "Apply the selected texture import settings at newly imported atlas textures.\n\n" + - "When exporting atlas textures from Spine with \"Premultiply alpha\" enabled (the default), assign \"PMATexturePreset\". If you have disabled \"Premultiply alpha\", leave it at \"StraightAlphaPreset\".\n\n" + - "You can also create your own TextureImporter Preset asset and assign it here.")); + SerializedProperty blendModeMaterialAdditive = settings.FindProperty("blendModeMaterialAdditive"); + SerializedProperty blendModeMaterialMultiply = settings.FindProperty("blendModeMaterialMultiply"); + SerializedProperty blendModeMaterialScreen = settings.FindProperty("blendModeMaterialScreen"); + + EditorGUILayout.Space(); + using (new GUILayout.HorizontalScope()) { + EditorGUILayout.PrefixLabel("Switch Texture Workflow"); + if (GUILayout.Button(new GUIContent("Straight Alpha", "Assign straight-alpha atlas texture workflow templates."), GUILayout.Width(96))) + SwitchToStraightAlphaDefaults(textureSettingsRef, blendModeMaterialAdditive, blendModeMaterialMultiply, blendModeMaterialScreen); + bool isLinearColorSpace = QualitySettings.activeColorSpace == ColorSpace.Linear; + using (new EditorGUI.DisabledScope(isLinearColorSpace)) { + if (GUILayout.Button(new GUIContent("PMA", isLinearColorSpace ? + "[Only supported with Gamma color space]" : "Assign PMA atlas texture workflow templates."), GUILayout.Width(64))) { + SwitchToPMADefaults(textureSettingsRef, blendModeMaterialAdditive, blendModeMaterialMultiply, blendModeMaterialScreen); + } + } + } + EditorGUILayout.PropertyField(settings.FindProperty("setTextureImporterSettings"), new GUIContent("Apply Atlas Texture Settings", "Apply reference settings for Texture Importers.")); + + SpineEditorUtilities.PresetAssetPropertyField(textureSettingsRef, new GUIContent("Atlas Texture Settings", + string.Format("Apply the selected texture import settings at newly imported atlas textures.\n\n" + + "When exporting atlas textures from Spine with \"Premultiply alpha\" enabled (the default), assign \"{0}\". If you have disabled \"Premultiply alpha\", leave it at \"{1}\".\n\n" + + "You can also create your own TextureImporter Preset asset and assign it here.", + DEFAULT_TEXTURE_PRESET_PMA, DEFAULT_TEXTURE_PRESET_STRAIGHT))); if (string.IsNullOrEmpty(textureSettingsRef.stringValue)) { - string[] pmaTextureSettingsReferenceGUIDS = AssetDatabase.FindAssets("StraightAlphaPreset"); + string[] pmaTextureSettingsReferenceGUIDS = AssetDatabase.FindAssets(DEFAULT_TEXTURE_PRESET); if (pmaTextureSettingsReferenceGUIDS.Length > 0) { string assetPath = AssetDatabase.GUIDToAssetPath(pmaTextureSettingsReferenceGUIDS[0]); if (!string.IsNullOrEmpty(assetPath)) textureSettingsRef.stringValue = assetPath; } } - - SerializedProperty blendModeMaterialAdditive = settings.FindProperty("blendModeMaterialAdditive"); - SerializedProperty blendModeMaterialMultiply = settings.FindProperty("blendModeMaterialMultiply"); - SerializedProperty blendModeMaterialScreen = settings.FindProperty("blendModeMaterialScreen"); bool isTexturePresetPMA = IsPMAWorkflow(textureSettingsRef.stringValue); ShowBlendModeMaterialProperty(blendModeMaterialAdditive, "Additive", isTexturePresetPMA); ShowBlendModeMaterialProperty(blendModeMaterialMultiply, "Multiply", isTexturePresetPMA); @@ -411,6 +439,44 @@ namespace Spine.Unity.Editor { } EditorGUIUtility.labelWidth = prevLabelWidth; } + + static void AssignAssetString (SerializedProperty stringProperty, string assetName) { + string[] guids = AssetDatabase.FindAssets(assetName); + if (guids.Length > 0) { + string assetPath = AssetDatabase.GUIDToAssetPath(guids[0]); + if (!string.IsNullOrEmpty(assetPath)) + stringProperty.stringValue = assetPath; + } + } + + static void AssignAssetReference (SerializedProperty stringProperty, string assetName) { + string[] guids = AssetDatabase.FindAssets(assetName); + if (guids.Length > 0) { + string assetPath = AssetDatabase.GUIDToAssetPath(guids[0]); + if (!string.IsNullOrEmpty(assetPath)) + stringProperty.objectReferenceValue = AssetDatabase.LoadAssetAtPath(assetPath); + } + } + + static void SwitchToStraightAlphaDefaults (SerializedProperty textureSettingsReference, + SerializedProperty blendModeMaterialAdditive, SerializedProperty blendModeMaterialMultiply, + SerializedProperty blendModeMaterialScreen) { + + AssignAssetString(textureSettingsReference, DEFAULT_TEXTURE_PRESET_STRAIGHT); + AssignAssetReference(blendModeMaterialAdditive, DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_STRAIGHT); + AssignAssetReference(blendModeMaterialMultiply, DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_STRAIGHT); + AssignAssetReference(blendModeMaterialScreen, DEFAULT_BLEND_MODE_SCREEN_MATERIAL_STRAIGHT); + } + + static void SwitchToPMADefaults (SerializedProperty textureSettingsReference, + SerializedProperty blendModeMaterialAdditive, SerializedProperty blendModeMaterialMultiply, + SerializedProperty blendModeMaterialScreen) { + + AssignAssetString(textureSettingsReference, DEFAULT_TEXTURE_PRESET_PMA); + AssignAssetReference(blendModeMaterialAdditive, DEFAULT_BLEND_MODE_ADDITIVE_MATERIAL_PMA); + AssignAssetReference(blendModeMaterialMultiply, DEFAULT_BLEND_MODE_MULTIPLY_MATERIAL_PMA); + AssignAssetReference(blendModeMaterialScreen, DEFAULT_BLEND_MODE_SCREEN_MATERIAL_PMA); + } #endif // NEW_PREFERENCES_SETTINGS_PROVIDER } }