Raycasting with Entities

2024-09-06 00:47 UTC gpt-4o Open in ChatGPT ↗

I have this Entities setup. I now want to perform raycasts through the created entities:

using Unity.Burst; using Unity.Collections; using Unity.Entities; using Unity.Entities.Graphics; using Unity.Jobs; using Unity.Mathematics; using Unity.Rendering; using Unity.Scenes; using Unity.Transforms; using UnityEngine; using UnityEngine.Rendering;

public class PointCacheToGameObjects : MonoBehaviour { public SubScene sub;

private World world;
private EntityManager entityManager;
private RenderMeshArray rma;
private RenderMeshDescription rmd;
private Entity prototype;
private EntityQuery oldEntitiesQuery;
[Header("Refs")]
public Material mat;
public Mesh mesh;

void Start()
{
    world = World.DefaultGameObjectInjectionWorld;
    entityManager = world.EntityManager;

    // Create a RenderMeshDescription using the convenience constructor
    // with named parameters.
    rmd = new RenderMeshDescription(
        shadowCastingMode: ShadowCastingMode.Off,
        receiveShadows: false);

    // Create an array of mesh and material required for runtime rendering.
     rma = new RenderMeshArray(new Material[] { mat }, new Mesh[] { mesh });


}

// Update is called once per frame
void Update()
{

}

private void CreateSpheresFromTexture(PointCache pc)
{
    oldEntitiesQuery = entityManager.CreateEntityQuery(typeof(SphereColliderData), typeof(SelectableTag));

    if (oldEntitiesQuery.CalculateEntityCount() > 0)
    {
        entityManager.DestroyEntity(oldEntitiesQuery);
    }

    // Create empty base entity
    prototype = entityManager.CreateEntity();

    RenderMeshUtility.AddComponents(
        prototype,
        entityManager,
        rmd,
        rma,
        MaterialMeshInfo.FromRenderMeshArrayIndices(0, 0));

    entityManager.AddComponentData(prototype, new LocalToWorld());
    entityManager.AddComponent<SphereColliderData>(prototype);
    entityManager.AddComponent<SelectableTag>(prototype);

    // Create a command buffer for job execution
    var ecb = new EntityCommandBuffer(Allocator.TempJob);

    // Create the spawn job to instantiate entities in parallel
    var spawnJob = new SpawnJob
    {
        Prototype = prototype,
        Ecb = ecb.AsParallelWriter(),
        EntityCount = pc.PointCount,
        Positions = pc.surfaces[0].GetRawTextureData<half4>() // Get texture data (positions)
    };

    // Schedule the job to run across multiple cores
    var spawnHandle = spawnJob.Schedule(pc.PointCount, 128);
    spawnHandle.Complete();

    // Apply the entity creation commands
    ecb.Playback(entityManager);
    ecb.Dispose();

    // Clean up the prototype entity
    entityManager.DestroyEntity(prototype);
}

public void ReceivePointCache(PointCache pc)
{
    CreateSpheresFromTexture(pc);
}

}

public struct SphereColliderData : IComponentData { public float3 Position; public float Radius; }

public struct SelectableTag : IComponentData { }

[BurstCompile] public struct SpawnJob : IJobParallelFor { public Entity Prototype; public int EntityCount; public EntityCommandBuffer.ParallelWriter Ecb;

[ReadOnly] public NativeArray<half4> Positions; // Position data from texture

public void Execute(int index)
{
    // Instantiate the prototype entity
    var entity = Ecb.Instantiate(index, Prototype);

    // Get the position from texture data
    var p = Positions[index];
    var position = new float3(p.x, p.y, p.z);

    // Set the LocalToWorld component for entity transformation
    Ecb.SetComponent(index, entity, new LocalToWorld { Value = float4x4.Translate(position) });
    Ecb.SetComponent(index, entity, new SphereColliderData {Position = position, Radius = 1});

    // Optional: Add other components like color or custom logic here
    //Ecb.SetComponent(index, entity, new MaterialColor { Value = new float4(1, 1, 1, 1) });
}

}

To perform raycasts through the entities you’ve created in Unity using the Entities system (formerly known as DOTS), you’ll need to use Unity’s PhysicsWorld and BuildPhysicsWorld to handle the physics aspects of your entities. Here’s how you can extend your system to include raycasting through the entities:

1. Add Unity Physics Packages

Before you begin, ensure you have the required Unity Physics packages installed:

Unity Physics (for physics components).
Unity Entities (for working with ECS).

You can add these via the Unity Package Manager.

2. Modify your Entities to include Physics Components

Entities need physics components (such as PhysicsCollider) to interact with the physics system. Here’s how to add a PhysicsCollider component for your spheres.

Update the CreateSpheresFromTexture method to include the PhysicsCollider component:

private void CreateSpheresFromTexture(PointCache pc)
{
    oldEntitiesQuery = entityManager.CreateEntityQuery(typeof(SphereColliderData), typeof(SelectableTag));

    if (oldEntitiesQuery.CalculateEntityCount() > 0)
    {
        entityManager.DestroyEntity(oldEntitiesQuery);
    }

    // Create empty base entity
    prototype = entityManager.CreateEntity();

    RenderMeshUtility.AddComponents(
        prototype,
        entityManager,
        rmd,
        rma,
        MaterialMeshInfo.FromRenderMeshArrayIndices(0, 0));

    entityManager.AddComponentData(prototype, new LocalToWorld());
    entityManager.AddComponent<SphereColliderData>(prototype);
    entityManager.AddComponent<SelectableTag>(prototype);

    // Add a PhysicsCollider component for collision detection
    var sphereCollider = Unity.Physics.SphereCollider.Create(new SphereGeometry
    {
        Center = float3.zero,
        Radius = 1.0f // Adjust the radius as needed
    });

    entityManager.AddComponentData(prototype, new PhysicsCollider
    {
        Value = sphereCollider
    });

    // Create a command buffer for job execution
    var ecb = new EntityCommandBuffer(Allocator.TempJob);

    // Create the spawn job to instantiate entities in parallel
    var spawnJob = new SpawnJob
    {
        Prototype = prototype,
        Ecb = ecb.AsParallelWriter(),
        EntityCount = pc.PointCount,
        Positions = pc.surfaces[0].GetRawTextureData<half4>() // Get texture data (positions)
    };

    // Schedule the job to run across multiple cores
    var spawnHandle = spawnJob.Schedule(pc.PointCount, 128);
    spawnHandle.Complete();

    // Apply the entity creation commands
    ecb.Playback(entityManager);
    ecb.Dispose();

    // Clean up the prototype entity
    entityManager.DestroyEntity(prototype);
}

3. Raycasting with Unity Physics

Now that your entities have colliders, you can perform raycasting using the PhysicsWorld from Unity Physics.

To perform a raycast, you’ll need access to the BuildPhysicsWorld system, which creates the physics world from your entities, and then use CollisionWorld to perform the actual raycast.

Here’s how you can add raycasting logic:

Add BuildPhysicsWorld and CollisionWorld dependencies.
Define a method to perform the raycast and get hit information.

Add this method to your class:

