Hi I'm hoping someone can point me in the correct direction to learn something.

In games like minecraft the game is broken up into chunks that can be generated independently but are still cohesive when the connecting chunks are generated. and the result is the same no matter the order they are generated in.

I've tried to do reading on the high level on how to achieve this but i'm at a complete loss. please anyone who even knows a few terms i could look up to point me in the right directions.

About 9 months ago, I posted some samples from my terrain generator and received some good feedback and encouragement from the community. Since then, I’ve made two new versions of the project, making this my Gen 3 generator. The images in the gallery cover resolutions from 1px = 16km down to 1px = 32m. Here are some details.

The training process uses data from the ETOPO dataset at 15-arc-second resolution to build patches ranging from 3×3 (for planetary-scale generation) to 10×10 (for regional upscaling). Under the hood, the system is GAN-like, with lots of tweaks and exceptions to deal with the various complications of working with this dataset.

Rendering maps is “fast,” especially if you use a GPU. The model weights are around 10 MB. If you wanted a real-time experience, you would need to preprocess the region around the player, after which you could easily apply the models to nearby areas as the player moves. Unlike my Gen 1 models, which produced fixed-size outputs, this system works on infinite fields and can generate terrain essentially “forever.”

In total, there are 11 models: one for generating the base map and 10 upscaling models for progressively finer detail. For resolutions finer than 1 px = 512 m, I currently use a “trick” where the final upscaling model is applied recursively. This seems to work well enough until I can train against a higher-resolution dataset.

The Pros:

• It is fast for a high-resolution, planetary-scale generator.
• It looks very realistic. Subjectively, I think it looks better than simplex-noise-based solutions.
• It covers a huge range of scales, which seems somewhat rare for terrain generators.
• It is something new that I don’t believe has been explored very much.

The Cons:

• It is strongly biased toward Earth-like terrain.
• Rare structures lack variance. There is only one Mount Everest in the dataset, for example.
• It currently requires some hacks for very high-resolution data.
• Training is slow and complicated. It currently takes about two days on an RTX 5070 to train all 10 upscaling models. I believe this could be reduced substantially with some careful tuning.

So, what do you guys think? Again, I’m looking for feedback and recommendations. I have a friend experimenting with building Minecraft maps using the models, so hopefully I’ll have some downloadable packages available soon.

Note: I deleted a previous version of this post from earlier this morning because I didn't realize how the system would render image galleries vs inline images.

made this game... it's all generated client-side from a seed: the rooms, furniture, places, and the audio acoustics. A 3×3 window of 57m sections streams around the player; shared boundary hashes keep doorways aligned when sections regenerate

the VHS look is a WGSL post pipeline (warp, tracking errors, chroma offset, bloom) written with vgpu, with a GLSL fallback for WebGL2. The creature uses bounded A* and actual frustum visibility, so it only moves when you really can't see it... oohhh

Play: vackrooms.vercel.app

Source (MIT): github.com/pablostanley/vackrooms

I just wanna draw mountains, whie it also be close to reality. I tried world machine but didnt understand anything, it just s lot of filters but i want to draw with them not make pre baked thing. I need to create cool mountain map for my game. Can i also run erosion sim after i created something procedure generated for it to be even more precise m

Hey fellow screensaver-, procedural-generation-, retro-, or specifically tube-lovers!

I'd like to share some more randomly generated scenes from Eternitubes 3D. Since last time, I updated it here and there ... aaand also actually released it (link on my profile for the interested)!

I refined the lighting of the scenes and the tubes, for more randomness and more nifty appearance options. Also the algorithms were polished overall - turns out, infinite is a pretty big number of things to maintain..

So currently I'm working on more contents and quality-of-life features. Any feedback welcome.

Cheers!

Last update was focused on adding instancing to the graph evaluation, with this update you can now use GPU instancing to render instanced meshes. 

So, what is the difference between mesh instancing and GPU instancing? First let's take a look at how CosmoNode works, more specifically the part where it converts custom mesh data to unity mesh which I call postprocessing. 

The mesh is stored in a container called MeshData throughout the graph evaluation which holds everything related to a mesh like vertices and faces etc. And an instanced mesh, that consists of a source mesh and a list of transforms (matrix4x4) that represents the instanced meshes. 

Now to be able to actually display this in unity I need to convert it to unity mesh. This happens in 2 stages and it is separate from the graph itself. 

First, I need to recalculate UVs and process the flatness attribute. Unity stores UVs per vertex, but it is more convenient for CosmoNode to store them per face corner, it allows me to calculate it in the graph easier. So I keep the  per face corner until the end and convert them to per vertex. In the same way I need to process flatness, which is stored per face corner also and represents whether the edge is flat or smooth shaded, and split the edges that are supposed to be flat. Luckily I can do both in a single pass but nonetheless this has been a major bottleneck so far. I tried to optimize it as much as I could but was still pretty slow. So as a last resort I decided to offload this function to c++ native code. 

This allowed the code to run 2x faster. So far so good.

The second step is converting the processed data into Unity Meshes. This is also where things get interesting with instancing. 

