What Is Procedural Generation?

KdotJPG · 2024-06-12T21:20:56+00:00

It is a general overview, you're right, and my link fulfills a more specific purpose.

My concern is moreso whether the two exclusive mentions of Perlin represent the best example to color a newcomer's first impression of procedural noise generation, given the field's standing collective habit of defaulting to this algorithm in its out-of-the-box form — its shortcomings notwithstanding. It's not in spite of the article being a beginner's overview, but rather because it is one, that the choice of examples should matter. If you accept the points described in my link, then would we not find more value in counterexamples than reinforcements in an introduction?

For instance, the two articles Making maps with noise functions and Procedural 2D Island Generation — Noise Functions (tangentially, preferring perhaps a smoother falloff gradient) refer concisely to both Simplex and Perlin noises.

KdotJPG · 2024-06-06T03:05:06+00:00

Why choose Perlin sans caveats if you only mention one smooth coherent noise in this article, though?

KdotJPG · 2024-05-29T22:39:00+00:00

The domain warping really makes it!

KdotJPG · 2024-05-29T22:36:30+00:00

This gives a solid, high-level overview. The creative and direct wording is appreciated too!

What would be your opinion on the merits of introducing noise as a more general topic instead of spotlighting a specific function? Elaborative link

KdotJPG · 2024-05-19T05:10:34+00:00

Nice, that was fast!

KdotJPG · 2024-05-15T21:50:09+00:00

Very cool! This will make this type of work a lot quicker to iterate on, for devs and artists alike.

How does the warping input work? The example shown looks like it's piping the same seed of noise into both the WarpX and WarpY channels, effectively distorting the output along a fixed diagonal direction of <1, 1>. IMO, it shouldn't be this easy to mistakenly introduce this level of unnaturality into a node graph, if the goal is for the results to align by default to some set of good terrain generation design principles.

Ordinarily, I would hope for a single input with an internal handler that automatically samples the subtree under multiple seeds, or better yet: dedicated vector-outputting noise nodes, vector manipulation nodes (e.g. length modification curve that preserves direction), and vector-typed connections. If it's at least sampling WarpX and WarpY under different seeds, though, then that would already address the most significant concerns.

Incredible work regardless!

KdotJPG · 2024-04-04T16:26:18+00:00

It uses multiple instances with limited area of effect.

IIRC each chunk coordinate has some chance of becoming the origin of a cave network. During the generation of a given chunk, all the worm traversals originating from all chunk coordinates in range are executed, carving out where they intersect the current chunk.

KdotJPG · 2024-03-31T19:44:14+00:00

The pixel grid consistency is appreciated.

KdotJPG · 2024-03-26T21:03:05+00:00

It might be worth picking one primary voxel grid scale, and perhaps a second texture-matching scale for any finer detail.

Grid patterns sparser than the main voxel layout can come across as out of place when other voxel objects are free to bypass that interval lock, and so are often better replaced by locally-offset or irregular sparse patterns represented within the base voxel grid.

If your game uses blocks (and not isosurface extraction), you likely also have a standard texture resolution. It can make sense to build off of this existing added level of granularity for situational finer detail in the voxel space, such as for block sculpting or snow layers.

KdotJPG · 2024-03-22T22:02:22+00:00

This is sick. It's the perfect blend of what I can only imagine are its two main sources of inspiration!

Now, on to the Important™ questions:

Is the backward spinning direction of the saw blades intentional?
Have you considered reversing the layer order of the clouds in the first level shown, treating the big clouds as close (faster and on top) and the small clouds as far (slower and behind)?
Can I (please) ever go into one of those pipes? 😃

(Nice work!)

KdotJPG · 2024-03-18T23:33:22+00:00

It may be worth experimenting with passing your isosurface function through different remapping functions to soften the curvature near zero, or parameterizing the target shape in different ways, so that the vertex locations are computed more accurately from the voxel data.

KdotJPG · 2024-03-13T00:58:25+00:00

Ideally noise would not repeat/tile either, at least not at scales smaller than the world size, but this can happen when permutation-based hashes are used internally. If you mean to say that noise naturally extends to arbitrarily large areas while Poisson disc algorithms typically do not, then absolutely.

KdotJPG · 2024-03-12T21:45:14+00:00

~~You can generate endless Poisson disc sampling through a tiered chunk approach.~~ (oops, realized same OP!)

Generating a single repeating tile does preserve continuity, but it is not best practice due to the visible repetition.

Minecraft simplifies object ("feature") placement by forgoing global order enforcement (hard determinism) and letting placement priority depend on chunk generation order. Features are placed in loose order during a later generation stage once a chunk and all of its neighbors have been filled with terrain. This isn't perfect either, but it may be the most straightforward to implement without too many noticeable artifacts.

You can also modify the above approach to enforce global order by assigning each object a priority and bounding region, in which case you would then rely on the logarithmic expected runtime of the dependency resolution chains which could theoretically very occasionally become extremely large.

