<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Graphics on Miles Macklin</title>
    <link>http://blog.mmacklin.com/tags/graphics/</link>
    <description>Recent content in Graphics on Miles Macklin</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <copyright>&amp;copy; 2019 Miles Macklin</copyright>
    <lastBuildDate>Wed, 29 Dec 2010 08:21:08 +0000</lastBuildDate><atom:link href="http://blog.mmacklin.com/tags/graphics/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Blackbody Rendering</title>
      <link>http://blog.mmacklin.com/2010/12/29/blackbody-rendering/</link>
      <pubDate>Wed, 29 Dec 2010 08:21:08 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2010/12/29/blackbody-rendering/</guid>
      <description>In between bouts of festive over-eating I added support for blackbody emission to my fluid simulator and thought I&#39;d describe what was involved.
Briefly, a blackbody is an idealised substance that gives off light when heated. Planck&#39;s formula describes the intensity of light per-wavelength with units W·sr-1·m-2·m-1 for a given temperature in Kelvins.
Radiance has units W·sr-1·m-2 so we need a way to convert the wavelength dependent power distribution given by Planck&#39;s formula to a radiance value in RGB that we can use in our shader / ray-tracer.</description>
    </item>
    
    <item>
      <title>Adventures in Fluid Simulation</title>
      <link>http://blog.mmacklin.com/2010/11/01/adventures-in-fluid-simulation/</link>
      <pubDate>Tue, 02 Nov 2010 01:34:27 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2010/11/01/adventures-in-fluid-simulation/</guid>
      <description>I have to admit to being simultaneously fascinated and slightly intimidated by the fluid simulation crowd. I&#39;ve been watching the videos on Ron Fedkiw&#39;s page for years and am still in awe of his results, which sometimes seem little short of magic.
Recently I resolved to write my first fluid simulator and purchased a copy of Fluid Simulation for Computer Graphics by Robert Bridson.
Like a lot of developers my first exposure to the subject was Jos Stam&#39;s stable fluids paper and his more accessible Fluid Dynamics for Games presentation, while the ideas are undeniable great I never came away feeling like I truly understood the concepts or the mathematics behind it.</description>
    </item>
    
    <item>
      <title>Tracing</title>
      <link>http://blog.mmacklin.com/2010/10/03/tracing/</link>
      <pubDate>Sun, 03 Oct 2010 23:37:47 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2010/10/03/tracing/</guid>
      <description>Gregory Pakosz reminded me to write a follow up on my path tracing efforts since my last post on the subject. It&#39;s good timing because the friendly work-place competition between Tom and me has been in full swing. The great thing about ray tracing is that there are many opportunities for optimisation at all levels of computation. This keeps you &#34;hooked&#34; by constantly offering decent speed increases for relatively little effort.</description>
    </item>
    
    <item>
      <title>Faster Fog</title>
      <link>http://blog.mmacklin.com/2010/06/10/faster-fog/</link>
      <pubDate>Fri, 11 Jun 2010 03:24:11 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2010/06/10/faster-fog/</guid>
      <description>Cedrick at Lucas suggested some nice optimisations for the in-scattering equation I posted last time.
I had left off at:
\[L_{s} = \frac{\sigma_{s}I}{v}( \tan^{-1}\left(\frac{d+b}{v}\right) - \tan^{-1}\left(\frac{b}{v}\right) )\]
But we can remove one of the two inverse trigonometric functions by using the following identity:
\[\tan^{-1}x - \tan^{-1}y = \tan^{-1}\frac{x-y}{1+xy}\]
Which simplifies the expression for $L_{s}$ to:
\[L_{s} = \frac{\sigma_{s}I}{v}( \tan^{-1}\frac{x-y}{1+xy} )\]
With $x$ and $y$ being replaced by:
\[\begin{array}{lcl} x = \frac{d+b}{v} \\ y = \frac{b}{v}\end{array}\]</description>
    </item>
    
    <item>
      <title>In-Scattering Demo</title>
      <link>http://blog.mmacklin.com/2010/05/29/in-scattering-demo/</link>
      <pubDate>Sat, 29 May 2010 23:32:07 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2010/05/29/in-scattering-demo/</guid>
      <description>This demo shows an analytic solution to the differential in-scattering equation for light in participating media. It&#39;s a similar but simplified version of equations found in[1], [2] and as I recently discovered [3]. However I thought showing the derivation might be interesting for some out there, plus it was a good excuse for me to brush up on my  \(\LaTeX\).
You might notice I also updated the site&#39;s theme, unfortunately you need a white background to make wordpress.</description>
    </item>
    
    <item>
      <title>GOW III: Shadows</title>
      <link>http://blog.mmacklin.com/2010/03/11/gow-iii-shadows/</link>
      <pubDate>Fri, 12 Mar 2010 06:09:31 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2010/03/11/gow-iii-shadows/</guid>
      <description>I checked out this session at GDC today - I&#39;ll try and sum up the main takeaways (at least for me):

Artist controlled cascaded shadow maps, each cascade is accumulated into a &#39;white buffer&#39; (new term coined?) in deferred style passes using standard PCF filtering
Shadow accumulation pass re-projects world space position from an FP32 depth buffer (separate from the main depth buffer). The motivation for the separate depth buffer is performance so I assume they store linear depth which means they can reconstruct the world position using just a single multiply-add (saving a reciprocal).</description>
    </item>
    
    <item>
      <title>Stochastic Pruning (2)</title>
      <link>http://blog.mmacklin.com/2010/02/07/stochastic-pruning-2/</link>
      <pubDate>Sun, 07 Feb 2010 07:39:41 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2010/02/07/stochastic-pruning-2/</guid>
      <description>A quick update for anyone who was having problems running my stochastic pruning demo on NVIDIA cards, I&#39;ve updated the demo with a fix (I had forgotten to disable a vertex array).
