I'm adding support for a new channel in my terrain streaming system for vegetation density. I am baking LOD'ed data from Copernicus Global Land Cover (PROBA-V LC100) for tree/shrub/grass cover. No vegeration rendering yet though. 😓

Regarding the synthetic fine detail I am experimenting with here, that is a world-coord-evaluated noise added by a compute shader as each tile is uploaded to the GPU.

All that information is pre-baked. After some head-banging against the keyboard, I found the cracks were caused by a signed vs. unsigned mismatch in a modulo operation at tile boundaries.

Geo-morphing in my engine is designed so each tile is self-contained with all the information it needs about itself and its neighbors. No cross-tile lookups at boundaries.

I finally fixed all the cracks at tile boundaries in my terrain engine + I started experimenting with run-time procedural fine detail over the GIS data

#indiedev #gamedev #computergraphics #procedural #terrain #rendering

I finally found some time to try to make sense of and port (~ verbatim) to my Vulkan framework this paper and example code repo: (PB-MPM by Chris Lewin @ EA). I'll try to add dual coupling with rigid solids at some point.

#mpm #sim #vulkan #gamedev

I've been fleshing out the subsystems for actors, user input, and Jolt physics integration.

#indiedev #gamedev #computergraphics #procedural #terrain #rendering

Taking some clunky baby steps: Better actor vs. terrain collision + Mostly fixed cascaded shadowmaps

#indiedev #gamedev #solodev #customengine #procedural #terrain

Getting ready to drop some non-procedural geometry in the terrain engine. 💥

#indiedev #gamedev #solodev #customengine #procedural #terrain

The physics is based on an elevation cache that reads back the terrain from the GPU (GIS-based + procedural GPU detail), kept alive only in the vicinity of active actors. This will allow for sparse planetary-scale physics.

Don't mind the many issues in the demo: faulty cascaded shadow maps, some terrain seams, lousy navigation controls...

For the physics backend, I cobbled together a minimal Rust wrapper of the fantastic Jolt (by @jrouwe). Built using f64.

Starting to add physics to the terrain! Dropping massive 500m spheres and watching them roll down the mountains 🏀

#indiedev #gamedev #solodev #customengine #procedural #terrain

Beyond GIS elevation data limits, procedural detail is added on the GPU. Elevation bounds for culling (yellow boxes) and tile heightfields for physics use async GPU read-back. Still experimental!

#indiedev #gamedev #solodev #customengine #procedural #terrain

This must be decoupled from rendering for actors other than the player, such as AI tanks and missiles, which need terrain collision data even when they're off-screen.

A new elevation cache (leveraging the same systems as the render tiles cache) will be used to cook heightfields for the physics system. Actors (like the camera) read-back tiles from the GPU in their vicinity at a specific LOD level.

#solodev #indiedev #gamedev #customengine #procedural #terrain

Ocean waves swell in Z, intersecting terrain in low areas like beaches. I render terrain into the stencil buffer to exclude water from terrain pixels. The first part of the video toggles stencil on/off.

#solodev #indiedev #gamedev #procedural #terrain #rendering

First integration of the ocean system into the terrain with aerial perspective 🌊

#solodev #indiedev #gamedev #procedural #terrain #rendering

ELLIPSE: Find the four points where the tangent slope is exactly +/-1. These 4 points define a parallelogram. Each pt defines a corner region, and each consecutive pair defines a band. Vertices are clamped against the conic solved for X or Y depending on which band or corner they fall in.

To clip the screen-space grid onto the conic:

HYPERBOLA: Rotate the conic so its transverse axis aligns with Y, then solve for Y. Vertices inside the forward branch (ocean side) are left unchanged. Vertices outside (sky side) are clamped along Y toward the curve. The result is then unrotated.

Conics are quadratics, so the screen-space horizon involves square roots and sign flips that make the algebra obnoxious. In particular, the hyperbola produces 2 branches: the actual horizon ahead of the camera, and a virtual projection from the part of the sphere behind the camera, mirrored.

When seen from afar, the ellipse is the obvious case. The hyperbola appears when you are close to the surface, looking toward the horizon line. The parabola case only happens when the ellipse is about to become a hyperbola and vice-versa.

The horizon in case (4) projects as one of the following conics:

4.1. An ellipse (or a circle if the camera is centered on the sphere).
4.2. A parabola, which I treat as a hyperbola by nudging the coefficients numerically.
4.3. A hyperbola.

There are four main cases:

1. Camera inside planet (point-in-sphere -> skip).
2. Camera looking away from planet (sphere outside frustum -> skip).
3. Camera sees only planet (all frustum corners hit sphere -> grid unaffected).
4. Camera sees both planet and sky (horizon visible).

This is an implementation of what I was talking about in my previous post: A grid in screenspace, clipped to the horizon (conic) of the planet (a sphere) for ocean rendering. 🧵

#solodev #indiedev #gamedev #procedural #terrain #rendering

Clipping to the ellipse is a little more convoluted. Clipping to the hyperbola is "basically" clamping sky vertices towards the branch that matters and disregarding the mirrored one, like so. The parabola case I am treating as a degenerate hyperbola.

Doing the math you end up with a quadratic, where the sign of A tells you the conic type (A<0:ellipse, A>0:hyperbola, A=0:parabola).

The image plane slices through this tangent cone. A plane cutting a cone gives a conic section. That's literally where the name comes from. So the horizon of a sphere in screen space is a conic: ellipse, hyperbola, or in a degenerate case, parabola.

Why a conic? The set of all rays from the camera that are tangent to the sphere forms a cone. The apex is the camera (eye), and the axis points toward the sphere center.

For planetary ocean rendering I use a screen-space projected grid. The grid starts as a flat mesh in NDC, and each vertex is projected onto the sphere surface. But what about vertices that point at the sky? You need to clip the grid to the horizon. The horizon is a CONIC SECTION.

#solodev #gamedev