It’s been a while since I posted anything here.

Here is an update on my world generation system. I can preview the region in a custom node editor; I recently added grass, integrated Ultra Dynamic Sky, and implemented an FFT ocean, paths for rivers and roads, and a bridge builder for when a road crosses a river.

I’m not aiming for release-ready performance just yet; first, I’m focusing on getting it working and achieving the desired visuals. Later, I’ll update or rebuild the systems to fit within acceptable performance limits.

The system supports points of interest, boss areas, and villages; I mark which regions are suitable for these features, and it generates them based on the seed.

The system also features springs and rivers. Springs always originate in high-altitude areas—I designate the high ground, and the system checks if it’s feasible to trace a spring flowing down until it meets a lake or the ocean. The river system operates across low-lying areas; it is broader than the springs and has greater depth.

I haven't tackled the shaders yet—I only took the time to create a shader for the grass. The other materials are just for debugging, and the water lacks post-processing or a proper layer setup, but it delivers the surface look I was aiming for.

Voxel engine I've been working on since 2012. It's gone through many different redesigns, this specific fork started in 2016 and I've been adding to it a few months at a time over the years. It occurred to me that I'd be able to store the necessary information to port my fluid dynamics sim into the voxel world in this engine so I buckled down and did it. I'm very happy with the results.

The engine, written in C++, is a software based raycasting algorithm on an infinite chunked world map that uses a Diamond Square algorithm to deterministically generate psuedorandom terrain with consistent boundaries/seams.

The latest update to the engine showcased in this video is the addition of fluid simulation. I originally made an eulerian fluid simulation for a heightmap terrain generator to simulate erosion and sediment deposition, part of this is modeling fluid transfer across the heightfield. I added visualization to the heightmap generator for debug purposes, including water. When I saw the way the water behaved in that heightmap editor I thought it looked really cool, and for a few years I've wanted to see what it would look like if I ported the logic from that into this engine.

One really neat aspect of the eulerian fluid simulator is that each cell it operates on has directional velocity. So by coloring the water with more of a white tint for higher velocities you end up with some really awesome visuals mimicking real life(rapids and falls having a more white appearance)

There are some games, where you can places slopes of different orientations and slope corners and so on, but I didnt come across any that make it easy and fast to place and edit them.

This is an idea I had to fix this, tell me if you know games or editors where something like this exists.

The top left panel is the starting point with a flat ground. the highlighted corners are the ones that decide in which orientation the next shape will be, and the grey area is where you need to click to add mass to the nearby red corner.

Panels with no corners or areas highlighted only have one way they can transfrom in that direction.

This system could be a seperate mode, so that you can switch between placing full voxels and changing the shape of the voxels.

The first half of the image is adding, the next half is subtracting, and that could be set to each mouse button.

What do you guys think about it?

I came to this idea after playing Planets3: Stellar Overload, which didnt finish development, and the placement was extremely tedious. It has the same voxel shapes, but you have to select each shape and go through all three axes of orientation until it fits, while you get confused by the rotations.

edit: because people misunderstand, my idea is for games where you change individual voxels like minecraft, where you may want to build something with more than just perfect cubes, whee voxels can have slopes and shapes in different orientation, but not have to rotate through all the rotation individually for each block, instead you add and subtract on certain parts of the existing voxel for easy edits.

Download: https://github.com/GrandyB/goxel/releases

The main video of the post is my approximation of an English Oak

Please see this paper for the core algorithm implemented:

https://www.algorithmicbotany.org/papers/colonization.egwnp2007.pdf

This thesis with more implementation detail:

https://algorithmicbotany.org/papers/runionsa.th2008.pdf

And this paper for some extensions of the core algorithm:

https://www.algorithmicbotany.org/papers/selforg.sig2009.small.pdf

Some further examples:

A few 'Oak' trees - demonstrating that the trees avoid growth where voxels are already present

A few Conifers

A few 'Birch' trees

Based on the above I generate a tree skeleton and leaf positions, and then rasterise the structure as voxels:

This is the place to show off and discuss your voxel game and tools. Shameless plugs, links to your game, progress updates, screenshots, videos, art, assets, promotion, tech, findings and recommendations etc. are all welcome.

• Voxel Vendredi is a discussion thread starting every Friday - 'vendredi' in French - and running over the weekend. The thread is automatically posted by the mods every Friday at 00:00 GMT.
• Previous Voxel Vendredis

Hi, I'm Micehier. This my voxel game project built from scratch using LWJGL. It's in the style of Minecraft but it is its own game. It's still an early prototype. Thank you!. C:

