Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the cricket Reference Manual, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Apr 19 15:46:45 2021 GMT+0.
| • Introduction | What cricket is all about | |
| • Systems | The systems documentation | |
| • Modules | The modules documentation | |
| • Files | The files documentation | |
| • Packages | The packages documentation | |
| • Definitions | The symbols documentation | |
| • Indexes | Concepts, functions, variables and data types |
Cricket is a comprehensive suite of coherent noise algorithms and composable tools for manipulating them to create interesting procedurally-generated imagery and other creative applications.
Unlike its more random cousin, coherent noise has interesting properties that give it a smooth appearance. A coherent noise function is an N-arity function that emits a single scalar value as its output. All coherent noise functions exhibit the following properties:
The dimensionality of a coherent noise function is determined by how many input parameters it accepts. Since inputs to a coherent noise function could be driven from any source of data, and output values are coherent in each of the function's supported dimensions, one could feed image coordinates into a 3-dimensional coherent noise function's first two parameters, and an incrementing time value as the third parameter, in order to smoothly animate an image effect such as clouds, fire, landscapes, or anything else creativity dreams up.
Coherent noise functions are especially ubiquitous in applications where memory is scarce, and in game development where one wants to generate 2-dimensional textures or 3-dimensional objects without storing any large chunks of image or geometry data on disk.
Cricket started out as a collection of noise algorithms for use in game development, but evolved over time into a more general form I thought could be useful to others outside of that domain. It borrows a lot of its ideas from C++'s libnoise, but adds numerous enhancements, corrections, and additional noise algorithms.
Well, they are noisy!
In summary, you call a function depending on the coherent noise algorithm and dimensionality you
want to generate to create a "generator". A generator can then be sampled from with a #'sample
function, passing to it input coordinates for each of the generator's dimensional axes to sample by.
Also, there exist "modifiers", which, like generators, are created and sampled from in the same way. What makes modifiers special, is that they take samplers (generators or other modifiers) as inputs, allowing you to create complex pipelines that perform all sorts of processing of noise data.
Additionally, there are tools for conveniently working with entire regions of noise space in order to generate entire images effortlessly.
For usage instructions, see below.
Currently, Cricket supports the following:
(ql:quickload :cricket)
To run the unit tests, first ensure you have prove installed:
(ql:quickload :prove)
Then run the tests:
(asdf:test-system :cricket)
The following usage instructions assumes you have added the "cricket" system to your list of
dependencies, and is loaded and present in your Lisp image. It also assumes you are working in a
package that has a package-local nickname mapping the cricket package to c in an effort to keep
some of the example pipelines brief:
(defpackage #:my-package
(:local-nicknames (#:c #:cricket))
(:use #:cl))
(in-package #:my-package)
To get started, let's get a feel for how to create and sample from a generator for one of the supported noise algorithms. Perlin noise is a well-known algorithm so let's create a 2D Perlin generator and sample from it:
(let ((p2d (c:perlin-2d)))
(c:sample p2d 0.1d0 42.5d0))
To create a generator we simply call a function, and we can sample from it using any double-precision floating point values as input coordinates, corresponding to the dimensionality of the noise generator - in this case, we are using a 2-dimensional noise algorithm, so we supplied 2 input coordinates.
There is one potential problem with the above code though: every time we run it it will produce a
different output. Doesn't that conflict with the first property of coherent noise mentioned at the
top of this document? No, it doesn't. By not supplying any arguments to #'perlin-2d, we are
telling Cricket to randomly seed this generator's random number generator. All generators have a
random number generator, and it is how we can retrieve different results with the same input. We can
change this behavior by supplying our own seed value.
(let ((p2d (c:perlin-2d :seed "abc")))
(c:sample p2d 0.1d0 42.5d0))
Now, when we run this multiple times, we will always get the same answer, and this is guaranteed to produce the same answer on different Lisp implementations or operating systems. Truly portable synthesized images is a nice feature to have!
In summary, one creates a generator with a function whose name consists of the algorithm name,
followed by a hyphen, followed by the dimensionality. All generators take a :seed keyword
argument, which is used to seed its own random number generator.
Of note is that all generators take a seed argument, even ones that don't make use of any random numbers in their implementation. This is needed for modifiers, which we'll use to build upon this example next.
There are about a couple dozen modifiers, all located in the src/modifiers directory with
documentation strings to get a basic idea of how they operate. Let's use the "addition" (+)
modifier, to combine two different noise generators into a single value when sampled.
(let* ((p2d (c:perlin-2d :seed "abc"))
(p3d (c:perlin-3d :seed "def"))
(add (c:+ p2d p3d)))
(c:sample add 0.1d0 42.5d0 13.6d0))
Here, we created both a Perlin 2D and a Perlin 3D generator, then we used a modifier which takes 2
samplers as arguments and returns a new sampler. Then, we sampled from the new sampler in the same
way we did earlier. The result of the addition modifier is the same as if you were to sample from
both of the Perlin generators individually, and then called #'cl:+ on their results; it simply
adds the two results together to obtain a new result.
The important thing to realize here, is that both generators and modifiers are "samplers", and can
be sampled from in the same way with #'c:sample. The only difference between the two, is
generators do not take samplers as inputs (in most cases); they are leaf nodes in an arbitrarily
deep tree of samplers.
Once we have more than a few modifiers in a sampler tree, it gets very messy:
(let ((tree (c:turbulence
(c:fractalize
(c:uniform-scale
(c:perlin-3d :seed "example") 1.5)
:fbm :frequency 1.3 :octaves 6 :lacunarity 3 :persistence 0.22)
(c:open-simplex-3d :seed "foo") :power 1.2 :roughness 4)))
(c:sample tree 0.1d0 42.5d0 13.5d0))
Cricket re-exports the -> arrow macro from arrow-macros
that can help us here. Rewriting the last sampler tree using the -> operator looks like this:
(c:-> (c:perlin-3d :seed "example")
(c:uniform-scale 1.5)
(c:fractalize :fbm :frequency 1.3 :octaves 6 :lacunarity 3 :persistence 0.22)
(c:turbulence (c:open-simplex-3d :seed "foo") :power 1.2 :roughness 4)
(c:sample 0.1d0 42.5d0 13.6d0))
That is much easier to read, and working with this library you'll likely be creating much more complex sampler trees.
So far, we've only sampled from a sampler once, but to create an image, we'd want to do that for each pixel of the image. Cricket has convenient tools to process arrays of noise values.
First, let's slightly modify our last complex sampler tree to add one more step at the end, which will generate an array of all the sampled outputs over a 2-dimensional area:
(c:-> (c:perlin-3d :seed "example")
(c:uniform-scale 1.5)
(c:fractalize :fbm :frequency 1.3 :octaves 6 :lacunarity 3 :persistence 0.22)
(c:turbulence (c:open-simplex-3d :seed "foo") :power 1.2 :roughness 4)
(c:make-map :width 1024 :height 1024))
Here, we removed the call to #'c:sample and replaced it with a call to #'c:make-map. This
function takes a width and height and returns an object containing an array of all sampled output
values for each X/Y coordinate pair. This data structure is called a "map", and it can be used on
its own, or processed further by other functions. For example, let's add one more function to our
pipeline:
(c:-> (c:perlin-3d :seed "example")
(c:uniform-scale 1.5)
(c:fractalize :fbm :frequency 1.3 :octaves 6 :lacunarity 3 :persistence 0.22)
(c:turbulence (c:open-simplex-3d :seed "foo") :power 1.2 :roughness 4)
(c:make-map :width 1024 :height 1024)
(c:render-map))
Here #'c:render-map takes the previously constructed map as its input, and returns an "image",
which is an object containing an array of RGBA pixel colors, that can then be inspected or written
to disk as an image format we can view in an image viewing application. To write the image object to
an image file on disk, we can add one more call to our pipeline:
(c:-> (c:perlin-3d :seed "example")
(c:uniform-scale 1.5)
(c:fractalize :fbm :frequency 1.3 :octaves 6 :lacunarity 3 :persistence 0.22)
(c:turbulence (c:open-simplex-3d :seed "foo") :power 1.2 :roughness 4)
(c:make-map :width 1024 :height 1024)
(c:render-map)
(c:write-image "/tmp/example.png"))
This will process the image object and write it to a PNG image file on disk. You can now go ahead and open it up in your image viewing application. It should look like this:
Pretty nice, although it is a bit boring. We could add some color to it bring out the texture.
Cricket includes a few gradients that we can apply when rendering a map with #'c:render-map. You
can also define your own with define-gradient, but for now, let's use the built-in :terrain
gradient, to try to make this look like some terrain. Modify the call to #'c:render-map like so:
(c:-> (c:perlin-3d :seed "example")
(c:uniform-scale 1.5)
(c:fractalize :fbm :frequency 1.3 :octaves 6 :lacunarity 3 :persistence 0.22)
(c:turbulence (c:open-simplex-3d :seed "foo") :power 1.2 :roughness 4)
(c:make-map :width 1024 :height 1024)
(c:render-map :gradient :terrain)
(c:write-image "/tmp/example.png"))
Now our generated image looks like this:
This concludes the basic overview of working with Cricket. More extensive documentation is on the list of things to add, but for now, if you have any questions or requests, please feel free to send me an email or contact me on the usual forums.
Copyright © Michael Fiano mail@mfiano.net.
Licensed under the MIT License.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The cricket system |
Michael Fiano <mail@mfiano.net>
MIT
A library for generating and manipulating coherent noise
cricket.asd (file)
Modules are listed depth-first from the system components tree.
| • The cricket/generators module | ||
| • The cricket/modifiers module | ||
| • The cricket/map module |
Next: The cricket/modifiers module, Previous: Modules, Up: Modules [Contents][Index]
common.lisp (file)
cricket (system)
generators/
Next: The cricket/map module, Previous: The cricket/generators module, Up: Modules [Contents][Index]
generators (module)
cricket (system)
modifiers/
Previous: The cricket/modifiers module, Up: Modules [Contents][Index]
modifiers (module)
cricket (system)
map/
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
Next: The cricket/package․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
/home/quickref/quicklisp/dists/quicklisp/software/cricket-20210411-git/cricket.asd
cricket (system)
Next: The cricket/conditions․lisp file, Previous: The cricket․asd file, Up: Lisp files [Contents][Index]
cricket (system)
package.lisp
Next: The cricket/common․lisp file, Previous: The cricket/package․lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
cricket (system)
conditions.lisp
Next: The cricket/generators/perlin-1d․lisp file, Previous: The cricket/conditions․lisp file, Up: Lisp files [Contents][Index]
conditions.lisp (file)
cricket (system)
common.lisp
Next: The cricket/generators/perlin-2d․lisp file, Previous: The cricket/common․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/perlin-1d.lisp
Next: The cricket/generators/perlin-3d․lisp file, Previous: The cricket/generators/perlin-1d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/perlin-2d.lisp
Next: The cricket/generators/perlin-4d․lisp file, Previous: The cricket/generators/perlin-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/perlin-3d.lisp
Next: The cricket/generators/simplex-1d․lisp file, Previous: The cricket/generators/perlin-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/perlin-4d.lisp
Next: The cricket/generators/simplex-2d․lisp file, Previous: The cricket/generators/perlin-4d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/simplex-1d.lisp
Next: The cricket/generators/simplex-3d․lisp file, Previous: The cricket/generators/simplex-1d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/simplex-2d.lisp
Next: The cricket/generators/simplex-4d․lisp file, Previous: The cricket/generators/simplex-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/simplex-3d.lisp
Next: The cricket/generators/open-simplex-2d․lisp file, Previous: The cricket/generators/simplex-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/simplex-4d.lisp
Next: The cricket/generators/open-simplex-3d․lisp file, Previous: The cricket/generators/simplex-4d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/open-simplex-2d.lisp
Next: The cricket/generators/open-simplex-4d․lisp file, Previous: The cricket/generators/open-simplex-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/open-simplex-3d.lisp
Next: The cricket/generators/open-simplex2f-2d․lisp file, Previous: The cricket/generators/open-simplex-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/open-simplex-4d.lisp
Next: The cricket/generators/open-simplex2f-3d․lisp file, Previous: The cricket/generators/open-simplex-4d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/open-simplex2f-2d.lisp
Next: The cricket/generators/open-simplex2f-4d․lisp file, Previous: The cricket/generators/open-simplex2f-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/open-simplex2f-3d.lisp
Next: The cricket/generators/open-simplex2s-2d․lisp file, Previous: The cricket/generators/open-simplex2f-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/open-simplex2f-4d.lisp
Next: The cricket/generators/open-simplex2s-3d․lisp file, Previous: The cricket/generators/open-simplex2f-4d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/open-simplex2s-2d.lisp
Next: The cricket/generators/open-simplex2s-4d․lisp file, Previous: The cricket/generators/open-simplex2s-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/open-simplex2s-3d.lisp
Next: The cricket/generators/value-2d․lisp file, Previous: The cricket/generators/open-simplex2s-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/open-simplex2s-4d.lisp
Next: The cricket/generators/value-3d․lisp file, Previous: The cricket/generators/open-simplex2s-4d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/value-2d.lisp
Next: The cricket/generators/cellular-2d․lisp file, Previous: The cricket/generators/value-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/value-3d.lisp
Next: The cricket/generators/cellular-3d․lisp file, Previous: The cricket/generators/value-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/cellular-2d.lisp
Next: The cricket/generators/cylinders-3d․lisp file, Previous: The cricket/generators/cellular-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/cellular-3d.lisp
Next: The cricket/generators/spheres-3d․lisp file, Previous: The cricket/generators/cellular-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/cylinders-3d.lisp
Next: The cricket/generators/checker-2d․lisp file, Previous: The cricket/generators/cylinders-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/spheres-3d.lisp
Next: The cricket/generators/constant․lisp file, Previous: The cricket/generators/spheres-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/checker-2d.lisp
Next: The cricket/generators/fbm-2d․lisp file, Previous: The cricket/generators/checker-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/constant.lisp
Next: The cricket/generators/fbm-3d․lisp file, Previous: The cricket/generators/constant․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/fbm-2d.lisp
Next: The cricket/generators/fbm-4d․lisp file, Previous: The cricket/generators/fbm-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/fbm-3d.lisp
Next: The cricket/generators/billow-2d․lisp file, Previous: The cricket/generators/fbm-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/fbm-4d.lisp
Next: The cricket/generators/billow-3d․lisp file, Previous: The cricket/generators/fbm-4d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/billow-2d.lisp
Next: The cricket/generators/billow-4d․lisp file, Previous: The cricket/generators/billow-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/billow-3d.lisp
Next: The cricket/generators/multifractal-2d․lisp file, Previous: The cricket/generators/billow-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/billow-4d.lisp
Next: The cricket/generators/multifractal-3d․lisp file, Previous: The cricket/generators/billow-4d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/multifractal-2d.lisp
Next: The cricket/generators/multifractal-4d․lisp file, Previous: The cricket/generators/multifractal-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/multifractal-3d.lisp
Next: The cricket/generators/hybrid-multifractal-2d․lisp file, Previous: The cricket/generators/multifractal-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/multifractal-4d.lisp
Next: The cricket/generators/hybrid-multifractal-3d․lisp file, Previous: The cricket/generators/multifractal-4d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/hybrid-multifractal-2d.lisp
Next: The cricket/generators/hybrid-multifractal-4d․lisp file, Previous: The cricket/generators/hybrid-multifractal-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/hybrid-multifractal-3d.lisp
Next: The cricket/generators/ridged-multifractal-2d․lisp file, Previous: The cricket/generators/hybrid-multifractal-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/hybrid-multifractal-4d.lisp
Next: The cricket/generators/ridged-multifractal-3d․lisp file, Previous: The cricket/generators/hybrid-multifractal-4d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/ridged-multifractal-2d.lisp
Next: The cricket/generators/ridged-multifractal-4d․lisp file, Previous: The cricket/generators/ridged-multifractal-2d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/ridged-multifractal-3d.lisp
Next: The cricket/modifiers/abs․lisp file, Previous: The cricket/generators/ridged-multifractal-3d․lisp file, Up: Lisp files [Contents][Index]
generators (module)
generators/ridged-multifractal-4d.lisp
Next: The cricket/modifiers/add․lisp file, Previous: The cricket/generators/ridged-multifractal-4d․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/abs.lisp
Next: The cricket/modifiers/blend․lisp file, Previous: The cricket/modifiers/abs․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/add.lisp
Next: The cricket/modifiers/cache․lisp file, Previous: The cricket/modifiers/add․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/blend.lisp
Next: The cricket/modifiers/clamp․lisp file, Previous: The cricket/modifiers/blend․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/cache.lisp
Next: The cricket/modifiers/curve․lisp file, Previous: The cricket/modifiers/cache․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/clamp.lisp
Next: The cricket/modifiers/displace․lisp file, Previous: The cricket/modifiers/clamp․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/curve.lisp
Next: The cricket/modifiers/divide․lisp file, Previous: The cricket/modifiers/curve․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/displace.lisp
Next: The cricket/modifiers/expt․lisp file, Previous: The cricket/modifiers/displace․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/divide.lisp
Next: The cricket/modifiers/fractalize․lisp file, Previous: The cricket/modifiers/divide․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/expt.lisp
Next: The cricket/modifiers/max․lisp file, Previous: The cricket/modifiers/expt․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/fractalize.lisp
fractalize (function)
Next: The cricket/modifiers/min․lisp file, Previous: The cricket/modifiers/fractalize․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/max.lisp
Next: The cricket/modifiers/negate․lisp file, Previous: The cricket/modifiers/max․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/min.lisp
Next: The cricket/modifiers/multiply․lisp file, Previous: The cricket/modifiers/min․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/negate.lisp
Next: The cricket/modifiers/power․lisp file, Previous: The cricket/modifiers/negate․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/multiply.lisp
Next: The cricket/modifiers/rotate․lisp file, Previous: The cricket/modifiers/multiply․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/power.lisp
Next: The cricket/modifiers/scale․lisp file, Previous: The cricket/modifiers/power․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/rotate.lisp
Next: The cricket/modifiers/select․lisp file, Previous: The cricket/modifiers/rotate․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/scale.lisp
Next: The cricket/modifiers/strengthen․lisp file, Previous: The cricket/modifiers/scale․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/select.lisp
Next: The cricket/modifiers/subtract․lisp file, Previous: The cricket/modifiers/select․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/strengthen.lisp
Next: The cricket/modifiers/terrace․lisp file, Previous: The cricket/modifiers/strengthen․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/subtract.lisp
Next: The cricket/modifiers/translate․lisp file, Previous: The cricket/modifiers/subtract․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/terrace.lisp
Next: The cricket/modifiers/turbulence․lisp file, Previous: The cricket/modifiers/terrace․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/translate.lisp
Next: The cricket/map/color․lisp file, Previous: The cricket/modifiers/translate․lisp file, Up: Lisp files [Contents][Index]
modifiers (module)
modifiers/turbulence.lisp
Next: The cricket/map/gradient․lisp file, Previous: The cricket/modifiers/turbulence․lisp file, Up: Lisp files [Contents][Index]
map (module)
map/color.lisp
Next: The cricket/map/image․lisp file, Previous: The cricket/map/color․lisp file, Up: Lisp files [Contents][Index]
map (module)
map/gradient.lisp
define-gradient (macro)
Next: The cricket/map/map․lisp file, Previous: The cricket/map/gradient․lisp file, Up: Lisp files [Contents][Index]
map (module)
map/image.lisp
Previous: The cricket/map/image․lisp file, Up: Lisp files [Contents][Index]
map (module)
map/map.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
Next: The cricket package, Previous: Packages, Up: Packages [Contents][Index]
package.lisp (file)
Next: The %cricket․modifiers package, Previous: The %cricket․generators package, Up: Packages [Contents][Index]
package.lisp (file)
Next: The %cricket․internal package, Previous: The cricket package, Up: Packages [Contents][Index]
package.lisp (file)
Next: The %cricket․map package, Previous: The %cricket․modifiers package, Up: Packages [Contents][Index]
package.lisp (file)
common-lisp
Next: The %cricket․generators․perlin-1d package, Previous: The %cricket․internal package, Up: Packages [Contents][Index]
package.lisp (file)
common-lisp
Next: The %cricket․generators․perlin-2d package, Previous: The %cricket․map package, Up: Packages [Contents][Index]
perlin-1d.lisp (file)
common-lisp
Next: The %cricket․generators․perlin-3d package, Previous: The %cricket․generators․perlin-1d package, Up: Packages [Contents][Index]
perlin-2d.lisp (file)
common-lisp
Next: The %cricket․generators․perlin-4d package, Previous: The %cricket․generators․perlin-2d package, Up: Packages [Contents][Index]
perlin-3d.lisp (file)
common-lisp
Next: The %cricket․generators․simplex-1d package, Previous: The %cricket․generators․perlin-3d package, Up: Packages [Contents][Index]
perlin-4d.lisp (file)
common-lisp
Next: The %cricket․generators․simplex-2d package, Previous: The %cricket․generators․perlin-4d package, Up: Packages [Contents][Index]
simplex-1d.lisp (file)
common-lisp
Next: The %cricket․generators․simplex-3d package, Previous: The %cricket․generators․simplex-1d package, Up: Packages [Contents][Index]
simplex-2d.lisp (file)
common-lisp
Next: The %cricket․generators․simplex-4d package, Previous: The %cricket․generators․simplex-2d package, Up: Packages [Contents][Index]
simplex-3d.lisp (file)
common-lisp
Next: The %cricket․generators․open-simplex-2d package, Previous: The %cricket․generators․simplex-3d package, Up: Packages [Contents][Index]
simplex-4d.lisp (file)
common-lisp
Next: The %cricket․generators․open-simplex-3d package, Previous: The %cricket․generators․simplex-4d package, Up: Packages [Contents][Index]
open-simplex-2d.lisp (file)
common-lisp
Next: The %cricket․generators․open-simplex-4d package, Previous: The %cricket․generators․open-simplex-2d package, Up: Packages [Contents][Index]
open-simplex-3d.lisp (file)
common-lisp
Next: The %cricket․generators․open-simplex2f-2d package, Previous: The %cricket․generators․open-simplex-3d package, Up: Packages [Contents][Index]
open-simplex-4d.lisp (file)
common-lisp
Next: The %cricket․generators․open-simplex2f-3d package, Previous: The %cricket․generators․open-simplex-4d package, Up: Packages [Contents][Index]
open-simplex2f-2d.lisp (file)
common-lisp
Next: The %cricket․generators․open-simplex2f-4d package, Previous: The %cricket․generators․open-simplex2f-2d package, Up: Packages [Contents][Index]
open-simplex2f-3d.lisp (file)
common-lisp
Next: The %cricket․generators․open-simplex2s-2d package, Previous: The %cricket․generators․open-simplex2f-3d package, Up: Packages [Contents][Index]
open-simplex2f-4d.lisp (file)
common-lisp
Next: The %cricket․generators․open-simplex2s-3d package, Previous: The %cricket․generators․open-simplex2f-4d package, Up: Packages [Contents][Index]
open-simplex2s-2d.lisp (file)
common-lisp
Next: The %cricket․generators․open-simplex2s-4d package, Previous: The %cricket․generators․open-simplex2s-2d package, Up: Packages [Contents][Index]
open-simplex2s-3d.lisp (file)
common-lisp
Next: The %cricket․generators․value-2d package, Previous: The %cricket․generators․open-simplex2s-3d package, Up: Packages [Contents][Index]
open-simplex2s-4d.lisp (file)
common-lisp
Next: The %cricket․generators․value-3d package, Previous: The %cricket․generators․open-simplex2s-4d package, Up: Packages [Contents][Index]
value-2d.lisp (file)
common-lisp
Next: The %cricket․generators․cellular-2d package, Previous: The %cricket․generators․value-2d package, Up: Packages [Contents][Index]
value-3d.lisp (file)
common-lisp
Next: The %cricket․generators․cellular-3d package, Previous: The %cricket․generators․value-3d package, Up: Packages [Contents][Index]
cellular-2d.lisp (file)
common-lisp
Next: The %cricket․generators․cylinders-3d package, Previous: The %cricket․generators․cellular-2d package, Up: Packages [Contents][Index]
cellular-3d.lisp (file)
common-lisp
Next: The %cricket․generators․spheres-3d package, Previous: The %cricket․generators․cellular-3d package, Up: Packages [Contents][Index]
cylinders-3d.lisp (file)
common-lisp
Next: The %cricket․generators․checker-2d package, Previous: The %cricket․generators․cylinders-3d package, Up: Packages [Contents][Index]
spheres-3d.lisp (file)
common-lisp
Next: The %cricket․generators․constant package, Previous: The %cricket․generators․spheres-3d package, Up: Packages [Contents][Index]
checker-2d.lisp (file)
common-lisp
Next: The %cricket․generators․fbm-2d package, Previous: The %cricket․generators․checker-2d package, Up: Packages [Contents][Index]
constant.lisp (file)
common-lisp
Next: The %cricket․generators․fbm-3d package, Previous: The %cricket․generators․constant package, Up: Packages [Contents][Index]
fbm-2d.lisp (file)
common-lisp
Next: The %cricket․generators․fbm-4d package, Previous: The %cricket․generators․fbm-2d package, Up: Packages [Contents][Index]
fbm-3d.lisp (file)
common-lisp
Next: The %cricket․generators․billow-2d package, Previous: The %cricket․generators․fbm-3d package, Up: Packages [Contents][Index]
fbm-4d.lisp (file)
common-lisp
Next: The %cricket․generators․billow-3d package, Previous: The %cricket․generators․fbm-4d package, Up: Packages [Contents][Index]
billow-2d.lisp (file)
common-lisp
Next: The %cricket․generators․billow-4d package, Previous: The %cricket․generators․billow-2d package, Up: Packages [Contents][Index]
billow-3d.lisp (file)
common-lisp
Next: The %cricket․generators․multifractal-2d package, Previous: The %cricket․generators․billow-3d package, Up: Packages [Contents][Index]
billow-4d.lisp (file)
common-lisp
Next: The %cricket․generators․multifractal-3d package, Previous: The %cricket․generators․billow-4d package, Up: Packages [Contents][Index]
multifractal-2d.lisp (file)
common-lisp
Next: The %cricket․generators․multifractal-4d package, Previous: The %cricket․generators․multifractal-2d package, Up: Packages [Contents][Index]
multifractal-3d.lisp (file)
common-lisp
Next: The %cricket․generators․hybrid-multifractal-2d package, Previous: The %cricket․generators․multifractal-3d package, Up: Packages [Contents][Index]
multifractal-4d.lisp (file)
common-lisp
Next: The %cricket․generators․hybrid-multifractal-3d package, Previous: The %cricket․generators․multifractal-4d package, Up: Packages [Contents][Index]
hybrid-multifractal-2d.lisp (file)
common-lisp
Next: The %cricket․generators․hybrid-multifractal-4d package, Previous: The %cricket․generators․hybrid-multifractal-2d package, Up: Packages [Contents][Index]
hybrid-multifractal-3d.lisp (file)
common-lisp
Next: The %cricket․generators․ridged-multifractal-2d package, Previous: The %cricket․generators․hybrid-multifractal-3d package, Up: Packages [Contents][Index]
hybrid-multifractal-4d.lisp (file)
common-lisp
Next: The %cricket․generators․ridged-multifractal-3d package, Previous: The %cricket․generators․hybrid-multifractal-4d package, Up: Packages [Contents][Index]
ridged-multifractal-2d.lisp (file)
common-lisp
Next: The %cricket․generators․ridged-multifractal-4d package, Previous: The %cricket․generators․ridged-multifractal-2d package, Up: Packages [Contents][Index]
ridged-multifractal-3d.lisp (file)
common-lisp
Next: The %cricket․modifiers․abs package, Previous: The %cricket․generators․ridged-multifractal-3d package, Up: Packages [Contents][Index]
ridged-multifractal-4d.lisp (file)
common-lisp
Next: The %cricket․modifiers․add package, Previous: The %cricket․generators․ridged-multifractal-4d package, Up: Packages [Contents][Index]
abs.lisp (file)
common-lisp
Next: The %cricket․modifiers․blend package, Previous: The %cricket․modifiers․abs package, Up: Packages [Contents][Index]
add.lisp (file)
common-lisp
Next: The %cricket․modifiers․cache package, Previous: The %cricket․modifiers․add package, Up: Packages [Contents][Index]
blend.lisp (file)
common-lisp
Next: The %cricket․modifiers․clamp package, Previous: The %cricket․modifiers․blend package, Up: Packages [Contents][Index]
cache.lisp (file)
common-lisp
Next: The %cricket․modifiers․curve package, Previous: The %cricket․modifiers․cache package, Up: Packages [Contents][Index]
clamp.lisp (file)
common-lisp
Next: The %cricket․modifiers․displace package, Previous: The %cricket․modifiers․clamp package, Up: Packages [Contents][Index]
curve.lisp (file)
common-lisp
Next: The %cricket․modifiers․divide package, Previous: The %cricket․modifiers․curve package, Up: Packages [Contents][Index]
displace.lisp (file)
common-lisp
Next: The %cricket․modifiers․expt package, Previous: The %cricket․modifiers․displace package, Up: Packages [Contents][Index]
divide.lisp (file)
common-lisp
Next: The %cricket․modifiers․fractalize package, Previous: The %cricket․modifiers․divide package, Up: Packages [Contents][Index]
expt.lisp (file)
common-lisp
Next: The %cricket․modifiers․max package, Previous: The %cricket․modifiers․expt package, Up: Packages [Contents][Index]
fractalize.lisp (file)
common-lisp
Next: The %cricket․modifiers․min package, Previous: The %cricket․modifiers․fractalize package, Up: Packages [Contents][Index]
max.lisp (file)
common-lisp
Next: The %cricket․modifiers․negate package, Previous: The %cricket․modifiers․max package, Up: Packages [Contents][Index]
min.lisp (file)
common-lisp
Next: The %cricket․modifiers․multiply package, Previous: The %cricket․modifiers․min package, Up: Packages [Contents][Index]
negate.lisp (file)
common-lisp
Next: The %cricket․modifiers․power package, Previous: The %cricket․modifiers․negate package, Up: Packages [Contents][Index]
multiply.lisp (file)
common-lisp
Next: The %cricket․modifiers․rotate package, Previous: The %cricket․modifiers․multiply package, Up: Packages [Contents][Index]
power.lisp (file)
common-lisp
Next: The %cricket․modifiers․scale package, Previous: The %cricket․modifiers․power package, Up: Packages [Contents][Index]
rotate.lisp (file)
common-lisp
Next: The %cricket․modifiers․select package, Previous: The %cricket․modifiers․rotate package, Up: Packages [Contents][Index]
scale.lisp (file)
common-lisp
Next: The %cricket․modifiers․strengthen package, Previous: The %cricket․modifiers․scale package, Up: Packages [Contents][Index]
select.lisp (file)
common-lisp
Next: The %cricket․modifiers․subtract package, Previous: The %cricket․modifiers․select package, Up: Packages [Contents][Index]
strengthen.lisp (file)
common-lisp
Next: The %cricket․modifiers․terrace package, Previous: The %cricket․modifiers․strengthen package, Up: Packages [Contents][Index]
subtract.lisp (file)
common-lisp
Next: The %cricket․modifiers․translate package, Previous: The %cricket․modifiers․subtract package, Up: Packages [Contents][Index]
terrace.lisp (file)
common-lisp
Next: The %cricket․modifiers․turbulence package, Previous: The %cricket․modifiers․terrace package, Up: Packages [Contents][Index]
translate.lisp (file)
common-lisp
Previous: The %cricket․modifiers․translate package, Up: Packages [Contents][Index]
turbulence.lisp (file)
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions | ||
| • Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported macros | ||
| • Exported functions | ||
| • Exported generic functions | ||
| • Exported conditions | ||
| • Exported structures |
Next: Exported functions, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
gradient.lisp (file)
Next: Exported generic functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
Construct a sampler that, when sampled, outputs the result of multiplying the outputs of
‘source1‘ and ‘source2‘.
‘source1‘: The first input sampler (required).
‘source2‘: The second input sampler (required).
multiply.lisp (file)
Construct a sampler that, when sampled, outputs the result of adding the outputs of ‘source1‘ and
‘source2‘.
‘source1‘: The first input sampler (required).
‘source2‘: The second input sampler (required).
add.lisp (file)
Construct a sampler that, when sampled, outputs the result of subtracting the output ‘source2‘
from the output of ‘source1‘.
‘source1‘: The first input sampler (required).
‘source2‘: The second input sampler (required).
subtract.lisp (file)
Construct a sampler that, when sampled, outputs the result of dividing the output ‘source1‘ by
the output of ‘source2‘.
‘source1‘: The first input sampler (required).
‘source2‘: The second input sampler (required).
divide.lisp (file)
Construct a sampler that, when sampled, outputs the absolute value of the output of ‘source‘.
‘source‘: The input sampler (required).
abs.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
2-dimensional billow fractal noise, using the supplied ‘generator‘ function to construct each
octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 2-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-2d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.5).
billow-2d.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
3-dimensional billow fractal noise, using the supplied ‘generator‘ function to construct each
octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 3-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-3d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.5).
billow-3d.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
4-dimensional billow fractal noise, using the supplied ‘generator‘ function to construct each
octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 4-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-4d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.5).
billow-4d.lisp (file)
Construct a sampler that, when sampled, outputs a blend between the outputs of ‘source1‘ and
‘source2‘, by means of a linear interpolation using the output value of ‘control‘ as the
interpolation parameter.
If the output of ‘control‘ is negative, the blended output is weighted towards the output of
‘source1‘. If the output of ‘control‘ is positive, the blended output is weighted towards the output
of ‘source2‘.
‘source1‘: The sampler to weight towards if the output of ‘control‘ is negative (required).
‘source2‘: The sampler to weight towards if the output of ‘control‘ is positive (required).
‘control‘: The sampler that determines the weight of the blending operation (required).
blend.lisp (file)
Construct a sampler that, when sampled, caches the set of input coordinates and the output of its
input sampler. If a set of input coordinates differs from the previous input coordinates, the cache
is invalidated and the new input coordinates and output value is cached.
Caching is useful if a sampler is used as a source for multiple modifiers. Without caching, the
duplicated input sources would redundantly compute the same outputs, which would be expensive,
especially if long modifier chains are shared.
‘source‘: The sampler to cache (required).
cache.lisp (file)
Construct a sampler that, when sampled, outputs 2-dimensional cellular noise values ranging from
-1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘distance-method‘: One of ‘:manhattan‘, ‘:euclidean‘, ‘:euclidean-squared‘, ‘:chebyshev‘, or
‘:minkowski4‘, denoting the distance function to use (optional, default: ‘:euclidean‘).
‘output-type‘: One of ‘:value‘, ‘:f1‘, ‘:f2‘, ‘:f1+f2‘, ‘:f2-f1‘, ‘:f1*f2‘, or ‘:f1/f2‘ denoting the
features to use (optional, default: ‘:f1‘).
‘jitter‘: A real number between 0.0 and 1.0, with values closer to one randomly distributing cells away from their grid alignment (optional, default: 1.0).
cellular-2d.lisp (file)
Construct a sampler that, when sampled, outputs 3-dimensional cellular noise values ranging from
-1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘distance-method‘: One of ‘:manhattan‘, ‘:euclidean‘, ‘:euclidean-squared‘, ‘:chebyshev‘, or
‘:minkowski4‘, denoting the distance function to use (optional, default: ‘:euclidean‘).
‘output-type‘: One of ‘:value‘, ‘:f1‘, ‘:f2‘, ‘:f1+f2‘, ‘:f2-f1‘, ‘:f1*f2‘, or ‘:f1/f2‘ denoting the
features to use (optional, default: ‘:f1‘).
‘jitter‘: A real number between 0.0 and 1.0, with values closer to one randomly distributing cells away from their grid alignment (optional, default: 1.0).
cellular-3d.lisp (file)
Construct a sampler that, when sampled, outputs a 2-dimensional checkered grid pattern, with
values being either -1.0 or 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
checker-2d.lisp (file)
Construct a sampler that, when sampled, clamps the output of ‘source‘ to be within the range
‘min‘..‘max‘. If the output of ‘source‘ is less than ‘min‘, the result will be ‘min‘. If the output
of ‘source‘ is greater than ‘max‘, the result will be ‘max‘.
‘source‘: The input sampler to clamp (required).
‘min‘: A real number denoting the lower bound of the clamping range (required).
‘max‘: A real number denoting the upper bound of the clamping range (required).
clamp.lisp (file)
Construct a sampler that, when sampled, outputs the constant ‘value‘ supplied. This is useful for
debugging and applications where you need to combine a constant value.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
constant.lisp (file)
Construct a sampler that, when sampled, outputs the result of sampling from ‘source‘ after
remapping to an arbitrary curve.
The curve is defined by a list of point pairs given with ‘points‘, with its format being a list of
cons cells. Each cons cell in the list of points represents an input and an output number. The curve
is a cubic spline, and so ‘points‘ must contain a list of four point pairs at a minimum.
Additionally, no two point pairs can contain the same input point value.
When sampling the input sampler ‘source‘, the result is evaluated using the curve data, and maps it
to a new output value.
‘source‘: The input sampler to map onto the curve (required).
‘points‘: A list of cons pairs denoting input (car) and output (cdr) control points of the curve (required).
curve.lisp (file)
Construct a sampler that, when sampled, outputs 3-dimensional concentric cylinder values ranging
from -1.0 to 1.0. The cylinders are oriented with their length along the Z axis.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘frequency‘: The frequency of the signal, which controls how small or large the cylinders are (optional, default: 1.0).
cylinders-3d.lisp (file)
Construct a sampler that, when sampled, modifies the input coordinates of its input sampler
‘source‘, before sampling from it. ‘x‘, ‘y‘, ‘z‘, and ‘w‘ are samplers, where the result of sampling
from them are added to the input coordinate of the corresponding axis. After modifying of the input
coordinates, ‘source‘ is then sampled with the new input coordinate set. Any displacement samplers
that are not specified will not displace the corresponding axis of the input sampler.
‘source‘: The input sampler to displace (required).
‘x‘: A sampler that is evaluated and added to the X axis input coordinate of ‘source‘ (optional).
‘y‘: A sampler that is evaluated and added to the Y axis input coordinate of ‘source‘ (optional).
‘z‘: A sampler that is evaluated and added to the Z axis input coordinate of ‘source‘ (optional).
‘w‘: A sampler that is evaluated and added to the W axis input coordinate of ‘source‘ (optional).
displace.lisp (file)
Construct a sampler that, when sampled, raises the power of the output of ‘source‘ to ‘power‘.
‘source‘: The input sampler (required).
‘power‘: The power to raise the output to (required).
expt.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
2-dimensional fractional Brownian motion noise, using the supplied ‘generator‘ function to construct
each octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 2-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2f-2d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.5).
fbm-2d.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
3-dimensional fractional Brownian motion noise, using the supplied ‘generator‘ function to construct
each octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 3-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2f-3d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.5).
fbm-3d.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
4-dimensional fractional Brownian motion noise, using the supplied ‘generator‘ function to construct
each octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 4-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2f-4d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.5).
fbm-4d.lisp (file)
Construct a sampler that, when sampled, outputs the result of fractalizing its input sampler’s
output over an arbitrary number of octaves. ‘type‘ may be a keyword denoting any of the built-in
generator fractal types:
‘:fbm‘: Fractional Brownian motion.
‘:billow‘: Creates billowy cloud or rock-like formations.
‘:multi‘: Multifractal whose fractal dimensions vary.
‘:hybrid-multi‘: Multifractal noise that results in valleys having smooth bottoms.
‘:ridged-multi‘: Creates ridges suitable for terrain generation.
The parameters supplied to this modifier are consistent with the behaviors they provide for the
corresponding fractal generator.
There are a few differences between this modifier and the corresponding generator:
- This modifier fractalizes each dimension of the input sampler; there is no ability to specify the
dimensionality of the output.
- The default parameter values of this modifier are generic, and may not match the default values of
the corresponding generator. You should ensure that you are calling this with the desired
parameter values if leaving any unspecified.
- The input sampler’s output is used for each octave of the generated fractal. This is in contrast to generator fractals, where their octaves are other generators each being seeded differently.
‘source‘: The input sampler (required).
‘type‘: A keyword denoting one of the valid fractal types (required).
‘octaves‘: The number of octaves to generate (optional, default: 4).
‘frequency‘: The frequency of the first octave (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive
octaves (optional, default 0.5).
‘attenuation‘: The attenuation to apply to the weight of each octave - only applicable for the ‘:ridged-multi‘ type (optional, default: 2.0)
fractalize.lisp (file)
image.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
2-dimensional hybrid multifractal noise, using the supplied ‘generator‘ function to construct each
octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 2-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-2d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.25).
hybrid-multifractal-2d.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
3-dimensional hybrid multifractal noise, using the supplied ‘generator‘ function to construct each
octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 3-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-3d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.25).
hybrid-multifractal-3d.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
4-dimensional hybrid multifractal noise, using the supplied ‘generator‘ function to construct each
octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 4-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-4d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.25).
hybrid-multifractal-4d.lisp (file)
image.lisp (file)
image.lisp (file)
image.lisp (file)
map.lisp (file)
map.lisp (file)
map.lisp (file)
map.lisp (file)
map.lisp (file)
Construct a sampler that, when sampled, outputs the maximum of the outputs of its two input
samplers.
‘source1‘: The first input sampler (required).
‘source2‘: The second input sampler (required).
max.lisp (file)
Construct a sampler that, when sampled, outputs the minimum of the outputs of its two input
samplers.
‘source1‘: The first input sampler (required).
‘source2‘: The second input sampler (required).
min.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
2-dimensional multifractal noise, using the supplied ‘generator‘ function to construct each octave’s
sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 2-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-2d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.5).
multifractal-2d.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
3-dimensional multifractal noise, using the supplied ‘generator‘ function to construct each octave’s
sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 3-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-3d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.5).
multifractal-3d.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
4-dimensional multifractal noise, using the supplied ‘generator‘ function to construct each octave’s
sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 4-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-4d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive octaves (optional, default 0.5).
multifractal-4d.lisp (file)
Construct a sampler that, when sampled, negates the output value of its input sampler.
‘source‘: The input sampler (required).
negate.lisp (file)
Construct a sampler that, when sampled, outputs 2-dimensional OpenSimplex noise values ranging
from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
open-simplex-2d.lisp (file)
Construct a sampler that, when sampled, outputs 3-dimensional OpenSimplex noise values ranging
from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
open-simplex-3d.lisp (file)
Construct a sampler that, when sampled, outputs 4-dimensional OpenSimplex noise values ranging
from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
open-simplex-4d.lisp (file)
Construct a sampler that, when sampled, outputs 2-dimensional OpenSimplex2F noise values ranging
from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘orientation‘: One of ‘:standard‘ or ‘:x/y‘, denoting the orientation of the lattice. ‘:x/y‘ has the Y axis pointing down the main diagonal, which might be more suitable for a game where Y is vertical (optional, default: ‘:standard‘).
open-simplex2f-2d.lisp (file)
Construct a sampler that, when sampled, outputs 3-dimensional OpenSimplex2F noise values ranging
from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘orientation‘: One of ‘:standard‘, ‘:xy/z‘, or ‘:xz/y‘, denoting the orientation of the lattice. ‘:xy/z‘ has better visual isotropy in XY, and ‘:xz/y‘ has better visual isotropy in XZ (optional, default: ‘:standard‘).
open-simplex2f-3d.lisp (file)
Construct a sampler that, when sampled, outputs 4-dimensional OpenSimplex2F noise values ranging
from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘orientation‘: One of ‘:standard‘, ‘:xy/zw‘, ‘:xz/yw‘, or ‘:xyz/w‘, denoting the orientation of the lattice. ‘:xy/zw‘ is recommended for 3D terrain where X/Y or Z/W are horizontal. ‘:xz/yw‘ is recommended for 3D terrain where X/Z or Y/W are horizontal. ‘:xyz/w‘ is recommended for time-varied animations of 3D objects, where W is time (optional, default: ‘:standard‘).
open-simplex2f-4d.lisp (file)
Construct a sampler that, when sampled, outputs 2-dimensional OpenSimplex2S noise values ranging
from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘orientation‘: One of ‘:standard‘ or ‘:x/y‘, denoting the orientation of the lattice. ‘:x/y‘ has the Y axis pointing down the main diagonal, which might be more suitable for a game where Y is vertical (optional, default: ‘:standard‘).
open-simplex2s-2d.lisp (file)
Construct a sampler that, when sampled, outputs 3-dimensional OpenSimplex2S noise values ranging
from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘orientation‘: One of ‘:standard‘, ‘:xy/z‘, or ‘:xz/y‘, denoting the orientation of the lattice. ‘:xy/z‘ has better visual isotropy in XY, and ‘:xz/y‘ has better visual isotropy in XZ (optional, default: ‘:standard‘).
open-simplex2s-3d.lisp (file)
Construct a sampler that, when sampled, outputs 4-dimensional OpenSimplex2S noise values ranging
from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘orientation‘: One of ‘:standard‘, ‘:xy/zw‘, ‘:xz/yw‘, or ‘:xyz/w‘, denoting the orientation of the lattice. ‘:xy/zw‘ is recommended for 3D terrain where X/Y or Z/W are horizontal. ‘:xz/yw‘ is recommended for 3D terrain where X/Z or Y/W are horizontal. ‘:xyz/w‘ is recommended for time-varied animations of 3D objects, where W is time (optional, default: ‘:standard‘).
open-simplex2s-4d.lisp (file)
Construct a sampler that, when sampled, outputs 1-dimensional Perlin Improved noise values
ranging from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
perlin-1d.lisp (file)
Construct a sampler that, when sampled, outputs 2-dimensional Perlin Improved noise values
ranging from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
perlin-2d.lisp (file)
Construct a sampler that, when sampled, outputs 3-dimensional Perlin Improved noise values
ranging from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
perlin-3d.lisp (file)
Construct a sampler that, when sampled, outputs 4-dimensional Perlin Improved noise values
ranging from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
perlin-4d.lisp (file)
Construct a sampler that, when sampled, raises the output of ‘source1‘ to the power of the output
of ‘source2‘.
‘source1‘: The first input sampler (required).
‘source2‘: The second input sampler (required).
power.lisp (file)
map.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
2-dimensional ridged multifractal noise, using the supplied ‘generator‘ function to construct each
octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 2-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-2d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive
octaves (optional, default 1.0).
‘attenuation‘: The attenuation to apply to the weight of each octave (optional, default: 2.0).
ridged-multifractal-2d.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
3-dimensional ridged multifractal noise, using the supplied ‘generator‘ function to construct each
octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 3-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-3d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive
octaves (optional, default 1.0).
‘attenuation‘: The attenuation to apply to the weight of each octave (optional, default: 2.0).
ridged-multifractal-3d.lisp (file)
Construct a sampler that, when sampled, outputs the application of multiple octaves of a
4-dimensional ridged multifractal noise, using the supplied ‘generator‘ function to construct each
octave’s sampler.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘generator‘: a function object pointing to one of the built-in 4-dimensional generators that is used
to construct a different sampler, each with a different seed, for each octave (optional, default
‘#’open-simplex2s-4d‘).
‘octaves‘: An integer between 1 and 32, denoting the number of octaves to apply (optional, default:
4).
‘frequency‘: The frequency of the first octave’s signal (optional, default: 1.0).
‘lacunarity‘: A multiplier that determines how quickly the frequency increases for successive
octaves (optional, default: 2.0).
‘persistence‘: A multiplier that determines how quickly the amplitude diminishes for successive
octaves (optional, default 1.0).
‘attenuation‘: The attenuation to apply to the weight of each octave (optional, default: 2.0).
ridged-multifractal-4d.lisp (file)
Construct a sampler that, when sampled, rotates the input coordinates around the origin before
sampling from it. The coordinate system is assumed to be left-handed. The angle of rotation around
each of the ‘x‘, ‘y‘, and ‘z‘ axes can be set individually.
‘source‘: The input sampler (required).
‘x‘: The angle in radians to rotate around the X axis (optional, default: 0.0).
‘y‘: The angle in radians to rotate around the Y axis (optional, default: 0.0).
‘z‘: The angle in radians to rotate around the Z axis (optional, default: 0.0).
rotate.lisp (file)
Construct a sampler that, when sampled, scales the input coordinates of ‘source‘ down (increases
the wavelength, and decreases the frequency), by the amounts given for each of the ‘x‘, ‘y‘, ‘z‘,
and ‘w‘ axes.
‘source‘: The input sampler (required).
‘x‘: The amount to scale along the X axis (optional, default: 1.0).
‘y‘: The amount to scale along the Y axis (optional, default: 1.0).
‘z‘: The amount to scale along the Z axis (optional, default: 1.0).
‘w‘: The amount to scale along the W axis (optional, default: 1.0).
scale.lisp (file)
Construct a sampler that, when sampled, outputs the result of sampling from either ‘source1‘ or
‘source2‘. The input sampler chosen is decided based upon the output of the ‘control‘ sampler.
If the output of ‘control‘ is within the range denoted by ‘min‘ and ‘max‘, ‘source2‘ is chosen. If
the output of ‘control‘ is outside of this range, ‘source1‘ is chosen.
‘source1‘: The first input sampler (required).
‘source2‘: The second input sampler (required).
‘control‘: The sampler that determines the sampler to output (required).
‘min‘: A real number between -1.0 and 1.0 defining the lower bound of the selection range (optional,
default: -1.0).
‘max‘: A real number between -1.0 and 1.0 defining the upper bound of the selection range (optional,
default: 1.0).
‘falloff‘: A real number between 0.0 and 1.0 specifying the smoothness of the transition (optional, default: 0.0).
select.lisp (file)
Construct a sampler that, when sampled, outputs 1-dimensional Simplex noise values ranging from
-1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
simplex-1d.lisp (file)
Construct a sampler that, when sampled, outputs 2-dimensional Simplex noise values ranging from
-1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
simplex-2d.lisp (file)
Construct a sampler that, when sampled, outputs 3-dimensional Simplex noise values ranging from
-1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
simplex-3d.lisp (file)
Construct a sampler that, when sampled, outputs 4-dimensional Simplex noise values ranging from
-1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
simplex-4d.lisp (file)
Construct a sampler that, when sampled, outputs 3-dimensional concentric sphere values ranging
from -1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not
supplied, one will be generated automatically which will negatively affect the reproducibility of
the noise (optional, default: NIL).
‘frequency‘: The frequency of the signal, which controls how small or large the spheres are (optional, default: 1.0).
spheres-3d.lisp (file)
Construct a sampler that, when sampled, modifies the output value of ‘source‘ by multiplying it
by ‘strength‘, and optionally adding ‘bias‘ afterwards.
‘source‘: The input sampler (required).
‘strength‘: A multiplier to apply to the output of ‘source‘ (required).
‘bias‘: An additional bias amount to add to the result (optional, default: 0.0).
strengthen.lisp (file)
Construct a sampler that, when sampled, maps the output of its input sampler onto a
terrace-forming curve, defined by the list of ‘points‘. ‘points‘ is a list of at least 2 real
numbers, each with a unique value.
‘source‘: The input sampler (required).
‘points‘: A list of at least two control points that define the curve (required).
‘invert-p‘: Whether the curve is inverted between the control points (optional, default: nil).
terrace.lisp (file)
Construct a sampler that, when sampled, offsets the input coordinates of ‘source‘ by the amounts
supplied each of the ‘x‘, ‘y‘, ‘z‘, and ‘w‘ axes, before sampling from it.
‘source‘: The input sampler (required).
‘x‘: The amount to offset along the X axis (optional, default: 0.0).
‘y‘: The amount to offset along the Y axis (optional, default: 0.0).
‘z‘: The amount to offset along the Z axis (optional, default: 0.0).
‘w‘: The amount to offset along the W axis (optional, default: 0.0).
translate.lisp (file)
Construct a sampler that, when sampled, displaces the input coordinates of its ‘source‘ input
sampler before sampling from it. The displacement values come from the result of sampling a
fractional Brownian motion application of the supplied ‘displacement‘ sampler, along with randomly
generated values retrieved using the random number generator of ‘source‘.
‘source‘: The input sampler whose input coordinates are displaced (required).
‘displacement‘: A sampler that has ‘roughness‘ octaves of fractional Brownian motion applied to it
to determine the random displacement (required).
‘frequency‘: The frequency of the fractional Brownian motion displacement (optional, default 1.0).
‘power‘: A scaling factor that is applied to the displacement amount (optional, default: 1.0).
‘roughness‘: The number of octaves to apply for the displacement fractional Brownian motion (optional, default: 3).
turbulence.lisp (file)
scale.lisp (file)
Construct a sampler that, when sampled, outputs 2-dimensional value noise values ranging from
-1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
value-2d.lisp (file)
Construct a sampler that, when sampled, outputs 3-dimensional value noise values ranging from
-1.0 to 1.0.
‘seed‘: A string used to seed the random number generator for this sampler, or NIL. If a seed is not supplied, one will be generated automatically which will negatively affect the reproducibility of the noise (optional, default: NIL).
value-3d.lisp (file)
image.lisp (file)
Next: Exported conditions, Previous: Exported functions, Up: Exported definitions [Contents][Index]
common.lisp (file)
turbulence.lisp (file)
translate.lisp (file)
terrace.lisp (file)
subtract.lisp (file)
strengthen.lisp (file)
select.lisp (file)
scale.lisp (file)
rotate.lisp (file)
power.lisp (file)
multiply.lisp (file)
negate.lisp (file)
min.lisp (file)
max.lisp (file)
expt.lisp (file)
divide.lisp (file)
displace.lisp (file)
curve.lisp (file)
clamp.lisp (file)
cache.lisp (file)
blend.lisp (file)
add.lisp (file)
abs.lisp (file)
ridged-multifractal-4d.lisp (file)
ridged-multifractal-3d.lisp (file)
ridged-multifractal-2d.lisp (file)
hybrid-multifractal-4d.lisp (file)
hybrid-multifractal-3d.lisp (file)
hybrid-multifractal-2d.lisp (file)
multifractal-4d.lisp (file)
multifractal-3d.lisp (file)
multifractal-2d.lisp (file)
billow-4d.lisp (file)
billow-3d.lisp (file)
billow-2d.lisp (file)
fbm-4d.lisp (file)
fbm-3d.lisp (file)
fbm-2d.lisp (file)
constant.lisp (file)
checker-2d.lisp (file)
spheres-3d.lisp (file)
cylinders-3d.lisp (file)
cellular-3d.lisp (file)
cellular-2d.lisp (file)
value-3d.lisp (file)
value-2d.lisp (file)
open-simplex2s-4d.lisp (file)
open-simplex2s-3d.lisp (file)
open-simplex2s-2d.lisp (file)
open-simplex2f-4d.lisp (file)
open-simplex2f-3d.lisp (file)
open-simplex2f-2d.lisp (file)
open-simplex-4d.lisp (file)
open-simplex-3d.lisp (file)
open-simplex-2d.lisp (file)
simplex-4d.lisp (file)
simplex-3d.lisp (file)
simplex-2d.lisp (file)
simplex-1d.lisp (file)
perlin-4d.lisp (file)
perlin-3d.lisp (file)
perlin-2d.lisp (file)
perlin-1d.lisp (file)
Next: Exported structures, Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
conditions.lisp (file)
error (condition)
sampler-type (method)
:sampler-type
sampler-type (generic function)
conditions.lisp (file)
cricket-error (condition)
:distance-method
distance-method (generic function)
:valid-distance-methods
valid-distance-methods (generic function)
conditions.lisp (file)
cricket-error (condition)
:output-type
output-type (generic function)
:valid-output-types
valid-output-types (generic function)
conditions.lisp (file)
cricket-error (condition)
value (method)
:value
value (generic function)
conditions.lisp (file)
cricket-error (condition)
:orientation
orientation (generic function)
:valid-orientations
valid-orientations (generic function)
conditions.lisp (file)
cricket-error (condition)
:argument
argument (generic function)
:value
value (generic function)
conditions.lisp (file)
cricket-error (condition)
:argument
argument (generic function)
:value
value (generic function)
conditions.lisp (file)
cricket-error (condition)
seed (method)
:seed
seed (generic function)
Previous: Exported conditions, Up: Exported definitions [Contents][Index]
multiply.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source1 (function)
(setf source1) (function)
%cricket.internal:sampler
source2 (function)
(setf source2) (function)
add.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source1 (function)
(setf source1) (function)
%cricket.internal:sampler
source2 (function)
(setf source2) (function)
subtract.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source1 (function)
(setf source1) (function)
%cricket.internal:sampler
source2 (function)
(setf source2) (function)
divide.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source1 (function)
(setf source1) (function)
%cricket.internal:sampler
source2 (function)
(setf source2) (function)
abs.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source (function)
(setf source) (function)
billow-2d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.5
persistence (function)
(setf persistence) (function)
billow-3d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.5
persistence (function)
(setf persistence) (function)
billow-4d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.5
persistence (function)
(setf persistence) (function)
blend.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source1 (function)
(setf source1) (function)
%cricket.internal:sampler
source2 (function)
(setf source2) (function)
%cricket.internal:sampler
control (function)
(setf control) (function)
cache.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source (function)
(setf source) (function)
boolean
cached-p (function)
(setf cached-p) (function)
golden-utils:f32
0.0
value (function)
(setf value) (function)
cellular-2d.lisp (file)
sampler (structure)
sample (method)
golden-utils:ub32
0
seed (function)
(setf seed) (function)
(member :manhattan :euclidean :euclidean-squared :chebyshev :minkowski4)
:euclidean
distance-method (function)
(setf distance-method) (function)
(member :value :f1 :f2 :f1+f2 :f2-f1 :f1*f2 :f1/f2)
:f1
output-type (function)
(setf output-type) (function)
golden-utils:f64
1.0d0
jitter (function)
(setf jitter) (function)
cellular-3d.lisp (file)
sampler (structure)
sample (method)
golden-utils:ub32
0
seed (function)
(setf seed) (function)
(member :manhattan :euclidean :euclidean-squared :chebyshev :minkowski4)
:euclidean
distance-method (function)
(setf distance-method) (function)
(member :value :f1 :f2 :f1+f2 :f2-f1 :f1*f2 :f1/f2)
:f1
output-type (function)
(setf output-type) (function)
golden-utils:f64
1.0d0
jitter (function)
(setf jitter) (function)
checker-2d.lisp (file)
sampler (structure)
sample (method)
clamp.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source (function)
(setf source) (function)
golden-utils:f32
-1.0
min (function)
(setf min) (function)
golden-utils:f32
1.0
max (function)
(setf max) (function)
constant.lisp (file)
sampler (structure)
sample (method)
golden-utils:f32
0.5
value (function)
(setf value) (function)
curve.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source (function)
(setf source) (function)
simple-vector
(make-array 0)
control-points (function)
(setf control-points) (function)
cylinders-3d.lisp (file)
sampler (structure)
sample (method)
golden-utils:f64
1.0d0
frequency (function)
(setf frequency) (function)
displace.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source (function)
(setf source) (function)
expt.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source (function)
(setf source) (function)
golden-utils:f32
1.0
power (function)
(setf power) (function)
fbm-2d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.5
persistence (function)
(setf persistence) (function)
fbm-3d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.5
persistence (function)
(setf persistence) (function)
fbm-4d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.5
persistence (function)
(setf persistence) (function)
hybrid-multifractal-2d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.25
persistence (function)
(setf persistence) (function)
hybrid-multifractal-3d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.25
persistence (function)
(setf persistence) (function)
hybrid-multifractal-4d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.25
persistence (function)
(setf persistence) (function)
image.lisp (file)
structure-object (structure)
golden-utils:ub32
0
image-width (function)
(setf image-width) (function)
golden-utils:ub32
0
image-height (function)
(setf image-height) (function)
simple-vector
(make-array 0)
image-data (function)
(setf image-data) (function)
map.lisp (file)
structure-object (structure)
golden-utils:ub24
512
map-width (function)
(setf map-width) (function)
golden-utils:ub24
512
map-height (function)
(setf map-height) (function)
golden-utils:f32a
(golden-utils:make-f32-array 0)
map-data (function)
(setf map-data) (function)
max.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source1 (function)
(setf source1) (function)
%cricket.internal:sampler
source2 (function)
(setf source2) (function)
min.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source1 (function)
(setf source1) (function)
%cricket.internal:sampler
source2 (function)
(setf source2) (function)
multifractal-2d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.5
persistence (function)
(setf persistence) (function)
multifractal-3d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.5
persistence (function)
(setf persistence) (function)
multifractal-4d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
0.5
persistence (function)
(setf persistence) (function)
negate.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source (function)
(setf source) (function)
open-simplex-2d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:ub8a 512)
table (function)
(setf table) (function)
open-simplex-3d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:ub8a 256)
%cricket.generators.open-simplex-3d::+permutation+
table (function)
(setf table) (function)
open-simplex-4d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:ub8a 512)
table (function)
(setf table) (function)
open-simplex2f-2d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:f64a 4096)
(golden-utils:make-f64-array 4096)
gradients (function)
(setf gradients) (function)
(golden-utils:b16a 2048)
(golden-utils:make-b16-array 2048)
table (function)
(setf table) (function)
(member :standard :x/y)
:standard
orientation (function)
(setf orientation) (function)
open-simplex2f-3d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:f64a 6144)
(golden-utils:make-f64-array 6144)
gradients (function)
(setf gradients) (function)
(golden-utils:b16a 2048)
(golden-utils:make-b16-array 2048)
table (function)
(setf table) (function)
(member :standard :xy/z :xz/y)
:standard
orientation (function)
(setf orientation) (function)
open-simplex2f-4d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:f64a 8192)
(golden-utils:make-f64-array 8192)
gradients (function)
(setf gradients) (function)
(golden-utils:b16a 2048)
(golden-utils:make-b16-array 2048)
table (function)
(setf table) (function)
(member :standard :xy/zw :xz/yw :xyz/w)
:standard
orientation (function)
(setf orientation) (function)
open-simplex2s-2d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:f64a 4096)
(golden-utils:make-f64-array 4096)
gradients (function)
(setf gradients) (function)
(golden-utils:b16a 2048)
(golden-utils:make-b16-array 2048)
table (function)
(setf table) (function)
(member :standard :x/y)
:standard
orientation (function)
(setf orientation) (function)
open-simplex2s-3d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:f64a 6144)
(golden-utils:make-f64-array 6144)
gradients (function)
(setf gradients) (function)
(golden-utils:b16a 2048)
(golden-utils:make-b16-array 2048)
table (function)
(setf table) (function)
(member :standard :xy/z :xz/y)
:standard
orientation (function)
(setf orientation) (function)
open-simplex2s-4d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:f64a 8192)
(golden-utils:make-f64-array 8192)
gradients (function)
(setf gradients) (function)
(golden-utils:b16a 2048)
(golden-utils:make-b16-array 2048)
table (function)
(setf table) (function)
(member :standard :xy/zw :xz/yw :xyz/w)
:standard
orientation (function)
(setf orientation) (function)
perlin-1d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:ub8a 512)
table (function)
(setf table) (function)
perlin-2d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:ub8a 512)
table (function)
(setf table) (function)
perlin-3d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:ub8a 512)
table (function)
(setf table) (function)
perlin-4d.lisp (file)
sampler (structure)
sample (method)
(golden-utils:ub8a 512)
table (function)
(setf table) (function)
power.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source1 (function)
(setf source1) (function)
%cricket.internal:sampler
source2 (function)
(setf source2) (function)
ridged-multifractal-2d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
1.0
persistence (function)
(setf persistence) (function)
golden-utils:f32
2.0
attenuation (function)
(setf attenuation) (function)
ridged-multifractal-3d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
1.0
persistence (function)
(setf persistence) (function)
golden-utils:f32
2.0
attenuation (function)
(setf attenuation) (function)
ridged-multifractal-4d.lisp (file)
sampler (structure)
sample (method)
simple-vector
(vector)
sources (function)
(setf sources) (function)
golden-utils:f32
1.0
scale (function)
(setf scale) (function)
(integer 1 32)
4
octaves (function)
(setf octaves) (function)
golden-utils:f32
1.0
frequency (function)
(setf frequency) (function)
golden-utils:f32
2.0
lacunarity (function)
(setf lacunarity) (function)
golden-utils:f32
1.0
persistence (function)
(setf persistence) (function)
golden-utils:f32
2.0
attenuation (function)
(setf attenuation) (function)
rotate.lisp (file)
sampler (structure)
sample (method)
%cricket.internal:sampler
source (function)
(setf source) (function)
golden-utils:f64
0.0d0
rx1 (function)
(setf rx1) (function)
golden-utils:f64
0.0d0
rx2 (function)
(setf rx2) (function)
golden-utils:f64
0.0d0
rx3 (function)
(setf rx3) (function)
golden-utils:f64
0.0d0
ry1 (function)
(setf ry1) (function)
golden-utils:f64
0.0d0
ry2 (function)
(setf ry2) (function)
golden-utils:f64
0.0d0
ry3 (function)
(setf ry3) (function)
golden-utils:f64
0.0d0
rz1 (function)
(setf rz1) (function)
golden-utils:f64
0.0d0
rz2 (function)
(setf rz2) (function)
golden-utils:f64
0.0d0
rz3 (function)
(setf rz3) (function)
common.lisp (file)
structure-object (structure)