TriFlow: Generating Artist-Like 3D Mesh Topology via Nearest-Vertex Vector Fields

Conference: ECCV2026
Paper: ECCV 2026 / Project page
Area: 3D Vision
Keywords: mesh topology generation, nearest-vertex vector field, latent flow matching, watershed clustering, QEM simplification

TL;DR

TriFlow represents mesh topology as a nearest-vertex vector field (NVF) over the surface — every surface point points to the vertex with the largest barycentric weight in its local triangle — generates this field from an input SDF with conditional latent flow matching, and recovers the mesh through watershed clustering plus constrained QEM simplification. This bypasses the slow inference and error accumulation of autoregressive sequence modeling: on Objaverse the Chamfer Distance drops from 0.98 (best prior learned method) to 0.12, inference is about 8x faster, and the resulting topology wins across the board in both VLM and human preference studies.

Background & Motivation

Triangle meshes are the fundamental representation in graphics and vision, valued for their explicit surface structure, computational efficiency, and direct compatibility with existing production tools. Yet geometric fidelity is only half of what a practical pipeline needs: how vertices, edges, and faces are organized — the topology — decides whether a mesh can be used for deformation, editing, and physical simulation, and badly organized connectivity causes artifacts and costly manual cleanup. In industry, topology is authored by hand, which the paper calls artist-like topology and characterizes with three operational properties: compact face count, smooth vertex distribution, and edges aligned with salient geometric features. The problem is that recent 3D generation and reconstruction methods mostly hide geometry inside implicit fields or structured latents (TRELLIS, Direct3D-S2, DORA, hi3dgen and the like). Recovering a mesh then requires iso-surfacing such as Marching Cubes, which returns a "triangle soup": extremely dense, with faces of wildly varying size. The geometry is accurate; the topology is unusable.

To obtain compact topology together with geometric fidelity, the two existing routes each hit a wall. The first is classical geometry processing: QEM edge-collapse simplification, Progressive Meshes, and direction/cross-field-driven quadrangulation such as QuadriFlow and Instant Field-Aligned Meshes. Direction fields only describe the direction in which edges should run, from which patch layouts are cut; such pipelines aim at near-uniform, grid-like layouts, which conflicts with an artist's habit of allocating polygons adaptively — dense where detail lives, sparse on flat regions — and nothing in the pipeline carries a topology prior learned from artist meshes. The second route models meshes as discrete sequences and generates them autoregressively (PolyGen, MeshGPT, MeshAnything V2, TreeMeshGPT, MeshMosaic, EdgeRunner, and others). Results are promising, but two structural flaws appear: a substantial share of model capacity is spent on modeling sequence ordering, an accounting artifact unrelated to geometric or topological relations; and token-by-token decoding is both slow and prone to error accumulation, degrading sharply once inputs leave the training distribution (for instance, when consuming the noisy geometry produced by TRELLIS). The paper's tables make this vivid: TreeMeshGPT reaches a Chamfer Distance of 0.98 in-distribution on Objaverse but 30.00 on TRELLIS-generated shapes, a 30x increase.

The authors argue the root cause is the choice to generate topology as discrete connectivity itself: vertex and face lists are non-differentiable, variable-length, and lack spatial locality, so they are intrinsically ill-suited to continuous models. Re-encoded, topology can be written as a field over the surface, because "which vertices are connected" is equivalent to "which target vertex each surface point belongs to, and how those regions adjoin one another." The paper therefore defines the nearest-vertex vector field (NVF): every surface point points toward the vertex with the maximal barycentric weight in its local triangle. This field is bijective to mesh topology and is piecewise continuous, hence directly learnable. Core idea: represent mesh topology as a nearest-vertex vector field, turning topology generation into "conditional latent vector-field generation given an SDF," and recover a compact, geometry-faithful mesh from the generated field via watershed clustering and constrained QEM.

Method

Overall Architecture

