FastNoise VS Scattered-Biome-Blender

If you go to the FastNoiseLite github you'll see there's a FastNoiseLite.glsl file, this file contains the entire library. So to use this in a shader we need to use the new shader #inlude preprocessor. In short, create a new ShaderInclude resource, paste the contents of the FastNoiseLite.glsl file into it and then simply #include it in your shader.

FastNoiseLite: ValueNoise, OpenSimplex2, OpenSimplex2S, Perlin, ValueCubic (from https://github.com/Auburn/FastNoiseLite )

Fair enough. If it helps, you can drop this into a P5.js sketch without too much friction: https://github.com/Auburn/FastNoiseLite/tree/master/JavaScript

I suppose I'll compile what I can find here for future searchers: Here's the original github for FNL , it has some images to use as examples but few explanations unless you want to download and run the preview program yourself.

Also take a look at FastNoiseLite if you want better control over noise generation, and for cool examples.

I used this repo: https://github.com/Auburn/FastNoiseLite

Yeah, that's literally what a seed does. It's really odd to me that the unity mathematics one doesn't have a seed. I use this one: FastNoiseLite

I really like this library which appears to have gals implementation. https://github.com/Auburn/FastNoiseLite

For the actual dunes I used fast noise lite ( https://github.com/Auburn/FastNoiseLite ). They have a nice gui app, where you can create noise textures (in my case voronoi noise). Then I apply the height map to the individual terrain tiles. So no fancy procedural Generation is going on here.

A jittered grid could work well, if you're dividing your world into chunks. You can take this class (+ all its dependencies), port it to whatever language you need, and instantiate it with the parameters you need. I detailed in this blog post the specific case I used it for.

Github Repo: https://github.com/KdotJPG/Scattered-Biome-Blender

To generate the point distributions you need, you could probably use this ChunkPointGatherer class I wrote for another project, and its dependency UnfilteredPointGatherer. Port to whatever language you need, of course. Here is my understand of how to implement this:

If you write a function that returns what the biome should be at or near an arbitrary point in the world, then you can evaluate that function at randomly-ish distributed points (with an upper bound on how far apart they can be spaced), and blend over them. I've implemented the blending part here, a user would just need to implement the callback and decide on the parameter values. The parameters are point frequency, and minimum blend radius (or length).

Blending can be difficult to make fast and not appear griddy at the same time. I did put together a quick blending system a couple weeks ago, though that addresses both of these problems. https://github.com/KdotJPG/Scattered-Biome-Blender It works by sampling a sparse and random-looking distribution of points from an underlying biome query function, then at each block or pixel in the world it considers all evaluation points within a certain circular range. It starts with a minimum circular size that guarantees there will always be at least one point in range, then it adds a user-specified padding to ensure a minimum distance for transition to occur over. It also inherently adds a bit of noisiness to the borders, which is something you may want anyway.