Search

Graphics processing units (GPUs) power today’s fastest supercomputers, are the dominant platform for deep learning, and provide the intelligence for devices ranging from self-driving cars to robots and smart cameras. They also generate compelling photorealistic images at real-time frame rates. GPUs have evolved by adding features to support new use cases. NVIDIA’s GeForce 256, the first GPU, was a dedicated processor for real-time graphics, an application that demands large amounts of floating-point arithmetic for vertex and fragment shading computations and high memory bandwidth. As real-time graphics advanced, GPUs became programmable. The combination of programmability and floating-point performance made GPUs attractive for running scientific applications. Scientists found ways to use early programmable GPUs by casting their calculations as vertex and fragment shaders. GPUs evolved to meet the needs of scientific users by adding hardware for simpler programming, double-precision floating-point arithmetic, and resilience.

This paper describes the usage of shaders to make parallel operations by improving the CPU–GPU communication, using both rendering and compute shaders. When the number of spheres is large, the execution becomes slow and requires a lot of space to store particles. We parallelized the frozen method using an efficient inter-process GPU communication to reduce the operations required. We propose to handle two buffers, one for operations and the other for rendering. While the rendering buffer increases as the number of spheres is required, the operational buffer maintains its size and the number of operations is hold. Experimental results demonstrate that the proposed method shows up 100x throughput improvement over the sequential version. We define a configuration by a 4-tuple as input to the algorithm, and we found a pattern to choose better configurations.

In Hybrid Cloud Gaming (HCG), as long as the graphical assets are available at the client side, rendering can be performed locally. However, if the client is not able to render all the frames in time, this may result in the frame rate to drop under the target value. This paper presents an Asset-based frame-level hybrid graphics/video rate control method for HCG, referred to as AHCG, which aims at improving the Quality of Experience (QoE) of players by tapping into the available processing power at the client side, while keeping a steady frame rate for thin clients and taking full advantage of the user’s tolerable delay. In the proposed client/server model, graphics data are intercepted and streamed in an asset-based approach. This approach handles the rate control issue per asset which is defined to be 3D object model data, textures, and shader programs. Rendering a frame on the client side not only maintains original quality for that frame, but it also reduces bandwidth requirements of the entire service by reusing the same assets for different frames. In the proposed method, if the accumulated rendering delay at the client side violates the tolerable delay set by the user, video streaming is used to compensate for the client device’s lack of processing power. Furthermore, quality fluctuation between graphics and video frames is addressed to provide a seamless experience when switching between graphics and video streaming. Several objective and subjective tests are conducted and the experimental results show a 20-fps increase in frame rate while maintaining a minimum value of 58 fps, with a minimum of 0.25 units improvement in the pooled standard deviation of SSIM values, compared to existing HCGs. Also, the subjective tests suggest an average 5.62 percent improvement in MOS compared to best HCG methods.

Emerging research in computer graphics, inverse problems, and machine learning requires us to differentiate and optimize parametric discontinuities. These discontinuities appear in object boundaries, occlusion, contact, and sudden change over time. In many domains, such as rendering and physics simulation, we differentiate the parameters of models that are expressed as integrals over discontinuous functions. Ignoring the discontinuities during differentiation often has a significant impact on the optimization process. Previous approaches either apply specialized hand-derived solutions, smooth out the discontinuities, or rely on incorrect automatic differentiation. We propose a systematic approach to differentiating integrals with discontinuous integrands, by developing a new differentiable programming language. We introduce integration as a language primitive and account for the Dirac delta contribution from differentiating parametric discontinuities in the integrand. We formally define the language semantics and prove the correctness and closure under the differentiation, allowing the generation of gradients and higher-order derivatives. We also build a system, Teg, implementing these semantics. Our approach is widely applicable to a variety of tasks, including image stylization, fitting shader parameters, trajectory optimization, and optimizing physical designs.

