Qhimm.com Forums

Final Fantasy Forums => Graphical Modding => Topic started by: Sunwalker on 2017-01-24 03:01:20

Title: New Shader for Post Process
Post by: Sunwalker on 2017-01-24 03:01:20
About 20 shader effect I add in it and share here. Can tweak through notepad plus or notepad, enable or disable for effect configuration.
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-25 09:57:50
Here the shader, I include also ff7 config, comment are welcome  :)

http://www.mediafire.com/file/nryid5mjb5tk1q1/Sunwalkers_Shaders_2.7z

Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-25 19:07:39
I corrected that whiteglowbloom code, .. now the white glow bloom should be okay

http://www.mediafire.com/file/srb6fj0s6cv8kb8/Sunwalkers_UPDATE_Shaders_2.7z
Title: Re: New Shader for Post Process
Post by: EQ2Alyza on 2017-01-26 07:53:26
I'll look into putting these in as an option for the next 7H update.
Title: Re: New Shader for Post Process
Post by: Kaldarasha on 2017-01-26 15:04:14
This looks promissing but it doesn't work for me here is a part of my app.log:

Code: [Select]
[00000000] INFO: FF7/FF8 OpenGL driver version 0.8.1b
[00000000] INFO: Auto-detected version: FF7 1.02 US English
[00000000] INFO: NVIDIA Corporation GeForce GT 630M/PCIe/SSE2 4.5.0 NVIDIA 376.33
[00000000] INFO: OpenGL 2.0 support detected
[00000000] INFO: Found swap_control extension
[00000000] GLITCH: Unable to turn off vsync
[00000000] INFO: Max texture size: 16384x16384
[00000000] INFO: Original resolution 640x480, window size 960x720, output resolution 960x720, internal resolution 1280x960
[00000000] INFO: Shader limits: varying 124, vert uniform 4096, frag uniform 4096
[00000000] INFO: fragment shader compile log:
0(18) : error C0206: invalid token "compatibility" in version line
0(384) : error C7011: implicit cast from "vec4" to "vec3"

[00000000] INFO: postprocessing program link log:
Fragment info
-------------
0(18) : error C0206: invalid token "compatibility" in version line
0(384) : error C7011: implicit cast from "vec4" to "vec3"
(0) : error C2003: incompatible options for link

[00000000] ERROR: init_postprocessing failed, postprocessing will be disabled
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-26 16:51:24
Here after I check again, I forget to erase that raymarch.. and i add ambient light to replace that raymarch..

http://www.mediafire.com/file/jeyy8m6jp98kiwl/Sunwalkers_UPDATE_1_Shaders_3.7z
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-26 17:00:42
to Kaldarasha, try change that #version 120 compatibility to #version 150 compatibility , if not help also, then u can delete or disable it. I test all the shader and no problem.. the vsync can enable or disable, but it drop my fps if I enable that vsync ..
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-27 10:11:01
here the final update, I remove that compatibility, and only #version 120 ..  in my  ff7 config i disable the vsync for increase my fps, i put windowed 960 and 720 for size y, actually you can enable that vsync, you can put size x 1280, size y 800, hope you all like this shader, and maybe someone who know more better than me can improve this shader.

http://www.mediafire.com/file/doo2e94cq311qy0/Sunwalkers_UPDATE_2_Shaders_4.7z
Title: Re: New Shader for Post Process
Post by: EQ2Alyza on 2017-01-27 11:03:43
I unfortunately can't get postprocessing to load with it:

Code: [Select]
[00000000] INFO: FF7/FF8 OpenGL driver version 0.8.1b
[00000000] INFO: Auto-detected version: FF7 1.02 US English
[00000000] INFO: NVIDIA Corporation GeForce GTX 965M/PCIe/SSE2 4.5.0 NVIDIA 378.49
[00000000] INFO: OpenGL 2.0 support detected
[00000000] INFO: Found swap_control extension
[00000000] INFO: Max texture size: 16384x16384
[00000000] INFO: Original resolution 640x480, window size 1280x800, output resolution 1066x800, internal resolution 3840x2560
[00000000] INFO: Shader limits: varying 124, vert uniform 4096, frag uniform 4096
[00000000] INFO: fragment shader compile log:
0(735) : error C1016: expression type incompatible with function return type

[00000000] INFO: postprocessing program link log:
Fragment info
-------------
0(735) : error C1016: expression type incompatible with function return type
(0) : error C2003: incompatible options for link

[00000000] ERROR: init_postprocessing failed, postprocessing will be disabled
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-27 11:36:50
In shadersmartpost.fx try add this ..

#version 120
#extension GL_NV_gpu_shader4 : enable
#extension GL_ARB_gpu_shader4 : enable
#extension GL_ARB_texture_rectangle : enable

and if still same.. try delete all that #extension

here my app.log .. 
Code: [Select]
[00000000] INFO: FF7/FF8 OpenGL driver version 0.8.1b
[00000000] INFO: Auto-detected version: FF7 1.02 US English
[00000000] INFO: Intel Intel(R) HD Graphics 3000 3.1.0 - Build 9.17.10.4229
[00000000] INFO: OpenGL 2.0 support detected
[00000000] INFO: Found swap_control extension
[00000000] INFO: Max texture size: 8192x8192
[00000000] INFO: Original resolution 640x480, window size 1280x768, output resolution 1024x768, internal resolution 3840x2560
[00000000] INFO: Shader limits: varying 41, vert uniform 512, frag uniform 1024
[00000000] INFO: vertex shader compile log:
No errors.

[00000000] INFO: fragment shader compile log:
No errors.

[00000000] INFO: main program link log:
No errors.

[00000000] INFO: fragment shader compile log:
No errors.

[00000000] INFO: postprocessing program link log:
No errors.

[00000000] INFO: FFMpeg movie player plugin loaded
[00000000] INFO: FFMpeg version SVN-r25886, Copyright (c) 2000-2010 Fabrice Bellard, et al.
[00000000] INFO: VGMStream music plugin loaded
[00000000] INFO: Loading external library Multi.dll
[00000000] LOCK UNLOCK TEST
[00000001] MATRIX INITIALIZE
[00000001] INITIALIZE DD/D3D END
[00000001] initializing sound...
[00000001] creating dsound primary buffer
[00000001] reading audio file
[00000001] loading static sounds
[00000001] sound initialized
[00000001] set music volume: 127
[00000001] set music volume: 127
[00000001] Entering MAIN
[00000001] Exiting MAIN
[00000001] START OF CREDITS!!!
[00000001] INFO: C:\Games\Final Fantasy VII\Data\Movies\eidoslogo.avi; h264/aac 640x480, 15.000000 FPS, duration: 10.263000, frames: 154
[00000001] INFO: vertex shader compile log:
No errors.

[00000001] INFO: fragment shader compile log:
No errors.

[00000001] INFO: yuv program link log:
No errors.

[00000019] WM_CLOSE
[00000019] END OF CREDITS!!!
[00000019] Field Quit
[00000019] UNINITIALIZE DD
 
Title: Re: New Shader for Post Process
Post by: Ansem on 2017-01-27 12:27:55
Same stuff happens on my end.

Code: [Select]
[00000000] INFO: FF7/FF8 OpenGL driver version 0.8.1b
[00000000] INFO: Auto-detected version: FF7 1.02 US English
[00000000] INFO: NVIDIA Corporation GeForce GTX 750 Ti/PCIe/SSE2 4.5.0 NVIDIA 376.33
[00000000] INFO: OpenGL 2.0 support detected
[00000000] INFO: Using PBO
[00000000] INFO: Found swap_control extension
[00000000] INFO: Max texture size: 16384x16384
[00000000] INFO: Original resolution 640x480, window size 1360x768, output resolution 1360x768, internal resolution 1920x960
[00000000] INFO: Shader limits: varying 124, vert uniform 4096, frag uniform 4096
[00000000] INFO: fragment shader compile log:
0(734) : error C1016: expression type incompatible with function return type

[00000000] INFO: postprocessing program link log:
Fragment info
-------------
0(734) : error C1016: expression type incompatible with function return type
(0) : error C2003: incompatible options for link

[00000000] ERROR: init_postprocessing failed, postprocessing will be disabled
[00000000] INFO: FFMpeg movie player plugin loaded
[00000000] INFO: FFMpeg version SVN-r25886, Copyright (c) 2000-2010 Fabrice Bellard, et al.
[00000000] INFO: VGMStream music plugin loaded
[00000000] INFO: Loading external library FF7anyCD.dll
[00000000] LOCK UNLOCK TEST
[00000001] MATRIX INITIALIZE
[00000001] INITIALIZE DD/D3D END
[00000001] initializing sound...
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-27 12:51:40
I see, all gtx Nvidia will have this problem to use my shader, I will search to make gtx Nvidia compatible with this shader
Title: Re: New Shader for Post Process
Post by: EQ2Alyza on 2017-01-27 13:08:36
Thanks. I'll keep my eye out for any updates :)
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-27 14:12:40
to [email protected]  try this one again.. this time I only enable that aabumpmap..

