Coder Legion - Recent posts tagged blender-addon

I Built an ML Routing Engine for 3D Mesh Retopology — Here's How It Works

Thu, 19 Mar 2026 12:31:11 +0000

I've spent the last several months building Quadify Ultra, a Blender 5.0 addon that uses a KNN-based ML engine to automatically route meshes to the right retopology algorithm. This post is about the technical decisions behind it — the parts that were harder than expected and the approaches that actually worked.

The problem: retopology algorithm selection is a classification task

Retopology — converting triangulated meshes to clean quad topology — isn't one problem. It's five different problems depending on what kind of mesh you're dealing with:

Open curved panels (car doors, fenders) need edge-flip and greedy quad matching that preserves vertex positions
CAD imports with hard edges need boundary detection before any merging happens
Flat CAD surfaces with n-gon triangulation need dissolve passes before quadification
Closed flat meshes need field-guided remeshing (QuadriFlow)
Organic meshes and scans with broken topology need voxel rebuilding

The routing decision — which algorithm for this mesh — is something experienced artists do implicitly. I wanted to automate it.

The input features I settled on after testing:

features = [
    tri_ratio,           # fraction of triangles
    quad_ratio,          # fraction of quads  
    ngon_ratio,          # fraction of n-gons
    boundary_ratio,      # open boundary edges / total edges
    non_manifold_ratio,  # non-manifold edges / total edges
    normal_std,          # standard deviation of face normals (surface curvature proxy)
    edge_length_cv,      # coefficient of variation of edge lengths
    face_area_cv,        # coefficient of variation of face areas
    avg_valence,         # average vertex valence
    pole_ratio,          # fraction of vertices with valence != 4
    # ... 8 more geometric ratios
]

18 features total. All normalised ratios — no absolute values, so the classifier is scale-independent.

The classifier: KNN with confidence blending

I went with KNN rather than a neural net for two reasons:

Interpretability — when the engine recommends Smart mode at 73% confidence, I can inspect the k nearest neighbours and understand why
Cold start — a neural net needs hundreds of examples before it's useful. KNN with k=3 gives reasonable results from the first 10 operations

The confidence score is the fraction of the k nearest neighbours that agree on the top recommendation:

def get_confidence(neighbours, top_strategy):
    agreeing = sum(1 for n in neighbours if n['strategy'] == top_strategy)
    return agreeing / len(neighbours)

At low DB count the system blends toward a deterministic heuristic:

blend_weight = min(1.0, db_count / 30)
confidence = (ml_confidence * blend_weight) + (heuristic_confidence * (1 - blend_weight))

This means the first 30 operations use mostly heuristic routing, gradually transitioning to learned routing as the DB grows.

The hardest bug: voxel remesh freezing Blender

The original implementation used bpy.ops.object.voxel_remesh(). This is a synchronous operator — it runs on Python's main thread and blocks the entire UI. On a 39,000-face burger mesh it produced about 731,000 intermediate voxel faces and froze Blender for several minutes.

The fix came from reading Quadify Pro's source code. They use a REMESH modifier instead:

mod              = obj.modifiers.new("QP_VoxelRebuild", "REMESH")
mod.mode         = 'VOXEL'
mod.voxel_size   = max(0.0005, min(0.05, world_diag / resolution))
mod.use_smooth_shade = True
bpy.ops.object.modifier_apply(modifier=mod.name)

The modifier executes in Blender's C stack, not Python. It never blocks the UI. Same result, dramatically faster, works on any mesh size.

The voxel_size formula needed one more fix. The original code had:

voxel_size = max(
    min_dim / 20.0,      # THIS was the bug
    local_diag / voxel_resolution,
    0.0005,
)

The min_dim / 20.0 floor was designed to prevent microscopic voxels on large meshes, but it overrode the resolution setting for small objects. A burger mesh at 0.2m scale gave min_dim / 20.0 = 0.01 — 15x larger than the resolution-based target of 0.00064. With 0.01 voxels the mesh produced only 3,138 intermediate faces. QuadriFlow then got min(target_faces, 3138) = 3,138 as its target and produced a low-detail result.