While commodity GPUs provide a continuously growing range of features and sophisticated methods for accelerating compute jobs, many state-of-the-art solutions for point cloud rendering still rely on the provided point primitives (GL_POINTS, POINTLIST, ...) of graphics APIs for image synthesis. In this paper, we present several compute-based point cloud rendering approaches that outperform the hardware pipeline by up to an order of magnitude and achieve significantly better frame times than previous compute-based methods. Beyond basic closest-point rendering, we also introduce a fast, high-quality variant to reduce aliasing. We present and evaluate several variants of our proposed methods with different flavors of optimization, in order to ensure their applicability and achieve optimal performance on a range of platforms and architectures with varying support for novel GPU hardware features. During our experiments, the observed peak performance was reached rendering 796 million points (12.7GB) at rates of 62 to 64 frames per second (50 billion points per second, 802GB/s) on an RTX 3090 without the use of level-of-detail structures. We further introduce an optimized vertex order for point clouds to boost the efficiency of GL_POINTS by a factor of 5x in cases where hardware rendering is compulsory. We compare different orderings and show that Morton sorted buffers are faster for some viewpoints, while shuffled vertex buffers are faster in others. In contrast, combining both approaches by first sorting according to Morton-code and shuffling the resulting sequence in batches of 128 points leads to a vertex buffer layout with high rendering performance and low sensitivity to viewpoint changes., Comment: 13 pages content, 5 pages appendix

Aquest projecte té com a finalitat la creació d’un vídeo confeccionat mitjançant CGI per a un spot publicitari d’automoció, que serveixi a l’alumne com a mostra de les seves habilitats tècniques i creatives quant a generació d’idees, conceptualització i disseny 3D, composició, edició i tot el conjunt de disciplines que engloben la producció audiovisual d’una peça d’aquestes característiques. La intenció final d’aquesta creació és augmentar la visibilitat de l’alumne a les xarxes socials, arribar a més artistes i gent interessada en el sector i conseqüentment despertar l’interès d’empreses del món audiovisual i de possibles futurs clients dins i fora de la plataforma de freelance Fiverr. El desenvolupament d’aquest projecte contempla la integració del material proporcionat per Pere Gras, que en el seu TFG es dedicarà a modelar el vehicle seleccionat a la proposta. Posteriorment, la part que contempla aquest treball, generarà tot el contingut digital necessari per a la renderització, composició i edició d’un vídeo. Aquesta proposta consistirà en la confecció de diferents seqüències on és essencial mantenir una coherència i estètica visual directament relacionada a treballs personals i projectes prèviament elaborats per l’alumne. D’aquesta manera, es busca lligar el TFG amb la trajectòria artística i la galeria de continguts digitals de la marca alguero3d. Els resultats generats en aquest projecte són fruit d’anys d’inspiració i de recopilació de referències visuals, musicals, estètics i artístiques, que han dut a l’alumne a veure que aquest treball és una gran oportunitat per poder plasmar moltes idees i per dur-lo més enllà d’un treball acadèmic i poder treure’n profit en l’àmbit professional.

Fiber tractography is still unique in providing detailed imaging of white matter fiber bundles and connectivity between different brain regions. For finding specific fiber bundles, the most applied technique is tracking fibers from the seeds in a region of interest (ROI) within a diffusion tensor imaging (DTI) volume, or the limitation of tracking results to the ROI. Color-encoded fractional anisotropy (FA) map derived from DTI data, neuroanatomical atlas, and anatomical T1-weighted magnetic resonance imaging (MRI) data have been proposed as complementary data to improve the placement of an ROI. Mental mapping of colors in color-encoded FA map to directions requires a cognitive process. This paper addresses the fusion of shape with color to make the ROI drawing more a perceptual rather than a cognitive task. We propose the rendering of diffusion tensors as superquadric glyphs (shape) superimposed over the standard practice consisting of a color-encoded FA map (color) co-registered to a T1-weighted MRI image (anatomical constraint). A novel object-space algorithm that can efficiently render diffusion tensor glyphs is presented. A strategy for distributing the GPU hardware workload was devised to maximize its occupancy and reduce its stall. Implementations with a compute shader, and a geometry shader are detailed comparatively. We show that our proposal outperforms other rendering solutions. Preliminary quantitative comparisons of the nerve fibers reconstructed by interactive seeding strategies with and without the glyphs suggest that the first approach is more accurate in conveying directional information.

Cross-platform development of medical applications in extended-reality (XR) head-mounted displays (HMDs) often relies on game engines with rendering capabilities currently not standardized in the context of medical visualizations. Many aspects of the visualization pipeline including the characterization of color have yet to be consistently defined across rendering models and platforms. We examined the transfer of color properties from digital objects, through the rendering and image processing steps, to the RGB values sent to the display device. Five rendering pipeline configurations within the Unity engine were evaluated using 24 digital color patches. In the second experiment, the same configurations were evaluated with a tissue slide sample image. Measurements of the change in color associated with each configuration were characterized using the CIE 1976 color difference ( $${\Delta}{\text{E}}$$ ). We found that the distribution of $${\Delta}{\text{E}}$$ for the first experiment ranges from zero, as in the case using an Unlit Shader, to 25.97, as in the case using default configurations. The default Unity configuration consistently returned the highest $${\Delta}{\text{E}}$$ across all 24 colors and also the largest range of color differences. In the second experiment, $${\Delta}{\text{E}}$$ E ranged from 7.49 to 34.18. The Unlit configuration resulted in the highest $${\Delta}{\text{E}}$$ in three of four selected pixels in the tissue sample image. Changes in color image properties associated with texture import settings were then evaluated in a third experiment using the TG18-QC test pattern. Differences in pixel values were found in all nine of the investigated texture import settings. The findings provide an initial characterization of color transfer and a basis for future work on standardization, consistency, and optimization of color in medical XR applications.