http://www.mediafire.com/file/kkkxnb2nd2pb2hb/Sunwalkers_UPDATE_3_Shaders_5.7z

So hard to believe, mine here working perfect..

I use Nvidia GT 520M
Title: Re: New Shader for Post Process
Post by: EQ2Alyza on 2017-01-27 14:39:00
It's working now.
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-27 14:52:32
I'm happy it working :) , if can I don't want to edit that vertex post, all go to post process without editing that vertex post.. I maybe too much put effect in it, if combine with AABumpMap and light maybe some of the effect cannot pass, try combine with AABumpMap and blendedBloom, for best effect ..try not to on all effect, use only 3 or 4 effect.. IF fps drop mean have to disable that vsync, and I purposely put # to the setting internal window size in ff7 config, to avoid over anti-aliasing..
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-27 15:35:20
here my final update for this shader, hope it will work perfect on Nvidia gtx..

http://www.mediafire.com/file/86wkoly5297e625/Sunwalkers_UPDATE_4_Shaders_6.7z
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-27 15:47:24
don't use that update 4, I forget to add some code for xbr.. here the final one..

http://www.mediafire.com/file/73dp3v22enxms8a/Sunwalkers_UPDATE_5_Shaders_7.7z
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-27 16:28:23
https://www.youtube.com/watch?v=JcGAjzAe6y0&feature=youtu.be

well, time to go disc 2
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-29 15:08:41
Version 1.04 , remove some effect and only 10 effect in it.

http://www.mediafire.com/file/prhvr2e9n443k4y/Sunwalker%27s_Shaders_V1.04.7z
Title: Re: New Shader for Post Process
Post by: Kaldarasha on 2017-01-29 19:57:39
Really great. I see only one problem, when the battle starts the screen is horizontal mirrored. I could live with that but it also affect other screen effects (Ifrit's attack as example).
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-29 20:32:08
Not sure about it,  mine here perfect, try adjust that texture_size in smartshaderpost ...

//##[TEXTURE_SIZE]
#define pixelWidth   2048.0                 
#define pixelHeight  1024.0                 
#define Quality      1.0

but when you disable mod_path and want to use original fields, than adjust again that texture_size to see the fxaa work. :)
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-30 16:12:44
I currently testing using GodRays, but my gpu card cannot carry it, 30 fps drop.. so heavy
Title: Re: New Shader for Post Process
Post by: Kaldarasha on 2017-01-31 04:15:27
No, it doesn't solve the mirror bug. It's one of the shader which does replace Aali's. Maybe you need to add the code of them to your shaders?

GodRays aren't really needed. An ambient and AO shader would be better. But I guess the later one would be hard to realize since there is no depth buffer, isn't it?
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-31 07:48:33
can I see the screenshot of that mirror bug?
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-01-31 15:17:53
To Kaldarasha, try this shader .. 2 effect only, inform me if it still same, I hard to figure out .. because I can't see what mirror bug is it.. try don't enable fbo..  try not using external_size in ff7 config.


http://www.mediafire.com/file/2se2959tn0p8324/Shader_testing.7z
Title: Re: New Shader for Post Process
Post by: Kaldarasha on 2017-02-01 04:39:49
Nope doesn't work either. Here is a picture of the bug:
(http://i.imgur.com/ahcQ6sk.png)
My FF7config:
Code: [Select]
# ff7_opengl-0.8b config file



## USER OPTIONS ##
## If you just want to play the game, these are the only options you'll want to change.

# set the window size (or fullscreen resolution) of FF7
# 0 means use original resolution in window mode, your current desktop resolution will be used in fullscreen mode
# preserve_aspect adds black borders as needed to preserve a 4:3 aspect ratio
window_size_x = 0
window_size_y = 0
internal_size_x = 0
internal_size_y = 0
preserve_aspect = off
fullscreen = on

# mod directory
# subdirectroy of mods/ where textures will be loaded from
mod_path = Textures

# check your Nvidia/ATI/Intel control panel settings if this option doesn't seem to work
enable_vsync = on


# allow FF7 to use linear filtering for its textures
# some things look slightly better with this option on, but alot of textures just lose their detail
# only affects low-res textures, high-res replacements will still be filtered where appropriate
linear_filter = on

# plugin used to play music, VGMstream requires a set of looping .ogg files in the music/vgmstream folder.
# If no music plugin is loaded the game will play MIDI as usual but FF7Music will NOT work.
music_plugin = plugins/vgmstream_music.fgp



## ENHANCEMENTS ##
## All the little extras that weren't part of the original game, default options include only trivial bug fixes.

# make all dialog boxes transparent, same effect as the transparent dialog boxes YAMP patch
transparent_dialogs = off

# include armor in magic defense calculation
mdef_fix = yes

# post-processing shader, used to apply fullscreen effects
post_source = shaders/SmartShaderPost.fx
enable_postprocessing = no

# vertex and fragment shaders
vert_source = shaders/vert.fx
frag_source = shaders/frag.fx

# YUV fast path shader
yuv_source = shaders/yuv.fx



## ADVANCED OPTIONS ##
## Don't fiddle with these unless you know what you're doing.

# enable alpha blending for textures without an existing blending effect
fancy_transparency = on

# display frames per second counter in upper right corner
show_fps = yes

# display some real-time debug information
show_stats = no

# store external textures in a compressed cache for increased performance
# compression is not lossless, some artifacts may appear when this option is in use
# texture cache does NOT update automatically if the source image changes, however, deleting anything from the cache
# will cause that file to be recreated from the source
compress_textures = no

# max size of the texture cache to hold in RAM, in megabytes
# don't set it any higher than 1GB unless you want your game to crash
texture_cache_size = 768

# use pixel buffer objects to speed up texture loading
# might crash horribly on ATI cards but should work for NVIDIA users
use_pbo = no

# use mipmaps (anisotropic filtering) for high-res textures
use_mipmaps = yes

# replace FF7's default framelimiter timer source
use_new_timer = yes

# plugin used to play movies, FFMpeg is the only choice for now
movie_plugin = plugins/ffmpeg_movies.fgp



## MODDER OPTIONS ##
## These options are mostly useful to modders and should not be enabled during normal play.

# read files directly instead of using LGP archives
# for example; if FF7 is looking for aaab.rsd in char.lgp, this option will make it open direct/char/aaab.rsd first,
# if this file doesn't exist it will look for the original in the LGP archive
direct_mode = on

# show every failed attempt at loading a .png texture
show_missing_textures = no

snowboard_framerate = 60
highway_framerate = 30
coaster_framerate = 60
battleswirl_framerate = 60

load_library = Multi.dll

BTW. I use the reunion mod, which I won't disable since it fix the damn game in many places. I guess I test which of the 3 replaced shader files are responsible for the bug.

Edit:
It's vert.fx, which is causing the trouble.
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-02-01 06:28:52
Thank you, :) .. now I replace that vert and frag and using original one... here the version 1.05 ..some effect i remove since maybe no one will using them ..

http://www.mediafire.com/file/629a9b9vill8toj/Sunwalker%27s_shader_V1.05.7z
Title: Re: New Shader for Post Process
Post by: Kaldarasha on 2017-02-01 18:51:29
Now it's perfect! Well, not really I would like this psx color mode back (NTSC_TV_EMULATION).
Title: Re: New Shader for Post Process
Post by: Tsunamix on 2017-02-01 21:07:12
How do i use this? Put it in the shader folder or the root?

EDIT: Got it
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-02-20 00:48:11
Any suggestion before I release version 1.06?
Title: Re: New Shader for Post Process
Post by: Kaldarasha on 2017-02-20 01:15:42
Do you observe my computer somehow?  :-o
I currently sitting hours on my PC and does play with the shaders (I have back ported the NTSC_TV_EMULATION  :mrgreen:).
I would love to see a screen ambient shader but I don't know if it will have the same strawberries performance as with reshade.

I don't if possible BUT this would be a great shader: http://ngemu.com/threads/links-and-guides-to-custom-shaders-for-petes-opengl2-plugin.76098/page-43

EDIT

I see that you are familiar with tis site. :D
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-02-20 01:27:53
Depth of field i already include in v 1.06, i can add ssao or hbao and remove that depth of field.. i want to know if someone like crt or scanline.. godrays etc..  :) and what is strawberries mean ?
Title: Re: New Shader for Post Process
Post by: Kaldarasha on 2017-02-20 01:34:21
Depth of field i already include in v 1.06, i can add ssao or hbao and remove that depth of field.. i want to know if someone like crt or scanline.. godrays etc..  :) and what is strawberries mean ?

Ask Covarr, it is his gag.

