ReShade - Advanced post-processing everywhere (SweetFX)

Which version of SweetFX is the fastest/lowest performance cost? Is it ReShade+SweetFX 2.0 Preview? I recently installed S.T.A.L.K.E.R. Shadows of Chernobyl with the Autumn Aurora 2 mod and I noticed it comes with a version of SweetFX, although I'm not sure which version. Because I'm also using the optional ENB I'm trying to maximize performance wherever possible.

 

Are you sure Stalker uses sweetfx? That would be a CLEAR violation of copyright infringment. See if there's a folder called "sweetfx" or something. I can't honestly see stalker being shipped with Sweetfx, but if it does, I'd sue their balls off if I was one of the developers of sweetfx. What makes you say this?

 

The Autumn Aurora 2 mod contains both SweetFX and ENB. NOT STALKER.

 

ReShade can be injected into MPC-HC as explained above. Also I ported some of the new shaders for MPC-HC use. You might use them until CeeJay releases a proper version.

FilmGrain:

Code:

  /*----------------.
  | :: FilmGrain :: |
  '----------------*/
/*
  FilmGrain version 1.0.0
  by Christian Cann Schuldt Jensen ~ CeeJay.dk

  Computes a noise pattern and blends it with the image to create a film grain look.
*/

#define FilmGrain_intensity 1 //[0.00 to 1.00] How visible the grain is. Higher is more visible.
#define FilmGrain_variance  0.5 //[0.00 to 1.00] Controls the variance of the gaussian noise. Lower values look smoother.
#define FilmGrain_SNR         8 //[0 to 16] Higher Signal-to-Noise Ratio values give less grain to brighter pixels. 0 disables this feature.

// -- Advanced Film Grain settings --
#define FilmGrain_mean     0.5 //[0.00 to 1.00] The average mean of the gaussian noise. Probably best kept at the middle value (0.50)

sampler s0 : register(s0);
float4 p0 : register(c0);
#define counter (p0[2])

float4 main(float2 tex : TEXCOORD0) : COLOR
{
  float4 colorInput = tex2D(s0, tex);
  float3 color = colorInput.rgb;
  
  //float inv_luma = dot(color, float3(-0.2126, -0.7152, -0.0722)) + 1.0;
  float inv_luma = dot(color, float3(-1.0/3.0, -1.0/3.0, -1.0/3.0)) + 1.0; //Calculate the inverted luma so it can be used later to control the variance of the grain
  
  /*---------------------.
  | :: Generate Grain :: |
  '---------------------*/

#ifndef PI
  #define PI acos(-1.0)
#endif
    
  //time counter using requested counter from Reshade
  float t = (counter * 0.1);
	
  //PRNG 2D - create two uniform noise values and save one DP2ADD
  float seed = dot(tex, float2(12.9898, 78.233));// + t;
  float sine = sin(seed);
  float cosine = cos(seed);
  float uniform_noise1 = frac(sine * 43758.5453 + t); //I just salt with t because I can
  float uniform_noise2 = frac(cosine * 53758.5453 - t); // and it doesn't cost any extra ASM

  //Get settings
  #if FilmGrain_SNR != 0
    float variance = (FilmGrain_variance*FilmGrain_variance) * pow(inv_luma,(float) FilmGrain_SNR); //Signal to noise feature - Brighter pixels get less noise.
  #else
    float variance = (FilmGrain_variance*FilmGrain_variance); //Don't use the Signal to noise feature
  #endif

  float mean = FilmGrain_mean;

  //Box-Muller transform
  uniform_noise1 = (uniform_noise1 < 0.0001) ? 0.0001 : uniform_noise1; //fix log(0)
        
  float r = sqrt(-log(uniform_noise1));
  r = (uniform_noise1 < 0.0001) ? PI : r; //fix log(0) - PI happened to be the right answer for uniform_noise == ~ 0.0000517.. Close enough and we can reuse a constant.
  float theta = (2.0 * PI) * uniform_noise2;
    
  float gauss_noise1 = variance * r * cos(theta) + mean;
  //float gauss_noise2 = variance * r * sin(theta) + mean; //we can get two gaussians out of it :)

  //gauss_noise1 = (ddx(gauss_noise1) - ddy(gauss_noise1)) * 0.50  + gauss_noise2;
  

  //Calculate how big the shift should be
  //float grain = lerp(1.0 - FilmGrain_intensity,  1.0 + FilmGrain_intensity, gauss_noise1);
  float grain = lerp(1.0 + FilmGrain_intensity,  1.0 - FilmGrain_intensity, gauss_noise1);
  
  //float grain2 = (2.0 * FilmGrain_intensity) * gauss_noise1 + (1.0 - FilmGrain_intensity);
	 
  //Apply grain
  color = color * grain;
  
  //color = (grain-1.0) *2.0 + 0.5;
  
  //color = lerp(color,colorInput.rgb,sqrt(luma));
 

  /*-------------------------.
  | :: Debugging features :: |
  '-------------------------*/
	//color.rgb = frac(gauss_noise1).xxx; //show the noise
	//color.rgb = (gauss_noise1 > 0.999) ? float3(1.0,1.0,0.0) : 0.0 ; //does it reach 1.0?
	
  /*---------------------------.
  | :: Returning the output :: |
  '---------------------------*/
   colorInput.rgb = color.rgb;

   return colorInput;
}