In domains that deal with physical space and geometry, programmers need to track the coordinate systems that underpin a computation. We identify a class of geometry bugs that arise from confusing which coordinate system a vector belongs to. These bugs are not ruled out by current languages for vector-oriented computing, are difficult to check for at run time, and can generate subtly incorrect output that can be hard to test for. We introduce a type system and language that prevents geometry bugs by reflecting the coordinate system for each geometric object. A value's geometry type encodes its reference frame, the kind of geometric object (such as a point or a direction), and the coordinate representation (such as Cartesian or spherical coordinates). We show how these types can rule out geometrically incorrect operations, and we show how to use them to automatically generate correct-by-construction code to transform vectors between coordinate systems. We implement a language for graphics programming, Gator, that checks geometry types and compiles to OpenGL's shading language, GLSL. Using case studies, we demonstrate that Gator can raise the level of abstraction for shader programming and prevent common errors without inducing significant annotation overhead or performance cost.

In this article, we first characterize register operand value locality in shader programs of modern gaming applications and observe that there is a high likelihood of one of the register operands of several multiply, logical-and, and similar operations being zero, dynamically. We provide intuition, examples, and a quantitative characterization for how zeros originate dynamically in these programs. Next, we show that this dynamic behavior can be gainfully exploited with a profile-guided code optimization called Zeroploit that transforms targeted code regions into a zero-(value-)specialized fast path and a default slow path. The fast path benefits from zero-specialization in two ways, namely: (a) the backward slice of the other operand of a given multiply or logical-and can be skipped dynamically, provided the only use of that other operand is in the given instruction, and (b) the forward slice of instructions originating at the given instruction can be zero-specialized, potentially triggering further backward slice specializations from operations of that forward slice as well. Such specialization helps the fast path avoid redundant dynamic computations as well as memory fetches, while the fast-slow versioning transform helps preserve functional correctness. With an offline value profiler and manually optimized shader programs, we demonstrate that Zeroploit is able to achieve an average speedup of 35.8% for targeted shader programs, amounting to an average frame-rate speedup of 2.8% across a collection of modern gaming applications on an NVIDIA® GeForce RTX™ 2080 GPU.

Physically-based rendering (PBR) concept is widely use nowadays in 3D rendering works, this concepts interested in the ray of light for describes the interaction of light and materials. Understanding the principles of PBR can be easier to adjust shader parameters to be realistic, react correctly to changes in lighting condition and also giving the same results even in different 3D rendering software. In Shading lighting and rendering (SLR) subject which PBR concepts become important concept instead the ‘old style rendering’ it was found that students are unable to clearly understand concepts of PBR. According to the problem, in this research bringing mobile augmented reality (AR) to be a media for demonstrate PBR concepts for students. The sample were 35 students from Department of Animation and Digital Media, Bansomdejchaopraya Rajabhat University. The results found that students understand the PBR concepts and can adjust the PBR shader paremeters to be realistic assess from students pre-test, post-test scores and students homework. The mobile AR application media were usable for students and suitable to be a learning media in 3D animation assess form students’ response.

General-purpose computing on graphics processing units (GPGPUs) is a programming model that uses graphics cards to perform computations traditionally done by CPU. It began to become practical with the advent of programmable shaders and floating-point support on GPU in around 2001. The spread of GPGPU has been accelerated with introduction of CUDA from NVIDIA in 2006 and later OpenCL in 2009. Nowadays GPGPU is widely deployed in various applications, such as data mining, artificial intelligence, and many scientific computations. GPGPU seemingly promises immense parallelism with massive concurrent cores, and thus much shorter run times. This is true for algorithms that bear intrinsic data and task parallelism, such as image and video processing. For an ATPG system where some algorithms are sequential in nature, the speedup is not easy to achieve in the real world. Flaws in setting up speedup evaluation can lead to false promises. Will GPGPU-based ATPG system become a reality? Or it is just a myth. In this paper, we try to provide an answer by surveying state-of-the-art works and by analyzing practical aspects of today’s industrial designs.

