Shading Language Research Articles

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.

가변길이 SIMD구조 쉐이더 명령어 및 컴파일러 설계

본 논문에서는 3차원 그래픽 쉐이더 3.0 API를 지원하는 쉐이더 명령어 및 컴파일러를 설계하고 그 결과를 평가한다. 기존의 명령어와는 달리 가변길이의 명령어 구조를 제안하고 명령어의 길이를 줄여 SIMD(Single Instruction Multiple Data)구조의 그래픽 프로세서의 하드웨어 크기를 줄일 수 있다. 가변길이 및 2 페이즈 구조의 명령어를 지원하며 ESSL(ES Shading Language) 수준에서 쉐이더 프로그램이 가능한 쉐이더 컴파일러의 설계를 수행하였다. 명령어와 컴파일러 설계 결과를 검증하기 위하여 크로노스그룹에서 제안하는 Conformance Test를 수행하였다. 그 결과로 제공하는 기본 GL 쉐이더의 기능 16개를 비교하여 보았을 때 전체 평균 37%가 줄어드는 것을 알 수 있다. Shader instructions and Compiler are designed for supporting 3D graphic shader 3.0 API. Variable-length instructions are proposed to reduce the size of hardware of graphic processor in SIMD structure by shortening the length of instructions. The designed shader compiler supports variable and two phased structured instructions, and can be programmable at ESSL level. Conformance Test proposed by Khronos group is accomplished to verify the design result of instructions and complier. The test result shows overall average 37% performance improvement at the 16 functions of basic GL shader.

Simulation of one-layer shallow water systems on multicore and CUDA architectures

The numerical solution of shallow water systems is useful for several applications related to geophysical flows, but the big dimensions of the domains suggests the use of powerful accelerators to obtain numerical results in reasonable times. This paper addresses how to speed up the numerical solution of a first order well-balanced finite volume scheme for 2D one-layer shallow water systems by using modern Graphics Processing Units (GPUs) supporting the NVIDIA CUDA programming model. An algorithm which exploits the potential data parallelism of this method is presented and implemented using the CUDA model in single and double floating point precision. Numerical experiments show the high efficiency of this CUDA solver in comparison with a CPU parallel implementation of the solver and with respect to a previously existing GPU solver based on a shading language.

Graphics shaders: theory and practice

Programmable graphics shaders, programs that can be downloaded to a graphics processor (GPU) to carry out operations outside the fixed-function pipeline of earlier standards, have become a key feature of computer graphics. This book is designed to open computer graphics shader programming to the student, whether in a traditional class or on their own. It will complement texts based on fixed-function graphics APIs, specifically OpenGL. It introduces shader programming in general, and specifically the GLSL shader language. It also introduces a flexible, easy-to-use tool, glman, that helps you develop, test, and tune shaders outside an application that would use them.

Towards Utilizing GPUs in Information Visualization: A Model and Implementation of Image-Space Operations

Modern programmable GPUs represent a vast potential in terms of performance and visual flexibility for information visualization research, but surprisingly few applications even begin to utilize this potential. In this paper, we conjecture that this may be due to the mismatch between the high-level abstract data types commonly visualized in our field, and the low-level floating-point model supported by current GPU shader languages. To help remedy this situation, we present a refinement of the traditional information visualization pipeline that is amenable to implementation using GPU shaders. The refinement consists of a final image-space step in the pipeline where the multivariate data of the visualization is sampled in the resolution of the current view. To concretize the theoretical aspects of this work, we also present a visual programming environment for constructing visualization shaders using a simple drag-and-drop interface. Finally, we give some examples of the use of shaders for well-known visualization techniques.

Using GPU Shaders for Visualization

GPU shaders seem used mostly for gaming and other forms of entertainment and simulation. But they have less-obvious visualization uses, for the same reasons that interest the gaming community: improved appearance and performance. This column looks at the use of shaders and the OpenGL shading language (GLSL) in two common visualization applications: point clouds and contour cutting planes.

ProteinShader: illustrative rendering of macromolecules.

