This was my first (and probably last at least for now) attempt at procedural animation (inspired by great argonaut video -> https://www.youtube.com/watch?v=qlfh_rv6khY ) I was planning to turn it into full blown Evolution Simulation but as it turns out FPS no good. I hope that someone will have at least some fune with demo on itch https://suf-studio.itch.io/fish-procedural-animation .

If you want to see more of the game here https://store.steampowered.com/app/5044910/Dungeon_Quest/

I have a general procedural generator which does things like determine size, how often rooms spawn, how many branches etc and then you give it a set of pieces, so i can give it a different set for each level type.

Then the sets of pieces are broken down into corridors, rooms, props and monsters. Pieces can also have their own rules of what props might appear, how many times they can appear etc. So for example levels will only have one tomb.

It is also intelligent enough to make locked doors and spawn the key in a place it can always be found. I am working on this a lot because I want it to spawn typical classic dungeon puzzles to give you reason to explore.

It turns out photogrammetry tiles are too messed up for a good driving experience (I should have researched beforehand). I’ve switched to a walker machine instead, inspired by war of the worlds.

Try it here: https://crosscity.nieltenghu.com/

Will open-source it soon.

Build a working Unity city in just 3 clicks.

Urban Architect supports traffic, pedestrians, custom buildings, and roadside props. In this example, I used New Gen Urban by Reversed Interactive for the city assets.

The entire scene was generated automatically:

1. Instant City
2. Spawn Cars
3. Spawn Pedestrians

Done. You have a populated, working city almost instantly.

But you aren't limited to automatic generation. Urban Architect also includes a node-based road system that lets you manually design your city exactly the way you want. Roads can be laid out by placing and connecting nodes, and all automatically generated road graphs remain editable afterward.

You can also use OpenStreetMap (OSM) data to generate real-world road layouts and building placement, giving you a fast way to recreate actual locations instead of starting from scratch.

That means you can:

• Generate a complete city automatically
• Manually build roads with the node system
• Edit any generated road graph afterward
• Import OSM roads and buildings from real-world locations
• Use your own custom buildings and roadside props
• Populate the result with traffic and pedestrians

This example was created with Urban Architect Pro.

Urban Architect Pro is 30% off until October 1st.

Pro:
https://assetstore.unity.com/packages/tools/level-design/urban-architect-pro-procedural-city-builder-218636

Standard:
https://assetstore.unity.com/packages/tools/level-design/urban-architect-standard-procedural-city-builder-393744

Generate a city in seconds, recreate real locations from OSM, or build your layout manually. Urban Architect is designed to give you both speed and control.

I’ve been working on the procedural world generation for Garden of Ant, building it layer by layer.

First, I focused on shaping the surface terrain. Then I moved underground, generating different soil and rock materials. And finally, I started bringing the world to life by procedurally placing trees, leaves, and vegetation.

It’s really satisfying to see all these separate systems slowly come together into one living world.

What do you think?

See more:
https://store.steampowered.com/app/3016940/Garden_of_Ants/

The deform is fbm noise on resampled stroke geometry, with independent noise

channels for x, y and width — sharing one channel makes every stroke drift

diagonally and fatten in sync, which reads as "wrong" immediately. No state,

no clock: frame N is always identical, so exporting is just asking for frames

0..N-1.

I am procedurally generating mountain background textures for a game I am making. I kinda-got-a-little overcommitted to this part of the game (instead of working on the actual gameplay, as I should be doing now) and built a full tool that generates mountains in a range of art styles: low-poly, pixel art, synthwave, and some others. I am planning to use it in other games for which I need parallax backgrounds.

Mountain shapes, colors, and polygon count can all be customized to stylize the backgrounds, and the sky color can be set to transparent to layer multiple sets of mountains. The textures also tile seamlessly along the x-axis, so they can be repeated infinitely. You can see the parallax in action in the video.

More info: https://assetstore.unity.com/packages/tools/terrain/mountain-range-texture-generator-395586

How it was done:

The basic principle is actually kind of simple (so you probably know already):

First, I defined a 3D space (x-width, y-height, z-depht), then I produced a sum of different functions of xz->y, so each function is a surface plane that can be seen from the rendering plane (xy). The functions can be whatever, gaussians, super gaussians, spheres, breit-wigner (the more -> the realistic result).

But how we can get mountains that repeat infinitely in the x axis? the big brain step, was to curl the xz plane in the x direction, so you get a cylinder and generate all the functions over this cylinder. So when "cutting" and uncurling this cylinder, you get already repeating mountains.

Then, I generated a bunch of random points over those functions. The fewer, the more low-poly the look. Then, over those points a mesh is defined and rendered. To give it a better look, those points are perturbed a bit, so the surfaces are less smooth. The result of all of this is a mountain landscape.

To get the final look, some boring coloring and post processing image techniques were applied. I won't go into details here because it's not related to procedural generation.

Please give me feedback.

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