Search

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 paper presents a technique to incorporate spatial blur effects in virtual reality devices. The considered spatial blur is based on foveation and defocus blur: concepts inspired by the human visual system. The proposed technique can be applied to any head-mounted display as a post-processing step. Our foveated depth-of-field method removes intensity leakage artifacts in the transitory regions and works in real-time. We verify the usefulness of our technique by conducting a pilot study on depth perception in virtual environments. In the conducted user study, systems integrated with our blur effect provided a better estimation of object depth in the peripheral regions.

Real-time ray-tracing debuted to consumer GPU hardware in 2018. Primary examples however, have been of hybrid raster and ray-tracing methods that are restricted to triangle mesh geometry. Our research looks at the viability of procedural methods in the real-time setting. We give implementations of analytical and implicit geometry in the domain of the global illumination algorithms bi-directional path-tracing, and GPU Photon-Mapping – both of which we have adapted to the new ray-tracing shader stages, as shown in Figure 1. Despite procedural intersections being more expensive than triangle intersections in Nvidia’s RTX hardware, our results show that these descriptions still run at interactive rates within computationally expensive multi-pass ray-traced global illumination and demonstrate the practical benefits of the geometry.

This paper presents a novel framework that allows low-cost devices to visualize and interact with photorealistic scenes. To accomplish this task, we use the Unity streaming package that allows for streaming an application within its editor and the Unity’s high definition render pipeline that has a proprietary ray-tracing algorithm. The framework contains a realistic scene using a ray tracing algorithm, a virtual reality camera with barrel shaders to correct the lens distortion necessary to use low-cost cardboards, and a method to collect the mobile device’s spatial orientation through a browser to control the user’s vision delivered via WebRTC. The proposed framework can produce low-latency, realistic, immersive environments to be accessed through low-cost HMDs and inexpensive mobile devices.

Many volumetric rendering algorithms use spatial 3D grids as the underlying data structure. Efficient representation, construction, and traversal of these grids are essential to achieve real-time performance, particularly for time-varying data such as in fluid simulations. In this paper, we present improvements on algorithms for building and traversing Bounding Volume Hierarchies (BVH) designed for sparse volumes. Our main insight was to simplify data layout representation by grouping voxels in buckets, preserving their spatiality using Morton codes, instead of using bricks, as current solutions use. Our solution does not use pointers nor stacks, allowing for its usage directly on computing shaders and provides, on average, 9.3x improvement in construction speed, compared with state-of-the-art approaches for Linear Bounding Volume Hierarchies (LBVH).

This Embedded Graphics libraries have evolved from OpenGL to next gen Vulkan libraries. OpenCL and CUDA have been used for many years for GPU compute on a range of SoC devices with powerful embedded GPU chipsets. OpenCL and CUDA were never able to be certified, due to the contributions from many developers. Next generation autonomous vehicles, unmanned aircraft, transportation and even military vehicles will require both graphics, as well as GPU compute to implement DSP or FPGA logic is software, as well as Deep Machine Learning. Vulkan libraries are available now and are defined by the Kronos Group, as well as this, a next generation of Vulkan safety critical library for safe Shader and GPU Compute is now available. This white paper will look at Vulkan architectures, embedded system use and the implications for using GPU Compute, where certification may be a critical requirement for ISO 26262, EN50182, IEC 61508, DO178C certifiable embedded systems.

Non-photorealistic rendering (NPR) of 3D models in a specific style has been a hot topic of NPR research, and people are working hard in the direction of a more similar rendering style and higher real-time performance, Chinese ink painting style is one of them. In general, previous studies of 3D model Chinese ink painting style rendering mainly in two methods: Set up a mathematical model of brushstroke to simulate the pressure and diffuse of brush, which is usually used in interactive painting. Another method is rendering the model in two parts (contour line the interior area) to automatically convert the 3D model into 2D Chinese ink painting style images. Combine with the application scenarios, this paper used the second method. We had improved the traditional algorithm. In the contour line rendering part, freehand style contour line extraction and rendering algorithm are used, and user-defined contour line thickness and omission control are added to give the artist more creative space. We use the improved dye shader and noise map in the interior rendering. Our results show a better aesthetics effect and real-time character.

