// ISystemを実装
public partial struct RotationSystem : ISystem
{
    [BurstCompile]
    public void OnCreate(ref SystemState state)
    {
        state.RequireForUpdate<ExecuteMainThread>();
    }

    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        float deltaTime = SystemAPI.Time.DeltaTime;

        // LocalTransform コンポーネントと RotationSpeed コンポーネントを持つすべてのエンティティをループします。
        foreach (var (transform, speed) in
                 SystemAPI.Query<RefRW<LocalTransform>, RefRO<RotationSpeed>>())
        {
            // ValueRW と ValueRO は両方とも、実際のコンポーネント値への参照を返します。
            // 違いは、ValueRW が読み取り/書き込みアクセスの安全性チェックを行う一方で、
            // ValueRO は読み取り専用アクセスの安全性チェックを行います。
            transform.ValueRW = transform.ValueRO.RotateY(
                speed.ValueRO.RadiansPerSecond * deltaTime);
        }
    }
}

[BurstCompile]
public void OnUpdate(ref SystemState state)
{
    var job = new RotateAndScaleJob
    {
        deltaTime = SystemAPI.Time.DeltaTime,
        elapsedTime = (float)SystemAPI.Time.ElapsedTime
    };
    job.Schedule();
}

public float deltaTime;
public float elapsedTime;

// Execute()のパラメータからクエリを作成
// ここで、クエリは LocalTransform、PostTransformMatrix、
// RotationSpeedコンポーネントを持つすべてのエンティティと一致
void Execute(ref LocalTransform transform, ref PostTransformMatrix postTransform, in RotationSpeed speed)
{
    transform = transform.RotateY(speed.RadiansPerSecond * deltaTime);
    postTransform.Value = float4x4.Scale(1, math.sin(elapsedTime), 1);
}

// アスペクトを使用して立方体を回転
// クエリには、VerticalMovementAspect のすべてのコンポーネントが含まれます。
// コンポーネントとは異なり、SystemAPI.Query のアスペクト タイプ パラメータは
// RefRW または RefRO でラップされていないことに注意してください。
foreach (var movement in
         SystemAPI.Query<VerticalMovementAspect>())
{
    movement.Move(elapsedTime);
}

// このアスペクトではLocalTransform コンポーネントと RotationSpeed コンポーネントをラップ
readonly partial struct VerticalMovementAspect : IAspect
{
    readonly RefRW<LocalTransform> m_Transform;
    readonly RefRO<RotationSpeed> m_Speed;

    public void Move(double elapsedTime)
    {
        m_Transform.ValueRW.Position.y = (float)math.sin(elapsedTime * m_Speed.ValueRO.RadiansPerSecond);
    }
}

class Baker : Baker<SpawnerAuthoring>
{
    public override void Bake(SpawnerAuthoring authoring)
    {
        var entity = GetEntity(TransformUsageFlags.None);
        AddComponent(entity, new Spawner
        {
            Prefab = GetEntity(authoring.Prefab, TransformUsageFlags.Dynamic)
        });
    }
}

struct Spawner : IComponentData
{
    public Entity Prefab;
}

[BurstCompile]
public void OnUpdate(ref SystemState state)
{
    // RotationSpeed Componentを持つすべてのEntityに一致するQueryを作成します。
    // (Queryはソース生成時にキャッシュされるため、更新のたびにQueryを再作成するコストは発生しません。)
    var spinningCubesQuery = SystemAPI.QueryBuilder().WithAll<RotationSpeed>().Build();

    // 現在Cubeが存在しない場合にのみCubeを生成します。
    if (spinningCubesQuery.IsEmpty)
    {
        // Spawnerを持つEntityは一つしか生成されないのでこれで取得
        var prefab = SystemAPI.GetSingleton<Spawner>().Prefab;

        // Entityをインスタンス化すると、同じComponentタイプと値を持つコピー Entityが作成されます。
        // instances配列の使用はOnUpdate内で完結するのでAllocator.Temp
        var instances = state.EntityManager.Instantiate(prefab, 500, Allocator.Temp);

        // new Random() とは異なり、CreateFromIndex() はランダム シードをハッシュします
        // 同様のシードが同様の結果を生成しないようにします。
        var random = Random.CreateFromIndex(updateCounter++);

        foreach (var entity in instances)
        {
            // Entityの LocalTransform Componentを新しい位置で更新します。
            var transform = SystemAPI.GetComponentRW<LocalTransform>(entity);
            transform.ValueRW.Position = (random.NextFloat3() - new float3(0.5f, 0, 0.5f)) * 20;
        }
    }
}

