[WWHD] - Fix flashing horizon and AO workaround

Enhancements/WindWakerHD_Contrasty_v1.1/04dcbf2655f94e03_00000000000007f9_ps.txt

@@ -2,6 +2,12 @@
 #extension GL_ARB_texture_gather : enable
 // shader 04dcbf2655f94e03 //hoirzon cloud layer lighten up
 uniform ivec4 uf_remappedPS[2];
+
+const float skyboxRed = float($skyboxRed);
+const float skyboxGreen = float($skyboxGreen); 
+const float skyboxBlue = float($skyboxBlue);
+const float skyboxMix = float($skyboxMix);
+
 layout(binding = 3) uniform sampler2D textureUnitPS3;// Tex3 addr 0x2702c000 res 1024x256x1 dim 1 tm: 4 format 0433 compSel: 0 1 2 3 mipView: 0x0 (num 0xb) sliceView: 0x0 (num 0x1) Sampler3 ClampX/Y/Z: 0 2 0 border: 0
 layout(location = 0) in vec4 passParameterSem6;
 layout(location = 0) out vec4 passPixelColor0;
@@ -55,6 +61,8 @@ R0f.w = PV1f.w;
 R1f.xyz = vec3(R2f.y,R2f.y,R2f.y);
 R1f.w = R2f.x;
 // export
-passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z*1.1, R0f.w)*1.3;
+
+//passPixelColor0 = vec4(R0f.x*$skyboxRed, R0f.y, R0f.z*1.1, R0f.w)*1.3;
+passPixelColor0 = vec4(R0f.x*skyboxRed, R0f.y*skyboxGreen, R0f.z*skyboxBlue*1.1, R0f.w)*skyboxMix*1.3;
 passPixelColor1 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
 }

Enhancements/WindWakerHD_Contrasty_v1.1/53141a02b3f78921_00000000000000ff_ps.txt

@@ -2,6 +2,11 @@
 #extension GL_ARB_texture_gather : enable
 // shader 53141a02b3f78921
 //make gradient more white blue 
+const float skyboxRed = float($skyboxRed);
+const float skyboxGreen = float($skyboxGreen); 
+const float skyboxBlue = float($skyboxBlue);
+const float skyboxMix = float($skyboxMix);
+
 uniform ivec4 uf_remappedPS[2];
 layout(location = 0) in vec4 passParameterSem1;
 layout(location = 0) out vec4 passPixelColor0;
@@ -53,6 +58,7 @@ R2f.w = PV1f.w;
 R3f.xyz = vec3(R1f.y,R1f.y,R1f.y);
 R3f.w = R1f.w;
 // export
-passPixelColor0 = vec4(R2f.x, R2f.y*0.75, R2f.z*1.25, R2f.w)*1.1;
+//passPixelColor0 = vec4(R2f.x, R2f.y*0.75, R2f.z*1.25, R2f.w)*1.1;
+passPixelColor0 = vec4(R2f.x*skyboxRed, R2f.y*skyboxGreen*0.75, R2f.z*skyboxBlue*1.25, R2f.w)*skyboxMix*1.1;
 passPixelColor1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
 }

Enhancements/WindWakerHD_Contrasty_v1.1/8a763b05908ba4e8_00000000000000ff_ps.txt

@@ -2,6 +2,11 @@
 #extension GL_ARB_texture_gather : enable
 // shader 8a763b05908ba4e8
 //Third band horizon
+const float skyboxRed = float($skyboxRed);
+const float skyboxGreen = float($skyboxGreen); 
+const float skyboxBlue = float($skyboxBlue);
+const float skyboxMix = float($skyboxMix);
+
 uniform ivec4 uf_remappedPS[3];
 layout(location = 0) in vec4 passParameterSem1;
 layout(location = 1) in vec4 passParameterSem2;
@@ -78,6 +83,7 @@ R0f.w = backupReg3f;
 R1f.xyz = vec3(R2f.x,R2f.y,R2f.y);
 R1f.w = R2f.w;
 // export
-passPixelColor0 = vec4(R0f.x, R0f.y*0.75, R0f.z*1.25, R0f.w)*1.2;
+//passPixelColor0 = vec4(R0f.x, R0f.y*0.75, R0f.z*1.25, R0f.w)*1.2;
+passPixelColor0 = vec4(R0f.x*skyboxRed, R0f.y*skyboxGreen*0.75, R0f.z*skyboxBlue*1.25, R0f.w)*skyboxMix*1.2;
 passPixelColor1 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
 }

Enhancements/WindWakerHD_Contrasty_v1.1/90ed656e9c17616b_00000000000000ff_ps.txt

@@ -2,6 +2,11 @@
 #extension GL_ARB_texture_gather : enable
 // shader 90ed656e9c17616b
 //make second gradient more white blue 
+const float skyboxRed = float($skyboxRed);
+const float skyboxGreen = float($skyboxGreen); 
+const float skyboxBlue = float($skyboxBlue);
+const float skyboxMix = float($skyboxMix);
+
 uniform ivec4 uf_remappedPS[3];
 layout(location = 0) in vec4 passParameterSem1;
 layout(location = 0) out vec4 passPixelColor0;
@@ -53,6 +58,7 @@ R2f.w = PV1f.w;
 R3f.xyz = vec3(R1f.y,R1f.y,R1f.y);
 R3f.w = R1f.w;
 // export
-passPixelColor0 = vec4(R2f.x, R2f.y*0.75, R2f.z*1.25, R2f.w)*1.2;
+//passPixelColor0 = vec4(R2f.x, R2f.y*0.75, R2f.z*1.25, R2f.w)*1.2;
+passPixelColor0 = vec4(R2f.x*skyboxRed, R2f.y*skyboxGreen*0.75, R2f.z*skyboxBlue*1.25, R2f.w)*skyboxMix*1.2;
 passPixelColor1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
 }

Enhancements/WindWakerHD_Contrasty_v1.1/92d5cf316124c301_00000000007fd249_ps.txt

