Pith. sign in

REVIEW 3 major objections 6 minor 31 references

Minimizing Ray Tracing Memory Traffic through Quantized Structures and Ray Stream Tracing

T0 review · 3 major / 6 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper claims that quantizing BVH bounds and triangle vertices to 8-bit fixed-point coordinates within local power-of-two grids, combined with ray stream traversal, reduces ray tracing memory traffic to about 18% of an uncompressed…

desk verdict Solid engineering paper with an overclaimed 18% headline and an unproven hole-free guarantee; the traffic-reduction measurements are credible and worth engaging with. read the letter →

arxiv 2505.24653 v1 pith:ZPVHWMH6 submitted 2025-05-30 cs.GR cs.AR

Moritz Grauer , Johannes Hanika , Carsten Dachsbacher This is my paper
classification cs.GRcs.AR
keywords raytracingmemorybandwidthBVHcompressionfixed-pointarithmeticstream8-bitquantizationwidewatertightintersection
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper tries to reduce the memory bandwidth cost of ray tracing, which the authors identify as the main bottleneck as compute outpaces memory speed. Their approach compresses both the bounding volume hierarchy and the triangle geometry into 8-bit fixed-point numbers inside per-node local grids, and combines that with ray stream traversal, which shares traversal state across many rays. The authors report that an 8-wide compressed BVH with ray streams moves about 18% of the memory traffic of the uncompressed, single-ray 8-wide baseline, while keeping quantization artifacts mostly at edges. A central concern is watertightness: fixed-point arithmetic with full-precision intermediates is meant to avoid the rounding inconsistencies that create cracks in floating-point tracers. If the claim holds, the method gives a concrete path to ray tracing on bandwidth-constrained hardware such as mobile GPUs.

What carries the argument

The central device is the quantized BVH node and the fixed-point tests that run on it. Each node stores a 32-bit integer origin, three 8-bit power-of-two scale factors, and six 8-bit plane coordinates per child, with triangles packed at 9 bytes each. The ray-box test is the slab method with explicit handling of zero direction components in fixed point; the ray-triangle test is an edge-function test whose cross and dot products stay in full precision (a derived worst case of 64 bits plus sign) until the edge-plane decisions are made. This joint design is what lets the paper claim both small memory footprint and crack-free behavior.

What would settle it

Render an adversarial mesh containing large and tiny triangles, where leaf scale factors vary by many bits, and test every shared edge with rays aimed exactly at the edge; any missed hit on one of two adjacent triangles would contradict the watertightness claim.

Watch

Extended reading notes

Core claim

The paper claims that a ray tracer can work directly on compressed structures: each BVH node sets up a local power-of-two grid with a 32-bit integer origin and three 8-bit scale exponents, and both child bounding boxes and triangle vertices are stored as 8-bit coordinates inside that grid. Traversal and intersection are carried out in fixed-point arithmetic, with all intermediate values kept at full precision until the initial edge-plane sign tests are done, so shared edges stay watertight. In the authors' experiments, the compressed 8-wide ray stream configuration (BVH8-RS-C) uses about 18% of the memory traffic of the uncompressed single-ray version (BVH8-SR-U), with BVH4-RS-C slightly better at high triangle counts; rendered images differ mostly at edges and corners.

Load-bearing premise

The hole-free guarantee depends on the assumption that holding all intermediate fixed-point values at full precision until the edge-plane dot tests prevents any missed intersections along shared triangle edges; this is asserted with a 64-bit-plus-sign bound but without a formal proof or exhaustive edge-case testing.

Editorial extensions

