Author Topic: [FF7PC]FF7 SYW "ArkTsukiVock" (v4) upscale : Battle, world map, fields, videos  (Read 2537 times)

satsuki

  • Insane poster
  • *
  • Posts: 317
  • Karma: 51
    • View Profile
    • My softs (french only)
Here's my V4 release of FF7 battle, world map, fields, and movies upscaled 4x.

For the fields this v4 is a mix (overlay) of my v3 with the Manakeiser works and lots of manual tweaking to get the best of all filtering (2 to 5 filtering used on each field)
Aavock helps also mainly by correting or re-drawing most of the writings

I used mostly esrgan with some prefilter for fields and world map.
I used mostly gigapixel for battles.

The main goal of this release is to get as much details as possible without oversharping nor overcleaning the files.
I wanted to get the rendering as natural and constant in quality as possible across the whole game.

The game have been done 5 time for bug hunting and optimisations, no bug reported (only the driver's ones but not related to this pack)
Some effect on some screens aren't filtered to avoid ingame animation bugs (ancnt2,blin68_2,datiao_8,jtempl,jtmpin2,trnad1,woa1,woa2,woa3)

I've also refiltered the videos files from a mix of the psx and steam versions

Comparing to the V3 it's more crisp but yes natural and also most of the dithering have been solved (thanks to Manakeiser pre-processing)
The movies pack is full english version
The Kela51's magic and battles background as mostly as in the v3

Iro link (for 7theaven):
Fields (+char) : http://yatoshicom.free.fr/ff7sywv4.php?id=fieldsv4
Battle : http://yatoshicom.free.fr/ff7sywv4.php?id=battlev4
World : http://yatoshicom.free.fr/ff7sywv4.php?id=worldv4
Kela51's Magics (corrected) : http://yatoshicom.free.fr/ff7sywv4.php?id=kelasv12
Movies : http://yatoshicom.free.fr/ff7sywv4.php?id=moviesv4

For the french players only, there's a all in one installer with hard mod selection, game patch... : http://ff7.fr/forum/index.php?page=forum&idf=40


How to use the release:
If you use 7thHeaven:
Just use the iro linked files

If you don't use 7thHeaven:
You can unpack the iro's files with this tool : http://forums.qhimm.com/index.php?topic=18653.0


Here's some pictures:

Fields
Spoiler: show





























World map:
Spoiler: show









Battles and Magics:
Spoiler: show





























Movies:
Spoiler: show






« Last Edit: 2019-09-07 08:37:07 by satsuki »

GregOli

  • Fast newbie
  • *
  • Posts: 5
  • Karma: 0
    • View Profile
Beautiful work, satsuki! I'll be upgrading from v3 ASAP

Manakaiser

  • Cool newbie
  • *
  • Posts: 76
  • Karma: 4
    • View Profile
fantastic work!

olearyf2525

  • Crazy poster
  • *
  • Posts: 241
  • Karma: 13
    • View Profile
Great job Satsuki!

indrema

  • Cool newbie
  • *
  • Posts: 62
  • Karma: 0
    • View Profile
Hi Satsuki, thanks a lot for this insane job!
I have an annoyng issue, I cannot load the battle texture, but everiting else work great.
The battle textures are copied inside my mods\Reunion\battle, but arent loaded during battle.
Please help me.

satsuki

  • Insane poster
  • *
  • Posts: 317
  • Karma: 51
    • View Profile
    • My softs (french only)
Hi Satsuki, thanks a lot for this insane job!
I have an annoyng issue, I cannot load the battle texture, but everiting else work great.
The battle textures are copied inside my mods\Reunion\battle, but arent loaded during battle.
Please help me.
check that you don't have 2 battle folder:
mods\Reunion\battle\STAGE01_T00_00.png ///// right
mods\Reunion\battle\battle\STAGE01_T00_00.png ///// wrong
check also that you don't have a direct folder with battle files in it

indrema

  • Cool newbie
  • *
  • Posts: 62
  • Karma: 0
    • View Profile
check that you don't have 2 battle folder:
mods\Reunion\battle\STAGE01_T00_00.png ///// right
mods\Reunion\battle\battle\STAGE01_T00_00.png ///// wrong
check also that you don't have a direct folder with battle files in it

I've check and the path and direct folder are fine, the strange thing is I can load the magic texture during the battle but not the background ones.
The only way that I have to load some battle texture is by directly added those into battle.lpg.

satsuki

  • Insane poster
  • *
  • Posts: 317
  • Karma: 51
    • View Profile
    • My softs (french only)
don't know why, that's strange

indrema

  • Cool newbie
  • *
  • Posts: 62
  • Karma: 0
    • View Profile
At this point I'm try to bach convert actual .png name convention to the lpg original one, and convert it back to original format. I haven't any other idea.

indrema

  • Cool newbie
  • *
  • Posts: 62
  • Karma: 0
    • View Profile
Ok, I've revert the name back and convert png to tex, now everyting work!
By the way, what are the original name of ENEMY166ac and ENEMY217ac to add them too?

indrema

  • Cool newbie
  • *
  • Posts: 62
  • Karma: 0
    • View Profile
On battle texture you have miss: STAGE39_T01_00

satsuki

  • Insane poster
  • *
  • Posts: 317
  • Karma: 51
    • View Profile
    • My softs (french only)
i didn't touch the ennemy name i just extracted them with the opengl driver's option

this battle file make a graphic glitch ingame, so i decided to not include it:

with this file upscaled


without this file


so looks more natural without
« Last Edit: 2019-09-08 19:22:14 by satsuki »

Cloud’s Stripe

  • Fast newbie
  • *
  • Posts: 7
  • Karma: 0
    • View Profile
Merci beaucoup Satsuki! Thank you so much for the work you have put into this. I found out about your work through the Remako mod, but I can easily tell the difference between the two in this version thanks to your adjustments. (i.e. the pipes inside the Mako reactor on the very first mission look so much better and consistent!)

I am a complete noob about this stuff but I would be interested to see a few comparisons between v.3 (and/or Remako) and v.4 from an aesthetic point of view.

I apply scanlines through Reshade to counter the ‘painted’ filtered look of upscaling and it works beautifully for me. I am (still) replaying FFVII for the first time since 1997 and i can’t believe how good it is in comparison to the PS4 version. (such a fantastic og experience along with the no mouth mod, wallmarket for buster sword texture, save anywhere and r.05 for the translation)

ps: just to make sure: I still have the downloaded movie files from v.3 and applied the iro from v.4 so i guess that’s all i need to do for the movie pack?


Sent from my iPhone using Tapatalk

satsuki

  • Insane poster
  • *
  • Posts: 317
  • Karma: 51
    • View Profile
    • My softs (french only)
"I am a complete noob about this stuff but I would be interested to see a few comparisons between v.3 (and/or Remako) and v.4 from an aesthetic point of view"
The v4 is sharper than the v3 and with a much more complete screen by screen adjustments, the v3 is no use in front of the v4 (a few fields are from the v3 because i can't find a way to improve them but it's less than 10 fields).
The v4 VS the remako .... to my mind the remako isn't on the same level , it as zero bug correction, zero adaptation .... i could do a compare on some screen but not worth it to me (you'll find 3 screen in the next message)