@@ -0,0 +1,276 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader 92d5cf316124c301
+//beach cooking
+uniform ivec4 uf_remappedPS[7];
+layout(binding = 0) uniform sampler2DArray textureUnitPS0;// Tex0 addr 0x22754000 res 4x4x1 dim 5 tm: 2 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf4200000 res 960x540x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 2) uniform sampler2D textureUnitPS2;// Tex2 addr 0x25304000 res 4096x4096x1 dim 1 tm: 4 format 0034 compSel: 0 0 0 5 mipView: 0x0 (num 0xd) sliceView: 0x0 (num 0x1) Sampler2 ClampX/Y/Z: 0 0 0 border: 1
+layout(binding = 3) uniform sampler2D textureUnitPS3;// Tex3 addr 0xf42ff800 res 960x540x1 dim 1 tm: 4 format 001a compSel: 1 2 3 0 mipView: 0x0 (num 0x2) sliceView: 0x0 (num 0x1) Sampler3 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 4) uniform sampler2D textureUnitPS4;// Tex4 addr 0x26528000 res 512x2048x1 dim 1 tm: 4 format 0431 compSel: 0 1 2 3 mipView: 0x0 (num 0xc) sliceView: 0x0 (num 0x1) Sampler4 ClampX/Y/Z: 0 0 0 border: 0
+layout(location = 0) in vec4 passParameterSem1;
+layout(location = 1) in vec4 passParameterSem2;
+layout(location = 2) in vec4 passParameterSem4;
+layout(location = 3) in vec4 passParameterSem5;
+layout(location = 4) in vec4 passParameterSem6;
+layout(location = 5) in vec4 passParameterSem7;
+layout(location = 6) in vec4 passParameterSem8;
+layout(location = 0) out vec4 passPixelColor0;
+layout(location = 1) out vec4 passPixelColor1;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec4 R1f = vec4(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R5f = vec4(0.0);
+vec4 R6f = vec4(0.0);
+vec4 R7f = vec4(0.0);
+vec4 R8f = vec4(0.0);
+vec4 R9f = vec4(0.0);
+vec4 R10f = vec4(0.0);
+vec4 R11f = vec4(0.0);
+vec4 R12f = vec4(0.0);
+vec4 R13f = vec4(0.0);
+vec4 R122f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R124f = vec4(0.0);
+vec4 R125f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem1;
+R1f = passParameterSem2;
+R2f = passParameterSem4;
+R3f = passParameterSem5;
+R4f = passParameterSem6;
+R5f = passParameterSem7;
+R6f = passParameterSem8;
+// 0
+R8f.x = R3f.w;
+R8f.x = clamp(R8f.x, 0.0, 1.0);
+PV0f.y = -(R3f.z) + -(intBitsToFloat(0x42700000));
+R12f.z = roundEven(0.0);
+R7f.w = 1.0;
+PS0f = 1.0 / R5f.z;
+// 1
+R7f.x = mul_nonIEEE(R5f.x, PS0f);
+PV1f.x = R7f.x;
+R7f.y = mul_nonIEEE(R5f.y, PS0f);
+PV1f.y = R7f.y;
+PV1f.z = PV0f.y * intBitsToFloat(0x3dcccccd);
+PV1f.z = clamp(PV1f.z, 0.0, 1.0);
+R127f.w = mul_nonIEEE(-(R3f.z), intBitsToFloat(uf_remappedPS[0].w));
+PS1f = 1.0 / R4f.z;
+// 2
+backupReg0f = R4f.x;
+R4f.x = mul_nonIEEE(backupReg0f, PS1f);
+R127f.y = (mul_nonIEEE(PV1f.y,intBitsToFloat(uf_remappedPS[1].y)) + 1.0)/2.0;
+PV0f.y = R127f.y;
+R127f.z = (mul_nonIEEE(PV1f.x,intBitsToFloat(uf_remappedPS[1].x)) + 1.0)/2.0;
+PV0f.z = R127f.z;
+R4f.w = mul_nonIEEE(R4f.y, PS1f);
+R0f.w = -(PV1f.z) + 1.0;
+PS0f = R0f.w;
+// 3
+PV1f.x = mul_nonIEEE(-(R3f.z), intBitsToFloat(uf_remappedPS[0].y));
+R4f.y = (mul_nonIEEE(-(intBitsToFloat(uf_remappedPS[0].z)),intBitsToFloat(uf_remappedPS[0].w)) + R127f.w);
+R4f.y = clamp(R4f.y, 0.0, 1.0);
+PV1f.z = floor(PV0f.y);
+PV1f.w = floor(PV0f.z);
+R8f.w = 0.0;
+PS1f = R8f.w;
+// 4
+R11f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z), PV1f.w);
+R11f.x *= 2.0;
+R11f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w), PV1f.z);
+R11f.y *= 2.0;
+R4f.z = R127f.z + -(PV1f.w);
+R6f.w = R127f.y + -(PV1f.z);
+R1f.w = (mul_nonIEEE(-(intBitsToFloat(uf_remappedPS[0].x)),intBitsToFloat(uf_remappedPS[0].y)) + PV1f.x);
+R1f.w = clamp(R1f.w, 0.0, 1.0);
+PS0f = R1f.w;
+R9f.xyzw = (textureGather(textureUnitPS1, R11f.xy).xyzw);
+R10f.xyw = (textureLod(textureUnitPS3, R7f.xy,R7f.w).xyw);
+R7f.xw = (textureLod(textureUnitPS3, R7f.xy,0.0).xw);
+R4f.x = (texture(textureUnitPS2, R4f.xw).x);
+R6f.xyz = (texture(textureUnitPS4, R6f.xy).xyz);
+// 0
+PV0f.x = -(R6f.w);
+R127f.y = -(R8f.x) + R9f.x;
+PV0f.z = mul_nonIEEE(R4f.z, R6f.w);
+R127f.w = -(R8f.x) + R9f.y;
+R127f.x = -(R8f.x) + R9f.z;
+PS0f = R127f.x;
+// 1
+R126f.x = -(R8f.x) + R9f.w;
+PV1f.y = PV0f.z;
+R127f.z = mul_nonIEEE(R5f.w, R4f.z);
+PV1f.w = -(PV0f.z);
+R125f.z = mul_nonIEEE(R5f.w, PV0f.x);
+PS1f = R125f.z;
+// 2
+backupReg0f = R127f.x;
+backupReg0f = R127f.x;
+R127f.x = max(R127f.y, -(R127f.y));
+R127f.y = mul_nonIEEE(R5f.w, PV1f.y);
+R126f.z = max(backupReg0f, -(backupReg0f));
+R126f.w = mul_nonIEEE(R5f.w, PV1f.w);
+R126f.y = max(R127f.w, -(R127f.w));
+PS0f = R126f.y;
+// 3
+PV1f.x = R10f.y + R0f.w;
+R125f.y = -(R7f.x) + R10f.x;
+R9f.z = (mul_nonIEEE(-(R1f.w),intBitsToFloat(uf_remappedPS[2].w)) + intBitsToFloat(uf_remappedPS[2].z));
+R127f.w = max(R126f.x, -(R126f.x));
+PV1f.w = R127f.w;
+R13f.w = 1.0;
+PS1f = R13f.w;
+// 4
+tempf.x = dot(vec4(R127f.z,R127f.y,R125f.z,R126f.w),vec4(PV1f.w,R127f.x,R126f.z,R126f.y));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R124f.z = tempf.x;
+R5f.z = R4f.y + PV1f.x;
+R5f.z = clamp(R5f.z, 0.0, 1.0);
+PS0f = R5f.z;
+// 5
+tempf.x = dot(vec4(R127f.z,R127f.y,R125f.z,R126f.w),vec4(R127f.w,R126f.z,R127f.x,R126f.y));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R122f.x = (mul_nonIEEE(R125f.y,PS0f) + R7f.x);
+PS1f = R122f.x;
+// 6
+PV0f.x = R4f.z + R124f.z;
+PV0f.x = clamp(PV0f.x, 0.0, 1.0);
+PV0f.y = mul_nonIEEE(PS1f, intBitsToFloat(uf_remappedPS[2].y));
+PV0f.z = R6f.w + PV1f.x;
+PV0f.z = clamp(PV0f.z, 0.0, 1.0);
+PV0f.w = -(R9f.z) + 1.0;
+PS0f = mul_nonIEEE(R7f.w, R10f.w);
+// 7
+R10f.x = mul_nonIEEE(R10f.w, PS0f);
+PV1f.x = R10f.x;
+R123f.y = (PV0f.x * 2.0 + -(1.0));
+PV1f.y = R123f.y;
+R123f.z = (PV0f.z * 2.0 + -(1.0));
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(PV0f.w,R5f.z) + R9f.z);
+PV1f.w = R123f.w;
+tempResultf = log2(PV0f.y);
+if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F;
+PS1f = tempResultf;
+// 8
+R12f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),PV1f.y) + R11f.x);
+R12f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),PV1f.z) + R11f.y);
+R5f.z = mul_nonIEEE(PV1f.w, PS1f);
+R10f.w = intBitsToFloat(uf_remappedPS[3].y) + R4f.x;
+R10f.w = clamp(R10f.w, 0.0, 1.0);
+R9f.z = mul_nonIEEE(R2f.x, PV1f.x);
+PS0f = R9f.z;
+R12f.xyz = (texture(textureUnitPS0, vec3(R12f.x,R12f.y,R12f.z)).xyz);
+// 0
+backupReg0f = R8f.y;
+backupReg0f = R8f.y;
+backupReg0f = R8f.y;
+R8f.xyz = vec3(R8f.w,backupReg0f,backupReg0f);
+R8f.w = backupReg0f;
+// 1
+R126f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].x), R10f.x);
+R126f.y = mul_nonIEEE(R2f.y, R10f.x);
+PV1f.y = R126f.y;
+R124f.z = -(R9f.z) + intBitsToFloat(uf_remappedPS[5].x);
+R127f.w = mul_nonIEEE(R2f.z, R10f.x);
+PS1f = exp2(R5f.z);
+// 2
+PV0f.x = mul_nonIEEE(R3f.z, R3f.z);
+R127f.y = -(PV1f.y) + intBitsToFloat(uf_remappedPS[5].y);
+PV0f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x), PS1f);
+PV0f.w = clamp(PV0f.w, 0.0, 1.0);
+// 3
+R127f.x = -(R127f.w) + intBitsToFloat(uf_remappedPS[5].z);
+PV1f.z = PV0f.w + intBitsToFloat(uf_remappedPS[3].x);
+PV1f.z = clamp(PV1f.z, 0.0, 1.0);
+R122f.x = (mul_nonIEEE(R3f.y,R3f.y) + PV0f.x);
+PS1f = R122f.x;
+// 4
+PV0f.x = mul_nonIEEE(PV1f.z, R10f.w);
+R123f.z = (mul_nonIEEE(R3f.x,R3f.x) + PS1f);
+PV0f.z = R123f.z;
+// 5
+PV1f.w = mul_nonIEEE(R2f.w, PV0f.x);
+PS1f = sqrt(PV0f.z);
+// 6
+R123f.x = (mul_nonIEEE(R1f.x,PS1f) + R1f.y);
+R123f.x = clamp(R123f.x, 0.0, 1.0);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(R127f.x,PV1f.w) + R127f.w);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(R127f.y,PV1f.w) + R126f.y);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(R124f.z,PV1f.w) + R9f.z);
+PV0f.w = R123f.w;
+// 7
+backupReg0f = R0f.x;
+backupReg1f = R0f.z;
+backupReg2f = R0f.y;
+PV1f.x = mul_nonIEEE(backupReg0f, PV0f.w);
+R0f.y = mul_nonIEEE(PV0f.x, PV0f.x);
+PV1f.z = mul_nonIEEE(backupReg1f, PV0f.y);
+PV1f.w = mul_nonIEEE(backupReg2f, PV0f.z);
+// 8
+R123f.x = (mul_nonIEEE(R126f.x,R12f.y) + PV1f.w);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(R126f.x,R12f.x) + PV1f.x);
+PV0f.y = R123f.y;
+R123f.w = (mul_nonIEEE(R126f.x,R12f.z) + PV1f.z);
+PV0f.w = R123f.w;
+// 9
+backupReg0f = R6f.y;
+backupReg1f = R6f.x;
+R6f.x = mul_nonIEEE(R6f.z, PV0f.w);
+R6f.y = mul_nonIEEE(backupReg0f, PV0f.x);
+R6f.z = mul_nonIEEE(backupReg1f, PV0f.y);
+// 0
+PV0f.x = -(R6f.y) + intBitsToFloat(uf_remappedPS[6].y);
+PV0f.y = -(R6f.z) + intBitsToFloat(uf_remappedPS[6].x);
+PV0f.w = -(R6f.x) + intBitsToFloat(uf_remappedPS[6].z);
+// 1
+R13f.x = (mul_nonIEEE(PV0f.y,R0f.y) + R6f.z);
+PV1f.x = R13f.x;
+R13f.y = (mul_nonIEEE(PV0f.x,R0f.y) + R6f.y);
+PV1f.y = R13f.y;
+R13f.z = (mul_nonIEEE(PV0f.w,R0f.y) + R6f.x);
+PV1f.z = R13f.z;
+// 2
+R7f.xyz = vec3(PV1f.x,PV1f.y,PV1f.z);
+R7f.w = R13f.w;
+// export
+passPixelColor0 = vec4(R7f.x, R7f.y, R7f.z, R7f.w)*$beach;
+passPixelColor1 = vec4(R8f.x, R8f.y, R8f.z, R8f.w);
+}

Enhancements/WindWakerHD_Contrasty_v1.1/960d3ef6662043c7_0000000000000079_ps.txt

@@ -1,6 +1,11 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
 // shader 960d3ef6662043c7//bloom blend
+const float skyboxRed = float($skyboxRed);
+const float skyboxGreen = float($skyboxGreen); 
+const float skyboxBlue = float($skyboxBlue);
+const float skyboxMix = float($skyboxMix);
+
 layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4000800 res 480x270x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x4) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
@@ -36,5 +41,7 @@ backupReg2f = R0f.z;
 R0f.xyz = vec3(backupReg0f,backupReg1f,backupReg2f);
 // export
 
-passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z*1.1, R0f.w)*0.75;
+//passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z*1.1, R0f.w)*0.75;
+passPixelColor0 = vec4(R0f.x*skyboxRed, R0f.y*skyboxGreen, R0f.z*skyboxBlue*1.1, R0f.w)*skyboxMix*0.75;
+
 }

Enhancements/WindWakerHD_Contrasty_v1.1/b77c717f243c0b08_00000000007f9249_ps.txt

@@ -2,6 +2,12 @@
 #extension GL_ARB_texture_gather : enable
 // shader b77c717f243c0b08
 uniform ivec4 uf_remappedPS[9];
+const float skyboxRed = float($skyboxRed);
+const float skyboxGreen = float($skyboxGreen); 
+const float skyboxBlue = float($skyboxBlue);
+const float skyboxMix = float($skyboxMix);
+
+
 layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x25672000 res 4096x4096x1 dim 1 tm: 4 format 0034 compSel: 0 0 0 5 mipView: 0x0 (num 0xd) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 0 0 0 border: 1
 layout(binding = 2) uniform sampler2D textureUnitPS2;// Tex2 addr 0xf42ff800 res 960x540x1 dim 1 tm: 4 format 001a compSel: 1 2 3 0 mipView: 0x0 (num 0x2) sliceView: 0x0 (num 0x1) Sampler2 ClampX/Y/Z: 2 2 2 border: 1
 layout(binding = 3) uniform sampler2D textureUnitPS3;// Tex3 addr 0x2df1f000 res 1024x1024x1 dim 1 tm: 4 format 0034 compSel: 0 0 0 0 mipView: 0x0 (num 0xb) sliceView: 0x0 (num 0x1) Sampler3 ClampX/Y/Z: 0 0 2 border: 1
@@ -242,6 +248,7 @@ R0f.w = backupReg0f;
 R1f.xyz = vec3(R8f.y,R8f.y,R8f.y);
 R1f.w = R8f.w;
 // export
-passPixelColor0 = vec4(R0f.x, R0f.y*0.9, R0f.z*1.1, R0f.w);
+//passPixelColor0 = vec4(R0f.x, R0f.y*0.9, R0f.z*1.1, R0f.w);
+passPixelColor0 = vec4(R0f.x*skyboxRed, R0f.y*skyboxGreen*0.9, R0f.z*skyboxBlue*1.1, R0f.w)*skyboxMix;
 passPixelColor1 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
 }

Enhancements/WindWakerHD_Contrasty_v1.1/c2cae30e906be2d5_0000000000001e49_ps.txt

