public void CallOnCollide(PhysicsCollider collider)
{
if (OnCollision != null) {
//Debug.Log("Call it!");
OnCollision(collider);
}
}
/// <summary>
/// Performs a collision correction at the specified position.
/// </summary>
/// <param name="entity"></param>
/// <param name="currPos"></param>
/// <param name="currRot"></param>
/// <param name="controller"></param>
/// <param name="collider"></param>
/// <param name="collisionWorld"></param>
private void CorrectForCollision(ref Entity entity, ref float3 currPos, ref quaternion currRot, ref CharacterControllerData controller, ref PhysicsCollider collider, ref CollisionWorld collisionWorld)
{
RigidTransform transform = new RigidTransform()
{
pos = currPos,
rot = currRot
};
// Use a subset sphere within our collider to test against.
// We do not use the collider itself as some intersection (such as on ramps) is ok.
var offset = -math.normalize(controller.gravity) * 0.1f;
var sampleCollider = new PhysicsCollider()
{
Value = SphereCollider.Create(new SphereGeometry()
{
Center = currPos + offset,
Radius = 0.1f
})
};
if (PhysicsUtils.ColliderDistance(out DistanceHit smallestHit, sampleCollider, 0.1f, transform, ref collisionWorld, entity, PhysicsCollisionFilters.DynamicWithPhysical, null, ColliderData, Allocator.Temp))
{
if (smallestHit.Distance < 0.0f)
{
currPos += math.abs(smallestHit.Distance) * smallestHit.SurfaceNormal;
}
}
}
public void OnCollide(PhysicsCollider collider)
{
//Debug.Log(state.velocity);
Game.instance.BallCollide(collider);
if (PhysicsManager.simulatedPhysic && collider.GetType() == typeof(PhysicsPlane)) {
if (collider.name == "WallLeft" || collider.name == "WallRight" || collider.name == "WallUp") { return; }
foreach (var obj in Object.FindObjectsOfType<AIPlayer>()) {
obj.ballCollisions++;
}
}
if (!PhysicsManager.simulatedPhysic && collider.GetType() == typeof(PhysicsPlane)) {
var plane = (PhysicsPlane)collider;
var normal = plane.Normal;
normal.x = Mathf.Abs(normal.x);
normal.y = Mathf.Abs(normal.y);
normal.z = Mathf.Abs(normal.z);
Vector3 wobble = Vector3.one;
if (normal.x > 0.5) { wobble = new Vector3(0.5f, 1.25f, 1.25f); }
if (normal.y > 0.5) { wobble = new Vector3(1.25f, 0.5f, 1.25f); }
if (normal.z > 0.5) { wobble = new Vector3(1.25f, 1.25f, 0.5f); }
_wobble = wobble;
}
}
public void Tick(float DeltaTime)
{
foreach (EHPhysics2D PhysicsComponent in PhysicsComponentSet)
{
if (PhysicsComponent.gameObject.activeInHierarchy && PhysicsComponent.enabled)
{
PhysicsComponent.Tick(DeltaTime);
}
}
foreach (EHBaseCollider2D MoveableCollider in ColliderComponentDictionary[EHBaseCollider2D.EColliderType.MOVEABLE])
{
if (MoveableCollider.gameObject.activeInHierarchy)
{
MoveableCollider.UpdateColliderBounds(true);
MoveableCollider.DragIntersectingColliders();
}
}
foreach (EHBaseCollider2D PhysicsCollider in ColliderComponentDictionary[EHBaseCollider2D.EColliderType.PHYSICS])
{
if (PhysicsCollider.gameObject.activeInHierarchy)
{
PhysicsCollider.UpdateColliderBounds(true);
}
}
foreach (EHBaseCollider2D TriggerCollider in TriggerColliderSet)
{
TriggerCollider.UpdateColliderBounds(false);
}
CheckPhysicsCollidersAgainstCategory();
CheckTriggerIntersections();
}
public unsafe void Execute <TCtx>(TCtx ctx, InputTriggerPort port) where TCtx : IGraphInstance
{
var entity = ctx.ReadEntity(Entity);
if (entity == Unity.Entities.Entity.Null)
{
return;
}
if (!ctx.EntityManager.HasComponent <PhysicsCollider>(entity))
{
return;
}
PhysicsCollider physicsCollider = ctx.EntityManager.GetComponentData <PhysicsCollider>(entity);
Collider * colliderPtr = (Collider *)physicsCollider.Value.GetUnsafePtr();
CollisionFilter newFilter = new CollisionFilter();
newFilter.BelongsTo = (uint)ctx.ReadInt(this.BelongsTo);
newFilter.CollidesWith = (uint)ctx.ReadInt(this.CollidesWith);
newFilter.GroupIndex = ctx.ReadInt(this.GroupIndex);
colliderPtr->Filter = newFilter;
ctx.Trigger(Output);
}
void Reset()
{
animator = GetComponent <Animator>();
renderer = GetComponent <SpriteRenderer>();
rigid = GetComponent <Rigidbody2D>();
//_hitable = GetComponent<HitableBullet>();
//hitableRay = GetComponent<HitableBulletRay>();
hitableCircleCast = GetComponent <HitableBulletCircleCast>();
hitableTrigger = GetComponent <HitableBulletTrigger>();
hitableRaycast = GetComponent <HitableBulletRayCast>();
shootable = GetComponent <ShootableBullet>();
moveable = GetComponent <MoveableBullet>();
ownerable = GetComponent <OwnerableBullet>();
timeLimitable = GetComponent <TimeLimitableBullet>();
damageable = GetComponent <DamageableBullet>();
spawnable = GetComponent <SpawnableBullet>();
shakeable = GetComponent <ShakeableBullet>();
disapearable = GetComponent <DisapearableBullet>();
guideable = GetComponent <GuideableBullet>();
orderable = GetComponent <Orderable>();
spinable = GetComponent <SpinableBullet>();
polygon = GetComponent <PolygonCollider2D>();
circle = GetComponent <CircleCollider2D>();
physics = GetComponent <PhysicsCollider>();
cachedTransform = transform;
}
/// <summary>
/// Performs a collider cast along the specified ray.<para/>
///
/// Will return true if there was a collision and populate the provided <see cref="ColliderCastHit"/>.
/// </summary>
/// <param name="nearestHit"></param>
/// <param name="collider"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="collisionWorld"></param>
/// <param name="ignore"></param>
/// <param name="filter">Used to exclude collisions that do not match the filter.</param>
/// <param name="manager">Required if specifying a collision filter. Otherwise is unused.</param>
/// <param name="colliderData">Alternative to the EntityManager if used in a job.</param>
/// <returns></returns>
public unsafe static bool ColliderCast(
out ColliderCastHit nearestHit,
PhysicsCollider collider,
float3 from,
float3 to,
ref CollisionWorld collisionWorld,
Entity ignore,
CollisionFilter?filter = null,
EntityManager?manager = null,
ComponentDataFromEntity <PhysicsCollider>?colliderData = null,
Allocator allocator = Allocator.TempJob)
{
nearestHit = new ColliderCastHit();
NativeList <ColliderCastHit> allHits = ColliderCastAll(collider, from, to, ref collisionWorld, ignore, allocator);
if (filter.HasValue)
{
if (manager.HasValue)
{
TrimByFilter(ref allHits, manager.Value, filter.Value);
}
else if (colliderData.HasValue)
{
TrimByFilter(ref allHits, colliderData.Value, filter.Value);
}
}
GetSmallestFractional(ref allHits, out nearestHit);
allHits.Dispose();
return(true);
}
/// <summary>
/// Performs a collider cast using the specified collider.
/// </summary>
/// <param name="smallestDistanceHit"></param>
/// <param name="collider"></param>
/// <param name="maxDistance"></param>
/// <param name="transform"></param>
/// <param name="collisionWorld"></param>
/// <param name="ignore"></param>
/// <returns></returns>
public static bool ColliderDistance(
out DistanceHit smallestDistanceHit,
PhysicsCollider collider,
float maxDistance,
RigidTransform transform,
ref CollisionWorld collisionWorld,
Entity ignore,
CollisionFilter?filter = null,
EntityManager?manager = null,
ComponentDataFromEntity <PhysicsCollider>?colliderData = null,
Allocator allocator = Allocator.TempJob)
{
var allDistances = ColliderDistanceAll(collider, maxDistance, transform, ref collisionWorld, ignore, allocator);
if (filter.HasValue)
{
if (manager.HasValue)
{
TrimByFilter(ref allDistances, manager.Value, filter.Value);
}
else if (colliderData.HasValue)
{
TrimByFilter(ref allDistances, colliderData.Value, filter.Value);
}
}
GetSmallestFractional(ref allDistances, out smallestDistanceHit);
allDistances.Dispose();
return(true);
}
unsafe void OnEnable()
{
if (this.enabled)
{
// Create entity prefab from the game object hierarchy once
Entity sourceEntity = GameObjectConversionUtility.ConvertGameObjectHierarchy(prefab, World.Active);
var entityManager = World.Active.EntityManager;
var positions = new NativeArray <float3>(count, Allocator.Temp);
var rotations = new NativeArray <quaternion>(count, Allocator.Temp);
RandomPointsOnCircle(transform.position, range, ref positions, ref rotations);
PhysicsCollider collider = entityManager.GetComponentData <PhysicsCollider>(sourceEntity);
Unity.Physics.Material material = ((ConvexColliderHeader *)collider.ColliderPtr)->Material;
material.Restitution = 1.0f;
((ConvexColliderHeader *)collider.ColliderPtr)->Material = material;
for (int i = 0; i < count; i++)
{
var instance = entityManager.Instantiate(sourceEntity);
entityManager.SetComponentData(instance, new Translation {
Value = positions[i]
});
entityManager.SetComponentData(instance, new Rotation {
Value = rotations[i]
});
entityManager.SetComponentData(instance, collider);
}
positions.Dispose();
rotations.Dispose();
}
}
public static PhysicsCollider CreateTerrainCollider(TerrainData terrainData, CollisionFilter filter)
{
var physicsCollider = new PhysicsCollider();
var size = new int2(terrainData.heightmapResolution, terrainData.heightmapResolution);
var scale = terrainData.heightmapScale;
var colliderHeights = new NativeArray<float>(terrainData.heightmapResolution * terrainData.heightmapResolution,
Allocator.TempJob);
var terrainHeights = terrainData.GetHeights(0, 0, terrainData.heightmapResolution,
terrainData.heightmapResolution);
for (int j = 0; j < size.y; j++)
for (int i = 0; i < size.x; i++)
{
var h = terrainHeights[i, j];
colliderHeights[j + i * size.x] = h;
}
physicsCollider.Value = Unity.Physics.TerrainCollider.Create(colliderHeights, size, scale,
Unity.Physics.TerrainCollider.CollisionMethod.Triangles, filter);
colliderHeights.Dispose();
return physicsCollider;
}
public static PhysicsCollider GetEnviromentPhysicsCollider(string name, float scale = 1f)
{
PhysicsCollider pc = new PhysicsCollider {
};
switch (name)
{
case "Kanto|Tree":
NativeArray <CompoundCollider.ColliderBlobInstance> cs = new NativeArray <CompoundCollider.ColliderBlobInstance>(2, Allocator.TempJob);
cs[0] = new CompoundCollider.ColliderBlobInstance
{
Collider = CylinderCollider.Create(new CylinderGeometry
{
Orientation = Quaternion.Euler(new float3(270f, 270f, 0)),
Height = 1f * scale,
Radius = .25f * scale,
SideCount = 20,
Center = new float3(0, .5f, 0) * scale
}, new CollisionFilter
{
BelongsTo = TriggerEventClass.Collidable,
CollidesWith = TriggerEventClass.Collidable,
GroupIndex = 1
}),
CompoundFromChild = new RigidTransform {
rot = quaternion.identity
}
};
cs[1] = new CompoundCollider.ColliderBlobInstance
{
Collider = CylinderCollider.Create(new CylinderGeometry
{
Center = new float3(0, 1.7f, 0) * scale,
Orientation = Quaternion.Euler(new float3(90f, 0, 0)),
Height = 1.5f * scale,
Radius = 1f * scale,
SideCount = 20
}, new CollisionFilter
{
BelongsTo = TriggerEventClass.Collidable,
CollidesWith = TriggerEventClass.Collidable,
GroupIndex = 1
}),
CompoundFromChild = new RigidTransform {
rot = quaternion.identity
}
};
pc = new PhysicsCollider {
Value = CompoundCollider.Create(cs)
};
cs.Dispose();
break;
default:
Debug.LogWarning("Failed to get collider for \"" + name + "\"");
break;
}
return(pc);
}
public unsafe void Execute <TCtx>(TCtx ctx, InputTriggerPort port) where TCtx : IGraphInstance
{
var entity = ctx.ReadEntity(Entity);
if (entity == Unity.Entities.Entity.Null)
{
return;
}
if (!ctx.EntityManager.HasComponent <PhysicsCollider>(entity))
{
return;
}
PhysicsCollider physicsCollider = ctx.EntityManager.GetComponentData <PhysicsCollider>(entity);
Collider * colliderPtr = (Collider *)physicsCollider.Value.GetUnsafePtr();
if (!ctx.EntityManager.HasComponent <PhysicsGravityFactor>(entity))
{
ctx.EntityManager.AddComponent <PhysicsGravityFactor>(entity);
}
float gravityFactor = ctx.ReadFloat(GravityFactor);
ctx.EntityManager.SetComponentData(entity, new PhysicsGravityFactor()
{
Value = gravityFactor
});
if (!ctx.EntityManager.HasComponent <PhysicsMass>(entity))
{
ctx.EntityManager.AddComponent <PhysicsMass>(entity);
}
float mass = ctx.ReadFloat(Mass);
ctx.EntityManager.SetComponentData(entity, PhysicsMass.CreateDynamic(colliderPtr->MassProperties, mass));
if (!ctx.EntityManager.HasComponent <PhysicsVelocity>(entity))
{
ctx.EntityManager.AddComponent <PhysicsVelocity>(entity);
}
ctx.EntityManager.SetComponentData(entity, new PhysicsVelocity {
Linear = float3.zero, Angular = float3.zero
});
float drag = ctx.ReadFloat(Drag);
float angularDrag = ctx.ReadFloat(AngularDrag);
if (!ctx.EntityManager.HasComponent <PhysicsDamping>(entity))
{
ctx.EntityManager.AddComponent <PhysicsDamping>(entity);
}
ctx.EntityManager.SetComponentData(entity, new PhysicsDamping {
Linear = drag, Angular = angularDrag
});
ctx.Trigger(Output);
}
internal override void ConfigureInstance(Entity instance, ref SpawnExplosionSettings spawnSettings)
{
// Create single collider per Explosion group
if (GroupId != spawnSettings.Id)
{
GroupId = spawnSettings.Id;
spawnSettings.Source = instance;
var collider = EntityManager.GetComponentData <PhysicsCollider>(instance);
var memsize = collider.Value.Value.MemorySize;
var oldFilter = collider.Value.Value.Filter;
// Only one of these needed per group, since all debris within
// a group will share a single collider
// This will make debris within a group collide some time after the explosion happens
EntityManager.AddComponentData(instance, new ChangeFilterCountdown
{
Countdown = spawnSettings.Countdown * 2,
Filter = oldFilter
});
// Make unique collider for each spawned group
unsafe
{
// Create new collider for the group
// TODO : make Collider ICloneable
BlobAssetReference <Collider> colliderCopy = BlobAssetReference <Collider> .Create(UnsafeUtility.Malloc(memsize, 16, Allocator.Persistent), memsize);
UnsafeUtility.MemCpy(colliderCopy.GetUnsafePtr(), collider.ColliderPtr, memsize);
// Set the GroupIndex to GroupId, which is negative
// This ensures that the debris within a group don't collide
colliderCopy.Value.Filter = new CollisionFilter
{
BelongsTo = oldFilter.BelongsTo,
CollidesWith = oldFilter.CollidesWith,
GroupIndex = GroupId,
};
PhysicsCollider newCollider = new PhysicsCollider
{
Value = colliderCopy
};
GroupCollider = newCollider;
CreatedColliders.Add(GroupCollider);
}
}
EntityManager.SetComponentData(instance, GroupCollider);
EntityManager.AddComponentData(instance, new ExplosionCountdown
{
Source = spawnSettings.Source,
Countdown = spawnSettings.Countdown,
Center = spawnSettings.Position,
Force = spawnSettings.Force
});
}
public static unsafe void SetBoxColliderSize(PhysicsCollider physicsCollider, float3 size)
{
Assert.IsTrue(physicsCollider.ColliderPtr->Type == ColliderType.Box);
var scPtr = (BoxCollider *)physicsCollider.ColliderPtr;
var geometry = scPtr->Geometry;
geometry.Size = size;
scPtr->Geometry = geometry;
}
/// <summary>
/// Handles horizontal movement on the XZ plane.
/// </summary>
/// <param name="horizontalVelocity"></param>
/// <param name="entity"></param>
/// <param name="currPos"></param>
/// <param name="currRot"></param>
/// <param name="controller"></param>
/// <param name="collider"></param>
/// <param name="collisionWorld"></param>
private void HandleHorizontalMovement(
ref float3 horizontalVelocity,
ref Entity entity,
ref float3 currPos,
ref quaternion currRot,
ref CharacterControllerData controller,
ref PhysicsCollider collider,
ref CollisionWorld collisionWorld)
{
if (MathUtils.IsZero(horizontalVelocity))
{
return;
}
float3 targetPos = currPos + horizontalVelocity;
NativeList <ColliderCastHit> horizontalCollisions = PhysicsUtils.ColliderCastAll(collider, currPos, targetPos, ref collisionWorld, entity, Allocator.Temp);
PhysicsUtils.TrimByFilter(ref horizontalCollisions, ColliderData, PhysicsCollisionFilters.DynamicWithPhysical);
if (horizontalCollisions.Length > 0)
{
// We either have to step or slide as something is in our way.
float3 step = new float3(0.0f, controller.maxStep, 0.0f);
PhysicsUtils.ColliderCast(out ColliderCastHit nearestStepHit, collider, targetPos + step, targetPos, ref collisionWorld, entity, PhysicsCollisionFilters.DynamicWithPhysical, null, ColliderData, Allocator.Temp);
if (!MathUtils.IsZero(nearestStepHit.Fraction))
{
// We can step up.
targetPos += (step * (1.0f - nearestStepHit.Fraction));
horizontalVelocity = targetPos - currPos;
}
else
{
// We can not step up, so slide.
NativeList <DistanceHit> horizontalDistances = PhysicsUtils.ColliderDistanceAll(collider, 1.0f, new RigidTransform()
{
pos = currPos + horizontalVelocity, rot = currRot
}, ref collisionWorld, entity, Allocator.Temp);
PhysicsUtils.TrimByFilter(ref horizontalDistances, ColliderData, PhysicsCollisionFilters.DynamicWithPhysical);
for (int i = 0; i < horizontalDistances.Length; ++i)
{
if (horizontalDistances[i].Distance >= 0.0f)
{
continue;
}
horizontalVelocity += (horizontalDistances[i].SurfaceNormal * -horizontalDistances[i].Distance);
}
horizontalDistances.Dispose();
}
}
horizontalCollisions.Dispose();
}
private static void AddMass(Entity e, PhysicsCollider collider)
{
PhysicsMass physicsMass = PhysicsMass.CreateDynamic(collider.MassProperties, 1f);
physicsMass.InverseInertia = new float3(0f, 0f, 0f); // Freeze rotation
m.AddComponentData(e, physicsMass);
m.AddComponentData(e, new PhysicsGravityFactor {
Value = 0f
}); // Disable built-in gravity on all dynamic entities
}
public ATriggerEvent processTriggers(ATriggerEvent ate)
{
PhysicsCollider physicsCollider = EntityManager.GetComponentData <PhysicsCollider>(ate.entityA);
switch (physicsCollider.Value.Value.Filter.BelongsTo)
{
case TriggerEventClass.Damage | TriggerEventClass.PokemonAttacking:
if (!EntityManager.HasComponent <DamageTrigger>(ate.entityB))
{
// Debug.Log("Adding DamageTrigger");
EntityManager.AddComponentData <DamageTrigger>(ate.entityB,
new DamageTrigger {
Value = EntityManager.GetComponentData <DamageTriggerData>(ate.entityA).Value
});
}
// else Debug.Log("The Entity already has a DamageTrigger");
return(new ATriggerEvent
{
entityA = ate.entityA,
entityB = ate.entityB,
valid = true,
triggerType = TriggerEventClass.Damage
});
case TriggerEventClass.Interaction:
if (!EntityManager.HasComponent <InteractionTrigger>(ate.entityB))
{
// Debug.Log("Adding InteractionTrigger");
EntityManager.AddComponentData <InteractionTrigger>(ate.entityB, new InteractionTrigger {
});
}
// else Debug.Log("The Entity already has a InteractionTrigger");
return(new ATriggerEvent
{
entityA = ate.entityA,
entityB = ate.entityB,
valid = true,
triggerType = TriggerEventClass.Interaction
});
default:
PhysicsCollider pc2 = EntityManager.GetComponentData <PhysicsCollider>(ate.entityB);
// Debug.Log("Detected an Unknown TriggerType " + ate.ToString() + " ABElongsTO = \""+ EntityManager.GetName(ate.entityA)+"\"\n"+
// /*physicsCollider.Value.Value.Filter.BelongsTo+*/"|"+TriggerEventClass.CollisionFilterValueToString(physicsCollider.Value.Value.Filter.BelongsTo) + ":"
// + /*physicsCollider.Value.Value.Filter.CollidesWith+*/"|"+ TriggerEventClass.CollisionFilterValueToString(physicsCollider.Value.Value.Filter.CollidesWith));
/* Debug.Log("Detected unknown Trigger Type:\nEntity A = \""+
* EntityManager.GetName(ate.entityA)+"\"\n\tBelongsTo: "+TriggerEventClass.CollisionFilterValueToString(physicsCollider.Value.Value.Filter.BelongsTo)+"\n\tCollidesWith: "+ TriggerEventClass.CollisionFilterValueToString(physicsCollider.Value.Value.Filter.CollidesWith)+
* "\nEntity B = \""+EntityManager.GetName(ate.entityB)+"\"\n\tBelongsTo: " + TriggerEventClass.CollisionFilterValueToString(pc2.Value.Value.Filter.BelongsTo) + "\n\tCollidesWith: " + TriggerEventClass.CollisionFilterValueToString(pc2.Value.Value.Filter.CollidesWith)
* );*/
break;
}
return(ate);
}
/// <summary>
/// Register the creation of a new collider
/// </summary>
/// <param name="Collider"></param>
public static void RegisterColliderCreate(PhysicsCollider Collider)
{
PhysicsController physics = Main;
if (Collider.gameObject.isStatic)
{
physics.mStaticColliders.Add(Collider);
}
else
{
physics.mDynamicColliders.Add(Collider);
}
}
/// <summary>
/// Register the destruction of a collider
/// </summary>
/// <param name="Collider"></param>
public static void RegisterColliderDestruction(PhysicsCollider Collider)
{
PhysicsController physics = Main;
if (Collider.gameObject.isStatic)
{
physics.mStaticColliders.Remove(Collider);
}
else
{
physics.mDynamicColliders.Remove(Collider);
}
}
public void ApplyChange(EntityManager entityManager, Entity entity, float mass = 0)
{
pm = entityManager.GetComponentData <PhysicsMass>(entity);
pc = entityManager.GetComponentData <PhysicsCollider>(entity);
if (IsKinematic)
{
PhysicsMass.CreateKinematic(pc.MassProperties);
}
else if (IsDynamic)
{
PhysicsMass.CreateDynamic(pc.MassProperties, mass > 0 ? mass : Mass);
}
}
public static CompoundCollider.ColliderBlobInstance[][] GenerateBasePokemonColliderData(CollisionFilter[] collisionFilter = null,
Unity.Physics.Material[] material = null, int[] groupIndex = null, int[] exclude = null)
{
if (exclude == null)
{
exclude = new int[0];
}
if (collisionFilter == null)
{
collisionFilter = new CollisionFilter[MaxPokedexNumber];
}
if (material == null)
{
material = new Unity.Physics.Material[MaxPokedexNumber];
}
if (groupIndex == null)
{
groupIndex = new int[MaxPokedexNumber];
for (int i = 0; i < MaxPokedexNumber; i++)
{
groupIndex[i] = 1;
}
}
CompoundCollider.ColliderBlobInstance[][] temp = new CompoundCollider.ColliderBlobInstance[MaxPokedexNumber][];
PhysicsCollider physicsCollider = new PhysicsCollider {
};
NativeArray <CompoundCollider.ColliderBlobInstance> colliders;
Quaternion rotation = new quaternion();
for (int i = 1; i < MaxPokedexNumber; i++)
{
// Debug.Log("Height = "+ PokemonBaseEntityData[i].Height+" i = "+i);
if (collisionFilter[i].Equals(new CollisionFilter()))
{
// Debug.Log("Creating new Collision Filter");
collisionFilter[i] = new CollisionFilter
{
BelongsTo = TriggerEventClass.Pokemon | TriggerEventClass.Collidable,
CollidesWith = TriggerEventClass.Collidable,
GroupIndex = groupIndex[i]
};
}
if (material[i].Equals(new Unity.Physics.Material()))
{
material[i] = GetPokemonColliderMaterial(i);
}
temp[i] = GeneratePokemonCollider(i, collisionFilter[i], material[i], groupIndex[i]);
}
return(temp);
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
NativeArray <KinematicMotor> chunkMotors = chunk.GetNativeArray(KinematicMotorType);
NativeArray <Movement> chunkMovements = chunk.GetNativeArray(MovementType);
NativeArray <PhysicsCollider> chunkColliders = chunk.GetNativeArray(PhysicsColliderType);
NativeArray <Translation> chunkTranslations = chunk.GetNativeArray(TranslationType);
NativeArray <Rotation> chunkRotations = chunk.GetNativeArray(RotationType);
for (int i = 0; i < chunk.Count; i++)
{
KinematicMotor motor = chunkMotors[i];
Movement movement = chunkMovements[i];
PhysicsCollider collider = chunkColliders[i];
Translation translation = chunkTranslations[i];
Rotation rotation = chunkRotations[i];
RigidTransform transform = new RigidTransform
{
pos = translation.Value,
rot = rotation.Value
};
float3 velocity = movement.Value;
unsafe
{
Collider *queryCollider;
{
Collider *colliderPtr = collider.ColliderPtr;
byte *copiedColliderMemory = stackalloc byte[colliderPtr->MemorySize];
queryCollider = (Collider *)(copiedColliderMemory);
UnsafeUtility.MemCpy(queryCollider, colliderPtr, colliderPtr->MemorySize);
queryCollider->Filter = CollisionFilter.Default;
}
KinematicMotorUtilities.SolveCollisionConstraints(World, DeltaTime, motor.MaxIterations, motor.SkinWidth, 360, queryCollider, ref transform, ref velocity, ref DistanceHits, ref ColliderCastHits, ref SurfaceConstraintInfos);
}
translation.Value = transform.pos;
movement.Value = velocity;
// Apply data back to chunk
{
chunkTranslations[i] = translation;
chunkMovements[i] = movement;
}
}
}
public unsafe void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
UnityEngine.MeshFilter meshFilter = this.GetComponent <UnityEngine.MeshFilter>();
PhysicsCollider physicsCollider = new PhysicsCollider
{
Value = BoxCollider.Create
(
CollisionGeomeotrySingleton.Instance.CreateOrGetBoxGeometry(meshFilter.mesh.bounds.size),
CollisionFilterSingleton.Instance.BelongsToPlayerFilter
)
};
dstManager.AddComponentData(entity, physicsCollider);
}
/// <summary>
/// Handles vertical movement from gravity and jumping.
/// </summary>
/// <param name="entity"></param>
/// <param name="currPos"></param>
/// <param name="currRot"></param>
/// <param name="controller"></param>
/// <param name="collider"></param>
/// <param name="collisionWorld"></param>
private void HandleVerticalMovement(
ref float3 verticalVelocity,
ref Entity entity,
ref float3 currPos,
ref quaternion currRot,
ref CharacterControllerData controller,
ref PhysicsCollider collider,
ref CollisionWorld collisionWorld, float DeltaTime)
{
controller.verticalVelocity = verticalVelocity;
if (MathUtils.IsZero(verticalVelocity))
{
return;
}
verticalVelocity *= DeltaTime;
NativeList <ColliderCastHit> verticalCollisions = PhysicsUtils.ColliderCastAll(collider, currPos, currPos + verticalVelocity, ref collisionWorld, entity, Allocator.Temp);
PhysicsUtils.TrimByFilter(ref verticalCollisions, ColliderData, PhysicsCollisionFilters.DynamicWithPhysical);
if (verticalCollisions.Length > 0)
{
RigidTransform transform = new RigidTransform()
{
pos = currPos + verticalVelocity,
rot = currRot
};
if (PhysicsUtils.ColliderDistance(out DistanceHit verticalPenetration, collider, 1.0f, transform, ref collisionWorld, entity, PhysicsCollisionFilters.DynamicWithPhysical, null, ColliderData, Allocator.Temp))
{
if (verticalPenetration.Distance < -0.01f)
{
verticalVelocity += (verticalPenetration.SurfaceNormal * verticalPenetration.Distance);
if (PhysicsUtils.ColliderCast(out ColliderCastHit adjustedHit, collider, currPos, currPos + verticalVelocity, ref collisionWorld, entity, PhysicsCollisionFilters.DynamicWithPhysical, null, ColliderData, Allocator.Temp))
{
verticalVelocity *= adjustedHit.Fraction;
}
}
}
}
verticalVelocity = MathUtils.ZeroOut(verticalVelocity, 0.0001f);
verticalCollisions.Dispose();
}
/// <summary>
/// Variant of <see cref="TrimByFilter{T}(ref NativeList{T}, EntityManager, CollisionFilter)"/> to be used within a Job which does not have access to an <see cref="EntityManager"/>.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="castResults"></param>
/// <param name="colliderData"></param>
/// <param name="filter"></param>
public unsafe static void TrimByFilter <T>(ref NativeList <T> castResults, ComponentDataFromEntity <PhysicsCollider> colliderData, CollisionFilter filter) where T : struct, IQueryResult
{
for (int i = (castResults.Length - 1); i >= 0; --i)
{
if (colliderData.HasComponent(castResults[i].Entity))
{
PhysicsCollider collider = colliderData[castResults[i].Entity];
if (CollisionFilter.IsCollisionEnabled(filter, collider.ColliderPtr->Filter))
{
continue;
}
}
castResults.RemoveAt(i);
}
}
private static PhysicsCollider CreateCompoundCollider(PhysicsCollider c1, PhysicsCollider c2)
{
CompoundCollider.ColliderBlobInstance[] colliderArray = new CompoundCollider.ColliderBlobInstance[2];
colliderArray[0] = new CompoundCollider.ColliderBlobInstance {
Collider = c1.Value
};
colliderArray[1] = new CompoundCollider.ColliderBlobInstance {
Collider = c2.Value
};
NativeArray <CompoundCollider.ColliderBlobInstance> colliderNativeArray = new NativeArray <CompoundCollider.ColliderBlobInstance>(colliderArray, Allocator.TempJob);
PhysicsCollider compoundCollider = new PhysicsCollider {
Value = CompoundCollider.Create(colliderNativeArray)
};
colliderNativeArray.Dispose();
return(compoundCollider);
}
public Entity CreateBody(float3 position, quaternion orientation, BlobAssetReference <Collider> collider,
float3 linearVelocity, float3 angularVelocity, float mass, bool isDynamic)
{
var entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
Entity entity = entityManager.CreateEntity(new ComponentType[] {});
entityManager.AddComponentData(entity, new LocalToWorld {
});
entityManager.AddComponentData(entity, new Translation {
Value = position
});
entityManager.AddComponentData(entity, new Rotation {
Value = orientation
});
var colliderComponent = new PhysicsCollider {
Value = collider
};
entityManager.AddComponentData(entity, colliderComponent);
EntityManager.AddSharedComponentData(entity, new PhysicsWorldIndex());
CreateRenderMeshForCollider(entityManager, entity, collider, isDynamic ? DynamicMaterial : StaticMaterial);
if (isDynamic)
{
entityManager.AddComponentData(entity, PhysicsMass.CreateDynamic(colliderComponent.MassProperties, mass));
float3 angularVelocityLocal = math.mul(math.inverse(colliderComponent.MassProperties.MassDistribution.Transform.rot), angularVelocity);
entityManager.AddComponentData(entity, new PhysicsVelocity
{
Linear = linearVelocity,
Angular = angularVelocityLocal
});
entityManager.AddComponentData(entity, new PhysicsDamping
{
Linear = 0.01f,
Angular = 0.05f
});
}
return(entity);
}
private void UpdateBoundsOfColliders()
{
foreach (KeyValuePair <CustomCollider2D.ECollisionType, HashSet <CustomCollider2D> > KeyValueColliderDictionaryData in AllActiveCollider2DComponentsInLevel)
{
if (KeyValueColliderDictionaryData.Key != CustomCollider2D.ECollisionType.STATIC)
{
foreach (CustomCollider2D Collider2D in KeyValueColliderDictionaryData.Value)
{
Collider2D.UpdateColliderBounds();
}
}
}
foreach (CustomCollider2D PhysicsCollider in AllActiveCollider2DComponentsInLevel[CustomCollider2D.ECollisionType.PHYSICS])
{
PhysicsCollider.UpdatePhysicsColliderBounds();
}
}
/// <summary>
/// Returns a list of all colliders within the specified distance of the provided collider, as a list of <see cref="DistanceHit"/>.<para/>
///
/// Can be used in conjunction with <see cref="ColliderCastAll"/> to get the penetration depths of any colliders (using the distance of collisions).<para/>
///
/// The caller must dispose of the returned list.
/// </summary>
/// <param name="collider"></param>
/// <param name="maxDistance"></param>
/// <param name="transform"></param>
/// <param name="collisionWorld"></param>
/// <returns></returns>
public unsafe static NativeList <DistanceHit> ColliderDistanceAll(PhysicsCollider collider, float maxDistance, RigidTransform transform, ref CollisionWorld collisionWorld, Entity ignore, Allocator allocator = Allocator.TempJob)
{
ColliderDistanceInput input = new ColliderDistanceInput()
{
Collider = collider.ColliderPtr,
MaxDistance = maxDistance,
Transform = transform
};
NativeList <DistanceHit> allDistances = new NativeList <DistanceHit>(allocator);
if (collisionWorld.CalculateDistance(input, ref allDistances))
{
TrimByEntity(ref allDistances, ignore);
}
return(allDistances);
}
/// <summary>
/// Performs a collider cast along the specified ray and returns all resulting <see cref="ColliderCastHit"/>s.<para/>
///
/// The caller must dispose of the returned list.
/// </summary>
/// <param name="collider"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="collisionWorld"></param>
/// <param name="ignore">Will ignore this entity if it was hit. Useful to prevent returning hits from the caster.</param>
/// <returns></returns>
public unsafe static NativeList <ColliderCastHit> ColliderCastAll(PhysicsCollider collider, float3 from, float3 to, ref CollisionWorld collisionWorld, Entity ignore, Allocator allocator = Allocator.TempJob)
{
ColliderCastInput input = new ColliderCastInput()
{
Collider = collider.ColliderPtr,
Start = from,
End = to
};
NativeList <ColliderCastHit> allHits = new NativeList <ColliderCastHit>(allocator);
if (collisionWorld.CastCollider(input, ref allHits))
{
TrimByEntity(ref allHits, ignore);
}
return(allHits);
}
void Start()
{
var em = World.Active.EntityManager;
EntityArchetype colliderArchetype = em.CreateArchetype(typeof(Translation)
, typeof(Rotation)
, typeof(PhysicsCollider)
// , typeof(PhysicsMass)
, typeof(PhysicsVelocity)
// , typeof(PhysicsDamping)
// , typeof(PhysicsGravityFactor)
);
var entity = em.CreateEntity(colliderArchetype);
_entity = entity;
#if UNITY_EDITOR
em.SetName(entity, "MyTestCollider");
#endif
em.SetComponentData(entity, new Translation {
Value = new float3(-0.5f, 23.81f, 0.5f),
});
var colli = new PhysicsCollider {
Value = Unity.Physics.SphereCollider.Create(new SphereGeometry {
Center = new float3(0, 0, 0), Radius = 0.5f,
},
new Unity.Physics.CollisionFilter {
BelongsTo = ~0u, CollidesWith = ~0u,
}, new Unity.Physics.Material {
Friction = 0,
FrictionCombinePolicy = Unity.Physics.Material.CombinePolicy.Maximum,
Restitution = 0f,
RestitutionCombinePolicy = Unity.Physics.Material.CombinePolicy.Maximum,
Flags = 0,
}),
};
em.SetComponentData(entity, colli);
em.SetComponentData(entity, new Rotation {
Value = new quaternion(0f, 0f, 0f, 1f),
});
// em.SetComponentData(entity, PhysicsMass.CreateKinematic(MassProperties.UnitSphere));
// em.SetComponentData(entity, PhysicsMass.CreateDynamic(MassProperties.UnitSphere, 1f));
// em.SetComponentData(entity, new PhysicsVelocity { Linear = new float3(0,0,0), Angular = new float3(0,0,0), });
}
public void BallCollide(PhysicsCollider collider)
{
if (PhysicsManager.simulatedPhysic) { return; }
if (collider.name == "WallLeft" || collider.name == "WallRight" || collider.name == "WallUp") { return; }
if (collider.name == "ActiveWall") { SetActivePlayer(!activePlayerA); ballTouched = false; return; }
bool isA = collider.physicsObject.gameObject == playerA.gameObject;
bool isB = collider.physicsObject.gameObject == playerB.gameObject;
if (isA || isB) { ballTouched = false; return; }
if (!ballTouched) { ballTouched = true; return; }
else {
var nonActivePlayer = activePlayerA ? playerB : playerA;
nonActivePlayer.matchPoints++;
InitGame();
CheckPoints();
}
}
private void CheckPhysicsCollidersAgainstCategory()
{
foreach (EHBaseCollider2D PhysicsCollider in ColliderComponentDictionary[EHBaseCollider2D.EColliderType.PHYSICS])
{
if (PhysicsCollider.gameObject.activeInHierarchy)
{
CollisionNodeHeap.Clear();
foreach (EHBaseCollider2D Static in ColliderComponentDictionary[EHBaseCollider2D.EColliderType.STATIC])
{
if (Static.gameObject.activeInHierarchy)
{
if (PhysicsCollider.IsPhysicsColliderOverlapping(Static) && !Physics2D.GetIgnoreLayerCollision(PhysicsCollider.gameObject.layer, Static.gameObject.layer))
{
CollisionNodeHeap.Push(new CollisionNode(PhysicsCollider.GetShortestDistanceFromPreviousPosition(Static), Static));
}
}
}
foreach (EHBaseCollider2D Moveable in ColliderComponentDictionary[EHBaseCollider2D.EColliderType.MOVEABLE])
{
if (Moveable.gameObject.activeInHierarchy && !Physics2D.GetIgnoreLayerCollision(PhysicsCollider.gameObject.layer, Moveable.gameObject.layer))
{
if (PhysicsCollider.IsPhysicsColliderOverlapping(Moveable))
{
CollisionNodeHeap.Push(new CollisionNode(PhysicsCollider.GetShortestDistanceFromPreviousPosition(Moveable), Moveable));
}
}
}
while (!CollisionNodeHeap.IsEmpty())
{
EHBaseCollider2D IntersectedCollider = CollisionNodeHeap.Pop().Collider;
if (IntersectedCollider.PushOutCollider(PhysicsCollider))
{
PhysicsCollider.UpdateColliderBounds(false);
}
}
}
}
CollisionNodeHeap.Clear();
}
private static bool Collide(PhysicsCollider A, PhysicsCollider B)
{
//Optimze mit Enum!
var AType = A.GetType();
var BType = B.GetType();
if (AType == typeof(PhysicsSphere)) {
if (BType == typeof(PhysicsSphere)) {
if (!A.collideWithSphere) { return false; }
if (!B.collideWithSphere) { return false; }
return ApplyCollision(A as PhysicsSphere, B as PhysicsSphere);
}
else if (BType == typeof(PhysicsPlane)) {
if (!A.collideWithPlane) { return false; }
if (!B.collideWithSphere) { return false; }
return ApplyCollision(B as PhysicsPlane, A as PhysicsSphere);
}
}
else if (AType == typeof(PhysicsPlane)) {
if (BType == typeof(PhysicsSphere)) {
if (!A.collideWithSphere) { return false; }
if (!B.collideWithPlane) { return false; }
return ApplyCollision(A as PhysicsPlane, B as PhysicsSphere);
}
else if (BType == typeof(PhysicsPlane)) {
//ApplyCollision(A as PhysicsPlane, B as PhysicsPlane);
}
}
return false;
}
public float GetCombinedBounciness(PhysicsCollider otherCol)
{
return (otherCol.bounciness + this.bounciness) / 2;
}
private void OnCollide(PhysicsCollider collider)
{
//Debug.Log("Collide! " + collider.name);
if (collider.physicsObject.name == "Ground") {
state.velocity.y *= 0.0f;
state.position.y = groundPosition;
state.lastPosition.y = groundPosition;
if (!PhysicsManager.simulatedPhysic) {
_dashed = false;
}
}
if (collider.physicsObject.name == "Ball") {
collider.physicsObject.applyGravity = true;
if (!PhysicsManager.simulatedPhysic) {
foreach (PhysicsCollider col in colliders) {
col.collideWithSphere = false;
}
}
if (this.transform.position.z > collider.physicsObject.transform.position.z) { return; }
collider.physicsObject.state.velocity = Vector3.Lerp(collider.physicsObject.state.velocity, Vector3.forward * 0.7f + Vector3.up * 0.25f, aimAssist);
}
}
