Refine
Document Type
- Bachelor Thesis (17)
- Master's Thesis (2)
Has Fulltext
- yes (19)
Is part of the Bibliography
- no (19)
Keywords
- Computervisualistik (4)
- Computergrafik (3)
- Line Space (3)
- Datenstruktur (2)
- Global Illumination (2)
- Linespace (2)
- Path Tracing (2)
- Raytracing (2)
- Realistische Computergrafik (2)
- 3D-Scan (1)
Institute
The present work introduces a rigid-body physics engine, focusing on the collision detection by GPU. The increasing performance and accessibility of modern graphics cards ensures that they can be also used for algorithms that are meant not only for imaging. This advantage is used to implement an efficient collision detection based on particles. The performance differences between CPU and GPU are presented by using a test environment.
Ray Tracing enables a close to reality rendering implementation of a modelled scene. Because of its functioning, it is able to display optical phenomena and complex lighting. Though, numerous computations per pixel have to be done. In practice implementations can not achieve computer graphics" aim of real-time rendering close to 60 frames per second. Current Graphics Processing Units (GPU) allows high execution parallelism of general-purpose computations. By using the graphics-API OpenGL this parallelism can be achieved and it is possible to design and realize a Ray-Tracer, which operates entirely on the GPU. The developed approach will be extended by an Uniform Grid - a Ray-Tracing acceleration structure. Hence, a speed-up is expected.
This thesis` purpose is the implementation of Ray-Tracer, which operates completely on the GPU, and its expansion by integrating an Uniform Grid. Afterwards, the evaluation of maximum achievable performance takes place. Possible problems regarding GPU-programming will be identified and analysed.
This thesis presents a novel technique in computer graphics to simulate realtime
global illumination using path tracing. Path tracing is done with compute shaders on the graphics card (GPU) to perform rendering in a highly parallelized manner. To improve the overall performance of tracing rays, the Line Space is used as an acceleration data structure in different variations, resulting in better
empty space skipping. The Line Space saves scene information based on a previous voxelization in direction-dependent shafts and is generated and traversed on the GPU. With this procedure, indirect lighting and soft shadows can be computed in a physically correct way. Furthermore, using the Line Space, path tracing can be performed mostly independent of the complexity of the scene geometry with over 100 frames per second, which is truly real-time and much faster than using a comparable voxel grid. The image quality is not affected negatively by this technique and the shadow quality is in most cases much better compared to shadow-mapping.
In this master's thesis the principle of hybrid ray tracing, consisting of a rasterization pipeline which includes ray tracing techniques for certain effects, is explained and the implementation of an application which uses a hybrid approach in which ray tracing is used to calculate shadows, ambient occlusion, and reflections and combines those with direct lighting is documented and explained. Hybrid ray tracing is based on the idea of combining the performance and flexibility of rasterization-based approaches with ray tracing to overcome the limitation of not being able to access the complete surrounding geometry at any point in the scene.
While describing the implementation of said application, the RTX API which is being used for ray tracing is explained as well Vulkan, the graphics API used.
Based on the results and the insights gained while using the RTX API, it is assessed in regards of its usage scenarios and technical sophistication.
Deformable Snow Rendering
(2019)
Accurate snow simulation is key to capture snow's iconic visuals. Intricate
methods exist that attempt to grasp snow behaviour in a holistic manner. Computational complexity prevents them from reaching real-time performance. This thesis presents three techniques making use of the GPU that focus on the deformation of a snow surface in real-time. The approaches are examined by their ability to scale with an increasing number of deformation actors and their visual portrayal of snow deformation. The findings indicate that the approaches maintain real-time performance well into several hundred individual deformation actors. However, these approaches each have their individual restrictions handicapping the visual results. An experimental approach is to combine the techniques at reduced deformation actor count to benefit from the detailed, merged deformation pattern.
The development of a game engine is considered a non-trivial problem. [3] The architecture of such simulation software must be able to manage large amounts of simulation objects in real-time while dealing with “crosscutting concerns” [3,p. 36] between subsystems. The use of object oriented paradigms to model simulation objects in class hierarchies has been reported as incompatible with constantly changing demands during game development [2, p. 9], resulting in anti-patterns and eventual, messy refactoring.[13]
Alternative architectures using data oriented paradigms revolving around object composition and aggregation have been proposed as a result. [13, 9, 1, 11]
This thesis describes the development of such an architecture with the explicit goals to be simple, inherently compatible with data oriented design, and to make reasoning about performance characteristics possible. Concepts are formally defined to help analyze the problem and evaluate results. A functional implementation of the architecture is presented together with use cases common to simulation software.
Bildsynthese durch Raytracing gewinnt durch Hardware-Unterstützung in Verbraucher-Grafikkarten eine immer größer werdende Relevanz. Der Linespace dient dabei als eine neue, vielversprechende Beschleunigungsstruktur. Durch seine richtungsbasierte Natur ist es sinnvoll, ihn in andere Datenstrukturen zu integrieren. Bisher wurde er in ein Uniform-Grid integriert. Problematisch werden einheitlich große Voxel allerdings bei Szenen mit variierbarem Detailgrad. Diese Arbeit führt den adaptiven Linespace ein, eine Kombination aus Octree und Linespace. Die Struktur wird hinsichtlich ihrer Beschleunigungsfähigkeit untersucht und mit dem bisherigen Grid-Ansatz verglichen. Es wird gezeigt, dass der adaptive Linespace für hohe Grid-Auflösungen besser skaliert, durch eine ineffiziente GPU-Nutzung allerdings keine optimalen Werte erzielt.
A gonioreflectometer is a device to measure the reflection properties of arbitrary materials. In this work, such an apparatus is being built from easily obtainable parts. Therefore three stepper-motors and 809 light-emitting diodes are controlled by an Arduino microcontroller. RGB-images are captured with an industrial camera which serve as refelction data. Furthermore, a control software with several capture programs and a renderer for displaying the measured materials are implemented. These allow capturing and rendering entire bidirectional reflection distribution functions (BRDFs) by which also complex anisotropic material properties can be represented. Although the quality of the results has some artifacts due to shadows of the camera, these artifacts can be largely removed by using special algorithms like inpainting. In addition, the goniorefelctometer is applied to other use cases. One can perform 3D scans, light field capturing and light staging without altering the construction. The quality of these processes also meet the expectations in a positive way. Thus, the gonioreflectometer built in this work can be seen as a widely applicable and economical alternative to other publications.
This thesis deals with the development of an interactive Android card game. As an example, the Hebrew game Yaniv was implemented. Focus is the elaboration of required background components and the corresponding implementation in that application. Required game processes will be screened and a possible solution will be identified.
This thesis presents an approach to optimizing the computation of soft shadows from area lights. The light source is sampled uniformly by traversing shadow rays as packets through an N-tree. This data structure stores an additional line space for every node. A line space stores precomputed information about geometry inside of shafts from one to another side of the node. This visibility information is used to terminate a ray. Additionally the graphics processing unit (short GPU) is used to speed up the computations through parallelism. The scene is rendered with OpenGL and the shadow value is computed on the GPU for each pixel. Evaluating the implementation shows a performance gain of 86% by comparison to the CPU, if using the GPU implementation. Using the line space instead of triangle intersections also increases the performance. The implementation provides good scaling with an increasing amount of triangles and has no visual disadvantages for many rays.