💻 computer science

PolyFlow: Continuous Topology Embedding Flow Matching for Artist-style Mesh Generation

PolyFlow introduces a novel framework that bridges the gap between efficient parallel generation and high-quality artist-style mesh synthesis by converting discrete mesh connectivity into a continuous embedding space, enabling a Transformer-based flow-matching model to outperform autoregressive baselines in both speed and geometric accuracy.

Original authors: Chunshi Wang, Haohan Weng, Junliang Ye, Biwen Lei, Yang Li, Zibo Zhao, Zeqiang Lai, Kaiyi Zhang, Yunhan Yang, Zhuo Chen, Chunchao Guo, Yawei Luo

Published 2026-07-01

📖 4 min read☕ Coffee break read

CC0 1.0

Original authors: Chunshi Wang, Haohan Weng, Junliang Ye, Biwen Lei, Yang Li, Zibo Zhao, Zeqiang Lai, Kaiyi Zhang, Yunhan Yang, Zhuo Chen, Chunchao Guo, Yawei Luo

Original paper dedicated to the public domain under CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are an artist trying to build a 3D statue out of a digital wireframe. You have a rough cloud of dust (a point cloud) that shows you where the statue should be, but you need to connect the dots with clean, organized lines to make a proper mesh that a video game or movie can use.

For a long time, the best way to do this was like writing a story one word at a time. This is called Autoregressive (AR) generation. The computer had to decide where to put the first dot, then the second, then the third, and so on, in a strict line. If it made a mistake early on, the whole statue could get messed up. It was accurate, but incredibly slow—like watching paint dry.

Other methods were faster, like diffusion models, which work like a sculptor starting with a block of clay and chipping away noise to reveal the shape. But these models struggled with the "wireframe" part. They could make the shape, but they couldn't figure out how to connect the dots with clean lines because "connecting" is a yes/no (discrete) decision, while these models are used to smooth, continuous numbers.

Enter PolyFlow.

The researchers at Tencent Hunyuan created a new way to do this that is both fast and precise. Here is how they did it, using some simple analogies:

1. The "Magic Translator" (The Topology Embedder)

The biggest problem was that computer networks don't speak "Yes/No" (is there a line here?) and "Smooth Numbers" (where is this point?) at the same time.

The team built a special Translator.

The Job: This translator looks at the final, perfect wireframe and converts the "Yes/No" decisions about which dots are connected into a secret, continuous language (a mathematical vector).
The Analogy: Imagine you have a map of a city with roads (lines) and intersections (dots). The translator turns the map into a set of GPS coordinates where, if two coordinates are close enough in a special "space-time" way, you know a road exists between them.
The Result: Now, the messy "Yes/No" problem is turned into a smooth "distance" problem that the fast models can understand.

2. The "Parallel Sculptor" (The Flow Model)

Once the translator is done, the main AI (PolyFlow) gets to work.

The Old Way (AR): The AI had to build the statue dot-by-dot, waiting for the previous dot to be finished before starting the next.
The PolyFlow Way: The AI looks at the entire statue at once. It starts with a cloud of random noise (like static on an old TV) and, in a single massive burst of calculation, cleans up the positions of all the dots, their angles, and their secret "connection codes" simultaneously.
The Analogy: Instead of painting a mural one brushstroke at a time, PolyFlow is like a magical spray that instantly turns a chaotic cloud of paint into a perfect, detailed image in seconds.

3. The "Magic Decoder" (Recovering the Mesh)

After the AI finishes its work, it has a list of smooth numbers for every dot. How do we get the lines back?

The Process: The system simply measures the "space-time distance" between every pair of dots. If two dots are close enough in this special language, the system draws a line between them.
The Result: The clean, artist-quality wireframe appears instantly.

Why is this a big deal?

Speed: Because it does everything at once (parallel) instead of one by one (sequential), it is tens of times faster than the previous best methods. It can generate a complex mesh in seconds rather than minutes.
Control: In the old methods, you couldn't easily tell the computer, "I want exactly 500 dots." With PolyFlow, you just tell it the number you want before it starts, and it generates exactly that many. It's like ordering a pizza and saying, "I want exactly 8 slices," and getting exactly 8.
Quality: It doesn't just get fast; it gets better. The paper shows it creates cleaner shapes with fewer missing parts or weird glitches compared to the slow, word-by-word methods.

In summary: PolyFlow is a new tool that translates the tricky "connect-the-dots" puzzle into a smooth math problem, allowing a super-fast AI to sculpt perfect 3D wireframes in seconds, with the user having total control over how detailed the final result should be.

Technical Summary: PolyFlow

Problem Statement

Automatic mesh generation with "artist-like" topology—characterized by clean, purposeful connectivity and controllable resolution—is a critical bottleneck in 3D content pipelines. While recent autoregressive (AR) Transformer models (e.g., PolyGen, MeshGPT, MeshAnything) have achieved high-quality results by serializing meshes into token sequences, they suffer from fundamental limitations:

Computational Latency: AR decoding is inherently sequential, requiring tokens to be generated one by one. This results in generation times of tens of seconds to minutes, orders of magnitude slower than parallel generative models used in 2D image synthesis.
Error Accumulation: The sequential nature of AR models leads to serial error accumulation, often causing missing semantic parts or structural inconsistencies in the final mesh.
Lack of Resolution Control: AR methods typically generate a fixed sequence length, making precise control over the output vertex count difficult without retraining or complex post-processing.

