Jump to content
  • Advertisement
  • entries
  • comments
  • views

Graphics Programming weekly - Issue 54 — September 2, 2018



I am going to be on vacation for the next two weeks so this series will take a small break and will return on September 24th.

  • presents a filtering approach for a pixel art style in a 3D environment
  • discussion of filtering theory and derivation of a filter for real-time use
  • provides GLSL implementation of the filter
  • in-depth documentation for unity
  • explains the most common terms, the difference between the rendering pipelines with strengths and weaknesses
  • explains the difference between global illumination systems and light modes
  • provides 4 example scenarios that show how the desired game influences the decisions

  • shows how to reformulate the rendering equation so that stochastic shadows can be combined with non-stochastic shading
  • explains how to denoise the stochastic shadows
  • shows results and discusses the performance of the approach
  • start of a new Intel series about Vulkan
  • the focus is on the high-level usage and will be comparing different approaches to common problems
  • walkthrough of the structure of the series and how the sample code will be structured
  • investigates the performance effect of different acquire → render → present approaches
  • shows visually why two sets of frame resources are required to utilize the available hardware efficiently
  • the sample allows experimentations with different scene complexities and CPU workloads
  • explains the strategy how GPU memory is currently managed and what allocation strategy is used
  • shows a visual representation of allocator usage and discusses the weaknesses of the current approach, pointing to possible future improvements
  • tutorial on how to implement a candle flame using 3 separate texture channels and noise distortion using unity
  • discusses how the drunk effect in “The Witcher 3” was implemented based on reverse engineering the D3D11 shader disassembly
  • provides the reverse engineered HLSL source code
  • reusing a generic ray-triangle intersection for other calculations such as calculating the distance from a ray to a curve segment
  • unity tutorial that extends water with flow map (previous part of the series) to support transparent water rendering
  • apply underwater fog and approximation of refractions
  • overview how the large-scale ambient occlusion data is baked for Homefront: The Revolution
  • implemented using rasterization with an orthographic projection and per-pixel linked lists
  • runtime information stored in regularly spaced cells
  • article discussing what is required to achieve high-quality lightmaps
  • UV space rasterization, using a UV G-buffer to collect necessary information to trace rays
  • dealing with shadow leaks and UV seams
  • an algorithm to enable mipmap generation for lightmaps
  • explains why clipping happens in 4D clip space before the perspective divide is applied
  • blender developers view of the technologies shown at Siggraph
  • talking about USD / Hydra, MaterialX / ShaderX / OSL / Gaffer and OpenColorIO
  • overview of the open shading language in 3ds Max
  • how OSL was implemented into the 3ds max architecture
  • discusses problems encountered and improvement possibilities for OSL
  • explains what contact-hardening shadows are
  • presents one technique that can be used to implement them and deal with artifacts
  • discussions of a method to optimize the process by splitting the shadow mask generation into two passes
  • the first pass generates the penumbra mask at a quarter resolution and the second pass generates the soft shadows, sampling from the quarter resolution penumbra mask

  • the slides for all talks from the High-Performance Graphics 2018 conference have been uploaded
  • can now show register and LDS (Local data share) usage as well as theoretical occupancy
  • new render target overview table, provides information about all render targets in the frame in one location
  • more robust handling for applications that create multiple device contexts
  • explains how to pack an integer and a floating point number into a single unsigned render target channel
  • provides source code for packing and unpacking into a variable number of available bits

If you are enjoying the series and getting value from it, please consider supporting this blog.

Support this blog

Read more


Recommended Comments

There are no comments to display.

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!