<div>Over the years, the performance demand for graphics applications has been steadily increasing. While upgrading the hardware is one direct solution, the emergence of the new low-level and low-overhead graphics APIs like Vulkan also exposed the possibility of improving rendering performance from the bottom of software implementation.</div><div><br></div><div>Most of the recent years’ middle- to high-end personal computers are equipped with both integrated and discrete GPUs. However, with previous graphics APIs, it is hard to put these two heterogeneous GPUs to work concurrently in the same application without tailored driver support.</div><div><br></div><div>This thesis provides an exploration into the utilization of such heterogeneous GPUs in real-time rendering with the help of Vulkan API. This paper first demonstrates the design and implementation details for the proposed heterogeneous GPUs working model. After that, the paper presents the test of two workload offloading strategies: offloading screen space output workload to the integrated GPU and offloading asynchronous computation workload to the integrated GPU.</div><div><br></div>While this study failed to obtain performance improvement through offloading screen space output workload, it is successful in validating that offloading asynchronous computation workload from the discrete GPU to the integrated GPU can improve the overall system performance. This study proves that it is possible to make use of the integrated and discrete GPUs concurrently in the same application with the help of Vulkan. And offloading asynchronous computation workload from the discrete GPU to the integrated GPU can provide up to 3-4% performance improvement with combinations like UHD Graphics 630 + RTX 2070 Max-Q and HD Graphics 630 + GTX 1050.

Gerenderte Animation von kinematisch gekoppelten Komponenten mit Pro/ENGINEER bzw. Creo zur Produktpräsentation oder auch Montageanleitung

Title: Atmospheric Rendering Author: Mgr. Lukáš Hošek Department: Department of Software and Computer Science Education Supervisor: doc. Dr. Alexander Wilkie, Department of Software and Computer Sci- ence Education Abstract: The sky is an important feature of all outdoor scenes. This thesis explores the topic of skydome models - an approach to getting the sky and atmospheric effects integrated into a renderer. We discuss the physics of atmospheric scattering and de- scribe in detail the construction of a first-principles path tracer atmospheric simulator implementation. The presented path tracer is fully spectral and produces polarization data. Finally, we present two different analytic skydome models. These analytic mod- els are highly practical because they can be integrated even into real-time renderers and provide an excellent combination of fidelity and low computational cost. The first model is a simpler version, providing just the skydome spectral radiance. The second model also provides polarization data, after-sunset skies with an accurate modeling of Earth's shadow, aerial perspective and full sphere data. Keywords: computer graphics, rendering, skylight models, atmospheric modeling

<div>Volumetric cloud generation and rendering algorithms are well-developed to meet the need for a realistic sky performance in animation or games. However, it is challenging to create a stylized or designed animation for volumetric clouds using physics-based generation and simulation methods in real-time.</div><div>The problem raised by the research is the current volumetric cloud animation controlling methods are not art-directable. Making a piece of volumetric cloud move in a specific way can be difficult when using only a physics-based simulation method. The purpose of the study is to implement an animating method for volumetric clouds and with art-directable controllers. Using this method, a designer can easily control the cloud's motion in a reliable way. The program will achieve interactive performance using parallel processing with CUDA. Users will be able to animate the cloud by input a few vectors inside the cloud volume. </div><div>After reviewing the literature related to the real-time simulation method of clouds, texture advection algorithms, fluid simulation, and other processes to achieve the results, the thesis offers a feasible design of the algorithm and experiments to test the hypotheses. The study uses noise textures and fractional Brownian motion (fBm) to generate volumetric clouds and render the clouds by the ray marching technique. The program will render user input vectors and a three-dimension interpolation vector field with OpenGL. By adding or changing input vectors, the user will gain a divergence minimization interpolation field. The cloud volume could be animated by the texture advection technique based on the interpolation vector field in real-time. By inputting several vectors, the user could plausibly animate the volume cloud in an art-directable way.</div>

<p>Real-time global illumination has been a very important topic and is widely used in game industry. Previous offline rendering requires a large amount of time to converge and reduce the noise generated in Monte Carlo method. Thus, it cannot be easily adapted in real-time rendering. Using voxels in the field of global illumination has become a popular approach. While a naïve voxel grid occupies huge memory in video card, a data structure called <i>sparse voxel octree</i> is often implemented in order to reduce memory cost of voxels and achieve efficient ray casting performance in an interactive frame rate. </p> <p>However, rendering of voxels can cause block effects due to the nature of voxel. One solution is to increase the resolution of voxel so that one voxel is smaller than a pixel on screen. But this is usually not feasible because higher resolution results in higher memory consumption. Thus, most of the global illumination methods of SVO (sparse voxel octree) only use it in visibility test and radiance storage, rather than render it directly. Previous research has tried to incorporate SVO in ray tracing, radiosity methods and voxel cone tracing, and all achieved real-time frame rates in complex scenes. However, most of them only focus on static scenes and does not consider dynamic updates of SVO and the influence of it on performance.</p> <p>In this thesis, we will discuss the tradeoff of multiple classic real-time global illumination methods and their implementations using SVO. We will also propose an efficient approach to dynamic update SVO in animated scenes. The deliverables will be implemented in CUDA 11.0 and OpenGL.</p>

The thesis compares two different methods for tracking and moving field lines. The first method included tracing one field line and moving each individual vertex along its own path with path following. The second method was done by tracing new field lines and using linear interpolation to move the field lines. The results show that the first method was incapable of rendering the field lines correctly due to the complexity and non-linearity of Earth's magnetic field. While it was successful at animating the initial motion of the field lines, it was not able to demonstrate the field line's change in topology. The second method was able to solve this issue, correctly visualizing field lines in motion, including changes in topology. However, the solution is limited in that it assumes that the vector field is static, which is not the case. To improve the visualization, a method for tracing and tracking field lines through multiple datasets is required. / <p>Examensarbetet är utfört vid Institutionen för teknik och naturvetenskap (ITN) vid Tekniska fakulteten, Linköpings universitet</p>