Depth of field and AO sounds interesting. I prefer a dotmask over scanlines though.
Title: Re: New Shader for Post Process
Post by: Covarr on 2017-02-20 17:04:02
Ask Covarr, it is his gag.
You can disable forum censorship in user settings to show it as the original swear word. I thought this would be more creative than ****.
Title: Re: New Shader for Post Process
Post by: Kaldarasha on 2017-02-23 19:50:42
(http://i.imgur.com/FdsfJn7.png)
(http://i.imgur.com/xhCmEHt.png)

It's really a nice shader combination you have adapted for Aali's driver.

Here is my setting with the port back of the PSX color mode.
Code: [Select]
/*===============================================================================*\
|#######################   [FINAL FANTASY 7 SHADER FX]    ########################|
|#########################   By Sunwalker 21/Jan/2017   ##########################|
||                                Version 1.04                                   ||
||                                                                               ||
||          This program is free software; you can redistribute it and/or        ||
||          modify it under the terms of the GNU General Public License          ||
||          as published by the Free Software Foundation; either version 2       ||
||          of the License, or (at your option) any later version.               ||
||                                                                               ||
||          This program is distributed in the hope that it will be useful,      ||
||          but WITHOUT ANY WARRANTY; without even the implied warranty of       ||
||          MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        ||
||          GNU General Public License for more details. (c)2016                 ||
||                                                                               ||
|#################################################################################|
\*===============================================================================*/
#version 120
//#extension GL_ARB_texture_rectangle : enable
/*------------------------------------------------------------------------------
[DEFINITIONS & ON/OFF OPTIONS]
------------------------------------------------------------------------------*/
//--------------------------#[CHOOSE EFFECTS]#--------------------------------\\
//#[ANTIALIASING TECHNIQUES]   [1=ON|0=OFF]  # NOTE: Enable one only
#define USE_FXAA                  0      //# [0 or 1] FXAA Fast Anti-aliasing : Smoothens jagged lines using the FXAA technique.
#define USE_AABUMPMAP               0      //# Bump Map Shader with AA

//#[LIGHTING & COLOUR]         [1=ON|0=OFF]  # NOTE: This one can enable all
#define GAMMA_CORRECTION            1      //# RGB Gamma Correction. Fixed expansion to variable compression gamma correction curve.
#define BLENDED_BLOOM               1      //# High Quality SP Bloom. Soft lighting with blending techniques, for a natural looking bloom.
#define SCENE_TONEMAPPING           1      //# HDR Scene Tonemapping. Layered component conversion, and applies scene tone mapping.
#define COLOR_CORRECTION            1      //# Component Color Correction. Colorspace conversion, with correction curves, and multiple palette types.
#define CROSS_PROCESSING            0      //# Filmic Cross Processing. Alters the tone of the scene, crossing the game's color set, with another.
#define COLOR_GRADING               0      //# Post-Complement Colour Grading. Alters individual colour components on a scene, to enhance selected colour tones.

//#[MISC]                      [1=ON|0=OFF]  # NOTE: Enable one only
#define USE_SCANLINES               0      //# Scanlines to simulate the look of a CRT TV. Typically suited to sprite games.
#define NTSC_TV_EMULATION           1      //# SimoneT's TV Colors Emulation Shader. Use to emulate the original PSX color space tone, and vibrancy.

/*------------------------------------------------------------------------------
[EFFECT CONFIG OPTIONS]
------------------------------------------------------------------------------*/

//##[USE_AABUMPMAP]
#define Bump 1.33                             //[0.00 to 1.70] Effect strenght - lower values bring more effect
#define Glow 1.25                             //[1.00 to 1.50] Max brightness on borders
#define Shde 0.75                             //[0.00 to 1.00] Max darkening
#define Range 1.0                             //[0.00 to 1.00] Range width 

//##[GAMMA_CORRECTION]
#define Gamma 2.20                            //[1.5 to 4.0] Gamma correction. Decrease for lower gamma(darker). Increase for higher gamma(brighter). (Default: 2.2)

//##[BLENDED_BLOOM]
#define BloomType BlendAddGlow                   //[BlendGlow, BlendAddGlow, BlendAddLight, BlendScreen, BlendLuma, BlendOverlay] The type of blended bloom. Light<->Dark.
#define BloomStrength 0.200                   //[0.000 to 1.000] Overall strength of the bloom. You may want to readjust for each blend type.
#define BlendStrength 1.000                   //[0.000 to 1.000] Strength of the blending. This is a modifier based on bloom. 1.0 equates to 100% strength.
#define BloomDefocus 2.000                    //[1.000 to 4.000] The initial bloom defocus value. Increases the softness of light, bright objects, etc.
#define BloomWidth 3.200                      //[1.000 to 8.000] Width of the bloom. Adjusts the width of the spread and soft glow. Scales with BloomStrength.
#define BloomReds 0.040                       //[0.000 to 1.000] Red channel correction of the bloom. Raising will increase the bloom of reds.
#define BloomGreens 0.030                     //[0.000 to 1.000] Green channel correction of the bloom. Raising will increase the bloom of greens.
#define BloomBlues 0.020                      //[0.000 to 1.000] Blue channel correction of the bloom. Raising will increase the bloom of blues.

//##[SCENE_TONEMAPPING]
#define TonemapType 2                         //[0|1|2|3] The base tone mapping operator. 0 is LDR, 1 is HDR(original), 2 & 3 are Filmic HDR(slight grading).
#define TonemapMask 1                         //[0 or 1] Enables an ALU tone masking curve. Produces a nice cinematic look. Suits some games more than others.
#define MaskStrength 0.10                     //[0.000 to 1.000] Strength of the tone masking. Higher for a stronger effect. This is a dependency of TonemapMask.
#define ToneAmount 0.360                      //[0.050 to 1.000] Tonemap strength (tone correction). Higher for stronger tone mapping, lower for lighter.
#define BlackLevels 0.000                     //[0.000 to 1.000] Black level balance (shadow correction). Increase to deepen blacks, lower to lighten them.
#define Exposure 1.000                        //[0.100 to 2.000] White correction (brightness). Higher values for more scene exposure, lower for less.
#define Luminance 1.000                       //[0.100 to 2.000] Luminance average (luminance correction). Higher values will lower scene luminance average.
#define WhitePoint 1.075                      //[0.100 to 2.000] Whitepoint average (wp lum correction). Higher values will lower the maximum scene white point.

//##[COLOR_CORRECTION]
#define CorrectionPalette 1                   //[1|2|3|4|5] The colorspace palette type. 1: RGB, 2: YXY, 3: XYZ, 4: HSV, 5: YUV. Each one will produce a different combination of shades & hues.
#define ChannelR 1.40                         //[0.00 to 8.00] R(1), Y(2), X(3), H(4), Y(5) component channel varies with the colorspace used. Higher values increase correction strength.
#define ChannelG 1.60                         //[0.00 to 8.00] G(1), X(2), Y(3), S(4), U(5) component channel varies with the colorspace used. Higher values increase correction strength.
#define ChannelB 1.80                         //[0.00 to 8.00] B(1), Y(2), Z(3), V(4), V(5) component channel varies with the colorspace used. Higher values increase correction strength.
#define PaletteStrength 2.00                  //[0.00 to 4.00] The interpolated strength ratio between the base color, and the corrected color. Raise to increase saturation.

//##[CROSS_PROCESSING]
#define FilmicProcess 1                       //[1|2|3] The color conversion type for the cross process. 1: cool, 2: warm, 3: dusk. You can achieve different results with each.
#define RedShift 0.50                         //[0.10 to 1.00] Red color component shift of the filmic processing. Alters the red balance of the shift.
#define GreenShift 0.50                       //[0.10 to 1.00] Green color component shift of the filmic processing. Alters the green balance of the shift.
#define BlueShift 0.50                        //[0.10 to 1.00] Blue color component shift of the filmic processing. Alters the blue balance of the shift.
#define ShiftRatio 0.50                       //[0.10 to 2.00] The blending ratio for the base color and the color shift. Higher for a stronger effect.

//##[COLOR_GRADING]
#define RedGrading 1.20                       //[0.00 to 3.00] Red colour grading coefficient. Adjust to influence the red channel coefficients of the grading, and highlight tones.
#define GreenGrading 1.10                     //[0.00 to 3.00] Green colour grading coefficient. Adjust to influence the Green channel coefficients of the grading, and highlight tones.
#define BlueGrading 1.10                      //[0.00 to 3.00] Blue colour grading coefficient. Adjust to influence the Blue channel coefficients of the grading, and highlight tones.
#define GradingStrength 0.25                  //[0.00 to 1.00] The overall max strength of the colour grading effect. Raise to increase, lower to decrease the amount.
#define Correlation 1.00                      //[0.10 to 1.00] Correlation between the base colour, and the grading influence. Lower = more of the scene is graded, Higher = less of the scene is graded.


//##[USE_SCANLINES]
#define Scanlines        0.20       //[default 0.25]
#define Brighten         0.30       //[default 0.40]
#define Colorshift       0.50       //[default 0.50]
#define Lineblur         0.50       //[default 0.50]
#define Phosphorgrid     0.00          //[default 0.20]
#define Screencurve      0.00       //[default 0.15]
#define Lines            272.0       //[default  272.0] For use with arcade conversions such as SFA3, Darkstalkers or Metal Slug. Change this to 224.0 and change PPSSPP's internal rendering resolution by 2x, to align the scanlines to the game's original arcade resolution.
#define xRES_u           1920.0       //[default 1920.0] This is the on-screen resolution of the emulation's output frame,
#define yRES_u           1088.0       //[default 1088.0] keep in mind the PSP's odd 16/9.06667 screen ratio.

//##[TEXTURE_SIZE]
#define pixelWidth   1024.0                   //[1024 to 4096] 
#define pixelHeight  512.0                    //[512 to 2048]
#define Quality      1.                       //[0.5 to 1.0] 

//[END OF USER OPTIONS]

/*------------------------------------------------------------------------------
[GLOBALS|FUNCTIONS]
------------------------------------------------------------------------------*/

//Global variables
#define SamplerState sampler2D
#define saturate(x) clamp(x, 0.0, 1.0)
#define lerp mix
#define frac fract
#define fmod mod
#define mul(x, y) (y * x)
#define float4x3 mat4x3
#define float3x3 mat3
#define float4x4 mat4
#define lumCoeff vec3(0.212656, 0.715158, 0.072186)

//OGL Uniforms
uniform vec4 OGLParam[4];
uniform sampler2D OGLTexture;
uniform sampler2D OGLTexture0;

//varying
uniform vec2 texcoord;
uniform vec4 color;

float Epsilon = 1e-10;
float xy = (Quality / pixelWidth, Quality / pixelHeight, Quality, 0.0);
//float y = (Quality / pixelHeight, 0.0);
vec2 OGLSize = vec2(pixelWidth, pixelHeight);
vec2 OGLInvSize = vec2(Quality / pixelWidth, Quality / pixelHeight);

//Average Relative Luminance (HSP Color Model)
//return (0.2126 * color.x) + (0.7152 * color.y) + (0.0722 * color.z);
float AvgLuminance(vec3 color)
{
return sqrt(dot(color * color, lumCoeff));
}

/*float smootherstep(float a, float b, float x)
{
x = clamp((x - a) / (b - a), 0.0, 1.0);
return x*x*x*(x*(x * 6 - 15) + 10);
}*/

//Smoothstep alt
float smootherstep(float a, float b, float x)
{
x = saturate((x - a) / (b - a));
return x*x*x*(x*(x * 6 - 15) + 10);
}

//Check for OOB rgb clipping
vec4 DebugClipping(vec4 color)
{
if (color.x >= 0.99999 && color.y >= 0.99999 &&
color.z >= 0.99999) color.xyz = vec3(1.0f, 0.0f, 0.0f);

if (color.x <= 0.00001 && color.y <= 0.00001 &&
color.z <= 0.00001) color.xyz = vec3(0.0f, 0.0f, 1.0f);

return color;
}

//Conversion matrices
vec3 RGBtoXYZ(vec3 RGB)
{
const mat3 RGBtoXYZ = mat3(
0.6068909, 0.1735011, 0.2003480,
0.2989164, 0.5865990, 0.1144845,
0.0000000, 0.0660957, 1.1162243);

return RGBtoXYZ*RGB;
}

vec3 XYZtoRGB(vec3 XYZ)
{
const mat3 XYZtoRGB = mat3(
1.9099961, -0.5324542, -0.2882091,
-0.9846663, 1.9991710, -0.0283082,
0.0583056, -0.1183781, 0.8975535);

return XYZtoRGB*XYZ;
}

vec3 XYZtoSRGB(vec3 XYZ)
{
const mat3 XYZtoSRGB = mat3(
3.2404542, -1.5371385, -0.4985314,
-0.9692660, 1.8760108, 0.0415560,
0.0556434, -0.2040259, 1.0572252);

return XYZtoSRGB*XYZ;
}

vec3 RGBtoYUV(vec3 RGB)
{
const mat3 RGBtoYUV = mat3(
0.2126, 0.7152, 0.0722,
-0.09991, -0.33609, 0.436,
0.615, -0.55861, -0.05639);

return RGBtoYUV*RGB;
}

vec3 YUVtoRGB(vec3 YUV)
{
const mat3 YUVtoRGB = mat3(
1.000, 0.000, 1.28033,
1.000, -0.21482, -0.38059,
1.000, 2.12798, 0.000);

return YUVtoRGB*YUV;
}

vec3 XYZtoYxy(vec3 XYZ)
{
float w = (XYZ.r + XYZ.g + XYZ.b);
vec3 Yxy;

Yxy.r = XYZ.g;
Yxy.g = XYZ.r / w;
Yxy.b = XYZ.g / w;

return Yxy;
}

vec3 YxytoXYZ(vec3 Yxy)
{
vec3 XYZ;
XYZ.g = Yxy.r;
XYZ.r = Yxy.r * Yxy.g / Yxy.b;
XYZ.b = Yxy.r * (1.0 - Yxy.g - Yxy.b) / Yxy.b;

return XYZ;
}

/*------------------------------------------------------------------------------
[FXAA CODE SECTION]
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
Code from http://www.geeks3d.com/20110405/fxaa-fast-approximate-anti-aliasing-demo-glsl-opengl-test-radeon-geforce/3/
Credit to original Author
------------------------------------------------------------------------------*/
#if USE_FXAA == 1


vec3 FxaaPixelShader(sampler2D OGLTexture, vec2 texcoord)
{
float FXAA_SPAN_MAX = 8.0;                     //[4.0 t0 8.0]             
float FXAA_REDUCE_MUL = (1.0 / FXAA_SPAN_MAX); //[Default]
float FXAA_REDUCE_MIN = (1.0 / 128.0);         //[Default]
float FXAA_SUBPIX_SHIFT = (1.0 / 4.0);         //[Default]

vec4 posPos = vec4(texcoord.xy, texcoord.xy - (OGLInvSize * (0.5 + FXAA_SUBPIX_SHIFT)));

/*---------------------------------------------------------*/
vec3 rgbNW = texture2D(OGLTexture, posPos.zw, 0.0).rgb;
vec3 rgbNE = texture2D(OGLTexture, posPos.zw + vec2(1., 0.)*OGLInvSize.xy, 0.0).rgb;
vec3 rgbSW = texture2D(OGLTexture, posPos.zw + vec2(0., 1.)*OGLInvSize.xy, 0.0).rgb;
vec3 rgbSE = texture2D(OGLTexture, posPos.zw + vec2(1., 1.)*OGLInvSize.xy, 0.0).rgb;
vec3 rgbM = texture2D(OGLTexture, texcoord.xy, 0.0).rgb;
/*---------------------------------------------------------*/
//vec3 luma = vec3(0.299, 0.587, 0.114);
float lumaNW = AvgLuminance(rgbNW);
float lumaNE = AvgLuminance(rgbNE);
float lumaSW = AvgLuminance(rgbSW);
float lumaSE = AvgLuminance(rgbSE);
float lumaM = AvgLuminance(rgbM);
/*---------------------------------------------------------*/
float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
/*---------------------------------------------------------*/
vec2 dir;
dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE));
/*---------------------------------------------------------*/
float dirReduce = max(
(lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL),
FXAA_REDUCE_MIN);
float rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce);
dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX),
max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),
dir * rcpDirMin)) * OGLInvSize.xy;
/*--------------------------------------------------------*/
vec3 rgbA = (1.0 / 2.0) * (
texture2D(OGLTexture, texcoord.xy + dir * (1.0 / 3.0 - 0.5)).rgb +
texture2D(OGLTexture, texcoord.xy + dir * (2.0 / 3.0 - 0.5)).rgb);
vec3 rgbB = rgbA * (1.0 / 2.0) + (1.0 / 4.0) * (
texture2D(OGLTexture, texcoord.xy + dir * (0.0 / 3.0 - 0.5)).rgb +
texture2D(OGLTexture, texcoord.xy + dir * (3.0 / 3.0 - 0.5)).rgb);
float lumaB = AvgLuminance(rgbB);
if ((lumaB < lumaMin) || (lumaB > lumaMax)) {
return rgbA.rgb;
}
else {
return rgbB.rgb;
}
}

