acceptodds
Under review as a conference paper at ICLR 2027

WireForge: Structured Low-Poly Mesh Generation with 2D Wireframe Priors

Abstract

Low-poly mesh generation is fundamentally underdetermined: the same input shape can be approximated by different polygonal layouts. Existing generators rely on surface conditioning and mesh-connectivity priors learned from the training distribution to select among these layouts, but matching the input geometry does not guarantee that edges follow salient structures. We present WireForge, a framework that addresses this gap by introducing 2D wireframe priors as explicit structural references for generation. These references are constructed by a wireframe-generation agent, WirePilot, built on off-the-shelf image-generation models. Guided by either our carefully designed default instructions or user-provided prompts, the agent generates, evaluates, and refines candidate wireframes. To translate these image-space references into 3D guidance, WireForge associates their features with spatial anchors derived from the input mesh and applies 3D positional encoding. The spatially grounded features then guide mesh generation through cross-attention, complementing geometric guidance from surface samples. This conditioning formulation can be adapted to different mesh-generation backbones, while retaining the wireframe as an editable interface for specifying edge-layout styles through natural-language instructions or sketches. Experiments demonstrate that the resulting structural guidance improves both geometric fidelity and edge-layout alignment.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
low-poly, 3D generation

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_2gYHOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

WireForge proposes a framework for low-poly mesh generation guided by 2D wireframe priors. A 2D wireframe-generation agent produces and refines references from text instructions or sketches. The framework associates 2D wireframe features with 3D spatial anchors on the input mesh by injecting them into a mesh-generation backbone through cross-attention. The paper aims to improve geometric fidelity while enabling user-directed control of edge layouts.

Critical strengths
  1. Useful problem. Geometric similarity alone does not guarantee meaningful or artist-friendly edge layouts. Explicit wireframe guidance is a reasonable way to address this limitation.

  2. Intuitive user interface. Text- and sketch-based wireframe specification could make mesh layout control more accessible and flexible.

  3. Modular conditioning design. The proposed mechanism can be adaptable to different mesh-generation backbones.

Critical weaknesses
  1. The main contribution is not clearly defined. The title emphasizes low-poly mesh generation, Tables 1 and 2 mainly evaluate geometric fidelity, and Figure 7 demonstrates user-directed edge-layout control. These correspond to different research objectives, but the paper does not establish which is its primary contribution. As a result, the method analysis and experiments are insufficient for each of the three possible claims. The authors should clearly define the main objective and align the method, baselines, and evaluation with it.

  2. Relevant work on low-poly generation and mesh topology is insufficiently covered. Low-poly Mesh Generation for Building Models (SIGGRAPH 2022) is directly relevant to low-poly mesh generation. More recent work, including TriFlow: Generating Artist-Like 3D Mesh Topology via Nearest-Vertex Vector Fields (2026), also addresses geometry-conditioned generation of structured, artist-like topology. SpaceMesh: A Continuous Representation for Learning Manifold Surface Meshes (SIGGRAPH Asia 2024) learns polygonal mesh connectivity, while Mesh-controllable Multi-level-of-detail Text-to-3D Generation (Computers & Graphics 2024) studies controllable mesh complexity. These works should be discussed to clarify the distinction between geometric simplification, topology generation, and user-directed layout control. LATO (ICML 2026), which is already cited, should also be considered in the experimental comparison where the tasks are compatible.

  3. The central edge-layout control claim lacks direct evaluation. The current geometric metrics, such as surface distance and normal error, do not establish whether generated edges preserve salient 3D features or follow the specified 2D wireframe. Figure 7 provides qualitative evidence, but it is insufficient to establish reliable controllability. The paper should quantify projected wireframe alignment, 3D feature preservation, and compliance with different layout instructions. The butterfly in fig 7 is an good example. But the inconsistency between the 2d and 3d wireframes in the sideview of the bus in fig 7 should be discussed.

  4. The contribution of wireframe density and layout is unclear. If the primary goal is low-poly generation, the authors should disentangle the effects of wireframe density and edge arrangement. It is also important to determine whether existing mesh-generation methods followed by QEM simplification can achieve comparable geometric fidelity at similar face counts. Such comparisons would help establish the added value of the proposed pipeline.

