// SIMD 최적화된 타입들
float4 position;    // 4개의 float을 하나의 SIMD 레지스터에
int4 indices;       // 4개의 int를 하나의 SIMD 레지스터에
bool4 conditions;   // 4개의 bool을 하나의 SIMD 레지스터에

// 수학 연산도 SIMD 명령어로 변환
float4 result = math.dot(a, b);
float4 normalized = math.normalize(vector);

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

public class BasicBurstExample : MonoBehaviour
{
    // [BurstCompile] 속성으로 Burst 컴파일 활성화
    [BurstCompile]
    struct AddNumbersJob : IJob
    {
        // 입력 데이터 (읽기 전용)
        [ReadOnly] public NativeArray<float> InputA;
        [ReadOnly] public NativeArray<float> InputB;

        // 출력 데이터 (쓰기)
        [WriteOnly] public NativeArray<float> Output;

        public void Execute()
        {
            // 배열의 모든 요소를 더함
            for (int i = 0; i < InputA.Length; i++)
            {
                Output[i] = InputA[i] + InputB[i];
            }
        }
    }

    void Start()
    {
        int dataSize = 1000;

        // NativeArray 생성 (Allocator.TempJob = 임시 할당)
        var inputA = new NativeArray<float>(dataSize, Allocator.TempJob);
        var inputB = new NativeArray<float>(dataSize, Allocator.TempJob);
        var output = new NativeArray<float>(dataSize, Allocator.TempJob);

        // 데이터 초기화
        for (int i = 0; i < dataSize; i++)
        {
            inputA[i] = i;
            inputB[i] = i * 2;
        }

        // Job 생성 및 스케줄링
        var job = new AddNumbersJob
        {
            InputA = inputA,
            InputB = inputB,
            Output = output
        };

        // Job 스케줄 및 완료 대기
        JobHandle handle = job.Schedule();
        handle.Complete();

        // 결과 확인
        Debug.Log($"Result[0] = {output[0]}, Result[999] = {output[999]}");

        // 메모리 해제 (필수!)
        inputA.Dispose();
        inputB.Dispose();
        output.Dispose();
    }
}

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

public class ParallelBurstExample : MonoBehaviour
{
    [BurstCompile]
    struct SquareNumbersJob : IJobParallelFor
    {
        [ReadOnly] public NativeArray<float> Input;
        [WriteOnly] public NativeArray<float> Output;

        // index는 자동으로 분배됨 (0 ~ Length-1)
        public void Execute(int index)
        {
            Output[index] = Input[index] * Input[index];
        }
    }

    void Start()
    {
        int dataSize = 100000;

        var input = new NativeArray<float>(dataSize, Allocator.TempJob);
        var output = new NativeArray<float>(dataSize, Allocator.TempJob);

        // 초기화
        for (int i = 0; i < dataSize; i++)
        {
            input[i] = i;
        }

        var job = new SquareNumbersJob
        {
            Input = input,
            Output = output
        };

        // Schedule(배열길이, 배치크기)
        // 배치크기: 한 스레드가 처리할 항목 수 (64~128 권장)
        JobHandle handle = job.Schedule(dataSize, 64);
        handle.Complete();

        Debug.Log($"100^2 = {output[100]}, 1000^2 = {output[1000]}");

        input.Dispose();
        output.Dispose();
    }
}

using Unity.Burst;
using Unity.Mathematics;
using UnityEngine;

// 클래스에도 [BurstCompile] 필요
[BurstCompile]
public static class BurstMathHelper
{
    // 정적 메서드에 [BurstCompile] 적용
    [BurstCompile]
    public static float CalculateDistance(in float3 a, in float3 b)
    {
        float3 diff = a - b;
        return math.sqrt(math.dot(diff, diff));
    }

    [BurstCompile]
    public static void NormalizeArray(ref NativeArray<float3> vectors)
    {
        for (int i = 0; i < vectors.Length; i++)
        {
            vectors[i] = math.normalize(vectors[i]);
        }
    }
}

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

public class BoidsSimulation : MonoBehaviour
{
    [Header("Simulation Settings")]
    public int boidCount = 1000;
    public float separationWeight = 1.5f;
    public float alignmentWeight = 1.0f;
    public float cohesionWeight = 1.0f;
    public float maxSpeed = 5f;
    public float perceptionRadius = 2.5f;

    private NativeArray<float3> _positions;
    private NativeArray<float3> _velocities;
    private NativeArray<float3> _accelerations;

    // Boid 행동 계산 Job
    [BurstCompile]
    struct CalculateBoidBehaviorJob : IJobParallelFor
    {
        [ReadOnly] public NativeArray<float3> Positions;
        [ReadOnly] public NativeArray<float3> Velocities;
        [WriteOnly] public NativeArray<float3> Accelerations;