Ascii:

Code:

  /*------------.
  | :: Ascii :: |
  '------------*/
/*
  Ascii by Christian Cann Schuldt Jensen ~ CeeJay.dk

	Converts the image to ASCII characters using a greyscale algoritm,
	cherrypicked characters and a custom bitmap font stored in a set of floats.
	
	It has 17 gray levels but uses dithering to greatly increase that number.
	
Version 0.6.0 by CeeJay.dk
- a work in progress


*/

#define Ascii_spacing                             3   //[0 to 9] Determines the spacing between characters. I feel 1 to 3 looks best.

#define Ascii_font_color       float3(255, 255, 255)  //[0 to 255, 0 to 255, 0 to 255] What color the font should be. In integer RGB colors.
#define Ascii_background_color float3(0, 0, 0)        //[0 to 255, 0 to 255, 0 to 255] What color the background should be. In integer RGB colors.

#define Ascii_invert_brightness                   0   //[0 or 1] 
#define Ascii_font_color_mode                     1   //[0 to 2] 0 = font_color, 1 = image color, 2 = colorized grayscale

sampler s0 : register(s0);
float4 p0 : register(c0);
float4 p1 : register(c1);
#define screen_size float2(p0.x,p0.y)
#define pixel float2(p1.x,p1.y)

#define Ascii_font_size float2(5.0,5.0) //The current font is 5x5, I can update this when/if I create other fonts