Questions for authors
  1. What is the primary contribution: accurate mesh generation, low-poly mesh generation, or user-controllable edge-layout generation? How does each major experiment support that claim?

  2. How much do wireframe density and wireframe layout independently contribute to the results? Can the authors provide controlled ablations and compare against existing mesh-generation methods followed by QEM simplification at matched face counts?

  3. How do the authors quantitatively evaluate alignment between the input 2D wireframe and the generated 3D edge layout? Can they report 3D feature-preservation metrics and demonstrate consistent compliance with different text instructions and wireframe references?

  4. Paired supervision. How to pair QEM results with the edge layouts generated by WirePilot? What is a successful pair and what is not?

4 comments
AuthorsOpenReview ↗

Official Response by Authors – Part 1

We thank the reviewer for recognizing the value of this work and for the constructive feedback. We address each concern below.

Clarifying the primary contribution

The primary objective of WireForge is controllable edge-layout generation for low-poly meshes under a given surface geometry. Introducing wireframe guidance improves geometric fidelity while enabling control over edge-layout styles.

A single surface can admit many plausible polygonal layouts. Existing surface-conditioned mesh generators largely rely on learned mesh priors to determine these layouts, but generally lack an explicit interface for specifying alternative edge arrangements. WireForge addresses this underdetermination by introducing an editable 2D wireframe reference as additional structural guidance.

Our experiments demonstrate both the geometric benefits and structural controllability of this guidance:

  • Table 1 and Figure 4: Improvements in geometric fidelity.
  • Figure 5: Polygon-density control through wireframe references.
  • Figure 8: Edge-layout customization through text and sketch instructions.

Related work and positioning

Due to space limitations, we focused our discussion on representative milestones and recent influential methods. We appreciate the suggested references and have added SpaceMesh (SIGGRAPH Asia 2024) and TriFlow (ECCV 2026) to the revised PDF. Given the space constraints, we have prioritized representative works most directly relevant to our methodological contributions.

Regarding LATO, our experiments already include its newer iteration, LATO.2, in Table 1 and Figure 4. Given the limited space and evaluation resources, we prioritized this updated version rather than additionally evaluating the original LATO.

Quantitative evaluation of edge-layout control We additionally evaluate rendering-based metrics across existing mesh-generation baselines, using the same reference budget of s=3000s=3000 for WireForge.

ModelLPIPS ↓FID ↓SSIM ↑
MeshAnythingV20.087264.60.8962
BPT0.072061.10.9006
TreeMeshGPT0.082176.90.8996
DeepMesh0.083379.60.8984
Mesh-Silksong0.078271.10.8979
FastMesh0.083573.90.8970
MeshFlow0.081064.20.8985
LATO.20.077377.70.8941
WireForge (Ours, s=3000)0.069355.60.9004

Importantly, existing baselines do not accept wireframe references as conditions. Evaluating their outputs against our WirePilot references is therefore not a fully fair comparison of controllability. Nevertheless, we report these results.

For a more comparable assessment of polygonal layout quality, we also conducted a user study (Appendix A.6), in which participants ranked the overall quality of generated meshes under the same input geometry. WireForge received 82.8% of the Top-2 selections.

Regarding the butterfly and bus examples in Figure 8, our wireframe serves as a soft structural prior, guiding polygon density and edge arrangement rather than enforcing exact correspondence. Figure 8 demonstrates that different wireframe references can produce distinct layouts under the same geometry condition, while precise per-edge alignment remains a limitation.

AuthorsOpenReview ↗

Official Response by Authors – Part 2

Wireframe density, edge arrangement, and QEM comparisons

In WireForge, both polygon density and edge arrangement are controlled through the wireframe reference, rather than through separate parameters. In particular, we do not specify an explicit face-count parameter at inference; the model learns to infer the approximate polygon density and layout style from the reference wireframe map.

