DEV Community: Mr Q

When clipping a triangle creates a zero-area face: a Monster Forge case study

Mr Q — Sun, 01 Nov 2026 18:25:50 +0000

Disclosure: this article was prepared by an AI agent on behalf of Mr Q, the maintainer of Monster Forge. The numerical example below was executed successfully; the production fix and regression assertions were checked in the project source.

A clipping boundary that passes exactly through an existing vertex is a useful geometry test. An endpoint can be emitted both as a retained vertex and as an edge intersection. Welding those points to the same vertex index does not, by itself, remove the repeated index from the polygon that is about to be triangulated.

Monster Forge, an open-source modular low-poly character constructor, handles this case when constructing a fitted scalp shell. Here is the mechanism in a smaller two-dimensional example, followed by the production boundary and checks.

Retaining a vertex and finding it again

Take the triangle A=(0,0), B=(1,1), C=(2,-1), and retain the side y >= 0. Walk its directed edges. A is retained on A→B. B is retained on B→C, and that edge crosses the boundary at D=(1.5,0). C→A also crosses from outside to inside, with its intersection exactly at A.

The emitted polygon is therefore [A, B, D, A]. Welding equal coordinates produces the index sequence [0, 1, 2, 0]. A fan triangulator then emits (0,1,2) and (0,2,0). The second face has zero area because two of its vertex references are identical.

This is why having a unique vertex table is a different property from having a valid polygon boundary.

A runnable minimal reproduction

The example uses only Python's standard library. Its round-to-ten-decimals key mirrors the coordinate-welding convention used by the project helper. The final assertions check both the repeated-index mechanism and the triangle areas.

triangle = [(0.0, 0.0), (1.0, 1.0), (2.0, -1.0)]
polygon = []
for a, b in zip(triangle, triangle[1:] + triangle[:1]):
    ha, hb = a[1], b[1]
    if ha >= 0:
        polygon.append(a)
    if (ha >= 0) != (hb >= 0):
        t = ha / (ha - hb)
        polygon.append(tuple(x + (y - x) * t for x, y in zip(a, b)))

vertices, lookup = [], {}
def index(p):
    key = tuple(round(x, 10) for x in p)
    if key not in lookup:
        lookup[key] = len(vertices)
        vertices.append(p)
    return lookup[key]

def fan(ids):
    return [(ids[0], ids[i], ids[i + 1]) for i in range(1, len(ids) - 1)]

def area(face):
    a, b, c = [vertices[i] for i in face]
    return abs((b[0] - a[0]) * (c[1] - a[1])
               - (b[1] - a[1]) * (c[0] - a[0])) / 2

ids = [index(p) for p in polygon]
unique_ids = list(dict.fromkeys(ids))
before, after = fan(ids), fan(unique_ids)
assert ids == [0, 1, 2, 0]
assert before == [(0, 1, 2), (0, 2, 0)]
assert after == [(0, 1, 2)]
assert [area(f) for f in before] == [0.75, 0.0]
assert [area(f) for f in after] == [0.75]
print('before:', before, 'areas:', [area(f) for f in before])
print('after: ', after, 'areas:', [area(f) for f in after])

The output is:

before: [(0, 1, 2), (0, 2, 0)] areas: [0.75, 0.0]
after:  [(0, 1, 2)] areas: [0.75]

Apply the fix before the fan

In scalp_shell, the production helper clips each skull triangle against the hairline classification, welds the resulting coordinates and then triangulates the clipped polygon. It now removes duplicate welded IDs while retaining their order:

ids = list(dict.fromkeys(index(p) for p in polygon))
for i in range(1, len(ids) - 1):
    faces.append([ids[0], ids[i], ids[i + 1]])

If clipping leaves only one or two unique IDs, this loop emits no face. In the boundary-through-A example, the duplicate closing endpoint disappears before it can create the second triangle.

The important scope is the small ordered polygon produced from one clipped triangle. This is not a general triangulator for arbitrary concave or self-intersecting polygons. It also does not prove that three distinct welded IDs are geometrically non-collinear. Area still needs its own check.

The shell builder subsequently creates outer and inner surfaces and closes the boundary. A degenerate face or self-edge introduced before that step can contaminate later topology work. Removing the repeated boundary ID at the clipping boundary keeps the fix close to the operation that produced it.

Test more than the picture

The regression case includes a female orc whose hairline passes through skull vertices. Its checks require finite coordinates, three distinct IDs per triangle, nonzero face area, two incident faces for each undirected edge, opposite edge directions, positive signed volume, and appropriate inward/outward shell orientation.

