asecli 0.6.2__py3-none-any.whl

asecli/bridge/resources/asecli_material_gui.part01.cs.txt

@@ -0,0 +1,290 @@
+
+        private static Dictionary<string, PropertyMetadata> ReadMetadata(Shader shader)
+        {
+            Dictionary<string, PropertyMetadata> result =
+                new Dictionary<string, PropertyMetadata>(StringComparer.Ordinal);
+            try
+            {
+                MethodInfo countMethod = FindShaderUtilMethod("GetPropertyCount", typeof(Shader));
+                if (countMethod == null)
+                    countMethod = FindShaderUtilMethod("GetShaderPropertyCount", typeof(Shader));
+                MethodInfo nameMethod = FindShaderUtilMethod("GetPropertyName", typeof(Shader), typeof(int));
+                MethodInfo attributesMethod = FindShaderUtilMethod(
+                    "GetShaderPropertyAttributes", typeof(Shader), typeof(int));
+                Type handlerType = typeof(MaterialEditor).Assembly.GetType("UnityEditor.MaterialPropertyHandler");
+                MethodInfo handlerMethod = handlerType != null
+                    ? handlerType.GetMethod(
+                        "GetHandler",
+                        BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static,
+                        null,
+                        new[] { typeof(Shader), typeof(string) },
+                        null
+                    )
+                    : null;
+                FieldInfo decoratorsField = handlerType != null
+                    ? handlerType.GetField(
+                        "m_DecoratorDrawers",
+                        BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance
+                    )
+                    : null;
+                if (countMethod == null || nameMethod == null ||
+                    (attributesMethod == null && (handlerMethod == null || decoratorsField == null)))
+                    throw new MissingMethodException("ShaderUtil property metadata API is unavailable");
+
+                int count = Convert.ToInt32(countMethod.Invoke(null, new object[] { shader }));
+                for (int index = 0; index < count; index++)
+                {
+                    string name = nameMethod.Invoke(null, new object[] { shader, index }) as string;
+                    if (String.IsNullOrEmpty(name))
+                        continue;
+                    PropertyMetadata metadata = new PropertyMetadata();
+                    if (attributesMethod != null)
+                    {
+                        string[] attributes = attributesMethod.Invoke(
+                            null, new object[] { shader, index }) as string[];
+                        if (attributes != null)
+                        {
+                            foreach (string attribute in attributes)
+                                ApplyAttribute(metadata, attribute);
+                        }
+                    }
+                    else
+                    {
+                        object handler = handlerMethod.Invoke(null, new object[] { shader, name });
+                        IEnumerable decorators = handler != null
+                            ? decoratorsField.GetValue(handler) as IEnumerable
+                            : null;
+                        if (decorators != null)
+                        {
+                            foreach (object drawer in decorators)
+                            {
+                                IASECLIMetadataDecorator decorator = drawer as IASECLIMetadataDecorator;
+                                if (decorator != null)
+                                    ApplyMetadata(metadata, decorator.MetadataType, decorator.MetadataValue);
+                            }
+                        }
+
+                        // Tuanjie 2022.3 has no ShaderUtil.GetShaderPropertyAttributes.
+                        // Its MaterialPropertyHandler can resolve a historical marker to
+                        // another package's drawer with the same unqualified type name.
+                        // In that case the drawer does not implement our private interface,
+                        // so recover only missing ASECLI/legacy metadata from this shader's
+                        // source asset. This is input-only compatibility, never a writer.
+                        PropertyMetadata sourceMetadata;
+                        if (TryReadSourceMetadata(shader, name, out sourceMetadata))
+                            MergeMissingMetadata(metadata, sourceMetadata);
+                    }
+                    result[name] = metadata;
+                }
+            }
+            catch (Exception exception)
+            {
+                if (!metadataWarningLogged)
+                {
+                    metadataWarningLogged = true;
+                    Debug.LogWarning("ASECLI Material GUI could not read shader attributes: " + exception.Message);
+                }
+            }
+            return result;
+        }
+
+        private static bool TryReadSourceMetadata(
+            Shader shader,
+            string propertyName,
+            out PropertyMetadata metadata)
+        {
+            metadata = new PropertyMetadata();
+            string assetPath = AssetDatabase.GetAssetPath(shader);
+            if (String.IsNullOrEmpty(assetPath) ||
+                !assetPath.StartsWith("Assets/", StringComparison.Ordinal))
+                return false;
+
+            try
+            {
+                string projectRoot = Directory.GetParent(Application.dataPath).FullName;
+                string fullPath = Path.Combine(projectRoot, assetPath);
+                if (!File.Exists(fullPath))
+                    return false;
+
+                string escapedPropertyName = Regex.Escape(propertyName);
+                Regex declarationPattern = new Regex(
+                    @"(?m)^[\t ]*(?<attributes>(?:\[[^\]\r\n]*\][\t ]*)*)" +
+                    escapedPropertyName +
+                    @"[\t ]*\(",
+                    RegexOptions.CultureInvariant
+                );
+                Match declaration = declarationPattern.Match(File.ReadAllText(fullPath));
+                if (!declaration.Success)
+                    return false;
+
+                foreach (Match attribute in RawPropertyAttributePattern.Matches(
+                    declaration.Groups["attributes"].Value))
+                    ApplyAttribute(metadata, attribute.Value);
+                return !String.IsNullOrEmpty(metadata.Foldout) ||
+                    !String.IsNullOrEmpty(metadata.Tooltip) ||
+                    !String.IsNullOrEmpty(metadata.Help);
+            }
+            catch (Exception exception)
+            {
+                if (!metadataWarningLogged)
+                {
+                    metadataWarningLogged = true;
+                    Debug.LogWarning("ASECLI Material GUI could not read shader source metadata: " +
+                        exception.Message);
+                }
+                return false;
+            }
+        }
+
+        private static void MergeMissingMetadata(
+            PropertyMetadata target,
+            PropertyMetadata source)
+        {
+            if (String.IsNullOrEmpty(target.Foldout))
+                target.Foldout = source.Foldout;
+            if (String.IsNullOrEmpty(target.Tooltip))
+                target.Tooltip = source.Tooltip;
+            if (String.IsNullOrEmpty(target.Help))
+                target.Help = source.Help;
+        }
+
+        private static MethodInfo FindShaderUtilMethod(string name, params Type[] parameterTypes)
+        {
+            return typeof(ShaderUtil).GetMethod(
+                name,
+                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static,
+                null,
+                parameterTypes,
+                null
+            );
+        }
+
+        private static void ApplyAttribute(PropertyMetadata metadata, string rawAttribute)
+        {
+            if (String.IsNullOrEmpty(rawAttribute))
+                return;
+            string value = rawAttribute.Trim();
+            if (value.StartsWith("[", StringComparison.Ordinal) &&
+                value.EndsWith("]", StringComparison.Ordinal))
+                value = value.Substring(1, value.Length - 2).Trim();
+
+            int open = value.IndexOf('(');
+            string typeName = open >= 0 ? value.Substring(0, open).Trim() : value;
+            string arguments = String.Empty;
+            if (open >= 0 && value.EndsWith(")", StringComparison.Ordinal))
+                arguments = value.Substring(open + 1, value.Length - open - 2);
+
+            ApplyMetadata(metadata, typeName, arguments);
+        }
+
+        private static void ApplyMetadata(PropertyMetadata metadata, string typeName, string arguments)
+        {
+            if (String.Equals(typeName, "ASECLIFoldout", StringComparison.OrdinalIgnoreCase) ||
+                String.Equals(typeName, "FoldoutMzgui", StringComparison.OrdinalIgnoreCase))
+                metadata.Foldout = DecodeFoldout(arguments);
+            else if (String.Equals(typeName, "ASECLITooltip", StringComparison.OrdinalIgnoreCase) ||
+                String.Equals(typeName, "TooltipMzgui", StringComparison.OrdinalIgnoreCase))
+                metadata.Tooltip = AppendLine(metadata.Tooltip, DecodeCustomUnicode(arguments));
+            else if (String.Equals(typeName, "ASECLIHelpBox", StringComparison.OrdinalIgnoreCase) ||
+                String.Equals(typeName, "HelpBoxMzgui", StringComparison.OrdinalIgnoreCase))
+                metadata.Help = AppendLine(metadata.Help, DecodeCustomUnicode(arguments));
+        }
+
+        private static string DecodeFoldout(string value)
+        {
+            return CustomUnicodePattern.Replace(
+                value,
+                match => ((char)Convert.ToInt32(match.Groups[1].Value, 16)).ToString()
+            );
+        }
+
+        private static string DecodeCustomUnicode(string value)
+        {
+            MatchCollection matches = CustomUnicodePattern.Matches(value);
+            if (matches.Count == 0)
+                return value;
+            char[] decoded = new char[matches.Count];
+            for (int index = 0; index < matches.Count; index++)
+                decoded[index] = (char)Convert.ToInt32(matches[index].Groups[1].Value, 16);
+            return new string(decoded);
+        }
+
+        private static string AppendLine(string current, string addition)
+        {
+            if (String.IsNullOrEmpty(addition))
+                return current;
+            return String.IsNullOrEmpty(current) ? addition : current + "\n" + addition;
+        }
+
+        private static Dictionary<string, string> ReadDefaultValues(Shader shader)
+        {
+            Dictionary<string, string> result =
+                new Dictionary<string, string>(StringComparer.Ordinal);
+            Material defaultMaterial = new Material(shader);
+            defaultMaterial.hideFlags = HideFlags.HideAndDontSave;
+            try
+            {
+                MaterialProperty[] defaultProperties = MaterialEditor.GetMaterialProperties(
+                    new UnityEngine.Object[] { defaultMaterial }
+                );
+                foreach (MaterialProperty property in defaultProperties)
+                    result[property.name] = FormatDefaultValue(property);
+            }
+            finally
+            {
+                UnityEngine.Object.DestroyImmediate(defaultMaterial);
+            }
+            return result;
+        }
+
+        private static string FormatDefaultValue(MaterialProperty property)
+        {
+            if (property.type == MaterialProperty.PropType.Color)
+            {
+                Color value = property.colorValue;
+                return Tuple(value.r, value.g, value.b, value.a);
+            }
+            if (property.type == MaterialProperty.PropType.Vector)
+            {
+                Vector4 value = property.vectorValue;
+                return Tuple(value.x, value.y, value.z, value.w);
+            }
+            if (property.type == MaterialProperty.PropType.Texture)
+                return property.textureValue != null ? property.textureValue.name : "None";
+            if (String.Equals(property.type.ToString(), "Int", StringComparison.Ordinal))
+            {
+                PropertyInfo intValueProperty = typeof(MaterialProperty).GetProperty(
+                    "intValue", BindingFlags.Public | BindingFlags.Instance);
+                if (intValueProperty != null)
+                    return Convert.ToInt32(intValueProperty.GetValue(property, null))
+                        .ToString(CultureInfo.InvariantCulture);
+                return Math.Round(property.floatValue).ToString(CultureInfo.InvariantCulture);
+            }
+            return Number(property.floatValue);
+        }
+
+        private static string Tuple(float x, float y, float z, float w)
+        {
+            return "(" + Number(x) + ", " + Number(y) + ", " + Number(z) + ", " + Number(w) + ")";
+        }
+
+        private static string Number(float value)
+        {
+            return value.ToString("0.######", CultureInfo.InvariantCulture);
+        }
+
+        private static string BuildTooltip(string customText, string propertyName, string defaultValue)
+        {
+            string technical = "变量名: " + propertyName + "\n默认值: " + defaultValue;
+            return String.IsNullOrEmpty(customText) ? technical : customText + "\n\n" + technical;
+        }
+    }
+}
+
+// Portable public entry point. A shader authored in a fallback project keeps
+// working unchanged when moved to a project containing the native MZGUI package.
+namespace MZGUI
+{
+    public sealed class MZGUI : ASECLI.MaterialGUI.ASECLIMaterialGUI { }
+}
+#endif

