The-Homebrew-Cloud/cemu_graphic_packs
2
0
Fork 0
mirror of https://github.com/cemu-project/cemu_graphic_packs.git synced 2025-01-08 07:50:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add src/WindWaker

Browse Source
This commit is contained in:
intra0 2024-12-13 22:37:45 -06:00 committed by GitHub
parent e99ba85762
commit 62c400378a
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
41 changed files with 4799 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/WindWakerHD/Enhancements/Bloom/960d3ef6662043c7_0000000000000079_ps.txt Normal file
View File

@ -0,0 +1,70 @@
#version 450
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
#ifdef VULKAN
layout(set = 1, binding = 1) uniform ufBlock
{
uniform vec4 uf_fragCoordScale;
};
#else
uniform vec2 uf_fragCoordScale;
#endif
// shader 960d3ef6662043c7
// Used for: Bloom
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
layout(location = 0) in vec4 passParameterSem0;
layout(location = 0) out vec4 passPixelColor0;
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);
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 = passParameterSem0;
R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz);
// 0
backupReg0f = R0f.x * $targetBloom;
backupReg1f = R0f.y * $targetBloom;
backupReg2f = R0f.z * $targetBloom;
R0f.xyz = vec3(backupReg0f,backupReg1f,backupReg2f);
// export
passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
}

40
src/WindWakerHD/Enhancements/Bloom/rules.txt Normal file
View File

@ -0,0 +1,40 @@
[Definition]
titleIds = 0005000010143400,0005000010143500,0005000010143600,000500010185400
name = Bloom
path = "The Legend of Zelda: The Wind Waker HD/Enhancements/Bloom"
description = Modify the amount of bloom. Bloom is used to make bright things emit a glow effect to make them look bright.
#Credits: Crementif
version = 6
[Default]
$targetBloom = 1.0
[Preset]
category = Bloom
name = Extra Bloom (150%)
$targetBloom = 1.5
[Preset]
category = Bloom
name = Normal Bloom (100%, Default)
default = 1
[Preset]
category = Bloom
name = Slightly Reduced Bloom (75%)
$targetBloom = 0.75
[Preset]
category = Bloom
name = Reduced Bloom (50%)
$targetBloom = 0.5
[Preset]
category = Bloom
name = Heavily Reduced Bloom (25%)
$targetBloom = 0.25
[Preset]
category = Bloom
name = No Bloom
$targetBloom = 0.0

94
src/WindWakerHD/Enhancements/Contrasty/04dcbf2655f94e03_00000000000007f9_ps.txt Normal file
View File

@ -0,0 +1,94 @@
#version 450
#extension GL_ARB_texture_gather : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader 04dcbf2655f94e03 //hoirzon cloud layer lighten up
#ifdef VULKAN
layout(set = 1, binding = 1) uniform ufBlock
{
uniform ivec4 uf_remappedPS[2];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[2];
uniform vec2 uf_fragCoordScale;
#endif
const float skyboxRed = float($skyboxRed);
const float skyboxGreen = float($skyboxGreen);
const float skyboxBlue = float($skyboxBlue);
const float skyboxMix = float($skyboxMix);
TEXTURE_LAYOUT(3, 1, 0) uniform sampler2D textureUnitPS3;
layout(location = 0) in vec4 passParameterSem6;
layout(location = 0) out vec4 passPixelColor0;
layout(location = 1) out vec4 passPixelColor1;
// uf_fragCoordScale was moved to the ufBlock
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);
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 = passParameterSem6;
R0f.xyzw = (texture(textureUnitPS3, R0f.xy).xyzw);
// 0
backupReg0f = R0f.x;
PV0f.x = R0f.w;
PV0f.x = clamp(PV0f.x, 0.0, 1.0);
R2f.y = (intBitsToFloat(uf_remappedPS[0].z) * 0.5 + 0.5);
R1f.x = mul_nonIEEE(backupReg0f, intBitsToFloat(uf_remappedPS[1].x));
PS0f = R1f.x;
// 1
R2f.x = PV0f.x;
R1f.y = mul_nonIEEE(R0f.y, intBitsToFloat(uf_remappedPS[1].y));
PV1f.y = R1f.y;
R1f.z = mul_nonIEEE(R0f.z, intBitsToFloat(uf_remappedPS[1].z));
PV1f.z = R1f.z;
R1f.w = PV0f.x;
PV1f.w = R1f.w;
// 2
R0f.xyz = vec3(R1f.x,PV1f.y,PV1f.z);
R0f.w = PV1f.w;
// 3
R1f.xyz = vec3(R2f.y,R2f.y,R2f.y);
R1f.w = R2f.x;
// export
//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);
}

90
src/WindWakerHD/Enhancements/Contrasty/53141a02b3f78921_00000000000000ff_ps.txt Normal file
View File

@ -0,0 +1,90 @@
#version 450
#extension GL_ARB_texture_gather : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// 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);
#ifdef VULKAN
layout(set = 1, binding = 0) uniform ufBlock
{
uniform ivec4 uf_remappedPS[2];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[2];
uniform vec2 uf_fragCoordScale;
#endif
layout(location = 0) in vec4 passParameterSem1;
layout(location = 0) out vec4 passPixelColor0;
layout(location = 1) out vec4 passPixelColor1;
// uf_fragCoordScale was moved to the ufBlock
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);
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;
// 0
PV0f.x = R0f.w;
PV0f.x = clamp(PV0f.x, 0.0, 1.0);
R1f.y = (intBitsToFloat(uf_remappedPS[0].z) * 0.5 + 0.5);
R0f.x = intBitsToFloat(uf_remappedPS[1].x);
PS0f = R0f.x;
// 1
R0f.yzw = vec3(intBitsToFloat(uf_remappedPS[1].y),intBitsToFloat(uf_remappedPS[1].z),PV0f.x);
PV1f.y = R0f.y;
PV1f.z = R0f.z;
PV1f.w = R0f.w;
R1f.w = PV0f.x;
PS1f = R1f.w;
// 2
R2f.xyz = vec3(R0f.x,PV1f.y,PV1f.z);
R2f.w = PV1f.w;
// 3
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*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);
}

115
src/WindWakerHD/Enhancements/Contrasty/8a763b05908ba4e8_00000000000000ff_ps.txt Normal file
View File

@ -0,0 +1,115 @@
#version 450
#extension GL_ARB_texture_gather : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// 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);
#ifdef VULKAN
layout(set = 1, binding = 0) uniform ufBlock
{
uniform ivec4 uf_remappedPS[3];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[3];
uniform vec2 uf_fragCoordScale;
#endif
layout(location = 0) in vec4 passParameterSem1;
layout(location = 1) in vec4 passParameterSem2;
layout(location = 2) in vec4 passParameterSem4;
layout(location = 0) out vec4 passPixelColor0;
layout(location = 1) out vec4 passPixelColor1;
// uf_fragCoordScale was moved to the ufBlock
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 R123f = 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;
// 0
backupReg0f = R0f.w;
tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,-0.0),vec4(R2f.x,R2f.y,R2f.z,0.0));
PV0f.x = tempf.x;
PV0f.y = tempf.x;
PV0f.z = tempf.x;
PV0f.w = tempf.x;
R0f.w = backupReg0f;
R0f.w = clamp(R0f.w, 0.0, 1.0);
PS0f = R0f.w;
// 1
R127f.x = -(intBitsToFloat(uf_remappedPS[0].y)) + intBitsToFloat(uf_remappedPS[1].y);
R127f.y = -(intBitsToFloat(uf_remappedPS[0].x)) + intBitsToFloat(uf_remappedPS[1].x);
R2f.w = PS0f;
PS1f = sqrt(PV0f.x);
// 2
R126f.x = -(intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[1].z);
R123f.w = (mul_nonIEEE(R1f.x,PS1f) + R1f.y);
R123f.w = clamp(R123f.w, 0.0, 1.0);
PV0f.w = R123f.w;
// 3
PV1f.z = mul_nonIEEE(PV0f.w, PV0f.w);
// 4
R0f.x = (mul_nonIEEE(R127f.y,PV1f.z) + intBitsToFloat(uf_remappedPS[0].x));
R0f.y = (mul_nonIEEE(R127f.x,PV1f.z) + intBitsToFloat(uf_remappedPS[0].y));
R0f.z = (mul_nonIEEE(R126f.x,PV1f.z) + intBitsToFloat(uf_remappedPS[0].z));
// 0
R2f.x = (intBitsToFloat(uf_remappedPS[2].z) * 0.5 + 0.5);
// 1
backupReg0f = R0f.x;
backupReg1f = R0f.y;
backupReg2f = R0f.z;
backupReg3f = R0f.w;
R0f.xyz = vec3(backupReg0f,backupReg1f,backupReg2f);
R0f.w = backupReg3f;
// 2
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*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);
}

90
src/WindWakerHD/Enhancements/Contrasty/90ed656e9c17616b_00000000000000ff_ps.txt Normal file
View File

@ -0,0 +1,90 @@
#version 450
#extension GL_ARB_texture_gather : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// 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);
#ifdef VULKAN
layout(set = 1, binding = 0) uniform ufBlock
{
uniform ivec4 uf_remappedPS[3];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[3];
uniform vec2 uf_fragCoordScale;
#endif
layout(location = 0) in vec4 passParameterSem1;
layout(location = 0) out vec4 passPixelColor0;
layout(location = 1) out vec4 passPixelColor1;
// uf_fragCoordScale was moved to the ufBlock
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);
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;
// 0
PV0f.x = mul_nonIEEE(R0f.w, intBitsToFloat(uf_remappedPS[0].x));
PV0f.x = clamp(PV0f.x, 0.0, 1.0);
R1f.y = (intBitsToFloat(uf_remappedPS[1].z) * 0.5 + 0.5);
// 1
R0f.xyz = vec3(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z));
PV1f.x = R0f.x;
PV1f.y = R0f.y;
PV1f.z = R0f.z;
R0f.w = PV0f.x;
PV1f.w = R0f.w;
R1f.w = PV0f.x;
PS1f = R1f.w;
// 2
R2f.xyz = vec3(PV1f.x,PV1f.y,PV1f.z);
R2f.w = PV1f.w;
// 3
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*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);
}

302
src/WindWakerHD/Enhancements/Contrasty/92d5cf316124c301_00000000007fd249_ps.txt Normal file
View File

@ -0,0 +1,302 @@
#version 450
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader 92d5cf316124c301
//beach cooking
#ifdef VULKAN
layout(set = 1, binding = 5) uniform ufBlock
{
uniform ivec4 uf_remappedPS[7];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[7];
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2DArray textureUnitPS0;
TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1;
TEXTURE_LAYOUT(2, 1, 2) uniform sampler2D textureUnitPS2;
TEXTURE_LAYOUT(3, 1, 3) uniform sampler2D textureUnitPS3;
TEXTURE_LAYOUT(4, 1, 4) uniform sampler2D textureUnitPS4;
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;
// uf_fragCoordScale was moved to the ufBlock
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);
}

71
src/WindWakerHD/Enhancements/Contrasty/960d3ef6662043c7_0000000000000079_ps.txt Normal file
View File

@ -0,0 +1,71 @@
#version 450
#extension GL_ARB_texture_gather : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader 960d3ef6662043c7//bloom blend
const float skyboxRed = float($skyboxRed);
const float skyboxGreen = float($skyboxGreen);
const float skyboxBlue = float($skyboxBlue);
const float skyboxMix = float($skyboxMix);
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
layout(location = 0) in vec4 passParameterSem0;
layout(location = 0) out vec4 passPixelColor0;
#ifdef VULKAN
layout(set = 1, binding = 1) uniform ufBlock
{
uniform vec4 uf_fragCoordScale;
};
#else
uniform vec2 uf_fragCoordScale;
#endif
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);
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 = passParameterSem0;
R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz);
// 0
backupReg0f = R0f.x;
backupReg1f = R0f.y;
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*skyboxRed, R0f.y*skyboxGreen, R0f.z*skyboxBlue*1.1, R0f.w)*skyboxMix*0.75;
}

280
src/WindWakerHD/Enhancements/Contrasty/b77c717f243c0b08_00000000007f9249_ps.txt Normal file
View File