Conversely, continuous generative frameworks like flow matching and diffusion models offer efficient parallel synthesis but cannot be directly applied to meshes. This is because mesh connectivity (edges and faces) is inherently discrete (binary existence), which is incompatible with standard continuous noise injection and denoising operations that assume a continuous state space.

Methodology

The authors propose PolyFlow, a Transformer-based flow-matching framework that bridges the gap between discrete mesh topology and continuous generative modeling. The core innovation is a novel continuous proxy representation that allows the entire mesh state (geometry and topology) to be denoised in parallel.

1. Continuous Topology Embedding

To resolve the incompatibility of discrete topology with continuous flow, the authors introduce a Topology Embedder.

Mechanism: This lightweight neural network takes ground-truth vertex positions and normals as input and outputs a low-dimensional continuous embedding ( $e_i$ ) for each vertex.
Spacetime Distance: The embeddings are supervised using a spacetime distance metric (inspired by SpaceMesh). Each embedding is split into space ( $e^s$ ) and time ( $e^t$ ) components. An edge between vertices $i$ and $j$ is recoverable if the spacetime distance $d^{st}(e_i, e_j) = \|e^s_i - e^s_j\|^2 - \|e^t_i - e^t_j\|^2$ falls below a learned threshold $\tau$ .
Training: The embedder is trained to minimize a binary cross-entropy loss over edge reconstruction. Once trained, it is frozen and acts as a fixed feature extractor.

2. Joint Flow State Representation

PolyFlow unifies geometry and topology into a single continuous state vector for each vertex:
$z_i = [p_i, n_i, e_i]$
where $p_i$ is the 3D position, $n_i$ is the surface normal, and $e_i$ is the frozen topology embedding. A mesh with $V$ vertices is represented as a matrix $Z \in \mathbb{R}^{V \times (3+3+d)}$ . Crucially, the number of vertices $V$ is an explicit input parameter, allowing for direct control over resolution.

3. Flow Matching Framework

The generation process is modeled as a flow matching problem:

Conditioning: The model is conditioned on features extracted from an input point cloud via a frozen encoder.
Denoising: A Transformer-based flow model (a Flux-style DiT) predicts the velocity field $v_\theta$ to denoise the joint state $Z$ from Gaussian noise to the data distribution in parallel.
Loss Function: The model is trained with a channel-weighted velocity matching loss, balancing the reconstruction of positions, normals, and topology embeddings.

4. Inference and Decoding

Parallel Generation: During inference, the user specifies a target vertex count $\hat{V}$ . The model initializes $\hat{V}$ tokens from noise and solves the Ordinary Differential Equation (ODE) in parallel using an Euler solver.
Topology Recovery: The generated topology embeddings are decoded back into edges by evaluating pairwise spacetime distances. Edges are formed where the distance is below the threshold $\tau$ .
Face Extraction: Faces are extracted by enumerating 3-cliques (triangles) from the recovered edge set.
Orientation Correction: Generated surface normals are used to determine the consistent winding order of faces, ensuring a globally outward orientation without separate manifold repair.

Key Contributions

Continuous Topology Embedding: The authors identify mesh topology discreteness as the primary barrier to continuous generative models and resolve it by learning a continuous embedding space where discrete adjacency is recoverable via spacetime distance thresholding.
Joint Geometry-Topology Flow State: They introduce a unified state $[p, n, e]$ denoised by a single Transformer, replacing autoregressive decoding with fully parallel generation.
Exact Vertex-Count Control: Unlike AR methods, PolyFlow allows users to specify the exact number of output vertices before generation, enabling precise resolution control from coarse to fine.
State-of-the-Art Performance: The method achieves superior geometric fidelity (Chamfer and Hausdorff distances) compared to AR baselines while offering significant speed improvements.

Experimental Results

Evaluated on the Toys4K benchmark (point-cloud conditioned mesh generation):

Accuracy: PolyFlow outperforms the strongest autoregressive baseline (BPT) by 43% in Chamfer Distance (CD) and 40% in Hausdorff Distance (HD). It also demonstrates lower standard deviation in these metrics, indicating more stable generation quality.
Speed: PolyFlow generates meshes in seconds. For a 4,000-vertex mesh, PolyFlow takes 5.88 seconds, compared to 138.6 seconds for BPT and 36.72 seconds for FastMesh. This represents a speedup of tens of times over AR methods and over 6x over FastMesh.
Ablation: The optimal topology embedding dimension is found to be 32. Lower dimensions (e.g., 8) fail to encode adjacency faithfully, while higher dimensions (e.g., 64) offer negligible gains in reconstruction but increase learning difficulty for the flow model.

Significance and Claims

The paper claims that PolyFlow successfully breaks the inherent limitation of discrete mesh topology for continuous generative models. By lifting topology into a continuous latent space, it enables:

Efficiency: Dramatic reduction in inference latency compared to sequential AR decoding.
Robustness: Elimination of serial error accumulation, leading to meshes with fewer broken regions and missing parts.
Controllability: Direct, explicit control over mesh resolution (vertex count), a feature previously unavailable in standard AR mesh generation pipelines.

The authors position PolyFlow as a significant step toward high-quality, production-ready automatic retopology that matches the efficiency of modern 2D generative models while preserving the structural integrity required for 3D assets.