@@ -0,0 +1,296 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader c2cae30e906be2d5
+//Ao scale 
+uniform ivec4 uf_remappedPS[8];
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4200000 res 960x540x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf4200000 res 960x540x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x2) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
+layout(binding = 2) uniform sampler2D textureUnitPS2;// Tex2 addr 0x3b5d5800 res 4x4x1 dim 1 tm: 2 format 0007 compSel: 0 1 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler2 ClampX/Y/Z: 0 0 0 border: 1
+layout(location = 0) in vec4 passParameterSem1;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec4 R1f = vec4(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R5f = vec4(0.0);
+vec4 R6f = vec4(0.0);
+vec4 R122f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R124f = vec4(0.0);
+vec4 R125f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem1;
+R2f.x = (texture(textureUnitPS0, R0f.xy).x);
+R1f.xy = (texture(textureUnitPS2, R0f.zw).xy)*$AO;
+// 0
+R4f.x = (R1f.y * 2.0 + -(1.0));
+PV0f.x = R4f.x;
+R4f.y = mul_nonIEEE(R2f.x, intBitsToFloat(uf_remappedPS[0].z));
+R5f.z = (R1f.x * 2.0 + -(1.0));
+PV0f.z = R5f.z;
+R123f.w = (mul_nonIEEE(-(R2f.x),intBitsToFloat(uf_remappedPS[1].y)) + 1.0);
+R123f.w = clamp(R123f.w, 0.0, 1.0);
+PV0f.w = R123f.w;
+// 1
+R5f.x = mul_nonIEEE(-(PV0f.x), intBitsToFloat(uf_remappedPS[2].z));
+R3f.y = mul_nonIEEE(PV0f.z, intBitsToFloat(uf_remappedPS[2].z));
+R4f.z = mul_nonIEEE(PV0f.w, intBitsToFloat(uf_remappedPS[1].x));
+PV1f.z = R4f.z;
+// 2
+R127f.x = mul_nonIEEE(PV1f.z, intBitsToFloat(uf_remappedPS[3].x));
+PV0f.x = R127f.x;
+R127f.y = mul_nonIEEE(PV1f.z, intBitsToFloat(uf_remappedPS[3].y));
+PV0f.z = mul_nonIEEE(PV1f.z, intBitsToFloat(uf_remappedPS[4].x));
+R127f.w = mul_nonIEEE(PV1f.z, intBitsToFloat(uf_remappedPS[4].y));
+PS0f = 1.0 / PV1f.z;
+// 3
+R6f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[5].z), PS0f);
+PV1f.y = mul_nonIEEE(R3f.y, PV0f.z);
+PV1f.z = mul_nonIEEE(R4f.x, PV0f.z);
+R4f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[5].z), PS0f);
+PS1f = mul_nonIEEE(R3f.y, PV0f.x);
+// 4
+PV0f.x = mul_nonIEEE(R4f.x, R127f.x);
+R126f.y = (mul_nonIEEE(R5f.x,R127f.y) + PS1f);
+R123f.z = (mul_nonIEEE(R5f.z,R127f.w) + PV1f.z);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(R5f.x,R127f.w) + PV1f.y);
+PV0f.w = R123f.w;
+R3f.x = mul_nonIEEE(R4f.z, intBitsToFloat(uf_remappedPS[6].x));
+PS0f = R3f.x;
+// 5
+R1f.xyz = vec3(R0f.x,R0f.y,R0f.x) + vec3(PV0f.w,PV0f.z,-(PV0f.w));
+R1f.w = R0f.y + -(PV0f.z);
+R122f.x = (mul_nonIEEE(R5f.z,R127f.y) + PV0f.x);
+PS1f = R122f.x;
+// 6
+R2f.xyz = vec3(R0f.x,R0f.y,R0f.x) + vec3(R126f.y,PS1f,-(R126f.y));
+R2f.w = R0f.y + -(PS1f);
+R3f.z = mul_nonIEEE(R4f.z, intBitsToFloat(uf_remappedPS[6].y));
+PS0f = R3f.z;
+R1f.x = (texture(textureUnitPS1, R1f.xy).x);
+R1f.y = (texture(textureUnitPS1, R1f.zw).x);
+R2f.x = (texture(textureUnitPS1, R2f.xy).x);
+R2f.y = (texture(textureUnitPS1, R2f.zw).x);
+// 0
+R127f.x = R4f.y + -(R2f.x);
+PV0f.x = R127f.x;
+R126f.y = R4f.y + -(R2f.y);
+PV0f.z = -(R1f.y) + R4f.y;
+PV0f.w = -(R1f.x) + R4f.y;
+// 1
+PV1f.x = mul_nonIEEE(PV0f.z, R4f.w);
+PV1f.x /= 2.0;
+PV1f.y = mul_nonIEEE(PV0f.w, R6f.x);
+PV1f.y /= 2.0;
+R126f.z = (mul_nonIEEE(-(PV0f.w),intBitsToFloat(uf_remappedPS[1].z)) + 1.0);
+R126f.z = clamp(R126f.z, 0.0, 1.0);
+R125f.w = (mul_nonIEEE(-(PV0f.z),intBitsToFloat(uf_remappedPS[1].z)) + 1.0);
+R125f.w = clamp(R125f.w, 0.0, 1.0);
+PS1f = mul_nonIEEE(PV0f.x, R6f.x);
+PS1f /= 2.0;
+// 2
+R126f.x = (mul_nonIEEE(PS1f,intBitsToFloat(uf_remappedPS[3].z)) + 0.5);
+R126f.x = clamp(R126f.x, 0.0, 1.0);
+PV0f.y = mul_nonIEEE(R126f.y, R4f.w);
+PV0f.y /= 2.0;
+R127f.z = (mul_nonIEEE(PV1f.x,intBitsToFloat(uf_remappedPS[4].z)) + 0.5);
+R127f.z = clamp(R127f.z, 0.0, 1.0);
+PV0f.z = R127f.z;
+R127f.w = (mul_nonIEEE(PV1f.y,intBitsToFloat(uf_remappedPS[4].z)) + 0.5);
+R127f.w = clamp(R127f.w, 0.0, 1.0);
+PV0f.w = R127f.w;
+R126f.w = mul_nonIEEE(R3f.y, R3f.x);
+PS0f = R126f.w;
+// 3
+R125f.x = (mul_nonIEEE(PV0f.y,intBitsToFloat(uf_remappedPS[3].z)) + 0.5);
+R125f.x = clamp(R125f.x, 0.0, 1.0);
+PV1f.x = R125f.x;
+R127f.y = (mul_nonIEEE(-(R127f.x),intBitsToFloat(uf_remappedPS[1].z)) + 1.0);
+R127f.y = clamp(R127f.y, 0.0, 1.0);
+PV1f.z = 0.5 + -(PV0f.w);
+PV1f.w = 0.5 + -(PV0f.z);
+R125f.y = (mul_nonIEEE(-(R126f.y),intBitsToFloat(uf_remappedPS[1].z)) + 1.0);
+R125f.y = clamp(R125f.y, 0.0, 1.0);
+PS1f = R125f.y;
+// 4
+R127f.x = (mul_nonIEEE(PV1f.z,R126f.z) + 0.5);
+PV0f.x = R127f.x;
+R126f.y = (mul_nonIEEE(PV1f.w,R125f.w) + 0.5);
+PV0f.y = R126f.y;
+PV0f.z = 0.5 + -(PV1f.x);
+PV0f.w = 0.5 + -(R126f.x);
+R125f.z = mul_nonIEEE(R4f.x, R3f.x);
+PS0f = R125f.z;
+// 5
+R124f.x = (mul_nonIEEE(PV0f.z,R125f.y) + 0.5);
+PV1f.x = R124f.x;
+R124f.y = (mul_nonIEEE(PV0f.w,R127f.y) + 0.5);
+PV1f.y = R124f.y;
+PV1f.z = R127f.z + -(PV0f.x);
+PV1f.w = R127f.w + -(PV0f.y);
+R127f.w = (mul_nonIEEE(R5f.x,R3f.z) + R126f.w);
+PS1f = R127f.w;
+// 6
+backupReg0f = R127f.x;
+backupReg1f = R126f.y;
+R127f.x = (mul_nonIEEE(PV1f.z,R125f.w) + backupReg0f);
+R126f.y = (mul_nonIEEE(PV1f.w,R126f.z) + backupReg1f);
+PV0f.z = R126f.x + -(PV1f.x);
+PV0f.w = R125f.x + -(PV1f.y);
+// 7
+R1f.x = R0f.x + R127f.w;
+R123f.y = (mul_nonIEEE(PV0f.w,R125f.y) + R124f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(R5f.z,R3f.z) + R125f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(PV0f.z,R127f.y) + R124f.x);
+PV1f.w = R123f.w;
+R3f.x = R0f.x + -(R127f.w);
+PS1f = R3f.x;
+// 8
+PV0f.x = mul_nonIEEE(PV1f.w, intBitsToFloat(uf_remappedPS[3].w));
+R1f.y = R0f.y + PV1f.z;
+PV0f.z = mul_nonIEEE(PV1f.y, intBitsToFloat(uf_remappedPS[3].w));
+R3f.w = R0f.y + -(PV1f.z);
+PS0f = mul_nonIEEE(R4f.z, intBitsToFloat(uf_remappedPS[7].x));
+// 9
+PV1f.x = mul_nonIEEE(R3f.y, PS0f);
+R3f.y = (mul_nonIEEE(R127f.x,intBitsToFloat(uf_remappedPS[4].w)) + PV0f.z);
+PV1f.z = mul_nonIEEE(R4f.z, intBitsToFloat(uf_remappedPS[7].y));
+R2f.w = (mul_nonIEEE(R126f.y,intBitsToFloat(uf_remappedPS[4].w)) + PV0f.x);
+PS1f = mul_nonIEEE(R4f.x, PS0f);
+// 10
+R5f.y = 0.0;
+R123f.z = (mul_nonIEEE(R5f.x,PV1f.z) + PV1f.x);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(R5f.z,PV1f.z) + PS1f);
+PV0f.w = R123f.w;
+R5f.w = 1.0;
+PS0f = R5f.w;
+// 11
+backupReg0f = R0f.x;
+backupReg1f = R0f.y;
+backupReg0f = R0f.x;
+backupReg1f = R0f.y;
+R0f.xyz = vec3(backupReg0f,backupReg1f,backupReg0f) + vec3(PV0f.z,PV0f.w,-(PV0f.z));
+R0f.w = backupReg1f + -(PV0f.w);
+R1f.x = (texture(textureUnitPS1, R1f.xy).x);
+R1f.y = (texture(textureUnitPS1, R3f.xw).x);
+R0f.x = (texture(textureUnitPS1, R0f.xy).x);
+R0f.y = (texture(textureUnitPS1, R0f.zw).x);
+// 0
+backupReg0f = R0f.x;
+backupReg1f = R0f.y;
+PV0f.x = R4f.y + -(R1f.y);
+PV0f.y = R4f.y + -(R1f.x);
+R125f.z = R4f.y + -(backupReg0f);
+PV0f.z = R125f.z;
+R127f.w = R4f.y + -(backupReg1f);
+// 1
+R124f.x = (mul_nonIEEE(-(PV0f.y),intBitsToFloat(uf_remappedPS[1].z)) + 1.0);
+R124f.x = clamp(R124f.x, 0.0, 1.0);
+R127f.y = (mul_nonIEEE(-(PV0f.x),intBitsToFloat(uf_remappedPS[1].z)) + 1.0);
+R127f.y = clamp(R127f.y, 0.0, 1.0);
+PV1f.z = mul_nonIEEE(PV0f.x, R4f.w);
+PV1f.z /= 2.0;
+PV1f.w = mul_nonIEEE(PV0f.y, R6f.x);
+PV1f.w /= 2.0;
+PS1f = mul_nonIEEE(PV0f.z, R6f.x);
+PS1f /= 2.0;
+// 2
+R127f.x = (mul_nonIEEE(PV1f.z,intBitsToFloat(uf_remappedPS[6].z)) + 0.5);
+R127f.x = clamp(R127f.x, 0.0, 1.0);
+PV0f.x = R127f.x;
+R126f.y = (mul_nonIEEE(PV1f.w,intBitsToFloat(uf_remappedPS[6].z)) + 0.5);
+R126f.y = clamp(R126f.y, 0.0, 1.0);
+PV0f.y = R126f.y;
+PV0f.z = mul_nonIEEE(R127f.w, R4f.w);
+PV0f.z /= 2.0;
+R125f.w = (mul_nonIEEE(PS1f,intBitsToFloat(uf_remappedPS[7].z)) + 0.5);
+R125f.w = clamp(R125f.w, 0.0, 1.0);
+// 3
+PV1f.x = 0.5 + -(PV0f.y);
+PV1f.y = 0.5 + -(PV0f.x);
+R126f.z = (mul_nonIEEE(PV0f.z,intBitsToFloat(uf_remappedPS[7].z)) + 0.5);
+R126f.z = clamp(R126f.z, 0.0, 1.0);
+PV1f.z = R126f.z;
+R126f.w = (mul_nonIEEE(-(R125f.z),intBitsToFloat(uf_remappedPS[1].z)) + 1.0);
+R126f.w = clamp(R126f.w, 0.0, 1.0);
+R125f.y = (mul_nonIEEE(-(R127f.w),intBitsToFloat(uf_remappedPS[1].z)) + 1.0);
+R125f.y = clamp(R125f.y, 0.0, 1.0);
+PS1f = R125f.y;
+// 4
+PV0f.x = 0.5 + -(PV1f.z);
+PV0f.y = 0.5 + -(R125f.w);
+R125f.z = (mul_nonIEEE(PV1f.x,R124f.x) + 0.5);
+PV0f.z = R125f.z;
+R127f.w = (mul_nonIEEE(PV1f.y,R127f.y) + 0.5);
+PV0f.w = R127f.w;
+// 5
+PV1f.x = R127f.x + -(PV0f.z);
+PV1f.y = R126f.y + -(PV0f.w);
+R127f.z = (mul_nonIEEE(PV0f.y,R126f.w) + 0.5);
+PV1f.z = R127f.z;
+R124f.w = (mul_nonIEEE(PV0f.x,R125f.y) + 0.5);
+PV1f.w = R124f.w;
+// 6
+PV0f.x = R125f.w + -(PV1f.w);
+PV0f.y = R126f.z + -(PV1f.z);
+R123f.z = (mul_nonIEEE(PV1f.x,R127f.y) + R125f.z);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(PV1f.y,R124f.x) + R127f.w);
+PV0f.w = R123f.w;
+// 7
+R123f.x = (mul_nonIEEE(PV0f.w,intBitsToFloat(uf_remappedPS[6].w)) + R2f.w);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(PV0f.y,R125f.y) + R127f.z);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(PV0f.z,intBitsToFloat(uf_remappedPS[6].w)) + R3f.y);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(PV0f.x,R126f.w) + R124f.w);
+PV1f.w = R123f.w;
+// 8
+R123f.x = (mul_nonIEEE(PV1f.w,intBitsToFloat(uf_remappedPS[7].w)) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.z = (mul_nonIEEE(PV1f.y,intBitsToFloat(uf_remappedPS[7].w)) + PV1f.z);
+PV0f.z = R123f.z;
+// 9
+PV1f.w = PV0f.x + PV0f.z;
+// 10
+PV0f.y = PV1f.w + intBitsToFloat(uf_remappedPS[1].w);
+// 11
+PV1f.x = PV0f.y + -(0.5);
+// 12
+PV0f.z = mul_nonIEEE(PV1f.x, intBitsToFloat(uf_remappedPS[0].y));
+PV0f.z = clamp(PV0f.z, 0.0, 1.0);
+// 13
+R5f.x = -(PV0f.z) + 1.0;
+// export
+passPixelColor0 = vec4(R5f.x, R5f.y, R5f.y, R5f.w);
+}

