Merge branch 'master' into test

Author: EternalDawn1

engine/Definitions/common/Physics/IPhysicsBody.def

@@ -125,4 +125,6 @@ native class IPhysicsBody as NativeEngine.IPhysicsBody
 	void SetTrigger( bool trigger );
 
 	void ResetProxy();
+
+	void SetBullet( bool bEnabled );
 }

engine/Sandbox.Engine/Scene/Components/Collider/Rigidbody.cs

@@ -296,6 +296,27 @@ public Rotation InertiaTensorRotation
 		}
 	}
 
+	/// <summary>
+	/// Enable enhanced continuous collision detection (CCD) for this body.
+	/// When enabled, the body performs CCD against dynamic bodies
+	/// (but not against other bodies with enhanced CCD enabled).
+	/// This is useful for fast-moving objects like bullets or rockets
+	/// that need reliable collision detection.
+	/// </summary>
+	[Advanced, Property]
+	public bool EnhancedCcd
+	{
+		get;
+		set
+		{
+			if ( field == value ) return;
+
+			field = value;
+
+			if ( _body.IsValid() ) _body.EnhancedCcd = value;
+		}
+	}
+
 	/// <summary>
 	/// Resets the inertia tensor and its rotation to the values automatically calculated from the attached colliders.  
 	/// This removes any custom overrides set via <see cref="InertiaTensor"/> or <see cref="InertiaTensorRotation"/>.
@@ -391,6 +412,8 @@ void EnsureBodyCreated()
 		_body.Velocity = _lastVelocity;
 		_body.AngularVelocity = _lastAngularVelocity;
 
+		_body.EnhancedCcd = EnhancedCcd;
+
 		// Make sure we clear these so we don't reapply them again later
 		_lastVelocity = default;
 		_lastAngularVelocity = default;

engine/Sandbox.Engine/Scene/Components/Component.Flags.cs

@@ -50,6 +50,11 @@ public enum ComponentFlags
 	/// Don't serialize this component when cloning
 	/// </summary>
 	NotCloned = 256,
+
+	/// <summary>
+	/// Can edit advanced properties in the component inspector
+	/// </summary>
+	ShowAdvancedProperties = 512,
 }
 
 public partial class Component

engine/Sandbox.Engine/Scene/Components/Component.Serialize.cs

@@ -37,7 +37,8 @@ public JsonNode Serialize( GameObject.SerializeOptions options = null )
 		{
 			{ JsonKeys.Type, t.SerializedName },
 			{ JsonKeys.Id, Id },
-			{ JsonKeys.Enabled, Enabled }
+			{ JsonKeys.Enabled, Enabled },
+			{ JsonKeys.Flags, (long)Flags }
 		};
 
 		if ( (isSceneForNetwork || isSingleNetworkObject) && this is INetworkSnapshot sw )
@@ -102,6 +103,8 @@ public void Deserialize( JsonObject node )
 			Id = (Guid)id;
 		}
 
+		DeserializeFlags( node );
+
 		if ( node.TryGetPropertyValue( JsonKeys.Snapshot, out var snapshotNode ) && this is INetworkSnapshot sw )
 		{
 			var data = snapshotNode.Deserialize<byte[]>();
@@ -117,6 +120,18 @@ public void Deserialize( JsonObject node )
 		Enabled = (bool)(jsonData[JsonKeys.Enabled] ?? true);
 	}
 
