- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper introduces DSF (Differentiable Shadow Fields), which is a dense grid that is optimized to represent visibility queries for ray-geometry intersections. The grid can be queried efficiently, and the authors show that it improves performance on inverse rendering baselines.
Critical strengths
The concept of fitting a visibility field to account for the specific ray-queries is novel, and the proposed framework integrates as a general module with other IR frameworks.
Critical weaknesses
Major:
-
Each DSF must be fit per-scene, which is very expensive (several minutes, as reported in Tab 1). In addition, DSF requires geometry and fits a dense voxel grid - it is therefore unclear how it will scale to large scenes (a lot of compute / storage would be wasted in free space). The current framework uses a resolution of 1024^3, which in float32 already is 4GB (as per Tab.30). The implications here are not sufficiently discussed, especially since most results are shown on small, single- or few-object scenes. More realistic applications/scenes like Crytek Sponza or Bistro or the ZipNeRF scenes with more clutter, and an analysis of grid resolution and potential artifacts, would have made a more compelling paper.
-
Also, DSF wants to integrate with existing IR frameworks, but the end-to-end-improvement is not sufficiently demonstrated. Fig.9 and 10 show only minor visual improvements, sometimes DSF even introduces small artifacts (on mustard / plate bottom silhouette, Fig.9), while increasing the rendering time of the methods (e.g., IRGS and LumiGauss, A.4.2). Similarly, DSF-Adam achieves the same success rate as Density in Tab.13, and while it admittedly reduces the median error by 2x, the total time is almost 4x slower.
-
Regarding the gradients: differentiability is one of the main selling points of the paper, it is even included in the paper title. Yet, at no point are the actual gradients visualized or numerically validated. The CMA-vs-Adam comparison does not isolate the practical benefit of the proposed endpoint gradients either: CMA is run with more objective evaluations (1,200 vs. 300 Adam steps) and higher time budget (roughly 2.9x longer). This shows that the DSF objective is useful, but not that the gradients are particularly useful. To show the latter, I would want to see optimization-success-vs-walltime convergence curves. Also, CMA-ES is a gradient-free optimizer, including a BVH+CMA version of this comparison would show how much DSF contributes to the optimization success.
-
Another issue is that the paper mixes claims from different versions of DSF: the high-throughput results mentioned as headline claims of the paper are achieved with the texture-version, whereas the differentiability, one of the main motivations, is achieved with the significantly slower differentiable version. This conflates things and makes the paper harder to parse, since the experiments do not establish a single implementation that simultaneously provides the advertised throughput and differentiability.
Minor:
- The teaser figure does not show the GT (exact intersection / GPU-BVH), which makes it hard to estimate the absolute quality of the shown results.
- Regarding the GPU-BVH baseline: it is implemented as a software CUDA closest-hit implementation, not hardware-accelerated any-hit shadow tracing (A.2.1), so conclusions w.r.t. actual production-grade GPU baselines are limited. For visibility, I would image any-hit to be sufficient, since the ray can only be blocked once anyway, so closest-hit is unnecessarily restrictive for this baseline.
Writing:
The writing is subpar, and hard to understand. First of all, the introduction does not clearly define the problem, and makes the reader work unnecessarily hard. The math in the introduction (L.71) arrives before the problem, keep the concept abstract here. The concept of “finite segment" (line connecting hitpoint and light) should be explained earlier, for readers unfamiliar with the field. In general, the writing uses many redundant and bloated phrases, which makes the content hard to understand and unfortunately often sound very AI-generated. Examples:
L.68–69: “We therefore calibrate the field directly through the final visibility query, allowing it to adapt to the evaluator rather than preserving exact metric distance.” Similarly, L. 88–90: “DSF jointly calibrates a shared spatial field and its endpoint-conditioned query against ray-traced visibility, optimizing the representation for finite-segment visibility rather than metric distance reconstruction.”
Why not simply say the much clearer “we optimize grid values and query parameters against ray-traced visibility, and allow them to depart from geometric distances”?
Related work: The following two references are relevant and should be cited:
- Neural Bounding, Liu et al., SIGGRAPH 2024. Relevance: learn a conservative bounding network around shapes to avoid expensive ray-geometry queries.
- Sphere Carving: Bounding Volumes for Signed Distance Fields, Schott et al., SIGGRAPH 2025. Relevance: construct bounding volume for signed distance fields via SDF queries.
Questions for authors
- In the video, why are there artifacts in the shadows? E.g., around the 0:13 - 0:15 minute mark, and also very visible around 1:25 - 1:40. Also, why is the discretization in the shadow so visible (around 1:07min) on the lower right hand side of the silhouette? I thought the calibration had the job of removing such artifacts.
- How does the method scale to bigger scenes, eg Crytek Sponza or Bistro? What are the limitations in terms of memory? Is the RTX6000Pro necessary, what are the peak VRAM requirements? Adding roughly 1B params (1024^3 dense grid) to inverse rendering methods feels expensive.
- I get that we’re using a dense grid for throughput efficiency, but comparing to a neural field is an experiment/ablation that’s a key missing ingredient. Using a neural field would allow better space management (almost no capacity wasted on empty regions), finer query granularity, compression/compactness, etc, and would help establish whether the dense grid is really necessary. Note that this is different from the Hash-MLP baseline, which directly predicts visibility (like NIF).