Multimodality medical data visualization can convey a significant amount of complementary image information from various sources into a single and meaningful display. Even though there have been publications on integrating multiple medical images into a unique 3D representation, there are no researches on rendering registered multiple medical data in web browsers and synchronizing the rendering results over Internet, especially in cardiac applications. Web-based multimodality medical data display is hampered by the large size of the dataset that makes the rendering and information streaming too slow to be applied in clinical diagnosis and treatment. In this paper, we introduce new algorithms and a software platform to address this issue. The presented research results take advantages of bidirectional network connection and hardware accelerated graphics shader processing to real-time fuse and display inner organ structures in web browsers and stream the rendering results over Internet, which will provide medical users with intuitive feedback in collaborative cardiac diagnosis and image-guided remote therapy.

In recent years several hobbyists and research institutions have turned to ARM based cluster computers to meet their high performance computing needs. These systems are typically low cost, power efficient machines made of 4 or more nodes. However, current applications running on these machines are limited to the computational capabilities of the on-board CPUs. An attempt to fully utilise the available hardware is to use the on-board GPUs for general purpose computation. The challenge with this approach is the difficulty of programming for embedded ARM GPUs, which support a very limited programming interface such as OpenGL ES 2.0. In this paper, we present a system which allows a high level program to utilise multiple embedded ARM based GPUs in parallel to perform computation, without the application developer concerning themselves with the details of OpenGL and writing shaders. We describe the vector and matrix functions which we implement and provide results detailing their speedup. For matrix multiplication, our system shows a speedup of nearly 7X on the 8 nodes of the PHINEAS cluster computer. We further describe how these functions may be composited with some CPU functionality to implement inferencing for a Convolutional Neural Network trained in Keras on a different machine. Our benchmarks demonstrate that the system’s performance scales well across several nodes for a variety of tasks. Our work brings the benefits of GPGPU computing to an as yet untouched class of cluster computers.

There is an ever increasing need for higher GPU performance to render sophisticated User Interface, latest high end 3D games and general purpose compute (GPGPU) applications. GPU SW programming models such as OpenGL have evolved over decades to cater to the unique mixed pipeline 3D GPU architectures. Due to the sticky nature of GPU SW programming model, leveraging other HW blocks to enhance graphics performance has been a most challenging task for SW architects. System designers have usually responded to the GFLOPS demand by increasing the GPU HW specifications. This paper proposes enhancing GPU performance by leveraging DSP transparently in background without impacting GPU software programming model. The proposed solution consists of multiple novel techniques namely ability to offload vertex shader to DSP, 3 stage pipelined execution and ability to re-use GPU internal pipeline. The proposed solution is prototyped in Jacinoto6 Platform from Texas Instruments. The default GPU spec performance is increased by up-to 41% by leveraging dual core C66x DSP in Jacinto6 Platform using proposed solution for different use-cases. The proposed solution is fully transparent to application software stack. In addition, the solution is directly applicable to any GPU + DSP architecture making it attractive approach for cost optimized solutions.

This paper proposes a terrain tessellation technique using the new GPU mesh pipeline, and compares it to the classically used tessellation pipeline. We explain how we can use it to greatly increase the tessellation capability within the draw call while keeping similar performances. We then show how it can be used to limit the CPU load as well as the data transfer to the GPU for rendering wide terrains.

Exploration of the challenges faced by individuals who are non sighted or visually impaired has primarily been limited to physical methods such as blindfolds and controlled environments. Using virtual reality, we provide a simulation of blind navigation using a shader effect with scattered light. The scattered light represents the auditory and haptic feedback that the player receives while using a walking cane to navigate the virtual environment. We discuss methods of development, and goals for this simulation.

The one-dimensional time axis on which the current meteorological observation platform depends is transformed into a two-dimensional coordinate system, i.e. one dimension, multi-source observation instruments, data and products are added. This dimension shows the observation occurring at a certain time node. The multi-source observations at the same time are vertically arranged to be distinguished by icons or colors. In this study, real-time display and rendering of scenes are realized through real-time efficient local multi-level of detail loading and adaptive multi-level caching of large-scale 3D spatial data and the dynamic interaction of multi-source observation information is realized by combining the CPU/GPU graphics hardware accelerated rendering technology of OpenGL+Shader. The platform is upgraded from one dimension of time to two dimensions of time and observation, which greatly expands the selection and change space of independent variables, thus the capacity of dependent variables is also greatly increased. Theoretically, it can accommodate all kinds of observation data and products. Through seamless connection on one page, it can freely schedule, switch and superimpose all kinds of observation information, enabling business researchers to efficiently and intensively obtain comprehensive meteorological observation data products, and carry out analysis and application.

