LSNIF: Locally-Subdivided Neural Intersection Function

TL;DR

LSNIF tackles the inefficiency of BVH-based ray-geometry queries by learning a per-object neural representation that is trained offline and independent of scene conditions. It combines local geometry voxelization, a sparse multi-resolution hash-grid encoder, and a single object-wide MLP to predict occlusion, hit distance, normals, albedo, and material indices for arbitrary rays, enabling memory-efficient rendering and flexible ray queries. The approach achieves memory reductions up to $106.2\times$ compared to compressed BVHs, supports scene editing and instancing, and can integrate with wavefront path tracing or DirectX Ray Tracing, albeit with current trade-offs in primary visibility and compute divergence. Future work will extend texture coordinates, topology changes, LODs, and adaptive sampling to broaden applicability and performance across diverse rendering pipelines.

Abstract

Neural representations have shown the potential to accelerate ray casting in a conventional ray-tracing-based rendering pipeline. We introduce a novel approach called Locally-Subdivided Neural Intersection Function (LSNIF) that replaces bottom-level BVHs used as traditional geometric representations with a neural network. Our method introduces a sparse hash grid encoding scheme incorporating geometry voxelization, a scene-agnostic training data collection, and a tailored loss function. It enables the network to output not only visibility but also hit-point information and material indices. LSNIF can be trained offline for a single object, allowing us to use LSNIF as a replacement for its corresponding BVH. With these designs, the network can handle hit-point queries from any arbitrary viewpoint, supporting all types of rays in the rendering pipeline. We demonstrate that LSNIF can render a variety of scenes, including real-world scenes designed for other path tracers, while achieving a memory footprint reduction of up to 106.2x compared to a compressed BVH.

Figures (13)

• Figure 1: The illustration of LSNIF methodology. First, the intersection points of a ray with the object's AABB are computed. These points are then used to perform DDA against the voxels, followed by the calculation of hit points on the surfaces of these voxels. The hit points are processed using 3D sparse hash grid encoding, with interpolated feature vectors concatenated into a large vector. This vector is then fed into the MLP which outputs the intersection information of the ray with the geometry.
• Figure 2: (a) Voxel representation of the geometry. (b, c, d, e) Outputs from LSNIF for primary rays. (f) Path-traced image with LSNIF. Note that (f) utilizes rasterization for primary visibility instead of the LSNIF representation shown in (b, c, d, e).
• Figure 3: Visual illustration of the proposed rendering pipeline. (a) the scene is rasterized from the camera. G-buffers are used to generate rays from the primary vertices. (b) the rays are intersected with triangles of non-LSNIF objects using BVHs. Then (c) the rays are tested against LSNIF objects which store a coarse voxel representation of the geometry. (d) the remaining part of the rendering pipeline stays the same to render global illumination.
• Figure 4: Comparison on different voxel resolutions, $V$. The four images for each are reconstructed shading normals from LSNIF, a visualization of voxelized geometry, a rendered image using LSNIF, and its FLIP error.
• Figure 5: Comparison of different upper bounds of the number of intersection points, $H$, and different hash-map sizes, $M$. The top-left image is rendered using LSNIF with $H = 18$ and $M = 2^{17}$ and the bottom-left image is its FLIP error. All images are rendered with 10k spp after 2,000 training steps.