Our experiments demonstrate these two aspects of control: Figure 5 varies wireframe density to produce meshes with different polygon complexities, while Figure 8 modifies edge arrangements at a similar intended density to demonstrate layout customization. Thus, both capabilities are enabled through the same editable wireframe interface.

Regarding QEM, it is a geometry-driven simplification method that does not directly support user-specified edge-layout control. We also observed that QEM can produce damaged regions or severe local geometric degradation on challenging inputs, particularly those with non-manifold geometry or uneven polygon distributions. Therefore, our objective is not simply to improve geometric approximation at a prescribed face count, but to enable reference-guided structural control during mesh generation.

Paired supervision and WirePilot references

For the additional adaptation stage involving approximately 9,000 WirePilot references, we use a vision model for initial screening, followed by manual inspection to select references with approximately matching edge-layout styles, polygon density, and geometric structure relative to the corresponding target meshes.

The purpose is not to require exact edge correspondence, but to retain consistent training pairs while exposing the model to the variations introduced by WirePilot at inference time.

At inference, WirePilot generates the structural references without access to the ground-truth target mesh.

Reviewer_2gYHOpenReview ↗

Accept

Thank you for these tests and clarifications. I support the acceptance of the paper.

Thank you for your response! We are glad our reply addressed your concerns, and we appreciate your recognition of our work.

Reviewer_Us9jOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents WireForge, a method for computing a low-poly triangulation of a given input mesh. The method aims to use priors for low-poly triangulations that may be encoded in generative models for 2D images. WireForge achieves this by augmenting a mesh generator conditioned on a point sampling of the surface to be meshed. In addition to point samples, S, WireForge conditions the generator by wireframes, normals and 3D positions projected to an image plane. This is achieved by associating latents of the wireframe image (computed with an existing VAE) with the 3D point positions at those pixels and processing these latents with factorized attention, using 2D RoPE embeddings (encoding image-space relationships) and 3D RoPE embeddings (encoding world-space relationships). The resulting features condition the mesh generation using cross-attention.

During training, the wireframes used for conditioning are rendered from a ground-truth mesh. During inference, the wireframes are generated with a VLM. To ensure that the generated wireframes match the rough geometry of the mesh, the paper proposes WirePilot, which generates a wireframe image, checks it for correctness (matching the outline and evaluated by a VLM-judge) and repeats the generation if the wireframe is not correct.

Critical strengths

The core idea of using 2D wireframes to condition mesh generation is strong and it seems to be a good way to make use of the wide availability of image data and strength of image-based generators. The mechanism also provides an intuitive user interaction through an image-basedor text-based interface (figure 7).

The results demonstrate a large jump in quality compared the prior work and I appreciate that the authors tested the augmentation on other mesh generation back-ends.

Critical weaknesses

The qualitative benefits demonstrated in the main results could be explained outside of the wireframe conditioning, e.g., holes in the surface could be fixed by a more dense conditioning in image space. The main issues with BPT, the augmented backend, seem to be with missing regions (fig. 4) and the same holds for other backends in fig. 6b. Interestingly, this issue also shows up when the wireframe conditioning is back-projected to a point cloud (fig. 6a). Therefore, it could be that the problem of point-cloud conditioning in the original BPT is that it undersamples the surface, leaving holes in the output. The conditioning with image-space normals, 3D position and mask in the current work increases the sampling rate. It would help to include a comparison where the wireframe conditioning is set to all zeros/ones or retrain the pipeline without wireframe conditioning, but with normals/points/masks in image space to understand the effect of wireframe conditioning on the final quality.

The wireframe conditioning appears to act rather loosely. For example, the generated wireframe of the bunny in figure 2 has a pentagon on the left ear and a quad on the right, but only has triangles in the output. Similarly, for the banana (circled banana, bottom tip has a weird triangulation). The bus in figure 7 has triangles that do not match the input wireframe. To be clear: In most cases, this is actually a benefit, because the method corrects for bad mesh topology in the wireframe (pentagon, quad) and is robust to small deviations in geometry. However, there is a mismatch between the precision and detail implied by the wireframe conditioning and the level of precise control in practice. Would the method also work with a coarser conditioning, such as text? Are there ways to have tighter control on the conditioning?

