Adds src/TwilighPrincessHD

src/TwilightPrincessHD/Enhancements/Bloom/49865bd2e62efda1_0000000000000079_ps.txt

@@ -0,0 +1,82 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+
+
+// shader 49865bd2e62efda1: tints the bloom mask and applies it to the frame
+
+
+#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[1]; // holds area specific bloom tint color
+		uniform vec4 uf_fragCoordScale;
+	};
+
+#else
+	uniform ivec4 uf_remappedPS[1]; // holds area specific bloom tint color
+	uniform vec2 uf_fragCoordScale;
+
+#endif
+
+TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0; // bloom mask created in 6e2f31b2b2fcab1f
+layout(location = 0) in vec4 passParameterSem0; // pixel coord
+layout(location = 0) out vec4 passPixelColor0; // pixel color, alpha = blend of original pixel -> used to dampen non-bloom areas in shadow world
+
+
+// more compatible interpolation
+float mixf(float x, float y, float a)
+{
+	return x * (1.0 - a) + y * a;
+}
+
+
+void main()
+{
+	// get pixel coord
+	vec2 coord = passParameterSem0.xy;
+
+	// get bloom mask
+	vec3 mask = texture(textureUnitPS0, coord).xyz;
+
+	// get area specific color tint
+	vec4 tint = vec4(0.0);
+	tint.x = intBitsToFloat(uf_remappedPS[0].x);
+	tint.y = intBitsToFloat(uf_remappedPS[0].y);
+	tint.z = intBitsToFloat(uf_remappedPS[0].z);
+	tint.w = intBitsToFloat(uf_remappedPS[0].w);
+
+	// get luminance of tint: removes color, keeps intended brightness
+	float tintLuminance = dot(tint.xyz, vec3(0.299, 0.587, 0.114)); // percieved approximation
+
+	// apply custom tint color
+	tint.x = mixf(tintLuminance, tint.x, $bloom_tint_strength);
+	tint.y = mixf(tintLuminance, tint.y, $bloom_tint_strength);
+	tint.z = mixf(tintLuminance, tint.z, $bloom_tint_strength);
+
+	// apply tint on mask
+	vec4 outColor = vec4(0.0);
+	outColor.x = mask.x * tint.x;
+	outColor.y = mask.y * tint.y;
+	outColor.z = mask.z * tint.z;
+
+	// custom brightness reduction, only in shadow world below 1.0
+	outColor.w = mixf(1.0, tint.w, $shadow_world_darkening);
+
+	// export
+	passPixelColor0 = vec4(outColor.x, outColor.y, outColor.z, outColor.w);
+}

src/TwilightPrincessHD/Enhancements/Bloom/5f422bf63e25be7f_0000000000000079_ps.txt

@@ -0,0 +1,75 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+
+
+// shader 5f422bf63e25be7f: desaturates colors (shadow world only)
+// desaturates the image by shifting colors towards the red channel
+// used in shadow world only, as far as tested
+// grading values always seem to be: 1.0, 1.0, 1.0, ~0.33
+
+
+#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)
+
+	layout(set = 1, binding = 1) uniform ufBlock
+	{
+		uniform ivec4 uf_remappedPS[1]; // grading
+	};
+
+#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)
+
+	uniform ivec4 uf_remappedPS[1]; // grading
+
+#endif
+
+
+TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0; // frame
+layout(location = 0) in vec4 passParameterSem1; // pixel coordinate
+layout(location = 0) out vec4 passPixelColor0; // output. w is alpha, overlayed
+
+
+// more compatible interpolation
+float mixf(float x, float y, float a)
+{
+	return x * (1.0 - a) + y * a;
+}
+
+
+void main()
+{
+	// get texel color
+	vec2 coord = passParameterSem1.xy;
+	vec3 texel = texture(textureUnitPS0, coord).xyz;
+
+	// get grading
+	vec4 grading = vec4(0.0);
+	grading.x = intBitsToFloat(uf_remappedPS[0].x); // 1.0
+	grading.y = intBitsToFloat(uf_remappedPS[0].y); // 1.0
+	grading.z = intBitsToFloat(uf_remappedPS[0].z); // 1.0
+	grading.w = intBitsToFloat(uf_remappedPS[0].w); // alpha, ~0.33
+
+	// shift towards red channel
+	vec4 color = vec4(0.0);
+	color.x = texel.x * grading.x; // red * 1.0
+	color.y = texel.x * grading.y; // red * 1.0
+	color.z = texel.x * grading.z; // red * 1.0
+	color.w = mixf(0.0, grading.w, $shadow_world_desaturation); // apply custom strength
+
+	// export
+	passPixelColor0 = vec4(color.x, color.y, color.z, color.w);
+
+
+	// test current grading colors
+	//passPixelColor0 = vec4(grading.x, grading.y, grading.z, 1.0);
+
+	// test current grading alpha
+	//passPixelColor0 = vec4(grading.w, grading.w, grading.w, 1.0);
+}

src/TwilightPrincessHD/Enhancements/Bloom/6e2f31b2b2fcab1f_0000000000000079_ps.txt

@@ -0,0 +1,67 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+
+
+// shader 6e2f31b2b2fcab1f: creates bloom mask
+
+
+#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[1]; // mask threshold
+		uniform vec4 uf_fragCoordScale;
+	};
+
+#else
+	uniform ivec4 uf_remappedPS[1]; // mask threshold
+	uniform vec2 uf_fragCoordScale;
+
+#endif
+
+TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0; // frame
+layout(location = 0) out vec4 passPixelColor0; // outputs to a texture used by c612390d4c70f430, 95a5a89d62998e0d and 49865bd2e62efda1
+
+
+void main()
+{
+	// get mask threshold data
+	float cutoff = intBitsToFloat(uf_remappedPS[0].x); // ~0.39: 0-1, higher = less glowing pixels
+	float contrast = intBitsToFloat(uf_remappedPS[0].y); // 4.5: higher = sharper edges
+
+	// get texture coordinate of this pixel
+	vec4 coord = GET_FRAGCOORD();
+	coord.x = coord.x * intBitsToFloat(0x3b088889); // align to scale/grid?
+	coord.y = coord.y * intBitsToFloat(0x3b72b9d6);
+
+	// get color of this pixel
+	vec3 color = texture(textureUnitPS0, vec2(coord.x, coord.y)).xyz;
+
+	// calculate luminance = percieved brightness
+	float luminance = dot(color, vec3(0.299, 0.587, 0.114)); // percieved approximation
+
+	// apply threshold, removes dark areas from the mask
+	luminance = contrast * (luminance - cutoff) * $bloom_strength; // apply custom strength
+
+	// apply to color and clamp
+	color.x = clamp(luminance * color.x, 0.0, 1.0);
+	color.y = clamp(luminance * color.y, 0.0, 1.0);
+	color.z = clamp(luminance * color.z, 0.0, 1.0);
+
+	// export
+	passPixelColor0 = vec4(color.x, color.y, color.z, 0.0);
+}

src/TwilightPrincessHD/Enhancements/Bloom/blur_unused_95a5a89d62998e0d_0000000000000079_ps.txt

@@ -0,0 +1,300 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+
+
+// shader 95a5a89d62998e0d: blurs bloom vertical
+
+
+#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[3];
+		uniform vec4 uf_fragCoordScale;
+	};
+
+#else
+	uniform ivec4 uf_remappedPS[3];
+	uniform vec2 uf_fragCoordScale;
+
+#endif
+
+TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) out vec4 passPixelColor0;
+
+
+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 R6f = vec4(0.0);
+	vec4 R7f = vec4(0.0);
+	vec4 R123f = 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 = GET_FRAGCOORD();
+
+
+	// 0
+	R7f.x = R0f.x * intBitsToFloat(0x3b088889);
+	R7f.y = R0f.y * intBitsToFloat(0x3b72b9d6);
+
+	// 1
+	R0f.x = R7f.x;
+	R0f.y = R7f.y + intBitsToFloat(0x3b72b9d6);
+	R1f.z = R7f.x;
+	R1f.y = R7f.y + intBitsToFloat(0xbb72b9d6);
+
+	// 2
+	R2f.x = R7f.x;
+	R2f.y = R7f.y + intBitsToFloat(0x3bf2b9d6);
+	R4f.z = R7f.x;
+	R4f.y = R7f.y + intBitsToFloat(0xbbf2b9d6);
+	R3f.xyzw = (textureLod(textureUnitPS0, vec2(R7f.x,R7f.y),0.0).xyzw);
+	R0f.xyzw = (textureLod(textureUnitPS0, vec2(R0f.x,R0f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.z,R1f.y),0.0).xyzw);
+	R2f.xyzw = (textureLod(textureUnitPS0, vec2(R2f.x,R2f.y),0.0).xyzw);
+
+	// 0
+	PV0fx = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.y);
+	PV0fy = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.z);
+	PV0fz = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.x);
+	PV0fw = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.w);
+	R0f.y = R7f.y + intBitsToFloat(0x3c360b60);
+
+	// 1
+	R123f.x = mul_nonIEEE(R3f.y,intBitsToFloat(uf_remappedPS[0].x)) + PV0fx;
+	R123f.y = mul_nonIEEE(R3f.w,intBitsToFloat(uf_remappedPS[0].x)) + PV0fw;
+	R123f.z = mul_nonIEEE(R3f.x,intBitsToFloat(uf_remappedPS[0].x)) + PV0fz;
+	R123f.w = mul_nonIEEE(R3f.z,intBitsToFloat(uf_remappedPS[0].x)) + PV0fy;
+	R0f.x = R7f.x;
+
+	// 2
+	backupReg0f = R123f.y;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.y) + R123f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.x) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.w) + backupReg0f;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.z) + R123f.w;
+	R1f.y = R7f.y + intBitsToFloat(0xbc360b60);
+
+	// 3
+	backupReg0f = R2f.z;
+	R3f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.x) + R123f.y;
+	R3f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.y) + R123f.x;
+	R2f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.w) + R123f.z;
+	R2f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),backupReg0f) + R123f.w;
+	R1f.x = R7f.x;
+
+	// 4
+	R2f.x = R7f.x;
+	R2f.y = R7f.y + intBitsToFloat(0x3c72b9d6);
+	R6f.z = R7f.x;
+	R6f.y = R7f.y + intBitsToFloat(0xbc72b9d6);
+	R4f.xyzw = (textureLod(textureUnitPS0, vec2(R4f.z,R4f.y),0.0).xyzw);
+	R0f.xyzw = (textureLod(textureUnitPS0, vec2(R0f.x,R0f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R5f.xyzw = (textureLod(textureUnitPS0, vec2(R2f.x,R2f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.x) + R3f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.w) + R2f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.z) + R2f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.y) + R3f.y;
+	R3f.y = R7f.y + intBitsToFloat(0x3c97b426);
+
+	// 1
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.w) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.x) + backupReg0f;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.z) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.y) + R123f.w;
+	R3f.x = R7f.x;
+
+	// 2
+	backupReg0f = R123f.y;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.w) + R123f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.z) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.y) + R123f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.x) + backupReg0f;
+	R1f.y = R7f.y + intBitsToFloat(0xbc97b426);
+
+	// 3
+	R0f.x = mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[1].x)) + R123f.y;
+	R0f.y = mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[1].x)) + R123f.x;
+	R5f.z = mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[1].x)) + R123f.z;
+	R5f.w = mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[1].x)) + R123f.w;
+	R1f.x = R7f.x;
+
+	// 4
+	R5f.x = R7f.x;
+	R5f.y = R7f.y + intBitsToFloat(0x3cb60b60);
+	R4f.z = R7f.x;
+	R4f.y = R7f.y + intBitsToFloat(0xbcb60b60);
+	R6f.xyzw = (textureLod(textureUnitPS0, vec2(R6f.z,R6f.y),0.0).xyzw);
+	R3f.xyzw = (textureLod(textureUnitPS0, vec2(R3f.x,R3f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R2f.xyzw = (textureLod(textureUnitPS0, vec2(R5f.x,R5f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.z) + R0f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.y) + R5f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.x) + R5f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.w) + R0f.y;
+	R0f.y = R7f.y + intBitsToFloat(0x3cd4629b);
+
+	// 1
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.y) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.w) + R123f.w;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.x) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.z) + backupReg0f;
+	R0f.x = R7f.x;
+
+	// 2
+	backupReg0f = R123f.y;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.y) + R123f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.x) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.w) + backupReg0f;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.z) + R123f.w;
+	R1f.y = R7f.y + intBitsToFloat(0xbcd4629b);
+
+	// 3
+	backupReg0f = R2f.z;
+	R3f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.x) + R123f.y;
+	R3f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.y) + R123f.x;
+	R2f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.w) + R123f.z;
+	R2f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),backupReg0f) + R123f.w;
+	R1f.x = R7f.x;
+
+	// 4
+	R2f.x = R7f.x;
+	R2f.y = R7f.y + intBitsToFloat(0x3cf2b9d6);
+	R6f.z = R7f.x;
+	R6f.y = R7f.y + intBitsToFloat(0xbcf2b9d6);
+	R4f.xyzw = (textureLod(textureUnitPS0, vec2(R4f.z,R4f.y),0.0).xyzw);
+	R0f.xyzw = (textureLod(textureUnitPS0, vec2(R0f.x,R0f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R5f.xyzw = (textureLod(textureUnitPS0, vec2(R2f.x,R2f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.x) + R3f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.w) + R2f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.z) + R2f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.y) + R3f.y;
+	R3f.y = R7f.y + intBitsToFloat(0x3d088888);
+
+	// 1
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.w) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.x) + backupReg0f;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.z) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.y) + R123f.w;
+	R3f.x = R7f.x;
+
+	// 2
+	backupReg0f = R123f.y;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.w) + R123f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.z) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.y) + R123f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.x) + backupReg0f;
+	R1f.y = R7f.y + intBitsToFloat(0xbd088888);
+
+	// 3
+	R0f.x = mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[2].x)) + R123f.y;
+	R0f.y = mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[2].x)) + R123f.x;
+	R5f.z = mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[2].x)) + R123f.z;
+	R5f.w = mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[2].x)) + R123f.w;
+	R1f.x = R7f.x;
+
+	// 4
+	R5f.x = R7f.x;
+	R5f.y = R7f.y + intBitsToFloat(0x3d17b426);
+	R4f.z = R7f.x;
+	R4f.y = R7f.y + intBitsToFloat(0xbd17b426);
+	R6f.xyzw = (textureLod(textureUnitPS0, vec2(R6f.z,R6f.y),0.0).xyzw);
+	R3f.xyzw = (textureLod(textureUnitPS0, vec2(R3f.x,R3f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R2f.xyzw = (textureLod(textureUnitPS0, vec2(R5f.x,R5f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.z) + R0f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.y) + R5f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.x) + R5f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.w) + R0f.y;
+	R0f.y = R7f.y + intBitsToFloat(0x3d26dfc3);
+
+	// 1
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.y) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.w) + R123f.w;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.x) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.z) + backupReg0f;
+	R0f.x = R7f.x;
+
+	// 2
+	backupReg0f = R123f.y;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.y) + R123f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.x) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.w) + backupReg0f;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.z) + R123f.w;
+	R7f.y = R7f.y + intBitsToFloat(0xbd26dfc3);
+
+	// 3
+	backupReg0f = R2f.z;
+	R2f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.x) + R123f.y;
+	R2f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.y) + R123f.x;
+	R2f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.w) + R123f.z;
+	R2f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),backupReg0f) + R123f.w;
+	R4f.xyzw = (textureLod(textureUnitPS0, vec2(R4f.z,R4f.y),0.0).xyzw);
+	R0f.xyzw = (textureLod(textureUnitPS0, vec2(R0f.x,R0f.y),0.0).xyzw);
+	R7f.xyzw = (textureLod(textureUnitPS0, vec2(R7f.x,R7f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.x) + R2f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.w) + R2f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.z) + R2f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.y) + R2f.y;
+
+	// 1
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.w) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.x) + backupReg0f;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.z) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.y) + R123f.w;
+
+	// 2
+	R7f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R7f.x) + R123f.y;
+	R7f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R7f.y) + R123f.w;
+	R7f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R7f.z) + R123f.z;
+	R7f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R7f.w) + R123f.x;
+
+	// export
+	passPixelColor0 = vec4(R7f.x, R7f.y, R7f.z, R7f.w);
+}

src/TwilightPrincessHD/Enhancements/Bloom/blur_unused_c612390d4c70f430_0000000000000079_ps.txt

