Pixel Shader Research Articles

Visualization method of seismic profile data based on adaptive mosaic

Three-dimensional visualization of seismic profile data can better display seismic data information than traditional profile display, but there are mosaic errors in grid mosaic. In order to solve the problem of false mosaics, an adaptive mosaic method is proposed, first in the pixel shader Calculate the sample point most relevant to the current sample point on the next track, and then map its relative offset in the time direction to the tilt mode and render it to the texture. When filling the vertex index, fully consider the tilt of the adjacent sample points on the same track In order to realize the adaptive tessellation of vertices; finally, the effectiveness of the proposed method is verified through experiments.

Design of Programmable Pixel Shader Computing Unit

With increased focus on improved Graphics, the gaming industries for computer and mobile devices requires more complex graphical algorithms, which in need of better computational resources. In general graphical computation requires more computational units, which will be major constraint in mobile devices as it demand for more power. In order to develop such efficient computational units, one need to focus on the Graphical pipeline to have better visual effects. In this paper design of programmable Pixel shader computing unit is discussed. In GPU, the Pixel shaders are used to process and manipulate the each pixel. Also the Pixel Shaders are used to provide final coloring to the processed data. Here the programmable Pixel shader computing unit design is discussed, which help the programmer to add his own code for achieving better visual effects or results. The possible Instructions of Pixel shader are designed using Verilog HDL. The SIMD(Single Instruction Multiple Data) concept is adopted for the designing of each instruction.

Procedural phasor noise

Procedural pattern synthesis is a fundamental tool of Computer Graphics, ubiquitous in games and special effects. By calling a single procedure in every pixel - or voxel - large quantities of details are generated at low cost, enhancing textures, producing complex structures within and along surfaces. Such procedures are typically implemented as pixel shaders. We propose a novel procedural pattern synthesis technique that exhibits desirable properties for modeling highly contrasted patterns, that are especially well suited to produce surface and microstructure details. In particular, our synthesizer affords for a precise control over the profile, orientation and distribution of the produced stochastic patterns, while allowing to grade all these parameters spatially. Our technique defines a stochastic smooth phase field - a phasor noise - that is then fed into a periodic function (e.g. a sine wave), producing an oscillating field with prescribed main frequencies and preserved contrast oscillations. In addition, the profile of each oscillation is directly controllable (e.g. sine wave, sawtooth, rectangular or any 1D profile). Our technique builds upon a reformulation of Gabor noise in terms of a phasor field that affords for a clear separation between local intensity and phase. Applications range from texturing to modeling surface displacements, as well as multi-material microstructures in the context of additive manufacturing.

ПРИМЕНЕНИЕ АППАРАТНОГО РАСТЕРИЗАТОРА В ЗАДАЧАХ МОДЕЛИРОВАНИЯ ГИДРОДИНАМИЧЕСКИХ ПОЛЕЙ В ТРАЛОВЫХ СИСТЕМАХ ПРИ ГИДРОЛОКАЦИИ

The paper proposes a fast method for rebuilding a three-dimensional computational grid for problems of modeling hydrodynamic fields in trawling systems during sound ranging at runtime using a hardware rasterizer of a graphics processor. When the position of a streamlined object changes, it is necessary to periodically update the boundary conditions at the grid nodes near its surface, which, in case of three-dimensional statement, is a laborious task. The suggested method allows a multiple acceleration of the grid update process compared to software implementations. The essence of the method lies in implementation of the pixel shader of the graphics pipeline during rendering, namely, the possibility of outputting the grid nodes into a 3D buffer taking into account information about Z-coordinate of a pixel and a velocity vector of a surface point. The method has been approved using a computer program developed on its basis. The method can be applied both in calculating the influence of hydrodynamic fields on propagation of acoustic waves, and in other applications.

The unexpected beauty of modular bivariate quadratic functions

abstractModular bivariate quadratic functions (quadratic functions of two variables over the integers modulo q) can be used to procedurally generate grey-scale and colour textures that resemble ornamentation, skin, scales, feathers, textiles, and optical illusions. The latter appear to include distorted perspective, false 3D, and Fechner colours, the combination of which is disturbing to some viewers. This technique is particularly suited to parallel execution using a pixel shader since each pixel is computed independently by performing a small number of arithmetic operations on the pixel coordinates. A prototype browser-based procedural texture generator with an interface suitable for use by non-mathematicians such as designers and artists is described.

GPU ray casting method for visualizing 3D pipelines in a virtual globe

