Current state of affairs is that we need a UV unwrapping solution, and the tessellation of the mesh plays a huge role. My heart is already with DelIso for triangle making but, I’ve been reading a lot of theory and science around UV unwrapping trying to figure out what kind of things we have to do, in order to make sure we’re not just creating a jumbled mess of algorithms, since this would be the third piece now. DelIso has many inherent benefits geometrically speaking, the grander concept of Delaunay Triangulation is actually how lots of LOD systems work under the hood. Going to try something soon to incorporate it’s qualities in an unwrapping solution.
The actual math in C# of the Convolution Surfaces themselves is done but, is not fast and not compatible with our past visions of using it in realtime, it’s just not feasible without compute shaders. We need to overhaul the reproduction system so the membrane doesn’t need constant regeneration.
Here are some notes of mine, may be incomplete:
/// RESTRICT
// figure out way to pick voxels on surface
pick random points in voxel grid
make sure we have a dense sample
foreach point selected // sites
{
// group together sites near each other
find nearest neighbors
separate neighbors as group
foreach group
{
// find voronoi cell bounds
find distance between each point // line is dual
place plane separating each pair halfway
build edges along any intersections // voronoi edge
foreach edge
{
// collect any restrictions of dual edges
if isosurface crosses edge: restrict dual
}
}
}
/// REFINE
foreach triangle of dual restriction
{
make circle around triangle
insert new site at center of circle
add site to collection of restricted sites
}
// sample density can go by the size of voronoi cells
restrict and refine sites until we have a dense enough sample
!! NOTES !!

We have a geometric skeleton so, we know the general shape

The skeleton has points of it’s own, we should try restricting some to see what happens

DelIso is unique from Marching Cubes in that we can have different cuts of creature refine independently that are smooth rather than being made up of voxels

DelIso has inherently useful properties for a generalized LOD system (Dynamic Tesselation) if we wish to make one

Convolution Surfaces are not lumpy, so there will be spots that match defined weights for skeletal elements, like metaball radius

If we can cut up the surface before triangulation (into 2D shapes), we can use this mapping for both greatly accelerated 2D voronoi restriction, and UV mappings

Could the surface be cut up using general formulas based on the mathematics of Convolution Surfaces?

This general algorithm should be done in C++ at a final iteration, it can be ‘slow’ depending on implementation, especially combined with Convolution Surfaces

Without compute shaders, we can’t use this constantly in realtime

Convolution Surfaces gives us integrals that we can use to find lines along the surface

This is potentially the final piece of the Convolution Surface puzzle, barring any Godot quirks