@@ -0,0 +1,454 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+
+
+// shader c612390d4c70f430: blurs bloom horizontal
+
+
+#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[5];
+		uniform vec4 uf_fragCoordScale;
+	};
+
+#else
+	uniform ivec4 uf_remappedPS[5];
+	uniform vec2 uf_fragCoordScale;
+
+#endif
+
+TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) out vec4 passPixelColor0;
+
+
+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 R6f = vec4(0.0);
+	vec4 R7f = vec4(0.0);
+	vec4 R123f = 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 = GET_FRAGCOORD();
+
+
+	// 0
+	R7f.x = R0f.x * intBitsToFloat(0x3b088889);
+	R7f.y = R0f.y * intBitsToFloat(0x3b72b9d6);
+
+	// 1
+	R0f.x = R7f.x + intBitsToFloat(0x3b088889);
+	R0f.y = R7f.y;
+	R1f.z = R7f.y;
+	R1f.x = R7f.x + intBitsToFloat(0xbb088889);
+
+	// 2
+	R2f.x = R7f.x + intBitsToFloat(0x3b888889);
+	R2f.y = R7f.y;
+	R4f.z = R7f.y;
+	R4f.x = R7f.x + intBitsToFloat(0xbb888889);
+	R3f.xyzw = (textureLod(textureUnitPS0, vec2(R7f.x,R7f.y),0.0).xyzw);
+	R0f.xyzw = (textureLod(textureUnitPS0, vec2(R0f.x,R0f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.z),0.0).xyzw);
+	R2f.xyzw = (textureLod(textureUnitPS0, vec2(R2f.x,R2f.y),0.0).xyzw);
+
+	// 0
+	PV0fx = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.z);
+	PV0fy = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.y);
+	PV0fz = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.x);
+	PV0fw = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.w);
+	R0f.x = R7f.x + intBitsToFloat(0x3bccccce);
+
+	// 1
+	R123f.x = mul_nonIEEE(R3f.w,intBitsToFloat(uf_remappedPS[0].x)) + PV0fw;
+	R123f.y = mul_nonIEEE(R3f.y,intBitsToFloat(uf_remappedPS[0].x)) + PV0fy;
+	R123f.z = mul_nonIEEE(R3f.x,intBitsToFloat(uf_remappedPS[0].x)) + PV0fz;
+	R123f.w = mul_nonIEEE(R3f.z,intBitsToFloat(uf_remappedPS[0].x)) + PV0fx;
+	R0f.y = R7f.y;
+
+	// 2
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.y) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.x) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.w) + backupReg0f;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.z) + R123f.w;
+	R1f.x = R7f.x + intBitsToFloat(0xbbccccce);
+
+	// 3
+	R3f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.w) + R123f.z;
+	R3f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.x) + R123f.y;
+	R2f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.z) + R123f.w;
+	R2f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.y) + R123f.x;
+	R1f.y = R7f.y;
+
+	// 4
+	R2f.x = R7f.x + intBitsToFloat(0x3c088889);
+	R2f.y = R7f.y;
+	R6f.z = R7f.y;
+	R6f.x = R7f.x + intBitsToFloat(0xbc088889);
+	R4f.xyzw = (textureLod(textureUnitPS0, vec2(R4f.x,R4f.z),0.0).xyzw);
+	R0f.xyzw = (textureLod(textureUnitPS0, vec2(R0f.x,R0f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R5f.xyzw = (textureLod(textureUnitPS0, vec2(R2f.x,R2f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.x) + R3f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.w) + R3f.x;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.z) + R2f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.y) + R2f.w;
+	R3f.x = R7f.x + intBitsToFloat(0x3c2aaaab);
+
+	// 1
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.x) + R123f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.w) + R123f.y;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.z) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.y) + R123f.w;
+	R3f.y = R7f.y;
+
+	// 2
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.w) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.z) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.y) + R123f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.x) + backupReg0f;
+	R1f.x = R7f.x + intBitsToFloat(0xbc2aaaab);
+
+	// 3
+	R0f.x = mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[1].x)) + R123f.x;
+	R0f.y = mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[1].x)) + R123f.y;
+	R5f.z = mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[1].x)) + R123f.z;
+	R5f.w = mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[1].x)) + R123f.w;
+	R1f.y = R7f.y;
+
+	// 4
+	R5f.x = R7f.x + intBitsToFloat(0x3c4cccce);
+	R5f.y = R7f.y;
+	R4f.z = R7f.y;
+	R4f.x = R7f.x + intBitsToFloat(0xbc4cccce);
+	R6f.xyzw = (textureLod(textureUnitPS0, vec2(R6f.x,R6f.z),0.0).xyzw);
+	R3f.xyzw = (textureLod(textureUnitPS0, vec2(R3f.x,R3f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R2f.xyzw = (textureLod(textureUnitPS0, vec2(R5f.x,R5f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.z) + R0f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.y) + R5f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.x) + R5f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.w) + R0f.x;
+	R0f.x = R7f.x + intBitsToFloat(0x3c6eeef0);
+
+	// 1
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.w) + R123f.w;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.y) + R123f.y;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.x) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.z) + backupReg0f;
+	R0f.y = R7f.y;
+
+	// 2
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.y) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.x) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.w) + backupReg0f;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.z) + R123f.w;
+	R1f.x = R7f.x + intBitsToFloat(0xbc6eeef0);
+
+	// 3
+	R3f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.w) + R123f.z;
+	R3f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.x) + R123f.y;
+	R2f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.z) + R123f.w;
+	R2f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.y) + R123f.x;
+	R1f.y = R7f.y;
+
+	// 4
+	R2f.x = R7f.x + intBitsToFloat(0x3c888889);
+	R2f.y = R7f.y;
+	R6f.z = R7f.y;
+	R6f.x = R7f.x + intBitsToFloat(0xbc888889);
+	R4f.xyzw = (textureLod(textureUnitPS0, vec2(R4f.x,R4f.z),0.0).xyzw);
+	R0f.xyzw = (textureLod(textureUnitPS0, vec2(R0f.x,R0f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R5f.xyzw = (textureLod(textureUnitPS0, vec2(R2f.x,R2f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.x) + R3f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.w) + R3f.x;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.z) + R2f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.y) + R2f.w;
+	R3f.x = R7f.x + intBitsToFloat(0x3c99999a);
+
+	// 1
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.x) + R123f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.w) + R123f.y;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.z) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.y) + R123f.w;
+	R3f.y = R7f.y;
+
+	// 2
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.w) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.z) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.y) + R123f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.x) + backupReg0f;
+	R1f.x = R7f.x + intBitsToFloat(0xbc99999a);
+
+	// 3
+	R0f.x = mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[2].x)) + R123f.x;
+	R0f.y = mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[2].x)) + R123f.y;
+	R5f.z = mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[2].x)) + R123f.z;
+	R5f.w = mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[2].x)) + R123f.w;
+	R1f.y = R7f.y;
+
+	// 4
+	R5f.x = R7f.x + intBitsToFloat(0x3caaaaab);
+	R5f.y = R7f.y;
+	R4f.z = R7f.y;
+	R4f.x = R7f.x + intBitsToFloat(0xbcaaaaab);
+	R6f.xyzw = (textureLod(textureUnitPS0, vec2(R6f.x,R6f.z),0.0).xyzw);
+	R3f.xyzw = (textureLod(textureUnitPS0, vec2(R3f.x,R3f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R2f.xyzw = (textureLod(textureUnitPS0, vec2(R5f.x,R5f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.z) + R0f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.y) + R5f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.x) + R5f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.w) + R0f.x;
+	R0f.x = R7f.x + intBitsToFloat(0x3cbbbbbc);
+
+	// 1
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.w) + R123f.w;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.y) + R123f.y;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.x) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.z) + backupReg0f;
+	R0f.y = R7f.y;
+
+	// 2
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.y) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.x) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.w) + backupReg0f;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.z) + R123f.w;
+	R1f.x = R7f.x + intBitsToFloat(0xbcbbbbbc);
+
+	// 3
+	R3f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.w) + R123f.z;
+	R3f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.x) + R123f.y;
+	R2f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.z) + R123f.w;
+	R2f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.y) + R123f.x;
+	R1f.y = R7f.y;
+
+	// 4
+	R2f.x = R7f.x + intBitsToFloat(0x3cccccce);
+	R2f.y = R7f.y;
+	R6f.z = R7f.y;
+	R6f.x = R7f.x + intBitsToFloat(0xbcccccce);
+	R4f.xyzw = (textureLod(textureUnitPS0, vec2(R4f.x,R4f.z),0.0).xyzw);
+	R0f.xyzw = (textureLod(textureUnitPS0, vec2(R0f.x,R0f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R5f.xyzw = (textureLod(textureUnitPS0, vec2(R2f.x,R2f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.x) + R3f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.w) + R3f.x;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.z) + R2f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.y) + R2f.w;
+	R3f.x = R7f.x + intBitsToFloat(0x3cdddddf);
+
+	// 1
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.x) + R123f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.w) + R123f.y;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.z) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.y) + R123f.w;
+	R3f.y = R7f.y;
+
+	// 2
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R1f.w) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R1f.z) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R1f.y) + R123f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R1f.x) + backupReg0f;
+	R1f.x = R7f.x + intBitsToFloat(0xbcdddddf);
+
+	// 3
+	R0f.x = mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[3].x)) + R123f.x;
+	R0f.y = mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[3].x)) + R123f.y;
+	R5f.z = mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[3].x)) + R123f.z;
+	R5f.w = mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[3].x)) + R123f.w;
+	R1f.y = R7f.y;
+
+	// 4
+	R5f.x = R7f.x + intBitsToFloat(0x3ceeeef0);
+	R5f.y = R7f.y;
+	R4f.z = R7f.y;
+	R4f.x = R7f.x + intBitsToFloat(0xbceeeef0);
+	R6f.xyzw = (textureLod(textureUnitPS0, vec2(R6f.x,R6f.z),0.0).xyzw);
+	R3f.xyzw = (textureLod(textureUnitPS0, vec2(R3f.x,R3f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R2f.xyzw = (textureLod(textureUnitPS0, vec2(R5f.x,R5f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].x),R6f.z) + R0f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].x),R6f.y) + R5f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].x),R6f.x) + R5f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].x),R6f.w) + R0f.x;
+	R0f.x = R7f.x + 0.03125;
+
+	// 1
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R3f.w) + R123f.w;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R3f.y) + R123f.y;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R3f.x) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R3f.z) + backupReg0f;
+	R0f.y = R7f.y;
+
+	// 2
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R1f.y) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R1f.x) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R1f.w) + backupReg0f;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R1f.z) + R123f.w;
+	R1f.x = R7f.x + -0.03125;
+
+	// 3
+	R3f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R2f.w) + R123f.z;
+	R3f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R2f.x) + R123f.y;
+	R2f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R2f.z) + R123f.w;
+	R2f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R2f.y) + R123f.x;
+	R1f.y = R7f.y;
+
+	// 4
+	R2f.x = R7f.x + intBitsToFloat(0x3d088889);
+	R2f.y = R7f.y;
+	R6f.z = R7f.y;
+	R6f.x = R7f.x + intBitsToFloat(0xbd088889);
+	R4f.xyzw = (textureLod(textureUnitPS0, vec2(R4f.x,R4f.z),0.0).xyzw);
+	R0f.xyzw = (textureLod(textureUnitPS0, vec2(R0f.x,R0f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R5f.xyzw = (textureLod(textureUnitPS0, vec2(R2f.x,R2f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R4f.x) + R3f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R4f.w) + R3f.x;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R4f.z) + R2f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R4f.y) + R2f.w;
+	R3f.x = R7f.x + intBitsToFloat(0x3d111112);
+
+	// 1
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R0f.x) + R123f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R0f.w) + R123f.y;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R0f.z) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R0f.y) + R123f.w;
+	R3f.y = R7f.y;
+
+	// 2
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R1f.w) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R1f.z) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R1f.y) + R123f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R1f.x) + backupReg0f;
+	R1f.x = R7f.x + intBitsToFloat(0xbd111112);
+
+	// 3
+	R0f.x = mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[4].x)) + R123f.x;
+	R0f.y = mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[4].x)) + R123f.y;
+	R5f.z = mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[4].x)) + R123f.z;
+	R5f.w = mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[4].x)) + R123f.w;
+	R1f.y = R7f.y;
+
+	// 4
+	R5f.x = R7f.x + intBitsToFloat(0x3d19999a);
+	R5f.y = R7f.y;
+	R4f.z = R7f.y;
+	R4f.x = R7f.x + intBitsToFloat(0xbd19999a);
+	R6f.xyzw = (textureLod(textureUnitPS0, vec2(R6f.x,R6f.z),0.0).xyzw);
+	R3f.xyzw = (textureLod(textureUnitPS0, vec2(R3f.x,R3f.y),0.0).xyzw);
+	R1f.xyzw = (textureLod(textureUnitPS0, vec2(R1f.x,R1f.y),0.0).xyzw);
+	R2f.xyzw = (textureLod(textureUnitPS0, vec2(R5f.x,R5f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].x),R6f.z) + R0f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].x),R6f.y) + R5f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].x),R6f.x) + R5f.w;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].x),R6f.w) + R0f.x;
+	R0f.x = R7f.x + intBitsToFloat(0x3d222223);
+
+	// 1
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R3f.w) + R123f.w;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R3f.y) + R123f.y;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R3f.x) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R3f.z) + backupReg0f;
+	R0f.y = R7f.y;
+
+	// 2
+	backupReg0f = R123f.x;
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R1f.y) + R123f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R1f.x) + R123f.z;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R1f.w) + backupReg0f;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R1f.z) + R123f.w;
+	R7f.x = R7f.x + intBitsToFloat(0xbd222223);
+
+	// 3
+	backupReg0f = R2f.x;
+	backupReg1f = R2f.y;
+	R2f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R2f.w) + R123f.z;
+	R2f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),backupReg0f) + R123f.y;
+	R2f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R2f.z) + R123f.w;
+	R2f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),backupReg1f) + R123f.x;
+	R4f.xyzw = (textureLod(textureUnitPS0, vec2(R4f.x,R4f.z),0.0).xyzw);
+	R0f.xyzw = (textureLod(textureUnitPS0, vec2(R0f.x,R0f.y),0.0).xyzw);
+	R7f.xyzw = (textureLod(textureUnitPS0, vec2(R7f.x,R7f.y),0.0).xyzw);
+
+	// 0
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R4f.x) + R2f.y;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R4f.w) + R2f.x;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R4f.z) + R2f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R4f.y) + R2f.w;
+
+	// 1
+	R123f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R0f.x) + R123f.x;
+	R123f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R0f.w) + R123f.y;
+	R123f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R0f.z) + R123f.z;
+	R123f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R0f.y) + R123f.w;
+
+	// 2
+	R7f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R7f.x) + R123f.x;
+	R7f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R7f.y) + R123f.w;
+	R7f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R7f.z) + R123f.z;
+	R7f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R7f.w) + R123f.y;
+
+	// export
+	passPixelColor0 = vec4(R7f.x, R7f.y, R7f.z, R7f.w);
+}

src/TwilightPrincessHD/Enhancements/Bloom/rules.txt

@@ -0,0 +1,434 @@
+[Definition]
+titleIds = 000500001019C800,000500001019E600,000500001019E500
+name = Bloom (Glow) and Shadow World Color Grading
+path = "The Legend of Zelda: Twilight Princess HD/Enhancements/Bloom"
+description = This pack allows you to adjust bloom and color grading in the shadow world.||It's not recommended to fully disable bloom, as it removes the intended tone of the game.|Bloom is particularly strong in the shadow world with a strong yellow tint, but is also used in the normal world.||Color grading only affects the shadow world. By default, the game darkens and desaturates the image in the shadow world to further distinguish it.
+#Credits: KoB-Kirito
+version = 7
+
+
+[Default]
+$bloom_custom = 0
+$bloom_enabled = 1
+$bloom_strength = 1.0
+#$bloom_blur_strength = 1.0
+$bloom_tint_strength = 1.0
+$shadow_world_custom = 0
+$shadow_world_darkening = 1.0
+$shadow_world_desaturation = 1.0
+
+
+# Bloom presets for dummies
+
+[Preset]
+category = Bloom
+name = Very High (Default)
+$bloom_custom = 0
+$bloom_strength = 1.0
+#$bloom_blur_strength = 1.0
+$bloom_tint_strength = 1.0
+
+[Preset]
+category = Bloom
+name = High
+$bloom_custom = 0
+$bloom_strength = 0.8
+#$bloom_blur_strength = 0.8
+$bloom_tint_strength = 0.8
+
+[Preset]
+category = Bloom
+name = Balanced (Recommended)
+$bloom_custom = 0
+$bloom_strength = 0.5
+#$bloom_blur_strength = 0.5
+$bloom_tint_strength = 0.8
+
+[Preset]
+category = Bloom
+name = Low
+$bloom_custom = 0
+$bloom_strength = 0.4
+#$bloom_blur_strength = 0.2
+$bloom_tint_strength = 0.9
+
+[Preset]
+category = Bloom
+name = Very Low
+$bloom_custom = 0
+$bloom_strength = 0.2
+#$bloom_blur_strength = 0.2
+$bloom_tint_strength = 0.9
+
+[Preset]
+category = Bloom
+name = Custom
+$bloom_custom = 1
+
+
+# Overall Bloom Strength (6e2f31b2b2fcab1f)
+
+[Preset]
+category = Bloom Strength
+name = 0% (Disables bloom entirely, not recommended)
+condition = $bloom_custom
+$bloom_enabled = 0
+$bloom_strength = 0.0
+
+[Preset]
+category = Bloom Strength
+name = 10%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 0.1
+
+[Preset]
+category = Bloom Strength
+name = 20%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 0.2
+
+[Preset]
+category = Bloom Strength
+name = 30%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 0.3
+
+[Preset]
+category = Bloom Strength
+name = 40%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 0.4
+
+[Preset]
+category = Bloom Strength
+name = 50% (Recommended)
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 0.5
+
+[Preset]
+category = Bloom Strength
+name = 60%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 0.6
+
+[Preset]
+category = Bloom Strength
+name = 70%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 0.7
+
+[Preset]
+category = Bloom Strength
+name = 80%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 0.8
+
+[Preset]
+category = Bloom Strength
+name = 90%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 0.9
+
+[Preset]
+category = Bloom Strength
+name = 100% (Default)
+default = 1
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 1.0
+
+[Preset]
+category = Bloom Strength
+name = 110%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 1.1
+
+[Preset]
+category = Bloom Strength
+name = 120%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 1.2
+
+[Preset]
+category = Bloom Strength
+name = 150%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 1.5
+
+[Preset]
+category = Bloom Strength
+name = 200%
+condition = $bloom_custom
+$bloom_enabled = 1
+$bloom_strength = 2.0
+
+
+## Blur Strength (ToDo)
+## Strength of the periodic blur would be most useful, some people feel nausatiated by it
+## Would recommend to set bloom higher with this reduced
+## Didn't figure out the shader yet. Most likely better solved via ASM
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 0% (Bloom will stay static)
+#condition = $bloom_enabled
+#$bloom_blur_strength = 0.0
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 10%
+#condition = $bloom_enabled
+#$bloom_blur_strength = 0.1
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 20%
+#condition = $bloom_enabled
+#$bloom_blur_strength = 0.2
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 30%
+#condition = $bloom_enabled
+#$bloom_blur_strength = 0.3
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 40%
+#condition = $bloom_enabled
+#$bloom_blur_strength = 0.4
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 50% (Recommended)
+#condition = $bloom_enabled
+#$bloom_blur_strength = 0.5
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 60%
+#condition = $bloom_enabled
+#$bloom_blur_strength = 0.6
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 70%
+#condition = $bloom_enabled
+#$bloom_blur_strength = 0.7
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 80%
+#condition = $bloom_enabled
+#$bloom_blur_strength = 0.8
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 90%
+#condition = $bloom_enabled
+#$bloom_blur_strength = 0.9
+#
+#[Preset]
+#category = Periodic Bloom Blur
+#name = 100% (Native)
+#condition = $bloom_enabled
+#default = 1
+#$bloom_blur_strength = 1.0
+
+
+# Area Specific Bloom Tint (49865bd2e62efda1)
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 0% (Same white bloom color everywhere)
+condition = $bloom_enabled + $bloom_custom > 1
+$bloom_tint_strength = 0.0
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 10%
+condition = $bloom_enabled + $bloom_custom > 1
+$bloom_tint_strength = 0.1
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 20%
+condition = $bloom_enabled + $bloom_custom > 1
+$bloom_tint_strength = 0.2
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 30%
+condition = $bloom_enabled + $bloom_custom > 1
+$bloom_tint_strength = 0.3
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 40%
+condition = $bloom_enabled + $bloom_custom > 1
+$bloom_tint_strength = 0.4
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 50%
+condition = $bloom_enabled + $bloom_custom > 1
+$bloom_tint_strength = 0.5
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 60%
+condition = $bloom_enabled + $bloom_custom > 1
+$bloom_tint_strength = 0.6
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 70%
+condition = $bloom_enabled + $bloom_custom > 1
+$bloom_tint_strength = 0.7
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 80% (Recommended)
+condition = $bloom_enabled + $bloom_custom > 1
+$bloom_tint_strength = 0.8
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 90%
+condition = $bloom_enabled + $bloom_custom > 1
+$bloom_tint_strength = 0.9
+
+[Preset]
+category = Area-Specific Bloom Tint Strength
+name = 100% (Default)
+condition = $bloom_enabled + $bloom_custom > 1
+default = 1
+$bloom_tint_strength = 1.0
+
+
+
+# Shadow world color grading presets for dummies
+
+[Preset]
+category = Shadow World Color Grading
+name = Very Dark (Default)
+default = 1
+$shadow_world_custom = 0
+$shadow_world_darkening = 1.0
+$shadow_world_desaturation = 1.0
+
+[Preset]
+category = Shadow World Color Grading
+name = Dark
+$shadow_world_custom = 0
+$shadow_world_darkening = 0.75
+$shadow_world_desaturation = 0.75
+
+[Preset]
+category = Shadow World Color Grading
+name = Balanced
+$shadow_world_custom = 0
+$shadow_world_darkening = 0.5
+$shadow_world_desaturation = 0.5
+
+[Preset]
+category = Shadow World Color Grading
+name = Bright (Recommended)
+$shadow_world_custom = 0
+$shadow_world_darkening = 0.25
+$shadow_world_desaturation = 0.5
+
+[Preset]
+category = Shadow World Color Grading
+name = Very Bright
+$shadow_world_custom = 0
+$shadow_world_darkening = 0.0
+$shadow_world_desaturation = 0.5
+
+[Preset]
+category = Shadow World Color Grading
+name = Custom
+$shadow_world_custom = 1
+
+
+# Shadow World Brightness (49865bd2e62efda1)
+# the alpha of the bloom color tint in the shadow world is used to darken the image
+# this is separated, because it is not affected by bloom strength at all
+
+[Preset]
+category = Shadow World Brightness
+name = 60% (Default)
+default = 1
+condition = $shadow_world_custom
+$shadow_world_darkening = 1.0
+
+[Preset]
+category = Shadow World Brightness
+name = 70%
+condition = $shadow_world_custom
+$shadow_world_darkening = 0.75
+
+[Preset]
+category = Shadow World Brightness
+name = 80%
+condition = $shadow_world_custom
+$shadow_world_darkening = 0.5
+
+[Preset]
+category = Shadow World Brightness
+name = 90% (Recommended)
+condition = $shadow_world_custom
+$shadow_world_darkening = 0.25
+
+[Preset]
+category = Shadow World Brightness
+name = 100% (Shadow world as bright as normal world)
+condition = $shadow_world_custom
+$shadow_world_darkening = 0.0
+
+
+# Shadow World Color Desaturation (5f422bf63e25be7f)
+# a custom shader is used exclusivly in the shadow world to desaturate its colors
+
+[Preset]
+category = Shadow World Saturation
+name = 60% (Default)
+default = 1
+condition = $shadow_world_custom
+$shadow_world_desaturation = 1.0
+
+[Preset]
+category = Shadow World Saturation
+name = 70%
+condition = $shadow_world_custom
+$shadow_world_desaturation = 0.75
+
+[Preset]
+category = Shadow World Saturation
+name = 80% (Recommended)
+condition = $shadow_world_custom
+$shadow_world_desaturation = 0.5
+
+[Preset]
+category = Shadow World Saturation
+name = 90%
+condition = $shadow_world_custom
+$shadow_world_desaturation = 0.25
+
+[Preset]
+category = Shadow World Saturation
+name = 100% (Shadow world as saturated as normal world)
+condition = $shadow_world_custom
+$shadow_world_desaturation = 0.0