@ -0,0 +1,280 @@
#version 450
#extension GL_ARB_texture_gather : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader b77c717f243c0b08
#ifdef VULKAN
layout(set = 1, binding = 5) uniform ufBlock
{
uniform ivec4 uf_remappedPS[9];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[9];
uniform vec2 uf_fragCoordScale;
#endif
const float skyboxRed = float($skyboxRed);
const float skyboxGreen = float($skyboxGreen);
const float skyboxBlue = float($skyboxBlue);
const float skyboxMix = float($skyboxMix);
TEXTURE_LAYOUT(1, 1, 0) uniform sampler2D textureUnitPS1;
TEXTURE_LAYOUT(2, 1, 1) uniform sampler2D textureUnitPS2;
TEXTURE_LAYOUT(3, 1, 2) uniform sampler2D textureUnitPS3;
TEXTURE_LAYOUT(4, 1, 3) uniform sampler2D textureUnitPS4;
TEXTURE_LAYOUT(5, 1, 4) uniform sampler2D textureUnitPS5;
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 = 4) in vec4 passParameterSem7;
layout(location = 5) in vec4 passParameterSem8;
layout(location = 6) in vec4 passParameterSem9;
layout(location = 0) out vec4 passPixelColor0;
layout(location = 1) out vec4 passPixelColor1;
// uf_fragCoordScale was moved to the ufBlock
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 R122f = 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;
R4f = passParameterSem7;
R5f = passParameterSem8;
R6f = passParameterSem9;
R5f.yzw = (texture(textureUnitPS4, R5f.xy).yzw);
// 0
R127f.x = R5f.y + -(0.5);
R127f.y = -(R1f.z) + -(intBitsToFloat(0x42700000));
PV0f.z = R5f.w + -(0.5);
R127f.w = R5f.z + -(0.5);
PS0f = 1.0 / R3f.z;
// 1
backupReg0f = R3f.y;
PV1f.x = mul_nonIEEE(PV0f.z, intBitsToFloat(uf_remappedPS[0].z));
PV1f.y = mul_nonIEEE(PV0f.z, intBitsToFloat(uf_remappedPS[0].x));
R3f.z = mul_nonIEEE(R3f.x, PS0f);
R3f.w = 1.0;
R3f.y = mul_nonIEEE(backupReg0f, PS0f);
PS1f = R3f.y;
// 2
R126f.x = R127f.y * intBitsToFloat(0x3dcccccd);
R126f.x = clamp(R126f.x, 0.0, 1.0);
R8f.y = 0.0;
R123f.z = (mul_nonIEEE(R127f.w,intBitsToFloat(uf_remappedPS[0].w)) + PV1f.x);
PV0f.z = R123f.z;
R123f.w = (mul_nonIEEE(R127f.w,intBitsToFloat(uf_remappedPS[0].y)) + PV1f.y);
PV0f.w = R123f.w;
PS0f = 1.0 / R2f.z;
// 3
R123f.x = (mul_nonIEEE(R127f.x,intBitsToFloat(uf_remappedPS[1].y)) + PV0f.z);
PV1f.x = R123f.x;
R123f.y = (mul_nonIEEE(R127f.x,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.w);
PV1f.y = R123f.y;
R5f.z = mul_nonIEEE(R2f.x, PS0f);
R5f.w = mul_nonIEEE(R2f.y, PS0f);
PS1f = exp2(intBitsToFloat(uf_remappedPS[1].z));
PS1f *= 4.0;
// 4
PV0f.x = mul_nonIEEE(-(R1f.z), intBitsToFloat(uf_remappedPS[2].y));
PV0f.y = mul_nonIEEE(PS1f, PV1f.x);
PV0f.z = mul_nonIEEE(PS1f, PV1f.y);
PV0f.w = mul_nonIEEE(-(R1f.z), intBitsToFloat(uf_remappedPS[2].w));
R127f.z = -(R126f.x) + 1.0;
PS0f = R127f.z;
// 5
PV1f.x = PV0f.z * intBitsToFloat(0x3e7f0000);
R123f.y = (mul_nonIEEE(-(intBitsToFloat(uf_remappedPS[2].z)),intBitsToFloat(uf_remappedPS[2].w)) + PV0f.w);
R123f.y = clamp(R123f.y, 0.0, 1.0);
PV1f.y = R123f.y;
R0f.z = (mul_nonIEEE(-(intBitsToFloat(uf_remappedPS[2].x)),intBitsToFloat(uf_remappedPS[2].y)) + PV0f.x);
R0f.z = clamp(R0f.z, 0.0, 1.0);
PV1f.w = PV0f.y * intBitsToFloat(0x3e7f0000);
R2f.x = mul_nonIEEE(R1f.z, R1f.z);
PS1f = R2f.x;
// 6
backupReg0f = R4f.x;
backupReg1f = R4f.y;
R4f.x = backupReg0f + PV1f.x;
R4f.y = backupReg1f + PV1f.w;
R2f.z = R6f.x + PV1f.x;
R2f.w = R6f.y + PV1f.w;
R6f.y = PV1f.y + R127f.z;
R6f.y = clamp(R6f.y, 0.0, 1.0);
PS0f = R6f.y;
R3f.x = (textureLod(textureUnitPS2, R3f.zy,0.0).x);
R6f.x = (textureLod(textureUnitPS2, R3f.zy,R3f.w).x);
R4f.xyzw = (texture(textureUnitPS3, R4f.xy).xyzw);
R7f.xyz = (texture(textureUnitPS5, R2f.zw).xyz);
R5f.x = (texture(textureUnitPS1, R5f.zw).x);
// 0
PV0f.x = -(R3f.x) + R6f.x;
R127f.y = (mul_nonIEEE(-(R0f.z),intBitsToFloat(uf_remappedPS[3].w)) + intBitsToFloat(uf_remappedPS[3].z));
PV0f.y = R127f.y;
R126f.z = mul_nonIEEE(R4f.w, intBitsToFloat(uf_remappedPS[4].w));
R126f.z = clamp(R126f.z, 0.0, 1.0);
R122f.x = (mul_nonIEEE(R1f.y,R1f.y) + R2f.x);
PS0f = R122f.x;
// 1
PV1f.x = -(PV0f.y) + 1.0;
PV1f.y = -(intBitsToFloat(uf_remappedPS[5].y)) + intBitsToFloat(uf_remappedPS[4].y);
PV1f.z = -(intBitsToFloat(uf_remappedPS[5].x)) + intBitsToFloat(uf_remappedPS[4].x);
R123f.w = (mul_nonIEEE(PV0f.x,R6f.y) + R3f.x);
PV1f.w = R123f.w;
R122f.x = (mul_nonIEEE(R1f.x,R1f.x) + PS0f);
PS1f = R122f.x;
// 2
R127f.x = (mul_nonIEEE(PV1f.z,R4f.x) + intBitsToFloat(uf_remappedPS[5].x));
R127f.x = clamp(R127f.x, 0.0, 1.0);
R126f.y = (mul_nonIEEE(PV1f.y,R4f.y) + intBitsToFloat(uf_remappedPS[5].y));
R126f.y = clamp(R126f.y, 0.0, 1.0);
PV0f.z = mul_nonIEEE(PV1f.w, intBitsToFloat(uf_remappedPS[3].y));
R127f.w = (mul_nonIEEE(PV1f.x,R6f.y) + R127f.y);
PS0f = sqrt(PS1f);
// 3
R126f.x = -(intBitsToFloat(uf_remappedPS[5].z)) + intBitsToFloat(uf_remappedPS[4].z);
R123f.w = (mul_nonIEEE(R0f.x,PS0f) + R0f.y);
R123f.w = clamp(R123f.w, 0.0, 1.0);
PV1f.w = R123f.w;
tempResultf = log2(PV0f.z);
if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F;
PS1f = tempResultf;
// 4
PV0f.x = mul_nonIEEE(R127f.w, PS1f);
R127f.y = -(intBitsToFloat(uf_remappedPS[5].y)) + intBitsToFloat(uf_remappedPS[6].y);
R127f.z = -(intBitsToFloat(uf_remappedPS[5].x)) + intBitsToFloat(uf_remappedPS[6].x);
R0f.w = R126f.z;
R0f.w = clamp(R0f.w, 0.0, 1.0);
R1f.z = mul_nonIEEE(PV1f.w, PV1f.w);
PS0f = R1f.z;
// 5
PV1f.x = -(intBitsToFloat(uf_remappedPS[5].z)) + intBitsToFloat(uf_remappedPS[6].z);
R127f.w = (mul_nonIEEE(R126f.x,R4f.z) + intBitsToFloat(uf_remappedPS[5].z));
R127f.w = clamp(R127f.w, 0.0, 1.0);
R126f.x = exp2(PV0f.x);
PS1f = R126f.x;
// 6
backupReg0f = R127f.y;
backupReg1f = R127f.z;
R127f.y = (mul_nonIEEE(PV1f.x,R7f.z) + intBitsToFloat(uf_remappedPS[5].z));
R127f.y = clamp(R127f.y, 0.0, 1.0);
PV0f.y = R127f.y;
R127f.z = (mul_nonIEEE(backupReg0f,R7f.y) + intBitsToFloat(uf_remappedPS[5].y));
R127f.z = clamp(R127f.z, 0.0, 1.0);
PV0f.z = R127f.z;
R126f.w = (mul_nonIEEE(backupReg1f,R7f.x) + intBitsToFloat(uf_remappedPS[5].x));
R126f.w = clamp(R126f.w, 0.0, 1.0);
PV0f.w = R126f.w;
R8f.w = R0f.w;
PS0f = R8f.w;
// 7
PV1f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].x), R126f.x);
PV1f.x = clamp(PV1f.x, 0.0, 1.0);
PV1f.y = R127f.w + -(PV0f.y);
PV1f.z = R126f.y + -(PV0f.z);
PV1f.w = R127f.x + -(PV0f.w);
R125f.z = intBitsToFloat(uf_remappedPS[7].y) + R5f.x;
R125f.z = clamp(R125f.z, 0.0, 1.0);
PS1f = R125f.z;
// 8
backupReg0f = R127f.z;
R127f.x = (mul_nonIEEE(PV1f.w,R126f.z) + R126f.w);
R127f.x = clamp(R127f.x, 0.0, 1.0);
PV0f.x = R127f.x;
PV0f.y = PV1f.x + intBitsToFloat(uf_remappedPS[7].x);
PV0f.y = clamp(PV0f.y, 0.0, 1.0);
R127f.z = (mul_nonIEEE(PV1f.y,R126f.z) + R127f.y);
R127f.z = clamp(R127f.z, 0.0, 1.0);
PV0f.z = R127f.z;
R126f.w = (mul_nonIEEE(PV1f.z,R126f.z) + backupReg0f);
R126f.w = clamp(R126f.w, 0.0, 1.0);
PV0f.w = R126f.w;
// 9
backupReg0f = R125f.z;
R126f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[7].z), PV0f.w);
PV1f.x = R126f.x;
R127f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[7].z), PV0f.x);
PV1f.y = R127f.y;
R125f.z = mul_nonIEEE(PV0f.y, backupReg0f);
R127f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[7].z), PV0f.z);
PV1f.w = R127f.w;
// 10
PV0f.x = R127f.z + -(PV1f.w);
PV0f.y = R126f.w + -(PV1f.x);
PV0f.z = R127f.x + -(PV1f.y);
// 11
R5f.x = (mul_nonIEEE(R125f.z,R127f.w) + PV0f.x);
R7f.y = (mul_nonIEEE(R125f.z,R126f.x) + PV0f.y);
R7f.z = (mul_nonIEEE(R125f.z,R127f.y) + PV0f.z);
// 0
PV0f.x = -(R7f.y) + intBitsToFloat(uf_remappedPS[8].y);
PV0f.y = -(R7f.z) + intBitsToFloat(uf_remappedPS[8].x);
PV0f.w = -(R5f.x) + intBitsToFloat(uf_remappedPS[8].z);
// 1
R0f.x = (mul_nonIEEE(PV0f.y,R1f.z) + R7f.z);
PV1f.x = R0f.x;
R0f.y = (mul_nonIEEE(PV0f.x,R1f.z) + R7f.y);
PV1f.y = R0f.y;
R0f.z = (mul_nonIEEE(PV0f.w,R1f.z) + R5f.x);
PV1f.z = R0f.z;
// 2
backupReg0f = R0f.w;
R0f.xyz = vec3(PV1f.x,PV1f.y,PV1f.z);
R0f.w = backupReg0f;
// 3
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*skyboxRed, R0f.y*skyboxGreen*0.9, R0f.z*skyboxBlue*1.1, R0f.w)*skyboxMix;
passPixelColor1 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
}