Enhancements/WindWakerHD_Contrasty_v1.1/e1ea1127489fd281_0000000000003fc9_ps.txt

@@ -2,6 +2,11 @@
 #extension GL_ARB_texture_gather : enable
 // shader e1ea1127489fd281 // horizon
 uniform ivec4 uf_remappedPS[5];
+const float skyboxRed = float($skyboxRed);
+const float skyboxGreen = float($skyboxGreen); 
+const float skyboxBlue = float($skyboxBlue);
+const float skyboxMix = float($skyboxMix);
+
 layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x25672000 res 4096x4096x1 dim 1 tm: 4 format 0034 compSel: 0 0 0 5 mipView: 0x0 (num 0xd) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 0 0 0 border: 1
 layout(binding = 2) uniform sampler2D textureUnitPS2;// Tex2 addr 0xf42ff800 res 960x540x1 dim 1 tm: 4 format 001a compSel: 1 2 3 0 mipView: 0x0 (num 0x2) sliceView: 0x0 (num 0x1) Sampler2 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem2;
@@ -154,6 +159,7 @@ R0f.w = R4f.w;
 R1f.xyz = vec3(R3f.z,R3f.y,R3f.y);
 R1f.w = R3f.y;
 // export
-passPixelColor0 = vec4(R0f.x, R0f.y*0.9, R0f.z*1.1, R0f.w);
+//passPixelColor0 = vec4(R0f.x, R0f.y*0.9, R0f.z*1.1, R0f.w);
+passPixelColor0 = vec4(R0f.x*skyboxRed, R0f.y*skyboxGreen*0.9, R0f.z*skyboxBlue*1.1, R0f.w)*skyboxMix;
 passPixelColor1 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
 }

Enhancements/WindWakerHD_Contrasty_v1.1/ef821134ed8dd294_0000000000003fc9_ps.txt

@@ -0,0 +1,166 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader ef821134ed8dd294 // horizon 2 missing shader
+const float skyboxRed = float($skyboxRed);
+const float skyboxGreen = float($skyboxGreen); 
+const float skyboxBlue = float($skyboxBlue);
+const float skyboxMix = float($skyboxMix);
+
+uniform ivec4 uf_remappedPS[5];
+layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x25304000 res 4096x4096x1 dim 1 tm: 4 format 0034 compSel: 0 0 0 5 mipView: 0x0 (num 0xd) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 0 0 0 border: 1
+layout(binding = 2) uniform sampler2D textureUnitPS2;// Tex2 addr 0xf42ff800 res 960x540x1 dim 1 tm: 4 format 001a compSel: 1 2 3 0 mipView: 0x0 (num 0x2) sliceView: 0x0 (num 0x1) Sampler2 ClampX/Y/Z: 2 2 2 border: 1
+layout(location = 0) in vec4 passParameterSem2;
+layout(location = 1) in vec4 passParameterSem4;
+layout(location = 2) in vec4 passParameterSem5;
+layout(location = 3) in vec4 passParameterSem6;
+layout(location = 0) out vec4 passPixelColor0;
+layout(location = 1) out vec4 passPixelColor1;
+uniform vec2 uf_fragCoordScale;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){return mix(0.0, a*b, (a != 0.0) && (b != 0.0));}
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec4 R1f = vec4(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R5f = vec4(0.0);
+vec4 R123f = vec4(0.0);
+vec4 R125f = vec4(0.0);
+vec4 R126f = vec4(0.0);
+vec4 R127f = vec4(0.0);
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = passParameterSem2;
+R1f = passParameterSem4;
+R2f = passParameterSem5;
+R3f = passParameterSem6;
+// 0
+PV0f.x = mul_nonIEEE(-(R1f.z), intBitsToFloat(uf_remappedPS[0].w));
+PV0f.y = -(R1f.z) + -(intBitsToFloat(0x42700000));
+R127f.z = mul_nonIEEE(-(R1f.z), intBitsToFloat(uf_remappedPS[0].y));
+R4f.w = 1.0;
+PS0f = 1.0 / R3f.z;
+// 1
+R4f.x = mul_nonIEEE(R3f.x, PS0f);
+R4f.y = mul_nonIEEE(R3f.y, PS0f);
+R3f.z = (mul_nonIEEE(-(intBitsToFloat(uf_remappedPS[0].z)),intBitsToFloat(uf_remappedPS[0].w)) + PV0f.x);
+R3f.z = clamp(R3f.z, 0.0, 1.0);
+PV1f.w = PV0f.y * intBitsToFloat(0x3dcccccd);
+PV1f.w = clamp(PV1f.w, 0.0, 1.0);
+PS1f = 1.0 / R2f.z;
+// 2
+backupReg0f = R2f.x;
+backupReg1f = R2f.y;
+R2f.x = mul_nonIEEE(backupReg0f, PS1f);
+R2f.y = mul_nonIEEE(backupReg1f, PS1f);
+R2f.z = -(PV1f.w) + 1.0;
+R0f.w = (mul_nonIEEE(-(intBitsToFloat(uf_remappedPS[0].x)),intBitsToFloat(uf_remappedPS[0].y)) + R127f.z);
+R0f.w = clamp(R0f.w, 0.0, 1.0);
+R5f.x = intBitsToFloat(uf_remappedPS[1].x);
+R5f.x = clamp(R5f.x, 0.0, 1.0);
+PS0f = R5f.x;
+R3f.x = (textureLod(textureUnitPS2, R4f.xy,0.0).x);
+R4f.x = (textureLod(textureUnitPS2, R4f.xy,R4f.w).x);
+R2f.x = (texture(textureUnitPS1, R2f.xy).x);
+// 0
+R127f.x = R3f.z + R2f.z;
+R127f.x = clamp(R127f.x, 0.0, 1.0);
+PV0f.x = R127f.x;
+PV0f.y = -(R3f.x) + R4f.x;
+R127f.z = (mul_nonIEEE(-(R0f.w),intBitsToFloat(uf_remappedPS[2].w)) + intBitsToFloat(uf_remappedPS[2].z));
+PV0f.z = R127f.z;
+R126f.w = intBitsToFloat(uf_remappedPS[1].y);
+R126f.w = clamp(R126f.w, 0.0, 1.0);
+R4f.w = 1.0;
+PS0f = R4f.w;
+// 1
+R126f.x = intBitsToFloat(uf_remappedPS[1].z);
+R126f.x = clamp(R126f.x, 0.0, 1.0);
+PV1f.x = R126f.x;
+PV1f.y = -(PV0f.z) + 1.0;
+R126f.z = intBitsToFloat(uf_remappedPS[3].y) + R2f.x;
+R126f.z = clamp(R126f.z, 0.0, 1.0);
+R123f.w = (mul_nonIEEE(PV0f.y,PV0f.x) + R3f.x);
+PV1f.w = R123f.w;
+R3f.z = 0.0;
+PS1f = R3f.z;
+// 2
+backupReg0f = R127f.x;
+R127f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z), R5f.x);
+R126f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z), R126f.w);
+PV0f.z = mul_nonIEEE(PV1f.w, intBitsToFloat(uf_remappedPS[2].y));
+R127f.w = (mul_nonIEEE(PV1f.y,backupReg0f) + R127f.z);
+R125f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z), PV1f.x);
+PS0f = R125f.z;
+// 3
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,-0.0),vec4(R1f.x,R1f.y,R1f.z,0.0));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+tempResultf = log2(PV0f.z);
+if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F;
+PS1f = tempResultf;
+// 4
+PV0f.x = mul_nonIEEE(R127f.w, PS1f);
+R127f.yzw = vec3(R5f.x,R126f.w,R126f.x) + vec3(-(R127f.x),-(R126f.y),-(R125f.z));
+PS0f = sqrt(PV1f.x);
+// 5
+R123f.w = (mul_nonIEEE(R0f.x,PS0f) + R0f.y);
+R123f.w = clamp(R123f.w, 0.0, 1.0);
+PV1f.w = R123f.w;
+PS1f = exp2(PV0f.x);
+// 6
+R2f.z = mul_nonIEEE(PV1f.w, PV1f.w);
+PV0f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x), PS1f);
+PV0f.w = clamp(PV0f.w, 0.0, 1.0);
+// 7
+PV1f.z = PV0f.w + intBitsToFloat(uf_remappedPS[3].x);
+PV1f.z = clamp(PV1f.z, 0.0, 1.0);
+// 8
+PV0f.y = mul_nonIEEE(PV1f.z, R126f.z);
+// 9
+R0f.x = (mul_nonIEEE(PV0f.y,R125f.z) + R127f.w);
+R0f.y = (mul_nonIEEE(PV0f.y,R126f.y) + R127f.z);
+R1f.z = (mul_nonIEEE(PV0f.y,R127f.x) + R127f.y);
+// 0
+backupReg0f = R0f.x;
+PV0f.x = -(R0f.y) + intBitsToFloat(uf_remappedPS[4].y);
+PV0f.y = -(R1f.z) + intBitsToFloat(uf_remappedPS[4].x);
+PV0f.w = -(backupReg0f) + intBitsToFloat(uf_remappedPS[4].z);
+// 1
+R4f.x = (mul_nonIEEE(PV0f.y,R2f.z) + R1f.z);
+PV1f.x = R4f.x;
+R4f.y = (mul_nonIEEE(PV0f.x,R2f.z) + R0f.y);
+PV1f.y = R4f.y;
+R4f.z = (mul_nonIEEE(PV0f.w,R2f.z) + R0f.x);
+PV1f.z = R4f.z;
+// 2
+R0f.xyz = vec3(PV1f.x,PV1f.y,PV1f.z);
+R0f.w = R4f.w;
+// 3
+R1f.xyz = vec3(R3f.z,R3f.y,R3f.y);
+R1f.w = R3f.y;
+// export
+//passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z*1.1, R0f.w)*0.93;
+passPixelColor0 = vec4(R0f.x*skyboxRed, R0f.y*skyboxGreen, R0f.z*skyboxBlue*1.1, R0f.w)*skyboxMix*0.93;
+passPixelColor1 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+}

