Using the CubicSurfaceExtractor to generate obj files from the meshes would be nice as another output target for the tool.

The palette is a texture of dimension 1x256. Export those uv coords to the obj file.

i created 8 objects and put each 2 of them into 1 layer but the convertor does not count the layers. it counts the objects. and if my objects go pass the 8 layers (or technically 7 because it starts from 0) it wont work.

Switching back doesn't solve the issue for the main viewport. The other three are working fine

//    First line is format identifier
Land of Sand voxel model
//    Second line describes the model
(model width) (model length) (model height) (number of voxels in model) (number of filled cells on plain) (number of columns in model)

//    Next follows a block of columns data. Each line describes one column. Only non-empty voxels are described.
col (col X coordinate)  (col Y coordinate) (col lowest voxel height) (number of voxels in col) data (voxel height)  (voxel colour) (voxel horizontal normal)  (voxel vertical normal)

//    Next follows description of singular voxels, not belonging to any column. Each line describes one voxel
vox (X coordinate) (Y coordinate) (Z coordinate) (voxel colour)  (voxel horizontal normal)  (voxel vertical normal)

//    col, data and vox are service words 
//    Colour is Graphics::TColor object
In lines every value/service word is separated with one space symbol
___
This is my hastily invented voxel model format.
It's most important distinction from Qubicle text format is that model is presented and sorted on a per column basis.
In my rendering engine models are rendered in columns and it's important to know column height to reserve enough storage for it.

Voxel model is presented as a plain and a one long column, dynamically divided into subcolumns.
The cells of the plain contain either a singular voxel, or a link to column of voxels, stored as part of long column.

Code of function saving model to format:

//        Title string used to identify format
    out << "Land of Sand voxel model" << endl;
    out << modelWidth << " " << modelLength << " " << modelHeight << " " << voxelCount << " " << basePointsCount << " " << colCount << endl;

//                                    Writing model columns 

    for (i = 0; i < colCount; i++)
    {
        height = columns[i].height;
        firstVoxel = columns[i].firstVoxel;
        out << "col " << columns[i].x << " " << columns[i].y << " " << columns[i].height << " " << columns[i].voxelNumber << " " << "data ";
        
        for (j = firstVoxel; j < firstVoxel+height; j++)
        if (modelColumn[j].horNormal >= 0)        //    if not empty
        {
            out << j-firstVoxel << " " << modelColumn[j].сolour << " " << modelColumn[j].horNormal << " " << modelColumn[j].vertNormal << " ";
        };
        out << endl;
    };    
//                                        Writing singular voxels, not belonging to any column

    for (i = 0; i < modelWidth; i++)
    for (j = 0; j < modelLength; j++)
    if (modelBase[i][j].height >= 0)        //    if not empty
        if (modelBase[i][j].colIndex < 0)        // if singular voxel
        {
            out << "vox " << i << " " << j << " " << modelBase[i][j].height << " " << modelBase[i][j].voxColour;
            out << " " << modelBase[i][j].horNormal << " " << modelBase[i][j].vertNormal << endl;
        };

The plan was to somehow compute the noise on the server and the client to prevent sending the chunks over the wire (to reduce traffic) - but it turns out, that the noise generation should/must be float based and thus we can't ensure that the same results would get generated on each client. Therefore we should send the (at least RLE encoded) chunks to all the clients. Regarding their viewdistance + threshold the client should receive and cache all the chunks. The client should send a chunk request message (that should later get a limit of allowed calls per client per timespan) to the server and the server should send the compressed chunks - this could theoretically also get implemented via http GET for the given seed in order to reduce computation and traffic on the server.

https://getqubicle.com/qubicle/documentation/docs/file/qef/

As OpenGL is no longer really supported by Apple, we should consider a Metal renderer backend.
Using OpenGL for e.g. voxedit works relatively good, but for the world rendering... 3 fps

This is the rgb.vox converted to obj and imported into blender. The screenshots shows the volume edge voxel at 31, 0, 31. You can see that there are at least 4 faces missing here.

Currently the RCON is based on QT - it should be converted to imgui and use the default application system as all other tools, too.

Hi There,

This project is still using an old implementation of LGTM's automated code review, which has now been disabled. To continue using automated code review, and receive checks on your Pull Requests, please install the GitHub App on this repository.

Thanks,
The LGTM Team

See this article for more details: https://www.enkisoftware.com/devlogpost-20150131-1-Normal-generation-in-the-pixel-shader

should be a command with a palette index and an optional layer name

There are multiple issues with the gizmo:

• Translating is wrong
• Line intersection is not always detected
• Scaling and rotating is missing.

Details about the scenegraph can e.g. be found here:

• RichysHub/MagicaVoxel-VOX-importer#10

https://abfab3d.com/svx-format/
https://www.shapeways.com/blog/archives/17972-shapeways-launches-svx-voxel-file-format-for-3d-printing.html

https://gist.github.com/Eisenwave/799416ac162a4dddeb1312f357f1385c

sphere.svx.zip

Looks like the viewport doesn't take the needed scrolling into account and the upper part of the screen is scissored away.

Right "original" side is the MagicaVoxel export

Cant login to server
new account didnt help
Today download your project/ all work for the first look, but client couldnt login to server

Island based world generation based on this blog post https://jobtalle.com/layered_voxel_rendering.html should be implemented. In a way that only 2d heightmaps are combined (even for cliffs). These heightmaps can then be sent to the client to fix the float-based-noise differences.