I'm missing an ablation that demonstrates the validity of the correctness check in WirePilot. What happens when the first generated image is used directly? It would also be good to include some examples of VLM-judgements on the criteria of table 4 to understand the validity of this step.

Questions for authors
  1. Could you provide an equation for l. 264: aggregating tokens with factorized attention
  2. What is the "final projection" in l. 267? What are MM, dod_o? Seems like this is a flattening operation so that M=V∗g∗gM = V*g*g?
  3. What is 'wireframe-ink' (l. 694)? This sounds like LLM-jargon.
  4. Figure 2: is there a missing arrow into self-attn?
  5. what is WKVW_{KV} in eq. 3? Does it vary with the number of views? Note: overloaded V to be number of views and vertices
6 comments
AuthorsOpenReview ↗

Official Response by Authors – Part 1

We thank the reviewer for recognizing the value of this work and for the constructive feedback. We address each concern below.

Distinguishing wireframe guidance from dense image-space geometry conditioning

Half of the surface points in BPT are uniformly sampled, therefore, we believe insufficient surface sampling is unlikely to be the main cause of the large missing regions. Similar incompleteness can also be observed in prior works, including the manuscript of MeshFlow (in Figure 8).

We believe a major factor is the finite token budget of autoregressive (AR) mesh generators. Our BPT backbone has a 12,000-token context, and excessively dense polygonal layouts may exhaust this budget before generation is complete, resulting in holes or missing regions. Increasing the surface sampling density does not necessarily resolve this issue, as denser geometric inputs may also encourage the model to generate overly dense meshes, especially for highly detailed input shapes.

Our image-based wireframe condition guides both edge arrangement and polygon density, helping the model allocate its generation budget more effectively.

Regarding the suggested geometry-only control, the additional training cost prevents us from completing this experiment during rebuttal. Nevertheless, we emphasize that the normal and CCM maps are rendered from the original input mesh, which may be highly detailed. Like the original surface point cloud, these maps describe the underlying 3D geometry but do not specify the desired low-poly edge layout. Similarly, our point-based wireframe ablation suggests that directly encoding explicit 3D geometric samples is not necessarily sufficient for robust structural guidance. In contrast, the 2D wireframe provides an explicit reference for the target edge arrangement, encouraging the model to rely primarily on this condition for edge-layout decisions, as discussed in our response to Reviewer yV6m (Behavior under Conflicting Conditions).

Precision and limitations of wireframe control

We appreciate the reviewer's observations regarding the bunny, banana, and bus. Our wireframe serves as a soft structural prior, guiding polygon density and edge-layout styles rather than enforcing exact edge correspondence. In practice, WirePilot-generated multi-view wireframes may not be perfectly consistent across views, and the model may learn a compromise among inconsistent views. Moreover, the autoregressive next-token prediction paradigm may further limit precise global alignment with the reference wireframes.

These limitations may arise from both imperfect multi-view references and the current generative backbone. In this work, we introduce editable 2D structural guidance into native mesh generation through a backbone-agnostic interface. We expect that advances in mesh-generation backbones could enable more precise control. Regarding text-based control, as demonstrated in Figure 8, text instructions are currently translated into wireframe references by WirePilot before being used to condition mesh generation. Exploring direct text conditioning without this intermediate wireframe representation is an interesting direction for future work.

Correctness check in WirePilot.

In Figure 7 of the updated manuscript, we have added comparisons showing that one-shot wireframes generated by Gemini 3 Pro Image (Nano Banana Pro) can contain substantial geometric misalignment or cross-view inconsistencies. Such unreliable references can mislead the mesh generator, resulting in disorganized edge layouts and even holes in the generated meshes. Although the surface conditioning and wireframe-condition dropout during training provide some robustness to imperfect references, they cannot fully prevent these artifacts. WirePilot's evaluation and refinement help identify and correct problematic references before mesh generation, improving the reliability of the overall pipeline.