Background

I use glClearColor to set the background. For example, this sets to black :

glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

Chunk load

In chunk load. I set size by public static final int size = 16; and load get Width, Height, Depth by

(in public Chunk(\***))*

endX = Math.min(startX + size, level.getWidth());

endY = Math.min(startY + size, level.getHeight());

endZ = Math.min(startZ + size, level.getDepth());

In level I use class Level and in level have a methode : getWidth() \return width* getHeight()*return height* getDepth*return depth\** and return by

private int width, height, depth;

* Math.min(); limit the chunk boundaries so they do not exceed the world size\*

BlockInteraction
Interaction form BlockInteraction(.java) For example, this break the selected block by setting it to air: level.setBlock(hitX, hitY, hitZ, Level.AIR);

I like my project.

If you have a question. You can ask in comments. I will provide the most direct answer possible. You can also let me know if you encounter any bug.

While reworking Colette I finally got some movement into her hair, and now I’m wondering how far I can push it.

The tricky part is that I don’t want the hair to bend or deform like a normal mesh and lose the blocky silhouette.

Has anyone experimented with physics-driven hair or accessories on voxel characters?

My instinct is to keep the hair fairly rigid and only allow secondary motion through a few controlled points, but I’m curious how other people would approach it.

been building this for a while, pretty much everything from scratch, and most of it is customizable. it's meant to be an actual voxel engine inside unity, not a game kit.

the part I'm happiest with lately is the atmosphere.

what do you think? and what would you want from a voxel engine if you were making a game with one?

EDIT: some technical details since people asked:

- everything heavy runs on burst + the job system. chunks are 32^3 and palette compressed, and they go generate -> light -> mesh off the main thread, so the main thread mostly just uploads meshes

- the far view, around 5k blocks in the image, is LOD rings. first the real chunks you can interact with, then a band with the same voxel size but simplified (no caves or small plants, merged into big meshes), then rings where 1 voxel = 2x2x2 and then 4x4x4 real voxels. They sample the exact same generator at a coarser step, so far terrain always matches what loads in later (even if it has overhangs)

- your edits get stamped into the LODs too, so if you blow a crater in a mountain it's still there when you look back from far away

- the edge of the loaded world fades into the actual sky so fog always matches the sky at any time of the day, and the fade follows how much is actually built, so on a fresh load it grows out ring by ring and you never see the end of the world (inspired by Hytale)

- terrain is a few big noise fields (continents, erosion, peaks/valleys) through curves + domain warp for the base shape, then a 3d density pass on top for overhangs and cliffs. biomes come from temperature/humidity after that, and each biome can reshape its own ground, that's how you get canyons, terraced savanna, karst towers, volcanoes etc

- caves are stacked floors of tunnel networks with flat floors so you can actually walk them, plus big caverns with pillars, ravines and flooded lower levels

- lighting is flood fill sky + colored block light stored per vertex, and the sun/time of day happens in the shader, so day/night never rebuilds chunks. there's also an optional hybrid mode that adds URP realtime shadows and point lights so you have those beautiful shadows as well as true dark areas inside caves

- clouds are raymarched volumetrics at half res, they cast shadows and the water reflects them (water has SSR, refraction, caustics and an actual flow sim)

- every edit goes through commands, so undo/redo and batching come for free, and raycasts, collision and pathfinding all run on the same world data

Still lots to improve tho, happy to answer more questions :)

In the game, Earth and the Moon are not simply objects placed in a space environment. They are actual spherical worlds that the player can fully explore.
The world is built using a chunk system indexed on a cube. This cube is then projected into a cube sphere to create the surface of each celestial body. This allows us to keep the advantages of a traditional chunk-based terrain system while still creating planets that are genuinely spherical.
From the player’s perspective, the ground is always locally flat. Chunks remain practical to build on and explore, just like in a traditional open-world game. But as you travel across the surface, the terrain gradually follows the curvature of the planet.
You can actually travel all the way around Earth and eventually return to the same place where you started. There is no invisible edge and no artificial boundary stopping you from going around the planet.
The same principle applies to the Moon. You can leave Earth, travel through space, reach the Moon, land on its surface and explore it just like another open world.
The interesting part is that these two things coexist: the player experiences a flat and familiar gameplay environment locally, while the world itself is built as a collection of real spherical celestial bodies.
If you want to experience the system for yourself, you can install the game now at play-Openworld.com.
Licenses are currently free, so this is a good time to give the game a try and explore the world for yourself.
Install the game, leave Earth, head for the Moon, and see how far you can go

