Coder Legion - Recent posts tagged 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.

I Built a Batch Asset Validator for Blender in Python — Here's What I Learned

Mon, 16 Mar 2026 13:58:07 +0000

I Built a Batch Asset Validator for Blender in Python — Here's What I Learned

Game developers and 3D artists deal with a problem that doesn't get talked about enough: you find out your assets are broken after you've already submitted them.

Wrong scale. Tri count way over budget. Missing textures. Unapplied transforms. Negative scale that makes your mesh flip inside-out in Unity. These issues are obvious in hindsight, but catching them manually across a folder of 50 FBX files before every export is the kind of tedious work that either doesn't happen, or happens inconsistently.

So I built AssetSentinel — a Blender addon that batch validates FBX and glTF assets against a target platform profile before they leave your machine. Here's the technical breakdown of how it works, what I ran into building it, and a full demo video at the end.

The Core Problem: Validation Belongs Before Export, Not After

Most 3D pipelines look like this:

Model → Export FBX/glTF → Import to Engine → Discover problem → Go back to Blender

The discovery step is the expensive one. If you're submitting to a marketplace like Fab or CGTrader, a rejection costs you review time. If you're a studio delivering to a client, it costs credibility. The fix is moving validation to before the export step:

Model → Validate → Fix → Export FBX/glTF → Import to Engine

That's what AssetSentinel does.

How It Works: Temp Scene Import Loop

The core mechanism is a modal operator that imports each file into a temporary Blender scene, runs a series of checks, then destroys the scene and moves to the next file. This keeps the user's working scene completely untouched.

def _evaluate_in_temp_scene(context, path: str, profile: dict) -> dict:
    win = context.window
    orig_scene = win.scene
    temp_scene = bpy.data.scenes.new(name="ASSETSENTINEL_TEMP")
    win.scene = temp_scene
    try:
        _import_file(path)
        # run all checks here
        tris, verts = _tri_vert_counts()
        ngons = _ngon_count()
        # ... more checks
    except Exception:
        # classify the import failure
        detail = _tb_last_meaningful_line(traceback.format_exc())
        ftype, suggestion = _classify_import_failure(detail)
    finally:
        win.scene = orig_scene
        bpy.data.scenes.remove(temp_scene)
        bpy.ops.outliner.orphans_purge(do_recursive=True)

The finally block is non-negotiable. You have to restore the original scene and purge orphan data whether the import succeeded or failed — otherwise you accumulate stale mesh data across every file in the batch.

Blender's UI locks up if you run long operations on the main thread. The solution is a modal operator driven by a timer event. Each tick of the timer processes one file, then yields back to Blender so the UI stays responsive and the user can cancel with ESC.

def modal(self, context, event):
    wm = context.window_manager
    if event.type == "ESC":
        wm.assetsentinel_cancel_requested = True
    if event.type != "TIMER":
        return {"PASS_THROUGH"}
    if self._idx >= len(self._files):
        wm.assetsentinel_status = "Done"
        return self._finish(context, cancelled=False)
    # process one file per tick
    path = self._files[self._idx]
    res = _evaluate_in_temp_scene(context, path, prof)
    self._results.append(res)
    self._idx += 1
    wm.assetsentinel_progress = int((self._idx / len(self._files)) * 100)
    return {"RUNNING_MODAL"}

The timer interval is 0.1 seconds. Fast enough to feel responsive, slow enough not to hammer the CPU.

Profile-Based Validation

Rather than hardcoding limits, AssetSentinel uses JSON profiles — one per target platform. Each profile defines the limits that matter for that destination:

{
  "UNITY_MOBILE": {
    "label": "Unity - Mobile",
    "max_tris": 20000,
    "max_texture_res": 2048,
    "max_material_slots": 4,
    "lod_required": true,
    "no_spaces": true,
    "min_bbox_m": 0.05,
    "max_bbox_m": 10.0,
    "tri_over_is_error": true,
    "lod_missing_is_error": false
  }
}

The _is_error flags per rule let you configure severity independently. A tri count violation might be a hard error on mobile, but only a warning on desktop. The profile system auto-merges on load — if a user has an older profiles.json, new keys from the defaults get added without losing their custom values.

The Checks

Here's what runs on every imported asset:

Geometry:

Triangle and vertex count via me.calc_loop_triangles() — falls back to bmesh triangulate if that fails
Ngon detection by checking p.loop_total > 4 on every polygon
Negative scale on any axis
Unapplied transforms (scale/rotation not at identity)

Textures:

Total image count from bpy.data.images
External file resolution — whether the filepath exists on disk
Max texture resolution from img.size[0] and img.size[1]
Missing external textures list

