Dave Prout - Hack This

Halo: Anniversary

Dave Prout — Tue, 15 Nov 2011 03:21:27 +0000

LAUNCHING TONIGHT!

Halo Anniversary is the 10 year remake of the original Halo: Combat Evolved. Microsoft's 343 Industries worked with us (Certain Affinity) for the Multiplayer and Saber Interactive for the Single Player campaign.

Here are a bunch of goodies, all in one place.

FUN FACTS:

There are easter eggs in the MP maps - look for them!
Certain Affinity used the Halo:Reach engine to create the Multiplayer experience
This is our third launch for 2011. Crimson Alliance launched in September on XBLA, and it's doing very well. Halo: Reach: Defiant launched in the spring to a great reception as well.

REVIEWS

Destructoid [9.0] - http://bit.ly/sGeTq6
IGN [8.0] - http://bit.ly/vPDc5r
Edge [9.0] - http://bit.ly/sT4n2p

VIDEOS

(Below videos were captured prior to the "finishing" pass on each of the maps)

Multiplayer ViDoc (Certain Affinity)

"High Noon" (remake of "Hang 'em High")

"Battle Creek" (remake of "Beaver Creek")

"Pennance" (remake of "Damnation")

"Solitary" (remake of "Prisoner")

"Breakneck" (remake of "Headlong")

"Ridgeline" (remake of "Timberland")

"Installation 04" (Firefight version of "Reunion Tour" from the original Campaign)

As always, development is an exciting road, and this game was no exception. Check it out, and post back here with your thoughts if you like!

Halo Reach: Defiant / Behind the Scenes

Dave Prout — Wed, 16 Mar 2011 03:15:43 +0000

Halo Reach: Defiant Maps

Dave Prout — Mon, 14 Feb 2011 14:54:37 +0000

The curtain has finally been lifted on the project my team at Certain Affinity has been working hard on for the past year. I had the fortune of working as a Tech Art Lead for this project, and it's been a blast!

Full Article here:

http://www.joystiq.com/2011/02/14/halo-reach-defiant-map-pack/

Enjoy!

UDK Lighting and Post Processing

Dave Prout — Wed, 31 Mar 2010 20:01:49 +0000

I mentioned a week or so ago that I've been working on a new UDK training session through Eat3D. It's now headed into production - be sure to check it out!

UDK Lighting and Post Processing - Eat3D

Photoshop Folder Batches

Dave Prout — Fri, 12 Mar 2010 17:40:51 +0000

Been head-down for a couple of weeks; I've been earnestly working on some material for eat3D, so I've been preoccupied. So I thought I'd poke my head up for a simple trick.

From time to time, I have a ton of bitmap files I need to adjust in some way (anyone remember Debabelizer?). Photoshop has a feature to run an action on all of the images in a given folder.

Here's how to do it:

One of those that is occasionally used and often forgotten. Enjoy!

Ripples for Free: Sine Wave Water

Dave Prout — Wed, 27 Jan 2010 02:53:36 +0000

In early 2008, I had the pleasure of working with several senior graphics engineers at Midway Games Austin. One of them was Stephen Baker, from whom I learned a ton. Though the game ended up being cancelled, some of the solutions we came up with are excellent know-how, worth sharing.

Epic's DM-Deck map used in this example

Steve and I worked together on Criminal, which was an open-world game using Unreal Engine 3 -- an engine which is amazing for games with constrained environments, but struggles with open-world layouts. Needless to say, performance and memory footprint were one of the highest priorities of our lives.

The credit for this nifty trick goes to Steve, who has given me permission to reproduce it here (thanks Steve!). Be sure to check out Steve's Site as well.

Why do we care about free?

In particular, a shader which requires a texture (otherwise known as "Maximum Texture Dependency Length", or "M.T.D.L." in UE3) to drive another, is incredibly slow.

NOTE: There is a hidden M.T.D.L. dependency when using the "ReflectionVector" node in the Material Editor --it will not have the magenta outline.

To quote Steve:

The problem isn't that the shader has more than one texture - it's that the output of one texture is used (whether directly or indirectly) to drive the texture coordinate for a second texture. I've always called this a "dependant texture" where one texture depends on the other. This is bad because the shader compiler breaks the code up into three bits: Before texture lookup, Texture lookup and After texture lookup. This is so that one GPU processor can be running the "Before" part for one pixel while the texture hardware is looking up the maps for the previous pixel and a different GPU processor is running the "After" part of the pixel before that. That way nobody has to wait while the textures are being looked up. That means that it has to reshuffle your code around so that all of the textures can be looked up at the same time. The texture lookup part can look up a lot of textures in parallel - so putting a modest number of textures into a single shader isn't all that expensive.

BUT - if you have the texture coordinate input of one map being provided by the output of another map then there is no way to split the program into those three parts because it can't look up the second texture until it's figured out what was in the first one (and maybe done some math on it). So what it has to do is to run the shader in two internal passes where it does the true "Before" part, looks up the first texture, then skips over the "After" part - does a SECOND trip through the "Before" part to run any math that has to be done on the output of the first texture - then it can do the lookup of the second texture and finally run a second "After" bit to. This means that the shader takes at least twice as long as it should - and probably much worse than that because of all of the internal reconfiguring going on.