With high quality in graphics being demanded a lot in modern video games, realistic clouds are noexception. In many video games, it is common that its rendering implementation is based on acollection of 2D cloud-images rendered into the scene. Through previously published work, it was found that while other techniques can be more appropriate depending on the project, volumetricrendering is the highest state-of-the-art in cloud rendering. The only lacking feature of this techniqueis the performance rate, as it is a very expensive technique. Two general problems regarding theperformance rate is that either the high quality of the clouds is not applicable to real-time rendering orthe quality has been pushed back to the point where the clouds lacked accuracy or realism in shape. There are three basic objectives to the project that were forumulated so that the aim can be completed. The objectives are listed as the following to satisfy the aim: Aim: Create a cloud generator with the volumetric rendering technique Objective 1: Create a 3D engine in OpenGL that generates clouds with volumetric rendering in real-time. Objective 2: Create different scenes that increase computational cost for the computer to render. Objective 3: Arrange tests across different computers running the engine and document the results in terms of performance. The project is created using the programming language C++ and the OpenGL library in Visual Studio. The code comes from a combination of other previously made projects regarding the subject ofrendering clouds in real-time. In order to save time in the project, two projects created by FedericoVaccaro and Sébastien Hillaire were used as references in order to quickly reach a solid foundation for experimenting with the performance rate of volumetric clouds. The resulting cloud implementation contains three of many cloud types and updates in real-time. It is possible to configure the clouds in real-time and have the density, coverage, light absorption and more be altered to generate between the three different cloud types. When changing the settings for the boxcontaining the clouds, as well as coloring and changing the position of the clouds and global light, the clouds updates in real-time. To conclude the project, rendering the clouds at the goal of above 60 FPS if only limiting the resultsdown to high-end computer was somewhat successful. The clouds visually looked realistic enough inthe scene and the efforts for improving the performance rate did not affect its overall quality. The high-end computer was able to render the clouds but the low-end computer was struggling with theclouds on their own

The old methods used for images inpainting of the Depth Image Based Rendering (DIBR) process are inefficient in producing high-quality virtual views from captured data. From the viewpoint of the original image, the generated data’s structure seems less distorted in the virtual view obtained by translation but when then the virtual view involves rotation, gaps and missing spaces become visible in the DIBR generated data. The typical approaches for filling the disocclusion tend to be slow, inefficient, and inaccurate. In this project, a modern technique Generative Adversarial Network (GAN) is used to fill the disocclusion. GAN consists of two or more neural networks that compete against each other and get trained. This study result shows that GAN can inpaint the disocclusion with a consistency of the structure. Additionally, another method (Filling) is used to enhance the quality of GAN and DIBR images. The statistical evaluation of results shows that GAN and filling method enhance the quality of DIBR images.

----- / As processor performance capabilities can only be increased through the useof a multicore architecture, software needs to be developed to utilize the parallelismoffered by the additional cores. Especially game developers need toseize this opportunity to save cycles and decrease the general rendering time.One of the existing advances towards this potential has been the creation ofmultithreaded game engines that take advantage of the additional processingunits. In such engines, different branches of the game loop are parallelized.However, the specifics of the parallel design patterns used are not outlined.Neither are any ideas of how to combine these patterns proposed. Thesemissing factors are addressed in this article, to provide a guideline for whento use which one of two parallel design patterns; fork-join and pipeline parallelism.Through a collection of data and a comparison using the metricsspeedup and efficiency, conclusions were derived that shed light on the waysin which a typical part of a game loop most efficiently can be organized forparallel execution through the use of different parallel design patterns. Thepipeline and fork-join patterns were applied respectively in a variety of testcases for two branches of a game loop: a BOIDS system and an animationsystem.

Large-scale particle data sets, such as those computed in molecular dynamics (MD) simulations, are crucial to investigating important processes in physics and thermodynamics. The simulated atoms are usually visualized as hard spheres with Phong shading, where individual particles can be perceived well in close-up views. However, for large-scale simulations with millions of particles, the visualization of large fields-of-view usually suffers from strong aliasing artifacts, because the mismatch between data size and output resolution leads to severe under-sampling of the geometry. In this dissertation, we present novel visualization methods for large-scale particle data that address aliasing while enabling interactive high-quality rendering by sampling only the visible particles of a data set from a given view. The first contribution of this thesis is the novel concept of screen-space normal distribution functions (S-NDFs) for particle data. S-NDFs represent the distribution of surface normals that map to a given pixel in screen space, which enables high-quality re-lighting without re-rendering particles. In order to facilitate interactive zooming, we cache S-NDFs in a screen-space mipmap (S-MIP). Together, these two concepts enable interactive, scaleconsistent re-lighting and shading changes, as well as zooming, without having to re-sample the particle data. Our second contribution is a novel architecture for probabilistic culling of large particle data. Wedecouplethesuper-samplingforrenderingfromthedeterminationofsub-pixelparticle visibility, and perform culling probabilistically in multiple stages, while incrementally tracking confidence in the visibility data gathered so far to avoid wrong visibility decisions with high probability. Our architecture determines particle visibility with high accuracy, while only sampling a small part of the whole data set. The particles that are not occluded are then super-sampled for high rendering quality, at a fraction of the cost of sampling the entire data set.