switch to per-sample FBM composition and displacement calculations which simplifies the code a lot (at the expense of a negligible cost in performance)

tayloraswift · tayloraswift · commit 545569f681c1 · 2017-07-11T15:47:56.000-04:00
diff --git a/sources/noise/compounds.swift b/sources/noise/compounds.swift
@@ -2,7 +2,11 @@ public
 struct FBM<Source>:Noise where Source:Noise
 {
     private
-    let generators:[Source]
+    let generators:[Source],
+        octaves:Int,
+        persistence:Double,
+        lacunarity:Double,
+        amplitude:Double
 
     // UNDOCUMENTED
     public
@@ -25,31 +29,45 @@ struct FBM<Source>:Noise where Source:Noise
     init(generators:[Source])
     {
         self.generators = generators
+
+        self.octaves = 1
+        self.persistence = 0.5
+        self.lacunarity = 2
+        self.amplitude = 1
     }
 
     @available(*, unavailable, message: "init(amplitude:frequency:seed:) defaults to octaves = 1, which does not make sense for FBM modules")
     public
     init(amplitude:Double, frequency:Double, seed:Int)
     {
         self.generators = []
+
+        self.octaves = 1
+        self.persistence = 0.5
+        self.lacunarity = 2
+        self.amplitude = 1
     }
 
     @available(*, unavailable, message: "use init(_:octaves:persistence:lacunarity:) instead")
     public
     init(amplitude:Double, frequency:Double, octaves:Int, persistence:Double = 0.75, lacunarity:Double = 2, seed:Int = 0)
     {
         self.generators  = []
+
+        self.octaves = 1
+        self.persistence = 0.5
+        self.lacunarity = 2
+        self.amplitude = 1
     }
 
     // UNDOCUMENTED, default was changed from 0.75 to 0.5
     public
     init(_ source:Source, octaves:Int, persistence:Double = 0.5, lacunarity:Double = 2)
     {
         // calculate maximum range
-        let range_inverse:Double
         if persistence == 0.5
         {
-            range_inverse = Double(1 << (octaves - 1)) / Double(1 << octaves - 1)
+            self.amplitude = Double(1 << (octaves - 1)) / Double(1 << octaves - 1)
         }
         else
         {
@@ -61,50 +79,65 @@ struct FBM<Source>:Noise where Source:Noise
                 contribution *= persistence
             }
 
-            range_inverse = 1 / accumulation
+            self.amplitude = 1 / accumulation
         }
 
-        var generators:[Source] = [source.amplitude_scaled(by: range_inverse)]
+        var generators:[Source] = [source]
             generators.reserveCapacity(octaves)
         for i in (0 ..< octaves - 1)
         {
-            generators.append(generators[i].amplitude_scaled(by: persistence).frequency_scaled(by: lacunarity).reseeded())
+            generators.append(generators[i].reseeded())
         }
 
         self.generators  = generators
+        self.octaves = octaves
+        self.persistence = persistence
+        self.lacunarity = lacunarity
     }
 
     public
     func evaluate(_ x:Double, _ y:Double) -> Double
     {
-        var z:Double = 0
+        var Σ:Double = 0,
+            a:Double = self.amplitude,
+            f:Double = 1
         for generator in self.generators
         {
-            z += generator.evaluate(x, y) // a .reduce(:{}) is much slower than a simple loop
+            Σ += a * generator.evaluate(f * x, f * y)
+            a *= self.persistence
+            f *= self.lacunarity
         }
-        return z
+        return Σ
     }
 
     public
     func evaluate(_ x:Double, _ y:Double, _ z:Double) -> Double
     {
-        var w:Double = 0
+        var Σ:Double = 0,
+            a:Double = self.amplitude,
+            f:Double = 1
         for generator in self.generators
         {
-            w += generator.evaluate(x, y, z)
+            Σ += a * generator.evaluate(f * x, f * y, f * z)
+            a *= self.persistence
+            f *= self.lacunarity
         }
-        return w
+        return Σ
     }
 
     public
     func evaluate(_ x:Double, _ y:Double, _ z:Double, _ w:Double) -> Double
     {
-        var u:Double = 0
+        var Σ:Double = 0,
+            a:Double = self.amplitude,
+            f:Double = 1
         for generator in self.generators
         {
-            u += generator.evaluate(x, y, z, w)
+            Σ += a * generator.evaluate(f * x, f * y, f * z, f * w)
+            a *= self.persistence
+            f *= self.lacunarity
         }
-        return u
+        return Σ
     }
 }
 