The input is a geometry condition — anything expressible as an SDF, such as an implicit field from a 3D generative model or a fused signed-distance grid from sensor measurements; its zero level set is the target surface. The pipeline has three stages. Stage one defines the target mesh's topology as an NVF over the surface and discretizes both the surface and the field into a \(512^3\) sparse voxel grid so a network can consume them. Stage two is generation: the SDF and the NVF are each compressed into a \(64^3\) sparse latent, and a conditional latent flow-matching model — conditioned on the SDF latent plus two user-controlled parameters, the target face count and the target quad-face ratio — samples an NVF latent that is decoded back into a voxelized field. Stage three is extraction: an over-tessellated proxy mesh is obtained from the same SDF with Marching Cubes, the predicted voxel field is transferred onto its vertices, a watershed algorithm partitions those vertices into regions according to their predicted target positions, and a constrained QEM — which only allows collapses inside a region and biases contraction points toward the predicted positions — simplifies the proxy mesh into the final output.

The authors stress the division of labor: the flow-matching stage generates (the NVF already encodes the complete target vertex positions and triangle formations), while watershed and QEM only extract and introduce no new topology information. This decoupling is what makes the method robust — since the extraction side generates nothing, it only has to absorb prediction noise and voxelization aliasing, which is why it needs almost no hyper-parameter tuning (one root threshold, one topology weight) and no adaptation to the input distribution.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400, 'subGraphTitleMargin': {'top': 8, 'bottom': 16}}}}%%
flowchart TD
    A["Input: SDF geometry"] -->|geometric distortion augmentation| B["Nearest-vertex vector field<br/>topology = piecewise-continuous field"]
    B --> C["Latent flow matching<br/>generate NVF from SDF latent"]
    C --> EXTRACT
    subgraph EXTRACT["Topology-aware mesh extraction"]
      direction TB
      D1["Watershed clustering<br/>regions from predicted targets"]
      D2["Constrained QEM<br/>no cross-region merges + bias"]
      D1 --> D2
    end
    EXTRACT --> F["Compact mesh<br/>controllable face count, regular flow"]

Key Designs

1. Nearest-vertex vector field (NVF): turning discrete topology into a piecewise-continuous field over the surface

Predicting vertex and face lists directly is neither differentiable nor fixed-length, which is the first obstacle to be removed. The NVF is built as follows: for any surface point \(p\), take the triangle \(f_n=(v_1,v_2,v_3)\) containing it and write it in barycentric coordinates as \(p=\lambda_1 v_1+\lambda_2 v_2+\lambda_3 v_3\); the vertex with the largest barycentric weight is taken as the "nearest vertex" \(v_n\), and the field value is the vector pointing to it:

\[n=\arg\max_{i\in\{1,2,3\}}\lambda_i,\qquad \boldsymbol{t}(p)=\boldsymbol{v}_n-p\]

The crucial detail is that "nearest" here means maximal barycentric weight, not minimal Euclidean distance. A minimal example (Fig. 6 in the paper) shows why: Euclidean nearest-neighbor assigns points to vertices that are geometrically close but share no connection with the current face, thereby corrupting connectivity, whereas barycentric weights only ever choose among the three incident vertices of the local face and thus always respect the mesh structure. This definition cuts every triangle into three regions, one per incident vertex, so all surface points that map to the same vertex form a connected region, and region adjacency is exactly vertex connectivity — the NVF is bijective to the topology, and it is piecewise continuous, precisely the kind of object a continuous generative model can fit.

Training also requires a finite-dimensional representation. Surface and field are discretized together on a \(512^3\) sparse voxel grid: for every voxel intersecting the surface, take the voxel center \(p_c\), find its closest surface point \(p\) and the triangle \(f_n\) containing it, determine \(v_n\) by the equation above, and set the voxelized field to \(\boldsymbol{t}_c(p_c)=\boldsymbol{v}_n-p_c\). Note that the subtraction is against the voxel center rather than the surface point, so the field carries not only direction but also the absolute position of the target vertex — which is exactly what lets the extraction stage read off vertex positions later.

2. Latent flow matching: generating the NVF conditioned on the SDF

The distribution of topology must be learned from artist meshes, but a \(512^3\) field is far too large and sparse for direct generative modeling, so the paper compresses it into a latent and runs flow matching there. Three interlocking pieces make this work.

First, SDF condition encoding: the input SDF is voxelized on a \(512^3\) grid and voxels whose unsigned distance exceeds \(1/128\) of the largest bounding-box extent are discarded, yielding a sparse representation, which an autoencoder compresses into a \(64^3\) sparse latent \(z_{\text{SDF}}\), trained with an \(\ell_1\) reconstruction loss. This latent is the sole source of geometric information for the generative stage.