+	private void DeserializeFlags( JsonObject node )
+	{
+		if ( !node.TryGetPropertyValue( JsonKeys.Flags, out var inFlagNode ) )
+			return;
+
+		var inFlags = (ComponentFlags)(long)inFlagNode;
+
+		const ComponentFlags savedFlags = ComponentFlags.ShowAdvancedProperties;
+
+		Flags = (Flags & ~savedFlags) | (inFlags & savedFlags);
+	}
+
 	internal void PostDeserialize()
 	{
 		if ( jsonData is null )

engine/Sandbox.Engine/Scene/Components/Joint/WheelJoint.cs

@@ -347,11 +347,11 @@ protected override PhysicsJoint CreateJoint( PhysicsPoint point1, PhysicsPoint p
 		{
 			localFrame1 = global::Transform.Zero;
 			localFrame1.Position = point1.LocalPosition;
-			localFrame1.Rotation = point1.LocalRotation * new Angles( 90, 0, 0 );
+			localFrame1.Rotation = point1.LocalRotation * new Angles( 90, 0, 0 ) * new Angles( 0, 90, 0 ); // face the right way, steer the right way
 
 			localFrame2 = global::Transform.Zero;
 			localFrame2.Position = point2.Body.Transform.PointToLocal( point1.Transform.Position );
-			localFrame2.Rotation = point2.Body.Transform.RotationToLocal( point1.Transform.Rotation * new Angles( 90, 0, 0 ) );
+			localFrame2.Rotation = point2.Body.Transform.RotationToLocal( point1.Transform.Rotation * new Angles( 90, 0, 0 ) * new Angles( 0, 90, 0 ) ); // face the right way, steer the right way
 		}
 
 		if ( !Scene.IsEditor )

engine/Sandbox.Engine/Scene/Components/Render/SkinnedModelRenderer.cs

@@ -1,4 +1,5 @@
-
+using System.Collections.Concurrent;
+
 namespace Sandbox;
 
 /// <summary>
@@ -519,39 +520,18 @@ bool UpdateGameObjectsFromBones()
 
 		return transformsChanged;
 	}
-
-	private IEnumerable<SkinnedModelRenderer> GetMergeDescendants()
+	internal void MergeDescendants( ConcurrentQueue<GameTransform> changedTransforms = null )
 	{
 		foreach ( var child in mergeChildren )
 		{
 			if ( !child.IsValid() )
 				continue;
 
-			yield return child;
-
-			foreach ( var descendant in child.GetMergeDescendants() )
-			{
-				yield return descendant;
-			}
-		}
-	}
-
-	internal void MergeDescendants( Action<GameTransform> transformChangedCallback = null )
-	{
-		if ( mergeChildren.Count == 0 )
-			return;
-
-		var descendants = GetMergeDescendants();
-		foreach ( var descendant in descendants )
-		{
-			if ( !descendant.IsValid() )
-				continue;
-
-			var so = descendant.SceneModel;
+			var so = child.SceneModel;
 			if ( !so.IsValid() )
 				continue;
 
-			var target = descendant.BoneMergeTarget;
+			var target = child.BoneMergeTarget;
 			if ( !target.IsValid() )
 				continue;
 
@@ -563,19 +543,21 @@ internal void MergeDescendants( Action<GameTransform> transformChangedCallback =
 			so.MergeBones( parent );
 
 			// Updated bones, transform is no longer dirty.
-			descendant._transformDirty = false;
+			child._transformDirty = false;
 
-			if ( !descendant.UpdateGameObjectsFromBones() )
-				continue;
-
-			if ( transformChangedCallback is not null )
-			{
-				transformChangedCallback( descendant.Transform );
-			}
-			else if ( ThreadSafe.IsMainThread )
+			if ( child.UpdateGameObjectsFromBones() )
 			{
-				descendant.Transform.TransformChanged();
+				if ( changedTransforms is not null )
+				{
+					changedTransforms.Enqueue( child.Transform );
+				}
+				else if ( ThreadSafe.IsMainThread )
+				{
+					child.Transform.TransformChanged();
+				}
 			}
+
+			child.MergeDescendants( changedTransforms );
 		}
 	}
 

engine/Sandbox.Engine/Scene/GameObjectSystems/SceneAnimationSystem.cs

@@ -65,8 +65,8 @@ void UpdateAnimation()
 				}
 			);
 