GPU has been applied to more and more visions which demand the hardware with higher performance, faster speed and lower computational cost. We propose a novel early z architecture named ZU1 who locates prior to the pixel shader stage for z range test. The module treats 8x8 pixel patch called tile as an input entry to calculate the tile’s z range, meanwhile acquiring cache zrange from z cache to which the tile zrange compares against according to the compare mode, so as to fastly evaluate z test for accepting or rejecting the tile. We benchmark our design on 3DMark set demonstrate substantial gains with 40% reject ratio and thousands of workloads per frame saving.

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

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.

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.

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.

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.

This paper presents an algorithm enhanced mixing of audio streams for computation on GPUs, which combines multiple stages of mixing by using two-pass rendering, which significantly reduces the switching time between buffers. Methods of computer experimental comparative studies were carried out evaluating the performance of the developed algorithm. The purpose of the present paper is development of an efficient algorithm for mixing audio streams for processing on GPUs. The method of transfer operations computing on graphics processors with the use of Shader programs was developed. Novel features presented solutions is using a two-pass rendering. The results showed that the application of the developed algorithm leads to an increase in computational performance up to 6 times. Presented solution can be implemented as software in the telecommunications multiprocessor systems.

As more low power devices are needed for applications such as IOT, reducing power and area is becoming more critical. Reducing power consumption and area caused by using full scan should be considered as a method to help achieve these stricter requirements. This is especially important in designs using near-threshold technology. In this work, we use partial scan to attempt to improve power, performance and area on a CPU core and a GPU shader core. We present our non-scan DFF selection algorithm that maximizes non-scan DFF count while achieving ATPG results close to those of the full scan design on both a CPU and a GPU shader core. In addition, we present the PPA (power, performance and area) results of these designs for both the full scan and partial scan.

We present a diminished reality application running live on consumer mobile devices. In our pre-observation-based approach, the clean 3D scene, free of undesired objects, is scanned beforehand and reconstructed as a high resolution textured 3D model. At runtime, objects added in a region of interest are efficiently removed by projecting the previously captured background. Differences of illumination conditions between scan time and run-time are compensated to obtain seamless results. The proposed approach requires no segmentation or manual input other than the definition of the 3D region of interest to be diminished, and is not based on any particular assumption on the background geometry. We show the potential of our approach by processing a variety of challenging unknown 3D scenes including textured backgrounds, dynamic illumination conditions and foreground objects partially occluding the diminished region. We provide details on our compute shader implementation to make as easy as possible the reimplementation by the community.

The process of data visualization often involves a balance between art and science. Data must be presented in such a way that preserves their accuracy and integrity, while incorporating many, somewhat subjective, artistic elements such as color, composition, depth, and others. The latter elements help the viewer to distinguish between variables, to perceive a range of values, to identify regions of scientific interest, and to orient themselves spatially in the virtual scene. This paper briefly explores the application of different cinematic effects, such as camera movement, camera focus, slow motion, color, lighting, and the use of various graphical shaders as a means of animating data in a way that is artistically compelling and engaging, while remaining accurate and informative.

This work proposes a method of fracturing one-sided 3D objects, in real time, using standard GPU shaders. Existing implementations include either pre-fracturing objects and replacing them at run-time, or precomputing the fracture patterns and using them to fracture the objects depending on user interaction. In this article we describe a novel method in which the fracturing calculations are handled by the GPU and only having the initial positions of the fracture fields handled by the CPU. To obtain higher resolutions of fractures, scalable tessellation is also implemented. As a result, this method allows for fast fracturing that could be utilized in real-time applications such as videogames.

Nowadays a wide range of rendering techniques are used in computer graphics development, each of them running in a shader program. Techniques combinations force graphics engines to manage a great number of permutations that increase exponencially. In this article we introduce an effects framework to manage orderly, maintainable and extensively all the available shaders, which was developed and integrated with our graphics engine. This solution improves code modularity and reutilization, and consists in an algorithm implementation to generate entires shaders from a set of reusables functions.

