UnityCatLikeCoding-PseudorandomNoise

[BurstCompile(FloatPrecision.Standard, FloatMode.Fast, CompileSynchronously = true)]
struct HashJob : IJobFor
{
    [ReadOnly]
    // 输入数据从 float3 变为 float3x4
    public NativeArray<float3x4> positions;
    [WriteOnly]
    // 输出数据从 uint 变为 uint4
    public NativeArray<uint4> hashes;
    public SmallXXHash4 hash;
    public float3x4 domainTRS;

    // 支持4x3 顶点的变换
    float4x3 TransformPositions(float3x4 trs, float4x3 p) => float4x3(
        trs.c0.x * p.c0 + trs.c1.x * p.c1 + trs.c2.x * p.c2 + trs.c3.x,
        trs.c0.y * p.c0 + trs.c1.y * p.c1 + trs.c2.y * p.c2 + trs.c3.y,
        trs.c0.z * p.c0 + trs.c1.z * p.c1 + trs.c2.z * p.c2 + trs.c3.z
    );

    public void Execute(int index)
    {
        // 将3x4 的数据变为 4x3 的数据
        float4x3 p = transpose(positions[index]);
        p = TransformPositions(domainTRS, p);

        int4 u = (int4)floor(p.c0);
        int4 v = (int4)floor(p.c1);
        int4 w = (int4)floor(p.c2);

        // 利用向量化后的SmallXXHash4 计算 hash 值
        hashes[index] = hash.Eat(u).Eat(v).Eat(w);
    }
}

void Update()
{
    // ......
    new HashJob{
        // 将 NativeArray<uint> 解释为NativeArray<uint4>
        hashes = hashes.Reinterpret<uint4>(4),
        // 将 NativeArray<float3> 解释为 NativeArray<float3x4>
        positions = positions.Reinterpret<float3x4>(3*4),
        hash = SmallXXHashX.Seed(seed),
        domainTRS = domain.Matrix
    }.ScheduleParallel(hashes.Length / 4, resolution, handle).Complete();
}

public static class Shapes
{
    public struct Job : IJobFor
    {
        [WriteOnly]
        // 输入数据从 float3 变为 float3x4
            NativeArray<float3x4> positions;

        [WriteOnly]
        // 输入数据从 float3 变为 float3x4
            NativeArray<float3x4> normals;
        public float resolution;
        public float invResolution;
        public float3x4 positionTRS;

        public void Execute(int index)
        {
            float4x2 uv;
            // index = [0, resolution/4]
            // 一次处理相邻的4个点
            float4 i4 = 4f * index + float4(0f, 1f, 2f, 3f);
            uv.c1 = floor(invResolution * i4 + 0.00001f);
            uv.c0 = invResolution * (i4 - resolution * uv.c1 + 0.5f) - 0.5f;
            uv.c1 = invResolution * (uv.c1 + 0.5f) - 0.5f;

            // 对4组位置进行变换
            positions[index] = transpose(TransformVectors(positionTRS, float4x3(uv.c0, 0f, uv.c1)));
            float3x4 n = transpose(TransformVectors(positionTRS, float4x3(0f, 1f, 0f), 0f));
            // 对4组normal进行变换
            normals[index] = float3x4(normalize(n.c0), normalize(n.c1), normalize(n.c2), normalize(n.c3));
        }

        float4x3 TransformVectors(float3x4 trs, float4x3 p, float w = 1f) => float4x3(
            trs.c0.x * p.c0 + trs.c1.x * p.c1 + trs.c2.x * p.c2 + trs.c3.x * w,
            trs.c0.y * p.c0 + trs.c1.y * p.c1 + trs.c2.y * p.c2 + trs.c3.y * w,
            trs.c0.z * p.c0 + trs.c1.z * p.c1 + trs.c2.z * p.c2 + trs.c3.z * w
            );
    }
}

public float4 GetNoise4 (float4x3 positions, SmallXXHash4 hash, int frequency)
{
    LatticeSpan4 x = default(L).GetLatticeSpan4(positions.c0, frequency);

    float4 minima = 2f;
    // 考虑相邻的格子
    for (int u = -1; u <= 1; u++) {
        SmallXXHash4 h = hash.Eat(x.p0 + u);
        minima = UpdateVoronoiMinima(minima, abs(h.Floats01A + u - x.g0));
    }
    return minima;
}

public float4 GetNoise4(float4x3 positions, SmallXXHash4 hash, int frequency)
{
    var l = default(L);
    LatticeSpan4 x = l.GetLatticeSpan4(positions.c0, frequency);
    LatticeSpan4 z = l.GetLatticeSpan4(positions.c2, frequency);
    float4 minima = 2f;
    for(int u=-1; u<=1; u++)
    {
        SmallXXHash4 hx = hash.Eat(l.ValidateSingleStep(x.p0 + u, frequency));
        float4 xOffset = u - x.g0;
        for(int v=-1; v<=1; v++)
        {
            SmallXXHash4 h = hx.Eat(l.ValidateSingleStep(z.p0 + v, frequency));
            float4 zOffset = v - z.g0;
            minima = UpdateVoronoiMinima(minima, GetDistance(h.Floats01A + xOffset, h.Floats01B + zOffset));
            // 增加一个填充点
            minima = UpdateVoronoiMinima(minima, GetDistance(h.Floats01C + xOffset, h.Floats01D + zOffset));
        }
    }
    return min(minima, 1f);
}
}

public struct Chebyshev : IVoronoiDistance
{
    public float4 GetDistance (float4 x) => abs(x);