@@ -114,7 +147,8 @@ struct DistortedNoise<Source, Displacement>:Noise where Source:Noise, Displaceme
 {
     private
     let source:Source,
-        displacement:Displacement
+        displacement:Displacement,
+        strength:Double
 
     public
     func amplitude_scaled(by factor:Double) -> DistortedNoise<Source, Displacement>
@@ -136,47 +170,49 @@ struct DistortedNoise<Source, Displacement>:Noise where Source:Noise, Displaceme
                                                     with: self.displacement.reseeded())
     }
 
-    public 
-    init(displacing source:Source, with displacement:Displacement)
+    public
+    init(displacing source:Source, with displacement:Displacement, strength:Double = 1)
     {
         self.source       = source
         self.displacement = displacement
+        self.strength     = strength
     }
 
     public
     func evaluate(_ x: Double, _ y: Double) -> Double
     {
-        let dx:Double = self.displacement.evaluate(x, y),
-            dy:Double = self.displacement.evaluate(y, x)
+        let dx:Double = self.strength * self.displacement.evaluate(x, y),
+            dy:Double = self.strength * self.displacement.evaluate(y, x)
         return self.source.evaluate(x + dx, y + dy)
     }
 
     public
     func evaluate(_ x: Double, _ y: Double, _ z: Double) -> Double
     {
-        let dx:Double = 1.0 + self.displacement.evaluate(x, y, z),
-            dy:Double = 1.0 + self.displacement.evaluate(y, z, x),
-            dz:Double = 1.0 + self.displacement.evaluate(z, x, y)
+        let dx:Double = self.strength * self.displacement.evaluate(x, y, z),
+            dy:Double = self.strength * self.displacement.evaluate(y, z, x),
+            dz:Double = self.strength * self.displacement.evaluate(z, x, y)
         return self.source.evaluate(x + dx, y + dy, z + dz)
     }
 
     public
     func evaluate(_ x: Double, _ y: Double, _ z: Double, _ w:Double) -> Double
     {
-        let dx:Double = self.displacement.evaluate(x, y, z, w),
-            dy:Double = self.displacement.evaluate(y, z, w, x),
-            dz:Double = self.displacement.evaluate(z, w, x, y),
-            dw:Double = self.displacement.evaluate(w, x, y, z)
+        let dx:Double = self.strength * self.displacement.evaluate(x, y, z, w),
+            dy:Double = self.strength * self.displacement.evaluate(y, z, w, x),
+            dz:Double = self.strength * self.displacement.evaluate(z, w, x, y),
+            dw:Double = self.strength * self.displacement.evaluate(w, x, y, z)
         return self.source.evaluate(x + dx, y + dy, z + dz, w + dw)
     }
 }
 
 extension DistortedNoise where Source == Displacement
 {
     public
-    init(_ source:Source, strength:Double)
+    init(_ source:Source, strength:Double = 1)
     {
         self.source       = source
-        self.displacement = source.amplitude_scaled(by: strength)
+        self.displacement = source
+        self.strength     = strength
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,11 @@ public`
`2`	`2`	`struct FBM<Source>:Noise where Source:Noise`
`3`	`3`	`{`
`4`	`4`	`private`
`5`		`- let generators:[Source]`
	`5`	`+ let generators:[Source],`
	`6`	`+ octaves:Int,`
	`7`	`+ persistence:Double,`
	`8`	`+ lacunarity:Double,`
	`9`	`+ amplitude:Double`
`6`	`10`
`7`	`11`	`// UNDOCUMENTED`
`8`	`12`	`public`
`@@ -25,31 +29,45 @@ struct FBM<Source>:Noise where Source:Noise`
`25`	`29`	`init(generators:[Source])`
`26`	`30`	`{`
`27`	`31`	`self.generators = generators`
	`32`	`+`
	`33`	`+ self.octaves = 1`
	`34`	`+ self.persistence = 0.5`
	`35`	`+ self.lacunarity = 2`
	`36`	`+ self.amplitude = 1`
`28`	`37`	`}`
`29`	`38`
`30`	`39`	`@available(*, unavailable, message: "init(amplitude:frequency:seed:) defaults to octaves = 1, which does not make sense for FBM modules")`
`31`	`40`	`public`
`32`	`41`	`init(amplitude:Double, frequency:Double, seed:Int)`
`33`	`42`	`{`
`34`	`43`	`self.generators = []`
	`44`	`+`
	`45`	`+ self.octaves = 1`
	`46`	`+ self.persistence = 0.5`
	`47`	`+ self.lacunarity = 2`
	`48`	`+ self.amplitude = 1`
`35`	`49`	`}`
`36`	`50`
`37`	`51`	`@available(*, unavailable, message: "use init(_:octaves:persistence:lacunarity:) instead")`
`38`	`52`	`public`
`39`	`53`	`init(amplitude:Double, frequency:Double, octaves:Int, persistence:Double = 0.75, lacunarity:Double = 2, seed:Int = 0)`
`40`	`54`	`{`
`41`	`55`	`self.generators = []`
	`56`	`+`
	`57`	`+ self.octaves = 1`
	`58`	`+ self.persistence = 0.5`
	`59`	`+ self.lacunarity = 2`
	`60`	`+ self.amplitude = 1`
`42`	`61`	`}`
`43`	`62`
`44`	`63`	`// UNDOCUMENTED, default was changed from 0.75 to 0.5`
`45`	`64`	`public`
`46`	`65`	`init(_ source:Source, octaves:Int, persistence:Double = 0.5, lacunarity:Double = 2)`
`47`	`66`	`{`
`48`	`67`	`// calculate maximum range`
`49`		`- let range_inverse:Double`
`50`	`68`	`if persistence == 0.5`
`51`	`69`	`{`
`52`		`- range_inverse = Double(1 << (octaves - 1)) / Double(1 << octaves - 1)`
	`70`	`+ self.amplitude = Double(1 << (octaves - 1)) / Double(1 << octaves - 1)`
`53`	`71`	`}`
`54`	`72`	`else`
`55`	`73`	`{`
`@@ -61,50 +79,65 @@ struct FBM<Source>:Noise where Source:Noise`
`61`	`79`	`contribution *= persistence`
`62`	`80`	`}`
`63`	`81`
`64`		`- range_inverse = 1 / accumulation`
	`82`	`+ self.amplitude = 1 / accumulation`
`65`	`83`	`}`
`66`	`84`
`67`		`- var generators:[Source] = [source.amplitude_scaled(by: range_inverse)]`
	`85`	`+ var generators:[Source] = [source]`
`68`	`86`	`generators.reserveCapacity(octaves)`
`69`	`87`	`for i in (0 ..< octaves - 1)`
`70`	`88`	`{`
`71`		`- generators.append(generators[i].amplitude_scaled(by: persistence).frequency_scaled(by: lacunarity).reseeded())`
	`89`	`+ generators.append(generators[i].reseeded())`
`72`	`90`	`}`
`73`	`91`
`74`	`92`	`self.generators = generators`
	`93`	`+ self.octaves = octaves`
	`94`	`+ self.persistence = persistence`
	`95`	`+ self.lacunarity = lacunarity`
`75`	`96`	`}`
`76`	`97`
`77`	`98`	`public`
`78`	`99`	`func evaluate(_ x:Double, _ y:Double) -> Double`
`79`	`100`	`{`
`80`		`- var z:Double = 0`
	`101`	`+ var Σ:Double = 0,`
	`102`	`+ a:Double = self.amplitude,`
	`103`	`+ f:Double = 1`
`81`	`104`	`for generator in self.generators`
`82`	`105`	`{`
`83`		`- z += generator.evaluate(x, y) // a .reduce(:{}) is much slower than a simple loop`
	`106`	`+ Σ += a * generator.evaluate(f * x, f * y)`
	`107`	`+ a *= self.persistence`
	`108`	`+ f *= self.lacunarity`
`84`	`109`	`}`
`85`		`- return z`
	`110`	`+ return Σ`
`86`	`111`	`}`
`87`	`112`
`88`	`113`	`public`
`89`	`114`	`func evaluate(_ x:Double, _ y:Double, _ z:Double) -> Double`
`90`	`115`	`{`
`91`		`- var w:Double = 0`
	`116`	`+ var Σ:Double = 0,`
	`117`	`+ a:Double = self.amplitude,`
	`118`	`+ f:Double = 1`
`92`	`119`	`for generator in self.generators`
`93`	`120`	`{`
`94`		`- w += generator.evaluate(x, y, z)`
	`121`	`+ Σ += a * generator.evaluate(f * x, f * y, f * z)`
	`122`	`+ a *= self.persistence`
	`123`	`+ f *= self.lacunarity`
`95`	`124`	`}`
`96`		`- return w`
	`125`	`+ return Σ`
`97`	`126`	`}`
`98`	`127`
`99`	`128`	`public`
`100`	`129`	`func evaluate(_ x:Double, _ y:Double, _ z:Double, _ w:Double) -> Double`
`101`	`130`	`{`
`102`		`- var u:Double = 0`
	`131`	`+ var Σ:Double = 0,`
	`132`	`+ a:Double = self.amplitude,`
	`133`	`+ f:Double = 1`
`103`	`134`	`for generator in self.generators`
`104`	`135`	`{`
`105`		`- u += generator.evaluate(x, y, z, w)`
	`136`	`+ Σ += a * generator.evaluate(f * x, f * y, f * z, f * w)`
	`137`	`+ a *= self.persistence`
	`138`	`+ f *= self.lacunarity`
`106`	`139`	`}`
`107`		`- return u`
	`140`	`+ return Σ`
`108`	`141`	`}`
`109`	`142`	`}`
`110`	`143`
`@@ -114,7 +147,8 @@ struct DistortedNoise<Source, Displacement>:Noise where Source:Noise, Displaceme`
`114`	`147`	`{`
`115`	`148`	`private`
`116`	`149`	`let source:Source,`
`117`		`- displacement:Displacement`
	`150`	`+ displacement:Displacement,`
	`151`	`+ strength:Double`
`118`	`152`
`119`	`153`	`public`
`120`	`154`	`func amplitude_scaled(by factor:Double) -> DistortedNoise<Source, Displacement>`
`@@ -136,47 +170,49 @@ struct DistortedNoise<Source, Displacement>:Noise where Source:Noise, Displaceme`
`136`	`170`	`with: self.displacement.reseeded())`
`137`	`171`	`}`
`138`	`172`
`139`		`- public`
`140`		`- init(displacing source:Source, with displacement:Displacement)`
	`173`	`+ public`
	`174`	`+ init(displacing source:Source, with displacement:Displacement, strength:Double = 1)`
`141`	`175`	`{`
`142`	`176`	`self.source = source`
`143`	`177`	`self.displacement = displacement`
	`178`	`+ self.strength = strength`
`144`	`179`	`}`
`145`	`180`
`146`	`181`	`public`
`147`	`182`	`func evaluate(_ x: Double, _ y: Double) -> Double`
`148`	`183`	`{`
`149`		`- let dx:Double = self.displacement.evaluate(x, y),`
`150`		`- dy:Double = self.displacement.evaluate(y, x)`
	`184`	`+ let dx:Double = self.strength * self.displacement.evaluate(x, y),`
	`185`	`+ dy:Double = self.strength * self.displacement.evaluate(y, x)`
`151`	`186`	`return self.source.evaluate(x + dx, y + dy)`
`152`	`187`	`}`
`153`	`188`
`154`	`189`	`public`
`155`	`190`	`func evaluate(_ x: Double, _ y: Double, _ z: Double) -> Double`
`156`	`191`	`{`
`157`		`- let dx:Double = 1.0 + self.displacement.evaluate(x, y, z),`
`158`		`- dy:Double = 1.0 + self.displacement.evaluate(y, z, x),`
`159`		`- dz:Double = 1.0 + self.displacement.evaluate(z, x, y)`
	`192`	`+ let dx:Double = self.strength * self.displacement.evaluate(x, y, z),`
	`193`	`+ dy:Double = self.strength * self.displacement.evaluate(y, z, x),`
	`194`	`+ dz:Double = self.strength * self.displacement.evaluate(z, x, y)`
`160`	`195`	`return self.source.evaluate(x + dx, y + dy, z + dz)`
`161`	`196`	`}`
`162`	`197`
`163`	`198`	`public`
`164`	`199`	`func evaluate(_ x: Double, _ y: Double, _ z: Double, _ w:Double) -> Double`
`165`	`200`	`{`
`166`		`- let dx:Double = self.displacement.evaluate(x, y, z, w),`
`167`		`- dy:Double = self.displacement.evaluate(y, z, w, x),`
`168`		`- dz:Double = self.displacement.evaluate(z, w, x, y),`
`169`		`- dw:Double = self.displacement.evaluate(w, x, y, z)`
	`201`	`+ let dx:Double = self.strength * self.displacement.evaluate(x, y, z, w),`
	`202`	`+ dy:Double = self.strength * self.displacement.evaluate(y, z, w, x),`
	`203`	`+ dz:Double = self.strength * self.displacement.evaluate(z, w, x, y),`
	`204`	`+ dw:Double = self.strength * self.displacement.evaluate(w, x, y, z)`
`170`	`205`	`return self.source.evaluate(x + dx, y + dy, z + dz, w + dw)`
`171`	`206`	`}`
`172`	`207`	`}`
`173`	`208`
`174`	`209`	`extension DistortedNoise where Source == Displacement`
`175`	`210`	`{`
`176`	`211`	`public`
`177`		`- init(_ source:Source, strength:Double)`
	`212`	`+ init(_ source:Source, strength:Double = 1)`
`178`	`213`	`{`
`179`	`214`	`self.source = source`
`180`		`- self.displacement = source.amplitude_scaled(by: strength)`
	`215`	`+ self.displacement = source`
	`216`	`+ self.strength = strength`
`181`	`217`	`}`
`182`	`218`	`}`