asecli/bridge/resources/asecli_material_gui.reconciliation.cs.txt

@@ -0,0 +1,174 @@
+
+#if UNITY_EDITOR
+namespace ASECLI.MaterialGUI.Authoring
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using UnityEditor;
+    using UnityEngine;
+
+    // Moves portable Custom Attributes into the native MZGUI authoring state when
+    // and only when the complete native PropertyNode capability is available.
+    internal static class ASENativeMzguiReconciler
+    {
+        internal static bool TryMerge(
+            UnityEngine.Object node, IEnumerable<string> source, out bool handled,
+            out bool changed, out string error)
+        {
+            handled = false;
+            changed = false;
+            int nativeProviders = NativeProviderCount();
+            if (nativeProviders == 0) { error = String.Empty; return true; }
+            if (nativeProviders != 1)
+            { handled = true; error = "检测到多个原生 MZGUI provider；已停止协调"; return false; }
+            FieldInfo attributesField = ASEReflection.Field(node.GetType(), "m_mzguiAttribs");
+            FieldInfo selectedField = ASEReflection.Field(node.GetType(), "m_selectedMzguiAttribs");
+            if (attributesField == null && selectedField == null)
+            { error = String.Empty; return true; }
+            handled = true;
+            IList attributes = attributesField != null ? attributesField.GetValue(node) as IList : null;
+            IList selected = selectedField != null ? selectedField.GetValue(node) as IList : null;
+            if (attributes == null || selected == null)
+            { error = "检测到不完整的原生 MZGUI 状态；已停止协调"; return false; }
+
+            Dictionary<string, string> requested = new Dictionary<string, string>(StringComparer.Ordinal);
+            foreach (string item in source)
+            {
+                string raw = (item ?? String.Empty).Trim();
+                if (raw.StartsWith("[", StringComparison.Ordinal) && raw.EndsWith("]", StringComparison.Ordinal))
+                    raw = raw.Substring(1, raw.Length - 2);
+                string semantic = Semantic(raw);
+                if (semantic == null) continue;
+                raw = CanonicalRaw(semantic, raw);
+                string previous;
+                if (requested.TryGetValue(semantic, out previous) && previous != raw)
+                { error = "同一 MZGUI 属性存在冲突值；已停止协调"; return false; }
+                requested[semantic] = raw;
+            }
+            if (requested.Count == 0) { error = String.Empty; return true; }
+
+            Dictionary<string, int> indexes = new Dictionary<string, int>(StringComparer.Ordinal);
+            Dictionary<string, object> records = new Dictionary<string, object>(StringComparer.Ordinal);
+            for (int index = 0; index < attributes.Count; index++)
+            {
+                object record = attributes[index];
+                string name = ReadString(record, "Name");
+                string value = ReadString(record, "Attribute");
+                MethodInfo modify = record != null ? record.GetType().GetMethod(
+                    "ModifyAttribute", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
+                    null, new[] { typeof(string), typeof(string) }, null) : null;
+                if (String.IsNullOrEmpty(name) || value == null || modify == null) continue;
+                if (indexes.ContainsKey(name))
+                { error = "原生 MZGUI 属性表包含重复项；已停止协调"; return false; }
+                indexes[name] = index;
+                records[name] = record;
+            }
+            foreach (string semantic in requested.Keys)
+                if (!indexes.ContainsKey(semantic))
+                { error = "原生 MZGUI 缺少 " + semantic + " capability；已停止协调"; return false; }
+
+            Undo.RecordObject(node, "Reconcile native MZGUI attributes");
+            foreach (KeyValuePair<string, string> item in requested)
+            {
+                int index = indexes[item.Key];
+                object record = records[item.Key];
+                string bracketed = "[" + item.Value + "]";
+                if (ReadString(record, "Attribute") != bracketed)
+                {
+                    record.GetType().GetMethod("ModifyAttribute",
+                        BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
+                        null, new[] { typeof(string), typeof(string) }, null)
+                        .Invoke(record, new object[] { item.Key, bracketed });
+                    changed = true;
+                }
+                if (!ContainsIndex(selected, index)) { selected.Add(index); changed = true; }
+            }
+            bool removed;
+            if (!TryRemovePortable(node, out removed, out error)) return false;
+            changed |= removed;
+            FieldInfo selectedArray = ASEReflection.Field(node.GetType(), "m_selectedMzguiAttribsArr");
+            if (selectedArray != null)
+            {
+                bool[] values = new bool[attributes.Count];
+                foreach (object value in selected)
+                { int index = Convert.ToInt32(value); if (index >= 0 && index < values.Length) values[index] = true; }
+                selectedArray.SetValue(node, values);
+            }
+            if (changed) EditorUtility.SetDirty(node);
+            error = String.Empty;
+            return true;
+        }
+
+        private static string Semantic(string raw)
+        {
+            if (raw.StartsWith("FoldoutMzgui", StringComparison.Ordinal)) return "Foldout";
+            if (raw.StartsWith("TooltipMzgui", StringComparison.Ordinal)) return "Tooltip";
+            if (raw.StartsWith("HelpBoxMzgui", StringComparison.Ordinal)) return "HelpBox";
+            if (raw.StartsWith("ASECLIFoldout", StringComparison.Ordinal)) return "Foldout";
+            if (raw.StartsWith("ASECLITooltip", StringComparison.Ordinal)) return "Tooltip";
+            if (raw.StartsWith("ASECLIHelpBox", StringComparison.Ordinal)) return "HelpBox";
+            return null;
+        }
+
+        private static string CanonicalRaw(string semantic, string raw)
+        {
+            string name = semantic == "Foldout" ? "FoldoutMzgui" :
+                (semantic == "Tooltip" ? "TooltipMzgui" : "HelpBoxMzgui");
+            int arguments = raw.IndexOf('(');
+            return name + (arguments >= 0 ? raw.Substring(arguments) : String.Empty);
+        }
+
+        private static string ReadString(object target, string name)
+        {
+            if (target == null) return null;
+            PropertyInfo property = target.GetType().GetProperty(name,
+                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+            if (property != null) return property.GetValue(target, null) as string;
+            FieldInfo field = ASEReflection.Field(target.GetType(), name);
+            return field != null ? field.GetValue(target) as string : null;
+        }
+
+        private static bool ContainsIndex(IList selected, int index)
+        {
+            foreach (object value in selected) if (Convert.ToInt32(value) == index) return true;
+            return false;
+        }
+
+        private static bool TryRemovePortable(
+            UnityEngine.Object node, out bool changed, out string error)
+        {
+            changed = false;
+            IList values; FieldInfo listField; FieldInfo countField;
+            if (!ASEAttributeStore.TryStorage(
+                    node, out values, out listField, out countField, out error)) return false;
+            for (int index = values.Count - 1; index >= 0; index--)
+            {
+                string raw = values[index] as string ?? String.Empty;
+                if (Semantic(raw.TrimStart('[')) == null &&
+                    !raw.StartsWith("ASECLIFoldout", StringComparison.Ordinal) &&
+                    !raw.StartsWith("ASECLITooltip", StringComparison.Ordinal) &&
+                    !raw.StartsWith("ASECLIHelpBox", StringComparison.Ordinal)) continue;
+                values.RemoveAt(index);
+                changed = true;
+            }
+            if (changed) countField.SetValue(node, values.Count);
+            error = String.Empty;
+            return true;
+        }
+
+        private static int NativeProviderCount()
+        {
+            int count = 0;
+            foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                Type type = assembly.GetType("MZGUI.MZGUI", false);
+                if (type == null || !typeof(ShaderGUI).IsAssignableFrom(type)) continue;
+                if (type.GetInterface("ASECLI.MaterialGUI.IASECLIFallbackProvider") == null) count++;
+            }
+            return count;
+        }
+    }
+}
+#endif