vec4 FXAAPass(vec4 Fxaa, vec2 texcoord)
{
Fxaa.rgb = FxaaPixelShader(OGLTexture, texcoord);

Fxaa.a = AvgLuminance(Fxaa.rgb);

return Fxaa.rgb;
}
#endif

/*------------------------------------------------------------------------------
[BUMP MAPPING with AA SHADER CODE SECTION]
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
Copyright(C) 2011 - 2015 guest(r) - [email protected]
Credit to Guest r.
------------------------------------------------------------------------------*/
#if USE_AABUMPMAP == 1
vec3 BumpMapping(sampler2D OGLTexture, vec2 texcoord)
{
float x = (Range / pixelWidth);
    float y = (Range / pixelHeight);

vec2 dg1 = vec2(x, y);
vec2 dg2 = vec2(-x, y);

vec2 dx = vec2(x, 0.0)*.5;
vec2 dy = vec2(0.0, y)*.5;

vec2 u_Tex0 = texcoord;
vec4 u_Tex1 = vec4(u_Tex0 - dy, u_Tex0 - dg2);
vec4 u_Tex2 = vec4(u_Tex0 + dy, u_Tex0 + dg2);
vec4 u_Tex3 = vec4(u_Tex0 - dx, u_Tex0 - dg2);
vec4 u_Tex4 = vec4(u_Tex0 + dx, u_Tex0 + dg2);
vec4 u_Tex5 = vec4(u_Tex0 - dg1, u_Tex0 - dg2);
vec4 u_Tex6 = vec4(u_Tex0 + dg1, u_Tex0 + dg2);

vec3 c10 = texture2D(OGLTexture, u_Tex1.xy).rgb;
vec3 c12 = texture2D(OGLTexture, u_Tex2.xy).rgb;
vec3 c01 = texture2D(OGLTexture, u_Tex3.xy).rgb;
vec3 c21 = texture2D(OGLTexture, u_Tex4.xy).rgb;
vec3 c00 = texture2D(OGLTexture, u_Tex5.xy).rgb;
vec3 c22 = texture2D(OGLTexture, u_Tex6.xy).rgb;
vec3 c11 = texture2D(OGLTexture, u_Tex0.xy).rgb;
vec3 c02 = texture2D(OGLTexture, u_Tex1.zw).rgb;
vec3 c20 = texture2D(OGLTexture, u_Tex2.zw).rgb;

vec3 dt = vec3(1.0, 1.0, 1.0);

float d1 = dot(abs(c00 - c22), dt) + 0.0001;
float d2 = dot(abs(c20 - c02), dt) + 0.0001;
float hl = dot(abs(c01 - c21), dt) + 0.0001;
float vl = dot(abs(c10 - c12), dt) + 0.0001;

float md = d1 + d2;   
float mc = hl + vl;
hl *= md;
vl *= md;   
d1 *= mc;
d2 *= mc;

float ww = d1 + d2 + hl + vl;

vec3 d11 = (hl*(c10 + c12) + vl*(c01 + c21) + d1*(c20 + c02) + d2*(c00 + c22) + ww*c11) / (3.0*ww);

c11 = (-c00 + c22 - c01 + c21 - c10 + c12 + Bump*d11) / Bump;

c11 = min(c11, Glow*d11);

c11 = max(c11, Shde*d11);

return c11;
}

