strips/voxelotl-engine
2
0
Fork 0
mirror of https://github.com/GayPizzaSpecifications/voxelotl-engine.git synced 2025-11-04 10:59:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

tower world gen

Browse Source
This commit is contained in:
a dinosaur
2024-09-04 01:38:27 +10:00
parent f77b64cc85
commit 080522e01b
9 changed files with 168 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
Sources/Voxelotl/Noise/CoherentNoise.swift
View File

@ -1,17 +1,21 @@
public protocol CoherentNoise2D {
public protocol CoherentNoise {
associatedtype Scalar: FloatingPoint & SIMDScalar
init()
}
public protocol CoherentNoiseRandomInit: CoherentNoise {
init<Random: RandomProvider>(random: inout Random)
}
public protocol CoherentNoise2D: CoherentNoise {
func get(_ point: SIMD2<Scalar>) -> Scalar
}
public protocol CoherentNoise3D {
associatedtype Scalar: FloatingPoint & SIMDScalar
public protocol CoherentNoise3D: CoherentNoise {
func get(_ point: SIMD3<Scalar>) -> Scalar
}
public protocol CoherentNoise4D {
associatedtype Scalar: FloatingPoint & SIMDScalar
public protocol CoherentNoise4D: CoherentNoise {
func get(_ point: SIMD4<Scalar>) -> Scalar
}

53
Sources/Voxelotl/Noise/LayeredNoise.swift Normal file
View File

@ -0,0 +1,53 @@
public struct LayeredNoise<Generator: CoherentNoise> {
public typealias Scalar = Generator.Scalar
public let octaves: Int
public let frequency: Scalar
public let amplitude: Scalar
private let _generators: [Generator]
init(octaves: Int, frequency: Scalar, amplitude: Scalar) {
self.octaves = octaves
self.frequency = frequency
self.amplitude = amplitude
self._generators = Array(repeating: .init(), count: octaves)
}
}
public extension LayeredNoise where Generator: CoherentNoiseRandomInit {
init<Random: RandomProvider>(random: inout Random, octaves: Int, frequency: Scalar, amplitude: Scalar) {
self.octaves = octaves
self.frequency = frequency
self.amplitude = amplitude
self._generators = Array(repeating: Generator(random: &random), count: octaves)
}
}
public extension LayeredNoise where Generator: CoherentNoise2D {
func get(_ point: SIMD2<Scalar>) -> Scalar {
zip(self._generators, 0..<self.octaves).map { layer, term in
let mul = Scalar(1 + term)
return layer.get(point * frequency * mul) / mul
}.reduce(0) { $0 + $1 } * amplitude
}
}
public extension LayeredNoise where Generator: CoherentNoise3D {
func get(_ point: SIMD3<Scalar>) -> Scalar {
zip(self._generators, 0..<self.octaves).map { layer, term in
let mul = Scalar(1 + term)
return layer.get(point * frequency * mul) / mul
}.reduce(0) { $0 + $1 } * amplitude
}
}
public extension LayeredNoise where Generator: CoherentNoise4D {
func get(_ point: SIMD4<Scalar>) -> Scalar {
zip(self._generators, 0..<self.octaves).map { layer, term in
let mul = Scalar(1 + term)
return layer.get(point * frequency * mul) / mul
}.reduce(0) { $0 + $1 } * amplitude
}
}

32
Sources/Voxelotl/Noise/PerlinNoiseGenerator.swift
View File

@ -1,18 +1,22 @@
import Foundation
public struct ImprovedPerlin<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D, CoherentNoise3D {
public struct ImprovedPerlin<Scalar: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D, CoherentNoise3D, CoherentNoiseRandomInit {
private let p: [Int16]
public init() {
self.init(permutation: defaultPermutation)
}
public init(permutation: [Int16]) {
assert(permutation.count == 0x100)
self.p = permutation
}
public init(random: inout any RandomProvider) {
public init<Random: RandomProvider>(random: inout Random) {
self.p = (0..<0x100).map { Int16($0) }.shuffled(using: &random)
}
public func get(_ point: SIMD2<T>) -> T {
public func get(_ point: SIMD2<Scalar>) -> Scalar {
// Find unit square
let idx = SIMD2(Int(floor(point.x)), Int(floor(point.y))) & 0xFF
// Find relative point in square
@ -37,7 +41,7 @@ public struct ImprovedPerlin<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise
grad(perm(bb), inner - .init(repeating: 1))))
}
public func get(_ point: SIMD3<T>) -> T {
public func get(_ point: SIMD3<Scalar>) -> Scalar {
// Find unit cube containg point
let idx = SIMD3(Int(floor(point.x)), Int(floor(point.y)), Int(floor(point.z))) & 0xFF
// Find relative point in cube
@ -74,9 +78,9 @@ public struct ImprovedPerlin<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise
@inline(__always) fileprivate func perm(_ x: Int) -> Int { Int(self.p[x & 0xFF]) }
@inline(__always) fileprivate func grad(_ hash: Int, _ point: SIMD2<T>) -> T { grad(hash, SIMD3(point, 0)) }
@inline(__always) fileprivate func grad(_ hash: Int, _ point: SIMD2<Scalar>) -> Scalar { grad(hash, SIMD3(point, 0)) }
fileprivate func grad(_ hash: Int, _ point: SIMD3<T>) -> T {
fileprivate func grad(_ hash: Int, _ point: SIMD3<Scalar>) -> Scalar {
// Convert low 4 bits of hash code into 12 gradient directions
let low4 = hash & 0xF
var u = low4 < 8 ? point.x : point.y
@ -86,3 +90,19 @@ public struct ImprovedPerlin<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise
return u + v
}
}
internal let defaultPermutation: [Int16] = [
151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,
8, 99,37,240,21,10,23,190, 6,148,247,120,234,75, 0,26,197,62,94,252,219,203,
117,35, 11,32,57,177,33, 88,237,149,56,87,174,20,125,136,171,168, 68,175,74,
165,71,134,139,48, 27,166,77,146,158,231,83,111,229,122, 60,211,133,230,220,
105,92,41,55,46,245,40,244,102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,
187,208, 89, 18,169,200,196,135,130,116,188,159, 86,164,100,109,198,173,186,
3,64,52,217,226,250,124,123, 5,202, 38,147,118,126,255,82,85,212,207,206,59,
227,47,16,58,17,182,189,28,42,223,183,170,213,119,248,152, 2,44,154,163, 70,
221,153,101,155,167, 43,172,9,129,22,39,253, 19, 98,108,110, 79,113,224,232,
178,185, 112,104,218,246,97,228,251, 34,242,193,238,210,144, 12,191,179,162,
241, 81,51,145,235,249,14,239,107,49,192,214, 31,181,199,106,157,184,84,204,
176,115,121,50,45,127, 4,150,254,138,236,205,93,222,114,67,29,24,72,243,141,
128,195,78,66,215,61,156,180
]

44
Sources/Voxelotl/Noise/SimplexNoise.swift
View File

@ -1,14 +1,14 @@
import Foundation
public struct SimplexNoise<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D, CoherentNoise3D, CoherentNoise4D {
public struct SimplexNoise<Scalar: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D, CoherentNoise3D, CoherentNoise4D, CoherentNoiseRandomInit {
private let p: [Int16], pMod12: [Int16]
private let grad3: [SIMD3<T>] = [
private let grad3: [SIMD3<Scalar>] = [
.init(1, 1, 0), .init(-1, 1, 0), .init(1, -1, 0), .init(-1, -1, 0),
.init(1, 0, 1), .init(-1, 0, 1), .init(1, 0, -1), .init(-1, 0, -1),
.init(0, 1, 1), .init( 0, -1, 1), .init(0, 1, -1), .init( 0, -1, -1)
]
private let grad4: [SIMD4<T>] = [
private let grad4: [SIMD4<Scalar>] = [
.init( 0, 1, 1, 1), .init( 0, 1, 1, -1), .init( 0, 1, -1, 1), .init( 0, 1, -1, -1),
.init( 0, -1, 1, 1), .init( 0, -1, 1, -1), .init( 0, -1, -1, 1), .init( 0, -1, -1, -1),
.init( 1, 0, 1, 1), .init( 1, 0, 1, -1), .init( 1, 0, -1, 1), .init( 1, 0, -1, -1),
@ -19,21 +19,25 @@ public struct SimplexNoise<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D
.init(-1, 1, 1, 0), .init(-1, 1, -1, 0), .init(-1, -1, 1, 0), .init(-1, -1, -1, 0)
]
public init() {
self.init(permutation: defaultPermutation)
}
public init(permutation: [Int16]) {
assert(permutation.count == 0x100)
self.p = permutation
self.pMod12 = self.p.map { $0 % 12 }
}
public init(random: inout any RandomProvider) {
public init<Random: RandomProvider>(random: inout Random) {
self.p = (0..<0x100).map { Int16($0) }.shuffled(using: &random)
self.pMod12 = self.p.map { $0 % 12 }
}
public func get(_ point: SIMD2<T>) -> T {
public func get(_ point: SIMD2<Scalar>) -> Scalar {
// Skew space into rhobuses to find which simplex cell we're in
let f2 = 0.5 * (T(3).squareRoot() - 1)
let g2 = (3 - T(3).squareRoot()) / 6
let f2 = 0.5 * (Scalar(3).squareRoot() - 1)
let g2 = (3 - Scalar(3).squareRoot()) / 6
let skewFactor = point.sum() * f2
let cellID = SIMD2(floor(point.x + skewFactor), floor(point.y + skewFactor))
let cellOrigin = cellID - (cellID.sum() * g2)
@ -42,7 +46,7 @@ public struct SimplexNoise<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D
// For the 2d case, the simplex shape is an equilateral triangle
// Determine which side of the rhombus on to find the simplex
let cornerOfs1: SIMD2<Int> = corner0.x > corner0.y ? .init(1, 0) : .init(0, 1)
let corner1 = corner0 - SIMD2<T>(cornerOfs1) + g2
let corner1 = corner0 - SIMD2<Scalar>(cornerOfs1) + g2
let corner2 = corner0 - 1 + 2 * g2
// Compute the hashed gradient indices of the three simplex corners
@ -52,7 +56,7 @@ public struct SimplexNoise<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D
let gradIndex2 = permMod12(cellHash.x + 1 + perm(cellHash.y + 1))
// Calculate the contribution from the three corners
@inline(__always) func cornerContribution(_ corner: SIMD2<T>, _ gradID: Int) -> T {
@inline(__always) func cornerContribution(_ corner: SIMD2<Scalar>, _ gradID: Int) -> Scalar {
var t = 0.5 - corner.x * corner.x - corner.y * corner.y
if t < 0 {
return 0
@ -68,9 +72,9 @@ public struct SimplexNoise<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D
return 70 * (noise0 + noise1 + noise2)
}
public func get(_ point: SIMD3<T>) -> T {
public func get(_ point: SIMD3<Scalar>) -> Scalar {
// Skew space into rhombohedrons to find which simplex cell we're in
let g3 = 1 / T(6), f3 = 1 / T(3)
let g3 = 1 / Scalar(6), f3 = 1 / Scalar(3)
let skewFactor = point.sum() * f3
let cellID = SIMD3(floor(point.x + skewFactor), floor(point.y + skewFactor), floor(point.z + skewFactor))
let cellOrigin = cellID - (cellID.sum() * g3)
@ -95,8 +99,8 @@ public struct SimplexNoise<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D
(.init(0, 1, 0), .init(1, 1, 0)) // Y X Z
}
}
let corner1 = corner0 - SIMD3<T>(corner1ID) + g3
let corner2 = corner0 - SIMD3<T>(corner2ID) + 2 * g3
let corner1 = corner0 - SIMD3<Scalar>(corner1ID) + g3
let corner2 = corner0 - SIMD3<Scalar>(corner2ID) + 2 * g3
let corner3 = corner0 - 1 + 3 * g3
// Compute the hashed gradient indices of the four simplex corners
@ -119,7 +123,7 @@ public struct SimplexNoise<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D
cellHash.z + 1)))
// Calculate the contribution from the four corners
@inline(__always) func cornerContribution(_ corner: SIMD3<T>, _ gradID: Int) -> T {
@inline(__always) func cornerContribution(_ corner: SIMD3<Scalar>, _ gradID: Int) -> Scalar {
var t = 0.6 - corner.x * corner.x - corner.y * corner.y - corner.z * corner.z
if t < 0 {
return 0
@ -136,8 +140,8 @@ public struct SimplexNoise<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D
return 32 * (noise0 + noise1 + noise2 + noise3)
}
public func get(_ point: SIMD4<T>) -> T {
let g4 = (5 - T(5).squareRoot()) / 20, f4 = (T(5).squareRoot() - 1) / 4
public func get(_ point: SIMD4<Scalar>) -> Scalar {
let g4 = (5 - Scalar(5).squareRoot()) / 20, f4 = (Scalar(5).squareRoot() - 1) / 4
let skewFactor = point.sum() * f4
let cellID = SIMD4(floor(point.x + skewFactor), floor(point.y + skewFactor), floor(point.z + skewFactor), floor(point.w + skewFactor))
let cellOrigin = cellID - (cellID.sum() * g4)
@ -157,9 +161,9 @@ public struct SimplexNoise<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D
let cornerOfs1 = SIMD4<Int>.zero.replacing(with: .one, where: rank .>= 3)
let cornerOfs2 = SIMD4<Int>.zero.replacing(with: .one, where: rank .>= 2)
let cornerOfs3 = SIMD4<Int>.zero.replacing(with: .one, where: rank .>= 1)
let corner1 = corner0 - SIMD4<T>(cornerOfs1) + g4
let corner2 = corner0 - SIMD4<T>(cornerOfs2) + 2 * g4
let corner3 = corner0 - SIMD4<T>(cornerOfs3) + 3 * g4
let corner1 = corner0 - SIMD4<Scalar>(cornerOfs1) + g4
let corner2 = corner0 - SIMD4<Scalar>(cornerOfs2) + 2 * g4
let corner3 = corner0 - SIMD4<Scalar>(cornerOfs3) + 3 * g4
let corner4 = corner0 - 1 + 4 * g4
// Compute the hashed gradient indices of the five simplex corners
@ -191,7 +195,7 @@ public struct SimplexNoise<T: BinaryFloatingPoint & SIMDScalar>: CoherentNoise2D
cellHash.w + 1))))) & 0x1F
// Calculate the contribution from the five corners
@inline(__always) func cornerContribution(_ corner: SIMD4<T>, _ gradID: Int) -> T {
@inline(__always) func cornerContribution(_ corner: SIMD4<Scalar>, _ gradID: Int) -> Scalar {
var t = corner.indices.reduce(0.6) { accum, i in accum - corner[i] * corner[i] }
if t < 0 {
return 0