mirror of
https://github.com/Facepunch/sbox-public.git
synced 2025-12-23 22:48:07 -05:00
6808d8768e
* Stop generating solutions via -test flag add -generatesolution * Add TestAppSystem remove Application.InitUnitTest Avoids some hacks and also makes sure our tests are as close to a real AppSystem as possible. * Add shutdown unit test shuts down an re-inits the engine * Properly dispose native resources hold by managed during shutdown Should fix a bunch of crashes * Fix filesystem and networking tests * StandaloneTest does proper Game Close * Make sure package tests clean up properly * Make sure menu scene and resources are released on shutdown * Report leaked scenes on shutdown * Ensure DestroyImmediate is not used on scenes * Fix unmounting in unit tests not clearing native refs * Force destroy native resource on ResourceLib Clear
772 lines
25 KiB
C#
772 lines
25 KiB
C#
using System;
|
|
|
|
namespace GameObjects.Components;
|
|
|
|
[TestClass]
|
|
public class ModelPhysicsTests
|
|
{
|
|
private static Model CitizenModel => Model.Load( "models/citizen/citizen.vmdl" );
|
|
|
|
[TestMethod]
|
|
public void ComponentCreation()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
|
|
Assert.IsNotNull( modelPhysics, "ModelPhysics component should be created" );
|
|
Assert.IsTrue( modelPhysics.IsValid(), "ModelPhysics component should be valid" );
|
|
Assert.AreEqual( 0, modelPhysics.Bodies.Count, "Bodies collection should be empty initially" );
|
|
Assert.AreEqual( 0, modelPhysics.Joints.Count, "Joints collection should be empty initially" );
|
|
Assert.AreEqual( 0, modelPhysics.PhysicsRebuildCount, "Shouldn't have built anything" );
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ModelAssignment_CreatesPhysics()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>( false );
|
|
|
|
// Assign model
|
|
modelPhysics.Model = CitizenModel;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// Physics should be created when model is assigned and component is enabled
|
|
Assert.IsTrue( modelPhysics.Bodies.Count > 0, "Bodies should be created from model physics" );
|
|
Assert.IsTrue( modelPhysics.Joints.Count > 0, "Joints should be created from model physics" );
|
|
Assert.AreEqual( 1, modelPhysics.PhysicsRebuildCount, "Should have built physics only once" );
|
|
}
|
|
|
|
[TestMethod]
|
|
public void RendererIntegration_AutoAssignsModel()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
|
|
// Create renderer first with a model
|
|
var renderer = go.Components.Create<SkinnedModelRenderer>();
|
|
renderer.Model = CitizenModel;
|
|
|
|
// Create ModelPhysics - should auto-assign model from renderer
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
|
|
Assert.AreEqual( CitizenModel, modelPhysics.Model, "Model should be auto-assigned from renderer" );
|
|
Assert.AreEqual( renderer, modelPhysics.Renderer, "Renderer should be auto-assigned" );
|
|
}
|
|
|
|
[TestMethod]
|
|
public void RigidbodyFlags_AppliedToAllBodies()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
// Set flags before enabling
|
|
var testFlags = RigidbodyFlags.DisableCollisionSounds;
|
|
modelPhysics.RigidbodyFlags = testFlags;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// All bodies should have the flags
|
|
foreach ( var body in modelPhysics.Bodies )
|
|
{
|
|
Assert.AreEqual( testFlags, body.Component.RigidbodyFlags,
|
|
"All bodies should have the specified RigidbodyFlags" );
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Locking_AppliedToAllBodies()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
// Set locking before enabling
|
|
var testLocking = new PhysicsLock { Roll = true };
|
|
modelPhysics.Locking = testLocking;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// All bodies should have the locking
|
|
foreach ( var body in modelPhysics.Bodies )
|
|
{
|
|
Assert.AreEqual( testLocking, body.Component.Locking,
|
|
"All bodies should have the specified locking" );
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MotionEnabled_TogglesDynamicPhysics()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// Default should be motion enabled
|
|
Assert.IsTrue( modelPhysics.MotionEnabled, "Motion should be enabled by default" );
|
|
|
|
// Disable motion
|
|
modelPhysics.MotionEnabled = false;
|
|
foreach ( var body in modelPhysics.Bodies )
|
|
{
|
|
Assert.IsFalse( body.Component.MotionEnabled,
|
|
"All bodies should have motion disabled" );
|
|
}
|
|
|
|
// Re-enable motion
|
|
modelPhysics.MotionEnabled = true;
|
|
foreach ( var body in modelPhysics.Bodies )
|
|
{
|
|
Assert.IsTrue( body.Component.MotionEnabled,
|
|
"All bodies should have motion enabled" );
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void StartAsleep_PutsBodiesAsleep()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>( false );
|
|
modelPhysics.Model = CitizenModel;
|
|
modelPhysics.StartAsleep = true;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// Trigger Start
|
|
modelPhysics.GameObject.Enabled = true;
|
|
|
|
// All bodies should be asleep
|
|
foreach ( var body in modelPhysics.Bodies )
|
|
{
|
|
Assert.IsTrue( body.Component.Sleeping,
|
|
"All bodies should be asleep when StartAsleep is true" );
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void DisablingComponent_DestroysPhysics()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
// Enable to create physics
|
|
modelPhysics.Enabled = true;
|
|
var initialBodyCount = modelPhysics.Bodies.Count;
|
|
var initialJointCount = modelPhysics.Joints.Count;
|
|
var initialColliderCount = 0;
|
|
|
|
foreach ( var collider in go.GetComponentsInChildren<Collider>( true ) )
|
|
{
|
|
if ( !collider.IsValid() ) continue;
|
|
|
|
// Collider should be on a physics bone
|
|
Assert.IsTrue( collider.GameObject.Flags.Contains( GameObjectFlags.PhysicsBone ) );
|
|
|
|
initialColliderCount++;
|
|
}
|
|
|
|
Assert.IsTrue( initialBodyCount > 0, "Should have bodies when enabled" );
|
|
Assert.IsTrue( initialJointCount > 0, "Should have joints when enabled" );
|
|
Assert.IsTrue( initialColliderCount > 0, "Should have colliders when enabled" );
|
|
|
|
// Disable should destroy physics
|
|
modelPhysics.Enabled = false;
|
|
|
|
Assert.AreEqual( 0, modelPhysics.Bodies.Count, "Bodies should be cleared when disabled" );
|
|
Assert.AreEqual( 0, modelPhysics.Joints.Count, "Joints should be cleared when disabled" );
|
|
|
|
var colliderCount = 0;
|
|
|
|
foreach ( var collider in go.GetComponentsInChildren<Collider>( true ) )
|
|
{
|
|
colliderCount++;
|
|
}
|
|
|
|
Assert.AreEqual( 0, colliderCount, "Colliders should be cleared when disabled" );
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IgnoreRoot_PreventsDrivingTransform()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
// Test with IgnoreRoot false (default)
|
|
modelPhysics.IgnoreRoot = false;
|
|
modelPhysics.Enabled = true;
|
|
Assert.IsFalse( modelPhysics.IgnoreRoot, "IgnoreRoot should be false by default" );
|
|
|
|
// Test with IgnoreRoot true
|
|
modelPhysics.IgnoreRoot = true;
|
|
Assert.IsTrue( modelPhysics.IgnoreRoot, "IgnoreRoot should be settable to true" );
|
|
}
|
|
|
|
[TestMethod]
|
|
public void CopyBonesFrom_TransfersBoneData()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
|
|
// Create source with renderer
|
|
var sourceGo = scene.CreateObject();
|
|
var sourceRenderer = sourceGo.Components.Create<SkinnedModelRenderer>();
|
|
sourceRenderer.Model = CitizenModel;
|
|
|
|
// Create target with ModelPhysics
|
|
var targetGo = scene.CreateObject();
|
|
var targetPhysics = targetGo.Components.Create<ModelPhysics>();
|
|
targetPhysics.Model = CitizenModel;
|
|
targetPhysics.Enabled = true;
|
|
|
|
// Copy bones
|
|
targetPhysics.CopyBonesFrom( sourceRenderer, false );
|
|
|
|
// Should complete without errors
|
|
Assert.IsTrue( targetPhysics.IsValid(), "ModelPhysics should remain valid after copying bones" );
|
|
}
|
|
|
|
[TestMethod]
|
|
public void BodyScaling_UpdatesJointPositions()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// Scale the GameObject
|
|
go.WorldScale = 2.0f;
|
|
|
|
// Joints should handle scaling
|
|
Assert.IsTrue( modelPhysics.Joints.Count > 0, "Should have joints to test scaling" );
|
|
foreach ( var joint in modelPhysics.Joints )
|
|
{
|
|
Assert.IsTrue( joint.Component.IsValid(), "Joint component should remain valid after scaling" );
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ProxyMode_HandlesNetworking()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
|
|
// Test proxy detection (this would normally be set by networking)
|
|
// We can't fully test proxy behavior without networking, but we can verify the property exists
|
|
var isProxy = modelPhysics.IsProxy;
|
|
Assert.IsNotNull( isProxy, "IsProxy property should exist for networking support" );
|
|
}
|
|
|
|
[TestMethod]
|
|
public void MultipleEnableDisable_HandlesCorrectly()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>( false );
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
// Enable/Disable multiple times
|
|
for ( int i = 0; i < 3; i++ )
|
|
{
|
|
modelPhysics.Enabled = true;
|
|
Assert.IsTrue( modelPhysics.Bodies.Count > 0, $"Iteration {i}: Should have bodies when enabled" );
|
|
|
|
modelPhysics.Enabled = false;
|
|
Assert.AreEqual( 0, modelPhysics.Bodies.Count, $"Iteration {i}: Should have no bodies when disabled" );
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void NullModel_HandlesGracefully()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
|
|
// Enable with null model
|
|
modelPhysics.Model = null;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// Should handle gracefully without creating bodies
|
|
Assert.AreEqual( 0, modelPhysics.Bodies.Count, "Should have no bodies with null model" );
|
|
Assert.AreEqual( 0, modelPhysics.Joints.Count, "Should have no joints with null model" );
|
|
}
|
|
|
|
[TestMethod]
|
|
public void RigidbodyAccess_ValidAfterCreation()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// All body components should be valid and accessible
|
|
foreach ( var body in modelPhysics.Bodies )
|
|
{
|
|
Assert.IsTrue( body.Component.IsValid(), "Body component should be valid" );
|
|
Assert.IsTrue( body.Component.GameObject.IsValid(), "Body GameObject should be valid" );
|
|
Assert.IsTrue( body.Bone >= 0, "Body should have valid bone index" );
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void JointConfiguration_PreservesSettings()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// Joints should maintain their configuration
|
|
foreach ( var joint in modelPhysics.Joints )
|
|
{
|
|
Assert.IsTrue( joint.Component.IsValid(), "Joint component should be valid" );
|
|
Assert.IsTrue( joint.Body1.Component.IsValid(), "Joint Body1 should be valid" );
|
|
Assert.IsTrue( joint.Body2.Component.IsValid(), "Joint Body2 should be valid" );
|
|
Assert.AreEqual( Sandbox.Joint.AttachmentMode.LocalFrames, joint.Component.Attachment,
|
|
"Joints should use LocalFrames attachment mode" );
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void CreatesHeadBoneWithRigidbody()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
|
|
// Assign the citizen model which should have a head bone
|
|
modelPhysics.Model = CitizenModel;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// Find the head child GameObject
|
|
GameObject headObject = go.GetComponentsInChildren<Rigidbody>().Where( x => x.GameObject.Name == "head" ).Single().GameObject;
|
|
|
|
// Verify head GameObject exists
|
|
Assert.IsNotNull( headObject, "A child GameObject named 'head' should be created" );
|
|
Assert.IsTrue( headObject.IsValid(), "Head GameObject should be valid" );
|
|
|
|
// Verify head has a Rigidbody component
|
|
var headRigidbody = headObject.GetComponent<Rigidbody>();
|
|
Assert.IsNotNull( headRigidbody, "Head GameObject should have a Rigidbody component" );
|
|
Assert.IsTrue( headRigidbody.IsValid(), "Head Rigidbody should be valid" );
|
|
|
|
// Additional verification - check it's in the Bodies list
|
|
var headBody = modelPhysics.Bodies.FirstOrDefault( b => b.Component.GameObject == headObject );
|
|
Assert.IsNotNull( headBody, "Head should be in the Bodies collection" );
|
|
Assert.AreEqual( headRigidbody, headBody.Component, "Rigidbody in Bodies should match head's Rigidbody" );
|
|
|
|
// Verify the GameObject has the physics bone flags set
|
|
Assert.IsTrue( headObject.Flags.HasFlag( GameObjectFlags.Absolute ), "Head GameObject should have Absolute flag" );
|
|
Assert.IsTrue( headObject.Flags.HasFlag( GameObjectFlags.PhysicsBone ), "Head GameObject should have PhysicsBone flag" );
|
|
}
|
|
|
|
[TestMethod]
|
|
public void CreatesNeck0BoneWithoutRigidbody()
|
|
{
|
|
var scene = new Scene();
|
|
using var sceneScope = scene.Push();
|
|
var go = scene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
|
|
// Assign the citizen model which should have a neck_0 bone
|
|
modelPhysics.Model = CitizenModel;
|
|
modelPhysics.Enabled = true;
|
|
|
|
// Find the neck_0 child GameObject
|
|
GameObject neckObject = go.GetAllObjects( true ).Where( x => x.Name == "neck_0" ).FirstOrDefault();
|
|
|
|
// Verify neck_0 GameObject exists (bone objects are created for all bones)
|
|
Assert.IsNotNull( neckObject, "A child GameObject named 'neck_0' should be created" );
|
|
Assert.IsTrue( neckObject.IsValid(), "Neck_0 GameObject should be valid" );
|
|
|
|
// Verify neck_0 does NOT have a Rigidbody component
|
|
var neckRigidbody = neckObject.GetComponent<Rigidbody>();
|
|
Assert.IsNull( neckRigidbody, "Neck_0 GameObject should NOT have a Rigidbody component" );
|
|
|
|
// Verify it's not in the Bodies list
|
|
var neckBody = modelPhysics.Bodies.FirstOrDefault( b => b.Component.GameObject == neckObject );
|
|
Assert.IsNull( neckBody.Component, "Neck_0 should NOT be in the Bodies collection" );
|
|
|
|
// Verify the GameObject doesn't have the physics bone flags
|
|
// (these are only set when physics components are added)
|
|
Assert.IsFalse( neckObject.Flags.HasFlag( GameObjectFlags.PhysicsBone ), "Neck_0 GameObject should NOT have PhysicsBone flag since it has no physics" );
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ClonedObjectKeepsFlags_Clone()
|
|
{
|
|
GameObject sourceGo = default;
|
|
|
|
var sourceScene = new Scene();
|
|
using ( var sceneScope = sourceScene.Push() )
|
|
{
|
|
var go = sourceScene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
sourceGo = go;
|
|
}
|
|
|
|
var scene = new Scene();
|
|
using ( var sceneScope = scene.Push() )
|
|
{
|
|
var go = sourceGo.Clone( new CloneConfig { StartEnabled = true } );
|
|
var modelPhysics = go.GetComponent<ModelPhysics>();
|
|
|
|
Assert.IsNotNull( modelPhysics, "Cloned GameObject should have ModelPhysics component" );
|
|
Assert.AreEqual( 0, modelPhysics.PhysicsRebuildCount );
|
|
Assert.AreNotEqual( 0, modelPhysics.Bodies.Count );
|
|
Assert.AreNotEqual( 0, modelPhysics.Joints.Count );
|
|
Assert.AreNotEqual( 0, go.GetComponentsInChildren<Rigidbody>().Count() );
|
|
|
|
foreach ( var part in go.GetComponentsInChildren<Rigidbody>() )
|
|
{
|
|
Assert.IsTrue( part.GameObject.Flags.Contains( GameObjectFlags.PhysicsBone ) );
|
|
Assert.IsTrue( part.GameObject.Flags.Contains( GameObjectFlags.Bone ) );
|
|
Console.WriteLine( part.GameObject.Flags );
|
|
}
|
|
|
|
}
|
|
scene.Destroy();
|
|
|
|
sourceScene.Destroy();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ClonedObjectKeepsFlags_Json()
|
|
{
|
|
string json = default;
|
|
|
|
var sourceScene = new Scene();
|
|
using ( var sceneScope = sourceScene.Push() )
|
|
{
|
|
var go = sourceScene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
json = go.Serialize().ToJsonString();
|
|
}
|
|
|
|
var jsonObject = Json.ParseToJsonObject( json );
|
|
Assert.IsNotNull( jsonObject );
|
|
SceneUtility.MakeIdGuidsUnique( jsonObject );
|
|
|
|
var scene = new Scene();
|
|
using ( var sceneScope = scene.Push() )
|
|
{
|
|
var go = new GameObject( false );
|
|
go.Deserialize( jsonObject );
|
|
go.Enabled = true;
|
|
|
|
var modelPhysics = go.GetComponent<ModelPhysics>();
|
|
|
|
Assert.IsNotNull( modelPhysics, "Cloned GameObject should have ModelPhysics component" );
|
|
Assert.AreEqual( 0, modelPhysics.PhysicsRebuildCount );
|
|
Assert.AreNotEqual( 0, modelPhysics.Bodies.Count );
|
|
Assert.AreNotEqual( 0, modelPhysics.Joints.Count );
|
|
Assert.AreNotEqual( 0, go.GetComponentsInChildren<Rigidbody>().Count() );
|
|
|
|
foreach ( var part in go.GetComponentsInChildren<Rigidbody>() )
|
|
{
|
|
Assert.IsTrue( part.GameObject.Flags.Contains( GameObjectFlags.PhysicsBone ) );
|
|
Console.WriteLine( part.GameObject.Flags );
|
|
}
|
|
|
|
}
|
|
scene.Destroy();
|
|
|
|
sourceScene.Destroy();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ClonedObjectKeepsPositions_Clone()
|
|
{
|
|
GameObject sourceGo = default;
|
|
|
|
var sourceScene = new Scene();
|
|
using ( var sceneScope = sourceScene.Push() )
|
|
{
|
|
var go = sourceScene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
sourceGo = go;
|
|
}
|
|
|
|
var scene = new Scene();
|
|
using ( var sceneScope = scene.Push() )
|
|
{
|
|
var targetPos = new Vector3( 10000, 0, 0 );
|
|
|
|
// spawn it a bit away
|
|
var go = sourceGo.Clone( new CloneConfig { StartEnabled = true, Transform = new Transform( targetPos ) } );
|
|
var modelPhysics = go.GetComponent<ModelPhysics>();
|
|
|
|
System.Console.WriteLine( go.WorldTransform );
|
|
|
|
Assert.IsNotNull( modelPhysics, "Cloned GameObject should have ModelPhysics component" );
|
|
Assert.AreEqual( 0, modelPhysics.PhysicsRebuildCount );
|
|
|
|
Assert.IsTrue( go.IsValid(), "Cloned GameObject should be valid" );
|
|
Assert.IsTrue( go.WorldPosition.Distance( targetPos ) < 1.0f, "Cloned GameObject should be near the target position" );
|
|
|
|
Assert.IsTrue( go.GetAllObjects( true ).Count() > 50, "Should have more than 20 child objects" );
|
|
|
|
var furthestObject = go.GetAllObjects( true ).Max( x => x.WorldPosition.Distance( targetPos ) );
|
|
Assert.IsTrue( furthestObject < 200.0f, $"Furthest object was {furthestObject:n0} away!" );
|
|
}
|
|
|
|
scene.Destroy();
|
|
|
|
sourceScene.Destroy();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ClonedObjectKeepsPositions_Json()
|
|
{
|
|
string json = default;
|
|
|
|
var sourceScene = new Scene();
|
|
using ( var sceneScope = sourceScene.Push() )
|
|
{
|
|
var go = sourceScene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
json = go.Serialize().ToJsonString();
|
|
}
|
|
|
|
var jsonObject = Json.ParseToJsonObject( json );
|
|
Assert.IsNotNull( jsonObject );
|
|
SceneUtility.MakeIdGuidsUnique( jsonObject );
|
|
|
|
var scene = new Scene();
|
|
using ( var sceneScope = scene.Push() )
|
|
{
|
|
var targetPos = new Vector3( 10000, 0, 0 );
|
|
|
|
var go = new GameObject( false );
|
|
go.Deserialize( jsonObject, new GameObject.DeserializeOptions { TransformOverride = new Transform( targetPos ) } );
|
|
go.Enabled = true;
|
|
|
|
// spawn it a bit away
|
|
var modelPhysics = go.GetComponent<ModelPhysics>();
|
|
|
|
System.Console.WriteLine( go.WorldTransform );
|
|
|
|
Assert.IsNotNull( modelPhysics, "Cloned GameObject should have ModelPhysics component" );
|
|
Assert.AreEqual( 0, modelPhysics.PhysicsRebuildCount );
|
|
|
|
Assert.IsTrue( go.IsValid(), "Cloned GameObject should be valid" );
|
|
Assert.IsTrue( go.WorldPosition.Distance( targetPos ) < 1.0f, "Cloned GameObject should be near the target position" );
|
|
|
|
Assert.IsTrue( go.GetAllObjects( true ).Count() > 50, "Should have more than 20 child objects" );
|
|
|
|
var furthestObject = go.GetAllObjects( true ).Max( x => x.WorldPosition.Distance( targetPos ) );
|
|
Assert.IsTrue( furthestObject < 200.0f, $"Furthest object was {furthestObject:n0} away!" );
|
|
}
|
|
|
|
scene.Destroy();
|
|
|
|
sourceScene.Destroy();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ClonedObjectKeepsPositions_Json_Update()
|
|
{
|
|
string json = default;
|
|
|
|
var sourceScene = new Scene();
|
|
using ( var sceneScope = sourceScene.Push() )
|
|
{
|
|
var go = sourceScene.CreateObject();
|
|
var modelRender = go.Components.Create<SkinnedModelRenderer>();
|
|
modelRender.Model = CitizenModel;
|
|
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
for ( int i = 0; i < 100; i++ )
|
|
{
|
|
sourceScene.GameTick( 0.1f );
|
|
}
|
|
|
|
json = go.Serialize().ToJsonString();
|
|
}
|
|
|
|
var jsonObject = Json.ParseToJsonObject( json );
|
|
Assert.IsNotNull( jsonObject );
|
|
SceneUtility.MakeIdGuidsUnique( jsonObject );
|
|
|
|
var scene = new Scene();
|
|
using ( var sceneScope = scene.Push() )
|
|
{
|
|
var targetPos = new Vector3( 10000, 0, 0 );
|
|
|
|
var go = new GameObject( false );
|
|
go.Deserialize( jsonObject, new GameObject.DeserializeOptions { TransformOverride = new Transform( targetPos ) } );
|
|
go.Enabled = true;
|
|
|
|
scene.GameTick( 0.1f );
|
|
|
|
// spawn it a bit away
|
|
var modelPhysics = go.GetComponent<ModelPhysics>();
|
|
|
|
System.Console.WriteLine( go.WorldTransform );
|
|
|
|
Assert.IsNotNull( modelPhysics, "Cloned GameObject should have ModelPhysics component" );
|
|
Assert.AreEqual( 0, modelPhysics.PhysicsRebuildCount );
|
|
|
|
Assert.IsTrue( go.IsValid(), "Cloned GameObject should be valid" );
|
|
Assert.IsTrue( go.WorldPosition.Distance( targetPos ) < 1.0f, "Cloned GameObject should be near the target position" );
|
|
|
|
Assert.IsTrue( go.GetAllObjects( true ).Count() > 50, "Should have more than 20 child objects" );
|
|
|
|
var furthestObject = go.GetAllObjects( true ).Max( x => x.WorldPosition.Distance( targetPos ) );
|
|
Assert.IsTrue( furthestObject < 200.0f, $"Furthest object was {furthestObject:n0} away!" );
|
|
}
|
|
|
|
scene.Destroy();
|
|
|
|
sourceScene.Destroy();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ClonedObjectKeepsPositions_Json_Batch()
|
|
{
|
|
string json = default;
|
|
|
|
var sourceScene = new Scene();
|
|
using ( var sceneScope = sourceScene.Push() )
|
|
{
|
|
var go = sourceScene.CreateObject();
|
|
var modelPhysics = go.Components.Create<ModelPhysics>();
|
|
modelPhysics.Model = CitizenModel;
|
|
|
|
json = go.Serialize().ToJsonString();
|
|
}
|
|
|
|
var jsonObject = Json.ParseToJsonObject( json );
|
|
Assert.IsNotNull( jsonObject );
|
|
SceneUtility.MakeIdGuidsUnique( jsonObject );
|
|
|
|
var scene = new Scene();
|
|
using ( var sceneScope = scene.Push() )
|
|
{
|
|
var targetPos = new Vector3( 10000, 0, 0 );
|
|
|
|
GameObject go = default;
|
|
|
|
SceneUtility.RunInBatchGroup( () =>
|
|
{
|
|
go = new GameObject( false );
|
|
go.Deserialize( jsonObject, new GameObject.DeserializeOptions { TransformOverride = new Transform( targetPos ) } );
|
|
go.Enabled = true;
|
|
} );
|
|
|
|
// spawn it a bit away
|
|
var modelPhysics = go.GetComponent<ModelPhysics>();
|
|
|
|
System.Console.WriteLine( go.WorldTransform );
|
|
|
|
Assert.IsNotNull( modelPhysics, "Cloned GameObject should have ModelPhysics component" );
|
|
Assert.AreEqual( 0, modelPhysics.PhysicsRebuildCount );
|
|
|
|
Assert.IsTrue( go.IsValid(), "Cloned GameObject should be valid" );
|
|
Assert.IsTrue( go.WorldPosition.Distance( targetPos ) < 1.0f, "Cloned GameObject should be near the target position" );
|
|
|
|
Assert.IsTrue( go.GetAllObjects( true ).Count() > 50, "Should have more than 20 child objects" );
|
|
|
|
var furthestObject = go.GetAllObjects( true ).Max( x => x.WorldPosition.Distance( targetPos ) );
|
|
Assert.IsTrue( furthestObject < 200.0f, $"Furthest object was {furthestObject:n0} away!" );
|
|
}
|
|
|
|
scene.Destroy();
|
|
|
|
sourceScene.Destroy();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ClonedObjectKeepsPositions_Json_Batch_Prop()
|
|
{
|
|
string json = default;
|
|
|
|
var sourceScene = new Scene();
|
|
using ( var sceneScope = sourceScene.Push() )
|
|
{
|
|
var go = sourceScene.CreateObject();
|
|
var prop = go.Components.Create<Prop>();
|
|
prop.Model = CitizenModel;
|
|
|
|
json = go.Serialize().ToJsonString();
|
|
}
|
|
|
|
var jsonObject = Json.ParseToJsonObject( json );
|
|
Assert.IsNotNull( jsonObject );
|
|
SceneUtility.MakeIdGuidsUnique( jsonObject );
|
|
|
|
var scene = new Scene();
|
|
using ( var sceneScope = scene.Push() )
|
|
{
|
|
var targetPos = new Vector3( 10000, 0, 0 );
|
|
|
|
GameObject go = default;
|
|
|
|
SceneUtility.RunInBatchGroup( () =>
|
|
{
|
|
go = new GameObject( false );
|
|
go.Deserialize( jsonObject, new GameObject.DeserializeOptions { TransformOverride = new Transform( targetPos ) } );
|
|
go.Enabled = true;
|
|
} );
|
|
|
|
// spawn it a bit away
|
|
var modelPhysics = go.GetComponent<ModelPhysics>();
|
|
|
|
System.Console.WriteLine( go.WorldTransform );
|
|
|
|
Assert.IsNotNull( modelPhysics, "Cloned GameObject should have ModelPhysics component" );
|
|
Assert.AreEqual( 0, modelPhysics.PhysicsRebuildCount );
|
|
|
|
Assert.IsTrue( go.IsValid(), "Cloned GameObject should be valid" );
|
|
Assert.IsTrue( go.WorldPosition.Distance( targetPos ) < 1.0f, "Cloned GameObject should be near the target position" );
|
|
|
|
Assert.IsTrue( go.GetAllObjects( true ).Count() > 50, "Should have more than 20 child objects" );
|
|
|
|
var furthestObject = go.GetAllObjects( true ).Max( x => x.WorldPosition.Distance( targetPos ) );
|
|
Assert.IsTrue( furthestObject < 200.0f, $"Furthest object was {furthestObject:n0} away!" );
|
|
}
|
|
|
|
scene.Destroy();
|
|
|
|
sourceScene.Destroy();
|
|
}
|
|
}
|