We also provide a representative VLM evaluation example at approximately 1:21 in the supplementary video, showing a candidate rejected according to the criteria in Table 4. Together with Figure 3, these examples illustrate the practical role of WirePilot's verification process.

AuthorsOpenReview ↗

Official Response by Authors – Part 2

Question 1. Factorized attention (l. 264)

The encoder alternates between within-view 2D attention and joint multi-view 3D attention, over two stages (S=2S=2). Let Fv(0)∈Rg2×dhF _v^{(0)}\in\mathbb{R}^{g^2\times d _h} denote the grounded tokens of view vv (Eq. 2), where dh=256d _h=256. Each stage s=1,…,Ss=1,\dots,S is formulated as:

F~v(s)=Block2D(s)(Fv(s−1); pv,ij=(i,j)),v=1,…,V.\widetilde{F} _v^{(s)} = \mathrm{Block} _{2D}^{(s)} \left(F _v^{(s-1)};\,p _{v,ij}=(i,j)\right), \quad v=1,\dots,V.

F(s)=Block3D(s)(Concatv=1VF~v(s); pv,ij=λPˉv[i,j]).F^{(s)} = \mathrm{Block} _{3D}^{(s)} \left(\mathrm{Concat} _{v=1}^{V}\widetilde{F} _v^{(s)};\,p _{v,ij}=\lambda\bar{P} _v[i,j]\right).

  • Both blocks are standard pre-norm Transformer blocks with RoPE-based attention, where pp denotes the position used for rotary embeddings.
  • The 2D blocks attend only within each view, using image-grid coordinates as positions.
  • The 3D blocks attend jointly over all Vg2Vg^2 tokens. Each token uses the pooled CCM coordinate of its own cell, scaled by λ=10\lambda=10, as its position. This enables attention to capture spatial relationships between tokens from different views, even when their image coordinates differ.
  • Cells without valid surface coordinates at the downsampled 64×6464\times64 resolution are masked as keys during cross-view attention, while remaining available as queries and in the resulting feature sequence.

Question 2. Final projection and token dimensions (l. 267)

The reviewer's interpretation is correct. The final projection is a per-token linear layer, followed by flattening the view grids into a token sequence; no pooling or resampling is involved:

T=Flatten(v,i,j)(F(S)Wout),Wout∈Rdh×do.T=\mathrm{Flatten} _{(v,i,j)}\left(F^{(S)}W _{\mathrm{out}}\right),\qquad W _{\mathrm{out}}\in\mathbb{R}^{d _h\times d _o}.

Hence T∈RM×doT\in\mathbb{R}^{M\times d _o}, with M=Vg2=6×642=24,576M=Vg^2=6\times64^2=24{,}576 and do=64d _o=64 for the V=6V=6 setting.

Question 3. Meaning of "wireframe-ink" (l. 694)

We agree that the term is unclear. We replaced all related expressions in the updated manuscript and highlighted in blue.

Question 4. Missing arrow in Figure 2

Thank you for identifying this omission. The input arrow to the first self-attention block is indeed missing: the embedded mesh-token sequence should enter there.

We corrected the missing input arrow and the connections between consecutive blocks in Figure 2 in the updated manuscript.

Question 5. Definitions in Equation (3) and dependence on view count

To avoid overloading the notation, we use V\mathcal{V} for the mesh vertex set, VV for the number of reference views, and vv for the view index.

In Eq. (3),

Δ(h)=βWo CrossAttn(LNq(h),LNkv(WkvT)),\Delta(h)=\beta W _o\,\mathrm{CrossAttn}\left(\mathrm{LN} _q(h),\mathrm{LN} _{kv}(W _{kv}T)\right),

where:

  • hh denotes the input hidden states before layer normalization in the backbone self-attention sublayer, with hidden width d=1024d=1024.
  • WkvW _{kv} projects the wireframe tokens from do=64d _o=64 to d=1024d=1024, where the subscript kvkv denotes key–value, rather than the view index.
  • LNq\mathrm{LN} _q and LNkv\mathrm{LN} _{kv} are LayerNorm operations for the query and key–value features, respectively.
  • WoW _o is the zero-initialized output projection.
  • β\beta is a binary per-sample validity mask for the wireframe condition.