Enhancements/WindWakerHD_Contrasty_v1.1/f1a49f43d95bec30_00000000000000ff_ps.txt

@@ -1,6 +1,11 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
 // shader f1a49f43d95bec30 //skybox
+const float skyboxRed = float($skyboxRed);
+const float skyboxGreen = float($skyboxGreen); 
+const float skyboxBlue = float($skyboxBlue);
+const float skyboxMix = float($skyboxMix);
+
 uniform ivec4 uf_remappedPS[2];
 layout(location = 0) out vec4 passPixelColor0;
 layout(location = 1) out vec4 passPixelColor1;
@@ -47,6 +52,7 @@ R2f.w = R0f.w;
 R3f.xyz = vec3(R1f.x,R1f.y,R1f.y);
 R3f.w = R1f.z;
 // export
-passPixelColor0 = vec4(R2f.x*0.92, R2f.y*0.9, R2f.z*1.1, R2f.w)*0.75;
+//passPixelColor0 = vec4(R2f.x*0.92, R2f.y*0.9, R2f.z*1.1, R2f.w)*0.75;
+passPixelColor0 = vec4(R2f.x*skyboxRed*0.92, R2f.y*skyboxGreen*0.9, R2f.z*skyboxBlue*1.1, R2f.w)*skyboxMix*0.75;
 passPixelColor1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
 }

Enhancements/WindWakerHD_Contrasty_v1.1/ff71dcd2ad4defdc_00000000000003c9_ps.txt

@@ -5,7 +5,7 @@
 
 uniform vec2 uf_fragCoordScale;
 
-const float hazeFactor = $hazeFactor;
+const float hazeFactor = 0.1;
 
 const float gamma = $gamma; // 1.0 is neutral  Botw is already colour graded at this stage
 const float exposure = $exposure; // 1.0 is neutral

Enhancements/WindWakerHD_Contrasty_v1.1/rules.txt

@@ -1,7 +1,7 @@
 [Definition]
 titleIds = 0005000010143400,0005000010143600,0005000010143500
 name = Contrasty
-path = "The Legend of Zelda: The Wind Waker HD/Enhancements/Contrasty" 
+path = "The Legend of Zelda: The Wind Waker HD/Enhancements/Contrasty v1.1" 
 description = This pack tweaks the colors and contrast to whatever preset you set it as. You can also make your own preset by editing the Default preset in the Contrasty folder from the game's graphic packs. Enabling will ignore your other AA settings.
 version = 3
 
@@ -27,27 +27,41 @@ $crushContrast = 0.0
 $bleach = 1.0
 $sharp_mix = 0.0
 
+$skyboxRed = 1.0
+$skyboxGreen = 1.05 
+$skyboxBlue = 0.9
+$skyboxMix = 1.05
+$AO = 1.0
+$beach = 1.0 
+
 [Preset]
-name = Some Contrast
+name = Less sky bloom
 $redShadows = 1.0
-$greenShadows = 0.99
+$greenShadows = 1.0
 $blueSadows = 1.0
 $redMid = 1.0
-$greenMid = 0.99
+$greenMid = 1.0
 $blueMid = 1.0
-$redHilight = 0.97
+$redHilight = 1.0
-$greenHilight = 0.97
+$greenHilight =1.0
-$blueHilight = 0.97
+$blueHilight = 1.0
 
-$contrastCurve = 0.4
+$contrastCurve = 0.2
-$hazeFactor = 0.25
+$hazeFactor = 1.0
-$bloom = 0.85
+$bloom = 1.0
-$gamma = 1.1
+$gamma = 1.05
-$exposure = 0.975
+$exposure = 1.0
-$vibrance = 0.05
+$vibrance = 0.0
-$crushContrast = 0.00
+$crushContrast = 0.0
-$bleach = 0.85
+$bleach = 1.0
-$sharp_mix = 0.1
+$sharp_mix = 0.0
+
+$skyboxRed = 1.0
+$skyboxGreen = 1.05 
+$skyboxBlue = 0.9
+$skyboxMix = 0.775
+$AO = 1.0
+$beach = 1.0 
 
 [Preset]
 name = High Contrasty
@@ -57,44 +71,58 @@ $blueSadows = 1.0
 $redMid = 0.99
 $greenMid = 0.99
 $blueMid = 0.99
-$redHilight = 1.0
+$redHilight = 1.1
 $greenHilight =1.0
 $blueHilight = 1.0
 
 $contrastCurve = 0.4
 $hazeFactor = 0.25
 $bloom = 0.85
-$gamma = 1.12
+$gamma = 0.98
 $exposure = 1.01
-$vibrance = 0.15
+$vibrance = 0.25
 $crushContrast = 0.00
 $bleach = 0.85
 $sharp_mix = 0.1
 
+$skyboxRed = 1.0
+$skyboxGreen = 1.0 
+$skyboxBlue = 1.0
+$skyboxMix = 1.15
+$AO = 1.0
+$beach = 1.0 
+
 [Preset]
 name = Colourful
 $redShadows = 1.0
 $greenShadows = 1.0
 $blueSadows = 1.0
-$redMid = 0.99
+$redMid = 1.0
-$greenMid = 0.98
+$greenMid = 0.99
-$blueMid = 0.99
+$blueMid = 1.0
 $redHilight = 1.0
 $greenHilight =0.99
 $blueHilight = 1.0
 
-$contrastCurve = 0.333
+$contrastCurve = 0.275
 $hazeFactor = 0.25
 $bloom = 0.85
-$gamma = 1.1
+$gamma = 0.975
 $exposure = 1.01
-$vibrance = 0.35
+$vibrance = 0.45
 $crushContrast = 0.00
 $bleach = 0.85
-$sharp_mix = 0.1
+$sharp_mix = 0.0
+
+$skyboxRed = 1.0
+$skyboxGreen = 1.0 
+$skyboxBlue = 1.0
+$skyboxMix = 0.9
+$AO = 1.0
+$beach = 1.0 
 
 [Preset]
-name = Neutral Contrasty
+name = Gamecube style
 $redShadows = 1.01
 $greenShadows = 1.01
 $blueSadows = 1.01
@@ -107,76 +135,46 @@ $blueHilight = 0.99
 
 $contrastCurve = 0.25
 $hazeFactor = 1.0
-$bloom = 0.85
+$bloom = 0.95
-$gamma = 1.05
+$gamma = 0.95
 $exposure = 1.0
-$vibrance = 0.0
+$vibrance = 0.175
 $crushContrast = 0.00
 $bleach = 0.85
-$sharp_mix = 0.1
-
-[Preset]
-name = Warm
-$redShadows = 1.0
-$greenShadows = 1.0
-$blueSadows = 1.0
-$redMid = 0.98
-$greenMid = 0.98
-$blueMid = 1.0
-$redHilight = 1.0
-$greenHilight = 1.0
-$blueHilight = 1.0
-
-$contrastCurve = 0.7
-$hazeFactor = 0.71
-$bloom = 0.85
-$gamma = 1.1
-$exposure = 1.07
-$vibrance = 0.15
-$crushContrast = 0.00
-$bleach = 0.85
-$sharp_mix = 0.1
-
-[Preset]
-name = Cold
-$redShadows = 0.95
-$greenShadows = 0.96
-$blueSadows = 1.03
-$redMid = 0.95
-$greenMid = 0.96
-$blueMid = 1.03
-$redHilight = 0.98
-$greenHilight = 0.99
-$blueHilight = 1.03
-
-$contrastCurve = 0.2
-$hazeFactor = 0.1
-$bloom = 1.0
-$gamma = 1.05
-$exposure = 0.99
-$vibrance = 0.45
-$crushContrast = 0.0
-$bleach = 0.85
-$sharp_mix = 0.1
-
-[Preset]
-name = GameCube Color Grading
-$redShadows = 1.0
-$greenShadows = 1.0
-$blueSadows = 1.0
-$redMid = 1.0
-$greenMid = 1.0
-$blueMid = 1.0
-$redHilight = 1.0
-$greenHilight = 1.0
-$blueHilight = 1.0
-
-$contrastCurve = 0.0
-$hazeFactor = 1.0
-$bloom = 1.0
-$gamma = 0.85
-$exposure = 1.02
-$vibrance = 0.0175
-$crushContrast = 0.0
-$bleach = 1.0
 $sharp_mix = 0.0
