felix91gr / rust-noisetoys Goto Github PK

The stdlib provided Vec seems like a good start.

This is important to keep track of exactly what we need to implement.

Perlin Noise

Description

• Input: an N-D vector v. Properties:
  • N dimensional, vector of real numbers
  • All coordinates have a well-defined value (not NaN or infinity, for example)
• Output: a value of noise f(v) for that vector. Properties:
  • 1-dimensional, real number
  • Value sits between 0 and 1
  • Function f is continuous
  • Its derivative is continuous as well. Is the second derivative continuous? I don't quite know 🤔
  • f(v) is deterministic: its value doesn't change if the state of the program changes.
  • f(v) appears to be random for v: ideally, v can't be found from f(v), and f(v+x) is unpredictable for large x.
  • f(v) is isotropic: it has no discernible directional patterns. Might not hold for Perlin. It does hold for Simplex, though.
  • f(v) has no discernible aliasing.

Step-by-Step

1. Find hypercube that contains v.
   • Smallest corner: v.floor().
   • Largest corner: v.ceil().
2. For each of the 2ⁿ corners in the hypercube, calculate their pseudorandom gradient.
3. For each corner c_i, with gradient g_ido:
   • u = v - c_i
   • n_i = u * g_i
4. For each value of n_i, interpolate using a fifth degree polynomial (or a Hermite blending function).
5. (alternative to 4): interpolate as it is done in the Simplex function. This reduces computational complexity.

The result of 4 (or 5) is f(v).

• Input: N-D vector
• Output: N-D unitary, pseudorandom vector

To-Do:

• Implement function
• Add test for length (n) and size (unitary) of output vector
• Add test for expected value of output vector (0ⁿ)
• Add tests to check that the output is deterministic.

rand crate could be a good start