Function open_simplex_2d

src/open_simplex.rs:15–72

(permutation: &Permutation, x: f32, y: f32)

const G2: f32 = (3.0 - SQRT3) / 6.0;

pub fn open_simplex_2d(permutation: &Permutation, x: f32, y: f32) -> f32 {
    let s = (x + y) * F2;
    let xs = x + s;
    let ys = y + s;

    let i = xs.floor() as isize;
    let j = ys.floor() as isize;

    // Unskew to get original coordinates
    let t = (i + j) as f32 * G2;
    let x0 = x - (i as f32 - t);
    let y0 = y - (j as f32 - t);

    // Determine simplex corner order
    let (i1, j1) = if x0 > y0 { (1, 0) } else { (0, 1) };

    // Second corner coordinates
    let x1 = x0 - i1 as f32 + G2;
    let y1 = y0 - j1 as f32 + G2;

    // Third corner coordinates
    let x2 = x0 - 1.0 + 2.0 * G2;
    let y2 = y0 - 1.0 + 2.0 * G2;

    // Hash gradient indices
    let ii = (i & 255) as usize;
    let jj = (j & 255) as usize;
    let gi0 = permutation.get(ii + permutation.get(jj)) & 7;
    let gi1 = permutation.get(ii + i1 + permutation.get(jj + j1)) & 7;
    let gi2 = permutation.get(ii + 1 + permutation.get(jj + 1)) & 7;

    // Computate dot products
    let mut n0 = 0.0;
    let mut n1 = 0.0;
    let mut n2 = 0.0;

    let t0 = 0.5 - x0 * x0 - y0 * y0;
    if t0 > 0.0 {
        let g = GRADIENTS_2D[gi0];
        n0 = (t0 * t0) * (t0 * t0) * (g.0 * x0 + g.1 * y0);
    }

    let t1 = 0.5 - x1 * x1 - y1 * y1;
    if t1 > 0.0 {
        let g = GRADIENTS_2D[gi1];
        n1 = (t1 * t1) * (t1 * t1) * (g.0 * x1 + g.1 * y1);
    }

    let t2 = 0.5 - x2 * x2 - y2 * y2;
    if t2 > 0.0 {
        let g = GRADIENTS_2D[gi2];
        n2 = (t2 * t2) * (t2 * t2) * (g.0 * x2 + g.1 * y2);
    }

    // Sum contributions and scale
    // 18.541 was the value I found to scale the best. It's not perfect, but there is no perfect value. It's close enough.
    18.541 * (n0 + n1 + n2)
}