Ambient occlusion ( abbr . AO) plays an important role in realistic rendering applications because AO produces more realistic ambient lighting, which is achieved by calculating the brightness of certain screen parts based on objects’ geometry. However, the baseline computation of AO algorithm is time-consuming, which limits its application for real-time rendering. Currently, most AO algorithms are based on screen space to reduce the computational consumption, which leads to unrealistic results due to the usage of artificial features. To overcome these challenges, in this paper, we first create a well-crafted dataset with the pair of deferred shading buffer data and ground-truth AO shaded images. Then, we design an efficient deep neural network for the screen space AO image generation, based on which we further design a Compute Shader Library to compute the shaded AO images. Our extensive experimental results show that our method achieves competent performance than existing screen space ambient or volumetric ambient based AO methods both in visual quality and efficiency.

With the increasing volume of 3D applications using immersive technologies such as virtual, augmented and mixed reality, it is very interesting to create better ways to integrate unstructured 3D data such as point clouds as a source of data. Indeed, this can lead to an efficient workflow from 3D capture to 3D immersive environment creation without the need to derive 3D model, and lengthy optimization pipelines. In this paper, the main focus is on the direct classification and integration of massive 3D point clouds in a virtual reality (VR) environment. The emphasis is put on leveraging open-source frameworks for an easy replication of the findings. First, we develop a semi-automatic segmentation approach to provide semantic descriptors (mainly classes) to groups of points. We then build an octree data structure leveraged through out-of-core algorithms to load in real time and continuously only the points that are in the VR user's field of view. Then, we provide an open-source solution using Unity with a user interface for VR point cloud interaction and visualisation. Finally, we provide a full semantic VR data integration enhanced through developed shaders for future spatio-semantic queries. We tested our approach on several datasets of which a point cloud composed of 2.3 billion points, representing the heritage site of the castle of Jehay (Belgium). The results underline the efficiency and performance of the solution for visualizing classifieds massive point clouds in virtual environments with more than 100 frame per second.

In this paper, we propose an active real-time capable 3D graph based simultaneous localization and mapping (Graph SLAM) approach, which actively estimates the state of an autonomous spacecraft relative to a simultaneously established map estimate. The graph is constructed in a tightly-coupled fashion, where an Extended Kalman Filter estimates the relative offset between two of its vertices. An additional relative measurement is derived by matching point clouds obtained by a light detection and ranging (LiDAR) system. In order to yield a significant speed-up, scan matching is implemented on the GPU. To reduce the uncertainty of either the state or the map estimate, we present an approach to actively control the system resting on an extended representation of uncertainty in the map. Furthermore, it adapts its behavior depending on the current uncertainty distribution in order to find a dynamic trade-off between exploitation (improve localization performance) and exploration (improve knowledge about the environment). Finally, we present a post-processing approach to discover landing sites in the map estimate without prior knowledge. The evaluation is conducted in a numerical simulation, where the spacecraft explores the real 3D model of Itokawa in its actual dynamic environment. Within that simulation, we use a shader-based GPU implementation for simulating LiDAR measurements. We evaluate the performance of the active SLAM approach and demonstrate that the use of the adaptive approach improves navigation and exploration performance at the same time.

The shader system for a modern game engine comprises much more than just compilation of source code to executable kernels. Shaders must also be exposed to art tools, interfaced with engine code, and specialized for performance. Engines typically address each of these tasks in an ad hoc fashion, without a unifying abstraction. The alternative of developing a more powerful compiler framework is prohibitive for most engines. In this paper, we identify staged metaprogramming as a unifying abstraction and implementation strategy to develop a powerful shader system with modest effort. By using a multi-stage language to perform metaprogramming at compile time, engine-specific code can consume, analyze, transform, and generate shader code that will execute at runtime. Staged metaprogramming reduces the effort required to implement a shader system that provides earlier error detection, avoids repeat declarations of shader parameters, and explores opportunities to improve performance. To demonstrate the value of this approach, we design and implement a shader system, called Selos, built using staged metaprogramming. In our system, shader and application code are written in the same language and can share types and functions. We implement a design space exploration framework for Selos that investigates static versus dynamic composition of shader features, exploring the impact of shader specialization in a deferred renderer. Staged metaprogramming allows Selos to provide compelling features with a simple implementation.