float4 main(float2 tex : TEXCOORD0) : COLOR {

  /*-------------------------.
  | :: Sample and average :: |
  '-------------------------*/
  
  float2 Ascii_block = Ascii_font_size + float(Ascii_spacing);
  float2 cursor_position = trunc((screen_size / Ascii_block) * tex) * (Ascii_block / screen_size);

  float3 color = tex2D(s0, cursor_position + float2( 1.5, 1.5) * pixel).rgb;
  color += tex2D(s0, cursor_position + float2( 1.5, 3.5) * pixel).rgb;
  color += tex2D(s0, cursor_position + float2( 1.5, 5.5) * pixel).rgb;
  color += tex2D(s0, cursor_position + float2( 3.5, 1.5) * pixel).rgb;
  color += tex2D(s0, cursor_position + float2( 3.5, 3.5) * pixel).rgb;
  color += tex2D(s0, cursor_position + float2( 3.5, 5.5) * pixel).rgb;
  color += tex2D(s0, cursor_position + float2( 5.5, 1.5) * pixel).rgb;
  color += tex2D(s0, cursor_position + float2( 5.5, 3.5) * pixel).rgb;
  color += tex2D(s0, cursor_position + float2( 5.5, 5.5) * pixel).rgb;

  color /= 9.0;
	
  /*------------------------.
  | :: Make it grayscale :: |
  '------------------------*/
  
    float luma = dot(color,float3(0.2126, 0.7152, 0.0722));
	float gray = luma;

	#if Ascii_invert_brightness == 1
		gray = 1.0 - gray;
	#endif
  
  /*-------------------.
  | :: Get position :: |
  '-------------------*/
	
	float2 p = frac((screen_size / Ascii_block) * tex);  //p is the position of the current pixel inside the character

	p = trunc(p * Ascii_block);

  float x = (Ascii_font_size.y * p.y + p.x);
  
  /*----------------.
  | :: Dithering :: |
  '----------------*/
  
  float num_of_chars = 17. ; 
  
  
  #if Ascii_dithering_temporal == 1
		//float even_frame = (frac(framecount * 0.5) < 0.25) ? -1.0 : 1.0;
    //float even_frame = (frac(timer / (1000. / 59.9 * 2.)) <= 0.50) ? -1.0 : 1.0;
	#endif

  //Pseudo Random Number Generator
  // -- PRNG 1 - Reference --
  float seed = dot(cursor_position, float2(12.9898,78.233)); //I could add more salt here if I wanted to
  float sine = sin(seed); //cos also works well. Sincos too if you want 2D noise.
  float noise = frac(sine * 43758.5453 + cursor_position.y); //tex.x is just some additional salt - it can be taken out.

  //Calculate how big the shift should be
  //float dither_shift = (2.0 / num_of_chars) * pingpong.y; // Using noise to determine shift.
  //float dither_shift = (2.0 / num_of_chars) * even_frame; // Using noise to determine shift.
  
  float dither_shift = (2.0 / num_of_chars); // Using noise to determine shift.
  float dither_shift_half = (dither_shift * 0.5); // The noise should vary between +- 0.5
  dither_shift = dither_shift * noise - dither_shift_half; // MAD

  //shift the color by dither_shift
  gray += dither_shift; //subpixel dithering

  /*---------------------------.
  | :: Convert to character :: |
  '---------------------------*/

	//2nd conditional assignment method - expanded to use all 17 chars
	//fast on hardware that can do this without branching (PC and Mac, unsure about mobile)
	//TODO add Q and move space to special case like with the signbit
	//and maybe add dithering
	
	//float num_of_chars = 17. ; // I moved this up to the dithering section
	// .:^"~cso*wSO8Q0#

	float n12   = (gray < (2./num_of_chars))  ? 4194304.  : 131200.  ; // . or :
	float n34   = (gray < (4./num_of_chars))  ? 324.      : 330.     ; // ^ or "
	float n56   = (gray < (6./num_of_chars))  ? 283712.   : 12650880.; // ~ or c
	float n78   = (gray < (8./num_of_chars))  ? 4532768.  : 13191552.; // v or o
	float n910  = (gray < (10./num_of_chars)) ? 10648704. : 11195936.; // * or w
	float n1112 = (gray < (12./num_of_chars)) ? 15218734. : 15255086.; // S or O
	float n1314 = (gray < (14./num_of_chars)) ? 15252014. : 32294446.; // 8 or Q
	float n1516 = (gray < (16./num_of_chars)) ? 15324974. : 11512810.; // 0 or #

	float n1234     = (gray < (3./num_of_chars))  ? n12   : n34;
	float n5678     = (gray < (7./num_of_chars))  ? n56   : n78;
	float n9101112  = (gray < (11./num_of_chars)) ? n910  : n1112;
	float n13141516 = (gray < (15./num_of_chars)) ? n1314 : n1516;

	float n12345678 = (gray < (5./num_of_chars)) ? n1234 : n5678;
	float n910111213141516 = (gray < (13./num_of_chars)) ? n9101112 : n13141516;

	float n = (gray < (9./num_of_chars)) ? n12345678 : n910111213141516;
	
	/*--------------------------------.
  | :: Decode character bitfield :: |
  '--------------------------------*/
  
	float character = 0.0;
	
		//test values
		//n = -(exp2(24.)-1.0); //-(2^24-1) All bits set - a white 5x5 box

		//24 bits and a multiplier (exponent)
		//Set the highest bit and use log2 to get the exponent that could respresent that
		//adjust the mantissa and get the remaining bits

    float lit = (gray <= (1./num_of_chars)) //if black then set all pixels to black (the space character)
      ? 0.0
      : 1.0 ;
    
    float signbit = (n < 0.0) //is n negative? (I would like to test for negative 0 here too but can't)
      ? lit 
      : 0.0 ;
    
    signbit = (x > 23.5) //is this the first pixel in the character?
      ? signbit
      : 0.0 ;

		//Tenary Multiply exp2
		character = ( frac( abs( n*exp2(-x-1.0))) >= 0.5) ? lit : signbit; //works on AMD and intel

	if (clamp(p.x, 0.0, 4.0) != p.x || clamp(p.y, 0.0, 4.0) != p.y)
    character = 0.0;

  /*---------------.
  | :: Colorize :: |
  '----------------*/

	#if Ascii_font_color_mode  == 1
		color = (character) ? character * color: Ascii_background_color / 255.0;
	#elif Ascii_font_color_mode  == 2
		color = (character) ? (Ascii_font_color / 255.0) * gray : Ascii_background_color / 255.0;	
	#else // Ascii_font_color_mode == 0 
		color = (character) ? (Ascii_font_color / 255.0) : Ascii_background_color / 255.0;
	#endif
		
	//colorInput.rgb = saturate(colorInput.rgb);
	//colorInput.rgb = pow(colorInput.rgb, 0.5);
	//colorInput.rgb = sqrt(colorInput.rgb);
    
  /*-------------.
  | :: Return :: |
  '-------------*/
	
	//color = gray;
	float4 c0 = tex2D(s0, tex);
	c0.rgb = color;
	return saturate(c0);
}


