From df95647b6543ab705163ac3ade4034adb47f2901 Mon Sep 17 00:00:00 2001 From: intra0 Date: Fri, 13 Dec 2024 23:37:02 -0600 Subject: [PATCH] Add src/SuperMario3DWorld --- .../be99d80628d31127_00000000000003c9_ps.txt | 312 ++ .../Enhancements/Contrasty/rules.txt | 119 + .../Enhancements/LevelofDetail/rules.txt | 54 + .../1f83c0d47b1c4c34_0000000000000000_vs.txt | 104 + .../280351fcf8e5949f_0000000000000000_vs.txt | 103 + .../470eee1bb25ab50d_0000000000000000_vs.txt | 105 + .../4c426260188ace42_0000000000000000_vs.txt | 137 + .../5661793d88425685_0000000007fffff9_ps.txt | 297 ++ .../6d9067fd20086bc0_0000000000000000_vs.txt | 113 + .../842a19b509f8b91a_0000000000000000_vs.txt | 128 + .../8d68a0e3561ff525_0000000000000000_vs.txt | 126 + .../b727c08e3b534992_0000000007fffffd_ps.txt | 360 ++ .../be99d80628d31127_00000000000003c9_ps.txt | 218 + .../c27612e2f7126ebf_0000000000000000_vs.txt | 140 + .../c4eaec09897d525e_0000000000000000_vs.txt | 98 + .../d388f32cb9be9a7a_000000000000f249_ps.txt | 292 ++ .../d9c81460d6984bb2_0000000000000000_vs.txt | 140 + .../e4e4a60266119f75_0000000000000000_vs.txt | 107 + .../fa47a4b5f1304f51_0000000000000000_vs.txt | 137 + .../Graphics/patch_resolution.asm | 14 + src/SuperMario3DWorld/Graphics/rules.txt | 3980 +++++++++++++++++ .../b84517cef3bb49ad_000000000000007d_ps.txt | 114 + .../d9953dbd7354b119_000000000000007d_ps.txt | 105 + .../d9f064ae204238df_000000000000007d_ps.txt | 103 + src/SuperMario3DWorld/Mods/NoHUD/rules.txt | 7 + 25 files changed, 7413 insertions(+) create mode 100644 src/SuperMario3DWorld/Enhancements/Contrasty/be99d80628d31127_00000000000003c9_ps.txt create mode 100644 src/SuperMario3DWorld/Enhancements/Contrasty/rules.txt create mode 100644 src/SuperMario3DWorld/Enhancements/LevelofDetail/rules.txt create mode 100644 src/SuperMario3DWorld/Graphics/1f83c0d47b1c4c34_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/280351fcf8e5949f_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/470eee1bb25ab50d_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/4c426260188ace42_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/5661793d88425685_0000000007fffff9_ps.txt create mode 100644 src/SuperMario3DWorld/Graphics/6d9067fd20086bc0_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/842a19b509f8b91a_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/8d68a0e3561ff525_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/b727c08e3b534992_0000000007fffffd_ps.txt create mode 100644 src/SuperMario3DWorld/Graphics/be99d80628d31127_00000000000003c9_ps.txt create mode 100644 src/SuperMario3DWorld/Graphics/c27612e2f7126ebf_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/c4eaec09897d525e_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/d388f32cb9be9a7a_000000000000f249_ps.txt create mode 100644 src/SuperMario3DWorld/Graphics/d9c81460d6984bb2_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/e4e4a60266119f75_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/fa47a4b5f1304f51_0000000000000000_vs.txt create mode 100644 src/SuperMario3DWorld/Graphics/patch_resolution.asm create mode 100644 src/SuperMario3DWorld/Graphics/rules.txt create mode 100644 src/SuperMario3DWorld/Mods/NoHUD/b84517cef3bb49ad_000000000000007d_ps.txt create mode 100644 src/SuperMario3DWorld/Mods/NoHUD/d9953dbd7354b119_000000000000007d_ps.txt create mode 100644 src/SuperMario3DWorld/Mods/NoHUD/d9f064ae204238df_000000000000007d_ps.txt create mode 100644 src/SuperMario3DWorld/Mods/NoHUD/rules.txt diff --git a/src/SuperMario3DWorld/Enhancements/Contrasty/be99d80628d31127_00000000000003c9_ps.txt b/src/SuperMario3DWorld/Enhancements/Contrasty/be99d80628d31127_00000000000003c9_ps.txt new file mode 100644 index 00000000..83549a72 --- /dev/null +++ b/src/SuperMario3DWorld/Enhancements/Contrasty/be99d80628d31127_00000000000003c9_ps.txt @@ -0,0 +1,312 @@ +#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 be99d80628d31127 //AA PS +// Used for: Another vertical blur + +#ifdef VULKAN +layout(set = 1, binding = 2) uniform ufBlock +{ +uniform ivec4 uf_remappedPS[4]; +uniform vec4 uf_fragCoordScale; +}; +#else +uniform ivec4 uf_remappedPS[4]; +uniform vec2 uf_fragCoordScale; +#endif + +const float hazeFactor = 0.1; + +const float gamma = $gamma; // 1.0 is neutral Botw is already colour graded at this stage +const float exposure = $exposure; // 1.0 is neutral +const float vibrance = $vibrance; // 0.0 is neutral +const float crushContrast = $crushContrast; // 0.0 is neutral. Use small increments, loss of shadow detail +const float contrastCurve = $contrastCurve; + + +vec3 RGB_Lift = vec3($redShadows, $greenShadows , $blueSadows); // [0.000 to 2.000] Adjust shadows for Red, Green and Blue. +vec3 RGB_Gamma = vec3($redMid ,$greenMid, $blueMid); // [0.000 to 2.000] Adjust midtones for Red, Green and Blue +vec3 RGB_Gain = vec3($redHilight, $greenHilight, $blueHilight); // [0.000 to 2.000] Adjust highlights for Red, Green and Blue +//lumasharpen +const float sharp_mix = $sharp_mix; +const float sharp_strength = 2.0; +const float sharp_clamp = 0.75; +const float offset_bias = 1.0; +float Sigmoid (float x) { + + return 1.0 / (1.0 + (exp(-(x - 0.5) * 5.5))); +} + + +#define px (1.0/1280.0*uf_fragCoordScale.x) +#define py (1.0/720.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; +} + +// uf_remappedPS[4] was moved to the ufBlock +TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0; +TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1; +layout(location = 0) in vec4 passParameterSem2; +layout(location = 0) out vec4 passPixelColor0; +//uniform vec2 uf_fragCoordScale; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){return mix(0.0, a*b, (a != 0.0) && (b != 0.0));} +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +bool activeMaskStack[2]; +bool activeMaskStackC[3]; +activeMaskStack[0] = false; +activeMaskStackC[0] = false; +activeMaskStackC[1] = false; +activeMaskStack[0] = true; +activeMaskStackC[0] = true; +activeMaskStackC[1] = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +float scaler = uf_fragCoordScale.x; +R0f = passParameterSem2; +if( activeMaskStackC[1] == true ) { +R4f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw); +R2f.xyzw = (textureGather(textureUnitPS1, R0f.xy).wzxy); +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +PV0f.x = min(R2f.z, R2f.x); +PV0f.y = max(R2f.z, R2f.x); +PV0f.z = mul_nonIEEE(R4f.x, intBitsToFloat(uf_remappedPS[0].x)); +PV0f.w = min(R2f.w, R2f.y); +PS0f = max(R2f.w, R2f.y); +// 1 +PV1f.x = min(PV0f.x, PV0f.w); +R123f.y = (mul_nonIEEE(R4f.y,intBitsToFloat(uf_remappedPS[0].y)) + PV0f.z); +PV1f.y = R123f.y; +R127f.z = R2f.z + -(R2f.y); +PV1f.z = R127f.z; +PV1f.w = max(PV0f.y, PS0f); +R126f.z = R2f.w + -(R2f.x); +PS1f = R126f.z; +// 2 +PV0f.x = mul_nonIEEE(PV1f.w, intBitsToFloat(uf_remappedPS[1].x)); +PV0f.y = max(PV1f.y, PV1f.w); +PV0f.z = min(PV1f.y, PV1f.x); +R3f.x = PV1f.z + PS1f; +PS0f = R3f.x; +// 3 +R1f.x = max(PV0f.x, intBitsToFloat(uf_remappedPS[1].y)); +R3f.y = -(PV0f.z) + PV0f.y; +R1f.y = R127f.z + -(R126f.z); +PS1f = R1f.y; +// 4 +predResult = (R3f.y > R1f.x); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +backupReg0f = R2f.y; +R1f.x = max(R3f.x, -(R3f.x)); +PV0f.x = R1f.x; +R2f.y = backupReg0f + R2f.x; +PV0f.y = R2f.y; +R0f.z = intBitsToFloat(uf_remappedPS[2].z) * 0.25; +R0f.w = max(R1f.y, -(R1f.y)); +PV0f.w = R0f.w; +R2f.x = -(intBitsToFloat(uf_remappedPS[3].x)); +PS0f = R2f.x; +// 1 +R3f.y = R2f.z + PV0f.y; +PV1f.y = R3f.y; +R2f.y = min(PV0f.x, PV0f.w); +PS1f = R2f.y; +// 2 +R3f.y = R2f.w + PV1f.y; +PV0f.y = R3f.y; +R1f.z = intBitsToFloat(uf_remappedPS[3].x); +R0f.w = intBitsToFloat(uf_remappedPS[3].y); +R5f.y = -(intBitsToFloat(uf_remappedPS[3].y)); +PS0f = R5f.y; +// 3 +backupReg0f = R0f.z; +R0f.z = (mul_nonIEEE(backupReg0f,PV0f.y) + intBitsToFloat(uf_remappedPS[2].w)); +PV1f.z = R0f.z; +// 4 +backupReg0f = R2f.y; +R2f.y = max(PV1f.z, backupReg0f); +PV0f.y = R2f.y; +// 5 +R2f.y = 1.0 / PV0f.y; +PS1f = R2f.y; +// 6 +backupReg0f = R1f.y; +R1f.x = mul_nonIEEE(R3f.x, PS1f); +PV0f.x = R1f.x; +R1f.y = mul_nonIEEE(backupReg0f, PS1f); +PV0f.y = R1f.y; +// 7 +R1f.x = max(PV0f.x, -(intBitsToFloat(uf_remappedPS[2].y))); +PV1f.x = R1f.x; +R1f.y = max(PV0f.y, -(intBitsToFloat(uf_remappedPS[2].y))); +PV1f.y = R1f.y; +// 8 +R1f.x = min(PV1f.x, intBitsToFloat(uf_remappedPS[2].y)); +PV0f.x = R1f.x; +R1f.y = min(PV1f.y, intBitsToFloat(uf_remappedPS[2].y)); +PV0f.y = R1f.y; +// 9 +backupReg0f = R0f.x; +backupReg1f = R0f.y; +backupReg0f = R0f.x; +backupReg2f = R0f.w; +backupReg1f = R0f.y; +R0f.x = (mul_nonIEEE(PV0f.x,R2f.x) *scaler + backupReg0f); +R0f.y = (mul_nonIEEE(PV0f.y,R5f.y) *scaler + backupReg1f); +R0f.z = (mul_nonIEEE(PV0f.x,R1f.z) *scaler + backupReg0f); +R0f.w = (mul_nonIEEE(PV0f.y,backupReg2f) *scaler + backupReg1f); +} +if( activeMaskStackC[2] == true ) { +R1f.xyzw = (texture(textureUnitPS0, R0f.zw).xyzw); +R0f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw); +} +if( activeMaskStackC[2] == true ) { +// 0 +backupReg0f = R0f.y; +backupReg1f = R0f.x; +PV0f.x = R0f.w + R1f.w; +PV0f.x /= 2.0; +PV0f.y = R0f.z + R1f.z; +PV0f.y /= 2.0; +PV0f.z = backupReg0f + R1f.y; +PV0f.z /= 2.0; +PV0f.w = backupReg1f + R1f.x; +PV0f.w /= 2.0; +// 1 +PV1f.x = -(R4f.w) + PV0f.x; +PV1f.y = -(R4f.z) + PV0f.y; +PV1f.z = -(R4f.y) + PV0f.z; +PV1f.w = -(R4f.x) + PV0f.w; +// 2 +backupReg0f = R4f.x; +backupReg1f = R4f.y; +backupReg2f = R4f.z; +backupReg3f = R4f.w; +R4f.x = (PV1f.w * intBitsToFloat(0x3f4ccccd) + backupReg0f); +R4f.y = (PV1f.z * intBitsToFloat(0x3f4ccccd) + backupReg1f); +R4f.z = (PV1f.y * intBitsToFloat(0x3f4ccccd) + backupReg2f); +R4f.w = (PV1f.x * intBitsToFloat(0x3f4ccccd) + backupReg3f); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +// export +R4f.xyz = contrasty(R4f.xyz); +R4f.xyz = mix(R4f.xyz, smoothstep(0.0, 1.0, R4f.xyz), contrastCurve); +float smask = lumasharping(textureUnitPS0, passParameterSem2.xy); +vec3 temp3 = R4f.xyz; +R4f.xyz = mix(R4f.xyz, (temp3.xyz += (smask)), sharp_mix); + +passPixelColor0 = vec4(R4f.x, R4f.y, R4f.z, R4f.w); +} diff --git a/src/SuperMario3DWorld/Enhancements/Contrasty/rules.txt b/src/SuperMario3DWorld/Enhancements/Contrasty/rules.txt new file mode 100644 index 00000000..3a6ef8f5 --- /dev/null +++ b/src/SuperMario3DWorld/Enhancements/Contrasty/rules.txt @@ -0,0 +1,119 @@ +[Definition] +titleIds = 0005000010145D00,0005000010145C00,0005000010106100 +name = Contrasty +path = "Super Mario 3D World/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. Doesn't work if you also upscale or downscale the resolution.|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] +name = debug +$redShadows = 1.0 +$greenShadows = 1.0 +$blueSadows = 1.0 +$redMid = 0.5 +$greenMid = 0.5 +$blueMid = 1.0 +$redHilight = 0.5 +$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.1 + +[Preset] +name = High Contrasty +$redShadows = 1.0 +$greenShadows = 1.0 +$blueSadows = 1.0 +$redMid = 0.98 +$greenMid = 0.98 +$blueMid = 0.9 +$redHilight = 1.0 +$greenHilight =1.0 +$blueHilight = 1.0 + +$contrastCurve = 0.6 +$hazeFactor = 0.25 +$bloom = 0.85 +$gamma = 1.1 +$exposure = 1.05 +$vibrance = 0.25 +$crushContrast = 0.00 +$bleach = 0.85 +$sharp_mix = 0.1 + +[Preset] +name = Colourful +$redShadows = 0.999 +$greenShadows = 0.98 +$blueSadows = 0.98 +$redMid = 1.0 +$greenMid = 0.99 +$blueMid = 0.99 +$redHilight = 1.0 +$greenHilight =0.99 +$blueHilight = 0.99 + +$contrastCurve = 0.15 +$hazeFactor = 1.0 +$bloom = 0.85 +$gamma = 1.05 +$exposure = 1.01 +$vibrance = 0.4 +$crushContrast = 0.00 +$bleach = 0.85 +$sharp_mix = 0.1 + +[Preset] +name = Neutral Contrasty +$redShadows = 1.01 +$greenShadows = 1.01 +$blueSadows = 1.01 +$redMid = 1.0 +$greenMid = 1.0 +$blueMid = 1.0 +$redHilight = 0.99 +$greenHilight =0.99 +$blueHilight = 0.99 + +$contrastCurve = 0.30 +$hazeFactor = 1.0 +$bloom = 0.85 +$gamma = 1.075 +$exposure = 1.01 +$vibrance = 0.15 +$crushContrast = 0.00 +$bleach = 0.85 +$sharp_mix = 0.1 diff --git a/src/SuperMario3DWorld/Enhancements/LevelofDetail/rules.txt b/src/SuperMario3DWorld/Enhancements/LevelofDetail/rules.txt new file mode 100644 index 00000000..a3041158 --- /dev/null +++ b/src/SuperMario3DWorld/Enhancements/LevelofDetail/rules.txt @@ -0,0 +1,54 @@ +[Definition] +titleIds = 0005000010145D00,0005000010145C00,0005000010106100 +name = Negative texture LOD bias +path = "Super Mario 3D World/Enhancements/Texture LOD" +description = Texture LOD override, possible shimmer but sharper textures.|Made by Ryce-Fast. +#Credits: Ryce-Fast +version = 6 + +[Default] +$0x431 = 0 +$0x432 = 0 +$0x433 = 0 +$0x434 = 0 + +[Preset] +name = Default LOD + +[Preset] +name = Slightly higher LOD +$0x431 = -.5 +$0x432 = -.5 +$0x433 = -.5 +$0x434 = -.5 + +[Preset] +name = High LOD +$0x431 = -1 +$0x432 = -1 +$0x433 = -1 +$0x434 = -1 + +[Preset] +name = Very High LOD +$0x431 = -4 +$0x432 = -4 +$0x433 = -4 +$0x434 = -4 + + +[TextureRedefine] +formats = 0x431 +overwriteRelativeLodBias = $0x431 + +[TextureRedefine] +formats = 0x432 +overwriteRelativeLodBias = $0x432 + +[TextureRedefine] +formats = 0x433 +overwriteRelativeLodBias = $0x433 + +[TextureRedefine] +formats = 0x434 +overwriteRelativeLodBias = $0x434 diff --git a/src/SuperMario3DWorld/Graphics/1f83c0d47b1c4c34_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/1f83c0d47b1c4c34_0000000000000000_vs.txt new file mode 100644 index 00000000..73929876 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/1f83c0d47b1c4c34_0000000000000000_vs.txt @@ -0,0 +1,104 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#ifdef VULKAN +#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location) +#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140) +#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation) +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw) +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#else +#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location) +#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140) +#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation) +#define SET_POSITION(_v) gl_Position = _v +#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw) +#endif +// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL. + +// shader 1f83c0d47b1c4c34 +// Used for: Background Blur +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[1]; +// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7 +}; +#else +uniform ivec4 uf_remappedVS[1]; +// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7 +#endif +// uf_windowSpaceToClipSpaceTransform was moved to the ufBlock +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +backupReg0f = R1f.x; +backupReg1f = R1f.y; +R1f.x = backupReg0f; +R1f.x *= 2.0; +R1f.y = backupReg1f; +R1f.y *= 2.0; +R1f.z = intBitsToFloat(0xbf800000); +R1f.w = 1.0; +PS0f = R2f.x + -(intBitsToFloat(uf_remappedVS[0].x)/resXScale); +// 1 +backupReg0f = R2f.y; +backupReg1f = R2f.x; +PV1f.x = R2f.y + -(intBitsToFloat(uf_remappedVS[0].y)/resYScale); +R2f.y = backupReg0f + intBitsToFloat(uf_remappedVS[0].y)/resYScale; +R2f.z = PS0f; +R2f.x = backupReg1f + intBitsToFloat(uf_remappedVS[0].x)/resXScale; +PS1f = R2f.x; +// 2 +R2f.w = PV1f.x; +// export +SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w)); +// export +passParameterSem3 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/280351fcf8e5949f_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/280351fcf8e5949f_0000000000000000_vs.txt new file mode 100644 index 00000000..4c0273e2 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/280351fcf8e5949f_0000000000000000_vs.txt @@ -0,0 +1,103 @@ +#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 280351fcf8e5949f +// Used for: Another vertical blur +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[1]; +// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7 +}; +#else +uniform ivec4 uf_remappedVS[1]; +// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7 +#endif +// uf_windowSpaceToClipSpaceTransform was moved to the ufBlock +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) noperspective out vec4 passParameterSem0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +backupReg0f = R1f.x; +backupReg1f = R1f.y; +R1f.x = backupReg0f; +R1f.x *= 2.0; +R1f.y = backupReg1f; +R1f.y *= 2.0; +R1f.z = 0.0; +R1f.w = 1.0; +PS0f = intBitsToFloat(uf_remappedVS[0].x)/resXScale * intBitsToFloat(0x3f99999a); +// 1 +backupReg0f = R2f.x; +backupReg0f = R2f.x; +backupReg0f = R2f.x; +R2f.x = R2f.y; +R2f.y = backupReg0f + -(PS0f); +R2f.z = backupReg0f + PS0f; +R2f.w = backupReg0f; +// export +SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w)); +// export +passParameterSem0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/470eee1bb25ab50d_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/470eee1bb25ab50d_0000000000000000_vs.txt new file mode 100644 index 00000000..d217650c --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/470eee1bb25ab50d_0000000000000000_vs.txt @@ -0,0 +1,105 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_separate_shader_objects : enable +#ifdef VULKAN +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#else +#define SET_POSITION(_v) gl_Position = _v +#endif +#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 470eee1bb25ab50d +// low res reflection +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[1]; +}; +#else +uniform ivec4 uf_remappedVS[1]; +#endif +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1; +out gl_PerVertex +{ + vec4 gl_Position; +}; +layout(location = 0) noperspective out vec4 passParameterSem0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +backupReg0f = R1f.x; +backupReg1f = R1f.y; +R1f.x = backupReg0f; +R1f.x *= 2.0; +R1f.y = backupReg1f; +R1f.y *= 2.0; +R1f.z = 0.0; +R1f.w = 1.0; +PS0f = intBitsToFloat(uf_remappedVS[0].y) * intBitsToFloat(0x3f99999a)/resXScale; +// 1 +backupReg0f = R2f.y; +backupReg0f = R2f.y; +backupReg0f = R2f.y; +R2f.y = backupReg0f + -(PS0f); +R2f.z = backupReg0f + PS0f; +R2f.w = backupReg0f; +// export +SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w)); +// export +passParameterSem0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/4c426260188ace42_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/4c426260188ace42_0000000000000000_vs.txt new file mode 100644 index 00000000..b1b39191 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/4c426260188ace42_0000000000000000_vs.txt @@ -0,0 +1,137 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_separate_shader_objects : enable +#ifdef VULKAN +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#else +#define SET_POSITION(_v) gl_Position = _v +#endif +#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 4c426260188ace42 +//switch palace reflection vertical +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[5]; +}; +#else +uniform ivec4 uf_remappedVS[5]; +#endif +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +out gl_PerVertex +{ + vec4 gl_Position; +}; +layout(location = 0) out vec4 passParameterSem0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +R127f.x = -(R1f.y); +PV0f.x = R127f.x; +R127f.y = (R1f.x > 0.0)?1.0:0.0; +R127f.y /= 2.0; +R126f.z = (0.0 > R1f.x)?1.0:0.0; +R126f.z /= 2.0; +R127f.w = 1.0; +PV0f.w = R127f.w; +R126f.x = intBitsToFloat(uf_remappedVS[0].w) * intBitsToFloat(0x3fae8a72)/resYScale; +PS0f = R126f.x; +// 1 +R0f.x = dot(vec4(R1f.x,R1f.y,R1f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w))); +PV1f.x = R0f.x; +PV1f.y = R0f.x; +PV1f.z = R0f.x; +PV1f.w = R0f.x; +R127f.z = (PV0f.x > 0.0)?1.0:0.0; +R127f.z /= 2.0; +PS1f = R127f.z; +// 2 +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w))); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R0f.y = tempf.x; +PS0f = (0.0 > R127f.x)?1.0:0.0; +PS0f /= 2.0; +// 3 +backupReg0f = R127f.z; +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w))); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +R0f.z = tempf.x; +R127f.z = backupReg0f + -(PS0f); +PS1f = R127f.z; +// 4 +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w))); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R0f.w = tempf.x; +PS0f = R127f.y + -(R126f.z); +// 5 +R1f.x = PS0f + 0.5; +PV1f.y = R127f.z + 0.5; +// 6 +R1f.y = PV1f.y + -(R126f.x); +R1f.z = PV1f.y + R126f.x; +R1f.w = PV1f.y; +// export +SET_POSITION(vec4(R0f.x, R0f.y, R0f.z, R0f.w)); +// export +passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/5661793d88425685_0000000007fffff9_ps.txt b/src/SuperMario3DWorld/Graphics/5661793d88425685_0000000007fffff9_ps.txt new file mode 100644 index 00000000..5c8fb1d7 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/5661793d88425685_0000000007fffff9_ps.txt @@ -0,0 +1,297 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#ifdef VULKAN +#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location) +#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140) +#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation) +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw) +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#else +#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location) +#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140) +#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation) +#define SET_POSITION(_v) gl_Position = _v +#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw) +#endif +// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL. + +// shader 5661793d88425685 +// Used for: First glitter bloom pass +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 1, binding = 1) uniform ufBlock +{ +uniform ivec4 uf_remappedPS[7]; +uniform vec4 uf_fragCoordScale; +}; +#else +uniform ivec4 uf_remappedPS[7]; +uniform vec2 uf_fragCoordScale; +#endif +TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +layout(location = 1) out vec4 passPixelColor1; +layout(location = 2) out vec4 passPixelColor2; +layout(location = 3) out vec4 passPixelColor3; +layout(location = 4) out vec4 passPixelColor4; +layout(location = 5) out vec4 passPixelColor5; +// uf_fragCoordScale was moved to the ufBlock +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R6f = vec4(0.0); +vec4 R7f = vec4(0.0); +vec4 R8f = vec4(0.0); +vec4 R9f = vec4(0.0); +vec4 R10f = vec4(0.0); +vec4 R11f = vec4(0.0); +vec4 R12f = vec4(0.0); +vec4 R13f = vec4(0.0); +vec4 R14f = vec4(0.0); +vec4 R15f = vec4(0.0); +vec4 R16f = vec4(0.0); +vec4 R17f = vec4(0.0); +vec4 R18f = vec4(0.0); +vec4 R122f = 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; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +R8f.xyz = (texture(textureUnitPS0, R0f.xy).xyz); +// 0 +R1f.x = R0f.x + intBitsToFloat(uf_remappedPS[0].x)/resXScale; +R1f.y = R0f.y + intBitsToFloat(uf_remappedPS[0].y)/resYScale; +R2f.z = (intBitsToFloat(uf_remappedPS[0].x)/resXScale * 2.0 + R0f.x); +R4f.w = intBitsToFloat(uf_remappedPS[1].y)/resYScale * intBitsToFloat(uf_remappedPS[1].y); +PV0f.w = R4f.w; +R2f.y = (intBitsToFloat(uf_remappedPS[0].y)/resYScale * 2.0 + R0f.y); +PS0f = R2f.y; +// 1 +R3f.x = (intBitsToFloat(uf_remappedPS[0].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +R3f.y = (intBitsToFloat(uf_remappedPS[0].y)/resYScale * intBitsToFloat(0x40400000) + R0f.y); +R9f.z = intBitsToFloat(uf_remappedPS[1].y)/resYScale * PV0f.w; +// 2 +R4f.x = R0f.x + intBitsToFloat(uf_remappedPS[2].x)/resXScale; +R4f.y = R0f.y + intBitsToFloat(uf_remappedPS[2].y)/resYScale; +R0f.z = (intBitsToFloat(uf_remappedPS[2].x)/resXScale * 2.0 + R0f.x); +R0f.w = (intBitsToFloat(uf_remappedPS[2].y)/resYScale * 2.0 + R0f.y); +R5f.x = (intBitsToFloat(uf_remappedPS[2].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +PS0f = R5f.x; +R1f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R2f.xyz = (texture(textureUnitPS0, R2f.zy).xyz); +R3f.xyz = (texture(textureUnitPS0, R3f.xy).xyz); +R4f.xyz = (texture(textureUnitPS0, R4f.xy).xyz); +// 0 +backupReg0f = R1f.y; +R123f.x = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R1f.z + R8f.z); +PV0f.x = R123f.x; +R1f.y = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R4f.x + R8f.x); +R123f.z = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * backupReg0f + R8f.y); +PV0f.z = R123f.z; +R123f.w = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R1f.x + R8f.x); +PV0f.w = R123f.w; +R1f.w = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R4f.y + R8f.y); +PS0f = R1f.w; +// 1 +R123f.x = (R4f.w * R2f.z + PV0f.x); +PV1f.x = R123f.x; +R6f.y = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R4f.z + R8f.z); +R123f.z = (R4f.w * R2f.y + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R4f.w * R2f.x + PV0f.w); +PV1f.w = R123f.w; +R5f.y = (intBitsToFloat(uf_remappedPS[2].y)/resYScale * intBitsToFloat(0x40400000) + R0f.y); +PS1f = R5f.y; +// 2 +R12f.x = (R9f.z * R3f.x + PV1f.w); +R12f.y = (R9f.z * R3f.y + PV1f.z); +R12f.z = (R9f.z * R3f.z + PV1f.x); +R3f.w = R0f.x + intBitsToFloat(uf_remappedPS[3].x)/resXScale; +R3f.y = R0f.y + intBitsToFloat(uf_remappedPS[3].y)/resYScale; +PS0f = R3f.y; +// 3 +R2f.x = (intBitsToFloat(uf_remappedPS[3].x)/resXScale * 2.0 + R0f.x); +R2f.y = (intBitsToFloat(uf_remappedPS[3].y)/resYScale * 2.0 + R0f.y); +R6f.z = (intBitsToFloat(uf_remappedPS[3].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +R6f.w = (intBitsToFloat(uf_remappedPS[3].y)/resYScale * intBitsToFloat(0x40400000) + R0f.y); +R7f.x = R0f.x + intBitsToFloat(uf_remappedPS[4].x)/resXScale; +PS1f = R7f.x; +R4f.xyz = (texture(textureUnitPS0, R0f.zw).xyz); +R5f.xyz = (texture(textureUnitPS0, R5f.xy).xyz); +R3f.xyz = (texture(textureUnitPS0, R3f.wy).xyz); +R2f.xyz = (texture(textureUnitPS0, R2f.xy).xyz); +// 0 +R123f.x = (R4f.w * R4f.z + R6f.y); +PV0f.x = R123f.x; +R123f.y = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R3f.x + R8f.x); +PV0f.y = R123f.y; +R123f.z = (R4f.w * R4f.x + R1f.y); +PV0f.z = R123f.z; +R123f.w = (R4f.w * R4f.y + R1f.w); +PV0f.w = R123f.w; +R122f.x = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R3f.z + R8f.z); +PS0f = R122f.x; +// 1 +R11f.x = (R9f.z * R5f.x + PV0f.z); +R11f.y = (R9f.z * R5f.y + PV0f.w); +R11f.z = (R9f.z * R5f.z + PV0f.x); +R1f.w = (R4f.w * R2f.x + PV0f.y); +R0f.w = (R4f.w * R2f.z + PS0f); +PS1f = R0f.w; +// 2 +R3f.x = (intBitsToFloat(uf_remappedPS[4].x)/resXScale * 2.0 + R0f.x); +R7f.y = R0f.y + intBitsToFloat(uf_remappedPS[4].y)/resYScale; +R123f.z = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R3f.y + R8f.y); +PV0f.z = R123f.z; +R3f.w = (intBitsToFloat(uf_remappedPS[4].y)/resYScale * 2.0 + R0f.y); +R5f.x = (intBitsToFloat(uf_remappedPS[4].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +PS0f = R5f.x; +// 3 +R2f.x = R0f.x + intBitsToFloat(uf_remappedPS[5].x)/resXScale; +R5f.y = (intBitsToFloat(uf_remappedPS[4].y)/resYScale * intBitsToFloat(0x40400000) + R0f.y); +R2f.z = (R4f.w * R2f.y + PV0f.z); +R2f.w = R0f.y + intBitsToFloat(uf_remappedPS[5].y)/resYScale; +R1f.x = (intBitsToFloat(uf_remappedPS[5].x)/resXScale * 2.0 + R0f.x); +PS1f = R1f.x; +R6f.xyz = (texture(textureUnitPS0, R6f.zw).xyz); +R7f.xyz = (texture(textureUnitPS0, R7f.xy).xyz); +R3f.xyz = (texture(textureUnitPS0, R3f.xw).xyz); +R5f.xyz = (texture(textureUnitPS0, R5f.xy).xyz); +// 0 +R10f.x = (R9f.z * R6f.x + R1f.w); +R10f.y = (R9f.z * R6f.y + R2f.z); +R10f.z = (R9f.z * R6f.z + R0f.w); +R123f.w = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R7f.x + R8f.x); +PV0f.w = R123f.w; +R122f.x = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R7f.y + R8f.y); +PS0f = R122f.x; +// 1 +R123f.x = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R7f.z + R8f.z); +PV1f.x = R123f.x; +R1f.y = (intBitsToFloat(uf_remappedPS[5].y)/resYScale * 2.0 + R0f.y); +R123f.z = (R4f.w * R3f.y + PS0f); +PV1f.z = R123f.z; +R123f.w = (R4f.w * R3f.x + PV0f.w); +PV1f.w = R123f.w; +R7f.x = (intBitsToFloat(uf_remappedPS[5].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +PS1f = R7f.x; +// 2 +R4f.x = (R9f.z * R5f.x + PV1f.w); +R4f.y = (R9f.z * R5f.y + PV1f.z); +R7f.z = (intBitsToFloat(uf_remappedPS[5].y)/resYScale * intBitsToFloat(0x40400000) + R0f.y); +R123f.w = (R4f.w * R3f.z + PV1f.x); +PV0f.w = R123f.w; +R3f.x = R0f.x + intBitsToFloat(uf_remappedPS[6].x)/resXScale; +PS0f = R3f.x; +// 3 +R5f.x = (intBitsToFloat(uf_remappedPS[6].x) * 2.0 + R0f.x); +R3f.y = R0f.y + intBitsToFloat(uf_remappedPS[6].y)/resYScale; +R4f.z = (R9f.z * R5f.z + PV0f.w); +R5f.w = (intBitsToFloat(uf_remappedPS[6].y)/resYScale * 2.0 + R0f.y); +R6f.x = (intBitsToFloat(uf_remappedPS[6].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +PS1f = R6f.x; +R2f.xyz = (texture(textureUnitPS0, R2f.xw).xyz); +R1f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R7f.xyz = (texture(textureUnitPS0, R7f.xz).xyz); +R3f.xyz = (texture(textureUnitPS0, R3f.xy).xyz); +// 0 +backupReg0f = R2f.y; +R123f.x = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R2f.z + R8f.z); +PV0f.x = R123f.x; +R2f.y = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R3f.x + R8f.x); +R123f.z = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * backupReg0f + R8f.y); +PV0f.z = R123f.z; +R123f.w = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R2f.x + R8f.x); +PV0f.w = R123f.w; +R2f.x = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R3f.y + R8f.y); +PS0f = R2f.x; +// 1 +backupReg0f = R0f.y; +R123f.x = (R4f.w * R1f.z + PV0f.x); +PV1f.x = R123f.x; +R0f.y = (intBitsToFloat(uf_remappedPS[1].y)/resYScale * R3f.z + R8f.z); +R123f.z = (R4f.w * R1f.y + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R4f.w * R1f.x + PV0f.w); +PV1f.w = R123f.w; +R6f.y = (intBitsToFloat(uf_remappedPS[6].y)/resYScale * intBitsToFloat(0x40400000) + backupReg0f); +PS1f = R6f.y; +// 2 +backupReg0f = R7f.x; +backupReg1f = R7f.y; +backupReg2f = R7f.z; +R7f.x = (R9f.z * backupReg0f + PV1f.w); +R7f.y = (R9f.z * backupReg1f + PV1f.z); +R7f.z = (R9f.z * backupReg2f + PV1f.x); +R5f.xyz = (texture(textureUnitPS0, R5f.xw).xyz); +R6f.xyz = (texture(textureUnitPS0, R6f.xy).xyz); +// 0 +R123f.x = (R4f.w * R5f.z + R0f.y); +PV0f.x = R123f.x; +R123f.z = (R4f.w * R5f.y + R2f.x); +PV0f.z = R123f.z; +R123f.w = (R4f.w * R5f.x + R2f.y); +PV0f.w = R123f.w; +// 1 +backupReg0f = R6f.x; +backupReg1f = R6f.y; +backupReg2f = R6f.z; +R6f.x = (R9f.z * backupReg0f + PV0f.w); +PV1f.x = R6f.x; +R6f.y = (R9f.z * backupReg1f + PV0f.z); +PV1f.y = R6f.y; +R6f.z = (R9f.z * backupReg2f + PV0f.x); +PV1f.z = R6f.z; +// 2 +R18f.xyz = vec3(PV1f.x,PV1f.y,PV1f.z); +R18f.w = R6f.w; +// 3 +R17f.xyz = vec3(R7f.x,R7f.y,R7f.z); +R17f.w = R7f.w; +// 4 +R16f.xyz = vec3(R4f.x,R4f.y,R4f.z); +R16f.w = R4f.w; +// 5 +R15f.xyz = vec3(R10f.x,R10f.y,R10f.z); +R15f.w = R10f.w; +// 6 +R14f.xyz = vec3(R11f.x,R11f.y,R11f.z); +R14f.w = R11f.w; +// 7 +R13f.xyz = vec3(R12f.x,R12f.y,R12f.z); +R13f.w = R12f.w; +// export +passPixelColor0 = vec4(R13f.x, R13f.y, R13f.z, R13f.w); +passPixelColor1 = vec4(R14f.x, R14f.y, R14f.z, R14f.w); +passPixelColor2 = vec4(R15f.x, R15f.y, R15f.z, R15f.w); +passPixelColor3 = vec4(R16f.x, R16f.y, R16f.z, R16f.w); +passPixelColor4 = vec4(R17f.x, R17f.y, R17f.z, R17f.w); +passPixelColor5 = vec4(R18f.x, R18f.y, R18f.z, R18f.w); +} diff --git a/src/SuperMario3DWorld/Graphics/6d9067fd20086bc0_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/6d9067fd20086bc0_0000000000000000_vs.txt new file mode 100644 index 00000000..1097a6e8 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/6d9067fd20086bc0_0000000000000000_vs.txt @@ -0,0 +1,113 @@ +#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 6d9067fd20086bc0 +// Used for: Vertical blur +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[1]; +// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7 +}; +#else +uniform ivec4 uf_remappedVS[1]; +// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7 +#endif +// uf_windowSpaceToClipSpaceTransform was moved to the ufBlock +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) noperspective out vec4 passParameterSem0; +layout(location = 1) noperspective out vec4 passParameterSem1; +layout(location = 2) noperspective 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); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +backupReg0f = R1f.x; +backupReg1f = R1f.y; +R1f.x = backupReg0f; +R1f.x *= 2.0; +R1f.y = backupReg1f; +R1f.y *= 2.0; +R1f.z = 0.0; +R1f.w = 1.0; +PS0f = intBitsToFloat(uf_remappedVS[0].x)/resXScale + R2f.x; +// 1 +R0f.x = PS0f; +R0f.y = R2f.y; +PV1f.z = -(intBitsToFloat(uf_remappedVS[0].x))/resXScale + R2f.x; +R3f.w = R2f.y; +R4f.x = R2f.x; +PS1f = R4f.x; +// 2 +R3f.x = PV1f.z; +R4f.y = R2f.y; +// export +SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w)); +// export +passParameterSem0 = vec4(R0f.x, R0f.y, R0f.z, R0f.z); +// export +passParameterSem1 = vec4(R3f.x, R3f.w, R3f.z, R3f.z); +// export +passParameterSem2 = vec4(R4f.x, R4f.y, R4f.z, R4f.z); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/842a19b509f8b91a_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/842a19b509f8b91a_0000000000000000_vs.txt new file mode 100644 index 00000000..32268ee3 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/842a19b509f8b91a_0000000000000000_vs.txt @@ -0,0 +1,128 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#ifdef VULKAN +#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location) +#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140) +#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation) +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw) +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#else +#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location) +#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140) +#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation) +#define SET_POSITION(_v) gl_Position = _v +#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw) +#endif +// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL. + +// shader 842a19b509f8b91a +// Used for: General Blur vertical +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[1]; +// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7 +}; +#else +uniform ivec4 uf_remappedVS[1]; +// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7 +#endif +// uf_windowSpaceToClipSpaceTransform was moved to the ufBlock +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 1) out vec4 passParameterSem1; +layout(location = 2) out vec4 passParameterSem2; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R127f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +backupReg0f = R1f.x; +backupReg1f = R1f.y; +R1f.x = backupReg0f; +R1f.x *= 2.0; +R1f.y = backupReg1f; +R1f.y *= 2.0; +R1f.z = 0.0; +R1f.w = 1.0; +PS0f = intBitsToFloat(uf_remappedVS[0].y)/resYScale * intBitsToFloat(0x3fb13a93); +// 1 +PV1f.x = intBitsToFloat(uf_remappedVS[0].y)/resYScale * intBitsToFloat(0x404ec4f0); +R127f.y = intBitsToFloat(uf_remappedVS[0].y)/resYScale * intBitsToFloat(0x40a275f7); +R2f.z = R2f.y + PS0f; +PV1f.z = R2f.z; +R2f.w = R2f.y; +PV1f.w = R2f.w; +R0f.y = R2f.y + -(PS0f); +PS1f = R0f.y; +// 2 +R0f.x = R2f.x; +R3f.y = R2f.y + -(PV1f.x); +R0f.z = PV1f.z; +R0f.w = PV1f.w; +R2f.z = R2f.y + PV1f.x; +PS0f = R2f.z; +// 3 +R3f.x = R2f.x; +R4f.y = R2f.y + -(R127f.y); +R3f.z = PS0f; +R3f.w = R2f.y; +R2f.z = R2f.y + R127f.y; +PS1f = R2f.z; +// 4 +R4f.xzw = vec3(R2f.x,PS1f,R2f.y); +// export +SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w)); +// export +passParameterSem0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w); +// export +passParameterSem1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w); +// export +passParameterSem2 = vec4(R4f.x, R4f.y, R4f.z, R4f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/8d68a0e3561ff525_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/8d68a0e3561ff525_0000000000000000_vs.txt new file mode 100644 index 00000000..7e6c802a --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/8d68a0e3561ff525_0000000000000000_vs.txt @@ -0,0 +1,126 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#ifdef VULKAN +#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location) +#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140) +#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation) +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw) +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#else +#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location) +#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140) +#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation) +#define SET_POSITION(_v) gl_Position = _v +#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw) +#endif +// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL. + +// shader 8d68a0e3561ff525 +// Used for: Horizontal Gameplay Blur +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[1]; +// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7 +}; +#else +uniform ivec4 uf_remappedVS[1]; +// uniform vec2 uf_windowSpaceToClipSpaceTransform; // Cemu optimized this uf_variable away in Cemu 1.15.7 +#endif +// uf_windowSpaceToClipSpaceTransform was moved to the ufBlock +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 1) out vec4 passParameterSem1; +layout(location = 2) out vec4 passParameterSem2; +layout(location = 0) out vec4 passParameterSem0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +backupReg0f = R1f.x; +backupReg1f = R1f.y; +R1f.x = backupReg0f; +R1f.x *= 2.0; +R1f.y = backupReg1f; +R1f.y *= 2.0; +R1f.z = 0.0; +R1f.w = 1.0; +R127f.y = intBitsToFloat(uf_remappedVS[0].x)/resXScale * intBitsToFloat(0x3fb13a93); +PS0f = R127f.y; +// 1 +PV1f.x = intBitsToFloat(uf_remappedVS[0].x)/resXScale * intBitsToFloat(0x404ec4f0); +R126f.y = intBitsToFloat(uf_remappedVS[0].x)/resXScale * intBitsToFloat(0x40a275f7); +R3f.z = R2f.x + PS0f; +R3f.w = R2f.x; +R3f.x = R2f.y; +PS1f = R3f.x; +// 2 +R0f.x = PS1f; +R3f.y = R2f.x + -(R127f.y); +R0f.z = R2f.x + PV1f.x; +R0f.w = R2f.x; +R0f.y = R2f.x + -(PV1f.x); +PS0f = R0f.y; +// 3 +backupReg0f = R2f.x; +backupReg0f = R2f.x; +backupReg0f = R2f.x; +R2f.x = R3f.x; +R2f.y = backupReg0f + -(R126f.y); +R2f.z = backupReg0f + R126f.y; +R2f.w = backupReg0f; +// export +SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w)); +// export +passParameterSem1 = vec4(R0f.x, R0f.y, R0f.z, R0f.w); +// export +passParameterSem2 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +// export +passParameterSem0 = vec4(R3f.x, R3f.y, R3f.z, R3f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/b727c08e3b534992_0000000007fffffd_ps.txt b/src/SuperMario3DWorld/Graphics/b727c08e3b534992_0000000007fffffd_ps.txt new file mode 100644 index 00000000..79c59955 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/b727c08e3b534992_0000000007fffffd_ps.txt @@ -0,0 +1,360 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#ifdef VULKAN +#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location) +#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140) +#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation) +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw) +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#else +#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location) +#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140) +#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation) +#define SET_POSITION(_v) gl_Position = _v +#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw) +#endif +// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL. + +// shader b727c08e3b534992 +// Used for: Second glitter bloom pass +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 1, binding = 1) uniform ufBlock +{ +uniform ivec4 uf_remappedPS[10]; +uniform vec4 uf_fragCoordScale; +}; +#else +uniform ivec4 uf_remappedPS[10]; +uniform vec2 uf_fragCoordScale; +#endif +TEXTURE_LAYOUT(1, 1, 0) uniform sampler2DArray textureUnitPS1; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +layout(location = 1) out vec4 passPixelColor1; +layout(location = 2) out vec4 passPixelColor2; +layout(location = 3) out vec4 passPixelColor3; +layout(location = 4) out vec4 passPixelColor4; +layout(location = 5) out vec4 passPixelColor5; +// uf_fragCoordScale was moved to the ufBlock +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R6f = vec4(0.0); +vec4 R7f = vec4(0.0); +vec4 R8f = vec4(0.0); +vec4 R9f = vec4(0.0); +vec4 R10f = vec4(0.0); +vec4 R11f = vec4(0.0); +vec4 R12f = vec4(0.0); +vec4 R13f = vec4(0.0); +vec4 R14f = vec4(0.0); +vec4 R15f = vec4(0.0); +vec4 R16f = vec4(0.0); +vec4 R17f = vec4(0.0); +vec4 R18f = vec4(0.0); +vec4 R19f = vec4(0.0); +vec4 R20f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +// 0 +R1f.x = R0f.x + intBitsToFloat(uf_remappedPS[0].x)/resXScale; +R5f.y = intBitsToFloat(uf_remappedPS[1].y)/resYScale * intBitsToFloat(uf_remappedPS[1].y); +PV0f.y = R5f.y; +R0f.z = roundEven(0.0); +PV0f.z = R0f.z; +R1f.w = R0f.y + intBitsToFloat(uf_remappedPS[0].y)/resYScale; +R2f.x = (intBitsToFloat(uf_remappedPS[0].x)/resXScale * 2.0 + R0f.x); +PS0f = R2f.x; +// 1 +R11f.x = intBitsToFloat(uf_remappedPS[2].x)/resXScale * intBitsToFloat(uf_remappedPS[1].y); +R14f.y = intBitsToFloat(uf_remappedPS[2].y)/resYScale * intBitsToFloat(uf_remappedPS[1].y); +R1f.z = PV0f.z; +R0f.w = intBitsToFloat(uf_remappedPS[1].y)/resYScale * PV0f.y; +R2f.z = PV0f.z; +PS1f = R2f.z; +// 2 +R14f.z = intBitsToFloat(uf_remappedPS[2].z)/resXScale * intBitsToFloat(uf_remappedPS[1].y); +R3f.w = R0f.z; +// 3 +R3f.x = (intBitsToFloat(uf_remappedPS[0].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +R2f.y = (intBitsToFloat(uf_remappedPS[0].y)/resYScale * 2.0 + R0f.y); +R16f.z = intBitsToFloat(uf_remappedPS[3].y)/resYScale * R5f.y; +R6f.w = intBitsToFloat(uf_remappedPS[3].x)/resXScale * R5f.y; +R3f.y = (intBitsToFloat(uf_remappedPS[0].y)/resYScale * intBitsToFloat(0x40400000) + R0f.y); +PS1f = R3f.y; +R4f.xyz = (texture(textureUnitPS1, vec3(R0f.x,R0f.y,R0f.z)).xyz); +R1f.xyz = (texture(textureUnitPS1, vec3(R1f.x,R1f.w,R1f.z)).xyz); +R2f.xyz = (texture(textureUnitPS1, vec3(R2f.x,R2f.y,R2f.z)).xyz); +R3f.xyz = (texture(textureUnitPS1, vec3(R3f.x,R3f.y,R3f.w)).xyz); +// 0 +R123f.x = (R1f.y * R14f.y + R4f.y); +PV0f.x = R123f.x; +R123f.y = (R1f.x * R11f.x + R4f.x); +PV0f.y = R123f.y; +R0f.z = roundEven(1.0); +PV0f.z = R0f.z; +R127f.w = (R1f.z * R14f.z + R4f.z); +R17f.z = intBitsToFloat(uf_remappedPS[4].x)/resXScale * R0f.w; +PS0f = R17f.z; +// 1 +R123f.x = (R2f.x * R6f.w + PV0f.y); +PV1f.x = R123f.x; +R16f.y = intBitsToFloat(uf_remappedPS[3].z)/resXScale * R5f.y; +PV1f.y = R16f.y; +R18f.z = intBitsToFloat(uf_remappedPS[4].y)/resYScale * R0f.w; +PV1f.z = R18f.z; +R123f.w = (R2f.y * R16f.z + PV0f.x); +PV1f.w = R123f.w; +R5f.z = PV0f.z; +PS1f = R5f.z; +// 2 +R20f.x = (R3f.x * R17f.z + PV1f.x); +R20f.y = (R3f.y * PV1f.z + PV1f.w); +R19f.z = intBitsToFloat(uf_remappedPS[4].z)/resXScale * R0f.w; +PV0f.z = R19f.z; +R123f.w = (R2f.z * PV1f.y + R127f.w); +PV0f.w = R123f.w; +R5f.x = R0f.x + intBitsToFloat(uf_remappedPS[5].x)/resXScale; +PS0f = R5f.x; +// 3 +R2f.x = (intBitsToFloat(uf_remappedPS[5].x)/resXScale * 2.0 + R0f.x); +R5f.y = R0f.y + intBitsToFloat(uf_remappedPS[5].y)/resYScale; +R20f.z = (R3f.z * PV0f.z + PV0f.w); +R2f.w = (intBitsToFloat(uf_remappedPS[5].y)/resYScale * 2.0 + R0f.y); +R2f.z = R0f.z; +PS1f = R2f.z; +// 4 +R6f.x = R0f.x; +R6f.y = R0f.y; +R6f.z = roundEven(2.0); +R4f.w = R0f.y; +R4f.z = roundEven(intBitsToFloat(0x40400000)); +PS0f = R4f.z; +// 5 +R4f.x = R0f.x; +R11f.y = R0f.y; +R11f.z = roundEven(4.0); +R11f.w = R0f.x; +R13f.z = roundEven(intBitsToFloat(0x40a00000)); +PS1f = R13f.z; +// 6 +R13f.x = R0f.x; +R13f.y = R0f.y; +R3f.xyz = (texture(textureUnitPS1, vec3(R0f.x,R0f.y,R0f.z)).xyz); +R8f.xyz = (texture(textureUnitPS1, vec3(R6f.x,R6f.y,R6f.z)).xyz); +R10f.xyz = (texture(textureUnitPS1, vec3(R4f.x,R4f.w,R4f.z)).xyz); +R12f.xyz = (texture(textureUnitPS1, vec3(R11f.w,R11f.y,R11f.z)).xyz); +R15f.xyz = (texture(textureUnitPS1, vec3(R13f.x,R13f.y,R13f.z)).xyz); +R5f.xyz = (texture(textureUnitPS1, vec3(R5f.x,R5f.y,R5f.z)).xyz); +// 0 +backupReg0f = R5f.x; +R5f.x = (backupReg0f * R11f.x + R3f.x); +R4f.y = (R5f.z * R14f.z + R3f.z); +R0f.w = (R5f.y * R14f.y + R3f.y); +// 1 +R3f.x = (intBitsToFloat(uf_remappedPS[5].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +R3f.y = (intBitsToFloat(uf_remappedPS[5].y)/resYScale * intBitsToFloat(0x40400000) + R0f.y); +R3f.z = R0f.z; +R5f.w = R0f.x + intBitsToFloat(uf_remappedPS[6].x)/resXScale; +R5f.y = R0f.y + intBitsToFloat(uf_remappedPS[6].y)/resYScale; +PS1f = R5f.y; +// 2 +R1f.x = (intBitsToFloat(uf_remappedPS[6].x)/resXScale * 2.0 + R0f.x); +R1f.y = (intBitsToFloat(uf_remappedPS[6].y)/resYScale * 2.0 + R0f.y); +R5f.z = R6f.z; +R1f.w = R6f.z; +R9f.x = (intBitsToFloat(uf_remappedPS[6].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +PS0f = R9f.x; +R2f.xyz = (texture(textureUnitPS1, vec3(R2f.x,R2f.w,R2f.z)).xyz); +R3f.xyz = (texture(textureUnitPS1, vec3(R3f.x,R3f.y,R3f.z)).xyz); +R7f.xyz = (texture(textureUnitPS1, vec3(R5f.w,R5f.y,R5f.z)).xyz); +R1f.xyz = (texture(textureUnitPS1, vec3(R1f.x,R1f.y,R1f.w)).xyz); +// 0 +R123f.x = (R2f.y * R16f.z + R0f.w); +PV0f.x = R123f.x; +R127f.y = (R2f.z * R16f.y + R4f.y); +R9f.z = R6f.z; +R123f.w = (R2f.x * R6f.w + R5f.x); +PV0f.w = R123f.w; +R2f.x = R0f.x + intBitsToFloat(uf_remappedPS[7].x)/resXScale; +PS0f = R2f.x; +// 1 +R6f.x = (R3f.x * R17f.z + PV0f.w); +R6f.y = (R3f.y * R18f.z + PV0f.x); +R2f.z = R4f.z; +R9f.w = (intBitsToFloat(uf_remappedPS[6].y) * intBitsToFloat(0x40400000) + R0f.y); +R2f.y = R0f.y + intBitsToFloat(uf_remappedPS[7].y)/resYScale; +PS1f = R2f.y; +// 2 +R123f.x = (R7f.x * R11f.x + R8f.x); +PV0f.x = R123f.x; +R3f.y = (intBitsToFloat(uf_remappedPS[7].y)/resYScale * 2.0 + R0f.y); +R6f.z = (R3f.z * R19f.z + R127f.y); +R3f.w = R4f.z; +R5f.y = (intBitsToFloat(uf_remappedPS[7].y)/resYScale * intBitsToFloat(0x40400000) + R0f.y); +PS0f = R5f.y; +// 3 +R7f.x = (R1f.x * R6f.w + PV0f.x); +R123f.y = (R7f.y * R14f.y + R8f.y); +PV1f.y = R123f.y; +R123f.w = (R7f.z * R14f.z + R8f.z); +PV1f.w = R123f.w; +R3f.x = (intBitsToFloat(uf_remappedPS[7].x)/resXScale * 2.0 + R0f.x); +PS1f = R3f.x; +// 4 +backupReg0f = R1f.y; +R1f.x = (R1f.z * R16f.y + PV1f.w); +R1f.y = R0f.y + intBitsToFloat(uf_remappedPS[8].y)/resYScale; +R5f.z = R4f.z; +R4f.w = (backupReg0f * R16f.z + PV1f.y); +R5f.x = (intBitsToFloat(uf_remappedPS[7].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +PS0f = R5f.x; +R9f.xyz = (texture(textureUnitPS1, vec3(R9f.x,R9f.w,R9f.z)).xyz); +R2f.xyz = (texture(textureUnitPS1, vec3(R2f.x,R2f.y,R2f.z)).xyz); +R3f.xyz = (texture(textureUnitPS1, vec3(R3f.x,R3f.y,R3f.w)).xyz); +R5f.xyz = (texture(textureUnitPS1, vec3(R5f.x,R5f.y,R5f.z)).xyz); +// 0 +backupReg0f = R7f.x; +R7f.x = (R9f.x * R17f.z + backupReg0f); +R7f.y = (R9f.y * R18f.z + R4f.w); +R1f.z = R11f.z; +R1f.w = R0f.x + intBitsToFloat(uf_remappedPS[8].x)/resXScale; +R4f.y = (intBitsToFloat(uf_remappedPS[8].y)/resYScale * 2.0 + R0f.y); +PS0f = R4f.y; +// 1 +R127f.x = (R2f.y * R14f.y + R10f.y); +R7f.z = (R9f.z * R19f.z + R1f.x); +R4f.w = (intBitsToFloat(uf_remappedPS[8].x)/resXScale * 2.0 + R0f.x); +R4f.z = R11f.z; +PS1f = R4f.z; +// 2 +R123f.x = (R2f.z * R14f.z + R10f.z); +PV0f.x = R123f.x; +R2f.y = (intBitsToFloat(uf_remappedPS[8].y)/resYScale * intBitsToFloat(0x40400000) + R0f.y); +R123f.w = (R2f.x * R11f.x + R10f.x); +PV0f.w = R123f.w; +R10f.y = R0f.y + intBitsToFloat(uf_remappedPS[9].y)/resYScale; +PS0f = R10f.y; +// 3 +R123f.x = (R3f.y * R16f.z + R127f.x); +PV1f.x = R123f.x; +R127f.y = (R3f.z * R16f.y + PV0f.x); +R2f.z = R11f.z; +R123f.w = (R3f.x * R6f.w + PV0f.w); +PV1f.w = R123f.w; +R2f.x = (intBitsToFloat(uf_remappedPS[8].x)/resXScale * intBitsToFloat(0x40400000) + R0f.x); +PS1f = R2f.x; +// 4 +R9f.x = (R5f.x * R17f.z + PV1f.w); +R9f.y = (R5f.y * R18f.z + PV1f.x); +R10f.z = R13f.z; +R10f.w = R0f.x + intBitsToFloat(uf_remappedPS[9].x)/resXScale; +R3f.x = (intBitsToFloat(uf_remappedPS[9].x)/resXScale * 2.0 + R0f.x); +PS0f = R3f.x; +// 5 +backupReg0f = R0f.x; +backupReg1f = R0f.y; +R0f.x = (intBitsToFloat(uf_remappedPS[9].x)/resXScale * intBitsToFloat(0x40400000) + backupReg0f); +R3f.y = (intBitsToFloat(uf_remappedPS[9].y)/resYScale * 2.0 + R0f.y); +R9f.z = (R5f.z * R19f.z + R127f.y); +R3f.w = R13f.z; +R0f.y = (intBitsToFloat(uf_remappedPS[9].y)/resYScale * intBitsToFloat(0x40400000) + backupReg1f); +PS1f = R0f.y; +R1f.xyz = (texture(textureUnitPS1, vec3(R1f.w,R1f.y,R1f.z)).xyz); +R4f.xyz = (texture(textureUnitPS1, vec3(R4f.w,R4f.y,R4f.z)).xyz); +R2f.xyz = (texture(textureUnitPS1, vec3(R2f.x,R2f.y,R2f.z)).xyz); +R10f.xyz = (texture(textureUnitPS1, vec3(R10f.w,R10f.y,R10f.z)).xyz); +// 0 +R123f.x = (R1f.y * R14f.y + R12f.y); +PV0f.x = R123f.x; +R123f.y = (R1f.x * R11f.x + R12f.x); +PV0f.y = R123f.y; +R123f.w = (R1f.z * R14f.z + R12f.z); +PV0f.w = R123f.w; +// 1 +R123f.x = (R4f.y * R16f.z + PV0f.x); +PV1f.x = R123f.x; +R127f.y = (R4f.z * R16f.y + PV0f.w); +R0f.z = R13f.z; +R123f.w = (R4f.x * R6f.w + PV0f.y); +PV1f.w = R123f.w; +// 2 +R4f.x = (R2f.x * R17f.z + PV1f.w); +R4f.y = (R2f.y * R18f.z + PV1f.x); +// 3 +R2f.x = (R10f.x * R11f.x + R15f.x); +R4f.z = (R2f.z * R19f.z + R127f.y); +// 4 +backupReg0f = R10f.y; +R10f.y = (backupReg0f * R14f.y + R15f.y); +R10f.w = (R10f.z * R14f.z + R15f.z); +R3f.xyz = (texture(textureUnitPS1, vec3(R3f.x,R3f.y,R3f.w)).xyz); +R0f.xyz = (texture(textureUnitPS1, vec3(R0f.x,R0f.y,R0f.z)).xyz); +// 0 +R123f.x = (R3f.x * R6f.w + R2f.x); +PV0f.x = R123f.x; +R127f.y = (R3f.z * R16f.y + R10f.w); +R123f.w = (R3f.y * R16f.z + R10f.y); +PV0f.w = R123f.w; +// 1 +R17f.x = (R0f.x * R17f.z + PV0f.x); +R17f.y = (R0f.y * R18f.z + PV0f.w); +// 2 +R17f.z = (R0f.z * R19f.z + R127f.y); +PV0f.z = R17f.z; +// 3 +R15f.xyz = vec3(R17f.x,R17f.y,PV0f.z); +R15f.w = R17f.w; +// 4 +R14f.xyz = vec3(R4f.x,R4f.y,R4f.z); +R14f.w = R4f.w; +// 5 +R13f.xyz = vec3(R9f.x,R9f.y,R9f.z); +R13f.w = R9f.w; +// 6 +R12f.xyz = vec3(R7f.x,R7f.y,R7f.z); +R12f.w = R7f.w; +// 7 +R11f.xyz = vec3(R6f.x,R6f.y,R6f.z); +R11f.w = R6f.w; +// 8 +R10f.xyz = vec3(R20f.x,R20f.y,R20f.z); +R10f.w = R20f.w; +// export +passPixelColor0 = vec4(R10f.x, R10f.y, R10f.z, R10f.w); +passPixelColor1 = vec4(R11f.x, R11f.y, R11f.z, R11f.w); +passPixelColor2 = vec4(R12f.x, R12f.y, R12f.z, R12f.w); +passPixelColor3 = vec4(R13f.x, R13f.y, R13f.z, R13f.w); +passPixelColor4 = vec4(R14f.x, R14f.y, R14f.z, R14f.w); +passPixelColor5 = vec4(R15f.x, R15f.y, R15f.z, R15f.w); +} diff --git a/src/SuperMario3DWorld/Graphics/be99d80628d31127_00000000000003c9_ps.txt b/src/SuperMario3DWorld/Graphics/be99d80628d31127_00000000000003c9_ps.txt new file mode 100644 index 00000000..3cbc1486 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/be99d80628d31127_00000000000003c9_ps.txt @@ -0,0 +1,218 @@ +#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 be99d80628d31127 //AA PS +// Used for: Another vertical blur +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 1, binding = 2) uniform ufBlock +{ +uniform ivec4 uf_remappedPS[4]; +uniform vec4 uf_fragCoordScale; +}; +#else +uniform ivec4 uf_remappedPS[4]; +uniform vec2 uf_fragCoordScale; +#endif +TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0; +TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1; +layout(location = 0) in vec4 passParameterSem2; +layout(location = 0) out vec4 passPixelColor0; +// uf_fragCoordScale was moved to the ufBlock +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){return mix(0.0, a*b, (a != 0.0) && (b != 0.0));} +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +bool activeMaskStack[2]; +bool activeMaskStackC[3]; +activeMaskStack[0] = false; +activeMaskStackC[0] = false; +activeMaskStackC[1] = false; +activeMaskStack[0] = true; +activeMaskStackC[0] = true; +activeMaskStackC[1] = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem2; +if( activeMaskStackC[1] == true ) { +R4f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw); +R2f.xyzw = (textureGather(textureUnitPS1, R0f.xy).wzxy); +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +PV0f.x = min(R2f.z, R2f.x); +PV0f.y = max(R2f.z, R2f.x); +PV0f.z = mul_nonIEEE(R4f.x, intBitsToFloat(uf_remappedPS[0].x)); +PV0f.w = min(R2f.w, R2f.y); +PS0f = max(R2f.w, R2f.y); +// 1 +PV1f.x = min(PV0f.x, PV0f.w); +R123f.y = (mul_nonIEEE(R4f.y,intBitsToFloat(uf_remappedPS[0].y)) + PV0f.z); +PV1f.y = R123f.y; +R127f.z = R2f.z + -(R2f.y); +PV1f.z = R127f.z; +PV1f.w = max(PV0f.y, PS0f); +R126f.z = R2f.w + -(R2f.x); +PS1f = R126f.z; +// 2 +PV0f.x = mul_nonIEEE(PV1f.w, intBitsToFloat(uf_remappedPS[1].x)); +PV0f.y = max(PV1f.y, PV1f.w); +PV0f.z = min(PV1f.y, PV1f.x); +R3f.x = PV1f.z + PS1f; +PS0f = R3f.x; +// 3 +R1f.x = max(PV0f.x, intBitsToFloat(uf_remappedPS[1].y)); +R3f.y = -(PV0f.z) + PV0f.y; +R1f.y = R127f.z + -(R126f.z); +PS1f = R1f.y; +// 4 +predResult = (R3f.y > R1f.x); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +backupReg0f = R2f.y; +R1f.x = max(R3f.x, -(R3f.x)); +PV0f.x = R1f.x; +R2f.y = backupReg0f + R2f.x; +PV0f.y = R2f.y; +R0f.z = intBitsToFloat(uf_remappedPS[2].z) * 0.25; +R0f.w = max(R1f.y, -(R1f.y)); +PV0f.w = R0f.w; +R2f.x = -(intBitsToFloat(uf_remappedPS[3].x)); +PS0f = R2f.x; +// 1 +R3f.y = R2f.z + PV0f.y; +PV1f.y = R3f.y; +R2f.y = min(PV0f.x, PV0f.w); +PS1f = R2f.y; +// 2 +R3f.y = R2f.w + PV1f.y; +PV0f.y = R3f.y; +R1f.z = intBitsToFloat(uf_remappedPS[3].x); +R0f.w = intBitsToFloat(uf_remappedPS[3].y); +R5f.y = -(intBitsToFloat(uf_remappedPS[3].y)); +PS0f = R5f.y; +// 3 +backupReg0f = R0f.z; +R0f.z = (mul_nonIEEE(backupReg0f,PV0f.y) + intBitsToFloat(uf_remappedPS[2].w)); +PV1f.z = R0f.z; +// 4 +backupReg0f = R2f.y; +R2f.y = max(PV1f.z, backupReg0f); +PV0f.y = R2f.y; +// 5 +R2f.y = 1.0 / PV0f.y; +PS1f = R2f.y; +// 6 +backupReg0f = R1f.y; +R1f.x = mul_nonIEEE(R3f.x, PS1f); +PV0f.x = R1f.x; +R1f.y = mul_nonIEEE(backupReg0f, PS1f); +PV0f.y = R1f.y; +// 7 +R1f.x = max(PV0f.x, -(intBitsToFloat(uf_remappedPS[2].y))); +PV1f.x = R1f.x; +R1f.y = max(PV0f.y, -(intBitsToFloat(uf_remappedPS[2].y))); +PV1f.y = R1f.y; +// 8 +R1f.x = min(PV1f.x, intBitsToFloat(uf_remappedPS[2].y)); +PV0f.x = R1f.x; +R1f.y = min(PV1f.y, intBitsToFloat(uf_remappedPS[2].y)); +PV0f.y = R1f.y; +// 9 +backupReg0f = R0f.x; +backupReg1f = R0f.y; +backupReg0f = R0f.x; +backupReg2f = R0f.w; +backupReg1f = R0f.y; +R0f.x = (mul_nonIEEE(PV0f.x,R2f.x) /resXScale + backupReg0f); +R0f.y = (mul_nonIEEE(PV0f.y,R5f.y) /resYScale+ backupReg1f); +R0f.z = (mul_nonIEEE(PV0f.x,R1f.z) /resXScale + backupReg0f); +R0f.w = (mul_nonIEEE(PV0f.y,backupReg2f)/ resXScale + backupReg1f); +} +if( activeMaskStackC[2] == true ) { +R1f.xyzw = (texture(textureUnitPS0, R0f.zw).xyzw); +R0f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw); +} +if( activeMaskStackC[2] == true ) { +// 0 +backupReg0f = R0f.y; +backupReg1f = R0f.x; +PV0f.x = R0f.w + R1f.w; +PV0f.x /= 2.0; +PV0f.y = R0f.z + R1f.z; +PV0f.y /= 2.0; +PV0f.z = backupReg0f + R1f.y; +PV0f.z /= 2.0; +PV0f.w = backupReg1f + R1f.x; +PV0f.w /= 2.0; +// 1 +PV1f.x = -(R4f.w) + PV0f.x; +PV1f.y = -(R4f.z) + PV0f.y; +PV1f.z = -(R4f.y) + PV0f.z; +PV1f.w = -(R4f.x) + PV0f.w; +// 2 +backupReg0f = R4f.x; +backupReg1f = R4f.y; +backupReg2f = R4f.z; +backupReg3f = R4f.w; +R4f.x = (PV1f.w * intBitsToFloat(0x3f4ccccd) + backupReg0f); +R4f.y = (PV1f.z * intBitsToFloat(0x3f4ccccd) + backupReg1f); +R4f.z = (PV1f.y * intBitsToFloat(0x3f4ccccd) + backupReg2f); +R4f.w = (PV1f.x * intBitsToFloat(0x3f4ccccd) + backupReg3f); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +// export +passPixelColor0 = vec4(R4f.x, R4f.y, R4f.z, R4f.w); +} diff --git a/src/SuperMario3DWorld/Graphics/c27612e2f7126ebf_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/c27612e2f7126ebf_0000000000000000_vs.txt new file mode 100644 index 00000000..793a7739 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/c27612e2f7126ebf_0000000000000000_vs.txt @@ -0,0 +1,140 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_separate_shader_objects : enable +#ifdef VULKAN +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#else +#define SET_POSITION(_v) gl_Position = _v +#endif +#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 c27612e2f7126ebf +//switch palace low res reflection 256x240 / 240x240 hz +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[5]; +}; +#else +uniform ivec4 uf_remappedVS[5]; +#endif +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +out gl_PerVertex +{ + vec4 gl_Position; +}; +layout(location = 0) out vec4 passParameterSem0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +R127f.x = (R1f.x > 0.0)?1.0:0.0; +R127f.x /= 2.0; +R127f.y = -(R1f.y); +PV0f.y = R127f.y; +R127f.z = (0.0 > R1f.x)?1.0:0.0; +R127f.z /= 2.0; +R127f.w = 1.0; +PV0f.w = R127f.w; +R126f.x = intBitsToFloat(uf_remappedVS[0].z) * intBitsToFloat(0x3f99999a)/resYScale; +PS0f = R126f.x; +// 1 +R0f.x = dot(vec4(R1f.x,R1f.y,R1f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w))); +PV1f.x = R0f.x; +PV1f.y = R0f.x; +PV1f.z = R0f.x; +PV1f.w = R0f.x; +R126f.w = (PV0f.y > 0.0)?1.0:0.0; +R126f.w /= 2.0; +PS1f = R126f.w; +// 2 +backupReg0f = R127f.y; +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w))); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R0f.y = tempf.x; +R127f.y = (0.0 > backupReg0f)?1.0:0.0; +R127f.y /= 2.0; +PS0f = R127f.y; +// 3 +backupReg0f = R127f.x; +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w))); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +R0f.z = tempf.x; +R127f.x = backupReg0f + -(R127f.z); +PS1f = R127f.x; +// 4 +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w))); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R0f.w = tempf.x; +PS0f = R126f.w + -(R127f.y); +// 5 +PV1f.y = PS0f + 0.5; +PV1f.z = R127f.x + 0.5; +// 6 +R1f.x = PV1f.y; +R1f.y = PV1f.z + -(R126f.x); +R1f.z = PV1f.z + R126f.x; +R1f.w = PV1f.z; +// export +SET_POSITION(vec4(R0f.x, R0f.y, R0f.z, R0f.w)); +// export +passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/c4eaec09897d525e_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/c4eaec09897d525e_0000000000000000_vs.txt new file mode 100644 index 00000000..15ed3562 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/c4eaec09897d525e_0000000000000000_vs.txt @@ -0,0 +1,98 @@ +#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 c4eaec09897d525e +//reflection +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[1]; +}; +#else +uniform ivec4 uf_remappedVS[1]; +#endif +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1; +out gl_PerVertex +{ + vec4 gl_Position; +}; +layout(location = 0) out vec4 passParameterSem0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +backupReg0f = R1f.x; +backupReg1f = R1f.y; +R1f.x = backupReg0f; +R1f.x *= 2.0; +R1f.y = backupReg1f; +R1f.y *= 2.0; +R1f.z = 0.0; +R1f.w = 1.0; +PS0f = intBitsToFloat(uf_remappedVS[0].y) * intBitsToFloat(0x3fae8a72)/resXScale; +// 1 +backupReg0f = R2f.y; +backupReg0f = R2f.y; +backupReg0f = R2f.y; +R2f.y = backupReg0f + -(PS0f); +R2f.z = backupReg0f + PS0f; +R2f.w = backupReg0f; +// export +SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w)); +// export +passParameterSem0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/d388f32cb9be9a7a_000000000000f249_ps.txt b/src/SuperMario3DWorld/Graphics/d388f32cb9be9a7a_000000000000f249_ps.txt new file mode 100644 index 00000000..cc90c02f --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/d388f32cb9be9a7a_000000000000f249_ps.txt @@ -0,0 +1,292 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_separate_shader_objects : enable +// shader d388f32cb9be9a7a +// Used for: Ambient-occlusion +float resScale = float($width)/float($gameWidth); + + +#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 = 4) uniform ufBlock +{ +uniform ivec4 uf_remappedPS[8]; +uniform vec4 uf_fragCoordScale; +}; +#else +uniform ivec4 uf_remappedPS[8]; +uniform vec2 uf_fragCoordScale; +#endif +TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0; +TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1; +TEXTURE_LAYOUT(2, 1, 2) uniform sampler2D textureUnitPS2; +TEXTURE_LAYOUT(3, 1, 3) uniform sampler2D textureUnitPS3; +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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +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 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 = passParameterSem1; +R7f.x = (texture(textureUnitPS0, R1f.xy).x); +R2f.xy = (texture(textureUnitPS3, R1f.zw).xy); +// 0 +R5f.x = (R2f.y * 2.0 + -(1.0)); +PV0f.x = R5f.x; +R4f.y = R7f.x * intBitsToFloat(uf_remappedPS[0].z); +R123f.z = (-(R7f.x) * intBitsToFloat(uf_remappedPS[1].y) + 1.0); +R123f.z = clamp(R123f.z, 0.0, 1.0); +PV0f.z = R123f.z; +R0f.w = (R2f.x * 2.0 + -(1.0)); +PV0f.w = R0f.w; +// 1 +R4f.x = PV0f.w * intBitsToFloat(uf_remappedPS[2].z)/resScale; +R125f.y = PV0f.z * intBitsToFloat(uf_remappedPS[1].x)/resScale; +PV1f.y = R125f.y; +R4f.z = -(PV0f.x) * intBitsToFloat(uf_remappedPS[2].z)/resScale; +// 2 +R127f.x = PV1f.y * intBitsToFloat(uf_remappedPS[3].x)/resScale; +PV0f.x = R127f.x; +R127f.y = PV1f.y * intBitsToFloat(uf_remappedPS[3].y)/resScale; +R127f.z = PV1f.y * intBitsToFloat(uf_remappedPS[4].y)/resScale; +PV0f.w = PV1f.y * intBitsToFloat(uf_remappedPS[4].x)/resScale; +PS0f = 1.0 / PV1f.y; +// 3 +PV1f.x = R5f.x * PV0f.w; +PV1f.y = R4f.x * PV0f.w; +R5f.z = intBitsToFloat(uf_remappedPS[5].z) * PS0f; +R5f.w = intBitsToFloat(uf_remappedPS[5].z) * PS0f; +PS1f = R4f.x * PV0f.x; +// 4 +PV0f.x = R5f.x * R127f.x; +R126f.y = (R4f.z * R127f.y + PS1f); +R123f.z = (R0f.w * R127f.z + PV1f.x); +PV0f.z = R123f.z; +R123f.w = (R4f.z * R127f.z + PV1f.y); +PV0f.w = R123f.w; +R6f.x = R125f.y * intBitsToFloat(uf_remappedPS[6].x)/resScale; +PS0f = R6f.x; +// 5 +R2f.xyz = vec3(R1f.x,R1f.y,R1f.x) + vec3(PV0f.w,PV0f.z,-(PV0f.w)); +R2f.w = R1f.y + -(PV0f.z); +R122f.x = (R0f.w * R127f.y + PV0f.x); +PS1f = R122f.x; +// 6 +R3f.xyz = vec3(R1f.x,R1f.y,R1f.x) + vec3(R126f.y,PS1f,-(R126f.y)); +R3f.w = R1f.y + -(PS1f); +R4f.w = R125f.y * intBitsToFloat(uf_remappedPS[6].y)/resScale; +PS0f = R4f.w; +R2f.x = (texture(textureUnitPS1, R2f.xy).x); +R2f.y = (texture(textureUnitPS1, R2f.zw).x); +R3f.x = (texture(textureUnitPS1, R3f.xy).x); +R3f.y = (texture(textureUnitPS1, R3f.zw).x); +// 0 +R127f.x = R4f.y + -(R3f.x); +PV0f.x = R127f.x; +PV0f.y = -(R2f.y) + R4f.y; +PV0f.z = -(R2f.x) + R4f.y; +R127f.w = R4f.y + -(R3f.y); +// 1 +PV1f.x = PV0f.z * R5f.w; +PV1f.x /= 2.0; +R125f.y = (-(PV0f.z) * intBitsToFloat(uf_remappedPS[1].z) + 1.0); +R125f.y = clamp(R125f.y, 0.0, 1.0); +R126f.z = (-(PV0f.y) * intBitsToFloat(uf_remappedPS[1].z) + 1.0); +R126f.z = clamp(R126f.z, 0.0, 1.0); +PV1f.w = PV0f.y * R5f.z; +PV1f.w /= 2.0; +PS1f = PV0f.x * R5f.w; +PS1f /= 2.0; +// 2 +PV0f.x = R127f.w * R5f.z; +PV0f.x /= 2.0; +R126f.y = (PV1f.w * intBitsToFloat(uf_remappedPS[4].z) + 0.5); +R126f.y = clamp(R126f.y, 0.0, 1.0); +PV0f.y = R126f.y; +R127f.z = (PV1f.x * intBitsToFloat(uf_remappedPS[4].z) + 0.5); +R127f.z = clamp(R127f.z, 0.0, 1.0); +PV0f.z = R127f.z; +R125f.w = (PS1f * intBitsToFloat(uf_remappedPS[3].z) + 0.5); +R125f.w = clamp(R125f.w, 0.0, 1.0); +PS0f = R4f.x * R6f.x; +// 3 +R126f.x = (PV0f.x * intBitsToFloat(uf_remappedPS[3].z) + 0.5); +R126f.x = clamp(R126f.x, 0.0, 1.0); +PV1f.x = R126f.x; +PV1f.y = 0.5 + -(PV0f.z); +PV1f.z = 0.5 + -(PV0f.y); +R124f.w = (R4f.z * R4f.w + PS0f); +R125f.z = (-(R127f.x) * intBitsToFloat(uf_remappedPS[1].z) + 1.0); +R125f.z = clamp(R125f.z, 0.0, 1.0); +PS1f = R125f.z; +// 4 +R127f.x = (PV1f.z * R126f.z + 0.5); +PV0f.x = R127f.x; +R127f.y = (-(R127f.w) * intBitsToFloat(uf_remappedPS[1].z) + 1.0); +R127f.y = clamp(R127f.y, 0.0, 1.0); +PV0f.y = R127f.y; +PV0f.z = 0.5 + -(PV1f.x); +R127f.w = (PV1f.y * R125f.y + 0.5); +PV0f.w = R127f.w; +PS0f = 0.5 + -(R125f.w); +// 5 +R125f.x = (PV0f.z * PV0f.y + 0.5); +PV1f.y = R126f.y + -(PV0f.w); +PV1f.z = R127f.z + -(PV0f.x); +R126f.w = (PS0f * R125f.z + 0.5); +PV1f.w = R126f.w; +PS1f = R5f.x * R6f.x; +// 6 +backupReg0f = R127f.x; +backupReg1f = R126f.z; +backupReg2f = R127f.w; +R127f.x = (PV1f.z * R125f.y + backupReg0f); +PV0f.y = R126f.x + -(PV1f.w); +R126f.z = (R0f.w * R4f.w + PS1f); +PV0f.z = R126f.z; +R127f.w = (PV1f.y * backupReg1f + backupReg2f); +// 7 +PV1f.x = R125f.w + -(R125f.x); +R123f.y = (PV0f.y * R127f.y + R126f.w); +PV1f.y = R123f.y; +R4f.z = R1f.x + R124f.w; +R4f.w = R1f.y + PV0f.z; +R5f.x = R1f.x + -(R124f.w); +PS1f = R5f.x; +// 8 +backupReg0f = R125f.x; +R125f.x = R7f.x * intBitsToFloat(uf_remappedPS[5].y); +R5f.y = R1f.y + -(R126f.z); +R123f.z = (PV1f.x * R125f.z + backupReg0f); +PV0f.z = R123f.z; +PV0f.w = PV1f.y * intBitsToFloat(uf_remappedPS[3].w); +R6f.z = 0.0; +PS0f = R6f.z; +// 9 +PV1f.x = PV0f.z * intBitsToFloat(uf_remappedPS[3].w); +R1f.y = (R127f.w * intBitsToFloat(uf_remappedPS[4].w) + PV0f.w); +R6f.w = 1.0; +// 10 +R1f.z = (R127f.x * intBitsToFloat(uf_remappedPS[4].w) + PV1f.x); +// 11 +R123f.z = (R7f.x * intBitsToFloat(uf_remappedPS[5].z) + intBitsToFloat(uf_remappedPS[5].x)/3); +PV1f.z = R123f.z; +// 12 +backupReg0f = R0f.x; +backupReg1f = R0f.z; +PV0f.x = backupReg0f * PV1f.z; +PV0f.z = backupReg1f * PV1f.z; +PV0f.w = R0f.y * PV1f.z; +// 13 +backupReg0f = R125f.x; +backupReg0f = R125f.x; +backupReg0f = R125f.x; +R125f.x = (backupReg0f * intBitsToFloat(uf_remappedPS[7].y) + PV0f.w); +R127f.y = (backupReg0f * intBitsToFloat(uf_remappedPS[7].x) + PV0f.x); +R123f.w = (backupReg0f * intBitsToFloat(uf_remappedPS[7].z) + PV0f.z); +PV1f.w = R123f.w; +// 14 +PS0f = 1.0 / PV1f.w; +// 15 +R0f.x = R127f.y * PS0f; +R0f.y = R125f.x * PS0f; +R7f.x = (texture(textureUnitPS1, R4f.zw).x); +R5f.y = (texture(textureUnitPS1, R5f.xy).x); +R6f.y = (texture(textureUnitPS2, R0f.xy).x); +// 0 +PV0f.x = R4f.y + -(R7f.x); +PV0f.w = R4f.y + -(R5f.y); +// 1 +R127f.x = (-(PV0f.x) * intBitsToFloat(uf_remappedPS[1].z) + 1.0); +R127f.x = clamp(R127f.x, 0.0, 1.0); +PV1f.y = PV0f.w * R5f.z; +PV1f.y /= 2.0; +PV1f.z = PV0f.x * R5f.w; +PV1f.z /= 2.0; +R126f.w = (-(PV0f.w) * intBitsToFloat(uf_remappedPS[1].z) + 1.0); +R126f.w = clamp(R126f.w, 0.0, 1.0); +// 2 +R125f.x = (PV1f.z * intBitsToFloat(uf_remappedPS[6].z) + 0.5); +R125f.x = clamp(R125f.x, 0.0, 1.0); +PV0f.x = R125f.x; +R127f.w = (PV1f.y * intBitsToFloat(uf_remappedPS[6].z) + 0.5); +R127f.w = clamp(R127f.w, 0.0, 1.0); +PV0f.w = R127f.w; +// 3 +PV1f.x = 0.5 + -(PV0f.w); +PV1f.w = 0.5 + -(PV0f.x); +// 4 +R127f.y = (PV1f.w * R127f.x + 0.5); +PV0f.y = R127f.y; +R126f.z = (PV1f.x * R126f.w + 0.5); +PV0f.z = R126f.z; +// 5 +PV1f.x = R125f.x + -(PV0f.z); +PV1f.w = R127f.w + -(PV0f.y); +// 6 +R123f.y = (PV1f.w * R126f.w + R127f.y); +PV0f.y = R123f.y; +R123f.z = (PV1f.x * R127f.x + R126f.z); +PV0f.z = R123f.z; +// 7 +R123f.x = (PV0f.z * intBitsToFloat(uf_remappedPS[6].w) + R1f.z); +PV1f.x = R123f.x; +R123f.w = (PV0f.y * intBitsToFloat(uf_remappedPS[6].w) + R1f.y); +PV1f.w = R123f.w; +// 8 +PV0f.z = PV1f.x + PV1f.w; +// 9 +PV1f.y = PV0f.z + intBitsToFloat(uf_remappedPS[1].w); +// 10 +PV0f.x = PV1f.y + -(0.5); +// 11 +PV1f.w = PV0f.x * intBitsToFloat(uf_remappedPS[0].y); +PV1f.w = clamp(PV1f.w, 0.0, 1.0); +// 12 +R6f.x = -(PV1f.w) + 1.0; +// export +passPixelColor0 = vec4(R6f.x, R6f.y, R6f.z, R6f.w); +} diff --git a/src/SuperMario3DWorld/Graphics/d9c81460d6984bb2_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/d9c81460d6984bb2_0000000000000000_vs.txt new file mode 100644 index 00000000..c5bcfad2 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/d9c81460d6984bb2_0000000000000000_vs.txt @@ -0,0 +1,140 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_separate_shader_objects : enable +#ifdef VULKAN +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#else +#define SET_POSITION(_v) gl_Position = _v +#endif +#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 d9c81460d6984bb2 +//switch palace reflection hz +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[5]; +}; +#else +uniform ivec4 uf_remappedVS[5]; +#endif +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +out gl_PerVertex +{ + vec4 gl_Position; +}; +layout(location = 0) out vec4 passParameterSem0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +R127f.x = (R1f.x > 0.0)?1.0:0.0; +R127f.x /= 2.0; +R127f.y = -(R1f.y); +PV0f.y = R127f.y; +R127f.z = (0.0 > R1f.x)?1.0:0.0; +R127f.z /= 2.0; +R127f.w = 1.0; +PV0f.w = R127f.w; +R126f.x = intBitsToFloat(uf_remappedVS[0].z) * intBitsToFloat(0x3fae8a72) /resYScale; +PS0f = R126f.x; +// 1 +R0f.x = dot(vec4(R1f.x,R1f.y,R1f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w))); +PV1f.x = R0f.x; +PV1f.y = R0f.x; +PV1f.z = R0f.x; +PV1f.w = R0f.x; +R126f.w = (PV0f.y > 0.0)?1.0:0.0; +R126f.w /= 2.0; +PS1f = R126f.w; +// 2 +backupReg0f = R127f.y; +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w))); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R0f.y = tempf.x; +R127f.y = (0.0 > backupReg0f)?1.0:0.0; +R127f.y /= 2.0; +PS0f = R127f.y; +// 3 +backupReg0f = R127f.x; +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w))); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +R0f.z = tempf.x; +R127f.x = backupReg0f + -(R127f.z); +PS1f = R127f.x; +// 4 +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w))); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R0f.w = tempf.x; +PS0f = R126f.w + -(R127f.y); +// 5 +PV1f.y = PS0f + 0.5; +PV1f.z = R127f.x + 0.5; +// 6 +R1f.x = PV1f.y; +R1f.y = PV1f.z + -(R126f.x); +R1f.z = PV1f.z + R126f.x; +R1f.w = PV1f.z; +// export +SET_POSITION(vec4(R0f.x, R0f.y, R0f.z, R0f.w)); +// export +passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/e4e4a60266119f75_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/e4e4a60266119f75_0000000000000000_vs.txt new file mode 100644 index 00000000..ba179f13 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/e4e4a60266119f75_0000000000000000_vs.txt @@ -0,0 +1,107 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_separate_shader_objects : enable +#ifdef VULKAN +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#else +#define SET_POSITION(_v) gl_Position = _v +#endif +#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 e4e4a60266119f75 +//reflection +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[1]; +}; +#else +uniform ivec4 uf_remappedVS[1]; +#endif +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +ATTR_LAYOUT(0, 1) in uvec4 attrDataSem1; +out gl_PerVertex +{ + vec4 gl_Position; +}; +layout(location = 0) out vec4 passParameterSem0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +backupReg0f = R1f.x; +backupReg1f = R1f.y; +R1f.x = backupReg0f; +R1f.x *= 2.0; +R1f.y = backupReg1f; +R1f.y *= 2.0; +R1f.z = 0.0; +R1f.w = 1.0; +PS0f = intBitsToFloat(uf_remappedVS[0].x) * intBitsToFloat(0x3fae8a72)/resXScale; +// 1 +backupReg0f = R2f.x; +backupReg0f = R2f.x; +backupReg0f = R2f.x; +R2f.x = R2f.y; +R2f.y = backupReg0f + -(PS0f); +R2f.z = backupReg0f + PS0f; +R2f.w = backupReg0f; +// export +SET_POSITION(vec4(R1f.x, R1f.y, R1f.z, R1f.w)); +// export +passParameterSem0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/fa47a4b5f1304f51_0000000000000000_vs.txt b/src/SuperMario3DWorld/Graphics/fa47a4b5f1304f51_0000000000000000_vs.txt new file mode 100644 index 00000000..c26f7fe6 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/fa47a4b5f1304f51_0000000000000000_vs.txt @@ -0,0 +1,137 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_separate_shader_objects : enable +#ifdef VULKAN +#define gl_VertexID gl_VertexIndex +#define gl_InstanceID gl_InstanceIndex +#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0 +#else +#define SET_POSITION(_v) gl_Position = _v +#endif +#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 fa47a4b5f1304f51 +// low res reflection +const float resXScale = float($width)/float($gameWidth); +const float resYScale = float($height)/float($gameHeight); + +#ifdef VULKAN +layout(set = 0, binding = 0) uniform ufBlock +{ +uniform ivec4 uf_remappedVS[5]; +}; +#else +uniform ivec4 uf_remappedVS[5]; +#endif +ATTR_LAYOUT(0, 0) in uvec4 attrDataSem0; +out gl_PerVertex +{ + vec4 gl_Position; +}; +layout(location = 0) out vec4 passParameterSem0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +R127f.x = -(R1f.y); +PV0f.x = R127f.x; +R127f.y = (R1f.x > 0.0)?1.0:0.0; +R127f.y /= 2.0; +R126f.z = (0.0 > R1f.x)?1.0:0.0; +R126f.z /= 2.0; +R127f.w = 1.0; +PV0f.w = R127f.w; +R126f.x = intBitsToFloat(uf_remappedVS[0].w) * intBitsToFloat(0x3f99999a)/resXScale; +PS0f = R126f.x; +// 1 +R0f.x = dot(vec4(R1f.x,R1f.y,R1f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w))); +PV1f.x = R0f.x; +PV1f.y = R0f.x; +PV1f.z = R0f.x; +PV1f.w = R0f.x; +R127f.z = (PV0f.x > 0.0)?1.0:0.0; +R127f.z /= 2.0; +PS1f = R127f.z; +// 2 +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w))); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R0f.y = tempf.x; +PS0f = (0.0 > R127f.x)?1.0:0.0; +PS0f /= 2.0; +// 3 +backupReg0f = R127f.z; +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w))); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +R0f.z = tempf.x; +R127f.z = backupReg0f + -(PS0f); +PS1f = R127f.z; +// 4 +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,R127f.w),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),intBitsToFloat(uf_remappedVS[4].w))); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R0f.w = tempf.x; +PS0f = R127f.y + -(R126f.z); +// 5 +R1f.x = PS0f + 0.5; +PV1f.y = R127f.z + 0.5; +// 6 +R1f.y = PV1f.y + -(R126f.x); +R1f.z = PV1f.y + R126f.x; +R1f.w = PV1f.y; +// export +SET_POSITION(vec4(R0f.x, R0f.y, R0f.z, R0f.w)); +// export +passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +// 0 +} diff --git a/src/SuperMario3DWorld/Graphics/patch_resolution.asm b/src/SuperMario3DWorld/Graphics/patch_resolution.asm new file mode 100644 index 00000000..f365a044 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/patch_resolution.asm @@ -0,0 +1,14 @@ +[SuperMario3DWorld_AspectRatio] +moduleMatches = 0xD2308838, 0xBBAF1908, 0xEB70C731 ; (EU), (NA), (JP) +; rodata constants +0x10363ED4 = .float $width/$height +0x1036A688 = .float $width/$height +_aspectAddr = 0x10363ED4 + +; Aspect calculation +0x0241D9B4 = lis r8, _aspectAddr@ha +0x0241D9B8 = lfs f0, _aspectAddr@l(r8) + +; touch position fix +0x0241D9D4 = lis r8, _aspectAddr@ha +0x0241D9D8 = lfs f0, _aspectAddr@l(r8) diff --git a/src/SuperMario3DWorld/Graphics/rules.txt b/src/SuperMario3DWorld/Graphics/rules.txt new file mode 100644 index 00000000..f6b5ac39 --- /dev/null +++ b/src/SuperMario3DWorld/Graphics/rules.txt @@ -0,0 +1,3980 @@ +[Definition] +titleIds = 0005000010145D00,0005000010145C00,0005000010106100 +name = Graphics Settings +path = "Super Mario 3D World/Graphics" +description = Changes the resolution of the game and the quality of shadows.|Made by Crementif and getdls. +#Credits: Crementif, getdls, Ryce-Fast +version = 6 + +[Default] +$width = 1280 +$height = 720 +$gameWidth = 1280 +$gameHeight = 720 +$shadowRes = 1 +$anisoLevel = 1 + +# Performance + +[Preset] +category = Resolution +name = 640x360 +$width = 640 +$height = 360 + +[Preset] +category = Resolution +name = 960x540 +$width = 960 +$height = 540 + +[Preset] +category = Resolution +name = 1280x720 (Default) +default = 1 + +# Common HD Resolutions + +[Preset] +category = Resolution +name = 1600x900 +$width = 1600 +$height = 900 + +[Preset] +category = Resolution +name = 1920x1080 +$width = 1920 +$height = 1080 + +[Preset] +category = Resolution +name = 2560x1440 +$width = 2560 +$height = 1440 + +[Preset] +category = Resolution +name = 3200x1800 +$width = 3200 +$height = 1800 + +[Preset] +category = Resolution +name = 3840x2160 +$width = 3840 +$height = 2160 + +[Preset] +category = Resolution +name = 5120x2880 +$width = 5120 +$height = 2880 + +[Preset] +category = Resolution +name = 7680x4320 +$width = 7680 +$height = 4320 + +# Common Ultrawide Resolutions + +[Preset] +category = Resolution +name = 2560x1080 (Ultrawide) +$width = 2560 +$height = 1080 + +[Preset] +category = Resolution +name = 3440x1440 (Ultrawide) +$width = 3440 +$height = 1440 + + + +[Preset] +category = Shadows +name = Low (50%) +$shadowRes = 0.5 + +[Preset] +category = Shadows +name = Medium (100%, Default) +default = 1 + +[Preset] +category = Shadows +name = High (200%) +$shadowRes = 2 + +[Preset] +category = Shadows +name = Ultra (300%) +$shadowRes = 3 + +[Preset] +category = Shadows +name = Extreme (400%, Unstable) +$shadowRes = 4 + +[Preset] +category = Anisotropic Filtering +name = 1x (Default) + +[Preset] +category = Anisotropic Filtering +name = 2x +$anisoLevel = 2 + +[Preset] +category = Anisotropic Filtering +name = 4x +$anisoLevel = 4 + +[Preset] +category = Anisotropic Filtering +name = 8x +$anisoLevel = 8 + +[Preset] +category = Anisotropic Filtering +name = 16x (Recommended) +$anisoLevel = 16 + +[Preset] +category = Anisotropic Filtering +name = 32x (Overkill) +$anisoLevel = 32 + +#ansio + +[TextureRedefine] +formats = 0x31,0x32,0x33,0x34,0x35,0x431,0x432,0x433,0x434,0x435 +overwriteAnisotropy = $anisoLevel + +#Shadows + +[TextureRedefine] +width = 1024 +height = 1024 +formats = 0x005 +overwriteWidth = $shadowRes * 1024 +overwriteHeight = $shadowRes * 1024 + +#Resolution + +[TextureRedefine] +width = 1280 +height = 720 +formatsExcluded = 0x008,0x41A,0x034,0x035 +overwriteWidth = ($width/$gameWidth) * 1280 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] #heat haze +width = 1152 +height = 720 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 1152 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] #heat haze +width = 1128 +height = 720 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 1128 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] #Zoom +width = 1024 +height = 608 +#formats = 0x80e,0x810 +overwriteWidth = ($width/$gameWidth) * 1024 +overwriteHeight = ($height/$gameHeight) * 608 + +[TextureRedefine] #Heat haze +width = 1024 +height = 1024 +formats = 0x005 +overwriteWidth = ($width/$gameWidth) * 1024 +overwriteHeight = ($height/$gameHeight) * 1024 + +[TextureRedefine] #Heat haze +width = 1024 +height = 512 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 1024 +overwriteHeight = ($height/$gameHeight) * 512 + +[TextureRedefine] #Zoom +width = 1000 +height = 600 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 1000 +overwriteHeight = ($height/$gameHeight) * 600 + +[TextureRedefine] #sparkly mine +width = 896 +height = 480 +overwriteWidth = ($width/$gameWidth) * 896 +overwriteHeight = ($height/$gameHeight) * 480 + +[TextureRedefine] +width = 864 +height = 480 +overwriteWidth = ($width/$gameWidth) * 864 +overwriteHeight = ($height/$gameHeight) * 480 + +[TextureRedefine] +width = 854 +height = 480 +overwriteWidth = ($width/$gameWidth) * 854 +overwriteHeight = ($height/$gameHeight) * 480 + +[TextureRedefine] #large mirror +width = 848 +height = 480 +#formats = 0x816,0x810,0x019,0x01a +overwriteWidth = ($width/$gameWidth) * 848 +overwriteHeight = ($height/$gameHeight) * 480 + +[TextureRedefine] #Depth 8 +width = 640 +height = 368 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 640 +overwriteHeight = ($height/$gameHeight) * 368 + +[TextureRedefine] #Depth +width = 640 +height = 360 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 640 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] #heat haze zoomed +width = 576 +height = 368 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 576 +overwriteHeight = ($height/$gameHeight) * 368 + +[TextureRedefine] #bowser carnival +width = 640 +height = 352 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 640 +overwriteHeight = ($height/$gameHeight) * 352 + +[TextureRedefine] #B C +width = 634 +height = 357 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 634 +overwriteHeight = ($height/$gameHeight) * 357 + +[TextureRedefine] +width = 629 +height = 354 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 629 +overwriteHeight = ($height/$gameHeight) * 354 + +[TextureRedefine] +width = 624 +height = 351 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 624 +overwriteHeight = ($height/$gameHeight) * 351 + +[TextureRedefine] +width = 618 +height = 348 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 618 +overwriteHeight = ($height/$gameHeight) * 348 + +[TextureRedefine] +width = 613 +height = 345 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 613 +overwriteHeight = ($height/$gameHeight) * 345 + +[TextureRedefine] +width = 608 +height = 342 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 608 +overwriteHeight = ($height/$gameHeight) * 342 + +[TextureRedefine] +width = 602 +height = 339 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 602 +overwriteHeight = ($height/$gameHeight) * 339 + +[TextureRedefine] +width = 597 +height = 336 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 597 +overwriteHeight = ($height/$gameHeight) * 336 + +[TextureRedefine] +width = 592 +height = 333 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 592 +overwriteHeight = ($height/$gameHeight) * 333 + +[TextureRedefine] +width = 586 +height = 330 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 586 +overwriteHeight = ($height/$gameHeight) * 330 + +[TextureRedefine] +width = 581 +height = 327 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 581 +overwriteHeight = ($height/$gameHeight) * 327 + +[TextureRedefine] +width = 576 +height = 324 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 576 +overwriteHeight = ($height/$gameHeight) * 324 + +[TextureRedefine] +width = 570 +height = 321 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 570 +overwriteHeight = ($height/$gameHeight) * 321 + +[TextureRedefine] +width = 565 +height = 318 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 565 +overwriteHeight = ($height/$gameHeight) * 318 + +[TextureRedefine] +width = 560 +height = 315 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 560 +overwriteHeight = ($height/$gameHeight) * 315 + +[TextureRedefine] +width = 554 +height = 312 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 554 +overwriteHeight = ($height/$gameHeight) * 312 + +[TextureRedefine] +width = 549 +height = 309 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 549 +overwriteHeight = ($height/$gameHeight) * 309 + +[TextureRedefine] +width = 544 +height = 306 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 544 +overwriteHeight = ($height/$gameHeight) * 306 + +[TextureRedefine] +width = 538 +height = 303 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 538 +overwriteHeight = ($height/$gameHeight) * 303 + +[TextureRedefine] +width = 533 +height = 300 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 533 +overwriteHeight = ($height/$gameHeight) * 300 + +[TextureRedefine] +width = 528 +height = 297 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 528 +overwriteHeight = ($height/$gameHeight) * 297 + +[TextureRedefine] +width = 522 +height = 294 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 522 +overwriteHeight = ($height/$gameHeight) * 294 + +[TextureRedefine] +width = 517 +height = 291 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 517 +overwriteHeight = ($height/$gameHeight) * 291 + + + + +[TextureRedefine] #816 fire transition, 80e switch palace +width = 512 +height = 512 +formats = 0x816,0x80e # #0x431,0x235,0x034,0x007 +overwriteWidth = ($width/$gameWidth) * 512 +overwriteHeight = ($height/$gameHeight) * 512 + +[TextureRedefine] +width = 512 +height = 304 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 512 +overwriteHeight = ($height/$gameHeight) * 304 + +[TextureRedefine] +width = 512 +height = 288 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 512 +overwriteHeight = ($height/$gameHeight) * 288 + +[TextureRedefine] +width = 512 +height = 256 +formats = 0x816,0x806 # 0x034,0x033,0x031,0x001,0x01a +overwriteWidth = ($width/$gameWidth) * 512 +overwriteHeight = ($height/$gameHeight) * 256 + +[TextureRedefine] +width = 506 +height = 285 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 506 +overwriteHeight = ($height/$gameHeight) * 285 + +[TextureRedefine] +width = 501 +height = 282 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 501 +overwriteHeight = ($height/$gameHeight) * 282 + +[TextureRedefine] +width = 500 +height = 300 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 500 +overwriteHeight = ($height/$gameHeight) * 300 + +[TextureRedefine] +width = 496 +height = 279 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 496 +overwriteHeight = ($height/$gameHeight) * 279 + +[TextureRedefine] +width = 490 +height = 276 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 490 +overwriteHeight = ($height/$gameHeight) * 276 + +[TextureRedefine] +width = 485 +height = 273 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 485 +overwriteHeight = ($height/$gameHeight) * 273 + +[TextureRedefine] # +width = 480 +height = 272 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 480 +overwriteHeight = ($height/$gameHeight) * 272 + +[TextureRedefine] +width = 480 +height = 256 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 480 +overwriteHeight = ($height/$gameHeight) * 256 + +[TextureRedefine] +width = 480 +height = 270 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 480 +overwriteHeight = ($height/$gameHeight) * 270 + +[TextureRedefine] +width = 320 +height = 192 +#formats = +overwriteWidth = ($width/$gameWidth) * 320 +overwriteHeight = ($height/$gameHeight) * 192 + +[TextureRedefine] +width = 474 +height = 267 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 474 +overwriteHeight = ($height/$gameHeight) * 267 + +[TextureRedefine] +width = 469 +height = 264 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 469 +overwriteHeight = ($height/$gameHeight) * 264 + +[TextureRedefine] +width = 464 +height = 261 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 464 +overwriteHeight = ($height/$gameHeight) * 261 + +[TextureRedefine] +width = 458 +height = 258 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 458 +overwriteHeight = ($height/$gameHeight) * 258 + +[TextureRedefine] +width = 453 +height = 255 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 453 +overwriteHeight = ($height/$gameHeight) * 255 + +[TextureRedefine] +width = 448 +height = 252 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 448 +overwriteHeight = ($height/$gameHeight) * 252 + +[TextureRedefine] +width = 442 +height = 249 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 442 +overwriteHeight = ($height/$gameHeight) * 249 + +[TextureRedefine] +width = 437 +height = 246 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 437 +overwriteHeight = ($height/$gameHeight) * 246 + +[TextureRedefine] +width = 432 +height = 243 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 432 +overwriteHeight = ($height/$gameHeight) * 243 + +[TextureRedefine] +width = 426 +height = 239 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 426 +overwriteHeight = ($height/$gameHeight) * 239 + +[TextureRedefine] +width = 421 +height = 236 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 421 +overwriteHeight = ($height/$gameHeight) * 236 + +[TextureRedefine] +width = 416 +height = 233 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 416 +overwriteHeight = ($height/$gameHeight) * 233 + +[TextureRedefine] +width = 410 +height = 231 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 410 +overwriteHeight = ($height/$gameHeight) * 231 + +[TextureRedefine] +width = 405 +height = 228 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 405 +overwriteHeight = ($height/$gameHeight) * 228 + +[TextureRedefine] +width = 400 +height = 225 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 400 +overwriteHeight = ($height/$gameHeight) * 225 + +[TextureRedefine] +width = 394 +height = 222 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 394 +overwriteHeight = ($height/$gameHeight) * 222 + +[TextureRedefine] +width = 389 +height = 219 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 389 +overwriteHeight = ($height/$gameHeight) * 219 + +[TextureRedefine] +width = 384 +height = 216 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 384 +overwriteHeight = ($height/$gameHeight) * 216 + +[TextureRedefine] +width = 378 +height = 213 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 378 +overwriteHeight = ($height/$gameHeight) * 213 + +[TextureRedefine] +width = 373 +height = 210 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 373 +overwriteHeight = ($height/$gameHeight) * 210 + +[TextureRedefine] +width = 368 +height = 207 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 368 +overwriteHeight = ($height/$gameHeight) * 207 + +[TextureRedefine] +width = 362 +height = 204 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 362 +overwriteHeight = ($height/$gameHeight) * 204 + +[TextureRedefine] +width = 357 +height = 201 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 357 +overwriteHeight = ($height/$gameHeight) * 201 + +[TextureRedefine] +width = 352 +height = 198 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 352 +overwriteHeight = ($height/$gameHeight) * 198 + +[TextureRedefine] +width = 346 +height = 194 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 346 +overwriteHeight = ($height/$gameHeight) * 194 + +[TextureRedefine] +width = 341 +height = 191 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 341 +overwriteHeight = ($height/$gameHeight) * 191 + +[TextureRedefine] +width = 336 +height = 188 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 336 +overwriteHeight = ($height/$gameHeight) * 188 + +[TextureRedefine] +width = 330 +height = 186 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 330 +overwriteHeight = ($height/$gameHeight) * 186 + +[TextureRedefine] +width = 325 +height = 183 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 325 +overwriteHeight = ($height/$gameHeight) * 183 + +[TextureRedefine] +width = 320 +height = 180 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 320 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] +width = 317 +height = 178 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 317 +overwriteHeight = ($height/$gameHeight) * 178 + +[TextureRedefine] +width = 314 +height = 177 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 314 +overwriteHeight = ($height/$gameHeight) * 177 + + +[TextureRedefine] #heat haze +width = 288 +height = 192 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 288 +overwriteHeight = ($height/$gameHeight) * 192 + +[TextureRedefine] #Transition fire +width = 282 +height = 180 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 282 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] +width = 256 +height = 256 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 256 +overwriteHeight = ($height/$gameHeight) * 256 + +[TextureRedefine] +width = 256 +height = 160 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 256 +overwriteHeight = ($height/$gameHeight) * 160 + +[TextureRedefine] +width = 256 +height = 144 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 256 +overwriteHeight = ($height/$gameHeight) * 144 + +[TextureRedefine] +width = 256 +height = 128 +formats = 0x816,0x806 +overwriteWidth = ($width/$gameWidth) * 256 +overwriteHeight = ($height/$gameHeight) * 128 + +[TextureRedefine] +width = 250 +height = 150 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 250 +overwriteHeight = ($height/$gameHeight) * 150 + +[TextureRedefine] +width = 253 +height = 142 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 253 +overwriteHeight = ($height/$gameHeight) * 142 + +[TextureRedefine] +width = 250 +height = 141 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 250 +overwriteHeight = ($height/$gameHeight) * 141 + +[TextureRedefine] +width = 248 +height = 139 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 248 +overwriteHeight = ($height/$gameHeight) * 139 + +[TextureRedefine] +width = 245 +height = 138 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 245 +overwriteHeight = ($height/$gameHeight) * 138 + +[TextureRedefine] +width = 242 +height = 136 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 242 +overwriteHeight = ($height/$gameHeight) * 136 + +[TextureRedefine] +width = 240 +height = 135 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 240 +overwriteHeight = ($height/$gameHeight) * 135 + +[TextureRedefine] +width = 237 +height = 133 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 237 +overwriteHeight = ($height/$gameHeight) * 133 + +[TextureRedefine] +width = 234 +height = 132 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 234 +overwriteHeight = ($height/$gameHeight) * 132 + +[TextureRedefine] +width = 232 +height = 130 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 232 +overwriteHeight = ($height/$gameHeight) * 130 + +[TextureRedefine] +width = 229 +height = 129 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 229 +overwriteHeight = ($height/$gameHeight) * 129 + +[TextureRedefine] +width = 226 +height = 127 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 226 +overwriteHeight = ($height/$gameHeight) * 127 + +[TextureRedefine] # mine sparkles +width = 224 +height = 128 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 224 +overwriteHeight = ($height/$gameHeight) * 128 + +[TextureRedefine] +width = 224 +height = 112 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 224 +overwriteHeight = ($height/$gameHeight) * 112 + +[TextureRedefine] +width = 221 +height = 124 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 221 +overwriteHeight = ($height/$gameHeight) * 124 + +[TextureRedefine] +width = 218 +height = 123 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 218 +overwriteHeight = ($height/$gameHeight) * 123 + +[TextureRedefine] +width = 216 +height = 121 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 216 +overwriteHeight = ($height/$gameHeight) * 121 + +[TextureRedefine] # mine sparkles +width = 213 +height = 120 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 213 +overwriteHeight = ($height/$gameHeight) * 120 + +[TextureRedefine] +width = 213 +height = 119 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 213 +overwriteHeight = ($height/$gameHeight) * 119 + +[TextureRedefine] +width = 210 +height = 118 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 210 +overwriteHeight = ($height/$gameHeight) * 118 + +[TextureRedefine] +width = 208 +height = 116 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 208 +overwriteHeight = ($height/$gameHeight) * 116 + +[TextureRedefine] +width = 205 +height = 115 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 205 +overwriteHeight = ($height/$gameHeight) * 115 + +[TextureRedefine] +width = 202 +height = 114 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 202 +overwriteHeight = ($height/$gameHeight) * 114 + +[TextureRedefine] +width = 200 +height = 112 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 200 +overwriteHeight = ($height/$gameHeight) * 112 + +[TextureRedefine] +width = 160 +height = 96 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 160 +overwriteHeight = ($height/$gameHeight) * 96 + +[TextureRedefine] +width = 160 +height = 90 +#formats = +overwriteWidth = ($width/$gameWidth) * 160 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] +width = 160 +height = 80 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 160 +overwriteHeight = ($height/$gameHeight) * 80 + +[TextureRedefine] +width = 158 +height = 89 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 158 +overwriteHeight = ($height/$gameHeight) * 89 + +[TextureRedefine] +width = 157 +height = 88 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 157 +overwriteHeight = ($height/$gameHeight) * 88 + +[TextureRedefine] +width = 156 +height = 87 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 156 +overwriteHeight = ($height/$gameHeight) * 87 + +[TextureRedefine] +width = 154 +height = 87 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 154 +overwriteHeight = ($height/$gameHeight) * 87 + +[TextureRedefine] +width = 153 +height = 86 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 153 +overwriteHeight = ($height/$gameHeight) * 86 + +[TextureRedefine] +width = 152 +height = 85 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 152 +overwriteHeight = ($height/$gameHeight) * 85 + +[TextureRedefine] +width = 150 +height = 84 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 150 +overwriteHeight = ($height/$gameHeight) * 84 + +[TextureRedefine] +width = 149 +height = 84 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 149 +overwriteHeight = ($height/$gameHeight) * 84 + +[TextureRedefine] +width = 148 +height = 83 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 148 +overwriteHeight = ($height/$gameHeight) * 83 + +[TextureRedefine] +width = 146 +height = 82 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 146 +overwriteHeight = ($height/$gameHeight) * 82 + +[TextureRedefine] +width = 145 +height = 81 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 145 +overwriteHeight = ($height/$gameHeight) * 81 + +[TextureRedefine] +width = 144 +height = 81 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 144 +overwriteHeight = ($height/$gameHeight) * 81 + +[TextureRedefine] +width = 142 +height = 80 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 142 +overwriteHeight = ($height/$gameHeight) * 80 + +[TextureRedefine] +width = 128 +height = 128 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 128 +overwriteHeight = ($height/$gameHeight) * 128 + +[TextureRedefine] +width = 128 +height = 72 +formats = 0x816 #,0x035 +overwriteWidth = ($width/$gameWidth) * 128 +overwriteHeight = ($height/$gameHeight) * 72 + +[TextureRedefine] #Transition fire +width = 141 +height = 90 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 141 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] +width = 128 +height = 80 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 128 +overwriteHeight = ($height/$gameHeight) * 80 + +[TextureRedefine] +width = 128 +height = 64 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 128 +overwriteHeight = ($height/$gameHeight) * 64 + +[TextureRedefine] #haze +width = 128 +height = 16 +formats = 0x823 +overwriteWidth = ($width/$gameWidth) * 128 +overwriteHeight = ($height/$gameHeight) * 16 + +[TextureRedefine] +width = 126 +height = 71 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 126 +overwriteHeight = ($height/$gameHeight) * 71 + +[TextureRedefine] +width = 125 +height = 70 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 125 +overwriteHeight = ($height/$gameHeight) * 70 + +[TextureRedefine] +width = 125 +height = 75 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 125 +overwriteHeight = ($height/$gameHeight) * 75 + +[TextureRedefine] +width = 124 +height = 69 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 124 +overwriteHeight = ($height/$gameHeight) * 69 + +[TextureRedefine] +width = 122 +height = 69 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 122 +overwriteHeight = ($height/$gameHeight) * 69 + +[TextureRedefine] +width = 121 +height = 68 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 121 +overwriteHeight = ($height/$gameHeight) * 68 + +[TextureRedefine] +width = 120 +height = 67 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 120 +overwriteHeight = ($height/$gameHeight) * 67 + +[TextureRedefine] +width = 118 +height = 66 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 118 +overwriteHeight = ($height/$gameHeight) * 66 + +[TextureRedefine] +width = 117 +height = 66 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 117 +overwriteHeight = ($height/$gameHeight) * 66 + +[TextureRedefine] +width = 116 +height = 65 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 116 +overwriteHeight = ($height/$gameHeight) * 65 + +[TextureRedefine] +width = 114 +height = 64 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 114 +overwriteHeight = ($height/$gameHeight) * 64 + +[TextureRedefine] +width = 113 +height = 63 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 113 +overwriteHeight = ($height/$gameHeight) * 63 + +[TextureRedefine] +width = 112 +height = 63 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 112 +overwriteHeight = ($height/$gameHeight) * 63 + +[TextureRedefine] +width = 110 +height = 62 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 110 +overwriteHeight = ($height/$gameHeight) * 62 + +[TextureRedefine] +width = 109 +height = 61 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 109 +overwriteHeight = ($height/$gameHeight) * 61 + +[TextureRedefine] +width = 108 +height = 60 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 108 +overwriteHeight = ($height/$gameHeight) * 60 + +[TextureRedefine] +width = 106 +height = 59 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 106 +overwriteHeight = ($height/$gameHeight) * 59 + +[TextureRedefine] +width = 105 +height = 59 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 105 +overwriteHeight = ($height/$gameHeight) * 59 + +[TextureRedefine] +width = 104 +height = 58 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 104 +overwriteHeight = ($height/$gameHeight) * 58 + +[TextureRedefine] +width = 102 +height = 57 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 102 +overwriteHeight = ($height/$gameHeight) * 57 + +[TextureRedefine] +width = 101 +height = 57 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 101 +overwriteHeight = ($height/$gameHeight) * 57 + +[TextureRedefine] +width = 100 +height = 56 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 100 +overwriteHeight = ($height/$gameHeight) * 56 + +[TextureRedefine] +width = 98 +height = 55 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 98 +overwriteHeight = ($height/$gameHeight) * 55 + +[TextureRedefine] +width = 97 +height = 54 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 97 +overwriteHeight = ($height/$gameHeight) * 54 + +[TextureRedefine] +width = 96 +height = 64 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 96 +overwriteHeight = ($height/$gameHeight) * 64 + +[TextureRedefine] +width = 96 +height = 48 +#formats = +overwriteWidth = ($width/$gameWidth) * 96 +overwriteHeight = ($height/$gameHeight) * 48 + +[TextureRedefine] +width = 86 +height = 48 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 86 +overwriteHeight = ($height/$gameHeight) * 48 + +[TextureRedefine] +width = 85 +height = 47 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 85 +overwriteHeight = ($height/$gameHeight) * 47 + +[TextureRedefine] +width = 84 +height = 47 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 84 +overwriteHeight = ($height/$gameHeight) * 47 + +[TextureRedefine] +width = 82 +height = 46 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 82 +overwriteHeight = ($height/$gameHeight) * 46 + +[TextureRedefine] +width = 81 +height = 45 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 81 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] +width = 80 +height = 45 +#formats = +overwriteWidth = ($width/$gameWidth) * 80 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] +width = 79 +height = 44 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 79 +overwriteHeight = ($height/$gameHeight) * 44 + +[TextureRedefine] +width = 78 +height = 44 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 78 +overwriteHeight = ($height/$gameHeight) * 44 + +[TextureRedefine] +width = 78 +height = 43 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 78 +overwriteHeight = ($height/$gameHeight) * 43 + +[TextureRedefine] +width = 77 +height = 43 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 77 +overwriteHeight = ($height/$gameHeight) * 43 + +[TextureRedefine] +width = 76 +height = 43 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 76 +overwriteHeight = ($height/$gameHeight) * 43 + +[TextureRedefine] +width = 76 +height = 42 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 76 +overwriteHeight = ($height/$gameHeight) * 42 + +[TextureRedefine] +width = 75 +height = 42 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 75 +overwriteHeight = ($height/$gameHeight) * 42 + +[TextureRedefine] +width = 74 +height = 42 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 74 +overwriteHeight = ($height/$gameHeight) * 42 + +[TextureRedefine] +width = 74 +height = 41 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 74 +overwriteHeight = ($height/$gameHeight) * 41 + +[TextureRedefine] +width = 73 +height = 41 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 73 +overwriteHeight = ($height/$gameHeight) * 41 + +[TextureRedefine] +width = 72 +height = 40 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 72 +overwriteHeight = ($height/$gameHeight) * 40 + +[TextureRedefine] +width = 71 +height = 40 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 71 +overwriteHeight = ($height/$gameHeight) * 40 + +[TextureRedefine] # Transition fire +width = 70 +height = 45 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 70 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] +width = 70 +height = 39 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 70 +overwriteHeight = ($height/$gameHeight) * 39 + +[TextureRedefine] +width = 69 +height = 39 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 69 +overwriteHeight = ($height/$gameHeight) * 39 + +[TextureRedefine] +width = 68 +height = 38 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 68 +overwriteHeight = ($height/$gameHeight) * 38 + +[TextureRedefine] +width = 67 +height = 37 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 67 +overwriteHeight = ($height/$gameHeight) * 37 + +[TextureRedefine] +width = 66 +height = 37 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 66 +overwriteHeight = ($height/$gameHeight) * 37 + +[TextureRedefine] +width = 65 +height = 36 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 65 +overwriteHeight = ($height/$gameHeight) * 36 + +[TextureRedefine] +width = 64 +height = 64 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 64 +overwriteHeight = ($height/$gameHeight) * 64 + +[TextureRedefine] +width = 64 +height = 48 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 64 +overwriteHeight = ($height/$gameHeight) * 48 + +[TextureRedefine] +width = 64 +height = 32 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 64 +overwriteHeight = ($height/$gameHeight) * 32 + +[TextureRedefine] +width = 64 +height = 36 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 64 +overwriteHeight = ($height/$gameHeight) * 36 + +[TextureRedefine] +width = 63 +height = 35 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 63 +overwriteHeight = ($height/$gameHeight) * 35 + +[TextureRedefine] +width = 62 +height = 35 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 62 +overwriteHeight = ($height/$gameHeight) * 35 + +[TextureRedefine] +width = 62 +height = 34 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 62 +overwriteHeight = ($height/$gameHeight) * 34 + +[TextureRedefine] +width = 61 +height = 34 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 61 +overwriteHeight = ($height/$gameHeight) * 34 + +[TextureRedefine] +width = 60 +height = 34 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 60 +overwriteHeight = ($height/$gameHeight) * 34 + +[TextureRedefine] +width = 62 +height = 37 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 60 +overwriteHeight = ($height/$gameHeight) * 37 + +[TextureRedefine] +width = 60 +height = 33 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 60 +overwriteHeight = ($height/$gameHeight) * 33 + +[TextureRedefine] #transition fire +width = 40 +height = 22 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 40 +overwriteHeight = ($height/$gameHeight) * 22 + +[TextureRedefine] +width = 35 +height = 22 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 35 +overwriteHeight = ($height/$gameHeight) * 22 + +[TextureRedefine] +width = 59 +height = 33 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 59 +overwriteHeight = ($height/$gameHeight) * 33 + +[TextureRedefine] +width = 58 +height = 33 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 58 +overwriteHeight = ($height/$gameHeight) * 33 + +[TextureRedefine] +width = 58 +height = 32 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 58 +overwriteHeight = ($height/$gameHeight) * 32 + +[TextureRedefine] +width = 57 +height = 32 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 57 +overwriteHeight = ($height/$gameHeight) * 32 + +[TextureRedefine] +width = 56 +height = 31 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 56 +overwriteHeight = ($height/$gameHeight) * 31 + +[TextureRedefine] +width = 55 +height = 31 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 55 +overwriteHeight = ($height/$gameHeight) * 31 + +[TextureRedefine] +width = 54 +height = 30 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 54 +overwriteHeight = ($height/$gameHeight) * 30 + +[TextureRedefine] +width = 53 +height = 29 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 53 +overwriteHeight = ($height/$gameHeight) * 29 + +[TextureRedefine] +width = 52 +height = 29 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 52 +overwriteHeight = ($height/$gameHeight) * 29 + +[TextureRedefine] +width = 51 +height = 28 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 51 +overwriteHeight = ($height/$gameHeight) * 28 + +[TextureRedefine] +width = 50 +height = 28 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 50 +overwriteHeight = ($height/$gameHeight) * 28 + +[TextureRedefine] +width = 49 +height = 27 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 49 +overwriteHeight = ($height/$gameHeight) * 27 + +[TextureRedefine] +width = 48 +height = 27 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 48 +overwriteHeight = ($height/$gameHeight) * 27 + +[TextureRedefine] +width = 47 +height = 26 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 47 +overwriteHeight = ($height/$gameHeight) * 26 + +[TextureRedefine] +width = 46 +height = 26 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 46 +overwriteHeight = ($height/$gameHeight) * 26 + +[TextureRedefine] +width = 46 +height = 25 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 46 +overwriteHeight = ($height/$gameHeight) * 25 + +[TextureRedefine] +width = 45 +height = 25 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 45 +overwriteHeight = ($height/$gameHeight) * 25 + +[TextureRedefine] +width = 44 +height = 25 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 44 +overwriteHeight = ($height/$gameHeight) * 25 + +[TextureRedefine] +width = 44 +height = 24 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 44 +overwriteHeight = ($height/$gameHeight) * 24 + +[TextureRedefine] +width = 43 +height = 24 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 43 +overwriteHeight = ($height/$gameHeight) * 24 + +[TextureRedefine] +width = 42 +height = 23 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 42 +overwriteHeight = ($height/$gameHeight) * 23 + +[TextureRedefine] +width = 41 +height = 23 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 41 +overwriteHeight = ($height/$gameHeight) * 23 + +[TextureRedefine] +width = 32 +height = 32 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 32 +overwriteHeight = ($height/$gameHeight) * 32 + +[TextureRedefine] +width = 32 +height = 16 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 32 +overwriteHeight = ($height/$gameHeight) * 16 + +[TextureRedefine] +width = 31 +height = 18 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 31 +overwriteHeight = ($height/$gameHeight) * 18 + +[TextureRedefine] +width = 24 +height = 16 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 24 +overwriteHeight = ($height/$gameHeight) * 16 + +[TextureRedefine] +width = 20 +height = 11 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 20 +overwriteHeight = ($height/$gameHeight) * 11 + +[TextureRedefine] #Transition fire +width = 17 +height = 11 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 17 +overwriteHeight = ($height/$gameHeight) * 11 + +[TextureRedefine] +width = 16 +height = 16 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 16 +overwriteHeight = ($height/$gameHeight) * 16 + +[TextureRedefine] +width = 15 +height = 9 +formats = 0x816,0x823 +overwriteWidth = ($width/$gameWidth) * 15 +overwriteHeight = ($height/$gameHeight) * 9 + +[TextureRedefine] # circus +width = 1272 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1272 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1264 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1264 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1256 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1256 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1248 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1248 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1240 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1240 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1232 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1232 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1224 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1224 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1216 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1216 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1208 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1208 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1200 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1200 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1192 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1192 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1184 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1184 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1176 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1176 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1168 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1168 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1160 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1160 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1152 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1152 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1144 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1144 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1136 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1136 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1128 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1128 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1120 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1120 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1112 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1112 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1104 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1104 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1096 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1096 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1088 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1088 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1080 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1080 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1072 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1072 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1064 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1064 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1056 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1056 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1048 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1048 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1040 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1040 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1032 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1032 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1024 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1024 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1016 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1016 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1008 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1008 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 1000 +height = 720 +overwriteWidth = ($width/$gameWidth) * 1000 +overwriteHeight = ($height/$gameHeight) * 720 + +[TextureRedefine] # circus +width = 640 +height = 320 +overwriteWidth = ($width/$gameWidth) * 640 +overwriteHeight = ($height/$gameHeight) * 320 + +[TextureRedefine] # circus +width = 636 +height = 360 +overwriteWidth = ($width/$gameWidth) * 636 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 632 +height = 360 +overwriteWidth = ($width/$gameWidth) * 632 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 628 +height = 360 +overwriteWidth = ($width/$gameWidth) * 628 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 624 +height = 360 +overwriteWidth = ($width/$gameWidth) * 624 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 620 +height = 360 +overwriteWidth = ($width/$gameWidth) * 620 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 616 +height = 360 +overwriteWidth = ($width/$gameWidth) * 616 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 612 +height = 360 +overwriteWidth = ($width/$gameWidth) * 612 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 608 +height = 360 +overwriteWidth = ($width/$gameWidth) * 608 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 604 +height = 360 +overwriteWidth = ($width/$gameWidth) * 604 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 600 +height = 360 +overwriteWidth = ($width/$gameWidth) * 600 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 596 +height = 360 +overwriteWidth = ($width/$gameWidth) * 596 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 592 +height = 360 +overwriteWidth = ($width/$gameWidth) * 592 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 588 +height = 360 +overwriteWidth = ($width/$gameWidth) * 588 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 584 +height = 360 +overwriteWidth = ($width/$gameWidth) * 584 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 580 +height = 360 +overwriteWidth = ($width/$gameWidth) * 580 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 576 +height = 360 +overwriteWidth = ($width/$gameWidth) * 576 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 572 +height = 360 +overwriteWidth = ($width/$gameWidth) * 572 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 568 +height = 360 +overwriteWidth = ($width/$gameWidth) * 568 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 564 +height = 360 +overwriteWidth = ($width/$gameWidth) * 564 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 560 +height = 360 +overwriteWidth = ($width/$gameWidth) * 560 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 556 +height = 360 +overwriteWidth = ($width/$gameWidth) * 556 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 552 +height = 360 +overwriteWidth = ($width/$gameWidth) * 552 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 548 +height = 360 +overwriteWidth = ($width/$gameWidth) * 548 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 544 +height = 360 +overwriteWidth = ($width/$gameWidth) * 544 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 540 +height = 360 +overwriteWidth = ($width/$gameWidth) * 540 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 536 +height = 360 +overwriteWidth = ($width/$gameWidth) * 536 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 532 +height = 360 +overwriteWidth = ($width/$gameWidth) * 532 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 528 +height = 360 +overwriteWidth = ($width/$gameWidth) * 528 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 524 +height = 360 +overwriteWidth = ($width/$gameWidth) * 524 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 520 +height = 360 +overwriteWidth = ($width/$gameWidth) * 520 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 516 +height = 360 +overwriteWidth = ($width/$gameWidth) * 516 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 512 +height = 360 +formatsExcluded = 0x034,0x033,0x031 # rain vulkan +overwriteWidth = ($width/$gameWidth) * 512 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 508 +height = 360 +overwriteWidth = ($width/$gameWidth) * 508 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 504 +height = 360 +overwriteWidth = ($width/$gameWidth) * 504 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 500 +height = 360 +overwriteWidth = ($width/$gameWidth) * 500 +overwriteHeight = ($height/$gameHeight) * 360 + +[TextureRedefine] # circus +width = 318 +height = 180 +overwriteWidth = ($width/$gameWidth) * 318 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 316 +height = 180 +overwriteWidth = ($width/$gameWidth) * 316 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 314 +height = 180 +overwriteWidth = ($width/$gameWidth) * 314 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 312 +height = 180 +overwriteWidth = ($width/$gameWidth) * 312 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 310 +height = 180 +overwriteWidth = ($width/$gameWidth) * 310 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 308 +height = 180 +overwriteWidth = ($width/$gameWidth) * 308 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 306 +height = 180 +overwriteWidth = ($width/$gameWidth) * 306 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 304 +height = 180 +overwriteWidth = ($width/$gameWidth) * 304 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 302 +height = 180 +overwriteWidth = ($width/$gameWidth) * 302 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 300 +height = 180 +overwriteWidth = ($width/$gameWidth) * 300 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 298 +height = 180 +overwriteWidth = ($width/$gameWidth) * 298 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 296 +height = 180 +overwriteWidth = ($width/$gameWidth) * 296 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 294 +height = 180 +overwriteWidth = ($width/$gameWidth) * 294 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 292 +height = 180 +overwriteWidth = ($width/$gameWidth) * 292 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 290 +height = 180 +overwriteWidth = ($width/$gameWidth) * 290 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 288 +height = 180 +overwriteWidth = ($width/$gameWidth) * 288 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 286 +height = 180 +formatsExcluded = 0x433 +overwriteWidth = ($width/$gameWidth) * 286 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 284 +height = 180 +overwriteWidth = ($width/$gameWidth) * 284 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 282 +height = 180 +overwriteWidth = ($width/$gameWidth) * 282 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 280 +height = 180 +overwriteWidth = ($width/$gameWidth) * 280 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 278 +height = 180 +overwriteWidth = ($width/$gameWidth) * 278 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 276 +height = 180 +overwriteWidth = ($width/$gameWidth) * 276 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 274 +height = 180 +overwriteWidth = ($width/$gameWidth) * 274 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 272 +height = 180 +overwriteWidth = ($width/$gameWidth) * 272 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 270 +height = 180 +overwriteWidth = ($width/$gameWidth) * 270 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 268 +height = 180 +overwriteWidth = ($width/$gameWidth) * 268 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 266 +height = 180 +formatsExcluded = 0x433 +overwriteWidth = ($width/$gameWidth) * 266 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 264 +height = 180 +overwriteWidth = ($width/$gameWidth) * 264 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 262 +height = 180 +overwriteWidth = ($width/$gameWidth) * 262 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 260 +height = 180 +overwriteWidth = ($width/$gameWidth) * 260 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 258 +height = 180 +overwriteWidth = ($width/$gameWidth) * 258 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 256 +height = 180 +overwriteWidth = ($width/$gameWidth) * 256 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 254 +height = 180 +overwriteWidth = ($width/$gameWidth) * 254 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 252 +height = 180 +overwriteWidth = ($width/$gameWidth) * 252 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 250 +height = 180 +overwriteWidth = ($width/$gameWidth) * 250 +overwriteHeight = ($height/$gameHeight) * 180 + +[TextureRedefine] # circus +width = 160 +height = 90 +overwriteWidth = ($width/$gameWidth) * 160 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 159 +height = 90 +overwriteWidth = ($width/$gameWidth) * 159 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 158 +height = 90 +overwriteWidth = ($width/$gameWidth) * 158 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 157 +height = 90 +overwriteWidth = ($width/$gameWidth) * 157 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 156 +height = 90 +overwriteWidth = ($width/$gameWidth) * 156 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 155 +height = 90 +overwriteWidth = ($width/$gameWidth) * 155 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 154 +height = 90 +overwriteWidth = ($width/$gameWidth) * 154 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 153 +height = 90 +overwriteWidth = ($width/$gameWidth) * 153 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 152 +height = 90 +overwriteWidth = ($width/$gameWidth) * 152 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 151 +height = 90 +overwriteWidth = ($width/$gameWidth) * 151 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 150 +height = 90 +overwriteWidth = ($width/$gameWidth) * 150 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 149 +height = 90 +overwriteWidth = ($width/$gameWidth) * 149 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 148 +height = 90 +overwriteWidth = ($width/$gameWidth) * 148 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 147 +height = 90 +overwriteWidth = ($width/$gameWidth) * 147 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 146 +height = 90 +overwriteWidth = ($width/$gameWidth) * 146 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 145 +height = 90 +overwriteWidth = ($width/$gameWidth) * 145 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 144 +height = 90 +overwriteWidth = ($width/$gameWidth) * 144 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 143 +height = 90 +overwriteWidth = ($width/$gameWidth) * 143 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 142 +height = 90 +overwriteWidth = ($width/$gameWidth) * 142 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 141 +height = 90 +overwriteWidth = ($width/$gameWidth) * 141 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 140 +height = 90 +overwriteWidth = ($width/$gameWidth) * 140 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 139 +height = 90 +overwriteWidth = ($width/$gameWidth) * 139 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 138 +height = 90 +overwriteWidth = ($width/$gameWidth) * 138 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 137 +height = 90 +overwriteWidth = ($width/$gameWidth) * 137 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 136 +height = 90 +overwriteWidth = ($width/$gameWidth) * 136 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 135 +height = 90 +overwriteWidth = ($width/$gameWidth) * 135 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 134 +height = 90 +overwriteWidth = ($width/$gameWidth) * 134 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 133 +height = 90 +overwriteWidth = ($width/$gameWidth) * 133 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 132 +height = 90 +overwriteWidth = ($width/$gameWidth) * 132 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 131 +height = 90 +overwriteWidth = ($width/$gameWidth) * 131 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 130 +height = 90 +overwriteWidth = ($width/$gameWidth) * 130 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 129 +height = 90 +overwriteWidth = ($width/$gameWidth) * 129 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 128 +height = 90 +overwriteWidth = ($width/$gameWidth) * 128 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 127 +height = 90 +overwriteWidth = ($width/$gameWidth) * 127 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 126 +height = 90 +overwriteWidth = ($width/$gameWidth) * 126 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 125 +height = 90 +overwriteWidth = ($width/$gameWidth) * 125 +overwriteHeight = ($height/$gameHeight) * 90 + +[TextureRedefine] # circus +width = 120 +height = 67 +overwriteWidth = ($width/$gameWidth) * 120 +overwriteHeight = ($height/$gameHeight) * 67 + +[TextureRedefine] # circus +width = 80 +height = 45 +overwriteWidth = ($width/$gameWidth) * 80 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 79 +height = 45 +overwriteWidth = ($width/$gameWidth) * 79 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 78 +height = 45 +overwriteWidth = ($width/$gameWidth) * 78 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 77 +height = 45 +overwriteWidth = ($width/$gameWidth) * 77 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 76 +height = 45 +overwriteWidth = ($width/$gameWidth) * 76 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 75 +height = 45 +overwriteWidth = ($width/$gameWidth) * 75 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 74 +height = 45 +overwriteWidth = ($width/$gameWidth) * 74 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 73 +height = 45 +overwriteWidth = ($width/$gameWidth) * 73 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 72 +height = 45 +overwriteWidth = ($width/$gameWidth) * 72 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 71 +height = 45 +overwriteWidth = ($width/$gameWidth) * 71 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 70 +height = 45 +overwriteWidth = ($width/$gameWidth) * 70 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 69 +height = 45 +overwriteWidth = ($width/$gameWidth) * 69 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 68 +height = 45 +overwriteWidth = ($width/$gameWidth) * 68 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 67 +height = 45 +overwriteWidth = ($width/$gameWidth) * 67 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 66 +height = 45 +overwriteWidth = ($width/$gameWidth) * 66 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 65 +height = 45 +overwriteWidth = ($width/$gameWidth) * 65 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 64 +height = 45 +overwriteWidth = ($width/$gameWidth) * 64 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 63 +height = 45 +overwriteWidth = ($width/$gameWidth) * 63 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 62 +height = 45 +overwriteWidth = ($width/$gameWidth) * 62 +overwriteHeight = ($height/$gameHeight) * 45 + +[TextureRedefine] # circus +width = 60 +height = 33 +overwriteWidth = ($width/$gameWidth) * 60 +overwriteHeight = ($height/$gameHeight) * 33 + +## Coopa castle + +[TextureRedefine] +width = 637 +height = 358 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 637 +overwriteHeight = ($height/$gameHeight) * 358 + +[TextureRedefine] +width = 632 +height = 355 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 632 +overwriteHeight = ($height/$gameHeight) * 355 + +[TextureRedefine] +width = 626 +height = 352 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 626 +overwriteHeight = ($height/$gameHeight) * 352 + +[TextureRedefine] +width = 621 +height = 349 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 621 +overwriteHeight = ($height/$gameHeight) * 349 + +[TextureRedefine] +width = 616 +height = 346 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 616 +overwriteHeight = ($height/$gameHeight) * 346 + +[TextureRedefine] +width = 610 +height = 343 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 610 +overwriteHeight = ($height/$gameHeight) * 343 + +[TextureRedefine] +width = 608 +height = 352 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 608 +overwriteHeight = ($height/$gameHeight) * 352 + +[TextureRedefine] +width = 608 +height = 336 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 608 +overwriteHeight = ($height/$gameHeight) * 336 + +[TextureRedefine] +width = 605 +height = 340 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 605 +overwriteHeight = ($height/$gameHeight) * 340 + +[TextureRedefine] +width = 600 +height = 337 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 600 +overwriteHeight = ($height/$gameHeight) * 337 + +[TextureRedefine] +width = 594 +height = 334 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 594 +overwriteHeight = ($height/$gameHeight) * 334 + +[TextureRedefine] +width = 589 +height = 331 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 589 +overwriteHeight = ($height/$gameHeight) * 331 + +[TextureRedefine] +width = 584 +height = 328 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 584 +overwriteHeight = ($height/$gameHeight) * 328 + +[TextureRedefine] +width = 578 +height = 325 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 578 +overwriteHeight = ($height/$gameHeight) * 325 + +[TextureRedefine] +width = 576 +height = 336 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 576 +overwriteHeight = ($height/$gameHeight) * 336 + +[TextureRedefine] +width = 576 +height = 320 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 576 +overwriteHeight = ($height/$gameHeight) * 320 + +[TextureRedefine] +width = 573 +height = 322 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 573 +overwriteHeight = ($height/$gameHeight) * 322 + +[TextureRedefine] +width = 568 +height = 319 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 568 +overwriteHeight = ($height/$gameHeight) * 319 + +[TextureRedefine] +width = 562 +height = 316 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 562 +overwriteHeight = ($height/$gameHeight) * 316 + +[TextureRedefine] +width = 557 +height = 313 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 557 +overwriteHeight = ($height/$gameHeight) * 313 + +[TextureRedefine] +width = 552 +height = 310 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 552 +overwriteHeight = ($height/$gameHeight) * 310 + +[TextureRedefine] +width = 546 +height = 307 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 546 +overwriteHeight = ($height/$gameHeight) * 307 + +[TextureRedefine] +width = 544 +height = 320 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 544 +overwriteHeight = ($height/$gameHeight) * 320 + +[TextureRedefine] +width = 544 +height = 304 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 544 +overwriteHeight = ($height/$gameHeight) * 304 + +[TextureRedefine] +width = 541 +height = 304 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 541 +overwriteHeight = ($height/$gameHeight) * 304 + +[TextureRedefine] +width = 536 +height = 301 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 536 +overwriteHeight = ($height/$gameHeight) * 301 + +[TextureRedefine] +width = 530 +height = 298 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 530 +overwriteHeight = ($height/$gameHeight) * 298 + +[TextureRedefine] +width = 525 +height = 295 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 525 +overwriteHeight = ($height/$gameHeight) * 295 + +[TextureRedefine] +width = 520 +height = 292 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 520 +overwriteHeight = ($height/$gameHeight) * 292 + +[TextureRedefine] +width = 514 +height = 289 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 514 +overwriteHeight = ($height/$gameHeight) * 289 + +[TextureRedefine] +width = 512 +height = 272 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 512 +overwriteHeight = ($height/$gameHeight) * 272 + +[TextureRedefine] +width = 509 +height = 286 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 509 +overwriteHeight = ($height/$gameHeight) * 286 + +[TextureRedefine] +width = 504 +height = 283 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 504 +overwriteHeight = ($height/$gameHeight) * 283 + +[TextureRedefine] +width = 498 +height = 280 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 498 +overwriteHeight = ($height/$gameHeight) * 280 + +[TextureRedefine] +width = 493 +height = 277 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 493 +overwriteHeight = ($height/$gameHeight) * 277 + +[TextureRedefine] +width = 488 +height = 274 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 488 +overwriteHeight = ($height/$gameHeight) * 274 + +[TextureRedefine] +width = 482 +height = 271 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 482 +overwriteHeight = ($height/$gameHeight) * 271 + +[TextureRedefine] +width = 477 +height = 268 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 477 +overwriteHeight = ($height/$gameHeight) * 268 + +[TextureRedefine] +width = 472 +height = 265 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 472 +overwriteHeight = ($height/$gameHeight) * 265 + +[TextureRedefine] +width = 466 +height = 262 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 466 +overwriteHeight = ($height/$gameHeight) * 262 + +[TextureRedefine] +width = 461 +height = 259 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 461 +overwriteHeight = ($height/$gameHeight) * 259 + +[TextureRedefine] +width = 456 +height = 256 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 456 +overwriteHeight = ($height/$gameHeight) * 256 + +[TextureRedefine] +width = 450 +height = 253 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 450 +overwriteHeight = ($height/$gameHeight) * 253 + +[TextureRedefine] +width = 448 +height = 256 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 448 +overwriteHeight = ($height/$gameHeight) * 256 + +[TextureRedefine] +width = 448 +height = 240 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 448 +overwriteHeight = ($height/$gameHeight) * 240 + +[TextureRedefine] +width = 445 +height = 250 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 445 +overwriteHeight = ($height/$gameHeight) * 250 + +[TextureRedefine] +width = 440 +height = 247 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 440 +overwriteHeight = ($height/$gameHeight) * 247 + +[TextureRedefine] +width = 434 +height = 244 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 434 +overwriteHeight = ($height/$gameHeight) * 244 + +[TextureRedefine] +width = 429 +height = 241 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 429 +overwriteHeight = ($height/$gameHeight) * 241 + +[TextureRedefine] +width = 424 +height = 238 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 424 +overwriteHeight = ($height/$gameHeight) * 238 + +[TextureRedefine] +width = 418 +height = 235 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 418 +overwriteHeight = ($height/$gameHeight) * 235 + +[TextureRedefine] +width = 416 +height = 240 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 416 +overwriteHeight = ($height/$gameHeight) * 240 + +[TextureRedefine] +width = 416 +height = 224 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 416 +overwriteHeight = ($height/$gameHeight) * 224 + +[TextureRedefine] +width = 413 +height = 232 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 413 +overwriteHeight = ($height/$gameHeight) * 232 + +[TextureRedefine] +width = 408 +height = 229 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 408 +overwriteHeight = ($height/$gameHeight) * 229 + +[TextureRedefine] +width = 402 +height = 226 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 402 +overwriteHeight = ($height/$gameHeight) * 226 + +[TextureRedefine] +width = 397 +height = 223 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 397 +overwriteHeight = ($height/$gameHeight) * 223 + +[TextureRedefine] +width = 392 +height = 220 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 392 +overwriteHeight = ($height/$gameHeight) * 220 + +[TextureRedefine] +width = 386 +height = 217 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 386 +overwriteHeight = ($height/$gameHeight) * 217 + +[TextureRedefine] +width = 384 +height = 224 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 384 +overwriteHeight = ($height/$gameHeight) * 224 + +[TextureRedefine] +width = 384 +height = 208 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 384 +overwriteHeight = ($height/$gameHeight) * 208 + +[TextureRedefine] +width = 381 +height = 214 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 381 +overwriteHeight = ($height/$gameHeight) * 214 + +[TextureRedefine] +width = 376 +height = 211 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 376 +overwriteHeight = ($height/$gameHeight) * 211 + +[TextureRedefine] +width = 370 +height = 208 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 370 +overwriteHeight = ($height/$gameHeight) * 208 + +[TextureRedefine] +width = 365 +height = 205 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 365 +overwriteHeight = ($height/$gameHeight) * 205 + +[TextureRedefine] +width = 360 +height = 202 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 360 +overwriteHeight = ($height/$gameHeight) * 202 + +[TextureRedefine] +width = 354 +height = 199 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 354 +overwriteHeight = ($height/$gameHeight) * 199 + +[TextureRedefine] +width = 352 +height = 208 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 352 +overwriteHeight = ($height/$gameHeight) * 208 + +[TextureRedefine] +width = 352 +height = 192 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 352 +overwriteHeight = ($height/$gameHeight) * 192 + +[TextureRedefine] +width = 349 +height = 196 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 349 +overwriteHeight = ($height/$gameHeight) * 196 + +[TextureRedefine] +width = 344 +height = 193 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 344 +overwriteHeight = ($height/$gameHeight) * 193 + +[TextureRedefine] +width = 338 +height = 190 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 338 +overwriteHeight = ($height/$gameHeight) * 190 + +[TextureRedefine] +width = 333 +height = 187 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 333 +overwriteHeight = ($height/$gameHeight) * 187 + +[TextureRedefine] +width = 328 +height = 184 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 328 +overwriteHeight = ($height/$gameHeight) * 184 + +[TextureRedefine] +width = 322 +height = 181 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 322 +overwriteHeight = ($height/$gameHeight) * 181 + +[TextureRedefine] +width = 318 +height = 179 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 318 +overwriteHeight = ($height/$gameHeight) * 179 + +[TextureRedefine] +width = 316 +height = 177 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 316 +overwriteHeight = ($height/$gameHeight) * 177 + + +[TextureRedefine] +width = 254 +height = 143 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 254 +overwriteHeight = ($height/$gameHeight) * 143 + +[TextureRedefine] +width = 252 +height = 141 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 252 +overwriteHeight = ($height/$gameHeight) * 141 + +[TextureRedefine] +width = 249 +height = 140 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 249 +overwriteHeight = ($height/$gameHeight) * 140 + +[TextureRedefine] +width = 246 +height = 138 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 246 +overwriteHeight = ($height/$gameHeight) * 138 + +[TextureRedefine] +width = 244 +height = 137 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 244 +overwriteHeight = ($height/$gameHeight) * 137 + +[TextureRedefine] +width = 241 +height = 135 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 241 +overwriteHeight = ($height/$gameHeight) * 135 + +[TextureRedefine] +width = 238 +height = 134 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 238 +overwriteHeight = ($height/$gameHeight) * 134 + +[TextureRedefine] +width = 236 +height = 132 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 236 +overwriteHeight = ($height/$gameHeight) * 132 + +[TextureRedefine] +width = 233 +height = 131 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 233 +overwriteHeight = ($height/$gameHeight) * 131 + +[TextureRedefine] +width = 230 +height = 129 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 230 +overwriteHeight = ($height/$gameHeight) * 129 + +[TextureRedefine] +width = 228 +height = 128 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 228 +overwriteHeight = ($height/$gameHeight) * 128 + +[TextureRedefine] +width = 225 +height = 126 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 225 +overwriteHeight = ($height/$gameHeight) * 126 + +[TextureRedefine] +width = 224 +height = 126 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 224 +overwriteHeight = ($height/$gameHeight) * 126 + +[TextureRedefine] +width = 222 +height = 125 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 222 +overwriteHeight = ($height/$gameHeight) * 125 + +[TextureRedefine] +width = 220 +height = 123 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 220 +overwriteHeight = ($height/$gameHeight) * 123 + +[TextureRedefine] +width = 217 +height = 122 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 217 +overwriteHeight = ($height/$gameHeight) * 122 + +[TextureRedefine] +width = 214 +height = 120 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 214 +overwriteHeight = ($height/$gameHeight) * 120 + +[TextureRedefine] +width = 212 +height = 119 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 212 +overwriteHeight = ($height/$gameHeight) * 119 + +[TextureRedefine] +width = 209 +height = 117 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 209 +overwriteHeight = ($height/$gameHeight) * 117 + +[TextureRedefine] +width = 206 +height = 116 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 206 +overwriteHeight = ($height/$gameHeight) * 116 + +[TextureRedefine] +width = 204 +height = 114 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 204 +overwriteHeight = ($height/$gameHeight) * 114 + +[TextureRedefine] +width = 201 +height = 113 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 201 +overwriteHeight = ($height/$gameHeight) * 113 + +[TextureRedefine] +width = 198 +height = 111 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 198 +overwriteHeight = ($height/$gameHeight) * 111 + +[TextureRedefine] +width = 197 +height = 111 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 197 +overwriteHeight = ($height/$gameHeight) * 111 + +[TextureRedefine] +width = 196 +height = 110 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 196 +overwriteHeight = ($height/$gameHeight) * 110 + +[TextureRedefine] +width = 194 +height = 109 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 194 +overwriteHeight = ($height/$gameHeight) * 109 + +[TextureRedefine] +width = 193 +height = 108 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 193 +overwriteHeight = ($height/$gameHeight) * 108 + +[TextureRedefine] +width = 159 +height = 89 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 159 +overwriteHeight = ($height/$gameHeight) * 89 + +[TextureRedefine] +width = 158 +height = 88 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 158 +overwriteHeight = ($height/$gameHeight) * 88 + +[TextureRedefine] +width = 156 +height = 88 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 156 +overwriteHeight = ($height/$gameHeight) * 88 + +[TextureRedefine] +width = 155 +height = 87 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 155 +overwriteHeight = ($height/$gameHeight) * 87 + +[TextureRedefine] +width = 154 +height = 86 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 154 +overwriteHeight = ($height/$gameHeight) * 86 + +[TextureRedefine] +width = 151 +height = 85 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 151 +overwriteHeight = ($height/$gameHeight) * 85 + +[TextureRedefine] +width = 147 +height = 82 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 147 +overwriteHeight = ($height/$gameHeight) * 82 + +[TextureRedefine] +width = 143 +height = 80 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 143 +overwriteHeight = ($height/$gameHeight) * 80 + +[TextureRedefine] +width = 142 +height = 79 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 142 +overwriteHeight = ($height/$gameHeight) * 79 + +[TextureRedefine] +width = 141 +height = 79 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 141 +overwriteHeight = ($height/$gameHeight) * 79 + +[TextureRedefine] +width = 140 +height = 79 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 140 +overwriteHeight = ($height/$gameHeight) * 79 + +[TextureRedefine] +width = 140 +height = 78 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 140 +overwriteHeight = ($height/$gameHeight) * 78 + +[TextureRedefine] +width = 139 +height = 78 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 139 +overwriteHeight = ($height/$gameHeight) * 78 + +[TextureRedefine] +width = 138 +height = 78 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 138 +overwriteHeight = ($height/$gameHeight) * 78 + +[TextureRedefine] +width = 138 +height = 77 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 138 +overwriteHeight = ($height/$gameHeight) * 77 + +[TextureRedefine] +width = 137 +height = 77 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 137 +overwriteHeight = ($height/$gameHeight) * 77 + +[TextureRedefine] +width = 136 +height = 76 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 136 +overwriteHeight = ($height/$gameHeight) * 76 + +[TextureRedefine] +width = 135 +height = 76 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 135 +overwriteHeight = ($height/$gameHeight) * 76 + +[TextureRedefine] +width = 134 +height = 75 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 134 +overwriteHeight = ($height/$gameHeight) * 75 + +[TextureRedefine] +width = 133 +height = 75 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 133 +overwriteHeight = ($height/$gameHeight) * 75 + +[TextureRedefine] +width = 132 +height = 74 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 132 +overwriteHeight = ($height/$gameHeight) * 74 + +[TextureRedefine] +width = 131 +height = 73 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 131 +overwriteHeight = ($height/$gameHeight) * 73 + +[TextureRedefine] +width = 130 +height = 73 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 130 +overwriteHeight = ($height/$gameHeight) * 73 + +[TextureRedefine] +width = 129 +height = 72 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 129 +overwriteHeight = ($height/$gameHeight) * 72 + +[TextureRedefine] +width = 127 +height = 71 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 127 +overwriteHeight = ($height/$gameHeight) * 71 + +[TextureRedefine] +width = 126 +height = 70 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 126 +overwriteHeight = ($height/$gameHeight) * 70 + +[TextureRedefine] +width = 124 +height = 70 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 124 +overwriteHeight = ($height/$gameHeight) * 70 + +[TextureRedefine] +width = 123 +height = 69 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 123 +overwriteHeight = ($height/$gameHeight) * 69 + +[TextureRedefine] +width = 122 +height = 68 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 122 +overwriteHeight = ($height/$gameHeight) * 68 + +[TextureRedefine] +width = 119 +height = 67 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 119 +overwriteHeight = ($height/$gameHeight) * 67 + +[TextureRedefine] +width = 115 +height = 64 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 115 +overwriteHeight = ($height/$gameHeight) * 64 + +[TextureRedefine] +width = 111 +height = 62 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 111 +overwriteHeight = ($height/$gameHeight) * 62 + +[TextureRedefine] +width = 110 +height = 61 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 110 +overwriteHeight = ($height/$gameHeight) * 61 + +[TextureRedefine] +width = 108 +height = 61 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 108 +overwriteHeight = ($height/$gameHeight) * 61 + +[TextureRedefine] +width = 107 +height = 60 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 107 +overwriteHeight = ($height/$gameHeight) * 60 + +[TextureRedefine] +width = 103 +height = 58 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 103 +overwriteHeight = ($height/$gameHeight) * 58 + +[TextureRedefine] +width = 99 +height = 55 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 99 +overwriteHeight = ($height/$gameHeight) * 55 + +[TextureRedefine] +width = 96 +height = 54 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 96 +overwriteHeight = ($height/$gameHeight) * 54 + +[TextureRedefine] +width = 95 +height = 53 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 95 +overwriteHeight = ($height/$gameHeight) * 53 + +[TextureRedefine] +width = 94 +height = 53 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 94 +overwriteHeight = ($height/$gameHeight) * 53 + +[TextureRedefine] +width = 94 +height = 52 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 94 +overwriteHeight = ($height/$gameHeight) * 52 + +[TextureRedefine] +width = 93 +height = 52 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 93 +overwriteHeight = ($height/$gameHeight) * 52 + +[TextureRedefine] +width = 92 +height = 52 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 92 +overwriteHeight = ($height/$gameHeight) * 52 + +[TextureRedefine] +width = 92 +height = 51 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 92 +overwriteHeight = ($height/$gameHeight) * 51 + +[TextureRedefine] +width = 91 +height = 51 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 91 +overwriteHeight = ($height/$gameHeight) * 51 + +[TextureRedefine] +width = 90 +height = 51 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 90 +overwriteHeight = ($height/$gameHeight) * 51 + +[TextureRedefine] +width = 90 +height = 50 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 90 +overwriteHeight = ($height/$gameHeight) * 50 + +[TextureRedefine] +width = 89 +height = 50 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 89 +overwriteHeight = ($height/$gameHeight) * 50 + +[TextureRedefine] +width = 88 +height = 49 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 88 +overwriteHeight = ($height/$gameHeight) * 49 + +[TextureRedefine] +width = 87 +height = 49 +formats = 0x816,0x035 +overwriteWidth = ($width/$gameWidth) * 87 +overwriteHeight = ($height/$gameHeight) * 49 + +[TextureRedefine] +width = 83 +height = 46 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 83 +overwriteHeight = ($height/$gameHeight) * 46 + +[TextureRedefine] +width = 71 +height = 39 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 71 +overwriteHeight = ($height/$gameHeight) * 39 + +[TextureRedefine] +width = 69 +height = 38 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 69 +overwriteHeight = ($height/$gameHeight) * 38 + +[TextureRedefine] +width = 67 +height = 38 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 67 +overwriteHeight = ($height/$gameHeight) * 38 + +[TextureRedefine] +width = 55 +height = 30 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 55 +overwriteHeight = ($height/$gameHeight) * 30 + +[TextureRedefine] +width = 53 +height = 30 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 53 +overwriteHeight = ($height/$gameHeight) * 30 + +[TextureRedefine] +width = 51 +height = 29 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 51 +overwriteHeight = ($height/$gameHeight) * 29 + +[TextureRedefine] +width = 426 +height = 240 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 426 +overwriteHeight = ($height/$gameHeight) * 240 + +[TextureRedefine] +width = 346 +height = 195 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 346 +overwriteHeight = ($height/$gameHeight) * 195 + +[TextureRedefine] +width = 341 +height = 192 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 341 +overwriteHeight = ($height/$gameHeight) * 192 + +[TextureRedefine] +width = 106 +height = 60 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 106 +overwriteHeight = ($height/$gameHeight) * 60 + +[TextureRedefine] +width = 85 +height = 48 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 85 +overwriteHeight = ($height/$gameHeight) * 48 + +[TextureRedefine] +width = 42 +height = 24 +formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 42 +overwriteHeight = ($height/$gameHeight) * 24 + +##1-5 Switch circus additional res + +[TextureRedefine] +width = 608 +height = 368 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 608 +overwriteHeight = ($height/$gameHeight) * 368 + +[TextureRedefine] +width = 544 +height = 368 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 544 +overwriteHeight = ($height/$gameHeight) * 368 + +[TextureRedefine] +width = 512 +height = 368 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 512 +overwriteHeight = ($height/$gameHeight) * 368 + +[TextureRedefine] +width = 256 +height = 192 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 256 +overwriteHeight = ($height/$gameHeight) * 192 + +[TextureRedefine] #low res reflection depth +width = 256 +height = 240 +#formats = 0x816,0x80e +overwriteWidth = ($width/$gameWidth) * 256 +overwriteHeight = ($height/$gameHeight) * 240 + +[TextureRedefine] #low res reflection shader 810,19,a01 +width = 240 +height = 240 +#formats = 0x816,0x80e +overwriteWidth = ($width/$gameWidth) * 240 +overwriteHeight = ($height/$gameHeight) * 240 + +[TextureRedefine] +width = 128 +height = 96 +#formats = 0x816 +overwriteWidth = ($width/$gameWidth) * 128 +overwriteHeight = ($height/$gameHeight) * 96 diff --git a/src/SuperMario3DWorld/Mods/NoHUD/b84517cef3bb49ad_000000000000007d_ps.txt b/src/SuperMario3DWorld/Mods/NoHUD/b84517cef3bb49ad_000000000000007d_ps.txt new file mode 100644 index 00000000..f6feac4e --- /dev/null +++ b/src/SuperMario3DWorld/Mods/NoHUD/b84517cef3bb49ad_000000000000007d_ps.txt @@ -0,0 +1,114 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_separate_shader_objects : enable +// shader b84517cef3bb49ad +// 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 = 1) uniform ufBlock +{ +uniform ivec4 uf_remappedPS[4]; +uniform vec4 uf_fragCoordScale; +}; +#else +uniform ivec4 uf_remappedPS[4]; +uniform vec2 uf_fragCoordScale; +#endif +TEXTURE_LAYOUT(0, 1, 0) uniform sampler2DArray textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 0) out vec4 passPixelColor0; +// end of shader inputs/outputs +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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R126i = ivec4(0); +ivec4 R127i = ivec4(0); +int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i; +ivec4 PV0i = ivec4(0), PV1i = ivec4(0); +int PS0i = 0, PS1i = 0; +ivec4 tempi = ivec4(0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = floatBitsToInt(passParameterSem0); +R1i = floatBitsToInt(passParameterSem1); +// 0 +backupReg0i = R1i.z; +R2i.x = ((intBitsToFloat(R0i.w) > 0.0)?int(0xFFFFFFFF):int(0x0)); +R1i.z = floatBitsToInt(roundEven(intBitsToFloat(backupReg0i))); +R1i.w = floatBitsToInt(texture(textureUnitPS0, vec3(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(R1i.z))).w); +// 0 +PV0i.x = R1i.w; +PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * 2.0); +PV0i.y = ((intBitsToFloat(0x3f0a3d71) > intBitsToFloat(R1i.w))?int(0xFFFFFFFF):int(0x0)); +PV0i.w = floatBitsToInt(intBitsToFloat(R1i.w) + -(0.5)); +PV0i.w = floatBitsToInt(intBitsToFloat(PV0i.w) * 2.0); +// 1 +R127i.y = ((PV0i.y == 0)?(0x3f800000):(PV0i.x)); +R127i.z = ((PV0i.y == 0)?(PV0i.w):(0)); +PV1i.z = R127i.z; +// 2 +R123i.z = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(uf_remappedPS[0].y) + intBitsToFloat(uf_remappedPS[1].y))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(uf_remappedPS[0].x) + intBitsToFloat(uf_remappedPS[1].x))); +PV0i.w = R123i.w; +// 3 +backupReg0i = R0i.x; +PV1i.x = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(uf_remappedPS[0].w)); +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedPS[0].z) + intBitsToFloat(uf_remappedPS[1].z))); +PV1i.y = R123i.y; +R126i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(R0i.y) * intBitsToFloat(PV0i.z)); +// 4 +R127i.x = floatBitsToInt(intBitsToFloat(R0i.z) * intBitsToFloat(PV1i.y)); +R126i.y = floatBitsToInt(intBitsToFloat(R0i.w) * intBitsToFloat(PV1i.x)); +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedPS[2].y) + intBitsToFloat(uf_remappedPS[3].y))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedPS[2].x) + intBitsToFloat(uf_remappedPS[3].x))); +PV0i.w = R123i.w; +// 5 +backupReg0i = R0i.x; +PV1i.x = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(uf_remappedPS[2].w)); +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedPS[2].z) + intBitsToFloat(uf_remappedPS[3].z))); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.w)); +PV1i.w = floatBitsToInt(intBitsToFloat(R0i.y) * intBitsToFloat(PV0i.z)); +// 6 +backupReg0i = R0i.z; +PV0i.x = floatBitsToInt(-(intBitsToFloat(R0i.w)) * intBitsToFloat(PV1i.x)); +R0i.y = ((R2i.x == 0)?(PV1i.w):(R127i.w)); +PV0i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.y)); +R0i.x = ((R2i.x == 0)?(PV1i.z):(R126i.z)); +PS0i = R0i.x; +// 7 +R0i.z = ((R2i.x == 0)?(PV0i.z):(R127i.x)); +R0i.w = ((R2i.x == 0)?(PV0i.x):(R126i.y)); +// export +passPixelColor0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), 0.); +} diff --git a/src/SuperMario3DWorld/Mods/NoHUD/d9953dbd7354b119_000000000000007d_ps.txt b/src/SuperMario3DWorld/Mods/NoHUD/d9953dbd7354b119_000000000000007d_ps.txt new file mode 100644 index 00000000..42015e5f --- /dev/null +++ b/src/SuperMario3DWorld/Mods/NoHUD/d9953dbd7354b119_000000000000007d_ps.txt @@ -0,0 +1,105 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_separate_shader_objects : enable +// shader d9953dbd7354b119 +// 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 = 1) uniform ufBlock +{ +uniform ivec4 uf_remappedPS[4]; +uniform vec4 uf_fragCoordScale; +}; +#else +uniform ivec4 uf_remappedPS[4]; +uniform vec2 uf_fragCoordScale; +#endif +TEXTURE_LAYOUT(0, 1, 0) uniform sampler2DArray textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 0) out vec4 passPixelColor0; +// end of shader inputs/outputs +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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R126i = ivec4(0); +ivec4 R127i = ivec4(0); +int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i; +ivec4 PV0i = ivec4(0), PV1i = ivec4(0); +int PS0i = 0, PS1i = 0; +ivec4 tempi = ivec4(0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = floatBitsToInt(passParameterSem0); +R1i = floatBitsToInt(passParameterSem1); +// 0 +backupReg0i = R1i.z; +R2i.x = floatBitsToInt(intBitsToFloat(uf_remappedPS[0].y) + intBitsToFloat(uf_remappedPS[1].y)); +R2i.y = ((intBitsToFloat(R0i.w) > 0.0)?int(0xFFFFFFFF):int(0x0)); +R1i.z = floatBitsToInt(roundEven(intBitsToFloat(backupReg0i))); +R2i.w = floatBitsToInt(intBitsToFloat(uf_remappedPS[0].x) + intBitsToFloat(uf_remappedPS[1].x)); +R1i.w = floatBitsToInt(texture(textureUnitPS0, vec3(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(R1i.z))).w); +// 0 +backupReg0i = R0i.y; +R127i.x = floatBitsToInt(intBitsToFloat(R0i.x) * intBitsToFloat(R2i.w)); +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedPS[0].z) + intBitsToFloat(uf_remappedPS[1].z)); +PV0i.z = floatBitsToInt(intBitsToFloat(R1i.w) + -(0.5)); +PV0i.z = floatBitsToInt(intBitsToFloat(PV0i.z) * 2.0); +PV0i.w = ((intBitsToFloat(0x3f0a3d71) > intBitsToFloat(R1i.w))?int(0xFFFFFFFF):int(0x0)); +R126i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(R2i.x)); +PS0i = R126i.w; +// 1 +R126i.x = floatBitsToInt(intBitsToFloat(R0i.z) * intBitsToFloat(PV0i.y)); +R123i.y = ((PV0i.w == 0)?(PV0i.z):(0)); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedPS[2].y) + intBitsToFloat(uf_remappedPS[3].y)); +PV1i.w = floatBitsToInt(intBitsToFloat(uf_remappedPS[2].x) + intBitsToFloat(uf_remappedPS[3].x)); +// 2 +backupReg0i = R0i.x; +backupReg1i = R0i.y; +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedPS[3].w)); +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedPS[1].w)); +PV0i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(backupReg1i) * intBitsToFloat(PV1i.z)); +// 3 +PV1i.x = floatBitsToInt(intBitsToFloat(R0i.w) * intBitsToFloat(PV0i.y)); +PV1i.y = floatBitsToInt(intBitsToFloat(uf_remappedPS[2].z) + intBitsToFloat(uf_remappedPS[3].z)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R0i.w)) * intBitsToFloat(PV0i.x)); +R1i.x = ((R2i.y == 0)?(PV0i.z):(R127i.x)); +PS1i = R1i.x; +// 4 +backupReg0i = R0i.z; +R1i.y = ((R2i.y == 0)?(R127i.w):(R126i.w)); +PV0i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.y)); +R1i.w = ((R2i.y == 0)?(PV1i.z):(PV1i.x)); +// 5 +R1i.z = ((R2i.y == 0)?(PV0i.z):(R126i.x)); +// export +passPixelColor0 = vec4(intBitsToFloat(R1i.x), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), 0.); +} diff --git a/src/SuperMario3DWorld/Mods/NoHUD/d9f064ae204238df_000000000000007d_ps.txt b/src/SuperMario3DWorld/Mods/NoHUD/d9f064ae204238df_000000000000007d_ps.txt new file mode 100644 index 00000000..04afa9d2 --- /dev/null +++ b/src/SuperMario3DWorld/Mods/NoHUD/d9f064ae204238df_000000000000007d_ps.txt @@ -0,0 +1,103 @@ +#version 450 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_separate_shader_objects : enable +// shader d9f064ae204238df +// 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 = 1) uniform ufBlock +{ +uniform ivec4 uf_remappedPS[4]; +uniform vec4 uf_fragCoordScale; +}; +#else +uniform ivec4 uf_remappedPS[4]; +uniform vec2 uf_fragCoordScale; +#endif +TEXTURE_LAYOUT(0, 1, 0) uniform sampler2DArray textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 0) out vec4 passPixelColor0; +// end of shader inputs/outputs +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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R127i = ivec4(0); +int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i; +ivec4 PV0i = ivec4(0), PV1i = ivec4(0); +int PS0i = 0, PS1i = 0; +ivec4 tempi = ivec4(0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = floatBitsToInt(passParameterSem0); +R1i = floatBitsToInt(passParameterSem1); +// 0 +backupReg0i = R1i.z; +R2i.x = ((intBitsToFloat(R0i.w) > 0.0)?int(0xFFFFFFFF):int(0x0)); +R1i.z = floatBitsToInt(roundEven(intBitsToFloat(backupReg0i))); +R1i.xyzw = floatBitsToInt(texture(textureUnitPS0, vec3(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(R1i.z))).xyzw); +// 0 +R123i.z = floatBitsToInt((intBitsToFloat(R1i.y) * intBitsToFloat(uf_remappedPS[0].y) + intBitsToFloat(uf_remappedPS[1].y))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R1i.x) * intBitsToFloat(uf_remappedPS[0].x) + intBitsToFloat(uf_remappedPS[1].x))); +PV0i.w = R123i.w; +// 1 +backupReg0i = R0i.x; +PV1i.x = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(uf_remappedPS[0].w)); +R123i.y = floatBitsToInt((intBitsToFloat(R1i.z) * intBitsToFloat(uf_remappedPS[0].z) + intBitsToFloat(uf_remappedPS[1].z))); +PV1i.y = R123i.y; +R127i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(R0i.y) * intBitsToFloat(PV0i.z)); +// 2 +R127i.x = floatBitsToInt(intBitsToFloat(R0i.z) * intBitsToFloat(PV1i.y)); +R127i.y = floatBitsToInt(intBitsToFloat(R0i.w) * intBitsToFloat(PV1i.x)); +R123i.z = floatBitsToInt((intBitsToFloat(R1i.y) * intBitsToFloat(uf_remappedPS[2].y) + intBitsToFloat(uf_remappedPS[3].y))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R1i.x) * intBitsToFloat(uf_remappedPS[2].x) + intBitsToFloat(uf_remappedPS[3].x))); +PV0i.w = R123i.w; +// 3 +backupReg0i = R0i.x; +PV1i.x = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(uf_remappedPS[2].w)); +R123i.y = floatBitsToInt((intBitsToFloat(R1i.z) * intBitsToFloat(uf_remappedPS[2].z) + intBitsToFloat(uf_remappedPS[3].z))); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.w)); +PV1i.w = floatBitsToInt(intBitsToFloat(R0i.y) * intBitsToFloat(PV0i.z)); +// 4 +backupReg0i = R0i.z; +PV0i.x = floatBitsToInt(-(intBitsToFloat(R0i.w)) * intBitsToFloat(PV1i.x)); +R0i.y = ((R2i.x == 0)?(PV1i.w):(R127i.w)); +PV0i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.y)); +R0i.x = ((R2i.x == 0)?(PV1i.z):(R127i.z)); +PS0i = R0i.x; +// 5 +R0i.z = ((R2i.x == 0)?(PV0i.z):(R127i.x)); +R0i.w = ((R2i.x == 0)?(PV0i.x):(R127i.y)); +// export +passPixelColor0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), 0.); +} diff --git a/src/SuperMario3DWorld/Mods/NoHUD/rules.txt b/src/SuperMario3DWorld/Mods/NoHUD/rules.txt new file mode 100644 index 00000000..76a2a600 --- /dev/null +++ b/src/SuperMario3DWorld/Mods/NoHUD/rules.txt @@ -0,0 +1,7 @@ +[Definition] +titleIds = 0005000010145D00,0005000010145C00,0005000010106100 +name = Remove All HUD Elements +path = "Super Mario 3D World/Mods/No HUD (breaks menus)" +description = Disable most of the UI while playing.|Use it only for screenshots as it breaks some menus.|Made by @etra0. +#Credits: @etra0 +version = 6