3. The Techniques

4. Separable Bokeh Depth-of-Field

5. Hi-Z / Z-Cull Reverse Reload Tricks

6. Chroma Sub-Sampled Image Processing

7. Tiled-Based Deferred Shading on Xbox 360

8. Temporally-Stable Screen-Space Ambient Occlusion

11. 5 Pillars:

12. Animation

13. Audio

14. Scale

15. Destruction

16. Rendering

19. publications.dice.se

27. Lens Length (derive from FOV)

28. F/Stop

29. Focal Plane

32. Store CoC in alpha

33. Recover colour by doing col.rgb /= col.a

36. Common in DX9 games. Cheap

37. 2D Area samples

38. Limited kernel size before texture tap explosion

39. GS expanded Point Sprites

40. Heavy fill rate

43. Gaussian blurs can be made separable O(N)

44. What 2D blurs can be made separable?

45. Gaussian

46. Box

50. Each rhombi can be computed via separable blur

53. But 7 passes and 6 blurs is not competitive

62. 2 Passes with a total of 2 blurs

63. Hexagonal

64. 2 Passes (3 resolves) with a total of 4 blurs

65. BUT each blur only needs half the taps therefore same #taps

66. BUT each tap contributes equally unlike Gaussian so need less taps for a given aesthetic filter kernel width!

69. Multiple passes fill in the under-sampling

73. However pixel shaders are designed to gather they can’t scatter the results

74. Typical blurs default the filter kernel to the CoC of pixel

77. You can then draw the plane at Z depth of 0.001f

78. In focus pixels will be quickly rejected by Hi Z

79. Same for iterative refinement

83. Stores a Low Res version of the Z buffer

84. Can use this to conservatively reject groups of pixels

91. Init aliased RT to D3DHIZFUNC_GREATER_EQUAL

96. By rendering the backfaces of convex polyhedra, pixels beyond the faces will quickly reject

97. If the camera is inside the volume then only pixels inside the volume will pass

101. Only world space pixels inside the cuboid will project onto the shadow map

121. Decompose image into luminance and chroma

124. Easy to optimise ALU down

125. Quickly hit a performance ceiling, especially for 16bpp pixels

126. Reading and writing a 720p image with 16bpp components is 14MB bandwidth

129. ¼ of the bandwidth required

130. Requires extra processing on the Colour

131. But this can be 2 channel at ¼ res ( 1/8 original size )

134. So, are the shaders now 4X quicker?

135. No. We are ALU bound again

136. Texture units and ALU are designed for 4 component SIMD

137. We are only using 1 component

140. Only need 1 texread to get 4 luma values

141. So a 1280x720 luma buffer is a 320x720 ARGB buffer

142. With the packed buffer bilinear filtering is not correct

143. Have to manually filter horizontally using DOTP

148. Mirror around the image center point

155. Platform is fixed  better usage of rendering resources

156. [Swoboda09] and [Coffin11] on Playstation3™, by [Andersson09] in DirectCompute, and other hybrids

157. Christina, Johan and I teamed-up for this version on 360

164. Fortunately, Xenos is powerful, and will crunch ALU

165. For maximal throughput, data at rendering time has to be cleverly pre-digested

166. If timed properly, we can also use the CPUs to help the GPU along the way...

167. GPU is better at analyzing a scene than CPUs…

170. Downsample and classify the scene from 720p to 40x23 (1 pixel == 1 tile)

171. Find each tile’s Min/Max depth

172. Find each tile’s material permutations

173. Downsampling is done in multi-pass and via MRTs

179. Cull lights against sky-free tiles in a shader

180. Store the culling results in a texture:

181. Column == Light ID

182. Row == Tile ID

183. Actually, 4 lights can be processed at once (A-R-G-B)

186. For each light type, For each tile, For each material permutation,

187. Regroup & set the light parameters for the PS constants

188. Setup the shader loop counter*

193. C: Cull

194. Light: Lighting pass

197. This WILL kill performance

198. To prevent, use the aL register when iterating over lights [Pritchard10]

199. If set properly, ALU / lighting will run at 100% efficiency

203. These shaders are ALU bound

204. Simplify your math, especially in the loops!

205. Get rid of complicated non 1:1 instructions (e.g. smoothstep)

206. Play with microcode: -normalize(v) is faster than normalize(-v)

209. Texture sampler scale/bias (*2-1)

210. Simplify / remove unneeded code via permutations

211. Upload constants via the constant buffer pointers

212. We use async pre-compiled command buffers (APCBs)

213. Keep them lean & mean (check contents in PIX)

218. Line sample [Loos10], with linear depth in a texture

219. Linearize depth for better precision/distributionkZ = – far * near / (far – near); kW = far / (far – near)linearDepth = kZ / (z - kW)

220. Sample linear depth texture with linear sampling

221. Scale SSAO parameters over distance

222. Final compositing with Hi-Stencil, reject sky pixels

228. On consoles, we have really tight budgets

229. Scenes are pretty action-packed, halos not too noticeable

230. AO should be a subtle effect

233. 1 horizontal tap == 4 taps (ARGB)

234. Combine with bilinear sampling (vertical pass only)

235. 9x9 Gaussian = 3 horizontal taps and 5 vertical taps

236. On PS3: alias the memory directly

241. Johan Andersson

242. Ivan Nevraev

243. Daniel Collin

244. Khalid Khalkhouli

245. Andrew Routledge

246. Stephen Hill

247. Aurelio Reis

248. Alex Ferrier

249. Fredrik Seehussen

250. Alex Fry

251. Natalya Tatarchuk