If this is right

  • The BVH8-RS-C configuration consumes about 18% of the memory traffic of BVH8-SR-U across the tested scenes, with BVH4-RS-C close behind and preferred at high triangle counts.
  • Compressed node size falls from 228 to 96 bytes for 8-wide BVHs (and proportionally for 4- and 2-wide), so bandwidth, not node storage, becomes the main saving.
  • Fixed-point intersection with full-precision intermediates keeps meshes watertight by construction, avoiding the cracks that floating-point slab and edge tests can produce.
  • Quantization error shows up mainly at edges and shrinks as ray direction precision increases from 8 to 12 bits; scenes with large triangles force coarser global scale factors and more visible error.
  • Octahedral ray compression plus ray stream stacks lets a ray fit in 32 bytes, making ray list traffic a controllable fraction of total traffic in stream configurations.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The 64-bit-plus-sign worst-case bound is derived, not proven exhaustively; a targeted edge-case sweep over shared-edge configurations with extreme scale-factor ratios would be the direct test of the watertightness claim.
  • Because the traffic figures come from a CPU simulation of DRAM transfers, an actual fixed-point hardware unit might shift the balance between BVH4 and BVH8 once on-chip caches and SIMD widths are counted.
  • The paper's suggestion to expose the quantized representation inside a graphics API implies that this could become a transparent, swappable format; the same 9-byte triangle format is also a plausible on-disk compressed geometry format, not just a runtime one.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 6 minor

Summary. This paper proposes a unified memory-traffic reduction scheme for ray tracing: BVH child bounds and triangle vertices are quantized to 8-bit fixed-point coordinates inside local power-of-two grids, with the coarsest leaf scale factors broadcast to all leaves, and rays are traced directly against the compressed structures using fixed-point arithmetic. Ray stream traversal is integrated with 2-, 4-, and 8-wide BVHs to reduce traversal-stack and ray-list traffic. The authors report measured memory traffic for six scenes and twelve configurations, concluding that the 8-wide compressed ray-stream configuration reduces traffic to 18% of the uncompressed single-ray baseline while maintaining visual quality.

Significance. If the correctness guarantees held, the paper would be a useful contribution to bandwidth-limited ray tracing, especially for hardware-oriented settings where the compact node layouts and fixed-point pipeline are attractive. The systematic accounting of traffic across bounds, geometry, rays, and stacks, and the combination of established compression (Ylitie et al.) and stream traversal (Barringer and Akenine-Möller) are sensible strengths, and the measured reductions are large and directionally credible. However, the two correctness pillars—the fixed-point bit-width bound and the shared-lattice watertightness argument—are asserted rather than demonstrated, and the headline 18% figure is not representative of the per-scene results in Table 4. These issues are fixable but require additional analysis or experiments.

major comments (3)
  1. [4.3] Equation (10) derives R4=38 and Q4=26 under the assumption Rtri=16, stated as "typically" obtained for triangle vertices after adding the node origin. The paper does not establish a bound on Rtri for all inputs: node origins are stored as signed 32-bit integers, no recentering or scene normalization is mentioned, and the coordinate ranges of the test scenes are not reported. If any world-space coordinate exceeds 2^15 in magnitude, Rtri exceeds 16, the required total exceeds 65 bits, and the "64 bits plus a sign bit" budget from Section 4.3 is insufficient; the edge-plane dot products can then overflow and change sign, potentially making a ray miss both triangles sharing an edge. The sentence in Section 3 that the approach "guarantees correctness for all input meshes" is therefore not substantiated. Please prove a bound on coordinate magnitudes, add overflow detection or wider intermediate types, or test the edge-case behavior on large-coordinate scenes.
  2. [3, Hole-free meshes] The broadcast of the coarsest leaf scale factors to all leaves ensures equal quantization gaps, but equal gaps alone do not imply that a shared edge vertex maps to the same grid point in two different leaves. Watertightness requires that the local origins of all leaves lie on a common lattice, i.e., each origin is an integer multiple of the common leaf scale, or an equivalent alignment condition. The construction of child origins in Section 3 ("origins are provided by the parent node") may imply such alignment, but this is not shown; if it holds, it is a simple induction and should be stated explicitly. Without it, the "hole-free meshes" claim is unsupported.
  3. [5, Figure 8] The abstract and introduction state that the method reduces memory traffic to "only 18% of traditional approaches." In the paper this 18% figure is the BVH8-RS-C to BVH8-SR-U ratio from the accumulated diffuse-bounce experiment in Figure 8, which is a single Cornell-box test. The per-scene single-bounce data in Table 4 give ratios of 20% (Teapot), 25% (Sponza), 37% (Classroom), 21% (Corridor), 32% (Courtyard), and 27% (Viking). Reporting the single best-case scene as the headline overstates the result; please present the range and the scene condition in the abstract and conclusion.