ABSTRACTPipelines are an important part of urban infrastructure development. As part of a virtual globe (VG), the high-efficiency and high-quality visualization of 3D large-scale and high-density urban pipelines is of great importance. This paper proposes a GPU-based pipeline ray casting method for the visualization of urban-scale pipelines in the framework of a VG. The method involves the initial partitioning of the pipeline data into tiles, based on the relationship between the pipeline layer scale and the discrete global grid system (DGGSs). The pipeline centerline in each tile is then segmented and encoded, and a coarser pipeline bounding volume is subsequently constructed using a geometry shader. Finally, the fine 3D pipeline is rendered using a pixel shader. The results of the experimental implementation of the proposed method show that it satisfies the requirements for the multiscale visualization of pipelines in a VG. Moreover, compared with the traditional polygon-based method, the method facilitates a 20% increase in rendering frame rate for the same pixel level accuracy display effect. It also enables the visualization of the thickness of the 3D pipeline without any obvious effect on the rendering efficiency.

Vector Regression Functions for Texture Compression

Raster images are the standard format for texture mapping, but they suffer from limited resolution. Vector graphics are resolution-independent but are less general and more difficult to implement on a GPU. We propose a hybrid representation called vector regression functions (VRFs), which compactly approximate any point-sampled image and support GPU texture mapping, including random access and filtering operations. Unlike standard GPU texture compression, (VRFs) provide a variable-rate encoding in which piecewise smooth regions compress to the square root of the original size. Our key idea is to represent images using the multilayer perceptron , allowing general encoding via regression and efficient decoding via a simple GPU pixel shader. We also propose a content-aware spatial partitioning scheme to reduce the complexity of the neural network model. We demonstrate benefits of our method including its quality, size, and runtime speed.

An introduction to coaster

coaster is a project that teaches a semester-long introductory computer graphics class by means often programming assignments. The assignments are incremental - each one building on the previous ones - and ultimately require implementation of most of the course content in the final one: a first-person rollercoaster simulation. Briefly described, the assignments (and their course contents) are: circles (2D graphics, applying trigonometry), wire track (3D graphics, parametric curves), wire car (meshes), hedgehog car (face and vertex normals), shaded car (lighting models and vertex shaders), shaded track (extrusion, model transforms), surfaces (Bezier surfaces, height maps), first person (viewing transforms, animation, splines), dynamics (physics-based modeling), and textures (textures, pixel shaders). Figure 1 shows the result of the last of these assignments.

Dedicated object processor for mobile augmented reality - sailor assistance case study

This paper addresses the design of embedded systems for outdoor augmented reality (AR) applications integrated to see-through glasses. The set of tasks includes object positioning, graphic computation, as well as wireless communications, and we consider constraints such as real-time, low power, and low footprint. We introduce an original sailor assistance application, as a typical, useful, and complex outdoor AR application, where context-dependent virtual objects must be placed in the user field of view according to head motions and ambient information. Our study demonstrates that it is worth working on power optimization, since the embedded system based on a standard general-purpose processor (GPP) + graphics processing unit (GPU) consumes more than high-luminosity see-through glasses. This work presents then three main contributions, the first one is the choice and combinations of position and attitude algorithms that fit with the application context. The second one is the architecture of the embedded system, where it is introduced as a fast and simple object processor (OP) optimized for the domain of mobile AR. Finally, the OP implements a new pixel rendering method (incremental pixel shader (IPS)), which is implemented in hardware and takes full advantage of OpenGL ES light model. A GP+OP(s) complete architecture is described and prototyped on field programmable gate-array (FPGA). It includes hardware/software partitioning based on the analysis of application requirements and ergonomics.

Automating Image Morphing Using Structural Similarity on a Halfway Domain

The main challenge in achieving good image morphs is to create a map that aligns corresponding image elements. Our aim is to help automate this often tedious task. We compute the map by optimizing the compatibility of corresponding warped image neighborhoods using an adaptation of structural similarity. The optimization is regularized by a thin-plate spline and may be guided by a few user-drawn points. We parameterize the map over a halfway domain and show that this representation offers many benefits. The map is able to treat the image pair symmetrically, model simple occlusions continuously, span partially overlapping images, and define extrapolated correspondences. Moreover, it enables direct evaluation of the morph in a pixel shader without mesh rasterization. We improve the morphs by optimizing quadratic motion paths and by seamlessly extending content beyond the image boundaries. We parallelize the algorithm on a GPU to achieve a responsive interface and demonstrate challenging morphs obtained with little effort.

YASARA View - molecular graphics for all devices - from smartphones to workstations.