vec4 BumpMappingPass(vec4 color, vec2 texcoord)
{
color.rgb = BumpMapping(OGLTexture, texcoord);

color.a = AvgLuminance(color.rgb);

return color;
}
#endif

/*------------------------------------------------------------------------------
[GAMMA CORRECTION CODE SECTION]
------------------------------------------------------------------------------*/

vec3 EncodeGamma(vec3 color, float gamma)
{
color = saturate(color);
color.r = (color.r <= 0.0404482362771082) ? color.r / 12.92 : pow((color.r + 0.055) / 1.055, gamma);
color.g = (color.g <= 0.0404482362771082) ? color.g / 12.92 : pow((color.g + 0.055) / 1.055, gamma);
color.b = (color.b <= 0.0404482362771082) ? color.b / 12.92 : pow((color.b + 0.055) / 1.055, gamma);

return color;
}

vec3 DecodeGamma(vec3 color, float gamma)
{
color = saturate(color);
color.r = (color.r <= 0.00313066844250063) ? color.r * 12.92 : 1.055 * pow(color.r, 1.0 / gamma) - 0.055;
color.g = (color.g <= 0.00313066844250063) ? color.g * 12.92 : 1.055 * pow(color.g, 1.0 / gamma) - 0.055;
color.b = (color.b <= 0.00313066844250063) ? color.b * 12.92 : 1.055 * pow(color.b, 1.0 / gamma) - 0.055;

return color;
}

#if GAMMA_CORRECTION == 1
vec4 GammaPass(vec4 color, vec2 texcoord)
{
const float GammaConst = 2.233333;
color.rgb = EncodeGamma(color.rgb, GammaConst);
color.rgb = DecodeGamma(color.rgb, float(Gamma));
color.a = AvgLuminance(color.rgb);

return color;
}
#endif

/*------------------------------------------------------------------------------
[BLENDED BLOOM CODE SECTION]
------------------------------------------------------------------------------*/

#if BLENDED_BLOOM == 1
vec3 BlendAddLight(vec3 bloom, vec3 blend)
{
return saturate(bloom + blend);
}

vec3 BlendScreen(vec3 bloom, vec3 blend)
{
return (bloom + blend) - (bloom * blend);
}

vec3 BlendGlow(vec3 bloom, vec3 blend)
{
float glow = AvgLuminance(bloom);
return lerp((bloom + blend) - (bloom * blend), (blend + blend) - (blend * blend), glow);
}

vec3 BlendAddGlow(vec3 bloom, vec3 blend)
{
float addglow = smootherstep(0.0, 1.0, AvgLuminance(bloom));
return lerp(saturate(bloom + blend), (blend + blend) - (blend * blend), addglow);
}

vec3 BlendLuma(vec3 bloom, vec3 blend)
{
float lumavg = smootherstep(0.0, 1.0, AvgLuminance(bloom + blend));
return lerp((bloom * blend), (1.0 - ((1.0 - bloom) * (1.0 - blend))), lumavg);
}

vec3 BlendOverlay(vec3 bloom, vec3 blend)
{
vec3 overlay = step(0.5, bloom);
return lerp((bloom * blend * 2.0), (1.0 - (2.0 *(1.0 - bloom) * (1.0 - blend))), overlay);
}

vec3 BloomCorrection(vec3 color)
{
vec3 bloom = color;

bloom.r = 2.0 / 3.0 * (1.0 - (bloom.r * bloom.r));
bloom.g = 2.0 / 3.0 * (1.0 - (bloom.g * bloom.g));
bloom.b = 2.0 / 3.0 * (1.0 - (bloom.b * bloom.b));

bloom.r = saturate(color.r + float(BloomReds) * bloom.r);
bloom.g = saturate(color.g + float(BloomGreens) * bloom.g);
bloom.b = saturate(color.b + float(BloomBlues) * bloom.b);
color = bloom;
return color;
}

vec4 DefocusFilter(sampler2D OGLTexture, vec2 texcoord, vec2 defocus)
{
defocus = clamp(defocus, 1.0, 1.5);
vec2 texel = OGLInvSize * defocus;

vec4 sampleA = texture2D(OGLTexture, texcoord + vec2(0.5, 0.5) * texel);
vec4 sampleB = texture2D(OGLTexture, texcoord + vec2(-0.5, 0.5) * texel);
vec4 sampleC = texture2D(OGLTexture, texcoord + vec2(0.5, -0.5) * texel);
vec4 sampleD = texture2D(OGLTexture, texcoord + vec2(-0.5, -0.5) * texel);

float fx = frac(texcoord.x * OGLSize.x);
float fy = frac(texcoord.y * OGLSize.y);

vec4 interpolateA = lerp(sampleA, sampleB, fx);
vec4 interpolateB = lerp(sampleC, sampleD, fx);
return lerp(interpolateA, interpolateB, fy);
}

vec4 BloomPass(vec4 color, vec2 texcoord)
{
float anflare = 4.0;
float width = BloomWidth;

vec2 defocus = vec2(BloomDefocus, BloomDefocus);
vec4 bloom = DefocusFilter(OGLTexture, texcoord, defocus);

vec2 dx = vec2(OGLInvSize.x * width, 0.0);
vec2 dy = vec2(0.0, OGLInvSize.y * width);

vec2 mdx = vec2(dx.x * defocus.x, 0.0);
vec2 mdy = vec2(0.0, dy.y * defocus.y);

vec4 blend = bloom * 0.22520613262190495;

blend += 0.002589001911021066 * texture2D(OGLTexture, texcoord - mdx + mdy);
blend += 0.010778807494659370 * texture2D(OGLTexture, texcoord - dx + mdy);
blend += 0.024146616900339800 * texture2D(OGLTexture, texcoord + mdy);
blend += 0.010778807494659370 * texture2D(OGLTexture, texcoord + dx + mdy);
blend += 0.002589001911021066 * texture2D(OGLTexture, texcoord + mdx + mdy);

blend += 0.010778807494659370 * texture2D(OGLTexture, texcoord - mdx + dy);
blend += 0.044875475183061630 * texture2D(OGLTexture, texcoord - dx + dy);
blend += 0.100529757860782610 * texture2D(OGLTexture, texcoord + dy);
blend += 0.044875475183061630 * texture2D(OGLTexture, texcoord + dx + dy);
blend += 0.010778807494659370 * texture2D(OGLTexture, texcoord + mdx + dy);

blend += 0.024146616900339800 * texture2D(OGLTexture, texcoord - mdx);
blend += 0.100529757860782610 * texture2D(OGLTexture, texcoord - dx);
blend += 0.100529757860782610 * texture2D(OGLTexture, texcoord + dx);
blend += 0.024146616900339800 * texture2D(OGLTexture, texcoord + mdx);

blend += 0.010778807494659370 * texture2D(OGLTexture, texcoord - mdx - dy);
blend += 0.044875475183061630 * texture2D(OGLTexture, texcoord - dx - dy);
blend += 0.100529757860782610 * texture2D(OGLTexture, texcoord - dy);
blend += 0.044875475183061630 * texture2D(OGLTexture, texcoord + dx - dy);
blend += 0.010778807494659370 * texture2D(OGLTexture, texcoord + mdx - dy);

blend += 0.002589001911021066 * texture2D(OGLTexture, texcoord - mdx - mdy);
blend += 0.010778807494659370 * texture2D(OGLTexture, texcoord - dx - mdy);
blend += 0.024146616900339800 * texture2D(OGLTexture, texcoord - mdy);
blend += 0.010778807494659370 * texture2D(OGLTexture, texcoord + dx - mdy);
blend += 0.002589001911021066 * texture2D(OGLTexture, texcoord + mdx - mdy);
blend = lerp(color, blend, float(BlendStrength));

bloom.xyz = BloomType(bloom.xyz, blend.xyz);
bloom.xyz = BloomCorrection(bloom.xyz);

color.w = AvgLuminance(color.xyz);
bloom.w = AvgLuminance(bloom.xyz);
bloom.w *= anflare;

color = lerp(color, bloom, float(BloomStrength));

return color;
}
#endif

