add rouge visuals and import physics package

Assets/Samples.meta

+fileFormatVersion: 2
+guid: 8fd8c37e630a3a64e8e2636362ea5048
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics.meta

+fileFormatVersion: 2
+guid: 92cec7108f023b74588d2faba8836a4a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6.meta

+fileFormatVersion: 2
+guid: 80b77087a57869e4e84989cedb3254a2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring.meta

+fileFormatVersion: 2
+guid: 5a924c0fdfd89e741bdc831420a6a596
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor.meta

+fileFormatVersion: 2
+guid: 929b1e3f9af32424295367e631b0d137
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/AssemblyInfo.cs

+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Unity.Physics.Custom.EditModeTests")]

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/AssemblyInfo.cs.meta

+fileFormatVersion: 2
+guid: 016d8a3094fcbdf44961b10be9ac5c56
+timeCreated: 1680116734
\ No newline at end of file

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/EditorTools.meta

+fileFormatVersion: 2
+guid: df54d2bd08525d5449ae01cf06c0117f
+timeCreated: 1678291379
\ No newline at end of file

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/EditorTools/BeveledBoxBoundsHandle.cs

+using System;
+using Unity.Mathematics;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    class BeveledBoxBoundsHandle : BoxBoundsHandle
+    {
+        public float bevelRadius
+        {
+            get => math.min(m_BevelRadius, math.cmin(GetSize()) * 0.5f);
+            set
+            {
+                if (!m_IsDragging)
+                    m_BevelRadius = math.max(0f, value);
+            }
+        }
+        float m_BevelRadius = ConvexHullGenerationParameters.Default.BevelRadius;
+        bool m_IsDragging = false;
+
+        static PhysicsBoundsHandleUtility.Corner[] s_Corners = new PhysicsBoundsHandleUtility.Corner[8];
+
+        public new void DrawHandle()
+        {
+            int prevHotControl = GUIUtility.hotControl;
+            if (prevHotControl == 0)
+                m_IsDragging = false;
+            base.DrawHandle();
+            int currHotcontrol = GUIUtility.hotControl;
+            if (currHotcontrol != prevHotControl)
+                m_IsDragging = currHotcontrol != 0;
+        }
+
+        protected override void DrawWireframe()
+        {
+            if (this.bevelRadius <= 0f)
+            {
+                base.DrawWireframe();
+                return;
+            }
+
+            var cameraPosition = float3.zero;
+            var cameraForward = new float3 { z = 1f };
+            if (Camera.current != null)
+            {
+                cameraPosition = Camera.current.transform.position;
+                cameraForward = Camera.current.transform.forward;
+            }
+
+            var bounds = new Bounds(this.center, this.size);
+            bool isCameraInsideBox = Camera.current != null && bounds.Contains(Handles.inverseMatrix.MultiplyPoint(cameraPosition));
+            var bevelRadius = this.bevelRadius;
+            var origin      = (float3)this.center;
+            var size        = (float3)this.size;
+
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f,  1f,  1f), bevelRadius, 0, axes, isCameraInsideBox);
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(-1f,  1f,  1f), bevelRadius, 0, axes, isCameraInsideBox);
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f,  1f,  1f), bevelRadius, 1, axes, isCameraInsideBox);
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f, -1f,  1f), bevelRadius, 1, axes, isCameraInsideBox);
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f,  1f,  1f), bevelRadius, 2, axes, isCameraInsideBox);
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f,  1f, -1f), bevelRadius, 2, axes, isCameraInsideBox);
+
+            var corner = 0.5f * size - new float3(1f) * bevelRadius;
+            var axisx = new float3(1f, 0f, 0f);
+            var axisy = new float3(0f, 1f, 0f);
+            var axisz = new float3(0f, 0f, 1f);
+
+            // Since the geometry is transformed by Handles.matrix during rendering, we transform the camera position
+            // by the inverse matrix so that the two-shaded wireframe will have the proper orientation.
+            var invMatrix   = Handles.inverseMatrix;
+            cameraPosition  = invMatrix.MultiplyPoint(cameraPosition);
+            cameraForward   = invMatrix.MultiplyVector(cameraForward);
+            var cameraOrtho = Camera.current == null || Camera.current.orthographic;
+
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f,  1f, -1f), quaternion.LookRotation(-axisz,  axisy), cameraPosition, cameraForward, cameraOrtho, bevelRadius, out s_Corners[0]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f,  1f,  1f), quaternion.LookRotation(-axisx,  axisy), cameraPosition, cameraForward, cameraOrtho, bevelRadius, out s_Corners[1]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f,  1f,  1f), quaternion.LookRotation(axisz,  axisy), cameraPosition, cameraForward, cameraOrtho, bevelRadius, out s_Corners[2]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f,  1f, -1f), quaternion.LookRotation(axisx,  axisy), cameraPosition, cameraForward, cameraOrtho, bevelRadius, out s_Corners[3]);
+
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f, -1f, -1f), quaternion.LookRotation(-axisx, -axisy), cameraPosition, cameraForward, cameraOrtho, bevelRadius, out s_Corners[4]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f, -1f,  1f), quaternion.LookRotation(axisz, -axisy), cameraPosition, cameraForward, cameraOrtho, bevelRadius, out s_Corners[5]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f, -1f,  1f), quaternion.LookRotation(axisx, -axisy), cameraPosition, cameraForward, cameraOrtho, bevelRadius, out s_Corners[6]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f, -1f, -1f), quaternion.LookRotation(-axisz, -axisy), cameraPosition, cameraForward, cameraOrtho, bevelRadius, out s_Corners[7]);
+
+            for (int i = 0; i < s_Corners.Length; i++)
+                PhysicsBoundsHandleUtility.DrawCorner(s_Corners[i], true);
+
+            // Draw the horizon edges between the corners
+            for (int upA = 3, upB = 0; upB < 4; upA = upB, upB++)
+            {
+                int dnA = upA + 4;
+                int dnB = upB + 4;
+
+                if (s_Corners[upA].splitAxis[0].z && s_Corners[upB].splitAxis[1].x) Handles.DrawLine(s_Corners[upA].points[0], s_Corners[upB].points[1]);
+                if (s_Corners[upA].splitAxis[1].z && s_Corners[upB].splitAxis[0].x) Handles.DrawLine(s_Corners[upA].points[1], s_Corners[upB].points[0]);
+
+                if (s_Corners[dnA].splitAxis[0].x && s_Corners[dnB].splitAxis[1].z) Handles.DrawLine(s_Corners[dnA].points[0], s_Corners[dnB].points[1]);
+                if (s_Corners[dnA].splitAxis[1].x && s_Corners[dnB].splitAxis[0].z) Handles.DrawLine(s_Corners[dnA].points[1], s_Corners[dnB].points[0]);
+
+                if (s_Corners[dnA].splitAxis[0].y && s_Corners[upA].splitAxis[1].y) Handles.DrawLine(s_Corners[dnA].points[0], s_Corners[upA].points[1]);
+                if (s_Corners[dnA].splitAxis[1].y && s_Corners[upA].splitAxis[0].y) Handles.DrawLine(s_Corners[dnA].points[1], s_Corners[upA].points[0]);
+            }
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/EditorTools/BeveledBoxBoundsHandle.cs.meta

+fileFormatVersion: 2
+guid: be997ba7f25d7f44b8996dfac81c1a3a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/EditorTools/BeveledCylinderBoundsHandle.cs.meta

+fileFormatVersion: 2
+guid: 4f5e502486013d44c9cc7466f6c3bcd1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/EditorTools/PhysicsBoundsHandleUtility.cs.meta

+fileFormatVersion: 2
+guid: e3c60d0e0940c3c419ec030b9685c622
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/EditorTools/PhysicsCapsuleBoundsHandle.cs

