The computational capacity of graphics cards for general-purpose computinghave progressed fast over the last decade. A major reason is computational heavycomputer games, where standard of performance and high quality graphics constantlyrise. Another reason is better suitable technologies for programming thegraphics cards. Combined, the product is high raw performance devices andmeans to access that performance. This thesis investigates some of the currenttechnologies for general-purpose computing on graphics processing units. Technologiesare primarily compared by means of benchmarking performance andsecondarily by factors concerning programming and implementation. The choiceof technology can have a large impact on performance. The benchmark applicationfound the difference in execution time of the fastest technology, CUDA, comparedto the slowest, OpenCL, to be twice a factor of two. The benchmark applicationalso found out that the older technologies, OpenGL and DirectX, are competitivewith CUDA and OpenCL in terms of resulting raw performance.

In this thesis I look into how one can train and run an artificial neural network using Compute Shader and what kind of performance can be expected. An artificial neural network is a computational model that is inspired by biological neural networks, e.g. a brain. Finding what kind of performance can be expected was done by creating an implementation that uses Compute Shader and then compare it to the FANN library, i.e. a fast artificial neural network library written in C. The conclusion is that you can improve performance by training an artificial neural network on the compute shader as long as you are using non-trivial datasets and neural network configurations.

Game engines are well known for their use in the gaming industry but are starting to have an impact in other areas as well. Architecture, automotive, and the defence industry are today using these engines to visualise and, to some extent, test their products. In this thesis, we have examined how the game engine Unity could be used for simulating a radar with the purpose of detecting and measuring sea clutter. Following a pre-study examining different implementation approaches, it was decided to use ray tracing. The radar itself is simulated by using the camera to emit rays and having a plane object directly behind it act as a receiver. Rays are then individually traced for each pixel, propagating throughout the scene and saving information such as hit coordinates, distance travelled, and direction. By using the total travel distance of each ray that returned to the receiver, the phase of each ray is calculated. This is then used to compute the total amplitude, which represents the returned signal strength. Using a compute shader, most of the computations are done in parallel on the GPU, enabling millions of rays to be traced. As measuring sea clutter was an objective of the study, tests measuring the ocean were carried out. These used ocean surfaces with two different sea states, using the Phillips spectrum to generate realistic waves. A ship object was then tested in free space and on two different ocean surfaces. The calculated amplitude and the number of rays returned were used to determine the signal strength returned and the RCS of the object. The purpose of this was to compare with other results of sea clutter studied, observed both in the real world and in simulated scenarios, and determine if our approach could be a valid choice for the industry. Some results matched the findings of a similar study that used a professional radar simulation tool called OKTAL. Other results of sea clutter were found to not be realistic due to certain limitations. The current main limitation of our implementation is not being able to trace a large enough ocean surface with the finer details needed for realistic results. However, this could be solved by creating a better implementation. These findings suggest that simulating radar and sea clutter in Unity is a feasible approach worth continuing to explore. / Spelmotorer är välkända för sin användning inom spelindustrin men har också fått genomslag inom andra områden. Arkitektur, fordonsindustrin och försvarsindustrin använder idag dessa verktyg för att visualisera och till viss mån, även testa sina produkter. I detta examensarbete har vi undersökt hur spelmotorn Unity kan användas för att simulera en radar i syfte att detektera och mäta sjöklotter. Efter en förstudie där olika implementeringsmetoder undersöktes, beslutades det att använda strålspårning (eng. ray tracing). Själva radarn simuleras genom att använda kameraobjektet i Unity för att sända ut strålar. Bakom kameran finns ett planobjekt som fungerar som mottagare. Strålar spåras sedan individuellt för varje pixel och sprider sig genom en given scen. Samtidigt sparas information såsom träffkoordinater, den totala färdsträckan samt riktning. Genom att använda det totala färdavståndet för varje stråle som återvänt till mottagaren kan fasen för varje stråle beräknas. Detta kan sedan användas för att beräkna den totala returnerade amplituden, vilket motsvarar den returnerade signalstyrkan. Med hjälp av en "compute shader" kan databeräkningarna göras parallellt av GPU:n vilket underlättar när så många strålar ska spåras. Eftersom syftet med uppsatsen var mätning av simulerat sjöklotter, genomfördes tester för att mäta på ett simulerat hav. Havsytorna hade två olika sjöstadier, vilka genererades med Phillips-spektrumet för att få realistiska vågor. Ett fartygsobjekt testades sedan i frirymd och sedan även i de två olika havsytorna. Amplituden och mängden strålar som returnerades användes för att bestämma den totala returnerade signalstyrkan och "Radar Cross Section" (RCS) för objektet. Syftet med detta var att kunna jämföra med andra studier gällande sjöklotter, både simulerade som verklighetsbaserade och avgöra om vårt tillvägagångssätt kunde resultera i ett användbart verktyg för branschen. De olika amplituder och antalet strålar som vi fick tillbaka varierade beroende på vilka vinklar och havsytor som användes.Vissa resultat var inte realistiska jämfört med verkliga mätningar av sjöklotter. Det beror främst på våra nuvarande begränsningar i att inte kunna spåra en tillräckligt stor och tillräckligt detaljerad havsyta, vilket behövs för att mätningarna ska vara mer realistiska. Däremot matchade vi några resultat med de från en liknande studie, där verktyget OKTAL, som är ett professionellt radarsimuleringsverktyg, användes. Detta i kombination med möjligheterna för en förbättrad implementation tyder på att användningen av en spelmotor som Unity är ett intressant verktyg värd att vidareutforska radarsimuleringar med.