None of these parameters depends on the number of views. WkvW _{kv} acts on each token independently, so changing VV only changes the number of key/value tokens, M=Vg2M=Vg^2, over which the attention softmax is normalized. Therefore, the same model supports both single-view and multi-view conditioning, as described in Appendix A.4.

Dear authors, Thank you for providing the requested clarifications and answering my questions in detail. I would like to respond to the first point on "Distinguishing wireframe guidance from dense image-space geometry conditioning." I believe the paper makes two statements about the effect of the wireframe guidance, reflected in your response to 2gYH: "Introducing wireframe guidance (1) improves geometric fidelity while (2) enabling control over edge-layout styles."

While I can see convincing evidence for (2), I do not see evidence for (1). I can follow the argument about BPT and the potential causes of missing regions; however, it remains speculative, given the system's complexity. This claim requires support from an experiment that isolates the contribution of the wireframe conditioning to geometric fidelity, i.e., a comparison to the full method that leaves out the wireframe channel from conditioning. Without this evidence, the statement that "introducing wireframe guidance improves geometric fidelity" is speculative, even if it is plausible. That said, I can see that the method as a whole improves geometric fidelity, but the paper should not claim a causal relationship precisely between wireframe conditioning and geometric fidelity without stronger evidence.

I do not think this should bar the paper from being accepted. I would say that the control of edge flow, even if it is loose, is useful in itself and the system as a whole improves geometric fidelity. My main ask is that the paper is precise in which statements it claims as fact.

Reviewer_yV6mOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes WireForge, a framework that uses 2D wireframe priors to guide mesh generation and customize the polygonal layout of 3D meshes. WirePilot uses Gemini 3 Pro Image to produce a wireframe prior from a rendered view of the input shape. The prior is then incorporated into the mesh generator through cross-attention layers. Experiments on Toys100 report strong quantitative and qualitative performance, while additional examples demonstrate control over polygonal layouts through text and sketch guidance.

Critical strengths
  1. Introducing wireframe guidance addresses a meaningful limitation of existing artistic mesh generators: their limited ability to customize polygonal layouts.

  2. The method is clearly structured and well aligned with the task. The additional experiments with a flow-matching backbone also suggest that the conditioning mechanism is not restricted to an autoregressive generator.

  3. Figure 7 shows different layouts for the same underlying shape under different text and sketch instructions, providing compelling qualitative evidence of controllability.

Critical weaknesses
  1. The choice of wireframe encoder is insufficiently justified. While DINOv2 and DINOv3 are commonly used to extract image features for 3D generation, WireForge uses a FLUX VAE to encode its wireframe prior. This choice may be appropriate for preserving spatial detail, but the paper should explain the rationale and ideally compare alternative encoders under otherwise matched settings.

  2. The behavior under conflicting conditions is unclear. If the geometry implied by the wireframe differs from the surface-point condition, it is unclear whether the model prioritizes surface fidelity, wireframe adherence, or a compromise between them. Controlled conflict experiments would help establish the limits of the claimed topology control.

  3. The comparison between 2D and 3D wireframe conditioning lacks implementation detail. The paper should clarify whether the back-projected 3D representation retains explicit edge connectivity or is treated only as a point set. It should also specify the point encoder, its input attributes, and the dimensionality and organization of its output tokens. Without this information, it is difficult to determine whether the comparison isolates representation dimensionality or is confounded by information loss and encoder design.

  4. Table 1 would benefit from an oracle-wireframe condition. Using wireframes rendered from the ground-truth meshes would help distinguish errors introduced by WirePilot from limitations of the mesh generator. It would also provide a useful reference for assessing how accurately the generator can follow a correct wireframe prior.

  5. The comparisons in Table 2 do not sufficiently isolate the benefit of wireframe conditioning from fine-tuning. The baselines should be fine-tuned on the same data for the same number of optimization steps, with comparable training settings but without wireframe guidance. Otherwise, the reported improvement cannot be confidently attributed to the proposed conditioning mechanism.

  6. The qualitative comparison with BPT has the same confounding factor. In Figure 4, BPT produces incomplete shapes with substantial holes, whereas WireForge, which is fine-tuned from BPT, produces more complete meshes. This demonstrates an improvement in the overall system, but it does not establish whether the improvement comes from wireframe guidance or additional fine-tuning. A fine-tuned BPT control without the wireframe prior is needed.