Naming:

Regex match against allowed_name_chars from the profile
Space detection in object and material names

Scale:

World-space bounding box via evaluated_get(depsgraph).bound_box
Compared against min_bbox_m and max_bbox_m in the profile

LOD:

Name-based detection — checks for _LOD0, _LOD1, _LOD2, _LOD3 substrings

Import Failure Classification

One of the more useful features: when an import fails, it doesn't just say "import error." It classifies the failure and suggests a fix:

def _classify_import_failure(detail_line: str) -> tuple[str, str]:
    s = (detail_line or "").lower()
    if "khr_texture_basisu" in s:
        return (
            "UNSUPPORTED_EXTENSION",
            "Re-export without BasisU/KHR_texture_basisu and try again."
        )
    if "bad gltf" in s and "json error" in s:
        return (
            "INVALID_GLTF",
            "The glTF/GLB appears corrupted. Re-export from your DCC."
        )
    return ("UNKNOWN", "Try re-exporting and verify the file opens in Blender.")

This is genuinely useful in practice. KHR_texture_basisu failures come up frequently with AI-generated GLB files and photogrammetry exports. The error message from Blender's importer isn't helpful on its own — this surfaces the actual fix.

The HTML Report

After the scan, results are exported as an HTML report with a CSV alongside it. The report uses a dark theme, shows per-asset pass/warning/fail status with a triangle count bar against the profile limit, and includes filter controls to show only failed or warning assets.

The report also surfaces "top violations" — which checks failed most frequently across the batch. On a folder of 26 game assets, the most common failures were tri count overages and suspicious bounding box scales. Both are things that would have caused problems in the engine.

Watch the Full Demo

[embed: https://www.youtube.com/watch?v=64qQiMLCSD0]

The video walks through a real batch scan of 26 assets against the Unreal Desktop profile — showing the scan running, reading the HTML report, and interpreting the results.

Get the Addon

AssetSentinel is available on Superhive (Blender Market): https://superhivemarket.com/products/assetsentinel

Supports Blender 3.6 and above. No external dependencies — pure Python, no PyPI packages.

What I'd Do Differently

A few things I'd approach differently if I started over:

Results storage. I'm serialising the results to JSON and storing them in a WindowManager property string. It works but it's awkward — a proper addon-level data store would be cleaner.

The modal pattern. The timer-based modal is the right approach for Blender, but the 0.1s interval is a guess. A smarter approach would adapt the interval based on file size or import time.

Profile UI. Right now profiles are JSON files edited externally. An in-panel profile editor would make this accessible to artists who don't want to touch JSON.

Happy to answer questions about any part of the implementation — drop them in the comments.

Modifier Stack Fixer [addon]

Sat, 17 Jan 2026 15:04:28 +0000

Modifier Stack Fixer scans your modifier stack and warns you about order issues that cause broken geometry, failed exports, and unexpected behavior—before the damage happens.If you work seriously in Blender, this is a tool you should own.Save time, protect your work, and get the addon now.

Modifier Stack Fixer

Thu, 08 Jan 2026 18:57:40 +0000

Hey everyone
I built Modifier Stack Fixer to solve a problem I kept running into:
broken geometry caused by wrong modifier order, especially in complex or game-ready meshes.
Blender won’t warn you when a modifier stack is quietly sabotaging your mesh. This addon does.
What it does:
Analyzes your modifier stack in real time
Detects common modifier order issues (Subdivision, Boolean, Mirror, Solidify, Armature, etc.)
Flags risky or illogical modifier placements
Suggests safer modifier orders without destructively applying anything
Helps prevent shading issues, deformation bugs, and export problems
Why I made it:
Most stack issues only show up after rigging, UVs, or export when it’s already painful to fix.
Modifier Stack Fixer catches problems early, before your mesh breaks downstream.

Coder Legion - Recent posts tagged addon

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

The problem: retopology algorithm selection is a classification task

The classifier: KNN with confidence blending

The hardest bug: voxel remesh freezing Blender

The community telemetry system

numpy boolean ambiguity in batch processing

What's live

I Built a Batch Asset Validator for Blender in Python — Here's What I Learned

I Built a Batch Asset Validator for Blender in Python — Here's What I Learned

The Core Problem: Validation Belongs Before Export, Not After

How It Works: Temp Scene Import Loop

The Modal Operator Pattern

Profile-Based Validation

The Checks

Import Failure Classification

The HTML Report

Watch the Full Demo

Get the Addon

What I'd Do Differently

Modifier Stack Fixer [addon]

Modifier Stack Fixer