minor comments (6)
  1. [4.1, Algorithm 1] In the zero-ray-direction branch, the else path appears to execute FixedDiv with a zero divisor when the ray is parallel to and inside the slab; the surrounding text says such cases need explicit handling, so the pseudocode should be aligned with the intended behavior.
  2. [Figure 2] The caption contains a typo ("toal" for "total"), and the text refers to a 225-byte size while the caption lists 228 bytes; please clarify whether 228 includes padding and make the wording consistent.
  3. [3] There are minor spelling errors, including "seperately" and "comrpession", that should be corrected.
  4. [4.3 and 6.1] The description of the intermediate format is inconsistent: Section 4.3 says "64 bits plus a sign bit" are required, while Section 6.1 says the implementation moves rays and triangles into a "64-bit precision" world space; please reconcile these statements.
  5. [6] The first paragraph of the conclusion contains an incomplete sentence ("an analysis of an integrated system combining.") that should be finished.
  6. [Table 4] The color coding of the best, second-best, and third-best entries is mentioned but not visible in the text; please add markers or a legend so the ranking survives grayscale printing.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the headline traffic reduction is measured, and the fixed-point precision analysis is derived from stated arithmetic rules.

full rationale

The central 18% traffic claim is an instrumented measurement comparing a defined compressed ray-stream configuration against an uncompressed single-ray baseline; it is not produced by fitting a parameter and then relabeling that fit as a prediction. The Section 4.3 precision bound follows from the paper's stated fixed-point range/fractional arithmetic rules and chosen ray parameters, and it does not assume the hole-free conclusion it is used to support. The hole-free argument is presented as a construction property (global broadcast of the coarsest leaf scale factors) rather than as an imported uniqueness theorem or self-citation. The only self-citations, [HK07] and [DHK08], appear in related-work context and are not load-bearing for the paper's measurements or derivations. Remaining concerns, such as the unstated dependence of the 64-bit bound on scene coordinates fitting Rtri=16 and the absence of exhaustive edge-case tests, are correctness risks rather than circularity.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The central claim rests on two hand-chosen numeric formats (8-bit quantization and the ray precision format) plus four assumptions: quantization containment is conservative, full-precision intermediates guarantee watertightness, global scale broadcast prevents cracks, and the simulation models hardware traffic. No new physical entities are introduced. No parameter is fitted to make the headline 18% number come out; the 18% is the measured outcome of the best configuration.

free parameters (3)
  • Quantization bit width for BVH bounds and triangle coordinates = 8 bits per coordinate
    Chosen design parameter. The headline 18% traffic number and all quality results depend on this width; no derivation shows 8 bits is optimal.
  • Ray fixed-point format (Rorg, Rdir, Qorg, Qdir) = Rorg=16, Rdir=1, Qorg=8, Qdir=10
    Section 4.3 calls this a typical scenario. The 64-bit intermediate precision bound and therefore the claimed watertightness depend on it.
  • BVH branching factor = 8 for headline result; 2 and 4 evaluated
    The paper highlights BVH8-RS-C, but Table 4 shows BVH4-RS-C is sometimes better. The choice of configuration is a hand-selected parameter of the claim.