/*------------------------------------------------------------------------------
[SCENE TONE MAPPING CODE SECTION]
------------------------------------------------------------------------------*/

#if SCENE_TONEMAPPING == 1

vec3 ScaleLuminance(vec3 x)
{
float W = 1.02; // WhitePoint Scale
float L = 0.16; // Luminance Scale
float C = 1.02; // Compression Scale

float N = clamp(0.82 + ToneAmount, 1.0, 2.0);
float K = (N - L * C) / C;

vec3 tone = L * C + (1.0 - L * C) * (1.0 + K * (x - L) / ((W - L) * (W - L))) * (x - L) / (x - L + K);

vec3 color;
color.r = (x.r > L) ? tone.r : C * x.r;
color.g = (x.g > L) ? tone.g : C * x.g;
color.b = (x.b > L) ? tone.b : C * x.b;

return color;
}

vec3 TmMask(vec3 color)
{
vec3 tone = color;

float highTone = 6.2;
float greyTone = 0.4;
float midTone = 1.62;
float lowTone = 0.06;

tone.r = (tone.r * (highTone * tone.r + greyTone)) / (tone.r * (highTone * tone.r + midTone) + lowTone);
tone.g = (tone.g * (highTone * tone.g + greyTone)) / (tone.g * (highTone * tone.g + midTone) + lowTone);
tone.b = (tone.b * (highTone * tone.b + greyTone)) / (tone.b * (highTone * tone.b + midTone) + lowTone);

const float gamma = 2.42;
tone = EncodeGamma(tone, gamma);

color = lerp(color, tone, float(MaskStrength));

return color;
}

vec3 TmCurve(vec3 color)
{
vec3 T = color;

float tnamn = ToneAmount;
float blevel = length(T);
float bmask = pow(blevel, 0.02);

float A = 0.100; float B = 0.300;
float C = 0.100; float D = tnamn;
float E = 0.020; float F = 0.300;

float W = 1.000;

T.r = ((T.r*(A*T.r + C*B) + D*E) / (T.r*(A*T.r + B) + D*F)) - E / F;
T.g = ((T.g*(A*T.g + C*B) + D*E) / (T.g*(A*T.g + B) + D*F)) - E / F;
T.b = ((T.b*(A*T.b + C*B) + D*E) / (T.b*(A*T.b + B) + D*F)) - E / F;

float denom = ((W*(A*W + C*B) + D*E) / (W*(A*W + B) + D*F)) - E / F;

vec3 black = vec3(bmask, bmask, bmask);
vec3 white = vec3(denom, denom, denom);

T = T / white;
T = T * black;

color = saturate(T);

return color;
}

vec4 TonemapPass(vec4 color, vec2 texcoord)
{
float L = Luminance;

vec3 tonemap = color.rgb;
vec3 luma = vec3(L, L, L);

float blackLevel = length(tonemap);
tonemap = ScaleLuminance(tonemap);

float luminanceAverage = AvgLuminance(luma);

if (TonemapMask == 1) { tonemap = TmMask(tonemap); }
if (TonemapType == 1) { tonemap = TmCurve(tonemap); }

// RGB -> XYZ conversion
vec3 XYZ = RGBtoXYZ(tonemap);

// XYZ -> Yxy conversion
vec3 Yxy;

Yxy.r = XYZ.g;                                  // copy luminance Y
Yxy.g = XYZ.r / (XYZ.r + XYZ.g + XYZ.b);        // x = X / (X + Y + Z)
Yxy.b = XYZ.g / (XYZ.r + XYZ.g + XYZ.b);        // y = Y / (X + Y + Z)

// (Wt) Tone mapped scaling of the initial wp before input modifiers
float Wt = saturate(Yxy.r / AvgLuminance(XYZ));

if (TonemapType == 2) { Yxy.r = TmCurve(Yxy).r; }

// (Lp) Map average luminance to the middlegrey zone by scaling pixel luminance
float Lp = Yxy.r * float(Exposure) / (luminanceAverage + Epsilon);

// (Wp) White point calculated, based on the toned white, and input modifier
float Wp = dot(abs(Wt), float(WhitePoint));

// (Ld) Scale all luminance within a displayable range of 0 to 1
Yxy.r = (Lp * (1.0 + Lp / (Wp * Wp))) / (1.0 + Lp);

// Yxy -> XYZ conversion
XYZ.r = Yxy.r * Yxy.g / Yxy.b;                  // X = Y * x / y
XYZ.g = Yxy.r;                                  // copy luminance Y
XYZ.b = Yxy.r * (1.0 - Yxy.g - Yxy.b) / Yxy.b;  // Z = Y * (1-x-y) / y

if (TonemapType == 3) { XYZ = TmCurve(XYZ); }

// XYZ -> RGB conversion
tonemap = XYZtoRGB(XYZ);

float shadowmask = pow(saturate(blackLevel), float(BlackLevels));
tonemap = tonemap * vec3(shadowmask, shadowmask, shadowmask);

color.rgb = tonemap;
color.a = AvgLuminance(color.rgb);

return color;
}
#endif

/*------------------------------------------------------------------------------
[COLOR CORRECTION CODE SECTION]
------------------------------------------------------------------------------*/

// Converting pure hue to RGB
vec3 HUEtoRGB(float H)
{
float R = abs(H * 6.0 - 3.0) - 1.0;
float G = 2.0 - abs(H * 6.0 - 2.0);
float B = 2.0 - abs(H * 6.0 - 4.0);

return saturate(vec3(R, G, B));
}

// Converting RGB to hue/chroma/value
vec3 RGBtoHCV(vec3 RGB)
{
vec4 BG = vec4(RGB.bg, -1.0, 2.0 / 3.0);
vec4 GB = vec4(RGB.gb, 0.0, -1.0 / 3.0);

vec4 P = (RGB.g < RGB.b) ? BG : GB;

vec4 XY = vec4(P.xyw, RGB.r);
vec4 YZ = vec4(RGB.r, P.yzx);

vec4 Q = (RGB.r < P.x) ? XY : YZ;

float C = Q.x - min(Q.w, Q.y);
float H = abs((Q.w - Q.y) / (6.0 * C + Epsilon) + Q.z);

return vec3(H, C, Q.x);
}

// Converting RGB to HSV
vec3 RGBtoHSV(vec3 RGB)
{
vec3 HCV = RGBtoHCV(RGB);
float S = HCV.y / (HCV.z + Epsilon);

return vec3(HCV.x, S, HCV.z);
}

// Converting HSV to RGB
vec3 HSVtoRGB(vec3 HSV)
{
vec3 RGB = HUEtoRGB(HSV.x);
return ((RGB - 1.0) * HSV.y + 1.0) * HSV.z;
}

#if COLOR_CORRECTION == 1
// Pre correction color mask
vec3 PreCorrection(vec3 color)
{
vec3 RGB = color;

RGB.r = 2.0 / 3.0 * (1.0 - (RGB.r * RGB.r));
RGB.g = 2.0 / 3.0 * (1.0 - (RGB.g * RGB.g));
RGB.b = 2.0 / 3.0 * (1.0 - (RGB.b * RGB.b));

RGB.r = saturate(color.r + (float(ChannelR) / 200.0) * RGB.r);
RGB.g = saturate(color.g + (float(ChannelG) / 200.0) * RGB.g);
RGB.b = saturate(color.b + (float(ChannelB) / 200.0) * RGB.b);

color = saturate(RGB);

return color;
}