+
+$skyboxRed = 1.1
+$skyboxGreen = 0.95 
+$skyboxBlue = 1.1
+$skyboxMix = 0.75
+$AO = 0.5
+$beach = 0.85 
+
+[Preset]
+name = Gangnam style
+$redShadows = 0.9
+$greenShadows = 0.91
+$blueSadows = 0.94
+$redMid = 1.4
+$greenMid = 1.0
+$blueMid = 1.3
+$redHilight = 0.99
+$greenHilight =0.99
+$blueHilight = 0.99
+
+$contrastCurve = 1.0
+$hazeFactor = 1.0
+$bloom = 0.95
+$gamma = 0.95
+$exposure = 1.05
+$vibrance = 1.1
+$crushContrast = 0.00
+$bleach = 0.85
+$sharp_mix = 0.9
+
+$skyboxRed = 1.5
+$skyboxGreen = 0.95 
+$skyboxBlue = 1.1
+$skyboxMix = 1.5
+$AO = 1.5
+$beach = 1.1 

Enhancements/WindWakerHD_Resolution_Shadows/rules.txt

@@ -0,0 +1,29 @@
+[Definition]
+titleIds = 0005000010143500 # replace with fulltitleID
+name = Resolution
+path = "The Legend of Zelda: The Wind Waker HD/Graphics/Shadow resolution"
+description = Note: Increasing shadow resolution is known to increase VRAM usage directly. Lowering this might give you a good boost in performance if you're limited on VRAM but makes shadows blockier. Medium is the original resolution.
+version = 3
+
+[Preset]
+name = 1024x1024 (1x, Default)
+$shadowRes = 1
+
+[Preset]
+name = 512x512 (0.5x) Downscale
+$shadowRes = 0.5
+
+[Preset]
+name = 2048x2048 (2x) - Good balance
+$shadowRes = 2
+
+[Preset]
+name = 4096x4096 (4x)
+$shadowRes = 4
+
+[TextureRedefine] #Shadows x3 Lods 
+width = 1024
+height = 1024
+formats = 0x005 #,0x034,0x431,0x034
+overwriteWidth =  $shadowRes * 1024
+overwriteHeight =  $shadowRes * 1024

Resolutions/WindWakerHD_Resolution/4c426260188ace42_0000000000000000_vs.txt

@@ -1,107 +0,0 @@
-#version 420
-#extension GL_ARB_texture_gather : enable
-#extension GL_ARB_separate_shader_objects : enable
-#extension GL_ARB_shading_language_packing : enable
-// shader 4c426260188ace42
-//3step vertical shadow n AO blur
-const float resXScale = (float($height)/float($gameHeight)); 
-uniform ivec4 uf_remappedVS[5];
-uniform vec2 uf_windowSpaceToClipSpaceTransform;
-layout(location = 0) in uvec4 attrDataSem0;
-out gl_PerVertex
-{
-	vec4 gl_Position;
-	float gl_PointSize;
-};
-layout(location = 0) out vec4 passParameterSem0;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){return mix(0.0, a*b, (a != 0.0) && (b != 0.0));}
-void main()
-{
-vec4 R0f = vec4(0.0);
-vec4 R1f = vec4(0.0);
-vec4 R126f = vec4(0.0);
-vec4 R127f = vec4(0.0);
-uvec4 attrDecoder;
-float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
-vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
-float PS0f = 0.0, PS1f = 0.0;
-vec4 tempf = vec4(0.0);
-float tempResultf;
-int tempResulti;
-ivec4 ARi = ivec4(0);
-bool predResult = true;
-vec3 cubeMapSTM;
-int cubeMapFaceId;
-R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID));
-attrDecoder.xyz = attrDataSem0.xyz;
-attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24));
-attrDecoder.w = 0;
-R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
-// 0
-R127f.x = -(R1f.y);
-PV0f.x = R127f.x;
-R127f.y = (R1f.x > 0.0)?1.0:0.0;
-R127f.y /= 2.0;
-R126f.z = (0.0 > R1f.x)?1.0:0.0;
-R126f.z /= 2.0;
-R127f.w = 1.0;
-PV0f.w = R127f.w;
-R126f.x = intBitsToFloat(uf_remappedVS[0].w) * intBitsToFloat(0x3fae8a72)/resXScale; //vert
-PS0f = R126f.x;
-// 1
-R0f.x = dot(vec4(R1f.x,R1f.y,R1f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
-PV1f.x = R0f.x;
-PV1f.y = R0f.x;
-PV1f.z = R0f.x;
-PV1f.w = R0f.x;
-R127f.z = (PV0f.x > 0.0)?1.0:0.0;
-R127f.z /= 2.0;
-PS1f = R127f.z;
-// 2
-tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
-PV0f.x = tempf.x;
-PV0f.y = tempf.x;
-PV0f.z = tempf.x;
-PV0f.w = tempf.x;
-R0f.y = tempf.x;
-PS0f = (0.0 > R127f.x)?1.0:0.0;
-PS0f /= 2.0;
-// 3
-backupReg0f = R127f.z;
-tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
-PV1f.x = tempf.x;
-PV1f.y = tempf.x;
-PV1f.z = tempf.x;
-PV1f.w = tempf.x;
-R0f.z = tempf.x;
-R127f.z = backupReg0f + -(PS0f);
-PS1f = R127f.z;
-// 4
-tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
-PV0f.x = tempf.x;
-PV0f.y = tempf.x;
-PV0f.z = tempf.x;
-PV0f.w = tempf.x;
-R0f.w = tempf.x;
-PS0f = R127f.y + -(R126f.z);
-// 5
-R1f.x = PS0f + 0.5;
-PV1f.y = R127f.z + 0.5;
-// 6
-R1f.y = PV1f.y + -(R126f.x);
-R1f.z = PV1f.y + R126f.x;
-R1f.w = PV1f.y;
-// export
-gl_Position = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
-// export
-passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
-// 0
-}

Resolutions/WindWakerHD_Resolution/4ffa96d07cd53c34_0000000000000000_vs.txt

@@ -5,7 +5,7 @@
 // shader 4ffa96d07cd53c34
 
 const float resXScale = (float($height)/float($gameHeight)); 
-const float resYScale = (float($width)/float($gameWidth)); 
+const float resYScale = (float($height)/float($gameHeight)); 
 
 
 //box low res (bloom?)

Resolutions/WindWakerHD_Resolution/842a19b509f8b91a_0000000000000000_vs.txt

@@ -2,9 +2,9 @@
 #extension GL_ARB_texture_gather : enable
 #extension GL_ARB_separate_shader_objects : enable
 #extension GL_ARB_shading_language_packing : enable
-// shader 842a19b509f8b91a //vertical pass stars
+// shader 842a19b509f8b91a //vertical pass bloom
 
-const float resYScale = (float($width)/float($gameWidth)); 
+const float resYScale = (float($height)/float($gameHeight)); 
 
 uniform ivec4 uf_remappedVS[1];
 uniform vec2 uf_windowSpaceToClipSpaceTransform;

Resolutions/WindWakerHD_Resolution/WWHD_Readme.md

@@ -0,0 +1,22 @@
+------
+### TLoZ Wind Waker HD 
+------
+There are some issues with AO and light sources, to mitigate this some “sub” viewports ned to scale evenly. XCX uses a similar approach to get smooth shadow transitions. 
+
+Example:
+[Preset]
+name = 3440x1440 (21:9)
+$width = 3440
+$height = 1440
+$gameWidth= 1920
+$gameHeight= 1080
+$lightSource = 1.5
+$scaleShader = (2560.0/3440.0)
+$aspectRatio = (43.0/18.0)
+
+Base resolution is 2560x1440 -> Uw patch res 3440
+AO needs to be 2160  = 1440 * $lightSource = 1.5
+We then need to scale back ultrawide to original aspect for all viewports using AO / light sources
+2560 = 3440 *$scaleShader  (2560.0/3440.0)  
+
+All AO shader scaling has also been removed, currently they break more than they fix.. 

Resolutions/WindWakerHD_Resolution/_d283b9338c6b10c5_0000000000000000_vs.txt

@@ -1,78 +0,0 @@
-#version 420
-#extension GL_ARB_texture_gather : enable
-#extension GL_ARB_shading_language_packing : enable
-// shader d283b9338c6b10c5 
-//AO noise/de-banding scaling is broken in 1.4
-const float resScale = ($height/$gameHeight)*$internalRes; 
-uniform ivec4 uf_remappedVS[1];
-uniform vec2 uf_windowSpaceToClipSpaceTransform;
-layout(location = 0) in uvec4 attrDataSem0;
-layout(location = 1) in uvec4 attrDataSem1;
-out gl_PerVertex
-{
-	vec4 gl_Position;
-	float gl_PointSize;
-};
-layout(location = 0) out vec4 passParameterSem1;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
-void main()
-{
-vec4 R0f = vec4(0.0);
-vec4 R1f = vec4(0.0);
-vec4 R2f = vec4(0.0);
-uvec4 attrDecoder;
-float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
-vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
-float PS0f = 0.0, PS1f = 0.0;
-vec4 tempf = vec4(0.0);
-float tempResultf;
-int tempResulti;
-ivec4 ARi = ivec4(0);
-bool predResult = true;
-vec3 cubeMapSTM;
-int cubeMapFaceId;
-R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID));
-attrDecoder.xyz = attrDataSem0.xyz;
-attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24));
-attrDecoder.w = 0;
-R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
-attrDecoder.xy = attrDataSem1.xy;
-attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
-attrDecoder.z = 0;
-attrDecoder.w = 0;
-R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
-// 0
-backupReg0f = R1f.x;
-backupReg1f = R1f.y;
-R1f.x = backupReg0f;
-R1f.x *= 2.0;
-R1f.y = backupReg1f;
-R1f.y *= 2.0;
-R1f.z = 0.0;
-R1f.w = 1.0;
-PS0f = 1.0 / intBitsToFloat(uf_remappedVS[0].x)*resScale;
-// 1
-PV1f.w = mul_nonIEEE(R2f.x, PS0f);
-PS1f = 1.0 / intBitsToFloat(uf_remappedVS[0].y)*resScale;
-// 2
-PV0f.y = mul_nonIEEE(PV1f.w, intBitsToFloat(uf_remappedVS[0].w));
-PV0f.z = mul_nonIEEE(R2f.y, PS1f);
-// 3
-PV1f.x = mul_nonIEEE(PV0f.z, intBitsToFloat(uf_remappedVS[0].w));
-R2f.z = PV0f.y;
-// 4
-R2f.w = PV1f.x;
-// export
-gl_Position = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
-// export
-passParameterSem1 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
-// 0
-}

Resolutions/WindWakerHD_Resolution/d283b9338c6b10c5_0000000000000000_vs.txt