src/TwilightPrincessHD/Enhancements/Contrasty/c14019840473ff86_00000000000003c9_ps.txt

@@ -0,0 +1,245 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader c14019840473ff86
+// start of shader inputs/outputs, predetermined by Cemu. Do not touch
+#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 vec4 uf_fragCoordScale;
+};
+#else
+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 = 0) out vec4 passPixelColor0;
+// end of shader inputs/outputs
+
+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;
+}
+
+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 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;
+float scaleRes = uf_fragCoordScale.x;
+R0f = passParameterSem0;
+R0f.w = (textureGather(textureUnitPS1, R0f.xy).y);
+// 0
+R1f.x = R0f.x + intBitsToFloat(0xba088889);
+R1f.y = R0f.y + intBitsToFloat(0xba72b9d6);
+R2f.z = R0f.x;
+R2f.y = R0f.y + intBitsToFloat(0xba72b9d6);
+PS0f = R2f.y;
+// 1
+R3f.x = R0f.x + intBitsToFloat(0xba088889);
+R3f.y = R0f.y;
+R1f.xyzw = (textureGather(textureUnitPS1, R1f.xy).xyzw);
+R2f.yz = (textureGather(textureUnitPS1, R2f.zy).yz);
+R3f.xy = (textureGather(textureUnitPS1, R3f.xy).xy);
+// 0
+PV0f.x = R2f.z + R3f.x;
+PV0f.y = R1f.w + R0f.w;
+PV0f.z = R1f.z + R3f.y;
+PV0f.w = R1f.x + R2f.y;
+// 1
+R123f.x = (R1f.y * 2.0 + -(PV0f.x));
+PV1f.x = R123f.x;
+R123f.y = (R1f.y * 2.0 + -(PV0f.y));
+PV1f.y = R123f.y;
+R123f.z = (R1f.y * 2.0 + -(PV0f.z));
+PV1f.z = R123f.z;
+R123f.w = (R1f.y * 2.0 + -(PV0f.w));
+PV1f.w = R123f.w;
+// 2
+PV0f.x = max(PV1f.x, -(PV1f.x));
+PV0f.y = max(PV1f.y, -(PV1f.y));
+PV0f.z = max(PV1f.z, -(PV1f.z));
+PV0f.w = max(PV1f.w, -(PV1f.w));
+// 3
+PV1f.x = PV0f.x + intBitsToFloat(0xb400d959);
+PV1f.y = PV0f.y + intBitsToFloat(0xb400d959);
+PV1f.z = PV0f.z + intBitsToFloat(0xb400d959);
+PV1f.w = PV0f.w + intBitsToFloat(0xb400d959);
+// 4
+R123f.x = intBitsToFloat(((PV1f.w >= 0.0)?(floatBitsToInt(1.0)):(0)));
+PV0f.x = R123f.x;
+R123f.y = intBitsToFloat(((PV1f.z >= 0.0)?(floatBitsToInt(1.0)):(0)));
+PV0f.y = R123f.y;
+R123f.z = intBitsToFloat(((PV1f.y >= 0.0)?(floatBitsToInt(1.0)):(0)));
+PV0f.z = R123f.z;
+R123f.w = intBitsToFloat(((PV1f.x >= 0.0)?(floatBitsToInt(1.0)):(0)));
+PV0f.w = R123f.w;
+// 5
+tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(0.25,0.25,0.25,0.25));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+// 6
+R127f.z = PV1f.x * intBitsToFloat(0x3f400000)* scaleRes;
+PV0f.z = R127f.z;
+// 7
+R1f.x = (PV0f.z * intBitsToFloat(0xba088889) * scaleRes + R0f.x);
+R1f.y = R0f.y;
+R2f.z = R0f.x;
+R2f.y = (PV0f.z * intBitsToFloat(0xba72b9d6) * scaleRes + R0f.y);
+PS1f = R2f.y;
+// 8
+R3f.x = (R127f.z * intBitsToFloat(0x3a088889) * scaleRes + R0f.x);
+R3f.y = R0f.y;
+R0f.w = (R127f.z * intBitsToFloat(0x3a72b9d6) * scaleRes + R0f.y);
+R1f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
+R2f.xyzw = (texture(textureUnitPS0, R2f.zy).xyzw);
+R3f.xyzw = (texture(textureUnitPS0, R3f.xy).xyzw);
+R0f.xyzw = (texture(textureUnitPS0, R0f.xw).xyzw);
+// 0
+PV0f.x = R1f.w + R2f.w;
+PV0f.y = R1f.z + R2f.z;
+PV0f.z = R1f.y + R2f.y;
+PV0f.w = R1f.x + R2f.x;
+// 1
+PV1f.x = R3f.w + PV0f.x;
+PV1f.y = R3f.z + PV0f.y;
+PV1f.z = R3f.y + PV0f.z;
+PV1f.w = R3f.x + PV0f.w;
+// 2
+backupReg0f = R0f.y;
+backupReg1f = R0f.x;
+PV0f.x = R0f.w + PV1f.x;
+PV0f.y = R0f.z + PV1f.y;
+PV0f.z = backupReg0f + PV1f.z;
+PV0f.w = backupReg1f + PV1f.w;
+// 3
+R0f.x = PV0f.w * 0.25;
+R0f.y = PV0f.z * 0.25;
+R0f.z = PV0f.y * 0.25;
+R0f.w = PV0f.x * 0.25;
+// export
+
+R0f.xyz = contrasty(R0f.xyz);
+R0f.xyz = mix(R0f.xyz, smoothstep(0.0, 1.0, R0f.xyz), contrastCurve);
+float smask = lumasharping(textureUnitPS0, passParameterSem0.xy);
+vec3 temp3 = R0f.xyz;
+R0f.xyz = mix(R0f.xyz, (temp3.xyz += (smask)), sharp_mix);
+
+passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+}

src/TwilightPrincessHD/Enhancements/Contrasty/rules.txt

@@ -0,0 +1,208 @@
+[Definition]
+titleIds = 000500001019C800,000500001019E600,000500001019E500
+name = Contrasty
+path = "The Legend of Zelda: Twilight Princess 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
+
+[Preset]
+name = default
+
+[Preset] # Preserve original washed out look, but balances bloom white point towards neutral
+name = Neutral Hi-lights
+$redShadows = 1.0
+$greenShadows = 1.0 #1.01
+$blueSadows = 1.01 #1.02
+$redMid = 0.98
+$greenMid = 0.99
+$blueMid = 1.01
+$redHilight = 1.0
+$greenHilight = 1.01 #.86
+$blueHilight = 1.15
+
+$contrastCurve = 0.0
+$hazeFactor = 0.1
+# $bloom = 1.0
+$gamma = 1.0
+$exposure = 1.0
+$vibrance = 0.25
+$crushContrast = 0.0
+# $bleach = 0.85
+$sharp_mix = 0.0
+
+[Preset] #Warm and washed out light-sources and bloom, original look "enhanced".
+name = Warm glow
+$redShadows = 1.0
+$greenShadows = 1.0
+$blueSadows = 1.0
+$redMid = 0.98
+$greenMid = 0.98
+$blueMid = 1.0
+$redHilight = 1.0
+$greenHilight =1.0
+$blueHilight = 1.0
+
+$contrastCurve = 0.5
+$hazeFactor = 0.71
+# $bloom = 0.85
+$gamma = 1.1
+$exposure = 1.07
+$vibrance = 0.15
+$crushContrast = 0.00
+# $bleach = 0.85
+$sharp_mix = 0.05
+
+[Preset] # Colourful midway between original and cold
+name = Warm / Colorful
+$redShadows = 0.96
+$greenShadows = 0.97
+$blueSadows = 1.01
+$redMid = 0.94
+$greenMid = 0.96
+$blueMid = 1.01
+$redHilight = 0.97
+$greenHilight = 0.99
+$blueHilight = 1.01
+
+$contrastCurve = 0.25
+$hazeFactor = 0.1
+# $bloom = 1.0
+$gamma = 1.075
+$exposure = 1.01
+$vibrance = 0.55
+$crushContrast = 0.0
+# $bleach = 0.85
+$sharp_mix = 0.05
+
+[Preset] #Neutral/cold white point, light and shadows interplay, caves are dark. Some discoloration of multi layer fx
+name = Cold
+$redShadows = 0.99 #0.99
+$greenShadows = 1.0 # 1.0
+$blueSadows = 1.0 #1.0 #1.01
+$redMid = 0.88 #0.87
+$greenMid = 0.925 #0.9 #0.88
+$blueMid = 1.0
+$redHilight = 1.0
+$greenHilight = 1.01 #.86
+$blueHilight = 1.11 #1.14
+
+$contrastCurve = 0.25
+$hazeFactor = 0.1
+
+$gamma = 1.025
+$exposure = 1.025
+$vibrance = 0.48
+$crushContrast = 0.0
+# $bleach = 0.875
+$sharp_mix = 0.00
+
+[Preset] #Warm colour palette, light and shadows interplay, caves are dark.
+name = Warm contrast crush
+$redShadows = 1.0 #1.02 #0.99
+$greenShadows = 1.0 #1.05 # 1.0
+$blueSadows = 0.98 #1.0 #1.01
+$redMid = 0.96 #0.87
+$greenMid = 1.04 #0.9 #0.88
+$blueMid = 1.10
+$redHilight = 0.99
+$greenHilight = 0.99 #.86
+$blueHilight = 1.05 #1.14
+
+$contrastCurve = 0.75
+$hazeFactor = 0.1
+# $bloom = 0.975
+$gamma = 1.03
+$exposure = 1.01
+$vibrance = 0.25
+$crushContrast = 0.0
+# $bleach = 0.875
+$sharp_mix = 0.00
+
+[Preset] #Neutral/cold white point, light and shadows interplay, caves are dark. Some discoloration of multi layer fx
+name = Cold contrast crush
+$redShadows = 1.01 #1.02 #0.99
+$greenShadows = 1.03 #1.05 # 1.0
+$blueSadows = 1.04 #1.0 #1.01
+$redMid = 0.99 #0.87
+$greenMid = 1.06 #0.9 #0.88
+$blueMid = 1.12
+$redHilight = 0.98
+$greenHilight = 0.97 #.86
+$blueHilight = 1.08 #1.14
+
+$contrastCurve = 0.75
+$hazeFactor = 0.1
+# $bloom = 0.975
+$gamma = 1.01
+$exposure = 1.01
+$vibrance = 0.29
+$crushContrast = 0.0
+# $bleach = 0.875
+$sharp_mix = 0.00
+
+[Preset] #Neutral/cold white point, light and shadows interplay, caves are dark. Some discoloration of multi layer fx
+name = Cold contrast preserve highlights
+$redShadows = 1.01 #1.02 #0.99
+$greenShadows = 1.02 #1.05 # 1.0
+$blueSadows = 1.04 #1.0 #1.01
+$redMid = 0.97 #0.87
+$greenMid = 1.06 #0.9 #0.88
+$blueMid = 1.14
+$redHilight = 0.98
+$greenHilight = 0.97 #.86
+$blueHilight = 1.09 #1.14
+
+$contrastCurve = 0.25
+$hazeFactor = 0.1
+# $bloom = 0.975
+$gamma = 0.75
+$exposure = 1.125
+$vibrance = 0.35
+$crushContrast = 0.0
+# $bleach = 0.875
+$sharp_mix = 0.00
+
+
+[Preset] # jff
+name = Skyward Swordish
+$redShadows = 0.95
+$greenShadows = 0.95
+$blueSadows = 1.0
+$redMid = 0.95
+$greenMid = 0.97
+$blueMid = 1.04
+$redHilight = 0.99
+$greenHilight =1.0
+$blueHilight = 1.01
+
+$contrastCurve = 0.95
+$hazeFactor = 0.71
+# $bloom = 0.85
+$gamma = 1.25
+$exposure = 1.1
+$vibrance = 1.25
+$crushContrast = 0.00
+# $bleach = 0.85
+$sharp_mix = 0.05

src/TwilightPrincessHD/Enhancements/Contrasty/unused_49865bd2e62efda1_0000000000000079_ps.txt

@@ -0,0 +1,82 @@
+#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 49865bd2e62efda1
+//dark world bloom
+
+const float bloom = $bloom;
+#ifdef VULKAN
+layout(set = 1, binding = 1) uniform ufBlock
+{
+uniform ivec4 uf_remappedPS[1];
+uniform vec4 uf_fragCoordScale;
+};
+#else
+uniform ivec4 uf_remappedPS[1];
+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;
+// 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);
+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 = (textureLod(textureUnitPS0, R0f.xy,0.0).xyz)*bloom;
+// 0
+backupReg0f = R0f.y;
+backupReg1f = R0f.x;
+PV0f.x = mul_nonIEEE(R0f.z, intBitsToFloat(uf_remappedPS[0].z));
+PV0f.y = mul_nonIEEE(backupReg0f, intBitsToFloat(uf_remappedPS[0].y));
+PV0f.z = mul_nonIEEE(backupReg1f, intBitsToFloat(uf_remappedPS[0].x));
+PV0f.w = intBitsToFloat(uf_remappedPS[0].w);
+// 1
+PV1f.x = max(PV0f.w, 0.0);
+PV1f.y = max(PV0f.x, 0.0);
+PV1f.z = max(PV0f.y, 0.0);
+PV1f.w = max(PV0f.z, 0.0);
+// 2
+R0f.x = min(PV1f.w, 1.0);
+R0f.y = min(PV1f.z, 1.0);
+R0f.z = min(PV1f.y, 1.0);
+R0f.w = min(PV1f.x, 1.0);
+// export
+passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+}

src/TwilightPrincessHD/Enhancements/Contrasty/unused_5f422bf63e25be7f_0000000000000079_ps.txt

@@ -0,0 +1,88 @@
+#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 5f422bf63e25be7f // Bleach pass cutscene
+
+const float bleach = $bleach;
+
+#ifdef VULKAN
+layout(set = 1, binding = 1) uniform ufBlock
+{
+uniform ivec4 uf_remappedPS[1];
+uniform vec4 uf_fragCoordScale;
+};
+#else
+uniform ivec4 uf_remappedPS[1];
+uniform vec2 uf_fragCoordScale;
+#endif
+TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
+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);
+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;
+R0f.w = (texture(textureUnitPS0, R0f.xy).x);
+// 0
+PV0f.x = intBitsToFloat(uf_remappedPS[0].x) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[0].z) * intBitsToFloat(0x3f7f0000);
+PV0f.w = intBitsToFloat(uf_remappedPS[0].y) * intBitsToFloat(0x3f7f0000);
+R1f.w = intBitsToFloat(uf_remappedPS[0].w);
+R1f.w = clamp(R1f.w, 0.0, 1.0);
+PS0f = R1f.w;
+// 1
+PV1f.x = fract(PV0f.w);
+PV1f.y = fract(PV0f.x);
+PV1f.w = fract(PV0f.z);
+// 2
+PV0f.x = PV1f.w * intBitsToFloat(0x3f808081);
+PV0f.y = PV1f.x * intBitsToFloat(0x3f808081);
+PV0f.z = PV1f.y * intBitsToFloat(0x3f808081);
+// 3
+R1f.x = mul_nonIEEE(R0f.w, PV0f.z);
+R1f.x = clamp(R1f.x, 0.0, 1.0);
+R1f.y = mul_nonIEEE(R0f.w, PV0f.y);
+R1f.y = clamp(R1f.y, 0.0, 1.0);
+R1f.z = mul_nonIEEE(R0f.w, PV0f.x);
+R1f.z = clamp(R1f.z, 0.0, 1.0);
+// export
+passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w) * bleach;
+}

src/TwilightPrincessHD/Enhancements/Contrasty/unused_95a5a89d62998e0d_0000000000000079_ps.txt