/*
  .---------------------.
  | :: Character set :: |
  '---------------------'

Here are some various chacters and gradients I created in my quest to get the best look

 .'~:;!>+=icjtJY56SXDQKHNWM
 .':!+ijY6XbKHNM
 .:%oO$8@#M
 .:+j6bHM
 .:coCO8@
 .:oO8@
 .:oO8
 :+#

 .:^"~cso*wSO8Q0# 
 .:^"~csoCwSO8Q0#
 .:^"~c?o*wSO8Q0#

n value // # of pixels // character
-----------//----//-------------------
4194304.   //  1 // . (bottom aligned) 
131200.    //  2 // : (middle aligned) 
4198400.   //  2 // : (bottom aligned)
2228352.   //  3 // ;
4325504.   //  3 // i (short)
14336.     //  3 // - (small)
324.       //  3 // ^
4329476.   //  4 // i (tall)
330.       //  4 // "
31744.     //  5 // - (larger)
283712.    //  5 // ~
10627072.  //  5 // x
145536.    //  5 // * or + (small and centered) 
6325440.   //  6 // c (narrow - left aligned)
12650880.  //  6 // c (narrow - center aligned)
9738240.   //  6 // n (left aligned)
6557772.   //  7 // s (tall)
8679696.   //  7 // f
4532768.   //  7 // v (1st)
4539936.   //  7 // v (2nd)
4207118.   //  7 // ?
-17895696. //  7 // %
6595776.   //  8 // o (left aligned)
13191552.  //  8 // o (right aligned)
14714304.  //  8 // c (wide)
12806528.  //  9 // e (right aligned)
332772.    //  9 // * (top aligned)
10648704.  //  9 // * (bottom aligned)
4357252.   //  9 // +
-18157904. //  9 // X
11195936.  // 10 // w
483548.    // 10 // s (thick)
15218734.  // 11 // S 
31491134.  // 11 // C   
15238702.  // 11 // C (rounded)
22730410.  // 11 // M (more like a large m)
10648714.  // 11 // * (larger)
4897444.   // 11 // * (2nd larger)
14726438.  // 11 // @ (also looks like a large e)
23385164.  // 11 // &
15255086.  // 12 // O
16267326.  // 13 // S (slightly larger)
15252014.  // 13 // 8
15259182.  // 13 // 0  (O with dot in the middle)
15517230.  // 13 // Q (1st)
-18405232. // 13 // M
-11196080. // 13 // W
32294446.  // 14 // Q (2nd)
15521326.  // 14 // Q (3rd)
32298542.  // 15 // Q (4th)
15324974.  // 15 // 0 or Ø
16398526.  // 15 // $
11512810.  // 16 // #
-33061950. // 17 // 5 or S (stylized)
-33193150. // 19 // $ (stylized)
-33150782. // 19 // 0 (stylized)



Idea! - try :  .';"~cso*wSO8Q0# 
by making shades close to each other use characters that are far from each other visually I might space out the dots and create a smoother looking gradient.
Especially with dithering enabled.

Instead of
 .:.:.:.
 :.:.:.:
 .:.:.:.
 :.:.:.:

I might use
 .'.'.'.
 '.'.'.'
 .'.'.'.
 '.'.'.'

*/

