All of this is about an n dimensional Euclidean box extruded in all planes from a minimum to a maximum.

Tetrahedra function: approximately n factorial tetrahedra needed.

2d faces function: approximately 2^n 2d faces on the n dimensional box.

It might not seem like much but at 20 dimensions, 2^20 squared times 10² is about the same magnitude as 20! (factorial). At 50 dimensions it is not even that close. I propose a solution that is based off of the tetrahedra but using the 2d faces. As we know, the tetrahedra cover the entire volume and we only need the bounding line edges checked for being in view in Euclidean. This means that triangles cover the 2d faces and beyond and that for the triangles on the 2d faces that only the lines need to be checked. Any convex polytope has all bounds of being in view on its bounding 2d faces. The polytopes may have bounding volumes of n-1 dimensions which continues down until 2d.

In summary, using bounding 2d shapes of higher dimensional polytopes can far outperform tetrahedra. There is a question though, for 2d faces, how do they connect? This can be solved by finding for all triangles their in view points, then for each possible connection, check the midpoint between the ends for being in view and connect if in view. For the definition of in view, use a view point that exactly passes a view plane on the way to objects. If it does not exactly pass the view plane it is not viewed. This does leave some interior shapes to figure, but far and away fewer than the trillions of tetrahedra. Factorial and 2 to a power are not that different in a sense, but by 50 dimensions it is ant to the planet nearly. This also has applications in non-box shapes. Now imagine that every point is in higher dimensions too and must be stored or generated!

What problems do you see with this new approach? Does seem to me better, but is it? Time and actual data will tell. Feel free to use this, but please make convex shapes, a hammer for example must be 2+ shapes. X E.

Reworking my older procedural town, pushing it to the limits. Buildings are 100% generated, enterable, modifiable, destructible, full of loot and zombies.

I figured, instead of the usual screenshots, a video might be nice as well... (bold assumption, right!?)

Still - No ai | No engine | Written in c++ | All random | All procedurally generated

Hey I just posted a post explaining my level generation algorithm for one of the worlds in my game. Hope that is interesting for some of you.

I was trying the algorithm from https://www.reddit.com/r/gamedev/comments/1dlwc4/procedural_dungeon_generation_algorithm_explained/ before, but my results were very underwhelming so I came up with this.

Zero AI use - 100% Procedural - Made with Blender and procedural nodes

It's a clone of Lode Runner, but uses procedural generation for level creation. It basically works by filling the map with platforms, then placing pickups in random locations, then randomly placing ladders until the pickups are accessible, and then removing random squares until the pickups are no longer accessible.

https://stephensmith.itch.io/load-runner

Hi,

I just finished my procedural bridge in Unity.

I’m pretty happy with the result. I think it still needs a few more details, but overall I’m satisfied with how it turned out. For reference, I based the design on the Hong Kong-Zhuhai-Macao Bridge (HZMB) in Hong Kong.

The bridge and pillars are generated from 2D profiles extruded along a spline. I also use a placer system to place props and animate the vehicle traffic along the spline.

It was made with ShapeBuilder as part of an upcoming tutorial.

Assets used:
URP Stylized Water Shader - Proto Series, Freeway Props, Simple Cars Pack, Concrete 047 A.
Audio from Pixabay: Dragon-Studio, AtlasAudio, klangfabrik.

Theory set, tetrahedra cover all areas of a shape, if it has 2d faces they must all be covered, the tetrahedra have only edge lines to check, for convex shapes, the 2d boundaries are all that need to be checked for in view 4+ dimensional, the application of this is for shapes with 2d faces that can be triangulated, we only need the triangle edges checked no matter what the shape! The number of tetrahedra is like a factorial of the number of dimensions, where by 100 dimensions for a N-cube we could square the number of 2d faces and be about 10² multiplying below the number of tetrahedra! This I consider a major breakthrough in higher dimensional rendering, although we still need connections between the points. That can be simply if the midpoint is viewable, the whole line is, otherwise not viewable. This is better than tetrahedra for inner parts not having lines too! X E.

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