asecli 0.6.2__py3-none-any.whl

asecli/bridge/resources/editor_create.part00.cs.txt

@@ -0,0 +1,176 @@
+var payloadJson = System.Text.Encoding.UTF8.GetString(System.Convert.FromBase64String("{payload_base64}"));
+var payload = Newtonsoft.Json.Linq.JObject.Parse(payloadJson);
+var assetPath = (string)payload["asset_path"];
+var temporaryAssetPath = (string)payload["temporary_asset_path"];
+var template = (Newtonsoft.Json.Linq.JObject)payload["template"];
+var nodes = (Newtonsoft.Json.Linq.JArray)payload["nodes"];
+var connections = (Newtonsoft.Json.Linq.JArray)payload["connections"];
+var previousWindow = AmplifyShaderEditor.UIUtils.CurrentWindow;
+var previousSelection = UnityEditor.Selection.activeObject;
+AmplifyShaderEditor.AmplifyShaderEditorWindow win = null;
+bool committed = false;
+bool success = false;
+bool stateRestored = false;
+System.Exception failure = null;
+try
+{
+    if ((int)payload["version"] != 1)
+        throw new System.Exception("unsupported EditorGraphSpec version");
+    string aseVersion = AmplifyShaderEditor.VersionInfo.StaticToString();
+    if (aseVersion != "1.9.6.2")
+        throw new System.Exception("unsupported ASE version: " + aseVersion);
+    if (string.IsNullOrEmpty(assetPath) || !assetPath.StartsWith("Assets/") ||
+        !assetPath.EndsWith(".shader") || assetPath.Contains("..") || assetPath.Contains("\\"))
+        throw new System.Exception("unsafe target asset path");
+    if (string.IsNullOrEmpty(temporaryAssetPath) || !temporaryAssetPath.StartsWith("Assets/") ||
+        !temporaryAssetPath.EndsWith(".shader") || temporaryAssetPath.Contains("..") ||
+        temporaryAssetPath.Contains("\\") || temporaryAssetPath == assetPath)
+        throw new System.Exception("unsafe temporary asset path");
+    string targetDirectory = System.IO.Path.GetDirectoryName(assetPath).Replace("\\", "/");
+    string temporaryDirectory = System.IO.Path.GetDirectoryName(temporaryAssetPath).Replace("\\", "/");
+    if (targetDirectory != temporaryDirectory ||
+        !System.IO.Path.GetFileName(temporaryAssetPath).StartsWith("ASECLI-Temp-"))
+        throw new System.Exception("temporary asset must be a controlled sibling of the target");
+    if (UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(assetPath) != null ||
+        System.IO.File.Exists(System.IO.Path.GetFullPath(assetPath)))
+        throw new System.Exception("target asset already exists");
+    if (UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(temporaryAssetPath) != null ||
+        System.IO.File.Exists(System.IO.Path.GetFullPath(temporaryAssetPath)))
+        throw new System.Exception("temporary asset already exists");
+
+    var publicInstance = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance;
+    var publicStatic = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static;
+    var privateInstance = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance;
+    var createTemplateMethod = typeof(AmplifyShaderEditor.AmplifyShaderEditorWindow).GetMethod(
+        "CreateNewTemplateShader", publicStatic, null,
+        new System.Type[] { typeof(string), typeof(string), typeof(string) }, null);
+    var createNodeMethod = typeof(AmplifyShaderEditor.AmplifyShaderEditorWindow).GetMethod(
+        "CreateNode", publicInstance, null,
+        new System.Type[] { typeof(System.Type), typeof(UnityEngine.Vector2), typeof(AmplifyShaderFunction), typeof(bool) }, null);
+    var createConnectionMethod = typeof(AmplifyShaderEditor.ParentGraph).GetMethod(
+        "CreateConnection", publicInstance, null,
+        new System.Type[] { typeof(int), typeof(int), typeof(int), typeof(int), typeof(bool) }, null);
+    var saveMethod = typeof(AmplifyShaderEditor.AmplifyShaderEditorWindow).GetMethod(
+        "SaveToDisk", publicInstance, null, new System.Type[] { typeof(bool) }, null);
+    var loadMethod = typeof(AmplifyShaderEditor.AmplifyShaderEditorWindow).GetMethod(
+        "LoadFromDisk", publicInstance, null,
+        new System.Type[] { typeof(string), typeof(AmplifyShaderFunction) }, null);
+    var expressionNameField = typeof(AmplifyShaderEditor.CustomExpressionNode).GetField("m_customExpressionName", privateInstance);
+    var expressionItemsField = typeof(AmplifyShaderEditor.CustomExpressionNode).GetField("m_items", privateInstance);
+    var expressionCodeField = typeof(AmplifyShaderEditor.CustomExpressionNode).GetField("m_code", privateInstance);
+    var expressionOutputField = typeof(AmplifyShaderEditor.CustomExpressionNode).GetField("m_outputTypeIdx", privateInstance);
+    var expressionFunctionField = typeof(AmplifyShaderEditor.CustomExpressionNode).GetField("m_functionMode", privateInstance);
+    var rawPropertyNameMethod = typeof(AmplifyShaderEditor.PropertyNode).GetMethod(
+        "SetRawPropertyName", publicInstance, null, new System.Type[] { typeof(string) }, null);
+    var propertyInspectorProperty = typeof(AmplifyShaderEditor.PropertyNode).GetProperty(
+        "PropertyInspectorName", publicInstance);
+    var precisionField = typeof(AmplifyShaderEditor.ParentNode).GetField(
+        "m_currentPrecisionType", privateInstance);
+    var rangedMinField = typeof(AmplifyShaderEditor.RangedFloatNode).GetField(
+        "m_min", privateInstance);
+    var rangedMaxField = typeof(AmplifyShaderEditor.RangedFloatNode).GetField(
+        "m_max", privateInstance);
+    if (createTemplateMethod == null || createNodeMethod == null || createConnectionMethod == null ||
+        saveMethod == null || loadMethod == null || expressionNameField == null ||
+        expressionItemsField == null || expressionCodeField == null ||
+        expressionOutputField == null || expressionFunctionField == null ||
+        rawPropertyNameMethod == null || propertyInspectorProperty == null ||
+        propertyInspectorProperty.GetSetMethod() == null || precisionField == null ||
+        rangedMinField == null || rangedMaxField == null)
+        throw new System.Exception("required ASE API member is missing");
+
+    var primitiveTypes = new System.Collections.Generic.Dictionary<string, System.Type> {
+        { "add", typeof(AmplifyShaderEditor.SimpleAddOpNode) }, { "sub", typeof(AmplifyShaderEditor.SimpleSubtractOpNode) },
+        { "mul", typeof(AmplifyShaderEditor.SimpleMultiplyOpNode) }, { "div", typeof(AmplifyShaderEditor.SimpleDivideOpNode) },
+        { "min", typeof(AmplifyShaderEditor.SimpleMinOpNode) }, { "max", typeof(AmplifyShaderEditor.SimpleMaxOpNode) },
+        { "remainder", typeof(AmplifyShaderEditor.SimpleRemainderNode) }, { "saturate", typeof(AmplifyShaderEditor.SaturateNode) },
+        { "one_minus", typeof(AmplifyShaderEditor.OneMinusNode) }, { "negate", typeof(AmplifyShaderEditor.NegateNode) },
+        { "abs", typeof(AmplifyShaderEditor.AbsOpNode) }, { "floor", typeof(AmplifyShaderEditor.FloorOpNode) },
+        { "ceil", typeof(AmplifyShaderEditor.CeilOpNode) }, { "fract", typeof(AmplifyShaderEditor.FractNode) },
+        { "round", typeof(AmplifyShaderEditor.RoundOpNode) }, { "trunc", typeof(AmplifyShaderEditor.TruncOpNode) },
+        { "sign", typeof(AmplifyShaderEditor.SignOpNode) }, { "sqrt", typeof(AmplifyShaderEditor.SqrtOpNode) },
+        { "rsqrt", typeof(AmplifyShaderEditor.RSqrtOpNode) }, { "rcp", typeof(AmplifyShaderEditor.ReciprocalOpNode) },
+        { "normalize", typeof(AmplifyShaderEditor.NormalizeNode) }, { "length", typeof(AmplifyShaderEditor.LengthOpNode) },
+        { "clamp", typeof(AmplifyShaderEditor.ClampOpNode) }, { "step", typeof(AmplifyShaderEditor.StepOpNode) },
+        { "smoothstep", typeof(AmplifyShaderEditor.SmoothstepOpNode) }, { "lerp", typeof(AmplifyShaderEditor.LerpOp) },
+        { "pow", typeof(AmplifyShaderEditor.PowerNode) }, { "exp", typeof(AmplifyShaderEditor.ExpOpNode) },
+        { "exp2", typeof(AmplifyShaderEditor.Exp2OpNode) }, { "log", typeof(AmplifyShaderEditor.LogOpNode) },
+        { "log2", typeof(AmplifyShaderEditor.Log2OpNode) }, { "log10", typeof(AmplifyShaderEditor.Log10OpNode) },
+        { "sin", typeof(AmplifyShaderEditor.SinOpNode) }, { "cos", typeof(AmplifyShaderEditor.CosOpNode) },
+        { "tan", typeof(AmplifyShaderEditor.TanOpNode) }, { "asin", typeof(AmplifyShaderEditor.ASinOpNode) },
+        { "acos", typeof(AmplifyShaderEditor.ACosOpNode) }, { "atan", typeof(AmplifyShaderEditor.ATanOpNode) },
+        { "atan2", typeof(AmplifyShaderEditor.ATan2OpNode) }, { "sinh", typeof(AmplifyShaderEditor.SinhOpNode) },
+        { "cosh", typeof(AmplifyShaderEditor.CoshOpNode) }, { "tanh", typeof(AmplifyShaderEditor.TanhOpNode) },
+        { "radians", typeof(AmplifyShaderEditor.RadiansOpNode) }, { "degrees", typeof(AmplifyShaderEditor.DegreesOpNode) },
+        { "fmod", typeof(AmplifyShaderEditor.FmodOpNode) }, { "remap", typeof(AmplifyShaderEditor.TFHCRemapNode) },
+        { "dot", typeof(AmplifyShaderEditor.DotProductOpNode) }, { "cross", typeof(AmplifyShaderEditor.CrossProductOpNode) },
+        { "distance", typeof(AmplifyShaderEditor.DistanceOpNode) }, { "reflect", typeof(AmplifyShaderEditor.ReflectOpNode) },
+        { "refract", typeof(AmplifyShaderEditor.RefractOpVec) }, { "rotate_axis", typeof(AmplifyShaderEditor.RotateAboutAxisNode) },
+        { "append", typeof(AmplifyShaderEditor.DynamicAppendNode) }, { "swizzle", typeof(AmplifyShaderEditor.SwizzleNode) },
+        { "component_mask", typeof(AmplifyShaderEditor.ComponentMaskNode) }, { "split", typeof(AmplifyShaderEditor.BreakToComponentsNode) },
+        { "luminance", typeof(AmplifyShaderEditor.LuminanceNode) }, { "desaturate", typeof(AmplifyShaderEditor.DesaturateOpNode) },
+        { "contrast", typeof(AmplifyShaderEditor.SimpleContrastOpNode) }, { "posterize", typeof(AmplifyShaderEditor.PosterizeNode) },
+        { "rgb_to_hsv", typeof(AmplifyShaderEditor.RGBToHSVNode) }, { "hsv_to_rgb", typeof(AmplifyShaderEditor.HSVToRGBNode) },
+        { "gamma_to_linear", typeof(AmplifyShaderEditor.GammaToLinearNode) }, { "linear_to_gamma", typeof(AmplifyShaderEditor.LinearToGammaNode) },
+        { "not", typeof(AmplifyShaderEditor.NotNode) }, { "nand", typeof(AmplifyShaderEditor.NandNode) },
+        { "and", typeof(AmplifyShaderEditor.AllOpNode) }, { "or", typeof(AmplifyShaderEditor.AnyOpNode) },
+        { "select", typeof(AmplifyShaderEditor.StaticSwitch) }, { "texcoord", typeof(AmplifyShaderEditor.TextureCoordinatesNode) },
+        { "world_position", typeof(AmplifyShaderEditor.WorldPosInputsNode) }, { "time", typeof(AmplifyShaderEditor.SimpleTimeNode) },
+        { "vertex_color", typeof(AmplifyShaderEditor.VertexColorNode) }, { "vertex_id", typeof(AmplifyShaderEditor.VertexIdVariableNode) },
+        { "instance_id", typeof(AmplifyShaderEditor.InstanceIdNode) }, { "world_normal", typeof(AmplifyShaderEditor.WorldNormalVector) },
+    };
+    System.Func<string, System.Type> primitiveClass = delegate (string op) {
+        System.Type found = null;
+        primitiveTypes.TryGetValue(op, out found);
+        return found;
+    };
+    System.Func<string, System.Type> constClass = delegate (string value) {
+        string s = value.Trim();
+        if (System.Text.RegularExpressions.Regex.IsMatch(s, @"^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$"))
+            return typeof(AmplifyShaderEditor.RangedFloatNode);
+        if (s.StartsWith("float2")) return typeof(AmplifyShaderEditor.Vector2Node);
+        if (s.StartsWith("float3")) return typeof(AmplifyShaderEditor.Vector3Node);
+        if (s.StartsWith("float4")) return typeof(AmplifyShaderEditor.Vector4Node);
+        return null;
+    };
+    System.Func<string, float[]> parseFloats = delegate (string value) {
+        int a = value.IndexOf('(');
+        int b = value.IndexOf(')');
+        if (a < 0 || b < 0 || b <= a) return new float[0];
+        string[] parts = value.Substring(a + 1, b - a - 1).Split(',');
+        float[] result = new float[parts.Length];
+        for (int i = 0; i < parts.Length; i++)
+            result[i] = float.Parse(parts[i].Trim(), System.Globalization.CultureInfo.InvariantCulture);
+        return result;
+    };
+    System.Action<AmplifyShaderEditor.ParentNode, string> writeConst = delegate (AmplifyShaderEditor.ParentNode node, string value) {
+        if (node is AmplifyShaderEditor.RangedFloatNode)
+            ((AmplifyShaderEditor.RangedFloatNode)node).Value = float.Parse(value.Trim(), System.Globalization.CultureInfo.InvariantCulture);
+        else if (node is AmplifyShaderEditor.Vector2Node) { float[] f = parseFloats(value); ((AmplifyShaderEditor.Vector2Node)node).Value = new UnityEngine.Vector2(f[0], f[1]); }
+        else if (node is AmplifyShaderEditor.Vector3Node) { float[] f = parseFloats(value); ((AmplifyShaderEditor.Vector3Node)node).Value = new UnityEngine.Vector3(f[0], f[1], f[2]); }
+        else if (node is AmplifyShaderEditor.Vector4Node) { float[] f = parseFloats(value); ((AmplifyShaderEditor.Vector4Node)node).Value = new UnityEngine.Vector4(f[0], f[1], f[2], f[3]); }
+    };
+
+    string templateGuid = (string)template["guid"];
+    string shaderName = (string)template["shader_name"];
+    var shader = AmplifyShaderEditor.AmplifyShaderEditorWindow.CreateNewTemplateShader(
+        templateGuid, temporaryAssetPath, shaderName + ".shader");
+    win = AmplifyShaderEditor.UIUtils.CurrentWindow as AmplifyShaderEditor.AmplifyShaderEditorWindow;
+    if (shader == null || win == null || win.CurrentGraph == null || win.CurrentGraph.CurrentMasterNode == null)
+        throw new System.Exception("ASE template graph was not created");
+    win.Show();
+    var layoutEvent = new UnityEngine.Event();
+    layoutEvent.type = UnityEngine.EventType.Layout;
+    win.SendEvent(layoutEvent);
+    var repaintEvent = new UnityEngine.Event();
+    repaintEvent.type = UnityEngine.EventType.Repaint;
+    win.SendEvent(repaintEvent);
+
+    var graph = win.CurrentGraph;
+    var aliasIds = new System.Collections.Generic.Dictionary<string, int>();
+    var recipePrimitiveIds = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.Dictionary<string, int>>();
+    var recipePrimitiveClasses = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.Dictionary<string, string>>();
+    var recipeOutputIds = new System.Collections.Generic.Dictionary<string, int>();
+    var recipeInputTargets = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<System.Tuple<int, int>>>>();
+    int masterId = graph.CurrentMasterNode.UniqueId;
+    foreach (Newtonsoft.Json.Linq.JObject nodeSpec in nodes)

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

@@ -0,0 +1,145 @@
+    {
+        string alias = (string)nodeSpec["alias"];
+        string kind = (string)nodeSpec["kind"];
+        var position = (Newtonsoft.Json.Linq.JArray)nodeSpec["position"];
+        if (kind == "recipe")
+        {
+            var recipeName = (string)nodeSpec["recipe"];
+            var recipeCode = (string)nodeSpec["code"];
+            var recipeOutputType = (string)nodeSpec["output_type"];
+            var recipeInputs = (Newtonsoft.Json.Linq.JArray)nodeSpec["inputs"];
+            var expansion = (Newtonsoft.Json.Linq.JObject)nodeSpec["expansion"];
+            var primitiveSpecs = (Newtonsoft.Json.Linq.JArray)expansion["primitives"];
+            string expansionOutput = (string)expansion["output"];
+
+            bool native = true;
+            foreach (Newtonsoft.Json.Linq.JObject primitiveSpec in primitiveSpecs)
+            {
+                string opName = (string)primitiveSpec["op"];
+                System.Type resolved = opName == "const" ? constClass((string)primitiveSpec["value"]) : primitiveClass(opName);
+                if (resolved == null) { native = false; break; }
+            }
+
+            if (!native)
+            {
+                var expression = win.CreateNode(typeof(AmplifyShaderEditor.CustomExpressionNode),
+                    new UnityEngine.Vector2((float)position[0], (float)position[1]), null, false) as AmplifyShaderEditor.CustomExpressionNode;
+                if (expression == null)
+                    throw new System.Exception("ASE failed to create recipe fallback expression: " + alias);
+                var inputSpecs = recipeInputs;
+                var items = new System.Collections.Generic.List<AmplifyShaderEditor.CustomExpressionInputItem>();
+                for (int inputIndex = 0; inputIndex < inputSpecs.Count; inputIndex++)
+                {
+                    var inputSpec = (Newtonsoft.Json.Linq.JObject)inputSpecs[inputIndex];
+                    string inputName = (string)inputSpec["name"];
+                    var inputType = (AmplifyShaderEditor.WirePortDataType)System.Enum.Parse(
+                        typeof(AmplifyShaderEditor.WirePortDataType), (string)inputSpec["type"]);
+                    var item = new AmplifyShaderEditor.CustomExpressionInputItem(
+                        AmplifyShaderEditor.PrecisionType.Inherit, AmplifyShaderEditor.VariableQualifiers.In,
+                        string.Empty, false, true, string.Empty);
+                    item.Type = inputType;
+                    items.Add(item);
+                    if (inputIndex == 0)
+                        expression.InputPorts[0].ChangeProperties(inputName, inputType, false);
+                    else
+                        expression.AddInputPort(inputType, false, inputName);
+                }
+                var outputType = (AmplifyShaderEditor.WirePortDataType)System.Enum.Parse(
+                    typeof(AmplifyShaderEditor.WirePortDataType), recipeOutputType);
+                int outputTypeIndex = recipeOutputType == "INT" ? 0 :
+                    recipeOutputType == "FLOAT" ? 1 :
+                    recipeOutputType == "FLOAT2" ? 2 :
+                    recipeOutputType == "FLOAT3" ? 3 :
+                    recipeOutputType == "FLOAT4" ? 4 :
+                    recipeOutputType == "FLOAT3x3" ? 5 : 6;
+                expression.OutputPorts[0].ChangeType(outputType, false);
+                expressionNameField.SetValue(expression, recipeName);
+                expressionItemsField.SetValue(expression, items);
+                expressionCodeField.SetValue(expression, recipeCode);
+                expressionOutputField.SetValue(expression, outputTypeIndex);
+                expressionFunctionField.SetValue(expression, recipeCode.Contains("return"));
+                aliasIds.Add(alias, expression.UniqueId);
+                continue;
+            }
+
+            var inputIndexByName = new System.Collections.Generic.Dictionary<string, int>();
+            for (int i = 0; i < recipeInputs.Count; i++)
+                inputIndexByName[(string)((Newtonsoft.Json.Linq.JObject)recipeInputs[i])["name"]] = i;
+            var idToNode = new System.Collections.Generic.Dictionary<string, AmplifyShaderEditor.ParentNode>();
+            var idToClass = new System.Collections.Generic.Dictionary<string, string>();
+            foreach (Newtonsoft.Json.Linq.JObject primitiveSpec in primitiveSpecs)
+            {
+                string pid = (string)primitiveSpec["id"];
+                string opName = (string)primitiveSpec["op"];
+                System.Type resolved = opName == "const" ? constClass((string)primitiveSpec["value"]) : primitiveClass(opName);
+                var pn = win.CreateNode(resolved,
+                    new UnityEngine.Vector2((float)position[0], (float)position[1]), null, false);
+                if (pn == null || pn.GetType() != resolved)
+                    throw new System.Exception("ASE failed to create recipe primitive: " + pid);
+                if (opName == "const")
+                    writeConst(pn, (string)primitiveSpec["value"]);
+                idToNode[pid] = pn;
+                idToClass[pid] = resolved.Name;
+            }
+            var targets = new System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<System.Tuple<int, int>>>();
+            foreach (Newtonsoft.Json.Linq.JObject primitiveSpec in primitiveSpecs)
+            {
+                string pid = (string)primitiveSpec["id"];
+                var pn = idToNode[pid];
+                var args = (Newtonsoft.Json.Linq.JArray)primitiveSpec["args"];
+                if (args == null) continue;
+                for (int argIndex = 0; argIndex < args.Count; argIndex++)
+                {
+                    string argRef = (string)args[argIndex];
+                    if (inputIndexByName.ContainsKey(argRef))
+                    {
+                        int inputPort = inputIndexByName[argRef];
+                        if (!targets.ContainsKey(inputPort))
+                            targets[inputPort] = new System.Collections.Generic.List<System.Tuple<int, int>>();
+                        targets[inputPort].Add(System.Tuple.Create(pn.UniqueId, argIndex));
+                        continue;
+                    }
+                    int sourceNodeId = idToNode[argRef].UniqueId;
+                    graph.CreateConnection(pn.UniqueId, argIndex, sourceNodeId, 0, false);
+                    if (!pn.GetInputPortByUniqueId(argIndex).IsConnectedTo(sourceNodeId, 0))
+                        throw new System.Exception("ASE rejected recipe primitive connection");
+                }
+            }
+            recipePrimitiveIds[alias] = new System.Collections.Generic.Dictionary<string, int>();
+            recipePrimitiveClasses[alias] = idToClass;
+            foreach (System.Collections.Generic.KeyValuePair<string, AmplifyShaderEditor.ParentNode> kv in idToNode)
+                recipePrimitiveIds[alias][kv.Key] = kv.Value.UniqueId;
+            recipeOutputIds[alias] = idToNode[expansionOutput].UniqueId;
+            recipeInputTargets[alias] = targets;
+            continue;
+        }
+
+        System.Type nodeType = null;
+        if (kind == "sampler") nodeType = typeof(AmplifyShaderEditor.SamplerNode);
+        else if (kind == "custom_expression") nodeType = typeof(AmplifyShaderEditor.CustomExpressionNode);
+        else if (kind == "primitive")
+        {
+            nodeType = primitiveClass((string)nodeSpec["op"]);
+            if (nodeType == null) throw new System.Exception("primitive op escaped closure: " + (string)nodeSpec["op"]);
+        }
+        else
+        {
+            string typeName = (string)nodeSpec["type"];
+            if (typeName == "WorldPosInputsNode") nodeType = typeof(AmplifyShaderEditor.WorldPosInputsNode);
+            else if (typeName == "TextureCoordinatesNode") nodeType = typeof(AmplifyShaderEditor.TextureCoordinatesNode);
+            else if (typeName == "BreakToComponentsNode") nodeType = typeof(AmplifyShaderEditor.BreakToComponentsNode);
+            else if (typeName == "SimpleAddOpNode") nodeType = typeof(AmplifyShaderEditor.SimpleAddOpNode);
+            else if (typeName == "SimpleSubtractOpNode") nodeType = typeof(AmplifyShaderEditor.SimpleSubtractOpNode);
+            else if (typeName == "SimpleMultiplyOpNode") nodeType = typeof(AmplifyShaderEditor.SimpleMultiplyOpNode);
+            else if (typeName == "SimpleDivideOpNode") nodeType = typeof(AmplifyShaderEditor.SimpleDivideOpNode);
+            else if (typeName == "SimpleMinOpNode") nodeType = typeof(AmplifyShaderEditor.SimpleMinOpNode);
+            else if (typeName == "SimpleMaxOpNode") nodeType = typeof(AmplifyShaderEditor.SimpleMaxOpNode);
+            else if (typeName == "SaturateNode") nodeType = typeof(AmplifyShaderEditor.SaturateNode);
+            else if (typeName == "OneMinusNode") nodeType = typeof(AmplifyShaderEditor.OneMinusNode);
+            else if (typeName == "LerpOp") nodeType = typeof(AmplifyShaderEditor.LerpOp);
+            else if (typeName == "TexturePropertyNode") nodeType = typeof(AmplifyShaderEditor.TexturePropertyNode);
+            else if (typeName == "RangedFloatNode") nodeType = typeof(AmplifyShaderEditor.RangedFloatNode);
+            else if (typeName == "Matrix4X4Node") nodeType = typeof(AmplifyShaderEditor.Matrix4X4Node);
+            else if (typeName == "Vector4Node") nodeType = typeof(AmplifyShaderEditor.Vector4Node);
+            else throw new System.Exception("node type escaped allowlist: " + typeName);
+        }

asecli/bridge/resources/editor_create.part02.cs.txt

@@ -0,0 +1,139 @@
+        var created = win.CreateNode(
+            nodeType,
+            new UnityEngine.Vector2((float)position[0], (float)position[1]),
+            null,
+            false);
+        if (created == null || created.GetType() != nodeType)
+            throw new System.Exception("ASE failed to create node: " + alias);
+        aliasIds.Add(alias, created.UniqueId);
+
+        if (kind == "sampler")
+        {
+            var sampler = created as AmplifyShaderEditor.SamplerNode;
+            sampler.CurrentParameterType = (AmplifyShaderEditor.PropertyType)System.Enum.Parse(
+                typeof(AmplifyShaderEditor.PropertyType), (string)nodeSpec["parameter_type"]);
+            sampler.SetPropertyName((string)nodeSpec["property_name"]);
+            sampler.SetInspectorName((string)nodeSpec["inspector_name"]);
+            sampler.AutoRegister = true;
+            sampler.OnPropertyNameChanged();
+        }
+        else if (kind == "property")
+        {
+            var property = created as AmplifyShaderEditor.PropertyNode;
+            if (property == null) throw new System.Exception("property-node cast failed: " + alias);
+            property.CurrentParameterType = (AmplifyShaderEditor.PropertyType)System.Enum.Parse(
+                typeof(AmplifyShaderEditor.PropertyType), (string)nodeSpec["parameter_type"]);
+            property.SetRawPropertyName((string)nodeSpec["property_name"]);
+            propertyInspectorProperty.SetValue(property, (string)nodeSpec["inspector_name"], null);
+            property.AutoRegister = true;
+            property.OnPropertyNameChanged();
+            if (property is AmplifyShaderEditor.RangedFloatNode && nodeSpec["default"] != null)
+            {
+                var ranged = (AmplifyShaderEditor.RangedFloatNode)property;
+                ranged.Value = (float)nodeSpec["default"];
+                if (nodeSpec["min"] != null)
+                {
+                    rangedMinField.SetValue(ranged, (float)nodeSpec["min"]);
+                    rangedMaxField.SetValue(ranged, (float)nodeSpec["max"]);
+                    ranged.SetFloatMode(false);
+                }
+            }
+            else if (property is AmplifyShaderEditor.Vector4Node && nodeSpec["default"] != null)
+            {
+                var vector = (AmplifyShaderEditor.Vector4Node)property;
+                var values = (Newtonsoft.Json.Linq.JArray)nodeSpec["default"];
+                vector.Value = new UnityEngine.Vector4((float)values[0], (float)values[1], (float)values[2], (float)values[3]);
+            }
+        }
+        else if (kind == "custom_expression")
+        {
+            var expression = created as AmplifyShaderEditor.CustomExpressionNode;
+            string expressionCode = (string)nodeSpec["code"];
+            var inputSpecs = (Newtonsoft.Json.Linq.JArray)nodeSpec["inputs"];
+            var items = new System.Collections.Generic.List<AmplifyShaderEditor.CustomExpressionInputItem>();
+            for (int inputIndex = 0; inputIndex < inputSpecs.Count; inputIndex++)
+            {
+                var inputSpec = (Newtonsoft.Json.Linq.JObject)inputSpecs[inputIndex];
+                string inputName = (string)inputSpec["name"];
+                var inputType = (AmplifyShaderEditor.WirePortDataType)System.Enum.Parse(
+                    typeof(AmplifyShaderEditor.WirePortDataType), (string)inputSpec["type"]);
+                var item = new AmplifyShaderEditor.CustomExpressionInputItem(
+                    AmplifyShaderEditor.PrecisionType.Inherit,
+                    AmplifyShaderEditor.VariableQualifiers.In,
+                    string.Empty,
+                    false,
+                    true,
+                    string.Empty);
+                item.Type = inputType;
+                items.Add(item);
+                if (inputIndex == 0)
+                    expression.InputPorts[0].ChangeProperties(inputName, inputType, false);
+                else
+                    expression.AddInputPort(inputType, false, inputName);
+            }
+            string outputTypeName = (string)nodeSpec["output_type"];
+            var outputType = (AmplifyShaderEditor.WirePortDataType)System.Enum.Parse(
+                typeof(AmplifyShaderEditor.WirePortDataType), outputTypeName);
+            int outputTypeIndex = outputTypeName == "INT" ? 0 :
+                outputTypeName == "FLOAT" ? 1 :
+                outputTypeName == "FLOAT2" ? 2 :
+                outputTypeName == "FLOAT3" ? 3 :
+                outputTypeName == "FLOAT4" ? 4 :
+                outputTypeName == "FLOAT3x3" ? 5 : 6;
+            expression.OutputPorts[0].ChangeType(outputType, false);
+            expressionNameField.SetValue(expression, (string)nodeSpec["name"]);
+            expressionItemsField.SetValue(expression, items);
+            expressionCodeField.SetValue(expression, expressionCode);
+            expressionOutputField.SetValue(expression, outputTypeIndex);
+            expressionFunctionField.SetValue(expression, expressionCode.Contains("return"));
+        }
+        if (nodeSpec["precision"] != null)
+            precisionField.SetValue(created,
+                (AmplifyShaderEditor.PrecisionType)System.Enum.Parse(
+                    typeof(AmplifyShaderEditor.PrecisionType), (string)nodeSpec["precision"]));
+    }
+
+    foreach (Newtonsoft.Json.Linq.JObject connectionSpec in connections)
+    {
+        var sourceSpec = (Newtonsoft.Json.Linq.JObject)connectionSpec["from"];
+        var destinationSpec = (Newtonsoft.Json.Linq.JObject)connectionSpec["to"];
+        string sourceAlias = (string)sourceSpec["node"];
+        string destinationAlias = (string)destinationSpec["node"];
+        int sourcePortId = (int)sourceSpec["port"];
+        int destinationPortId = (int)destinationSpec["port"];
+        int sourceNodeId = recipeOutputIds.ContainsKey(sourceAlias) ? recipeOutputIds[sourceAlias] : aliasIds[sourceAlias];
+        int sourceOutPort = recipeOutputIds.ContainsKey(sourceAlias) ? 0 : sourcePortId;
+        var sourceNode = graph.GetNode(sourceNodeId);
+        if (sourceNode == null || sourceNode.GetOutputPortByUniqueId(sourceOutPort) == null)
+            throw new System.Exception("connection source endpoint not found");
+
+        if (destinationAlias == "master")
+        {
+            graph.CreateConnection(masterId, destinationPortId, sourceNodeId, sourceOutPort, false);
+            if (!graph.CurrentMasterNode.GetInputPortByUniqueId(destinationPortId).IsConnectedTo(sourceNodeId, sourceOutPort))
+                throw new System.Exception("ASE rejected connection");
+        }
+        else if (recipeInputTargets.ContainsKey(destinationAlias))
+        {
+            var targets = recipeInputTargets[destinationAlias];
+            if (!targets.ContainsKey(destinationPortId) || targets[destinationPortId].Count == 0)
+                throw new System.Exception("recipe input port has no consumer");
+            foreach (System.Tuple<int, int> target in targets[destinationPortId])
+            {
+                graph.CreateConnection(target.Item1, target.Item2, sourceNodeId, sourceOutPort, false);
+                if (!graph.GetNode(target.Item1).GetInputPortByUniqueId(target.Item2).IsConnectedTo(sourceNodeId, sourceOutPort))
+                    throw new System.Exception("ASE rejected recipe input connection");
+            }
+        }
+        else
+        {
+            int destinationNodeId = aliasIds[destinationAlias];
+            var destinationNode = graph.GetNode(destinationNodeId);
+            if (destinationNode == null ||
+                destinationNode.GetInputPortByUniqueId(destinationPortId) == null)
+                throw new System.Exception("connection destination endpoint not found");
+            graph.CreateConnection(destinationNodeId, destinationPortId, sourceNodeId, sourceOutPort, false);
+            if (!destinationNode.GetInputPortByUniqueId(destinationPortId).IsConnectedTo(sourceNodeId, sourceOutPort))
+                throw new System.Exception("ASE rejected connection");
+        }
+    }

asecli/bridge/resources/editor_create.part03.cs.txt

@@ -0,0 +1,161 @@
+    bool saved = win.SaveToDisk(false);
+    if (!saved) throw new System.Exception("ASE SaveToDisk returned false");
+    var loadResult = win.LoadFromDisk(temporaryAssetPath, null);
+    bool reloaded = loadResult == AmplifyShaderEditor.ShaderLoadResult.LOADED ||
+        loadResult == AmplifyShaderEditor.ShaderLoadResult.TEMPLATE_LOADED;
+    if (!reloaded) throw new System.Exception("ASE temporary LoadFromDisk failed: " + loadResult);
+
+    graph = win.CurrentGraph;
+    var reloadedMaster = graph.CurrentMasterNode as AmplifyShaderEditor.TemplateMultiPassMasterNode;
+    var reloadedShader = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.Shader>(temporaryAssetPath);
+    if (reloadedMaster == null || reloadedMaster.CurrentTemplate == null || reloadedShader == null ||
+        reloadedMaster.CurrentTemplate.GUID != templateGuid ||
+        reloadedMaster.ShaderName != shaderName || reloadedShader.name != shaderName)
+        throw new System.Exception("template or shader identity changed after temporary reload");
+    var manifestNodes = new Newtonsoft.Json.Linq.JArray();
+    foreach (Newtonsoft.Json.Linq.JObject nodeSpec in nodes)
+    {
+        string alias = (string)nodeSpec["alias"];
+        string kind = (string)nodeSpec["kind"];
+        var manifestNode = new Newtonsoft.Json.Linq.JObject();
+        manifestNode["alias"] = alias;
+        manifestNode["kind"] = kind;
+
+        if (kind == "recipe" && recipePrimitiveIds.ContainsKey(alias))
+        {
+            manifestNode["type"] = "Recipe";
+            manifestNode["recipe"] = (string)nodeSpec["recipe"];
+            manifestNode["output_type"] = (string)nodeSpec["output_type"];
+            var manifestExpansion = new Newtonsoft.Json.Linq.JArray();
+            var expectedPrimitives = (Newtonsoft.Json.Linq.JArray)((Newtonsoft.Json.Linq.JObject)nodeSpec["expansion"])["primitives"];
+            foreach (Newtonsoft.Json.Linq.JObject primitiveSpec in expectedPrimitives)
+            {
+                string pid = (string)primitiveSpec["id"];
+                var pn = graph.GetNode(recipePrimitiveIds[alias][pid]);
+                if (pn == null)
+                    throw new System.Exception("recipe primitive missing after reload: " + pid);
+                if (pn.GetType().Name != recipePrimitiveClasses[alias][pid])
+                    throw new System.Exception("recipe primitive type changed after reload: " + pid);
+                var manifestPrimitive = new Newtonsoft.Json.Linq.JObject();
+                manifestPrimitive["id"] = pid;
+                manifestPrimitive["type"] = pn.GetType().Name;
+                manifestExpansion.Add(manifestPrimitive);
+            }
+            manifestNode["expansion_nodes"] = manifestExpansion;
+            manifestNodes.Add(manifestNode);
+            continue;
+        }
+
+        var actualNode = graph.GetNode(aliasIds[alias]);
+        if (actualNode == null) throw new System.Exception("node missing after reload: " + alias);
+        string expectedType = kind == "sampler" ? "SamplerNode" :
+            kind == "custom_expression" ? "CustomExpressionNode" :
+            kind == "primitive" ? primitiveClass((string)nodeSpec["op"]).Name :
+            kind == "recipe" ? "CustomExpressionNode" :
+            (string)nodeSpec["type"];
+        if (actualNode.GetType().Name != expectedType)
+            throw new System.Exception("node type changed after reload: " + alias);
+        manifestNode["type"] = actualNode.GetType().Name;
+        if (kind == "sampler" || kind == "property")
+        {
+            var property = actualNode as AmplifyShaderEditor.PropertyNode;
+            if (property.PropertyName != (string)nodeSpec["property_name"] ||
+                property.PropertyInspectorName != (string)nodeSpec["inspector_name"] ||
+                property.CurrentParameterType.ToString() != (string)nodeSpec["parameter_type"])
+                throw new System.Exception("property changed after reload: " + alias);
+            manifestNode["property_name"] = property.PropertyName;
+            manifestNode["inspector_name"] = property.PropertyInspectorName;
+            manifestNode["parameter_type"] = property.CurrentParameterType.ToString();
+        }
+        else if (kind == "custom_expression" || kind == "recipe")
+        {
+            var expression = actualNode as AmplifyShaderEditor.CustomExpressionNode;
+            string actualName = (string)expressionNameField.GetValue(expression);
+            string actualCode = (string)expressionCodeField.GetValue(expression);
+            string actualOutputType = expression.OutputPorts[0].DataType.ToString();
+            if (actualName != (string)nodeSpec[(kind == "recipe") ? "recipe" : "name"] ||
+                actualCode != (string)nodeSpec["code"] || actualOutputType != (string)nodeSpec["output_type"])
+                throw new System.Exception("custom expression changed after reload: " + alias);
+            manifestNode["name"] = actualName;
+            manifestNode["code"] = actualCode;
+            manifestNode["output_type"] = actualOutputType;
+            var manifestInputs = new Newtonsoft.Json.Linq.JArray();
+            var expectedInputs = (Newtonsoft.Json.Linq.JArray)nodeSpec["inputs"];
+            if (expression.InputPorts.Count != expectedInputs.Count)
+                throw new System.Exception("custom expression input count changed after reload: " + alias);
+            for (int inputIndex = 0; inputIndex < expectedInputs.Count; inputIndex++)
+            {
+                var expectedInput = (Newtonsoft.Json.Linq.JObject)expectedInputs[inputIndex];
+                var actualInput = expression.InputPorts[inputIndex];
+                if (actualInput.Name != (string)expectedInput["name"] ||
+                    actualInput.DataType.ToString() != (string)expectedInput["type"])
+                    throw new System.Exception("custom expression input changed after reload: " + alias);
+                var manifestInput = new Newtonsoft.Json.Linq.JObject();
+                manifestInput["name"] = actualInput.Name;
+                manifestInput["type"] = actualInput.DataType.ToString();
+                manifestInputs.Add(manifestInput);
+            }
+            manifestNode["inputs"] = manifestInputs;
+        }
+        else if (kind == "primitive")
+        {
+            manifestNode["op"] = (string)nodeSpec["op"];
+        }
+        if (nodeSpec["precision"] != null)
+            manifestNode["precision"] = ((AmplifyShaderEditor.PrecisionType)
+                precisionField.GetValue(actualNode)).ToString();
+        if (nodeSpec["default"] != null)
+        {
+            if (actualNode is AmplifyShaderEditor.RangedFloatNode)
+                manifestNode["default"] = ((AmplifyShaderEditor.RangedFloatNode)actualNode).Value;
+            else if (actualNode is AmplifyShaderEditor.Vector4Node)
+            {
+                var vector = ((AmplifyShaderEditor.Vector4Node)actualNode).Value;
+                manifestNode["default"] = new Newtonsoft.Json.Linq.JArray(vector.x, vector.y, vector.z, vector.w);
+            }
+        }
+        if (nodeSpec["min"] != null)
+        {
+            manifestNode["min"] = (float)rangedMinField.GetValue(actualNode);
+            manifestNode["max"] = (float)rangedMaxField.GetValue(actualNode);
+        }
+        manifestNodes.Add(manifestNode);
+    }
+
+    var manifestConnections = new Newtonsoft.Json.Linq.JArray();
+    foreach (Newtonsoft.Json.Linq.JObject connectionSpec in connections)
+    {
+        var sourceSpec = (Newtonsoft.Json.Linq.JObject)connectionSpec["from"];
+        var destinationSpec = (Newtonsoft.Json.Linq.JObject)connectionSpec["to"];
+        string sourceAlias = (string)sourceSpec["node"];
+        string destinationAlias = (string)destinationSpec["node"];
+        int sourcePortId = (int)sourceSpec["port"];
+        int destinationPortId = (int)destinationSpec["port"];
+        int sourceNodeId = recipeOutputIds.ContainsKey(sourceAlias) ? recipeOutputIds[sourceAlias] : aliasIds[sourceAlias];
+        int sourceOutPort = recipeOutputIds.ContainsKey(sourceAlias) ? 0 : sourcePortId;
+
+        if (destinationAlias == "master")
+        {
+            if (!graph.CurrentMasterNode.GetInputPortByUniqueId(destinationPortId).IsConnectedTo(sourceNodeId, sourceOutPort))
+                throw new System.Exception("connection missing after reload");
+        }
+        else if (recipeInputTargets.ContainsKey(destinationAlias))
+        {
+            var targets = recipeInputTargets[destinationAlias];
+            if (!targets.ContainsKey(destinationPortId) || targets[destinationPortId].Count == 0)
+                throw new System.Exception("recipe input port has no consumer after reload");
+            foreach (System.Tuple<int, int> target in targets[destinationPortId])
+            {
+                if (!graph.GetNode(target.Item1).GetInputPortByUniqueId(target.Item2).IsConnectedTo(sourceNodeId, sourceOutPort))
+                    throw new System.Exception("recipe input connection missing after reload");
+            }
+        }
+        else
+        {
+            int destinationNodeId = aliasIds[destinationAlias];
+            var destinationPort = graph.GetNode(destinationNodeId).GetInputPortByUniqueId(destinationPortId);
+            if (destinationPort == null || !destinationPort.IsConnectedTo(sourceNodeId, sourceOutPort))
+                throw new System.Exception("connection missing after reload");
+        }
+        manifestConnections.Add(connectionSpec.DeepClone());
+    }