void PerformRaycast(float3 rayOrigin, float3 rayDirection)
{
    var buildPhysicsWorldSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem<BuildPhysicsWorld>();
    var collisionWorld = buildPhysicsWorldSystem.PhysicsWorld.CollisionWorld;

    // Create a ray input
    var raycastInput = new RaycastInput
    {
        Start = rayOrigin,
        End = rayOrigin + rayDirection * 1000f, // Adjust the length of the ray as needed
        Filter = new CollisionFilter
        {
            BelongsTo = ~0u, // Ray can hit all layers
            CollidesWith = ~0u // Collide with all layers
        }
    };

    // Perform the raycast
    if (collisionWorld.CastRay(raycastInput, out RaycastHit hit))
    {
        // We hit something! Process the hit information
        Entity hitEntity = buildPhysicsWorldSystem.PhysicsWorld.Bodies[hit.RigidBodyIndex].Entity;

        // Retrieve data from the hit entity
        if (entityManager.HasComponent<SphereColliderData>(hitEntity))
        {
            SphereColliderData sphereData = entityManager.GetComponentData<SphereColliderData>(hitEntity);
            Debug.Log($"Hit entity with sphere at position: {sphereData.Position}, radius: {sphereData.Radius}");
        }
    }
    else
    {
        // No hit
        Debug.Log("Raycast did not hit anything.");
    }
}

4. Call Raycast Method in `Update`

Now, in the Update method, you can test raycasting by calling PerformRaycast with the desired ray origin and direction:

void Update()
{
    // Example ray from the camera position forward
    if (Input.GetMouseButtonDown(0))
    {
        var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        PerformRaycast(ray.origin, ray.direction);
    }
}

Key Components

PhysicsCollider: Used to add collision detection to entities.
BuildPhysicsWorld: A system responsible for constructing the physics world.
RaycastInput and RaycastHit: Structures used for defining ray inputs and receiving hit results.
collisionWorld.CastRay: Performs the raycast through the CollisionWorld.

This setup allows you to perform raycasts through entities with colliders and handle interactions like selecting or interacting with them based on the raycast hit.

If nothing is hit by your raycasts, there are several potential issues that could be causing the problem. Let’s walk through some steps to troubleshoot and improve the raycasting system.

1. Ensure the PhysicsWorld is Built Properly

The BuildPhysicsWorld system needs to run before the raycast. Ensure that the physics world is properly built and updated in your scene before performing raycasts.

Make sure that you’re accessing BuildPhysicsWorld and its PhysicsWorld correctly and that it’s being updated before you perform the raycast. You can use the Dependency attribute to ensure that the raycast happens after the physics world is built.

2. Check Entity Collider Setup

Ensure that your entities are properly set up with colliders and that the PhysicsCollider component is valid. For example, if the PhysicsCollider is not correctly assigned or its shape is incorrect, the raycast won’t detect collisions.

Verify that each entity has the PhysicsCollider component and that the colliders are assigned correctly.

3. Debug Ray Input

Make sure the ray’s origin, direction, and distance are correct. If the ray is not long enough or is pointed in the wrong direction, it won’t hit anything.

You can also visualize the ray in the Scene view using Debug.DrawRay to see if it’s actually intersecting with the entities.

4. Modify Raycast Filter

The CollisionFilter in your raycast might be too restrictive, which could prevent it from detecting hits. Ensure that the ray can collide with the appropriate layers.

5. Verify Entity Layers

Ensure that your entities are part of the physics world and can be detected by the raycast. If the entities are placed on different physics layers or are not properly included in the CollisionFilter, the ray might miss them.

Here’s an updated version of your raycasting logic, along with some debugging steps:

Updated `PerformRaycast` Method with Debugging

void PerformRaycast(float3 rayOrigin, float3 rayDirection)
{
    // Get the physics world and collision world
    var buildPhysicsWorldSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem<BuildPhysicsWorld>();
    var collisionWorld = buildPhysicsWorldSystem.PhysicsWorld.CollisionWorld;

    // Create a ray input with a reasonable length for the ray
    var raycastInput = new RaycastInput
    {
        Start = rayOrigin,
        End = rayOrigin + rayDirection * 1000f, // Ray length of 1000 units
        Filter = CollisionFilter.Default // Use default filter to hit all collidable objects
    };

    // Visualize the ray in the Scene view
    Debug.DrawRay(rayOrigin, rayDirection * 1000f, Color.red, 5f);

    // Perform the raycast and check for hits
    if (collisionWorld.CastRay(raycastInput, out RaycastHit hit))
    {
        // Get the entity hit by the ray
        Entity hitEntity = buildPhysicsWorldSystem.PhysicsWorld.Bodies[hit.RigidBodyIndex].Entity;

        // Debugging: print entity info
        Debug.Log($"Hit entity: {hitEntity}");

        // Retrieve the SphereColliderData component from the hit entity
        if (entityManager.HasComponent<SphereColliderData>(hitEntity))
        {
            SphereColliderData sphereData = entityManager.GetComponentData<SphereColliderData>(hitEntity);
            Debug.Log($"Hit entity with sphere at position: {sphereData.Position}, radius: {sphereData.Radius}");
        }
    }
    else
    {
        // No hit detected
        Debug.Log("Raycast did not hit any entity.");
    }
}

Debugging Steps:

Visualize the Raycast: Use Debug.DrawRay to visualize the ray in the Scene view to confirm that it’s pointing in the right direction and of sufficient length to hit entities.
```
Debug.DrawRay(rayOrigin, rayDirection * 1000f, Color.red, 5f);
```

Print Collider Information: If the raycast doesn’t hit anything, print the positions and radii of the spheres or collider information in your Update method to ensure they’re where you expect them to be.

foreach (var entity in oldEntitiesQuery.ToEntityArray(Allocator.TempJob))
{
    var collider = entityManager.GetComponentData<SphereColliderData>(entity);
    Debug.Log($"Entity position: {collider.Position}, radius: {collider.Radius}");
}

Verify Raycast Input: Double-check that the ray’s origin and direction are correct. If the camera’s ScreenPointToRay is being used, ensure that the ray is actually intersecting the entities. You can print out the origin and direction values:
```
Debug.Log($"Ray Origin: {rayOrigin}, Ray Direction: {rayDirection}");
```
Test CollisionFilter: Use a simple CollisionFilter.Default to make sure you’re not missing hits due to filtering:
```
Filter = CollisionFilter.Default // Allow collisions with all layers
```
Physics Debugging: Ensure the physics world is set up correctly and updated in the Update loop. Try calling buildPhysicsWorldSystem.Update(); in your Update method to ensure the physics world is current before you perform the raycast.

Example `Update` Method

void Update()
{
    // Update the physics world manually before raycasting
    var buildPhysicsWorldSystem = World.DefaultGameObjectInjectionWorld.GetExistingSystem<BuildPhysicsWorld>();
    buildPhysicsWorldSystem.Update();

    // Example ray from camera on mouse click
    if (Input.GetMouseButtonDown(0))
    {
        var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        PerformRaycast(ray.origin, ray.direction);
    }
}

By visualizing the ray and debugging your entities, you’ll be able to pinpoint why the raycast isn’t hitting the entities and adjust your logic accordingly.

To properly set up raycasting with Unity’s DOTS and Unity Physics, you need to ensure that the entire physics system is initialized and integrated with your entities. Let’s walk through a full, working setup that includes adding the necessary physics components, building the physics world, and performing raycasts.

Steps to Set Up Raycasting with Physics

Ensure Unity Physics and Entities Packages: Make sure you have the following Unity packages installed via the Package Manager:
- Unity Physics
- Unity Entities
Add Physics Components to Entities: For your entities to participate in physics simulation and raycasting, they need to have physics components like PhysicsCollider. We’ll set up sphere colliders for your entities.
Set Up the Physics World: Use BuildPhysicsWorld and StepPhysicsWorld systems to ensure the physics world is created and updated.
Perform Raycasting Using the Physics World: Implement raycasting using CollisionWorld to test for intersections with your entities.