We investigate the potential of Vulkan for fluid animation using smoothed particle hydrodynamics (SPH) method. A simple parallel SPH algorithm is devised and implemented in OpenGL Shading Language(GLSL) compute shader. This GLSL code is converted into latest Standard Portable Intermediate Representation (SPIR-V) format and then implemented with Vulkan and OpenGL 4.6. Two test cases are used to verify that the implementations are correct by examining the visual output. The first test case is dropping a cube of water into a box and the second is a dam break in a closed channel, both at room temperature. And finally, we analyze the performance of both implementations in real-time graphic processor unit (GPU). We found that the most optimum of the work group size is 128, and our Vulkan implementation performs faster than OpenGL for 30,000 or greater particles.

In most cities in Taiwan, electronic signboards can be seen everywhere. Advertising signboards for stores are becoming more common, larger, and more noticeable in order to attract more attention. The harmony between outdoor signboards and the surrounding environment has long been ignored by local residents. Because of the urban aesthetics of absence, outdoor signboards have come to be treated as visual pollution. In this paper, we focus on vision-based markerless tracking [7] in an augmented reality (AR) [4] [5] [6] application as part of a signboard aided-design system. We present an AR framework that uses simultaneous localization and mapping (SLAM) [8] to approach an AR scene as realistically as a photographic image. Two AR systems are developed as demonstration examples: a signboard design photo-image storage system and a signboard display system. The project is developed using 3D computer graphics technologies, including a visual SLAM [9] algorithm, tessellation shader technology, and editable 3D textures with an embedded image approach. With the features of 3D relief signboard displays and a measurable landscape, the system helps signboard designers to improve their signboards by recognizing the influence of environmental factors. Consequently, the aided design system offers a path toward environmental harmony for designers by facilitating the pre-production process using mobile AR.

In this paper, we evaluate the influence of different VR rendering styles on the QoE of users of a training application. To this end, we present the results of a lab-based QoE study featuring a virtual manufacturing training setting in which participants were asked to correctly allocate spare parts to mounting locations inside and outside a vehicle using an HTC Vive VR Setup. We evaluate how five different rendering styles (defined by rendering technique and shader used), ranging from point cloud to highly photo-realistic, affect different quality dimensions such as perceived visual quality, task difficulty, spatial orientation ability, and discomfort (including cyber-sickness). Our results show that while rendering style has a significant impact on QoE and other dimensions (like task completion time), a standard shader already can provide sufficient quality to support the provided training task and can even outperform rendering styles using more sophisticated techniques like ambient occlusion. Furthermore, we also discuss significant influence of user-related factors like previous experience with VR or gender as well as other related critical issues to be considered in VR training application and assessment study design.

Aiming at the problem that scattering effect can not be achieved in traditional shader rendering, a water surface scattering model based on Unity3D Shader is proposed. Firstly, the scattered light is simulated and calculated. Secondly, the logical structure of the shader model is constructed. The vertex program function including the calculation of scattered light is designed. The function structure containing the concept of time is introduced into the static water model to develop the dynamic water surface scattering shader. Finally, taking Hainan seascape communication experience platform as an example, we verify the effect of the shader model.

One of the methods for analysis of data obtained in computer simulation of the processes of unstable oil displacement is to visual analyze the plane sections of level surface (isosurface) of the saturation of a displacing viscous liquid in a sample of a porous medium. This paper presents an efficient distributed method for plane section visualization on a graphics processing unit (GPU) in a polygonal model of considered level surface. A polygonal model of clipped isosurface is created using a modified "marching cubes" method by means of the developed geometric and fragment shader programs. Based on the solutions proposed, a visualization program complex with an ergonomic user interface was implemented, which can be used in scientific researches, virtual laboratories, virtual environment systems, educational applications, etc.

The transformation relationships between real-world and 3D virtual objects are analyzed for projection mapping. Projector coordinates systems and OpenGL vertex transformation model are examined. Mainly, we analyzed lens distortion model and its inverse model, and proposed shader code for it.

