Search

In this paper, we introduce an interactive coastal wave simulation and visualization software, called Celeris. Celeris is an open source software which needs minimum preparation to run on a Windows machine. The software solves the extended Boussinesq equations using a hybrid finite volume–finite difference method and supports moving shoreline boundaries. The simulation and visualization are performed on the GPU using Direct3D libraries, which enables the software to run faster than real-time. Celeris provides a first-of-its-kind interactive modeling platform for coastal wave applications and it supports simultaneous visualization with both photorealistic and colormapped rendering capabilities. We validate our software through comparison with three standard benchmarks for non-breaking and breaking waves. Program summary Program title: Celeris Program Files doi: http://dx.doi.org/10.17632/5djwvf5x5k.1 Licensing provisions : GNU General Public License 3 (GPL) Programming language : C++, HLSL Nature of problem : Boussinesq-type models provide the research-level accuracy needed for modeling wave propagation in coastal zones. However the current models, both commercial and open source, do not provide means for real-time computation , nor provide model interactivity and concurrent visualization. In order to achieve a real-time simulation speed in current parallelized models, dozens to hundreds of CPU cores are needed. Celeris is an interactive software which provides faster than real-time simulation and visualization speed on an average user laptop. The novelty of this software is its interactive environment, which allows the user to modify the model and field parameters as the model is running, and to see the effect of these changes immediately. Solution method : A hybrid finite volume-finite difference scheme is used to solve the extended Boussinesq equations. The solver is parallelized using shader programming with Direct3D libraries. Visualization is also performed with the same libraries.

This paper presents a novel method to generate contour lines from grid DEM data based on the programmable GPU pipeline. The previous contouring approaches often use CPU to construct a finite element mesh from the raw DEM data, and then extract contour segments from the elements. They also need a tracing or sorting strategy to generate the final continuous contours. These approaches can be heavily CPU-costing and time-consuming. Meanwhile the generated contours would be unsmooth if the raw data is sparsely distributed. Unlike the CPU approaches, we employ the GPU's vertex shader to generate a triangular mesh with arbitrary user-defined density, in which the height of each vertex is calculated through a third-order Cardinal spline function. Then in the same frame, segments are extracted from the triangles by the geometry shader, and translated to the CPU-side with an internal order in the GPU's transform feedback stage. Finally we propose a “Grid Sorting” algorithm to achieve the continuous contour lines by travelling the segments only once. Our method makes use of multiple stages of GPU pipeline for computation, which can generate smooth contour lines, and is significantly faster than the previous CPU approaches. The algorithm can be easily implemented with OpenGL 3.3 API or higher on consumer-level PCs.

Modern game engines seek to balance the conflicting goals of high rendering performance and productive software development. To improve CPU performance, the most recent generation of real-time graphics APIs provide new primitives for performing efficient batch updates to shader parameters. However, modern game engines featuring large shader codebases have struggled to take advantage of these benefits. The problem is that even though shader parameters can be organized into efficient modules bound to the pipeline at various frequencies, modern shading languages lack corresponding primitives to organize shader logic (requiring these parameters) into modules as well. The result is that complex shaders are typically compiled to use a monolithic block of parameters, defeating the design, and performance benefits, of the new parameter binding API. In this paper we propose to resolve this mismatch by introducing shader components , a first-class unit of modularity in a shader program that encapsulates a unit of shader logic and the parameters that must be bound when that logic is in use. We show that by building sophisticated shaders out of components, we can retain essential aspects of performance (static specialization of the shader logic in use and efficient update of parameters at component granularity) while maintaining the modular shader code structure that is desirable in today's high-end game engines.

This paper presents a new distributed method for virtual Earth terrain tessellation on a graphics processing unit (GPU) for space simulator complexes. The method operates in real time in multi-object virtual scenes comprising up to two million polygons. A polygonal terrain model is constructed using triangle patches of different levels of detail on graphics cards with programmable tessellation. Patches of the same level of detail are calculated entirely on the GPU, in parallel and independently, by using a developed shader program written in the OpenGL Shading Language (GLSL). This paper also describes a patch extraction algorithm for visible Earth surface rendering and an algorithm for correcting the barycentric coordinates of tessellated patch vertices that allows triangles in the terrain model to be docked without geometric discontinuities. Based on the distributed methods and algorithms developed, a program complex for virtual Earth surface visualization was created and successfully tested. The proposed solution can also be employed in virtual environment systems, virtual labs, educational geo-applications, etc.