Full Code Setup

Here’s a complete setup to integrate physics into your existing ECS system, including entity creation, adding colliders, and performing raycasts.

1. Entity Setup with Physics Components

In your PointCacheToGameObjects class, we need to update the entity creation process to include physics components such as PhysicsCollider.

using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Physics;
using Unity.Physics.Systems;
using Unity.Rendering;
using Unity.Transforms;
using UnityEngine;
using UnityEngine.Rendering;

public class PointCacheToGameObjects : MonoBehaviour
{
    public SubScene sub;

    private World world;
    private EntityManager entityManager;
    private RenderMeshArray rma;
    private RenderMeshDescription rmd;
    private Entity prototype;
    private EntityQuery oldEntitiesQuery;

    [Header("Refs")]
    public Material mat;
    public Mesh mesh;

    void Start()
    {
        world = World.DefaultGameObjectInjectionWorld;
        entityManager = world.EntityManager;

        rmd = new RenderMeshDescription(
            shadowCastingMode: ShadowCastingMode.Off,
            receiveShadows: false);

        rma = new RenderMeshArray(new Material[] { mat }, new Mesh[] { mesh });
    }

    void Update()
    {
        // Call raycasting test on mouse click
        if (Input.GetMouseButtonDown(0))
        {
            var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            PerformRaycast(ray.origin, ray.direction);
        }
    }

    private void CreateSpheresFromTexture(PointCache pc)
    {
        oldEntitiesQuery = entityManager.CreateEntityQuery(typeof(SphereColliderData), typeof(SelectableTag));

        if (oldEntitiesQuery.CalculateEntityCount() > 0)
        {
            entityManager.DestroyEntity(oldEntitiesQuery);
        }

        prototype = entityManager.CreateEntity();

        RenderMeshUtility.AddComponents(
            prototype,
            entityManager,
            rmd,
            rma,
            MaterialMeshInfo.FromRenderMeshArrayIndices(0, 0));

        entityManager.AddComponentData(prototype, new LocalToWorld());
        entityManager.AddComponent<SphereColliderData>(prototype);
        entityManager.AddComponent<SelectableTag>(prototype);

        // Add PhysicsCollider to the entity
        var sphereCollider = Unity.Physics.SphereCollider.Create(new SphereGeometry
        {
            Center = float3.zero,
            Radius = 1.0f // Adjust radius
        });

        entityManager.AddComponentData(prototype, new PhysicsCollider
        {
            Value = sphereCollider
        });

        var ecb = new EntityCommandBuffer(Allocator.TempJob);

        var spawnJob = new SpawnJob
        {
            Prototype = prototype,
            Ecb = ecb.AsParallelWriter(),
            EntityCount = pc.PointCount,
            Positions = pc.surfaces[0].GetRawTextureData<half4>()
        };

        var spawnHandle = spawnJob.Schedule(pc.PointCount, 128);
        spawnHandle.Complete();

        ecb.Playback(entityManager);
        ecb.Dispose();

        entityManager.DestroyEntity(prototype);
    }

    public void ReceivePointCache(PointCache pc)
    {
        CreateSpheresFromTexture(pc);
    }

    // Perform raycast in the physics world
    void PerformRaycast(float3 rayOrigin, float3 rayDirection)
    {
        var physicsWorldSystem = World.DefaultGameObjectInjectionWorld.GetExistingSystem<BuildPhysicsWorld>();
        var collisionWorld = physicsWorldSystem.PhysicsWorld.CollisionWorld;

        var raycastInput = new RaycastInput
        {
            Start = rayOrigin,
            End = rayOrigin + rayDirection * 1000f, // Long ray length
            Filter = CollisionFilter.Default
        };

        Debug.DrawRay(rayOrigin, rayDirection * 1000f, Color.red, 5f);

        if (collisionWorld.CastRay(raycastInput, out Unity.Physics.RaycastHit hit))
        {
            Entity hitEntity = physicsWorldSystem.PhysicsWorld.Bodies[hit.RigidBodyIndex].Entity;

            if (entityManager.HasComponent<SphereColliderData>(hitEntity))
            {
                SphereColliderData sphereData = entityManager.GetComponentData<SphereColliderData>(hitEntity);
                Debug.Log($"Hit entity at position: {sphereData.Position}, radius: {sphereData.Radius}");
            }
        }
        else
        {
            Debug.Log("Raycast did not hit any entity.");
        }
    }
}

public struct SphereColliderData : IComponentData
{
    public float3 Position;
    public float Radius;
}

public struct SelectableTag : IComponentData { }

[BurstCompile]
public struct SpawnJob : IJobParallelFor
{
    public Entity Prototype;
    public int EntityCount;
    public EntityCommandBuffer.ParallelWriter Ecb;

    [ReadOnly] public NativeArray<half4> Positions;

    public void Execute(int index)
    {
        var entity = Ecb.Instantiate(index, Prototype);
        var p = Positions[index];
        var position = new float3(p.x, p.y, p.z);

        Ecb.SetComponent(index, entity, new LocalToWorld { Value = float4x4.Translate(position) });
        Ecb.SetComponent(index, entity, new SphereColliderData { Position = position, Radius = 1 });
    }
}

Explanation

Entity Setup: The CreateSpheresFromTexture method sets up entities with RenderMesh, LocalToWorld, SphereColliderData, and PhysicsCollider. The PhysicsCollider is essential for enabling collisions and raycasting.
Raycasting: In the PerformRaycast method, we use the PhysicsWorld and CollisionWorld to cast a ray through the scene. If an entity is hit, the corresponding SphereColliderData is retrieved, and a message is logged.
Physics Systems: The BuildPhysicsWorld system is used to access the CollisionWorld, which allows us to perform raycasts. This system is automatically updated by Unity’s DOTS system.
Job-Based Entity Creation: The SpawnJob creates multiple entities in parallel using the EntityCommandBuffer.

2. Physics World Systems

You don’t need to explicitly manage the PhysicsWorld updates in your Update method. The BuildPhysicsWorld and StepPhysicsWorld systems automatically update each frame in Unity’s ECS architecture.

This setup should allow you to successfully raycast through your entities. The PhysicsCollider component is what enables your entities to participate in the physics simulation, and the raycasting will interact with these colliders. The Debug.DrawRay helps visualize the raycast in the Scene view, ensuring that the ray direction is correct.

Yes, you can create a filtering system for raycasting in Unity’s DOTS using the CollisionFilter struct from Unity Physics. The CollisionFilter allows you to define which layers or categories of objects the ray can interact with during a raycast. This is essential when you want to control what the ray should hit (e.g., only specific entities or certain groups).

Filtering Setup with `CollisionFilter`

The CollisionFilter struct is part of the Unity Physics system and provides a way to filter what a physics query (like a raycast) should interact with. Here’s how you can set up a filtering system.

Steps to Create a Filtering System

Understand CollisionFilter: The CollisionFilter contains three main properties:
- BelongsTo: Specifies which physics layers this entity belongs to.
- CollidesWith: Specifies which physics layers this entity can collide with.
- GroupIndex: Used for custom grouping rules (more advanced use case).
Assign Layers to Entities: You can assign specific layers to your entities by using a CollisionFilter when creating the PhysicsCollider component.
Apply Filtering in Raycasting: When performing a raycast, you can set up a CollisionFilter to ensure the ray only interacts with specific layers.

Full Example with Filtering System

Below is an example of how to create a filtering system using CollisionFilter for raycasting.