In this paper, we are proposing a 3D segmentation and interactive visualization workflow. The segmentation implementation uses a globally convex multiphase active contours without edges. This algorithm has been proven to be initialization independent due to their globally convex formulation and better than other approaches due to robustness to image variations and adaptive energy functionals. The workflow includes a flexible 3D visualization application that can handle very large volumes using multi-resolution hierarchical data formats following the segmentation. We also designed a custom fragment shader that is capable of meaningfully fusing the data from three different volumes: a segmented label volume, a mean value per voxel volume and a skull striped volume for effective visualization without modifying the segmented results. Giving researchers the access to a whole end to end pipeline, from 3D segmentation to custom real time interactive 3D visualization is, in our opinion, a powerful tool focused on an analyst/expert centric workflow.

Fluid simulation using meshless methods has increasingly become a robust way to solve mechanics problems that require dealing with large deformations, and has become very popular in many applications such as naval engineering, mechanical engineering, movies and games. One of the main methods is the Smoothed Particle Hydrodynamics (SPH). This work has two main goals: to propose a multiphase SPH formulation by extending the work of Silva et al. and to propose a shader based render solution for this kind of simulation. The proposed SPH method was able to simulate multiphase fluids with up to one million particles and the renderer was able to generate visually plausible results up to 60fps.

Fluid simulation, specifically the Material Point Method (MPM) based simulation, requires a large number of particles and a big grid size to create a realistic looking simulation. This paper explains what we can do to improve the performance of the simulation by using compute shader and the strategy behind it. Compute shader is a shader used for General Purpose Graphics Processing Unit (GPGPU) programming, running in a separate pipeline than the rendering pipeline. Since the MPM simulation requires serialized code to update the values of the grid nodes and particles, it becomes a challenge to implement it into a parallelized code that can be run on the GPU with compute shader. First, we have to plan which part of the code that can be parallelized. We also have to translate the code into a GLSL program that doesn't have any C/C++ pointer and Object Oriented class. We then compare the simulation performance between the one running on CPU and the compute shader one, and see how much improvement is made by implementing it with compute shader.

Presilicon simulation is one of the key toolsets for computer architects to evaluate and optimize their future designs. As Graphics Processing Units (GPUs) have become the platform of choice in many computing communities due to their impressive processing capabilities, computer architecture researchers need a simulation framework that allows them to quantitatively consider design tradeoffs. In this paper, we present the Multi2Sim Kepler simulator framework, a new detailed GPU microarchitecture performance simulator that supports NVIDIA's Kepler shader assembly (SASS) code execution. The toolset provides a disassembler, a functional simulator and a detailed cycle-based simulator. We provide insight into the architecture of the NVIDIA Kepler GPU, describing the details of the streaming multiprocessor, front-end and instruction pipelines. We compare the performance of this new simulator against an NVIDIA K20X, a high-end Kepler device. We also evaluate the performance of NVIDIA's CUDA benchmark suite on our GPU performance simulator.

Finding the best suitable environment for 3D navigation that utilizes at least six degrees-of-freedom is still difficult. Furthermore, creating a system to procedurally generate a large virtual environment provides an opportunity for researchers to understand this problem further. Therefore, we present a novel technique to render a parametric celestial skybox with the ability to light environments similar to natural color corrected images from telescopes. We first pre-compute a spherical ray map that corresponds to the cubemap coordinates, then generate stars and dust through a combination of different noise generation shaders.

The importance of visual elements in video games is increasing, and players demand high quality graphics. To reach more of the target market, game developers need to maintain good performance while still delivering high quality graphical effects. Game developers want to use the most efficient ways to render game graphics, specifically particle systems, one of the most resource intensive elements in a game. Geometry shader is a new technology that was proposed to offer the right capability in rendering particle systems. The aim of this paper is to find out whether geometry shader is more efficient to render particle systems by analyzing the performance differences and resource consumption between rendering particle systems using a CPU and geometry shader. These research experiments support the power of a GPU-based geometry shader approach to render particle systems compared to the CPU rendering of particle systems. Geometry shader is shown to be effective and provides sufficient benefits for optimizing the geometry generations. However, the benefits of the geometry shader approach diminish when the particle size increases and the screen resolution gets higher.

During the using of 3D meshes, the different level of detail (LOD) meshes are needed for a model. This paper presents an algorithm of mesh reconstruction based on view maps. It bases the rendering pipeline, performs the coordinate transform and records the original coordinates of the mesh during the vertex shader. It interpolates the vertex's 3D coordinates for every pixel in the rasterization step. During the pixel shader, it extracts the visible pixels through the depth testing, and then outputs the corresponding 3D coordinates as a view map. According to pixel's relative position in the map, it connects the 3D vertices together to make a triangle mesh for the current view. The result LOD mesh can be obtained by merging these triangle meshes for different views. The experiments show that the algorithm is effective, speedy and convenient for adjusting the LOD.