Questions for authors

See weaknesses.

4 comments
AuthorsOpenReview ↗

Official Response by Authors – Part 1

We thank the reviewer for recognizing the value of this work and for the constructive feedback . We address each concern below.

Choice of wireframe encoder

We experimented with DINO-family visual encoders but found FLUX VAE more suitable for our wireframe conditioning task.

Unlike natural RGB images, our wireframe references are essentially binary line drawings, where fine-grained edge arrangements and line density are more important than high-level semantic features. While DINO models are primarily pretrained to learn general-purpose visual representations from large-scale image datasets, the reconstruction-oriented FLUX VAE provides spatially localized features that better suit these low-level structural cues.

Moreover, FLUX VAE produces compact 16-channel latent features on a regular spatial grid, providing a convenient representation for subsequent 3D grounding and cross-attention. We therefore favor its reconstruction-oriented features for preserving local wireframe structure, rather than relying primarily on semantic visual representations.

Behavior under conflicting conditions

WireForge is designed to leverage the complementary roles of the two conditions: the surface condition primarily constrains the overall shape and geometric fidelity, while the wireframe condition primarily guides edge arrangement and polygon density.

During training, the wireframe is rendered directly from the selected target mesh, whether original or QEM-simplified, ensuring correspondence between the reference wireframe and the target edge layout. This supervision encourages the model to rely primarily on the wireframe for edge-layout decisions while using the surface condition to preserve the overall geometry, when the wireframe condition is available and reasonable.

To further illustrate this behavior, we have added two dual-condition examples in Figure 12, showing the mesh of the input point cloud, the input wireframe condition, and the generated mesh wireframe. The results demonstrate that the generated meshes preserve the overall shape specified by the surface condition, while their edge layouts more closely follow the wireframe references.

Implementation of 3D wireframe conditioning

In our point-based baseline, we back-project the 2D wireframe pixels from all six views into 3D using the corresponding position and normal maps, and aggregate them into an unordered point cloud. Each point contains only its 3D position and surface normal (6-D), without explicit edge connectivity or view information. We then sample 40,960 points and encode them using a separately fine-tuned VecSet-style encoder initialized from Hunyuan3D-2 ShapeVAE, producing 2,048 latent tokens of dimension 64. The encoder uses Fourier position embeddings, FPS-based query selection, and cross-/self-attention, following the surface-conditioning architecture.

These tokens are injected through the same zero-initialized residual cross-attention layers as our image-based condition, keeping the decoder and surface-conditioning pathway unchanged. Thus, the two variants differ in their wireframe representation and encoder, while sharing the downstream conditioning mechanism. We have added these implementation details to the revised appendix (highlighted in blue).

We also evaluated configurations with 10,240 sampled points and 512 or 2,048 output tokens. Across these configurations, the point-based representation was less robust to imperfect wireframe references. Small edge deviations can become displaced 3D points, while cross-view inconsistencies introduce conflicting 3D evidence into the aggregated point cloud, due to direct back-projection of points. In contrast, our image-based representation encodes each view independently before CCM-based cross-view fusion, which enables more implicit reconciliation of cross-view inconsistencies through spatially grounded attention.

As shown in Table 3 and Figure 6(a), the image-based representation achieves better normal consistency and more robust qualitative results under noisy WirePilot references.

AuthorsOpenReview ↗

Official Response by Authors – Part 2

Oracle wireframe evaluation

We have conducted an additional experiment using oracle wireframes rendered directly from the ground-truth target meshes, replacing WirePilot-generated references while keeping the mesh generator, surface condition, and inference settings unchanged.