@@ -0,0 +1,367 @@
+#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 95a5a89d62998e0d
+
+// blur
+const float bloom = $bloom;
+
+#ifdef VULKAN
+layout(set = 1, binding = 1) 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;
+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 R7f = vec4(0.0);
+vec4 R123f = 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;
+float scaler;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = GET_FRAGCOORD();
+scaler =  uf_fragCoordScale.x;
+// 0
+R7f.x = R0f.x * intBitsToFloat(0x3b088889);
+PV0f.x = R7f.x;
+R7f.y = R0f.y * intBitsToFloat(0x3b72b9d6);
+PV0f.y = R7f.y;
+// 1
+R0f.x = PV0f.x;
+R0f.y = PV0f.y + intBitsToFloat(0x3b72b9d6) * scaler;
+R1f.z = PV0f.x;
+R1f.y = PV0f.y + intBitsToFloat(0xbb72b9d6) * scaler;
+PS1f = R1f.y;
+// 2
+R2f.x = R7f.x;
+R2f.y = R7f.y + intBitsToFloat(0x3bf2b9d6) * scaler;
+R4f.z = R7f.x;
+R4f.y = R7f.y + intBitsToFloat(0xbbf2b9d6) * scaler;
+PS0f = R4f.y;
+R3f.xyzw = (textureLod(textureUnitPS0, R7f.xy,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.zy,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+backupReg0f = R0f.x;
+backupReg1f = R0f.w;
+PV0f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.y);
+PV0f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.z);
+PV0f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), backupReg0f);
+PV0f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), backupReg1f);
+R0f.y = R7f.y + intBitsToFloat(0x3c360b60) * scaler;
+PS0f = R0f.y;
+// 1
+R123f.x = (mul_nonIEEE(R3f.y,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.x);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(R3f.w,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.w);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(R3f.x,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(R3f.z,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.y);
+PV1f.w = R123f.w;
+R0f.x = R7f.x;
+PS1f = R0f.x;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.y) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.w) + PV1f.y);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R1f.y = R7f.y + intBitsToFloat(0xbc360b60) * scaler;
+PS0f = R1f.y;
+// 3
+backupReg0f = R2f.z;
+R3f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.x) + PV0f.y);
+R3f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.y) + PV0f.x);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.w) + PV0f.z);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),backupReg0f) + PV0f.w);
+R1f.x = R7f.x;
+PS1f = R1f.x;
+// 4
+R2f.x = R7f.x;
+R2f.y = R7f.y + intBitsToFloat(0x3c72b9d6) * scaler;
+R6f.z = R7f.x;
+R6f.y = R7f.y + intBitsToFloat(0xbc72b9d6) * scaler;
+PS0f = R6f.y;
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.zy,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R5f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.x) + R3f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.w) + R2f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.z) + R2f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.y) + R3f.y);
+PV0f.w = R123f.w;
+R3f.y = R7f.y + intBitsToFloat(0x3c97b426) * scaler;
+PS0f = R3f.y;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.w) + PV0f.y);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.x) + PV0f.x);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+R3f.x = R7f.x;
+PS1f = R3f.x;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.w) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.z) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.y) + PV1f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.x) + PV1f.y);
+PV0f.w = R123f.w;
+R1f.y = R7f.y + intBitsToFloat(0xbc97b426) * scaler;
+PS0f = R1f.y;
+// 3
+R0f.x = (mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.y);
+R0f.y = (mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.x);
+R5f.z = (mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.z);
+R5f.w = (mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.w);
+R1f.x = R7f.x;
+PS1f = R1f.x;
+// 4
+R5f.x = R7f.x;
+R5f.y = R7f.y + intBitsToFloat(0x3cb60b60) * scaler;
+R4f.z = R7f.x;
+R4f.y = R7f.y + intBitsToFloat(0xbcb60b60) * scaler;
+PS0f = R4f.y;
+R6f.xyzw = (textureLod(textureUnitPS0, R6f.zy,0.0).xyzw);
+R3f.xyzw = (textureLod(textureUnitPS0, R3f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R5f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.z) + R0f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.y) + R5f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.x) + R5f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.w) + R0f.y);
+PV0f.w = R123f.w;
+R0f.y = R7f.y + intBitsToFloat(0x3cd4629b) * scaler;
+PS0f = R0f.y;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.y) + PV0f.y);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.w) + PV0f.w);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.x) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.z) + PV0f.x);
+PV1f.w = R123f.w;
+R0f.x = R7f.x;
+PS1f = R0f.x;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.y) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.w) + PV1f.y);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R1f.y = R7f.y + intBitsToFloat(0xbcd4629b) * scaler;
+PS0f = R1f.y;
+// 3
+backupReg0f = R2f.z;
+R3f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.x) + PV0f.y);
+R3f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.y) + PV0f.x);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.w) + PV0f.z);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),backupReg0f) + PV0f.w);
+R1f.x = R7f.x;
+PS1f = R1f.x;
+// 4
+R2f.x = R7f.x;
+R2f.y = R7f.y + intBitsToFloat(0x3cf2b9d6) * scaler;
+R6f.z = R7f.x;
+R6f.y = R7f.y + intBitsToFloat(0xbcf2b9d6) * scaler;
+PS0f = R6f.y;
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.zy,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R5f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.x) + R3f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.w) + R2f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.z) + R2f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.y) + R3f.y);
+PV0f.w = R123f.w;
+R3f.y = R7f.y + intBitsToFloat(0x3d088888) * scaler;
+PS0f = R3f.y;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.w) + PV0f.y);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.x) + PV0f.x);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+R3f.x = R7f.x;
+PS1f = R3f.x;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.w) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.z) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.y) + PV1f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.x) + PV1f.y);
+PV0f.w = R123f.w;
+R1f.y = R7f.y + intBitsToFloat(0xbd088888) * scaler;
+PS0f = R1f.y;
+// 3
+R0f.x = (mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.y);
+R0f.y = (mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.x);
+R5f.z = (mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.z);
+R5f.w = (mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.w);
+R1f.x = R7f.x;
+PS1f = R1f.x;
+// 4
+R5f.x = R7f.x;
+R5f.y = R7f.y + intBitsToFloat(0x3d17b426) * scaler;
+R4f.z = R7f.x;
+R4f.y = R7f.y + intBitsToFloat(0xbd17b426) * scaler;
+PS0f = R4f.y;
+R6f.xyzw = (textureLod(textureUnitPS0, R6f.zy,0.0).xyzw);
+R3f.xyzw = (textureLod(textureUnitPS0, R3f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R5f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.z) + R0f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.y) + R5f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.x) + R5f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.w) + R0f.y);
+PV0f.w = R123f.w;
+R0f.y = R7f.y + intBitsToFloat(0x3d26dfc3) * scaler;
+PS0f = R0f.y;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.y) + PV0f.y);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.w) + PV0f.w);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.x) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.z) + PV0f.x);
+PV1f.w = R123f.w;
+R0f.x = R7f.x;
+PS1f = R0f.x;
+// 2
+backupReg0f = R7f.y;
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.y) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.w) + PV1f.y);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R7f.y = backupReg0f + intBitsToFloat(0xbd26dfc3) * scaler;
+PS0f = R7f.y;
+// 3
+backupReg0f = R2f.x;
+backupReg1f = R2f.y;
+backupReg2f = R2f.z;
+R2f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),backupReg0f) + PV0f.y);
+R2f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),backupReg1f) + PV0f.x);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.w) + PV0f.z);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),backupReg2f) + PV0f.w);
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.zy,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R7f.xyzw = (textureLod(textureUnitPS0, R7f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.x) + R2f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.w) + R2f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.z) + R2f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.y) + R2f.y);
+PV0f.w = R123f.w;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.w) + PV0f.y);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.x) + PV0f.x);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+// 2
+backupReg0f = R7f.x;
+backupReg1f = R7f.y;
+backupReg2f = R7f.z;
+backupReg3f = R7f.w;
+R7f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),backupReg0f) + PV1f.y);
+R7f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),backupReg1f) + PV1f.w);
+R7f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),backupReg2f) + PV1f.z);
+R7f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),backupReg3f) + PV1f.x);
+// export
+passPixelColor0 = vec4(R7f.x, R7f.y, R7f.z, R7f.w)* bloom;
+}

src/TwilightPrincessHD/Enhancements/Contrasty/unused_e334517825fdd599_0000000000000079_ps.txt

@@ -0,0 +1,130 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader e334517825fdd599
+//water, sun, fog.
+uniform vec2 uf_fragCoordScale;
+
+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;
+}
+
+
+
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4001000 res 1920x1080x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0
+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.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+// export
+R0f.xyz = contrasty(R0f.xyz);
+//R0f.xyz = mix(R0f.xyz, smoothstep(0.0, 1.0, R0f.xyz), 0.25); //contrast difference between heat haze and sky
+
+passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+}

src/TwilightPrincessHD/Enhancements/NegativeLOD/rules.txt

@@ -0,0 +1,68 @@
+[Definition]
+titleIds = 000500001019C800,000500001019E600,000500001019E500
+name = Level of detail
+path = "The Legend of Zelda: Twilight Princess HD/Enhancements/Negative Texture LOD"
+description = Sharper textures at risk of shimmering when set too high.|Made by getdls.
+#Credits: getdls
+version = 6
+
+[Default]
+$0x031 = 0
+$0x033 = 0
+$0x034 = 0
+$0x035 = 0
+$0x01a = 0
+
+[Preset]
+name = LOD +2 (Simulate WiiU LOD on higher resolution)
+$0x031 = +2
+$0x033 = +2
+$0x034 = +2
+$0x035 = +2
+$0x01a = 0
+
+[Preset]
+name = LOD Default
+
+[Preset]
+name = LOD -0.5 (Sharper)
+$0x031 = -.5
+$0x033 = -.5
+$0x034 = -.5
+$0x035 = -.5
+$0x01a = -.5
+[Preset]
+name = LOD -1 (Super Sharp)
+$0x031 = -1
+$0x033 = -1
+$0x034 = -1
+$0x035 = -1
+$0x01a = -1
+
+[Preset]
+name = LOD -4 (Overkill - For screenshots)
+$0x031 = -4
+$0x033 = -4
+$0x034 = -4
+$0x035 = -4
+$0x01a = -4
+
+[TextureRedefine]
+formats = 0x031 #0x431,0x432,0x433,0x434,0x435 not used.
+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 = 0x01a
+overwriteRelativeLodBias = $0x01a

src/TwilightPrincessHD/Graphics/15e4acf324eb0912_0000000000000000_vs.txt

@@ -0,0 +1,150 @@
+#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 15e4acf324eb0912 missing
+//map mission objectives missing
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem1;
+layout(location = 1) 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 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)));
+// skipped unused attribute for r5
+attrDecoder.xy = attrDataSem2.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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R1f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R0f.x = 0.0;
+PS0f = R0f.x;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R3f.x = R2f.x;
+PS1f = R3f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+R3f.y = R2f.y;
+PS0f = R3f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+R3f.z = R127f.w;
+PS1f = R3f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+// skipped export to semanticId 255
+// export
+passParameterSem1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
+// export
+passParameterSem2 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
+}

src/TwilightPrincessHD/Graphics/18893ce415f2fcc7_0000000000000000_vs.txt

@@ -0,0 +1,149 @@
+#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 18893ce415f2fcc7
+//Map icon position
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem1;
+layout(location = 1) 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 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)));
+// skipped unused attribute for r8
+attrDecoder.xy = attrDataSem2.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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R1f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R0f.x = 0.0;
+PS0f = R0f.x;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R3f.x = R2f.x;
+PS1f = R3f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+R3f.y = R2f.y;
+PS0f = R3f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+R3f.z = R127f.w;
+PS1f = R3f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+// skipped export to semanticId 255
+// export
+passParameterSem1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
+// export
+passParameterSem2 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
+}

src/TwilightPrincessHD/Graphics/1caed2ca3d14f36b_0000000000000000_vs.txt

