Triangulation of uniform particle systems: its application to the implicit surface texturing

Particle systems, as originally presented by Witkin and Heckbert [32], offer an elegant solution to sample implicit surfaces of arbitrary genus, while providing an extremely regular distribution of samples over the surface. In this paper, we present an ef cient technique that uses particle systems to rapidly generate a triangular mesh over an implicit surface, where each triangle is almost equilateral. The major advantage of such a triangulation is that it minimizes the deformations between the mesh and the underlying implicit surface. We exploit this property by using few triangular texture samples mapped in a non-periodic fashion as presented by Neyret and Cani [16]. The result is a pattern-based texturing method that maps homogeneous non-periodic textures to arbitrary implicit surfaces, with almost no deformation

Relief mapping on cubic cell complexes

In this paper we present an algorithm for parameterizing arbitrary surfaces onto a quadrilateral domain defined by a collection of cubic cells. The parameterization inside each cell is implicit and thus requires storing no texture coordinates. Based upon this parameterization, we propose a unified representation of geometric and appearance information of complex models. The representation consists of a set of cubic cells (providing a coarse representation of the object) together with a collection of distance maps (encoding fine geometric detail inside each cell). Our new representation has similar uses than geometry images, but it requires storing a single distance value per texel instead of full vertex coordinates. When combined with color and normal maps, our representation can be used to render an approximation of the model through an output-sensitive relief mapping algorithm, thus being specially amenable for GPU raytracing.Postprint (author’s final draft

An Octree-based proxy for collision detection in large-scale particle systems

International audienceParticle systems are important building block for simulating vivid and detail-rich effects in virtual world. One of the most difficult aspects of particle systems has been detecting collisions between particlesand mesh surface. Due to the huge computation, a variety of proxy-based approaches have been proposed recently to perform visually correct simulation. However, all either limit the complexity of the scene, fail toguarantee non-penetration, or are too slow for real-time use with many particles. In this paper, we propose anew octree-based proxy for colliding particles with meshes on the GPU. Our approach works by subdividingthe scene mesh with an octree in which each leaf node associates with a representative normal correspondingto the normals of the triangles that intersect the node. We present a view-visible method, which is suitable forboth closed and non-closed models, to label the empty leaf nodes adjacent to nonempty ones with appropriateback/front property, allowing particles to collide with both sides of the scene mesh. We show how collisionscan be performed robustly on this proxy structure in place of the original mesh, and describe an extension thatallows for fast traversal of the octree structure on the GPU. The experiments show that the proposed methodis fast enough for real-time performance with millions of particles interacting with complex scenes

Hierarchical N-Body problem on graphics processor unit

Galactic simulation is an important cosmological computation, and represents a classical N-body problem suitable for implementation on vector processors. Barnes-Hut algorithm is a hierarchical N-Body method used to simulate such galactic evolution systems. Stream processing architectures expose data locality and concurrency available in multimedia applications. On the other hand, there are numerous compute-intensive scientific or engineering applications that can potentially benefit from such computational and communication models. These applications are traditionally implemented on vector processors. Stream architecture based graphics processor units (GPUs) present a novel computational alternative for efficiently implementing such high-performance applications. Rendering on a stream architecture sustains high performance, while user-programmable modules allow implementing complex algorithms efficiently. GPUs have evolved over the years, from being fixed-function pipelines to user programmable processors. In this thesis, we focus on the implementation of Barnes-Hut algorithm on typical current-generation programmable GPUs. We exploit computation and communication requirements present in Barnes-Hut algorithm to expose their suitability for user-programmable GPUs. Our implementation of the Barnes-Hut algorithm is formulated as a fragment shader targeting the selected GPU. We discuss implementation details, design issues, results, and challenges encountered in programming the fragment shader

Interactive Out-Of-Core Texturing Using Point-Sampled Textures

International audienceThe visualization of huge 3D objects becomes available on common workstations thanks to highly optimized data-structures and out-of-core frameworks for rendering. However, the editing, and in particular, the texturing of such objects is still a challenging task, since usual methods for optimized rendering are not easily amenable to interactive modification. In this paper, we introduce the idea of point-sampled textures, and show how to interactively texture such a huge model at various scales, without any parameterization. An adaptive in-core point-based approximated geometry is first created by employing an efficient out-of-core point-sampling algorithm. This simplified geometry is then used for an interactive and multi-scale point-based texturing. Finally, a feature-preserving kernel is used to convert the point-based model into a global 3D texture which can be applied back on the initial huge geometry. Our technique thus provides a flexible tool to generate, edit and apply size-independent textures to a wide range of huge 3D objects thanks to point-based methods

Interactive Out-Of-Core Texturing

International audienceInteractive rendering of huge objects becomes available on common workstations thanks to highly optimized data-structures and out-of-core frameworks for rendering. However, interactive editing, and in particular interactive texturing of such objects, is still a challenging task, since the dynamic information added during this editing step would break any highly-optimized data-structures, such as GPU vertex buffers or specific out-of-core representations of huge objects. We propose Point-Sampled Textures (PST) for interactive texturing of large models at various scales without requiring 2D parameterization (complex and expensive for large models). This framework allows the user to interactively set any appearance property of the original object, from per-sample color to complex BRDFs

Hybrid Sample-based Surface Rendering

The performance of rasterization-based rendering on current GPUs strongly depends on the abilities to avoid overdraw and to prevent rendering triangles smaller than the pixel size. Otherwise, the rates at which highresolution polygon models can be displayed are affected significantly. Instead of trying to build these abilities into the rasterization-based rendering pipeline, we propose an alternative rendering pipeline implementation that uses rasterization and ray-casting in every frame simultaneously to determine eye-ray intersections. To make ray-casting competitive with rasterization, we introduce a memory-efficient sample-based data structure which gives rise to an efficient ray traversal procedure. In combination with a regular model subdivision, the most optimal rendering technique can be selected at run-time for each part. For very large triangle meshes our method can outperform pure rasterization and requires a considerably smaller memory budget on the GPU. Since the proposed data structure can be constructed from any renderable surface representation, it can also be used to efficiently render isosurfaces in scalar volume fields. The compactness of the data structure allows rendering from GPU memory when alternative techniques already require exhaustive paging

On sparse voxel DAGs and memory efficient compression of surface attributes for real-time scenarios

The general shape of a 3D object can expeditiously be represented as, e.g., triangles or voxels, while smaller-scale features usually are parameterized over the surface of the object. Such features include, but are not limited to, color details, small-scale surface-normal variations, or even view-dependent properties required for the light-surface interactions. This thesis is a collection of four papers that focus on new ways to compress and efficiently utilize surface data in 3D for real-time usage.In Paper IA and IB, we extend upon the concept of sparse voxel DAGs, a real-time compression format of a voxel-grid, to allow an attribute mapping with a negligible impact on the size. The main contribution, however, is a novel real-time compression format of the mapped colors over such sparse voxel surfaces.Paper II aims to utilize the results of the previous papers to achieve uv-free texturing of surfaces, such as triangle meshes, with optimized run-time minification as well as magnification filtering.Paper III extends upon previous compact representations of view dependent radiance using spherical gaussians (SG). By using a convolutional neural network, we are able to compress the light-field by finding SGs with free directions, amplitudes and sharpnesses, whereas previous methods were limited to only free amplitudes in similar scenarios