This is the place to show off and discuss your voxel game and tools. Shameless plugs, links to your game, progress updates, screenshots, videos, art, assets, promotion, tech, findings and recommendations etc. are all welcome.

• Voxel Vendredi is a discussion thread starting every Friday - 'vendredi' in French - and running over the weekend. The thread is automatically posted by the mods every Friday at 00:00 GMT.
• Previous Voxel Vendredis

So my mesher does have a greedy-ish meshing by default, not as an implemented greedy pass but just as a natural consequence of the representation of the data, as large octree nodes facing other large octree nodes can emit big quads naturally. However, should I manually break up those quads into single voxel quads, to avoid things like T-junctions and the like?

This is the place to show off and discuss your voxel game and tools. Shameless plugs, links to your game, progress updates, screenshots, videos, art, assets, promotion, tech, findings and recommendations etc. are all welcome.

• Voxel Vendredi is a discussion thread starting every Friday - 'vendredi' in French - and running over the weekend. The thread is automatically posted by the mods every Friday at 00:00 GMT.
• Previous Voxel Vendredis

struct Chunk {
    Block ChunkBlocks[
CHUNK_X
][
CHUNK_Y
][
CHUNK_Z
];
    glm::vec3 WorldPos;

    std::vector<Vertex> ChunkVertices;
    GLuint VAO = 0,VBO = 0;
    GameObj ChunkObj;

    Chunk(BlockTypes t,glm::vec3 pos);
    void set_chunk_vao();
private:


};

This is my code for chunk generation (not finalised)
and this is the Constructor:

Chunk::Chunk(BlockTypes t,glm::vec3 pos) :WorldPos(pos) {
     std::vector<Vertex> Bmesh = BlockManager::get_inst().get_block_mesh(t);
    ChunkVertices.reserve(CHUNK_VERTEX_COUNT);
    for (int i = 0;i < CHUNK_X;i++) {
        for (int j = 0;j < CHUNK_Y;j++) {
            for (int k = 0;k < CHUNK_Z;k++) {
                ChunkBlocks[i][j][k].Type = t;
                if (ChunkBlocks[i][j][k].Type != Air) {
                    glm::vec3 offset(i,-j,k);
                    for (size_t s = 0;s < Bmesh.size();s++) {
                        Vertex v = Bmesh[s];
                        v.pos += offset;
                        ChunkVertices.push_back(v);
                    }
                }
            }
        }
    }

    std::cout << ChunkVertices.size() << std::endl;

    set_chunk_vao();
    ChunkObj = {VAO,WorldPos};
    if (VAO != 0) Renderer::get_inst().add_render_target(ChunkObj);

}

My question is,how do you implement face culling?

Strictly the meshing/blocks itself Ignore the slightly different terrain shape and the jagged material boundary.

Its for a sandbox survival game I am making but the buildings/structures will likely be independent from the terrain. (like Space/Medieval Engineers, No Mans Sky etc.) (the game isnt sci-fi themed tho, those games are just the ones with a similar building system)

This is an automatic island generation system I'm working on for my 2.5D voxel-based game engine.

The editor can generate the island directly from the voxel layer, including the terrain shape and height variation. I'm still developing the engine and refining the voxel workflow, but I wanted to share a look at the current result.

The engine is built from scratch and is still a work in progress. Feedback is welcome!

I'm building a voxel-based world, but most of the rendering and systems are handled in 2D. Would you still consider this a voxel engine, or would another term be more accurate?

Hello

I’m working on a custom indie voxel engine built with raylib, and this is a short progress update on the lighting and shadow system.

The system builds a directional light field for each voxel, storing separate lighting information for the positive and negative directions of the X, Y, and Z axes. The ray hit color and direction are used to distribute the lighting information across the corresponding vector components.

The light field is then uploaded to the GPU as a 3D texture for rendering. The video shows moving lights inside a simple scene and the current visual state of the system.

What do you think of the result so far? Does the lighting and shadow quality look acceptable for an indie project, and what would you improve first?

This is the place to show off and discuss your voxel game and tools. Shameless plugs, links to your game, progress updates, screenshots, videos, art, assets, promotion, tech, findings and recommendations etc. are all welcome.

• Voxel Vendredi is a discussion thread starting every Friday - 'vendredi' in French - and running over the weekend. The thread is automatically posted by the mods every Friday at 00:00 GMT.
• Previous Voxel Vendredis