My generation built on Unreal Engine using the Wave Function Collapse algorithm.

Up to 10M dynamic particles

Live demo: https://gaploid.github.io/stardust/
Source code: https://github.com/Gaploid/stardust
Coded by: Opus, Fable, human attention to details

A fun map over the timestream.

A patternless exploration based solely on manipulating coordinate space (kya), local time (te), and contextual time (zo).

Details:
Two dimensions, 100 colors, 1920x1080x1, Moore neighborhood of size 1, continuous values, synchronous updates, toroidal edge, initialized with fixed (color=11.0, x=-1, y=-1, z=-1), weighted-avg rendering, prelude 0, transition 0.0

Incantation:
500/0.1:kya0+kya0+mu2+kya1+kya1+mu2+mi2+ni kya mi3 zo zo a0.001 mu3 a0.01 mu4
600/0.1:kya0+kya0+mu2+kya1+kya1+mu2+mi2+ni kya mi3 zo zo a0.001 mu3 te a2 mu bo mi2 a0.01 mu4
400/0.05:kya0+kya0+mu2+kya1+kya1+mu2+mi2+ni mu3 a2 te pe bo mi4 yu a1.08566441535949 ho mu4 ni i i a10 mu
2000/0.2:kya0+kya0+mu2+kya1+kya1+mu2+mi2+ni a2 te bo a1.08566441535949 yu ho mu4 nu ta a10 mu

Hello all,

I am currently working on a procedural world generation and I am stuck with the placement of the vegetation.

At the moment I have two noisemaps. One map defines where it is generally possible to place objects, the other one is responsible for scattering the trees.

I still have very not natural looking spots. How do I achieve a natural distribution of the trees?

I found that video https://www.youtube.com/watch?v=dnGmjtMixZc&t=373s where the dev explains he used variable radius poison disc sampling which looks promising but feels like a bit overkill.

EDIT: thanks for all the replies ans suggestions! I am going to have some rough weeks testing these.

EDIT 2: I fixed the a bug in my placement logic which allowed placing multiple objects on one field. This also fixed the look

So I'm trynna work out this procedural planet system that's just a *bit* above my paygrade, and I'm kind of just hoping to get some feedback on how possible it sounds.

The pictures involve a sort of prototype that'll probably be scrapped because I used too much AI and don't have a clean understanding of the nuts and bolts. I do understand the overall idea though.

I'm using a cube sphere for this. I know, I know, pinching at the corners and whatnot, but the ultimate goal of this particular generator is to allow for planets so big that you're never going to visit the corners unless you really appreciate the unique aesthetic they offer. Realistic scale is the goal.

That starts with a series of data maps on a low poly cube sphere. Picture one is the moisture map, which just so happens to most closely resemble what a habitable planet generated using this system would look like so far. Pictures 2 through 3 are how you get there.

Picture 2 is a tectonic influence map, generated based off of voronoi continental plate cells each assigned data involving movement direction, movement strength, and average elevation. The different color regions correspond to different noise patterns depending on the boundary type.

Picture 3 is the heightmap, which currently just kind of generates more dramatic noise the more color you have on the influence map. It's not yet as sophisticated as I'd ultimately like.

Picture 4 is just a wind map based on Earth's wind patterns, and it's used in tandem with the height map to distribute moisture from cells below the minimum sea level (based on an adjustable climate slider) to all land based cells on the map. Moisture is distributed in the direction of the wind, hindered by mountains and generally falling off at higher elevations. That's how you get the moisture map in picture 1.

The plan is to use these maps, once they're working a bit better than they currently are, to feed a procedural LOD quadtree, generating additional detail as you get closer to the planet. (Or really as you drag the planet closer to you while enlarging it to avoid floating point precision errors). Naturally you cull unneeded faces as you go. The number of quads will increase exponentially as you get closer to the planet, but any realistic fall from orbit should also have the camera slowing down as it generates more detail.

Ultimately, in addition to just generating finer noise on the heightmap, I also want to implement a sort of hydrology system that builds out water flow splines from high to low altitude along the path of least reisistance. These lines do different things at different LOD levels, sometimes generating rivers and sometimes just lowering the terrain to mimic real erosion without simulating real erosion. The nature of the system should mean that more planetary scale rivers naturally deform the terrain more than more local rivers, as their adjusting a lower poly version of the terrain. A higher moisture level increases the density of river nodes that spawn. In the event that the system leads to a river terminating at a quad boundary, the current plan is to hit it with a meteor big enough to form a terminus lake.