The regression also checks the shell's radial clearance from the skull and an unchanged human control mesh. These are separate assertions with separate purposes: a closed mesh can still have an invalid face, and a nonzero-area mesh can still have inconsistent winding.

For this case, the topology and area assertions explain the fix more directly than a render would. They do not establish artistic quality or validate every possible character combination.

Source and context

The implementation is in constructor_surface_fit.py. The regression assertions are in test_constructor_hair_fit.py.

Monster Forge includes 33 race and creature templates and 193 presets, with a local browser interface and Python build service. Rigged templates export skeleton and weights; existing unrigged authoring templates export static geometry. Code and the declared built-in source resources are Apache-2.0. Some stored positioning references were AI-generated; the running constructor builds from geometry recipes.

Project and launch instructions: https://github.com/QoobIY/monster-forge

Author: Mr Q. Public contact: https://github.com/QoobIY

Monster Forge: building reproducible modular characters with Python

Mr Q — Sun, 01 Nov 2026 15:18:41 +0000

By Mr Q. Public contact: https://github.com/QoobIY

A character editor produces more than a preview. It produces a selection of source parts, material choices and an exported artifact that someone must be able to reproduce later. Monster Forge is an open-source low-poly character constructor built around that relationship.

The repository includes 33 race and creature templates, 193 presets, and its existing face, hair, clothing, body-shape, limb and accessory choices. The application and the declared built-in source resources are licensed under Apache-2.0. You can run the constructor locally without installing a separate game project or obtaining an image-generation API key.

Composition in the browser

The Body Parts workspace exposes the existing catalog and appearance controls. A shared viewer updates after changes without reloading the page. Assembly stores character revisions so that a saved selection can be opened again.

Exports contain an assembly.json instruction and one model.glb. Templates that have a rig export their skeleton and skin weights. Existing authoring templates without a rig export static geometry and identify that limitation explicitly. A catalog entry is not a claim that a complete animation rig exists for every creature.

These files are inputs to your own asset workflow. Test the imported model and its conventions in the engine or tool you intend to use; the constructor does not certify every engine integration.

Treat generated files as build products

The permanent source library holds geometry recipes, metadata, appearance presets and required reference inputs. Compiled parts, weight sidecars and UI cards are reconstructible cache files under /tmp/monster-forge.

That boundary matters when another developer clones the project. A preview on the maintainer's machine is not enough: the checkout needs the inputs required to rebuild it. Conversely, thumbnails and intermediate GLBs should not become the only surviving copy of an asset.

Source hashes and revision identifiers make changes explicit. Updating a source part creates a new revision rather than silently replacing the bytes behind an existing character. Saved assemblies preserve the selected settings and reference the built result.

Keep one implementation of geometry and weights

Python calculates geometry, bind transforms and weights. The browser displays the returned result. The same ConstructorService boundary is used for validation, building, preview and storage, which makes it possible to test the result independently of clicking through the UI.

For example, run this from a checkout with the application dependencies installed:

from pathlib import Path
from tempfile import TemporaryDirectory
from monsterforge.constructor import ConstructorService

service = ConstructorService()
settings = service.default_settings()

with TemporaryDirectory() as temporary:
    instruction, model = service.compact_assembly(settings, Path(temporary))
    assert instruction["schema_version"] == 2
    assert instruction["model"]["path"] == "model.glb"
    print(len(model))

Tests check finite coordinates, allowed bone influences, normalized skin weights, bind consistency, shared floor placement, source hashes and reopening saved settings. Those numerical checks establish technical properties, not artistic quality.

Try it and extend it

The tested launch environment uses Linux, Python 3.12, uv and make:

git clone https://github.com/QoobIY/monster-forge.git
cd monster-forge
make run

The first run installs the locked application dependencies. Open http://127.0.0.1:5050/characters/ to use the included catalog.

The contributor documentation describes ConstructorRegistry, SourceBundle and ConstructorService. Presets live in versioned JSON files. New production source extensions use the humanoid_v1 contract; the existing additional authoring templates remain available.

A complete game Playground and an end-to-end text-to-character generation workflow remain future work. Some stored positioning references were generated with AI, while the running constructor builds geometry from versioned recipes rather than issuing live generation requests.

Code, screenshots and contributor documentation: https://github.com/QoobIY/monster-forge

Disclosure: this article was drafted by an AI agent on behalf of the project maintainer. Its technical claims were checked against the project source, and the Python example above was executed successfully.