Second, NVF encoding and decoding. The NVF is voxelized at \(512^3\) and encoded by a VAE into a \(64^3\) latent \(z_{\text{NVF}}\). What is special is that the decoder does not regress the three field components; it outputs a unit direction and the square root of the magnitude, \(d=T/\|T\|_2\) and \(s=\sqrt{\|T\|_2}\), and is trained with an \(\ell_1\) loss on the reconstructed direction \(\hat d\) and scaled magnitude \(\hat s\) plus a KL term weighted by \(\lambda_{KL}=0.001\). This decomposition targets a numerical pathology near vertices: there the field magnitude approaches zero, and a direct three-component regression would let direction components be dominated by noise and become useless. With the \((d,s)\) parameterization the magnitude vanishes naturally as \(s^2\) while the direction \(d\) is explicitly supervised everywhere — and direction is precisely what extraction depends on, since a point's direction decides which target vertex it belongs to. The parameterization is thus aligned with the downstream stage by construction.

Actual generation happens in latent space. The condition \(c\) consists of two user-supplied topology parameters: the target face count, which controls output density, and the target quad-face ratio, which controls topological regularity — artist meshes are typically quad-dominant, so conditioning on that ratio amounts to telling the model "produce connectivity as regular as a quad-dominant mesh." Training follows the linear interpolation path \(z(i)=(1-i)z_0+i\epsilon\) from the ground-truth latent to Gaussian noise, and the network regresses the velocity field that pushes samples back toward the data distribution:

\[\mathcal{L}_{\text{flow}}=\mathbb{E}_{i,\,z_0,\,\epsilon}\left\|u_\theta\big(z(i),\,i,\,z_{\text{SDF}},\,c\big)-(\epsilon-z_0)\right\|^2,\qquad z(i)=(1-i)z_0+i\epsilon\]

⚠️ Formulas (2) and (4) are badly corrupted by OCR in the cached PDF (formula (4) survives only as u_θ(z(i),i,z_SDF,c)(εz_0)). The expression above follows the paper's prose and the standard conditional-flow-matching target, i.e. regressing the velocity \(\epsilon-z_0\); refer to the original paper for the exact form. The generated latent is decoded back into a voxelized NVF and handed to extraction.

Compared with autoregressive alternatives, this design pays off three ways: sampling takes a single pass with no token-by-token latency; no capacity is diverted to modeling sequence ordering, leaving the model free to focus on shape and topology; and there is no sequential decoding error to accumulate, so out-of-distribution inputs do not trigger a collapse.

3. Topology-aware mesh extraction: watershed fixes the regions, constrained QEM fixes the geometry

The generated field has two practical problems. Prediction noise and voxelization aliasing make "which vertex does this point belong to" locally ambiguous, so merging vertices directly from the field shatters the surface into fragments. And the predicted target vertex positions are mildly misaligned with the true geometry, so driving vertex flow purely by the field drops geometry — the w/o QEM ablation fails exactly this way, with "missing" geometry. Extraction is therefore split into "robustly determine regions" and "snap those regions back onto the geometry."

The first step is smoothing and transfer. A bilateral filter is applied to the predicted voxel NVF to suppress noise while preserving smoothness inside regions. An over-tessellated proxy mesh \(M_d=(V_d,F_d)\) is then extracted from the input SDF \(G\) via Marching Cubes, its vertices densely sampling the surface of \(G\). The voxel field is transferred onto those vertices: each vertex \(v_d\) looks up its nearest voxel center and receives that voxel's predicted vector, giving every vertex a predicted target position \(\boldsymbol{x}(v_d)=\boldsymbol{v}_d+\boldsymbol{t}_d(\boldsymbol{v}_d)\) (this assignment guarantees that the vertex points to the same target position as the corresponding voxel prediction).

The second step is watershed clustering, which converts field noise into a robust flooding problem on a graph, in three sub-steps:

• Region root initialization: vertices whose displacement magnitude is very small are already close to a target vertex and can seed a region, \(\mathcal{R}=\{\boldsymbol{r}\in V_d:\|\boldsymbol{t}_d(\boldsymbol{r})\|_\infty<\tau\}\), with threshold \(\tau\) set to half a voxel size; each root seeds an initial cluster.
• Iterative expansion: labels are flooded over the adjacency graph of \(M_d\) with a priority queue; an unlabeled neighbor joins the cluster of the root offering the smallest Euclidean distance to its predicted target position, i.e. \(\arg\min_{r\in\mathcal{R}}\|\boldsymbol{x}(v_d)-\boldsymbol{x}(r)\|_2\), and vertices are processed in ascending cost order so growth favors spatially coherent regions.
• NVF update: once every vertex is labeled, the field is rewritten from its cluster root's predicted position, \(\boldsymbol{t}_d(v_d)\leftarrow \boldsymbol{x}(r^\*)-\boldsymbol{v}_d\), so all vertices in a cluster share one target position and the whole region can collapse cleanly onto a single point.

The third step is constrained QEM. The proxy mesh is over-dense and must be simplified, but vanilla QEM only tracks geometric error and does not respect artist-like topology. The paper changes exactly two things: (i) an edge collapse is rejected whenever its two endpoints fall in different watershed regions, which prevents distinct regions from being welded together and makes the generated topology an actual constraint on simplification; (ii) when a valid collapse involves a region root, the contraction point is biased toward the generative model's predicted target position by augmenting the geometric quadric with a positional penalty, \(Q=\operatorname{mean}(Q_{\text{geom}})+\lambda_t Q_t\), where \(Q_t\) penalizes deviation from the target \(\boldsymbol{x}(v_d)=(x_t,y_t,z_t)\) and \(\lambda_t=0.1\) sets the strength (⚠️ formula (9) is corrupted by OCR in the cache; refer to the original paper for the explicit matrices). This resolves both requirements at once: geometric fidelity, and the guarantee that topology constraints do not cost geometry.

4. Geometric data augmentation at training time: buying out-of-distribution generalization with random distortion

Training data consists of clean artist meshes from Objaverse, but real inputs rarely are: scanned surfaces are noisy and generative outputs are often bumpy. A model that only ever sees clean data fails outright on local surface variation, and the topology in that region collapses. The remedy is to apply a random 3D distortion field to the training geometry while perturbing the corresponding NVF field together with it, forcing the model to produce stable topological predictions under local noise (the precise definition of the distortion field is deferred to the supplementary material). This goes further than any inference-time post-processing because it changes the mapping the model learns.

The ablation quantifies the benefit: removing the augmentation raises FID on TRELLIS-generated shapes from 16.19 to 18.06 and drops the topological perceptual score from 4.0 to 3.7, with failures concentrated on locally wavy surfaces. Notably its FID increase is the smallest of the three ablated components (the other two climb to 25.95 and 29.13), which says what it buys is not average quality but "not collapsing out of distribution" — exactly the generalization property the paper is after.

A Worked Example

Take one TRELLIS-generated shape (for such shapes the paper fixes the target at roughly 6000 faces). The input is voxelized into a \(512^3\) sparse SDF and encoded into a \(64^3\) \(z_{\text{SDF}}\); flow matching samples a \(z_{\text{NVF}}\) in latent space, which is decoded into a \(512^3\) sparse NVF voxel field and bilateral-filtered. In parallel, Marching Cubes extracts the proxy mesh \(M_d\) from the same SDF — it is over-tessellated, with far more vertices than the few thousand target ones (⚠️ the paper does not report the proxy mesh size; refer to the original paper). Each \(M_d\) vertex picks up a predicted vector from its nearest voxel, hence a "where do I think I should contract to" target position. Vertices with displacement below half a voxel become region roots, and flooding pulls surrounding vertices into their clusters by target proximity, forming regions of hundreds or thousands of vertices; each region is then collapsed by the constrained QEM into one output vertex whose position is pulled toward the region's predicted target, while cross-region merges are forbidden entirely. The result is a mesh with a face count near the requested value and edge flow that follows the features — with no token-by-token decoding anywhere in the loop.

Loss & Training

