Xavier Décoret

Conservative volumetric visibility with occluder fusion

Visibility determination is a key requirement in a wide range of graphics algorithms. This paper introduces a new approach to the computation of volume visibility, the detection of occluded portions of space as seen from a given region. The method is conservative and classifies regions as occluded only when they are guaranteed to be invisible. It operates on a discrete representation of space and uses the opaque interior of objects as occluders. This choice of occluders facilitates their extension into adjacent opaque regions of space, in essence maximizing their size and impact. Our method efficiently detects and represents the regions of space hidden by such occluders. It is the first one to use the property that occluders can also be extended into empty space provided this space is itself occluded from the viewing volume. This proves extremely effective for computing the occlusion by a set of occluders, effectively realizing occluder fusion. An auxiliary data structure represents occlusion in the scene and can then be queried to answer volume visibility questions. We demonstrate the applicability to visibility preprocessing for real-time walkthroughs and to shadow-ray acceleration for extended light sources in ray tracing, with significant acceleration in both cases.

Fast scene voxelization and applications

This paper presents a novel approach that uses graphics hardware to dynamically calculate a voxel-based representation of a scene. The voxelization is obtained on run-time in the order of milliseconds, even for complex and dynamic scenes containing more than 1,000,000 polygons. The voxelization is created and stored on the GPU avoiding unnecessary data transfer. The approach can handle both regular grids and locally optimized grids that better fit the scene geometry. The paper demonstrates applications to shadow calculation, refraction simultation and shadow volume culling/clamping.

Multi‐layered impostors for accelerated rendering

This paper describes the successful combination of pre‐generated and dynamically updated image‐based representations to accelerate the visualization of complex virtual environments. We introduce a new type of impostor, which has the desirable property of limiting de‐occlusion errors to a user‐specified amount. This impostor, composed of multiple layers of textured meshes, replaces the distant geometry and is much faster to draw. It captures the relevant depth complexity in the model without resorting to a complete sampling of the scene. We show that layers can be dynamically updated during visualization. This guarantees bounded scene complexity in each frame and also exploits temporal coherence to improve image quality when possible. We demonstrate the strengths of this approach in the context of city walkthroughs.

Dynamic label placement for improved interactive exploration

This work presents a novel approach for dynamically rendering annotations attached to a 3D scene. We formulate the problem as a general optimization under constraints, accounting for certain desirable properties. To approximately solve the NP-hard optimization problem in real-time, we present a particular heuristic that greedily places labels while maintaining constraints. Typical greedy label placement algorithms do not pay particular attention to the order of placement and, as a result, suffer from the fundamental limitation that successive labels get progressively more difficult to place. We use algorithmic and mathematical tools that compensate for the drawback of typical greedy approaches. In addition, they are well suited for GPU implementation, because they are completely image based. As a result, we can place tens of labels in real-time, as demonstrated in this paper.

N-Buffers for efficient depth map query

We introduce the N-buffer as a tool for multiresolution depth map representation. This neighborhood buffer encodes the value and position of local depth extrema at different scales in an image cube, in contrast to the image pyramid. The resulting increase in storage space is largely compensated by the following benefits: objects of any size can be culled in constant time against an occlusion map using four depth lookups; visibility-like queries can be performed in vertex and fragment programs; N-buffers can be computed very efficiently with graphics hardware. We present three applications of this datastructure, and in particular a novel approach for shadow volume acceleration.

Visibility Sampling on GPU and Applications

In this paper, we show how recent GPUs can be used to very efficiently and conveniently sample the visibility between two surfaces, given a set of occluding triangles. We use bitwise arithmetics to evaluate, encode, and combine the samples blocked by each triangle. In particular, the number of operations is almost independent of the number of samples. Our method requires no CPU/GPU transfers, is fully implemented as geometric, vertex and fragment shaders, and thus does not impose to modify the way the geometry is sent to the graphics card. We finally present applications to soft shadows, and visibility analysis for level design.

Realistic water volumes in real-time

We present a real-time technique to render realistic water volumes. Water volumes are represented as the space enclosed between a ground heightfield and an animable water surface heightfield. This representation allows the application of recent GPU-based heightfield rendering algorithms. Our method is a simplified raytracing approach which correctly handles reflections and refractions and allows us to render complex effects such as light absorption, refracted shadows and refracted caustics. It runs at high framerates by exploiting the power of the latest graphic cards, and could be used in real-time applications like video games, or interactive simulation.

Plausible Image Based Soft Shadows Using Occlusion Textures

This paper presents a novel image-based approach to render plausible soft shadows for complex dynamic scenes with rectangular light sources. The algorithms performance is mostly independent of the scene complexity and the sources size. Occluders and receivers do not need to be separated and no knowledge about the scene representation is required, making the method easy to use. The main idea is to approximate the occlusion in the scene with pre-filtered occlusion textures. The visibility of the light source at a point in space is estimated by accumulating the occlusion caused by each texture, using a novel formula based on probabilities

Occlusion Textures for Plausible Soft Shadows

This paper presents a new approach to compute plausible soft shadows for complex dynamic scenes and rectangular light sources. We estimate the occlusion at each point of the scene using prefiltered occlusion textures, which dynamically approximate the scene geometry. The algorithm is fast and its performance independent of the lights size. Being image‐based, it is mostly independent of the scene complexity and type. No a priori information is needed, and there is no caster/receiver separation. This makes the method appealing and easy to use.

On Exact Error Bounds for View‐Dependent Simplification

In this article we present an analytical closed‐form expression to ensure exact error bounds for view‐dependent simplification which is of importance for several algorithms. The present work contains proofs and solutions for the general 2D case and particular 3D cases.