"I apply scanlines through Reshade"
here's a great shader to use with aali driver (credits to  Sunwalker) :
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               1      //# Scanlines to simulate the look of a CRT TV. Typically suited to sprite games.
#define NTSC_TV_EMULATION           0      //# 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 - [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;
}


"ps: just to make sure: I still have the downloaded movie files from v.3 and applied the iro from v.4 so i guess that’s all i need to do for the movie pack?"
Yes you just need to use the iro, it'll use the iro's file and not the game folder's ones ^^
« Last Edit: 2019-09-10 15:34:53 by satsuki »

satsuki

  • Insane poster
  • *
  • Posts: 317
  • Karma: 51
    • View Profile
    • My softs (french only)
just for quick compare, first remako then mine (but you can test yourself, some remako looks good but not the most of it, and it have zero consistency nor bug correction):

Spoiler: show









Cloud’s Stripe

  • Fast newbie
  • *
  • Posts: 7
  • Karma: 0
    • View Profile
Yeah fantastic results, your efforts really paid off! Thanks for your elaborate reply. I will try out the shader as well some time. I managed to tweak the crt filter I use in Reshade last night by switching it on and off to have the colours and brightness match your original as close as i could (Juno was really good for that thanks to the orange and reds), it looks way better than before ^_^


Sent from my iPhone using Tapatalk