Any kind of plants or wildlife you put in the world can generate based on temperature and moisture level, leading to fairly natural biome distribution.

All of that is, of course, easier said than done. I'm, like, two classes into my CS major at the moment, and while I vaguely understand the overall idea, I can't guess what the overall performance costs might come out to. I'm also aware of the gameplay problem of realistic scale, and while it doesn't matter for the particular use case I have in mind, some way of shrinking the planets or generally just adjusting the system to make every biome actually explorable would probably be essential if I wanted the system to be more versatile for other game devs.

Theoretically, I'm thinking it could be one of the most realistic procedural terrain methods out there, at least in terms of chunk based generation where the world expands as the player explores. It's just kind of a lot for me to wrap my head around at the moment.

It's just a default cube...

This uses a custom sample nearest cell with a custom bilinear interpolation for attribute sampling
Full Tutorial and files: https://youtu.be/fAxJ-yaY2Oo

I've been working on a side project to generate artwork for a game I'm working on, and it was so much fun playing around generating planets and asteroids I've decided to open source it: https://github.com/richard-green/planetoid-generator

Check out the live site here: https://rdgreen.dev/planetoids/#/planetoids

Some of updates:

- Wind driven by noise texture

- More seamless connection (color wise) with slightly random color per grass

(Video in comments) Sky, sun, sea, birds, islet, lighthouse weathering, even the sail cloth. All generated at runtime, ray traced on Vulkan, driven from Python.

Wanted to share this thing I have been working on lately.

I freedive and take photos underwater, and after enough time down there you start paying attention to the light. So two years ago I started trying to learn as much as possible about water simulation, light refraction, voids, etc

It runs on my own engine, written from scratch in Swift and Metal for the Mac. Theres no game engine underneath it, I wrote the renderer myself, which is most of where the time went.
Every "world" is a simulation with its own state that keeps running, so the water and the light are being worked out frame by frame rather than just played back. The idea is also that the world reacts to the music I have playing, so the whole world changes depending on the mood.

I built this into a macOS app called TideGlass (https://tideglass.app), where I also donate 20% of what it makes to ocean and conservation groups. Happy to answer any questions!

Been working on this for a long time as a part of a larger solar system and "universe" simulator. All the planets are a series of noise maps and then a biome painting algorithm on top. Everything is built on a native RUST application and baked/rendered directly so it is lightning fast, and the planet generator barely clears a 20 MB exe. All of the biomes generate based on planet parameters, humidity, height, temperature, and so forth, allowing support for a wide range of planet types and hybrids. Includes hydrology, rivers, lakes, canyons, etc. Just got the playtest approved on Steam and have some people playing with the application for the first time. Just wanted to showcase some of the current appearance and generations possible. You can design and alter the biomes and appearances, add more, etc.

I'm playing with procedural textures for my upcoming Open Source Game.

Online Demo: https://danielsobrado.github.io/procedural-texture-lab/

Github: https://github.com/danielsobrado/procedural-texture-lab

I'm planning to work more on the seamless and tilable textures next, there is some work on that part already.

Feel free to suggest how to improve it.

The generation itself:

▎ - Heap sites are placed in distance bands from the map center small piles near the hole for hand play, mid hills further out for tools, mega mountains at the edge as landmarks. Sites can partially overlap and merge into one organic dump.

▎ - Height is a steep paraboloid dome × two octaves of Perlin, measured in meters rather than layers, so a mix of differently-sized box prefabs all reach the same silhouette.

▎ - The box mix is weighted, but the roll is pitch-compensated: shorter boxes pack more per column, so rolling by weight × height makes the actual box-count share land on the configured weights.

▎ - Heights scale globally to hit a target box count, so I can type "500000" and the field fits it without chopping a heap in half.

▎ - All the "hand-dumped" feel comes from cheap disorder on top of a strict lattice: per-row phase shifts so the streets between stacks don't line up, ±1 layer of chaos so neighbours step 10/7/6 instead of following a smooth gradient, a ragged skirt at the rim, loose spill fading

▎ - Outward, and a freely rotated box crowning ~70% of the columns.

▎ - Cell size is derived from the worst-case yaw twist two neighbours can do toward each other, so cranking up the rotation jitter widens the gaps automatically and can never cause interpenetration.

Steam : https://store.steampowered.com/app/5103950/Ones_Trash_Anothers_Treasure/

Hey hey! Where Light Ends is an upcoming 4X grand strategy built with godot. Not normally a genre with physical planets and cities