This paper by Boubekeur (TU Berlin) and Schlick (INRIA) presents a flexible GPU kernel for adaptive on-the-fly refinement of meshes with arbitrary topology. By simply reserving a small amount of GPU memory to store a set of adaptive refinement patterns, on-the-fly refinement is performed by the GPU, without any preprocessing or additional topology data structure. The level of adaptive refinement can be controlled by specifying a per-vertex depth tag, in addition to usual position, normal, color and texture coordinates. This depth tag is used by the kernel to instanciate the correct refinement pattern. Finally, the refined patch produced for each triangle can be displaced by the vertex shader, using any kind of geometric refinement, such as Bezier patch smoothing, scalar valued displacement, procedural geometry synthesis or subdivision surfaces. This refinement engine requires no multi-pass rendering, fragment processing, or special preprocessing of the input mesh structure. It can be implemented on any GPU with vertex shading capabilities. (A Flexible Kernel for Adaptive Mesh Refinement on GPU, Tamy Boubekeur and Christophe Schlick, Computer Graphics Forum, 2008.)

This paper by Boubekeur and Schlick of the INRIA IPARLA Team describes a simple and easy-to- integrate method for "on-GPU refinement" (tesselation + displacement), adapted to any programmable GPU. This solution to the refinement problem reduces the usual CPU->GPU bottleneck and memory consumption by using instantiation over a template refinement pattern. This approach is usuful for rendering objects that are represented as a simple mesh plus a detailed displacement requiring deep tesselation (high-res maps, smooth surfaces, procedural displacement, etc). (Generic Mesh Refinement on GPU. Tamy Boubekeur and Christophe Schlick. Proceedings of Graphics Hardware 2005).

To implement dynamic LOD on the GPU, a quadtree structure is created based on a seamless geometry image atlas,and all the nodes in the quadtree are packed into the atlas textures. There are two passes in the approach. In the first pass, the LOD selection is performed in fragment shaders. The resultant buffer is taken as the input texture to the second pass by vertex texturing, and node culling and triangulation are performed in vertex shaders. The LOD algorithm can generate adaptive meshes dynamically, and can be fully implemented on the GPU. It improves the efficiency of LOD selection, and reduces computing load on CPU. (Dynamic LOD on GPU. Junfeng Ji, Enhua Wu, Sheng Li, and Xuehui Liu. Proceedings of Computer Graphics International 2005.)

This paper by Valerio Pascucci describes a simple technique to compute isosurfaces on programmable GPUs. Given the vertices of a tetrahedron a simple vertex program computes the position of the vertices, normal and connectivity of the potential portion of an isosurface contained in the tetrahedron (a marching tet approach). One main advantage of this technique is to offload the CPU of the task of computing the isosurface and more importantly to avoid storing the surface in main memory. Interestingly, one could compile a display list for a tetrahedral mesh and display different isosurfaces by changing an OpenGL parameter and always rendering the same list. The paper presents and comments in detail all the source code of the vertex program. ( Isosurface Computation Made Simple: Hardware Acceleration, Adaptive Refinement and Tetrahedral Stripping. V. Pascucci, Proceedings of VisSym 2004)