Shading Language Research Articles

RenderKernel: High-level programming for real-time rendering systems

Real-time rendering applications leverage heterogeneous computing to optimize performance. However, software development across multiple devices presents challenges, including data layout inconsistencies, synchronization issues, resource management complexities, and architectural disparities. Additionally, the creation of such systems requires verbose and unsafe programming models. Recent developments in domain-specific and unified shading languages aim to mitigate these issues. Yet, current programming models primarily address data layout consistency, neglecting other persistent challenges.In this paper, we introduce RenderKernel, a programming model designed to simplify the development of real-time rendering systems. Recognizing the need for a high-level approach, RenderKernel addresses the specific challenges of real-time rendering, enabling development on heterogeneous systems as if they were homogeneous. This model allows for early detection and prevention of errors due to system heterogeneity at compile-time. Furthermore, RenderKernel enables the use of common programming patterns from homogeneous environments, freeing developers from the complexities of underlying heterogeneous systems. Developers can focus on coding unique application features, thereby enhancing productivity and reducing the cognitive load associated with real-time rendering system development.

Understanding 3D seismic data visualization with C++, OpenGL and GLSL

Seismic data visualization in 3D space is a valuable interpretation tool. Several open-source visualization tools are available. However, little explanation is provided about the inner working of visualization process. The current work discusses a “hello world” equivalent source code for 3D seismic data visualization using Graphical Processing Units (GPUs) with OpenGL and the OpenGL Shading Language (GLSL) programming languages. Rendering is the core process generating 2D image that we see on the screen from the 3D data structures being visualized. Texture mapping-based rendering commonly applied to seismic data starts with creating an OpenGL object called texture. The texture is then mapped over a rectangular object to display a seismic line. The work presented here is performed using OpenGL, GLSL, C++ and Qt toolkit. Here Qt provides the application GUI framework, C++ is used for data I/O, filtering, and sorting, and OpenGL and GLSL are used for 3D rendering. This paper describes the data flow through the application, and two implementations of vertex and fragment GLSL shaders. Visualization is critical for seismic data processing and interpretation. The low-level details of the process presented here will hopefully help readers in obtaining better understanding of the visualization concept and inner working principle and facilitate further development.

COMPUTER PRODUCTION OF FACIAL EPITHETS

BACKGROUND: The issue of rehabilitation of patients with facial defects is extremely acute. In addition to the annual increase in the number of patients with cancer of the maxillofacial region, in recent years the number of people with shrapnel and gunshot wounds to the face has increased as a result of local wars and conflicts. Traditional methods of orthopedic rehabilitation of patients and the manufacture of facial epitheses are quite a complex and lengthy process. In the postoperative period, there is a sharp decrease in the quality of life of this category of patients, a violation of the basic body functions necessary for vital activity and poor social adaptation. Direct prosthetics of the face in the postoperative period was impossible due to the lack of necessary digital modeling technologies and structural materials for additive or subtractive production methods. The production of temporary or permanent facial epitheses using digital technologies is an urgent task that can improve the social and functional living conditions of patients. AIMS: Development of 3D modeling technology for additive manufacturing of facial epithets. METHODS: To achieve this goal, the first task was to develop specialized three-dimensional software for modeling defects in the facial area. The functionality of the program should allow you to virtually simulate the missing parts of the face (ear, eye, nose, orbit). To create a digital platform together with IT specialists, it was decided to use the following programming languages: C++ - Writing the software core, writing UI/UX interaction modules, interacting with the Windows operating system; C# - Complex assembly of the entire project; Python is an automated assembly of virtual library modules; OpenGL HSLS is a shader language for graphical visualization of objects; C is the creation of functions for interacting with shaders that require high speed. RESULTS: A specialized computer program has been developed for 3D modeling of prostheses in patients with defects in the middle zone of the face using combined facial scanning and computed tomography data (Computer program. Apresyan S.V., Stepanov A.G. "A program for 3D modeling of facial epitheses. Registration number (certificate) 2023663490, Registration date: 07/04/2023). Instead of obtaining analog impressions with plaster or silicone material, the developed technology uses a special 3D facial scanner, which greatly eases the suffering of patients. A virtual three-dimensional database of ears, noses, orbits, and zygomatic bones of patients of various ages and gender is integrated into the developed program. This allows the specialist to select the most adaptive part of the face to make up for the defect. Built-in modeling tools allow you to personalize a 3D model of a part of the face, based on the structural features of the maxillofacial region of a person. The finished three-dimensional model of a part of the face can be exported in various formats CONCLUSIONS: The developed 3D program for modeling defects allows to avoid invasive prosthetics approaches, to coordinate the shape of future structures with the patient. The built-in library of structures with a database provides remote manufacturing of the prosthesis without the presence of the patient, in case of a need to replace it. Among the undeniable advantages of the technology, it is important to include the fact that prostheses can be made directly on the day of surgery to remove part of the face, completely restoring lost functions and providing rapid social adaptation.

