MeshSuite: A Unified Benchmark for Triangle- and Mesh-Based Neural Rendering

Figure 1 | The MeshSuite Framework Architecture: The Dataset Management layer standardizes data formats (image resolution, camera-view alignment, and color channels). Triangle- and mesh-based splatting methods (2DTS, Triangle Splatting, MeshSplatting, DiffSoup) are unified in the Algorithm Pool and trained via Model Training. Trained models are systematically evaluated across three rendering paradigms: Non-Engine Render (native CUDA rasterizers), Standard Deployment (conventional opaque vertex-colored mesh in Unity), and Dedicated Deployment (method-specific Unity renderers preserving alpha blending and view-dependent appearance).

⚠️

The Deployment Gap

Deploying soup methods as standard opaque meshes in a game engine causes catastrophic visual collapse (up to 15.6 dB PSNR drop). MeshSplatting loses the least due to indexed Delaunay geometry.

⚖️

The Fidelity-Speed Tradeoff

Dedicated Unity shaders recover 2.7–10.8 dB PSNR by retaining soft coverage and alpha compositing, but suffer a 5×–33× framerate slowdown due to depth sorting overhead.

🧩

Topological Illusion

Shared vertex indexing does not ensure a valid manifold mesh. Structural audits reveal 18–28% non-manifold edges, 65–87% non-manifold vertices, and hundreds of thousands of disconnected shards.

🎮

Unified Engine Pipeline

Includes a universal .triasset serialization layer and production Unity shaders supporting continuous alpha, view-dependent SH, and in-shader neural Micro-MLP texture decoding.

Motivation & Summary

Abstract

Triangle- and mesh-based neural rendering aims to bridge neural scene representations and existing graphics engines (e.g., Unity, Blender) by leveraging triangle primitives compatible with standard rasterization hardware. There have been several such methods driven by parallel efforts, developed and evaluated under inconsistent settings, with little or no comparison with each other; critically, most have never used graphics engines for evaluation nor considered deployability in practice — significantly undermining the objective and motivation.

To address these issues, we introduce MeshSuite, the first benchmark of its kind to enable systematic evaluation of graphics-engine deployment and Non-Engine Render for triangle- and mesh-based neural rendering methods. Importantly, our deployment protocol includes two engine deployment settings:

(1) Standard Deployment — a conventional opaque mesh pipeline with vertex colors and hardware Z-buffering;
(2) Dedicated Deployment — method-specific engine implementations supporting retained appearance and compositing features (e.g., alpha blending), taking into account individual model characteristics.

For mesh splatting, we further propose a structural audit of exported surfaces, diagnosing topological and geometric integrity toward downstream graphics assets. From this benchmark, we validate that rasterizability is merely part of graphics readiness, and highlight the significance of assessing the graphics engine deployment process.

Interactive Visualizer

4-Way Synchronized Image Split Comparison

Comparing novel-view synthesis across Standard Deployment → Dedicated Deployment → Non-Engine Render → Ground Truth. Drag the vertical divider lines to dynamically adjust the visible split regions!

Standard → Dedicated → Non-Engine → GT

Std | Ded

Ded | Native

Native | GT

Standard Deployment

Dedicated Deployment

Non-Engine Render

Ground Truth

Presets:

2DTS

The Soup Deployment Collapse: 2DTS relies heavily on alpha blending of independent triangle facelets. In Standard Deployment with hardware Z-buffering, overlapping semi-transparent triangles degenerate into opaque black shards (15.6 dB drop). Dedicated Deployment recovers multi-pass alpha compositing.

Evaluation Protocol

The Three Evaluation Settings

Systematically dissecting the transition from research CUDA kernels to engine rasterization.

Baseline Setting

1. Non-Engine Render

Evaluated directly using each method's official source research renderer (differentiable CUDA kernels). Serves as the upper-bound fidelity benchmark.

Source paper rasterization
Full continuous opacity
Not usable in game engines

Conventional Asset

2. Standard Deployment

