FastNoise VS TinyEngine

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.

The full code is available here. Written in C++ with TinyEngine.

You can find an article explaining how this works on my blog here and a terrain-based implementation here. For more detailed source code on the LBM method, check out the examples here.

This is a simulation of wind flow over procedural terrain using my own GPU accelerated implementation of the lattice boltzmann method. All implemented and visualized in TinyEngine (by me). Terrain generated using SimpleHydrology (also by me). The source for this is not released (yet!). This scene is 100% procedural.

[Source Code]

I went ahead and made you a reference implementation. You can find it here. It's pretty short, and by the shaders you should understand how it works. Instance render 3D quads using centroids as attribdivisors, then reposition the quad vertices correctly, manually write to the cubemap depth buffer and whatever you want to the colorbuffer.

Here the link to the github repo: https://github.com/weigert/TinyEngine I thought it seemed neat and think I may use it for some future projects.

I have already integrated this into my personal engine TinyEngine (simply by making all file loading interfaces use stdio.h FILE* style interfaces). Any program built with this system can use either a real, relative file system or be built to have a virtual snapshot embedded into the executable!

The visualization of the dynamic data was made using my own TinyEngine.

So I wrote an article on it here. You can find the code here.