Boundary SPH for Robust Particle–Mesh Interaction in Three Dimensions

This paper introduces an algorithm to tackle the boundary condition (BC) problem, which has long persisted in the numerical and computational treatment of smoothed particle hydrodynamics (SPH). Central to the BC problem is a need for an effective method to reconcile a numerical representation of particles with 2D or 3D geometry. We describe and evaluate an algorithmic solution—boundary SPH (BSPH)—drawn from a novel twist on the mesh-based boundary method, allowing SPH particles to interact (directly and implicitly) with either convex or concave 3D meshes. The method draws inspiration from existing works in graphics, particularly discrete signed distance fields, to determine whether particles are intersecting or submerged with mesh triangles. We evaluate the efficacy of BSPH through application to several simulation environments of varying mesh complexity, showing practical real-time implementation in Unity3D and its high-level shader language (HLSL), which we test in the parallelization of particle operations. To examine robustness, we portray slip and no-slip conditions in simulation, and we separately evaluate convex and concave meshes. To demonstrate empirical utility, we show pressure gradients as measured in simulated still water tank implementations of hydrodynamics. Our results identify that BSPH, despite producing irregular pressure values among particles close to the boundary manifolds of the meshes, successfully prevents particles from intersecting or submerging into the boundary manifold. Average FPS calculations for each simulation scenario show that the mesh boundary method can still be used effectively with simple simulation scenarios. We additionally point the reader to future works that could investigate the effect of simulation parameters and scene complexity on simulation performance, resolve abnormal pressure values along the mesh boundary, and test the method’s robustness on a wider variety of simulation environments.

VoxAR: Adaptive Visualization of Volume Rendered Objects in Optical See-Through Augmented Reality.

We present VoxAR, a method to facilitate an effective visualization of volume-rendered objects in optical see-through head-mounted displays (OST-HMDs). The potential of augmented reality (AR) to integrate digital information into the physical world provides new opportunities for visualizing and interpreting scientific data. However, a limitation of OST-HMD technology is that rendered pixels of a virtual object can interfere with the colors of the real-world, making it challenging to perceive the augmented virtual information accurately. We address this challenge in a two-step approach. First, VoxAR determines an appropriate placement of the volume-rendered object in the real-world scene by evaluating a set of spatial and environmental objectives, managed as user-selected preferences and pre-defined constraints. We achieve a real-time solution by implementing the objectives using a GPU shader language. Next, VoxAR adjusts the colors of the input transfer function (TF) based on the real-world placement region. Specifically, we introduce a novel optimization method that adjusts the TF colors such that the resulting volume-rendered pixels are discernible against the background and the TF maintains the perceptual mapping between the colors and data intensity values. Finally, we present an assessment of our approach through objective evaluations and subjective user studies.

SLANG.D: Fast, Modular and Differentiable Shader Programming

We introduce SLANG.D, an extension to the Slang shading language that incorporates first-class automatic differentiation support. The new shading language allows us to transform a Direct3D-based path tracer to be fully differentiable with minor modifications to existing code. SLANG.D enables a shared ecosystem between machine learning frameworks and pre-existing graphics hardware API-based rendering systems, promoting the interchange of components and ideas across these two domains. Our contributions include a differentiable type system designed to ensure type safety and semantic clarity in codebases that blend differentiable and non-differentiable code, language primitives that automatically generate both forward and reverse gradient propagation methods, and a compiler architecture that generates efficient derivative propagation shader code for graphics pipelines. Our compiler supports differentiating code that involves arbitrary control-flow, dynamic dispatch, generics and higher-order differentiation, while providing developers flexible control of checkpointing and gradient aggregation strategies for best performance. Our system allows us to differentiate an existing real-time path tracer, Falcor, with minimal change to its shader code. We show that the compiler-generated derivative kernels perform as efficiently as handwritten ones. In several benchmarks, the SLANG.D code achieves significant speedup when compared to prior automatic differentiation systems.