Background. Being able to modify virtual environments can create immersive experiences for video-game players. Storing data as volumetric scalar fields allows for highly modifiable 3D environments that can be converted into GPU-friendly triangles with isosurface algorithms. Using scalar fields and isosurface algorithms can be more computationally expensive and require more data than the more commonly used polygonal models. Objectives. The aim of this thesis is to explore solutions to modifying real-time 3D environments with isosurface algorithms. This will be done in two parts. First in terms of observing how modern games deal with storing scalar fields, researching which isosurface algorithms are being used and how they are being used in games. The second part is to create an application and limit the data storage required while still running at a real-time speed. Methods. There are two methods to achieve the aim. The first is to research and see which data structures and isosurface algorithms are being used in modern games and how they are utilized. The second method will be done by implementation. The implementation will use the GPU through compute shaders and use marching cubes as isosurface algorithm. It will utilize Christopher Dyken’s Histogram Pyramids for stream compaction. Two different versions will be implemented that differ in terms of what data types will be used for storage. The first using the data type char and the second int. Between these two versions, the runtime speed will be measured and compared on two different hardware configurations. Results. Finding good data on what algorithms games use is difficult. Modern games are using scalar fields in many different ways: Some allow almost complete modification of terrain, others only use it for a 3D environment. For data storage, octrees and chunks are two common ways to store the fields. Dual Contouring appears to be the primary isosurface algorithm being used based on the researched games. The results of the implementation were very fast and usable in real time environments for destruction of terrain on a large scale. The less storage intensive variation of this implementation(char) gave faster results on modern hardware but the opposite(int) was true on older hardware. Conclusions. Modifying scalar field terrain is done at a very large scale in modern games. The choice of using Dual Contouring or Marching Cubes depends on the use-case. For areas where sharp features can be important Dual Contouring is the preferred choice. Likely for these reasons Dual Contouring was found to be a popular choice in the studied games. For other areas, like many types of terrain, Marching Cubes is very fast, as can be seen in the implementation. By using the char version of the implementation, interacting with the environment in real-time is possible at high frame-rates.

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.

Context. Ray tracing has always been a simple but effective way to create a photorealistic scene but at a greater cost when expanding the scene. Recent improvements in GPU and CPU hardware have made ray tracing faster, making more complex scenes possible with the same amount of time needed to process the scene. Despite the improvements in hardware ray tracing is still rarely run at a interactive speed. Objectives. The aim of this experiment was to implement a new kdtree generation algorithm using DirectX 11 compute shaders. Methods. The implementation created during the experiment was tested using two platforms and five scenarios where the generation time for the kd-tree was measured in milliseconds. The results where compared to a sequential implementation running on the CPU. Results. In the end the kd-tree generation algorithm implemented did not run within our definition of real-time. Comparing the generation times from the implementations shows that there is a speedup for the GPU implementation compared to our CPU implementation, it also shows linear scaling for the generation time as the number of triangles in the scene increase. Conclusions. Noticeable limitations encountered during the experiment was that the handling of dynamic structures and sorting of arrays are limited which forced us to use less memory efficient solutions.