Filmic Curve:

Code:

/*
Filmic Curve: Improved version of the well-known Uncharted 2 filmic curve, first seen in iCEnhancer 0.3.
*/

sampler s0 : register(s0);

float3 CustomToneMapping(in float3 x)
{
	const float A = 0.665f;
	const float B = 0.09f;
	const float C = 0.004f;
	const float D = 0.445f;
	const float E = 0.26f;
	const float F = 0.025f;
	const float G = 0.16f;//0.145f;
	const float H = 1.1844f;//1.15f;

    // gamma space or not?
	return (((x*(A*x+B)+C)/(x*(D*x+E)+F))-G) / H;
}

float4 main(float2 tex : TEXCOORD0) : COLOR {
	float4 c0 = tex2D(s0, tex);

	c0.rgb = CustomToneMapping(c0);
	return c0;
}

As far as I know porting LensDirt shader to MPC-HC is impossible because of MPC-HC's limitations. (It requires access to a custom texture.) But it is possible to use it after injecting ReShade into MPC-HC. If there are any other shaders you want me port, just ask.

 

Hi guys. Just a quick note to say congrats on the progress of the next generation of shaders post injection. This is really awesome work. I wish I could know about programming to help you guys with this project.

Just one question : I am somewhat an active user of Sweet FX (pretty much every games) and I am familiar with all the tools needed to make it work most of the time (Radeon Pro on Win 8.1, etc). I'm just curious, when Sweet FX V2 eventually release, will it be a complement of Reshade, or there will be a full standalone version with included shaders? Can we expect the same level of drag and drop user friendlyness of previous Sweet FX versions, or will it require different files for different games and DX version?

Thanks!

 

Why don't you see it for yourself?

http://reshade.me/#download

 

Thanks for the reply! I saw this page, but I was curious to know if it will be different once Sweet FX 2.0 releases officially. Will it be available in one package? I see a lot of different shader packs on the Sweet FX settings database (master effects, and others) and I just hope we will get a more unified solution.

 

Hey guys. I really need your help here. I am trying to get SweetFX working in Dying Light. No matter how I try I can't get it to work.

I recieve this error upon trying to use the x64 dll's:

EDIT: Never mind guys. I found out what was causing this. FRAPS

That little bugger...

 

Hey guys, I decided to play Crysis 2 again with Maldo's 4.0 mod and when I select either of the SweetFX Inject AA settings; "No Post-AA ingame +SMAA Ultra" and "FXAA Ultra ingame + SweetFX" and launch the game I get this error:

"CreateDXGIFactory2" wasn't found in the DLL "C:\Windows\SYSTEM32\d3d11.dll"

The game still launches after the error but when I check in Graphic settings, DX11 is grayed out and is disabled. This does not happen when I choose other AA settings which do not use SweetFX but the game looks crappy. The game worked fine on Windows 8 and this only happened after I upgraded to 8.1.

Maldo 4.0 uses SweetFX 1.3, so I downloaded the latest SweetFX version 1.5.1 and replaced the files thinking it would fix the problem but it still persists. I read that it is incompatible with Windows 8.1 because of DX 11.2 but is there any workaround and is it going to be addressed/updated soon?

Thanks

 

With patch 6.1 launching for World of Warcraft, SweetFX is being completely blocked when running the game with DX11. I even tried using ReShade but the game refuses to launch, I can see it hanging at 160mb of memory in the task manager.

