@alpsckr/unitycli 0.4.0

package/unitypkg/Editor/Tools/physics/PhysicsToolSupport.cs

@@ -0,0 +1,389 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// physics 域 IUnityCliTool 共享的基础设施 helper:物理设置构造、刚体信息、
+    /// 射线查询、碰撞解析、模式规范化。仅供 physics 域自包含工具复用;
+    /// 不实现 IUnityCliTool,不参与工具发现。
+    /// </summary>
+    public static class PhysicsToolSupport
+    {
+        /// <summary>拦截编译/导入/构建/PlayMode 过渡期的写入请求。</summary>
+        public static void EnsureEditorNotBusy(string command)
+        {
+            SceneToolSupport.EnsureEditorNotBusy(command);
+        }
+
+        /// <summary>规范化 2d/3d 模式字符串;空或非 2d 返回 3d。</summary>
+        public static string NormalizeMode(string mode)
+        {
+            return string.Equals(mode, "2d", StringComparison.OrdinalIgnoreCase) ? "2d" : "3d";
+        }
+
+        /// <summary>规范化 Vector2;零向量回退 right。</summary>
+        public static Vector2 NormalizeVector2(Vector2 value)
+        {
+            return value.sqrMagnitude <= 0f ? Vector2.right : value.normalized;
+        }
+
+        /// <summary>规范化 Vector3;零向量回退 forward。</summary>
+        public static Vector3 NormalizeVector3(Vector3 value)
+        {
+            return value.sqrMagnitude <= 0f ? Vector3.forward : value.normalized;
+        }
+
+        /// <summary>解析 ForceMode 枚举;空返回 Force。</summary>
+        public static ForceMode ParseForceMode(string value)
+        {
+            if (string.IsNullOrEmpty(value)) return ForceMode.Force;
+            return (ForceMode)Enum.Parse(typeof(ForceMode), value, true);
+        }
+
+        /// <summary>解析 CapsuleDirection2D;horizontal/0 返回 Horizontal,否则 Vertical。</summary>
+        public static CapsuleDirection2D ParseCapsuleDirection2D(string value, int? numeric)
+        {
+            if (numeric.HasValue && numeric.Value == 0) return CapsuleDirection2D.Horizontal;
+            if (string.Equals(value, "horizontal", StringComparison.OrdinalIgnoreCase) || value == "0") return CapsuleDirection2D.Horizontal;
+            return CapsuleDirection2D.Vertical;
+        }
+
+        /// <summary>构造 PhysicsSettings DTO(3d+2d 合并视图)。</summary>
+        public static PhysicsSettingsInfo BuildPhysicsSettings()
+        {
+            return new PhysicsSettingsInfo
+            {
+                Mode = "3d+2d",
+                Gravity = new Vector3Data(Physics.gravity),
+                Gravity2d = new Vector2Data(Physics2D.gravity),
+                DefaultContactOffset = Physics.defaultContactOffset,
+                BounceThreshold = Physics.bounceThreshold,
+                DefaultSolverIterations = Physics.defaultSolverIterations,
+                DefaultSolverVelocityIterations = Physics.defaultSolverVelocityIterations,
+                QueriesHitTriggers = Physics.queriesHitTriggers,
+                QueriesHitBackfaces = Physics.queriesHitBackfaces,
+                QueriesStartInColliders = Physics2D.queriesStartInColliders,
+                AutoSimulation = IsAutoSimulation3D(),
+                SimulationMode2D = Physics2D.simulationMode.ToString()
+            };
+        }
+
+        /// <summary>按 Unity 2022.3 SimulationMode 读取旧 autoSimulation 的等价语义。</summary>
+        public static bool IsAutoSimulation3D()
+        {
+            return Physics.simulationMode != SimulationMode.Script;
+        }
+
+        /// <summary>设置 3D 物理自动/脚本模拟模式；自动模式固定恢复为 FixedUpdate。</summary>
+        public static void SetAutoSimulation3D(bool enabled)
+        {
+            Physics.simulationMode = enabled ? SimulationMode.FixedUpdate : SimulationMode.Script;
+        }
+
+        /// <summary>构造 Rigidbody 摘要 DTO。</summary>
+        public static RigidbodyInfo BuildRigidbodyInfo(Rigidbody rb)
+        {
+            return new RigidbodyInfo
+            {
+                Mass = rb.mass,
+                Drag = rb.drag,
+                AngularDrag = rb.angularDrag,
+                UseGravity = rb.useGravity,
+                IsKinematic = rb.isKinematic,
+                Velocity = new Vector3Data(rb.velocity),
+                AngularVelocity = new Vector3Data(rb.angularVelocity),
+                CenterOfMass = new Vector3Data(rb.centerOfMass),
+                CollisionDetectionMode = rb.collisionDetectionMode.ToString(),
+                Interpolation = rb.interpolation.ToString(),
+                Constraints = rb.constraints.ToString(),
+                Sleeping = rb.IsSleeping()
+            };
+        }
+
+        /// <summary>构造 Rigidbody2D 摘要 DTO。</summary>
+        public static Rigidbody2DInfo BuildRigidbody2DInfo(Rigidbody2D rb)
+        {
+            return new Rigidbody2DInfo
+            {
+                Mass = rb.mass,
+                Drag = rb.drag,
+                AngularDrag = rb.angularDrag,
+                GravityScale = rb.gravityScale,
+                BodyType = rb.bodyType.ToString(),
+                Velocity = new Vector2Data(rb.velocity),
+                AngularVelocity = rb.angularVelocity,
+                CollisionDetectionMode = rb.collisionDetectionMode.ToString(),
+                Interpolation = rb.interpolation.ToString(),
+                Constraints = rb.constraints.ToString(),
+                Sleeping = rb.IsSleeping()
+            };
+        }
+
+        /// <summary>构造 Collider 引用 DTO。</summary>
+        public static ColliderRef BuildColliderRef(GameObject gameObject, string colliderType)
+        {
+            if (gameObject == null) return null;
+            return new ColliderRef
+            {
+                Id = gameObject.GetInstanceID(),
+                Name = gameObject.name,
+                Path = GameObjectToolSupport.HierarchyPath(gameObject),
+                Type = colliderType
+            };
+        }
+
+        /// <summary>构造 3D 射线命中 DTO。</summary>
+        public static RaycastHitInfo BuildRaycast3DHit(RaycastHit hit)
+        {
+            var gameObject = hit.collider != null ? hit.collider.gameObject : null;
+            return new RaycastHitInfo
+            {
+                Distance = hit.distance,
+                Point = new Vector3Data(hit.point),
+                Normal = new Vector3Data(hit.normal),
+                Collider = BuildColliderRef(gameObject, hit.collider == null ? null : hit.collider.GetType().Name)
+            };
+        }
+
+        /// <summary>构造 2D 射线命中 DTO。</summary>
+        public static RaycastHitInfo BuildRaycast2DHit(RaycastHit2D hit)
+        {
+            var gameObject = hit.collider != null ? hit.collider.gameObject : null;
+            return new RaycastHitInfo
+            {
+                Distance = hit.distance,
+                Point = new Vector3Data(new Vector3(hit.point.x, hit.point.y, 0)),
+                Normal = new Vector3Data(new Vector3(hit.normal.x, hit.normal.y, 0)),
+                Collider = BuildColliderRef(gameObject, hit.collider == null ? null : hit.collider.GetType().Name)
+            };
+        }
+
+        /// <summary>构造射线查询参数 DTO(3D)。</summary>
+        public static RaycastQuery BuildRaycast3DQuery(Vector3 origin, Vector3 direction, float distance, int layerMask)
+        {
+            return new RaycastQuery
+            {
+                Origin = new Vector3Data(origin),
+                Direction = new Vector3Data(direction),
+                Distance = distance,
+                LayerMask = layerMask
+            };
+        }
+
+        /// <summary>构造射线查询参数 DTO(2D)。</summary>
+        public static RaycastQuery BuildRaycast2DQuery(Vector2 origin, Vector2 direction, float distance, int layerMask)
+        {
+            return new RaycastQuery
+            {
+                Origin = new Vector3Data(new Vector3(origin.x, origin.y, 0)),
+                Direction = new Vector3Data(new Vector3(direction.x, direction.y, 0)),
+                Distance = distance,
+                LayerMask = layerMask
+            };
+        }
+
+        /// <summary>解析 Layer 名称或数字为 layer index。</summary>
+        public static int ParseLayer(string value)
+        {
+            return GameObjectToolSupport.ParseLayer(value);
+        }
+
+        /// <summary>在 GameObject 上按类型名+可选索引解析 Collider。</summary>
+        public static Collider ResolveCollider(GameObject target, string colliderType, int colliderIndex)
+        {
+            var colliders = target.GetComponents<Collider>();
+            if (!string.IsNullOrEmpty(colliderType))
+            {
+                var filtered = new List<Collider>();
+                foreach (var c in colliders)
+                {
+                    if (string.Equals(c.GetType().Name, colliderType, StringComparison.OrdinalIgnoreCase) || string.Equals(c.GetType().FullName, colliderType, StringComparison.OrdinalIgnoreCase))
+                        filtered.Add(c);
+                }
+                colliders = filtered.ToArray();
+            }
+            if (colliders.Length == 0)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_COLLIDER_NOT_FOUND", "No 3D Collider found on target: " + target.name, "Add a Collider component before assigning a PhysicMaterial.");
+            }
+            if (colliderIndex < 0 || colliderIndex >= colliders.Length)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_COLLIDER_INDEX_INVALID", "colliderIndex is outside the matching Collider component range.", "Use a colliderIndex from 0 to " + (colliders.Length - 1).ToString(CultureInfo.InvariantCulture) + ".");
+            }
+            return colliders[colliderIndex];
+        }
+
+        /// <summary>解析 ReflectionProbe(供 graphics 域复用)。</summary>
+        public static ReflectionProbe ResolveReflectionProbe(string target)
+        {
+            var probes = UnityEngine.Object.FindObjectsOfType<ReflectionProbe>();
+            if (string.IsNullOrEmpty(target)) return probes.Length > 0 ? probes[0] : null;
+            foreach (var probe in probes)
+            {
+                if (GameObjectToolSupport.HierarchyPath(probe.gameObject) == target || probe.gameObject.name == target || probe.GetInstanceID().ToString(CultureInfo.InvariantCulture) == target)
+                    return probe;
+            }
+            return null;
+        }
+    }
+
+    // ── physics 域 DTO ──
+
+    public sealed class PhysicsSettingsInfo
+    {
+        public string Mode { get; set; }
+        public Vector3Data Gravity { get; set; }
+        public Vector2Data Gravity2d { get; set; }
+        public double DefaultContactOffset { get; set; }
+        public double BounceThreshold { get; set; }
+        public long DefaultSolverIterations { get; set; }
+        public long DefaultSolverVelocityIterations { get; set; }
+        public bool QueriesHitTriggers { get; set; }
+        public bool QueriesHitBackfaces { get; set; }
+        public bool QueriesStartInColliders { get; set; }
+        public bool AutoSimulation { get; set; }
+        public string SimulationMode2D { get; set; }
+    }
+
+    public sealed class RigidbodyInfo
+    {
+        public double Mass { get; set; }
+        public double Drag { get; set; }
+        public double AngularDrag { get; set; }
+        public bool UseGravity { get; set; }
+        public bool IsKinematic { get; set; }
+        public Vector3Data Velocity { get; set; }
+        public Vector3Data AngularVelocity { get; set; }
+        public Vector3Data CenterOfMass { get; set; }
+        public string CollisionDetectionMode { get; set; }
+        public string Interpolation { get; set; }
+        public string Constraints { get; set; }
+        public bool Sleeping { get; set; }
+    }
+
+    public sealed class Rigidbody2DInfo
+    {
+        public double Mass { get; set; }
+        public double Drag { get; set; }
+        public double AngularDrag { get; set; }
+        public double GravityScale { get; set; }
+        public string BodyType { get; set; }
+        public Vector2Data Velocity { get; set; }
+        public double AngularVelocity { get; set; }
+        public string CollisionDetectionMode { get; set; }
+        public string Interpolation { get; set; }
+        public string Constraints { get; set; }
+        public bool Sleeping { get; set; }
+    }
+
+    public sealed class Vector2Data
+    {
+        public Vector2Data() { }
+        public Vector2Data(Vector2 v) { X = v.x; Y = v.y; }
+        public double X { get; set; }
+        public double Y { get; set; }
+    }
+
+    public sealed class ColliderRef
+    {
+        public long Id { get; set; }
+        public string Name { get; set; }
+        public string Path { get; set; }
+        public string Type { get; set; }
+    }
+
+    public sealed class RaycastHitInfo
+    {
+        public double Distance { get; set; }
+        public Vector3Data Point { get; set; }
+        public Vector3Data Normal { get; set; }
+        public ColliderRef Collider { get; set; }
+    }
+
+    public sealed class RaycastQuery
+    {
+        public Vector3Data Origin { get; set; }
+        public Vector3Data Direction { get; set; }
+        public double Distance { get; set; }
+        public long LayerMask { get; set; }
+    }
+
+    public sealed class CollisionLayerEntry
+    {
+        public long Index { get; set; }
+        public string Name { get; set; }
+    }
+
+    public sealed class CollisionMatrixRow
+    {
+        public long Layer { get; set; }
+        public string Name { get; set; }
+        public List<CollisionMatrixPair> Pairs { get; set; }
+    }
+
+    public sealed class CollisionMatrixPair
+    {
+        public long Layer { get; set; }
+        public string Name { get; set; }
+        public bool Ignored { get; set; }
+    }
+
+    public sealed class CollisionPairInfo
+    {
+        public long LayerA { get; set; }
+        public long LayerB { get; set; }
+        public bool Ignored { get; set; }
+    }
+
+    public sealed class PhysicMaterialInfo
+    {
+        public string Path { get; set; }
+        public string Name { get; set; }
+        public double DynamicFriction { get; set; }
+        public double StaticFriction { get; set; }
+        public double Bounciness { get; set; }
+    }
+
+    public sealed class PhysicMaterialRef
+    {
+        public string Name { get; set; }
+        public string Path { get; set; }
+    }
+
+    public sealed class ColliderAssignmentInfo
+    {
+        public string Type { get; set; }
+        public long InstanceId { get; set; }
+        public PhysicMaterialRef PreviousMaterial { get; set; }
+        public PhysicMaterialRef Material { get; set; }
+    }
+
+    public sealed class PhysicsPlannedEffect
+    {
+        public string Type { get; set; }
+        public string Property { get; set; }
+        public string Value { get; set; }
+        public string Target { get; set; }
+    }
+
+    public sealed class GameObjectTargetRef
+    {
+        public long Id { get; set; }
+        public string Name { get; set; }
+        public string Path { get; set; }
+    }
+
+    public sealed class SimulationInfo
+    {
+        public bool Simulate { get; set; }
+        public long Steps { get; set; }
+        public double DeltaTime { get; set; }
+        public double FixedDeltaTime { get; set; }
+        public bool AutoSimulation { get; set; }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/physics/assign-material.cs

@@ -0,0 +1,88 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// physics.assign-material — 将 PhysicMaterial 资产分配到 GameObject 的 Collider。
+    /// </summary>
+    public class PhysicsAssignMaterialTool : IUnityCliTool<PhysicsAssignMaterialTool.Request, PhysicsAssignMaterialTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Target { get; set; }
+            public string MaterialPath { get; set; }
+            public string Path { get; set; }
+            public string Collider { get; set; }
+            public int ColliderIndex { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public ColliderAssignmentInfo Collider { get; set; }
+            public bool DryRun { get; set; }
+            public List<PhysicsPlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "physics.assign-material",
+            Summary = "Assign a PhysicMaterial asset to a Collider on a target GameObject, with dry-run support.",
+            Description = "Resolve a target GameObject, load a PhysicMaterial asset, and assign it to the matching Collider. Supports collider type filter and index. dryRun=true previews without mutating.",
+            Group = "physics",DestructiveHint = false, SupportsDryRun = true, SideEffects = new[] { "scene-modify" },
+            Target = "editor", PlayModeSupport = "supported",
+            DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000,
+            Examples = new[] { new ToolExample { Description = "Assign bouncy material", Input = new Request { Target = "Player", MaterialPath = "Assets/Physics/Bouncy.physicMaterial" } } }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var target = GameObjectToolSupport.ResolveUniqueTarget(request.Target, "physics.assign-material requires --target.");
+            var path = SceneToolSupport.NormalizeAssetPath(request.MaterialPath ?? request.Path);
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_PHYSICS_MATERIAL_PATH_REQUIRED", "physics.assign-material requires a PhysicMaterial asset path.", "Pass materialPath like Assets/Physics/Bouncy.physicMaterial.");
+            }
+            var material = AssetDatabase.LoadAssetAtPath<PhysicMaterial>(path);
+            if (material == null)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_PHYSICS_MATERIAL_NOT_FOUND", "PhysicMaterial asset not found: " + path, "Create it with physics.material first, then rerun physics.assign-material.");
+            }
+            var collider = PhysicsToolSupport.ResolveCollider(target, request.Collider, request.ColliderIndex);
+            var targetId = target.GetInstanceID();
+            var colliderId = collider.GetInstanceID();
+            var previous = collider.sharedMaterial;
+            var dryRun = ctx.DryRun;
+            if (!dryRun)
+            {
+                ctx.CommitEffect();
+                UnityCliSceneMutation.RecordObject(collider, "Assign PhysicMaterial");
+                collider.sharedMaterial = material;
+                UnityCliSceneMutation.MarkSceneObjectDirty(collider);
+                UnityCliSceneMutation.MarkSceneDirty(target.scene);
+            }
+            // mutation 后同时重解析目标与组件，禁止使用写前 Collider 引用作为 proof。
+            var observedTarget = dryRun ? target : EditorUtility.InstanceIDToObject(targetId) as GameObject;
+            var observedCollider = dryRun ? collider : EditorUtility.InstanceIDToObject(colliderId) as Collider;
+            var observedMaterial = observedCollider == null ? null : observedCollider.sharedMaterial;
+            if (observedTarget == null || observedCollider == null || (!dryRun && observedMaterial != material))
+                throw new UnityCliBridge.BridgeCommandException("E_PHYSICS_ASSIGN_MATERIAL_STATE_MISMATCH", "Collider material did not match the requested PhysicMaterial.", "Inspect the Collider material after the Editor is idle and retry.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                Collider = new ColliderAssignmentInfo
+                {
+                    Type = observedCollider.GetType().Name,
+                    InstanceId = observedCollider.GetInstanceID(),
+                    PreviousMaterial = previous == null ? null : new PhysicMaterialRef { Name = previous.name, Path = AssetDatabase.GetAssetPath(previous) },
+                    Material = observedMaterial == null ? null : new PhysicMaterialRef { Name = observedMaterial.name, Path = AssetDatabase.GetAssetPath(observedMaterial) }
+                },
+                DryRun = dryRun,
+                PlannedEffects = new List<PhysicsPlannedEffect> { new PhysicsPlannedEffect { Type = "physics.assign-material", Target = GameObjectToolSupport.HierarchyPath(observedTarget) } }
+            });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/physics/collision-matrix.cs

