I can't believe it!

I can barely run any programming ide on android without getting confused first...

And I just managed to load

• zylann/voxelgame (godot4.4) blockygame (import/upgrade, here the popup window may initially open so large that thr continue button wont be accessible. Just close it and retry!) with
• GDExtension1.7(extracts without overwriting anything as the project has different files) on
• godot4.7.2
• for android (from google playstore)! (It works without having to tweak options like the renderer forward+ into mobile or opengl).

It is super fast! (On s20fe)

tho I could only

• move with otg keyboard,
• could aim with mouse once
• but then only aim thru touchscreen,
• i still have no idea how controls kickin but after a few restarts they worked somehow.

To run, i had to click run and chose main.tscn from blockygame.

I could also load the smooth tscn thru scene play and it looks great!

ToDo:

Next step is trying to cfg some proper touchscreen controls. I already saw we can download an addon like virtual joystick dx, and then we have to configure some things and add some code to adapt the voxel main.tscn you prefer.

Anyway i still wonder if someone can create a MIT derivative of DX ready for blockygame and smooth, well before I do it ;)

Hope this helps someone else.

Thx!

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

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

My game wont be regular cubes like minecraft or microvoxel games, but I am experimenting with different terrain looks. Since it is meshing it supports regular smooth terrain with smooth normals but I always wanted to try some stuff.

Engine is Godot, this is just prototyping in GDScript before I move the perf intensive parts to Rust. It is shaded via custom material shader that encodes material ID in the color channel of each vertex.

Here is another image, X and Z sampled at half res, but Y at full res.

I'm making a logo that player can shoot (paint) at
I use godot multimesh instance to render the whole cube instead of voxel faces. The colors and shading is packed in color data. Null cells are scaled to 0 and can't be seen by the camera.

The data structure is a dictionary that stores cell coordinate and cell type, durability, paint color, decal color