@@ -0,0 +1,159 @@
+#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 1caed2ca3d14f36b
+//object box bg 2
+
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[10];
+};
+#else
+uniform ivec4 uf_remappedVS[10];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem2;
+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 R3f = 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 = attrDataSem2.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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R127f.w = R1f.w;
+PS0f = R127f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R2f.z = 1.0;
+PS1f = R2f.z;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+PS0f = 1.0;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R3f.z = PS0f;
+PS1f = R3f.z;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// 7
+R0f.xyz = vec3(intBitsToFloat(uf_remappedVS[7].x),intBitsToFloat(uf_remappedVS[7].y),intBitsToFloat(uf_remappedVS[7].z));
+R0f.w = intBitsToFloat(uf_remappedVS[7].w);
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+passParameterSem0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// 0
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.z),vec4(intBitsToFloat(uf_remappedVS[8].x),intBitsToFloat(uf_remappedVS[8].y),intBitsToFloat(uf_remappedVS[8].z),intBitsToFloat(uf_remappedVS[8].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.z),vec4(intBitsToFloat(uf_remappedVS[9].x),intBitsToFloat(uf_remappedVS[9].y),intBitsToFloat(uf_remappedVS[9].z),intBitsToFloat(uf_remappedVS[9].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R3f.x = PV0f.x;
+PS1f = R3f.x;
+// 2
+R3f.y = PV1f.x;
+// export
+passParameterSem1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
+}

src/TwilightPrincessHD/Graphics/24b09ef9b11b98d5_0000000000000000_vs.txt

@@ -0,0 +1,148 @@
+#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 24b09ef9b11b98d5
+//UI text front
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+const float UItransp = $UItransp;
+
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+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 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R2f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R2f.x = R3f.x;
+PS0f = R2f.x;
+// 3
+R3f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R3f.x;
+PV1f.y = R3f.x;
+PV1f.z = R3f.x;
+PV1f.w = R3f.x;
+R2f.y = R3f.y;
+PS1f = R2f.y;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R3f.y = tempf.x;
+R2f.z = R127f.w;
+PS0f = R2f.z;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R3f.z = tempf.x;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R3f.w = tempf.x;
+// export
+SET_POSITION(vec4(R3f.x*UIx, R3f.y*UIy, R3f.z, R3f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w*UItransp);
+// export
+passParameterSem1 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
+}

src/TwilightPrincessHD/Graphics/27b429c755f71162_0000000000000000_vs.txt

@@ -0,0 +1,197 @@
+#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 27b429c755f71162
+//Map arrows
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[11];
+};
+#else
+uniform ivec4 uf_remappedVS[11];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) out vec4 passParameterSem2;
+layout(location = 2) 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);
+vec4 R3f = vec4(0.0);
+vec4 R4f = vec4(0.0);
+vec4 R5f = 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R127f.w = R2f.w;
+PS0f = R127f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R0f.z = 1.0;
+PS1f = R0f.z;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R126f.z = tempf.x;
+R127f.z = 1.0;
+PS0f = R127f.z;
+// 3
+R2f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R2f.x;
+PV1f.y = R2f.x;
+PV1f.z = R2f.x;
+PV1f.w = R2f.x;
+R126f.w = 1.0;
+PS1f = R126f.w;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R126f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.y = tempf.x;
+R0f.y = 0.0;
+PS0f = R0f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R126f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R2f.z = tempf.x;
+R4f.z = R127f.z;
+PS1f = R4f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R126f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.w = tempf.x;
+R5f.z = R126f.w;
+PS0f = R5f.z;
+// export
+SET_POSITION(vec4(R2f.x*UIx, R2f.y*UIy, R2f.z, R2f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+// export
+// skipped export to semanticId 255
+// 0
+backupReg0f = R0f.z;
+backupReg0f = R0f.z;
+tempf.x = dot(vec4(R3f.x,R3f.y,backupReg0f,backupReg0f),vec4(intBitsToFloat(uf_remappedVS[7].x),intBitsToFloat(uf_remappedVS[7].y),intBitsToFloat(uf_remappedVS[7].z),intBitsToFloat(uf_remappedVS[7].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+// 1
+backupReg0f = R0f.z;
+backupReg0f = R0f.z;
+tempf.x = dot(vec4(R3f.x,R3f.y,backupReg0f,backupReg0f),vec4(intBitsToFloat(uf_remappedVS[8].x),intBitsToFloat(uf_remappedVS[8].y),intBitsToFloat(uf_remappedVS[8].z),intBitsToFloat(uf_remappedVS[8].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R4f.x = PV0f.x;
+PS1f = R4f.x;
+// 2
+backupReg0f = R0f.z;
+backupReg0f = R0f.z;
+tempf.x = dot(vec4(R3f.x,R3f.y,backupReg0f,backupReg0f),vec4(intBitsToFloat(uf_remappedVS[9].x),intBitsToFloat(uf_remappedVS[9].y),intBitsToFloat(uf_remappedVS[9].z),intBitsToFloat(uf_remappedVS[9].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R4f.y = PV1f.x;
+PS0f = R4f.y;
+// 3
+backupReg0f = R0f.z;
+backupReg0f = R0f.z;
+tempf.x = dot(vec4(R3f.x,R3f.y,backupReg0f,backupReg0f),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R5f.x = PV0f.x;
+PS1f = R5f.x;
+// 4
+R5f.y = PV1f.x;
+// export
+passParameterSem2 = vec4(R4f.x, R4f.y, R4f.z, R4f.w);
+// export
+passParameterSem3 = vec4(R5f.x, R5f.y, R5f.z, R5f.w);
+}

src/TwilightPrincessHD/Graphics/4f5f72f9eec53a90_0000000000000000_vs.txt

@@ -0,0 +1,165 @@
+#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 4f5f72f9eec53a90
+//BG box 3
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[9];
+};
+#else
+uniform ivec4 uf_remappedVS[9];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) 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 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R2f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R3f.z = 1.0;
+PS1f = R3f.z;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R127f.w = 1.0;
+PS0f = R127f.w;
+// 3
+R2f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R2f.x;
+PV1f.y = R2f.x;
+PV1f.z = R2f.x;
+PV1f.w = R2f.x;
+R0f.z = 0.0;
+PS1f = R0f.z;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.y = tempf.x;
+R4f.z = R127f.w;
+PS0f = R4f.z;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R2f.z = tempf.x;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.w = tempf.x;
+// export
+SET_POSITION(vec4(R2f.x*UIx, R2f.y*UIy, R2f.z, R2f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+// export
+// skipped export to semanticId 255
+// 0
+tempf.x = dot(vec4(R3f.x,R3f.y,R3f.z,R3f.z),vec4(intBitsToFloat(uf_remappedVS[7].x),intBitsToFloat(uf_remappedVS[7].y),intBitsToFloat(uf_remappedVS[7].z),intBitsToFloat(uf_remappedVS[7].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+// 1
+tempf.x = dot(vec4(R3f.x,R3f.y,R3f.z,R3f.z),vec4(intBitsToFloat(uf_remappedVS[8].x),intBitsToFloat(uf_remappedVS[8].y),intBitsToFloat(uf_remappedVS[8].z),intBitsToFloat(uf_remappedVS[8].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R4f.x = PV0f.x;
+PS1f = R4f.x;
+// 2
+R4f.y = PV1f.x;
+// export
+passParameterSem2 = vec4(R4f.x, R4f.y, R4f.z, R4f.w);
+}

src/TwilightPrincessHD/Graphics/5f2ae4dbd2256d0c_0000000000000000_vs.txt

@@ -0,0 +1,146 @@
+#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 5f2ae4dbd2256d0c
+//minimap
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem1;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){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)));
+// skipped unused attribute for r8
+attrDecoder.xy = attrDataSem2.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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R1f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R3f.x = 0.0;
+PS0f = R3f.x;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R0f.x = R2f.x;
+PS1f = R0f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+R0f.y = R2f.y;
+PS0f = R0f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+R0f.z = R127f.w;
+PS1f = R0f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+passParameterSem1 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+}

src/TwilightPrincessHD/Graphics/6dc0977212eae7b3_0000000000000000_vs.txt

@@ -0,0 +1,153 @@
+#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 6dc0977212eae7b3
+//hearts
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+const float UItransp = $UItransp;
+
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) 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 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R2f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R4f.x = 0.0;
+PS0f = R4f.x;
+// 3
+R2f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R2f.x;
+PV1f.y = R2f.x;
+PV1f.z = R2f.x;
+PV1f.w = R2f.x;
+R0f.x = R3f.x;
+PS1f = R0f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.y = tempf.x;
+R0f.y = R3f.y;
+PS0f = R0f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R2f.z = tempf.x;
+R0f.z = R127f.w;
+PS1f = R0f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.w = tempf.x;
+// export
+SET_POSITION(vec4(R2f.x*UIx, R2f.y*UIy, R2f.z, R2f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w*UItransp);
+// export
+passParameterSem2 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+}

src/TwilightPrincessHD/Graphics/70e776430cd020a9_0000000000000000_vs.txt

@@ -0,0 +1,165 @@
+#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 70e776430cd020a9
+//box bg 5
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[10];
+};
+#else
+uniform ivec4 uf_remappedVS[10];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) 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 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 = attrDataSem2.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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R1f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R3f.z = 1.0;
+PS1f = R3f.z;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R127f.w = 1.0;
+PS0f = R127f.w;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R2f.z = 0.0;
+PS1f = R2f.z;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+R4f.z = R127f.w;
+PS0f = R4f.z;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// 7
+R0f.xyz = vec3(intBitsToFloat(uf_remappedVS[7].x),intBitsToFloat(uf_remappedVS[7].y),intBitsToFloat(uf_remappedVS[7].z));
+R0f.w = intBitsToFloat(uf_remappedVS[7].w);
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+passParameterSem0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+// 0
+tempf.x = dot(vec4(R2f.x,R2f.y,R3f.z,R3f.z),vec4(intBitsToFloat(uf_remappedVS[8].x),intBitsToFloat(uf_remappedVS[8].y),intBitsToFloat(uf_remappedVS[8].z),intBitsToFloat(uf_remappedVS[8].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R3f.z,R3f.z),vec4(intBitsToFloat(uf_remappedVS[9].x),intBitsToFloat(uf_remappedVS[9].y),intBitsToFloat(uf_remappedVS[9].z),intBitsToFloat(uf_remappedVS[9].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R4f.x = PV0f.x;
+PS1f = R4f.x;
+// 2
+R4f.y = PV1f.x;
+// export
+passParameterSem2 = vec4(R4f.x, R4f.y, R4f.z, R4f.w);
+}

src/TwilightPrincessHD/Graphics/7674f1be5f1b1e0c_0000000000000000_vs.txt

@@ -0,0 +1,165 @@
+#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 7674f1be5f1b1e0c
+//object box BG
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[9];
+};
+#else
+uniform ivec4 uf_remappedVS[9];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) 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 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R2f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R3f.z = 1.0;
+PS1f = R3f.z;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R127f.w = 1.0;
+PS0f = R127f.w;
+// 3
+R2f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R2f.x;
+PV1f.y = R2f.x;
+PV1f.z = R2f.x;
+PV1f.w = R2f.x;
+R0f.z = 0.0;
+PS1f = R0f.z;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.y = tempf.x;
+R4f.z = R127f.w;
+PS0f = R4f.z;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R2f.z = tempf.x;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.w = tempf.x;
+// export
+SET_POSITION(vec4(R2f.x*UIx, R2f.y*UIy, R2f.z, R2f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+// export
+// skipped export to semanticId 255
+// 0
+tempf.x = dot(vec4(R3f.x,R3f.y,R3f.z,R3f.z),vec4(intBitsToFloat(uf_remappedVS[7].x),intBitsToFloat(uf_remappedVS[7].y),intBitsToFloat(uf_remappedVS[7].z),intBitsToFloat(uf_remappedVS[7].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+// 1
+tempf.x = dot(vec4(R3f.x,R3f.y,R3f.z,R3f.z),vec4(intBitsToFloat(uf_remappedVS[8].x),intBitsToFloat(uf_remappedVS[8].y),intBitsToFloat(uf_remappedVS[8].z),intBitsToFloat(uf_remappedVS[8].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R4f.x = PV0f.x;
+PS1f = R4f.x;
+// 2
+R4f.y = PV1f.x;
+// export
+passParameterSem2 = vec4(R4f.x, R4f.y, R4f.z, R4f.w);
+}

src/TwilightPrincessHD/Graphics/7c5a0f2532be049f_0000000000000000_vs.txt

@@ -0,0 +1,152 @@
+#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 7c5a0f2532be049f
+//Map highlight
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) 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 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R2f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R4f.x = 0.0;
+PS0f = R4f.x;
+// 3
+R2f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R2f.x;
+PV1f.y = R2f.x;
+PV1f.z = R2f.x;
+PV1f.w = R2f.x;
+R0f.x = R3f.x;
+PS1f = R0f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.y = tempf.x;
+R0f.y = R3f.y;
+PS0f = R0f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R2f.z = tempf.x;
+R0f.z = R127f.w;
+PS1f = R0f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.w = tempf.x;
+// export
+SET_POSITION(vec4(R2f.x*UIx, R2f.y*UIy, R2f.z, R2f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+// export
+passParameterSem2 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+}

src/TwilightPrincessHD/Graphics/7fc573264230ed00_0000000000000000_vs.txt

@@ -0,0 +1,158 @@
+#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 7fc573264230ed00
+//lights bloom sensor
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[10];
+};
+#else
+uniform ivec4 uf_remappedVS[10];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem2;
+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 R3f = 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 = attrDataSem2.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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R127f.w = R1f.w;
+PS0f = R127f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R2f.z = 1.0;
+PS1f = R2f.z;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+PS0f = 1.0;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R3f.z = PS0f;
+PS1f = R3f.z;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// 7
+R0f.xyz = vec3(intBitsToFloat(uf_remappedVS[7].x),intBitsToFloat(uf_remappedVS[7].y),intBitsToFloat(uf_remappedVS[7].z));
+R0f.w = intBitsToFloat(uf_remappedVS[7].w);
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+passParameterSem0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// 0
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.z),vec4(intBitsToFloat(uf_remappedVS[8].x),intBitsToFloat(uf_remappedVS[8].y),intBitsToFloat(uf_remappedVS[8].z),intBitsToFloat(uf_remappedVS[8].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.z),vec4(intBitsToFloat(uf_remappedVS[9].x),intBitsToFloat(uf_remappedVS[9].y),intBitsToFloat(uf_remappedVS[9].z),intBitsToFloat(uf_remappedVS[9].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R3f.x = PV0f.x;
+PS1f = R3f.x;
+// 2
+R3f.y = PV1f.x;
+// export
+passParameterSem1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
+}

src/TwilightPrincessHD/Graphics/827afe113fd67658_0000000000000000_vs.txt

@@ -0,0 +1,164 @@
+#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 827afe113fd67658
+//lamp oil indicator
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[9];
+};
+#else
+uniform ivec4 uf_remappedVS[9];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+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){ 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 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R127f.w = R2f.w;
+PS0f = R127f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R0f.z = 1.0;
+PS1f = R0f.z;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+PS0f = 1.0;
+// 3
+R2f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R2f.x;
+PV1f.y = R2f.x;
+PV1f.z = R2f.x;
+PV1f.w = R2f.x;
+R4f.z = PS0f;
+PS1f = R4f.z;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.y = tempf.x;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R2f.z = tempf.x;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.w = tempf.x;
+// export
+SET_POSITION(vec4(R2f.x*UIx, R2f.y*UIy, R2f.z, R2f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+// 0
+backupReg0f = R0f.z;
+backupReg0f = R0f.z;
+tempf.x = dot(vec4(R3f.x,R3f.y,backupReg0f,backupReg0f),vec4(intBitsToFloat(uf_remappedVS[7].x),intBitsToFloat(uf_remappedVS[7].y),intBitsToFloat(uf_remappedVS[7].z),intBitsToFloat(uf_remappedVS[7].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+// 1
+backupReg0f = R0f.z;
+backupReg0f = R0f.z;
+tempf.x = dot(vec4(R3f.x,R3f.y,backupReg0f,backupReg0f),vec4(intBitsToFloat(uf_remappedVS[8].x),intBitsToFloat(uf_remappedVS[8].y),intBitsToFloat(uf_remappedVS[8].z),intBitsToFloat(uf_remappedVS[8].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R4f.x = PV0f.x;
+PS1f = R4f.x;
+// 2
+R4f.y = PV1f.x;
+// export
+passParameterSem1 = vec4(R4f.x, R4f.y, R4f.z, R4f.w);
+}

src/TwilightPrincessHD/Graphics/85b15b7fe92662bb_0000000000000000_vs.txt

@@ -0,0 +1,147 @@
+#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 85b15b7fe92662bb
+//map dungeon BG
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem1;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec4 R1f = vec4(0.0);
+vec4 R2f = vec4(0.0);
+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)));
+// skipped unused attribute for r5
+attrDecoder.xy = attrDataSem2.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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R1f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R3f.x = 0.0;
+PS0f = R3f.x;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R0f.x = R2f.x;
+PS1f = R0f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+R0f.y = R2f.y;
+PS0f = R0f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+R0f.z = R127f.w;
+PS1f = R0f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+passParameterSem1 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+}

src/TwilightPrincessHD/Graphics/95a5a89d62998e0d_0000000000000079_ps.txt

@@ -0,0 +1,364 @@
+#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 95a5a89d62998e0d
+// blur
+#ifdef VULKAN
+layout(set = 1, binding = 1) 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;
+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 R7f = vec4(0.0);
+vec4 R123f = 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;
+float scaler;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = GET_FRAGCOORD();
+scaler =  uf_fragCoordScale.x;
+// 0
+R7f.x = R0f.x * intBitsToFloat(0x3b088889);
+PV0f.x = R7f.x;
+R7f.y = R0f.y * intBitsToFloat(0x3b72b9d6);
+PV0f.y = R7f.y;
+// 1
+R0f.x = PV0f.x;
+R0f.y = PV0f.y + intBitsToFloat(0x3b72b9d6) * scaler;
+R1f.z = PV0f.x;
+R1f.y = PV0f.y + intBitsToFloat(0xbb72b9d6) * scaler;
+PS1f = R1f.y;
+// 2
+R2f.x = R7f.x;
+R2f.y = R7f.y + intBitsToFloat(0x3bf2b9d6) * scaler;
+R4f.z = R7f.x;
+R4f.y = R7f.y + intBitsToFloat(0xbbf2b9d6) * scaler;
+PS0f = R4f.y;
+R3f.xyzw = (textureLod(textureUnitPS0, R7f.xy,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.zy,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+backupReg0f = R0f.x;
+backupReg1f = R0f.w;
+PV0f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.y);
+PV0f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.z);
+PV0f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), backupReg0f);
+PV0f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), backupReg1f);
+R0f.y = R7f.y + intBitsToFloat(0x3c360b60) * scaler;
+PS0f = R0f.y;
+// 1
+R123f.x = (mul_nonIEEE(R3f.y,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.x);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(R3f.w,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.w);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(R3f.x,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(R3f.z,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.y);
+PV1f.w = R123f.w;
+R0f.x = R7f.x;
+PS1f = R0f.x;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.y) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.w) + PV1f.y);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R1f.y = R7f.y + intBitsToFloat(0xbc360b60) * scaler;
+PS0f = R1f.y;
+// 3
+backupReg0f = R2f.z;
+R3f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.x) + PV0f.y);
+R3f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.y) + PV0f.x);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.w) + PV0f.z);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),backupReg0f) + PV0f.w);
+R1f.x = R7f.x;
+PS1f = R1f.x;
+// 4
+R2f.x = R7f.x;
+R2f.y = R7f.y + intBitsToFloat(0x3c72b9d6) * scaler;
+R6f.z = R7f.x;
+R6f.y = R7f.y + intBitsToFloat(0xbc72b9d6) * scaler;
+PS0f = R6f.y;
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.zy,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R5f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.x) + R3f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.w) + R2f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.z) + R2f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.y) + R3f.y);
+PV0f.w = R123f.w;
+R3f.y = R7f.y + intBitsToFloat(0x3c97b426) * scaler;
+PS0f = R3f.y;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.w) + PV0f.y);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.x) + PV0f.x);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+R3f.x = R7f.x;
+PS1f = R3f.x;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.w) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.z) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.y) + PV1f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.x) + PV1f.y);
+PV0f.w = R123f.w;
+R1f.y = R7f.y + intBitsToFloat(0xbc97b426) * scaler;
+PS0f = R1f.y;
+// 3
+R0f.x = (mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.y);
+R0f.y = (mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.x);
+R5f.z = (mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.z);
+R5f.w = (mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.w);
+R1f.x = R7f.x;
+PS1f = R1f.x;
+// 4
+R5f.x = R7f.x;
+R5f.y = R7f.y + intBitsToFloat(0x3cb60b60) * scaler;
+R4f.z = R7f.x;
+R4f.y = R7f.y + intBitsToFloat(0xbcb60b60) * scaler;
+PS0f = R4f.y;
+R6f.xyzw = (textureLod(textureUnitPS0, R6f.zy,0.0).xyzw);
+R3f.xyzw = (textureLod(textureUnitPS0, R3f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R5f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.z) + R0f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.y) + R5f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.x) + R5f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.w) + R0f.y);
+PV0f.w = R123f.w;
+R0f.y = R7f.y + intBitsToFloat(0x3cd4629b) * scaler;
+PS0f = R0f.y;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.y) + PV0f.y);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.w) + PV0f.w);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.x) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.z) + PV0f.x);
+PV1f.w = R123f.w;
+R0f.x = R7f.x;
+PS1f = R0f.x;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.y) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.w) + PV1f.y);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R1f.y = R7f.y + intBitsToFloat(0xbcd4629b) * scaler;
+PS0f = R1f.y;
+// 3
+backupReg0f = R2f.z;
+R3f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.x) + PV0f.y);
+R3f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.y) + PV0f.x);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.w) + PV0f.z);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),backupReg0f) + PV0f.w);
+R1f.x = R7f.x;
+PS1f = R1f.x;
+// 4
+R2f.x = R7f.x;
+R2f.y = R7f.y + intBitsToFloat(0x3cf2b9d6) * scaler;
+R6f.z = R7f.x;
+R6f.y = R7f.y + intBitsToFloat(0xbcf2b9d6) * scaler;
+PS0f = R6f.y;
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.zy,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R5f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.x) + R3f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.w) + R2f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.z) + R2f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.y) + R3f.y);
+PV0f.w = R123f.w;
+R3f.y = R7f.y + intBitsToFloat(0x3d088888) * scaler;
+PS0f = R3f.y;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.w) + PV0f.y);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.x) + PV0f.x);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+R3f.x = R7f.x;
+PS1f = R3f.x;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.w) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.z) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.y) + PV1f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.x) + PV1f.y);
+PV0f.w = R123f.w;
+R1f.y = R7f.y + intBitsToFloat(0xbd088888) * scaler;
+PS0f = R1f.y;
+// 3
+R0f.x = (mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.y);
+R0f.y = (mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.x);
+R5f.z = (mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.z);
+R5f.w = (mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.w);
+R1f.x = R7f.x;
+PS1f = R1f.x;
+// 4
+R5f.x = R7f.x;
+R5f.y = R7f.y + intBitsToFloat(0x3d17b426) * scaler;
+R4f.z = R7f.x;
+R4f.y = R7f.y + intBitsToFloat(0xbd17b426) * scaler;
+PS0f = R4f.y;
+R6f.xyzw = (textureLod(textureUnitPS0, R6f.zy,0.0).xyzw);
+R3f.xyzw = (textureLod(textureUnitPS0, R3f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R5f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.z) + R0f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.y) + R5f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.x) + R5f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.w) + R0f.y);
+PV0f.w = R123f.w;
+R0f.y = R7f.y + intBitsToFloat(0x3d26dfc3) * scaler;
+PS0f = R0f.y;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.y) + PV0f.y);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.w) + PV0f.w);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.x) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.z) + PV0f.x);
+PV1f.w = R123f.w;
+R0f.x = R7f.x;
+PS1f = R0f.x;
+// 2
+backupReg0f = R7f.y;
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.y) + PV1f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.w) + PV1f.y);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R7f.y = backupReg0f + intBitsToFloat(0xbd26dfc3) * scaler;
+PS0f = R7f.y;
+// 3
+backupReg0f = R2f.x;
+backupReg1f = R2f.y;
+backupReg2f = R2f.z;
+R2f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),backupReg0f) + PV0f.y);
+R2f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),backupReg1f) + PV0f.x);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.w) + PV0f.z);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),backupReg2f) + PV0f.w);
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.zy,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R7f.xyzw = (textureLod(textureUnitPS0, R7f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.x) + R2f.x);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.w) + R2f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.z) + R2f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.y) + R2f.y);
+PV0f.w = R123f.w;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.w) + PV0f.y);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.x) + PV0f.x);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+// 2
+backupReg0f = R7f.x;
+backupReg1f = R7f.y;
+backupReg2f = R7f.z;
+backupReg3f = R7f.w;
+R7f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),backupReg0f) + PV1f.y);
+R7f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),backupReg1f) + PV1f.w);
+R7f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),backupReg2f) + PV1f.z);
+R7f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),backupReg3f) + PV1f.x);
+// export
+passPixelColor0 = vec4(R7f.x, R7f.y, R7f.z, R7f.w);
+}

src/TwilightPrincessHD/Graphics/TPHD_Readme.md