BackgroundCartoon-style illustrative renderings of proteins can help clarify structural features that are obscured by space filling or balls and sticks style models, and recent advances in programmable graphics cards offer many new opportunities for improving illustrative renderings.ResultsThe ProteinShader program, a new tool for macromolecular visualization, uses information from Protein Data Bank files to produce illustrative renderings of proteins that approximate what an artist might create by hand using pen and ink. A combination of Hermite and spherical linear interpolation is used to draw smooth, gradually rotating three-dimensional tubes and ribbons with a repeating pattern of texture coordinates, which allows the application of texture mapping, real-time halftoning, and smooth edge lines. This free platform-independent open-source program is written primarily in Java, but also makes extensive use of the OpenGL Shading Language to modify the graphics pipeline.ConclusionBy programming to the graphics processor unit, ProteinShader is able to produce high quality images and illustrative rendering effects in real-time. The main feature that distinguishes ProteinShader from other free molecular visualization tools is its use of texture mapping techniques that allow two-dimensional images to be mapped onto the curved three-dimensional surfaces of ribbons and tubes with minimum distortion of the images.

A game loop architecture for the GPU used as a math coprocessor in real-time applications

This article concerns the use of a graphics processor unit (GPU) as a math co-processor in real-time applications in special games and physics simulations. To validate this approach, we present a new game loop architecture that employs GPUs for general-purpose computations (GPGPUs). A critical issue here is the process distribution between the CPU and the GPU. The architecture consists of a model for distribution, and our implementation offers many advantages in comparison to other approaches without the GPGPU stage. This architecture can be used either by a general-purpose language such as the Compute Unified Device Architecture (CUDA), or shader languages such as the High-Level Shader Language (HLSL) and the OpenGL Shading Language (GLSL). Although the architecture proposed here aims at supporting mathematics and physics on the GPU, it is possible to adapt any kind of generic computation. This article discusses the model implementation in an open-source game engine and presents the results of using this platform.

TU‐EE‐A4‐06: Fast DRR and CBCT Reconstruction On GPU

Purpose: To accelerate the synthesis of digitally reconstructed radiographs (DRRs) and the reconstruction of cone‐beam CT (CBCT) data with the help of commodity graphics processing units (GPUs). The massively parallel architecture of GPUs allows significant improvements in execution speed for algorithms that present various levels of symmetry. Method and Materials: We have implemented DRR synthesis and CBCT reconstruction algorithms on GPUs and have compared their execution speed and accuracy with those of traditional CPU implementations. DRRs were obtained with an incremental version of Siddon's algorithm, an exact raytracing routine, while CBCT reconstructions were based on the FDK algorithm. The benchmarking was conducted with a nVidia GeForce 8800 GTX graphics board hosted in a 2.4 GHz Intel Quad Core PC. The Cg shading language was used for GPU programming, and all calculations were performed in single precision. Results: We have achieved execution speed improvement factors of 47x for DDR synthesis and of 100x for CBCT reconstruction with the GPU implementation. These figures, obtained with relatively large, clinically relevant datasets (512 Mb), could further be improved by using smaller datasets that fit entirely in the video memory. The DRRs obtained with the GPU implementation were identical to their CPU versions while the CBCT images presented slight differences (2% standard deviation), most likely due to discrepancies in the CPU‐GPU floating‐point rounding conventions. Conclusion: We have implemented on a streaming architecture two algorithms relevant to many branches of medical physics. We have achieved significant speed increase factors while preserving the accuracy of the results. The rapid development of GPU products sporting more memory, supporting double‐precision and running at higher clock speeds lets envision even faster execution and more accurate results, thereby opening the way to new, innovative applications in medical physics.

OpenGL Shading Language by Randi J. Rost

OpenGL Shading Language by Randi J. Rost

Teaching graphics with the openGL shading language

A long-standing difficulty in the development of introductory courses in computer graphics is balancing the educational necessity of ensuring mastery of fundamental graphical concepts with the highly desirable goal of exciting and inspiring students to further study by enabling them to produce visually interesting programming projects. Recently, we have developed a modified curriculum predicated on the extensive integration of the OpenGL Shading Language with a more traditional pedagogical approach. We utilized this curriculum in the quarter-long, upper-division introductory graphics course taught in the Department of Computer Science at the University of California, Santa Cruz. Our experience indicates that making shading an integral part of the entry-level curriculum inculcates students with a comprehensive understanding of the algorithms and mathematical concepts that underlie modern graphical systems, while simultaneously equipping them with the tools necessary to produce complex projects with state-of-the-art technology.

Retina simulation using cellular automata and GPU programming