        public float SeparationWeight;
        public float AlignmentWeight;
        public float CohesionWeight;
        public float PerceptionRadius;
        public float PerceptionRadiusSq;  // 제곱값 미리 계산

        public void Execute(int index)
        {
            float3 myPos = Positions[index];
            float3 myVel = Velocities[index];

            float3 separation = float3.zero;
            float3 alignment = float3.zero;
            float3 cohesion = float3.zero;
            int neighborCount = 0;

            // 모든 다른 Boid와의 관계 계산
            for (int i = 0; i < Positions.Length; i++)
            {
                // 자기 자신은 건너뜀
                if (i == index)
                {
                    continue;
                }

                float3 otherPos = Positions[i];
                float3 diff = myPos - otherPos;
                float distSq = math.lengthsq(diff);

                // 인식 범위 내의 이웃만 처리
                if (distSq >= PerceptionRadiusSq)
                {
                    continue;
                }

                float dist = math.sqrt(distSq);

                // Separation: 너무 가까운 이웃으로부터 멀어지기
                if (dist > 0.001f)
                {
                    separation += diff / dist;
                }

                // Alignment: 이웃들의 평균 속도 방향으로
                alignment += Velocities[i];

                // Cohesion: 이웃들의 중심으로 이동
                cohesion += otherPos;

                neighborCount++;
            }

            float3 acceleration = float3.zero;

            if (neighborCount > 0)
            {
                // 평균 계산 및 가중치 적용
                separation = separation / neighborCount * SeparationWeight;
                alignment = (alignment / neighborCount - myVel) * AlignmentWeight;
                cohesion = (cohesion / neighborCount - myPos) * CohesionWeight;

                acceleration = separation + alignment + cohesion;
            }

            Accelerations[index] = acceleration;
        }
    }

    // 위치 업데이트 Job
    [BurstCompile]
    struct UpdatePositionsJob : IJobParallelFor
    {
        public NativeArray<float3> Positions;
        public NativeArray<float3> Velocities;
        [ReadOnly] public NativeArray<float3> Accelerations;

        public float DeltaTime;
        public float MaxSpeed;
        public float3 BoundsMin;
        public float3 BoundsMax;

        public void Execute(int index)
        {
            float3 vel = Velocities[index] + Accelerations[index] * DeltaTime;

            // 최대 속도 제한
            float speed = math.length(vel);
            if (speed > MaxSpeed)
            {
                vel = vel / speed * MaxSpeed;
            }

            float3 pos = Positions[index] + vel * DeltaTime;

            // 경계 처리 (wrap around)
            pos = math.fmod(pos - BoundsMin + (BoundsMax - BoundsMin),
                           BoundsMax - BoundsMin) + BoundsMin;

            Positions[index] = pos;
            Velocities[index] = vel;
        }
    }

    void Start()
    {
        // NativeArray 할당 (Persistent = 장기 사용)
        _positions = new NativeArray<float3>(boidCount, Allocator.Persistent);
        _velocities = new NativeArray<float3>(boidCount, Allocator.Persistent);
        _accelerations = new NativeArray<float3>(boidCount, Allocator.Persistent);

        // 초기 위치/속도 랜덤 설정
        var random = new Unity.Mathematics.Random(12345);
        for (int i = 0; i < boidCount; i++)
        {
            _positions[i] = random.NextFloat3(-10f, 10f);
            _velocities[i] = random.NextFloat3Direction() * maxSpeed * 0.5f;
        }
    }

    void Update()
    {
        // Job 1: Boid 행동 계산
        var behaviorJob = new CalculateBoidBehaviorJob
        {
            Positions = _positions,
            Velocities = _velocities,
            Accelerations = _accelerations,
            SeparationWeight = separationWeight,
            AlignmentWeight = alignmentWeight,
            CohesionWeight = cohesionWeight,
            PerceptionRadius = perceptionRadius,
            PerceptionRadiusSq = perceptionRadius * perceptionRadius
        };

        JobHandle behaviorHandle = behaviorJob.Schedule(boidCount, 64);

        // Job 2: 위치 업데이트 (Job 1 완료 후 실행)
        var updateJob = new UpdatePositionsJob
        {
            Positions = _positions,
            Velocities = _velocities,
            Accelerations = _accelerations,
            DeltaTime = Time.deltaTime,
            MaxSpeed = maxSpeed,
            BoundsMin = new float3(-20f, -20f, -20f),
            BoundsMax = new float3(20f, 20f, 20f)
        };

        JobHandle updateHandle = updateJob.Schedule(boidCount, 64, behaviorHandle);
        updateHandle.Complete();

        // 여기서 _positions를 사용하여 렌더링
        // (GPU Instancing 또는 개별 Transform 업데이트)
    }