They aren't loaded with the error message "Broken file" but 255x255x255 works fine

Event based

Needed

a) ability to record and save the events (WindowedApp::onRunning())
b) ability to play back recorded events
c) custom event to handle screenshots (just to automatically validate the proper ui state or to present screenshots in case of an error)

Criterias

• The system should be guarded with a preprocessor define
• The events must be stored compressed
• The applications have two new command line arguments - one for save events to file, and one for play back events from file.

imgui test framework

https://0fps.net/2018/03/03/a-level-of-detail-method-for-blocky-voxels/

https://bztsrc.gitlab.io/model3d/

validator: https://bztsrc.gitlab.io/model3d/validator/

People are used to wasd for movement, and the S key is bound to the togglelayerstate command. That should be changed.

https://www.youtube.com/watch?v=WiFzI6ItodM&feature=youtu.be

Code for parsing went into master with commit 64a0c0c

But it's not yet used.

https://github.com/NickM13/Chronovox-Studio/blob/0f13e0aba310706853377325a07cad72902ffe36/src/engine/editor/model/format/import/NvmFormat.cpp

idk if this is a bug or not.. but in the console i guess you can just ignore sending this message or just send 1. because when it reaches the amount of layers in the object i dont think it needs to check other layers too.

The colors and ao values should be backed into a texture and no longer be taken into account by the meshing algo.

Examples like these could benefit.

The result texture is one pixel for each visible face of the voxel.

Doesn't create a torus

Maybe via environement variable or start parameter. Allow to disable the interactive input handling or window creating at all

Hello @mgerhardy,

I'm interested in the shadertool you wrote about in your blog post. It looks really useful as way to have the compiler help with the work of maintaining shaders. I notice there are some dependencies to internal code; are there too many dependencies to make it worthwhile splitting this into a standalone tool?

Greets,

Ben

Getting rid of turbobadger dependency would be nice - this is also a quite easy ui and should be easily convertible.

Thread from https://twitter.com/SebAaltonen/status/1315982782439591938

[quote]
Geometry shaders and instanced draw are unoptimal choices. Geometry shader outputs strips (unoptimal topology) and it needs GPU storage and load balancing. Instanced draw is suboptimal on many older GPUs for small 8 vertex / 12 triangle instances.
The most efficient way to render a big amount of procedural cubes on most GPUs is the following: At startup you fill an index buffer with max amount of cubes. 326 = 36 indices each (index data = 0..7 + i8). Never modify this index buffer at runtime.
No vertex buffer. You use SV_VertexId in the shader. Divide it by 8 (bit shift) to get cube index (to fetch cube position from an array). The low 3 bits are XYZ bits (see OP image). LocalVertexPos = float3(X2-1, Y2-1, Z2-1). This is just a few ALU in the vertex shader.
Use indirect draw call to control the drawn cube count from GPU side. Write the (visible) cube data (position or transform matrix, or whatever you need) to an array (UAV). This is indexed in the vertex shader (SRV).
There's an additional optimization: Only 3 faces of a cube can be visible at once. Instead generate only 323=18 indices per cube (positive corner). Calculate vec from cube center to camera. Extract XYZ signs. Flip XYZ of the output vertices accordingly...
If you flip odd number of vertex coordinates, the triangle winding will get flipped. Thus you need to fix it (read triangle lookup using "2-i") if you have 1 or 3 flips. This is just a few extra ALU too. Result = you are rendering 6 faces per cube, thus saving 50% triangle count.
The index buffer is still fully static even with this optimization. It's best to keep the index numbering 0..7 (8) per cube even with this optimization to be able to use bit shift instead of integer divide (which is slow). GPU's do index dedup. Extra "slot" doesn't cost anything,
[/quote]

The file dialogs should get the ability to store bookmarks and maybe even to show the default folders of the OS (like Downloads, Pictures, ...)

The custom bookmarks should just be stored as a Cvar (see core/Var.h, or in-game-console command cvarlist) that is separated with ;

https://github.com/NickM13/Chronovox-Studio/blob/0f13e0aba310706853377325a07cad72902ffe36/src/engine/editor/model/format/import/CsmFormat.cpp

Having STL support in voxconvert and voxedit would be cool.
https://en.wikipedia.org/wiki/STL_(file_format)

https://docs.microsoft.com/en-us/windows/win32/dxtecharts/common-techniques-to-improve-shadow-depth-maps

Using the map view birds-view feature or gliding in either the client or mapview will show a lot of shadow artifacts. The linked article describes them very well.

Rotating the objects in MV will give some sort of warning in the console and the exported file is not rotated too.

using a naive picker to determine the height seems flaky. It jumps around and does not always match the mouse

Now that it compiles (cgerikj/binary-greedy-meshing#2), give https://github.com/cgerikj/binary-greedy-meshing a try to replace the CubicSurfaceExtractor class

module voxelrender
in WorldRenderer.cpp

WorldRenderer::WorldRenderer(const voxelworld::WorldMgrPtr& world) :
                _octree(math::AABB<int>(), 5), _world(world) {
        setViewDistance(240.0f);
}

if increase setViewDistance to 500 or above / engine crashed

Looks like there is no pkg-config support and no cmake find module. This works for others, so we have to find out why the detection doesn't work for libuv