This article shows how the architectural modelization of biological retina allows real-time performances, on standard widespread computing systems. First, we describe the biological retina with regard to its pipeline architecture, detailing its layer behaviours and properties. Then we propose a corresponding pipelined model of artificial retina based on cellular automata. In this work, the main innovation is the computing method based on the programming of a personal computer graphical card using OpenGL shading language. The last section demonstrates the efficiency of our model through numerical and graphical results. We lay particular emphasis on the fact that our direct implementation of the Graphical Processor Unit (GPU) provides computation power about 20 times as fast as conventional programming.

The Direct3D 10 system

We present a system architecture for the 4 th generation of PC-class 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 multi-year collaboration with application developers and hardware designers.

Improvement of Web3D Data Format using Shading Language

Web3D techniques for managing 3DCG in the contents of HTML pages have made remarkable progress since VRML appeared in 1995.Many Web3D systems use fixed shaders for graphics API for realtime 3DCG rendering,so it is difficult to simulate the global illumination.We propose a solution to the problem of global illumination that uses a Web3D environment map in our proprietary Web3D format,'3DX' and the GPU shading language.

Shader algebra

An algebra consists of a set of objects and a set of operators that act on those objects. We treat shader programs as first-class objects and define two operators: connection and combination. Connection is functional composition: the outputs of one shader are fed into the inputs of another. Combination concatenates the input channels, output channels, and computations of two shaders. Similar operators can be used to manipulate streams and apply computational kernels expressed as shaders to streams. Connecting a shader program to a stream applies that program to all elements of the stream; combining streams concatenates the record definitions of those streams.In conjunction with an optimizing compiler, these operators can manipulate shader programs in many useful ways, including specialization, without modifying the original source code. We demonstrate these operators in Sh, a metaprogramming shading language embedded in C++.

Cg

The latest real-time graphics architectures include programmable floating-point vertex and fragment processors, with support for data-dependent control flow in the vertex processor. We present a programming language and a supporting system that are designed for programming these stream processors. The language follows the philosophy of C, in that it is a hardware-oriented, general-purpose language, rather than an application-specific shading language. The language includes a variety of facilities designed to support the key architectural features of programmable graphics processors, and is designed to support multiple generations of graphics architectures with different levels of functionality. The system supports both of the major 3D graphics APIs: OpenGL and Direct3D. This paper identifies many of the choices that we faced as we designed the system, and explains why we made the decisions that we did.

Sampling procedural shaders using affine arithmetic

Procedural shaders have become popular tools for describing surface reflectance functions and other material properties. In comparison to fixed resolution textures, they have the advantage of being resolution-independent and storage-efficient. While procedural shaders provide an interface for evaluating the shader at a single point, it is not easily possible to obtain an average value of the shader together with accurate error bounds over a finite area. Yet the ability to compute such error bounds is crucial for several interesting applications, most notably heirarchical area sampling for global illumination, using the finite element approach, and for generation of textures used in interactive computer graphics. Using affine arithmetic for evaluating the shader over a finite area yields a tight, conservative error interval for the shader function. Compilers can automatically generate code for utilizing affine arithmetic from within shaders implemented in a dedicated language such as the RenderMann shading language.

Implementing RenderMan ‐ Practice, Problems and Enhancements

AbstractThe RenderMan interface has been proposed as a general interface to rendering systems, yet only a few implementations of the interface exist. In this paper we describe the implementation of the RenderMan interface on a general rendering architecture that supports various rendering algorithms. Specifically we discuss the implementation of the RenderMan Shading Language and its integration into our rendering architecture. Special attention is focused on the problems that we have encountered and how they can be solved. Additionally, we suggest extensions and enhancements to the current interface definition, which would make RenderMan easier to implement and more flexible to use.

A language for shading and lighting calculations

A shading language provides a means to extend the shading and lighting formulae used by a rendering system. This paper discusses the design of a new shading language based on previous work of Cook and Perlin. This language has various types of shaders for light sources and surface reflectances, point and color data types, control flow constructs that support the casting of outgoing and the integration of incident light, a clearly specified interface to the rendering system using global state variables, and a host of useful built-in functions. The design issues and their impact on the implementation are also discussed.

Building block shaders

This paper describes an implementation of Cook's "shade trees" in which shaders are described as networks of modules, building blocks, whose connections can be defined interactively.The high level interface to the shaders is a graphical editor which permits users to construct complex shaders by connecting shading elements in a network, in effect a graphical shading language. A low level interface to the shaders is also provided. In the low level interface, shading elements are programmed in a standard programming language and compiled into modules which can linked either at run time or compile time.Each link in the shading network represents a subroutine call. In essence, execution of the network is analogous to the execution of an interpreted language.