technicolour icecream hellscape terrain

Sources/Voxelotl/Noise/LayeredNoise.swift

@@ -58,3 +58,51 @@ public extension LayeredNoise where Generator: CoherentNoise4D {
       $0 + $1 } * self._amplitudeAdjusted
   }
 }
+
+//MARK: - Experimental
+
+public struct LayeredNoiseAlt<Generator: CoherentNoise> {
+  public typealias Scalar = Generator.Scalar
+
+  public let octaves: Int
+  public let frequency: Scalar
+  public let amplitude: Scalar
+
+  private let _generator: Generator
+  private let _amplitudeAdjusted: Scalar
+
+}
+
+public extension LayeredNoiseAlt where Generator: CoherentNoiseRandomInit {
+  init<Random: RandomProvider>(random: inout Random, octaves: Int, frequency: Scalar, amplitude: Scalar = 1) {
+    self.octaves   = octaves
+    self.frequency = frequency
+    self.amplitude = amplitude
+    self._generator = Generator(random: &random)
+    self._amplitudeAdjusted = amplitude / 2
+  }
+}
+
+public extension LayeredNoiseAlt where Generator: CoherentNoise3D & CoherentNoise2D {
+  func get(_ point: SIMD2<Scalar>) -> Scalar {
+    let layerOffset: Int = 1
+    return (1..<self.octaves).map { term in
+      let mul = Scalar(1 + term)
+      let point3D = SIMD3(point * frequency * mul, Scalar(term * layerOffset))
+      return self._generator.get(point3D) / mul
+    }.reduce(self._generator.get(point * frequency)) {
+      $0 + $1 } * self._amplitudeAdjusted
+  }
+}
+
+public extension LayeredNoiseAlt where Generator: CoherentNoise4D & CoherentNoise3D {
+  func get(_ point: SIMD3<Scalar>) -> Scalar {
+    let layerOffset: Int = 1
+    return (1..<self.octaves).map { term in
+      let mul = Scalar(1 + term)
+      let point4D = SIMD4(point * frequency * mul, Scalar(term * layerOffset))
+      return self._generator.get(point4D) / mul
+    }.reduce(self._generator.get(point * frequency)) {
+      $0 + $1 } * self._amplitudeAdjusted
+  }
+}