SweetFX is working fine with WoW running in DX9 mode however.

I'm really worried about this. Anyone else having this same issue?

EDIT: Nevermind, culprit was RadeonPro running in the background. Everything is working fine now. (I swear that program breaks so many things, I'm seriously considering uninstalling it now.)

 

thank you very much

 

Hmmm just noticed that reshade is bundled with sweetfx 2.0 preview. Is that official? newest I know is 1.5.1 and bolotaur version for 64bit. both for dx9,10,11.

What 2.0 offers ?

also btw. Any tips on how to sue reshade and sweetfx ? Never used reshade... man i am all wbackwards with this lately. I am stuck on sweetfx and radeonpro as far as my knowledge goes... well used some gedosato too but it introduces hugggeee input lag

 

2.0 (preview 3) is made for ReShade which is the new injector (Recently updated to version 0.15.0) however I am not sure about the exact differences between that and the older 1.5.1 version.

Readme and their own website and forums ( http://reshade.me/ ) should provide more details and info on how to use it than I can do.

 

But if I want dof, sao etc, I need mastereffects?
Can I use both? how ?

Actually reshade is just a "box" in which I drop al my injectors and it makes it more compatibile ? yeah.. sorry :lol:

 

MasterEffect is the shader package you would want to use for the depth of field, ambient occlusion and some other effects.

It's file name is ReShade.fx which is loaded before Sweet.fx (But after dxgi.fx if I remember correctly, that's the name of the graphical API used so dxgi.fx, d3d9.fx or opengl32.fx I think, depending on what the game uses.) anyways if you were to place both Sweet.fx and ReShade.fx together with the ReShade 32 or 64 bit .dll - renamed to dxgi.dll/d3d9.dll/opengl32.dll depending on what API the game tries to use. - then only ReShade.fx would be loaded since ReShade does not load multiple .fx files so priority (Determined by file name.) decides which .fx file is loaded first.
(I think I remember that part correctly, most of it should be in the readme file as well.)

You would have to manually combine the ReShade or rather MasterEffect .fx and SweetFx .fx files if you want the effects from both packs, the ReShade forums might have a premade file already, I wouldn't know how to go about merging them correctly.

I would recommend starting with MasterEffect by itself and enabling what effects you want to use (By opening ReShade.fx in a text editor and setting the effects you want to use from 0 to 1, it's the first part of the file and following that is a list of configurable settings for the individual effects.) before trying to merge the shader effect files unless you already know of a specific shader effect in SweetFx that you want to use but is not part of MasterEffect.


Also if you do use ReShade 0.15.0 there's currently a little bug where you need to change a value in ReShade.fx for MasterEffects or it won't work properly.
http://reshade.me/forum/releases/7-public-beta?start=84#1915
(It's not too complicated, just a few changes in notepad.)

(MasterEffect can be found here by the way: http://reshade.me/forum/shaderpack-mastereffect/161-mastereffect-reborn-official-thread )

 

its pretty neat but I prefer new reshade + sweetfx preview. Not even remotely as taxing as master effects and I dont really find dof all that usefull.

I really hope that reshade will continue to implement sweetfx and add frame limiter, osd and some kind of vsync/tb support

 

SweetFX 1.5.1 is currently the fastest, but once I'm done with it I hope SweetFX 2.0 will match it in speed.

This is because 2.0 separates effects into their own passes which avoid some of the problems that 1.5 has with this, but it's also a little slower.
It's also because the SMAA version in 1.5.1 has optimizations by me, but the one in 2.0 beta does not yet have them.
And also because the depth buffer preview adds a little overhead.

In the future the 2.x versions should be faster because ReShade allows for many more performance optimizations .. I just haven't gotten around to implementing them yet.

 

I've updated the 2.0 beta to preview 5 - this adds a smaller 3x5 font to the ascii shader which allows for even finer details.

I'm still tweaking the character set for that one but the current one works well.

It can be downloaded from http://reshade.me/

 

fantastic. Thanks !
edit: btw. it still says preview 3 in settings file

 

I've just edited my developer branch .. it now says preview 6 so even if I forget to update it, it will still be correct come next release.