Papers for

graphics engine developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Payne-hanek range reduction method made faster and more accurate

A performance enhancement of the Payne-Hanek range reduction algorithm

Abstract: Range reduction plays a crucial role in the accuracy and performance of evaluating trigonometric functions, and is often the primary bottleneck for large floating-point inputs. While fast algorithms such as Cody--Waite work efficiently over narrow intervals, the Payne--Hanek algorithm remains the standard technique for accurate reduction across large floating-point inputs. However, existing implementations of Payne--Hanek suffer from high latency due to heavy branching, conversion overheads, and the use of multi-word integer arithmetic, which hinders SIMD vectorization. In this paper, we analyze and present a branch-free variation of the Payne--Hanek algorithm using only floating-point arithmetic. Our method operates directly over large double-precision inputs ($|x| \ge 2^{16}$) and is well suited to hardware with FMA instructions. We formulate the precision constraints in terms of a truncation error budget, construct a compact lookup table indexed by the input exponent, and prove that the reduced argument is accurate to within one ulp for every input. The same routine can serve both as the complete range reduction of a single-stage implementation and as the fast path of a correctly rounded one, and it improves both latency and throughput over existing implementations. The algorithm is currently implemented in the LLVM libc project.

Mon 28 SeptMathematical Software
The gist
When computers calculate sine or cosine for very large numbers, they first simplify the number through a process called range reduction. This step can be slow and complicated, especially for big numbers. The authors improved an existing method called Payne-Hanek by removing slow parts like branching and complex integer math, relying only on fast floating-point math instead. Their new approach works efficiently on large inputs and keeps answers very accurate, making trigonometric calculations faster.
Open → 2609.35015v1

Omnidirectional image compression boosts virtual reality rendering speed and quality

Rate-Distortion Adaptive Primitive Selection for Omnidirectional Gaussian Splatting

Abstract: Learned image codecs (LICs) achieve high reconstruction quality, but their decoding speed is often insufficient for immersive virtual reality (VR). Gaussian splatting (GS) codecs render much faster, yet still lag in reconstruction quality and typically decide primitive allocation without considering the coding cost of each primitive. We introduce OIC-GS, an omnidirectional GS codec with a new hierarchical HEALPix primitive grid representation. Gaussian primitives are anchored at predefined spherical locations, eliminating explicit coordinate coding. Finer levels refine their coarser ancestors, naturally supporting coarse-to-fine reconstruction and layered transmission. The predefined grid also enables efficient viewport decoding by selecting only view-relevant primitives. We further introduce a lightweight entropy model for quantized primitives and optimize the codec under a spherical rate-distortion objective. Primitives with insufficient rate-distortion benefit are automatically removed when their quantized opacity becomes zero, allowing OIC-GS to adapt both primitive density and level of detail without a fixed primitive budget. A single bitstream supports full-sphere, viewport-dependent, and progressive decoding. The first viewport reaches final quality after decoding only 52% of the bitstream, and is then rendered at 1,270 FPS. On a 100-image omnidirectional benchmark, OIC-GS outperforms all evaluated GS codecs, reducing WS-PSNR BD-rate by 49.6% over GaussianImage++ and 68.6% over SGI, which uses a learned entropy model.

Mon 28 SeptComputer Vision and Pattern Recognition
The gist
Virtual reality needs very fast and good-quality images so users feel immersed, but current methods often force a trade-off between speed and image quality. The authors created a new way to represent these images using Gaussian dots arranged on a special sphere grid, which makes encoding more efficient and lets the system focus on the part of the image the user is looking at. Their method adapts by removing less useful dots automatically to keep the data size small, all while supporting smooth and fast loading of images. This approach shows better image quality and much faster rendering compared to previous methods in tests.
Open → 2609.34367v1

ControlGS improves extended reality image quality by adapting rendering

ControlGS: Conditioning Neural Gaussians for Downstream-Processing-Aware XR Rendering

Abstract: Extended Reality (XR) users do not directly perceive the output of a rendering engine. Instead, rendered images pass through a post-processing pipeline and the physical display-optics path before reaching the eye. Critically, the exact downstream processing can vary significantly at run time, influenced by, for instance, camera pose and display power budget. Traditional 3DGS methods either implicitly assume that this downstream pipeline preserves image quality or cannot adapt to downstream processing changes. To bridge this gap, we present ControlGS, an XR Gaussian rendering pipeline that optimizes end-to-end visual quality. ControlGS models and integrates the entire downstream processing, between the rendering output and the human eye, into the optimization objective. To adapt to downstream processing at run time, ControlGS dynamically generates Gaussian primitives conditioned upon the downstream processing parameters. Experiments show that ControlGS consistently improves end-to-end post-optics XR quality across different neural Gaussian backbones and datasets, with minimal overhead. Code is available at https://horizon-lab.org/controlgs/.

Fri 25 SeptComputer Vision and Pattern RecognitionGraphics
The gist
Images created for virtual or augmented reality go through many changes before you actually see them, like adjustments from your device and display. The way these changes happen can vary a lot depending on things like where you are looking or how much power your device uses. The authors created ControlGS, a method that adjusts the image-making process by taking these changes into account ahead of time, making the final images look better to the user. Their experiments show that ControlGS works well across various setups with little extra cost.
Open → 2609.32038v1