322
src/WindWakerHD/Enhancements/Contrasty/c2cae30e906be2d5_0000000000001e49_ps.txt Normal file
View File

@ -0,0 +1,322 @@
#version 450
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader c2cae30e906be2d5
//Ao scale
#ifdef VULKAN
layout(set = 1, binding = 3) uniform ufBlock
{
uniform ivec4 uf_remappedPS[8];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[8];
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1;
TEXTURE_LAYOUT(2, 1, 2) uniform sampler2D textureUnitPS2;
layout(location = 0) in vec4 passParameterSem1;
layout(location = 0) out vec4 passPixelColor0;
// uf_fragCoordScale was moved to the ufBlock
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);
}

191
src/WindWakerHD/Enhancements/Contrasty/e1ea1127489fd281_0000000000003fc9_ps.txt Normal file
View File

@ -0,0 +1,191 @@
#version 450
#extension GL_ARB_texture_gather : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader e1ea1127489fd281 // horizon
#ifdef VULKAN
layout(set = 1, binding = 2) uniform ufBlock
{
uniform ivec4 uf_remappedPS[5];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[5];
uniform vec2 uf_fragCoordScale;
#endif
const float skyboxRed = float($skyboxRed);
const float skyboxGreen = float($skyboxGreen);
const float skyboxBlue = float($skyboxBlue);
const float skyboxMix = float($skyboxMix);
TEXTURE_LAYOUT(1, 1, 0) uniform sampler2D textureUnitPS1;
TEXTURE_LAYOUT(2, 1, 1) uniform sampler2D textureUnitPS2;
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;
// uf_fragCoordScale was moved to the ufBlock
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 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*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);
}

192
src/WindWakerHD/Enhancements/Contrasty/ef821134ed8dd294_0000000000003fc9_ps.txt Normal file
View File

@ -0,0 +1,192 @@
#version 450
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// 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);
#ifdef VULKAN
layout(set = 1, binding = 2) uniform ufBlock
{
uniform ivec4 uf_remappedPS[5];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[5];
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(1, 1, 0) uniform sampler2D textureUnitPS1;
TEXTURE_LAYOUT(2, 1, 1) uniform sampler2D textureUnitPS2;
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;
// uf_fragCoordScale was moved to the ufBlock
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);
}

84
src/WindWakerHD/Enhancements/Contrasty/f1a49f43d95bec30_00000000000000ff_ps.txt Normal file
View File

@ -0,0 +1,84 @@
#version 450
#extension GL_ARB_texture_gather : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader f1a49f43d95bec30 //skybox
const float skyboxRed = float($skyboxRed);
const float skyboxGreen = float($skyboxGreen);
const float skyboxBlue = float($skyboxBlue);
const float skyboxMix = float($skyboxMix);
#ifdef VULKAN
layout(set = 1, binding = 0) uniform ufBlock
{
uniform ivec4 uf_remappedPS[2];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[2];
uniform vec2 uf_fragCoordScale;
#endif
layout(location = 0) out vec4 passPixelColor0;
layout(location = 1) out vec4 passPixelColor1;
// uf_fragCoordScale was moved to the ufBlock
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);
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;
// 0
R1f.x = (intBitsToFloat(uf_remappedPS[0].z) * 0.5 + 0.5);
R0f.y = intBitsToFloat(uf_remappedPS[1].y);
R1f.z = 0.0;
R0f.w = 0.0;
R0f.x = intBitsToFloat(uf_remappedPS[1].x);
PS0f = R0f.x;
// 1
R0f.z = intBitsToFloat(uf_remappedPS[1].z);
PV1f.z = R0f.z;
// 2
R2f.xyz = vec3(R0f.x,R0f.y,PV1f.z);
R2f.w = R0f.w;
// 3
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*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);
}

314
src/WindWakerHD/Enhancements/Contrasty/ff71dcd2ad4defdc_00000000000003c9_ps.txt Normal file
View File

@ -0,0 +1,314 @@
#version 450
#extension GL_ARB_texture_gather : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader ff71dcd2ad4defdc
//AA ps
#ifdef VULKAN
layout(set = 1, binding = 2) uniform ufBlock
{
uniform ivec4 uf_remappedPS[4];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[4];
uniform vec2 uf_fragCoordScale;
#endif
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
const float vibrance = $vibrance; // 0.0 is neutral
const float crushContrast = $crushContrast; // 0.0 is neutral. Use small increments, loss of shadow detail
const float contrastCurve = $contrastCurve;
vec3 RGB_Lift = vec3($redShadows, $greenShadows , $blueSadows); // [0.000 to 2.000] Adjust shadows for Red, Green and Blue.
vec3 RGB_Gamma = vec3($redMid ,$greenMid, $blueMid); // [0.000 to 2.000] Adjust midtones for Red, Green and Blue
vec3 RGB_Gain = vec3($redHilight, $greenHilight, $blueHilight); // [0.000 to 2.000] Adjust highlights for Red, Green and Blue
//lumasharpen
const float sharp_mix = $sharp_mix;
const float sharp_strength = 2.0;
const float sharp_clamp = 0.75;
const float offset_bias = 1.0;
float Sigmoid (float x) {
return 1.0 / (1.0 + (exp(-(x - 0.5) * 5.5)));
}
#define px (1.0/1920.0*uf_fragCoordScale.x)
#define py (1.0/1080.0*uf_fragCoordScale.y)
#define CoefLuma vec3(0.2126, 0.7152, 0.0722)
float lumasharping(sampler2D tex, vec2 pos) {
vec4 colorInput = texture(tex, pos);
vec3 ori = colorInput.rgb;
// -- Combining the strength and luma multipliers --
vec3 sharp_strength_luma = (CoefLuma * sharp_strength);
// -- Gaussian filter --
// [ .25, .50, .25] [ 1 , 2 , 1 ]
// [ .50, 1, .50] = [ 2 , 4 , 2 ]
// [ .25, .50, .25] [ 1 , 2 , 1 ]
vec3 blur_ori = texture(tex, pos + vec2(px, -py) * 0.5 * offset_bias).rgb; // South East
blur_ori += texture(tex, pos + vec2(-px, -py) * 0.5 * offset_bias).rgb; // South West
blur_ori += texture(tex, pos + vec2(px, py) * 0.5 * offset_bias).rgb; // North East
blur_ori += texture(tex, pos + vec2(-px, py) * 0.5 * offset_bias).rgb; // North West
blur_ori *= 0.25; // ( /= 4) Divide by the number of texture fetches
// -- Calculate the sharpening --
vec3 sharp = ori - blur_ori; //Subtracting the blurred image from the original image
// -- Adjust strength of the sharpening and clamp it--
vec4 sharp_strength_luma_clamp = vec4(sharp_strength_luma * (0.5 / sharp_clamp), 0.5); //Roll part of the clamp into the dot
float sharp_luma = clamp((dot(vec4(sharp, 1.0), sharp_strength_luma_clamp)), 0.0, 1.0); //Calculate the luma, adjust the strength, scale up and clamp
sharp_luma = (sharp_clamp * 2.0) * sharp_luma - sharp_clamp; //scale down
return sharp_luma;
}
vec3 LiftGammaGainPass(vec3 colorInput)
{ //reshade BSD https://reshade.me , Alexkiri port
vec3 color = colorInput;
color = color * (1.5 - 0.5 * RGB_Lift) + 0.5 * RGB_Lift - 0.5;
color = clamp(color, 0.0, 1.0);
color *= RGB_Gain;
color = pow(color, 1.0 / RGB_Gamma);
return clamp(color, 0.0, 1.0);
}
vec3 contrasty(vec3 colour){
vec3 fColour = (colour.xyz);
//fColour = LiftGammaGainPass(fColour);
fColour = clamp(exposure * fColour, 0.0, 1.0);
fColour = pow(fColour, vec3(1.0 / gamma));
float luminance = fColour.r*0.299 + fColour.g*0.587 + fColour.b*0.114;
float mn = min(min(fColour.r, fColour.g), fColour.b);
float mx = max(max(fColour.r, fColour.g), fColour.b);
float sat = (1.0 - (mx - mn)) * (1.0 - mx) * luminance * 5.0;
vec3 lightness = vec3((mn + mx) / 2.0);
fColour = LiftGammaGainPass(fColour);
// vibrance
fColour = mix(fColour, mix(fColour, lightness, -vibrance), sat);
fColour = max(vec3(0.0), fColour - vec3(crushContrast));
return fColour;
}
const float resScale = 2.0;
// uf_remappedPS[4] was moved to the ufBlock
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1;
layout(location = 0) in vec4 passParameterSem2;
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 R123f = 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;
bool activeMaskStack[2];
bool activeMaskStackC[3];
activeMaskStack[0] = false;
activeMaskStackC[0] = false;
activeMaskStackC[1] = false;
activeMaskStack[0] = true;
activeMaskStackC[0] = true;
activeMaskStackC[1] = true;
vec3 cubeMapSTM;
int cubeMapFaceId;
R0f = passParameterSem2;
if( activeMaskStackC[1] == true ) {
R1f.xyzw = (textureGather(textureUnitPS1, R0f.xy).wzxy);
R2f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
}
if( activeMaskStackC[1] == true ) {
activeMaskStack[1] = activeMaskStack[0];
activeMaskStackC[2] = activeMaskStackC[1];
// 0
PV0f.x = R1f.y + R1f.x;
R127f.y = intBitsToFloat(uf_remappedPS[0].z) * 0.25;
PV0f.z = R1f.w + -(R1f.x);
PV0f.w = R1f.z + -(R1f.y);
R127f.z = mul_nonIEEE(R2f.x, intBitsToFloat(uf_remappedPS[1].x));
PS0f = R127f.z;
// 1
R127f.x = PV0f.w + -(PV0f.z);
PV1f.x = R127f.x;
R126f.y = PV0f.w + PV0f.z;
PV1f.y = R126f.y;
PV1f.z = R1f.z + PV0f.x;
R127f.w = min(R1f.z, R1f.x);
R126f.w = min(R1f.w, R1f.y);
PS1f = R126f.w;
// 2
PV0f.x = R1f.w + PV1f.z;
PV0f.y = max(PV1f.x, -(PV1f.x));
PV0f.z = max(PV1f.y, -(PV1f.y));
PV0f.w = max(R1f.z, R1f.x);
PS0f = max(R1f.w, R1f.y);
// 3
PV1f.x = min(PV0f.z, PV0f.y);
R123f.y = (mul_nonIEEE(R2f.y,intBitsToFloat(uf_remappedPS[1].y)) + R127f.z);
PV1f.y = R123f.y;
R127f.z = min(R127f.w, R126f.w);
PV1f.z = R127f.z;
R123f.w = (mul_nonIEEE(R127f.y,PV0f.x) + intBitsToFloat(uf_remappedPS[0].w));
PV1f.w = R123f.w;
R127f.w = max(PV0f.w, PS0f);
PS1f = R127f.w;
// 4
PV0f.x = mul_nonIEEE(PS1f, intBitsToFloat(uf_remappedPS[2].x));
PV0f.y = max(PV1f.y, PS1f);
PV0f.z = min(PV1f.y, PV1f.z);
PV0f.w = max(PV1f.w, PV1f.x);
R4f.z = -(PV1f.z) + PS1f;
PS0f = R4f.z;
// 5
R3f.x = max(PV0f.x, intBitsToFloat(uf_remappedPS[2].y));
R3f.y = -(PV0f.z) + PV0f.y;
R4f.w = R127f.z + R127f.w;
PS1f = 1.0 / PV0f.w;
// 6
PV0f.x = mul_nonIEEE(R127f.x, PS1f); //p
PV0f.y = mul_nonIEEE(R126f.y, PS1f);
// 7
PV1f.z = max(PV0f.x, -(intBitsToFloat(uf_remappedPS[0].y))); //p
PV1f.w = max(PV0f.y, -(intBitsToFloat(uf_remappedPS[0].y)));
// 8
R1f.x = min(PV1f.w, intBitsToFloat(uf_remappedPS[0].y));
R1f.y = min(PV1f.z, intBitsToFloat(uf_remappedPS[0].y));
// 9
predResult = (R3f.y > R3f.x);
activeMaskStack[1] = predResult;
activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true;
}
else {
activeMaskStack[1] = false;
activeMaskStackC[2] = false;
}
if( activeMaskStackC[2] == true ) {
// 0
R3f.x = (mul_nonIEEE(R1f.x,-(intBitsToFloat(uf_remappedPS[3].z) / resScale)) + R0f.x);
R3f.y = (mul_nonIEEE(R1f.y,-(intBitsToFloat(uf_remappedPS[3].w) / resScale)) + R0f.y);
R0f.z = (mul_nonIEEE(R1f.x,intBitsToFloat(uf_remappedPS[3].z)) + R0f.x); //leave out, looks better on avg
R0f.w = (mul_nonIEEE(R1f.y,intBitsToFloat(uf_remappedPS[3].w)) + R0f.y);//leave out, looks better on avg
R4f.x = (mul_nonIEEE(R1f.x,-(intBitsToFloat(uf_remappedPS[3].x) / resScale)) + R0f.x);
PS0f = R4f.x;
// 1
R4f.y = (mul_nonIEEE(R1f.y,-(intBitsToFloat(uf_remappedPS[3].y)/resScale)) + R0f.y);
R3f.z = (mul_nonIEEE(R1f.x,intBitsToFloat(uf_remappedPS[3].x) / resScale) + R0f.x);
R3f.w = (mul_nonIEEE(R1f.y,intBitsToFloat(uf_remappedPS[3].y) / resScale) + R0f.y);
}
if( activeMaskStackC[2] == true ) {
R1f.xyzw = (texture(textureUnitPS0, R0f.zw).xyzw);
R0f.xyzw = (texture(textureUnitPS0, R3f.xy).xyzw);
R2f.xyzw = (texture(textureUnitPS0, R4f.xy).xyzw);
R3f.xyzw = (texture(textureUnitPS0, R3f.zw).xyzw);
}
if( activeMaskStackC[2] == true ) {
// 0
R127f.xyz = vec3(R0f.x,R0f.w,R0f.z) + vec3(R1f.x,R1f.w,R1f.z);
PV0f.x = R127f.x;
PV0f.y = R127f.y;
PV0f.z = R127f.z;
R127f.w = R0f.y + R1f.y;
PV0f.w = R127f.w;
// 1
PV1f.x = R2f.x + PV0f.x;
PV1f.y = R2f.w + PV0f.y;
PV1f.z = R2f.z + PV0f.z;
PV1f.w = R2f.y + PV0f.w;
// 2
R126f.x = R3f.x + PV1f.x;
R126f.x /= 2.0;
PV0f.x = R126f.x;
R126f.y = R3f.w + PV1f.y;
R126f.y /= 2.0;
PV0f.y = R126f.y;
R126f.z = R3f.z + PV1f.z;
R126f.z /= 2.0;
PV0f.z = R126f.z;
R126f.w = R3f.y + PV1f.w;
R126f.w /= 2.0;
PV0f.w = R126f.w;
// 3
backupReg0f = R127f.y;
R123f.x = (mul_nonIEEE(PV0f.x,intBitsToFloat(uf_remappedPS[1].x)) + -(R4f.w));
PV1f.x = R123f.x;
R127f.yzw = vec3(R127f.z,R127f.w,R127f.x) + vec3(-(PV0f.z),-(PV0f.w),-(PV0f.x));
R127f.x = backupReg0f + -(PV0f.y);
PS1f = R127f.x;
// 4
R123f.w = (mul_nonIEEE(R126f.w,intBitsToFloat(uf_remappedPS[1].y)) + PV1f.x);
PV0f.w = R123f.w;
// 5
PV1f.z = max(PV0f.w, -(PV0f.w));
// 6
PV0f.y = -(R4f.z) + PV1f.z;
// 7
R123f.x = intBitsToFloat(((PV0f.y >= 0.0)?(floatBitsToInt(1.0)):(0)));
PV1f.x = R123f.x;
// 8
R2f.x = (mul_nonIEEE(R127f.w,PV1f.x) + R126f.x)/2.0;
R2f.y = (mul_nonIEEE(R127f.z,PV1f.x) + R126f.w)/2.0;
R2f.z = (mul_nonIEEE(R127f.y,PV1f.x) + R126f.z)/2.0;
R2f.w = (mul_nonIEEE(R127f.x,PV1f.x) + R126f.y)/2.0;
}
activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true;
// export
R2f.xyz = contrasty(R2f.xyz);
R2f.xyz = mix(R2f.xyz, smoothstep(0.0, 1.0, R2f.xyz), contrastCurve);
float smask = lumasharping(textureUnitPS1, passParameterSem2.xy);
vec3 temp3 = R2f.xyz;
R2f.xyz = mix(R2f.xyz, (temp3.xyz += (smask)), sharp_mix);
passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
}