    void OnDestroy()
    {
        // 메모리 해제 필수!
        if (_positions.IsCreated) _positions.Dispose();
        if (_velocities.IsCreated) _velocities.Dispose();
        if (_accelerations.IsCreated) _accelerations.Dispose();
    }
}

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

[RequireComponent(typeof(MeshFilter))]
public class WaveMeshDeformation : MonoBehaviour
{
    [Header("Wave Settings")]
    public float waveHeight = 0.5f;
    public float waveFrequency = 1f;
    public float waveSpeed = 1f;

    private Mesh _mesh;
    private NativeArray<float3> _originalVertices;
    private NativeArray<float3> _modifiedVertices;
    private NativeArray<float3> _normals;

    // 파도 변형 Job
    [BurstCompile]
    struct WaveDeformJob : IJobParallelFor
    {
        [ReadOnly] public NativeArray<float3> OriginalVertices;
        [WriteOnly] public NativeArray<float3> ModifiedVertices;

        public float Time;
        public float WaveHeight;
        public float WaveFrequency;
        public float WaveSpeed;

        public void Execute(int index)
        {
            float3 vertex = OriginalVertices[index];

            // Perlin noise를 사용한 파도 계산
            float xOffset = vertex.x * WaveFrequency + Time * WaveSpeed;
            float zOffset = vertex.z * WaveFrequency + Time * WaveSpeed * 0.7f;

            // noise.cnoise는 -1 ~ 1 범위의 Perlin noise 반환
            float noiseValue = noise.cnoise(new float2(xOffset, zOffset));

            // Y 좌표에 파도 높이 적용
            vertex.y += noiseValue * WaveHeight;

            ModifiedVertices[index] = vertex;
        }
    }

    // 노말 재계산 Job
    [BurstCompile]
    struct RecalculateNormalsJob : IJobParallelFor
    {
        [ReadOnly] public NativeArray<float3> Vertices;
        [WriteOnly] public NativeArray<float3> Normals;

        public float WaveFrequency;
        public float WaveHeight;
        public float Time;
        public float WaveSpeed;

        public void Execute(int index)
        {
            float3 vertex = Vertices[index];

            // 주변 포인트의 기울기로 노말 근사 계산
            float delta = 0.01f;

            float xOffset = vertex.x * WaveFrequency + Time * WaveSpeed;
            float zOffset = vertex.z * WaveFrequency + Time * WaveSpeed * 0.7f;

            // X 방향 기울기
            float heightL = noise.cnoise(new float2(xOffset - delta, zOffset)) * WaveHeight;
            float heightR = noise.cnoise(new float2(xOffset + delta, zOffset)) * WaveHeight;
            float dX = (heightR - heightL) / (2 * delta);

            // Z 방향 기울기
            float heightD = noise.cnoise(new float2(xOffset, zOffset - delta)) * WaveHeight;
            float heightU = noise.cnoise(new float2(xOffset, zOffset + delta)) * WaveHeight;
            float dZ = (heightU - heightD) / (2 * delta);

            // 노말 계산 (cross product의 결과)
            float3 normal = math.normalize(new float3(-dX, 1, -dZ));

            Normals[index] = normal;
        }
    }

    void Start()
    {
        _mesh = GetComponent<MeshFilter>().mesh;
        _mesh.MarkDynamic();  // 자주 변경되는 메시임을 알림

        Vector3[] vertices = _mesh.vertices;
        int vertexCount = vertices.Length;

        // NativeArray 할당
        _originalVertices = new NativeArray<float3>(vertexCount, Allocator.Persistent);
        _modifiedVertices = new NativeArray<float3>(vertexCount, Allocator.Persistent);
        _normals = new NativeArray<float3>(vertexCount, Allocator.Persistent);

        // 원본 버텍스 복사
        for (int i = 0; i < vertexCount; i++)
        {
            _originalVertices[i] = vertices[i];
        }
    }

    void Update()
    {
        // Job 1: 파도 변형
        var deformJob = new WaveDeformJob
        {
            OriginalVertices = _originalVertices,
            ModifiedVertices = _modifiedVertices,
            Time = Time.time,
            WaveHeight = waveHeight,
            WaveFrequency = waveFrequency,
            WaveSpeed = waveSpeed
        };

        JobHandle deformHandle = deformJob.Schedule(_originalVertices.Length, 64);

        // Job 2: 노말 재계산 (변형 후)
        var normalJob = new RecalculateNormalsJob
        {
            Vertices = _modifiedVertices,
            Normals = _normals,
            WaveFrequency = waveFrequency,
            WaveHeight = waveHeight,
            Time = Time.time,
            WaveSpeed = waveSpeed
        };

        JobHandle normalHandle = normalJob.Schedule(_originalVertices.Length, 64, deformHandle);
        normalHandle.Complete();

        // 메시에 결과 적용
        _mesh.SetVertices(_modifiedVertices);
        _mesh.SetNormals(_normals);
    }

