- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This submission describes MeshSplatBench, a benchmark that explores how triangle and mesh-based scene representations actually perform inside a real graphics engine. The motivation behind this effort is that these methods are pitched as "game-engine ready" since they use triangle primitives that are theoretically compatible with standard rasterization but have actually never been tested inside an engine under a unified evaluation protocol.
Concretely, 2DTS, Triangle-Splatting, MeshSplatting, and DiffSoup are rendered and evaluated across three different modes. Each method is evaluated under a "non-engine render" mode which just uses the method's native renderer outside of the graphics engine (the authors treat this as an "upper bound" on quality), a "standard deployment" mode that treats method outputs as a plain opaque mesh with vertex colors within the engine (no opacity, no view-dependent color, etc), and a "dedicated deployment" mode where the submission authors re-implement custom Unity renderers for each method's features (this is the main engineering contribution of the paper). The authors do an additional mesh structure audit measuring vertex reuse, manifoldness, and global connectivity on MeshSplatting only.
The methods are evaluated across these deployment modes on Mip-NeRF 360 and Tanks and Temples (the authors exclude DiffSoup from standard mode because of its neural feature decoder) along with 3DGS/2DGS in non-engine mode and 2DGS in standard mode. DTU and NeRF-Synthetic are also evaluated in the non-engine render setting. When evaluated in the non-engine render setting, the authors reproduce the published numbers within 0.075 dB PSNR on average, and no method consistently dominates across quality and speed. MeshSplatting does best in the standard deployment setting (since it's trained to use opaque triangles as opposed to soft, semi-transparent primitives like 2DTS and Triangle-Splatting). 2DTS/Triangle-Splatting are narrowly best in dedicated rendering mode, although their PSNR drops 4-5 dB compared to non-engine rendering. Overall the dedicated rendering mode gives visually better results than the standard mode but the authors report 6-30x slower rendering speeds. The mesh structural analysis performed on MeshSplatting finds that its meshes look regular but aren't very clean (18% of edges and 65% of vertices are non-manifold, which would make remeshing/UV mapping/etc difficult, and scene splits into 710k disconnected pieces on average).
Critical strengths
I think the big value of this paper is flagging that currently a lot of methods that claim compatibility with graphics engines should actually be tested within a more realistic deployment framework. To that end, developing a standard benchmarking protocol is a valuable contribution to the field. At a high level, asking "how well do these methods perform with/without custom shaders" makes a lot of sense. This would be the main thing that would convince me to advocate accepting the paper.
As a secondary contribution, the dedicated deployment implementations of the baselines are potentially useful if released and upstreamed into the relevant repositories.
Critical weaknesses
My main concerns around this submission revolve around the soundness and usefulness of the evaluation protocol (I initially rated soundness as 2 but feel it's close to 1). As currently designed the "standard deployment" mode doesn't feel very informative or useful - 2DTS/Triangle-Splatting being worse than MeshSplatting is not surprising considering they use semi-transparent triangles by default and the latter doesn't. The protocol for that mode feels overall arbitrary - why exclude DiffSoup and not bake its neural features into color when 2DGS is already going through similar baking + TSDF meshing? A more useful set of evaluation modes would be: (a) adapting the methods as much as possible to render well without custom shaders and (b) writing custom shaders that best render the methods (the current "dedicated deployment" protocol). To compound my concerns, Triangle Splatting's official repo has a "train_game_engine.py" mode (which prunes low-opacity triangles and adds a loss that increases opacity) that this submission doesn't seem to use. 2DTS has a similar opaque mode. Triangle Splatting+ [1] (a preprint and thus technically not required to cite/compare against) in fact evaluates Triangle Splatting in game-engine mode and reports 21.05 dB PSNR on Mip-NeRF 360 instead of this paper's 14.77 dB finding.
Since the dedicated deployment mode relies on the submission authors' implementations (which I could not find in the supplement), it is also difficult to interpret these results and why there is such a quality drop from the non-engine render mode. It is critical for the authors to provide a convincing analysis as to why this is the case before I would be comfortable recommending acceptance.
Other soundness issues include:
- The 2DGS results look suspiciously bad in Table 4 - and no explanation/visuals are provided (Triangle Splatting+ reports 15.36 dB on M360 for 2DGS-derived meshes)
- The FPS timings in Table 4 and Table 6 are inconsistent - all of the Table 4 entries roughly match 1000 divided by the median GPU time in Table 6 except for Triangle-Splatting under the dedicated deployment protocol (Table 4 lists it at 70FPS while Table 6 implies 263). Sec 4.2 suggests that the latter includes CPU sorting overhead but it would then be unclear to list the other methods' GPU-only timings.
These issues are compounded by the fact that several closely related works are missing, most notably MILo [2], which proposes a mesh-based NVS formulation that scores a reconstruction by rendering its opaque mesh (essentially this submission's standard deployment mode), and nvdiffrec [3], which optimizes triangle meshes and materials end-to-end for use in standard graphics engines. Other established 3DGS/NeRF-to-mesh pipelines, such as Gaussian Opacity Fields [4] and Binary Opacity Grids [5], are also related, and including them would strengthen the analysis.
The writing of this paper is much more complicated than it needs to be to the extent that I look more negatively on the submission than I otherwise would (I am rating presentation as 2 because I think it's fixable). The core thesis of the paper (evaluate neural scene representations in a realistic deployment setting) is clean, but wording like "A three-dimensional audit protocol across visual, computational, and structural dimensions" (lines 245-247) and "Resolves the academic-to-engine impedance mismatch through five modular pillars" (Fig 4 caption) needlessly obscures the paper's message. There are many examples of this (Eq. 1 formalizing "export a checkpoint to a file", "Multi-modal audit" in Figure 1, "engine contract" in line 397, "tier-dependent losses in visual fidelity" in line 402). I would strongly encourage the authors to do a full pass of the paper, drop as much jargon as possible, and make sure the writing is as clean, concise, and legible as can be.
On a more minor note, the figures in the paper could be nicer (especially Figures 1 and 4 that are text-heavy diagrams) and I'd recommend the authors make them more aesthetically pleasing (such as a figure showing a scene rendered across all three modes) ahead of a potential camera-ready.
References:
- [1] Jan Held et al. Triangle Splatting+: Differentiable Rendering with Opaque Triangles. arXiv 2025.
- [2] Antoine Guédon et al. MILo: Mesh-In-the-Loop Gaussian Splatting for Detailed and Efficient Surface Reconstruction. SIGGRAPH Asia, 2025.
- [3] Jacob Munkberg et al. Extracting Triangular 3D Models, Materials, and Lighting From Images. CVPR 2022.
- [4] Zehao Yu et al. Gaussian Opacity Fields. SIGGRAPH Asia 2024.
- [5] Christian Reiser et al. Binary Opacity Grids: Capturing Fine Geometric Detail for Mesh-Based View Synthesis. SIGGRAPH 2024.
Questions for authors
As mentioned in the weaknesses section, the paper needs to convincingly explain the rendering gap from non-engine to dedicated deployment and why their custom shader implementations are a credible measure of these methods.
The action that is otherwise most likely to move my rating upwards would be a more useful "standard deployment" evaluation where the authors make a fair effort to adapt these methods to standard rendering (bake DiffSoup textures, use the proper configrations for Triangle Splatting and 2DTS) and provide updated numbers and analysis.
Other questions:
- Lines 295-297 implies that DiffSoup uses 4x downsampling whereas the methods use 2x and 4x downsample. If true, this suggests that the FPS measurements are not comparable across methods. Could the authors clarify?
- Clarification on the Table 4 vs Table 6 discrepancy
- Clarification on why 2DGS quality is so low
Thank you for the clarification and additional experiments. I appreciate the matched-resolution evaluation of DiffSoup and the correction of the numerical inconsistency, which address part of my concerns.
However, my main concern remains unresolved. The authors attribute the substantial fidelity losses in Dedicated Deployment to differences between rendering pipelines, but provide little explanation of the underlying mechanisms. Especially since the authors explicitly emphasize this as a new finding, I think it is reasonable to expect some meaningful analysis of why these differences occur. Without identifying whether the losses arise from inherent engine constraints or implementation-specific approximations, simply reporting these gaps offers limited insight or practical guidance for graphics rendering development.
I agree that benchmarking practical deployment under specific engine configurations can be valuable. However, the current results remain difficult to interpret beyond the particular implementations evaluated.