// raycast caring about both where and what was hit
private bool Raycast(float3 fromPosition, float3 toPosition, ref Unity.Physics.RaycastHit hit, ref Entity e)
{
BuildPhysicsWorld buildPhysicsWorld = World.DefaultGameObjectInjectionWorld.GetExistingSystem <Unity.Physics.Systems.BuildPhysicsWorld>(); //Get the build physics world
CollisionWorld collisionWorld = buildPhysicsWorld.PhysicsWorld.CollisionWorld; //get the collision world
RaycastInput raycastInput = new RaycastInput {
Start = fromPosition,
End = toPosition,
Filter = new CollisionFilter {
BelongsTo = ~0u, // belongs to all layers
CollidesWith = ~0u, // collides with all layers
GroupIndex = 0, // a new group
}
};
if (collisionWorld.CastRay(raycastInput, out hit)) // use the collision world to cast a ray
// hit something
{
e = buildPhysicsWorld.PhysicsWorld.Bodies[hit.RigidBodyIndex].Entity;
return(true);
}
else
{
return(false);
}
}
public void Execute(int index)
{
var hit = new RaycastHit();
m_world.CastRay(m_inputs[index], out hit);
m_results[index] = hit;
}
public unsafe void Execute(int index)
{
RaycastHit hit;
world.CastRay(inputs[index], out hit);
results[index] = hit;
}
protected override void OnUpdate()
{
Entities.ForEach((ref PhysicsControllerStruct player, ref Translation trans) =>
{
//Ground check
float3 pos = trans.Value;
float3 target = pos;
target.y -= 1.15f;
RaycastInput rInput = new RaycastInput()
{
Start = pos,
End = target,
Filter = new CollisionFilter()
{
BelongsTo = 1,
CollidesWith = 2,
GroupIndex = 1
}
};
BuildPhysicsWorld physWorld = World.Active.GetExistingSystem <BuildPhysicsWorld>();
CollisionWorld collisionWorld = physWorld.PhysicsWorld.CollisionWorld;
//Ground check raycast
player.isGrounded = collisionWorld.CastRay(rInput, out RaycastHit hit);
//Rigidbody hit
player.rbIndex = hit.RigidBodyIndex;
});
}
public void Execute()
{
var mousePickCollector = new MousePickCollector(1.0f, CollisionWorld.Bodies, NumDynamicBodies);
mousePickCollector.IgnoreTriggers = IgnoreTriggers;
CollisionWorld.CastRay(RayInput, ref mousePickCollector);
if (mousePickCollector.MaxFraction < 1.0f)
{
float fraction = mousePickCollector.Hit.Fraction;
RigidBody hitBody = CollisionWorld.Bodies[mousePickCollector.Hit.RigidBodyIndex];
MTransform bodyFromWorld = Inverse(new MTransform(hitBody.WorldFromBody));
float3 pointOnBody = Mul(bodyFromWorld, mousePickCollector.Hit.Position);
SpringData[0] = new SpringData
{
Entity = hitBody.Entity,
Dragging = 1,
PointOnBody = pointOnBody,
MouseDepth = Near + math.dot(math.normalize(RayInput.End - RayInput.Start), Forward) * fraction * k_MaxDistance,
};
}
else
{
SpringData[0] = new SpringData
{
Dragging = 0
};
}
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
var chunkTranslations = chunk.GetNativeArray(TranslationType);
var chunkRotations = chunk.GetNativeArray(RotationType);
var chunkObstacleDistanceSettings = chunk.GetNativeArray(ObstacleDistanceSettingComponentType);
var chunkObstacleDistances = chunk.GetNativeArray(ObstacleDistanceComponentType);
for (var i = 0; i < chunk.Count; ++i)
{
var translation = chunkTranslations[i].Value;
var rotation = chunkRotations[i].Value;
var setting = chunkObstacleDistanceSettings[i];
ref var od = ref chunkObstacleDistances.AsWritableRef(i);
var ray = new RaycastInput {
Start = translation,
End = translation + math.mul(rotation, new float3(0, 0, 10000)),
Filter = setting.Filter,
};
bool hitted = MCollisionWorld.CastRay(ray, out var hit);
float distance = float.MaxValue;
if (hitted)
{
var diff = hit.Position - translation;
distance = math.length(diff);
}
od.Distance = distance;
}
private Entity Raycast(float3 fromPosition, float3 toPosition)
{
BuildPhysicsWorld buildPhysicsWorld = World.DefaultGameObjectInjectionWorld.GetExistingSystem <BuildPhysicsWorld>();
CollisionWorld collisionWorld = buildPhysicsWorld.PhysicsWorld.CollisionWorld;
RaycastInput raycastInput = new RaycastInput {
Start = fromPosition,
End = toPosition,
Filter = new CollisionFilter {
BelongsTo = ~0u,
CollidesWith = ~0u,
GroupIndex = 0,
}
};
Unity.Physics.RaycastHit raycastHit = new Unity.Physics.RaycastHit();
if (collisionWorld.CastRay(raycastInput, out raycastHit))
{
// Hit
Entity hitEntity = buildPhysicsWorld.PhysicsWorld.Bodies[raycastHit.RigidBodyIndex].Entity;
return(hitEntity);
}
else
{
return(Entity.Null);
}
}
public void Execute(ref Translation translation, ref LocalToWorld c2)
{
// Check the collisionworld for a hit
var hit = CollisionWorld.CastRay(new RaycastInput
{
Start = translation.Value, End = translation.Value + maths.down * 10, Filter = CollisionFilter.Default
},
out var rayHit);
if (!hit)
{
return;
}
// Early return if the index is invalid
if (rayHit.RigidBodyIndex <= 0)
{
return;
}
var hitentity = CollisionWorld.Bodies[rayHit.RigidBodyIndex].Entity;
var hitbody = CollisionWorld.Bodies[rayHit.RigidBodyIndex]; //RigidBody?
var instigator = Entity.Null;
Debug.Log(hitentity);
}
protected override void OnUpdate()
{
CollisionWorld collisionWorld = _buildPhysicsWorld.PhysicsWorld.CollisionWorld;
Entities.WithReadOnly(collisionWorld).ForEach((ref RayCasterPoint rayCaster, in LocalToWorld l2w, in Rotation rot) =>
{
var rayInput = new RaycastInput
{
Start = l2w.Position,
End = l2w.Position - rayCaster.castLength * l2w.Up,
Filter = new CollisionFilter()
{
BelongsTo = ~0u,
CollidesWith = ~0u,
GroupIndex = 0
}
};
Debug.DrawLine(l2w.Position, l2w.Position - rayCaster.castLength * l2w.Up);
rayCaster.hasHit = collisionWorld.CastRay(rayInput, out var hit);
if (rayCaster.hasHit)
{
rayCaster.stablePosition = hit.Position + hit.SurfaceNormal * 0.2f;
rayCaster.stableUpsideVector = hit.SurfaceNormal;
Debug.DrawLine(hit.Position, hit.Position + hit.SurfaceNormal * 0.2f, Color.red);
}
}).ScheduleParallel();
private bool Raycast(float3 from, float3 to, out float3 point, out Entity entity)
{
BuildPhysicsWorld physicsWorld = World.GetOrCreateSystem <BuildPhysicsWorld>();
CollisionWorld collisionWorld = physicsWorld.PhysicsWorld.CollisionWorld;
RaycastInput raycastInput = new RaycastInput
{
Start = from,
End = to,
Filter = new CollisionFilter
{
BelongsTo = ~0u,
CollidesWith = ~0u,
GroupIndex = 0
}
};
var hit = new Unity.Physics.RaycastHit();
if (collisionWorld.CastRay(raycastInput, out hit))
{
point = hit.Position;
entity = hit.Entity;
return(true);
}
point = hit.Position;
entity = hit.Entity;
return(false);
}
public Entity Raycast(float3 startPos, float3 endPos)
{
//首先获取物理世界
BuildPhysicsWorld physicsWorld = World.DefaultGameObjectInjectionWorld.GetExistingSystem <BuildPhysicsWorld>();
//然后获取碰撞世界
CollisionWorld collisionWorld = physicsWorld.PhysicsWorld.CollisionWorld;
RaycastInput raycastInput = new RaycastInput()
{
Start = startPos,
End = endPos,
//声明碰撞过滤器，用来过滤某些层级下的物体是否进行射线检测
Filter = CollisionFilter.Default,
//Filter = new CollisionFilter()
//{
// BelongsTo = ~0u,
// CollidesWith = ~0u,
// GroupIndex = 0,
//}
};
//发射射线去检测Entity实体
if (collisionWorld.CastRay(raycastInput, out raycastHit))
{
isGo = true;
//拿到我们射线击中的entity
Entity entity = physicsWorld.PhysicsWorld.Bodies[raycastHit.RigidBodyIndex].Entity;
return(entity);
}
else
{
Debug.Log("Notthing Found");
return(Entity.Null);
}
}
public void Execute()
{
var collector = new IgnoreTransparentClosestHitCollector(World);
World.CastRay(RaycastInput, ref collector);
Hit[0] = collector.ClosestHit;
}
protected override void OnUpdate()
{
CollisionWorld collisionWorld = m_BuildPhysicsWorld.PhysicsWorld.CollisionWorld;
EntityCommandBuffer commandBuffer = m_EntityCommandBufferSystem.CreateCommandBuffer();
Dependency = JobHandle.CombineDependencies(Dependency, m_EndFramePhysicsSystem.FinalJobHandle);
Entities
.WithName("RaycastWithCustomCollector")
.WithBurst()
.ForEach((Entity entity, ref Translation position, ref Rotation rotation, ref VisualizedRaycast visualizedRaycast) =>
{
var raycastLength = visualizedRaycast.RayLength;
// Perform the Raycast
var raycastInput = new RaycastInput
{
Start = position.Value,
End = position.Value + (math.forward(rotation.Value) * visualizedRaycast.RayLength),
Filter = CollisionFilter.Default
};
var collector = new IgnoreTransparentClosestHitCollector(collisionWorld);
collisionWorld.CastRay(raycastInput, ref collector);
var hit = collector.ClosestHit;
var hitDistance = raycastLength * hit.Fraction;
// position the entities and scale based on the ray length and hit distance
// visualization elements are scaled along the z-axis aka math.forward
var newFullRayPosition = new float3(0, 0, raycastLength * 0.5f);
var newFullRayScale = new float3(1f, 1f, raycastLength);
var newHitPosition = new float3(0, 0, hitDistance);
var newHitRayPosition = new float3(0, 0, hitDistance * 0.5f);
var newHitRayScale = new float3(1f, 1f, raycastLength * hit.Fraction);
commandBuffer.SetComponent(visualizedRaycast.HitPositionEntity, new Translation {
Value = newHitPosition
});
commandBuffer.SetComponent(visualizedRaycast.HitRayEntity, new Translation {
Value = newHitRayPosition
});
commandBuffer.SetComponent(visualizedRaycast.HitRayEntity, new NonUniformScale {
Value = newHitRayScale
});
commandBuffer.SetComponent(visualizedRaycast.FullRayEntity, new Translation {
Value = newFullRayPosition
});
commandBuffer.SetComponent(visualizedRaycast.FullRayEntity, new NonUniformScale {
Value = newFullRayScale
});
}).Schedule();
m_EntityCommandBufferSystem.AddJobHandleForProducer(Dependency);
}
public static bool CastRay(float3 start, float3 end, out Unity.Physics.RaycastHit result, CollisionWorld world, CollisionFilter filter)
{
var input = new RaycastInput
{
Start = start,
End = end,
Filter = filter,
};
return(world.CastRay(input, out result));
}
public void Execute()
{
var mousePickCollector = new MousePickCollector(1.0f, CollisionWorld.Bodies, CollisionWorld.NumDynamicBodies);
mousePickCollector.IgnoreTriggers = IgnoreTriggers;
mousePickCollector.IgnoreStatic = IgnoreStatic;
if (CollisionWorld.CastRay(RayInput, ref mousePickCollector))
{
RaycastHitRef.Value = mousePickCollector.Hit;
}
}
public void Execute(ArchetypeChunk batchInChunk, int batchIndex)
{
var boidChunk = batchInChunk.GetNativeArray(boidTypeHandle);
var translationsChunk = batchInChunk.GetNativeArray(translationTypeHandle);
var ltwChunk = batchInChunk.GetNativeArray(ltwTypeHandle);
var obstacleAvoidanceChunk = batchInChunk.GetNativeArray(obstacleAvoidanceTypeHandle);
var rotationChunk = batchInChunk.GetNativeArray(rotationTypeHandle);
for (int i = 0; i < batchInChunk.Count; i++)
{
float3 force = Vector3.zero;
Translation p = translationsChunk[i];
ObstacleAvoidance oa = obstacleAvoidanceChunk[i];
LocalToWorld ltw = ltwChunk[i];
Boid b = boidChunk[i];
Rotation r = rotationChunk[i];
oa.normal = Vector3.zero;
oa.point = Vector3.zero;
float3 forward = math.mul(r.Value, Vector3.forward);
forward = math.normalize(forward);
var input = new RaycastInput()
{
Start = p.Value,
End = p.Value + (forward * oa.forwardFeelerDepth),
//Filter = CollisionFilter.Default
Filter = new CollisionFilter {
BelongsTo = ~0u,
CollidesWith = ~0u,
GroupIndex = 0
}
};
oa.start = input.Start;
oa.end = input.End;
Unity.Physics.RaycastHit hit;
if (collisionWorld.CastRay(input, out hit))
{
Debug.Log("Collides");
float dist = math.distance(hit.Position, p.Value);
force += hit.SurfaceNormal * (oa.forwardFeelerDepth / dist);
oa.normal = hit.SurfaceNormal;
oa.point = hit.Position;
}
oa.force = force;
obstacleAvoidanceChunk[i] = oa;
}
}
public static bool CastRayFromMouse(float3 cameraPos, float3 mouseWorldPos, float distance, out Unity.Physics.RaycastHit closestHit, CollisionFilter collisionFilter, CollisionWorld collisionWorld)
{
float3 origin = cameraPos;
float3 direction = math.normalize(mouseWorldPos - origin);
RaycastInput rayInput = new RaycastInput()
{
Start = origin,
End = origin + (direction * distance),
Filter = collisionFilter
};
return(collisionWorld.CastRay(rayInput, out closestHit));
}
private bool Raycast(float3 rayFrom, float3 rayTo, out RaycastHit raycastHit)
{
var input = new RaycastInput()
{
Start = rayFrom,
End = rayTo,
Filter = new CollisionFilter
{
BelongsTo = (uint)CollisionLayers.Selection,
CollidesWith = (uint)(CollisionLayers.Ground | CollisionLayers.Units)
}
};
return(_collisionWorld.CastRay(input, out raycastHit));
}
public void Execute()
{
float fraction = 1.0f;
RigidBody?hitBody = null;
if (CollisionWorld.CastRay(RayInput, out RaycastHit hit))
{
if (hit.RigidBodyIndex < NumStaticBodies)
{
hitBody = CollisionWorld.Bodies[hit.RigidBodyIndex];
//Debug.Log(hitBody);
//commandBuffer.AddComponent(hitBody.Value.Entity, new Selected());
selected[0] = hitBody.Value.Entity;
}
}
}
/// <summary>
/// BuildPhysicsWorld physicsWorldSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem<BuildPhysicsWorld>();
/// CollisionWorld collisionWorld = physicsWorldSystem.PhysicsWorld.CollisionWorld;
/// </summary>
/// <param name="RayFrom"></param>
/// <param name="RayTo"></param>
/// <param name="collidesWithMask"></param>
/// <param name="belongsToMask"></param>
/// <param name="physicsWorld"></param>
/// <returns></returns>
public static bool Raycast(float3 RayFrom, float3 RayTo, uint collidesWithMask, uint belongsToMask, PhysicsWorld physicsWorld)
{
CollisionWorld collisionWorld = physicsWorld.CollisionWorld;
RaycastInput input = new RaycastInput()
{
Filter = new CollisionFilter()
{
CollidesWith = collidesWithMask,
BelongsTo = belongsToMask,
GroupIndex = 0
},
Start = RayFrom,
End = RayTo
};
return(collisionWorld.CastRay(input));
}
/// <summary>
/// Performs a raycast along the specified ray and returns all resulting <see cref="RaycastHit"/>s.<para/>
/// The caller must dispose of the returned list.
/// </summary>
/// <param name="collisionWorld"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="ignore">Will ignore this entity if it was hit. Useful to prevent returning hits from the caster.</param>
/// <param name="filter"></param>
/// <returns></returns>
public unsafe static NativeList <RaycastHit> RaycastAll(float3 from, float3 to, ref CollisionWorld collisionWorld, Entity ignore, CollisionFilter?filter = null, Allocator allocator = Allocator.TempJob)
{
RaycastInput input = new RaycastInput()
{
Start = from,
End = to,
Filter = (filter.HasValue ? filter.Value : PhysicsCollisionFilters.AllWithAll)
};
NativeList <RaycastHit> allHits = new NativeList <RaycastHit>(allocator);
if (collisionWorld.CastRay(input, ref allHits))
{
TrimByEntity(ref allHits, ignore);
}
return(allHits);
}
public void OnMouseLeftButton(InputAction.CallbackContext context)
{
BuildPhysicsWorld stepWorld = World.GetOrCreateSystem <BuildPhysicsWorld>();
CollisionWorld collisionWorld = stepWorld.PhysicsWorld.CollisionWorld;
Ray ray = Camera.main.ScreenPointToRay(mousePosition);
RaycastInput raycastInput = new RaycastInput
{
Start = ray.origin,
End = ray.origin + ray.direction * 1000f,
Filter = CollisionFilter.Default,
};
RaycastHit closestHit = new RaycastHit();
if (collisionWorld.CastRay(raycastInput, out closestHit))
{
Bang(closestHit.Position);
}
}
private bool Visible
(
ref CollisionWorld world,
float3 position,
float3 detectedPos,
ref FieldOfView setting)
{
var input = new RaycastInput
{
Start = position,
End = detectedPos,
Filter = new CollisionFilter
{
BelongsTo = setting.SelfTag.Value, CollidesWith = setting.TargetTag.Value
}
};
return(world.CastRay(input, out var hit));
}
public void Execute()
{
float fraction = 1.0f;
RigidBody?hitBody = null;
var rayCastInput = new RaycastInput {
Ray = Ray, Filter = CollisionFilter.Default
};
if (CollisionWorld.CastRay(rayCastInput, out RaycastHit hit))
{
if (hit.RigidBodyIndex < NumDynamicBodies)
{
hitBody = CollisionWorld.Bodies[hit.RigidBodyIndex];
fraction = hit.Fraction;
}
}
// If there was a hit, set up the spring
if (hitBody != null)
{
float3 pointInWorld = (Ray.Origin + Ray.Direction * fraction);
MTransform bodyFromWorld = Inverse(new MTransform(hitBody.Value.WorldFromBody));
float3 pointOnBody = Mul(bodyFromWorld, pointInWorld);
SpringData[0] = new SpringData
{
Entity = hitBody.Value.Entity,
Dragging = 1,
PointOnBody = pointOnBody,
MouseDepth = Near + math.dot(math.normalize(Ray.Direction), Forward) * fraction * k_MaxDistance
};
}
else
{
SpringData[0] = new SpringData
{
Dragging = 0
};
}
}
protected override void OnUpdate()
{
BuildPhysicsWorld buildPhysicsWorld = World.DefaultGameObjectInjectionWorld.GetExistingSystem <BuildPhysicsWorld>();
CollisionWorld collisionWorld = buildPhysicsWorld.PhysicsWorld.CollisionWorld;
var player = GetSingletonEntity <Player>();
// Get player translation component
ComponentDataFromEntity <Translation> translations = GetComponentDataFromEntity <Translation>(true);
Translation playerTranslate = translations[player];
float3 start = new float3 {
x = playerTranslate.Value.x, y = playerTranslate.Value.y, z = playerTranslate.Value.z
};
ComponentDataFromEntity <Player> playerEntities = GetComponentDataFromEntity <Player>(false);
RaycastInput input = new RaycastInput
{
Start = start,
End = Vector3.down,
Filter = CollisionFilter.Default
};
Player playerInfo = playerEntities[player]; // Getting the player info
bool grounded = false;
NativeList <Unity.Physics.RaycastHit> allHits = new NativeList <Unity.Physics.RaycastHit>(Allocator.Temp);
if (collisionWorld.CastRay(input, ref allHits)) // If something is right beneath the player - the player shall be grounded
{
foreach (var rayHit in allHits)
{
Entity hitEntity = buildPhysicsWorld.PhysicsWorld.Bodies[rayHit.RigidBodyIndex].Entity;
if (hitEntity != player)
{
if (Vector3.Distance(start, rayHit.Position) < 0.7)
{
grounded = true;
break;
}
}
}
}
playerInfo.isGrounded = grounded;
playerEntities[player] = playerInfo; // Reassigning the info to the array
}
public void Execute()
{
var raycastInput = new RaycastInput
{
Start = CameraLocation,
End = CameraDirection * 500 + CameraLocation,
Filter = new CollisionFilter
{
BelongsTo = 1u << 2,
CollidesWith = 1u << 1,
GroupIndex = 0
}
};
if (!CollisionWorld.CastRay(raycastInput, out var terrainHit))
{
return;
}
Endpoint[0] = terrainHit.Position;
}
private bool GetPointInWorldFromMousePosition(out float3 pointInWorld)
{
CollisionWorld collisionWorld = m_BuildPhysicsWorldSystem.PhysicsWorld.CollisionWorld;
// Create a new Ray from the camera screen
Vector2 mousePosition = Input.mousePosition;
UnityEngine.Ray unityRay = Camera.main.ScreenPointToRay(mousePosition);
var ray = new Ray(unityRay.origin, unityRay.direction * k_MaxDistance);
var fraction = 1.0f;
RigidBody?hitBody = null;
// Now cast the ray and see if the it hits any colliders.
var rayCastInput = new RaycastInput
{
Ray = ray, Filter = new CollisionFilter
{
CategoryBits = ~0u << 2, // Belongs to group Raycasts
MaskBits = ~0u << 2 // Only collides with Raycasts group
}
};
if (collisionWorld.CastRay(rayCastInput, out RaycastHit hit))
{
hitBody = collisionWorld.Bodies[hit.RigidBodyIndex];
fraction = hit.Fraction;
}
// If we have a hit, then we'll update the singleton data with
// the x and z values. (we're not doing anything with y at the moment)
if (hitBody != null)
{
pointInWorld = ray.Origin + ray.Direction * fraction;
return(true);
}
// default value
pointInWorld = float3.zero;
return(false);
}
private Entity EntityRaycast(float3 from, float3 to)
{
buildPhysicsWorld = World.DefaultGameObjectInjectionWorld.GetExistingSystem <BuildPhysicsWorld>();
collisionWorld = buildPhysicsWorld.PhysicsWorld.CollisionWorld;
RaycastInput raycastInput = new RaycastInput
{
Start = from,
End = to,
Filter = raycastFilter
};
Unity.Physics.RaycastHit raycastHit = new Unity.Physics.RaycastHit();
if (collisionWorld.CastRay(raycastInput, out raycastHit))
{
Entity hitEntity = buildPhysicsWorld.PhysicsWorld.Bodies[raycastHit.RigidBodyIndex].Entity;
return(hitEntity);
}
else
{
return(Entity.Null);
}
}
private Entity Raycast(float3 fromPosition, float3 toPosition)
{
// Get the CollisionWorld
BuildPhysicsWorld buildPhysicsWorld = World.DefaultGameObjectInjectionWorld.GetExistingSystem <BuildPhysicsWorld>();
CollisionWorld collisionWorld = buildPhysicsWorld.PhysicsWorld.CollisionWorld;
// Create Raycast Input, Filters are essentially layers from old raycast
// ~0u is a bit operation not, meaning we get all bits after 1 and includes all layers
// Group Index is used to filter for collisions by overriding the bitmask
RaycastInput raycastInput = new RaycastInput
{
Start = fromPosition,
End = toPosition,
Filter = new CollisionFilter
{
BelongsTo = ~0u,
CollidesWith = ~0u,
GroupIndex = 0
}
};
// Create a RaycastHit
Unity.Physics.RaycastHit raycastHit = new Unity.Physics.RaycastHit();
// Create Ray, returns a bool
if (collisionWorld.CastRay(raycastInput, out raycastHit)) // Can also use a NativeList of RaycastHits for all hits
{
// Hit Something
Entity hitEntity = buildPhysicsWorld.PhysicsWorld.Bodies[raycastHit.RigidBodyIndex].Entity;
return(hitEntity);
}
else
{
return(Entity.Null);
}
}
public void Execute(int index)
{
Unity.Physics.RaycastHit hit;
world.CastRay(inputs[index], out hit);
results[index] = hit;
}