@@ -0,0 +1,90 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// physics.collision-matrix — 读取/写入 Unity 层碰撞矩阵(32 层)。
+    /// </summary>
+    public class PhysicsCollisionMatrixTool : IUnityCliTool<PhysicsCollisionMatrixTool.Request, PhysicsCollisionMatrixTool.Result>
+    {
+        public sealed class Request
+        {
+            public string LayerA { get; set; }
+            public string LayerB { get; set; }
+            public bool? Ignore { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public string Mode { get; set; }
+            public long LayerCount { get; set; }
+            public List<CollisionLayerEntry> Layers { get; set; }
+            public List<CollisionMatrixRow> Matrix { get; set; }
+            public CollisionPairInfo Collision { get; set; }
+            public List<PhysicsPlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "physics.collision-matrix",
+            Summary = "Read or update the Unity 32-layer physics collision matrix, optionally ignoring a single layer pair.",
+            Description = "Read the full 32-layer collision matrix by default. Pass layerA and layerB with ignore=true/false to update a single pair. Layer names or numeric indexes are accepted.",
+            Group = "physics",DestructiveHint = true, SideEffects = new[] { "settings-write" },
+            Target = "editor", PlayModeSupport = "supported",
+            DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000,
+            Examples = new[] { new ToolExample { Description = "Read full collision matrix", Input = new Request { } } }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            // 单层对读写模式
+            if (!string.IsNullOrEmpty(request.LayerA) || !string.IsNullOrEmpty(request.LayerB))
+            {
+                if (string.IsNullOrEmpty(request.LayerA) || string.IsNullOrEmpty(request.LayerB))
+                {
+                    throw new UnityCliBridge.BridgeCommandException("E_PHYSICS_COLLISION_PAIR_REQUIRED", "Reading or writing a single collision pair requires both layerA and layerB.", "Pass both layerA and layerB, or omit both to read the full 32-layer matrix.");
+                }
+                var layerA = PhysicsToolSupport.ParseLayer(request.LayerA);
+                var layerB = PhysicsToolSupport.ParseLayer(request.LayerB);
+                if (request.Ignore.HasValue)
+                {
+                    ctx.CommitEffect();
+                    Physics.IgnoreLayerCollision(layerA, layerB, request.Ignore.Value);
+                    if (Physics.GetIgnoreLayerCollision(layerA, layerB) != request.Ignore.Value)
+                        throw new UnityCliBridge.BridgeCommandException("E_PHYSICS_COLLISION_MATRIX_STATE_MISMATCH", "Collision matrix did not match the requested ignore state.", "Inspect Project Settings > Physics and retry after the Editor is idle.");
+                }
+                var effects = new List<PhysicsPlannedEffect>();
+                if (request.Ignore.HasValue)
+                    effects.Add(new PhysicsPlannedEffect { Type = "physics.collision-matrix", Property = "ignore", Value = request.Ignore.Value.ToString().ToLowerInvariant() });
+                return new System.Threading.Tasks.ValueTask<Result>(new Result
+                {
+                    Collision = new CollisionPairInfo { LayerA = layerA, LayerB = layerB, Ignored = Physics.GetIgnoreLayerCollision(layerA, layerB) },
+                    PlannedEffects = effects
+                });
+            }
+            // 全量矩阵读取
+            var layers = new List<CollisionLayerEntry>();
+            for (var i = 0; i < 32; i++)
+                layers.Add(new CollisionLayerEntry { Index = i, Name = LayerMask.LayerToName(i) });
+            var matrix = new List<CollisionMatrixRow>();
+            for (var a = 0; a < 32; a++)
+            {
+                var pairs = new List<CollisionMatrixPair>();
+                for (var b = 0; b < 32; b++)
+                    pairs.Add(new CollisionMatrixPair { Layer = b, Name = LayerMask.LayerToName(b), Ignored = Physics.GetIgnoreLayerCollision(a, b) });
+                matrix.Add(new CollisionMatrixRow { Layer = a, Name = LayerMask.LayerToName(a), Pairs = pairs });
+            }
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                Mode = "3d",
+                LayerCount = 32,
+                Layers = layers,
+                Matrix = matrix,
+                PlannedEffects = new List<PhysicsPlannedEffect>()
+            });
+        }
+    }
+}
+#endif