Animation on the web: a survey <s> Rendering Animation <s> This paper presents a new algorithm for the progressive compression of manifold polygon meshes. The input surface is decimated by several traversals that generate successive levels of detail through a specific patch decimation operator which combines vertex removal and local remeshing. The mesh connectivity is encoded by two lists of Boolean error predictions based on the mesh geometry: one for the inserted edges and the other for the faces with a removed center vertex. The mesh geometry is encoded with a barycentric error prediction of the removed vertex coordinates and a local curvature prediction. We also include two methods that improve the rate-distortion performance: a wavelet formulation with a lifting scheme and an adaptive quantization technique. Experimental results demonstrate the effectiveness of our approach in terms of compression rates and rate-distortion performance. <s> BIB001 </s> Animation on the web: a survey <s> Rendering Animation <s> We discuss our experience in creating scalable systems for distributing and rendering gigantic 3D surfaces on web environments and common handheld devices. Our methods are based on compressed streamable coarse-grained multiresolution structures. By combining CPU and GPU compression technology with our multiresolution data representation, we are able to incrementally transfer, locally store and render with unprecedented performance extremely detailed 3D mesh models on WebGL-enabled browsers, as well as on hardware-constrained mobile devices. <s> BIB002 </s> Animation on the web: a survey <s> Rendering Animation <s> We present an adaptive bandwidth-optimized approach for progressive image transmission to allow instant textured rendering in web-based 3D applications. Applications utilizing a lot of image data require an adaptive technology to build responsive user interfaces. This applies especially for the use in mobile networks. While several approaches provide a progressive geometry streaming, they do not focus on a fast and simple texture streaming for 3D web applications. However, standard 2D image transmission technologies are usually inappropriate within a 3D context. In 2D, image size as well as resolution are often set during the authoring phase, whereas in 3D applications size and displayed resolution of textured 3D objects depend on the virtual camera. An adaptive texture transmission mechanism has to consider this as part of its control function. Our approach thus combines progressive texture streaming with an adaptive number of refinement levels without any pixel retransmission. It enables a fast user feedback and reduces the transmitted data to a minimum without loss of visual quality. Moreover, our GPUII approach (GPU-based Image Interlacing) allows an easy integration into existing applications while also reducing the CPU load. <s> BIB003 </s> Animation on the web: a survey <s> Rendering Animation <s> The visualization of massive 3D models is an intensively examined field of research. Due to their rapidly growing complexity of such models, visualisation them in real-time will never be possible through a higher speed of rasterization alone. Instead, a practical solution has to reduce the amount of data to be processed, using a fast visibility determination. In recent years, the combination of Javascript and WebGL raised attention for the possibility of rendering hardware-accelerated 3D graphics directly in the browser. However, when compared to desktop applications, they are still fighting with their disadvantages of a generally slower execution speed, or a downgraded set of functionality. We demonstrate the integration of spatial data structures, computed on the client side, using latest technology trends to mitigate the shortcomings of the 3D Web environment. We employ comparably small bounding volume hierarchies to accelerate our visibility determination, as well as to enable specific culling techniques. This allows for an interactive visualization of such massive 3D data sets. Our in-depth analysis of different data structures and environments shows which combination of data structure and visibility determination techniques are currently the best fit for the Web. <s> BIB004
Animation in the WebGL context can employ many different concepts such as: 1) programmatically updating properties of the visual object each time through the run loop; 2) Using key frame animation, intermediate frames are generated via interpolation; 3) Using morph targets to deform geometry by blending among a set of distinct shapes. 4) Using skinning to deform geometry based on the underlying skeleton. And 5) Implementation of some/all of the above using GPU based methods, where the deformation of vertices and fragment values are computed on the GPU in the shaders. For rendering progressive animation in WebGL, the animation should be reconstructed first after the minimal transmission is done, a coarse representation is rendered on the screen. Then as more data is downloaded, and more information becomes accessible, the compressed animation is refined. Mostly these refinement methods can be classified into 1) Connectivity updating -which changes the feature shapes of an animation, and 2) Geometry updating -which changes the complexity of the motion. In real-time rendering, 2D images are used to store textures that are applied and interpolated during the shading process to flat surfaces in 3D space. Similarly, Normal maps and displacement maps give the illusion of more structured details. For 3D data transmission, textures can be used by using the quantization threshold BIB002 BIB001  ] which represents a factor by which to quantize the geometry, which can be transmitted separately in a JSON file. Once the client side application knows of the factor, the decompression of the PNG takes place to retrieve the chunk of relevant data into a WebGL texture. Behr et al. present a detailed explanation on various techniques involving 2D images for data transmission.  Using VBO in WebGL: Declarative languages provide types for data entries in the structure which can be directly mapped to an OpenGL Vertex Buffer Objects (VBOs). These set of vertex attributes can then be packed into Vertex Array Objects (VAOs) (available in WebGL 1.0 through OES_vertex_array_object extension) and called in a single API call to reduce the state change overhead. In comparison, when data is transmitted in binary or any other domain specific manner, different subsets of 3D data is sent to the shader to be rendered. To draw such highly frequent changing data in the VBOs, they need to be constantly created and/or updated and the data needs to be passed from main memory to client-side index array which proves to be a huge performance bottleneck for WebGL. One approach to reduce the vertex buffer switches, is to have all the mesh data in a single image (either a texture atlas or map) and create one VBO on the JavaScript layer and bind it with this single image geometry and have all the other data directly uploaded as textures in the GPU. This is similar to the technique used in  ,  , BIB003 and BIB004 ]. This allows the GPU to store more mesh data, and calculate all the decoding and vertex coordination on the fly.