Context Subsurface scattering - the effect of light scattering within a material. Lots of materials on earth possess translucent properties. It is therefore an important factor to consider when trying to render realistic images. Historically the effect has been used for offline rendering with ray tracers, but is now considered a real-time rendering technique and is done based on approximations off previous models. Early real-time methods approximates the effect in object texture space which does not scale well with real-time applications such as games. A relatively new approach makes it possible to apply the effect as a post processing effect using GPGPU capabilities, making this approach compatible with most modern rendering pipelines. Objectives The aim of this thesis is to explore the possibilities of a dynamic real-time solution to subsurface scattering with a modern rendering API to utilize GPGPU programming and modern data management, combined with previous techniques Methods The proposed subsurface scattering technique is implemented in a delimited real-time graphics engine using a modern rendering API to evaluate the impact on performance by conducting several experiments with specific properties. Results The result obtained hints that by using a flexible solution to represent materials, execution time lands at an acceptable rate and could be used in real-time. These results shows that the execution time grows nearly linearly with consideration to the number of layers and the strength of the effect. Because the technique is performed in screen space, the performance scales with subsurface scattering screen coverage and screen resolution. Conclusions The technique could be used in real-time and could trivially be integrated to most existing rendering pipelines. Further research and testing should be done in order to determine how the effect scales in a complex 3D-game environment.

Visualization of volumetric data has always been useful in big va- riety of ways, for example computer tomography (CT) and magnet resonance tomography (MRT) are two major applications of this sorts of algorithms. Since volumetric data has no limitation regarding the shape of the object that ordinary mesh algorithms has we can fully reconstruct anything using the Marching cubes algorithm. New tech- niques allow us to implement this algorithm by new and exible means. Here we will use the latest of DirectX technology to run marching cubes in realtime using compute shaders. / kristoffer.swe@gmail.com

The game industry have always looked for rendering techniques that makes the games as good looking and realistic as possible. The common approach is to use triangles built up by vertices and apply many different techniques to make it look as good as possible. When triangles are used to draw objects, there is always edges and those edges often make the objects look less realistic than desired. To reduce these visible edges the amount of triangles for an object have to be increased, but with more triangles more processing power from the graphics cards is needed. Another way to approach rendering is ray tracing which can render an extremely photo realistic image but to the cost of unbearable low performance if you would use it in a realtime application. The reason raytracing is so slow is the massive amount of calculations that needs to be made. In DirectX 11 a few new shaders where announced and one of them were the compute shader, the compute shader allows you to calculate data on the graphics card which is not bound to the pipeline. The compute shader allows you to use the hundreds of cores that the graphic card has and is therefore well suited for a raytracing algorithm. One application is used to see if the hypothesis is correct. A flag is used to define if the application runs on the CPU and the GPU. The same algorithm is used in both versions. Three test where done on each processing unit to confirm the hypothesis. Three more tests where done on the GPU to see how the performance scaled on the GPU depending on the number of rendered objects. The tests proved throughout that the compute shader performs considerably better than the CPU when running our ray tracing algorithm.

Modelling and rendering natural phenomena, such as rain, is an important aspect of creating a realistic driving simulator. Rain is a crucial issue when driving in the real world as it for instance obstructs the driver’s vision. The difficulty is to implement it in a visually appealing way while simultaneously making it look realistic and keeping the computational cost low. In this report, a GPGPU (general-purpose computing on graphical processing units) based approach is presented where the final product is a rain simulation rendered onto a 2D texture, which can then be applied to a surface. The simulated raindrops interact with gravity, wind, a windshield wiper as well as with each other, and are then used to distort the background behind them in a convincing manner. The simulation takes into account multiple physical properties of raindrops and is shown to be suitable to run in real-time. The result is presented in form of a visual demonstration. In conclusion, even though the final simulation is still in its first iteration, it clearly highlights what can be accomplished by utilizing the GPU and the benefits of using a texture-based approach. The appropriate simulation approach will however always depend on the characteristics of the problem and the limitations of the hardware.