Three networks each have their own objective: the SDF autoencoder uses an \(\ell_1\) reconstruction loss; the NVF VAE uses \(\ell_1\) reconstruction of direction and scaled magnitude plus a KL term weighted by \(\lambda_{KL}=0.001\); the conditional flow-matching model uses the velocity-regression loss above. Training data consists of 656k Objaverse samples. The SDF autoencoder is fine-tuned from the Direct3D-S2 VAE for 170k iterations at batch size 16 on 8x A6000 GPUs for 8 days; the NVF VAE shares that architecture and is trained for 252k iterations at batch size 32 on 8x H100 GPUs for 11 days; the flow-matching model is built on the TRELLIS architecture and trained for 179k iterations at batch size 64 on 8x H100 GPUs for 12 days. Both the SDF and NVF latents have dimension 16. Evaluation and runtime measurements use a single A6000 with 4 CPU cores, and the main extraction hyper-parameters are a target quad-face ratio of 0.95, a region-root threshold \(\tau\) of half a voxel size, and a topology weight \(\lambda_t=0.1\).

Key Experimental Results

Main Results

Evaluation covers two datasets: about 1000 Objaverse test samples (single-component meshes with clean topology, an in-domain benchmark for learned methods), and 65 TRELLIS-generated shapes (bumpy surfaces with typical generative artifacts, an out-of-distribution test that mimics the real pipeline of converting over-tessellated generations into usable topology). Geometric metrics are Chamfer Distance (meshes normalized to a unit cube, 10k sampled surface points, values in the table scaled by 1000) and FID between shaded renderings; topological quality is measured by VLM perceptual scores (\(M_G\) for geometric similarity, \(M_T\) for topological similarity) and human ratings (\(U_G\), \(U_T\)). For comparable methods (TriFlow, QEM, QuadriFlow) the target face count on Objaverse is set to match ground truth, while TRELLIS shapes are targeted at roughly 6000 faces.

Method	Objaverse CD↓	Objaverse FID↓	In-dist. \(M_G\)↑	In-dist. \(M_T\)↑	TRELLIS CD↓	TRELLIS FID↓	OOD \(M_G\)↑	OOD \(M_T\)↑	Human \(U_G\)↑	Human \(U_T\)↑
QEM	0.14	8.0	4.3	3.3	0.20	22.1	3.6	3.3	4.0	3.6
QuadriFlow	4.81	46.9	3.0	2.7	0.52	95.6	3.4	3.1	2.5	3.2
MeshMosaic	1.62	27.0	3.9	3.6	9.02	45.3	2.8	1.7	3.3	2.1
TreeMeshGPT	0.98	8.1	3.8	3.5	30.00	74.9	1.9	1.7	1.5	1.7
TriFlow	0.12	5.0	4.8	4.7	0.20	16.2	4.4	4.0	4.5	4.6

Preference study (win rate of TriFlow against each baseline, %):

TriFlow vs.	VLM-Geometry	VLM-Topology	VLM-Overall	Human-Geometry	Human-Topology	Human-Overall
QEM	70.7	65.9	68.3	76.5	80.2	83.3
QuadriFlow	81.8	84.8	84.8	95.7	94.9	97.1
MeshMosaic	93.0	74.4	76.7	84.4	96.1	90.8
TreeMeshGPT	82.9	92.7	92.7	97.9	95.0	97.9

TriFlow achieves the best or tied-best Chamfer Distance on both datasets (tied at 0.20 with QEM on TRELLIS) along with the lowest FID and the highest VLM and human geometry/topology scores. The abstract's "roughly 90% lower Chamfer Distance" corresponds to Objaverse against TreeMeshGPT (0.98 to 0.12, about 88% lower); the "8x speedup" corresponds to 31 seconds per sample versus 4.3 minutes for TreeMeshGPT (about 8.3x), while against MeshMosaic's 2.2 hours the gap is two orders of magnitude.

Ablation Study

Each component removed in turn on TRELLIS-generated geometry (CD again scaled by 1000):

Config	CD↓	FID↓	\(M_G\)↑	\(M_T\)↑	Note
w/o Watershed	0.21	25.95	3.9	3.8	Positional quadrics added to all vertices and cross-region collapses allowed; triangulation becomes irregular
w/o QEM	0.21	29.13	4.1	3.5	Replaced by NVF-driven iterative vertex flow; visible topological artifacts and discontinuities, geometry goes "missing"
w/o Augmentation	0.20	18.06	4.2	3.7	Fails to generalize to local surface variation; topology prediction in those regions breaks down
TriFlow (full)	0.20	16.19	4.4	4.0	—