Converts trained models to conventional opaque meshes with static vertex colors rendered using standard hardware Z-buffering in Unity.

Blazing fast (up to 5,480 FPS)
100% plug-and-play CG asset
Massive quality loss (8–15 dB drop)

Engine Native

3. Dedicated Deployment

Customized engine shaders in Unity implementing method-specific appearance (view-dependent SH, soft coverage, order-dependent alpha blending).

Recovers 2.7–10.8 dB PSNR
Micro-MLP shader decoding
5×–33× slower than Standard

Engine Support and Retained Rendering Features (Table 1)

Method	Standard Deployment		Dedicated Deployment (Method-Aware Unity Shaders)
Method	Support	Appearance	View-dep. SH	Opacity	Soft Coverage	Depth Sort	Appearance Model
3DGS (Reference)	N/A	—	N/A	—	—	—	—
2DGS (TSDF Mesh)	Fallback	baked color	N/A	—	—	—	—
2DTS	Fallback	baked SH-DC					SH (Spherical Harmonics)
Triangle-Splatting	Fallback	baked SH-DC					SH (Spherical Harmonics)
MeshSplatting	Fallback	baked SH-DC			—		SH (Spherical Harmonics)
DiffSoup	N/A	Requires decoder		—	—	—	In-Shader Micro-MLP

Empirical Results

Benchmark Leaderboards

Standardized novel-view synthesis, throughput, memory allocation, and geometry quality.

Evaluated on single NVIDIA RTX 4090 GPU

Setting	Method	Type	PSNR ↑	SSIM ↑	LPIPS ↓	Throughput (FPS) ↑	GPU Latency (P50 ms) ↓	VRAM / Alloc ↓
Non-Engine Render	3DGS (Reference)	Gaussian Splats	27.21	0.815	0.214	109	—	—
	2DGS (Reference)	Surface Gaussians	26.79	0.796	0.252	38	—	—
	2DTS	Triangle Soup	28.16	0.841	0.215	70	—	10,069 MiB (Train)
	Triangle-Splatting	Triangle Soup	27.13	0.812	0.227	94	—	18,901 MiB (Train)
	DiffSoup	Neural Texture Soup	23.54	0.689	0.322	168	—	23,484 MiB (Train)
	MeshSplatting	Indexed Mesh	24.72	0.729	0.365	38	—	23,134 MiB (Train)
Standard Deployment (Unity)	2DGS (TSDF)	Opaque Mesh	12.70	0.311	0.594	2,778	0.4 ms	54 MiB
	2DTS	Opaque Soup Shards	12.52	0.311	0.661	3,754	0.3 ms	54 MiB
	Triangle-Splatting	Opaque Soup Shards	14.77	0.246	0.656	2,294	0.5 ms	54 MiB
	MeshSplatting	Delaunay Mesh	19.83	0.491	0.518	943	1.1 ms	54 MiB
Dedicated Deployment (Unity)	2DTS	Custom Alpha Splat	23.28	0.699	0.313	545	2.1 ms	1,140 MiB
	Triangle-Splatting	Custom Window Splat	22.96	0.695	0.301	70	3.8 ms	1,559 MiB
	DiffSoup	Compute Micro-MLP	23.15	0.647	0.331	1,995	0.5 ms	288 MiB
	MeshSplatting	Indexed Alpha Mesh	22.52	0.589	0.457	157	6.4 ms	927 MiB

Setting	Method	Type	PSNR ↑	SSIM ↑	LPIPS ↓	FPS ↑	P50 Latency ↓	Asset Size ↓
Non-Engine	2DTS	Triangle Soup	23.42	0.853	0.203	101	—	352 MiB
	Triangle-Splatting	Triangle Soup	23.08	0.856	0.171	159	—	498 MiB
	DiffSoup	Neural Texture	18.90	0.685	0.352	226	—	258 MiB
	MeshSplatting	Indexed Mesh	20.53	0.756	0.319	66	—	390 MiB