Particle systems are widely used to create visual effects with a large number of elements (or particles). Earlier works were CPU based, while recent developments use the GPU to take advantage of the fact that, in most cases, particles are independent entities. In here, we propose a GPU-based library that focuses on extensibility and ease of use. The library allows for virtually any particle logic to be implemented, supporting fully programmable shader based effects, facilitating the definition of multiple resources and providing full control over the particle system’s simulation execution. Projects can be easily specified using XML, and extended via shaders and stubs, C functions that can be executed in between particle system’s processing stages. The examples presented illustrate the potential of the API, with multiple particle systems acting in a sequence, later extended to create custom graphic effects., COMPETE: POCI-01- 0145-FEDER-007043 and FCT – Fundaçãao para a Ciência e Tecnologia within the Project Scope: UID/CEC/00319/2013

In the past thirty years, with the tremendous development of computer graphics, various techniques have been proposed to solve problem of medical images, like CT and MRI data, visualization[1][2]. These techniques include iso-surface rendering [3][4], volume ray casting[5][6], texture-based volume rendering and so on. Sometimes it is necessary to perform medical grinding work to cure a person in operation like otitis. The corresponding parts around ears in application cannot display on the screen like it disappeared in real world. This paper will present a basic surgical navigation framework and provide a method to display the medical data volume dynamic in surgical navigation system. The visualization technique is direct volume rendering that do not extract any polygon meshes from volumetric data and can easily implement on GPU by OpenGL shader program. It also employs a mask to control whether this part of input model should display on the screen. The mask is as the same dimensions as the input volumetric data. To eliminate the jagged edges and achieve iterative rate, a 3D Gaussian filter loaded in shader program executed by GPU (Graphics Processing Unit).

Volume rendering is an important area of study in computer graphics, due to its application in areas such as medicine, physic simulations, oil and gas industries, and others. The main used method nowadays for volume rendering is ray casting. Nevertheless, there are a variety of parallel APIs that can be used to implement it. Thus, it is important to evaluate the performance of ray casting in different parallel APIs to help programmers in selecting one of them. In this paper, we present a performance comparison using OpenGL® with fragment shader, OpenGL® with compute shader, OpenCL, and CUDA.

Nowadays, mobile devices, virtual reality and augment reality technologies are developing faster and faster. With a variety of equipments, people are no longer only using PC to handle tasks. Some traditional system frameworks are migrating to these new technology areas, and direct volume rendering is one of them. In this paper, we propose a real-time and intuitive volume data exploration framework on mobile devices. Our framework introduces a direct-touch transfer function design method that is able for the user to pick voxels directly on a volume rendered image. With one-pass shader, user interaction and volume rendering can be handled efficiently in real-time. The user only needs to learn a few related knowledge to explore a volume data and get its rendered image. As a result, the time cost of transfer function design for direct volume rendering is significantly reduced. Our framework is implemented with OpenGL ES 3.0 and GLSL shader. Experimental results show the advantages of our framework. Researchers, and even general users, can easily obtain volume rendered images of volume data.

Interactive rendering of illumination from area lights in virtual worlds has always proved to be challenging. In this paper, we extend the work of multi resolution rendering for direct illumination from area lights. We propose a deferred shading method for direct illumination which subdivides screenspace into multi resolution 2D-fragments in which higher resolution fragments are created to represent geometric and depth discontinuities as well as shadow boundaries. To detect shadow boundaries, our subdivision scheme, sub-fragment visibility test (SFVT), performs a visibility discontinuity check within each fragment and subdivides the fragment to a higher resolution level if discontinuity is found. In addition, our proposed gradient aware screenspace subdivision (GASS) algorithm accelerates the refinement by increasing the number of subdivisions based on gradient differences. Our technique utilizes the stream-compaction feature of the transform feedback shader (TFS) in the graphics shading pipeline to filter out fragments for soft shadow refinement. A single pass screenspace irradiance upsampling scheme which uses radial basis functions (RBF) is proposed for interpolating scattered fragments. This reduces artifacts caused by large fragments. Our technique does not require precomputations and is able to run at interactive rates.