Results 1  10
of
174
Geometry images
 IN PROC. 29TH SIGGRAPH
, 2002
"... Surface geometry is often modeled with irregular triangle meshes. The process of remeshing refers to approximating such geometry using a mesh with (semi)regular connectivity, which has advantages for many graphics applications. However, current techniques for remeshing arbitrary surfaces create onl ..."
Abstract

Cited by 280 (22 self)
 Add to MetaCart
Surface geometry is often modeled with irregular triangle meshes. The process of remeshing refers to approximating such geometry using a mesh with (semi)regular connectivity, which has advantages for many graphics applications. However, current techniques for remeshing arbitrary surfaces create only semiregular meshes. The original mesh is typically decomposed into a set of disklike charts, onto which the geometry is parametrized and sampled. In this paper, we propose to remesh an arbitrary surface onto a completely regular structure we call a geometry image. It captures geometry as a simple 2D array of quantized points. Surface signals like normals and colors are stored in similar 2D arrays using the same implicit surface parametrization — texture coordinates are absent. To create a geometry image, we cut an arbitrary mesh along a network of edge paths, and parametrize the resulting single chart onto a square. Geometry images can be encoded using traditional image compression algorithms, such as waveletbased coders.
Linear Algebra Operators for GPU Implementation of Numerical Algorithms
 ACM Transactions on Graphics
, 2003
"... In this work, the emphasis is on the development of strategies to realize techniques of numerical computing on the graphics chip. In particular, the focus is on the acceleration of techniques for solving sets of algebraic equations as they occur in numerical simulation. We introduce a framework for ..."
Abstract

Cited by 249 (9 self)
 Add to MetaCart
In this work, the emphasis is on the development of strategies to realize techniques of numerical computing on the graphics chip. In particular, the focus is on the acceleration of techniques for solving sets of algebraic equations as they occur in numerical simulation. We introduce a framework for the implementation of linear algebra operators on programmable graphics processors (GPUs), thus providing the building blocks for the design of more complex numerical algorithms. In particular, we propose a stream model for arithmetic operations on vectors and matrices that exploits the intrinsic parallelism and efficient communication on modern GPUs. Besides performance gains due to improved numerical computations, graphics algorithms benefit from this model in that the transfer of computation results to the graphics processor for display is avoided. We demonstrate the effectiveness of our approach by implementing direct solvers for sparse matrices, and by applying these solvers to multidimensional finite difference equations, i.e. the 2D wave equation and the incompressible NavierStokes equations.
Sparse matrix solvers on the GPU: conjugate gradients and multigrid
 ACM Trans. Graph
, 2003
"... Permission to make digital/hard copy of part of all of this work for personal or classroom use is granted without fee provided that the copies are not made or distributed for profit or commercial advantage, the copyright notice, the title of the publication, and its date appear, and notice is given ..."
Abstract

Cited by 232 (3 self)
 Add to MetaCart
Permission to make digital/hard copy of part of all of this work for personal or classroom use is granted without fee provided that the copies are not made or distributed for profit or commercial advantage, the copyright notice, the title of the publication, and its date appear, and notice is given that copying is by permission
Cg: A system for programming graphics hardware in a clike language
 ACM Transactions on Graphics
, 2003
"... ..."
Interactive Global Illumination using Fast Ray Tracing
, 2002
"... Rasterization hardware provides interactive frame rates for rendering dynamic scenes, but lacks the ability of ray tracing required for efficient global illumination simulation. Existing ray tracing based methods yield high quality renderings but are far too slow for interactive use. We present a ..."
Abstract

Cited by 110 (19 self)
 Add to MetaCart
Rasterization hardware provides interactive frame rates for rendering dynamic scenes, but lacks the ability of ray tracing required for efficient global illumination simulation. Existing ray tracing based methods yield high quality renderings but are far too slow for interactive use. We present a new parallel global illumination algorithm that perfectly scales, has minimal preprocessing and communication overhead, applies highly efficient sampling techniques based on randomized quasiMonte Carlo integration, and benefits from a fast parallel ray tracing implementation by shooting coherent groups of rays. Thus a performance is achieved that allows for applying arbitrary changes to the scene, while simulating global illumination including shadows from area light sources, indirect illumination, specular effects, and caustics at interactive frame rates. Ceasing interaction rapidly provides high quality renderings.
The Direct3D 10 system
 ACM Trans. Graph
"... We present a system architecture for the 4 th generation of PCclass programmable graphics processing units (GPUs). The new pipeline features significant additions and changes to the prior generation pipeline including a new programmable stage capable of generating additional primitives and streaming ..."
Abstract

Cited by 91 (1 self)
 Add to MetaCart
We present a system architecture for the 4 th generation of PCclass programmable graphics processing units (GPUs). The new pipeline features significant additions and changes to the prior generation pipeline including a new programmable stage capable of generating additional primitives and streaming primitive data to memory, an expanded, common feature set for all of the programmable stages, generalizations to vertex and image memory resources, and new storage formats. We also describe structural modifications to the API, runtime, and shading language to complement the new pipeline. We motivate the design with descriptions of frequently encountered obstacles in current systems. Throughout the paper we present rationale behind prominent design choices and alternatives that were ultimately rejected, drawing on insights collected during a multiyear collaboration with application developers and hardware designers.
EigenSkin: Real Time Large Deformation Character Skinning in Hardware
 In ACM SIGGRAPH Symposium on Computer Animation