Replacing that first texture with some math breaks that double-cost - and makes the shader run at least twice as fast.

Here are a couple of videos to compare their motion.

Implemented the standard way in the Material Editor, and a simple puddle can suck entire milliseconds from your GPU time (or if you're less technically inclined, think of it costing a couple of frames per second). Too expensive for a shipping game. BUT....we like rippling water. We like it a lot. And that's why you should care about getting ripples for free. Here's how to do it.

Expensive Ripples - Shader Graph - click to enlarge

Cheap Ripples - Shader Graph - click to enlarge

Again, many thanks to Steve. We can all now have free ripples without fearing the wrath of graphics engineers!

Material Post Effects Lab: Distance Color Blending

Dave Prout — Tue, 19 Jan 2010 04:51:52 +0000

As mentioned in past posts, the Unreal Post Effects system is tremendously powerful. One of the least-explored areas of UE3 is material-based post effects, which is simply one of the coolest pieces of the software.

For this post, I'm using the "DM-Sanctuary" map included in Epic's UDK.

Original Image --> Distance Color Blend Image --> Depth Mask

Using the Scene Depth node, you can create a realtime depth mask to use in your shader, which I tend to do a lot. One of the quick-and-easy benefits of using a depth mask is that you can tune foreground and background chroma and value independently to dial in the effect you're after.

For the purposes of this post, I've created a shader graph that enables foreground- and background-specific colors (currently multiplied), and individual saturation control. The shader graph can easily be modified to control foreground/background brightness as well, or anything else you might dream up. (See the link at the end of this post for the actual .upk file.)

Shader Graph (click to enlarge)

To bring the scene's depth into perceptible range, the node must be divided by a relatively large number (what I've labeled as the "Gradient Spread"). Here are some examples at different numbers. Notice the castle fades more quickly to blue the smaller the value:

Once created, the foreground and background colors will of course remain relative to the player's camera, rather than the scene. Notice how distance blues turn into oranges in the following progression:

Here is the UDK package file for the Distance Color Blend post effect material.

The Unreal Post Effects Chain

Dave Prout — Wed, 13 Jan 2010 14:21:31 +0000

Due to the tremendous response to Edge Detection using Material Post Effects, over the next couple of weeks I'll be posting some additional tips and tricks regarding Post Processing in Unreal. So check back often!

(This tutorial is utilizing Epic's free version of the Unreal Engine, the Unreal Developer's Kit, or UDK)

-------------------

For those just starting to experiment with post processing effects in Unreal, at the heart of it all is the default Post Process chain node. Here's how to find it:

1. Locate the DefaultEditor.ini file in your tree.

2. In Unreal's Content Browser, sort the packages by "All" and locate the post process node.

3. Open the post process node to see the post process chain.

The nodes in the chain can be moved and reorganized to get different effects, so experiment. Each node adds something new to your rendered frame. To get more detail, of course, click the node:

To preview the post process effects in your viewport, make sure "PostProcess Effects" is enabled:

Enjoy!

-------------------------------------

Coming Soon: The Material Post FX Laboratory

"Perception & Hallucination"

Dave Prout — Mon, 04 Jan 2010 15:16:49 +0000

Got a Camera? Have some Normal Maps!

It amazes me how discoveries as profound as this one take so long to permeate relevant industries in which they could affect. So, I'm here to do my part to spread the word on the genius discovery by Mashhuda Glenncross's team at the University of Manchester.

This technique produces much more accurate results than even the great flashlight technique by Ryan Clark.

Called "A Perceptually Validated Model for Surface Depth Hallucination" (which is really just a fancy way of saying, "Look, instant normal maps!"), this team has devised a way to create great normal maps based off of two photographs - one with a flash, and one without.

Further examination of the whitepaper details the steps one needs to take in order to reproduce this technique. (Warning: math content).

I have attempted myself to reproduce their results several times over the past year or so, but always run into the problem of needing to find a true subtract algorithm. If anyone out there knows of one, we'd love to hear about it. If you're up for some experimenting yourself, some of the images used in the video are available here.

Got Signed Distance Fields? Think about it.

Dave Prout — Wed, 30 Dec 2009 01:31:07 +0000

While working on a project at Midway Austin called Criminal, which was ultimately cancelled, a lot of excellent folks were pushing hard to get that open-world game to function within a Midway-augmented version of Unreal Engine 3.

For the environments, we set an aggressive 60MB memory + 12ms gpu limit, and we made great strides toward achieving it.

One of the excellent techniques we came across is Signed Distance Fields. Originally we learned of it via this Valve whitepaper and implemented a version of it in the Criminal engine. It essentially allows for crisp edges on tiny, blurry bitmaps at infinite magnification. (Think TrueType fonts.)

Earlier this year, Epic incorporated the technique into it light maps, and immediately switched the default light baking for static meshes back to light maps (from color vertex lighting, where it had been for years). It's briefly mentioned on this publicly available page on the UDN.

The result is great looking light maps for dramatically lower memory footprint, and can be baked in a fraction of the time. Visually, they become simplified in the same manner as the above logo.

It's an excellent and practical application of the technique to achieve high quality results.