183
src/WindWakerHD/Enhancements/Contrasty/rules.txt Normal file
View File

@ -0,0 +1,183 @@
[Definition]
titleIds = 0005000010143400,0005000010143500,0005000010143600,000500010185400
name = Contrasty v1.1
path = "The Legend of Zelda: The Wind Waker HD/Enhancements/Contrasty"
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.|Made by getdls.
#Credits: getdls
version = 6
[Default]
$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 = 1.0
$exposure = 1.0
$vibrance = 0.0
$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 = Default
[Preset]
name = Less sky bloom
$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.2
$hazeFactor = 1.0
$bloom = 1.0
$gamma = 1.05
$exposure = 1.0
$vibrance = 0.0
$crushContrast = 0.0
$bleach = 1.0
$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
$redShadows = 1.0
$greenShadows = 1.0
$blueSadows = 1.0
$redMid = 0.99
$greenMid = 0.99
$blueMid = 0.99
$redHilight = 1.1
$greenHilight =1.0
$blueHilight = 1.0
$contrastCurve = 0.4
$hazeFactor = 0.25
$bloom = 0.85
$gamma = 0.98
$exposure = 1.01
$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 = 1.0
$greenMid = 0.99
$blueMid = 1.0
$redHilight = 1.0
$greenHilight =0.99
$blueHilight = 1.0
$contrastCurve = 0.275
$hazeFactor = 0.25
$bloom = 0.85
$gamma = 0.975
$exposure = 1.01
$vibrance = 0.45
$crushContrast = 0.00
$bleach = 0.85
$sharp_mix = 0.0
$skyboxRed = 1.0
$skyboxGreen = 1.0
$skyboxBlue = 1.0
$skyboxMix = 0.9
$AO = 1.0
$beach = 1.0
[Preset]
name = Gamecube style
$redShadows = 1.01
$greenShadows = 1.01
$blueSadows = 1.01
$redMid = 1.0
$greenMid = 1.0
$blueMid = 1.0
$redHilight = 0.99
$greenHilight =0.99
$blueHilight = 0.99
$contrastCurve = 0.25
$hazeFactor = 1.0
$bloom = 0.95
$gamma = 0.95
$exposure = 1.0
$vibrance = 0.175
$crushContrast = 0.00
$bleach = 0.85
$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

98
src/WindWakerHD/Enhancements/LODBias/rules.txt Normal file
View File

@ -0,0 +1,98 @@
[Definition]
titleIds = 0005000010143400,0005000010143500,0005000010143600,000500010185400
name = Negative texture LOD bias
path = "The Legend of Zelda: The Wind Waker HD/Enhancements/Negative Texture LOD"
description = Texture LOD override, possible shimmer but sharper textures.
#Credits: getdls
version = 6
[Default]
$0x031 = 0
$0x033 = 0
$0x034 = 0
$0x035 = 0
$0x431 = 0
$0x432 = 0
$0x433 = 0
$0x434 = 0
[Preset] #16x Anisotropic filter makes (ocean) textures to sharp, they should fade to blur.
name = +2 LOD 34 smooth ocean mipmap transition.
$0x031 = 0
$0x033 = 0
$0x034 = +2
$0x035 = 0
$0x431 = 0
$0x432 = 0
$0x433 = 0
$0x434 = 0
[Preset]
name = LOD Default
default = 1
[Preset]
name = LOD -0.5 (Sharper)
$0x031 = -.5
$0x033 = -.5
$0x034 = -.5
$0x035 = -.5
$0x431 = -.5
$0x432 = -.5
$0x433 = -.5
$0x434 = -.5
[Preset]
name = LOD -1 (Super Sharp)
$0x031 = -1
$0x033 = -1
$0x034 = -1
$0x035 = -1
$0x431 = -1
$0x432 = -1
$0x433 = -1
$0x434 = -1
[Preset]
name = LOD -4 (Overkill - For screenshots)
$0x031 = -4
$0x033 = -4
$0x034 = -4
$0x035 = -4
$0x431 = -4
$0x432 = -4
$0x433 = -4
$0x434 = -4
[TextureRedefine]
formats = 0x031 #
overwriteRelativeLodBias = $0x031
[TextureRedefine]#Per format, possible to have separate scaling if needed
formats = 0x033
overwriteRelativeLodBias = $0x033
[TextureRedefine]
formats = 0x034
overwriteRelativeLodBias = $0x034
[TextureRedefine]
formats = 0x035
overwriteRelativeLodBias = $0x035
[TextureRedefine]
formats = 0x431
overwriteRelativeLodBias = $0x431
[TextureRedefine]
formats = 0x432
overwriteRelativeLodBias = $0x432
[TextureRedefine]
formats = 0x433
overwriteRelativeLodBias = $0x433
[TextureRedefine]
formats = 0x434
overwriteRelativeLodBias = $0x434

323
src/WindWakerHD/Enhancements/NoSSAO/c2cae30e906be2d5_0000000000001e49_ps.txt Normal file
View File

@ -0,0 +1,323 @@
#version 450
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader c2cae30e906be2d5
// Wind Waker - NoSSAO
#ifdef VULKAN
layout(set = 1, binding = 3) uniform ufBlock
{
uniform ivec4 uf_remappedPS[8];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[8];
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1;
TEXTURE_LAYOUT(2, 1, 2) uniform sampler2D textureUnitPS2;
layout(location = 0) in vec4 passParameterSem1;
layout(location = 0) out vec4 passPixelColor0;
// uf_fragCoordScale was moved to the ufBlock
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);
// 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);
passPixelColor0.r = 1.0;
}

7
src/WindWakerHD/Enhancements/NoSSAO/rules.txt Normal file
View File

@ -0,0 +1,7 @@
[Definition]
titleIds = 0005000010143400,0005000010143500,0005000010143600,000500010185400
name = No SSAO
path = "The Legend of Zelda: The Wind Waker HD/Enhancements/No SSAO"
description = Removes the SSAO of the game, which are these little blurred shadows around Link when you're standing under a tree, for example.
#Credits: MelonSpeedruns
version = 6

84
src/WindWakerHD/Enhancements/RemoveAA/ff71dcd2ad4defdc_00000000000003c9_ps.txt Normal file
View File