While data on human behavior in COVID-19 rich environments have been captured and publicly released, spatial components of such data are recorded in two-dimensions. Thus, the complete roles of the built and natural environment cannot be readily ascertained. This paper introduces a mechanism for the three-dimensional (3D) visualization of egress behaviors of individuals leaving a COVID-19 exposed healthcare facility in Spring 2020 in New York City. Behavioral data were extracted and projected onto a 3D aerial laser scanning point cloud of the surrounding area rendered with Potree, a readily available open-source Web Graphics Library (WebGL) point cloud viewer. The outcomes were 3D heatmap visualizations of the built environment that indicated the event locations of individuals exhibiting specific characteristics (e.g., men vs. women; public transit users vs. private vehicle users). These visualizations enabled interactive navigation through the space accessible through any modern web browser supporting WebGL. Visualizing egress behavior in this manner may highlight patterns indicative of correlations between the environment, human behavior, and transmissible diseases. Findings using such tools have the potential to identify high-exposure areas and surfaces such as doors, railings, and other physical features. Providing flexible visualization capabilities with 3D spatial context can enable analysts to quickly advise and communicate vital information across a broad range of use cases. This paper presents such an application to extract the public health information necessary to form localized responses to reduce COVID-19 infection and transmission rates in urban areas.

While the cloth component in Unity engine has been used to represent the 3D cloth object for augmented reality (AR) and virtual reality (VR), it has several limitations in term of resolution and performance. The purpose of our research is to develop a stable cloth simulation based on a parallel algorithm. The method of a mass–spring system is applied to real-time cloth simulation with three types of springs. However, cloth simulation using the mass–spring system requires a small integration time-step to use a large stiffness coefficient. Furthermore, constraint enforcement is applied to obtain the stable behavior of the cloth model. To reduce the computational burden of constraint enforcement, the adaptive constraint activation and deactivation (ACAD) technique that includes the mass–spring system and constraint enforcement method is applied to prevent excessive elongation of the cloth. The proposed algorithm utilizes the graphics processing unit (GPU) parallel processing, and implements it in Compute Shader that executes in different pipelines to the rendering pipeline. In this paper, we investigate the performance and compare the behavior of the mass–spring system, constraint enforcement, and ACAD techniques using a GPU-based parallel method.

Кваліфікаційна робота включає пояснювальну записку (50 с., 29 рис., 3 табл., 2 додатки) Метою дипломного проєкту є створення апаратно-прискоренного алгоритму рендерингу 3D-моделей на основі трасування променів. Під час розробки були виконані наступні задачі: • Аналіз існуючих рішень, які дозволяють виконувати рендеринг за допомогою метода трасування променів. • Вибір оптимальних технологій для розробки. • Реалізація спроектованого алгоритму. • Тестування якості рендерингу розробленого алгоритму. • Тестування ефективності алгоритму. • Вибір оптимальних опцій рендерингу. Програма була розроблена з використанням мови С++. Для роботи з графікою була обрана бібліотека GLEW. Для створення головного вікна та зчитування вводу користувача з клавіатури та миші була застосована бібліотека GLFW. Для реалізації графічного інтерфейсу було використано бібліотеку ImGui. Для роботи з математичними обчисленями була інтегрована бібліотека GLM. Qualification work includes an explanatory note (50 pages, 29 figures, 3 tables, 2 appendices) The purpose of the diploma project is to create a hardware-accelerated algorithm for rendering 3D models based on ray tracing. The following tasks were performed during the development: • Analysis of existing solutions that allow rendering using the method of ray tracing. • Selection of optimal technologies for development. • Implementation of the designed algorithm. • Testing the quality of rendering the developed algorithm. • Testing the effectiveness of the algorithm. • Selection of optimal rendering options. The program was developed using the C ++ language. The GLEW library was chosen to work with graphics. The GLFW library was used to create the main window and read user input from the keyboard and mouse. The ImGui library was used to implement the graphical interface. The GLM library was integrated to work with mathematical calculations.

En este polimedia se describe el shader Principled GSDF, su uso en blender y algunos de sus parámetros más importantes, Visualización, reproducción y estudio