-			// Now merge any descendants
-			System.Threading.Tasks.Parallel.ForEach( rootRenderers.Where( x => !x.BoneMergeTarget.IsValid() ), _animParallelOptions, x => x.MergeDescendants( ChangedTransforms.Enqueue ) );
+			// Now merge any descendants without allocating per-merge delegates
+			System.Threading.Tasks.Parallel.ForEach( rootRenderers.Where( x => !x.BoneMergeTarget.IsValid() ), _animParallelOptions, renderer => renderer.MergeDescendants( ChangedTransforms ) );
 
 			while ( ChangedTransforms.TryDequeue( out var tx ) )
 			{

engine/Sandbox.Engine/Scene/GameObjectSystems/SceneSpriteSystem.cs

@@ -231,6 +231,11 @@ private static RenderGroupKey GetRenderGroupKey( ISpriteRenderGroup component, G
 			flags |= InstanceGroupFlags.Additive;
 		}
 
+		if ( component.Opaque )
+		{
+			flags |= InstanceGroupFlags.Opaque;
+		}
+
 		RenderGroupKey renderGroupKey = new()
 		{
 			GroupFlags = flags,
@@ -281,6 +286,7 @@ private SpriteBatchSceneObject CreateRenderGroup( RenderGroupKey renderGroupKey
 		renderGroupObject.Flags.ExcludeGameLayer = (renderGroupKey.GroupFlags & InstanceGroupFlags.CastOnlyShadow) != 0;
 		renderGroupObject.Sorted = (renderGroupKey.GroupFlags & InstanceGroupFlags.Transparent) != 0;
 		renderGroupObject.Additive = (renderGroupKey.GroupFlags & InstanceGroupFlags.Additive) != 0;
+		renderGroupObject.Opaque = (renderGroupKey.GroupFlags & InstanceGroupFlags.Opaque) != 0;
 		renderGroupObject.Tags.SetFrom( new TagSet( renderGroupKey.Tags ) );
 		renderGroupKey.RenderLayer.Apply( renderGroupObject );
 
@@ -362,6 +368,7 @@ internal enum InstanceGroupFlags
 		CastShadow = 1 << 0,
 		CastOnlyShadow = 1 << 1,
 		Transparent = 1 << 2,
-		Additive = 1 << 3
+		Additive = 1 << 3,
+		Opaque = 1 << 4
 	}
 }

engine/Sandbox.Engine/Systems/Physics/PhysicsBody.cs

@@ -1233,4 +1233,16 @@ internal void ResetProxy()
 	{
 		native.ResetProxy();
 	}
+
+	/// <summary>
+	/// Enable enhanced continuous collision detection (CCD) for this body.
+	/// When enabled, the body performs CCD against dynamic bodies
+	/// (but not against other bodies with enhanced CCD enabled).
+	/// This is useful for fast-moving objects like bullets or rockets
+	/// that need reliable collision detection.
+	/// </summary>
+	public bool EnhancedCcd
+	{
+		set => native.SetBullet( value );
+	}
 }

engine/Sandbox.Engine/Systems/SceneSystem/SpriteBatchSceneObject.cs

@@ -13,6 +13,7 @@ internal sealed class SpriteBatchSceneObject : SceneCustomObject
 	public bool Sorted { get; set; } = false;
 	public bool Filtered { get; set; } = false;
 	public bool Additive { get; set; } = false;
+	public bool Opaque { get; set; } = false;
 
 	internal Dictionary<Guid, SpriteRenderer> Components = new();
 
@@ -512,6 +513,7 @@ public override void RenderSceneObject()
 		Graphics.ResourceBarrierTransition( SpriteBufferOut, ResourceState.Common );
 
 		Graphics.Attributes.SetCombo( "D_BLEND", Additive ? 1 : 0 );
+		Graphics.Attributes.SetCombo( "D_OPAQUE", Opaque ? 1 : 0 );
 
 		// Sort
 		if ( Sorted )