3D graphics pipeline can be divided into two subsystems: geometry subsystem and rendering subsystem. Hardware implementation of the transformation and lighting in the geometric subsystem can be divided into two categories, fixed function pipeline and programmable vertex shader. This thesis proposes a programmable vertex shader design based on OpenGL ES 2.0 specification. We start from the design of instruction set and use a multiplier-accumulator (MAC)-based SIMD (Single-Instruction Multiple-Data) structure. The vertex shader supports both floating-point and fixed-point operations of both scalar and vector formats. In addition, the special function unit for calculation of complicated functions is also integrated in the vertex shader. Besides, we also make out best to minimize the cost, power ,and delay during the entire design process.

Last year evolution of interactive 3D graphics became quicken when emerged high level programming language of interactive shaders and their creation tools. In this project I found out and chose all information about interactive shaders and their practice. I explored interactive shaders creation tools, analyzed Cg-HLSL programming language and how to practice it for three-dimensional graphics system. In this project I reviewed Cg and HLSL implementation and I built few examples of interactive shaders effects.

Modern graphics accelerators have embedded programmable components in the form of vertex and fragment shading units. Current APIs permit specification of the programs for these components using an assembly-language level interface. Compilers for high-level shading languages are available but these read in an external string specification, which can be inconvenient. It is possible, using standard C++, to define an embedded high-level shading language. Such a language can be nearly indistinguishable from a special-purpose shading language, yet permits more direct interaction with the specification of textures and parameters, simplifies implementation, and enables on-the-fly generation, manipulation, and specification of shader programs. An embedded shading language also permits the lifting of C++ host language type, modularity, and scoping constructs into the shading language without any additional implementation effort.

Modern graphics accelerators have embedded programmable components in the form of vertex and fragment shading units. Current APIs permit specification of the programs for these components using an assembly-language level interface. Compilers for high-level shading languages are available but these read in an external string specification, which can be inconvenient. It is possible, using standard C++, to define an embedded high-level shading language. Such a language can be nearly indistinguishable from a special-purpose shading language, yet permits more direct interaction with the specification of textures and parameters, simplifies implementation, and enables on-the-fly generation, manipulation, and specification of shader programs. An embedded shading language also permits the lifting of C++ host language type, modularity, and scoping constructs into the shading language without any additional implementation effort.

Game developers today are putting a lot of effort into their games. Consumers are hard to please and demand a game which can provide both fun and visual quality. This is why developers aim to make the most use of what hardware resources are available to them to achieve the best possible quality of the game. It is easy to use too many performance demanding techniques in a game, making the game unplayable. The hard part is to make the game look good without decreasing the performance. This can be done by using techniques in a smart way to make the graphics as smooth and efficient as they can be without compromising the visual quality. One of these techniques is deferred rendering. The latest version of Microsoft’s graphics platform, DirectX 11, comes with several new features. One of these is the Compute shader which is a feature making it easier to execute general computation on the graphics card. Developers do not need to use DirectX 11 cards to be able to use this feature though. Microsoft has made it available on graphic cards made for DirectX 10 as well. There are however a few differences between the two versions. The focus of this report will be to investigate the possible performance differences between these versions on when using deferred rendering. An application was made supporting both shader model 4 and 5 of the compute shader, to be able to investigate this.

It is a great challenge to develop a computer game. Today many games are developed in large game studios where lots of skilled people are working together. Everyone has to know what the final game should look like. Game designers are responsible for how the game should feel and look like. This also means that they decide if a programmer has to develop new techniques or not. Sometimes the game designers require lots of new techniques to be developed. Such a new technique may be rendering particle systems with a lot of particles in it. This is where this report will focus. To render particle systems it is necessary to know about the limitations there are in both hardware and software. Until today particle systems have been updated and calculated using the Central Processing Unit of the computer. With Microsoft Direct3D 10 there are new ways to render particles using Geometry Shaders. Geometry Shaders runs on the graphics card. This thesis focuses on testing rendering performance between using Geometry Shaders and not using Geometry Shaders. A questionnaire was sent to Swedish game developers to get more information about relevant topics for investigation. A general answer was that Geometry Shaders always increase particle rendering performance. This thesis investigates if and when the statement is true or not. The hypothesis was obtained from the answers to the questionnaire. Two test applications were used to investigate if the hypothesis was true or false. One test application has particle calculations on the CPU of the computer. The other test application has particle calculations on the GPU of the graphics card. Six different tests were done and the Geometry Shader approach went out to be the fastest in five of the tests. Since not all tests were faster than the CPU approach the hypothesis is not always true.

This thesis deals with implementation of a debugging and development tool for GLSL shader programming. In the text, you will find design of the application and it's implementation in Qt library. The thesis also includes performance testing with GLSL shaders. Experiments were focused on commands of application control flow in GLSL and texturing commands used in shaders. In the thesis, you will find explanation of the functionality of some shaders used in OpenGL. Application developed in this thesis, is meant to help with implementation of graphic programs programmed in OpenGL 3.3 or higher.

In the field of computer graphics, shaders provide an interface between lights and surfaces, giving the appearance of metal, plastic, wood, etc. As the field progresses, more and more shaders are required to simulate a wider and wider variety of materials. We present a new shader for the simulation of wood burl, a complex material used in furniture, art, car interiors, and a host of other luxury items. This shader was developed through a morphological approach - a study of the original material, its structure, and growth. Consequently, research began with a thorough look at wood burl, polished and unpolished, in an assortment of different species. We discovered the appearance can be broken into three sub-appearances - knots, curl, and a subtle undergrain. These three sub-appearances interact to create the characteristic swirls and whorls of burl. For the subtle undergrain, we used a common oak shader, added noise, and faded it into the background. We then developed a system of randomly placing points through the material to act as knots. Since the knots grow and distort the surrounding grain, we used distance-scaled forces to push the surface coordinates around and between all the knots. When the oak shader is applied, it appears to swirl and curl around the knots, much like a stream between rocks. This created the first level of curl or swirly grained wood, but one level alone appeared flat. To solve this, we procedurally blended levels of curl to give a look of increased depth. Finally, we added reflection, gloss, and other surface properties to give a look of warmth and polish. All of these properties are controlled by a set of parameters in the shader's interface. By adjusting these parameters, the user can emulate a variety of different burl types.

Celtic art contains mysterious and fascinating aesthetic elements including complex knot work motifs. The problem is that creating and exploring these motifs require substantial human effort. One solution to this problem is to create a process that collaboratively uses interactive and procedural methods within a computer graphic environment. Spline models of Celtic knot work can be interactively modeled and used as input into procedural shaders. Procedural shaders are computer programs that describe surface, light, and volumetric appearances to a renderer. The control points of spline models can be used to drive shading procedures such as the coloring and displacement of surface meshes. The result of this thesis provides both an automated and interactive process that is capable of producing complex interlaced structures such as Celtic knot work within a three-dimensional environment.

This thesis focuses on efficient design of a vertex shader for per-vertex operations such as Transformation and Lighting in the OpenGL ES 2.0 graphics pipeline. The vertex shader performs these complex operations using logarithmic number system, and makes partial optimization for the hardware area based on the accuracy requirement of half-precision floating-point. The vertex shader design emphasizes low cost, and is well suited to low-accuracy embedded applications. The vertex shader is an SIMD (Single-Instruction-Multiple-Data) design with customized instruction set that allows users to write efficient vertex shader programs.