assumptions (4)
  • standard math Conservative rounding of child bounds in Eqs. (3)-(4) guarantees child nodes remain inside parents after quantization.
    Mathematical property of floor/ceiling quantization; the paper invokes it in Section 3 for hierarchy integrity.
  • domain assumption Keeping all fixed-point products and dot products at full precision until the intersection decision guarantees no missed intersections along shared triangle edges.
    Section 4.2 states this as a guarantee, but no formal proof or exhaustive edge-case validation is provided.
  • ad hoc to paper Broadcasting the coarsest leaf scale factors to all leaf nodes prevents cracks between triangles in different leaves.
    This global scaling rule is introduced by the paper in Section 3 to enforce watertightness; it also forces coarse quantization for scenes with large triangles.
  • domain assumption The CPU-simulated byte counting of memory transactions approximates real hardware memory traffic.
    Section 5 states results are obtained by instrumenting code, and Section 6.1 admits no actual hardware was built.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Minimizing Ray Tracing Memory Traffic through Quantized Structures and Ray Stream Tracing." pith.science (2026). https://pith.science/paper/ZPVHWMH6

@misc{pith2026250524653,
  author       = {Pith},
  title        = {Pith review of: Minimizing Ray Tracing Memory Traffic through Quantized Structures and Ray Stream Tracing},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ZPVHWMH6}},
  note         = {Machine review of arXiv:2505.24653}
}
read the original abstract

Memory bandwidth constraints continue to be a significant limiting factor in ray tracing performance, particularly as scene complexity grows and computational capabilities outpace memory access speeds. This paper presents a memory-efficient ray tracing methodology that integrates compressed data structures with ray stream techniques to reduce memory traffic. The approach implements compressed BVH and triangle representations to minimize acceleration structure size in combination with ray stream tracing to reduce traversal stack memory traffic. The technique employs fixed-point arithmetic for intersection tests for prospective hardware with tailored integer operations. Despite using reduced precision, geometric holes are avoided by leveraging fixed-point arithmetic instead of encountering the floating-point rounding errors common in traditional approaches. Quantitative analysis demonstrates significant memory traffic reduction across various scene complexities and BVH configurations. The presented 8-wide BVH ray stream implementation reduces memory traffic to only 18% of traditional approaches by using 8-bit quantization for box and triangle coordinates and directly ray tracing these quantized structures. These reductions are especially beneficial for bandwidth-constrained hardware environments such as mobile devices. This integrated approach addresses both memory bandwidth limitations and numerical precision challenges inherent to modern ray tracing applications.

Figures

Figures reproduced from arXiv: 2505.24653 by the authors.