1. Define Custom Layers for Entities

You can assign custom physics layers to your entities when you create their PhysicsCollider. For example, you might want different layers for “Spheres” and “OtherObjects”.

Here is how you can modify your entity setup to include custom layers:

private void CreateSpheresFromTexture(PointCache pc)
{
    oldEntitiesQuery = entityManager.CreateEntityQuery(typeof(SphereColliderData), typeof(SelectableTag));

    if (oldEntitiesQuery.CalculateEntityCount() > 0)
    {
        entityManager.DestroyEntity(oldEntitiesQuery);
    }

    prototype = entityManager.CreateEntity();

    RenderMeshUtility.AddComponents(
        prototype,
        entityManager,
        rmd,
        rma,
        MaterialMeshInfo.FromRenderMeshArrayIndices(0, 0));

    entityManager.AddComponentData(prototype, new LocalToWorld());
    entityManager.AddComponent<SphereColliderData>(prototype);
    entityManager.AddComponent<SelectableTag>(prototype);

    // Define custom collision filter for the sphere
    CollisionFilter sphereFilter = new CollisionFilter
    {
        BelongsTo = 1u << 1, // Layer 1 for spheres
        CollidesWith = 1u << 2 // Collides with Layer 2 objects (adjust as needed)
    };

    // Add PhysicsCollider to the entity with the custom collision filter
    var sphereCollider = Unity.Physics.SphereCollider.Create(new SphereGeometry
    {
        Center = float3.zero,
        Radius = 1.0f // Adjust radius as needed
    }, sphereFilter);

    entityManager.AddComponentData(prototype, new PhysicsCollider
    {
        Value = sphereCollider
    });

    var ecb = new EntityCommandBuffer(Allocator.TempJob);

    var spawnJob = new SpawnJob
    {
        Prototype = prototype,
        Ecb = ecb.AsParallelWriter(),
        EntityCount = pc.PointCount,
        Positions = pc.surfaces[0].GetRawTextureData<half4>()
    };

    var spawnHandle = spawnJob.Schedule(pc.PointCount, 128);
    spawnHandle.Complete();

    ecb.Playback(entityManager);
    ecb.Dispose();

    entityManager.DestroyEntity(prototype);
}

In this example, we create a custom CollisionFilter for the spheres where:

BelongsTo = 1u << 1: Assigns the sphere to layer 1.
CollidesWith = 1u << 2: The sphere will only collide with objects that belong to layer 2.

2. Apply Filtering in Raycasting

When performing a raycast, you can specify what layers the ray should interact with by setting up the ray’s CollisionFilter:

void PerformRaycast(float3 rayOrigin, float3 rayDirection)
{
    var physicsWorldSystem = World.DefaultGameObjectInjectionWorld.GetExistingSystem<BuildPhysicsWorld>();
    var collisionWorld = physicsWorldSystem.PhysicsWorld.CollisionWorld;

    // Define a collision filter for the raycast
    CollisionFilter rayFilter = new CollisionFilter
    {
        BelongsTo = ~0u, // The ray belongs to all layers
        CollidesWith = 1u << 1 // The ray can only collide with Layer 1 (spheres)
    };

    // Create the raycast input with the collision filter
    var raycastInput = new RaycastInput
    {
        Start = rayOrigin,
        End = rayOrigin + rayDirection * 1000f, // Long ray length
        Filter = rayFilter // Apply custom collision filter
    };

    Debug.DrawRay(rayOrigin, rayDirection * 1000f, Color.red, 5f);

    if (collisionWorld.CastRay(raycastInput, out Unity.Physics.RaycastHit hit))
    {
        Entity hitEntity = physicsWorldSystem.PhysicsWorld.Bodies[hit.RigidBodyIndex].Entity;

        if (entityManager.HasComponent<SphereColliderData>(hitEntity))
        {
            SphereColliderData sphereData = entityManager.GetComponentData<SphereColliderData>(hitEntity);
            Debug.Log($"Hit sphere entity at position: {sphereData.Position}, radius: {sphereData.Radius}");
        }
    }
    else
    {
        Debug.Log("Raycast did not hit any entity.");
    }
}

Here’s how the ray’s filter works:

BelongsTo = ~0u: The ray “belongs to” all layers, meaning it can interact with any object.
CollidesWith = 1u << 1: The ray will only collide with objects that belong to layer 1 (spheres in this case).

3. Customizing Layers Further

You can define as many layers as you need. For example:

Layer 0: Default.
Layer 1: Spheres.
Layer 2: Obstacles.
Layer 3: Targets.

You can modify the BelongsTo and CollidesWith flags to customize which layers interact with each other.

4. Advanced Filtering with Group Index

For more advanced collision rules, you can use the GroupIndex field in CollisionFilter. This allows for custom grouping logic, but it’s typically used for more complex setups such as special collision rules (e.g., ignoring collisions between specific entities while allowing them to interact with others).

For most cases, BelongsTo and CollidesWith should suffice for defining which entities interact with each other.

Summary

With this setup, you can control which entities a raycast will hit by customizing the CollisionFilter in both the entities and the ray itself. The key is assigning different layers to your entities and configuring the CollisionFilter appropriately when you create the PhysicsCollider. The ray will only interact with entities that match the specified collision filter.

To ensure that colliders are properly registered with Unity’s DOTS physics system, you need to make sure the following components and systems are correctly implemented:

Add the PhysicsCollider Component: When creating entities, attach a PhysicsCollider component to the entities so they can interact with Unity Physics.
Ensure the BuildPhysicsWorld System is Running: The BuildPhysicsWorld system is responsible for registering all entities with PhysicsCollider components in the physics simulation.
Attach Physics-Related Systems: Ensure that the physics systems such as BuildPhysicsWorld, StepPhysicsWorld, and EndFramePhysicsSystem are running. These systems update the physics world, handle collision detection, and apply the results back to the entities.

Step-by-Step Process to Register Colliders with the Physics System

Add the PhysicsCollider Component: When you create entities, you need to assign a PhysicsCollider component. This component defines the shape and properties of the collider. The collider can be any type: a sphere, box, capsule, or custom mesh.

Here’s how you can add a sphere collider to an entity:
```
using Unity.Physics;
using Unity.Physics.Authoring;

// Create a PhysicsCollider component with a SphereGeometry shape
var sphereCollider = Unity.Physics.SphereCollider.Create(new SphereGeometry
{
    Center = float3.zero, // Collider center in local space
    Radius = 1.0f // Collider radius
});

// Add the PhysicsCollider to the entity
entityManager.AddComponentData(entity, new PhysicsCollider
{
    Value = sphereCollider
});
```
This registers the entity with a PhysicsCollider using a sphere shape. You can also use other geometries (box, capsule, etc.) by using their respective Create functions.
Ensure Physics Systems are Running: Unity Physics uses several built-in systems that handle physics world updates. These systems must be part of the World to properly register colliders:
- BuildPhysicsWorld: Builds the physics world from entities with PhysicsCollider components.
- StepPhysicsWorld: Advances the physics simulation each frame.
- EndFramePhysicsSystem: Applies the results of the physics simulation back to the entities.
These systems are added by default when you have the Unity Physics package installed.