The paper additionally analyzes the NVF formulation itself: determining nearest vertices by Euclidean distance breaks mesh connectivity (the simple example in Fig. 6), making the barycentric frame necessary. It also reports face-orientation consistency (the proxy mesh comes from the SDF and QEM preserves normal consistency, so TriFlow outputs are naturally consistent, unlike autoregressive baselines) and level-of-detail behavior (at low LOD TriFlow produces the regular edge flow of a hand-made low-poly model, at high LOD a structured tessellation, whereas QEM produces triangle soup under the same face budget).

Key Findings

• Learned baselines collapse out of distribution; TriFlow barely moves: TreeMeshGPT's CD rises from 0.98 in-domain to 30.00 out-of-distribution (30x), MeshMosaic from 1.62 to 9.02, while TriFlow goes only from 0.12 to 0.20. The authors attribute this to two structural flaws of the autoregressive paradigm: sequence ordering consuming model capacity, and token-level errors accumulating faster on out-of-distribution inputs.
• Chamfer Distance is not a sufficient measure of topological quality: in the ablation all three degraded configurations sit at CD 0.20/0.21, essentially indistinguishable; what separates them is FID (16.19 vs 18.06 / 25.95 / 29.13) and the perceptual scores. In the main table QEM ties TriFlow at CD 0.20 on TRELLIS yet scores only 3.3 versus 4.0 on topological likeness — a geometrically accurate mesh can have terrible topology.
• The three components have clear roles: watershed and constrained QEM determine topological quality (removal drops \(M_T\) from 4.0 to 3.8 / 3.5 and raises FID to 25.95 / 29.13), while geometric augmentation mainly buys out-of-distribution robustness (\(M_T\) 4.0 to 3.7, FID 16.19 to 18.06). Losing constrained QEM is the most damaging (FID 29.13) because it forfeits the geometric constraint along with the topology.
• The speed advantage comes from the paradigm, not from engineering: 31 seconds per sample versus 4.3 minutes for TreeMeshGPT and 2.2 hours for MeshMosaic; the order of magnitude follows from "one forward pass plus one extraction" versus token-by-token decoding.
• Controllable parameters: face count and quad-face ratio enter as conditions, so users can tune mesh density and regularity at inference time, covering several LODs with a single model.

Highlights & Insights

• Encoding discrete topology as a continuous field is the paper's "aha" moment: topology is normally a non-differentiable, variable-length connectivity table, and the authors rewrite it as a piecewise-continuous vector field over the surface — "which target vertex does each surface point belong to" — so topology and geometry share the same surface parameter domain and mature latent generative models become directly applicable. This is not an engineering trick but a restatement of the problem.
• Defining "nearest vertex" by barycentric weight rather than Euclidean distance: a single counterexample makes the necessity clear. It also buys two things at once — connectivity is always respected, and each triangle is naturally partitioned into three self-consistent regions, so region adjacency equals vertex connectivity exactly.
• The direction / square-root-magnitude decomposition \((d,\sqrt{\|T\|})\): near vertices the field magnitude tends to zero, so regressing three components directly lets noise swallow the direction — yet extraction depends only on direction. Parameterizing direction separately and supervising it explicitly is a very cheap, high-return numerical design, transferable to any field-regression task that needs directional semantics where the magnitude vanishes.
• Generation and extraction are decoupled: the generative side decides what the topology looks like, the extraction side only lands it robustly on the geometry without adding topology, so either side can be swapped (a different clustering for watershed, a different simplifier for QEM) and almost no tuning is required.
• A transferable paradigm: whenever a network must predict a combinatorial structure (a graph, a mesh, a segmentation, an assembly relation), consider encoding it as an "ownership field" over a continuous domain and decoding with clustering plus constrained optimization, sidestepping the ordering overhead and error accumulation of sequence modeling.

Limitations & Future Work