Summary: Today's graphics processing units (GPUs) compose the scene from individual triangles. As about 320 triangles are needed to approximate a single sphere—an atom—in a convincing way, visualizing larger proteins with atomic details requires tens of millions of triangles, far too many for smooth interactive frame rates. We describe a new approach to solve this ‘molecular graphics problem’, which shares the work between GPU and multiple CPU cores, generates high-quality results with perfectly round spheres, shadows and ambient lighting and requires only OpenGL 1.0 functionality, without any pixel shader Z-buffer access (a feature which is missing in most mobile devices).Availability and implementation: YASARA View, a molecular modeling program built around the visualization algorithm described here, is freely available (including commercial use) for Linux, MacOS, Windows and Android (Intel) from www.YASARA.org.Contact: elmar@yasara.orgSupplementary information: Supplementary data are available at Bioinformatics online.

Design and optimization for multiprocessor interactive GPU

In order to achieve maximization of parallelism, effective distribution of rendering tasks, balance between performance and flexibility in graphics processing pipeline, this article presents design, performance analysis and optimization for multi-core interactive graphics processing unit (MIGPU). This processor integrates twelve processing cores with specific instruction set architecture and many sophisticated application-specific accelerators into a 3D graphics engine. It is implemented on XC6VLX550T field programmable gate array (FPGA). MIGPU supports OpenGL2.0 with programmable front-end processor, vertex shader, plane clipper, geometry transformer, three-D clippers and pixel shaders. For boosting the performance of MIGPU, the relationship model is established between primitive types, vertices, pixels, and the effect of culling, clipping, and memory access, and shows a way to improve the speed up of the graphics pipeline. It is capable of assigning graphics rendering tasks to different processors for efficiency and flexibility. The pixel filling rate can reach to 40 Mpixel/s at its peak performance.

Adventures in ASCII Art

This is an account of the author's three-and-a-half decade obsession with ASCII art in which he progresses from a manual typewriter to computers, pixel shaders, real-time animation, and a new variant of color ASCII art that can be reproduced on a manual typewriter using only three or four colored ribbons.

Multiresolution Attributes for Hardware Tessellated Objects

Hardware tessellation is one of the latest GPU features. Triangle or quad meshes are tessellated on-the-fly, where the tessellation level is chosen adaptively in a separate shader. The hardware tessellator only generates topology; attributes such as positions or texture coordinates of the newly generated vertices are determined in a domain shader. Typical applications of hardware tessellation are view dependent tessellation of parametric surfaces and displacement mapping. Often, the attributes for the newly generated vertices are stored in textures, which requires uv unwrapping, chartification, and atlas generation of the input mesh--a process that is time consuming and often requires manual intervention. In this paper, we present an alternative representation that directly stores optimized attribute values for typical hardware tessellation patterns and simply assigns these attributes to the generated vertices at render time. Using a multilevel fitting approach, the attribute values are optimized for several resolutions. Thereby, we require no parameterization, save memory by adapting the density of the samples to the content, and avoid discontinuities by construction. Our representation is optimally suited for displacement mapping: it automatically generates seamless, view-dependent displacement mapped models. The multilevel fitting approach generates better low-resolution displacement maps than simple downfiltering. By properly blending levels, we avoid artifacts such as popping or swimming surfaces. We also show other possible applications such as signal-optimized texturing or light baking. Our representation can be evaluated in a pixel shader, resulting in signal adaptive, parameterization-free texturing, comparable to PTex or Mesh Colors. Performance evaluation shows that our representation is on par with standard texture mapping and can be updated in real time, allowing for application such as interactive sculpting.

A 2.05 GVertices/s 151 mW Lighting Accelerator for 3D Graphics Vertex and Pixel Shading in 32 nm CMOS

Advanced lighting computation is the key ingredient for rendering realistic images in high-throughput 3D graphics pipelines. It is the most performance and power-critical operation in programmable vertex and pixel shaders due to the large number of complex floating-point (FP) multiplications and exponentiations [1]. Performance and energy-efficiency of geometry rendering can be significantly improved by hardware acceleration of lighting computations, which is leveraged by vertex/pixel shader programs residing in the memory of a programmable 3D graphics engine [2] (Fig. 10.4.1). A single-cycle throughput lighting accelerator targeted for on-die acceleration of 3D graphics vertex and pixel shading in high-performance processors and mobile SoCs is fabricated in 32nm high-k metal-gate CMOS [3] (Fig. 10.4.1). Ambient, diffuse, and specular components of the Phong Illumination (PI) equation [4] are computed in parallel in the log domain with 4-cycle latency and 560mV-to-1.2V operation. A high-accuracy 5-segment piecewise linear (PWL) approximation-based log circuit (FPWL-L) with low Hamming weight coefficients, a 32×32b signed truncated specular multiplier, and a high-precision 4-segment PWL approximation-based anti-log circuit (FPWL-AL) enable accurate fixed-point log-domain computation of PI lighting. Five FP multiplications and one FP exponentiation are transformed to five fixed-point additions and one fixed-point multiplication, respectively, resulting in single-cycle lighting throughput of 2.05GVertices/s (measured at 1.05V, 25°C) in a compact area of 0.064mm2 (Fig. 10.4.7) while achieving: (i) 47% reduction in critical path logic stages, (ii) 0.56% mean vertex lighting error compared to a single-precision FP computation, (iii) 354μW active leakage power measured at 1.05V, 25°C, (iv) scalable performance up to 2.22GHz, 232mW measured at 1.2V, and (v) peak energy efficiency of 56GVertices/s/W, measured at 560mV, 25°C.