Cybersickness is one of the major roadblocks in the widespread adoption of mixed reality devices. Prolonged exposure to these devices, especially virtual reality devices, can cause users to feel discomfort and nausea, spoiling the immersive experience. Incorporating spatial blur in stereoscopic 3D stimuli has shown to reduce cybersickness. In this paper, we develop a technique to incorporate spatial blur in VR systems inspired by the human physiological system. The technique makes use of concepts from foveated imaging and depth-of-field. The developed technique can be applied to any eye tracker equipped VR system as a post-processing step to provide an artifact-free scene. We verify the usefulness of the proposed system by conducting a user study on cybersickness evaluation. We used a custom-built rollercoaster VR environment developed in Unity and an HTC Vive Pro Eye headset to interact with the user. A Simulator Sickness Questionnaire was used to measure the induced sickness while gaze and heart rate data were recorded for quantitative analysis. The experimental analysis highlighted the aptness of our foveated depth-of-field effect in reducing cybersickness in virtual environments by reducing the sickness scores by approximately 66%.

Recently, ray tracing techniques have been highly adopted to produce high quality images and animations. In this paper, we present our design and implementation of a real-time ray-traced rendering engine. We achieved real-time capability for triangle primitives, based on the ray tracing techniques on GPGPU (general-purpose graphics processing unit) compute shaders. To accelerate the ray tracing engine, we used a set of acceleration techniques, including bounding volume hierarchy, its roped representation, joint up-sampling, and bilateral filtering. Our current implementation shows remarkable speed-ups, with acceptable error values. Experimental results shows 2.5–13.6 times acceleration, and less than 3% error values for the 95% confidence range. Our next step will be enhancing bilateral filter behaviors.