@@ -0,0 +1,48 @@
+------
+### TLoZ Twilight Princess HD 
+------
+### Graphic options 
+
+3840x4320 vert x2 SSAA - Runs the game at double vertical res balancing look and performance when super sampling. Run full screen scaling in stretched and bilinear when activating this option. 
+
+0.5 Sub scaling - Runs transparances and blur at half resolution, slight performance improvement (in higher resolutions). 
+
+UI 25% transp - Dims static GUI elements, making them slightly transparent. Reduces chance of burn in when using Oled or plasma display. 
+
+
+### 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)
+```
+![21:9](TP21_9.jpg)
+
+

src/TwilightPrincessHD/Graphics/_cac95df4d2d6f5b8_0000000000000000_vs.txt

@@ -0,0 +1,102 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_packing : enable
+// shader cac95df4d2d6f5b8
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+//uncomment to remove pillarbox
+uniform ivec4 uf_remappedVS[8];
+layout(location = 0) in uvec4 attrDataSem0;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+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 R127f = vec4(0.0);
+uvec4 attrDecoder;
+float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+float PS0f = 0.0, PS1f = 0.0;
+vec4 tempf = vec4(0.0);
+float tempResultf;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID));
+attrDecoder.xyz = attrDataSem0.xyz;
+attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24));
+attrDecoder.w = 0;
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R127f.w = R1f.w;
+PS0f = R127f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// 7
+//R0f.xyz = vec3(intBitsToFloat(uf_remappedVS[7].x),intBitsToFloat(uf_remappedVS[7].y),intBitsToFloat(uf_remappedVS[7].z));
+R0f.w = intBitsToFloat(uf_remappedVS[7].w);
+// export
+//gl_Position = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+// export
+// skipped export to semanticId 255
+}

src/TwilightPrincessHD/Graphics/acbedb86f89efae4_0000000000000000_vs.txt

@@ -0,0 +1,146 @@
+#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 acbedb86f89efae4
+//mapscreen bg
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem1;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){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)));
+// skipped unused attribute for r8
+attrDecoder.xy = attrDataSem2.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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R1f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R3f.x = 0.0;
+PS0f = R3f.x;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R0f.x = R2f.x;
+PS1f = R0f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+R0f.y = R2f.y;
+PS0f = R0f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+R0f.z = R127f.w;
+PS1f = R0f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+passParameterSem1 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+}

src/TwilightPrincessHD/Graphics/aebb1e76797684a2_0000000000000000_vs.txt

@@ -0,0 +1,151 @@
+#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 aebb1e76797684a2
+//UI text bg
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) 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 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R2f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R4f.x = 0.0;
+PS0f = R4f.x;
+// 3
+R2f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R2f.x;
+PV1f.y = R2f.x;
+PV1f.z = R2f.x;
+PV1f.w = R2f.x;
+R0f.x = R3f.x;
+PS1f = R0f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.y = tempf.x;
+R0f.y = R3f.y;
+PS0f = R0f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R2f.z = tempf.x;
+R0f.z = R127f.w;
+PS1f = R0f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.w = tempf.x;
+// export
+SET_POSITION(vec4(R2f.x*UIx, R2f.y*UIy, R2f.z, R2f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+// export
+passParameterSem2 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+}

src/TwilightPrincessHD/Graphics/b5241d6db4feef42_0000000000000000_vs.txt

@@ -0,0 +1,165 @@
+#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 b5241d6db4feef42
+//selection highlight
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[10];
+};
+#else
+uniform ivec4 uf_remappedVS[10];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) 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){ 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 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 = attrDataSem2.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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R1f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R3f.z = 1.0;
+PS1f = R3f.z;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R127f.w = 1.0;
+PS0f = R127f.w;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R2f.z = 0.0;
+PS1f = R2f.z;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+R4f.z = R127f.w;
+PS0f = R4f.z;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// 7
+R0f.xyz = vec3(intBitsToFloat(uf_remappedVS[7].x),intBitsToFloat(uf_remappedVS[7].y),intBitsToFloat(uf_remappedVS[7].z));
+R0f.w = intBitsToFloat(uf_remappedVS[7].w);
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+passParameterSem0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+// 0
+tempf.x = dot(vec4(R2f.x,R2f.y,R3f.z,R3f.z),vec4(intBitsToFloat(uf_remappedVS[8].x),intBitsToFloat(uf_remappedVS[8].y),intBitsToFloat(uf_remappedVS[8].z),intBitsToFloat(uf_remappedVS[8].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R3f.z,R3f.z),vec4(intBitsToFloat(uf_remappedVS[9].x),intBitsToFloat(uf_remappedVS[9].y),intBitsToFloat(uf_remappedVS[9].z),intBitsToFloat(uf_remappedVS[9].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R4f.x = PV0f.x;
+PS1f = R4f.x;
+// 2
+R4f.y = PV1f.x;
+// export
+passParameterSem2 = vec4(R4f.x, R4f.y, R4f.z, R4f.w);
+}

src/TwilightPrincessHD/Graphics/c14019840473ff86_00000000000003c9_ps.txt

@@ -0,0 +1,159 @@
+#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 c14019840473ff86
+//scale boxblur fx
+
+TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
+TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+#ifdef VULKAN
+layout(set = 1, binding = 2) 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);
+vec4 R1f = vec4(0.0);
+vec4 R2f = vec4(0.0);
+vec4 R3f = 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;
+float scaler;
+R0f = passParameterSem0;
+scaler = uf_fragCoordScale.x;
+R0f.w = (textureGather(textureUnitPS1, R0f.xy).y);
+// 0
+R1f.x = R0f.x + intBitsToFloat(0xba088889);
+R1f.y = R0f.y + intBitsToFloat(0xba72b9d6);
+R2f.z = R0f.x;
+R2f.y = R0f.y + intBitsToFloat(0xba72b9d6);
+PS0f = R2f.y;
+// 1
+R3f.x = R0f.x + intBitsToFloat(0xba088889);
+R3f.y = R0f.y;
+R1f.xyzw = (textureGather(textureUnitPS1, R1f.xy).xyzw);
+R2f.yz = (textureGather(textureUnitPS1, R2f.zy).yz);
+R3f.xy = (textureGather(textureUnitPS1, R3f.xy).xy);
+// 0
+PV0f.x = R2f.z + R3f.x;
+PV0f.y = R1f.w + R0f.w;
+PV0f.z = R1f.z + R3f.y;
+PV0f.w = R1f.x + R2f.y;
+// 1
+R123f.x = (R1f.y * 2.0 + -(PV0f.x));
+PV1f.x = R123f.x;
+R123f.y = (R1f.y * 2.0 + -(PV0f.y));
+PV1f.y = R123f.y;
+R123f.z = (R1f.y * 2.0 + -(PV0f.z));
+PV1f.z = R123f.z;
+R123f.w = (R1f.y * 2.0 + -(PV0f.w));
+PV1f.w = R123f.w;
+// 2
+PV0f.x = max(PV1f.x, -(PV1f.x));
+PV0f.y = max(PV1f.y, -(PV1f.y));
+PV0f.z = max(PV1f.z, -(PV1f.z));
+PV0f.w = max(PV1f.w, -(PV1f.w));
+// 3
+PV1f.x = PV0f.x + intBitsToFloat(0xb400d959);
+PV1f.y = PV0f.y + intBitsToFloat(0xb400d959);
+PV1f.z = PV0f.z + intBitsToFloat(0xb400d959);
+PV1f.w = PV0f.w + intBitsToFloat(0xb400d959);
+// 4
+R123f.x = intBitsToFloat(((PV1f.w >= 0.0)?(floatBitsToInt(1.0)):(0)));
+PV0f.x = R123f.x;
+R123f.y = intBitsToFloat(((PV1f.z >= 0.0)?(floatBitsToInt(1.0)):(0)));
+PV0f.y = R123f.y;
+R123f.z = intBitsToFloat(((PV1f.y >= 0.0)?(floatBitsToInt(1.0)):(0)));
+PV0f.z = R123f.z;
+R123f.w = intBitsToFloat(((PV1f.x >= 0.0)?(floatBitsToInt(1.0)):(0)));
+PV0f.w = R123f.w;
+// 5
+tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(0.25*scaler,0.25*scaler,0.25*scaler,0.25*scaler));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+// 6
+R127f.z = PV1f.x * intBitsToFloat(0x3f400000);
+PV0f.z = R127f.z;
+// 7
+R1f.x = (PV0f.z * intBitsToFloat(0xba088889) + R0f.x);
+R1f.y = R0f.y;
+R2f.z = R0f.x;
+R2f.y = (PV0f.z * intBitsToFloat(0xba72b9d6) + R0f.y);
+PS1f = R2f.y;
+// 8
+R3f.x = (R127f.z * intBitsToFloat(0x3a088889) + R0f.x);
+R3f.y = R0f.y;
+R0f.w = (R127f.z * intBitsToFloat(0x3a72b9d6) + R0f.y);
+R1f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
+R2f.xyzw = (texture(textureUnitPS0, R2f.zy).xyzw);
+R3f.xyzw = (texture(textureUnitPS0, R3f.xy).xyzw);
+R0f.xyzw = (texture(textureUnitPS0, R0f.xw).xyzw);
+// 0
+PV0f.x = R1f.w + R2f.w;
+PV0f.y = R1f.z + R2f.z;
+PV0f.z = R1f.y + R2f.y;
+PV0f.w = R1f.x + R2f.x;
+// 1
+PV1f.x = R3f.w + PV0f.x;
+PV1f.y = R3f.z + PV0f.y;
+PV1f.z = R3f.y + PV0f.z;
+PV1f.w = R3f.x + PV0f.w;
+// 2
+backupReg0f = R0f.y;
+backupReg1f = R0f.x;
+PV0f.x = R0f.w + PV1f.x;
+PV0f.y = R0f.z + PV1f.y;
+PV0f.z = backupReg0f + PV1f.z;
+PV0f.w = backupReg1f + PV1f.w;
+// 3
+R0f.x = PV0f.w * 0.25;
+R0f.y = PV0f.z * 0.25;
+R0f.z = PV0f.y * 0.25;
+R0f.w = PV0f.x * 0.25;
+// export
+passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+}

src/TwilightPrincessHD/Graphics/c612390d4c70f430_0000000000000079_ps.txt

@@ -0,0 +1,567 @@
+#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 c612390d4c70f430 //cutscene focus n bloom
+
+#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
+TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
+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 R7f = vec4(0.0);
+vec4 R123f = 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;
+float scaler;
+int tempResulti;
+ivec4 ARi = ivec4(0);
+bool predResult = true;
+vec3 cubeMapSTM;
+int cubeMapFaceId;
+R0f = GET_FRAGCOORD();
+scaler = uf_fragCoordScale.x;
+// 0
+R7f.x = R0f.x * intBitsToFloat(0x3b088889);
+PV0f.x = R7f.x;
+R7f.y = R0f.y * intBitsToFloat(0x3b72b9d6);
+PV0f.y = R7f.y;
+// 1
+R0f.x = PV0f.x + intBitsToFloat(0x3b088889) * scaler;
+R0f.y = PV0f.y;
+R1f.z = PV0f.y;
+R1f.x = PV0f.x + intBitsToFloat(0xbb088889) * scaler;
+PS1f = R1f.x;
+// 2
+R2f.x = R7f.x + intBitsToFloat(0x3b888889) * scaler;
+R2f.y = R7f.y;
+R4f.z = R7f.y;
+R4f.x = R7f.x + intBitsToFloat(0xbb888889) * scaler;
+PS0f = R4f.x;
+R3f.xyzw = (textureLod(textureUnitPS0, R7f.xy,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xz,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+backupReg0f = R0f.y;
+backupReg1f = R0f.x;
+backupReg2f = R0f.w;
+PV0f.x = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), R0f.z);
+PV0f.y = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), backupReg0f);
+PV0f.z = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), backupReg1f);
+PV0f.w = mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y), backupReg2f);
+R0f.x = R7f.x + intBitsToFloat(0x3bccccce) * scaler;
+PS0f = R0f.x;
+// 1
+R123f.x = (mul_nonIEEE(R3f.w,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.w);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(R3f.y,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(R3f.x,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(R3f.z,intBitsToFloat(uf_remappedPS[0].x)) + PV0f.x);
+PV1f.w = R123f.w;
+R0f.y = R7f.y;
+PS1f = R0f.y;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.y) + PV1f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.w) + PV1f.x);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R1f.x = R7f.x + intBitsToFloat(0xbbccccce) * scaler;
+PS0f = R1f.x;
+// 3
+backupReg0f = R2f.z;
+R3f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.w) + PV0f.z);
+R3f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.x) + PV0f.y);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),backupReg0f) + PV0f.w);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R2f.y) + PV0f.x);
+R1f.y = R7f.y;
+PS1f = R1f.y;
+// 4
+R2f.x = R7f.x + intBitsToFloat(0x3c088889) * scaler;
+R2f.y = R7f.y;
+R6f.z = R7f.y;
+R6f.x = R7f.x + intBitsToFloat(0xbc088889) * scaler;
+PS0f = R6f.x;
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.xz,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R5f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.x) + R3f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.w) + R3f.x);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.z) + R2f.z);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].z),R4f.y) + R2f.w);
+PV0f.w = R123f.w;
+R3f.x = R7f.x + intBitsToFloat(0x3c2aaaab) * scaler;
+PS0f = R3f.x;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.x) + PV0f.x);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.w) + PV0f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+R3f.y = R7f.y;
+PS1f = R3f.y;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.w) + PV1f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.z) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.y) + PV1f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[0].w),R1f.x) + PV1f.x);
+PV0f.w = R123f.w;
+R1f.x = R7f.x + intBitsToFloat(0xbc2aaaab) * scaler;
+PS0f = R1f.x;
+// 3
+R0f.x = (mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.x);
+R0f.y = (mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.y);
+R5f.z = (mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.z);
+R5f.w = (mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[1].x)) + PV0f.w);
+R1f.y = R7f.y;
+PS1f = R1f.y;
+// 4
+R5f.x = R7f.x + intBitsToFloat(0x3c4cccce) * scaler;
+R5f.y = R7f.y;
+R4f.z = R7f.y;
+R4f.x = R7f.x + intBitsToFloat(0xbc4cccce) * scaler;
+PS0f = R4f.x;
+R6f.xyzw = (textureLod(textureUnitPS0, R6f.xz,0.0).xyzw);
+R3f.xyzw = (textureLod(textureUnitPS0, R3f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R5f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.z) + R0f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.y) + R5f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.x) + R5f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].x),R6f.w) + R0f.x);
+PV0f.w = R123f.w;
+R0f.x = R7f.x + intBitsToFloat(0x3c6eeef0) * scaler;
+PS0f = R0f.x;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.w) + PV0f.w);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.y) + PV0f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.x) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R3f.z) + PV0f.x);
+PV1f.w = R123f.w;
+R0f.y = R7f.y;
+PS1f = R0f.y;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.y) + PV1f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.w) + PV1f.x);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R1f.x = R7f.x + intBitsToFloat(0xbc6eeef0) * scaler;
+PS0f = R1f.x;
+// 3
+backupReg0f = R2f.z;
+R3f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.w) + PV0f.z);
+R3f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.x) + PV0f.y);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),backupReg0f) + PV0f.w);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R2f.y) + PV0f.x);
+R1f.y = R7f.y;
+PS1f = R1f.y;
+// 4
+R2f.x = R7f.x + intBitsToFloat(0x3c888889) * scaler;
+R2f.y = R7f.y;
+R6f.z = R7f.y;
+R6f.x = R7f.x + intBitsToFloat(0xbc888889) * scaler;
+PS0f = R6f.x;
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.xz,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R5f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.x) + R3f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.w) + R3f.x);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.z) + R2f.z);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].z),R4f.y) + R2f.w);
+PV0f.w = R123f.w;
+R3f.x = R7f.x + intBitsToFloat(0x3c99999a) * scaler;
+PS0f = R3f.x;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.x) + PV0f.x);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.w) + PV0f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+R3f.y = R7f.y;
+PS1f = R3f.y;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.w) + PV1f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.z) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.y) + PV1f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[1].w),R1f.x) + PV1f.x);
+PV0f.w = R123f.w;
+R1f.x = R7f.x + intBitsToFloat(0xbc99999a) * scaler;
+PS0f = R1f.x;
+// 3
+R0f.x = (mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.x);
+R0f.y = (mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.y);
+R5f.z = (mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.z);
+R5f.w = (mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[2].x)) + PV0f.w);
+R1f.y = R7f.y;
+PS1f = R1f.y;
+// 4
+R5f.x = R7f.x + intBitsToFloat(0x3caaaaab) * scaler;
+R5f.y = R7f.y;
+R4f.z = R7f.y;
+R4f.x = R7f.x + intBitsToFloat(0xbcaaaaab) * scaler;
+PS0f = R4f.x;
+R6f.xyzw = (textureLod(textureUnitPS0, R6f.xz,0.0).xyzw);
+R3f.xyzw = (textureLod(textureUnitPS0, R3f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R5f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.z) + R0f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.y) + R5f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.x) + R5f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].x),R6f.w) + R0f.x);
+PV0f.w = R123f.w;
+R0f.x = R7f.x + intBitsToFloat(0x3cbbbbbc) * scaler;
+PS0f = R0f.x;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.w) + PV0f.w);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.y) + PV0f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.x) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R3f.z) + PV0f.x);
+PV1f.w = R123f.w;
+R0f.y = R7f.y;
+PS1f = R0f.y;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.y) + PV1f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.w) + PV1f.x);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R1f.x = R7f.x + intBitsToFloat(0xbcbbbbbc) * scaler;
+PS0f = R1f.x;
+// 3
+backupReg0f = R2f.z;
+R3f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.w) + PV0f.z);
+R3f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.x) + PV0f.y);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),backupReg0f) + PV0f.w);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R2f.y) + PV0f.x);
+R1f.y = R7f.y;
+PS1f = R1f.y;
+// 4
+R2f.x = R7f.x + intBitsToFloat(0x3cccccce) * scaler;
+R2f.y = R7f.y;
+R6f.z = R7f.y;
+R6f.x = R7f.x + intBitsToFloat(0xbcccccce) * scaler;
+PS0f = R6f.x;
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.xz,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R5f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.x) + R3f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.w) + R3f.x);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.z) + R2f.z);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].z),R4f.y) + R2f.w);
+PV0f.w = R123f.w;
+R3f.x = R7f.x + intBitsToFloat(0x3cdddddf) * scaler;
+PS0f = R3f.x;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.x) + PV0f.x);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.w) + PV0f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+R3f.y = R7f.y;
+PS1f = R3f.y;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R1f.w) + PV1f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R1f.z) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R1f.y) + PV1f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[2].w),R1f.x) + PV1f.x);
+PV0f.w = R123f.w;
+R1f.x = R7f.x + intBitsToFloat(0xbcdddddf) * scaler;
+PS0f = R1f.x;
+// 3
+R0f.x = (mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[3].x)) + PV0f.x);
+R0f.y = (mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[3].x)) + PV0f.y);
+R5f.z = (mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[3].x)) + PV0f.z);
+R5f.w = (mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[3].x)) + PV0f.w);
+R1f.y = R7f.y;
+PS1f = R1f.y;
+// 4
+R5f.x = R7f.x + intBitsToFloat(0x3ceeeef0) * scaler;
+R5f.y = R7f.y;
+R4f.z = R7f.y;
+R4f.x = R7f.x + intBitsToFloat(0xbceeeef0) * scaler;
+PS0f = R4f.x;
+R6f.xyzw = (textureLod(textureUnitPS0, R6f.xz,0.0).xyzw);
+R3f.xyzw = (textureLod(textureUnitPS0, R3f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R5f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].x),R6f.z) + R0f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].x),R6f.y) + R5f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].x),R6f.x) + R5f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].x),R6f.w) + R0f.x);
+PV0f.w = R123f.w;
+R0f.x = R7f.x + intBitsToFloat(0x3d000000) * scaler;
+PS0f = R0f.x;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R3f.w) + PV0f.w);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R3f.y) + PV0f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R3f.x) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R3f.z) + PV0f.x);
+PV1f.w = R123f.w;
+R0f.y = R7f.y;
+PS1f = R0f.y;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R1f.y) + PV1f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R1f.w) + PV1f.x);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R1f.x = R7f.x + intBitsToFloat(0xbd000000) * scaler;
+PS0f = R1f.x;
+// 3
+backupReg0f = R2f.z;
+R3f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R2f.w) + PV0f.z);
+R3f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R2f.x) + PV0f.y);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),backupReg0f) + PV0f.w);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R2f.y) + PV0f.x);
+R1f.y = R7f.y;
+PS1f = R1f.y;
+// 4
+R2f.x = R7f.x + intBitsToFloat(0x3d088889) * scaler;
+R2f.y = R7f.y;
+R6f.z = R7f.y;
+R6f.x = R7f.x + intBitsToFloat(0xbd088889) * scaler;
+PS0f = R6f.x;
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.xz,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R5f.xyzw = (textureLod(textureUnitPS0, R2f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R4f.x) + R3f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R4f.w) + R3f.x);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R4f.z) + R2f.z);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].z),R4f.y) + R2f.w);
+PV0f.w = R123f.w;
+R3f.x = R7f.x + intBitsToFloat(0x3d111112) * scaler;
+PS0f = R3f.x;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R0f.x) + PV0f.x);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R0f.w) + PV0f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+R3f.y = R7f.y;
+PS1f = R3f.y;
+// 2
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R1f.w) + PV1f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R1f.z) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R1f.y) + PV1f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[3].w),R1f.x) + PV1f.x);
+PV0f.w = R123f.w;
+R1f.x = R7f.x + intBitsToFloat(0xbd111112) * scaler;
+PS0f = R1f.x;
+// 3
+R0f.x = (mul_nonIEEE(R5f.w,intBitsToFloat(uf_remappedPS[4].x)) + PV0f.x);
+R0f.y = (mul_nonIEEE(R5f.z,intBitsToFloat(uf_remappedPS[4].x)) + PV0f.y);
+R5f.z = (mul_nonIEEE(R5f.y,intBitsToFloat(uf_remappedPS[4].x)) + PV0f.z);
+R5f.w = (mul_nonIEEE(R5f.x,intBitsToFloat(uf_remappedPS[4].x)) + PV0f.w);
+R1f.y = R7f.y;
+PS1f = R1f.y;
+// 4
+R5f.x = R7f.x + intBitsToFloat(0x3d19999a) * scaler;
+R5f.y = R7f.y;
+R4f.z = R7f.y;
+R4f.x = R7f.x + intBitsToFloat(0xbd19999a) * scaler;
+PS0f = R4f.x;
+R6f.xyzw = (textureLod(textureUnitPS0, R6f.xz,0.0).xyzw);
+R3f.xyzw = (textureLod(textureUnitPS0, R3f.xy,0.0).xyzw);
+R1f.xyzw = (textureLod(textureUnitPS0, R1f.xy,0.0).xyzw);
+R2f.xyzw = (textureLod(textureUnitPS0, R5f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].x),R6f.z) + R0f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].x),R6f.y) + R5f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].x),R6f.x) + R5f.w);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].x),R6f.w) + R0f.x);
+PV0f.w = R123f.w;
+R0f.x = R7f.x + intBitsToFloat(0x3d222223) * scaler;
+PS0f = R0f.x;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R3f.w) + PV0f.w);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R3f.y) + PV0f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R3f.x) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R3f.z) + PV0f.x);
+PV1f.w = R123f.w;
+R0f.y = R7f.y;
+PS1f = R0f.y;
+// 2
+backupReg0f = R7f.x;
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R1f.y) + PV1f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R1f.x) + PV1f.z);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R1f.w) + PV1f.x);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].y),R1f.z) + PV1f.w);
+PV0f.w = R123f.w;
+R7f.x = backupReg0f + intBitsToFloat(0xbd222223) * scaler;
+PS0f = R7f.x;
+// 3
+backupReg0f = R2f.x;
+backupReg1f = R2f.z;
+backupReg2f = R2f.y;
+R2f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R2f.w) + PV0f.z);
+R2f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),backupReg0f) + PV0f.y);
+R2f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),backupReg1f) + PV0f.w);
+R2f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),backupReg2f) + PV0f.x);
+R4f.xyzw = (textureLod(textureUnitPS0, R4f.xz,0.0).xyzw);
+R0f.xyzw = (textureLod(textureUnitPS0, R0f.xy,0.0).xyzw);
+R7f.xyzw = (textureLod(textureUnitPS0, R7f.xy,0.0).xyzw);
+// 0
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R4f.x) + R2f.y);
+PV0f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R4f.w) + R2f.x);
+PV0f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R4f.z) + R2f.z);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].z),R4f.y) + R2f.w);
+PV0f.w = R123f.w;
+// 1
+R123f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R0f.x) + PV0f.x);
+PV1f.x = R123f.x;
+R123f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R0f.w) + PV0f.y);
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R0f.z) + PV0f.z);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),R0f.y) + PV0f.w);
+PV1f.w = R123f.w;
+// 2
+backupReg0f = R7f.x;
+backupReg1f = R7f.y;
+backupReg2f = R7f.z;
+backupReg3f = R7f.w;
+R7f.x = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),backupReg0f) + PV1f.x);
+R7f.y = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),backupReg1f) + PV1f.w);
+R7f.z = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),backupReg2f) + PV1f.z);
+R7f.w = (mul_nonIEEE(intBitsToFloat(uf_remappedPS[4].w),backupReg3f) + PV1f.y);
+// export
+passPixelColor0 = vec4(R7f.x, R7f.y, R7f.z, R7f.w);
+}

src/TwilightPrincessHD/Graphics/ce7aa5fffc34aab0_0000000000000000_vs.txt

@@ -0,0 +1,147 @@
+#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 ce7aa5fffc34aab0
+//action buttons
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+const float UItransp = $UItransp;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+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 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R2f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R2f.x = R3f.x;
+PS0f = R2f.x;
+// 3
+R3f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R3f.x;
+PV1f.y = R3f.x;
+PV1f.z = R3f.x;
+PV1f.w = R3f.x;
+R2f.y = R3f.y;
+PS1f = R2f.y;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R3f.y = tempf.x;
+R2f.z = R127f.w;
+PS0f = R2f.z;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R3f.z = tempf.x;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R3f.w = tempf.x;
+// export
+SET_POSITION(vec4(R3f.x*UIx, R3f.y*UIy, R3f.z, R3f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w*UItransp);
+// export
+passParameterSem1 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
+}

src/TwilightPrincessHD/Graphics/e9d455979cba2505_0000000000000000_vs.txt

@@ -0,0 +1,150 @@
+#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 e9d455979cba2505
+//dungeon objects
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem1;
+layout(location = 1) 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){ 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 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)));
+// skipped unused attribute for r5
+attrDecoder.xy = attrDataSem2.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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R1f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R0f.x = 0.0;
+PS0f = R0f.x;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R3f.x = R2f.x;
+PS1f = R3f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+R3f.y = R2f.y;
+PS0f = R3f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+R3f.z = R127f.w;
+PS1f = R3f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+// skipped export to semanticId 255
+// export
+passParameterSem1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
+// export
+passParameterSem2 = vec4(R3f.x, R3f.y, R3f.z, R3f.w);
+}

src/TwilightPrincessHD/Graphics/eec9403a9d54137e_0000000000000000_vs.txt

@@ -0,0 +1,151 @@
+#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 eec9403a9d54137e
+//Map bg middle layer
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) 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 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R2f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R4f.x = 0.0;
+PS0f = R4f.x;
+// 3
+R2f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R2f.x;
+PV1f.y = R2f.x;
+PV1f.z = R2f.x;
+PV1f.w = R2f.x;
+R0f.x = R3f.x;
+PS1f = R0f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.y = tempf.x;
+R0f.y = R3f.y;
+PS0f = R0f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R2f.z = tempf.x;
+R0f.z = R127f.w;
+PS1f = R0f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.w = tempf.x;
+// export
+SET_POSITION(vec4(R2f.x*UIx, R2f.y*UIy, R2f.z, R2f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+// export
+passParameterSem2 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+}

src/TwilightPrincessHD/Graphics/f017fcfaf1bd28ab_0000000000000000_vs.txt

@@ -0,0 +1,145 @@
+#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 f017fcfaf1bd28ab
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+
+//amiibo
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+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 passParameterSem1;
+int clampFI32(int v)
+{
+if( v == 0x7FFFFFFF )
+	return floatBitsToInt(1.0);
+else if( v == 0xFFFFFFFF )
+	return floatBitsToInt(0.0);
+return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+}
+float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
+void main()
+{
+vec4 R0f = vec4(0.0);
+vec4 R1f = vec4(0.0);
+vec4 R2f = vec4(0.0);
+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
+R127f.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R1f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R1f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R3f.x = 0.0;
+PS0f = R3f.x;
+// 3
+R1f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R1f.x;
+PV1f.y = R1f.x;
+PV1f.z = R1f.x;
+PV1f.w = R1f.x;
+R0f.x = R2f.x;
+PS1f = R0f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.y = tempf.x;
+R0f.y = R2f.y;
+PS0f = R0f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R1f.z = tempf.x;
+R0f.z = R127f.w;
+PS1f = R0f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R1f.w = tempf.x;
+// export
+SET_POSITION(vec4(R1f.x*UIx, R1f.y*UIy, R1f.z, R1f.w));
+// export
+passParameterSem1 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+}

src/TwilightPrincessHD/Graphics/f5034fe4aa1fec23_0000000000000000_vs.txt

@@ -0,0 +1,152 @@
+#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 f5034fe4aa1fec23
+//map fade
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) 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){ 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 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R2f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R4f.x = 0.0;
+PS0f = R4f.x;
+// 3
+R2f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R2f.x;
+PV1f.y = R2f.x;
+PV1f.z = R2f.x;
+PV1f.w = R2f.x;
+R0f.x = R3f.x;
+PS1f = R0f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.y = tempf.x;
+R0f.y = R3f.y;
+PS0f = R0f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R2f.z = tempf.x;
+R0f.z = R127f.w;
+PS1f = R0f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.w = tempf.x;
+// export
+SET_POSITION(vec4(R2f.x*UIx, R2f.y*UIy, R2f.z, R2f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+// export
+passParameterSem2 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
+// export
+// skipped export to semanticId 255
+}

src/TwilightPrincessHD/Graphics/fc148873ef522f50_0000000000000000_vs.txt

@@ -0,0 +1,154 @@
+#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 fc148873ef522f50
+// objective shadow
+const float UIx = $UIAspectX;
+const float UIy = $UIAspectY;
+#ifdef VULKAN
+layout(set = 0, binding = 0) uniform ufBlock
+{
+uniform ivec4 uf_remappedVS[7];
+};
+#else
+uniform ivec4 uf_remappedVS[7];
+#endif
+ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0;
+ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1;
+ATTR_LAYOUT(0, 2) in uvec4 attrDataSem2;
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+layout(location = 0) out vec4 passParameterSem0;
+layout(location = 1) out vec4 passParameterSem2;
+layout(location = 2) 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);
+vec4 R3f = vec4(0.0);
+vec4 R4f = 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;
+R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
+attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem1.xyzw)/255.0);
+R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w)));
+attrDecoder.xy = attrDataSem2.xy;
+attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
+attrDecoder.z = 0;
+attrDecoder.w = 0;
+R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
+// 0
+R127f.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)));
+PV0f.x = R127f.x;
+PV0f.y = R127f.x;
+PV0f.z = R127f.x;
+PV0f.w = R127f.x;
+R126f.w = R2f.w;
+PS0f = R126f.w;
+// 1
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R127f.y = tempf.x;
+R127f.w = 1.0;
+PS1f = R127f.w;
+// 2
+tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,R2f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R127f.z = tempf.x;
+R0f.x = 0.0;
+PS0f = R0f.x;
+// 3
+R2f.x = dot(vec4(R127f.x,R127f.y,PV0f.x,R126f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)));
+PV1f.x = R2f.x;
+PV1f.y = R2f.x;
+PV1f.z = R2f.x;
+PV1f.w = R2f.x;
+R4f.x = R3f.x;
+PS1f = R4f.x;
+// 4
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.y = tempf.x;
+R4f.y = R3f.y;
+PS0f = R4f.y;
+// 5
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),intBitsToFloat(uf_remappedVS[5].w)));
+PV1f.x = tempf.x;
+PV1f.y = tempf.x;
+PV1f.z = tempf.x;
+PV1f.w = tempf.x;
+R2f.z = tempf.x;
+R4f.z = R127f.w;
+PS1f = R4f.z;
+// 6
+tempf.x = dot(vec4(R127f.x,R127f.y,R127f.z,R126f.w),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)));
+PV0f.x = tempf.x;
+PV0f.y = tempf.x;
+PV0f.z = tempf.x;
+PV0f.w = tempf.x;
+R2f.w = tempf.x;
+// export
+SET_POSITION(vec4(R2f.x*UIx, R2f.y, R2f.z, R2f.w));
+// export
+passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+// export
+// skipped export to semanticId 255
+// export
+passParameterSem2 = vec4(R4f.x, R4f.y, R4f.z, R4f.w);
+// export
+passParameterSem3 = vec4(R4f.x, R4f.y, R4f.z, R4f.w);
+}

src/TwilightPrincessHD/Graphics/patch_resolution.asm

@@ -0,0 +1,8 @@
+[TwilightPrincessHD_Resolution]
+moduleMatches = 0x1A03E108, 0xA3175EEA ; v81(EU/NA), v82(JP)
+0x1005AAD8 = .float $aspectRatio
+_aspectAddr = 0x1006AAD8
+0x028D75B8 = lis r11, _aspectAddr@h
+0x028D75C0 = lfs f0, _aspectAddr@l(r11) ; Main 3d Aspect
+0x029BB184 = lis r12, _aspectAddr@h
+0x029BB188 = lfs f2, _aspectAddr@l(r12) ; may just be the intro zelda graphic

src/TwilightPrincessHD/Mods/RemoveHUD/14e81f55c62139c7_0000000000000079_ps.txt

@@ -0,0 +1,72 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader 14e81f55c62139c7
+// Used for: Removing the button prompts in the HUD
+
+
+#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
+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;
+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
+backupReg0f = R0f.x;
+backupReg1f = R0f.y;
+backupReg2f = R0f.z;
+backupReg3f = R0f.w;
+R0f.x = mul_nonIEEE(backupReg0f, R1f.x);
+R0f.x = clamp(R0f.x, 0.0, 1.0);
+R0f.y = mul_nonIEEE(backupReg1f, R1f.y);
+R0f.y = clamp(R0f.y, 0.0, 1.0);
+R0f.z = mul_nonIEEE(backupReg2f, R1f.z);
+R0f.z = clamp(R0f.z, 0.0, 1.0);
+R0f.w = mul_nonIEEE(backupReg3f, R1f.w);
+R0f.w = clamp(R0f.w, 0.0, 1.0);
+// export
+passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, 0.0);
+}

src/TwilightPrincessHD/Mods/RemoveHUD/4e1d21b4863fc48c_0000000000000079_ps.txt

@@ -0,0 +1,125 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader 4e1d21b4863fc48c
+// Used for: Removes the HUD icons like 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 = 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;
+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 = passParameterSem2;
+R1f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
+// 0
+PV0f.x = intBitsToFloat(uf_remappedPS[0].w) * intBitsToFloat(0x3f7f0000);
+PV0f.y = intBitsToFloat(uf_remappedPS[0].z) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[0].y) * intBitsToFloat(0x3f7f0000);
+PV0f.w = intBitsToFloat(uf_remappedPS[0].x) * intBitsToFloat(0x3f7f0000);
+// 1
+PV1f.x = fract(PV0f.w);
+R127f.y = fract(PV0f.x);
+R127f.z = fract(PV0f.y);
+PV1f.w = fract(PV0f.z);
+R127f.w = intBitsToFloat(uf_remappedPS[1].x) * intBitsToFloat(0x3f7f0000);
+PS1f = R127f.w;
+// 2
+R127f.x = intBitsToFloat(uf_remappedPS[1].w) * intBitsToFloat(0x3f7f0000);
+PV0f.y = intBitsToFloat(uf_remappedPS[1].z) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[1].y) * intBitsToFloat(0x3f7f0000);
+R126f.w = PV1f.x * intBitsToFloat(0x3f808081);
+R126f.x = PV1f.w * intBitsToFloat(0x3f808081);
+PS0f = R126f.x;
+// 3
+R125f.x = R127f.y * intBitsToFloat(0x3f808081);
+PV1f.y = fract(R127f.w);
+PV1f.z = fract(PV0f.z);
+R127f.w = R127f.z * intBitsToFloat(0x3f808081);
+PV1f.w = R127f.w;
+PS1f = fract(PV0f.y);
+// 4
+PV0f.x = fract(R127f.x);
+R123f.y = (PS1f * intBitsToFloat(0x3f808081) + -(PV1f.w));
+PV0f.y = R123f.y;
+R123f.z = (PV1f.z * intBitsToFloat(0x3f808081) + -(R126f.x));
+PV0f.z = R123f.z;
+R123f.w = (PV1f.y * intBitsToFloat(0x3f808081) + -(R126f.w));
+PV0f.w = R123f.w;
+// 5
+R123f.x = (mul_nonIEEE(PV0f.w,R1f.x) + R126f.w);
+R123f.x = clamp(R123f.x, 0.0, 1.0);
+PV1f.x = R123f.x;
+R123f.y = (PV0f.x * intBitsToFloat(0x3f808081) + -(R125f.x));
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(PV0f.y,R1f.z) + R127f.w);
+R123f.z = clamp(R123f.z, 0.0, 1.0);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(PV0f.z,R1f.y) + R126f.x);
+R123f.w = clamp(R123f.w, 0.0, 1.0);
+PV1f.w = R123f.w;
+// 6
+R123f.x = (mul_nonIEEE(PV1f.y,R1f.w) + R125f.x);
+R123f.x = clamp(R123f.x, 0.0, 1.0);
+PV0f.x = R123f.x;
+R1f.y = mul_nonIEEE(R0f.y, PV1f.w);
+R1f.y = clamp(R1f.y, 0.0, 1.0);
+R1f.z = mul_nonIEEE(R0f.z, PV1f.z);
+R1f.z = clamp(R1f.z, 0.0, 1.0);
+R1f.x = mul_nonIEEE(R0f.x, PV1f.x);
+R1f.x = clamp(R1f.x, 0.0, 1.0);
+PS0f = R1f.x;
+// 7
+R1f.w = mul_nonIEEE(R0f.w, PV0f.x);
+R1f.w = clamp(R1f.w, 0.0, 1.0);
+// export
+passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, 0.0);
+}

src/TwilightPrincessHD/Mods/RemoveHUD/9f1ac253de80a927_0000000000000079_ps.txt

@@ -0,0 +1,125 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader 9f1ac253de80a927
+// Used for: Removing the blinking button in the HUD
+
+
+#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 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;
+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 = passParameterSem2;
+R1f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
+// 0
+PV0f.x = intBitsToFloat(uf_remappedPS[0].w) * intBitsToFloat(0x3f7f0000);
+PV0f.y = intBitsToFloat(uf_remappedPS[0].z) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[0].y) * intBitsToFloat(0x3f7f0000);
+PV0f.w = intBitsToFloat(uf_remappedPS[0].x) * intBitsToFloat(0x3f7f0000);
+// 1
+PV1f.x = fract(PV0f.w);
+R127f.y = fract(PV0f.x);
+R127f.z = fract(PV0f.y);
+PV1f.w = fract(PV0f.z);
+R127f.w = intBitsToFloat(uf_remappedPS[1].x) * intBitsToFloat(0x3f7f0000);
+PS1f = R127f.w;
+// 2
+R127f.x = intBitsToFloat(uf_remappedPS[1].w) * intBitsToFloat(0x3f7f0000);
+PV0f.y = intBitsToFloat(uf_remappedPS[1].z) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[1].y) * intBitsToFloat(0x3f7f0000);
+R126f.w = PV1f.x * intBitsToFloat(0x3f808081);
+R126f.x = PV1f.w * intBitsToFloat(0x3f808081);
+PS0f = R126f.x;
+// 3
+R125f.x = R127f.y * intBitsToFloat(0x3f808081);
+PV1f.y = fract(R127f.w);
+PV1f.z = fract(PV0f.z);
+R127f.w = R127f.z * intBitsToFloat(0x3f808081);
+PV1f.w = R127f.w;
+PS1f = fract(PV0f.y);
+// 4
+PV0f.x = fract(R127f.x);
+R123f.y = (PS1f * intBitsToFloat(0x3f808081) + -(PV1f.w));
+PV0f.y = R123f.y;
+R123f.z = (PV1f.z * intBitsToFloat(0x3f808081) + -(R126f.x));
+PV0f.z = R123f.z;
+R123f.w = (PV1f.y * intBitsToFloat(0x3f808081) + -(R126f.w));
+PV0f.w = R123f.w;
+// 5
+R123f.x = (mul_nonIEEE(PV0f.w,R1f.x) + R126f.w);
+R123f.x = clamp(R123f.x, 0.0, 1.0);
+PV1f.x = R123f.x;
+R123f.y = (PV0f.x * intBitsToFloat(0x3f808081) + -(R125f.x));
+PV1f.y = R123f.y;
+R123f.z = (mul_nonIEEE(PV0f.y,R1f.z) + R127f.w);
+R123f.z = clamp(R123f.z, 0.0, 1.0);
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(PV0f.z,R1f.y) + R126f.x);
+R123f.w = clamp(R123f.w, 0.0, 1.0);
+PV1f.w = R123f.w;
+// 6
+R123f.x = (mul_nonIEEE(PV1f.y,R1f.w) + R125f.x);
+R123f.x = clamp(R123f.x, 0.0, 1.0);
+PV0f.x = R123f.x;
+R1f.y = mul_nonIEEE(R0f.y, PV1f.w);
+R1f.y = clamp(R1f.y, 0.0, 1.0);
+R1f.z = mul_nonIEEE(R0f.z, PV1f.z);
+R1f.z = clamp(R1f.z, 0.0, 1.0);
+R1f.x = mul_nonIEEE(R0f.x, PV1f.x);
+R1f.x = clamp(R1f.x, 0.0, 1.0);
+PS0f = R1f.x;
+// 7
+R1f.w = mul_nonIEEE(R0f.w, PV0f.x);
+R1f.w = clamp(R1f.w, 0.0, 1.0);
+// export
+passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, 0.0);
+}

src/TwilightPrincessHD/Mods/RemoveHUD/acd66e3570ee3a72_0000000000000079_ps.txt

@@ -0,0 +1,137 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader acd66e3570ee3a72
+// Used for: Removing the last bit of text in the HUD
+
+
+#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 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 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 = passParameterSem0;
+R1f = passParameterSem2;
+R1f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
+// 0
+PV0f.x = intBitsToFloat(uf_remappedPS[0].w) * intBitsToFloat(0x3f7f0000);
+PV0f.y = intBitsToFloat(uf_remappedPS[0].z) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[0].y) * intBitsToFloat(0x3f7f0000);
+PV0f.w = intBitsToFloat(uf_remappedPS[0].x) * intBitsToFloat(0x3f7f0000);
+R126f.w = R1f.x;
+R126f.w = clamp(R126f.w, 0.0, 1.0);
+PS0f = R126f.w;
+// 1
+PV1f.x = fract(PV0f.w);
+R127f.y = fract(PV0f.x);
+R127f.z = fract(PV0f.y);
+PV1f.w = fract(PV0f.z);
+R127f.w = intBitsToFloat(uf_remappedPS[1].x) * intBitsToFloat(0x3f7f0000);
+PS1f = R127f.w;
+// 2
+R127f.x = intBitsToFloat(uf_remappedPS[1].w) * intBitsToFloat(0x3f7f0000);
+PV0f.y = intBitsToFloat(uf_remappedPS[1].z) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[1].y) * intBitsToFloat(0x3f7f0000);
+R125f.w = PV1f.x * intBitsToFloat(0x3f808081);
+R126f.x = PV1f.w * intBitsToFloat(0x3f808081);
+PS0f = R126f.x;
+// 3
+backupReg0f = R127f.z;
+R125f.x = R127f.y * intBitsToFloat(0x3f808081);
+PV1f.y = fract(R127f.w);
+R127f.z = fract(PV0f.z);
+R127f.w = backupReg0f * intBitsToFloat(0x3f808081);
+R126f.z = fract(PV0f.y);
+PS1f = R126f.z;
+// 4
+PV0f.x = fract(R127f.x);
+R127f.y = R1f.z;
+R127f.y = clamp(R127f.y, 0.0, 1.0);
+R125f.z = R1f.y;
+R125f.z = clamp(R125f.z, 0.0, 1.0);
+R124f.w = R1f.w;
+R124f.w = clamp(R124f.w, 0.0, 1.0);
+R122f.x = (PV1f.y * intBitsToFloat(0x3f808081) + -(R125f.w));
+PS0f = R122f.x;
+// 5
+R123f.x = (PV0f.x * intBitsToFloat(0x3f808081) + -(R125f.x));
+PV1f.x = R123f.x;
+R123f.y = (R126f.z * intBitsToFloat(0x3f808081) + -(R127f.w));
+PV1f.y = R123f.y;
+R123f.z = (R127f.z * intBitsToFloat(0x3f808081) + -(R126f.x));
+PV1f.z = R123f.z;
+R123f.w = (mul_nonIEEE(PS0f,R126f.w) + R125f.w);
+R123f.w = clamp(R123f.w, 0.0, 1.0);
+PV1f.w = R123f.w;
+// 6
+R123f.x = (mul_nonIEEE(PV1f.x,R124f.w) + R125f.x);
+R123f.x = clamp(R123f.x, 0.0, 1.0);
+PV0f.x = R123f.x;
+R123f.z = (mul_nonIEEE(PV1f.y,R127f.y) + R127f.w);
+R123f.z = clamp(R123f.z, 0.0, 1.0);
+PV0f.z = R123f.z;
+R123f.w = (mul_nonIEEE(PV1f.z,R125f.z) + R126f.x);
+R123f.w = clamp(R123f.w, 0.0, 1.0);
+PV0f.w = R123f.w;
+R1f.x = mul_nonIEEE(R0f.x, PV1f.w);
+R1f.x = clamp(R1f.x, 0.0, 1.0);
+PS0f = R1f.x;
+// 7
+R1f.y = mul_nonIEEE(R0f.y, PV0f.w);
+R1f.y = clamp(R1f.y, 0.0, 1.0);
+R1f.z = mul_nonIEEE(R0f.z, PV0f.z);
+R1f.z = clamp(R1f.z, 0.0, 1.0);
+R1f.w = mul_nonIEEE(R0f.w, PV0f.x);
+R1f.w = clamp(R1f.w, 0.0, 1.0);
+// export
+passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
+}

src/TwilightPrincessHD/Mods/RemoveHUD/b567aed28aa42ec7_0000000000000079_ps.txt

@@ -0,0 +1,122 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader b567aed28aa42ec7
+// Used for: Removing the text from the HUD
+
+
+#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 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;
+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 = passParameterSem2;
+R1f.w = (texture(textureUnitPS0, R1f.xy).w);
+// 0
+PV0f.x = intBitsToFloat(uf_remappedPS[0].w) * intBitsToFloat(0x3f7f0000);
+PV0f.y = intBitsToFloat(uf_remappedPS[0].z) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[0].y) * intBitsToFloat(0x3f7f0000);
+PV0f.w = intBitsToFloat(uf_remappedPS[0].x) * intBitsToFloat(0x3f7f0000);
+// 1
+PV1f.x = fract(PV0f.w);
+R127f.y = fract(PV0f.x);
+R127f.z = fract(PV0f.y);
+PV1f.w = fract(PV0f.z);
+R127f.w = intBitsToFloat(uf_remappedPS[1].x) * intBitsToFloat(0x3f7f0000);
+PS1f = R127f.w;
+// 2
+R127f.x = intBitsToFloat(uf_remappedPS[1].w) * intBitsToFloat(0x3f7f0000);
+PV0f.y = intBitsToFloat(uf_remappedPS[1].z) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[1].y) * intBitsToFloat(0x3f7f0000);
+R126f.w = PV1f.x * intBitsToFloat(0x3f808081);
+R126f.x = PV1f.w * intBitsToFloat(0x3f808081);
+PS0f = R126f.x;
+// 3
+R125f.x = R127f.y * intBitsToFloat(0x3f808081);
+PV1f.y = fract(R127f.w);
+PV1f.z = fract(PV0f.z);
+R127f.w = R127f.z * intBitsToFloat(0x3f808081);
+PV1f.w = R127f.w;
+PS1f = fract(PV0f.y);
+// 4
+PV0f.x = fract(R127f.x);
+R123f.y = (PS1f * intBitsToFloat(0x3f808081) + -(PV1f.w));
+PV0f.y = R123f.y;
+R123f.z = (PV1f.z * intBitsToFloat(0x3f808081) + -(R126f.x));
+PV0f.z = R123f.z;
+R123f.w = (PV1f.y * intBitsToFloat(0x3f808081) + -(R126f.w));
+PV0f.w = R123f.w;
+// 5
+PV1f.x = R126f.w + PV0f.w;
+PV1f.x = clamp(PV1f.x, 0.0, 1.0);
+R123f.y = (PV0f.x * intBitsToFloat(0x3f808081) + -(R125f.x));
+PV1f.y = R123f.y;
+PV1f.z = R127f.w + PV0f.y;
+PV1f.z = clamp(PV1f.z, 0.0, 1.0);
+PV1f.w = R126f.x + PV0f.z;
+PV1f.w = clamp(PV1f.w, 0.0, 1.0);
+// 6
+R123f.x = (mul_nonIEEE(PV1f.y,R1f.w) + R125f.x);
+R123f.x = clamp(R123f.x, 0.0, 1.0);
+PV0f.x = R123f.x;
+R1f.y = mul_nonIEEE(R0f.y, PV1f.w);
+R1f.y = clamp(R1f.y, 0.0, 1.0);
+R1f.z = mul_nonIEEE(R0f.z, PV1f.z);
+R1f.z = clamp(R1f.z, 0.0, 1.0);
+R1f.x = mul_nonIEEE(R0f.x, PV1f.x);
+R1f.x = clamp(R1f.x, 0.0, 1.0);
+PS0f = R1f.x;
+// 7
+R1f.w = mul_nonIEEE(R0f.w, PV0f.x);
+R1f.w = clamp(R1f.w, 0.0, 1.0);
+// export
+passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, 0.0);
+}

src/TwilightPrincessHD/Mods/RemoveHUD/e264c779e7deb774_0000000000000079_ps.txt

@@ -0,0 +1,69 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader e264c779e7deb774
+// Used for: Removing the map from the HUD
+
+
+#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
+TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) 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);
+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;
+R0f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
+// 0
+backupReg0f = R0f.x;
+backupReg1f = R0f.y;
+backupReg2f = R0f.z;
+backupReg3f = R0f.w;
+R0f.x = backupReg0f;
+R0f.x = clamp(R0f.x, 0.0, 1.0);
+R0f.y = backupReg1f;
+R0f.y = clamp(R0f.y, 0.0, 1.0);
+R0f.z = backupReg2f;
+R0f.z = clamp(R0f.z, 0.0, 1.0);
+R0f.w = backupReg3f;
+R0f.w = clamp(R0f.w, 0.0, 1.0);
+// export
+passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, 0.0);
+}

src/TwilightPrincessHD/Mods/RemoveHUD/f6e03fd012597dda_0000000000000079_ps.txt

@@ -0,0 +1,122 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader f6e03fd012597dda
+// Used for: Removing even more text from HUD
+
+
+#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 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 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;
+R0f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
+// 0
+backupReg0f = R0f.x;
+PV0f.x = intBitsToFloat(uf_remappedPS[0].w) * intBitsToFloat(0x3f7f0000);
+PV0f.y = intBitsToFloat(uf_remappedPS[0].z) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[0].y) * intBitsToFloat(0x3f7f0000);
+PV0f.w = intBitsToFloat(uf_remappedPS[0].x) * intBitsToFloat(0x3f7f0000);
+R126f.w = backupReg0f;
+R126f.w = clamp(R126f.w, 0.0, 1.0);
+PS0f = R126f.w;
+// 1
+PV1f.x = fract(PV0f.w);
+R127f.y = fract(PV0f.x);
+R127f.z = fract(PV0f.y);
+PV1f.w = fract(PV0f.z);
+R127f.w = intBitsToFloat(uf_remappedPS[1].x) * intBitsToFloat(0x3f7f0000);
+PS1f = R127f.w;
+// 2
+R127f.x = intBitsToFloat(uf_remappedPS[1].w) * intBitsToFloat(0x3f7f0000);
+PV0f.y = intBitsToFloat(uf_remappedPS[1].z) * intBitsToFloat(0x3f7f0000);
+PV0f.z = intBitsToFloat(uf_remappedPS[1].y) * intBitsToFloat(0x3f7f0000);
+R125f.w = PV1f.x * intBitsToFloat(0x3f808081);
+R126f.x = PV1f.w * intBitsToFloat(0x3f808081);
+PS0f = R126f.x;
+// 3
+backupReg0f = R127f.z;
+R125f.x = R127f.y * intBitsToFloat(0x3f808081);
+PV1f.y = fract(R127f.w);
+R127f.z = fract(PV0f.z);
+R127f.w = backupReg0f * intBitsToFloat(0x3f808081);
+R126f.z = fract(PV0f.y);
+PS1f = R126f.z;
+// 4
+PV0f.x = fract(R127f.x);
+R127f.y = R0f.z;
+R127f.y = clamp(R127f.y, 0.0, 1.0);
+R125f.z = R0f.y;
+R125f.z = clamp(R125f.z, 0.0, 1.0);
+R124f.w = R0f.w;
+R124f.w = clamp(R124f.w, 0.0, 1.0);
+R122f.x = (PV1f.y * intBitsToFloat(0x3f808081) + -(R125f.w));
+PS0f = R122f.x;
+// 5
+R123f.x = (PV0f.x * intBitsToFloat(0x3f808081) + -(R125f.x));
+PV1f.x = R123f.x;
+R123f.y = (R126f.z * intBitsToFloat(0x3f808081) + -(R127f.w));
+PV1f.y = R123f.y;
+R123f.z = (R127f.z * intBitsToFloat(0x3f808081) + -(R126f.x));
+PV1f.z = R123f.z;
+R0f.x = (mul_nonIEEE(PS0f,R126f.w) + R125f.w);
+R0f.x = clamp(R0f.x, 0.0, 1.0);
+PS1f = R0f.x;
+// 6
+R0f.y = (mul_nonIEEE(PV1f.z,R125f.z) + R126f.x);
+R0f.y = clamp(R0f.y, 0.0, 1.0);
+R0f.z = (mul_nonIEEE(PV1f.y,R127f.y) + R127f.w);
+R0f.z = clamp(R0f.z, 0.0, 1.0);
+R0f.w = (mul_nonIEEE(PV1f.x,R124f.w) + R125f.x);
+R0f.w = clamp(R0f.w, 0.0, 1.0);
+// export
+passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, 0.0);
+}

src/TwilightPrincessHD/Mods/RemoveHUD/faace4c78d269ce1_0000000000000079_ps.txt

@@ -0,0 +1,72 @@
+#version 450
+#extension GL_ARB_texture_gather : enable
+#extension GL_ARB_separate_shader_objects : enable
+// shader faace4c78d269ce1
+// Used for: Removing more text from HUD
+
+
+#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
+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;
+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.w = (texture(textureUnitPS0, R1f.xy).w);
+// 0
+backupReg0f = R0f.x;
+backupReg1f = R0f.y;
+backupReg2f = R0f.z;
+backupReg3f = R0f.w;
+R0f.x = backupReg0f;
+R0f.x = clamp(R0f.x, 0.0, 1.0);
+R0f.y = backupReg1f;
+R0f.y = clamp(R0f.y, 0.0, 1.0);
+R0f.z = backupReg2f;
+R0f.z = clamp(R0f.z, 0.0, 1.0);
+R0f.w = mul_nonIEEE(backupReg3f, R1f.w);
+R0f.w = clamp(R0f.w, 0.0, 1.0);
+// export
+passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, 0.0);
+}

src/TwilightPrincessHD/Mods/RemoveHUD/rules.txt

@@ -0,0 +1,7 @@
+[Definition]
+titleIds = 000500001019E500,000500001019E600,000500001019C800
+name = Remove HUD
+path = "The Legend of Zelda: Twilight Princess HD/Mods/Remove HUD (breaks menus)"
+description = Hides the HUD elements like the hearts, controller buttons and rupees count.|You should only enable this graphic pack when you want to make a screenshot without the HUD.
+#Credits: Crementif
+version = 6

src/TwilightPrincessHD/Mods/RemoveHaze/patch_RemoveHaze.asm

@@ -0,0 +1,9 @@
+[TwilightPrincessHD_RemoveHaze]
+moduleMatches = 0x1A03E108, 0xA3175EEA ; v81(EU/NA), v82(JP)
+;##exp and haze settings
+0x100C3EB8 = .float $nearExp   ; Near world (over)exposure
+0x100C36C4 = .float $bloomExp  ; Bloom npc/object (over) "
+0x100C3780 = .float $distExp   ; Distant world (over)exposure
+;0x100C3774 = .float $distanceFog
+0x1012C898 = .float  $distanceFog
+;0x100871C8 = .float 0.01 ;100871C8:.float 0.00050000002   ;cloud float

src/TwilightPrincessHD/Mods/RemoveHaze/rules.txt

@@ -0,0 +1,44 @@
+[Definition]
+titleIds = 000500001019C800,000500001019E600,000500001019E500
+name = Distant Fog
+path = "The Legend of Zelda: Twilight Princess HD/Mods/Distant Fog"
+description = Sets the depth and exposure of distant fog. Possible issues with disappearing objects.|Made by getdls.
+#Credits: getdls
+version = 6
+
+[Default]
+$distanceFog = 21.0
+$nearExp = 0.0039
+$bloomExp = 0.0039
+$distExp = 0.0039
+
+[Preset]
+name = Default
+
+[Preset]
+name = Half-distant fog
+$distanceFog = 22.0
+$nearExp = 0.0039
+$bloomExp = 0.0039
+$distExp = 0.0039
+
+[Preset]
+name = No distant fog
+$distanceFog = 60.0
+$nearExp = 0.0039
+$bloomExp = 0.0039
+$distExp = 0.0039
+
+[Preset]
+name = Low exposure
+$distanceFog = 21.0
+$nearExp = 0.00375
+$bloomExp = 0.00375
+$distExp = 0.00375
+
+[Preset]
+name = Lowest exposure
+$distanceFog = 22.0
+$nearExp = 0.003
+$bloomExp = 0.00325
+$distExp = 0.00325