Index

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

API symbols

AnyPoint:

• types: type AnyPoint

buildPermutations:

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

calculatePerm:

• common: proc calculatePerm(noise: Noise; coords: AnyPoint[int]): int

get:

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

grad:

• common: proc grad(hash: int; p: Point2D[float]): float
• common: proc grad(hash: int; p: Point3D[float]): float
• common: proc grad(hash: int; p: Point4D[float]): float

hash:

• common: proc hash(self: Noise; unit: AnyPoint[int]; u: AnyPoint[int]; pos: AnyPoint[float]): float
• common: proc hash(self: Noise; unit: AnyPoint[int]; u: AnyPoint[int]; pos: AnyPoint[float]; g: AnyPoint): float

i:

• types: proc i(point: AnyPoint): auto

j:

• types: proc j(point: AnyPoint): auto

k:

• types: proc k(point: Point3D): auto

mapIt:

• common: template mapIt[S: static int; T](point: Point[S, T]; 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: SomeNumber): float
• perlin: proc perlin(self: Noise; x, y, z: SomeNumber): float
• perlin: proc perlin(self: Noise; x, y, z, w: SomeNumber): float

perlin2:

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

perlin3:

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

perlin4:

• perlin: proc perlin4(self: Noise; point: Point4D[float]): float

persistence:

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

Point:

• types: type Point

Point2D:

• types: type Point2D

Point3D:

• types: type Point3D

Point4D:

• types: type Point4D

pureGet:

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

purePerlin:

• perlin: proc purePerlin(self: Noise; x, y: SomeNumber): float
• perlin: proc purePerlin(self: Noise; x, y, z: SomeNumber): float
• perlin: proc purePerlin(self: Noise; x, y, z, w: SomeNumber): float

pureSimplex:

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

randomSeed:

• perlin: proc randomSeed(): uint32

simplex:

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

simplex2:

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

simplex3:

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

w:

• types: proc w(point: Point4D): auto

x:

• types: proc x(point: AnyPoint): auto

y:

• types: proc y(point: AnyPoint): auto

z:

• types: proc z(point: Point3D | Point4D): auto

zipIt:

• common: template zipIt[S: static int; A, B](pointA: Point[S, A]; pointB: Point[S, B]; apply: untyped): untyped