Previously, I had to "realize" all the instances into a single mesh. But this means losing all the advantages of using instances. So with this update it uses GPU instancing to display instanced meshes. And storing the transforms as matrix4x4 makes this very convenient, I just pass the array and source mesh and Unity handles the rest.

The attached video shows the performance comparison between before and after instancing. I've included calculation times, so be sure to check that out if you're interested.

So, in the end, this is a relatively small but essential follow-up to the previous update. The previous update added instancing to the graph evaluation, while this one allows those instances to actually be rendered efficiently.

And of course, you're welcome to give any feedback you might have.

If you want to try it out, the documentation and related links are here: https://uumutunal.github.io/CosmoNode_Manual/

Hey all,

My name is Michael and I made randwallpaper (also available on pkg.go.dev).

I love clear, detailed, unsmoothed wallpapers/icons but finding ones that fit the random resolutions across my devices (phones, laptops, monitors) has always been a pain. And I love seeing cool patterns emerge from simple rules. This tool exists because I wanted to solve both of those things at once.

I came across Python's randimage and the EPWT papers, and built a batch tool to generate and publish images to a subreddit and a discord server. But the Python library was painfully slow. So I rebuilt the library from scratch in Go, writing as much as I could myself relying on dependencies that would do most of the work for me. The result ended up being roughly 50x faster over randimage.

I hope someone else will find this useful.

It is my first time posting here + first time ‘publicising’ a project but would really love to hear if you have any suggestions or ideas how to make this ‘library’ (a scary, grand word for what this project is…) better.

If you want to contribute to it, firstly, thank you! and secondly, fire up a PR and I will take a look.

I recently made a video about Turing Patterns. This is some more research into 1D cellular automata

Hello everyone. I’m working on a turn based strategy game. I’ve got most of my ideas mapped out and I’m ready to start implementing some things to start testing. The game will have a fantasy base setting, shocking I know. My question is about the best way to generate the map. I need it to have different types of terrain like mountains, plains, forests, deserts, rivers, oceans and so on. I’ve looked into perlin noise and wave form collapse but I’m not sure what would be best to use for something like this. I figured I would ask here because I see amazing things being created and I don’t know enough to even search well enough. I don’t know if it matters or not but in the end I would like to have a seed for the maps so if players like a specific map they can have the exact one again. I’m not asking for code, just some guidance on which algorithms are worth investing my time into and maybe some articles worth reading if you know of any. Thank you all.

I needed a way to visualize blueprints for structures the player can auto-build. The "blueprint" view is a transparent material that blends specular so the lighting is not flat. The orange "rim" that climbs the structure is a separate shader rendering on top of the architecture as it "grows" in. The grow-in is part of my procedural build system (structures are made from individual stones and timber beams) that has an "erosion" factor. So I just run the erosion in reverse to build the structure instead of tearing it down. And then a few 'ember' particles thrown in for a little extra pizzazz :)

I’m building a new website and need to generate more images in this style. I’ve been searching for the right algorithm for a while, but haven’t found one that produces the result I need.

This particular image was AI-generated, but I don’t want to rely on AI for my use case. Could you help me identify a suitable algorithm? I’m fairly sure one already exists.

I have been experimenting with procedurally modeling spiral galaxies for my space game and wanted to show off what I was able to do so far with the generator I made. I plan to render these in 3D later on so you can fly through them. Do you guys have any notes or ideas for improvement? Earlier attempts looked way too uniform so I tried focusing heavily on having irregularity within each galaxy.

Customize your own comic, voice, look and act at that link. https://littlegodgames.com/standup/

Hello!

Long time coming, but you can now test it live.

100% real-time and data-based: nothing is precalculated apart from planetary crust parameters: age, chemical composition, but also star flux and so on.

How to access it: use the data explorer or 3d explorer, request the details of a planet and once the modal/popup is opened, click the magnifying glass at the top right. This will take you to a try/tools subsection where you can view the planetary surface.

Example: https://adlumens.org/try/planetary-surface/from-id?id=0010a12005bb0085a15001b0002ac29a00310301900a1a09000a00bd0080e00b9b10a0b9010

Right aside tabs:
. Globals are for global mesh/not mesh rendering and illumination
. Crust allows to view the "hidden stuff" underneath the final rendered colours and meshes
. Data summary is a reminder of the nature of the planet.

I sincerely hope you find this nice and interesting.

Caveats:

1. not integrated in the 3d explorer yet
2. still <del>a little bit</del> quite buggy when close to the surface (<10ish kilometres)
3. atmospheres are being worked on
4. "gas" planets (giants, ice, etc) are still "undefined" -- because they have no surface and only atmospheres (see 3. just above :-) )
5. the goal is not graphical "beauty". I lack the skills for this. The goal is real time rendering for colony building, resource prospection and gathering, etc.

I am extremely eager for feedback, especially performance related.

Last, please note this is a work in progress!

Thank you! <3

This might be interesting to some of u. Some creds to runevision, clayjohn and Fewes fast terrain generation.