Figure 1
Figure 1. Each node spans a local grid with coordinates in 8 bit. The resolution of the grid is defined by the scale factors of each axis. In this example, this results in slightly rectangular grid cells, matching the shape of the underlying bounding box. The origin (bottom left corner) of the local grid is in integer world space. Child bounds and triangles are snapped to this local grid and thus repre￾sented with 8 bits per … view at source ↗
Figure 2
Figure 2. Memory layout of the BVHNode8 structure used in our acceleration structure. The toal size as listed is 225 bytes, which is padded to 228 bytes. of their parents. However, conservative rounding of child bounding boxes can create new overlaps between sibling nodes, potentially increasing the number of ray-box intersections during traversal. Our approach to maintaining the hierarchical scale factor con￾straint (child n… view at source ↗
Figure 4
Figure 4. The test scenes used for our evaluation. For triangle counts and BVH sizes see [PITH_FULL_IMAGE:figures/full_fig_p008_4.png] view at source ↗
Figures from the paper (4 more)
Figure 5
Figure 5. Figure 5: Comparison of ray-traced images (Teapot and Viking) using the compressed BVH and triangle representations against a floating￾point reference. Quantization of ray directions results in visible differences, less pronounced when using 10-bit or 12-bit ray directions. In t…
Figure 6
Figure 6. Figure 6: Left: Path traced without compression. Right: Path traced with compression of Rays, BVH and triangles. 10-bits were used for the precision of ray origins and directions. Quantization errors can be spotted mostly along edges. leverage findings from previous work and pre…
Figure 7
Figure 7. Figure 7: Comparison of the total memory traffic for all evaluated configurations. The two best configurations, BVH8-RS-C and BVH4-RS-C do not consistently achieve lowest memory traffic in all scenes (see [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]
Figure 8
Figure 8. Figure 8: Comparison of the accumulated total memory traffic over multiple diffuse bounces using path tracing for the cornell box ( [PITH_FULL_IMAGE:figures/full_fig_p011_8.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

31 extracted references · 25 canonical work pages

  1. [1]

    write newline

    " write newline "" before.all 'output.state := FUNCTION fin.entry.original add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 i...

  2. [2]

    \'A fra A. T. : Faster Incoherent Ray Traversal Using 8-Wide AVX Instructions . Tech. rep., Babe s -Bolyai University, 2013. URL: http://www.cs.ubbcluj.ro/ afra/publications/afra2013tr_mbvh8.pdf

    work page 2013

  3. [3]

    : Dynamic ray stream traversal

    Barringer R., Akenine-M\" o ller T. : Dynamic ray stream traversal. ACM Trans. Graph. 33, 4 (2014). https://doi.org/10.1145/2601097.2601222 doi:10.1145/2601097.2601222

    work page arXiv 2014

  4. [4]

    : Dgf: A dense, hardware-friendly geometry format for lossily compressing meshlets with arbitrary topologies

    Barczak J., Benthin C., McAllister D. : Dgf: A dense, hardware-friendly geometry format for lossily compressing meshlets with arbitrary topologies. Proc. ACM Comput. Graph. Interact. Tech. 7, 3 (2024). URL: https://doi.org/10.1145/3675383, https://doi.org/10.1145/3675383 doi:10.1145/3675383

    work page doi:10.1145/3675383 2024

  5. [5]

    : Real‐time ray tracing of micro‐poly geometry with hierarchical level of detail

    Benthin C., Peters C. : Real‐time ray tracing of micro‐poly geometry with hierarchical level of detail. Computer Graphics Forum 42 (2023). https://doi.org/10.1111/cgf.14868 doi:10.1111/cgf.14868

    work page doi:10.1111/cgf.14868 2023

  6. [6]

    : A flexible kernel for adaptive mesh refinement on gpu

    Boubekeur T., Schlick C. : A flexible kernel for adaptive mesh refinement on gpu. Computer Graphics Forum 27, 1 (2008), 102--113. https://doi.org/https://doi.org/10.1111/j.1467-8659.2007.01040.x doi:https://doi.org/10.1111/j.1467-8659.2007.01040.x

    arXiv 2008

  7. [8]

    H., Donow S., Evangelakos D., Mara M., McGuire M., Meyer Q

    Cigolle Z. H., Donow S., Evangelakos D., Mara M., McGuire M., Meyer Q. : A survey of efficient representations for independent unit vectors. Journal of Computer Graphics Techniques (JCGT) 3, 2 (2014), 1--30. URL: http://jcgt.org/published/0003/02/01/

    work page 2014

  8. [9]

    : Fast 3d line segment-triangle intersection test

    Chirkov N. : Fast 3d line segment-triangle intersection test. journal of graphics, gpu, and game tools 10, 3 (2005), 13--18

    work page 2005

Show all 31 references
  1. [10]

    : Shallow bounding volume hierarchies for fast simd ray tracing of incoherent rays

    Dammertz H., Hanika J., Keller A. : Shallow bounding volume hierarchies for fast simd ray tracing of incoherent rays. Comput. Graph. Forum 27 (2008). https://doi.org/10.1111/j.1467-8659.2008.01261.x doi:10.1111/j.1467-8659.2008.01261.x

    2008

  2. [12]

    : Efficient ray tracing kernels for modern cpu architectures

    Fuetterling V., Lojewski C., Pfreundt F.-J., Ebert A. : Efficient ray tracing kernels for modern cpu architectures. Journal of Computer Graphics Techniques (JCGT) 4, 5 (2015), 90--111. URL: http://jcgt.org/published/0004/04/05/

    2015

  3. [14]

    : Towards hardware ray tracing using fixed point arithmetic

    Hanika J., Keller A. : Towards hardware ray tracing using fixed point arithmetic. In IEEE Symposium on Interactive Ray Tracing (2007), pp. 119--128. https://doi.org/10.1109/RT.2007.4342599 doi:10.1109/RT.2007.4342599

    2007

  4. [15]

    J., Lee J., Shin Y., Lee W.-J., Ryu S

    Hwang S. J., Lee J., Shin Y., Lee W.-J., Ryu S. : A mobile ray tracing engine with hybrid number representations. In SIGGRAPH Asia Mobile Graphics and Interactive Applications (2015), Association for Computing Machinery. https://doi.org/10.1145/2818427.2818446 doi:10.1145/2818...

    2015

  5. [16]

    : Integer ray tracing

    Heinly J., Recker S., Bensema K., Porch J., Gribble C. : Integer ray tracing. Journal of Graphics, GPU, and Game Tools 14, 4 (2009), 31--56. https://doi.org/10.1080/2151237X.2009.10129289 doi:10.1080/2151237X.2009.10129289

    2009 arXiv

  6. [17]

    : Robust BVH ray traversal

    Ize T. : Robust BVH ray traversal. Journal of Computer Graphics Techniques (JCGT) 2, 2 (2013), 12--27. URL: http://jcgt.org/published/0002/02/02/

    2013

  7. [18]

    : A deep dive into nanite virtualized geometry

    Karis B., Stubbe R., Wihlidal G. : A deep dive into nanite virtualized geometry. In Advances in Real-Time Rendering in Games, Part 1 (2021)

    2021

  8. [19]

    : Vk\_nv\_cluster\_acceleration\_structure

    Kushwaha V., Werness E., Kubisch C., Schmid J., Knowles P. : Vk\_nv\_cluster\_acceleration\_structure. https://registry.khronos.org/vulkan/specs/latest/man/html/VK_NV_cluster_acceleration_structure.html, 2025

    2025

  9. [20]

    B., Vidal C

    Lenz R., Cavalcante-Neto J. B., Vidal C. A. : Optimized pattern-based adaptive mesh refinement using gpu. In 2009 XXII Brazilian Symposium on Computer Graphics and Image Processing (2009), pp. 88--95. https://doi.org/10.1109/SIBGRAPI.2009.37 doi:10.1109/SIBGRAPI.2009.37

    2009 doi

  10. [21]

    : A high-resolution compression scheme for ray tracing subdivision surfaces with displacement

    Lier A., Martinek M., Stamminger M., Selgrad K. : A high-resolution compression scheme for ray tracing subdivision surfaces with displacement. Proc. ACM Comput. Graph. Interact. Tech. 1, 2 (2018). URL: https://doi.org/10.1145/3233308, https://doi.org/10.1145/3233308 doi:10.114...

    2018 doi

  11. [22]

    Mahovsky J. A. : Ray tracing with reduced-precision bounding volume hierarchies. PhD thesis, University of Calgary, CAN, 2005. AAINR06958

    2005

  12. [23]

    : Memory-conserving bounding volume hierarchies with coherent raytracing

    Mahovsky J., Wyvill B. : Memory-conserving bounding volume hierarchies with coherent raytracing. Computer Graphics Forum 25, 2 (2006), 173--182. https://doi.org/https://doi.org/10.1111/j.1467-8659.2006.00933.x doi:https://doi.org/10.1111/j.1467-8659.2006.00933.x

    2006

  13. [24]

    P., Davis A

    Ramani K., Gribble C. P., Davis A. : Streamray: a stream filtering architecture for coherent ray tracing. SIGARCH Comput. Archit. News 37, 1 (2009), 325–336. https://doi.org/10.1145/2528521.1508282 doi:10.1145/2528521.1508282

    2009

  14. [25]

    : Multi-level ray tracing algorithm

    Reshetov A., Soupikov A., Hurley J. : Multi-level ray tracing algorithm. ACM Transactions on Graphics - TOG 24 (2005), 1176--1185. https://doi.org/10.1145/1073204.1073329 doi:10.1145/1073204.1073329

    2005

  15. [26]

    : Memory efficient ray tracing with hierarchical mesh quantization

    Segovia B., Ernst M. : Memory efficient ray tracing with hierarchical mesh quantization. In Proceedings of Graphics Interface (2010), GI '10, Canadian Information Processing Society, p. 153–160

    2010

  16. [27]

    Tsakok J. A. : Faster incoherent rays: Multi-bvh ray stream tracing. In Proceedings of the Conference on High Performance Graphics (2009), Association for Computing Machinery, p. 151–158. https://doi.org/10.1145/1572769.1572793 doi:10.1145/1572769.1572793

    2009

  17. [28]

    : Wide BVH Traversal with a Short Stack

    Vaidyanathan K., Woop S., Benthin C. : Wide BVH Traversal with a Short Stack . In High-Performance Graphics - Short Papers (2019), Steinberger M., Foley T., (Eds.), The Eurographics Association. https://doi.org/10.2312/hpg.20191190 doi:10.2312/hpg.20191190

    2019 doi

  18. [29]

    : Getting rid of packets - efficient simd single-ray traversal using multi-branching bvhs -

    Wald I., Benthin C., Boulos S. : Getting rid of packets - efficient simd single-ray traversal using multi-branching bvhs -. In IEEE Symposium on Interactive Ray Tracing (2008), pp. 49--57. https://doi.org/10.1109/RT.2008.4634620 doi:10.1109/RT.2008.4634620

    2008

  19. [30]

    K., Shirley P

    Williams A., Barrus S., Morley R. K., Shirley P. : An efficient and robust ray-box intersection algorithm. In ACM SIGGRAPH 2005 Courses (2005), SIGGRAPH '05, Association for Computing Machinery, p. 9–es. https://doi.org/10.1145/1198555.1198748 doi:10.1145/1198555.1198748

    2005

  20. [31]

    P., Boulos S., Kensler A

    Wald I., Gribble C. P., Boulos S., Kensler A. : SIMD Ray Stream Tracing- SIMD Ray Traversal with Generalized Ray Packets and On-the-fly Re-Ordering. Tech. Rep. UUSCI-2007-012, University of Utah, 2007

    2007

  21. [32]

    : Interactive rendering with coherent ray tracing

    Wald I., Slusallek P., Benthin C., Wagner M. : Interactive rendering with coherent ray tracing. Computer Graphics Forum 20, 3 (2001), 153--165. https://doi.org/https://doi.org/10.1111/1467-8659.00508 doi:https://doi.org/10.1111/1467-8659.00508

    2001

  22. [33]

    S., Ernst M

    Wald I., Woop S., Benthin C., Johnson G. S., Ernst M. : Embree: a kernel framework for efficient cpu ray tracing. ACM Trans. Graph. 33, 4 (2014). https://doi.org/10.1145/2601097.2601199 doi:10.1145/2601097.2601199

    2014

  23. [34]

    : Efficient incoherent ray traversal on gpus through compressed wide bvhs

    Ylitie H., Karras T., Laine S. : Efficient incoherent ray traversal on gpus through compressed wide bvhs. In Proceedings of High Performance Graphics (2017), Association for Computing Machinery. https://doi.org/10.1145/3105762.3105773 doi:10.1145/3105762.3105773

    2017

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.