• The authors' primary stated limitation is the reliance on a voxelized representation, which limits scalability to large scenes; multi-resolution, coarse-to-fine generation or a chunk-based pipeline is suggested as a remedy.
• Their second stated limitation is that the method generates triangle meshes only. This avoids the planar ambiguity inherent to n-gon faces, but it means native quad-dominant topology cannot be produced (regularity can only be nudged through the quad-face-ratio condition). Extending the NVF to native n-gons is named as the next step.
• Limitations I see: the \((d,s)\) parameterization together with the \(512^3\) voxel resolution sets a ceiling on detail, and thin rods or thin sheets are easily consumed by voxelization, yet the paper has no dedicated evaluation for thin structures. Evaluation scale is modest (about 1000 Objaverse samples plus 65 TRELLIS shapes), and the TRELLIS part fixes all outputs at about 6000 faces, so the core selling point of adaptive face allocation is under-examined. QuadriFlow's non-manifold samples were excluded, so its numbers are computed on a subset and cross-comparisons need that caveat. All ablations are run on out-of-distribution TRELLIS data, with no in-domain ablation.
• In addition, the semantics of the "target quad-face ratio" condition are not fully spelled out in the main text (how the ratio is annotated during training, what 0.95 corresponds to); the supplementary material is needed ⚠️ refer to the original paper.
• Improvement directions: replace watershed plus QEM with a learnable region partition for end-to-end differentiable extraction; use octrees or multi-resolution voxels to handle large scenes; extend the NVF to a multi-valued (n-RoSy style) field to generate quad-dominant topology directly, skipping the "generate triangles then merge" detour.

Related Work & Insights

• vs QEM (classical simplification): QEM only tracks geometric error and iteratively collapses edges; its geometric fidelity is actually competitive (CD 0.20 on TRELLIS, tied with TriFlow), but it carries no topology prior, produces irregular triangles without guaranteed face orientation, and scores only 3.3 on topological likeness versus 4.0 — at low LOD it degenerates into triangle soup. TriFlow effectively equips QEM with topology constraints: which edges may not collapse, and where contraction points should be biased.
• vs QuadriFlow / Instant Field-Aligned Meshes (direction-field-driven quadrangulation): these methods also use fields, but direction fields define only edge orientation and patch layout, contain no target vertex positions, and target near-uniform grid-like layouts that conflict with how artists allocate polygons adaptively to geometric detail. TriFlow's NVF is bijective to the topology — the field itself encodes vertex positions and connectivity — and is learned as a generative prior from artist meshes. Empirically QuadriFlow reaches CD 4.81 and FID 46.9 on Objaverse, a large gap.
• vs TreeMeshGPT / MeshMosaic / DeepMesh (autoregressive topology generation): these model artist topology priors directly on discrete token sequences. In-domain they are strong (TreeMeshGPT: CD 0.98, FID 8.1 on Objaverse), but inference is serial per token, capacity is diverted to sequence ordering, error accumulates out of distribution, CD rises to 30.00, and they are more than 8x slower. TriFlow removes the ordering dimension entirely in exchange for generalization and speed.
• vs implicit-field generators (TRELLIS / Direct3D-S2 and others): those solve where the geometry comes from; TriFlow is complementary — it accepts any SDF, including their outputs, and converts over-tessellated meshes into usable compact topology. The paper validates exactly this practical path on 65 TRELLIS-generated shapes.

Rating

• Novelty: ⭐⭐⭐⭐⭐ Restating mesh topology as a nearest-vertex vector field over the surface turns discrete topology generation into continuous field generation — a genuine change of problem representation.
• Experimental Thoroughness: ⭐⭐⭐⭐ Covers in-domain and out-of-distribution datasets, classical and learned baselines, and both VLM and human preference studies; but the scale is small (65 out-of-distribution shapes), in-domain ablations are missing, and the topological metric coverage could be broader.
• Writing Quality: ⭐⭐⭐⭐ The division of labor between motivation and method is clear, and the three-component ablation is honest (it does not hide that CD barely moves); however some formulas are corrupted in the cache and the semantics of the conditioning parameters are left to the supplementary material.
• Value: ⭐⭐⭐⭐⭐ It addresses the real pain point of 3D generation deployment — good geometry but unusable topology — and the 8x speedup plus stronger out-of-distribution generalization make it practically relevant for production pipelines.

Related Papers

• [CVPR 2026] ExMesh: EXplicit Mesh Reconstruction with Topology Adaptation
• [ECCV 2026] TreeSRNF: Square-Root Normal Fields for Generative Modelling of the Geometric and Structural Variability in Tree-like 3D Objects
• [ICML 2025] FlowDrag: 3D-aware Drag-based Image Editing with Mesh-guided Deformation Vector Flow Fields
• [ICLR 2026] Topology-Preserved Auto-regressive Mesh Generation in the Manner of Weaving Silk
• [CVPR 2025] GenVDM: Generating Vector Displacement Maps From a Single Image