Unity DOTS中实现支持可空泛型的通用CopyJob方案咨询

针对你在Unity DOTS空间分区系统开发中，重复编写实体复制作业的问题，以下是两种可行的解决方案：

方案1：泛型IJobEntity配合[Optional]属性与占位组件 #

该方案利用Unity IJobEntity的[Optional]属性实现可选组件支持，同时通过自定义空占位组件满足非托管类型约束，无需为每种组件组合重复编写作业代码。

步骤1：定义空占位组件 #

创建一个空的非托管组件作为不需要的泛型参数占位：

public struct EmptyComponent : IComponentData { }

步骤2：编写泛型复制作业 #

partial struct GenericCopyJob<T1, T2, T3, T4, T5> : IJobEntity 
    where T1 : unmanaged, IComponentData
    where T2 : unmanaged, IComponentData
    where T3 : unmanaged, IComponentData
    where T4 : unmanaged, IComponentData
    where T5 : unmanaged, IComponentData
{
    public NativeList<Entity> Entities;
    public NativeList<T1>? List1;
    public NativeList<T2>? List2;
    public NativeList<T3>? List3;
    public NativeList<T4>? List4;
    public NativeList<T5>? List5;

    void Execute(Entity entity, 
        [Optional] in T1 comp1, 
        [Optional] in T2 comp2, 
        [Optional] in T3 comp3, 
        [Optional] in T4 comp4, 
        [Optional] in T5 comp5)
    {
        Entities.Add(entity);

        if (List1 != null && typeof(T1) != typeof(EmptyComponent))
            List1.Value.Add(comp1);
        if (List2 != null && typeof(T2) != typeof(EmptyComponent))
            List2.Value.Add(comp2);
        if (List3 != null && typeof(T3) != typeof(EmptyComponent))
            List3.Value.Add(comp3);
        if (List4 != null && typeof(T4) != typeof(EmptyComponent))
            List4.Value.Add(comp4);
        if (List5 != null && typeof(T5) != typeof(EmptyComponent))
            List5.Value.Add(comp5);
    }
}

步骤3：使用泛型作业 #

以复制角色组件为例，不需要的泛型参数用EmptyComponent填充，对应的NativeList设为null：

// 初始化存储列表
var entityList = new NativeList<Entity>(Allocator.TempJob);
var bodyList = new NativeList<CharacterControllerComponent>(Allocator.TempJob);
var transformList = new NativeList<LocalTransform>(Allocator.TempJob);
var stateList = new NativeList<AICharacterStateData>(Allocator.TempJob);
var signalList = new NativeList<AIInteractionSignalData>(Allocator.TempJob);

// 创建并配置作业
var copyJob = new GenericCopyJob<
    CharacterControllerComponent,
    LocalTransform,
    AICharacterStateData,
    AIInteractionSignalData,
    EmptyComponent
>
{
    Entities = entityList,
    List1 = bodyList,
    List2 = transformList,
    List3 = stateList,
    List4 = signalList,
    List5 = null
};

// 调度并完成作业
var jobHandle = copyJob.Schedule();
jobHandle.Complete();

// 使用数据后释放资源
entityList.Dispose();
bodyList.Dispose();
transformList.Dispose();
stateList.Dispose();
signalList.Dispose();

优势：保留IJobEntity的自动实体筛选能力，仅处理拥有所有必填组件的实体；代码复用性高，无需重复编写作业结构。

方案2：IJobChunk实现灵活组件复制 #

如果需要支持任意数量的组件组合，可使用IJobChunk直接操作ArchetypeChunk，避免泛型参数数量限制：

public struct FlexibleCopyJob : IJobChunk
{
    public NativeList<Entity> Entities;
    // 存储各组件的NativeList，需提前初始化对应类型
    public NativeList<CharacterControllerComponent>? BodyList;
    public NativeList<LocalTransform>? TransformList;
    public NativeList<AICharacterStateData>? StateList;

    public void Execute(in ArchetypeChunk chunk, int unfilteredChunkIndex, bool useEnabledMask, in v128 chunkEnabledMask)
    {
        var entityArray = chunk.GetNativeArray(EntityType.Index);
        
        // 按需获取组件数组
        NativeArray<CharacterControllerComponent>? bodyArray = null;
        if (BodyList != null && chunk.Has(ComponentType.ReadOnly<CharacterControllerComponent>()))
            bodyArray = chunk.GetNativeArray<CharacterControllerComponent>();

        NativeArray<LocalTransform>? transformArray = null;
        if (TransformList != null && chunk.Has(ComponentType.ReadOnly<LocalTransform>()))
            transformArray = chunk.GetNativeArray<LocalTransform>();

        NativeArray<AICharacterStateData>? stateArray = null;
        if (StateList != null && chunk.Has(ComponentType.ReadOnly<AICharacterStateData>()))
            stateArray = chunk.GetNativeArray<AICharacterStateData>();

        // 遍历实体复制数据
        for (int i = 0; i < chunk.Count; i++)
        {
            Entities.Add(entityArray[i]);
            
            if (bodyArray.HasValue) BodyList.Value.Add(bodyArray.Value[i]);
            if (transformArray.HasValue) TransformList.Value.Add(transformArray.Value[i]);
            if (stateArray.HasValue) StateList.Value.Add(stateArray.Value[i]);
        }
    }
}

使用示例 #

var query = EntityManager.CreateEntityQuery(
    ComponentType.ReadOnly<CharacterControllerComponent>(),
    ComponentType.ReadOnly<LocalTransform>(),
    ComponentType.ReadOnly<AICharacterStateData>()
);

var flexibleJob = new FlexibleCopyJob
{
    Entities = entityList,
    BodyList = bodyList,
    TransformList = transformList,
    StateList = stateList
};

var jobHandle = flexibleJob.Schedule(query);
jobHandle.Complete();

优势：支持任意数量的组件组合，无需受泛型参数数量限制；适合组件组合频繁变化的场景。

内容的提问来源于stack exchange，提问作者Dhruv Bansal