[BurstCompile]
public void OnUpdate(ref SystemState state)
{
    var spinningCubesQuery = SystemAPI.QueryBuilder().WithAll<RotationSpeed, LocalTransform>().Build();

    var job = new RotationJob
    {
        // Chunk内に格納されたComponent配列を扱うためにComponentTypeHandleが必要
        TransformTypeHandle = SystemAPI.GetComponentTypeHandle<LocalTransform>(),
        RotationSpeedTypeHandle = SystemAPI.GetComponentTypeHandle<RotationSpeed>(true), // ReadOnly = true
        DeltaTime = SystemAPI.Time.DeltaTime
    };

    state.Dependency = job.Schedule(spinningCubesQuery, state.Dependency);
}

[BurstCompile]
struct RotationJob : IJobChunk
{
    public ComponentTypeHandle<LocalTransform> TransformTypeHandle;
    [ReadOnly] public ComponentTypeHandle<RotationSpeed> RotationSpeedTypeHandle;
    public float DeltaTime;
    
    public void Execute(in ArchetypeChunk chunk, int unfilteredChunkIndex, bool useEnabledMask,
        in v128 chunkEnabledMask)
    {
        // 後で誰かがクエリまたはコンポーネントのタイプを変更した場合に備えて、このガード チェックを追加することをお勧めします。
        Assert.IsFalse(useEnabledMask);

        // Chunk内のComponentのNativeArrayを取得して扱う
        var transforms = chunk.GetNativeArray(ref TransformTypeHandle);
        var rotationSpeeds = chunk.GetNativeArray(ref RotationSpeedTypeHandle);
        for (int i = 0, chunkEntityCount = chunk.Count; i < chunkEntityCount; i++)
        {
            transforms[i] = transforms[i].RotateY(rotationSpeeds[i].RadiansPerSecond * DeltaTime);
        }
    }
}

// ※1
var ecb = new EntityCommandBuffer(Allocator.Temp);

if (attached)
{
    // 子から Parent コンポーネントを削除して、すべての子をRotatorから切り離します。
    DynamicBuffer<Child> children = SystemAPI.GetBuffer<Child>(rotatorEntity);
    for (int i = 0; i < children.Length; i++)
    {
        // ※2
        ecb.RemoveComponent<Parent>(children[i].Value);
    }
}
else
{
    // 親コンポーネントを立方体に追加して、すべての小さな立方体をローテーターにアタッチします。
    foreach (var (transform, entity) in
             SystemAPI.Query<RefRO<LocalTransform>>()
                 .WithNone<RotationSpeed>() // ※3
                 .WithEntityAccess())   // ※4
    {
        ecb.AddComponent(entity, new Parent { Value = rotatorEntity });
    }
}

// 実際に実行
ecb.Playback(state.EntityManager);

attached = !attached;

// Bake内
SetComponentEnabled<RotationSpeed>(entity, authoring.StartEnabled);

// IEnableableComponentを追加
struct RotationSpeed : IComponentData, IEnableableComponent
{
    public float RadiansPerSecond;
}

foreach (var rotationSpeedEnabled in
         SystemAPI.Query<EnabledRefRW<RotationSpeed>>() //※1
         .WithOptions(EntityQueryOptions.IgnoreComponentEnabledState) // ※2
)
{
    rotationSpeedEnabled.ValueRW = !rotationSpeedEnabled.ValueRO;
}