vec3 ColorCorrection(vec3 color)
{
float X = 1.0 / (1.0 + exp(float(ChannelR) / 2.0));
float Y = 1.0 / (1.0 + exp(float(ChannelG) / 2.0));
float Z = 1.0 / (1.0 + exp(float(ChannelB) / 2.0));

color.r = (1.0 / (1.0 + exp(float(-ChannelR) * (color.r - 0.5))) - X) / (1.0 - 2.0 * X);
color.g = (1.0 / (1.0 + exp(float(-ChannelG) * (color.g - 0.5))) - Y) / (1.0 - 2.0 * Y);
color.b = (1.0 / (1.0 + exp(float(-ChannelB) * (color.b - 0.5))) - Z) / (1.0 - 2.0 * Z);

return saturate(color);
}

vec4 CorrectionPass(vec4 color, vec2 texcoord)
{
vec3 colorspace = PreCorrection(color.rgb);

#if CorrectionPalette == 1
colorspace = ColorCorrection(colorspace);

#elif CorrectionPalette == 2
vec3 XYZ = RGBtoXYZ(colorspace);
vec3 Yxy = XYZtoYxy(XYZ);

Yxy = ColorCorrection(Yxy);
XYZ = YxytoXYZ(Yxy);
colorspace = XYZtoRGB(XYZ);

#elif CorrectionPalette == 3
vec3 XYZ = RGBtoXYZ(colorspace);
vec3 Yxy = XYZtoYxy(XYZ);
XYZ = YxytoXYZ(Yxy);
XYZ = ColorCorrection(XYZ);
colorspace = XYZtoRGB(XYZ);

#elif CorrectionPalette == 4
vec3 hsv = RGBtoHSV(colorspace);
hsv = ColorCorrection(hsv);
colorspace = HSVtoRGB(hsv);

#elif CorrectionPalette == 5
vec3 yuv = RGBtoYUV(colorspace);
yuv = ColorCorrection(yuv);
colorspace = YUVtoRGB(yuv);
#endif

color.rgb = lerp(color.rgb, colorspace, float(PaletteStrength));

color.a = AvgLuminance(color.rgb);

return color;
}
#endif

/*------------------------------------------------------------------------------
[CROSS PROCESSING CODE SECTION]
------------------------------------------------------------------------------*/
#if CROSS_PROCESSING == 1

vec3 CrossShift(vec3 color)
{
vec3 cross;

vec2 CrossMatrix[3] = vec2[](
vec2(0.960, 0.040 * color.x),
vec2(0.980, 0.020 * color.y),
vec2(0.970, 0.030 * color.z));

cross.x = float(RedShift) * CrossMatrix[0].x + CrossMatrix[0].y;
cross.y = float(GreenShift) * CrossMatrix[1].x + CrossMatrix[1].y;
cross.z = float(BlueShift) * CrossMatrix[2].x + CrossMatrix[2].y;

float lum = AvgLuminance(color);
vec3 black = vec3(0.0, 0.0, 0.0);
vec3 white = vec3(1.0, 1.0, 1.0);

cross = lerp(black, cross, saturate(lum * 2.0));
cross = lerp(cross, white, saturate(lum - 0.5) * 2.0);
color = lerp(color, cross, saturate(lum * float(ShiftRatio)));

return color;
}

vec4 CrossPass(vec4 color, vec2 texcoord)
{
#if FilmicProcess == 1
color.rgb = CrossShift(color.rgb);

#elif FilmicProcess == 2
vec3 XYZ = RGBtoXYZ(color.rgb);
vec3 Yxy = XYZtoYxy(XYZ);

Yxy = CrossShift(Yxy);
XYZ = YxytoXYZ(Yxy);

color.rgb = XYZtoRGB(XYZ);

#elif FilmicProcess == 3
vec3 XYZ = RGBtoXYZ(color.rgb);
vec3 Yxy = XYZtoYxy(XYZ);

XYZ = YxytoXYZ(Yxy);
XYZ = CrossShift(XYZ);

color.rgb = XYZtoRGB(XYZ);
#endif

color.a = AvgLuminance(color.rgb);

return saturate(color);
}
#endif

/*------------------------------------------------------------------------------
[COLOR GRADING CODE SECTION]
------------------------------------------------------------------------------*/

#if COLOR_GRADING == 1
float RGBCVtoHUE(vec3 RGB, float C, float V)
{
vec3 Delta = (V - RGB) / C;

Delta.rgb -= Delta.brg;
Delta.rgb += vec3(2.0, 4.0, 6.0);
Delta.brg = step(V, RGB) * Delta.brg;

float H;
H = max(Delta.r, max(Delta.g, Delta.b));
return frac(H / 6);
}

vec3 HSVComplement(vec3 HSV)
{
vec3 complement = HSV;
complement.x -= 0.5;

if (complement.x < 0.0) {
complement.x += 1.0;
}
return(complement);
}

float HueLerp(float h1, float h2, float v)
{
float d = abs(h1 - h2);

if (d <= 0.5)
{
return lerp(h1, h2, v);
}
else if (h1 < h2)
{
return frac(lerp((h1 + 1.0), h2, v));
}
else
{
return frac(lerp(h1, (h2 + 1.0), v));
}
}

vec4 ColorGradingPass(vec4 color, vec2 texcoord)
{
vec3 guide = vec3(RedGrading, GreenGrading, BlueGrading);

float amount = GradingStrength;
float correlation = Correlation;
float concentration = 2.00;

vec3 colorHSV = RGBtoHSV(color.rgb);
vec3 huePoleA = RGBtoHSV(guide);
vec3 huePoleB = HSVComplement(huePoleA);

float dist1 = abs(colorHSV.x - huePoleA.x);
if (dist1 > 0.5) dist1 = 1.0 - dist1;

float dist2 = abs(colorHSV.x - huePoleB.x);
if (dist2 > 0.5) dist2 = 1.0 - dist2;

float descent = smoothstep(0.0, correlation, colorHSV.y);

vec3 HSVColor = colorHSV;

    if (dist1 < dist2) {

float c = descent * amount * (1.0 - pow((dist1 * 2.0), 1.0 / concentration));

HSVColor.x = HueLerp(colorHSV.x, huePoleA.x, c);
HSVColor.y = lerp(colorHSV.y, huePoleA.y, c);
}
else
{
float c = descent * amount * (1.0 - pow((dist2 * 2.0), 1.0 / concentration));

HSVColor.x = HueLerp(colorHSV.x, huePoleB.x, c);
HSVColor.y = lerp(colorHSV.y, huePoleB.y, c);
}

color.rgb = HSVtoRGB(HSVColor);

color.a = AvgLuminance(color.rgb);

return saturate(color);
}
#endif

/*------------------------------------------------------------------------------
[SCANLINES CODE SECTION]
------------------------------------------------------------------------------*/
//arcade scanlines by Nick
//Credit to Nick
//intended for use with the original PSP resolution (but works with high res too)

#if USE_SCANLINES == 1

//adjusting misc variables & stuff, no need to change these:
#define _PI               3.141592653
#define Shiftlines       0.75
#define Hblur            0.001 * Lineblur
#define Cshift           0.001 * Colorshift
#define Phosphor         1.0 - clamp(Phosphorgrid, 0.0, 1.0)
#define Darken           1.0 - clamp(Scanlines, 0.0, 1.0)
#define Scanwidthcurve   Scanlines / 2.0

vec3 ArcadeScanlines(sampler2D OGLTexture, vec2 texcoord)
{
//TV screen curve:
//horizontal and vertical screen curve functions:
vec2 f = vec2(pow(texcoord.x - 0.5, 2.0) * Screencurve, pow(texcoord.y - 0.5, 2.0) * Screencurve * 0.567);

//applying and aligning functions to screen pixels:
vec2 curvedcoord = vec2(texcoord.x + (f.y - f.y * (1.5 - texcoord.x)), texcoord.y + (f.x - f.x * (1.5 - texcoord.y)));

//make the border outside the screen black instead of stretched colors:
float xborder = int(curvedcoord.x + 1.0);
float yborder = int(curvedcoord.y + 1.0);

//horizontal blur and color shift, and a sine based line sampler that stretches filtered pixels vertically
//to make them fit the scanlines better and prevent scanline bleed:
float sinsample = (sin(curvedcoord.y*Lines*2.0*_PI) + curvedcoord.y*Lines*2.0*_PI) / (Lines*2.0*_PI);

float r = (texture2D(OGLTexture, vec2(curvedcoord.x + Cshift, sinsample)).x + texture2D(OGLTexture, vec2(curvedcoord.x + Cshift + Hblur, sinsample)).x + texture2D(OGLTexture, vec2(curvedcoord.x + Cshift - Hblur, sinsample)).x) / (3.0 - Brighten);
float g = (texture2D(OGLTexture, vec2(curvedcoord.x - Cshift, sinsample)).y + texture2D(OGLTexture, vec2(curvedcoord.x - Cshift + Hblur, sinsample)).y + texture2D(OGLTexture, vec2(curvedcoord.x - Cshift - Hblur, sinsample)).y) / (3.0 - Brighten);
float b = (texture2D(OGLTexture, vec2(curvedcoord.x, sinsample)).z + texture2D(OGLTexture, vec2(curvedcoord.x + Hblur, sinsample)).z + texture2D(OGLTexture, vec2(curvedcoord.x - Hblur, sinsample)).z) / (3.0 - Brighten);

//phosphor rgb grid:
//rgb color lines:
int posr = int(texcoord.x * xRES_u + 2.0);
int posg = int(texcoord.x * xRES_u + 1.0);
int posb = int(texcoord.x * xRES_u);

float intr = mod(float(posr), 3.0);
float intg = mod(float(posg), 3.0);
float intb = mod(float(posb), 3.0);

r *= clamp(intg * intb, Phosphor, 1.0);
g *= clamp(intr * intb, Phosphor, 1.0);
b *= clamp(intr * intg, Phosphor, 1.0);

//breaks between phosphor rgb elements in a hexagonal pattern:
int yposPhosbreak1 = int(texcoord.y * yRES_u);
int yposPhosbreak2 = int(texcoord.y * yRES_u + 2.0);
int xposPhosbreak = int(texcoord.x * xRES_u / 3.0 - 0.333333333);

float intPhosbreak1 = mod(float(yposPhosbreak1), 4.0) + mod(float(xposPhosbreak), 2.0);
float intPhosbreak2 = mod(float(yposPhosbreak2), 4.0) + (1.0 - mod(float(xposPhosbreak), 2.0));

//final composition, phosphor seems to slightly redden image (?), so if it's on, we slightly mute r:
vec3 rgb = vec3(r*(0.9 + 0.1*Phosphor), g, b);

//apply phosphor breaks:
rgb *= clamp(intPhosbreak1*intPhosbreak2 + 0.5 + 0.5 * Phosphor, 0.0, 1.0);

//make scanlines:
rgb -= 1.0 - clamp(Darken + Scanwidthcurve*(1.0 + cos(Shiftlines*_PI + curvedcoord.y*_PI*2.0*Lines)), 0.0, 1.0);

//apply border:
rgb *= mod(float(xborder), 2.0)*mod(float(yborder), 2.0);

//pixel all done!
return rgb;
}