@@ -1,77 +0,0 @@
-#version 420
-#extension GL_ARB_texture_gather : enable
-#extension GL_ARB_separate_shader_objects : enable
-#extension GL_ARB_shading_language_packing : enable
-// shader d283b9338c6b10c5
-uniform ivec4 uf_remappedVS[1];
-uniform vec2 uf_windowSpaceToClipSpaceTransform;
-layout(location = 0) in uvec4 attrDataSem0;
-layout(location = 1) in uvec4 attrDataSem1;
-out gl_PerVertex
-{
-	vec4 gl_Position;
-	float gl_PointSize;
-};
-layout(location = 0) out vec4 passParameterSem1;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
-void main()
-{
-vec4 R0f = vec4(0.0);
-vec4 R1f = vec4(0.0);
-vec4 R2f = vec4(0.0);
-uvec4 attrDecoder;
-float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
-vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
-float PS0f = 0.0, PS1f = 0.0;
-vec4 tempf = vec4(0.0);
-float tempResultf;
-int tempResulti;
-ivec4 ARi = ivec4(0);
-bool predResult = true;
-vec3 cubeMapSTM;
-int cubeMapFaceId;
-R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID));
-attrDecoder.xyz = attrDataSem0.xyz;
-attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24));
-attrDecoder.w = 0;
-R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
-attrDecoder.xy = attrDataSem1.xy;
-attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
-attrDecoder.z = 0;
-attrDecoder.w = 0;
-R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
-// 0
-backupReg0f = R1f.x;
-backupReg1f = R1f.y;
-R1f.x = backupReg0f;
-R1f.x *= 2.0;
-R1f.y = backupReg1f;
-R1f.y *= 2.0;
-R1f.z = 0.0;
-R1f.w = 1.0;
-PS0f = 1.0 / intBitsToFloat(uf_remappedVS[0].x);
-// 1
-PV1f.w = mul_nonIEEE(R2f.x, PS0f);
-PS1f = 1.0 / intBitsToFloat(uf_remappedVS[0].y);
-// 2
-PV0f.y = mul_nonIEEE(PV1f.w, intBitsToFloat(uf_remappedVS[0].w));
-PV0f.z = mul_nonIEEE(R2f.y, PS1f);
-// 3
-PV1f.x = mul_nonIEEE(PV0f.z, intBitsToFloat(uf_remappedVS[0].w));
-R2f.z = PV0f.y;
-// 4
-R2f.w = PV1f.x;
-// export
-gl_Position = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
-// export
-passParameterSem1 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
-// 0
-}

Resolutions/WindWakerHD_Resolution/d9c81460d6984bb2_0000000000000000_vs.txt