In a typical Unity DOTS project, you don’t need to manually update these systems unless you’re doing advanced control over the update loop. Unity will automatically register the entities and update the physics world in each frame. However, if you need to manually control the updates, you can do so like this:
```
var physicsWorldSystem = World.DefaultGameObjectInjectionWorld.GetExistingSystem<BuildPhysicsWorld>();
var stepPhysicsWorldSystem = World.DefaultGameObjectInjectionWorld.GetExistingSystem<StepPhysicsWorld>();

// Manually update the systems if needed
physicsWorldSystem.Update();
stepPhysicsWorldSystem.Update();
```
These systems ensure that any entities with PhysicsCollider components are properly registered and managed in the physics simulation.
Attach Additional Physics Components (Optional): For more advanced physics behavior, you can attach other physics-related components to the entity. Here are some common components:
- PhysicsVelocity: Specifies the linear and angular velocity of an entity for movement within the physics world.
- PhysicsMass: Defines the mass and inertia tensor of an entity, which is required for dynamic rigid bodies.
- PhysicsDamping: Adds damping (friction or resistance) to an entity’s motion.
- PhysicsGravityFactor: Adjusts how much gravity affects the entity.
Example of adding PhysicsVelocity and PhysicsMass components:
```
// Add PhysicsVelocity for movement
entityManager.AddComponentData(entity, new PhysicsVelocity
{
    Linear = float3.zero,
    Angular = float3.zero
});

// Add PhysicsMass for dynamic rigid body behavior
entityManager.AddComponentData(entity, PhysicsMass.CreateDynamic(sphereCollider.Value.MassProperties, 1.0f)); // mass = 1.0f
```
Verify Physics System is Active: To ensure that the physics system is working, you can check in the Unity Editor by going to Window -> Analysis -> Entity Debugger. This shows all active systems, and you should see the BuildPhysicsWorld and StepPhysicsWorld systems running.
Check for Physics Debugging: To visualize the physics colliders in your scene (even when they are invisible), you can enable physics debugging by selecting Gizmos in the Scene view, or by using the Physics Debug Display tool from the Unity Physics package.

In the code, you can also check if entities with PhysicsCollider are correctly created:
```
var query = entityManager.CreateEntityQuery(typeof(PhysicsCollider));
Debug.Log($"Number of entities with PhysicsCollider: {query.CalculateEntityCount()}");
```

Example: Full Setup for Registering Colliders with Physics

Here’s a complete example where we create entities with sphere colliders, register them with the physics system, and ensure the physics world is running properly.

using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Physics;
using Unity.Physics.Authoring;
using Unity.Rendering;
using Unity.Transforms;
using UnityEngine;

public class PhysicsSetup : MonoBehaviour
{
    private EntityManager entityManager;
    private EntityArchetype entityArchetype;

    [Header("Refs")]
    public Mesh mesh;
    public Material material;

    void Start()
    {
        // Get the default World and EntityManager
        entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;

        // Define an entity archetype with required physics and rendering components
        entityArchetype = entityManager.CreateArchetype(
            typeof(LocalToWorld),
            typeof(RenderMesh),
            typeof(RenderBounds),
            typeof(Translation),
            typeof(PhysicsCollider), // Physics Collider
            typeof(PhysicsVelocity),  // Physics Velocity for movement
            typeof(PhysicsMass)       // Physics Mass for dynamic behavior
        );

        // Create entities
        CreatePhysicsEntity(new float3(0, 1, 0), 1.0f); // Sphere at position (0, 1, 0) with radius 1
    }

    void CreatePhysicsEntity(float3 position, float radius)
    {
        // Create an entity using the defined archetype
        var entity = entityManager.CreateEntity(entityArchetype);

        // Assign RenderMesh for visual representation
        entityManager.SetComponentData(entity, new RenderMesh
        {
            mesh = mesh,
            material = material
        });

        // Set the entity's position
        entityManager.SetComponentData(entity, new Translation { Value = position });

        // Create a sphere collider with the specified radius
        var sphereCollider = Unity.Physics.SphereCollider.Create(new SphereGeometry
        {
            Center = float3.zero,
            Radius = radius
        });

        // Assign the PhysicsCollider to the entity
        entityManager.SetComponentData(entity, new PhysicsCollider
        {
            Value = sphereCollider
        });

        // Assign PhysicsMass for dynamic behavior
        entityManager.SetComponentData(entity, PhysicsMass.CreateDynamic(sphereCollider.Value.MassProperties, 1.0f));
    }
}

Conclusion

In Unity’s DOTS-based physics system, registering colliders with the physics system is done by attaching PhysicsCollider components to entities. Ensure that the BuildPhysicsWorld system is running, and your entities will automatically be registered in the physics simulation. You can also extend the functionality by adding other physics components like PhysicsVelocity and PhysicsMass to control movement and behavior.

In Unity’s DOTS framework, creating a System to manage certain behaviors or logic related to your entities is optional but recommended depending on what you’re trying to achieve. It helps organize and automate updates to the entities in a scalable way.

Let me break down when you would need a System and when it’s optional.

When You Need a System

Automated and Efficient Updates: Systems in Unity DOTS provide a way to apply logic to your entities automatically during each update frame. They are especially useful when you need to run code every frame (or at specific intervals) on a large set of entities.

For example:
- Physics simulation: If you want to move or check entities based on their PhysicsVelocity, it’s best to do it within a System that updates every frame.
- Raycasting: If you want to perform raycasting periodically or based on user input, using a System ensures the raycasting logic is handled properly in the ECS update loop.
Separation of Concerns: Systems help separate different types of logic into distinct parts of your codebase. Instead of handling everything in a MonoBehaviour, which can get messy, Systems focus on specific tasks (e.g., handling movement, detecting collisions, applying physics forces).
Job Parallelization: Systems make it easier to take advantage of DOTS’ Job System and Burst Compiler. This allows you to schedule parallel jobs for performance-critical tasks such as mass entity updates, pathfinding, or physics interactions.
Entity Queries: If you want to operate on specific entities that match certain criteria (e.g., entities that have both a PhysicsCollider and SelectableTag), using an EntityQuery in a System allows you to easily filter and work on only the relevant entities.

When It’s Optional

Simple or One-Time Operations: If you are performing a single operation that doesn’t need to run every frame (like initializing entities, creating or destroying entities on user input), you can do this directly in a MonoBehaviour without needing a System.
Direct Input Handling: When you handle user input and need to manipulate a few entities based on that input (e.g., clicking to spawn or move entities), you can simply call ECS-related methods inside a MonoBehaviour without creating a dedicated System. However, for more complex input handling, a System could help manage it better.

Example: Physics and Raycasting in a System

Let’s say you want to create a System that performs raycasting every frame and checks for interactions with entities that have a PhysicsCollider. This is best handled inside a System rather than a MonoBehaviour because it’s something you’ll want to update regularly.

Here’s an example of how to create a simple RaycastSystem that handles the raycasting:

using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Physics;
using Unity.Physics.Systems;
using Unity.Transforms;
using UnityEngine;

[UpdateInGroup(typeof(SimulationSystemGroup))]
public partial class RaycastSystem : SystemBase
{
    private BuildPhysicsWorld buildPhysicsWorld;
    private EndFramePhysicsSystem endFramePhysicsSystem;

    protected override void OnCreate()
    {
        base.OnCreate();
        buildPhysicsWorld = World.GetOrCreateSystem<BuildPhysicsWorld>();
        endFramePhysicsSystem = World.GetOrCreateSystem<EndFramePhysicsSystem>();
    }

    protected override void OnUpdate()
    {
        // Handle raycasting on mouse click
        if (Input.GetMouseButtonDown(0))
        {
            var ray = Camera.main.ScreenPointToRay(Input.mousePosition);

            // Get ray origin and direction from Unity's ray
            float3 rayOrigin = ray.origin;
            float3 rayDirection = ray.direction;

            PerformRaycast(rayOrigin, rayDirection);
        }
    }