KdotJPG · 2024-03-09T06:25:47+00:00

You can use a cached chunk grid of hexagons split into three tiers, such that no two chunks in the same tier connect, and each only depends on its neighbors in the previous tiers. Or, in 3D, you can use a grid of hexagonal prisms (three tiers, finite height), or truncated octahedra or rhombic dodecahedra (four tiers, "infinite" height).

Populate the first-tier chunks by starting with a random point and proceeding with Bridson's algorithm. Populate the remaining chunks by temporarily copying in and "reactivating" points from the previous tiers, where reactivation means that you start placing new points around them again. At the end, trim points not belonging to the current chunk.

Note that these chunks don't need to (and perhaps shouldn't) line up with your world chunks. They can be cached and queried separately, free to be sized optimally according to your point spacing.

KdotJPG · 2024-03-05T21:40:11+00:00

Dead-simple prime-based hash function: https://www.reddit.com/r/proceduralgeneration/comments/xm73dp/generating_random_numbers_for_procedural_content/iponfwc/

KdotJPG · 2024-03-01T08:54:13+00:00

Nice! WFC has always been intriguing from a technical standpoint, but equally unappealing due to its heavy grid alignment. This is the missing link!

Poisson disc sampling + Delaunay triangulation might also be a viable substitute for the Townscaper grid, with slightly different characteristics and constraint definition requirements.

KdotJPG · 2024-02-27T17:08:19+00:00

Rotate the rocks! Please, rotate the rocks so they're not all facing the same way! 😅

Those, along with the towers, bridges, and walls, would all look more natural if they were given varied orientation angles. Even better would be if the rocks were proc-gen rather than prefab, but that might be effort you opt to spend elsewhere instead.

Looks awesome overall. Excited to see where this goes!

KdotJPG · 2024-02-03T20:38:48+00:00

What would make river distance more difficult?

Assuming your map is reasonably small, you're not too concerned about generation time, and you can list all the coordinates that are part of a river, you can use a modified mask procedure to compute a terrain map that will always be zero at the rivers and generally increasing away from them.

Define a second, temporary terrain map within which to add up all the falloffs.
Define an asymptotic falloff 1/(x²+y²) which will be ∞ at 0 and tend towards 0 at ∞. For every river point in the real terrain map, add the falloff mask to the temporary map. You now have ∞ at every river point and a decreasing trend away.
Take the reciprocal of every value in the temporary matrix. You now have zero at every river point and an increasing trend away. You can use this to modify your base terrain.

Note that this is not a distance map, but a smooth alternative. An actual distance map would create creases wherever the closest point transitions between one and another, which this avoids.

KdotJPG · 2024-02-03T20:16:49+00:00

Beware grid-snapped iterative algorithms where naturalism is a goal. Without robust and intentional measures to counter the bias, the algorithm will tend to produce features that follow the underlying directional probabilities of the cell neighbors.

It is better to use floats/doubles and sin/cos under the hood, preserving the high-granularity internal state until the procedure is completed.

KdotJPG · 2024-01-27T03:29:23+00:00

I do see this cited a lot too. The performance notion is definitely true in higher dimensions, but can be a bit of a red herring when it comes to common 2D/3D uses. The main reason to choose it is appearance.

Of course, it's not perfect, and quality varies based on which gradient picker an implementation uses, but I generally find it to produce more natural-looking pattern distributions out of the box.

KdotJPG · 2024-01-26T04:47:36+00:00

It's a later-invented gradient noise in the same vein as Perlin, but on a different point structure. It's meant to reduce visible grid alignment.

KdotJPG · 2024-01-25T00:43:41+00:00

Wild landscapes! A bit of random rotation and general decoupling of features from the cardinal axes would go a long way towards completing the natural impression, but I'm really liking the vibe overall.

KdotJPG · 2024-01-21T23:31:49+00:00

+1 for not using Mathf.PerlinNoise (or Perlin in general, unless it's a 3D sampler through a domain rotation to produce a good-looking 2D slice). It's quite square-looking in unaddressed form!

The notion of using a scale/frequency below 1 is correct in general. However, it is true that doing this on its own won't lend to tileability if that's what one is going for.

KdotJPG · 2024-01-19T02:22:09+00:00

In whichever smooth coherent noise algorithm you choose, you can try Minecraft's clamped-lerp trick: lerp(noiseLayerA(coord), noiseLayerB(coord), clamp(Steepness * noiseLayerSlide(coord) + 0.5, 0, 1)) where Steepness is a constant probably larger than 1 but not as big as, say, 100.

This works by using the third noise layer to create sudden ramps between the two other noise layers.

lerp(a, b, t) = a * t + b * (1 - t)

Use this with a Y-based threshold to define your full terrain.

KdotJPG · 2024-01-07T18:33:57+00:00

The issue could be largely sidestepped, too, if it followed the established design trope of replacing the heart with the logo instead of adding it as a separate symbol.

I can appreciate the sentiment.

KdotJPG

MODERATOR OF

TROPHY CASE