@ -0,0 +1,84 @@
#version 450
#extension GL_ARB_texture_gather : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
#ifdef VULKAN
layout(set = 1, binding = 1) uniform ufBlock
{
uniform ivec4 uf_remappedPS[5];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[5];
uniform vec2 uf_fragCoordScale;
#endif
//// shader ff71dcd2ad4defdc
//uniform ivec4 uf_remappedPS[4];
//layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5807800 res 1920x1080x1 dim 1 tm: 4 format 0019 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 0xf4000800 res 1920x1080x1 dim 1 tm: 4 format 0001 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1
//layout(location = 0) in vec4 passParameterSem2;
//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 R123f = 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;
//bool activeMaskStack[2];
//bool activeMaskStackC[3];
//activeMaskStack[0] = false;
//activeMaskStackC[0] = false;
//activeMaskStackC[1] = false;
//activeMaskStack[0] = true;
//activeMaskStackC[0] = true;
//activeMaskStackC[1] = true;
//vec3 cubeMapSTM;
//int cubeMapFaceId;
//R0f = passParameterSem2;
////R1f.xyzw = (textureGather(textureUnitPS1, R0f.xy).wzxy);
//R2f.xyzw= (texture(textureUnitPS0, R0f.xy).xyzw);
//passPixelColor0 = R2f.xyzw;
//}

7
src/WindWakerHD/Enhancements/RemoveAA/rules.txt Normal file
View File

@ -0,0 +1,7 @@
[Definition]
titleIds = 0005000010143400,0005000010143500,0005000010143600,000500010185400
name = Remove Anti-Aliasing
path = "The Legend of Zelda: The Wind Waker HD/Enhancements/Remove AA"
description = Dissable the game's native AA.
#Credits: getdls
version = 6

106
src/WindWakerHD/Graphics/1f83c0d47b1c4c34_0000000000000000_vs.txt Normal file
View File

@ -0,0 +1,106 @@
#version 450
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader 1f83c0d47b1c4c34 //box downscale
const float resXScale = (float($height)/float($gameHeight));
const float resYScale = (float($width)/float($gameWidth));
#ifdef VULKAN
layout(set = 0, binding = 0) uniform ufBlock
{
uniform ivec4 uf_remappedVS[1];
// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7
};
#else
uniform ivec4 uf_remappedVS[1];
// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7
#endif
// uf_windowSpaceToClipSpaceTransform was moved to the ufBlock
ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
out gl_PerVertex
{
vec4 gl_Position;
float gl_PointSize;
};
layout(location = 0) out vec4 passParameterSem3;
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);
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 = intBitsToFloat(0xbf800000);
R1f.w = 1.0;
PS0f = R2f.x + -(intBitsToFloat(uf_remappedVS[0].x)/resYScale); //vert
// 1
backupReg0f = R2f.y;
backupReg1f = R2f.x;
PV1f.x = R2f.y + -(intBitsToFloat(uf_remappedVS[0].y)/resXScale); //horiz
R2f.y = backupReg0f + intBitsToFloat(uf_remappedVS[0].y)/resXScale; //horiz
R2f.z = PS0f;
R2f.x = backupReg1f + intBitsToFloat(uf_remappedVS[0].x)/resYScale; //vert
PS1f = R2f.x;
// 2
R2f.w = PV1f.x;
// export
SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w));
// export
passParameterSem3 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
// 0
}

115
src/WindWakerHD/Graphics/4ffa96d07cd53c34_0000000000000000_vs.txt Normal file
View File

@ -0,0 +1,115 @@
#version 450
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader 4ffa96d07cd53c34
const float resXScale = (float($height)/float($gameHeight));
const float resYScale = (float($height)/float($gameHeight));
//box low res (bloom?)
#ifdef VULKAN
layout(set = 0, binding = 0) uniform ufBlock
{
uniform ivec4 uf_remappedVS[1];
// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7
};
#else
uniform ivec4 uf_remappedVS[1];
// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7
#endif
// uf_windowSpaceToClipSpaceTransform was moved to the ufBlock
ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
out gl_PerVertex
{
vec4 gl_Position;
float gl_PointSize;
};
layout(location = 0) out vec4 passParameterSem0;
layout(location = 1) 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){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 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)));
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;
R127f.x = R2f.y + intBitsToFloat(uf_remappedVS[0].w)/resYScale; //vert
PS0f = R127f.x;
// 1
backupReg0f = R2f.x;
backupReg1f = R2f.y;
backupReg0f = R2f.x;
R2f.x = backupReg0f + intBitsToFloat(uf_remappedVS[0].z)/resXScale;//hz right
R2f.y = PS0f;
PV1f.z = backupReg1f + -(intBitsToFloat(uf_remappedVS[0].w)/resYScale); ///vert
R0f.x = backupReg0f + -(intBitsToFloat(uf_remappedVS[0].z)/resXScale); //hz left
PS1f = R0f.x;
// 2
R0f.y = R127f.x;
R0f.z = PV1f.z;
R2f.w = PV1f.z;
// export
SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w));
// export
passParameterSem0 = vec4(R2f.x, R2f.y, R2f.x, R2f.w);
// export
passParameterSem1 = vec4(R0f.x, R0f.y, R0f.x, R0f.z);
// 0
}

128
src/WindWakerHD/Graphics/842a19b509f8b91a_0000000000000000_vs.txt Normal file
View File

@ -0,0 +1,128 @@
#version 450
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader 842a19b509f8b91a //vertical pass bloom
const float resYScale = (float($height)/float($gameHeight));
#ifdef VULKAN
layout(set = 0, binding = 0) uniform ufBlock
{
uniform ivec4 uf_remappedVS[1];
// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7
};
#else
uniform ivec4 uf_remappedVS[1];
// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7
#endif
// uf_windowSpaceToClipSpaceTransform was moved to the ufBlock
ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
out gl_PerVertex
{
vec4 gl_Position;
float gl_PointSize;
};
layout(location = 0) out vec4 passParameterSem0;
layout(location = 1) out vec4 passParameterSem1;
layout(location = 2) out vec4 passParameterSem2;
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 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)));
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 = intBitsToFloat(uf_remappedVS[0].y) * intBitsToFloat(0x3fb13a93)/resYScale; // center
// 1
PV1f.x = intBitsToFloat(uf_remappedVS[0].y) * intBitsToFloat(0x404ec4f0)/resYScale; //wide
R127f.y = intBitsToFloat(uf_remappedVS[0].y) * intBitsToFloat(0x40a275f7)/resYScale; //Low res pass, not first
R2f.z = R2f.y + PS0f;
PV1f.z = R2f.z;
R2f.w = R2f.y;
PV1f.w = R2f.w;
R0f.y = R2f.y + -(PS0f);
PS1f = R0f.y;
// 2
R0f.x = R2f.x;
R3f.y = R2f.y + -(PV1f.x);
R0f.z = PV1f.z;
R0f.w = PV1f.w;
R2f.z = R2f.y + PV1f.x;
PS0f = R2f.z;
// 3
R3f.x = R2f.x;
R4f.y = R2f.y + -(R127f.y);
R3f.z = PS0f;
R3f.w = R2f.y;
R2f.z = R2f.y + R127f.y;
PS1f = R2f.z;
// 4
R4f.xzw = vec3(R2f.x,PS1f,R2f.y);
// export
SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w));
// export
passParameterSem0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
// export
passParameterSem1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
// export
passParameterSem2 = vec4(R4f.x, R4f.y, R4f.z, R4f.w);
// 0
}

126
src/WindWakerHD/Graphics/8d68a0e3561ff525_0000000000000000_vs.txt Normal file
View File

@ -0,0 +1,126 @@
#version 450
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#define gl_VertexID gl_VertexIndex
#define gl_InstanceID gl_InstanceIndex
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define SET_POSITION(_v) gl_Position = _v
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
// shader 8d68a0e3561ff525 //horiztontal bloom pass
const float resXScale = (float($width)/float($gameWidth));
#ifdef VULKAN
layout(set = 0, binding = 0) uniform ufBlock
{
uniform ivec4 uf_remappedVS[1];
// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7
};
#else
uniform ivec4 uf_remappedVS[1];
// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7
#endif
// uf_windowSpaceToClipSpaceTransform was moved to the ufBlock
ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
out gl_PerVertex
{
vec4 gl_Position;
float gl_PointSize;
};
layout(location = 1) out vec4 passParameterSem1;
layout(location = 2) out vec4 passParameterSem2;
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 R2f = vec4(0.0);
vec4 R3f = 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)));
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;
R127f.y = intBitsToFloat(uf_remappedVS[0].x) * intBitsToFloat(0x3fb13a93)/resXScale;//center pass
PS0f = R127f.y;
// 1
PV1f.x = intBitsToFloat(uf_remappedVS[0].x) * intBitsToFloat(0x404ec4f0)/resXScale; //wide pass
R126f.y = intBitsToFloat(uf_remappedVS[0].x) * intBitsToFloat(0x40a275f7) /resXScale; //nothing on first pass
R3f.z = R2f.x + PS0f;
R3f.w = R2f.x;
R3f.x = R2f.y;
PS1f = R3f.x;
// 2
R0f.x = PS1f;
R3f.y = R2f.x + -(R127f.y);
R0f.z = R2f.x + PV1f.x;
R0f.w = R2f.x;
R0f.y = R2f.x + -(PV1f.x);
PS0f = R0f.y;
// 3
backupReg0f = R2f.x;
backupReg0f = R2f.x;
backupReg0f = R2f.x;
R2f.x = R3f.x;
R2f.y = backupReg0f + -(R126f.y);
R2f.z = backupReg0f + R126f.y;
R2f.w = backupReg0f;
// export
SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w));
// export
passParameterSem1 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
// export
passParameterSem2 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
// export
passParameterSem0 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
// 0
}

43
src/WindWakerHD/Graphics/WWHD_Readme.md Normal file
View File

@ -0,0 +1,43 @@
------
### TLoZ Wind Waker HD
------
### Graphic options
3840x4320 vert x2 SSAA - light res x2
3840x4320 vert x2 SSAA - Runs the game at double vertical res balancing look and performance when super sampling. Aspect is still 16:9 so run full screen scaling in stretched and bilinear when activating this option.
Light res x2 - Doubles resolution of light sources and mitigate light haloing around object edges.
### Nice to know when creating a custom resolution
There are some issues with AO and light sources, to mitigate this some “sub” viewports need 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)
```
[TextureRedefine]
width = 1024
height = 544
formats = 0x001
overwriteWidth = ($width/$gameWidth) * (1024*$lightSource*$scaleShader)
overwriteHeight = ($height/$gameHeight) * (544*$lightSource)
```

17
src/WindWakerHD/Graphics/patch_resolution.asm Normal file
View File

@ -0,0 +1,17 @@
[WindWakerHD_Aspect_EU]
moduleMatches = 0xB7E748DE ; (EU)
0x1004AAF0 = .float ($aspectRatio)
0x101417E0 = .float ($aspectRatio)
0x101658A8 = .float ($aspectRatio)
[WindWakerHD_Aspect_NA]
moduleMatches = 0x475BD29F ; (NA)
0x1004AAF0 = .float ($aspectRatio)
0x101417D0 = .float ($aspectRatio)
0x10165898 = .float ($aspectRatio)
[WindWakerHD_Aspect_JP]
moduleMatches = 0x74BD3F6A ; (JP)
0x1004AAF0 = .float ($aspectRatio)
0x101417F8 = .float ($aspectRatio)
0x101658C0 = .float ($aspectRatio)

564
src/WindWakerHD/Graphics/rules.txt Normal file
View File