+using System;
+using Unity.Mathematics;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    class PhysicsCapsuleBoundsHandle : CapsuleBoundsHandle
+    {
+        static PhysicsBoundsHandleUtility.Corner[] s_Corners = new PhysicsBoundsHandleUtility.Corner[8];
+
+        protected override void DrawWireframe()
+        {
+            if (this.radius <= 0f)
+            {
+                base.DrawWireframe();
+                return;
+            }
+
+            var cameraPos = default(float3);
+            var cameraFwd = new float3 { z = 1f };
+            var cameraOrtho = true;
+            if (Camera.current != null)
+            {
+                cameraPos = Camera.current.transform.position;
+                cameraFwd = Camera.current.transform.forward;
+                cameraOrtho = Camera.current.orthographic;
+            }
+
+            var size        = new float3(this.radius * 2f, this.radius * 2f, height);
+            var radius      = this.radius;
+            var origin      = (float3)this.center;
+            var bounds      = new Bounds(this.center, size);
+
+            // Since the geometry is transformed by Handles.matrix during rendering, we transform the camera position
+            // by the inverse matrix so that the two-shaded wireframe will have the proper orientation.
+            var invMatrix       = Handles.inverseMatrix;
+            var cameraCenter    = (float3)invMatrix.MultiplyPoint(cameraPos);
+            var cameraForward   = (float3)invMatrix.MultiplyVector(cameraFwd);
+
+            bool isCameraInsideBox = Camera.current != null
+                && bounds.Contains(invMatrix.MultiplyPoint(cameraPos));
+
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f,  1f,  1f), radius, 0, axes, isCameraInsideBox);
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(-1f,  1f,  1f), radius, 0, axes, isCameraInsideBox);
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f,  1f,  1f), radius, 1, axes, isCameraInsideBox);
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f, -1f,  1f), radius, 1, axes, isCameraInsideBox);
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f,  1f,  1f), radius, 2, axes, isCameraInsideBox);
+            PhysicsBoundsHandleUtility.DrawFace(origin, size * new float3(1f,  1f, -1f), radius, 2, axes, isCameraInsideBox);
+
+            var corner = 0.5f * size - new float3(1f) * radius;
+            var axisx = new float3(1f, 0f, 0f);
+            var axisy = new float3(0f, 1f, 0f);
+            var axisz = new float3(0f, 0f, 1f);
+
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f,  1f, -1f), quaternion.LookRotation(-axisz,  axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[0]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f,  1f,  1f), quaternion.LookRotation(-axisx,  axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[1]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f,  1f,  1f), quaternion.LookRotation(axisz,  axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[2]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f,  1f, -1f), quaternion.LookRotation(axisx,  axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[3]);
+
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f, -1f, -1f), quaternion.LookRotation(-axisx, -axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[4]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(-1f, -1f,  1f), quaternion.LookRotation(axisz, -axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[5]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f, -1f,  1f), quaternion.LookRotation(axisx, -axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[6]);
+            PhysicsBoundsHandleUtility.CalculateCornerHorizon(origin + corner * new float3(1f, -1f, -1f), quaternion.LookRotation(-axisz, -axisy), cameraCenter, cameraForward, cameraOrtho, radius, out s_Corners[7]);
+
+            PhysicsBoundsHandleUtility.DrawCorner(s_Corners[0], new bool3(false, true,  true));
+            PhysicsBoundsHandleUtility.DrawCorner(s_Corners[3], new bool3(true,  false, true));
+            PhysicsBoundsHandleUtility.DrawCorner(s_Corners[4], new bool3(true,  false, true));
+            PhysicsBoundsHandleUtility.DrawCorner(s_Corners[7], new bool3(false, true,  true));
+
+            PhysicsBoundsHandleUtility.DrawCorner(s_Corners[1], new bool3(true,  false, true));
+            PhysicsBoundsHandleUtility.DrawCorner(s_Corners[2], new bool3(false, true,  true));
+            PhysicsBoundsHandleUtility.DrawCorner(s_Corners[5], new bool3(false, true,  true));
+            PhysicsBoundsHandleUtility.DrawCorner(s_Corners[6], new bool3(true,  false, true));
+
+            // Draw the horizon edges between the corners
+            for (int upA = 3, upB = 0; upB < 4; upA = upB, upB++)
+            {
+                int dnA = upA + 4;
+                int dnB = upB + 4;
+
+                if (s_Corners[upA].splitAxis[0].z && s_Corners[upB].splitAxis[1].x) Handles.DrawLine(s_Corners[upA].points[0], s_Corners[upB].points[1]);
+                if (s_Corners[upA].splitAxis[1].z && s_Corners[upB].splitAxis[0].x) Handles.DrawLine(s_Corners[upA].points[1], s_Corners[upB].points[0]);
+
+                if (s_Corners[dnA].splitAxis[0].x && s_Corners[dnB].splitAxis[1].z) Handles.DrawLine(s_Corners[dnA].points[0], s_Corners[dnB].points[1]);
+                if (s_Corners[dnA].splitAxis[1].x && s_Corners[dnB].splitAxis[0].z) Handles.DrawLine(s_Corners[dnA].points[1], s_Corners[dnB].points[0]);
+
+                if (s_Corners[dnA].splitAxis[0].y && s_Corners[upA].splitAxis[1].y) Handles.DrawLine(s_Corners[dnA].points[0], s_Corners[upA].points[1]);
+                if (s_Corners[dnA].splitAxis[1].y && s_Corners[upA].splitAxis[0].y) Handles.DrawLine(s_Corners[dnA].points[1], s_Corners[upA].points[0]);
+            }
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/EditorTools/PhysicsCapsuleBoundsHandle.cs.meta

+fileFormatVersion: 2
+guid: c1af170fae6badc40bb2ed5376031c6f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/EditorTools/PhysicsSphereBoundsHandle.cs

+using System;
+using Unity.Mathematics;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    class PhysicsSphereBoundsHandle : SphereBoundsHandle
+    {
+        protected override void DrawWireframe()
+        {
+            bool x = IsAxisEnabled(Axes.X);
+            bool y = IsAxisEnabled(Axes.Y);
+            bool z = IsAxisEnabled(Axes.Z);
+
+            if (x && !y && !z)
+                Handles.DrawLine(Vector3.right * radius, Vector3.left * radius);
+            if (!x && y && !z)
+                Handles.DrawLine(Vector3.up * radius, Vector3.down * radius);
+            if (!x && !y && z)
+                Handles.DrawLine(Vector3.forward * radius, Vector3.back * radius);
+
+            const float kEpsilon = 0.000001F;
+
+            if (radius > 0)
+            {
+                var frontfacedColor = Handles.color;
+                var backfacedColor  = Handles.color * new Color(1f, 1f, 1f, PhysicsBoundsHandleUtility.kBackfaceAlphaMultiplier);
+                var discVisible = new bool[]
+                {
+                    y && z,
+                    x && z,
+                    x && y
+                };
+                var discOrientations = new float3[]
+                {
+                    Vector3.right,
+                    Vector3.up,
+                    Vector3.forward
+                };
+
+                // Since the geometry is transformed by Handles.matrix during rendering, we transform the camera position
+                // by the inverse matrix so that the two-shaded wireframe will have the proper orientation.
+                var invMatrix               = Handles.inverseMatrix;
+
+                var cameraCenter            = Camera.current == null ? Vector3.zero : Camera.current.transform.position;
+                var cameraToCenter          = center - invMatrix.MultiplyPoint(cameraCenter); // vector from camera to center
+                var sqrDistCameraToCenter   = cameraToCenter.sqrMagnitude;
+                var sqrRadius               = radius * radius;                  // squared radius
+                var isCameraOrthographic    = Camera.current == null || Camera.current.orthographic;
+                var sqrOffset               = isCameraOrthographic ? 0 : (sqrRadius * sqrRadius / sqrDistCameraToCenter);   // squared distance from actual center to drawn disc center
+                var insideAmount            = sqrOffset / sqrRadius;
+                if (insideAmount < 1)
+                {
+                    if (math.abs(sqrDistCameraToCenter) >= kEpsilon)
+                    {
+                        using (new Handles.DrawingScope(frontfacedColor))
+                        {
+                            if (isCameraOrthographic)
+                            {
+                                var horizonRadius = radius;
+                                var horizonCenter = center;
+                                Handles.DrawWireDisc(horizonCenter, cameraToCenter, horizonRadius);
+                            }
+                            else
+                            {
+                                var horizonRadius = math.sqrt(sqrRadius - sqrOffset);
+                                var horizonCenter = center - sqrRadius * cameraToCenter / sqrDistCameraToCenter;
+                                Handles.DrawWireDisc(horizonCenter, cameraToCenter, horizonRadius);
+                            }
+                        }
+
+                        var planeNormal = cameraToCenter.normalized;
+                        for (int i = 0; i < 3; i++)
+                        {
+                            if (!discVisible[i])
+                                continue;
+
+                            var discOrientation = discOrientations[i];
+
+                            var angleBetweenDiscAndNormal = math.acos(math.dot(discOrientation, planeNormal));
+                            angleBetweenDiscAndNormal = (math.PI * 0.5f) - math.min(angleBetweenDiscAndNormal, math.PI - angleBetweenDiscAndNormal);
+
+                            float f = math.tan(angleBetweenDiscAndNormal);
+                            float g = math.sqrt(sqrOffset + f * f * sqrOffset) / radius;
+                            if (g < 1)
+                            {
+                                var angleToHorizon          = math.degrees(math.asin(g));
+                                var discTangent             = math.cross(discOrientation, planeNormal);
+                                var vectorToPointOnHorizon  = Quaternion.AngleAxis(angleToHorizon, discOrientation) * discTangent;
+                                var horizonArcLength        = (90 - angleToHorizon) * 2.0f;
+
+                                using (new Handles.DrawingScope(frontfacedColor))
+                                    Handles.DrawWireArc(center, discOrientation, vectorToPointOnHorizon, horizonArcLength, radius);
+                                using (new Handles.DrawingScope(backfacedColor))
+                                    Handles.DrawWireArc(center, discOrientation, vectorToPointOnHorizon, horizonArcLength - 360, radius);
+                            }
+                            else
+                            {
+                                using (new Handles.DrawingScope(backfacedColor))
+                                    Handles.DrawWireDisc(center, discOrientation, radius);
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    using (new Handles.DrawingScope(backfacedColor))
+                    {
+                        for (int i = 0; i < 3; i++)
+                        {
+                            var discOrientation = discOrientations[i];
+                            Handles.DrawWireDisc(center, discOrientation, radius);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/EditorTools/PhysicsSphereBoundsHandle.cs.meta

+fileFormatVersion: 2
+guid: d4f82f07aa94f9241ad081812f8c3b1a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors.meta

+fileFormatVersion: 2
+guid: 30413a61e5b44d54dbd680b077804e45
+timeCreated: 1678288991
\ No newline at end of file

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/BallAndSocketJointEditor.cs

+#if UNITY_EDITOR
+
+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [CustomEditor(typeof(BallAndSocketJoint))]
+    public class BallAndSocketEditor : UnityEditor.Editor
+    {
+        protected virtual void OnSceneGUI()
+        {
+            BallAndSocketJoint ballAndSocket = (BallAndSocketJoint)target;
+
+            EditorGUI.BeginChangeCheck();
+
+            EditorUtilities.EditPivot(ballAndSocket.worldFromA, ballAndSocket.worldFromB, ballAndSocket.AutoSetConnected,
+                ref ballAndSocket.PositionLocal, ref ballAndSocket.PositionInConnectedEntity, ballAndSocket);
+        }
+    }
+}
+
+#endif

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/BallAndSocketJointEditor.cs.meta

+fileFormatVersion: 2
+guid: 8bfafdfc59379ec4c86d512554577279
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/CustomPhysicsMaterialTagNamesEditor.cs

+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [CustomEditor(typeof(CustomPhysicsMaterialTagNames))]
+    [CanEditMultipleObjects]
+    class CustomPhysicsMaterialTagNamesEditor : BaseEditor
+    {
+        #pragma warning disable 649
+        [AutoPopulate(ElementFormatString = "Custom Physics Material Tag {0}", Resizable = false, Reorderable = false)]
+        ReorderableList m_TagNames;
+        #pragma warning restore 649
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/CustomPhysicsMaterialTagNamesEditor.cs.meta

+fileFormatVersion: 2
+guid: 9a6f5e4709a915246864e50578af0cf3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/EditorUtilities.cs.meta

+fileFormatVersion: 2
+guid: 5c7e2e7874c307546bb3ab423b21a11e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/LimitedHingeJointEditor.cs

+#if UNITY_EDITOR
+
+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [CustomEditor(typeof(LimitedHingeJoint))]
+    public class LimitedHingeEditor : UnityEditor.Editor
+    {
+        private EditorUtilities.AxisEditor m_AxisEditor = new EditorUtilities.AxisEditor();
+        private JointAngularLimitHandle m_LimitHandle = new JointAngularLimitHandle();
+
+        public override void OnInspectorGUI()
+        {
+            LimitedHingeJoint limitedHinge = (LimitedHingeJoint)target;
+
+            EditorGUI.BeginChangeCheck();
+
+            GUILayout.BeginHorizontal();
+            GUILayout.Label("Editors:");
+            limitedHinge.EditPivots = GUILayout.Toggle(limitedHinge.EditPivots, new GUIContent("Pivot"), "Button");
+            limitedHinge.EditAxes = GUILayout.Toggle(limitedHinge.EditAxes, new GUIContent("Axis"), "Button");
+            limitedHinge.EditLimits = GUILayout.Toggle(limitedHinge.EditLimits, new GUIContent("Limits"), "Button");
+            GUILayout.EndHorizontal();
+            DrawDefaultInspector();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                SceneView.RepaintAll();
+            }
+        }
+
+        protected virtual void OnSceneGUI()
+        {
+            LimitedHingeJoint limitedHinge = (LimitedHingeJoint)target;
+
+            if (limitedHinge.EditPivots)
+            {
+                EditorUtilities.EditPivot(limitedHinge.worldFromA, limitedHinge.worldFromB, limitedHinge.AutoSetConnected,
+                    ref limitedHinge.PositionLocal, ref limitedHinge.PositionInConnectedEntity, limitedHinge);
+            }
+            if (limitedHinge.EditAxes)
+            {
+                m_AxisEditor.Update(limitedHinge.worldFromA, limitedHinge.worldFromB,
+                    limitedHinge.AutoSetConnected,
+                    limitedHinge.PositionLocal, limitedHinge.PositionInConnectedEntity,
+                    ref limitedHinge.HingeAxisLocal, ref limitedHinge.HingeAxisInConnectedEntity,
+                    ref limitedHinge.PerpendicularAxisLocal, ref limitedHinge.PerpendicularAxisInConnectedEntity,
+                    limitedHinge);
+            }
+            if (limitedHinge.EditLimits)
+            {
+                EditorUtilities.EditLimits(limitedHinge.worldFromA, limitedHinge.worldFromB,
+                    limitedHinge.PositionLocal,
+                    limitedHinge.HingeAxisLocal, limitedHinge.HingeAxisInConnectedEntity,
+                    limitedHinge.PerpendicularAxisLocal, limitedHinge.PerpendicularAxisInConnectedEntity,
+                    ref limitedHinge.MinAngle, ref limitedHinge.MaxAngle, m_LimitHandle, limitedHinge);
+            }
+        }
+    }
+}
+
+#endif

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/LimitedHingeJointEditor.cs.meta

+fileFormatVersion: 2
+guid: f79ce4d7693ece94fb5927586cd79ad9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/PhysicsBodyAuthoringEditor.cs

+using System.Collections.Generic;
+using Unity.Mathematics;
+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [CustomEditor(typeof(PhysicsBodyAuthoring))]
+    [CanEditMultipleObjects]
+    class PhysicsBodyAuthoringEditor : BaseEditor
+    {
+        static class Content
+        {
+            public static readonly GUIContent MassLabel = EditorGUIUtility.TrTextContent("Mass");
+            public static readonly GUIContent CenterOfMassLabel = EditorGUIUtility.TrTextContent(
+                "Center of Mass", "Center of mass in the space of this body's transform."
+            );
+            public static readonly GUIContent InertiaTensorLabel = EditorGUIUtility.TrTextContent(
+                "Inertia Tensor", "Resistance to angular motion about each axis of rotation."
+            );
+            public static readonly GUIContent OrientationLabel = EditorGUIUtility.TrTextContent(
+                "Orientation", "Orientation of the body's inertia tensor in the space of its transform."
+            );
+            public static readonly GUIContent AdvancedLabel = EditorGUIUtility.TrTextContent(
+                "Advanced", "Advanced options"
+            );
+        }
+
+        #pragma warning disable 649
+        [AutoPopulate] SerializedProperty m_MotionType;
+        [AutoPopulate] SerializedProperty m_Smoothing;
+        [AutoPopulate] SerializedProperty m_Mass;
+        [AutoPopulate] SerializedProperty m_GravityFactor;
+        [AutoPopulate] SerializedProperty m_LinearDamping;
+        [AutoPopulate] SerializedProperty m_AngularDamping;
+        [AutoPopulate] SerializedProperty m_InitialLinearVelocity;
+        [AutoPopulate] SerializedProperty m_InitialAngularVelocity;
+        [AutoPopulate] SerializedProperty m_OverrideDefaultMassDistribution;
+        [AutoPopulate] SerializedProperty m_CenterOfMass;
+        [AutoPopulate] SerializedProperty m_Orientation;
+        [AutoPopulate] SerializedProperty m_InertiaTensor;
+        [AutoPopulate] SerializedProperty m_WorldIndex;
+        [AutoPopulate] SerializedProperty m_CustomTags;
+        #pragma warning restore 649
+
+        bool showAdvanced;
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(m_MotionType);
+
+            if (m_MotionType.intValue != (int)BodyMotionType.Static)
+                EditorGUILayout.PropertyField(m_Smoothing);
+
+            var dynamic = m_MotionType.intValue == (int)BodyMotionType.Dynamic;
+
+            if (dynamic)
+                EditorGUILayout.PropertyField(m_Mass, Content.MassLabel);
+            else
+            {
+                EditorGUI.BeginDisabledGroup(true);
+                var position = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight);
+                EditorGUI.BeginProperty(position, Content.MassLabel, m_Mass);
+                EditorGUI.FloatField(position, Content.MassLabel, float.PositiveInfinity);
+                EditorGUI.EndProperty();
+                EditorGUI.EndDisabledGroup();
+            }
+
+            if (m_MotionType.intValue == (int)BodyMotionType.Dynamic)
+            {
+                EditorGUILayout.PropertyField(m_LinearDamping, true);
+                EditorGUILayout.PropertyField(m_AngularDamping, true);
+            }
+
+            if (m_MotionType.intValue != (int)BodyMotionType.Static)
+            {
+                EditorGUILayout.PropertyField(m_InitialLinearVelocity, true);
+                EditorGUILayout.PropertyField(m_InitialAngularVelocity, true);
+            }
+
+            if (m_MotionType.intValue == (int)BodyMotionType.Dynamic)
+            {
+                EditorGUILayout.PropertyField(m_GravityFactor, true);
+            }
+
+            showAdvanced = EditorGUILayout.Foldout(showAdvanced, Content.AdvancedLabel);
+            if (showAdvanced)
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUILayout.PropertyField(m_WorldIndex);
+                if (m_MotionType.intValue != (int)BodyMotionType.Static)
+                {
+                    EditorGUILayout.PropertyField(m_OverrideDefaultMassDistribution);
+                    if (m_OverrideDefaultMassDistribution.boolValue)
+                    {
+                        ++EditorGUI.indentLevel;
+                        EditorGUILayout.PropertyField(m_CenterOfMass, Content.CenterOfMassLabel);
+
+                        EditorGUI.BeginDisabledGroup(!dynamic);
+                        if (dynamic)
+                        {
+                            EditorGUILayout.PropertyField(m_Orientation, Content.OrientationLabel);
+                            EditorGUILayout.PropertyField(m_InertiaTensor, Content.InertiaTensorLabel);
+                        }
+                        else
+                        {
+                            EditorGUI.BeginDisabledGroup(true);
+                            var position =
+                                EditorGUILayout.GetControlRect(true, EditorGUI.GetPropertyHeight(m_InertiaTensor));
+                            EditorGUI.BeginProperty(position, Content.InertiaTensorLabel, m_InertiaTensor);
+                            EditorGUI.Vector3Field(position, Content.InertiaTensorLabel,
+                                Vector3.one * float.PositiveInfinity);
+                            EditorGUI.EndProperty();
+                            EditorGUI.EndDisabledGroup();
+                        }
+
+                        EditorGUI.EndDisabledGroup();
+
+                        --EditorGUI.indentLevel;
+                    }
+                }
+                EditorGUILayout.PropertyField(m_CustomTags);
+                --EditorGUI.indentLevel;
+            }
+
+            if (EditorGUI.EndChangeCheck())
+                serializedObject.ApplyModifiedProperties();
+
+            DisplayStatusMessages();
+        }
+
+        MessageType m_Status;
+        List<string> m_StatusMessages = new List<string>(8);
+
+        void DisplayStatusMessages()
+        {
+            m_Status = MessageType.None;
+            m_StatusMessages.Clear();
+
+            var hierarchyStatus = StatusMessageUtility.GetHierarchyStatusMessage(targets, out var hierarchyStatusMessage);
+            if (!string.IsNullOrEmpty(hierarchyStatusMessage))
+            {
+                m_StatusMessages.Add(hierarchyStatusMessage);
+                m_Status = (MessageType)math.max((int)m_Status, (int)hierarchyStatus);
+            }
+
+            if (m_StatusMessages.Count > 0)
+                EditorGUILayout.HelpBox(string.Join("\n\n", m_StatusMessages), m_Status);
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/PhysicsBodyAuthoringEditor.cs.meta

+fileFormatVersion: 2
+guid: a63bbe7a0e8f0934fb7896991b8408ce
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/PhysicsCategoryNamesEditor.cs

+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [CustomEditor(typeof(PhysicsCategoryNames))]
+    [CanEditMultipleObjects]
+    class PhysicsCategoryNamesEditor : BaseEditor
+    {
+        #pragma warning disable 649
+        [AutoPopulate(ElementFormatString = "Category {0}", Resizable = false, Reorderable = false)]
+        ReorderableList m_CategoryNames;
+        #pragma warning restore 649
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/PhysicsCategoryNamesEditor.cs.meta

+fileFormatVersion: 2
+guid: fcbb532fa3ab5ca4cb5005410a82cc83
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/PhysicsShapeAuthoringEditor.cs.meta

+fileFormatVersion: 2
+guid: 209b4a4e54f038844baf182ae186f813
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/RagdollJointEditor.cs

+#if UNITY_EDITOR
+
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+using Unity.Mathematics;
+using Unity.Physics.Authoring;
+
+namespace Unity.Physics.Editor
+{
+    [CustomEditor(typeof(RagdollJoint))]
+    public class RagdollJointEditor : UnityEditor.Editor
+    {
+        private EditorUtilities.AxisEditor m_AxisEditor = new EditorUtilities.AxisEditor();
+        private JointAngularLimitHandle m_LimitHandle = new JointAngularLimitHandle();
+
+        public override void OnInspectorGUI()
+        {
+            RagdollJoint ragdoll = (RagdollJoint)target;
+
+            EditorGUI.BeginChangeCheck();
+
+            GUILayout.BeginVertical();
+            GUILayout.Space(10.0f);
+
+            GUILayout.BeginHorizontal();
+            GUILayout.Label("Editors:");
+            ragdoll.EditPivots = GUILayout.Toggle(ragdoll.EditPivots, new GUIContent("Pivot"), "Button");
+            ragdoll.EditAxes = GUILayout.Toggle(ragdoll.EditAxes, new GUIContent("Axis"), "Button");
+            ragdoll.EditLimits = GUILayout.Toggle(ragdoll.EditLimits, new GUIContent("Limits"), "Button");
+            GUILayout.EndHorizontal();
+
+            GUILayout.Space(10.0f);
+            GUILayout.EndVertical();
+
+            DrawDefaultInspector();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                SceneView.RepaintAll();
+            }
+        }
+
+        private static void DrawCone(float3 point, float3 axis, float angle, Color color)
+        {
+#if UNITY_EDITOR
+            Handles.color = color;
+
+            float3 dir;
+            float scale = Math.NormalizeWithLength(axis, out dir);
+
+            float3 arm;
+            {
+                float3 perp1, perp2;
+                Math.CalculatePerpendicularNormalized(dir, out perp1, out perp2);
+                arm = math.mul(quaternion.AxisAngle(perp1, angle), dir) * scale;
+            }
+
+            const int res = 16;
+            quaternion q = quaternion.AxisAngle(dir, 2.0f * (float)math.PI / res);
+            for (int i = 0; i < res; i++)
+            {
+                float3 nextArm = math.mul(q, arm);
+                Handles.DrawLine(point, point + arm);
+                Handles.DrawLine(point + arm, point + nextArm);
+                arm = nextArm;
+            }
+#endif
+        }
+
+        protected virtual void OnSceneGUI()
+        {
+            RagdollJoint ragdoll = (RagdollJoint)target;
+
+            bool drawCones = false;
+            if (ragdoll.EditPivots)
+            {
+                EditorUtilities.EditPivot(ragdoll.worldFromA, ragdoll.worldFromB, ragdoll.AutoSetConnected,
+                    ref ragdoll.PositionLocal, ref ragdoll.PositionInConnectedEntity, ragdoll);
+            }
+            if (ragdoll.EditAxes)
+            {
+                m_AxisEditor.Update(ragdoll.worldFromA, ragdoll.worldFromB, ragdoll.AutoSetConnected,
+                    ragdoll.PositionLocal, ragdoll.PositionInConnectedEntity, ref ragdoll.TwistAxisLocal, ref ragdoll.TwistAxisInConnectedEntity,
+                    ref ragdoll.PerpendicularAxisLocal, ref ragdoll.PerpendicularAxisInConnectedEntity, ragdoll);
+                drawCones = true;
+            }
+            if (ragdoll.EditLimits)
+            {
+                EditorUtilities.EditLimits(ragdoll.worldFromA, ragdoll.worldFromB, ragdoll.PositionLocal, ragdoll.TwistAxisLocal, ragdoll.TwistAxisInConnectedEntity,
+                    ragdoll.PerpendicularAxisLocal, ragdoll.PerpendicularAxisInConnectedEntity, ref ragdoll.MinTwistAngle, ref ragdoll.MaxTwistAngle, m_LimitHandle, ragdoll);
+            }
+
+            if (drawCones)
+            {
+                float3 pivotB = math.transform(ragdoll.worldFromB, ragdoll.PositionInConnectedEntity);
+                float3 axisB = math.rotate(ragdoll.worldFromB, ragdoll.TwistAxisInConnectedEntity);
+                DrawCone(pivotB, axisB, math.radians(ragdoll.MaxConeAngle), Color.yellow);
+
+                float3 perpendicularB = math.rotate(ragdoll.worldFromB, ragdoll.PerpendicularAxisInConnectedEntity);
+                DrawCone(pivotB, perpendicularB, math.radians(ragdoll.MinPerpendicularAngle + 90f), Color.red);
+                DrawCone(pivotB, perpendicularB, math.radians(ragdoll.MaxPerpendicularAngle + 90f), Color.red);
+            }
+        }
+    }
+}
+
+#endif

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Editors/RagdollJointEditor.cs.meta

+fileFormatVersion: 2
+guid: 4c97c008c29536647add5a287db56ae2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers.meta

+fileFormatVersion: 2
+guid: 23d0032aba561954aaf56c65acf751bd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/BaseDrawer.cs

+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    abstract class BaseDrawer : PropertyDrawer
+    {
+        protected abstract bool IsCompatible(SerializedProperty property);
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            return IsCompatible(property)
+                ? EditorGUI.GetPropertyHeight(property)
+                : EditorGUIUtility.singleLineHeight;
+        }
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            if (IsCompatible(property))
+                DoGUI(position, property, label);
+            else
+                EditorGUIControls.DisplayCompatibilityWarning(position, label, ObjectNames.NicifyVariableName(GetType().Name));
+        }
+
+        protected abstract void DoGUI(Rect position, SerializedProperty property, GUIContent label);
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/BaseDrawer.cs.meta

+fileFormatVersion: 2
+guid: a4ce107efdd5d5f439469b8b109f601f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/EnumFlagsDrawer.cs

+using System;
+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [CustomPropertyDrawer(typeof(EnumFlagsAttribute))]
+    class EnumFlagsDrawer : BaseDrawer
+    {
+        protected override bool IsCompatible(SerializedProperty property)
+        {
+            return property.propertyType == SerializedPropertyType.Enum;
+        }
+
+        protected override void DoGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            EditorGUI.BeginProperty(position, label, property);
+
+            var value = property.longValue;
+            EditorGUI.BeginChangeCheck();
+            value = Convert.ToInt64(
+                EditorGUI.EnumFlagsField(position, label, (Enum)Enum.ToObject(fieldInfo.FieldType, value))
+            );
+            if (EditorGUI.EndChangeCheck())
+                property.longValue = value;
+
+            EditorGUI.EndProperty();
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/EnumFlagsDrawer.cs.meta

+fileFormatVersion: 2
+guid: 91d983b20a4beed4794e82ce61acb452
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/EulerAnglesDrawer.cs

+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [CustomPropertyDrawer(typeof(EulerAngles))]
+    class EulerAnglesDrawer : BaseDrawer
+    {
+        protected override bool IsCompatible(SerializedProperty property) => true;
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            var value = property.FindPropertyRelative(nameof(EulerAngles.Value));
+            return EditorGUI.GetPropertyHeight(value);
+        }
+
+        protected override void DoGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            var value = property.FindPropertyRelative(nameof(EulerAngles.Value));
+            EditorGUI.PropertyField(position, value, label, true);
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/EulerAnglesDrawer.cs.meta

+fileFormatVersion: 2
+guid: aa19ca1ba7846e443a44ba0fff644d17
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/ExpandChildrenDrawer.cs

+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [CustomPropertyDrawer(typeof(ExpandChildrenAttribute))]
+    class ExpandChildrenDrawer : PropertyDrawer
+    {
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            property.isExpanded = true;
+            return EditorGUI.GetPropertyHeight(property)
+                - EditorGUIUtility.standardVerticalSpacing
+                - EditorGUIUtility.singleLineHeight;
+        }
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            var endProperty = property.GetEndProperty();
+            var childProperty = property.Copy();
+            childProperty.NextVisible(true);
+            while (!SerializedProperty.EqualContents(childProperty, endProperty))
+            {
+                position.height = EditorGUI.GetPropertyHeight(childProperty);
+                OnChildPropertyGUI(position, childProperty);
+                position.y += position.height + EditorGUIUtility.standardVerticalSpacing;
+                childProperty.NextVisible(false);
+            }
+        }
+
+        protected virtual void OnChildPropertyGUI(Rect position, SerializedProperty childProperty)
+        {
+            EditorGUI.PropertyField(position, childProperty, true);
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/ExpandChildrenDrawer.cs.meta

+fileFormatVersion: 2
+guid: 0c02598cdac1be04a9039046cc3b8459
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/PhysicsMaterialCoefficientDrawer.cs

+using System;
+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [CustomPropertyDrawer(typeof(PhysicsMaterialCoefficient))]
+    class PhysicsMaterialCoefficientDrawer : BaseDrawer
+    {
+        static class Styles
+        {
+            public const float PopupWidth = 100f;
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label) =>
+            EditorGUIUtility.singleLineHeight;
+
+        protected override bool IsCompatible(SerializedProperty property) => true;
+
+        protected override void DoGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            EditorGUI.BeginProperty(position, label, property);
+            EditorGUI.PropertyField(
+                new Rect(position) { xMax = position.xMax - Styles.PopupWidth },
+                property.FindPropertyRelative("Value"),
+                label
+            );
+
+            var indent = EditorGUI.indentLevel;
+            EditorGUI.indentLevel = 0;
+            EditorGUI.PropertyField(
+                new Rect(position) { xMin = position.xMax - Styles.PopupWidth + EditorGUIUtility.standardVerticalSpacing },
+                property.FindPropertyRelative("CombineMode"),
+                GUIContent.none
+            );
+            EditorGUI.indentLevel = indent;
+            EditorGUI.EndProperty();
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/PhysicsMaterialCoefficientDrawer.cs.meta

+fileFormatVersion: 2
+guid: 637c07be1ce65064687a822ad33de1aa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/PhysicsMaterialPropertiesDrawer.cs.meta

+fileFormatVersion: 2
+guid: 72400ec801359f34e9b82e3be224cde5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/SoftRangeDrawer.cs

+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [CustomPropertyDrawer(typeof(SoftRangeAttribute))]
+    class SoftRangeDrawer : BaseDrawer
+    {
+        protected override bool IsCompatible(SerializedProperty property)
+        {
+            return property.propertyType == SerializedPropertyType.Float;
+        }
+
+        protected override void DoGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            var attr = attribute as SoftRangeAttribute;
+            EditorGUIControls.SoftSlider(
+                position, label, property, attr.SliderMin, attr.SliderMax, attr.TextFieldMin, attr.TextFieldMax
+            );
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/SoftRangeDrawer.cs.meta

+fileFormatVersion: 2
+guid: b3973ec625484cb418fb92f5b2bbffdd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/TagsDrawer.cs

+using System.Collections.Generic;
+using System.Linq;
+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    abstract class TagsDrawer<T> : PropertyDrawer where T : ScriptableObject, ITagNames
+    {
+        static class Styles
+        {
+            public static readonly string EverythingName = L10n.Tr("Everything");
+            public static readonly string MixedName = L10n.Tr("Mixed...");
+            public static readonly string NothingName = L10n.Tr("Nothing");
+
+            public static readonly string MultipleAssetsTooltip =
+                L10n.Tr("Multiple {0} assets found. UI will display labels defined in {1}.");
+
+            public static readonly GUIContent MultipleAssetsWarning =
+                new GUIContent { image = EditorGUIUtility.Load("console.warnicon") as Texture };
+        }
+
+        protected abstract int MaxNumCategories { get; }
+        protected abstract string DefaultCategoryName { get; }
+        internal string FirstChildPropertyPath { get; set; } // TODO: remove when all usages of bool[] are migrated
+
+        string DefaultFormatString => L10n.Tr($"(Undefined {DefaultCategoryName})");
+
+        string[] DefaultOptions =>
+            m_DefaultOptions ?? (
+                m_DefaultOptions =
+                    Enumerable.Range(0, MaxNumCategories)
+                        .Select(i => string.Format(DefaultFormatString, i))
+                        .ToArray()
+            );
+        string[] m_DefaultOptions;
+
+        string[] GetOptions()
+        {
+            if (m_Options != null)
+                return m_Options;
+
+            var guids = AssetDatabase.FindAssets($"t:{typeof(T).Name}");
+            m_NamesAssets = guids
+                .Select(AssetDatabase.GUIDToAssetPath)
+                .Select(AssetDatabase.LoadAssetAtPath<T>)
+                .Where(c => c != null)
+                .ToArray();
+
+            m_Options = m_NamesAssets.FirstOrDefault()?.TagNames.ToArray() ?? DefaultOptions;
+            for (var i = 0; i < m_Options.Length; ++i)
+            {
+                if (string.IsNullOrEmpty(m_Options[i]))
+                    m_Options[i] = DefaultOptions[i];
+
+                m_Options[i] = $"{i}: {m_Options[i]}";
+            }
+
+            return m_Options;
+        }
+
+        string[] m_Options;
+
+        static string GetButtonLabel(int value, IReadOnlyList<string> optionNames)
+        {
+            switch (value)
+            {
+                case 0:
+                    return Styles.NothingName;
+                case ~0:
+                    return Styles.EverythingName;
+                default:
+                {
+                    for (var i = 0; i < 32; i++)
+                    {
+                        if (value == 1 << i)
+                            return optionNames[i];
+                    }
+                    break;
+                }
+            }
+            return Styles.MixedName;
+        }
+
+        T[] m_NamesAssets;
+
+        // TODO: remove when all usages of bool[] are migrated
+        SerializedProperty GetFirstChildProperty(SerializedProperty property)
+        {
+            if (!string.IsNullOrEmpty(FirstChildPropertyPath))
+                return property.FindPropertyRelative(FirstChildPropertyPath);
+            var sp = property.Copy();
+            sp.NextVisible(true);
+            return sp;
+        }
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            if (m_NamesAssets?.Length > 1)
+                position.xMax -= EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+
+            EditorGUI.BeginProperty(position, label, property);
+
+            var controlPosition = EditorGUI.PrefixLabel(position, label);
+
+            var indent = EditorGUI.indentLevel;
+            EditorGUI.indentLevel = 0;
+            var showMixed = EditorGUI.showMixedValue;
+
+            var value = 0;
+            var everything = 0;
+            var sp = GetFirstChildProperty(property);
+            for (int i = 0, count = MaxNumCategories; i < count; ++i)
+            {
+                EditorGUI.showMixedValue |= sp.hasMultipleDifferentValues;
+                value |= sp.boolValue ? 1 << i : 0;
+                everything |= 1 << i;
+                sp.NextVisible(false);
+            }
+            // in case size is smaller than 32
+            if (value == everything)
+                value = ~0;
+
+            var options = GetOptions();
+            if (
+                EditorGUI.DropdownButton(
+                    controlPosition,
+                    EditorGUIUtility.TrTempContent(GetButtonLabel(value, options)),
+                    FocusType.Passive,
+                    EditorStyles.popup
+                )
+            )
+            {
+                var menu = new GenericMenu();
+
+                menu.AddItem(
+                    new GUIContent(Styles.NothingName),
+                    value == 0,
+                    () =>
+                    {
+                        sp = GetFirstChildProperty(property);
+                        for (int i = 0, count = MaxNumCategories; i < count; ++i)
+                        {
+                            sp.boolValue = false;
+                            sp.NextVisible(false);
+                        }
+                        sp.serializedObject.ApplyModifiedProperties();
+                    }
+                );
+
+                menu.AddItem(
+                    new GUIContent(Styles.EverythingName),
+                    value == ~0,
+                    () =>
+                    {
+                        sp = GetFirstChildProperty(property);
+                        for (int i = 0, count = MaxNumCategories; i < count; ++i)
+                        {
+                            sp.boolValue = true;
+                            sp.NextVisible(false);
+                        }
+                        sp.serializedObject.ApplyModifiedProperties();
+                    }
+                );
+
+                for (var option = 0; option < options.Length; ++option)
+                {
+                    var callbackValue = option;
+                    menu.AddItem(
+                        EditorGUIUtility.TrTextContent(options[option]),
+                        ((1 << option) & value) != 0,
+                        args =>
+                        {
+                            var changedBitAndValue = (KeyValuePair<int, bool>)args;
+                            sp = GetFirstChildProperty(property);
+                            for (int i = 0, count = changedBitAndValue.Key; i < count; ++i)
+                                sp.NextVisible(false);
+                            sp.boolValue = changedBitAndValue.Value;
+                            sp.serializedObject.ApplyModifiedProperties();
+                        },
+                        new KeyValuePair<int, bool>(callbackValue, ((1 << option) & value) == 0)
+                    );
+                }
+
+                menu.AddSeparator(string.Empty);
+
+                menu.AddItem(
+                    EditorGUIUtility.TrTempContent($"Edit {ObjectNames.NicifyVariableName(typeof(T).Name)}"),
+                    false,
+                    () =>
+                    {
+                        if (m_NamesAssets.Length > 0)
+                            Selection.activeObject = m_NamesAssets[0];
+                        else
+                        {
+                            var assetPath = AssetDatabase.GenerateUniqueAssetPath($"Assets/{typeof(T).Name}.asset");
+                            AssetDatabase.CreateAsset(ScriptableObject.CreateInstance<T>(), assetPath);
+                            Selection.activeObject = AssetDatabase.LoadAssetAtPath<T>(assetPath);
+                            m_Options = null;
+                        }
+                    }
+                );
+                menu.DropDown(controlPosition);
+            }
+
+            EditorGUI.showMixedValue = showMixed;
+            EditorGUI.indentLevel = indent;
+
+            EditorGUI.EndProperty();
+
+            if (m_NamesAssets?.Length > 1)
+            {
+                var id = GUIUtility.GetControlID(FocusType.Passive);
+                if (Event.current.type == EventType.Repaint)
+                {
+                    position.width = EditorGUIUtility.singleLineHeight;
+                    position.x = controlPosition.xMax + EditorGUIUtility.standardVerticalSpacing;
+                    Styles.MultipleAssetsWarning.tooltip = string.Format(
+                        Styles.MultipleAssetsTooltip,
+                        ObjectNames.NicifyVariableName(typeof(T).Name),
+                        m_NamesAssets.FirstOrDefault(n => n != null)?.name
+                    );
+                    GUIStyle.none.Draw(position, Styles.MultipleAssetsWarning, id);
+                }
+            }
+        }
+    }
+
+    [CustomPropertyDrawer(typeof(CustomPhysicsBodyTags))]
+    class CustomBodyTagsDrawer : TagsDrawer<CustomPhysicsBodyTagNames>
+    {
+        protected override string DefaultCategoryName => "Custom Physics Body Tag";
+        protected override int MaxNumCategories => 8;
+    }
+
+    [CustomPropertyDrawer(typeof(CustomPhysicsMaterialTags))]
+    class CustomMaterialTagsDrawer : TagsDrawer<CustomPhysicsMaterialTagNames>
+    {
+        protected override string DefaultCategoryName => "Custom Physics Material Tag";
+        protected override int MaxNumCategories => 8;
+    }
+
+    [CustomPropertyDrawer(typeof(PhysicsCategoryTags))]
+    class PhysicsCategoryTagsDrawer : TagsDrawer<PhysicsCategoryNames>
+    {
+        protected override string DefaultCategoryName => "Physics Category";
+        protected override int MaxNumCategories => 32;
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/PropertyDrawers/TagsDrawer.cs.meta

+fileFormatVersion: 2
+guid: bacae2b76edd4224d8ccf21bbeb71833
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Unity.Physics.Custom.Editor.asmdef

+{
+    "name": "Unity.Physics.Custom.Editor",
+    "references": [
+        "Unity.Burst",
+        "Unity.Collections",
+        "Unity.Entities",
+        "Unity.Mathematics",
+        "Unity.Physics",
+        "Unity.Physics.Editor",
+        "Unity.Physics.Hybrid",
+        "Unity.Physics.Samples",
+        "Unity.Physics.Custom"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": []
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Unity.Physics.Custom.Editor.asmdef.meta

+fileFormatVersion: 2
+guid: dde4aa253ec0b874ba280d1bde6b5386
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Utilities.meta

+fileFormatVersion: 2
+guid: f3d7894b5b13854409e8c11b2c933f3e
+timeCreated: 1678290090
\ No newline at end of file

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Utilities/EditorGUIControls.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Unity.Mathematics;
+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    [InitializeOnLoad]
+    static class EditorGUIControls
+    {
+        static EditorGUIControls()
+        {
+            if (k_SoftSlider == null)
+                Debug.LogException(new MissingMemberException("Could not find expected signature of EditorGUI.Slider() for soft slider."));
+        }
+
+        static class Styles
+        {
+            public static readonly string CompatibilityWarning = L10n.Tr("Not compatible with {0}.");
+        }
+
+        public static void DisplayCompatibilityWarning(Rect position, GUIContent label, string incompatibleType)
+        {
+            EditorGUI.HelpBox(
+                EditorGUI.PrefixLabel(position, label),
+                string.Format(Styles.CompatibilityWarning, incompatibleType),
+                MessageType.Error
+            );
+        }
+
+        static readonly MethodInfo k_SoftSlider = typeof(EditorGUI).GetMethod(
+            "Slider",
+            BindingFlags.Static | BindingFlags.NonPublic,
+            null,
+            new[]
+            {
+                typeof(Rect),          // position
+                typeof(GUIContent),    // label
+                typeof(float),         // value
+                typeof(float),         // sliderMin
+                typeof(float),         // sliderMax
+                typeof(float),         // textFieldMin
+                typeof(float)          // textFieldMax
+            },
+            Array.Empty<ParameterModifier>()
+        );
+
+        static readonly object[] k_SoftSliderArgs = new object[7];
+
+        public static void SoftSlider(
+            Rect position, GUIContent label, SerializedProperty property,
+            float sliderMin, float sliderMax,
+            float textFieldMin, float textFieldMax
+        )
+        {
+            if (property.propertyType != SerializedPropertyType.Float)
+            {
+                DisplayCompatibilityWarning(position, label, property.propertyType.ToString());
+            }
+            else if (k_SoftSlider == null)
+            {
+                EditorGUI.BeginChangeCheck();
+                EditorGUI.PropertyField(position, property, label);
+                if (EditorGUI.EndChangeCheck())
+                    property.floatValue = math.clamp(property.floatValue, textFieldMin, textFieldMax);
+            }
+            else
+            {
+                k_SoftSliderArgs[0] = position;
+                k_SoftSliderArgs[1] = label;
+                k_SoftSliderArgs[2] = property.floatValue;
+                k_SoftSliderArgs[3] = sliderMin;
+                k_SoftSliderArgs[4] = sliderMax;
+                k_SoftSliderArgs[5] = textFieldMin;
+                k_SoftSliderArgs[6] = textFieldMax;
+                EditorGUI.BeginProperty(position, label, property);
+                EditorGUI.BeginChangeCheck();
+                var result = k_SoftSlider.Invoke(null, k_SoftSliderArgs);
+                if (EditorGUI.EndChangeCheck())
+                    property.floatValue = (float)result;
+                EditorGUI.EndProperty();
+            }
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Utilities/EditorGUIControls.cs.meta

+fileFormatVersion: 2
+guid: 871e6b9236392b347a91f460fd84f976
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Utilities/ManipulatorUtility.cs

+using System;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    enum MatrixState
+    {
+        UniformScale,
+        NonUniformScale,
+        ZeroScale,
+        NotValidTRS
+    }
+
+    static class ManipulatorUtility
+    {
+        public static MatrixState GetMatrixState(ref float4x4 localToWorld)
+        {
+            if (
+                localToWorld.c0.w != 0f
+                || localToWorld.c1.w != 0f
+                || localToWorld.c2.w != 0f
+                || localToWorld.c3.w != 1f
+            )
+                return MatrixState.NotValidTRS;
+
+            var m = new float3x3(localToWorld.c0.xyz, localToWorld.c1.xyz, localToWorld.c2.xyz);
+            var lossyScale = new float3(math.length(m.c0.xyz), math.length(m.c1.xyz), math.length(m.c2.xyz));
+            if (math.determinant(m) < 0f)
+                lossyScale.x *= -1f;
+            if (math.lengthsq(lossyScale) == 0f)
+                return MatrixState.ZeroScale;
+            return math.abs(math.cmax(lossyScale)) - math.abs(math.cmin(lossyScale)) > 0.000001f
+                ? MatrixState.NonUniformScale
+                : MatrixState.UniformScale;
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Utilities/ManipulatorUtility.cs.meta

+fileFormatVersion: 2
+guid: 1ed6267b3a6f75e4aa4aca986451797e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Utilities/SceneViewUtility.cs

+using System;
+using Unity.Mathematics;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    static class SceneViewUtility
+    {
+        static class Styles
+        {
+            public static readonly GUIStyle ProgressBarTrack = new GUIStyle
+            {
+                fixedHeight = 4f,
+                normal = new GUIStyleState { background = Texture2D.whiteTexture }
+            };
+            public static readonly GUIStyle ProgressBarIndicator = new GUIStyle
+            {
+                fixedHeight = 4f,
+                normal = new GUIStyleState { background = Texture2D.whiteTexture }
+            };
+            public static readonly GUIStyle SceneViewStatusMessage = new GUIStyle("NotificationBackground")
+            {
+                fontSize = EditorStyles.label.fontSize
+            };
+
+            static Styles() => SceneViewStatusMessage.padding = SceneViewStatusMessage.border;
+        }
+
+        const string k_NotificationsPrefKey = "SceneView/Tools/Notifications";
+        const bool k_DefaultNotifications = true;
+        const string k_NotificationSpeedPrefKey = "SceneView/Tools/Notification Speed";
+        const float k_DefaultNotificationsSpeed = 20f;
+
+        const float k_NotificationDuration = 1f;
+        const float k_NotificationFadeInTime = 0.04f;
+        const float k_NotificationFadeOutTime = 0.2f;
+        static readonly AnimationCurve k_NotificationFadeCurve = new AnimationCurve
+        {
+            keys = new[]
+            {
+                new Keyframe { time = 0f, value = 0f, outTangent = 1f / k_NotificationFadeInTime },
+                new Keyframe { time = k_NotificationFadeInTime, value = 1f, inTangent = 0f, outTangent = 0f },
+                new Keyframe { time = k_NotificationDuration - k_NotificationFadeOutTime, value = 1f, inTangent = 0f, outTangent = 0f },
+                new Keyframe { time = k_NotificationDuration, value = 0f, inTangent = -1f / k_NotificationFadeOutTime }
+            },
+            postWrapMode = WrapMode.Clamp,
+            preWrapMode = WrapMode.Clamp
+        };
+        const float k_IndeterminateProgressCurveDuration = 2f;
+        static readonly AnimationCurve k_IndeterminateProgressCurveLeftMargin = new AnimationCurve
+        {
+            keys = new[]
+            {
+                new Keyframe { time = 0f, value = 0f, inTangent = 0f, outTangent = 0f },
+                new Keyframe { time = k_IndeterminateProgressCurveDuration / 2f, value = 0.25f, inTangent = 0f, outTangent = 0f },
+                new Keyframe { time = k_IndeterminateProgressCurveDuration, value = 1f, inTangent = 0f, outTangent = 0f }
+            },
+            postWrapMode = WrapMode.Loop,
+            preWrapMode = WrapMode.Loop
+        };
+        static readonly AnimationCurve k_IndeterminateProgressCurveRightMargin = new AnimationCurve
+        {
+            keys = new[]
+            {
+                new Keyframe { time = 0f, value = 1f, inTangent = 0f, outTangent = 0f },
+                new Keyframe { time = k_IndeterminateProgressCurveDuration / 2f, value = 0f, inTangent = 0f, outTangent = 0f },
+                new Keyframe { time = k_IndeterminateProgressCurveDuration, value = 0f, inTangent = 0f, outTangent = 0f }
+            },
+            postWrapMode = WrapMode.Loop,
+            preWrapMode = WrapMode.Loop
+        };
+
+        static string s_StatusMessage;
+        static DateTime s_StartTime;
+        static bool s_IsTemporary;
+        static Func<float> s_GetProgress;
+
+        public static void DisplayProgressNotification(string message, Func<float> getProgress) =>
+            // insert an extra line to make room for progress bar
+            DisplayNotificationInSceneView(getProgress == null ? message : $"{message}\n", false, getProgress);
+
+        public static void DisplayPersistentNotification(string message) =>
+            DisplayNotificationInSceneView(message, false, null);
+
+        public static void DisplayTemporaryNotification(string message) =>
+            DisplayNotificationInSceneView(message, true, null);
+
+        static void DisplayNotificationInSceneView(string message, bool temporary, Func<float> getProgress)
+        {
+            s_StatusMessage = message ?? string.Empty;
+            s_StartTime = DateTime.Now;
+            s_IsTemporary = temporary;
+            s_GetProgress = getProgress;
+            ClearNotificationInSceneView();
+            SceneView.duringSceneGui += ToolNotificationCallback;
+            SceneView.RepaintAll();
+        }
+
+        static void ToolNotificationCallback(SceneView obj)
+        {
+            if (Camera.current == null)
+                return;
+
+            var duration = math.max(s_StatusMessage.Length, 1)
+                / EditorPrefs.GetFloat(k_NotificationSpeedPrefKey, k_DefaultNotificationsSpeed);
+            var t = (float)(DateTime.Now - s_StartTime).TotalSeconds;
+            if (
+                s_IsTemporary
+                && (t >= duration || !EditorPrefs.GetBool(k_NotificationsPrefKey, k_DefaultNotifications))
+            )
+            {
+                ClearNotificationInSceneView();
+            }
+            else
+            {
+                Handles.BeginGUI();
+                var color = GUI.color;
+                var progress = s_GetProgress?.Invoke() ?? 0f;
+                GUI.color *=
+                    new Color(1f, 1f, 1f, math.max(k_NotificationFadeCurve.Evaluate(math.abs(t) / duration), progress));
+                var rect = new Rect { size = Camera.current.pixelRect.size / EditorGUIUtility.pixelsPerPoint };
+                using (new GUILayout.AreaScope(rect))
+                using (new GUILayout.HorizontalScope())
+                {
+                    GUILayout.FlexibleSpace();
+                    using (new GUILayout.VerticalScope())
+                    {
+                        GUILayout.Space(rect.height * 0.75f);
+                        GUILayout.FlexibleSpace();
+                        var maxWidth = rect.width * 0.5f;
+                        GUILayout.Box(s_StatusMessage, Styles.SceneViewStatusMessage, GUILayout.MaxWidth(maxWidth));
+                        if (s_GetProgress != null)
+                        {
+                            rect = GUILayoutUtility.GetLastRect();
+                            rect = Styles.SceneViewStatusMessage.padding.Remove(rect);
+                            rect.y = rect.yMax - Styles.ProgressBarTrack.fixedHeight;
+                            rect.height = Styles.ProgressBarTrack.fixedHeight;
+                            var c = GUI.color;
+                            GUI.color *= Color.black;
+                            GUI.Box(rect, GUIContent.none, Styles.ProgressBarTrack);
+                            GUI.color = c;
+                            if (progress >= 0f && progress <= 1f)
+                            {
+                                rect.width *= progress;
+                            }
+                            else
+                            {
+                                var w = rect.width;
+                                rect.xMin = rect.xMin + w * k_IndeterminateProgressCurveLeftMargin.Evaluate(t);
+                                rect.xMax = rect.xMax - w * k_IndeterminateProgressCurveRightMargin.Evaluate(t);
+                            }
+                            GUI.Box(rect, GUIContent.none, Styles.ProgressBarIndicator);
+                        }
+                        GUILayout.FlexibleSpace();
+                    }
+                    GUILayout.FlexibleSpace();
+                }
+                GUI.color = color;
+                Handles.EndGUI();
+            }
+
+            SceneView.RepaintAll();
+        }
+
+        public static void ClearNotificationInSceneView() => SceneView.duringSceneGui -= ToolNotificationCallback;
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Utilities/SceneViewUtility.cs.meta

+fileFormatVersion: 2
+guid: b7c9bbfa7889d6e4faa42c14d33bebb7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Utilities/StatusMessageUtility.cs

+using System.Collections.Generic;
+using System.Linq;
+using Unity.Physics.Authoring;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Physics.Editor
+{
+    static class StatusMessageUtility
+    {
+        public static MessageType GetHierarchyStatusMessage(IReadOnlyList<UnityEngine.Object> targets, out string statusMessage)
+        {
+            statusMessage = string.Empty;
+            if (targets.Count == 0)
+                return MessageType.None;
+
+            var numChildTargets = 0;
+            foreach (Component c in targets)
+            {
+                // hierarchy roots and leaf shapes do not emit a message
+                if (
+                    c == null
+                    || c.transform.parent == null
+                    || PhysicsShapeExtensions.GetPrimaryBody(c.gameObject) != c.gameObject
+                )
+                    continue;
+
+                var targetType = c.GetType();
+                // only bodies (both explicit and implicit static bodies) will emit a message
+                if (
+                    targetType == typeof(PhysicsBodyAuthoring)
+                    || targetType == typeof(Rigidbody)
+                    || c.GetComponent<PhysicsBodyAuthoring>() == null
+                    && c.GetComponent<Rigidbody>() == null
+                )
+                    ++numChildTargets;
+            }
+
+            switch (numChildTargets)
+            {
+                case 0:
+                    return MessageType.None;
+                case 1:
+                    statusMessage =
+                        L10n.Tr("Target will be un-parented during the conversion process in order to take part in physics simulation.");
+                    return MessageType.Warning;
+                default:
+                    statusMessage =
+                        L10n.Tr("One or more targets will be un-parented during the conversion process in order to take part in physics simulation.");
+                    return MessageType.Warning;
+            }
+        }
+
+        public static MessageType GetMatrixStatusMessage(
+            IReadOnlyList<MatrixState> matrixStates, out string statusMessage
+        )
+        {
+            statusMessage = string.Empty;
+            if (matrixStates.Contains(MatrixState.NotValidTRS))
+            {
+                statusMessage = L10n.Tr(
+                    matrixStates.Count == 1
+                    ? "Target's local-to-world matrix is not a valid transformation."
+                    : "One or more targets' local-to-world matrices are not valid transformations."
+                );
+                return MessageType.Error;
+            }
+
+            if (matrixStates.Contains(MatrixState.ZeroScale))
+            {
+                statusMessage =
+                    L10n.Tr(matrixStates.Count == 1 ? "Target has zero scale." : "One or more targets has zero scale.");
+                return MessageType.Warning;
+            }
+
+            if (matrixStates.Contains(MatrixState.NonUniformScale))
+            {
+                statusMessage = L10n.Tr(
+                    matrixStates.Count == 1
+                    ? "Target has non-uniform scale. Shape data will be transformed during conversion in order to bake scale into the run-time format."
+                    : "One or more targets has non-uniform scale. Shape data will be transformed during conversion in order to bake scale into the run-time format."
+                );
+                return MessageType.Warning;
+            }
+
+            return MessageType.None;
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.Editor/Utilities/StatusMessageUtility.cs.meta

+fileFormatVersion: 2
+guid: 73b942099bb387a48abd183643304f85
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom.meta

+fileFormatVersion: 2
+guid: 0daf7b2549ab2f04c8a53849098d77e3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/AssemblyInfo.cs

+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Unity.Physics.Custom.Editor")]
+[assembly: InternalsVisibleTo("Unity.Physics.Custom.EditModeTests")]

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/AssemblyInfo.cs.meta

+fileFormatVersion: 2
+guid: 79534194088d466faf51dedb0dbb3012
+timeCreated: 1680051514
\ No newline at end of file

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/BaseBodyPairConnector.cs

+using Unity.Entities;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Physics.Authoring
+{
+    [RequireComponent(typeof(PhysicsBodyAuthoring))]
+    public abstract class BaseBodyPairConnector : MonoBehaviour
+    {
+        public PhysicsBodyAuthoring LocalBody => GetComponent<PhysicsBodyAuthoring>();
+        public PhysicsBodyAuthoring ConnectedBody;
+
+        public RigidTransform worldFromA => LocalBody == null
+        ? RigidTransform.identity
+        : Math.DecomposeRigidBodyTransform(LocalBody.transform.localToWorldMatrix);
+
+        public RigidTransform worldFromB => ConnectedBody == null
+        ? RigidTransform.identity
+        : Math.DecomposeRigidBodyTransform(ConnectedBody.transform.localToWorldMatrix);
+
+
+        public Entity EntityA { get; set; }
+
+        public Entity EntityB { get; set; }
+
+
+        void OnEnable()
+        {
+            // included so tick box appears in Editor
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/BaseBodyPairConnector.cs.meta

+fileFormatVersion: 2
+guid: 239c8ffb2d0d90043a794cea1df207f7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Bodies.meta

+fileFormatVersion: 2
+guid: 67021bc32b354a27adca79ce72cc0632
+timeCreated: 1678114562
\ No newline at end of file

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Bodies/BakingSystems.meta

+fileFormatVersion: 2
+guid: debd1c7da217451682429a0a443b3fb4
+timeCreated: 1678225532
\ No newline at end of file

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Bodies/BakingSystems/PhysicsBodyBakingSystem.cs

+using System.Collections.Generic;
+using Unity.Entities;
+using Unity.Mathematics;
+using Unity.Physics.Extensions;
+using Unity.Physics.GraphicsIntegration;
+using Unity.Transforms;
+using UnityEngine;
+
+namespace Unity.Physics.Authoring
+{
+    [TemporaryBakingType]
+    public struct PhysicsBodyAuthoringData : IComponentData
+    {
+        public bool IsDynamic;
+        public float Mass;
+        public bool OverrideDefaultMassDistribution;
+        public MassDistribution CustomMassDistribution;
+    }
+
+    class PhysicsBodyAuthoringBaker : BasePhysicsBaker<PhysicsBodyAuthoring>
+    {
+        internal List<UnityEngine.Collider> colliderComponents = new List<UnityEngine.Collider>();
+        internal List<PhysicsShapeAuthoring> physicsShapeComponents = new List<PhysicsShapeAuthoring>();
+
+        public override void Bake(PhysicsBodyAuthoring authoring)
+        {
+            // Priority is to Legacy Components. Ignore if baked by Legacy.
+            if (GetComponent<Rigidbody>()  || GetComponent<UnityEngine.Collider>())
+            {
+                return;
+            }
+
+            var entity = GetEntity(TransformUsageFlags.Dynamic);
+            // To process later in the Baking System
+            AddComponent(entity, new PhysicsBodyAuthoringData
+            {
+                IsDynamic = (authoring.MotionType == BodyMotionType.Dynamic),
+                Mass = authoring.Mass,
+                OverrideDefaultMassDistribution = authoring.OverrideDefaultMassDistribution,
+                CustomMassDistribution = authoring.CustomMassDistribution
+            });
+
+            AddSharedComponent(entity, new PhysicsWorldIndex(authoring.WorldIndex));
+
+            var bodyTransform = GetComponent<Transform>();
+
+            var motionType = authoring.MotionType;
+            var hasSmoothing = authoring.Smoothing != BodySmoothing.None;
+
+            PostProcessTransform(bodyTransform, motionType);
+
+            var customTags = authoring.CustomTags;
+            if (!customTags.Equals(CustomPhysicsBodyTags.Nothing))
+                AddComponent(entity, new PhysicsCustomTags { Value = customTags.Value });
+
+            // Check that there is at least one collider in the hierarchy to add these three
+            GetComponentsInChildren(colliderComponents);
+            GetComponentsInChildren(physicsShapeComponents);
+            if (colliderComponents.Count > 0 || physicsShapeComponents.Count > 0)
+            {
+                AddComponent(entity, new PhysicsCompoundData()
+                {
+                    AssociateBlobToBody = false,
+                    ConvertedBodyInstanceID = authoring.GetInstanceID(),
+                    Hash = default,
+                });
+                AddComponent<PhysicsRootBaked>(entity);
+                AddComponent<PhysicsCollider>(entity);
+            }
+
+            if (authoring.MotionType == BodyMotionType.Static || IsStatic())
+                return;
+
+            var massProperties = MassProperties.UnitSphere;
+
+            AddComponent(entity, authoring.MotionType == BodyMotionType.Dynamic ?
+                PhysicsMass.CreateDynamic(massProperties, authoring.Mass) :
+                PhysicsMass.CreateKinematic(massProperties));
+
+            var physicsVelocity = new PhysicsVelocity
+            {
+                Linear = authoring.InitialLinearVelocity,
+                Angular = authoring.InitialAngularVelocity
+            };
+            AddComponent(entity, physicsVelocity);
+
+            if (authoring.MotionType == BodyMotionType.Dynamic)
+            {
+                // TODO make these optional in editor?
+                AddComponent(entity, new PhysicsDamping
+                {
+                    Linear = authoring.LinearDamping,
+                    Angular = authoring.AngularDamping
+                });
+                if (authoring.GravityFactor != 1)
+                {
+                    AddComponent(entity, new PhysicsGravityFactor
+                    {
+                        Value = authoring.GravityFactor
+                    });
+                }
+            }
+            else if (authoring.MotionType == BodyMotionType.Kinematic)
+            {
+                AddComponent(entity, new PhysicsGravityFactor
+                {
+                    Value = 0
+                });
+            }
+
+            if (hasSmoothing)
+            {
+                AddComponent(entity, new PhysicsGraphicalSmoothing());
+                if (authoring.Smoothing == BodySmoothing.Interpolation)
+                {
+                    AddComponent(entity, new PhysicsGraphicalInterpolationBuffer
+                    {
+                        PreviousTransform = Math.DecomposeRigidBodyTransform(bodyTransform.localToWorldMatrix),
+                        PreviousVelocity = physicsVelocity,
+                    });
+                }
+            }
+        }
+    }
+
+    [RequireMatchingQueriesForUpdate]
+    [UpdateAfter(typeof(EndColliderBakingSystem))]
+    [WorldSystemFilter(WorldSystemFilterFlags.BakingSystem)]
+    public partial struct PhysicsBodyBakingSystem : ISystem
+    {
+        public void OnUpdate(ref SystemState state)
+        {
+            var entityManager = state.EntityManager;
+
+            // Fill in the mass properties based on custom mass properties for bodies without colliders
+            foreach (var(physicsMass, bodyData, entity) in
+                     SystemAPI.Query<RefRW<PhysicsMass>, RefRO<PhysicsBodyAuthoringData>>()
+                         .WithNone<PhysicsCollider>()
+                         .WithEntityAccess()
+                         .WithOptions(EntityQueryOptions.IncludePrefab | EntityQueryOptions.IncludeDisabledEntities))
+            {
+                physicsMass.ValueRW = CreatePhysicsMass(entityManager, entity, bodyData.ValueRO, MassProperties.UnitSphere);
+            }
+
+            // Fill in the mass properties based on collider and custom mass properties if provided.
+            foreach (var(physicsMass, bodyData, collider, entity) in
+                     SystemAPI.Query<RefRW<PhysicsMass>, RefRO<PhysicsBodyAuthoringData>, RefRO<PhysicsCollider>>()
+                         .WithEntityAccess()
+                         .WithOptions(EntityQueryOptions.IncludePrefab | EntityQueryOptions.IncludeDisabledEntities))
+            {
+                physicsMass.ValueRW = CreatePhysicsMass(entityManager, entity, bodyData.ValueRO,
+                    collider.ValueRO.MassProperties, true);
+            }
+        }
+
+        private PhysicsMass CreatePhysicsMass(EntityManager entityManager, in Entity entity,
+            in PhysicsBodyAuthoringData inBodyData, in MassProperties inMassProperties, in bool hasCollider = false)
+        {
+            var massProperties = inMassProperties;
+            var scale = 1f;
+
+            // Scale the provided mass properties by the LocalTransform.Scale value to create the correct
+            // initial mass distribution for the rigid body.
+            if (entityManager.HasComponent<LocalTransform>(entity))
+            {
+                var localTransform = entityManager.GetComponentData<LocalTransform>(entity);
+                scale = localTransform.Scale;
+
+                massProperties.Scale(scale);
+            }
+
+            // Override the mass properties with user-provided values if specified
+            if (inBodyData.OverrideDefaultMassDistribution)
+            {
+                massProperties.MassDistribution = inBodyData.CustomMassDistribution;
+                if (hasCollider)
+                {
+                    // Increase the angular expansion factor to account for the shift in center of mass
+                    massProperties.AngularExpansionFactor += math.length(massProperties.MassDistribution.Transform.pos -
+                        inBodyData.CustomMassDistribution.Transform.pos);
+                }
+            }
+
+            // Create the physics mass properties. Among others, this scales the unit mass inertia tensor
+            // by the scalar mass of the rigid body.
+            var physicsMass = inBodyData.IsDynamic ?
+                PhysicsMass.CreateDynamic(massProperties, inBodyData.Mass) :
+                PhysicsMass.CreateKinematic(massProperties);
+
+            // Now, apply inverse scale to the final, baked physics mass properties in order to prevent invalid simulated mass properties
+            // caused by runtime scaling of the mass properties later on while building the physics world.
+            physicsMass = physicsMass.ApplyScale(math.rcp(scale));
+
+            return physicsMass;
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Bodies/BakingSystems/PhysicsBodyBakingSystem.cs.meta

+fileFormatVersion: 2
+guid: 922a37a81b1c6cc4da69a1148c8d2988
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Bodies/BakingSystems/PhysicsShapeBakingSystem.cs.meta

+fileFormatVersion: 2
+guid: c7b2bb3849ee2c24ea6f8416bc3c8ee0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Bodies/PhysicsBodyAuthoring.cs

+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Physics.Authoring
+{
+    /// <summary>   The physics body authoring. This class cannot be inherited. </summary>
+#if UNITY_2021_2_OR_NEWER
+    [Icon(k_IconPath)]
+#endif
+    [AddComponentMenu("Entities/Physics/Physics Body")]
+    [DisallowMultipleComponent]
+    public sealed class PhysicsBodyAuthoring : MonoBehaviour
+    {
+        const string k_IconPath = "Packages/com.unity.physics/Unity.Physics.Editor/Editor Default Resources/Icons/d_Rigidbody@64.png";
+
+        PhysicsBodyAuthoring() {}
+
+        public BodyMotionType MotionType { get => m_MotionType; set => m_MotionType = value; }
+        [SerializeField]
+        [Tooltip("Specifies whether the body should be fully physically simulated, moved directly, or fixed in place.")]
+        BodyMotionType m_MotionType;
+
+        public BodySmoothing Smoothing { get => m_Smoothing; set => m_Smoothing = value; }
+        [SerializeField]
+        [Tooltip("Specifies how this body's motion in its graphics representation should be smoothed when the rendering framerate is greater than the fixed step rate used by physics.")]
+        BodySmoothing m_Smoothing = BodySmoothing.None;
+
+        const float k_MinimumMass = 0.001f;
+
+        public float Mass
+        {
+            get => m_MotionType == BodyMotionType.Dynamic ? m_Mass : float.PositiveInfinity;
+            set => m_Mass = math.max(k_MinimumMass, value);
+        }
+        [SerializeField]
+        float m_Mass = 1.0f;
+
+        public float LinearDamping { get => m_LinearDamping; set => m_LinearDamping = math.max(0f, value); }
+        [SerializeField]
+        [Tooltip("This is applied to a body's linear velocity reducing it over time.")]
+        float m_LinearDamping = 0.01f;
+
+        public float AngularDamping { get => m_AngularDamping; set => m_AngularDamping = math.max(0f, value); }
+        [SerializeField]
+        [Tooltip("This is applied to a body's angular velocity reducing it over time.")]
+        float m_AngularDamping = 0.05f;
+
+        public float3 InitialLinearVelocity { get => m_InitialLinearVelocity; set => m_InitialLinearVelocity = value; }
+        [SerializeField]
+        [Tooltip("The initial linear velocity of the body in world space")]
+        float3 m_InitialLinearVelocity = float3.zero;
+
+        public float3 InitialAngularVelocity { get => m_InitialAngularVelocity; set => m_InitialAngularVelocity = value; }
+        [SerializeField]
+        [Tooltip("This represents the initial rotation speed around each axis in the local motion space of the body i.e. around the center of mass")]
+        float3 m_InitialAngularVelocity = float3.zero;
+
+        public float GravityFactor
+        {
+            get => m_MotionType == BodyMotionType.Dynamic ? m_GravityFactor : 0f;
+            set => m_GravityFactor = value;
+        }
+        [SerializeField]
+        [Tooltip("Scales the amount of gravity to apply to this body.")]
+        float m_GravityFactor = 1f;
+
+        public bool OverrideDefaultMassDistribution
+        {
+#pragma warning disable 618
+            get => m_OverrideDefaultMassDistribution;
+            set => m_OverrideDefaultMassDistribution = value;
+#pragma warning restore 618
+        }
+        [SerializeField]
+        [Tooltip("Override default mass distribution based on the shapes associated with this body by the specified mass distribution, assuming unit mass.")]
+        bool m_OverrideDefaultMassDistribution;
+
+        public MassDistribution CustomMassDistribution
+        {
+            get => new MassDistribution
+            {
+                Transform = new RigidTransform(m_Orientation, m_CenterOfMass),
+                InertiaTensor =
+                    m_MotionType == BodyMotionType.Dynamic ? m_InertiaTensor : new float3(float.PositiveInfinity)
+            };
+            set
+            {
+                m_CenterOfMass = value.Transform.pos;
+                m_Orientation.SetValue(value.Transform.rot);
+                m_InertiaTensor = value.InertiaTensor;
+#pragma warning disable 618
+                m_OverrideDefaultMassDistribution = true;
+#pragma warning restore 618
+            }
+        }
+
+        [SerializeField]
+        float3 m_CenterOfMass;
+
+        [SerializeField]
+        EulerAngles m_Orientation = EulerAngles.Default;
+
+        [SerializeField]
+        // Default value to solid unit sphere : https://en.wikipedia.org/wiki/List_of_moments_of_inertia
+        float3 m_InertiaTensor = new float3(2f / 5f);
+
+        public uint WorldIndex { get => m_WorldIndex; set => m_WorldIndex = value; }
+        [SerializeField]
+        [Tooltip("The index of the physics world this body belongs to. Default physics world has index 0.")]
+        uint m_WorldIndex = 0;
+
+        public CustomPhysicsBodyTags CustomTags { get => m_CustomTags; set => m_CustomTags = value; }
+        [SerializeField]
+        CustomPhysicsBodyTags m_CustomTags = CustomPhysicsBodyTags.Nothing;
+
+        void OnEnable()
+        {
+            // included so tick box appears in Editor
+        }
+
+        void OnValidate()
+        {
+            m_Mass = math.max(k_MinimumMass, m_Mass);
+            m_LinearDamping = math.max(m_LinearDamping, 0f);
+            m_AngularDamping = math.max(m_AngularDamping, 0f);
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Bodies/PhysicsBodyAuthoring.cs.meta

+fileFormatVersion: 2
+guid: ccea9ea98e38942e0b0938c27ed1903e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Bodies/PhysicsShapeAuthoring.cs.meta

+fileFormatVersion: 2
+guid: b275e5f92732148048d7b77e264ac30e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/CustomPhysicsMaterialTagNames.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Unity.Physics.Authoring
+{
+    [CreateAssetMenu(menuName = "Unity Physics/Custom Physics Material Tag Names", fileName = "Custom Material Tag Names", order = 506)]
+    public sealed partial class CustomPhysicsMaterialTagNames : ScriptableObject, ITagNames
+    {
+        CustomPhysicsMaterialTagNames() {}
+
+        public IReadOnlyList<string> TagNames => m_TagNames;
+        [SerializeField]
+        [FormerlySerializedAs("m_FlagNames")]
+        string[] m_TagNames = Enumerable.Range(0, 8).Select(i => string.Empty).ToArray();
+
+        void OnValidate()
+        {
+            if (m_TagNames.Length != 8)
+                Array.Resize(ref m_TagNames, 8);
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/CustomPhysicsMaterialTagNames.cs.meta

+fileFormatVersion: 2
+guid: 7c8956dd10f66427faa4a4067c5dd97d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7c7a0159cb0d5433b90c970978f6cf5c, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/CustomPhysicsMaterialTags.cs

+using System;
+using Unity.Mathematics;
+
+namespace Unity.Physics.Authoring
+{
+    [Serializable]
+    public struct CustomPhysicsMaterialTags : IEquatable<CustomPhysicsMaterialTags>
+    {
+        public static CustomPhysicsMaterialTags Everything => new CustomPhysicsMaterialTags { Value = unchecked((byte)~0) };
+        public static CustomPhysicsMaterialTags Nothing => new CustomPhysicsMaterialTags { Value = 0 };
+
+        public bool Tag00;
+        public bool Tag01;
+        public bool Tag02;
+        public bool Tag03;
+        public bool Tag04;
+        public bool Tag05;
+        public bool Tag06;
+        public bool Tag07;
+
+        internal bool this[int i]
+        {
+            get
+            {
+                SafetyChecks.CheckInRangeAndThrow(i, new int2(0, 7), nameof(i));
+                switch (i)
+                {
+                    case 0: return Tag00;
+                    case 1: return Tag01;
+                    case 2: return Tag02;
+                    case 3: return Tag03;
+                    case 4: return Tag04;
+                    case 5: return Tag05;
+                    case 6: return Tag06;
+                    case 7: return Tag07;
+                    default: return default;
+                }
+            }
+            set
+            {
+                SafetyChecks.CheckInRangeAndThrow(i, new int2(0, 7), nameof(i));
+                switch (i)
+                {
+                    case 0: Tag00 = value; break;
+                    case 1: Tag01 = value; break;
+                    case 2: Tag02 = value; break;
+                    case 3: Tag03 = value; break;
+                    case 4: Tag04 = value; break;
+                    case 5: Tag05 = value; break;
+                    case 6: Tag06 = value; break;
+                    case 7: Tag07 = value; break;
+                }
+            }
+        }
+
+        public byte Value
+        {
+            get
+            {
+                var result = 0;
+                result |= (Tag00 ? 1 : 0) << 0;
+                result |= (Tag01 ? 1 : 0) << 1;
+                result |= (Tag02 ? 1 : 0) << 2;
+                result |= (Tag03 ? 1 : 0) << 3;
+                result |= (Tag04 ? 1 : 0) << 4;
+                result |= (Tag05 ? 1 : 0) << 5;
+                result |= (Tag06 ? 1 : 0) << 6;
+                result |= (Tag07 ? 1 : 0) << 7;
+                return (byte)result;
+            }
+            set
+            {
+                Tag00 = (value & (1 << 0)) != 0;
+                Tag01 = (value & (1 << 1)) != 0;
+                Tag02 = (value & (1 << 2)) != 0;
+                Tag03 = (value & (1 << 3)) != 0;
+                Tag04 = (value & (1 << 4)) != 0;
+                Tag05 = (value & (1 << 5)) != 0;
+                Tag06 = (value & (1 << 6)) != 0;
+                Tag07 = (value & (1 << 7)) != 0;
+            }
+        }
+
+        public bool Equals(CustomPhysicsMaterialTags other) => Value == other.Value;
+
+        public override bool Equals(object obj) => obj is CustomPhysicsMaterialTags other && Equals(other);
+
+        public override int GetHashCode() => Value;
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/CustomPhysicsMaterialTags.cs.meta

+fileFormatVersion: 2
+guid: 05cffa1394b6f481ca7e686dfc6404b9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/EditorInitialization.cs

+#if UNITY_EDITOR
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Build;
+
+namespace Unity.Physics.Authoring
+{
+    [InitializeOnLoad]
+    class EditorInitialization
+    {
+        static readonly string k_CustomDefine = "UNITY_PHYSICS_CUSTOM";
+
+        static EditorInitialization()
+        {
+            var fromBuildTargetGroup = NamedBuildTarget.FromBuildTargetGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
+            var definesStr = PlayerSettings.GetScriptingDefineSymbols(fromBuildTargetGroup);
+            var defines = definesStr.Split(';').ToList();
+            var found = defines.Find(define => define.Equals(k_CustomDefine));
+            if (found == null)
+            {
+                defines.Add(k_CustomDefine);
+                PlayerSettings.SetScriptingDefineSymbols(fromBuildTargetGroup, string.Join(";", defines.ToArray()));
+            }
+        }
+    }
+}
+#endif

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/EditorInitialization.cs.meta

+fileFormatVersion: 2
+guid: 23f03a5c38aa4a6e81448a178cc0a09f
+timeCreated: 1680128866
\ No newline at end of file

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints.meta

+fileFormatVersion: 2
+guid: 7f26f023234dd844797f8158565ecb4f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/BallAndSocketJoint.cs

+using System;
+using Unity.Collections;
+using Unity.Entities;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Physics.Authoring
+{
+    [BakingType]
+    public struct JointEntityBaking : IComponentData
+    {
+        public Entity Entity;
+    }
+
+    public class BallAndSocketJoint : BaseJoint
+    {
+        // Editor only settings
+        [HideInInspector]
+        public bool EditPivots;
+
+        [Tooltip("If checked, PositionLocal will snap to match PositionInConnectedEntity")]
+        public bool AutoSetConnected = true;
+
+        public float3 PositionLocal;
+        public float3 PositionInConnectedEntity;
+
+        public virtual void UpdateAuto()
+        {
+            if (AutoSetConnected)
+            {
+                RigidTransform bFromA = math.mul(math.inverse(worldFromB), worldFromA);
+                PositionInConnectedEntity = math.transform(bFromA, PositionLocal);
+            }
+        }
+    }
+
+    public abstract class JointBaker<T> : Baker<T> where T : BaseJoint
+    {
+        protected PhysicsConstrainedBodyPair GetConstrainedBodyPair(BaseJoint authoring)
+        {
+            return new PhysicsConstrainedBodyPair(
+                GetEntity(TransformUsageFlags.Dynamic),
+                authoring.ConnectedBody == null ? Entity.Null : GetEntity(authoring.ConnectedBody, TransformUsageFlags.Dynamic),
+                authoring.EnableCollision
+            );
+        }
+
+        public Entity CreateJointEntity(uint worldIndex, PhysicsConstrainedBodyPair constrainedBodyPair, PhysicsJoint joint)
+        {
+            using (var joints = new NativeArray<PhysicsJoint>(1, Allocator.Temp) { [0] = joint })
+            using (var jointEntities = new NativeList<Entity>(1, Allocator.Temp))
+            {
+                CreateJointEntities(worldIndex, constrainedBodyPair, joints, jointEntities);
+                return jointEntities[0];
+            }
+        }
+
+        public uint GetWorldIndex(Component c)
+        {
+            uint worldIndex = 0;
+            if (c)
+            {
+                var physicsBody = GetComponent<PhysicsBodyAuthoring>(c);
+                if (physicsBody != null)
+                {
+                    worldIndex = physicsBody.WorldIndex;
+                }
+            }
+            return worldIndex;
+        }
+
+        public uint GetWorldIndexFromBaseJoint(BaseJoint authoring)
+        {
+            var physicsBody = GetComponent<PhysicsBodyAuthoring>(authoring);
+            uint worldIndex = physicsBody.WorldIndex;
+            if (authoring.ConnectedBody == null)
+            {
+                return worldIndex;
+            }
+
+            var connectedBody = GetComponent<PhysicsBodyAuthoring>(authoring.ConnectedBody);
+            if (connectedBody != null)
+            {
+                Assertions.Assert.AreEqual(worldIndex, connectedBody.WorldIndex);
+            }
+
+            return worldIndex;
+        }
+
+        public void CreateJointEntities(uint worldIndex, PhysicsConstrainedBodyPair constrainedBodyPair, NativeArray<PhysicsJoint> joints, NativeList<Entity> newJointEntities)
+        {
+            if (!joints.IsCreated || joints.Length == 0)
+                return;
+
+            if (newJointEntities.IsCreated)
+                newJointEntities.Clear();
+            else
+                newJointEntities = new NativeList<Entity>(joints.Length, Allocator.Temp);
+
+            // create all new joints
+            var multipleJoints = joints.Length > 1;
+
+            var entity = GetEntity(TransformUsageFlags.Dynamic);
+            for (var i = 0; i < joints.Length; ++i)
+            {
+                var jointEntity = CreateAdditionalEntity(TransformUsageFlags.Dynamic);
+                AddSharedComponent(jointEntity, new PhysicsWorldIndex(worldIndex));
+
+                AddComponent(jointEntity, constrainedBodyPair);
+                AddComponent(jointEntity, joints[i]);
+
+                newJointEntities.Add(jointEntity);
+
+                if (GetComponent<ModifyJointLimitsAuthoring>() != null)
+                {
+                    AddComponent(jointEntity, new JointEntityBaking()
+                    {
+                        Entity = entity
+                    });
+                    AddSharedComponentManaged(jointEntity, new ModifyJointLimits());
+                }
+            }
+
+            if (multipleJoints)
+            {
+                // set companion buffers for new joints
+                for (var i = 0; i < joints.Length; ++i)
+                {
+                    var companions = AddBuffer<PhysicsJointCompanion>(newJointEntities[i]);
+                    for (var j = 0; j < joints.Length; ++j)
+                    {
+                        if (i == j)
+                            continue;
+                        companions.Add(new PhysicsJointCompanion {JointEntity = newJointEntities[j]});
+                    }
+                }
+            }
+        }
+    }
+
+    class BallAndSocketJointBaker : JointBaker<BallAndSocketJoint>
+    {
+        public override void Bake(BallAndSocketJoint authoring)
+        {
+            authoring.UpdateAuto();
+            var physicsJoint = PhysicsJoint.CreateBallAndSocket(authoring.PositionLocal, authoring.PositionInConnectedEntity);
+            physicsJoint.SetImpulseEventThresholdAllConstraints(authoring.MaxImpulse);
+
+            var constraintBodyPair = GetConstrainedBodyPair(authoring);
+
+            uint worldIndex = GetWorldIndexFromBaseJoint(authoring);
+            CreateJointEntity(worldIndex, constraintBodyPair, physicsJoint);
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/BallAndSocketJoint.cs.meta

+fileFormatVersion: 2
+guid: 28a669fa0e32f734c9d34661ccdfd58d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/BaseJoint.cs

+using Unity.Mathematics;
+
+namespace Unity.Physics.Authoring
+{
+    public abstract class BaseJoint : BaseBodyPairConnector
+    {
+        public bool EnableCollision;
+        public float3 MaxImpulse = float.PositiveInfinity;
+
+        void OnEnable()
+        {
+            // included so tick box appears in Editor
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/BaseJoint.cs.meta

+fileFormatVersion: 2
+guid: 02bf6429cb18f3147ae5f7d8e3fd5f07
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/FreeHingeJoint.cs

+using Unity.Entities;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Physics.Authoring
+{
+    public class FreeHingeJoint : BallAndSocketJoint
+    {
+        // Editor only settings
+        [HideInInspector]
+        public bool EditAxes;
+
+        public float3 HingeAxisLocal;
+        public float3 HingeAxisInConnectedEntity;
+
+        public override void UpdateAuto()
+        {
+            base.UpdateAuto();
+            if (AutoSetConnected)
+            {
+                RigidTransform bFromA = math.mul(math.inverse(worldFromB), worldFromA);
+                HingeAxisInConnectedEntity = math.mul(bFromA.rot, HingeAxisLocal);
+            }
+        }
+    }
+
+    class FreeHingeJointBaker : JointBaker<FreeHingeJoint>
+    {
+        public override void Bake(FreeHingeJoint authoring)
+        {
+            authoring.UpdateAuto();
+
+            Math.CalculatePerpendicularNormalized(authoring.HingeAxisLocal, out var perpendicularLocal, out _);
+            Math.CalculatePerpendicularNormalized(authoring.HingeAxisInConnectedEntity, out var perpendicularConnected, out _);
+
+            var physicsJoint = PhysicsJoint.CreateHinge(
+                new BodyFrame {Axis = authoring.HingeAxisLocal, Position = authoring.PositionLocal, PerpendicularAxis = perpendicularLocal},
+                new BodyFrame {Axis = authoring.HingeAxisInConnectedEntity, Position = authoring.PositionInConnectedEntity, PerpendicularAxis = perpendicularConnected }
+            );
+
+            physicsJoint.SetImpulseEventThresholdAllConstraints(authoring.MaxImpulse);
+
+            var constraintBodyPair = GetConstrainedBodyPair(authoring);
+
+            uint worldIndex = GetWorldIndexFromBaseJoint(authoring);
+            CreateJointEntity(worldIndex, constraintBodyPair, physicsJoint);
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/FreeHingeJoint.cs.meta

+fileFormatVersion: 2
+guid: e5dc8c079bffa454ca607aac63ea7e7a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/LimitDOFJoint.cs

+using Unity.Collections;
+using Unity.Entities;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Physics.Authoring
+{
+    // This Joint allows you to lock one or more of the 6 degrees of freedom of a constrained body.
+    // This is achieved by combining the appropriate lower level 'constraint atoms' to form the higher level Joint.
+    // In this case Linear and Angular constraint atoms are combined.
+    // One use-case for this Joint could be to restrict a 3d simulation to a 2d plane.
+    public class LimitDOFJoint : BaseJoint
+    {
+        public bool3 LockLinearAxes;
+        public bool3 LockAngularAxes;
+
+        public PhysicsJoint CreateLimitDOFJoint(RigidTransform offset)
+        {
+            var constraints = new FixedList512Bytes<Constraint>();
+            if (math.any(LockLinearAxes))
+            {
+                constraints.Add(new Constraint
+                {
+                    ConstrainedAxes = LockLinearAxes,
+                    Type = ConstraintType.Linear,
+                    Min = 0,
+                    Max = 0,
+                    SpringFrequency = Constraint.DefaultSpringFrequency,
+                    DampingRatio = Constraint.DefaultDampingRatio,
+                    MaxImpulse = MaxImpulse,
+                });
+            }
+            if (math.any(LockAngularAxes))
+            {
+                constraints.Add(new Constraint
+                {
+                    ConstrainedAxes = LockAngularAxes,
+                    Type = ConstraintType.Angular,
+                    Min = 0,
+                    Max = 0,
+                    SpringFrequency = Constraint.DefaultSpringFrequency,
+                    DampingRatio = Constraint.DefaultDampingRatio,
+                    MaxImpulse = MaxImpulse,
+                });
+            }
+
+            var joint = new PhysicsJoint
+            {
+                BodyAFromJoint = BodyFrame.Identity,
+                BodyBFromJoint = offset
+            };
+            joint.SetConstraints(constraints);
+            return joint;
+        }
+    }
+
+    class LimitDOFJointBaker : Baker<LimitDOFJoint>
+    {
+        public Entity CreateJointEntity(uint worldIndex, PhysicsConstrainedBodyPair constrainedBodyPair, PhysicsJoint joint)
+        {
+            using (var joints = new NativeArray<PhysicsJoint>(1, Allocator.Temp) { [0] = joint })
+            using (var jointEntities = new NativeList<Entity>(1, Allocator.Temp))
+            {
+                CreateJointEntities(worldIndex, constrainedBodyPair, joints, jointEntities);
+                return jointEntities[0];
+            }
+        }
+
+        public void CreateJointEntities(uint worldIndex, PhysicsConstrainedBodyPair constrainedBodyPair, NativeArray<PhysicsJoint> joints, NativeList<Entity> newJointEntities = default)
+        {
+            if (!joints.IsCreated || joints.Length == 0)
+                return;
+
+            if (newJointEntities.IsCreated)
+                newJointEntities.Clear();
+            else
+                newJointEntities = new NativeList<Entity>(joints.Length, Allocator.Temp);
+
+            // create all new joints
+            var multipleJoints = joints.Length > 1;
+
+            for (var i = 0; i < joints.Length; ++i)
+            {
+                var jointEntity = CreateAdditionalEntity(TransformUsageFlags.Dynamic);
+                AddSharedComponent(jointEntity, new PhysicsWorldIndex(worldIndex));
+
+                AddComponent(jointEntity, constrainedBodyPair);
+                AddComponent(jointEntity, joints[i]);
+
+                newJointEntities.Add(jointEntity);
+            }
+
+            if (multipleJoints)
+            {
+                // set companion buffers for new joints
+                for (var i = 0; i < joints.Length; ++i)
+                {
+                    var companions = AddBuffer<PhysicsJointCompanion>(newJointEntities[i]);
+                    for (var j = 0; j < joints.Length; ++j)
+                    {
+                        if (i == j)
+                            continue;
+                        companions.Add(new PhysicsJointCompanion {JointEntity = newJointEntities[j]});
+                    }
+                }
+            }
+        }
+
+        protected PhysicsConstrainedBodyPair GetConstrainedBodyPair(LimitDOFJoint authoring)
+        {
+            return new PhysicsConstrainedBodyPair(
+                GetEntity(TransformUsageFlags.Dynamic),
+                authoring.ConnectedBody == null ? Entity.Null : GetEntity(authoring.ConnectedBody, TransformUsageFlags.Dynamic),
+                authoring.EnableCollision
+            );
+        }
+
+        public uint GetWorldIndex(Component c)
+        {
+            uint worldIndex = 0;
+            var physicsBody = GetComponent<PhysicsBodyAuthoring>(c);
+            if (physicsBody != null)
+            {
+                worldIndex = physicsBody.WorldIndex;
+            }
+            return worldIndex;
+        }
+
+        public override void Bake(LimitDOFJoint authoring)
+        {
+            if (!math.any(authoring.LockLinearAxes) && !math.any(authoring.LockAngularAxes))
+                return;
+
+            RigidTransform bFromA = math.mul(math.inverse(authoring.worldFromB), authoring.worldFromA);
+            PhysicsJoint physicsJoint = authoring.CreateLimitDOFJoint(bFromA);
+
+            var worldIndex = GetWorldIndex(authoring);
+            CreateJointEntity(
+                worldIndex,
+                GetConstrainedBodyPair(authoring),
+                physicsJoint
+            );
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/LimitDOFJoint.cs.meta

+fileFormatVersion: 2
+guid: 9457d04025dadec4b85ae39dad2e1822
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/LimitedDistanceJoint.cs

+using Unity.Entities;
+using static Unity.Physics.Math;
+
+namespace Unity.Physics.Authoring
+{
+    public class LimitedDistanceJoint : BallAndSocketJoint
+    {
+        public float MinDistance;
+        public float MaxDistance;
+    }
+
+    class LimitedDistanceJointBaker : JointBaker<LimitedDistanceJoint>
+    {
+        public override void Bake(LimitedDistanceJoint authoring)
+        {
+            authoring.UpdateAuto();
+
+            var physicsJoint = PhysicsJoint.CreateLimitedDistance(authoring.PositionLocal, authoring.PositionInConnectedEntity, new FloatRange(authoring.MinDistance, authoring.MaxDistance));
+            physicsJoint.SetImpulseEventThresholdAllConstraints(authoring.MaxImpulse);
+
+            var constraintBodyPair = GetConstrainedBodyPair(authoring);
+
+            uint worldIndex = GetWorldIndexFromBaseJoint(authoring);
+            CreateJointEntity(worldIndex, constraintBodyPair, physicsJoint);
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/LimitedDistanceJoint.cs.meta

+fileFormatVersion: 2
+guid: d79d98418b67aa44db932451943018a8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/LimitedHingeJoint.cs

+using Unity.Entities;
+using Unity.Mathematics;
+using UnityEngine;
+using static Unity.Physics.Math;
+
+namespace Unity.Physics.Authoring
+{
+    public class LimitedHingeJoint : FreeHingeJoint
+    {
+        // Editor only settings
+        [HideInInspector]
+        public bool EditLimits;
+
+        public float3 PerpendicularAxisLocal;
+        public float3 PerpendicularAxisInConnectedEntity;
+        public float MinAngle;
+        public float MaxAngle;
+
+        public override void UpdateAuto()
+        {
+            base.UpdateAuto();
+            if (AutoSetConnected)
+            {
+                RigidTransform bFromA = math.mul(math.inverse(worldFromB), worldFromA);
+                HingeAxisInConnectedEntity = math.mul(bFromA.rot, HingeAxisLocal);
+                PerpendicularAxisInConnectedEntity = math.mul(bFromA.rot, PerpendicularAxisLocal);
+            }
+        }
+    }
+
+    class LimitedHingeJointBaker : JointBaker<LimitedHingeJoint>
+    {
+        public override void Bake(LimitedHingeJoint authoring)
+        {
+            authoring.UpdateAuto();
+
+            var physicsJoint = PhysicsJoint.CreateLimitedHinge(
+                new BodyFrame
+                {
+                    Axis = math.normalize(authoring.HingeAxisLocal),
+                    PerpendicularAxis = math.normalize(authoring.PerpendicularAxisLocal),
+                    Position = authoring.PositionLocal
+                },
+                new BodyFrame
+                {
+                    Axis = math.normalize(authoring.HingeAxisInConnectedEntity),
+                    PerpendicularAxis = math.normalize(authoring.PerpendicularAxisInConnectedEntity),
+                    Position = authoring.PositionInConnectedEntity
+                },
+                math.radians(new FloatRange(authoring.MinAngle, authoring.MaxAngle))
+            );
+
+            physicsJoint.SetImpulseEventThresholdAllConstraints(authoring.MaxImpulse);
+
+            var constraintBodyPair = GetConstrainedBodyPair(authoring);
+
+            uint worldIndex = GetWorldIndexFromBaseJoint(authoring);
+            CreateJointEntity(worldIndex, constraintBodyPair, physicsJoint);
+        }
+    }
+}

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/LimitedHingeJoint.cs.meta

+fileFormatVersion: 2
+guid: cbaf9813ee7af2f41a5fd776598ab5b5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/ModifyJointLimitsAuthoring.cs.meta

+fileFormatVersion: 2
+guid: 09435b2483c7b48409764517bbfff081
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Unity Physics/1.2.0-pre.6/Custom Physics Authoring/Unity.Physics.Custom/Joints/PrismaticJoint.cs

+using Unity.Entities;
+using Unity.Mathematics;
+using static Unity.Physics.Math;
+
+namespace Unity.Physics.Authoring
+{
+    public class PrismaticJoint : BallAndSocketJoint
+    {
+        public float3 AxisLocal;
+        public float3 AxisInConnectedEntity;
+        public float3 PerpendicularAxisLocal;
+        public float3 PerpendicularAxisInConnectedEntity;
+        public float MinDistanceOnAxis;
+        public float MaxDistanceOnAxis;
+
+        public override void UpdateAuto()
+        {
+            base.UpdateAuto();
+            if (AutoSetConnected)
+            {
+                RigidTransform bFromA = math.mul(math.inverse(worldFromB), worldFromA);
+                AxisInConnectedEntity = math.mul(bFromA.rot, AxisLocal);
+                PerpendicularAxisInConnectedEntity = math.mul(bFromA.rot, PerpendicularAxisLocal);
+            }
+        }
+    }
+
+    class PrismaticJointBaker : JointBaker<PrismaticJoint>
+    {
+        public override void Bake(PrismaticJoint authoring)
+        {
+            authoring.UpdateAuto();
+
+            var physicsJoint = PhysicsJoint.CreatePrismatic(
+                new BodyFrame
+                {
+                    Axis = authoring.AxisLocal,
+                    PerpendicularAxis = authoring.PerpendicularAxisLocal,
+                    Position = authoring.PositionLocal
+                },
+                new BodyFrame
+                {
+                    Axis = authoring.AxisInConnectedEntity,
+                    PerpendicularAxis = authoring.PerpendicularAxisInConnectedEntity,
+                    Position = authoring.PositionInConnectedEntity
+                },
+                new FloatRange(authoring.MinDistanceOnAxis, authoring.MaxDistanceOnAxis)
+            );
+
+            physicsJoint.SetImpulseEventThresholdAllConstraints(authoring.MaxImpulse);
+
+            var constraintBodyPair = GetConstrainedBodyPair(authoring);
+
+            uint worldIndex = GetWorldIndexFromBaseJoint(authoring);
+            CreateJointEntity(worldIndex, constraintBodyPair, physicsJoint);
+        }
+    }
+}