Fix: remove the floor entirely, use world-space diagonal from matrix_world @ Vector(v) for scale independence, and add a 150k face cap to prevent genuinely large meshes from freezing:

bb_world = [obj.matrix_world @ Vector(v) for v in obj.bound_box]
diag = max((p - bb_world[0]).length for p in bb_world)
voxel_size = max(0.0001, min(0.05, diag / voxel_resolution))

# Cap to prevent freeze on large meshes
estimated_faces = (diag / voxel_size) ** 2
if estimated_faces > 150000:
    voxel_size = diag / math.sqrt(150000)

The community telemetry system

Each opted-in operation sends 18 geometry ratios and the algorithm result to Supabase:

payload = {
    'version':   1,
    'features':  [float(f) for f in features],  # 18 ratios only
    'strategy':  strategy,
    'quad_pct':  quad_pct,
    'corrected': corrected,
}

No mesh geometry. No vertex positions. No filenames. Just the feature vector and outcome.

The fetch uses only apikey header — no Authorization: Bearer — because the new Supabase sb_publishable_* key format explicitly rejects the Authorization header:

req = urllib.request.Request(url, headers={
    'apikey':  SUPABASE_KEY,
    'Accept':  'application/json',
})

Applying the update merges remote records into the local KNN experience DB, with deduplication and Postgres array format handling ({0.1,0.2,...} → Python list).

The callback uses bpy.app.timers to write results back to Blender properties on the main thread — background threads cannot write to Blender properties directly:

def apply_result():
    if _result[0] is None:
        return 0.5  # check again in 0.5s
    success, data = _result[0]
    scene.quadify_ultra.ml_update_status = f"Updated — {total:,} operations"
    return None  # stop timer

bpy.app.timers.register(apply_result, first_interval=0.5)

numpy boolean ambiguity in batch processing

One subtle bug that cost time: MeshFeatureExtractor.extract() returns a numpy array. In the batch loop:

normal_std = features[5] if features else 0.3  # WRONG

if features on a numpy array raises ValueError: The truth value of an array is ambiguous. The fix:

normal_std = float(features[5]) if features is not None else 0.3

The float() wrapper also prevents numpy scalar type issues downstream in JSON serialisation.

What's live

Quadify Ultra is available on Superhive: https://superhivemarket.com/products/quadify

$200 one-time, Blender 5.0+, MIT licensed. The ML model improves as the community database grows — currently ~160+ operations from early testers.

Happy to go deeper on any part of the implementation.

Quadify Base, Premium, & Pro

Thu, 29 Jan 2026 15:54:44 +0000

I’ve just released three variants of Quadify on Superhive: Base, Premium, and Pro.

Quadify is a Blender toolset built around one idea:
mesh cleanup and quad generation should be deterministic, intentional, and fast — not a guessing game.

This isn’t a replacement for manual retopology tools. It’s designed to be used before them, when you’re dealing with messy geometry and trying to decide how much work is actually worth doing.

Here’s how the three variants are intentionally scoped:

Quadify Base
Focused on safe, predictable tri-to-quad conversion.
It handles the obvious cleanup first, preserves seams and materials, and clearly shows what still needs manual attention.
Built for speed and transparency, not magic.

Quadify Premium
Adds manual quadification and region-based control.
You decide where topology is rebuilt and what stays untouched.
This turns quad cleanup into a deterministic decision process instead of a global operation you hope works.

Quadify Pro
Built for production pipelines and scale.
Includes pipeline workflows, automation recipes, LOD generation, texel density tools, validation, and reporting.
The focus here is repeatability and trust — knowing an asset is actually ready for downstream use.

All three share the same core philosophy:

deterministic behavior

visibility before action

control before commitment

If you work with scans, AI-generated meshes, imported assets, or production pipelines where cleanup keeps breaking things, Quadify is meant to remove the mechanical, repeatable pain — not replace artistic judgment.