While I was at it I added some grass:

The grass uses stochastic pruning but still generates a lot of geometry, it&#39;s just one grass tile flipped around and rendered multiple times. I wanted to see if it would be practical for games to render grass using pure geometry but really you&#39;d need to be much more aggressive with the LOD (Update: apparently the same technique was used in Flower, see comments).</description>
    </item>
    
    <item>
      <title>Stochastic Pruning for Real-Time LOD</title>
      <link>http://blog.mmacklin.com/2010/01/12/stochastic-pruning-for-real-time-lod/</link>
      <pubDate>Tue, 12 Jan 2010 07:28:31 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2010/01/12/stochastic-pruning-for-real-time-lod/</guid>
      <description>Rendering plants efficiently has always been a challenge in computer graphics, a relatively new technique to address this is Pixar&#39;s stochastic pruning algorithm. Originally developed for rendering the desert scenes in Cars, Weta also claim to have used the same technique on Avatar.
Although designed with offline rendering in mind it maps very naturally to the GPU and real-time rendering. The basic algorithm is this:
 Build your mesh of N elements (in the case of a tree the elements would be leaves, usually represented by quads)</description>
    </item>
    
    <item>
      <title>Sky</title>
      <link>http://blog.mmacklin.com/2009/12/31/sky/</link>
      <pubDate>Thu, 31 Dec 2009 22:46:48 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2009/12/31/sky/</guid>
      <description>I had been meaning to implement Preetham&#39;s analytic sky model ever since I first came across it years ago. Well I finally got around to it and was pleased to find it&#39;s one of those few papers that gives you pretty much everything you need to put together an implementation (although with over 50 unique constants you need to be careful with your typing).
I integrated it into my path tracer which made for some nice images:</description>
    </item>
    
    <item>
      <title>Path Tracing</title>
      <link>http://blog.mmacklin.com/2009/12/02/path-tracing/</link>
      <pubDate>Thu, 03 Dec 2009 06:59:48 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2009/12/02/path-tracing/</guid>
      <description>A few of us at work have been having a friendly path-tracing competition (greets to Tom &amp;amp; Dom). It&#39;s been a lot of fun and comparing images in the office each Monday morning is a great motivation to get features in and renders out. I thought I&#39;d write a post about it to record my progress and gather links to some reference material.
Here&#39;s a list of features I&#39;ve implemented so far and some pics below:</description>
    </item>
    
    <item>
      <title>Trees (the green kind)</title>
      <link>http://blog.mmacklin.com/2009/09/28/trees-the-green-kind/</link>
      <pubDate>Mon, 28 Sep 2009 17:13:26 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2009/09/28/trees-the-green-kind/</guid>
      <description>I&#39;ve always had an interest in computer generated plants so I was pleased to read Self-organising tree models for image synthesis from Siggraph this year.
The paper basically pulls together a bunch of techniques that have been around for a while and uses them to generate some really good looking tree models.
Seeing as I&#39;ve had a bit of time on my hands between Batman and before I start at LucasArts I decided to put together an implementation in OpenGL (being a games programmer I want realtime feedback).</description>
    </item>
    
    <item>
      <title>Tim Sweeney&#39;s HPG talk</title>
      <link>http://blog.mmacklin.com/2009/08/14/tim-sweeneys-hpg-talk/</link>
      <pubDate>Fri, 14 Aug 2009 12:14:37 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2009/08/14/tim-sweeneys-hpg-talk/</guid>
      <description>This link was going round our office, a discussion over at Lambda the Ultimate regarding Tim Sweeney&#39;s HPG talk.
http://lambda-the-ultimate.org/node/3560
Tim chimes in a bit further down in the comments.</description>
    </item>
    
    <item>
      <title>Handy hints for Bovine occlusion</title>
      <link>http://blog.mmacklin.com/2009/07/24/handy-hints-for-bovine-occlusion/</link>
      <pubDate>Fri, 24 Jul 2009 10:42:55 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2009/07/24/handy-hints-for-bovine-occlusion/</guid>
      <description>Code517E recently  reminded me of a site I&#39;ve used before when looking up form factors for various geometric configurations.
One I had missed the first time though is the differential element on ceiling, floor or wall to cow.
http://www.me.utexas.edu/~howell/sectionb/B-68.html
Very handy if you&#39;re writing a farmyard simulator I&#39;m sure.</description>
    </item>
    
    <item>
      <title>Particle lighting</title>
      <link>http://blog.mmacklin.com/2009/06/15/particle-lighting/</link>
      <pubDate>Mon, 15 Jun 2009 22:39:50 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2009/06/15/particle-lighting/</guid>
      <description>I put together an implementation of the particle shadowing technique NVIDIA showed off a while ago. My original intention was to do a survey of particle lighting techniques, in the end I just tried out two different methods that I thought sounded promising.
The first was the one ATI used in the Ruby White Out demo, the best take away from it is that they write out the min distance, max distance and density in one pass.</description>
    </item>
    
    <item>
      <title>Red balls</title>
      <link>http://blog.mmacklin.com/2009/04/01/red-balls/</link>
      <pubDate>Wed, 01 Apr 2009 23:00:13 +0000</pubDate>
      
      <guid>http://blog.mmacklin.com/2009/04/01/red-balls/</guid>
      <description>A small update on my global illumination renderer, I&#39;ve ported the radiance transfer to the GPU. It was fairly straight forward as my CPU tree structure was already set up for easy GPU traversal, basically just a matter of converting array offsets into texture coordinates and packing into an indices texture.
The hardest part is of course wrangling OpenGL to do what you want and give you a proper error message.</description>
    </item>
    
  </channel>
</rss>
