- if texture are edited in Gimp/Photoshop are most probably in sRGB space, so you must convert in linear color space manually inside the shader or use GL_TEXTURE_SRGB version..

- if you framebuffer is not sRGB, call glEnable(GL_FRAMEBUFFER_SRGB) (OpenGL 3+) or manually convert via pow func inside the shader.

I noticed that point about “The input is implied to be at a reasonable exposure”, so instead of our typical “rendering colors between 0 and 1″ we might have to render to a higher range (-1000 .. 1000? who knows?) — but then, I thought that’s what the multiplier=16 would do for our LDR texture already.

I’m trying out the GLSL version of it. Unfortunately the image gets extremely saturated/exposed. Am I doing something wrong here:

//From Filmic Tonemapping, Uncharted: http://filmicgames.com/archives/75

uniform bool use_tex;
uniform sampler2D tex;
uniform bool use_tex_matrix;
uniform mat4 tex_matrix;
varying vec4 varying_color;
varying vec2 varying_texcoord;

float A = 0.15;
float B = 0.50;
float C = 0.10;
float D = 0.20;
float E = 0.02;
float F = 0.30;
float W = 11.2;
float exposurebias = 2.0;
float multiplier = 16.0;
float power = 0.454;

vec3 Tonemap(vec3 x)
{
return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;
}

vec3 performTonemap(vec3 tmp)
{
vec3 tmpmap;
vec3 cur;
vec3 newcur;
vec3 whitescale;
tmpmap = multiplier * tmp;
cur = Tonemap(exposurebias*tmpmap);
whitescale = 1.0/Tonemap(vec3(W, W, W));
newcur = cur*whitescale;
return vec3(pow(newcur.r, power), pow(newcur.g, power), pow(newcur.b, power));
}

void main(){
vec4 tmp=varying_color;
vec4 coord = vec4(varying_texcoord, 0.0, 1.0);
if (use_tex_matrix) {
vec4 sample;
coord = coord * tex_matrix;
sample = texture2D(tex, coord.st);
tmp *= sample;
}
else if (use_tex) {
vec4 sample = texture2D(tex, coord.st);
tmp *= sample;
}
//Everything till here works as a good passthrough pixel shader.
gl_FragColor=vec4(performTonemap(vec3(tmp.r, tmp.g, tmp.b)), tmp.a);
}

There are some cases that are harder but doable. Like thin pieces of geometry that are far away (like flag poles) could be solved switching to an alpha card far away, but few games do that because it’s not worth the effort. It’s kindof like LOD switching in a way. Back when the PS3 was being released Sony had all these presentations on how to automatically blend between LODs with no pops. And no one that I know of uses it because it’s not worth the trouble.

There are a few cases where to reduce aliasing you would have no option but to go with some variant of MSAA. But those cases are quite rare IMO. Triangles and draw calls will probably still be tight on next gen. That’s why any technique that starts with “and you need an extra render pass” is a nonstarter for me. Tiling with MSAA fits in that category.

One final note: Many artists don’t actually care what the final game looks like. Most do, but you’d be surprised how many obsess over how their art looks on their screen but don’t care what the player actually sees. In many cases they could fix the aliasing with better LODs but they don’t because they literally don’t care. I’ve seen it happen.

@Jonathan Swift:
Yep, I’d agree. With the one caveat that before these post techniques took off I was a huge proponent of at least 2x MSAA. 1x with no good cleanup looks bad enough that I have trouble focusing on anything else. Fortunately, FXAA and other variants fix that problem for me.

@Micki:
Good point on HDR and movement. Crawling jaggies are certainly much worse than regular ones. For HDR, I generally propose doing AA after tonemapping which is yet another advantage for post techniques over MSAA.

That leads to: geometry aliasing will be less and less important in future, it’s solvable quite easily (if you just want to hide geometry borders to the player). Shader/Material aliasing will become more of a problem. Imagine you want to draw a night sky (pure black:0×000000), with bright starts (pure white:0xffffff) – no fake alpha faded sprites- AND avoid any aliasing in motion. Some will say, you need twice the sampling frequency of the object you sample, … but of what? it’s not of the object size, but… ?
if you don’t want to see any aliasing, you’d need to ovesample in a way, that the brightness difference of some aprticular area (the one that maps to one ’sensor’ of your eye) stays relatively constant. you might assume you don’t see a brightness difference of 1/16th of the screen min/max, with the ‘twice the sampling frequency’ rule, it would mean we need to make around 32sample points.
And that’s just the case if you work with after-tonemapping AA, if you want to anti-alias HDR, you’ll need to have even more samples to not realize any aliasing. That explains why movies vary their super sampling between simple 7×7 and sometimes 39×39 (and add post effects to further hide aliasing, like blur+sharpen)