The full release is live here on Superhive:
https://superhivemarket.com/products/quadify

Happy to answer questions about design decisions, scope tradeoffs, or why certain things are intentionally not automated.

I build Blender automation tools. What repetitive production task should not exist anymore?

Thu, 29 Jan 2026 15:46:17 +0000

I build Blender tools with a focus on automation and production speed, primarily for game art workflows.

Before deciding what to build next, I want to hear directly from people who use Blender seriously and run into the same problems over and over—the kind where you think “this should not be manual in 2026.”

I’m not looking for abstract feature ideas or wishlist items. I’m looking for concrete, repeatable pain points that:

You hit frequently (daily or weekly)

Are tedious, mechanical, or error-prone

Feel like they should be solvable with a tool or add-on

Aren’t already cleanly solved by an existing addon

If you respond, please be specific. Context matters more than volume.

Helpful examples:

“When doing X, I always have to manually do A → B → C because Blender doesn’t expose Y.”

“This part of my pipeline breaks unless I double-check Z every time.”

“I waste time fixing the same class of mistake over and over.”

Less helpful:

“Blender’s UI is bad”

“I want Maya feature X”

“Everything should be procedural”

If it helps, you can include:

Your role (environment artist, character artist, tech artist, etc.)

The kind of assets you work on

Where the friction shows up (modeling, UVs, baking, export, scene management, cleanup, validation, etc.)

I can’t promise I’ll build everything that’s mentioned, but I will prioritize problems that show up across multiple workflows and can be solved cleanly.

If you’ve ever thought “I should script this, but I don’t have time,” that’s exactly the kind of problem I want to hear about.

PS: Anyone whose suggestion I build will get a free copy with long-term support.

Quadify

Mon, 22 Dec 2025 16:10:47 +0000

Quadify: Manual Selective Quadification for Real Production Assets

Quadify is a Blender-based quadification tool designed around a simple observation:

Most production meshes do not benefit from global quadification.

Real assets are mixed by nature — hard-surface and organic elements, deforming and static parts, scanned and authored geometry — often combined in a single model. Treating all of that geometry as a uniform problem leads to unnecessary topology damage, cleanup work, and loss of author intent.

Quadify introduces a manual selective quadification workflow that allows artists to decide where quadification should be applied and where it should not.

The Problem Quadify Is Addressing

Manual Selective Quadification: Taking Back Control of Retopology

Mon, 22 Dec 2025 15:53:13 +0000

Quadification is often discussed as if it were a single operation: press a button, convert triangles to quads, and move on.

In real production environments, that framing is misleading.

Meshes used in games, VFX, visualization, and technical pipelines are rarely uniform. They are layered artifacts—built over time, modified by different tools, combined from scans, CAD data, or kitbashed parts. Expecting a single global quadification pass to treat all of that geometry appropriately is not only unrealistic, it is often counterproductive.

This update introduces Manual Selective Quadification, a workflow designed around how assets are actually built and used. Rather than attempting to “solve” topology everywhere, it allows artists to decide where quadification is appropriate, where it is unnecessary, and where it should be avoided entirely.

This article explains the reasoning behind that design, how to use it effectively, and why selective quadification is often the most technically correct approach.

What Quadification Is Really For

Quadification is not an aesthetic goal.
It is a functional intervention.

Quads are valuable because they:

Deform predictably during animation

Subdivide cleanly

Support sculpting and surface refinement

Produce more stable shading under certain workflows

But not all geometry needs these properties.

Many real-world assets include:

Rigid mechanical components

Flat or planar surfaces

Boolean-heavy CAD geometry

Already-acceptable triangulation

Non-deforming or secondary elements

Applying quadification indiscriminately to these areas does not improve the asset. In many cases, it actively degrades it by introducing unnecessary edge flow, breaking hard edges, or increasing cleanup time.

The mistake is treating quadification as a requirement rather than a tool.

Why Global Quadification Breaks Down

