Jump to content

  • Log In with Google      Sign In   
  • Create Account


Member Since 19 May 2011
Offline Last Active Today, 12:30 PM

Posts I've Made

In Topic: Closing cracks between neighboring chunks with different LoDs in a non-cubica...

22 March 2016 - 05:11 AM

yeah, I've run into the same problem as he did:



basically, the seam nodes gathered from the chunk's neighbors

generate polygons which coincide with the neighbor's polygons.


i.e. octree nodes collected from a neighboring chunk generate polys between themselves.

when later the neighbor's mesh is built, it will also generate the polys in the same positions.


maybe, there's a better algorithm for generating seams?

because all 7 neighbors (connected to the chunk via a seam) must be re-meshed whenever the chunk's LoD changes.

In Topic: Closing cracks between neighboring chunks with different LoDs in a non-cubica...

21 March 2016 - 09:11 AM

Sorry, I didn't understand why the problem should be inversed, drawing the complicated buildings first and then filling the terrain.

Did you mean I should connect terrain to buildings?


btw, I almost solved the seams problem yesterday using octrees.

All cracks are filled correctly, but the seam generator produces overlapping polygons (which causes Z-fighting).


Here's an ugly picture showing a grid consisting of 16x16x2 chunks (resolution of each chunk = 16^3) with some Simplex noise clipped by a box and a few shapes added on top:




I haven't implemented LoD selection yet, only experimented with changing LoDs on a single chunk.

In Topic: Closing cracks between neighboring chunks with different LoDs in a non-cubica...

19 March 2016 - 05:31 AM

I haven't implemented arbitrary meshes yet (they can be easily converted to a signed octree or a BSP tree serving as distance field).

Currently, I'm creating volumetric models from signed distance fields for testing purposes.

Models are represented as signed octrees and allow basic LoD by collapsing all nodes up to a certain level.

Though, at extreme levels of simplification the topology is destroyed (the mesh "opens up" and turns "inside out"). LoDs should be much better with Manifold Dual Contouring (2007) (based on Dual Marching Cubes (Nielson, 2004) which can place up to 4 vertices in a cell thereby guaranteeing 2-manifold quad meshes, but in "Adaptive surface extraction from anisotropic volumetric data: contouring on generalized octrees" they pointed out a non-manifold edge configuration).

I've implemented basic mesh simplification based on half-edge collapses (Stan Melax's algo, dihedral angles), but my iterative version was too slow for practical use.


My game concept is inspired by VoxelFarm, and I want to move on to large worlds where people can build anything (and you need LoDs for buldings).

As far as I know, in VoxelFarm both terrains and buildings are using the same representation.


My current goal is to implement a large procedural terrain which you boolean.

I have a basic chunk system with LoDs (no multiple materials yet), and I was just asking whether there is a good method for stitching chunks.

In Topic: Shader Library design and implementation

25 May 2013 - 01:34 PM

Are there open-source implementations of stateless, 'packetized' renderers that i can learn from?

Could you give me an example of a stateless low-level graphics API? What functions should it contain?

In Topic: Shader Library design and implementation

24 May 2013 - 01:28 PM

What's the most efficient way to do redundancy checking (to avoid extraneous Direct3D API function calls for binding pipeline resources) ?


my goal is to minimize the low-level graphics wrapper overhead as much as possible.

(i use small integer handles everywhere instead of pointers. i decided to use 8-bit handles for all immutable render states (DepthStencil, Rasterizer, Sampler and Blend - they are created at the start) and all constant buffers (i have a fixed pool of CBs). i can only have 8 CBs/samplers bound simultaneously so i can concatenate the whole pipeline state into a few 64-bit integers and use bitwise instructions to calculate 'delta' and issue the corresponding Set* calls if needed.)