asecli/bridge/resources/asecli_material_gui.transaction.cs.txt

@@ -0,0 +1,108 @@
+
+#if UNITY_EDITOR
+namespace ASECLI.MaterialGUI.Authoring
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using UnityEditor;
+    using UnityEngine;
+
+    internal static class ASEApplyTransaction
+    {
+        internal static bool TryApply(
+            UnityEngine.Object node, string foldout, string tooltip, string help,
+            string enabledIf,
+            bool assignEditor, bool save, out string error)
+        {
+            List<string> attributes;
+            int attributeCount;
+            object master;
+            FieldInfo masterField;
+            string inspector;
+            string shaderPath;
+            byte[] shaderContent;
+            if (!TrySnapshot(node, out attributes, out attributeCount, out error) ||
+                !ASEReflection.TryMasterSnapshot(
+                    assignEditor, out master, out masterField, out inspector, out error) ||
+                !ASEReflection.CanSave(save, out error) ||
+                !ASEReflection.TryDiskSnapshot(save, out shaderPath, out shaderContent, out error))
+                return false;
+
+            Undo.IncrementCurrentGroup();
+            int group = Undo.GetCurrentGroup();
+            Undo.SetCurrentGroupName("Apply ASECLI MZGUI attributes");
+            string stage = "write_attributes";
+            try
+            {
+                if (!ASEAttributeStore.TryWrite(
+                        node, foldout, tooltip, help, enabledIf, out error))
+                    throw new InvalidOperationException(error);
+                stage = "assign_editor";
+                if (assignEditor && !ASEReflection.TryAssignFallbackEditor(out error))
+                    throw new InvalidOperationException(error);
+                stage = "save_shader";
+                if (save && !ASEReflection.TrySave(out error))
+                    throw new InvalidOperationException(error);
+                Undo.CollapseUndoOperations(group);
+                error = String.Empty;
+                return true;
+            }
+            catch (Exception exception)
+            {
+                Undo.RevertAllDownToGroup(group);
+                string attributeRollback;
+                string masterRollback;
+                string diskRollback;
+                bool restoredAttributes = TryRestore(
+                    node, attributes, attributeCount, out attributeRollback);
+                bool restoredMaster = ASEReflection.TryRestoreMaster(
+                    master, masterField, inspector, out masterRollback);
+                bool restoredDisk = ASEReflection.TryRestoreDisk(
+                    shaderPath, shaderContent, out diskRollback);
+                string cause = exception.GetBaseException().Message;
+                error = "MZGUI 应用失败 [" + stage + "]: " + cause +
+                    "; rollback=" + (restoredAttributes && restoredMaster && restoredDisk ? "ok" : "failed");
+                if (!restoredAttributes) error += "; attributes=" + attributeRollback;
+                if (!restoredMaster) error += "; editor=" + masterRollback;
+                if (!restoredDisk) error += "; disk=" + diskRollback;
+                Debug.LogError("ASECLI " + error);
+                return false;
+            }
+        }
+
+        private static bool TrySnapshot(
+            UnityEngine.Object node, out List<string> snapshot, out int count, out string error)
+        {
+            snapshot = new List<string>();
+            count = 0;
+            IList values; FieldInfo listField; FieldInfo countField;
+            if (!ASEAttributeStore.TryStorage(
+                    node, out values, out listField, out countField, out error)) return false;
+            foreach (object item in values) snapshot.Add(item as string ?? String.Empty);
+            count = Convert.ToInt32(countField.GetValue(node));
+            return true;
+        }
+
+        private static bool TryRestore(
+            UnityEngine.Object node, List<string> snapshot, int count, out string error)
+        {
+            try
+            {
+                IList values; FieldInfo listField; FieldInfo countField;
+                if (!ASEAttributeStore.TryStorage(
+                        node, out values, out listField, out countField, out error)) return false;
+                values.Clear();
+                foreach (string item in snapshot) values.Add(item);
+                countField.SetValue(node, count);
+                EditorUtility.SetDirty(node);
+                error = String.Empty;
+                return true;
+            }
+            catch (Exception exception)
+            { error = exception.GetBaseException().Message; return false; }
+        }
+    }
+}
+#endif