Index

Modules: perlin, perlin/private/common, perlin/private/perlin, perlin/private/simplex, perlin/private/types.

API symbols

buildPermutations:

• types: proc buildPermutations(seed: uint32): array[0 .. 511, int]

get:

• perlin: proc get(self: Noise; typ: NoiseType; x, y: int | float): float
• perlin: proc get(self: Noise; typ: NoiseType; x, y, z: int | float): float

grad:

• common: proc grad(hash: int; x, y, z: float): float

hash:

• common: template hash(self: Noise; unit: Point2D[int]; ux, uy: untyped; pos: Point2D[float]; gx, gy: untyped): untyped
• common: template hash(self: Noise; unit: Point3D[int]; ux, uy, uz: untyped; pos: Point3D[float]; gx, gy, gz: untyped): untyped

map:

• common: template map(point: Point; apply: untyped): untyped

mapIt:

• common: template mapIt(point: Point; kind: typedesc; apply: untyped): untyped

newNoise:

• types: proc newNoise(): Noise
• types: proc newNoise(octaves: int; persistence: float): Noise
• types: proc newNoise(seed: uint32; octaves: int = 1; persistence: float = 0.5): Noise

Noise:

• types: object Noise

NoiseType:

• types: enum NoiseType

octaves:

• types: proc octaves(noise: Noise): auto

perlin:

• perlin: proc perlin(self: Noise; x, y: int | float): float
• perlin: proc perlin(self: Noise; x, y, z: int | float): float

perlin2:

• perlin: proc perlin2(self: Noise; point: Point2D[float]): float

perlin3:

• perlin: proc perlin3(self: Noise; point: Point3D[float]): float

persistence:

• types: proc persistence(noise: Noise): auto

Point:

• types: type Point

Point2D:

• types: tuple Point2D

Point3D:

• types: tuple Point3D

PointND:

• types: type PointND

pureGet:

• perlin: proc pureGet(self: Noise; typ: NoiseType; x, y: int | float): float
• perlin: proc pureGet(self: Noise; typ: NoiseType; x, y, z: int | float): float

purePerlin:

• perlin: proc purePerlin(self: Noise; x, y: int | float): float
• perlin: proc purePerlin(self: Noise; x, y, z: int | float): float

pureSimplex:

• perlin: proc pureSimplex(self: Noise; x, y: int | float): float
• perlin: proc pureSimplex(self: Noise; x, y, z: int | float): float

randomSeed:

• perlin: proc randomSeed(): uint32

simplex:

• perlin: proc simplex(self: Noise; x, y: int | float): float
• perlin: proc simplex(self: Noise; x, y, z: int | float): float

simplex2:

• simplex: proc simplex2(self: Noise; point: Point2D[float]): float

simplex3:

• simplex: proc simplex3(self: Noise; point: Point3D[float]): float