Background Precise definition, rendering and manipulation of visual stimuli are essential in neuroscience. Rather than implementing these tasks from scratch, scientists benefit greatly from using reusable software routines from freely available toolboxes. Existing toolboxes work well when the operating system and hardware are painstakingly optimized, but may be less suited to applications that require multi-tasking (for example, closed-loop systems that involve real-time acquisition and processing of signals). New method We introduce a new cross-platform visual stimulus toolbox called Shady ( https://pypi.org/project/Shady )—so called because of its heavy reliance on a shader program to perform parallel pixel processing on a computer's graphics processor. It was designed with an emphasis on performance robustness in multi-tasking applications under unforgiving conditions. For optimal timing performance, the CPU drawing management commands are carried out by a compiled binary engine. For configuring stimuli and controlling their changes over time, Shady provides a programmer's interface in Python, a powerful, accessible and widely-used high-level programming language. Results Our timing benchmark results illustrate that Shady's hybrid compiled/interpreted architecture requires less time to complete drawing operations, exhibits smaller variability in frame-to-frame timing, and hence drops fewer frames, than pure-Python solutions under matched conditions of resource contention. This performance gain comes despite an expansion of functionality (e.g. “noisy-bit” dithering as standard on all pixels and all frames, to enhance effective dynamic range) relative to previous offerings. Conclusions Shady simultaneously advances the functionality and performance available to scientists for rendering visual stimuli and manipulating them in real time.

The traditional 2D panoramic view has the problem of small imaging range, low utilization of original image and serious stretching of the foreground. This paper designs a 3D panoramic viewing system. The real-time performance of the panoramic system requires a large number of parallel image transformations. The general-purpose processor CPU is incapable. This paper designs an embedded GPU solution. The core computing module is based on NXP's i.MX6Q application processor and builds an embedded Linux system. Using V4L2 to capture images to reduce memory and CPU usage, and use OpenGL ES shaders to process image transformations in parallel at high speed. Because it is in a 3D environment, it is impossible to cover all images through a still viewpoint like a 2D look-around. In order to roam the 3D scene, this paper proposes to design a virtual camera system. Using the virtual camera to roam the 3D environment, realize the virtual viewpoint in the 3D scene, traverse each scene in the grid, eliminate the dead angle of the field of view, and finally realize the 3D panoramic view, and verified on the embedded hardware platform, which can clearly roam every image on the surface. And recorded the video of 3-D looping. Experiments show that the 3D panoramic viewing system proposed in this paper has excellent performance and good effects. It has a good real-time performance on the image display, and the response speed is increased by 5%. The main operation is undertaken by the GPU and only takes a small number of CPU resources. The proposed virtual camera system can better realize the 3D panoramic view.

The power consumption models of mobile application processors have emerged as key objects of interest following the tremendous growth in mobile device production given that such consumption is an important factor in the graphics performance of mobile technologies. Conventionally, the performance of the graphics processing units (GPUs) depends critically on texture mapping units, which is why the number of such GPU components and texture fill rates value prominently whenever the GPU performance is evaluated. Our previous work has established a model to predict maximum performance based on unified shaders. By extending the work, this paper developed a practically applicable GPU performance prediction model on the basis of texture mapping performance. The effects of increased texture mapping units on unified shader performance and GPU efficiency were examined, and a performance prediction model based on the number of frames per second (FPS) was constructed. For these purposes, a benchmark related to texture mapping units was formulated and the experiments were conducted to determine utilization factors that are relevant to GPU performance and efficiency. The final stage in model construction involved establishing a relationship between the previously investigated utilization factors and relevant resources that are consumed during graphics processing. The experimental results showed that the proposed prediction model produced an average error rate of 5.77%.

This article examines the development of the audiovisual duo Obi-Wan Codenobi and The Wookie (authors Shawn Lawson and Ryan Ross Smith respectively). The authors trace a now four-year trajectory of technological and artistic development, while highlighting the impact that a more recent physical displacement has had on the creative and collaborative aspects of the project. We seek to reflect upon the creative and technological journey through our collaboration, including Lawson’s development of The Force, an OpenGL shader-based live-coding environment for generative visuals, while illuminating our experiences with, and takeaways from, live coding in practice and performance, EDM in general and algorave culture specifically.

When a ray hits a geometry in the scene, the ray tracing hardware needs some way to determine which shader to call to perform intersection tests or shading calculations. The Shader Binding Table (SBT) provides this information. The SBT is a lookup table that associates each geometry in the scene with a set of shader function handles and parameters for these functions. Each set of function handles and parameters is referred to as a shader record. When a geometry is hit by a ray, a set of parameters specified on both the host and device sides of the application combine to determine which shader record is called. The three GPU ray tracing APIs (DirectX Raytracing, Vulkan KHR Ray Tracing, and OptiX) use the SBT to run user code when tracing rays in the scene. These APIs provide a great deal of flexibility as to how the SBT can be set up and indexed during rendering, providing a number of options to applications. However, this generality makes properly setting up the SBT an especially thorny part of these APIs for new users, as incorrect SBT access often leads to crashes or difficult bugs. Translating knowledge from one API to another can also be difficult due to subtle naming differences between them. This chapter looks at the similarities and differences of each API's SBT to develop a holistic understanding of the programming model. A few common configurations of the scene, SBT, and renderer are also discussed to provide guidance through hands-on examples.

With the continuous development and progress of virtual reality technology in recent years, the application of virtual reality technology in all aspects of real life is no longer limited to the military field, medical, or film production fields, but it gradually appears in front of the public, into the lives of ordinary people. The human-computer interaction method in virtual reality and the presentation effect of the virtual scene are the two most important aspects of the virtual reality experience. How to provide a good human-computer interaction method for virtual reality applications and how to improve the final presentation effect of the virtual reality scene is also becoming an important research direction. This paper takes the virtual fitness club experience system as the application background, analyzes the function and performance requirements of the virtual reality experience system in the virtual reality environment, and proposes the use of Kinect as a video acquisition device to extract the user’s somatosensory operation actions through in-depth information to achieve somatosensory control. This article adopts a real human-computer interaction solution, uses Unity 3D game engine to build a virtual reality scene, defines shaders to improve the rendering effect of the scene, and uses Oculus Rift DK2 to complete an immersive 3D scene demonstration. This process greatly reduces resource consumption; it not only enables users to experience unprecedented immersion as users but also helps people create unprecedented scenes and experiences through virtual imagination. The virtual fitness club experience system probably reduces resource consumption by nearly 70%.

The most fundamental step in any ray tracing program is the ray generation (or "raygen") program that produces the rays themselves. This chapter describes seven essential projections that should be in every toolkit and gives parameterized raygen shader code for each.

Aquest projecte consisteix en la creació, disseny i desenvolupament d'un simulador de cossos celestes amb un cert grau de realisme físic en un entorn immersiu de Realitat Virtual. La simulació inclou la vista en detall d'una galàxia i d'un forat negre sense rotació, a mes d'una vista 360 graus des de la terra en la que es poden seleccionar altres cossos celestes sense entrar-hi en detall. La implementació s'ha fet en Unity i amb l'equipament de realitat virtual HTC Vive. This project is about the creation, design and development of a celestial body simulator with a certain degree of physic realism in a Virtual Reality environment. The simulation includes the detailed view of a galaxy and a non-rotating black hole, plus a 360-degree view from the Earth point of view, where we can look at some other celestial bodies with a lot less detail. The project was implemented with Unity and the HTC Vive VR equipment. Este proyecto consiste en la creación, diseño y desarrollo de un simulador de cuerpos celestes con un cierto grado de realismo físico en un entorno inmersivo de Realidad Virtual. La simulación incluye la vista en detalle de una galaxia y de un agujero negro sin rotación, además de una vista 360 grados desde tierra en la que se pueden seleccionar otros cuerpos celestes sin entrar en detalle. La implementación se ha llevado a cabo con el equipamiento de realidad virtual HTC Vive.

International audience; With the increasing use of high-order methods and high-order meshes, scientific visualization software need to adapt themselves to reliably render the associated meshes and numerical solutions. In this paper, a novel approach, based on OpenGL 4 framework, enables a GPU-based rendering of high-order meshes as well as an almost pixel-exact rendering of high-order solutions. Several aspects of the OpenGL Shading Language and in particular the use of dedicated shaders (GPU programs) allows to answer this visualization challenge. Fragment shaders are used to compute the exact solution for each pixel, made possible by the transfer of degrees of freedom and shape functions to the GPU with textures. Tessellation shaders, combined with geometric error estimates, allow us to render high-order curved meshes by providing an adaptive subdivision of elements on the GPU directly. A convenient way to compute bounds for high-order solutions is described. The interest of using Bézier basis instead of Lagrange functions lies in the existence of fast and robust evaluation of polynomial functions with de Casteljau algorithm. A technique to plot highly nonlinear isolines and wire frames with a desired thickness is derived. It is based on a finite difference scheme performed on GPU. In comparison with standard techniques, we remove the use of any linear interpolation step and the need to generate a priori a fixed subdivided mesh. This reduces the memory footprint, improves the accuracy and the speed of the rendering. Finally, the method is illustrated with various 3D examples.

Ray cones were presented as a fast, approximate way to calculate a suitable mip level index for a particular texture sample in a ray tracing shader setup. Though the original technique was doing all the mathematics needed to compute the final mip level index, in this chapter we reformulate the problem in a different way that relies on existing hardware-supported instructions. This maintains almost the same visual results and leads to more convenient shader code. It also further simplifies and reduces the number of instructions from the original ray cones implementation, though we do not claim this necessarily leads to better performance.

With the recent release of inline ray tracing, it is possible to traverse and register ray hits inside a pixel shader. This allows for convenient implementation of ray tracing into past rasterization algorithms and possibly improve on their limitations. One such rasterization algorithm is image-space refractions, which are used for approximating refractions in real time. Image-space refractions are limited in that they can be highly inaccurate when refracting through concave objects containing more than two surface layers. This chapter combines image-space refractions with inline ray tracing into a hybrid method that overcomes such limitations and generates more realistic refractions. The results are closer to fully ray traced images, but using fewer rays. By replacing some rays with image-space refractions, our hybrid method improves rendering speed as compared to pure ray traced refractions.

This chapter describes how to use intersection and closest-hit shaders to implement real-time visualizations of complex fractals using distance functions. The Mandelbulb and Julia sets are used as examples.

We build acceleration structures for voxel/brick scenes using NVIDIA OptiX and render them in a non-photorealistic style with outlines and one bounce of indirect lighting; this method runs at interactive rates on recent RTX hardware and is implemented entirely in OptiX shaders with no post-processing.

Real-time physically based rendering has long been looked at as the holy grail in Computer Graphics. With the introduction of Nvidia RTX-enabled GPUs family, light transport simulations under real-time constraint started to look like a reality. This paper presents Lift, an educational framework written in C++ that explores the RTX hardware pipeline by using the low-level Vulkan API and its Ray Tracing extension, recently made available by Khronos Group. Furthermore, to accomplish low variance rendered images, we integrated the AI-based denoiser available from the Nvidia ́s OptiX framework. Lift’s development arose primarily in the context of the graduate 3D Programming course taught at Instituto Superior Técnico and Master Theses focused on Real-Time Ray Trac- ing and provides the foundations for laboratory assignments and projects development. The platform aims to make easier students to learn and to develop, by programming the shaders of the RT pipeline, their physically-based ren- dering approaches and to compare them with the built-in progressive unidirectional and bidirectional path tracers. The GUI allows a user to specify camera settings and navigation speed, to select the input scene as well as the rendering method, to define the number of samples per pixel and the path length as well as to denoise the generated image either every frame or just the final frame. Statistics related with the timings, image resolution and total number of accumulated samples are provided too. Such platform will teach that nowadays physically-accurate images can be rendered in real-time under different lighting conditions and how well a denoiser can reconstruct images rendered with just one sample per pixel.