Program Reconditioning: Avoiding Undefined Behaviour When Finding and Reducing Compiler Bugs

We introduce program reconditioning, a method for allowing program generation and differential testing to be used to find miscompilation bugs, and test-case reduction to be used to simplify bug-triggering programs, even when (a) the programming language of interest features undefined behaviour (UB) and (b) no tools exist to detect and avoid this UB. We present two program generation tools based on our reconditioning idea: GLSLsmith for the OpenGL Shading Language (GLSL), a widely-used language for graphics programming, and WGSLsmith for the WebGPU Shading Language (WGSL), a new language for web-based graphics rendering. GLSL features many UBs, but unlike for languages such as C and C++ no tools exist to detect them automatically. While the WGSL language specification features very limited UB, early WGSL implementations do exhibit UB, for reasons of initial implementation simplicity, making it challenging to test them to quickly detect and eliminate unrelated miscompilation bugs. Thanks to reconditioning, we show that GLSLsmith and WGSLsmith allow differential testing and test-case reduction to be applied to compilers for GLSL and WGSL for the first time, despite the unavailability of UB detection techniques for these languages. Through a large testing campaign, we have found 24 and 33 bugs in GLSL and WGSL compilers, respectively. We present experiments showing that when reconditioning is disabled, compiler testing leads to a high rate of test programs that appear to trigger miscompilation bugs, but actually just feature UB. We also present a novel approach to managing floating-point roundoff error using reconditioning, implemented for both GLSL and WGSL.

Seamless GPU Acceleration for C++-Based Physics with the Metal Shading Language on Apple’s M Series Unified Chips

Abstract The M series of chips produced by Apple has proven a capable and power-efficient alternative to mainstream Intel and AMD ×86 processors for everyday tasks. In addition, the unified design integrating the central processing and graphics processing unit (GPU), have allowed these M series chips to excel at many tasks with heavy graphical requirements without the need for a discrete GPU) in some cases even outperforming discrete GPUs. In this work, we show how the M series chips can be leveraged using the Metal Shading Language (MSL) to accelerate typical array operations in C++. More important, we show how the usage of MSL avoids the typical complexity of compute unified device architecture (CUDA) or OpenACC memory management by allowing the central processing unit (CPU) and GPU to work in unified memory. We demonstrate how performant the M series chips are on standard 1D and 2D array operations such as array addition, single-precision A·X plus Y, and finite-difference stencils, with respect to serial and OpenMP-accelerated CPU code. The reduced complexity of implementing MSL also allows us to accelerate an existing elastic wave equation solver (originally based on OpenMP-accelerated C++) while retaining all CPU and OpenMP functionality without modification. The resulting performance gain of simulating the wave equation is near an order of magnitude for large domain sizes. This gain attained from using MSL is similar to other GPU-accelerated wave-propagation codes with respect to their CPU variants but does not come at much increased programming complexity that prohibits the typical scientific programmer to leverage these accelerators. This result shows how unified processing units can be a valuable tool to seismologists and computational scientists in general, lowering the bar to writing performant codes that leverage modern GPUs.

Инженерный расчет разноглубинного рыболовного трала

This paper presents a method for calculating the power and geometric properties of a midwater fishing trawl, which is a complicated engineering structure made up of tied flexible (threads, ropes, flap) and rigid (rigging, trawl boards) elements. A computational model, the functional relations for internal forces and geometric characteristics of the trawl, and a calculation procedure based on the finite element method are proposed. The computational algorithm is implemented on a graphics processing unit of a personal computer with the use of DirectCompute, Shader Model 5, and high-level shader language. The performance and resource intensity of the algorithm applied in the computer-aided design system for industrial fishing gear are assessed in terms of the number of trawl nodes and computing equipment. A comparative analysis of the calculated and experimentally obtained characteristics of the trawl physical model is presented. According to the results, the computational error in geometric characteristics and internal forces is less than 3 and 5%, respectively.

LuisaRender

