MassFX Shader Pack

• Fake HDR & Tonemapping:
  Fake HDR can provide eye adaptation and tonemapping can increase the details of an image a lot, a white fix is also available for LDR games.
• Physically-Based Bloom:
  Inspired by the bloom shaders seen in Unreal 4 and Minecraft SEUS, although technically not 100% physically based it still allows for a very realistic effect.
• Mouse-Based Motion Blur:
  A simple motion blur effect that is based on mouse velocity and optionally depth as well.
• Vignette:
  Simple but great, tinting is also available.
• LUT:
  Color lookup table, color grading based on a texture, allowing for various color filters to be created with GIMP/Photoshop, a small tutorial is included as well as some presets in MassFX\Textures\LUTs.
• Grain:
  A simple shader that simulates film grain with a pseudo-random grain pattern, it can also be affected by brightness.

matsilagi wrote: If you add some lensdirt which gets the same color from Bloom i will certainly use this a lot.

I know it may be hard because of the LDR colorspace but, its worth a try.

I took a quick look at it, can't you just save position and velocity in the same texture? It saves you from using 2 different textures. And IIRC, RG16F has no improvement over RGBA16F, or atleast, it doesn't seem to.

	float3 Downsample1(v2f i) : SV_Target {
		return Blur(2, ReShade::BackBuffer, i.uv).rgb;
	}
	
	float3 Downsample2(v2f i) : SV_Target {
		return Blur(4, sTex1, i.uv).rgb;
	}
	
	float3 Downsample3(v2f i) : SV_Target {
		return Blur(8, sTex2, i.uv).rgb;
	}
	
	float3 Downsample4(v2f i) : SV_Target {
		return Blur(16,sTex3, i.uv).rgb;
	}
	
	float3 Downsample5(v2f i) : SV_Target {
		return Blur(32, sTex4, i.uv).rgb;
	}
	
	float3 Downsample6(v2f i) : SV_Target {
		return Blur(64, sTex5, i.uv).rgb;
	}
	
	float3 Downsample7(v2f i) : SV_Target {
		return Blur(128, sTex6, i.uv).rgb;
	}
	
	float3 Downsample8(v2f i) : SV_Target {
		return Blur(256, sTex7, i.uv).rgb;
	}

The effect might not always be physically correct but it can help to hint the relative brightness of objects or add realism to the LDR (low dynamic range) image that is shown on the screen.

luluco250 wrote:

I took a quick look at it, can't you just save position and velocity in the same texture? It saves you from using 2 different textures. And IIRC, RG16F has no improvement over RGBA16F, or atleast, it doesn't seem to.

I haven't took time to optimize the MBMB code yet, I was occupied with the PBB shader.
But I am looking forward to do so, you do have a point I could create a 2x2 texture where int2(0,0) is the last position and int2(1,1) is the velocity, will take a look at it.

luluco250 wrote: According to the Unreal 4 Elemental tech demo paper, they apply bloom the following way:

If you are referring this:
de45xmedrsdbp.cloudfront.net/Resources/f..._16x9-1248544805.pdf

then what I proposed is pretty much what they're doing. (see slider 61)

btw, UE4 bloom has nothing to do with PBR... it is even in the description: docs.unrealengine.com/latest/INT/Engine/...cts/Bloom/index.html

kingeric1992 wrote: Gaussian alone is a good approximation. (without stacking them, which is used to compensate the HDR range)
en.wikipedia.org/wiki/Airy_disk

Warning: Spoiler!

But if ignoring the performance impact, the legit way is through

f = FFT(original image) * Aperture * lens dirt
result = InverseFFT( f )

Basically, Bloom and Lens Flares (the strip one, not the ghosting flare) are caused by same thing, light diffraction, under different characteristic aperture.

and another paper,
resources.mpi-inf.mpg.de/lensflareRendering/pdf/flare.pdf

btw, reshade can also perform pixel shader based FFT and iFFT, there is a gpu gem on radix-2 algorithm.
however, higher radix should be possible with multiple render target setup.

3dmark11 WhitePaper wrote: Bloom
The effect is computed by transforming the computed illumination to frequency domain using Fast Fourier
Transform (FFT) and applying bloom filter to the input in that domain. An inverse FFT is then applied to the
filtered image. The forward FFT, applying the bloom filter and inverse FFT are done with the Compute Shader
(CS). The effect is computed in reduced resolution. The input image resolution is halved twice and then
rounded up to nearest power of two. The FFTs are computed using DXGI_FORMAT_R32G32B32A32_FLOAT
textures. A procedurally precomputed texture is used as the bloom filter. The filter combines blur, streak,
lenticular halo and anamorphic flare effects.