Web-based visualization libraries are in wide use, but performance bottlenecks occur when rendering, and especially animating, a large number of graphical marks. While GPU-based rendering can drastically improve performance, that paradigm has a steep learning curve, usually requiring expertise in the computer graphics pipeline and shader programming. In addition, the recent growth of virtual and augmented reality poses a challenge for supporting multiple display environments beyond regular canvases, such as a Head Mounted Display (HMD) and Cave Automatic Virtual Environment (CAVE). In this paper, we introduce a new web-based visualization library called Stardust, which provides a familiar API while leveraging GPU’s processing power. Stardust also enables developers to create both 2D and 3D visualizations for diverse display environments using a uniform API. To demonstrate Stardust’s expressiveness and portability, we present five example visualizations and a coding playground for four display environments. We also evaluate its performance by comparing it against the standard HTML5 Canvas, D3, and Vega.

Isogeometric Analysis (IGA) introduced in 2005 by Hughes et al. (2005) [1] exploits one mathematical basis representation for computer aided design (CAD), geometry and analysis during the entire engineering process. In this paper we extend this concept also for visualization. The presented post-processing and visualization techniques thereby strengthen the relation between geometry, analysis and visualization. This is achieved by facilitating the same mathematical function space used for geometry and analysis also for post-processing and visualization purposes. During non-linear analysis derivatives are incrementally computed and stored with different basis function representations. We introduce and investigate projection methods to be able to use the same function space for both displacements and stresses without loss of accuracy. To obtain a common representation for structured and unstructured meshes like hierarchical spline, locally refined B-spline (LR B-spline) and T-spline techniques we exploit Bézier decomposition in a post-processing step resulting in a Bézier element representation and constitute it as generalized representation. The typically used unrelated (fictitious) finite element mesh representation for visualization purposes are easily replaced without changing the underlying geometry as well as the algorithmic data structure. One further benefit of the used Bézier decomposition lies in the fact that it facilitates a natural parallel implementation on Graphics Processor Units (GPUs) exploiting shader programming. In this paper we have developed and investigated an accurate, efficient and practical post-processing pipeline for visualization of isogeometric analysis results. The proposed IGA visualization pipeline consists of three steps: (1) Projection, (2) Bézier decomposition and (3) Pixel-accurate rendering. We have tested four different projection methods. A description on how to perform Bézier decomposition of LR B-splines are given (whereas for hierarchical and T-splines this has been done before). Furthermore, the use of GPU shader programming to enable efficient and pixel-accurate visualization is detailed. The performance of the four different projection techniques has been tested on manufactured problems as well as on realistic benchmark problems. Furthermore, the IGA visualization pipeline has been demonstrated on a number of real-world applications. © 2016 The Author(s). Published by Elsevier B.V. This is an open access article under the CC BY-NC-ND license (http:// creativecommons.org/licenses/by-nc-nd/4.0/).

OpenGL has been the standard API for teaching computer graphics. There are now multiple versions of the standard, including WebGL. which is the JavaScript implementation of OpenGL ES 2.0. The author argues that WebGL is the version best suited for an introductory course in computer graphics.

We propose a compute shader based point cloud rasterizer with up to 10 times higher performance than classic point-based rendering with the GL_POINT primitive. In addition to that, our rasterizer offers 5 byte depth-buffer precision with uniform or customizable distribution, and we show that it is possible to implement a high-quality splatting method that blends together overlapping fragments while still maintaining higher frame-rates than the traditional approach.

This visualization of a scientific simulation shows the giant impact that formed the Moon. 4.5 billion years ago, the early Earth collided with a Mars-sized rock called "Theia", resulting in a spinning disk of lava and vaporized rock hotter than the surface of the sun. In this sequence, we see the first 24 hours of the 100-year process of our Moon's formation. This 1.1 million-point smoothed particle hydrodynamics model was 32 gigabytes and featured 492 data snapshots, which were interpolated by a factor of ten to play back smoothly on a 4K fulldome cinema screen. Using Houdini, special sprites used instanced spheres with a procedural falloff shader to face the hemispherical camera lens, to prevent intersection artifacts as particles evolved from solid to liquid to gas, and to avoid camera intersection. Other particles were surfaced as solids and liquids, and dynamic geometry lights allowed the emissive surfaces to illuminate diffuse surfaces. Processing and rendering a million translucent sprites was prohibitive on the AVL's 30-machine cluster, so the team used their custom Blurend pipeline to process imagery on the Blue Waters supercomputer. The shot was completed in Nuke, adding a Milky Way background and grading the mixing planet-forming material.

The availability of hardware-accelerated ray tracing in GPUs and standardized APIs has led to a rapid adoption of ray tracing in games. While these APIs allow programmable surface shading and intersections, most of the ray traversal is assumed to be fixed-function. As a result, the implementation of per-instance Level-of-Detail (LOD) techniques is very limited. In this paper, we propose an extended programming model for ray tracing which includes an additional programmable stage called the traversal shader that enables procedural selection of acceleration structures for instances. Using this programming model, we demonstrate multiple applications such as procedural multi-level instancing and stochastic LOD selection that can significantly reduce the bandwidth and memory footprint of ray tracing with no perceptible loss in image quality.

This paper presents an open-source simulation environment for 360-degree traffic imaging. The environment is built on the openly available AirSim Windridge City Asset. In this work, the city is populated with custom autonomous vehicles and pedestrians. The vehicles navigate along a designed node map that can be manually placed on the roads according to the specified traffic regulations. The vehicles are also made to detect other vehicles, pedestrians, and traffic lights for simple collision avoidance and smoother traffic flows in intersections. The pedestrians follow a NavMesh placed on the walkable areas and stop at the traffic lights when crossing the streets. Weather effects, time-of-day, and rain distortion lens shader bring the environment more close to the reality. The whole system is built on top of free and self-made assets, making it easy to use, configure, and extend. The performance of the simulator exceeds 60 frames per second when run on NVIDIA RTX 2070 with Intel Xeon E5-2620 or equivalent hardware. acceptedVersion

International audience; We present Videostrates, a concept and a toolkit for creating real-time collaborative video editing tools. Videostrates supports both live and recorded video composition with a declarative HTML-based notation, combining both simple and sophisticated editing tools that can be used collaboratively. Videostrates is programmable and unleashes the power of the modern web platform for video manipulation. We demonstrate its potential through three use scenarios: collaborative video editing with multiple tools and devices; orchestration of multiple live streams that are recorded and broadcast to a popular streaming platform; and programmatic creation of video using WebGL and shaders for blue screen effects. These scenarios only scratch the surface of Videostrates’ potential, which opens up a design space for novel collaborative video editors with fully programmable interfaces.

Procedural texture has been used to generate a pattern on the 3D realistic surface for several years and became more important in the physically based rendering (PBR) [1]. Procedural technologies relating to procedural shading have been used successfully for the simulations of natural material and phenomena such as marble, wood, stone, and clouds. In this paper, we demonstrate an imitation of realistic texture which has been developed in procedural pattern generator by the noise texturing algorithm. We try to standardize a workflow that can represent the surface characteristics of the realistic procedural texture by using the physically-based shader. This procedural method could generate complex and realistic textures by using a combination of several component functions. To realize the relation between texture features and basic primitive functions (Noise, Turbulence, Clamp, Histogram, Smoothstep, etc), we propose a useful and practical guideline for designer to build procedural textures by selecting the parameter values. These procedural textures have been summarized in a table that could explain in terms of the classifications of the procedural pattern definitions. Our system uses the 3ds Max software with the Substance plugin in order to offer the flexible editing of request parameters. This paper referred to the multi-pass rendering of texture mapping which is classified into different texture channels (albedo map, roughness map, metallic map, normal map, height map)in PBR. We introduced the process of the texture synthesis between noise functions and texture highlights, such as fractal noise functions, color mapping methods, and bump mapping definitions. This framework can help both programmer and art designer to customize their own shaders with the design routines of procedural textures.

We present FragmentFusion, a real-time dense reconstruction pipeline that combines sparse camera tracking with image-space volumetric fusion. The tracking is based on ORB-SLAM, which constructs and optimizes a sparse global map of 3D points and keyframes. We transform each of these keyframes into decimated meshes and render them from the estimated viewpoint. Fusion is performed in the pixel shader by exploiting atomic operations on a packed data structure. This eliminates the need of a 3D voxel grid making FragmentFusion very flexible at large scenes and varying scales. Moreover, since all keyframes are fused on-the-fly, we can use bundle adjustment and loop-closure without expensive volumetric re-integration. FragmentFusion is lightweight in terms of compute power and memory consumption. It can easily fuse several hundreds of keyframes in real time, in a quality comparable to other approaches. We achieve real-time frame rates on a notebook at around 20% CPU and GPU utilization and low memory consumption.

Kaleidogen lets you breed abstract circular patterns. You can crossbreed two and add their offspring to your stock. The game has no end, no score, no time pressure, the only goal is to please your personal sense of aesthetics. The mechanisms behind Kaleidogen imitate genetic inheritance. It is written in Haskell, compiled to JavaScript, runs in the browser and generates GL shader programs on the fly.

The Toy Story universe makes its home at small scales, with the camera sometimes just a few centimeters from surfaces where typical shader approaches are unable to provide the desired level of detail. For environments like the Second Chance Antiques Store for Toy Story 4, the Set Extensions team developed systems to generate dimensional, granular elements such as dust, small debris, and cobwebs to enhance storytelling and ambiance. In addition to improving realism, these elements help indicate how hidden or exposed an area is from human observation and elevated the sense of drama and history.

We complement the last three editions of the course at SIGGRAPH Asia (2015, 2016, 2018) and SIGGRAPH (2017) to make it more of a hands-on nature and include OpenISS. We explore a rapid prototyping of interactive graphical applications for stage and beyond using Jitter/Max and Processing with OpenGL, shaders, and featuring connectivity with various devices. Such rapid prototyping environment is ideal for entertainment computing, as well as for artists and live performances using real-time interactive graphics. We share the expertise we developed in connecting the real-time graphics with on-stage performance with the Illimitable Space System (ISS) v2 and its OpenISS core framework for creative near-realtime broadcasting, and the use of AI and HCI techniques in art.

The savage world of Anthem is volatile, lush, expansive, and full of unexpected characters. Bringing these aspects to life in a real-time (30fps) interactive environment presented a wealth of challenging problems for BioWare's technical artists and rendering engineers. These developers work with content creators to bridge art and technology through creative problem solving in areas such as performance/runtime, shaders, and artist tools. This retrospective panel will highlight some of the team's work, alongside reflections on innovation, distributed collaboration/coordination, and the successes and challenges of creating a new IP for the world to enjoy.

We introduce a novel method for rectangular selection of components in large 3D models on the web. Our technique provides an easy to use solution that is developed for renderers with partial fragment shader support such as embedded systems running WebGL. This method was implemented using the Unity 3D game engine within the 3D Repo open source framework running on a web browser. A case study with industrial 3D models of varying complexity and object count shows that such a solution performs within reasonable rendering expectations even on underpowered devices without a dedicated graphics card.

In this contribution we studied how different rendering styles of a virtual human impacted users' visual attention in an interactive medical training simulator. In a mixed design experiment, 78 participants interacted with a virtual human representing a sample from the non-photorealistic (NPR) to the photorealistic (PR) rendering continuity. We presented five rendering style samples scenarios, namely low fidelity all Pencil Shaded (APS), Low to Mid Fidelity Pencil Shader on virtual patient (VP) only (PS), Mid Fidelity All Cartoon Shaded (ACT), Mid to High Fidelity Cartoon Shader on VP only (CT), and relatively High Fidelity Human Like (HL) appearance, and compared how visual attention differed between groups of users. For this study, we employed an eye tracking system for collecting and analyzing users' gaze during interaction with the virtual human in a failure to rescue medical training simulation. Results suggests that users may spend more time in the simulations on the non-realistic fidelity continuum that necessarily do not involve interaction with the virtual human. However, users preferred visually attending to virtual humans in the middle and high fidelity visual appearance conditions when engaging virtual humans in simulated social face-to-face dialogue as compared to the other conditions

In modern computer graphics, we have mixtures of the classical fixed-function graphics pipelines and the shader-programmable graphics pipelines. With the new shader-programmable graphics pipelines, every graphics output features should be implemented as the shader programs, which are binary executable codes spe-cific to the GPUs(graphics processing units). In the safety-critical market, the OpenGL SC (safety-critical) 1.0 fixed-function graphics library was widely used. Recently, they released the new standard specification of OpenGL SC 2.0, which uses only the shader-programmable graphics pipeline model, and cannot execute the deprecated OpenGL SC 1.0 programs. One solution to get the backward compatibility is emulating traditional SC 1.0 fixed-function programs with the SC 2.0 shader programs. In this work, we show an adaptive selection scheme, to choose the most optimal shader program, among a set of candidate shader-specific binary executable codes. We show the analysis of the problem and over-all design. We can accelerate the OpenGL SC 1.0 features emulations with this new adaptive selection scheme.

Recently, physically based rendering (PBR) [1] has become popular with respect to visual realism in the computer graphics field. PBR model is more of a ray tracing calculation than a legacy Lambert or Phong model. This technique has become the industry standard for movies and video game developments. This paper refers to a simple model for subsurface light transport in translucent materials with respect to the PBR system. We attempt to simulate a realistic subsurface scattering by choosing to mimic a cake-surface texture, which has a sophisticated translucent material, and nest-like structure that can demonstrate the characteristics of the bidirectional scattering distribution function (BSDF). We used the Arnold engine with 3ds max software for Monte Carlo ray-tracing calculation in CPU. We compared the difference between the photo-scanning map and the procedural shader, which were fed into the displacement channel to achieve a random organic texture of a cake-surface. This approach showed the advantages and disadvantages of these different situations in the PBR workflow. With the knowledge of the examining mathematical model of PBR, we describe that the PBR theory and the practical aspect to validate this procedural shader, can provide more advantages in a variety of material mimic. Finally, the workflow of the experiment can help 3D artists design realistic looking surfaces as effortlessly as possible based on physically accurate formulas.

In this paper, we present a solution for the photorealistic ambient light render of holograms into dynamic real scenes, in augmented reality applications. Based on Microsoft HoloLens, we achieved this result with an Image Base Lighting (IBL) approach. The real-time image capturing that has been designed is able to automatically locate and position directional lights providing the right illumination to the holograms. We also implemented a negative &ldquo, shadow drawing&rdquo, shader that contributes to the final photorealistic and immersive effect of holograms in real life. The main focus of this research was to achieve a superior photorealism through the combination of real-time lights placement and negative &ldquo, shader. The solution was evaluated in various Augmented Reality case studies, from classical ones (using Vuforia Toolkit) to innovative applications (using HoloLens).

Profiling OpenCL [3] applications on modern GPUs is usually limited to gathering timestamps from the host side or gathering performance counter data for a complete GPU kernel. In this presentation, we will show the limitations of existing performance counter-based methods with respect to optimizing complex applications. Existing performance counter-based methods of profiling only provide information aggregated over a kernel's lifetime and does not provide insight into load balancing across shader engines or the behavior of a GPU kernel over time. In this paper, we present the Radeon GPU Profiler (RGP) [2]. RGP is a performance analysis tool that enables OpenCL developers the ability to understand the utilization of their device during their OpenCL kernel's execution.

The recent introduction of the Vulkan API and the SPIR-V intermediate-level language by the Khronos Group provides a new GPU programming model in an effort to combine the advantages of its predecessors, OpenGL for 3D graphics and OpenCL for computing. Vulkan's low-level and more direct control over the underlying GPU hardware as well as its support for explicit multi-threaded execution offers opportunities for better performance at the cost of higher programming effort.Most of the previous work associated with Vulkan has targeted the graphics pipeline. The fact that Vulkan also supports the compute pipeline has motivated us to examine it from the GPGPU perspective, by porting a number of realistic applications to a desktop GPU and evaluating their Vulkan implementations in terms of performance and programmability. Specifically, we consider the Laplacian filter which is used in image processing to detect areas of rapid change (edges) in images. Also, we consider a Visual Odometry (VO) application used to track the position and pose of a robot by analyzing a sequence of camera frames. VO is part of a Simultaneous Localization and Mapping (SLAM) application used in autonomous navigation systems to build a map of surrounding environments and to determine the location of a moving robot inside this map. These applications require advanced pixel-level processing at different levels of pyramid-based granularity, and may even require real-time performance (when, for example, SLAM is used in a robot navigation system). We ported the original implementations (written in C for Laplacian filter and in CUDA for SLAM) to OpenCL, OpenGL and Vulkan and evaluated their performance on a desktop NVIDIA GPGPU.We show that Vulkan performance is comparable (within 10%) with the performance attained by OpenCL and higher than the performance attained by OpenGL compute shader implementations. By exploiting Vulkan synchronization primitives using the command buffer, we can eliminate the overhead of launching multiple kernel invocations in iterative applications and improve performance of Vulkan implementations by up to 30%. However, the OpenCL compiler seems to be more mature than the SPIR-V compiler used in Vulkan implementations resulting in slightly faster OpenCL kernel execution.On the other hand, the low-level semantics of Vulkan demand higher programming effort compared with OpenCL/OpenGL which can be a burden if Vulkan is to be used as a GPGPU programming model. Most of the additional effort, however, is boilerplate code that can be reused in more than one Vulkan applications.Our work is one of the first to consider Vulkan compute as an implementation language for larger scale applications (and not just for small kernels as in previous work).

My MET 2019 invited talk will focus on GraphicsFuzz, a technique and tool for automated metamorphic testing of the shader compiler components of graphics drivers. Starting out as a research project at Imperial College London, GraphicsFuzz led to a spin-out company of the same name, which was acquired by Google in 2018. The technology has since been open sourced and is being used by Google to test Vulkan and OpenGL ES graphics drivers and supporting tools.

Due to recent advances in the field of virtual reality, the demand for immersive sound design has increased dramatically. While pre-recorded samples are a popular tool in this context, it has limited flexibility and user interactivity. We propose a real-time method that can synthesize fully immersive sounds of droplets falling in water. The physics of air bubbles produced in the liquid are considered in detail, and the sound samples are synthesized in a GLSL shader to make full use of parallel computing. A vertex shader shows the resulting disturbance on the liquid surface, to further immerse the user with consistent visuals. Results show that a large amount of bubbles can easily be generated on a regular desktop computer.

Viewers of virtual reality appear to have an incorrect sense of space when performing blind directed-action tasks, such as blind walking or blind throwing. It has been shown that various manipulations can influence this incorrect sense of space, and that the degree of misperception varies by person. It follows that one could measure the degree of misperception an individual experiences and generate some manipulation to correct for it, though it is not clear that correct behavior in a specific blind directed action task leads to correct behavior in all tasks in general. In this work, we evaluate the effectiveness of correcting perceived distance in virtual reality by first measuring individual perceived distance through blind throwing, then manipulating sense of space using a vertex shader to make things appear more or less distant, to a degree personalized to the individual's perceived distance. Two variants of the manipulation are explored. The effects of these personalized manipulations are first evaluated when performing the same blind throwing task used to calibrate the manipulation. Then, in order to observe the effects of the manipulation on dissimilar tasks, participants perform two perceptual matching tasks which allow full visual feedback as objects, or the participants themselves, move through space.

To accelerate Convolutional Neural Networks (CNN) operations on resource-limited mobile graphics processing units (GPUs), taking advantage of the common characteristics between texture filtering and convolutional layer, we propose a configurable texture unit called tensor and texture unit (TTU) to offload the computation from shader cores. With adding a new datapath for loading weight parameters in the texture unit, reusing the original texture cache, increasing the flexibility of the filtering unit, and packing the input data and weight parameters to fixed-point format, we make the texture unit be able to support convolutional and pooling layers with only small modifications. The proposed architecture is verified by integrating TTU into a GPU system in RTL level. Experimental results show that 18.54x speedup can be achieved with the overhead of only 8.5% compared with a GPU system with a traditional texture unit.

Live coding in virtual reality allows users to create and modify their surroundings through code without the need to leave the virtual reality environment. Previous work focuses on modifying the scene. We propose an application that allows developers to modify virtually everything at runtime, including the scene but also the render engine, shader code and input handling, using standard desktop IDEs through a desktop mirror.

GPUs are now a mainstream compute device. They are widely used to render images on medical devices. Today, it has become impossible to imagine AI without them. To build confidence on the accuracy of rendering images and complex calculations, it is essential to consider formalizing the behaviour of GPU Instruction Set Architecture (ISA) at the assembly language level. In this paper, we present the formalization of GPU shader programs. We prove some properties of shader programs with respect to operational semantics of our formal model. We use Coq to mechanize the formalization of our model and proofs.

The aim of the research was the geometric analysis, the digital reconstruction and the real-time simulation of the Fallingwater House designed by Frank Lloyd Wright for Edgar Kaufmann in the forest area of Pennsylvania. The research wants to define a procedure to be used for advanced perception of contemporary architecture designed inside natural contexts using new technologies of Virtual Reality. A detailed study of the spatial configuration of the environment was the main step of the work, considering 3D modeling of terrain morphology and different types of vegetation. Then we used 3D procedural shaders to apply static realistic material effects on surfaces and advanced dynamic shaders for moving materials, such as the water of the river. In this case three different typologies of water were defined, using particle flow procedures, to simulate running water, waterfall and water vapor generated with the collision of water on the rocks. The final step was to use a Virtual Reality System to allow users to explore in real-time the whole exterior and interior space of the scene. Thanks to the advanced restitution we can understand better the close relationship between natura naturans and natura naturata.

The 3D character development process is long, heavy and requires a high level of professional skills. For today, traditional approaches require from the developer a lot of time, resources and high-professional skills for making a 3D character model. To facilitate this work, we propose the approach with using the textures maps module. This module includes a set of prepared and it has divided into segments textures of different types (diffuse, specular, displacement, bump, SSS). It enables to simplify the texture stage and requires less professional skills, since the developer no longer needs to create a new texture. In addition, the module enables to skip the stages of sculpting and retopology, and get various visual outcomes for same 3D model geometry. The result of texturing affects directly the quality of both shader and visualization. The implementation of the proposed approach is described, and case-study results are presented.

The first engine that we’re going to dive into is Unity. Unity is an amazingly flexible platform to build a game with, and is my personal favorite environment to prototype new shaders or graphics techniques in. However, Unity is a very complex engine to wrap your head around, and this chapter is not going to provide a ground-up tutorial in how to work with Unity, just how to write shaders for it. If you’d like to learn to use Unity, but haven’t before, I recommend jumping into some tutorials online before trying to tackle the content in this chapter; otherwise you’ll likely be a bit lost. You don’t need to be a Unity expert to start writing shaders for the engine, but you do need to at least be able to navigate the editor and get an object onto your screen.

Rendering 3D games is a bit of a different animal than the 2D projects we’ve been doing so far. Unlike sprites drawn on quads, 3D meshes have a lot of information about their shape. 3D games can use this shape information to perform lighting calculations inside shader code, to make these objects appear to be lit in real time by the game world. We’re going to see how some of these lighting calculations work in later chapters, but first we need to have a 3D project to work with. This chapter is going to walk through how to set one of those up. We’re going to get a mesh loaded into a new project and set up a camera that can properly render 3D content.

We’ve focused a lot so far on things we can do with a fragment shader: tinting, brightening, mixing—all that jazz. You’d be forgiven for thinking that vertex shaders exist only to pass information to the real stars of the show, but nothing could be further from the truth. While fragment shaders drive a lot of the visual effects that we’re used to in modern games, vertex shaders are the unsung workhorse of modern video game graphics, and this chapter is going to focus on why.

Before we can dive in to writing shaders, we first need to cover some background information about how games put things on screen, and some of the basic math that they use when doing so. In this chapter we’re going to get a bird’s-eye view of what rendering is, and how a game renders a frame of a video game. Next, we’ll talk about what a shader is, and how it fits into the rendering process we just learned about. Finally, we’ll end the chapter with a very brief introduction to what vectors are, which will give us all the information we need to start writing our own shaders in the subsequent chapters.

Many manufactured objects and worn surfaces exhibit rounded corners and edges. These fine details are a source of sharp highlights and shading effects, important to our perception between joining surfaces. However, their representation is often neglected because they introduce complex geometric meshing in very small areas. This paper presents a new method for managing thin rounded corners and edges without explicitly modifying the underlying geometry, so as to produce their visual effects in sample-based rendering algorithms (e.g., ray tracing and path tracing). Our method relies on positioning virtual spheres and cylinders, associated with a detection and acceleration structure that makes the process more robust and more efficient than existing bevel shaders. Moreover, using our implicit surfaces rather than polygonal meshes allows our method to generate extreme close views of the surfaces with a much better visual quality for little additional memory. We illustrate the achieved effects and analyze comparisons generated with existing industrial software shaders.

We propose ARAMIS, a solution to provide real-time “x-ray see-through vision” of a patient’s internal structure to the surgeon, via an optical see-through head-mounted display (OST-HMD), in minimally invasive laparoscopic surgery. ARAMIS takes input imaging from a binocular endoscope, reconstructs a dense point cloud with a GPU-accelerated semi-global matching algorithm on a per-frame basis, and then wirelessly streams the point cloud to an untethered OST-HMD (currently, Microsoft HoloLens) for visualization. The OST-HMD localizes the endoscope distal tip by fusing fiducial-based tracking and self-localization. The point cloud is rendered on the OST-HMD with a custom shader supporting our data-efficient point cloud representation. ARAMIS is able to visualize the reconstructed point cloud (184k points) at 41.27 Hz with an end-to-end latency of 178.3 ms. A user study with 25 subjects, including 2 experienced users, compared ARAMIS to conventional laparoscopy during a peg transfer task on a deformable phantom. Results showed no significant difference in task completion time, but users generally preferred ARAMIS and reported improved intuitiveness, hand-eye coordination and depth perception. Inexperienced users showed a stronger preference for ARAMIS and achieved higher task success rates with the system, whereas the two experienced users indicated a slight preference for ARAMIS and succeeded in all tasks with and without assistance.

Целью работы является разработка иллюстративного шейдера для достижения уникального стиля рендеринга проекта «Project GRACE», главной особенностью которого, является эффект рисованной анимации. В первой части представлен краткий обзор игрового движка Unity, особенности работы с шейдерами внутри движка, на основе концепт-артов художников проекта, выделены ключевые особенности визуального стиля и установлены требования к реализации, рассмотрены аналоги на Asset Store. «Общая концепция» посвящена базовым принципам работы со светом в компьютерной графике, а также идеям на которых будет строится процесс разработки. В третьей части рассмотрена реализация. Затем будет проведен анализ полученных результатов, и, наконец, в «Заключении» будут подведены итоги., The goal of this graduate work is a development of illustrative shader for achieve the unique rendering style of «Project GRACE» which main feature is an effect of hand-drawn animation. The first part presents a brief overview of Unity game engine, features of shaders in the engine, key features of graphics style was defined based on project concept arts, development requirements, and the overview of similar solutions in Asset Store. «Base concept» is devoted to a basic principles of work with lights in CG and main concepts of shader’s development process which represented in the next part. Analyze of result represents in part four, and finally, after that the results of the work will be summarized in conclusion.

This chapter describes the rendering pipeline developed for PICA PICA, a real-time ray tracing experiment featuring self-learning agents in a procedurally assembled world. PICA PICA showcases a hybrid rendering pipeline in which rasterization, compute, and ray tracing shaders work together to enable real-time visuals approaching the quality of offline path tracing.

Until now, our scene has been lit only by a single directional light. This has worked for us because we’ve been trying to light a simple outdoor scene, and a directional light is excellent at simulating light from the sun. Many games get by with lighting that isn’t any more complicated than this. However, the drawback for keeping lighting so simple is that it limits the amount of flexibility you have when deciding how your project will look. Since we don’t want to always be limited to lighting things with just the sun, this chapter is going to introduce different types of lights commonly used by video games and how to write shaders that work with multiple lights at once. Along the way, we’ll change our example project to be a night-time scene, with a number of different sources of light all working together.