Fewtch

  • Fast newbie
  • *
  • Posts: 23
  • Karma: 0
    • View Profile
    • ArtStation
Came here to congratulate you on your latest work. When I first began paying attention to FF7 mods a couple years ago, I was your biggest critic. I didnt even consider your fields to be worth showing off but I'm very very VERY glad to see that you stuck with it and continued to improve them again and again. Your work speaks for itself, and as someone who prefers to show rather than tell, I can offer you no higher praise.
Thank you again for your continued hard work and dedication, you're an inspiration.

Fraggoso

  • Insane poster
  • *
  • Posts: 279
  • Karma: 13
    • View Profile
Wow, just Wow!
It really eliminates most things that Remake AI via Gigapixel didn't get right. Great release!

LordUrQuan

  • VirtualBox dweller
  • Insane poster
  • *
  • Posts: 319
  • Karma: 0
  • LOAD "FF2J",8,1
    • View Profile
I didnt even consider your fields to be worth showing off but I'm very very VERY glad to see that you stuck with it and continued to improve them again and again. Your work speaks for itself, and as someone who prefers to show rather than tell, I can offer you no higher praise.
Thank you again for your continued hard work and dedication, you're an inspiration.
Anything worth doing is worth doing well, and doing it well often requires a metric fsck-ton of failure.

EQ2Alyza

  • 7th Heaven Crew
  • Global moderator
  • No life
  • *
  • Posts: 3033
  • Karma: 208
  • Dilly-Dally Shilly-Shally
    • View Profile
    • EQ2Alyza - YouTube Channel
Anything worth doing is worth doing well, and doing it well often requires a metric fsck-ton of failure.

Eww, yuck. Linking that movie should be against forum policies :P

LordUrQuan

  • VirtualBox dweller
  • Insane poster
  • *
  • Posts: 319
  • Karma: 0
  • LOAD "FF2J",8,1
    • View Profile
Eww, yuck. Linking that movie should be against forum policies :P
For the most part, I'd agree, but I've yet to find anything Yoda has said in any of his appearances that isn't worth remembering.

Fafyx

  • Fast newbie
  • *
  • Posts: 12
  • Karma: 0
    • View Profile
Hello, I'm starting to use this V4 upscale, but my "Cloud" in the world map or anywhere else is still a "puppet", not a better quality "person" as in the image upper in this post. Also the various berret and the rest of avalanche characters are puppets... Could you tell me why please? there is any other mod i could apply or have i just put the "char" directory in a wrong place? thanks
VERY IMPORTANT : i have applied this V4 upscale mod to the 98 game, patched version, and ITA reloaded 1.1.0 mod.

HeXy

  • Fast newbie
  • *
  • Posts: 22
  • Karma: 0
    • View Profile
    • Toast the Ghost
This is stunning work, thank you so much  ;D

satsuki

  • Insane poster
  • *
  • Posts: 317
  • Karma: 51
    • View Profile
    • My softs (french only)
Hello, I'm starting to use this V4 upscale, but my "Cloud" in the world map or anywhere else is still a "puppet", not a better quality "person" as in the image upper in this post. Also the various berret and the rest of avalanche characters are puppets... Could you tell me why please? there is any other mod i could apply or have i just put the "char" directory in a wrong place? thanks
VERY IMPORTANT : i have applied this V4 upscale mod to the 98 game, patched version, and ITA reloaded 1.1.0 mod.
I use the ChaOS -Character Overhaul Seven from Kaldarasha : http://forums.qhimm.com/index.php?topic=13960.0

Fafyx

  • Fast newbie
  • *
  • Posts: 12
  • Karma: 0
    • View Profile
I use the ChaOS -Character Overhaul Seven from Kaldarasha : http://forums.qhimm.com/index.php?topic=13960.0

Ok, so now i don't know where to put them : in you v4 upscale there are 5 folders (battle, char, field, magic, world) that contains mainly png files, but the file from kaldarasha (ChaOS - character overhaul) that you suggested me to download, instead contains 4 forlders (battle, char, mini, world) with other sub-folders that contains strange files .p or uknown... how do i have to use them? i mean, how and where i have to put them? thanks...