The advancements in hardware have drawn more attention than ever to high-quality offline rendering with modern stream processors, both in the industry and in research fields. However, the graphics APIs are fragmented and existing shading languages lack high-level constructs such as polymorphism, which adds complexity to developing and maintaining cross-platform high-performance renderers. We present LuisaRender 1 , a high-performance rendering framework for modern stream-architecture hardware. Our main contribution is an expressive C++-embedded DSL for kernel programming with JIT code generation and compilation. We also implement a unified runtime layer with resource wrappers and an optimized Monte Carlo renderer. Experiments on test scenes show that LuisaRender achieves much higher performance than existing research renderers on modern graphics hardware, e.g., 5--11× faster than PBRT-v4 and 4--16× faster than Mitsuba 3.

Computer 3D Scene Simulation of Ecological Landscape Layout Planning

There are some problems in traditional 3D landscape construction and virtual display, such as inflexible landscape spatial organization and limitations of virtual garden simulation in reality. Virtual reality, virtual plants and geographic information systems, and other technologies are used. Based on parameterized method in constructing 3D landscape scene, the main elements of the landscape were, respectively, constructed and rendered in 3D model, and a complete 3D landscape scene construction model was formed. OpenGL shader language was used for rendering, improved NSGA-II algorithm was used with the help of bionic logic of the genetic evolution process to achieve landscape land allocation optimization. The experimental result shows: through 3D scene view clipping hierarchical detail model and other techniques, the frame rate of 3D landscape vegetation scene drawing was improved. The interactive 3D scene browsing is realized, and the six-degree-of-freedom omni-directional display of the whole landscape is provided.

Parallel Cloth Simulation Using OpenGL Shading Language

The primary goal of cloth simulation is to express object behavior in a realistic manner and achieve real-time performance by following the fundamental concept of physic. In general, the mass–spring system is applied to real-time cloth simulation with three types of springs. However, hard spring cloth simulation using the mass–spring system requires a small integration time-step in order to use a large stiffness coefficient. Furthermore, to obtain stable behavior, constraint enforcement is used instead of maintenance of the force of each spring. Constraint force computation involves a large sparse linear solving operation. Due to the large computation, we implement a cloth simulation using adaptive constraint activation and deactivation techniques that involve the mass–spring system and constraint enforcement method to prevent excessive elongation of cloth. At the same time, when the length of the spring is stretched or compressed over a defined threshold, adaptive constraint activation and deactivation method deactivates the spring and generate the implicit constraint. Traditional method that uses a serial process of the Central Processing Unit (CPU) to solve the system in every frame cannot handle the complex structure of clothmodel in real-time. Our simulation utilizes the Graphic Processing Unit (GPU) parallel processing with compute shader in OpenGL Shading Language (GLSL) to solve the system effectively. In this paper, we design and implement parallel method for cloth simulation, and experiment on the performance and behavior comparison of the mass–spring system, constraint enforcement, and adaptive constraint activation and deactivation techniques the using GPU-based parallel method.

OpenCL and OpenGL Implementation of Simultaneous Localization and Mapping Algorithm using High-End GPU

Simultaneous Localization And Mapping (SLAM) algorithms are being used in many robotic applications and autonomous navigation systems. The FastSLAM2.0 addresses an issue of the SLAM problem and allows a robot to navigate in an unknown environment. Several works have presented many algorithmic optimizations to reduce the computational complexity of such algorithm. In this paper, a GPGPU (general-purpose computing on graphics processing units) is exploited to achieve a parallel implementation of the FastSLAM2.0. The GPGPU acceleration is done using two different implementations for parallel programming. The first implementation used OpenGL shading language which is based on the characteristics of graphics hardwares. The second implementation used OpenCL which allows hardware acceleration across heterogeneous architectures. We also explored the impact of the two approaches on the the resulting GPGPU implementation. A comparison related to processing-time and localization accuracy is made using a real indoor dataset. Our results show a significant speedup of the GPGPU implementation over a Quad-Core CPU. We show also that, by adopting the same optimization methodology using the two approachs, the OpenCL implementation is faster and suitable for GPGPU accelerated SLAM algorithms.

Real-time Volume Preserving Constraints for Volumetric Model on GPU