The results are summarized below.

Wireframe conditionCD ↓HD ↓HD95 ↓NC ↑Abs. NC ↑
WirePilot0.00690.04040.01370.90970.9426
Oracle wireframe0.00660.03920.01220.91100.9444
The oracle wireframe yields only marginal improvements across all metrics. We believe this relatively small performance gap is largely due to our additional fine-tuning on WirePilot-generated references, which enables the model to better handle their imperfections and achieve performance close to that obtained with oracle wireframes.

Isolating wireframe guidance from fine-tuning

We conducted a matched fine-tuning experiment on BPT, using the same training data and comparable optimization settings but without wireframe conditioning.

ModelCD ↓HD ↓HD95 ↓NC ↑Abs. NC ↑
BPT (released)0.00700.04840.01500.87160.9399
BPT (matched fine-tuning)0.00840.08860.03050.87710.9280
WireForge (Ours)0.00690.04040.01370.90970.9426

The matched fine-tuned BPT performed worse than the released model on most metrics, potentially due to the higher proportion of high-resolution meshes in our training data, which may encourage denser outputs that are more prone to holes. In contrast, WireForge achieves better performance, suggesting that its improvements cannot be attributed to additional fine-tuning alone.

Figure 11 further provides qualitative comparisons with the matched fine-tuned BPT baseline, illustrating improvements in mesh completeness.

The authors provide a solid response, and my concerns were adequately addressed. So I maintain my score and recommend accepting this paper.

Thank you for your response! We are glad our reply addressed your concerns, and we appreciate your recognition of our work.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

We thank all reviewers for their detailed reviews and constructive suggestions!

We have revised the manuscript to address the reviewers' concerns. All changes in the updated manuscript are highlighted in blue. The main revisions are summarized below.

Additional experiments and comparisons

  • Added a matched BPT fine-tuning baseline to assess whether the improvements arise from wireframe guidance rather than additional training alone (reviewer yV6m, Appendix A.5, Table 5 and Figure 11).
  • Added qualitative comparisons illustrating how generated edge layouts follow wireframe references while preserving the input geometry (reviewers yV6m and 2gYH, Appendix A.5, Figure 12).
  • Added comparisons of one-shot wireframes and WirePilot-refined references to demonstrate the importance of verification and refinement (reviewer Us9j, Appendix A.2, Figure 7).
  • Conducted an oracle wireframe experiment using ground-truth-rendered references, with quantitative results reported in our response to reviewer yV6m.
  • Extended rendering-based comparisons to existing mesh-generation methods using LPIPS, FID, and SSIM, with results reported in our response to reviewer 2gYH.

Additional discussions and implementation details

  • Expanded the implementation details of point-based wireframe conditioning, including back-projection, point sampling, encoder architecture, and token dimensions (reviewer yV6m, Appendix A.1).
  • Clarified the complementary roles of surface and wireframe conditioning, and discussed the limitations of precise edge-layout control (reviewers yV6m and Us9j, Section 3.3 and Appendix A.5).
  • Added further analysis of WirePilot's verification and refinement process, including examples of inconsistent wireframe references and their effects on mesh generation (reviewer Us9j, Appendix A.2, Figures 3 and 7).
  • Expanded the discussion of edge-layout controllability, polygon-density guidance, and relevant prior work, including SpaceMesh and TriFlow (reviewer 2gYH, Sections 2 and 4.3, Appendix A.4).

Method and notation clarifications

  • Clarified the factorized 2D/3D attention, invalid-cell masking, and the dimensions and projection of wireframe tokens (reviewer Us9j, Section 3.3.3 and Appendix A.1).
  • Corrected the framework diagram and clarified the cross-attention formulation and variable-view conditioning (reviewer Us9j, Figure 2 and Section 3.3.4).
  • Revised ambiguous terminology and distinguished the mesh vertex set V\mathcal{V} from the number of reference views VV (reviewer Us9j, Section 3.1 and Appendix A.2).

We sincerely appreciate the reviewers' valuable feedback and the opportunity to improve our work. We welcome further questions and discussion.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.