private void AddBody <T>() where T : unmanaged, IConvexShape
{
T withType = (T)colliderShape;
colliderShape.ComputeInertia(mass, out BodyInertia inertia);
if (isStatic)
{
staticHandle = PhysicsHandler.Simulation.Statics.Add(
new StaticDescription(
parent.Movement.Position,
new CollidableDescription(
PhysicsHandler.Simulation.Shapes.Add(withType),
0.1f
)
)
);
}
else
{
bodyHandle = PhysicsHandler.Simulation.Bodies.Add(
BodyDescription.CreateDynamic(
parent.Movement.Position,
inertia,
new CollidableDescription(
PhysicsHandler.Simulation.Shapes.Add(withType),
0.1f
),
new BodyActivityDescription(0.01f)
)
);
}
}
private PhysicsObject FindObject(StaticHandle staticHandle, BodyHandle bodyHandle)
{
foreach (var physicsObject in Bodies)
{
if (!physicsObject.Reference.Exists)
{
continue;
}
if (physicsObject.Id == bodyHandle.Value)
{
return(physicsObject);
}
}
foreach (var physicsObject in Statics)
{
if (!physicsObject.Reference.Exists)
{
continue;
}
if (physicsObject.Id == staticHandle.Value)
{
return(physicsObject);
}
}
throw new Exception($"Failed to find physics object: Got {staticHandle}/{bodyHandle}");
}
private PhyObject CreateVanilla(ObjectState state, CollidableDescription collidableDescription, BodyInertia bodyInertia)
{
PhyObject phy;
if (state.mass != 0)
{
BodyDescription boxDescription = BodyDescription.CreateDynamic(state.position, bodyInertia,
collidableDescription,
new BodyActivityDescription(0.01f));
boxDescription.Pose = new RigidPose(state.position, state.quaternion);
var bodyHandle = Simulation.Bodies.Add(boxDescription);
phy = SetUpPhyObject(bodyHandle, state);
objectsHandlers.Add(bodyHandle, phy);
}
else
{
StaticDescription description = new StaticDescription(state.position, state.quaternion, collidableDescription);
StaticHandle handle = Simulation.Statics.Add(description);
//collidableMaterials.Allocate(handle) = new SimpleMaterial { FrictionCoefficient = 1, MaximumRecoveryVelocity = float.MaxValue, SpringSettings = new SpringSettings(1f, 1f) };
phy = SetUpPhyObject(handle, state);
staticObjectsHandlers.Add(handle, (StaticPhyObject)phy);
//objectsHandlers.Add(handle,phy);
}
return(phy);
}
internal override void Instantiate(Vector3 position, Quaternion rotation)
{
Position = position;
Rotation = rotation;
handle = TGCGame.physicSimulation.CreateStatic(position, rotation, Shape);
TGCGame.physicSimulation.collitionEvents.RegisterCollider(handle, this);
base.Instantiate(position, rotation);
}
private StaticPhyObject SetUpPhyObject(StaticHandle staticHandle, ObjectState state)
{
StaticPhyObject phy = (StaticPhyObject)GetPhyClass(state.type);
phy.Load(staticHandle, connectionState, this, state);
return(phy);
}
protected override void OnAttach()
{
//this will set all the properties in the native side object
base.OnAttach();
Entity.Transform.UpdateWorldMatrix();
Entity.Transform.GetWorldTransformation(out var entityPosition, out var entityRotation, out var scale);
var position = new System.Numerics.Vector3(entityPosition.X, entityPosition.Y, entityPosition.Z);
var rotation = new System.Numerics.Quaternion(entityRotation.X, entityRotation.Y,
entityRotation.Z, entityRotation.W);
var collidableDescription = new CollidableDescription(ColliderShape.InternalShapeIndex, SpeculativeMargin);
staticHandle = Simulation.AddStatic(new StaticDescription(position, rotation, collidableDescription));
Simulation.physicsBodySettings.Allocate(staticHandle) = new SimplePhysicsBodySettings
{
CustomDamping = false,
CustomGravity = false,
};
Simulation.physicsMaterials.Allocate(staticHandle) = new SimplePhysicsMaterial
{
FrictionCoefficient = 1f,
MaximumRecoveryVelocity = 2f,
SpringSettings = new BepuPhysics.Constraints.SpringSettings(30, 1)
};
Simulation.physicsTags.Allocate(staticHandle) = new SimplePhysicsTag
{
ComponentId = Id
};
Simulation.collisionProps.Allocate(staticHandle) = new CollisionProperty
{
GenerateOverlapEvents = GenerateOverlapEvents,
CollisionEnabled = CollisionPresets.CollisionEnabled,
ObjectType = CollisionPresets.ObjectType,
Visibility = CollisionPresets.CollisionResponses.TraceResponse.Visibility,
Camera = CollisionPresets.CollisionResponses.TraceResponse.Camera,
WorldStatic = CollisionPresets.CollisionResponses.ObjectResponse.WorldStatic,
WorldDynamic = CollisionPresets.CollisionResponses.ObjectResponse.WorldDynamic,
Pawn = CollisionPresets.CollisionResponses.ObjectResponse.Pawn,
PhysicsBody = CollisionPresets.CollisionResponses.ObjectResponse.PhysicsBody,
};
if (GenerateOverlapEvents)
{
Simulation.RegisterOverlapListener(staticHandle);
}
}
public virtual void Load(StaticHandle bodyHandle, ConnectionState connectionState, Simulator simulator, ObjectState state)
{
this.connectionState = connectionState;
this.bodyHandle = bodyHandle;
this.state = state;
this.simulator = simulator;
SetMeshRotation();
SendCreateMessage();
}
internal void DestroyStatic(StaticHandle handle) => simulation.Statics.Remove(handle);
public CollidableReference(StaticHandle handle)
: this(CollidableMobility.Static, handle.Value)
{
}
internal void UnregisterCollider(StaticHandle handle) => collidersS.TryRemove(handle, out _);
internal ICollitionHandler GetHandler(StaticHandle handle) => collidersS.GetValueOrDefault(handle);
internal void RegisterCollider(StaticHandle handle, ICollitionHandler handler) => collidersS.TryAdd(handle, handler);
public StaticPhyObject handleToPhyObject(StaticHandle handle)
{
StaticPhyObject obj = staticObjectsHandlers[handle];
return(obj);
}
public PhysicsStatic(PhysicsSimulation simulation, StaticHandle handle) : base(simulation)
{
Handle = handle;
Reference = simulation.Simulation.Statics.GetStaticReference(handle);
}
public TriggerBox(PhysicsSimulation simulation, StaticHandle handle) : base(simulation, handle)
{
}
public StaticReference GetStaticReference(StaticHandle handle)
{
return(new StaticReference(handle, Simulation.Statics));
}
public object GetStaticContext(StaticHandle handle) => _staticContexts.ContainsKey(handle) ? _staticContexts[handle] : null;