    private void PerformRaycast(float3 rayOrigin, float3 rayDirection)
    {
        var collisionWorld = buildPhysicsWorld.PhysicsWorld.CollisionWorld;

        // Raycast input
        var raycastInput = new RaycastInput
        {
            Start = rayOrigin,
            End = rayOrigin + rayDirection * 1000f,
            Filter = CollisionFilter.Default
        };

        // Perform the raycast
        if (collisionWorld.CastRay(raycastInput, out RaycastHit hit))
        {
            var hitEntity = buildPhysicsWorld.PhysicsWorld.Bodies[hit.RigidBodyIndex].Entity;

            // Perform actions based on the hit entity
            if (EntityManager.HasComponent<SelectableTag>(hitEntity))
            {
                Debug.Log("Raycast hit an entity with SelectableTag.");
            }
        }
        else
        {
            Debug.Log("Raycast did not hit any entity.");
        }
    }
}

Key Features of the System:

OnUpdate: This method is automatically called every frame. In this case, it checks if the mouse was clicked and then performs a raycast.
BuildPhysicsWorld: This system is required to query the CollisionWorld for raycasting.
Raycasting Logic: The raycast checks if the ray hits an entity, and if that entity has a specific tag (like SelectableTag), it performs an action.

When to Use a MonoBehaviour Without a System

If you have simple entity operations that don’t need to run every frame or on many entities, you can get away with using MonoBehaviour to directly interact with the ECS:

Entity Creation: You can create entities directly in MonoBehaviour without a System. For example, creating entities when the user presses a button is fine to do in MonoBehaviour.

void Update()
{
    if (Input.GetKeyDown(KeyCode.Space))
    {
        CreateEntity();
    }
}

private void CreateEntity()
{
    var entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
    var entity = entityManager.CreateEntity();
    entityManager.AddComponentData(entity, new Translation { Value = new float3(0, 0, 0) });
    entityManager.AddComponentData(entity, new Rotation { Value = quaternion.identity });
}

One-Time Initialization: Initialization tasks that only happen once at the start (e.g., creating entities at runtime or loading data) can also be handled directly in MonoBehaviour.
```
void Start()
{
    CreateEntity();
}
```

Summary: When to Use Systems vs. MonoBehaviour

Use a System:
- When you need to apply logic to entities every frame or at specific intervals.
- When you are dealing with many entities that need to be processed in parallel.
- When you need to take advantage of DOTS performance optimizations, like the Job System or Burst Compiler.
Use a MonoBehaviour:
- When you’re doing simple, one-time operations like creating entities based on user input.
- When you’re doing small-scale, isolated entity manipulations that don’t need to happen every frame.

Creating Systems is optional for basic tasks, but for scalability, performance, and clean separation of concerns, Systems are generally recommended for more complex logic or frequent updates.

No, you don’t need to explicitly “start” a system in Unity’s DOTS architecture. Unity automatically manages the lifecycle of systems. Once a system is created (either through your code or by default in the World), it will be updated in the proper order according to its update group.

How Systems are Managed in Unity DOTS

Systems Automatically Update: When you create a system, it automatically starts executing in its respective update group (e.g., SimulationSystemGroup, PresentationSystemGroup). Unity DOTS handles when each system runs based on the built-in update groups.
OnCreate and OnStartRunning: You can use the OnCreate method to set up any initialization logic when the system is first created. Similarly, OnStartRunning is called the first time the system starts updating.
OnUpdate: The system’s logic is typically defined inside the OnUpdate method, which runs once per frame (or based on specific conditions like input, physics updates, etc.).

Example Lifecycle of a System

Creation: When the game starts, Unity creates the system and calls its OnCreate method.
Start Running: When the system starts running (e.g., when the game is playing), Unity calls OnStartRunning (if you override it).
Update: The OnUpdate method is called every frame (or as appropriate for the system’s update group).
End: If the system is disabled or the game ends, Unity calls OnStopRunning and eventually OnDestroy to clean up the system.

Example of a Simple System

Here’s an example of a system that will automatically start and run when the game begins:

using Unity.Entities;
using UnityEngine;

[UpdateInGroup(typeof(SimulationSystemGroup))]
public partial class SimpleSystem : SystemBase
{
    // Called when the system is first created (initialization)
    protected override void OnCreate()
    {
        Debug.Log("System Created");
    }

    // Called when the system starts running (first frame or after being re-enabled)
    protected override void OnStartRunning()
    {
        Debug.Log("System Started Running");
    }

    // Called every frame while the system is running
    protected override void OnUpdate()
    {
        // Put your frame-by-frame logic here
        Debug.Log("System is updating.");
    }

    // Called when the system stops running (e.g., when the game is paused)
    protected override void OnStopRunning()
    {
        Debug.Log("System Stopped Running");
    }

    // Called when the system is destroyed (e.g., when the game ends or the system is removed)
    protected override void OnDestroy()
    {
        Debug.Log("System Destroyed");
    }
}

Key Points

No Explicit “Start” Needed: Once your system exists, Unity handles its execution. You do not need to call any “start” function manually.
OnUpdate Runs Automatically: The OnUpdate method runs every frame as long as the system is enabled and belongs to an active update group.
Update Groups: Systems run in their respective groups. For example, if you want your system to run as part of the simulation phase (after physics updates), you can ensure it’s in the SimulationSystemGroup with the [UpdateInGroup] attribute.

Managing When a System Runs

If you want finer control over when a system runs, you can do the following:

Disable a System: You can manually disable a system by calling Enabled = false;. This will prevent OnUpdate from being called.
```
this.Enabled = false; // Disable the system
this.Enabled = true;  // Re-enable the system
```
Update Order: You can define the update order by placing your system in specific groups like SimulationSystemGroup or PresentationSystemGroup, or by specifying explicit dependencies between systems using the [UpdateBefore] or [UpdateAfter] attributes.

Conditional Updates: You can use conditional checks inside OnUpdate to only run the system when needed, such as when a certain key is pressed or when specific entities are present.

protected override void OnUpdate()
{
    // Only update if a specific condition is met
    if (Input.GetKeyDown(KeyCode.Space))
    {
        Debug.Log("Space key pressed. System Update.");
    }
}

Example: System That Only Runs on Input

Here’s an example system that only performs its update logic when the player presses the space bar:

[UpdateInGroup(typeof(SimulationSystemGroup))]
public partial class InputControlledSystem : SystemBase
{
    protected override void OnUpdate()
    {
        // Check if the space key is pressed
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Debug.Log("Space key pressed, system running logic.");
            // Place your logic here that you want to execute when space is pressed
        }
    }
}

Summary

You do not need to explicitly start a system in Unity DOTS. Systems automatically run when they are created and will update each frame as part of their assigned update group.
OnUpdate is called each frame by default, but you can control when a system runs by enabling/disabling it or adding conditional logic inside OnUpdate.
Unity handles the lifecycle of systems, so you only need to worry about implementing your logic, and the system will start updating as long as it belongs to an active update group.

In most cases, as long as you add the system to a valid World, Unity will automatically “start” it during gameplay.

Spawning entities inside a SubScene in Unity’s DOTS (Data-Oriented Technology Stack) architecture involves a few steps. A SubScene is a way to group entities and other assets that can be loaded and unloaded at runtime. Entities in a SubScene are typically authored in the Unity Editor, but you can also dynamically spawn entities into a SubScene during runtime.

Here’s how you can achieve this:

Steps to Spawn Entities in a SubScene

Set Up the SubScene: Create and configure a SubScene in the Unity Editor.
Access the EntityManager for the SubScene: When the SubScene is loaded, its entities are managed by the same EntityManager as the main world. You can create and manage entities dynamically and associate them with the SubScene.
Ensure Proper SubScene Loading: Ensure the SubScene is loaded at runtime, either through Unity’s automatic loading mechanism or by explicitly loading it using the SceneSystem.
Spawn Entities Using EntityCommandBuffer or EntityManager: Use either the EntityCommandBuffer or EntityManager to spawn entities dynamically within the SubScene’s world.

Full Example to Spawn Entities in a SubScene

1. Set Up the SubScene in Unity Editor

In the Unity Editor, right-click in the Hierarchy window and select Create Empty.
Convert this GameObject into a SubScene by right-clicking on it and choosing Convert To SubScene.
You can put entities, GameObjects, and other components in the SubScene.
SubScenes are handled by the SceneSystem in DOTS.

2. Ensure the SubScene is Loaded

If the SubScene is set to load automatically, Unity will load it when the main scene is loaded. However, if you want to manually control when the SubScene loads, you can do so using the SceneSystem.

Here’s how you can load a SubScene manually:

using Unity.Entities;
using Unity.Scenes;
using UnityEngine;

public class LoadSubSceneExample : MonoBehaviour
{
    public SubScene subScene; // Reference to the SubScene

    private void Start()
    {
        // Ensure the SubScene is loaded
        var entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
        var sceneSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem<SceneSystem>();
        var sceneEntity = sceneSystem.LoadSceneAsync(subScene.SceneGUID);

        // Ensure the scene is fully loaded
        sceneSystem.RequestSceneLoaded(sceneEntity);
    }
}

3. Spawn Entities Inside the SubScene

You can spawn entities dynamically after the SubScene has been loaded. These entities will be part of the same world as the SubScene and will benefit from the performance optimizations of DOTS.

Here’s an example of spawning an entity inside the SubScene:

using Unity.Entities;
using Unity.Mathematics;
using Unity.Transforms;
using Unity.Rendering;
using UnityEngine;

public class EntitySpawnerInSubScene : MonoBehaviour
{
    public SubScene subScene; // Reference to the SubScene
    public Mesh entityMesh;
    public Material entityMaterial;

    private EntityManager entityManager;
    private EntityArchetype entityArchetype;

    void Start()
    {
        entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;

        // Ensure SubScene is loaded before spawning
        var sceneSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem<SceneSystem>();
        var sceneEntity = sceneSystem.LoadSceneAsync(subScene.SceneGUID);
        sceneSystem.RequestSceneLoaded(sceneEntity);

        // Define an entity archetype
        entityArchetype = entityManager.CreateArchetype(
            typeof(LocalToWorld),
            typeof(Translation),
            typeof(RenderMesh),
            typeof(RenderBounds)
        );

        // Spawn an entity after the SubScene is loaded
        SpawnEntity(new float3(0, 0, 0));
    }

    void SpawnEntity(float3 position)
    {
        // Create the entity
        Entity entity = entityManager.CreateEntity(entityArchetype);

        // Set position
        entityManager.SetComponentData(entity, new Translation { Value = position });

        // Set the render mesh (visual representation)
        entityManager.SetSharedComponentData(entity, new RenderMesh
        {
            mesh = entityMesh,
            material = entityMaterial
        });
    }
}

Key Points in the Example

SubScene Reference: We reference the SubScene in the EntitySpawnerInSubScene class by dragging and dropping it in the Unity Editor.
Entity Manager: We access the same EntityManager for the default World where the SubScene entities are loaded. This allows us to spawn new entities in the SubScene.
Entity Archetype: An entity archetype is defined to describe the components that each new entity will have, such as LocalToWorld, Translation, and RenderMesh for rendering purposes.
Spawning Entities: Entities are dynamically spawned inside the SubScene once it’s loaded. We can modify the position, mesh, and material of the entity dynamically.

4. Handling SubScene Lifecycle

If you want to dynamically load, unload, and spawn entities based on SubScene lifecycle, you can:

Unload a SubScene: Use the SceneSystem to unload a SubScene when it’s no longer needed.
```
sceneSystem.UnloadScene(sceneEntity);
```

Check if the SubScene is Loaded: Before spawning entities, you may want to ensure the SubScene is fully loaded.

var sceneSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem<SceneSystem>();
if (sceneSystem.IsSceneLoaded(sceneEntity))
{
    // SubScene is loaded, proceed with spawning
}

Conclusion

Spawning entities inside a SubScene follows the same principles as spawning them in the main scene, since SubScenes are part of the same World. The key differences are ensuring the SubScene is loaded and managing the lifecycle of the SubScene using the SceneSystem.

Here’s the main process:

Set up a SubScene in the Editor.
Ensure the SubScene is loaded using the SceneSystem.
Spawn entities dynamically using EntityManager or EntityCommandBuffer, which will work within the same world as the SubScene.

In regular C#, you can select GameObjects based on whether they are within the camera’s frustum using frustum culling. Unity provides tools for this, such as the GeometryUtility.TestPlanesAABB method, which allows you to determine if an object’s bounds intersect with the camera’s viewing frustum.

Steps to Select GameObjects Based on Frustum

Get the Camera’s Frustum Planes: Use the GeometryUtility.CalculateFrustumPlanes method to calculate the frustum planes of the camera.
Get the GameObject’s Bounds: For each GameObject, you need to get its Renderer.bounds, which represents the bounding box of the object in world space.
Check if GameObject is Inside the Frustum: Use GeometryUtility.TestPlanesAABB to test if the bounding box of the object intersects with the frustum planes.

Example Code

Here’s a full example that iterates through a list of GameObjects and checks if they are within the camera’s frustum:

using UnityEngine;

public class FrustumCullingExample : MonoBehaviour
{
    public Camera mainCamera; // Assign your camera here
    public GameObject[] gameObjectsToCheck; // List of GameObjects you want to check

    void Update()
    {
        // Get the frustum planes of the camera
        Plane[] frustumPlanes = GeometryUtility.CalculateFrustumPlanes(mainCamera);

        // Loop through all game objects and check if they are inside the frustum
        foreach (GameObject obj in gameObjectsToCheck)
        {
            Renderer renderer = obj.GetComponent<Renderer>();

            if (renderer != null)
            {
                // Get the bounding box of the GameObject (in world space)
                Bounds bounds = renderer.bounds;

                // Test if the bounds are within the camera's frustum
                if (GeometryUtility.TestPlanesAABB(frustumPlanes, bounds))
                {
                    Debug.Log(obj.name + " is inside the frustum.");
                    // Do something with the object (e.g., highlight it, enable it, etc.)
                }
                else
                {
                    Debug.Log(obj.name + " is outside the frustum.");
                    // Do something else (e.g., disable it)
                }
            }
        }
    }
}

Explanation:

GeometryUtility.CalculateFrustumPlanes: This method calculates the six planes (left, right, top, bottom, near, far) that define the viewing frustum of the camera.
```
Plane[] frustumPlanes = GeometryUtility.CalculateFrustumPlanes(mainCamera);
```
Renderer.bounds: Each GameObject with a Renderer component has a bounds property that represents an axis-aligned bounding box (AABB) that contains the object in world space.
```
Bounds bounds = renderer.bounds;
```
GeometryUtility.TestPlanesAABB: This method checks if the bounding box of an object (the AABB) is inside the camera’s frustum by testing against the six planes.
```
bool isInFrustum = GeometryUtility.TestPlanesAABB(frustumPlanes, bounds);
```