public void OnUpdate(ref SystemState state)
{
    // 一回だけ実行されるようにする
    state.Enabled = false;

    // Directoryクラスを探す
    var go = GameObject.Find("Directory");
    if (go == null)
    {
        throw new Exception("GameObject 'Directory' not found.");
    }

    var directory = go.GetComponent<Directory>();

    // DirectoryのすべてのフィールドをDirectoryManagedに格納
    var directoryManaged = new DirectoryManaged();
    directoryManaged.RotatorPrefab = directory.RotatorPrefab;
    directoryManaged.RotationToggle = directory.RotationToggle;

    // Entityを生成して値を追加
    var entity = state.EntityManager.CreateEntity();
    state.EntityManager.AddComponentData(entity, directoryManaged);
}

foreach (var (goPrefab, entity) in
         SystemAPI.Query<RotationSpeed>()
             .WithNone<RotatorGO>()
             .WithEntityAccess())
{
    var go = GameObject.Instantiate(directory.RotatorPrefab);
		
		// イテレータの中でComponentを追加するのでECBを使う
    ecb.AddComponent(entity, new RotatorGO(go));
}

public void OnUpdate(ref SystemState state)
{
		// Toggleの情報を取得
    var directory = SystemAPI.ManagedAPI.GetSingleton<DirectoryManaged>();
    if (!directory.RotationToggle.isOn)
    {
        return;
    }

    float deltaTime = SystemAPI.Time.DeltaTime;

		// LocalTransform、RotationSpeed、RotatorGOを持つEntityがマッチ
    foreach (var (transform, speed, go) in
             SystemAPI.Query<RefRW<LocalTransform>, RefRO<RotationSpeed>, RotatorGO>())
    {
        transform.ValueRW = transform.ValueRO.RotateY(
            speed.ValueRO.RadiansPerSecond * deltaTime);

        // GameObjectとEntityのRotationを同期
        go.Value.transform.rotation = transform.ValueRO.Rotation;
    }
}

var boxQuery = SystemAPI.QueryBuilder()
                .WithAll<LocalTransform, DefaultColor, URPMaterialPropertyBaseColor>().Build();
      
// すべてのbox translationsとEntity ID の一時コピーを作成する必要がある
var boxTransforms = boxQuery.ToComponentDataArray<LocalTransform>(Allocator.Temp);
var boxEntities = boxQuery.ToEntityArray(Allocator.Temp);

foreach (var (transform, defaultColor, color, entity) in
         SystemAPI.Query<RefRO<LocalTransform>, RefRO<DefaultColor>,
                 RefRW<URPMaterialPropertyBaseColor>>()
             .WithEntityAccess())
{
    // ボックスの色をデフォルトにリセットします
    color.ValueRW.Value = defaultColor.ValueRO.Value;

    // このボックスが別のボックスと交差する場合は色を変更します
    for (int i = 0; i < boxTransforms.Length; i++)
    {
        var otherEnt = boxEntities[i];
        var otherTrans = boxTransforms[i];

        // ボックスはそれ自体と交差してはいけないため、他のエンティティの ID が現在のエンティティの ID と一致するかどうかを確認します。
        if (entity != otherEnt && math.distancesq(transform.ValueRO.Position, otherTrans.Position) < 1)
        {
            color.ValueRW.Value.y = 0.5f; // set green channel
            break;
        }
    }
}

// 前のフレームで生成されたエンティティから NewSpawn タグ コンポーネントを削除します。
var newSpawnQuery = SystemAPI.QueryBuilder().WithAll<NewSpawn>().Build();
state.EntityManager.RemoveComponent<NewSpawn>(newSpawnQuery);

// Spawn the boxes
var prefab = SystemAPI.GetSingleton<Config>().Prefab;
state.EntityManager.Instantiate(prefab, count, Allocator.Temp);

// スポーンされたすべてのボックスには一意のシードが必要なので、
// seedOffset はフレームごとにボックスの数だけ増加する必要があります。
seedOffset += count;

new RandomPositionJob
{
    SeedOffset = seedOffset
}.ScheduleParallel();

[WithAll(typeof(NewSpawn))]
[BurstCompile]
partial struct RandomPositionJob : IJobEntity
{
    ...
}

[UpdateInGroup(typeof(FixedStepSimulationSystemGroup))]
public partial struct FixedRateSpawnerSystem : ISystem
{
	...
}