99
Created by @r_channels
Procedural Generation Software
Hi everyone!
I'v been working on a tool for some time now.
I'v seen myself writing the same code again and again in different engine or project regarding
procedural content generation stuff. This tool is my attempt to focus my effort in one single tool
while still being able to use it everywhere i want.
Features for now include :
\- Some noise function
\- SDF Primitivces (Cube, Sphere, Plane...)
\- SDF Boolean operation (Union, Substraction, Intersection, & smooth version)
\- The ability to generate arbitrary point/randomize them
\- Node to render SDF at those point, for scattering rock for example
\- And some other random thing like utility node etc
Of course there is a gazillion things i want to add but for now that's what there is!
It's not ready yet even for a pre-alpha release, i still have bugs to fix things to add etc etc. i'm also on linux so it's hard for me to check everytime if it works on windows, but thanks to my friends it still should work on windows no problem. if you still want to try it you can compile it from the source : https://github.com/HITOA/gin
I'll be more than happy to talk about the tool for criticism/feature idea or anything else really.
It's my first time sharing something that iv made like this so i'm not sure how that work but i'm open to people contribution in the repos. Thanks & Have a nice day!
Demo video on ytb : https://www.youtube.com/watch?v=JkhjU9\_8bAk
https://reddit.com/link/1cdk96g/video/ry3a23fcitwc1/player
https://redd.it/1cdk96g
@proceduralgeneration
arrangements - python + some gimp
https://redd.it/1cd2fnc
@proceduralgeneration
A dumb question about procedural generation and "seeds"
Hello, i like this reddit as i always find really interesting visual stuff, thanks a LOT to all the people that contribute here.
I have one little question : i like playing video games and i really liked some good procedural generated world games (Rimworld, Valheim, Dyson Sphere Program, etc...). There is always a "seed" to enter and i wanted to know how the concept of seed works.
I always thought the procedural was putting some RAND() function in the world generation code, but the seed imply if you know it you can generate always the same world, right ?
Is it possible to explain easily (as i'm not really a mathematician or engineer)
Thanks in advance
https://redd.it/1ccwol7
@proceduralgeneration
Looping circuits :D
https://redd.it/1cc4i5d
@proceduralgeneration
My attempt at a procedural galaxy generator using Unity VFX Graph
https://youtu.be/zuwSsXtEngk
https://redd.it/1cb7oqs
@proceduralgeneration
Need help with possible rendering issue in WebGL
Hello, I'm working on a game for itch.io using Unity and C#. I modified an asset pack (Pixel Heroes: Fantasy Editor) to generate random enemies for each level.
In the Unity editor, the sprites appear clear and each one is unique:
https://preview.redd.it/115ccp0tg3wc1.png?width=461&format=png&auto=webp&s=b6bff0e7a51b8c972b46da67f3e6cd8f30f2fa05
However, on itch, when the enemies appear on screen, they are displaying like this:
https://preview.redd.it/4p4sqymqh3wc1.png?width=571&format=png&auto=webp&s=4cfc8c3143be32abb61ed6c8ee87af745baf39fa
Has anyone come across something like this before? I've tried everything I can think of to get them to render properly, from adjusting the texture compression settings (ASTC & ETC2) to attempting to pre-load the assets from the sprite collection.
I'm starting to wonder if it's not a compression issue at all, but maybe something completely different? Any advice or thoughts on this would be greatly appreciated.
https://redd.it/1calxtb
@proceduralgeneration
Stylized grass made with blender
https://redd.it/1ca6i75
@proceduralgeneration
I've been sucked into Procedural Generation for the 3D web
https://youtu.be/XUoICFxEhfg
https://redd.it/1c96m9n
@proceduralgeneration
Audio Reactive Elementary Cellular Automata
https://redd.it/1c8r5s4
@proceduralgeneration
Using GLSL shaders to make perlin noise generation much faster: using several octave layers, 1000x1000 points, exports to either binary file or .obj
https://redd.it/1c8okjp
@proceduralgeneration
[R&D] Procedural Stylized Eye | Houdini
https://redd.it/1c7t8un
@proceduralgeneration
Resources for learning about procedural generation?
I am relatively new to programming but am enthusiastic to learn. I am learning some rudimentary C++ and C# to use with simple creations in Unreal 5 and Unity.
I would like to learn about how I can create simple scenarios that generate themselves within certain parameters based on current and historical user input. Think something simple along the lines of The Oregon Trail, but with more branching paths that are generated randomly.
My goal is more or less to create a "tool" to generate (realistic) role-playing scenarios at random based on either custom input or randomly-selected variables (I'm in an office setting/I'm at a school/I'm in a mall/I'm working at a data center; it is September/October/December/whatever; we're in Maine/Texas/California/somewhere; there is an aggressive trespasser/shoplifter/active shooter/weirdo with a silly hat) for recipients to respond to.
What tools might I learn and use to accomplish this?
https://redd.it/1c6tsro
@proceduralgeneration
I hosted a panel about procedural tooling in game development at GDC this year!
https://youtu.be/o1cQ43eKlQQ
https://redd.it/1c6bv1p
@proceduralgeneration
Best approach to upscale height maps?
Hello everyone,
I'm developing a game and I'm currently stuck in a problem during my world generation process: I first generate a 512px x 512px height map of an island and then I want to let the player choose a start location. During gameplay, the actual chunks are generated and each pixel in the overworld should account for 32x32x32 blocks in the real world.
Here are some examples of the height maps generated and how they currently look in game:
https://i.imgur.com/ST6YwyK.png
https://i.imgur.com/fCgRY1K.png
https://i.imgur.com/NdCd6WJ.png
Up until this point, I have been using the same noise functions but decreasing the frequency so that the noise appears scaled. This has some issues though. First of all, we loose a lot of detail. This can be somewhat worked around increasing the number of simplex noise octaves layered, but I'm not sure it's the best approach.
Worse than that, I started implementing biomes and other features that I want to be generated based on an analysis of the map. E.g., identifying coasts to generate beaches, using a unsigned distance field to be able to lookup the distance from the sea, finding local maxima to generate volcanoes, etc.
This analytic pass on the generated map seems incompatible with my current flow of generating chunks on the fly. It seems that I need to somehow upscale the initial generated maps.
I found [this](https://www.gamedev.net/blogs/entry/2277772-dithered-fractal-interpolation-for-procedural-generation/) post describing an approach, but before diving too deep in this rabbit hole, I wanted to ask if anyone has other resources or ideas on how to solve this issue.
If anyone is interested, here's the repo for my game:
https://github.com/stefandevai/ysamba
And here's the initial height map generation (the code is very dirty as I'm still experimenting with a lot of things):
https://github.com/stefandevai/ysamba/blob/main/src/world/generators/island_generator.cpp
Thanks a lot in advance :)
https://redd.it/1c65s7b
@proceduralgeneration
Complete procedural race track generator!
https://redd.it/1c5kfe8
@proceduralgeneration
Risk like map generator
I made a risk like map generator for my next game
It has different landmass creation methods
Usa markov chains for name generator
https://preview.redd.it/zy3o0dew9twc1.png?width=1922&format=png&auto=webp&s=b15b4ba24bb37ba77e933c006c8a237ffd23a69f
https://preview.redd.it/blzj0t4x9twc1.png?width=1922&format=png&auto=webp&s=941df0ad9d83982d1dfa7ec7a397424be98355de
https://preview.redd.it/v2y2i9yx9twc1.png?width=1922&format=png&auto=webp&s=e0e4421a7004ce1777b0d447938045d5b4a5b2df
https://preview.redd.it/ecegpi0z9twc1.png?width=1922&format=png&auto=webp&s=e804a8e814def7e94cc612dfc5d34038f5ed955d
https://redd.it/1cdj0bj
@proceduralgeneration
mystery-o-matic: open-source murder mystery generation using fuzzing testing
https://github.com/mystery-o-matic/mystery-o-matic.github.io
https://redd.it/1ccxzcb
@proceduralgeneration
Flowfields
https://emildziewanowski.com/flowfields/
https://redd.it/1cc9t04
@proceduralgeneration
Dot product of vec2(x,x) and vec2(y,y) graphed creates a star:
https://redd.it/1cbmuck
@proceduralgeneration
Added Unique Procedurally Generated Enemies in Slimefinity Idle
About a month ago, I released a prototype for a game I’ve been working on. It’s an incremental idle game where players are rewarded for not restarting the game to collect rewards.
I updated this to have procedurally generated unique enemies each time a new one is spawned. If you’re into this type of game, let me know what you think!
https://echoswarm.itch.io/slimefinity-idle
https://redd.it/1carlhg
@proceduralgeneration
My obsession with procgen led me to create a cozy island builder game with procedural generation tools
https://redd.it/1cac7jp
@proceduralgeneration
Sorcery (Made with Geometry Nodes and Simulation Nodes)
https://youtube.com/shorts/7UagkXWrFRo
https://redd.it/1c9fdhi
@proceduralgeneration
Voxel spell crafting in my game Emergent Magic
https://redd.it/1c93zs5
@proceduralgeneration
Full level runtime procedural generation, UE5
https://www.youtube.com/watch?v=6Pi-QYDTWI0
https://redd.it/1c8qg49
@proceduralgeneration
Shells.
https://redd.it/1c86120
@proceduralgeneration
Mercurial Collection // see comments for full collection
https://redd.it/1c75y5d
@proceduralgeneration
The Muirhead-Newell Endless Maze Algorithm
https://intarch.ac.uk/journal/issue59/3/full-text.html
https://redd.it/1c6n0qs
@proceduralgeneration
improved snow placement - perlin noise procedural terrain
https://youtu.be/_McyuIgSws8?feature=shared
https://redd.it/1c68cv5
@proceduralgeneration
Just discovered what happens if you multiply consecutive Perlin noise octaves instead of adding them.... Looks kind cool!
I on a whim, thought about multiplying consecutive octaves of Perlin noise instead of adding them, and the results look quite interesting. It's as though it is an inversion, but more visually fractal like.
Both were generated on the same seed using unity built in Perlin noise functions.
https://preview.redd.it/027nc4vhdwuc1.png?width=1080&format=png&auto=webp&s=d9cc199a5ab411b4b143a2c049ae69cede0b8751
https://preview.redd.it/kke1t1vhdwuc1.png?width=1080&format=png&auto=webp&s=b1321713f065587402d43b11c4525f9c3d1a703e
https://redd.it/1c5prth
@proceduralgeneration
Differences in different types of noise?
Are there certain benefits to different types of noise, like Perlin and Open Simplex noise? I am working on procedural map generation for my 2d game but I want to code my own noise function (as a way to learn and understand the inner workings)?
https://redd.it/1c50n3e
@proceduralgeneration