Standard (Unity)	2DTS	Opaque Mesh	12.40	0.337	0.629	5,480	0.2 ms	352 MiB
	Triangle-Splatting	Opaque Mesh	11.08	0.292	0.661	3,928	0.3 ms	498 MiB
	MeshSplatting	Delaunay Mesh	14.38	0.506	0.490	1,528	0.7 ms	390 MiB
Dedicated (Unity)	2DTS	Custom Splat	19.26	0.646	0.296	909	1.2 ms	352 MiB
	Triangle-Splatting	Custom Splat	19.54	0.719	0.258	536	1.9 ms	498 MiB
	DiffSoup	Micro-MLP	17.02	0.606	0.402	2,388	0.4 ms	258 MiB
	MeshSplatting	Indexed Alpha	16.09	0.587	0.435	300	3.4 ms	390 MiB

Method	Geometry Accuracy (Chamfer Distance mm) ↓	PSNR ↑	SSIM ↑	LPIPS ↓	Render FPS ↑	Peak Train Mem ↓	Train Time ↓
2DTS	0.63 mm	29.66	0.951	0.110	312	2,470 MiB	21.2 min
Triangle-Splatting	1.27 mm	27.78	0.944	0.080	165	4,163 MiB	13.1 min
MeshSplatting	0.80 mm	27.82	0.933	0.106	114	7,680 MiB	10.7 min
DiffSoup	3.89 mm	17.91	0.760	0.263	170	23,930 MiB	14.5 min

Method	Representation	PSNR ↑	SSIM ↑	LPIPS ↓	FPS ↑	Peak Train Mem ↓	Train Time ↓
2DTS	Triangle Soup	33.65	0.970	0.034	126	3,172 MiB	16.3 min
Triangle-Splatting	Triangle Soup	29.87	0.956	0.055	243	12,257 MiB	19.1 min
MeshSplatting	Indexed Delaunay	29.50	0.945	0.071	86	23,386 MiB	13.4 min
DiffSoup	Neural Texture Soup	28.65	0.910	0.076	371	16,334 MiB	12.2 min

Trade-Off Analysis

Quality vs. Efficiency Trade-Off

How image fidelity transitions to framerate across Standard, Dedicated, and Native renderers.

Fidelity vs. Throughput Trajectories

Standard Deployment hits thousands of FPS (up to 5,480 FPS) via GPU rasterization, but at the cost of drastic visual drops. Dedicated Deployment shifts along the Pareto frontier, restoring near-native PSNR while operating at 70–2,388 FPS.

Deployment Gaps Across Datasets

Illustrating the adaptation gap (ΔQ^adapt), portability gap (ΔQ^port), and overall deployment gap (ΔQ^deploy). MeshSplatting displays the smallest portability gap due to shared vertex geometry.

Geometric & Topological Integrity

Structural Audit of Exported Meshes

Does explicit triangle indexing ensure a viable 3D asset for physics, animation, and downstream CG pipelines?

Figure 2 | Topology diagnostics for the structural audit: (a) Boundary edges with 1 incident face; (b) Non-manifold edges with >2 incident faces; (c) Non-manifold vertices with disconnected incident-face fans; (d) Edge-connected components representing disconnected face clusters.

Mesh Diagnostics for MeshSplatting across All Benchmark Datasets (Table 5)

Dataset	Local Reuse		Local Structure Defect Rate			Global Connectivity & Fragmentation
Dataset	V / F Ratio	Valence	Boundary Edges	Non-Manifold Edges ↓	Non-Manifold Verts ↓	LCC Faces ↑	LCC Area ↑	Components (K) ↓
Mip-NeRF 360	0.523	6.49	45.4%	17.8%	65.2%	69.9%	68.9%	712.9 K
Tanks & Temples	0.516	6.49	46.1%	18.2%	66.5%	69.9%	66.6%	442.8 K
DTU	0.428	7.36	41.2%	22.2%	72.7%	76.9%	77.5%	43.3 K
NeRF-Synthetic	0.339	8.59	37.2%	28.4%	87.3%	80.4%	80.4%	65.8 K