    void OnDestroy()
    {
        if (_originalVertices.IsCreated) _originalVertices.Dispose();
        if (_modifiedVertices.IsCreated) _modifiedVertices.Dispose();
        if (_normals.IsCreated) _normals.Dispose();
    }
}

using System;
using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using UnityEngine;

// Function Pointer 델리게이트 정의
// IL2CPP 호환을 위해 UnmanagedFunctionPointer 필요
[System.Runtime.InteropServices.UnmanagedFunctionPointer(
    System.Runtime.InteropServices.CallingConvention.Cdecl)]
public delegate float MathOperationDelegate(float a, float b);

// Burst 컴파일될 정적 메서드들을 포함하는 클래스
[BurstCompile]
public static class BurstMathOperations
{
    [BurstCompile]
    [AOT.MonoPInvokeCallback(typeof(MathOperationDelegate))]
    public static float Add(float a, float b) => a + b;

    [BurstCompile]
    [AOT.MonoPInvokeCallback(typeof(MathOperationDelegate))]
    public static float Multiply(float a, float b) => a * b;

    [BurstCompile]
    [AOT.MonoPInvokeCallback(typeof(MathOperationDelegate))]
    public static float Power(float a, float b) => Unity.Mathematics.math.pow(a, b);

    [BurstCompile]
    [AOT.MonoPInvokeCallback(typeof(MathOperationDelegate))]
    public static float Max(float a, float b) => Unity.Mathematics.math.max(a, b);
}

public class FunctionPointerExample : MonoBehaviour
{
    public enum Operation { Add, Multiply, Power, Max }
    public Operation selectedOperation = Operation.Add;

    // Burst 컴파일된 Function Pointer 캐시
    private FunctionPointer<MathOperationDelegate> _addPtr;
    private FunctionPointer<MathOperationDelegate> _mulPtr;
    private FunctionPointer<MathOperationDelegate> _powPtr;
    private FunctionPointer<MathOperationDelegate> _maxPtr;

    // Function Pointer를 사용하는 Job
    [BurstCompile]
    struct ProcessArrayJob : IJobParallelFor
    {
        [ReadOnly] public NativeArray<float> InputA;
        [ReadOnly] public NativeArray<float> InputB;
        [WriteOnly] public NativeArray<float> Output;

        // Function Pointer (런타임에 결정)
        public FunctionPointer<MathOperationDelegate> Operation;

        public void Execute(int index)
        {
            // Function Pointer를 통한 Burst 컴파일된 함수 호출
            Output[index] = Operation.Invoke(InputA[index], InputB[index]);
        }
    }

    void Start()
    {
        // Function Pointer 컴파일 (한 번만 수행)
        _addPtr = BurstCompiler.CompileFunctionPointer<MathOperationDelegate>(
            BurstMathOperations.Add);
        _mulPtr = BurstCompiler.CompileFunctionPointer<MathOperationDelegate>(
            BurstMathOperations.Multiply);
        _powPtr = BurstCompiler.CompileFunctionPointer<MathOperationDelegate>(
            BurstMathOperations.Power);
        _maxPtr = BurstCompiler.CompileFunctionPointer<MathOperationDelegate>(
            BurstMathOperations.Max);
    }

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

        int dataSize = 10000;
        var inputA = new NativeArray<float>(dataSize, Allocator.TempJob);
        var inputB = new NativeArray<float>(dataSize, Allocator.TempJob);
        var output = new NativeArray<float>(dataSize, Allocator.TempJob);

        // 데이터 초기화
        for (int i = 0; i < dataSize; i++)
        {
            inputA[i] = i * 0.01f;
            inputB[i] = 2f;
        }

        // 선택된 연산에 따라 Function Pointer 선택
        FunctionPointer<MathOperationDelegate> selectedPtr = selectedOperation switch
        {
            Operation.Add => _addPtr,
            Operation.Multiply => _mulPtr,
            Operation.Power => _powPtr,
            Operation.Max => _maxPtr,
            _ => _addPtr
        };

        var job = new ProcessArrayJob
        {
            InputA = inputA,
            InputB = inputB,
            Output = output,
            Operation = selectedPtr
        };

        job.Schedule(dataSize, 64).Complete();

        Debug.Log($"Operation: {selectedOperation}");
        Debug.Log($"Result[100] = {output[100]}, Result[5000] = {output[5000]}");

        inputA.Dispose();
        inputB.Dispose();
        output.Dispose();
    }
}

[BurstCompile(
    FloatPrecision.Standard,     // 또는 Low, Medium, High
    FloatMode.Fast,              // 또는 Default, Strict, Deterministic
    CompileSynchronously = false,
    OptimizeFor = OptimizeFor.Performance  // 또는 Size, Balanced
)]
struct MyJob : IJob { ... }