vec4 ScanlinesPass(vec4 color, vec2 texcoord)
{
color.rgb = ArcadeScanlines(OGLTexture, texcoord);

color.a = AvgLuminance(color.rgb);

return color;
}
#endif

/*------------------------------------------------------------------------------
[TV COLORS EMU CODE SECTION]
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
SimoneT NTSC TV colors emulation 1.0 Shader
Copyright (C) 2016 SimoneT - s[email protected]
Credit to SimoneT.
------------------------------------------------------------------------------*/

#if NTSC_TV_EMULATION == 1

// conversion from NTSC RGB Reference White D65 ( color space used by NA/Japan TV's ) to XYZ
vec3 NTSC(vec3 c)
{
vec3 v = vec3(pow(c.r, 2.2), pow(c.g, 2.2), pow(c.b, 2.2)); //Inverse Companding
return v*mat3(
0.6068909, 0.1735011, 0.2003480,
0.2989164, 0.5865990, 0.1144845,
0.0000000, 0.0660957, 1.1162243);
}

// conversion from XYZ to sRGB Reference White D65 ( color space used by windows )
vec3 sRGB(vec3 c)
{
vec3 v = c*mat3(
3.2404542, -1.5371385, -0.4985314,
-0.9692660, 1.8760108, 0.0415560,
0.0556434, -0.2040259, 1.0572252);

//Companding
v.r = (v.r > 0.0031308) ? ((1.055 * pow(v.r, (1.0 / 2.4))) - 0.055) : 12.92 * v.r;
v.g = (v.g > 0.0031308) ? ((1.055 * pow(v.g, (1.0 / 2.4))) - 0.055) : 12.92 * v.g;
v.b = (v.b > 0.0031308) ? ((1.055 * pow(v.b, (1.0 / 2.4))) - 0.055) : 12.92 * v.b;
return v;
}

// NTSC RGB to sRGB
vec3 NTSCtoSRGB(vec3 c)
{
return sRGB(NTSC(c));
}

// Ported from SimoneT TV colors emulation 1.0 Shader
vec4 TvColorsPass(vec4 color, vec2 texcoord)
{
color.rgb = NTSCtoSRGB(color.rgb);

return color;
}
#endif

/*------------------------------------------------------------------------------
[MAIN() & COMBINE PASS CODE SECTION]
------------------------------------------------------------------------------*/

void main()
{
vec2 texcoord = gl_TexCoord[0].xy;
vec4 color = texture2D(OGLTexture0, texcoord);

#if USE_AABUMPMAP == 1
color = BumpMappingPass(color, texcoord);
#endif

#if USE_FXAA == 1
color = FXAAPass(color, texcoord);
#endif

#if GAMMA_CORRECTION == 1
color = GammaPass(color, texcoord);
#endif

#if BLENDED_BLOOM == 1
color = BloomPass(color, texcoord);
#endif

#if SCENE_TONEMAPPING == 1
color = TonemapPass(color, texcoord);
#endif

#if COLOR_CORRECTION == 1
color = CorrectionPass(color, texcoord);
#endif

#if CROSS_PROCESSING == 1
color = CrossPass(color, texcoord);
#endif

#if COLOR_GRADING == 1
color = ColorGradingPass(color, texcoord);
#endif

#if USE_SCANLINES == 1
color = ScanlinesPass(color, texcoord);
#endif

#if NTSC_TV_EMULATION == 1
color = TvColorsPass(color, texcoord);
#endif

gl_FragColor = color;
}

Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-03-14 10:45:06
Here the Shader V1.06 for testing only, I havent put all code here because before I process to complete it I want someone to test it if have problem incompatible with this shader ..

http://www.mediafire.com/file/nlruh7nu07jd7zw/Sunwalker%27s_shader_Testing.7z
Title: Re: New Shader for Post Process
Post by: Kaldarasha on 2017-03-14 16:19:56
Doesn't work on my end.

App.log
Code: [Select]
[00000000] INFO: FF7/FF8 OpenGL driver version 0.8.1b
[00000000] INFO: Auto-detected version: FF7 1.02 US English
[00000000] INFO: NVIDIA Corporation GeForce GT 630M/PCIe/SSE2 4.5.0 NVIDIA 378.66
[00000000] INFO: OpenGL 2.0 support detected
[00000000] INFO: Found swap_control extension
[00000000] INFO: Max texture size: 16384x16384
[00000000] INFO: Original resolution 640x480, window size 1600x900, output resolution 1600x900, internal resolution 1920x960
[00000000] INFO: Shader limits: varying 124, vert uniform 4096, frag uniform 4096
[00000000] INFO: fragment shader compile log:
0(475) : error C1016: expression type incompatible with function return type
0(803) : error C7011: implicit cast from "vec4" to "vec3"
0(872) : error C7011: implicit cast from "vec4" to "vec3"
0(911) : error C7011: implicit cast from "vec4" to "vec3"
0(913) : error C7011: implicit cast from "vec4" to "vec3"
0(1649) : error C7616: global variable gl_TexCoord is removed after version 140
0(1700) : warning C7533: global variable gl_FragColor is deprecated after version 120

[00000000] INFO: postprocessing program link log:
Fragment info
-------------
0(475) : error C1016: expression type incompatible with function return type
0(803) : error C7011: implicit cast from "vec4" to "vec3"
0(872) : error C7011: implicit cast from "vec4" to "vec3"
0(911) : error C7011: implicit cast from "vec4" to "vec3"
0(913) : error C7011: implicit cast from "vec4" to "vec3"
0(1649) : error C7616: global variable gl_TexCoord is removed after version 140
0(1700) : warning C7533: global variable gl_FragColor is deprecated after version 120
(0) : error C2003: incompatible options for link

[00000000] ERROR: init_postprocessing failed, postprocessing will be disabled
Title: Re: New Shader for Post Process
Post by: Sunwalker on 2017-03-14 17:51:19
Thank you for the feedback :) .. mean i have to stick with 120 version only .. well .. i will change again all of the code soon ..
Title: Re: New Shader for Post Process
Post by: DLPB on 2017-05-18 02:09:59
https://e63i.imgup.net/test1fef9.png

The left hand side picture is how the game should look [ignore the right side]. The PSX version.  Your shader is the closest thing I've seen for a fix to make the game appear as it did there, but it clearly needs a few tweaks (slight pixellation in the backgrounds, colour is off, gamma is off).  Are you still working on this?

tbh I think the PC colour is better. After all, the PSX was limited in ways that the PC isn't. I've enabled FXAA on its own.  There is a slight error here... a tearing type artifact happens as you move about screen.


Edit. Disregard (apart from tearing issue).  I've tweaked it and it looks very good.  Will upload soon to bug thread.
Title: Re: New Shader for Post Process
Post by: DLPB on 2018-10-07 14:50:57
I've included this shader in The Reunion with my own values.

Below

Left: Mednafen with goat scanlines
Right: This shader with scanlines.

As you can see, the PC version looks better than mednafen.

https://drive.google.com/file/d/1SVmQq48x5qQITHF18efnJRGkB_-glOJB/view?usp=sharing

Suggest download and then view at 100%.