    public float4 GetDistance (float4 x, float4 y) => max(abs(x), abs(y));

    public float4 GetDistance (float4 x, float4 y, float4 z) => max(max(abs(x), abs(y)), abs(z));

    // 不需要执行 min(minima.c0, 1) min(minima.c1, 1)
    public float4x2 Finalize1D (float4x2 minima) => minima;
    public float4x2 Finalize2D (float4x2 minima) => minima;
    public float4x2 Finalize3D (float4x2 minima) => minima;
}

public struct Simplex1D<G> : INoise where G : struct, IGradient
{
    public float4 GetNoise4(float4x3 positions, SmallXXHash4 hash, int frequency)
    {
        positions *= frequency;
        int4 x0 = (int4)floor(positions.c0);
        int4 x1 = x0 + 1;
        return default(G).EvaluateAfterInterpolation(
            // simplex noise sums kernels
            Kernel(hash.Eat(x0), x0, positions) + Kernel(hash.Eat(x1), x1, positions)
        );
    }

    static float4 Kernel(SmallXXHash4 hash, float4 lx, float4x3 positions)
    {
        float4 x = positions.c0 - lx;
        return default(G).Evaluate(hash, x);
    }
}

static float4 Kernel(SmallXXHash4 hash, float4 lx, float4x3 positions)
{
    float4 x = positions.c0 - lx;
    float4 f = 1f - abs(x);
    // use f scale gradient
    return f * default(G).Evaluate(hash, x);
}

public struct Simplex2D<G> : INoise where G : struct, IGradient
{
    public float4 GetNoise4(float4x3 positions, SmallXXHash4 hash, int frequency)
    {
        positions *= frequency;
        int4 x0 = (int4)floor(positions.c0);
        int4 x1 = x0 + 1;
        int4 z0 = (int4)floor(positions.c2);
        int4 z1 = z0 + 1;

        SmallXXHash4 h0 = hash.Eat(x0);
        SmallXXHash4 h1 = hash.Eat(x1);

        return default(G).EvaluateCombined(
            Kernel(h0.Eat(z0), x0, z0, positions) +
            Kernel(h0.Eat(z1), x0, z1, positions) +
            Kernel(h1.Eat(z0), x1, z0, positions) +
            Kernel(h1.Eat(z1), x1, z1, positions)
        );
    }

    static float4 Kernel(SmallXXHash4 hash, float4 lx, float4 lz, float4x3 positions)
    {
        float4 x = positions.c0 - lx;
        float4 z = positions.c2 - lz;

        float4 f = 1 - x * x - z * z;
        f = f * f * f;
        return f;
    }
}

static float4 Kernel(SmallXXHash4 hash, float4 lx, float4 lz, float4x3 positions)
{
    float4 x = positions.c0 - lx;
    float4 z = positions.c2 - lz;

    float4 f = 1 - x * x - z * z;
    f = f * f * f;
    return max(0f, f);
}

public static class BaseGradients
{
    // 生成1维值
    public static float4 Line(SmallXXHash4 hash, float4 x)
    {
        return (1 + hash.Floats01A) * select(-x, x, ((uint4)hash&1 << 8) == 0);
    }

    // 生成2维向量
    public static float4x2 SquareVectors(SmallXXHash4 hash)
    {
        float4x2 v;
        v.c0 = hash.Floats01A * 2f - 1f;
        v.c1 = 0.5f - abs(v.c0);
        v.c0 -= floor(v.c0 + 0.5f);
        return v;
    }

    // 生成3维向量
    public static float4x3 OctahedronVectors(SmallXXHash4 hash)
    {
        float4x3 g;
        g.c0 = hash.Floats01A * 2f - 1f;
        g.c1 = hash.Floats01D * 2f - 1f;
        g.c2 = 1f - abs(g.c0) - abs(g.c1);
        float4 offset = max(-g.c2, 0f);
        g.c0 += select(-offset, offset, g.c0 < 0f);
        g.c1 += select(-offset, offset, g.c1 < 0f);
        return g;
    }

    public static float4 Square(SmallXXHash4 hash, float4 x, float4 y)
    {
        float4x2 v = SquareVectors(hash);
        return v.c0 * x + v.c1 * y;
    }

    // x, y 输入可以是任何形状的格子，因为这里对梯度向量进行了归一化
    public static float4 Circle(SmallXXHash4 hash, float4 x, float4 y)
    {
        float4x2 v = SquareVectors(hash);
        // * rsqrt(v.c0 * v.c0 + v.c1 * v.c1) 就是对2维向量进行归一化
        return (v.c0 * x + v.c1 * y) * rsqrt(v.c0 * v.c0 + v.c1 * v.c1);
    }

    public static float4 Octahedron(SmallXXHash4 hash, float4 x, float4 y, float4 z)
    {
        float4x3 v = OctahedronVectors(hash);
        return v.c0 * x + v.c1 * y + v.c2 * z;
    }

    // x, y, z 输入可以是任何形状的格子，因为这里对梯度向量进行了归一化
    public static float4 Sphere(SmallXXHash4 hash, float4 x, float4 y, float4 z)
    {
        float4x3 v = OctahedronVectors(hash);
        // * rsqrt(v.c0 * v.c0 + v.c1 * v.c1 + v.c2 * v.c2) 就是对3维向量进行归一化
        return (v.c0 * x + v.c1 * y + v.c2 * z) * rsqrt(v.c0 * v.c0 + v.c1 * v.c1 + v.c2 * v.c2);
    }
}