This paper presents a parallel method for simulating real-time 3D deformable objects using the volume preservation mass-spring system method on tetrahedron meshes. In general, the conventional mass-spring system is manipulated as a force-driven method because it is fast, simple to implement, and the parameters can be controlled. However, the springs in traditional mass-spring system can be excessively elongated which cause severe stability and robustness issues that lead to shape restoring, simulation blow-up, and huge volume loss of the deformable object. In addition, traditional method that uses a serial process of the central processing unit (CPU) to solve the system in every frame cannot handle the complex structure of deformable object in real-time. Therefore, the first order implicit constraint enforcement for a mass-spring model is utilized to achieve accurate visual realism of deformable objects with tough constraint error. In this paper, we applied the distance constraint and volume conservation constraints for each tetrahedron element to improve the stability of deformable object simulation using the mass-spring system and behave the same as its real-world counterparts. To reduce the computational complexity while ensuring stable simulation, we applied a method that utilizes OpenGL compute shader, a part of OpenGL Shading Language (GLSL) that executes on the graphic processing unit (GPU) to solve the numerical problems effectively. We applied the proposed methods to experimental volumetric models, and volume percentages of all objects are compared. The average volume percentages of all models during the simulation using the mass-spring system, distance constraint, and the volume constraint method were 68.21%, 89.64%, and 98.70%, respectively. The proposed approaches are successfully applied to improve the stability of mass-spring system and the performance comparison from our experimental tests also shows that the GPU-based method is faster than CPU-based implementation for all cases.

Dense monocular Simultaneous Localization and Mapping by direct surfel optimization

This work presents a novel approach for monocular dense Simultaneous Localization and Mapping. The surface to be estimated is represented as a piecewise planar surface, defined as a group of surfels each having as parameters its position and normal. These parameters are then directly estimated from the raw camera pixels measurements, by a Gauss-Newton iterative process. The representation of the surface as a group of surfels has several advantages. It allows the recovery of robust and accurate pixel depths, without the need to use a computationally demanding depth regularization schema. This has the further advantage of avoiding the use of a physically unlikely surface smoothness prior. New surfels can be correctly initialized from the information present in nearby surfels, avoiding also the need to use an expensive initialization routine commonly needed in Gauss-Newton methods. The method was written in the GLSL shading language, allowing the usage of GPU thus achieving real-time. The method was tested against several datasets, showing both its depth and normal estimation correctness, and its scene reconstruction quality. The results presented here showcase the usefulness of the more physically grounded piecewise planar scene depth prior, instead of the more commonly pixel depth independence and smoothness prior.

Distributed simulation and visualization of the ALICE detector magnetic field

The ALICE detector at CERN uses properties of the magnetic field acting on charged particles as part of the particle tracking and identification system – via measuring the strength of bending of charged particles in a magnetic field supplied by electromagnets. During the calibration of the detector the magnetic field was measured by the scientific team. The measurement points were then fitted using Chebyshev polynomials to create a field model. That model is used extensively in particle trajectory reconstruction, but for maximum compatibility it is handled by CPU-only software. We propose multiple approaches to the implementation of the model in a shader language, which allows it to run in a graphical GPU environment. This makes the model run more efficiently, as well as enables it to be used for field visualisation, which was not previously done for ALICE.

The Design of RenderMan.

The design of RenderMan was driven by the requirements of rendering for the movies. The rendered images could have no digital artifacts and they had to be able to be composited seamlessly with live-action footage. This article recounts the development of RenderMan. It tells the story of the invention of the fundamental architecture and algorithms, the application of good engineering and design principles, RenderMan's use in feature films, the long-term influence of the RenderMan Shading Language on real-time graphics and high-performance computing, and, where the name came from.

Geometry types for graphics programming

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.

Automatic sound synthesis using the fly algorithm

Our study is demonstrated a new type of evolutionary sound synthesis method. This work based on the fly algorithm, a cooperative co-evolution algorithm; it is derived from the Parisian evolution approach. The algorithm has relatively amended the position of individuals (the Flies) represented by 3-D points. The fly algorithm has successfully investigated in different applications, starting with a real-time stereo vision for robotics. Also, the algorithm shows promising results in tomography to reconstruct 3-D images. The final application of the fly algorithm was generating artistic images, such as digital mosaics. In all these applications, the flies’representation started for simple, 3-D points, to complex one, the structure of 9-elements. Our method follows evolutionary digital art with the fly algorithm in representing the pattern of the flies. They represented in a way of having their structure. This structure includes position, colour, rotation angle, and size. Our algorithm has the benefit of graphics processing units (GPUs) to generate the sound waveform using the modern OpenGL shading language.

On pixel-exact rendering for high-order mesh and solution

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.