@ -0,0 +1,564 @@
[Definition]
titleIds = 0005000010143400,0005000010143500,0005000010143600,000500010185400
name = Graphics Settings
path = "The Legend of Zelda: The Wind Waker HD/Graphics"
description = Changes the resolution of the game and shadow quality.|Made by getdls and Morph.
#Credits: getdls, Morph, NineKain
version = 6
[Default]
$width = 1920
$height = 1080
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
$shadowRes = 1
$anisoLevel = 1
[Preset]
category = Resolution
name = 320x180
$width = 320
$height = 180
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
name = 640x360
$width = 640
$height = 360
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
name = 960x540
$width = 960
$height = 540
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
name = 1280x720
$width = 1280
$height = 720
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
name = 1600x900
$width = 1600
$height = 900
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
name = 1920x1080 (Default)
default = 1
[Preset]
category = Resolution
name = 2560x1440
$width = 2560
$height = 1440
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
name = 2732x1536
$width = 2732
$height = 1536
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
name = 3200x1800
$width = 3200
$height = 1800
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
name = 3840x2160
$width = 3840
$height = 2160
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
name = 5120x2880
$width = 5120
$height = 2880
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
name = 7680x4320
$width = 7680
$height = 4320
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 1.0
$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]
category = Resolution
name = ---- Ultra wide 21:9 ----
$width = 2560
$height = 1080
$gameWidth= 1920
$gameHeight= 1080
$lightSource = 2.0
$scaleShader = (1920.0/2560.0)
$aspectRatio = (64.0/27.0) #LG
[Preset]
category = Resolution
name = 2560x1080 (21:9 HD)
$width = 2560
$height = 1080
$gameWidth= 1920
$gameHeight= 1080
$lightSource = 2.0
$scaleShader = (1920.0/2560.0)
$aspectRatio = (64.0/27.0) #LG
[Preset]
category = Resolution
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)
[Preset]
category = Resolution
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]
category = Resolution
name = 5160x2160 (4k 21:9)
$width = 5160
$height = 2160
$gameWidth= 1920
$gameHeight= 1080
$lightSource = 1.0
$scaleShader = (3840.0/5160.0)
$aspectRatio = (64.0/27.0) #LG
[Preset]
category = Resolution
name = ---- Superwide 32:9 ----
$width = 5120
$height = 1440
$gameWidth= 1920
$gameHeight= 1080
$lightSource = 1.5
$scaleShader = (2560.0/5120.0)
$aspectRatio = (96.0/27.0)
[Preset]
category = Resolution
name = 5120x1440 (32:9)
$width = 5120
$height = 1440
$gameWidth= 1920
$gameHeight= 1080
$lightSource = 1.5
$scaleShader = (2560.0/5120.0)
$aspectRatio = (96.0/27.0)
[Preset]
category = Resolution
name = 7680x2160 (4k 32:9)
$width = 7680
$height = 2160
$gameWidth= 1920
$gameHeight= 1080
$lightSource = 1.0
$scaleShader = (3840.0/7680.0)
$aspectRatio = (96.0/27.0)
[Preset]
category = Resolution
name = ---- Custom resolutions ----
$width = 1920
$height = 1080
$gameWidth = 1920
$gameHeight = 1080
$lightSource = 2.0
$scaleShader = 1.0
$aspectRatio = (16.0/9.0)
[Preset]
category = Resolution
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]
category = Resolution
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]
category = Resolution
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]
category = Resolution
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]
category = Resolution
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)
[Preset]
category = Shadow Quality
name = Low (50%)
$shadowRes = 0.5
[Preset]
category = Shadow Quality
name = Medium (100%, Default)
default = 1
[Preset]
category = Shadow Quality
name = High (200%)
$shadowRes = 2
[Preset]
category = Shadow Quality
name = Ultra (300%)
$shadowRes = 3
[Preset]
category = Shadow Quality
name = Extreme (400%, Unstable)
$shadowRes = 4
[Preset]
category = Anisotropic Filtering
name = 1x (Default)
Default = 1
[Preset]
category = Anisotropic Filtering
name = 2x
$anisoLevel = 2
[Preset]
category = Anisotropic Filtering
name = 4x
$anisoLevel = 4
[Preset]
category = Anisotropic Filtering
name = 8x
$anisoLevel = 8
[Preset]
category = Anisotropic Filtering
name = 16x (Recommended)
$anisoLevel = 16
[Preset]
category = Anisotropic Filtering
name = 32x (Overkill)
$anisoLevel = 32
## Colour depth increase - Didn't see any visual improvement.
#
#[TextureRedefine]
#formats = 0x001
#overwriteFormat = 0x005
#
#[TextureRedefine]
#formats = 0x01a
#overwriteFormat = 0x01f
#
#[TextureRedefine]
#formats = 0x019
#overwriteFormat = 0x01f
#
#[TextureRedefine]
#formats = 0x806
#overwriteFormat = 0x80e
#
#[TextureRedefine]
#formats = 0x816
#overwriteFormat = 0x820
[TextureRedefine]
formats = 0x31,0x32,0x33,0x34,0x35,0x431,0x432,0x433,0x434,0x435
overwriteAnisotropy = $anisoLevel
[TextureRedefine] # Shadows x3 Lods
width = 1024
height = 1024
formats = 0x005
overwriteWidth = $shadowRes * 1024
overwriteHeight = $shadowRes * 1024
[TextureRedefine]
width = 1920
height = 1088
formats = 0x80e,0x019,0x001
overwriteWidth = ($width/$gameWidth) * 1920
overwriteHeight = ($height/$gameHeight) * 1088
[TextureRedefine]
width = 1920
height = 1080
formats = 0x80e,0x019,0x001
overwriteWidth = ($width/$gameWidth) * 1920
overwriteHeight = ($height/$gameHeight) * 1080
[TextureRedefine]
width = 1024
height = 544
formats = 0x001
overwriteWidth = ($width/$gameWidth) * (1024*$lightSource*$scaleShader)
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,0x001,0x80e
overwriteWidth = ($width/$gameWidth) * (960*$lightSource*$scaleShader)
overwriteHeight = ($height/$gameHeight) * (540*$lightSource)
[TextureRedefine]
width = 864
height = 480
formats = 0x019,0x80e
overwriteWidth = ($width/$gameWidth) * 864
overwriteHeight = ($height/$gameHeight) * 480
[TextureRedefine]
width = 854
height = 480
formats = 0x019,0x80e
overwriteWidth = ($width/$gameWidth) * 854
overwriteHeight = ($height/$gameHeight) * 480
[TextureRedefine] #
width = 512
height = 512
formats = 0x019,0x01a #,0x806
overwriteWidth = ($width/$gameWidth) * (512*$lightSource*$scaleShader)
overwriteHeight = ($height/$gameHeight) * (512*$lightSource)
[TextureRedefine]
width = 480
height = 270
formats = 0x816
overwriteWidth = ($width/$gameWidth) * (480)
overwriteHeight = ($height/$gameHeight) * (270)
[TextureRedefine]
width = 480
height = 272
formats = 0x816
overwriteWidth = ($width/$gameWidth) * (480)
overwriteHeight = ($height/$gameHeight) * (272)
[TextureRedefine] #
width = 256
height = 256
formats = 0x816
overwriteWidth = ($width/$gameWidth) * (256)
overwriteHeight = ($height/$gameHeight) * (256)
[TextureRedefine]
width = 256
height = 144
formats = 0x816,0x01a
overwriteWidth = ($width/$gameWidth) * (256)
overwriteHeight = ($height/$gameHeight) * (144)
[TextureRedefine]
width = 240
height = 135
formats = 0x816,0x01a
overwriteWidth = ($width/$gameWidth) * (240)
overwriteHeight = ($height/$gameHeight) * (135)
[TextureRedefine] #
width = 128
height = 128
formats = 0x816
overwriteWidth = ($width/$gameWidth) * (128)
overwriteHeight = ($height/$gameHeight) * (128)
[TextureRedefine]
width = 128
height = 80
formats = 0x816
overwriteWidth = ($width/$gameWidth) * (128)
overwriteHeight = ($height/$gameHeight) * (80)
[TextureRedefine]
width = 120
height = 67
#formats =
overwriteWidth = ($width/$gameWidth) * (120)
overwriteHeight = ($height/$gameHeight) * (67)
[TextureRedefine] #
width = 64
height = 64
formats = 0x816
overwriteWidth = ($width/$gameWidth) * (64)
overwriteHeight = ($height/$gameHeight) * (64)
[TextureRedefine]
width = 64
height = 48
formats = 0x816
overwriteWidth = ($width/$gameWidth) * (64)
overwriteHeight = ($height/$gameHeight) * (48)
[TextureRedefine]
width = 60
height = 33
#formats =
overwriteWidth = ($width/$gameWidth) * (60)
overwriteHeight = ($height/$gameHeight) * (33)
[TextureRedefine] #Pictograph
width = 1600
height = 912
formats = 0x019
overwriteWidth = ($height/$gameHeight) * 1600
overwriteHeight = ($height/$gameHeight) * 912
[TextureRedefine] #Pictograph
width = 1600
height = 900
formats = 0x019
overwriteWidth = ($height/$gameHeight) * 1600
overwriteHeight = ($height/$gameHeight) * 900
### pictograph. If you try to fix this, verify that saved pictures can be loaded from album.
#
#[TextureRedefine] #pictograph
#width = 832
#height = 450
#formats = 0x01a,080e,0x41a
#overwriteWidth = ($width/$gameWidth) * 832
#overwriteHeight = ($height/$gameHeight) * 450
#
#[TextureRedefine] #pictograph
#width = 800
#height = 464
#formats = 0x01a,080e,0x41a #
#overwriteWidth = ($width/$gameWidth) * 800
#overwriteHeight = ($height/$gameHeight) * 464
#
#[TextureRedefine] #pictograph
#width = 800
#height = 450
#formats = 0x01a,080e,0x41a
#overwriteWidth = ($width/$gameWidth) * 800
#overwriteHeight = ($height/$gameHeight) * 450

65
src/WindWakerHD/Mods/RemoveHUD/2802e519ac163806_0000000000000079_ps.txt Normal file
View File

@ -0,0 +1,65 @@
#version 460
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
// shader 2802e519ac163806
// Used for: Removing the red part of the hearts
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
#ifdef VULKAN
layout(set = 1, binding = 1) uniform ufBlock
{
uniform ivec4 uf_remappedPS[2];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[2];
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
layout(location = 0) in vec4 passParameterSem0;
layout(location = 0) out vec4 passPixelColor0;
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);
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 = passParameterSem0;
R0f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
// 0
R1f.x = (mul_nonIEEE(R0f.x,intBitsToFloat(uf_remappedPS[0].x)) + intBitsToFloat(uf_remappedPS[1].x));
R1f.y = (mul_nonIEEE(R0f.y,intBitsToFloat(uf_remappedPS[0].y)) + intBitsToFloat(uf_remappedPS[1].y));
// 1
R1f.z = (mul_nonIEEE(R0f.z,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[1].z));
R1f.w = (mul_nonIEEE(R0f.w,intBitsToFloat(uf_remappedPS[0].w)) + intBitsToFloat(uf_remappedPS[1].w));
// export
passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, 0.0);
}

100
src/WindWakerHD/Mods/RemoveHUD/62b20d3dab5b31f4_00000000000003c9_ps.txt Normal file
View File

@ -0,0 +1,100 @@
#version 460
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
// shader 62b20d3dab5b31f4
// Used for: Removing the red glanse from the red hearts
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
#ifdef VULKAN
layout(set = 1, binding = 2) uniform ufBlock
{
uniform ivec4 uf_remappedPS[3];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[3];
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1;
layout(location = 0) in vec4 passParameterSem0;
layout(location = 1) in vec4 passParameterSem1;
layout(location = 2) in vec4 passParameterSem2;
layout(location = 0) out vec4 passPixelColor0;
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()
{
ivec4 R0i = ivec4(0);
ivec4 R1i = ivec4(0);
ivec4 R2i = ivec4(0);
ivec4 R123i = ivec4(0);
ivec4 R127i = ivec4(0);
int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i;
ivec4 PV0i = ivec4(0), PV1i = ivec4(0);
int PS0i = 0, PS1i = 0;
ivec4 tempi = ivec4(0);
float tempResultf;
int tempResulti;
ivec4 ARi = ivec4(0);
bool predResult = true;
vec3 cubeMapSTM;
int cubeMapFaceId;
R0i = floatBitsToInt(passParameterSem0);
R1i = floatBitsToInt(passParameterSem1);
R2i = floatBitsToInt(passParameterSem2);
R1i.xyzw = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R1i.xy)).xyzw);
R2i.xyzw = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R2i.xy)).xyzw);
// 0
PV0i.x = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R2i.x), intBitsToFloat(R2i.w)));
PV0i.y = floatBitsToInt(-(intBitsToFloat(R2i.w)) + 1.0);
R127i.z = uf_remappedPS[0].x & 0x00000080;
PV0i.w = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R2i.y), intBitsToFloat(R2i.w)));
PS0i = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R2i.z), intBitsToFloat(R2i.w)));
// 1
R123i.x = floatBitsToInt((mul_nonIEEE(intBitsToFloat(R1i.x),intBitsToFloat(PV0i.y)) + intBitsToFloat(PV0i.x)));
PV1i.x = R123i.x;
PV1i.y = floatBitsToInt(min(intBitsToFloat(R1i.w), intBitsToFloat(R2i.w)));
PV1i.z = floatBitsToInt(max(intBitsToFloat(R1i.w), intBitsToFloat(R2i.w)));
R123i.w = floatBitsToInt((mul_nonIEEE(intBitsToFloat(R1i.y),intBitsToFloat(PV0i.y)) + intBitsToFloat(PV0i.w)));
PV1i.w = R123i.w;
R127i.w = floatBitsToInt((mul_nonIEEE(intBitsToFloat(R1i.z),intBitsToFloat(PV0i.y)) + intBitsToFloat(PS0i)));
PS1i = R127i.w;
// 2
R123i.x = ((R127i.z == 0)?(PV1i.z):(PV1i.y));
PV0i.x = R123i.x;
R127i.z = floatBitsToInt((mul_nonIEEE(intBitsToFloat(PV1i.w),intBitsToFloat(uf_remappedPS[1].y)) + intBitsToFloat(uf_remappedPS[2].y)));
R123i.w = floatBitsToInt((mul_nonIEEE(intBitsToFloat(PV1i.x),intBitsToFloat(uf_remappedPS[1].x)) + intBitsToFloat(uf_remappedPS[2].x)));
PV0i.w = R123i.w;
// 3
R123i.x = floatBitsToInt((mul_nonIEEE(intBitsToFloat(PV0i.x),intBitsToFloat(uf_remappedPS[1].w)) + intBitsToFloat(uf_remappedPS[2].w)));
PV1i.x = R123i.x;
R123i.y = floatBitsToInt((mul_nonIEEE(intBitsToFloat(R127i.w),intBitsToFloat(uf_remappedPS[1].z)) + intBitsToFloat(uf_remappedPS[2].z)));
PV1i.y = R123i.y;
R1i.x = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.x), intBitsToFloat(PV0i.w)));
PS1i = R1i.x;
// 4
R1i.y = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.y), intBitsToFloat(R127i.z)));
R1i.z = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.z), intBitsToFloat(PV1i.y)));
R1i.w = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.w), intBitsToFloat(PV1i.x)));
// export
passPixelColor0 = vec4(intBitsToFloat(R1i.x), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), 0.0);
}

