99
Created by @r_channels
I've been working on the procedural generation techniques I'm using in this game for years. The maps are entirely procedurally generated, and the missions placed throughout. How does it look? This is my game trailer.
https://redd.it/1bx1noe
@proceduralgeneration
Realtime Refractions with a SDF and a Raymarcher while using different Boolean Operations
https://redd.it/1bvsioe
@proceduralgeneration
In my 4X game, I craft landscapes using the Square Diamond algorithm and thermal erosion, then simulate river paths by tracking the steepest slopes and identifying the lowest passes from depressions encountered. Valleys around rivers are then shaped using Perlin noise. Your thoughts?
https://redd.it/1bvfml7
@proceduralgeneration
Everything Procedural Conference in Breda on April 18 and April 19
Just wanted to share this conference (Everything Procedural) that is happening in Breda (the Netherlands) on April 18 and April 19. There is a nice variety of talks on procedural generation for games. More info can be found on the website: www.everythingprocedural.com
Before the conference there are also several Masterclasses that can be attended, more info on the website.
https://preview.redd.it/k0tl4n6sf8sc1.png?width=1920&format=png&auto=webp&s=99137beacecfc23ed5f62d94bc4ce48f93741dfe
https://redd.it/1buo6o1
@proceduralgeneration
Finally got my steam page up for the procedural city / world game project :-)
Wanted to share my (currently) 100% procgen city game / world page with you as I post here semi-regularly: Infinicity on Steam (steampowered.com)
https://redd.it/1bulk50
@proceduralgeneration
I have a question regarding the implementation of Perlin noise.
I'm trying to understand the implementation of the Perlin noise algorithm on this website: https://rtouti.github.io/graphics/perlin-noise-algorithm
Specifically, I don't understand the following part:
const topRight = new Vector2(xf-1.0, yf-1.0); const topLeft = new Vector2(xf, yf-1.0); const bottomRight = new Vector2(xf-1.0, yf); const bottomLeft = new Vector2(xf, yf);
From my understanding, this part is generating the corner points around the input coordinates. However, I don't understand why they are subtracting 1.0 from the input coordinates for topRight and bottomRight.
Additionally, I thought the original Perlin noise algorithm involved taking the dot product of the distance vector and the gradient vector. But in this implementation, it seems to be taking the dot product directly with the corner points:
const dotTopRight = topRight.dot(GetConstantVector(valueTopRight)); const dotTopLeft = topLeft.dot(GetConstantVector(valueTopLeft)); const dotBottomRight = bottomRight.dot(GetConstantVector(valueBottomRight)); const dotBottomLeft = bottomLeft.dot(GetConstantVector(valueBottomLeft));
I would appreciate if you could explain the reasoning behind these parts of the implementation.
https://redd.it/1btmff6
@proceduralgeneration
Conway Game of life with time represented as Y axis (done with three.JS)
​
https:\/\/shannonegoiste.github.io\/ConwayTreeOfLife\/
https://redd.it/1bt8tkq
@proceduralgeneration
made some ring sprites procedural (can be used in games) :) kind of less variety based on the fact that there are just rings :)
https://redd.it/1brl5qs
@proceduralgeneration
Procedurally generated weapons info UI overhaul
https://redd.it/1brizgm
@proceduralgeneration
I added a Step Function node into my Procedural Generation asset
https://redd.it/1bqth7m
@proceduralgeneration
misty mesh
https://redd.it/1bpuaef
@proceduralgeneration
I made this 3 months ago using Blender, been busy. I had a few trys at porting it to a language, python is obviously slow but proved the algorithm until it choked. I know Unity, kinda know Godot, not much knowledge in Unreal. C# script is there in Unity, or should I bite and make a compute shader?
https://youtu.be/W9k8nn5-KQU
https://redd.it/1bpbff4
@proceduralgeneration
Chunk Generation Questions
Hey guys, kind of a procedural generation noob here. I’m working on a top down 2D mining game for fun and am wanting to start diving into generating “infinite” terrain and have a couple questions about how to go about it. Especially insuring that the terrain will generate the same way with the same seed no matter how it’s explored.
I’ve played around with different noise maps before and have watched a lot of videos on them so I have a pretty good understanding of how that aspect works. But here’s what I’m wondering:
1. How should I generate ore veins? I know I can’t use random number generators to place them because loading chunks in a different order will get different results. Do I use a different kind of noise map? If so, what kind?
2. Do you have any tips for generating caves in a seed repeatable way? If I have a sort of walker go around and carve caves, that doesn’t span over ungenerated chunks, and once again will change depending on what other things are randomized before it.
3. What is your go to method for generating biomes? I’ve tried a few methods, but haven’t found something that works super well.
I love the idea of procedural generation and have played with the idea in different ways for a long time, but I really want to make the terrain nice in this game.
Thank you for your feedback!
Edit: Typos
https://redd.it/1bpbidy
@proceduralgeneration
Model synthesis/ Wave function collapse with ai
I am an AI and procedural generation enthusiast and when I discovered the two algorithms model synthesis and wave function collapse I asked myself: would it be possible to use a neural network to carry out the task of building the model output, an AI model capable of determining adjacency constraints and randomly drawing one of the possible labels. And could this AI model also be more efficient in terms of execution time and memory costs? Or we can't make it more efficient than ms/wfc with an artificial neural network
https://redd.it/1bowwdr
@proceduralgeneration
Per-vertex smoothed ambient occlusion for Surface Nets meshes and Voxel meshes
https://redd.it/1bolu23
@proceduralgeneration
Realistic Ocean Simulation: Multiple Cascades Bug Fix
https://redd.it/1bwonre
@proceduralgeneration
Better Mountain Generators That Aren't Perlin Noise or Erosion
https://www.youtube.com/watch?v=gsJHzBTPG0Y
https://redd.it/1bvo8c0
@proceduralgeneration
How can endless worlds be generated with such precision? And how can you teleport in noise-based worlds if it needs the data of nearby area to generate itself?
I am building a top-down game, but the terrain generation is kind of weird. How does games like Minecraft can generate itself in a concise way? In my understand, games like these don't generate all at the same time, they generate as the player explores the terrain. But let's say I teleport one chunk at a time, making a checkerboard pattern, all the loaded terrain will be right and connect. If I ask the game to generate again, but this time, generate the other chunks in the checkerboard pattern, the results will be the same. How can this be possible, as to generate one chunk, you need the information of the ones around it. How can a game know how to generate a faraway chunk if all those to get there were not generated yet?
https://redd.it/1butfbb
@proceduralgeneration
Using drunken walk for height maps
Saw this great video about height map generation yesterday, thought I'd share it here... Specifically it is about a couple of methods of generating that eroded mountain look without the expense of an erosion simulation.
https://www.youtube.com/watch?v=gsJHzBTPG0Y
The second method he looks at is based on Diffusion Limited Aggregation.
In DLA, they pick random unset, or "low" pixels, and move them around randomly until they bump into a set "high" pixel.
This seemed to me to be an incredibly inefficient method, and I had a couple ideas for changes - instead of randomly moving pixels around the void until they hit the structure, why not randomly pick a point on the structure and expand it into the void, and instead of applying height afterwards via a blur filter, why not step the height down when new pixels are plotted...
At this point it is pretty much a drunken walk maze generator, except with heights. One nice side effect is that from any low point, there should always be a traversable path to the highest point, but if you add a water level, not all shorelines will lead to the peak, since it makes a lot of cliffs, by design.
I also wanted to try out ChatGPT as a code assistant, and it managed to write about 90% of this little javascript thingy today, it has a few parameters you can mess with for different output:
https://planet11games.com/drunkwalk/
Thought some of you might find it interesting, I might get ChatGPT to put the output in WebGL 3D context next...
https://preview.redd.it/dgzumhpnr8sc1.png?width=512&format=png&auto=webp&s=91954fbcc673bd27dd7456a8a63cfcb734f647e2
https://preview.redd.it/x2vu1awmr8sc1.png?width=512&format=png&auto=webp&s=9f2e5de56bf727048de744ff662249c732838c4a
https://preview.redd.it/rnqsjxcmr8sc1.png?width=512&format=png&auto=webp&s=f10570ed7a576a8f04ad21dfc760134614414e30
https://redd.it/1bup6wm
@proceduralgeneration
I've finally made a trailer for my procedural open-world survival game Forty-Niner set in Wild West!
https://www.youtube.com/watch?v=04hpb-_e9Nk&t=1s
https://redd.it/1bueilf
@proceduralgeneration
These are the lessons I've learned by making procedural low-poly mountains with Unity Shader Graph
​
https://reddit.com/link/1btfnne/video/uccip5p1lxrc1/player
I'm creating a rhythm game that use procedural terrain for background. However, as of recently, this background was handled by script. The performances were not ideal, and it became worse once I wanted to animate it! For a rhythm game, this is not tolerable.
So I rebuilt it entirely with Unity Shader Graph, so that it relies on GPU only. After all, it's just vertex displacement on a low-poly plane. It can't be that hard, right?
Well, there was some catches though. Some being tough to resolve! So for others not to make the same mistakes as I did, I made this short video listing some advice for making low-poly terrain with Unity Shader Graph:
https://youtu.be/g4hfedgrjKA?si=XOfq4E\_FA3hrb1Qz
I hope it'll be helfpul! I made the choice to make it into an "advanced techniques" video rather than a tutorial. There a plenty of video for beginners on the web, and although they can be extremely useful, they take a lot of time when I'm already familiar with the tool and want to learn something new or get a specific information. So I made it for people who like me, know how to use Unity Shader Graph, but want to learn some advanced tricks with that can be used in different shaders.
https://redd.it/1btfnne
@proceduralgeneration
"Siloed" + 2 - python
https://redd.it/1bsmgbx
@proceduralgeneration
dragonskin
https://redd.it/1brjhx2
@proceduralgeneration
working on a homebrew cylinderizing function in python
https://redd.it/1bra7e9
@proceduralgeneration
Procedural terrain and racetrack using marching cubes (OpenGL / C++)
https://redd.it/1bpvr80
@proceduralgeneration
My Simulated IVY on a Cliff. Any ideas for the next Plant?
https://redd.it/1bpt9tu
@proceduralgeneration
Procedural water flow while deforming terrain in my Wild West survival game Forty-Niner. The whole world is procedurally generated as well
https://redd.it/1bpdcyo
@proceduralgeneration
Cool procedural tech demo running simultaneously in Unity and Unreal
https://www.youtube.com/watch?v=29j_Fc_OtU8
https://redd.it/1boy22a
@proceduralgeneration
Glossophytor: an experiment in algorithmically-generated language
https://old.reddit.com/r/conlangs/comments/1bomxhd/glossophytor_an_experiment_in/
https://redd.it/1boq0ut
@proceduralgeneration
Procedural Alpine landscape
https://youtu.be/ea1Rj6uaOpE?feature=shared
https://redd.it/1bojpcv
@proceduralgeneration