Key Insight: Even though MeshSplatting adopts indexed Delaunay meshes, up to 87.3% of vertices and 28.4% of edges are non-manifold, with hundreds of thousands of fragmented islands. Visual fidelity does not imply structural readiness for standard rigging, physics simulation, or subdivision.

Industrial Engine Parity

Unity Engine Integration & Shaders

Exporting feature-preserving .triasset formats and executing custom rendering passes.

Figure 3 | Software Architecture & Implementation Overview: Unified modular pipelines spanning config-locked training, translation layers, export adapters, Unity runtime render passes, and automated headless batch evaluation.

MethodSpecificSplat.shader

Procedural Splatting Shader

Implements differentiable window evaluations, view-dependent spherical harmonics, and ordered multi-pass alpha blending directly in Unity's graphics pipeline.

MeshSplatIndexedMesh.shader

Indexed Mesh Shader

Consumes shared vertex buffers and face index buffers with per-vertex spherical harmonics colors, bypassing redundant vertex transmissions.

DiffSoupMetal.shader

In-Shader Micro-MLP Decoder

Evaluates neural texture latents inside a custom compute shader on Metal/Vulkan, executing lightweight MLP forward passes in real-time at ~2,000 FPS.

StandardVertexColorRaw.shader

Standard Opaque Baseline

Evaluates conventional game-engine opaque mesh rendering with static vertex colors and hardware Z-buffering for standard deployment comparisons.

Interactive Camera Trajectory Player

3-Way Synchronized Video Split Comparison

Real-time camera orbit videos rendered across Standard Deployment → Dedicated Deployment → Non-Engine Render. Drag the vertical divider lines to dynamically adjust the visible split regions!

Standard → Dedicated → Non-Engine

Standard | Dedicated

Dedicated | Non-Engine

Standard Deployment

Dedicated Deployment

Non-Engine Render

00:00 / 00:40

Presets:

Getting Started

Installation & CLI Usage

Reproduce training, export .triasset packages, and profile framerates in Unity.

          # Clone the unified benchmark repository
git clone https://github.com/prinasi/MeshSuite.git
cd MeshSuite

# Option 1: Conda Environment (Recommended)
conda env create -f environment.yml
conda activate msbench

# Option 2: Pip editable install with compiled CUDA rasterizers
pip install -e ".[dev,cuda]" --no-build-isolation
        

          # Train, render novel views, and evaluate metrics in a unified CLI
msbench train --config configs/triangle-splatting/mipnerf360/bicycle.yaml
msbench render images --config configs/triangle-splatting/mipnerf360/bicycle.yaml
msbench eval images --config configs/triangle-splatting/mipnerf360/bicycle.yaml

# Train full dataset with helper script
bash single_train.sh triangle-splatting mipnerf360/all 0
        

          # Export method-preserving .triasset packages for Unity
bash single_export_unity.sh triangle-splatting mipnerf360/all 0
bash single_export_unity.sh mesh-splatting mipnerf360/garden 0

# Serializes vertices, triangular topology, SH color coefficients, 
# opacity compactness, and micro-MLP neural textures
        

          # Headless Unity evaluation: captures frames, profiles P50/P95 latencies and FPS
bash single_unity_eval.sh 2dts mipnerf360/bicycle 0 \
  --unity "$UNITY" \
  --unity-project unity

# Render camera trajectory video in Unity
bash single_unity_video.sh triangle-splatting mipnerf360/bicycle 0 \
  --unity "$UNITY" \
  --unity-project unity
        

Citation

BibTeX

@article{zhang2026meshsuite,
  title   = {MeshSuite: A Unified Benchmark for Triangle- and Mesh-Based Neural Rendering},
  author  = {Zhang, Kaixuan and Li, Minxian and Ren, Mingwu and Zhu, Xiatian},
  journal = {arXiv preprint arXiv:2609.01306},
  year    = {2026},
  url     = {https://arxiv.org/abs/2609.01306}
}