Optimization Tips

Use a Layer Mask: If you have many GameObjects and only some of them are relevant for culling, use a layer mask to limit which objects are checked.
```
int layerMask = LayerMask.GetMask("YourLayerName");
```

Check Objects Periodically: Frustum culling is a relatively cheap operation, but if you have many GameObjects, you may want to check them periodically rather than every frame (e.g., check every second).

private float checkInterval = 1.0f;
private float nextCheckTime = 0f;

void Update()
{
    if (Time.time >= nextCheckTime)
    {
        nextCheckTime = Time.time + checkInterval;
        // Perform frustum culling checks
    }
}

Cull Based on Distance: You can combine frustum culling with distance checks to further optimize the selection of objects. For example, skip frustum checks for objects that are too far from the camera.

float maxDistance = 100f;
foreach (GameObject obj in gameObjectsToCheck)
{
    if (Vector3.Distance(mainCamera.transform.position, obj.transform.position) < maxDistance)
    {
        // Perform frustum culling checks
    }
}

Summary

This approach uses Unity’s built-in frustum culling tools to efficiently determine which GameObjects are inside the camera’s view. You can use GeometryUtility.CalculateFrustumPlanes to get the camera’s frustum and GeometryUtility.TestPlanesAABB to check whether a GameObject’s bounding box is within the frustum.

To implement frustum culling in Unity using DOTS with a ParallelForJob or IJobParallelFor, you’ll need to move away from using typical GameObjects and instead operate on Entities with components. Unity’s DOTS jobs and ECS systems allow you to perform parallel operations on entities in a highly efficient manner, which can be applied to tasks such as frustum culling.

In DOTS, you’ll be working with entities, and to run the frustum culling in parallel, you’ll need to:

Use IJobParallelFor or IJobChunk for multithreading.
Implement frustum culling based on Bounds (or a similar component representing the object’s space).
Access the camera’s frustum planes in a thread-safe manner (pass them to the job).
Schedule the job to run on multiple entities in parallel.

Steps for Frustum Culling in a Parallel Job

Define Components for Position and Bounds: Each entity will need components for its position and bounds (similar to Renderer.bounds for GameObjects).
Get Camera Frustum Planes: Before running the job, you’ll calculate the camera’s frustum planes using GeometryUtility.CalculateFrustumPlanes.
Parallel Job for Frustum Culling: You’ll define a job that runs frustum culling logic in parallel for each entity.
Job Execution: Finally, you’ll schedule and run the job.

Full Example: Frustum Culling in a Parallel Job

1. Define Components for Frustum Culling

Define the components representing the position and bounds of entities.

using Unity.Entities;
using Unity.Mathematics;

public struct FrustumCullingComponent : IComponentData
{
    public float3 Position;
    public float3 BoundsSize;
}

This component represents an entity’s position and the size of its bounds.

2. Get the Camera Frustum Planes

In your SystemBase, calculate the camera’s frustum planes and pass them to the job.

using Unity.Entities;
using UnityEngine;

public class FrustumCullingSystem : SystemBase
{
    protected override void OnUpdate()
    {
        Camera mainCamera = Camera.main;
        if (mainCamera == null) return;

        // Get the camera's frustum planes
        Plane[] frustumPlanes = GeometryUtility.CalculateFrustumPlanes(mainCamera);

        // Convert Plane[] into a more job-friendly structure (you cannot pass Plane[] directly)
        NativeArray<Plane> frustumPlanesNative = new NativeArray<Plane>(frustumPlanes, Allocator.TempJob);

        // Schedule the frustum culling job
        var frustumCullingJob = new FrustumCullingJob
        {
            FrustumPlanes = frustumPlanesNative
        };

        // Schedule the job to run over all entities with the FrustumCullingComponent in parallel
        JobHandle jobHandle = frustumCullingJob.ScheduleParallel(Dependency);
        jobHandle.Complete();

        // Dispose of the frustum planes after the job is done
        frustumPlanesNative.Dispose();
    }
}

3. Create the Parallel Job for Frustum Culling

Define the job that will run in parallel, checking if each entity is inside the camera’s frustum:

using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;

[BurstCompile]
public struct FrustumCullingJob : IJobEntityBatch
{
    [ReadOnly] public NativeArray<Plane> FrustumPlanes;

    public void Execute(ArchetypeChunk batchInChunk, int batchIndex)
    {
        var chunkPositions = batchInChunk.GetNativeArray(ChunkComponentTypeHandle<FrustumCullingComponent>(true));

        for (int i = 0; i < batchInChunk.Count; i++)
        {
            var entityPosition = chunkPositions[i].Position;
            var entityBoundsSize = chunkPositions[i].BoundsSize;

            Bounds bounds = new Bounds(entityPosition, entityBoundsSize);

            // Perform frustum culling
            bool isInFrustum = GeometryUtility.TestPlanesAABB(FrustumPlanes.ToArray(), bounds);

            if (isInFrustum)
            {
                // Entity is inside the frustum, take action here
                Debug.Log($"Entity {i} is inside the frustum.");
            }
            else
            {
                // Entity is outside the frustum, you can cull or disable it
                Debug.Log($"Entity {i} is outside the frustum.");
            }
        }
    }
}

Key Details:

IJobEntityBatch:
- This job type allows you to operate on chunks of entities in parallel, and it’s a good fit for tasks like frustum culling. You can also use IJobParallelFor if you prefer, but IJobEntityBatch is better optimized for ECS data.
NativeArray<Plane>:
- The frustum planes are calculated outside the job using GeometryUtility.CalculateFrustumPlanes and passed to the job as a NativeArray for thread safety.
Bounds Calculation:
- Each entity has a position and bounds size, and we construct a Bounds object to represent its AABB (axis-aligned bounding box) in world space. This is then tested against the camera’s frustum.
Frustum Culling:
- GeometryUtility.TestPlanesAABB is used to check if the entity’s bounding box intersects with the camera frustum.

4. Optimizations:

Burst Compiler: The job is marked with [BurstCompile] to take advantage of the Burst Compiler’s performance optimizations.
NativeArrays: The job uses NativeArray<T> for the frustum planes to ensure thread safety and fast access in a parallel job.

5. Scheduling and Running the Job

The job is scheduled inside the FrustumCullingSystem and runs on all entities with the FrustumCullingComponent. The ScheduleParallel method is used to run the job in parallel.

protected override void OnUpdate()
{
    Camera mainCamera = Camera.main;
    if (mainCamera == null) return;

    Plane[] frustumPlanes = GeometryUtility.CalculateFrustumPlanes(mainCamera);
    NativeArray<Plane> frustumPlanesNative = new NativeArray<Plane>(frustumPlanes, Allocator.TempJob);

    var frustumCullingJob = new FrustumCullingJob
    {
        FrustumPlanes = frustumPlanesNative
    };

    // Schedule the job to run in parallel
    JobHandle jobHandle = frustumCullingJob.ScheduleParallel(Dependency);
    jobHandle.Complete();

    frustumPlanesNative.Dispose();
}

Final Notes

Performance: By running the frustum culling in parallel using DOTS jobs, you can significantly improve performance when checking visibility for a large number of entities.
Custom Optimization: Depending on the complexity of the scene and the objects, you might want to introduce custom optimizations (e.g., broad-phase culling with spatial partitioning).

This approach uses DOTS and Unity’s Jobs system to efficiently implement frustum culling in a highly parallelized manner.