@@ -1,110 +0,0 @@
-#version 420
-#extension GL_ARB_texture_gather : enable
-#extension GL_ARB_separate_shader_objects : enable
-#extension GL_ARB_shading_language_packing : enable
-// shader d9c81460d6984bb2
-//3step shadow n AO blur horiz
-const float resYScale = (float($width)/float($gameWidth)); 
-uniform ivec4 uf_remappedVS[5];
-uniform vec2 uf_windowSpaceToClipSpaceTransform;
-layout(location = 0) in uvec4 attrDataSem0;
-out gl_PerVertex
-{
-	vec4 gl_Position;
-	float gl_PointSize;
-};
-layout(location = 0) out vec4 passParameterSem0;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){return mix(0.0, a*b, (a != 0.0) && (b != 0.0));}
-void main()
-{
-vec4 R0f = vec4(0.0);
-vec4 R1f = vec4(0.0);
-vec4 R126f = vec4(0.0);
-vec4 R127f = vec4(0.0);
-uvec4 attrDecoder;
-float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
-vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
-float PS0f = 0.0, PS1f = 0.0;
-vec4 tempf = vec4(0.0);
-float tempResultf;
-int tempResulti;
-ivec4 ARi = ivec4(0);
-bool predResult = true;
-vec3 cubeMapSTM;
-int cubeMapFaceId;
-R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID));
-attrDecoder.xyz = attrDataSem0.xyz;
-attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24));
-attrDecoder.w = 0;
-R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
-// 0
-R127f.x = (R1f.x > 0.0)?1.0:0.0;
-R127f.x /= 2.0;
-R127f.y = -(R1f.y);
-PV0f.y = R127f.y;
-R127f.z = (0.0 > R1f.x)?1.0:0.0;
-R127f.z /= 2.0;
-R127f.w = 1.0;
-PV0f.w = R127f.w;
-R126f.x = intBitsToFloat(uf_remappedVS[0].z) * intBitsToFloat(0x3fae8a72)/resYScale; //horizontal
-PS0f = R126f.x;
-// 1
-R0f.x = dot(vec4(R1f.x,R1f.y,R1f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
-PV1f.x = R0f.x;
-PV1f.y = R0f.x;
-PV1f.z = R0f.x;
-PV1f.w = R0f.x;
-R126f.w = (PV0f.y > 0.0)?1.0:0.0;
-R126f.w /= 2.0;
-PS1f = R126f.w;
-// 2
-backupReg0f = R127f.y;
-tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
-PV0f.x = tempf.x;
-PV0f.y = tempf.x;
-PV0f.z = tempf.x;
-PV0f.w = tempf.x;
-R0f.y = tempf.x;
-R127f.y = (0.0 > backupReg0f)?1.0:0.0;
-R127f.y /= 2.0;
-PS0f = R127f.y;
-// 3
-backupReg0f = R127f.x;
-tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
-PV1f.x = tempf.x;
-PV1f.y = tempf.x;
-PV1f.z = tempf.x;
-PV1f.w = tempf.x;
-R0f.z = tempf.x;
-R127f.x = backupReg0f + -(R127f.z);
-PS1f = R127f.x;
-// 4
-tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
-PV0f.x = tempf.x;
-PV0f.y = tempf.x;
-PV0f.z = tempf.x;
-PV0f.w = tempf.x;
-R0f.w = tempf.x;
-PS0f = R126f.w + -(R127f.y);
-// 5
-PV1f.y = PS0f + 0.5;
-PV1f.z = R127f.x + 0.5;
-// 6
-R1f.x = PV1f.y;
-R1f.y = PV1f.z + -(R126f.x);
-R1f.z = PV1f.z + R126f.x;
-R1f.w = PV1f.z;
-// export
-gl_Position = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
-// export
-passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
-// 0
-}

Resolutions/WindWakerHD_Resolution/patches.txt

@@ -1,17 +1,17 @@
 [WWHDAspectEUR]
 moduleMatches = 0xB7E748DE
-0x1004AAF0 = .float $width/$height 
+0x1004AAF0 = .float ($aspectRatio)
-0x101417E0 = .float $width/$height
+0x101417E0 = .float ($aspectRatio)
-0x101658A8 = .float $width/$height
+0x101658A8 = .float ($aspectRatio)
 
 [WWHDAspectJAP]
 moduleMatches = 0x74BD3F6A
-0x1004AAF0 = .float $width/$height
+0x1004AAF0 = .float ($aspectRatio)
-0x101417F8 = .float $width/$height
+0x101417F8 = .float ($aspectRatio)
-0x101658C0 = .float $width/$height
+0x101658C0 = .float ($aspectRatio)
 
 [WWHDAspectUSA]
 moduleMatches = 0x475BD29F
-0x1004AAF0 = .float $width/$height
+0x1004AAF0 = .float ($aspectRatio)
-0x101417D0 = .float $width/$height
+0x101417D0 = .float ($aspectRatio)
-0x10165898 = .float $width/$height
+0x10165898 = .float ($aspectRatio)

Resolutions/WindWakerHD_Resolution/rules.txt

@@ -6,46 +6,14 @@ description = Changes the resolution of the game.
 version = 3
 
 [Preset]
-name = 1920x1080 (HD Default)
+name = 1920x1080 Default
 $width = 1920
 $height = 1080
 $gameWidth = 1920
 $gameHeight = 1080
-$internalRes = 1
+$lightSource = 1.0
-$dither = 0.5
-$scaleShader = 1.0
-
-// Performance
-
-[Preset]
-name = 320x180
-$width = 320
-$height = 180
-$gameWidth = 1920
-$gameHeight = 1080
-$internalRes = 1
-$dither = 0.5
-$scaleShader = 1.0
-
-[Preset]
-name = 640x360
-$width = 640
-$height = 360
-$gameWidth = 1920
-$gameHeight = 1080
-$internalRes = 1
-$dither = 0.5
-$scaleShader = 1.0
-
-[Preset]
-name = 960x540
-$width = 960
-$height = 540
-$gameWidth = 1920
-$gameHeight = 1080
-$internalRes = 1
-$dither = 0.5
 $scaleShader = 1.0
+$aspectRatio = (16.0/9.0)
 
 [Preset]
 name = 1280x720
@@ -53,9 +21,9 @@ $width = 1280
 $height = 720
 $gameWidth = 1920
 $gameHeight = 1080
-$internalRes = 1
+$lightSource = 1.0
-$dither = 0.5
 $scaleShader = 1.0
+$aspectRatio = (16.0/9.0)
 
 [Preset]
 name = 1600x900
@@ -63,93 +31,65 @@ $width = 1600
 $height = 900
 $gameWidth = 1920
 $gameHeight = 1080
-$internalRes = 1
+$lightSource = 1.0
-$dither = 0.65
 $scaleShader = 1.0
-
+$aspectRatio = (16.0/9.0)
-// Common HD Resolutions
 
 [Preset]
-name = 1920x1080 (HD) x2 sub scaling
+name = 2732x1536
-$width = 1920
+$width = 2732
-$height = 1080
+$height = 1536
 $gameWidth = 1920
 $gameHeight = 1080
-$internalRes = 2
+$lightSource = 1.0
-$dither = 0.65
 $scaleShader = 1.0
+$aspectRatio = (16.0/9.0)
 
 [Preset]
-name = 2560x1440 (2k)
+name = 3200x1800
-$width = 2560
-$height = 1440
-$gameWidth= 1920
-$gameHeight= 1080
-$internalRes = 1
-$dither = 0.66
-$scaleShader = 1.0 #(1920.0/2560.0)
-
-[Preset]
-name = 2560x1440 (2k) x2 sub scaling
-$width = 2560
-$height = 1440
-$gameWidth= 1920
-$gameHeight= 1080
-$internalRes = 2
-$dither = 0.75
-$scaleShader = (1920.0/2560.0)
-
-[Preset]
-name = 3200x1800 (3k)
 $width = 3200
 $height = 1800
 $gameWidth = 1920
 $gameHeight = 1080
-$internalRes = 1
+$lightSource = 1.0
-$dither = 0.75
 $scaleShader = 1.0
+$aspectRatio = (16.0/9.0)
 
 [Preset]
-name = 3840x2160 (4k - Native x2)
+name = 3840x2160
 $width = 3840
 $height = 2160
 $gameWidth = 1920
 $gameHeight = 1080
-$internalRes = 1
+$lightSource = 1.0
-$dither = 0.76
 $scaleShader = 1.0
+$aspectRatio = (16.0/9.0)
 
 [Preset]
-name = 3840x2160 (4k - Native x2) x2 sub scaling
+name = 5120x2880
-$width = 3840
-$height = 2160
-$gameWidth= 1920
-$gameHeight= 1080
-$internalRes = 2
-$dither = 0.745
-$scaleShader = 1.0
-
-[Preset]
-name = 5120x2880 (5k)
 $width = 5120
 $height = 2880
 $gameWidth = 1920
 $gameHeight = 1080
-$internalRes = 1
+$lightSource = 1.0
-$dither = 0.95
 $scaleShader = 1.0
+$aspectRatio = (16.0/9.0)
+
+
+#Resolutions						|Aspect ratio
+#2560×1080, 5120×2160, 8192×3456	|64:27 (2.370)
+#3440×1440							|43:18 (2.38)
+#1920×800, 3840×1600, 7680×3200		|12:5 (2.4)
 
 [Preset]
-name = 5120x2880 (5k)x2 sub scaling
+name = ---- Ultra wide 21:9 ----
-$width = 5120
+$width = 2560
-$height = 2880
+$height = 1080
 $gameWidth= 1920
 $gameHeight= 1080
-$internalRes = 2
+$lightSource = 2.0
-$dither = 0.95
+$scaleShader = (1920.0/2560.0)
-$scaleShader = 1.0
+$aspectRatio = (64.0/27.0) #LG
-
-// Common Ultrawide Resolutions
 
 [Preset]
 name = 2560x1080 (21:9 HD)
@@ -157,9 +97,9 @@ $width = 2560
 $height = 1080
 $gameWidth= 1920
 $gameHeight= 1080
-$internalRes = 1
+$lightSource = 2.0
-$dither = 0.5
 $scaleShader = (1920.0/2560.0)
+$aspectRatio = (64.0/27.0) #LG
 
 [Preset]
 name = 3440x1440 (21:9)
@@ -167,9 +107,19 @@ $width = 3440
 $height = 1440
 $gameWidth= 1920
 $gameHeight= 1080
-$internalRes = 1
+$lightSource = 1.5
-$dither = 0.66
 $scaleShader = (2560.0/3440.0)
+$aspectRatio = (43.0/18.0)
+
+[Preset]
+name = 3840x1600 (21:9)
+$width = 3840
+$height = 1600
+$gameWidth= 1920
+$gameHeight= 1080
+$lightSource = 1.35
+$scaleShader = (2844.445/3840.0)
+$aspectRatio = (12.0/5.0)
 
 [Preset]
 name = 5160x2160 (4k 21:9)
@@ -177,191 +127,226 @@ $width = 5160
 $height = 2160
 $gameWidth= 1920
 $gameHeight= 1080
-$internalRes = 1
+$lightSource = 1.0
-$dither = 0.76
 $scaleShader = (3840.0/5160.0)
-
+$aspectRatio = (64.0/27.0) #LG
-// 48:9 Aspect Ratio
-
-#[Preset] ## Too broken, disabled
-#name = 7680x1440 (48:9)
-#$width = 7680
-#$height = 1440
-#$gameWidth= 1920
-#$gameHeight= 1080
-#$internalRes = 1
-#$dither = 0.66
-#$scaleShader = (2560.0/7680.0)
 
 [Preset]
-name = 5760x1080 (48:9 HD)
+name = ---- Custom resolutions ---- 
-$width = 5760
+$width = 1920
 $height = 1080
 $gameWidth = 1920
 $gameHeight = 1080
-$internalRes = 1
+$lightSource = 2.0
-$dither = 0.5
+$scaleShader = 1.0
-$scaleShader = (1920.0/5760.0)
+$aspectRatio = (16.0/9.0)
 
+[Preset]
+name = 1920x1080 AO fix - Light res x2 
+$width = 1920
+$height = 1080
+$gameWidth = 1920
+$gameHeight = 1080
+$lightSource = 2.0
+$scaleShader = 1.0
+$aspectRatio = (16.0/9.0)
+
+[Preset]
+name = 2560x1440 AO fix
+$width = 2560
+$height = 1440
+$gameWidth = 1920
+$gameHeight = 1080
+$lightSource = 1.5
+$scaleShader = 1.0 #(1088.0/1440.0)
+$aspectRatio = (16.0/9.0)
+
+[Preset]
+name = 3840x2160 AO fix - light res x2
+$width = 3840
+$height = 2160
+$gameWidth = 1920
+$gameHeight = 1080
+$lightSource = 2.0
+$scaleShader = 1.0
+$aspectRatio = (16.0/9.0)
+
+[Preset]
+name = 1920x2160 vert x2 SSAA - light res x2
+$width = 1920
+$height = 2160
+$gameWidth = 1920
+$gameHeight = 1080
+$lightSource = 2.0
+$scaleShader = 1.0
+$aspectRatio = (16.0/9.0)
+
+[Preset]
+name = 3840x4320 vert x2 SSAA - light res x2
+$width = 3840
+$height = 4320 # x2
+$gameWidth = 1920
+$gameHeight = 1080
+$lightSource = 2.0
+$scaleShader = 1.0
+$aspectRatio = (16.0/9.0)
+
+#[TextureRedefine]
+#formats = 0x01a
+#overwriteFormat = 0x01f
 
 [TextureRedefine]
 width = 1920
 height = 1088
 #formats = 0x80e,0x019,0x001
+formatsExcluded = 0x816
 overwriteWidth = ($width/$gameWidth) * 1920
 overwriteHeight = ($height/$gameHeight) * 1088
 
 [TextureRedefine]
 width = 1920
 height = 1080
-#formatsExcluded = 0x41A
+#formats = 0x80e,0x019,0x001
+formatsExcluded = 0x816
 overwriteWidth = ($width/$gameWidth) * 1920
 overwriteHeight = ($height/$gameHeight) * 1080
 
-[TextureRedefine] #Shadows
+[TextureRedefine] #pictograph texture?
-width = 1024
+width = 1600
-height = 1024
+height = 900
-formats = 0x005 #,0x034,0x431,0x034
+#formats = 
-overwriteWidth = ($width/$gameWidth) * (1024*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * 1600
-overwriteHeight = ($height/$gameHeight) * (1024*$internalRes)
+overwriteHeight = ($height/$gameHeight) * 900
 
-[TextureRedefine] #Shadows
+#[TextureRedefine] #Shadows x3 Lods 
+#width = 1024
+#height = 1024
+#formats = 0x005 #,0x034,0x431,0x034
+#overwriteWidth = ($width/$gameWidth) * 1024
+#overwriteHeight = ($height/$gameHeight) * 1024
+
+[TextureRedefine]
 width = 1024
 height = 544
-formats = 0x005,0x80e,0x019,0x001 #,0x034,0x431,0x034
+formats = 0x001
-overwriteWidth = ($width/$gameWidth) * (1024*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (1024*$lightSource*$scaleShader)
-overwriteHeight = ($height/$gameHeight) * (544*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (544*$lightSource)
+
+[TextureRedefine]
+width = 960
+height = 544
+#formats = 0x816,0x806,0x019,0x01a,0x001,0x80e
+overwriteWidth = ($width/$gameWidth) * (960*$lightSource*$scaleShader)
+overwriteHeight = ($height/$gameHeight) * (544*$lightSource)
 
 [TextureRedefine]
 width = 960
 height = 540
-#formats = 0x816,0x806,0x019,0x01a
+#formats = 0x816,0x806,0x019,0x01a,0x001,0x80e
-overwriteWidth = ($width/$gameWidth) * (960*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (960*$lightSource*$scaleShader)
-overwriteHeight = ($height/$gameHeight) * (540*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (540*$lightSource)
-
-[TextureRedefine]
-width = 960
-height = 544
-#formats = 0x816,0x806,0x019,0x01a
-overwriteWidth = ($width/$gameWidth) * (960*$internalRes*$scaleShader)
-overwriteHeight = ($height/$gameHeight) * (544*$internalRes)
 
 [TextureRedefine]
 width = 864
 height = 480
-#formats = 
+#formats = 0x019,0x80e
 overwriteWidth = ($width/$gameWidth) * 864
 overwriteHeight = ($height/$gameHeight) * 480
 
 [TextureRedefine]
 width = 854
 height = 480
-#formats = 
+#formats = 0x019,0x80e
 overwriteWidth = ($width/$gameWidth) * 854
 overwriteHeight = ($height/$gameHeight) * 480
 
-[TextureRedefine]
+#[TextureRedefine] #pictograph texture?
+#width = 800
+#height = 450
+##formats = 
+#overwriteWidth = ($width/$gameWidth) * 800
+#overwriteHeight = ($height/$gameHeight) * 450
+
+[TextureRedefine] #
 width = 512
 height = 512
-formats = 0x806,0x019,0x01a
+formats = 0x019,0x01a
-overwriteWidth = ($width/$gameWidth) * (512*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (512*$lightSource*$scaleShader)
-overwriteHeight = ($height/$gameHeight) * (512*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (512*$lightSource)
-
-[TextureRedefine]
-width = 480
-height = 272
-#formats = 0x816
-overwriteWidth = ($width/$gameWidth) * (480*$internalRes*$scaleShader)
-overwriteHeight = ($height/$gameHeight) * (272*$internalRes)
 
 [TextureRedefine]
 width = 480
 height = 270
 #formats = 0x816
-overwriteWidth = ($width/$gameWidth) * (480*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (480)
-overwriteHeight = ($height/$gameHeight) * (270*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (270)
-
-#[TextureRedefine]
-#width = 360
-#height = 346
-##formats = 
-#overwriteWidth = ($width/$gameWidth) * (360*$internalRes*$scaleShader)
-#overwriteHeight = ($height/$gameHeight) * (346*$internalRes)
 
 [TextureRedefine]
-width = 256
+width = 480
-height = 144
+height = 272
 #formats = 0x816
-#formatsExcluded = 0x01a
+overwriteWidth = ($width/$gameWidth) * (480)
-overwriteWidth = ($width/$gameWidth) * (256*$internalRes*$scaleShader)
+overwriteHeight = ($height/$gameHeight) * (272)
-overwriteHeight = ($height/$gameHeight) * (144*$internalRes)
 
-[TextureRedefine]
+[TextureRedefine] #
 width = 256
 height = 256
 formats = 0x816
-overwriteWidth = ($width/$gameWidth) * (256*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (256)
-overwriteHeight = ($height/$gameHeight) * (256*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (256)
 
 [TextureRedefine]
 width = 256
 height = 144
-#formats = 0x816
+#formats = 0x816,0x01a
-overwriteWidth = ($width/$gameWidth) * (256*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (256)
-overwriteHeight = ($height/$gameHeight) * (144*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (144)
 
 [TextureRedefine]
 width = 240
 height = 135
-#formats = 0x816
+#formats = 0x816,0x01a
-overwriteWidth = ($width/$gameWidth) * (240*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (240)
-overwriteHeight = ($height/$gameHeight) * (135*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (135)
 
-[TextureRedefine]
+[TextureRedefine] #
 width = 128
 height = 128
 formats = 0x816
-overwriteWidth = ($width/$gameWidth) * (128*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (128)
-overwriteHeight = ($height/$gameHeight) * (128*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (128)
 
 [TextureRedefine]
 width = 128
 height = 80
 #formats = 0x816
-overwriteWidth = ($width/$gameWidth) * (128*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (128)
-overwriteHeight = ($height/$gameHeight) * (80*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (80)
 
 [TextureRedefine]
 width = 120
 height = 67
 #formats = 
-overwriteWidth = ($width/$gameWidth) * (120*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (120)
-overwriteHeight = ($height/$gameHeight) * (67*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (67)
 
-[TextureRedefine]
+[TextureRedefine] #
 width = 64
 height = 64
 formats = 0x816
-overwriteWidth = ($width/$gameWidth) * (64*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (64)
-overwriteHeight = ($height/$gameHeight) * (64*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (64)
 
 [TextureRedefine]
 width = 64
 height = 48
-#formats = 
+#formats = 0x816
-overwriteWidth = ($width/$gameWidth) * (64*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (64)
-overwriteHeight = ($height/$gameHeight) * (48*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (48)
 
 [TextureRedefine]
 width = 60
 height = 33
 #formats = 
-overwriteWidth = ($width/$gameWidth) * (60*$internalRes*$scaleShader)
+overwriteWidth = ($width/$gameWidth) * (60)
-overwriteHeight = ($height/$gameHeight) * (33*$internalRes)
+overwriteHeight = ($height/$gameHeight) * (33)
-
-#[TextureRedefine]
-#width = 4
-#height = 4
-##formats = 
-#overwriteWidth = ($width/$gameWidth) * (4*$internalRes)
-#overwriteHeight = ($height/$gameHeight) * (4*$internalRes)