public static bool OverlapSphereCustom <T, C>(ref T target, float3 position, float radius, ref C collector, CollisionFilter filter, QueryInteraction queryInteraction = QueryInteraction.Default) where T : struct, ICollidable where C : struct, ICollector <DistanceHit> { PointDistanceInput input = new PointDistanceInput { Filter = filter, MaxDistance = radius, Position = position }; if (queryInteraction == QueryInteraction.Default) { return(target.CalculateDistance(input, ref collector)); } else { unsafe { var interactionCollector = new QueryInteractionCollector <DistanceHit, C> { Collector = collector }; bool returnValue = target.CalculateDistance(input, ref interactionCollector); collector = interactionCollector.Collector; return(returnValue); } } }
public bool DistanceLeaf <T>(PointDistanceInput input, int rigidBodyIndex, ref T collector) where T : struct, ICollector <DistanceHit> { rigidBodyIndex += BaseRigidBodyIndex; RigidBody body = m_Bodies[rigidBodyIndex]; // Transform the input into body space var worldFromBody = new MTransform(body.WorldFromBody); MTransform bodyFromWorld = Inverse(worldFromBody); var inputLs = new PointDistanceInput { Position = Mul(bodyFromWorld, input.Position), MaxDistance = input.MaxDistance, Filter = input.Filter, QueryContext = new QueryContext { RigidBodyIndex = rigidBodyIndex, ColliderKey = ColliderKey.Empty, NumColliderKeyBits = 0, WorldFromLocalTransform = worldFromBody, Entity = body.Entity, IsInitialized = true } }; return(body.CalculateDistance(inputLs, ref collector)); }
public unsafe bool CalculateDistance <T>(PointDistanceInput input, ref T collector) where T : struct, ICollector <DistanceHit> { fixed(TerrainCollider *target = &this) { return(DistanceQueries.PointCollider(input, (Collider *)target, ref collector)); } }
public bool DistanceLeaf <T>(PointDistanceInput input, int rigidBodyIndex, ref T collector) where T : struct, ICollector <DistanceHit> { rigidBodyIndex += BaseRigidBodyIndex; RigidBody body = m_Bodies[rigidBodyIndex]; // Transform the input into body space var worldFromBody = new MTransform(body.WorldFromBody); MTransform bodyFromWorld = Inverse(worldFromBody); var inputLs = new PointDistanceInput { Position = Mul(bodyFromWorld, input.Position), MaxDistance = input.MaxDistance, Filter = input.Filter }; float fraction = collector.MaxFraction; int numHits = collector.NumHits; if (body.CalculateDistance(inputLs, ref collector)) { // Transform results back into world space collector.TransformNewHits(numHits, fraction, worldFromBody, rigidBodyIndex); return(true); } return(false); }
public bool CalculateDistance <T>(PointDistanceInput input, ref T collector) where T : struct, ICollector <DistanceHit> { // Transform the input into body space MTransform worldFromBody = new MTransform(WorldFromBody); MTransform bodyFromWorld = Inverse(worldFromBody); input.Position = Mul(bodyFromWorld, input.Position); SetQueryContextParameters(ref input.QueryContext, ref worldFromBody); return(Collider.IsCreated && Collider.Value.CalculateDistance(input, ref collector)); }
public bool DistanceLeaf <T>(PointDistanceInput input, int rigidBodyIndex, ref T collector) where T : struct, ICollector <DistanceHit> { rigidBodyIndex += BaseRigidBodyIndex; input.QueryContext.IsInitialized = true; input.QueryContext.RigidBodyIndex = rigidBodyIndex; RigidBody body = m_Bodies[rigidBodyIndex]; return(body.CalculateDistance(input, ref collector)); }
public static bool CalculateDistance <T>(ref T target, PointDistanceInput input, out DistanceHit result) where T : struct, ICollidable { var collector = new ClosestHitCollector <DistanceHit>(input.MaxDistance); if (target.CalculateDistance(input, ref collector)) { result = collector.ClosestHit; // TODO: would be nice to avoid this copy return(true); } result = new DistanceHit(); return(false); }
public bool CalculateDistance <T>(PointDistanceInput input, NativeSlice <RigidBody> rigidBodies, ref T collector) where T : struct, ICollector <DistanceHit> { if (input.Filter.IsEmpty) { return(false); } var leafProcessor = new BvhLeafProcessor(rigidBodies); leafProcessor.BaseRigidBodyIndex = m_DynamicTree.NumBodies; bool hasHit = m_StaticTree.BoundingVolumeHierarchy.Distance(input, ref leafProcessor, ref collector); leafProcessor.BaseRigidBodyIndex = 0; hasHit |= m_DynamicTree.BoundingVolumeHierarchy.Distance(input, ref leafProcessor, ref collector); return(hasHit); }
public bool DistanceLeaf <T>(PointDistanceInput input, int primitiveKey, ref T collector) where T : struct, ICollector <DistanceHit> { m_Mesh->GetPrimitive(primitiveKey, out float3x4 vertices, out Mesh.PrimitiveFlags flags, out CollisionFilter filter); if (!CollisionFilter.IsCollisionEnabled(input.Filter, filter)) // TODO: could do this check within GetPrimitive() { return(false); } int numPolygons = Mesh.GetNumPolygonsInPrimitive(flags); bool isQuad = Mesh.IsPrimitveFlagSet(flags, Mesh.PrimitiveFlags.IsQuad); float3 normalDirection = math.cross(vertices[1] - vertices[0], vertices[2] - vertices[0]); bool acceptHit = false; for (int polygonIndex = 0; polygonIndex < numPolygons; polygonIndex++) { Result result; if (isQuad) { result = QuadSphere( vertices[0], vertices[1], vertices[2], vertices[3], normalDirection, input.Position, 0.0f, MTransform.Identity); } else { result = TriangleSphere( vertices[0], vertices[1], vertices[2], normalDirection, input.Position, 0.0f, MTransform.Identity); } if (result.Distance < collector.MaxFraction) { acceptHit |= collector.AddHit(new DistanceHit { Fraction = result.Distance, Position = result.PositionOnAinA, SurfaceNormal = -result.NormalInA, ColliderKey = new ColliderKey(m_NumColliderKeyBits, (uint)(primitiveKey << 1 | polygonIndex)) }); } } return(acceptHit); }
public bool CalculateDistance <T>(PointDistanceInput input, ref T collector) where T : struct, ICollector <DistanceHit> { return(CollisionWorld.CalculateDistance(input, ref collector)); }
public bool CalculateDistance(PointDistanceInput input, ref NativeList <DistanceHit> allHits) => QueryWrappers.CalculateDistance(ref this, input, ref allHits);
public static bool CalculateDistance <T>(ref T target, PointDistanceInput input) where T : struct, ICollidable { var collector = new AnyHitCollector <DistanceHit>(input.MaxDistance); return(target.CalculateDistance(input, ref collector)); }
public static unsafe bool PointCollider <T>(PointDistanceInput input, Collider *target, ref T collector) where T : struct, ICollector <DistanceHit> { if (!CollisionFilter.IsCollisionEnabled(input.Filter, target->Filter)) { return(false); } Result result; switch (target->Type) { case ColliderType.Sphere: var sphere = (SphereCollider *)target; result = PointPoint(sphere->Center, input.Position, sphere->Radius, sphere->Radius); break; case ColliderType.Capsule: var capsule = (CapsuleCollider *)target; result = CapsuleSphere(capsule->Vertex0, capsule->Vertex1, capsule->Radius, input.Position, 0.0f, MTransform.Identity); break; case ColliderType.Triangle: var triangle = (PolygonCollider *)target; result = TriangleSphere( triangle->Vertices[0], triangle->Vertices[1], triangle->Vertices[2], triangle->Planes[0].Normal, input.Position, 0.0f, MTransform.Identity); break; case ColliderType.Quad: var quad = (PolygonCollider *)target; result = QuadSphere( quad->Vertices[0], quad->Vertices[1], quad->Vertices[2], quad->Vertices[3], quad->Planes[0].Normal, input.Position, 0.0f, MTransform.Identity); break; case ColliderType.Convex: case ColliderType.Box: case ColliderType.Cylinder: ref ConvexHull hull = ref ((ConvexCollider *)target)->ConvexHull; result = ConvexConvex(hull.VerticesPtr, hull.NumVertices, hull.ConvexRadius, &input.Position, 1, 0.0f, MTransform.Identity); break; case ColliderType.Mesh: return(PointMesh(input, (MeshCollider *)target, ref collector)); case ColliderType.Compound: return(PointCompound(input, (CompoundCollider *)target, ref collector)); default: throw new NotImplementedException(); } if (result.Distance < collector.MaxFraction) { collector.AddHit(new DistanceHit { Fraction = result.Distance, SurfaceNormal = -result.NormalInA, Position = result.PositionOnAinA, ColliderKey = ColliderKey.Empty }); return(true); } return(false); }
public bool CalculateDistance(PointDistanceInput input) => QueryWrappers.CalculateDistance(ref this, input);
public static bool CalculateDistance <T>(ref T target, PointDistanceInput input, ref NativeList <DistanceHit> allHits) where T : struct, ICollidable { var collector = new AllHitsCollector <DistanceHit>(input.MaxDistance, ref allHits); return(target.CalculateDistance(input, ref collector)); }
public bool CalculateDistance(PointDistanceInput input, out DistanceHit closestHit) => QueryWrappers.CalculateDistance(ref this, input, out closestHit);
public bool CalculateDistance <T>(PointDistanceInput input, ref T collector) where T : struct, ICollector <DistanceHit> { return(Collider != null && Collider->CalculateDistance(input, ref collector)); }
public bool CalculateDistance <T>(PointDistanceInput input, ref T collector) where T : struct, ICollector <DistanceHit> { return(Broadphase.CalculateDistance(input, m_Bodies, ref collector)); }
public bool CalculateDistance <T>(PointDistanceInput input, ref T collector) where T : struct, ICollector <DistanceHit> { return(Collider.IsCreated && Collider.Value.CalculateDistance(input, ref collector)); }