, 2002
"... We present a technique which allows subtle nonlinear quasistatic deformations of articulated characters to be compactly approximated by datadependent eigenbases which are optimized for real time rendering on commodity graphics hardware. The method extends the common SkeletalSubspace Deformation ( ..."
Abstract

Cited by 89 (4 self)
 Add to MetaCart
We present a technique which allows subtle nonlinear quasistatic deformations of articulated characters to be compactly approximated by datadependent eigenbases which are optimized for real time rendering on commodity graphics hardware. The method extends the common SkeletalSubspace Deformation (SSD) technique to provide efficient approximations of the complex deformation behaviours exhibited in simulated, measured, and artistdrawn characters. Instead of storing displacements for key poses (which may be numerous), we precompute principal components of the deformation influences for individual kinematic joints, and so construct erroroptimal eigenbases describing each joint's deformation subspace. Posedependent deformations are then expressed in terms of these reduced eigenbases, allowing precomputed coefficients of the eigenbasis to be interpolated at run time. Vertex program hardware can then efficiently render nonlinear skin deformations using a small number of eigendisplacements stored in graphics hardware. We refer to the final resulting character skinning construct as the model's EigenSkin. Animation results are presented for a very large nonlinear finite element model of a human hand rendered in real time at minimal cost to the main CPU.
PhysicallyBased Visual Simulation on Graphics Hardware
, 2002
"... In this paper, we present a method for realtime visual simulation of diverse dynamic phenomena using programmable graphics hardware. The simulations we implement use an extension of cellular automata known as the coupled map lattice (CML). CML represents the state of a dynamic system as continuous ..."
Abstract

Cited by 89 (5 self)
 Add to MetaCart
In this paper, we present a method for realtime visual simulation of diverse dynamic phenomena using programmable graphics hardware. The simulations we implement use an extension of cellular automata known as the coupled map lattice (CML). CML represents the state of a dynamic system as continuous values on a discrete lattice. In our implementation we store the lattice values in a texture, and use pixellevel programming to implement simple nextstate computations on lattice nodes and their neighbors. We apply these computations successively to produce interactive visual simulations of convection, reactiondiffusion, and boiling. We have built an interactive framework for building and experimenting with CML simulations running on graphics hardware, and have integrated them into interactive 3D graphics applications.
A RealTime Procedural Shading System for Programmable Graphics Hardware
, 2001
"... Realtime graphics hardware is becoming programmable, but this programmable hardware is complex and difficult to use given current APIs. Higherlevel abstractions would both increase programmer productivity and make programs more portable. However, it is challenging to raise the abstraction level wh ..."
Abstract

Cited by 84 (8 self)
 Add to MetaCart
Realtime graphics hardware is becoming programmable, but this programmable hardware is complex and difficult to use given current APIs. Higherlevel abstractions would both increase programmer productivity and make programs more portable. However, it is challenging to raise the abstraction level while still providing high performance. We have developed a realtime procedural shading language system designed to achieve this goal. Our system is organized around multiple computation frequencies. For example, computations may be associated with vertices or with fragments/pixels. Our system’s shading language provides a unified interface that allows a single procedure to include operations from more than one computation frequency. Internally, our system virtualizes limited hardware resources to allow for arbitrarilycomplex computations. We map operations to graphics hardware if possible, or to the host CPU as a last resort. This mapping is performed by compiler backend modules associated with each computation frequency. Our system can map vertex operations to either programmable vertex hardware or to the host CPU, and can map fragment operations to either programmable fragment hardware or to multipass OpenGL. By carefully designing all the components of the system, we are able to generate highlyoptimized code. We demonstrate our system running in realtime on a variety of hardware.
Accelerator: using data parallelism to program GPUs for generalpurpose uses
 in Proceedings of the 12th international conference on Architectural
, 2006
"... GPUs are difficult to program for generalpurpose uses. Programmers can either learn graphics APIs and convert their applications to use graphics pipeline operations or they can use stream programming abstractions of GPUs. We describe Accelerator, a system that uses data parallelism to program GPUs ..."
Abstract

Cited by 81 (0 self)
 Add to MetaCart
GPUs are difficult to program for generalpurpose uses. Programmers can either learn graphics APIs and convert their applications to use graphics pipeline operations or they can use stream programming abstractions of GPUs. We describe Accelerator, a system that uses data parallelism to program GPUs for generalpurpose uses instead. Programmers use a conventional imperative programming language and a library that provides only highlevel dataparallel operations. No aspects of GPUs are exposed to programmers. The library implementation compiles the dataparallel operations on the fly to optimized GPU pixel shader code and API calls. We describe the compilation techniques used to do this. We evaluate the effectiveness of using data parallelism to program GPUs by providing results for a set of computeintensive benchmarks. We compare the performance of Accelerator versions of the benchmarks against handwritten pixel shaders. The speeds of the Accelerator versions are typically within 50 % of the speeds of handwritten pixel shader code. Some benchmarks significantly outperform C versions on a CPU: they are up to 18 times faster than C code running on a CPU.