Jump to content
  • Advertisement

b34r

Member
  • Content Count

    293
  • Joined

  • Last visited

Community Reputation

365 Neutral

About b34r

  • Rank
    Member
  1. Quote:Original post by IrYoKu1 IMHO it seems not to be so much faster. Our MLAA approach here runs a 1080p image in ~1ms in the same GPU. But it all depends how much less from 1ms takes NFAA (in the post says <1ms =) Nice, I was not aware of a practical GPU implementation of MLAA. The variant of an AA filter I proposed in the NFAA thread is basically 9 (very localized) texture fetch and I think that it can be reduced to 8 samples with no visual difference. I would not be surprised if it could very easily be brought down to 4 samples and weighting with a bit of brainstorming. I would have liked to try this 1ms MLAA but it does not seem to be public?
  2. You can check this thread for a much faster alternative to MLAA for deferred renderers. On the topic of the Z-prepass I'd like to add that you have to take in account the batch count of your scene. A Z-prepass implies an additional run through your batches which can be very expensive. If you have very careful artists with a strong discipline you might be ok but batches are in my experience the #1 worst performance enemy in a standard game scenario and they can quickly add up the more you add passes. It is not always possible to efficiently merge tri-strips/lists under a few giant A-only draw calls due to transformation, alpha textures, etc...
  3. Hi, Very nice results! Unfortunately I could not reproduce them no matter how. So I came up with my own version of your filter. It requires slightly less samples and still gives very good results. I made a blog entry about it and here is the GLSL filter. w controls the width of the filter (how large the edges will get) and the threshold (hard-coded comparison to 1.0/6.0) prevents over blurring edges that might not need it. float lumRGB(vec3 v) { return dot(v, vec3(0.212, 0.716, 0.072)); } void main() { vec2 UV = gl_FragCoord.xy * inverse_buffer_size; float w = 1.75; float t = lumRGB(texture2D(source, UV + vec2(0.0, -1.0) * w * inverse_buffer_size).xyz), l = lumRGB(texture2D(source, UV + vec2(-1.0, 0.0) * w * inverse_buffer_size).xyz), r = lumRGB(texture2D(source, UV + vec2(1.0, 0.0) * w * inverse_buffer_size).xyz), b = lumRGB(texture2D(source, UV + vec2(0.0, 1.0) * w * inverse_buffer_size).xyz); vec2 n = vec2(-(t - b), r - l); float nl = length(n); if (nl < (1.0 / 16.0)) gl_FragColor = texture2D(source, UV); else { n *= inverse_buffer_size / nl; vec4 o = texture2D(source, UV), t0 = texture2D(source, UV + n * 0.5) * 0.9, t1 = texture2D(source, UV - n * 0.5) * 0.9, t2 = texture2D(source, UV + n) * 0.75, t3 = texture2D(source, UV - n) * 0.75; gl_FragColor = (o + t0 + t1 + t2 + t3) / 4.3; } } Btw, I played with temporal anti-aliasing and there really is something great to be done on this front too. The main issue to solve is about how to combine jittered frames without introducing too much ghosting artifacts. Cheers
  • 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!