Global quadification workflows implicitly assume three things:

All parts of a mesh have the same topology needs

A single algorithmic strategy is suitable everywhere

Artistic intent can be inferred from geometry alone

These assumptions do not hold in production.

Consider a vehicle model:

Tires benefit from controlled quad flow

Body panels may already be clean

Interior parts may never deform

Bolts, trims, and small details often should remain untouched

A global quadification pass treats all of these regions as equivalent problems. The result is predictable: some areas improve, others degrade, and the overall cleanup cost increases.

Manual Selective Quadification exists to break this pattern.

The Core Idea: Apply Automation Only Where It Helps

Selective quadification is built on a simple premise:

The artist already knows which parts of the mesh are problematic.

Instead of forcing automation to guess, the workflow allows the artist to explicitly declare intent.

This shifts the role of automation:

From decision-maker → to execution engine

From global transformer → to localized operator

Automation still does the heavy lifting—but only where it has been invited to do so.

Selection as a Technical Signal

In this workflow, selection is not just a UI convenience.
It is a semantic input.

When you select specific meshes and set the target mode to Selected, you are providing information that no algorithm can reliably infer:

These areas deform

These areas will be subdivided

These areas currently have poor topology

These areas justify restructuring

Everything not selected implicitly communicates the opposite:

Preserve existing structure

Do not reinterpret intent

Avoid unnecessary changes

This is a far stronger signal than curvature analysis or density heuristics alone.

Practical Workflow Breakdown

Evaluate the Asset in Regions

Instead of treating the mesh as a single unit, identify regions with different requirements:

Deforming vs static

Organic vs mechanical

High-density vs low-density

Legacy/problematic vs acceptable

This is already how experienced artists think—the tool simply aligns with that mental model.

Select Only What Needs Quadification

Using viewport selection or the outliner:

Select meshes or parts that genuinely benefit from quadification

Leave stable or intentional topology untouched

The goal is precision, not completeness.

Set Target Mode to “Selected”

This constrains quadification strictly to the selected elements:

No global reinterpretation

No accidental topology damage elsewhere

No unnecessary processing

Run Quadify

Quadification is applied only where specified, producing a hybrid result:

Automated quad flow where useful

Original topology preserved elsewhere

Predictable outcomes with less cleanup

Why This Matters in Real Production

Selective quadification is not just a quality-of-life feature—it is a production safeguard.

It helps:

Reduce unintended topology changes

Preserve authored edge flow

Minimize downstream cleanup

Maintain consistency across iterations

Most importantly, it acknowledges a reality often ignored by automation tools: artists already understand their assets better than any heuristic.

Broader Design Philosophy

This update reflects a broader shift in tool design:

Automation should amplify judgment, not replace it.

Instead of pursuing a mythical one-click solution, Manual Selective Quadification embraces constraint, intent, and context. It allows automation to work with artistic decision-making rather than against it.

This philosophy underpins the continued development of Quadify as a production tool rather than a novelty feature set. For those interested in exploring the tool in more depth, Quadify is available as part of its ongoing development and update cycle:
Quadify

Docs
https://quadify3d.com

The emphasis, however, remains on workflow clarity rather than feature accumulation.

When Selective Quadification Is (and Isn’t) Appropriate

Use it when:

Only parts of a mesh have poor topology

Assets combine hard-surface and organic elements

You want predictable, low-risk automation

Avoid it when:

You are in the early blockout stages

The entire mesh clearly needs uniform restructuring

Manual retopology is intentionally required everywhere

Like any effective tool, it is about choosing the right moment.

Final Thoughts

Quadification should not be an act of faith.
It should be an informed decision.

Manual Selective Quadification reframes quadification as a targeted operation rather than a blanket transformation. By allowing artists to control where automation applies, it reduces risk, preserves intent, and aligns topology changes with real production needs.

It does not attempt to outthink the artist.
It simply executes when the artist decides it should.

That shift—subtle as it may seem—makes a meaningful difference.