67
src/WindWakerHD/Mods/RemoveHUD/7d7d874efcc7ba4b_0000000000000079_ps.txt Normal file
View File

@ -0,0 +1,67 @@
#version 460
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
// shader 7d7d874efcc7ba4b: textbox continue icon
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.z, 1.0/gl_FragCoord.w)
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
#ifdef VULKAN
layout(set = 1, binding = 1) uniform ufBlock
{
uniform vec4 uf_fragCoordScale;
};
#else
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
layout(location = 0) in vec4 passParameterSem0;
layout(location = 1) in vec4 passParameterSem1;
layout(location = 0) out vec4 passPixelColor0;
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);
float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
float PV0fx = 0.0, PV0fy = 0.0, PV0fz = 0.0, PV0fw = 0.0, PV1fx = 0.0, PV1fy = 0.0, PV1fz = 0.0, PV1fw = 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;
R0f = passParameterSem0;
R1f = passParameterSem1;
R1f.xyzw = (texture(textureUnitPS0, vec2(R1f.x,R1f.y)).xyzw);
// 0
R0f.x = mul_nonIEEE(R0f.x, R1f.x);
R0f.x = clamp(R0f.x, 0.0, 1.0);
R0f.y = mul_nonIEEE(R0f.y, R1f.y);
R0f.y = clamp(R0f.y, 0.0, 1.0);
R0f.z = mul_nonIEEE(R0f.z, R1f.z);
R0f.z = clamp(R0f.z, 0.0, 1.0);
R0f.w = mul_nonIEEE(R0f.w, R1f.w);
R0f.w = clamp(R0f.w, 0.0, 1.0);
// export
passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, 0.0);
}

115
src/WindWakerHD/Mods/RemoveHUD/b84517cef3bb49ad_000000000000007d_ps.txt Normal file
View File

@ -0,0 +1,115 @@
#version 460
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
// shader b84517cef3bb49ad
// Used for: Removes the text from the HUD, also breaks other text menus though.
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
#ifdef VULKAN
layout(set = 1, binding = 1) uniform ufBlock
{
uniform ivec4 uf_remappedPS[4];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[4];
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2DArray textureUnitPS0;
layout(location = 0) in vec4 passParameterSem0;
layout(location = 1) in vec4 passParameterSem1;
layout(location = 0) out vec4 passPixelColor0;
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()
{
ivec4 R0i = ivec4(0);
ivec4 R1i = ivec4(0);
ivec4 R2i = ivec4(0);
ivec4 R123i = ivec4(0);
ivec4 R126i = ivec4(0);
ivec4 R127i = ivec4(0);
int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i;
ivec4 PV0i = ivec4(0), PV1i = ivec4(0);
int PS0i = 0, PS1i = 0;
ivec4 tempi = ivec4(0);
float tempResultf;
int tempResulti;
ivec4 ARi = ivec4(0);
bool predResult = true;
vec3 cubeMapSTM;
int cubeMapFaceId;
R0i = floatBitsToInt(passParameterSem0);
R1i = floatBitsToInt(passParameterSem1);
// 0
backupReg0i = R1i.z;
R2i.x = ((intBitsToFloat(R0i.w) > 0.0)?int(0xFFFFFFFF):int(0x0));
R1i.z = floatBitsToInt(roundEven(intBitsToFloat(backupReg0i)));
R1i.w = floatBitsToInt(texture(textureUnitPS0, vec3(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(R1i.z))).w);
// 0
PV0i.x = R1i.w;
PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * 2.0);
PV0i.y = ((intBitsToFloat(0x3f0a3d71) > intBitsToFloat(R1i.w))?int(0xFFFFFFFF):int(0x0));
PV0i.w = floatBitsToInt(intBitsToFloat(R1i.w) + -(0.5));
PV0i.w = floatBitsToInt(intBitsToFloat(PV0i.w) * 2.0);
// 1
R127i.y = ((PV0i.y == 0)?(0x3f800000):(PV0i.x));
R127i.z = ((PV0i.y == 0)?(PV0i.w):(0));
PV1i.z = R127i.z;
// 2
R123i.z = floatBitsToInt((mul_nonIEEE(intBitsToFloat(PV1i.z),intBitsToFloat(uf_remappedPS[0].y)) + intBitsToFloat(uf_remappedPS[1].y)));
PV0i.z = R123i.z;
R123i.w = floatBitsToInt((mul_nonIEEE(intBitsToFloat(PV1i.z),intBitsToFloat(uf_remappedPS[0].x)) + intBitsToFloat(uf_remappedPS[1].x)));
PV0i.w = R123i.w;
// 3
backupReg0i = R0i.x;
PV1i.x = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R127i.y), intBitsToFloat(uf_remappedPS[0].w)));
R123i.y = floatBitsToInt((mul_nonIEEE(intBitsToFloat(R127i.z),intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[1].z)));
PV1i.y = R123i.y;
R126i.z = floatBitsToInt(mul_nonIEEE(intBitsToFloat(backupReg0i), intBitsToFloat(PV0i.w)));
R127i.w = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.y), intBitsToFloat(PV0i.z)));
// 4
R127i.x = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.z), intBitsToFloat(PV1i.y)));
R126i.y = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.w), intBitsToFloat(PV1i.x)));
R123i.z = floatBitsToInt((mul_nonIEEE(intBitsToFloat(R127i.z),intBitsToFloat(uf_remappedPS[2].y)) + intBitsToFloat(uf_remappedPS[3].y)));
PV0i.z = R123i.z;
R123i.w = floatBitsToInt((mul_nonIEEE(intBitsToFloat(R127i.z),intBitsToFloat(uf_remappedPS[2].x)) + intBitsToFloat(uf_remappedPS[3].x)));
PV0i.w = R123i.w;
// 5
backupReg0i = R0i.x;
PV1i.x = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R127i.y), intBitsToFloat(uf_remappedPS[2].w)));
R123i.y = floatBitsToInt((mul_nonIEEE(intBitsToFloat(R127i.z),intBitsToFloat(uf_remappedPS[2].z)) + intBitsToFloat(uf_remappedPS[3].z)));
PV1i.y = R123i.y;
PV1i.z = floatBitsToInt(mul_nonIEEE(intBitsToFloat(backupReg0i), intBitsToFloat(PV0i.w)));
PV1i.w = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.y), intBitsToFloat(PV0i.z)));
// 6
backupReg0i = R0i.z;
PV0i.x = floatBitsToInt(mul_nonIEEE(-(intBitsToFloat(R0i.w)), intBitsToFloat(PV1i.x)));
R0i.y = ((R2i.x == 0)?(PV1i.w):(R127i.w));
PV0i.z = floatBitsToInt(mul_nonIEEE(intBitsToFloat(backupReg0i), intBitsToFloat(PV1i.y)));
R0i.x = ((R2i.x == 0)?(PV1i.z):(R126i.z));
PS0i = R0i.x;
// 7
R0i.z = ((R2i.x == 0)?(PV0i.z):(R127i.x));
R0i.w = ((R2i.x == 0)?(PV0i.x):(R126i.y));
// export
passPixelColor0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), 0.0);
}

115
src/WindWakerHD/Mods/RemoveHUD/d80a321ea97e9415_0000000000000079_ps.txt Normal file
View File

@ -0,0 +1,115 @@
#version 460
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
// shader d80a321ea97e9415: text shadow
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.z, 1.0/gl_FragCoord.w)
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
#ifdef VULKAN
layout(set = 1, binding = 1) uniform ufBlock
{
uniform ivec4 uf_remappedPS[2];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[2];
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
layout(location = 0) in vec4 passParameterSem0;
layout(location = 1) in vec4 passParameterSem2;
layout(location = 0) out vec4 passPixelColor0;
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 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;
float PV0fx = 0.0, PV0fy = 0.0, PV0fz = 0.0, PV0fw = 0.0, PV1fx = 0.0, PV1fy = 0.0, PV1fz = 0.0, PV1fw = 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;
R0f = passParameterSem0;
R1f = passParameterSem2;
R1f.xyzw = (texture(textureUnitPS0, vec2(R1f.x,R1f.y)).xyzw);
// 0
PV0fx = intBitsToFloat(uf_remappedPS[0].w) * 0.99609375;
PV0fy = intBitsToFloat(uf_remappedPS[0].z) * 0.99609375;
PV0fz = intBitsToFloat(uf_remappedPS[0].y) * 0.99609375;
PV0fw = intBitsToFloat(uf_remappedPS[0].x) * 0.99609375;
// 1
PV1fx = fract(PV0fw);
R127f.y = fract(PV0fx);
R127f.z = fract(PV0fy);
PV1fw = fract(PV0fz);
R127f.w = intBitsToFloat(uf_remappedPS[1].x) * 0.99609375;
// 2
R127f.x = intBitsToFloat(uf_remappedPS[1].w) * 0.99609375;
PV0fy = intBitsToFloat(uf_remappedPS[1].z) * 0.99609375;
PV0fz = intBitsToFloat(uf_remappedPS[1].y) * 0.99609375;
R126f.w = PV1fx * intBitsToFloat(0x3f808081);
R126f.x = PV1fw * intBitsToFloat(0x3f808081);
// 3
R125f.x = R127f.y * intBitsToFloat(0x3f808081);
PV1fy = fract(R127f.w);
PV1fz = fract(PV0fz);
R127f.w = R127f.z * intBitsToFloat(0x3f808081);
PS1f = fract(PV0fy);
// 4
PV0fx = fract(R127f.x);
R123f.y = PS1f * intBitsToFloat(0x3f808081) + -(R127f.w);
R123f.z = PV1fz * intBitsToFloat(0x3f808081) + -(R126f.x);
R123f.w = PV1fy * intBitsToFloat(0x3f808081) + -(R126f.w);
// 5
backupReg0f = R123f.y;
backupReg1f = R123f.z;
R123f.x = mul_nonIEEE(R123f.w,R1f.x) + R126f.w;
R123f.x = clamp(R123f.x, 0.0, 1.0);
R123f.y = PV0fx * intBitsToFloat(0x3f808081) + -(R125f.x);
R123f.z = mul_nonIEEE(backupReg0f,R1f.z) + R127f.w;
R123f.z = clamp(R123f.z, 0.0, 1.0);
R123f.w = mul_nonIEEE(backupReg1f,R1f.y) + R126f.x;
R123f.w = clamp(R123f.w, 0.0, 1.0);
// 6
backupReg0f = R123f.x;
R123f.x = mul_nonIEEE(R123f.y,R1f.w) + R125f.x;
R123f.x = clamp(R123f.x, 0.0, 1.0);
R1f.y = mul_nonIEEE(R0f.y, R123f.w);
R1f.y = clamp(R1f.y, 0.0, 1.0);
R1f.z = mul_nonIEEE(R0f.z, R123f.z);
R1f.z = clamp(R1f.z, 0.0, 1.0);
R1f.x = mul_nonIEEE(R0f.x, backupReg0f);
R1f.x = clamp(R1f.x, 0.0, 1.0);
// 7
R1f.w = mul_nonIEEE(R0f.w, R123f.x);
R1f.w = clamp(R1f.w, 0.0, 1.0);
// export
passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, 0.0);
}

103
src/WindWakerHD/Mods/RemoveHUD/d9953dbd7354b119_000000000000007d_ps.txt Normal file
View File