Genetic programming for shader simplification

We present a framework based on Genetic Programming (GP) for automatically simplifying procedural shaders. Our approach computes a series of increasingly simplified shaders that expose the inherent trade-off between speed and accuracy. Compared to existing automatic methods for pixel shader simplification [Olano et al. 2003; Pellacini 2005], our approach considers a wider space of code transformations and produces faster and more faithful results. We further demonstrate how our cost function can be rapidly evaluated using graphics hardware, which allows tens of thousands of shader variants to be considered during the optimization process. Our approach is also applicable to multi-pass shaders and perceptual-based error metrics.

Parallel algorithm for viewshed analysis on a modern GPU

Spatial analysis, including viewshed analysis, is an important aspect of the Digital Earth system. Viewshed analysis is usually performed on a large scale, so efficiency is important in any Digital Earth application making these calculations. In this paper, a real-time algorithm for viewshed analysis in 3D scenes is presented by using the parallel computing capabilities of a graphics processing unit (GPU). In contrast to traditional algorithms based on line-of-sight, this algorithm runs completely within the programmable 3D visualization pipeline to render 3D terrains with viewshed analysis. The most important difference is its integration of the viewshed calculation with the rendering module. Invisible areas are rendered as shadows in the 3D scene. The algorithm process is paralleled by rasterizer units in the graphics card and by vertex and pixel shaders executed on the GPU. We have implemented this method in our 3D Digital Earth system with the DirectX 9.0c API and tested on some consumer-level PC platforms with interactive frame-rates and high image quality. Our algorithm has been widely used in related systems based on Digital Earth.

Power-Gated Arithmetic Circuits for Energy-Precision Tradeoffs in Mobile Graphics Processing Units

In mobile devices, limiting the Graphics Processing Unit's (GPU's) energy usage is of great importance to extending battery life. This work shows that significant energy savings can be obtained by reducing the precision of graphics computations, yet maintaining acceptable quality of the final rendered image. In particular, we focus on a portion of a typical graphics processor pipeline— the vertex transformation stage—and evaluate the tradeoff between energy efficiency and image fidelity. We first develop circuit-level designs of arithmetic components whose precision can be varied dynamically with fine-grained power gating techniques. Spice simulation is used to characterize each component's energy consumption, based on which a system-level energy model for the entire vertex stage is developed. We then use this energy model in conjunction with a graphics hardware simulator to determine the energy savings for real workloads. Results show that, solely by changing the precision of the arithmetic in the vertex shaders' ALUs, we can save up to 10% of the overall energy in the GPU. As promising as these savings are, we expect that our circuits and approach will enable energy-precision tradeoffs in other areas of the graphics pipeline, such as the pixel shader, which consume even more energy than the vertex shader.

Research on Key Factors in Shader Programming of Dynamic Water Surface

Research on real time dynamic water surface is a hotspot in the study of virtual reality with very broad application prospect. With the rapid development of calculating ability of GPU (Graphics Processing Unit) and the development of HLSL (High-Level Shader Language), the tasks such as vertex shader ,pixel shader, calculation of normal vector, dynamic texture mapping and calculation of water reflections and refractions can be done by GPU. In our research we studied the key factors affecting the effect of dynamic water surface and indicated that the writer presents some opinions which can generate more accurate reflections and refractions of water through adjusting light intensity and colorimchy by lighting and perturbing 2D texture mapping with normal mapping. A shader program in Virtools has been written and applied in virtual reality project. In the actual operation the effect is real and the rendering speed has greatly increased.

Parallel algorithm for real-time contouring from grid DEM on modern GPUs

A real-time algorithm for constructing contour maps from grid DEM data is pre-sented. It runs completely within the pro grammable 3D visualization pipeline. The interpolation is paralleled by rasterizer units in the graphics card, and contour litw extraction is paralleled by pixel shader. During each frame of the rendering, we first make an elevation gradient map out of original terrain vertex data, then figure out the final contour lines with image-space processing, and directly blend the result on the original scene to obtain a final scene with contour map using alpha-blending. We implement this method in our globa 3D-digitalearth system with Direct3D®9.0c API and tested on some consumer level PC platforms. For arbitrary scene witl certain LOD level, the process takes less than 10 ms, giving topologically correct, anti-aliased contour lines.