@ -0,0 +1,103 @@
#version 460
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
// shader d9953dbd7354b119
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
#ifdef VULKAN
layout(set = 1, binding = 1) uniform ufBlock
{
uniform ivec4 uf_remappedPS[4];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[4];
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2DArray textureUnitPS0;
layout(location = 0) in vec4 passParameterSem0;
layout(location = 1) in vec4 passParameterSem1;
layout(location = 0) out vec4 passPixelColor0;
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()
{
ivec4 R0i = ivec4(0);
ivec4 R1i = ivec4(0);
ivec4 R2i = ivec4(0);
ivec4 R123i = ivec4(0);
ivec4 R126i = ivec4(0);
ivec4 R127i = ivec4(0);
int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i;
ivec4 PV0i = ivec4(0), PV1i = ivec4(0);
int PS0i = 0, PS1i = 0;
ivec4 tempi = ivec4(0);
float tempResultf;
int tempResulti;
ivec4 ARi = ivec4(0);
bool predResult = true;
vec3 cubeMapSTM;
int cubeMapFaceId;
R0i = floatBitsToInt(passParameterSem0);
R1i = floatBitsToInt(passParameterSem1);
// 0
backupReg0i = R1i.z;
R2i.x = floatBitsToInt(intBitsToFloat(uf_remappedPS[0].y) + intBitsToFloat(uf_remappedPS[1].y));
R2i.y = ((intBitsToFloat(R0i.w) > 0.0)?int(0xFFFFFFFF):int(0x0));
R1i.z = floatBitsToInt(roundEven(intBitsToFloat(backupReg0i)));
R2i.w = floatBitsToInt(intBitsToFloat(uf_remappedPS[0].x) + intBitsToFloat(uf_remappedPS[1].x));
R1i.w = floatBitsToInt(texture(textureUnitPS0, vec3(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(R1i.z))).w);
// 0
backupReg0i = R0i.y;
R127i.x = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.x), intBitsToFloat(R2i.w)));
PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedPS[0].z) + intBitsToFloat(uf_remappedPS[1].z));
PV0i.z = floatBitsToInt(intBitsToFloat(R1i.w) + -(0.5));
PV0i.z = floatBitsToInt(intBitsToFloat(PV0i.z) * 2.0);
PV0i.w = ((intBitsToFloat(0x3f0a3d71) > intBitsToFloat(R1i.w))?int(0xFFFFFFFF):int(0x0));
R126i.w = floatBitsToInt(mul_nonIEEE(intBitsToFloat(backupReg0i), intBitsToFloat(R2i.x)));
PS0i = R126i.w;
// 1
R126i.x = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.z), intBitsToFloat(PV0i.y)));
R123i.y = ((PV0i.w == 0)?(PV0i.z):(0));
PV1i.y = R123i.y;
PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedPS[2].y) + intBitsToFloat(uf_remappedPS[3].y));
PV1i.w = floatBitsToInt(intBitsToFloat(uf_remappedPS[2].x) + intBitsToFloat(uf_remappedPS[3].x));
// 2
backupReg0i = R0i.x;
backupReg1i = R0i.y;
PV0i.x = floatBitsToInt(mul_nonIEEE(intBitsToFloat(PV1i.y), intBitsToFloat(uf_remappedPS[3].w)));
PV0i.y = floatBitsToInt(mul_nonIEEE(intBitsToFloat(PV1i.y), intBitsToFloat(uf_remappedPS[1].w)));
PV0i.z = floatBitsToInt(mul_nonIEEE(intBitsToFloat(backupReg0i), intBitsToFloat(PV1i.w)));
R127i.w = floatBitsToInt(mul_nonIEEE(intBitsToFloat(backupReg1i), intBitsToFloat(PV1i.z)));
// 3
PV1i.x = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R0i.w), intBitsToFloat(PV0i.y)));
PV1i.y = floatBitsToInt(intBitsToFloat(uf_remappedPS[2].z) + intBitsToFloat(uf_remappedPS[3].z));
PV1i.z = floatBitsToInt(mul_nonIEEE(-(intBitsToFloat(R0i.w)), intBitsToFloat(PV0i.x)));
R1i.x = ((R2i.y == 0)?(PV0i.z):(R127i.x));
PS1i = R1i.x;
// 4
backupReg0i = R0i.z;
R1i.y = ((R2i.y == 0)?(R127i.w):(R126i.w));
PV0i.z = floatBitsToInt(mul_nonIEEE(intBitsToFloat(backupReg0i), intBitsToFloat(PV1i.y)));
R1i.w = ((R2i.y == 0)?(PV1i.z):(PV1i.x));
// 5
R1i.z = ((R2i.y == 0)?(PV0i.z):(R126i.x));
// export
passPixelColor0 = vec4(intBitsToFloat(R1i.x), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), 0.0);
}

78
src/WindWakerHD/Mods/RemoveHUD/fcd26205b94e11ca_0000000000000079_ps.txt Normal file
View File

@ -0,0 +1,78 @@
#version 460
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
// shader fcd26205b94e11ca
// Used for: Removing the bigger red glanse/glow of the red hearts
#ifdef VULKAN
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
#else
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
#endif
#ifdef VULKAN
layout(set = 1, binding = 1) uniform ufBlock
{
uniform ivec4 uf_remappedPS[2];
uniform vec4 uf_fragCoordScale;
};
#else
uniform ivec4 uf_remappedPS[2];
uniform vec2 uf_fragCoordScale;
#endif
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
layout(location = 0) in vec4 passParameterSem0;
layout(location = 1) in vec4 passParameterSem1;
layout(location = 0) out vec4 passPixelColor0;
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 R123f = 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 = passParameterSem0;
R1f = passParameterSem1;
R1f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
// 0
R127f.z = (mul_nonIEEE(R1f.y,intBitsToFloat(uf_remappedPS[0].y)) + intBitsToFloat(uf_remappedPS[1].y));
R123f.w = (mul_nonIEEE(R1f.x,intBitsToFloat(uf_remappedPS[0].x)) + intBitsToFloat(uf_remappedPS[1].x));
PV0f.w = R123f.w;
// 1
R123f.x = (mul_nonIEEE(R1f.w,intBitsToFloat(uf_remappedPS[0].w)) + intBitsToFloat(uf_remappedPS[1].w));
PV1f.x = R123f.x;
R123f.y = (mul_nonIEEE(R1f.z,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[1].z));
PV1f.y = R123f.y;
R1f.x = mul_nonIEEE(R0f.x, PV0f.w);
PS1f = R1f.x;
// 2
R1f.y = mul_nonIEEE(R0f.y, R127f.z);
R1f.z = mul_nonIEEE(R0f.z, PV1f.y);
R1f.w = mul_nonIEEE(R0f.w, PV1f.x);
// export
passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, 0.0);
}

7
src/WindWakerHD/Mods/RemoveHUD/rules.txt Normal file
View File

@ -0,0 +1,7 @@
[Definition]
titleIds = 0005000010143400,0005000010143500,0005000010143600,000500010185400
name = Remove HUD
path = "The Legend of Zelda: The Wind Waker HD/Mods/Remove HUD (breaks menus)"
description = Removes the HUD elements for taking screenshots.|This will break other menus making it very hard to navigate those.
#Credits:
version = 7

11
src/WindWakerHD/Workarounds/FPSSlowdownFix/patch_fpsSlowDown.asm Normal file
View File

@ -0,0 +1,11 @@
[WindWakerHD_SlowDownFix_EU] ;OliveOperationMgrThread found by BenjaminLSR
moduleMatches = 0xB7E748DE ; (EU)
0x025AC21C = nop; SUSPEND OliveOperationMgrThread
[WindWakerHD_SlowDownFix_NA] ;Ported to US by M&&M
moduleMatches = 0x475BD29F ; (NA)
0x025AC25C = nop; SUSPEND OliveOperationMgrThread
[WindWakerHD_SlowDownFix_JP] ;Ported to JP by Crementif
moduleMatches = 0x74BD3F6A ; (JP)
0x025AC24C = nop; SUSPEND OliveOperationMgrThread

8
src/WindWakerHD/Workarounds/FPSSlowdownFix/rules.txt Normal file
View File

@ -0,0 +1,8 @@
[Definition]
titleIds = 0005000010143400,0005000010143500,0005000010143600,000500010185400
name = FPS Slowdown
path = "The Legend of Zelda: The Wind Waker HD/Workarounds/FPS Slowdown"
description = Fixes slowdown that could occur on weaker hardware.
#Credits: BenjaminLSR, M&&M, Crementif
version = 6
default = 1

20
src/WindWakerHD/Workarounds/IntelFixes/patch_IntelFixes.asm Normal file
View File

@ -0,0 +1,20 @@
[WindWakerHD_IntelFix_EU] ;made by BenjaminLSR
moduleMatches = 0xB7E748DE ; (EU)
_emptyString = 0x10166948
;is_useSsaoDirectDraw
0x0278EED8 = lis r0, _emptyString@ha
0x0278EEE4 = addic r0, r0, _emptyString@l
[WindWakerHD_IntelFix_NA] ;ported to US by M&M
moduleMatches = 0x475BD29F ; (NA)
_emptyString = 0x1016693C
;is_useSsaoDirectDraw
0x0278E618 = lis r0, _emptyString@ha
0x0278E624 = addic r0, r0, _emptyString@l
[WindWakerHD_IntelFix_JP] ;ported to JP by Crementif
moduleMatches = 0x74BD3F6A ; (JP)
_emptyString = 0x1016695C
;is_useSsaoDirectDraw
0x0278F0F8 = lis r0, _emptyString@ha
0x0278F104 = addic r0, r0, _emptyString@l

7
src/WindWakerHD/Workarounds/IntelFixes/rules.txt Normal file
View File

@ -0,0 +1,7 @@
[Definition]
titleIds = 0005000010143400,0005000010143500,0005000010143600,000500010185400
name= Graphical fixes for Intel Integrated GPUs
path = "The Legend of Zelda: The Wind Waker HD/Workarounds/Intel Integrated GPU Fixes"
description = Fixes graphical bugs while using an Intel iGPU. Don't use this if you're using a Nvidia or AMD GPU.
#Credits: BenjaminLSR, M&&M, Crementif
version = 6

40
src/WindWakerHD/Workarounds/PictoBox/patch_PictoBox.asm Normal file
View File

@ -0,0 +1,40 @@
;For loadline versions, try looking up addresses in PPC debugger. Correct opcodes should be near these addresses. Changing it should be easy.
[WindWakerHD_PictoBox_EU]
moduleMatches = 0xB7E748DE ; (EU)
_sub_exit = 0x022D013C
;First picture
0x022D00EC = nop ; cmp r0, 1
0x022D00F0 = b _sub_exit ; beq 0x022D013C
;Second picture
0x022D0118 = nop ; cmp r0, 2
0x022D011C = nop ; bne 0x022D00F4
;Third picture
0x022D0134 = nop ; cmp r0, 3
0x022D0138 = nop ; bne 0x022D00F4
[WindWakerHD_PictoBox_NA]
moduleMatches = 0x475BD29F ; (NA)
_sub_exit = 0x022D0138
;First picture
0x022D00E8 = nop ; cmp r0, 1
0x022D00EC = b _sub_exit ; beq 0x022D0138
;Second picture
0x022D0114 = nop ; cmp r0, 2
0x022D0118 = nop ; bne 0x022D00F0
;Third picture
0x022D0130 = nop ; cmp r0, 3
0x022D0134 = nop ; bne 0x022D00F0
[WindWakerHD_PictoBox_JP]
moduleMatches = 0x74BD3F6A ; (JP)
_sub_exit = 0x022D0140
;First picture
0x022D00F0 = nop ; cmp r0, 1
0x022D00F4 = b _sub_exit ; beq 0x022D0140
;Second picture
0x022D011C = nop ; cmp r0, 2
0x022D0120 = nop ; bne 0x022D00F8
;Third picture
0x022D0138 = nop ; cmp r0, 3
0x022D013C = nop ; bne 0x022D00F8

7
src/WindWakerHD/Workarounds/PictoBox/rules.txt Normal file
View File

@ -0,0 +1,7 @@
[Definition]
titleIds = 0005000010143400,0005000010143500,0005000010143600,000500010185400
name = Picto-Box Fix
path = "The Legend of Zelda: The Wind Waker HD/Workarounds/Picto-Box Fix"
description = This is more of a cheat than workaround. Forces Lenzo to accept any pictures in the quest 'Lenzo's Research Assistant'.|Made by Vladimir-1799.
#Credits: Vladimir-1799
version = 6