diff --git a/Enthusiast/SuperMario3DWorld_2880p/0457fe3efc9a772f_0000000000000079_ps.txt b/Enthusiast/CaptainToadTreasureTracker_2880p/0457fe3efc9a772f_0000000000000079_ps.txt similarity index 94% rename from Enthusiast/SuperMario3DWorld_2880p/0457fe3efc9a772f_0000000000000079_ps.txt rename to Enthusiast/CaptainToadTreasureTracker_2880p/0457fe3efc9a772f_0000000000000079_ps.txt index fa5d4c1e..ecbdb758 100644 --- a/Enthusiast/SuperMario3DWorld_2880p/0457fe3efc9a772f_0000000000000079_ps.txt +++ b/Enthusiast/CaptainToadTreasureTracker_2880p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -1,7 +1,7 @@ #version 420 #extension GL_ARB_texture_gather : enable // shader 0457fe3efc9a772f -// Used for: Horizontal Blur (Captain Toad Treasure Tracker) +// Used for: Horizontal Bloom const float blurFactor = 1.0; //Higher is less blur // Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ diff --git a/Enthusiast/SuperMario3DWorld_5760p/9fad3b3505a6d831_0000000000000079_ps.txt b/Enthusiast/CaptainToadTreasureTracker_2880p/9fad3b3505a6d831_0000000000000079_ps.txt similarity index 94% rename from Enthusiast/SuperMario3DWorld_5760p/9fad3b3505a6d831_0000000000000079_ps.txt rename to Enthusiast/CaptainToadTreasureTracker_2880p/9fad3b3505a6d831_0000000000000079_ps.txt index 106a8a74..1ca34191 100644 --- a/Enthusiast/SuperMario3DWorld_5760p/9fad3b3505a6d831_0000000000000079_ps.txt +++ b/Enthusiast/CaptainToadTreasureTracker_2880p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -1,7 +1,7 @@ #version 420 #extension GL_ARB_texture_gather : enable // shader 9fad3b3505a6d831 -// Used for: Vertical Blur (Captain Toad Treasure Tracker) +// Used for: Vertical Bloom const float blurFactor = 1.0; //Higher is less blur // Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ diff --git a/Enthusiast/CaptainToadTreasureTracker_2880p/rules.txt b/Enthusiast/CaptainToadTreasureTracker_2880p/rules.txt new file mode 100644 index 00000000..993f82c4 --- /dev/null +++ b/Enthusiast/CaptainToadTreasureTracker_2880p/rules.txt @@ -0,0 +1,99 @@ +[Definition] +titleIds = 0005000010180600,0005000010180700,0005000010180500 +name = "Captain Toad Treasure Tracker - 5120x2880" +version = 2 + +[TextureRedefine] # tv +width = 1280 +height = 720 +formatsExcluded = 0x008,0x41A,0x034,0x035 # exclude obvious textures +overwriteWidth = 5120 +overwriteHeight = 2880 + +[TextureRedefine] # zoomed in +width = 1128 +height = 720 +overwriteWidth = 5120 +overwriteHeight = 2880 + +[TextureRedefine] # zoom transition +width = 1000 +height = 600 +overwriteWidth = 5120 +overwriteHeight = 2880 + +[TextureRedefine] # zoom transition 2 +width = 1000 +height = 720 +overwriteWidth = 5120 +overwriteHeight = 2880 + +[TextureRedefine] # half-res alpha +width = 640 +height = 360 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # half-res (zoomed in) +width = 564 +height = 360 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # half-res (zoom transition) +width = 500 +height = 300 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # half-res (zoom transition 2) +width = 500 +height = 360 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # quarter-res alpha +width = 320 +height = 180 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # q-res (zoomed in) +width = 282 +height = 180 +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # q-res (zoom transition) +width = 250 +height = 150 +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # q-res (zoom transition 2) +width = 250 +height = 180 +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # gamepad +width = 854 +height = 480 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # half-res (gamepad) +width = 427 +height = 240 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # q-res (gamepad) +width = 214 +height = 120 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 640 +overwriteHeight = 360 \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_5760p/0457fe3efc9a772f_0000000000000079_ps.txt b/Enthusiast/CaptainToadTreasureTracker_4320p/0457fe3efc9a772f_0000000000000079_ps.txt similarity index 94% rename from Enthusiast/SuperMario3DWorld_5760p/0457fe3efc9a772f_0000000000000079_ps.txt rename to Enthusiast/CaptainToadTreasureTracker_4320p/0457fe3efc9a772f_0000000000000079_ps.txt index fa5d4c1e..ecbdb758 100644 --- a/Enthusiast/SuperMario3DWorld_5760p/0457fe3efc9a772f_0000000000000079_ps.txt +++ b/Enthusiast/CaptainToadTreasureTracker_4320p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -1,7 +1,7 @@ #version 420 #extension GL_ARB_texture_gather : enable // shader 0457fe3efc9a772f -// Used for: Horizontal Blur (Captain Toad Treasure Tracker) +// Used for: Horizontal Bloom const float blurFactor = 1.0; //Higher is less blur // Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ diff --git a/Enthusiast/SuperMario3DWorld_2880p/9fad3b3505a6d831_0000000000000079_ps.txt b/Enthusiast/CaptainToadTreasureTracker_4320p/9fad3b3505a6d831_0000000000000079_ps.txt similarity index 94% rename from Enthusiast/SuperMario3DWorld_2880p/9fad3b3505a6d831_0000000000000079_ps.txt rename to Enthusiast/CaptainToadTreasureTracker_4320p/9fad3b3505a6d831_0000000000000079_ps.txt index 106a8a74..1ca34191 100644 --- a/Enthusiast/SuperMario3DWorld_2880p/9fad3b3505a6d831_0000000000000079_ps.txt +++ b/Enthusiast/CaptainToadTreasureTracker_4320p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -1,7 +1,7 @@ #version 420 #extension GL_ARB_texture_gather : enable // shader 9fad3b3505a6d831 -// Used for: Vertical Blur (Captain Toad Treasure Tracker) +// Used for: Vertical Bloom const float blurFactor = 1.0; //Higher is less blur // Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ diff --git a/Enthusiast/CaptainToadTreasureTracker_4320p/rules.txt b/Enthusiast/CaptainToadTreasureTracker_4320p/rules.txt new file mode 100644 index 00000000..3c4c7d4a --- /dev/null +++ b/Enthusiast/CaptainToadTreasureTracker_4320p/rules.txt @@ -0,0 +1,99 @@ +[Definition] +titleIds = 0005000010180600,0005000010180700,0005000010180500 +name = "Captain Toad Treasure Tracker - 7680x4320" +version = 2 + +[TextureRedefine] # tv +width = 1280 +height = 720 +formatsExcluded = 0x008,0x41A,0x034,0x035 # exclude obvious textures +overwriteWidth = 7680 +overwriteHeight = 4320 + +[TextureRedefine] # zoomed in +width = 1128 +height = 720 +overwriteWidth = 7680 +overwriteHeight = 4320 + +[TextureRedefine] # zoom transition +width = 1000 +height = 600 +overwriteWidth = 7680 +overwriteHeight = 4320 + +[TextureRedefine] # zoom transition 2 +width = 1000 +height = 720 +overwriteWidth = 7680 +overwriteHeight = 4320 + +[TextureRedefine] # half-res alpha +width = 640 +height = 360 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 3840 +overwriteHeight = 2160 + +[TextureRedefine] # half-res (zoomed in) +width = 564 +height = 360 +overwriteWidth = 3840 +overwriteHeight = 2160 + +[TextureRedefine] # half-res (zoom transition) +width = 500 +height = 300 +overwriteWidth = 3840 +overwriteHeight = 2160 + +[TextureRedefine] # half-res (zoom transition 2) +width = 500 +height = 360 +overwriteWidth = 3840 +overwriteHeight = 2160 + +[TextureRedefine] # quarter-res alpha +width = 320 +height = 180 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # q-res (zoomed in) +width = 282 +height = 180 +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # q-res (zoom transition) +width = 250 +height = 150 +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # q-res (zoom transition 2) +width = 250 +height = 180 +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # gamepad +width = 854 +height = 480 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # half-res (gamepad) +width = 427 +height = 240 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # q-res (gamepad) +width = 214 +height = 120 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 640 +overwriteHeight = 360 \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_4320p/0457fe3efc9a772f_0000000000000079_ps.txt b/Enthusiast/CaptainToadTreasureTracker_5760p/0457fe3efc9a772f_0000000000000079_ps.txt similarity index 94% rename from Enthusiast/SuperMario3DWorld_4320p/0457fe3efc9a772f_0000000000000079_ps.txt rename to Enthusiast/CaptainToadTreasureTracker_5760p/0457fe3efc9a772f_0000000000000079_ps.txt index fa5d4c1e..ecbdb758 100644 --- a/Enthusiast/SuperMario3DWorld_4320p/0457fe3efc9a772f_0000000000000079_ps.txt +++ b/Enthusiast/CaptainToadTreasureTracker_5760p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -1,7 +1,7 @@ #version 420 #extension GL_ARB_texture_gather : enable // shader 0457fe3efc9a772f -// Used for: Horizontal Blur (Captain Toad Treasure Tracker) +// Used for: Horizontal Bloom const float blurFactor = 1.0; //Higher is less blur // Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ diff --git a/Quality/SuperMario3DWorld_1080p/9fad3b3505a6d831_0000000000000079_ps.txt b/Enthusiast/CaptainToadTreasureTracker_5760p/9fad3b3505a6d831_0000000000000079_ps.txt similarity index 94% rename from Quality/SuperMario3DWorld_1080p/9fad3b3505a6d831_0000000000000079_ps.txt rename to Enthusiast/CaptainToadTreasureTracker_5760p/9fad3b3505a6d831_0000000000000079_ps.txt index 106a8a74..1ca34191 100644 --- a/Quality/SuperMario3DWorld_1080p/9fad3b3505a6d831_0000000000000079_ps.txt +++ b/Enthusiast/CaptainToadTreasureTracker_5760p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -1,7 +1,7 @@ #version 420 #extension GL_ARB_texture_gather : enable // shader 9fad3b3505a6d831 -// Used for: Vertical Blur (Captain Toad Treasure Tracker) +// Used for: Vertical Bloom const float blurFactor = 1.0; //Higher is less blur // Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ diff --git a/Enthusiast/CaptainToadTreasureTracker_5760p/rules.txt b/Enthusiast/CaptainToadTreasureTracker_5760p/rules.txt new file mode 100644 index 00000000..9b06ad55 --- /dev/null +++ b/Enthusiast/CaptainToadTreasureTracker_5760p/rules.txt @@ -0,0 +1,99 @@ +[Definition] +titleIds = 0005000010180600,0005000010180700,0005000010180500 +name = "Captain Toad Treasure Tracker - 10240x5760" +version = 2 + +[TextureRedefine] # tv +width = 1280 +height = 720 +formatsExcluded = 0x008,0x41A,0x034,0x035 # exclude obvious textures +overwriteWidth = 10240 +overwriteHeight = 5760 + +[TextureRedefine] # zoomed in +width = 1128 +height = 720 +overwriteWidth = 10240 +overwriteHeight = 5760 + +[TextureRedefine] # zoom transition +width = 1000 +height = 600 +overwriteWidth = 10240 +overwriteHeight = 5760 + +[TextureRedefine] # zoom transition 2 +width = 1000 +height = 720 +overwriteWidth = 10240 +overwriteHeight = 5760 + +[TextureRedefine] # half-res alpha +width = 640 +height = 360 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 5120 +overwriteHeight = 2880 + +[TextureRedefine] # half-res (zoomed in) +width = 564 +height = 360 +overwriteWidth = 5120 +overwriteHeight = 2880 + +[TextureRedefine] # half-res (zoom transition) +width = 500 +height = 300 +overwriteWidth = 5120 +overwriteHeight = 2880 + +[TextureRedefine] # half-res (zoom transition 2) +width = 500 +height = 360 +overwriteWidth = 5120 +overwriteHeight = 2880 + +[TextureRedefine] # quarter-res alpha +width = 320 +height = 180 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # q-res (zoomed in) +width = 282 +height = 180 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # q-res (zoom transition) +width = 250 +height = 150 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # q-res (zoom transition 2) +width = 250 +height = 180 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # gamepad +width = 854 +height = 480 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # half-res (gamepad) +width = 427 +height = 240 +formatsExcluded = 0x41A # exclude obvious textures1 +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # q-res (gamepad) +width = 214 +height = 120 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 640 +overwriteHeight = 360 \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_2880p/4102408f48cb6b94_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_2880p/4102408f48cb6b94_0000000000000079_ps.txt new file mode 100644 index 00000000..3a08ba7e --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_2880p/4102408f48cb6b94_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4102408f48cb6b94 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_2880p/46575655811a12b7_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_2880p/46575655811a12b7_0000000000000079_ps.txt new file mode 100644 index 00000000..535e6fc5 --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_2880p/46575655811a12b7_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 46575655811a12b7 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Weights and Offsets calculated with BlurNinja with these arguments: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_2880p/74b3539704b05bfd_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_2880p/74b3539704b05bfd_0000000000000079_ps.txt new file mode 100644 index 00000000..63adcd52 --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_2880p/74b3539704b05bfd_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 74b3539704b05bfd +// Used for: Horizontal Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 3 --reduce 3 13 --linear +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_2880p/f5190dd4ae552353_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_2880p/f5190dd4ae552353_0000000000000079_ps.txt new file mode 100644 index 00000000..341223d9 --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_2880p/f5190dd4ae552353_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader f5190dd4ae552353 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_2880p/rules.txt b/Enthusiast/SuperMario3DWorld_2880p/rules.txt index 42027a76..abc92145 100644 --- a/Enthusiast/SuperMario3DWorld_2880p/rules.txt +++ b/Enthusiast/SuperMario3DWorld_2880p/rules.txt @@ -1,6 +1,6 @@ [Definition] -titleIds = 0005000010145d00,0005000010145c00,0005000010106100,0005000010180600,0005000010180700,0005000010180500 -name = "Super Mario 3D World + Captain Toad: Treasure Tracker - 5120x2880" +titleIds = 0005000010145d00,0005000010145c00,0005000010106100 +name = "Super Mario 3D World - 5120x2880" version = 2 [TextureRedefine] # tv diff --git a/Enthusiast/SuperMario3DWorld_4320p/4102408f48cb6b94_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_4320p/4102408f48cb6b94_0000000000000079_ps.txt new file mode 100644 index 00000000..3a08ba7e --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_4320p/4102408f48cb6b94_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4102408f48cb6b94 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_4320p/46575655811a12b7_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_4320p/46575655811a12b7_0000000000000079_ps.txt new file mode 100644 index 00000000..535e6fc5 --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_4320p/46575655811a12b7_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 46575655811a12b7 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Weights and Offsets calculated with BlurNinja with these arguments: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_4320p/74b3539704b05bfd_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_4320p/74b3539704b05bfd_0000000000000079_ps.txt new file mode 100644 index 00000000..63adcd52 --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_4320p/74b3539704b05bfd_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 74b3539704b05bfd +// Used for: Horizontal Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 3 --reduce 3 13 --linear +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_4320p/f5190dd4ae552353_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_4320p/f5190dd4ae552353_0000000000000079_ps.txt new file mode 100644 index 00000000..341223d9 --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_4320p/f5190dd4ae552353_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader f5190dd4ae552353 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_4320p/rules.txt b/Enthusiast/SuperMario3DWorld_4320p/rules.txt index 3fb8152d..9c136df3 100644 --- a/Enthusiast/SuperMario3DWorld_4320p/rules.txt +++ b/Enthusiast/SuperMario3DWorld_4320p/rules.txt @@ -1,6 +1,6 @@ [Definition] -titleIds = 0005000010145d00,0005000010145c00,0005000010106100,0005000010180600,0005000010180700,0005000010180500 -name = "Super Mario 3D World + Captain Toad: Treasure Tracker - 7680x4320" +titleIds = 0005000010145d00,0005000010145c00,0005000010106100 +name = "Super Mario 3D World - 7680x4320" version = 2 [TextureRedefine] # tv diff --git a/Enthusiast/SuperMario3DWorld_5760p/4102408f48cb6b94_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_5760p/4102408f48cb6b94_0000000000000079_ps.txt new file mode 100644 index 00000000..3a08ba7e --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_5760p/4102408f48cb6b94_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4102408f48cb6b94 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_5760p/46575655811a12b7_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_5760p/46575655811a12b7_0000000000000079_ps.txt new file mode 100644 index 00000000..535e6fc5 --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_5760p/46575655811a12b7_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 46575655811a12b7 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Weights and Offsets calculated with BlurNinja with these arguments: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_5760p/74b3539704b05bfd_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_5760p/74b3539704b05bfd_0000000000000079_ps.txt new file mode 100644 index 00000000..63adcd52 --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_5760p/74b3539704b05bfd_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 74b3539704b05bfd +// Used for: Horizontal Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 3 --reduce 3 13 --linear +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_5760p/f5190dd4ae552353_0000000000000079_ps.txt b/Enthusiast/SuperMario3DWorld_5760p/f5190dd4ae552353_0000000000000079_ps.txt new file mode 100644 index 00000000..341223d9 --- /dev/null +++ b/Enthusiast/SuperMario3DWorld_5760p/f5190dd4ae552353_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader f5190dd4ae552353 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/SuperMario3DWorld_5760p/rules.txt b/Enthusiast/SuperMario3DWorld_5760p/rules.txt index ebe21928..0848a1b9 100644 --- a/Enthusiast/SuperMario3DWorld_5760p/rules.txt +++ b/Enthusiast/SuperMario3DWorld_5760p/rules.txt @@ -1,6 +1,6 @@ [Definition] -titleIds = 0005000010145d00,0005000010145c00,0005000010106100,0005000010180600,0005000010180700,0005000010180500 -name = "Super Mario 3D World + Captain Toad: Treasure Tracker - 10240x5760" +titleIds = 0005000010145d00,0005000010145c00,0005000010106100 +name = "Super Mario 3D World - 10240x5760" version = 2 [TextureRedefine] # tv diff --git a/Performance/SuperMario3DWorld_360p/rules.txt b/Performance/SuperMario3DWorld_360p/rules.txt index cb016dd7..62e15128 100644 --- a/Performance/SuperMario3DWorld_360p/rules.txt +++ b/Performance/SuperMario3DWorld_360p/rules.txt @@ -1,6 +1,6 @@ [Definition] -titleIds = 0005000010145d00,0005000010145c00,0005000010106100,0005000010180600,0005000010180700,0005000010180500 -name = "Super Mario 3D World + Captain Toad: Treasure Tracker - 640x360" +titleIds = 0005000010145d00,0005000010145c00,0005000010106100 +name = "Super Mario 3D World - 640x360" version = 2 [TextureRedefine] # tv diff --git a/Performance/SuperMario3DWorld_540p/rules.txt b/Performance/SuperMario3DWorld_540p/rules.txt index 801fcf44..f1c1f96b 100644 --- a/Performance/SuperMario3DWorld_540p/rules.txt +++ b/Performance/SuperMario3DWorld_540p/rules.txt @@ -1,6 +1,6 @@ [Definition] -titleIds = 0005000010145d00,0005000010145c00,0005000010106100,0005000010180600,0005000010180700,0005000010180500 -name = "Super Mario 3D World + Captain Toad: Treasure Tracker - 960x540" +titleIds = 0005000010145d00,0005000010145c00,0005000010106100 +name = "Super Mario 3D World - 960x540" version = 2 [TextureRedefine] # tv diff --git a/Quality/SuperMario3DWorld_1080p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/CaptainToadTreasureTracker_1080p/0457fe3efc9a772f_0000000000000079_ps.txt similarity index 94% rename from Quality/SuperMario3DWorld_1080p/0457fe3efc9a772f_0000000000000079_ps.txt rename to Quality/CaptainToadTreasureTracker_1080p/0457fe3efc9a772f_0000000000000079_ps.txt index fa5d4c1e..ecbdb758 100644 --- a/Quality/SuperMario3DWorld_1080p/0457fe3efc9a772f_0000000000000079_ps.txt +++ b/Quality/CaptainToadTreasureTracker_1080p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -1,7 +1,7 @@ #version 420 #extension GL_ARB_texture_gather : enable // shader 0457fe3efc9a772f -// Used for: Horizontal Blur (Captain Toad Treasure Tracker) +// Used for: Horizontal Bloom const float blurFactor = 1.0; //Higher is less blur // Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ diff --git a/Enthusiast/SuperMario3DWorld_4320p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/CaptainToadTreasureTracker_1080p/9fad3b3505a6d831_0000000000000079_ps.txt similarity index 94% rename from Enthusiast/SuperMario3DWorld_4320p/9fad3b3505a6d831_0000000000000079_ps.txt rename to Quality/CaptainToadTreasureTracker_1080p/9fad3b3505a6d831_0000000000000079_ps.txt index 106a8a74..1ca34191 100644 --- a/Enthusiast/SuperMario3DWorld_4320p/9fad3b3505a6d831_0000000000000079_ps.txt +++ b/Quality/CaptainToadTreasureTracker_1080p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -1,7 +1,7 @@ #version 420 #extension GL_ARB_texture_gather : enable // shader 9fad3b3505a6d831 -// Used for: Vertical Blur (Captain Toad Treasure Tracker) +// Used for: Vertical Bloom const float blurFactor = 1.0; //Higher is less blur // Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ diff --git a/Quality/CaptainToadTreasureTracker_1080p/rules.txt b/Quality/CaptainToadTreasureTracker_1080p/rules.txt new file mode 100644 index 00000000..3ad9e7d7 --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1080p/rules.txt @@ -0,0 +1,86 @@ +[Definition] +titleIds = 0005000010180600,0005000010180700,0005000010180500 +name = "Captain Toad Treasure Tracker - 1920x1080" +version = 2 + +[TextureRedefine] # tv +width = 1280 +height = 720 +formatsExcluded = 0x008,0x41A,0x034,0x035 # exclude obvious textures +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # zoomed in +width = 1128 +height = 720 +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # zoom transition +width = 1000 +height = 600 +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # zoom transition 2 +width = 1000 +height = 720 +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # half-res alpha +width = 640 +height = 360 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 960 +overwriteHeight = 540 + +[TextureRedefine] # half-res (zoomed in) +width = 564 +height = 360 +overwriteWidth = 960 +overwriteHeight = 540 + +[TextureRedefine] # half-res (zoom transition) +width = 500 +height = 300 +overwriteWidth = 960 +overwriteHeight = 540 + +[TextureRedefine] # half-res (zoom transition 2) +width = 500 +height = 360 +overwriteWidth = 960 +overwriteHeight = 540 + +[TextureRedefine] # quarter-res alpha +width = 320 +height = 180 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 480 +overwriteHeight = 270 + +[TextureRedefine] # q-res (zoomed in) +width = 282 +height = 180 +overwriteWidth = 480 +overwriteHeight = 270 + +[TextureRedefine] # q-res (zoom transition) +width = 250 +height = 150 +overwriteWidth = 480 +overwriteHeight = 270 + +[TextureRedefine] # q-res (zoom transition 2) +width = 250 +height = 180 +overwriteWidth = 480 +overwriteHeight = 270 + +[TextureRedefine] # gamepad + +width = 854 +height = 480 +#overwriteWidth = 1920 +#overwriteHeight = 1080 \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/CaptainToadTreasureTracker_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..ecbdb758 --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Horizontal Bloom +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/CaptainToadTreasureTracker_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..1ca34191 --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Vertical Bloom +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_1080pUW/patches.txt b/Quality/CaptainToadTreasureTracker_1080pUW/patches.txt new file mode 100644 index 00000000..0c8d99ff --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1080pUW/patches.txt @@ -0,0 +1,34 @@ +[RedCarpetAspectUW] +moduleMatches = 0xBBAF1908, 0xD2308838, 0xEB70C731 +# rodata constants +0x10363ED4 = .float 2.370 +0x1036A688 = .float 2.370 +_aspectAddr = 0x10363ED4 + +# Aspect calculation +0x0241D9B4 = lis r8, _aspectAddr@ha +0x0241D9B8 = lfs f0, _aspectAddr@l(r8) + +[KinopioAspectUW] +moduleMatches = 0x43781F76, 0xC64B0A12, 0xD80AD9B4 +#rodata constants +0x100A0EE0 = .float 2.370 +0x100BE2EC = .float 2.370 +0x100D79B4 = .float 2.370 +_aspectAddr = 0x100A0EE0 + +#Aspect Calculation +0x02368158 = lis r31, _aspectAddr@ha +0x0236815c = lfs f13, _aspectAddr@l(r31) + +[KinopioAspectUWv16] +moduleMatches = 0x9E0461E7, 0x1B377483, 0x0576A725 +#rodata constants +0x0100A2D38 = .float 2.370 +0x0100C0164 = .float 2.370 +0x0100D982C = .float 2.370 +_aspectAddr = 0x0100A2D38 + +#Aspect Calculation +0x02373530 = lis r31, _aspectAddr@ha +0x02373534 = lfs f13, _aspectAddr@l(r31) diff --git a/Quality/CaptainToadTreasureTracker_1080pUW/rules.txt b/Quality/CaptainToadTreasureTracker_1080pUW/rules.txt new file mode 100644 index 00000000..76e0f53f --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1080pUW/rules.txt @@ -0,0 +1,79 @@ +[Definition] +titleIds = 0005000010180600,0005000010180700,0005000010180500 +name = "Captain Toad Treasure Tracker - 2560x1080 (21:9)" +version = 2 + +[TextureRedefine] # tv +width = 1280 +height = 720 +formatsExcluded = 0x008,0x41A,0x034,0x035 # exclude obvious textures +overwriteWidth = 2560 +overwriteHeight = 1080 + +[TextureRedefine] # zoomed in +width = 1128 +height = 720 +overwriteWidth = 2560 +overwriteHeight = 1080 + +[TextureRedefine] # zoom transition +width = 1000 +height = 600 +overwriteWidth = 2560 +overwriteHeight = 1080 + +[TextureRedefine] # zoom transition 2 +width = 1000 +height = 720 +overwriteWidth = 2560 +overwriteHeight = 1080 + +[TextureRedefine] # half-res alpha +width = 640 +height = 360 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 1280 +overwriteHeight = 540 + +[TextureRedefine] # half-res (zoomed in) +width = 564 +height = 360 +overwriteWidth = 1280 +overwriteHeight = 540 + +[TextureRedefine] # half-res (zoom transition) +width = 500 +height = 300 +overwriteWidth = 1280 +overwriteHeight = 540 + +[TextureRedefine] # half-res (zoom transition 2) +width = 500 +height = 360 +overwriteWidth = 1280 +overwriteHeight = 540 + +[TextureRedefine] # quarter-res alpha +width = 320 +height = 180 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 640 +overwriteHeight = 270 + +[TextureRedefine] # q-res (zoomed in) +width = 282 +height = 180 +overwriteWidth = 640 +overwriteHeight = 270 + +[TextureRedefine] # q-res (zoom transition) +width = 250 +height = 150 +overwriteWidth = 640 +overwriteHeight = 270 + +[TextureRedefine] # q-res (zoom transition 2) +width = 250 +height = 180 +overwriteWidth = 640 +overwriteHeight = 270 \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_1440p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/CaptainToadTreasureTracker_1440p/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..ecbdb758 --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1440p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Horizontal Bloom +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_1440p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/CaptainToadTreasureTracker_1440p/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..1ca34191 --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1440p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Vertical Bloom +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_1440p/rules.txt b/Quality/CaptainToadTreasureTracker_1440p/rules.txt new file mode 100644 index 00000000..3f48e261 --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1440p/rules.txt @@ -0,0 +1,86 @@ +[Definition] +titleIds = 0005000010180600,0005000010180700,0005000010180500 +name = "Captain Toad Treasure Tracker - 2560x1440" +version = 2 + +[TextureRedefine] # tv +width = 1280 +height = 720 +formatsExcluded = 0x008,0x41A,0x034,0x035 # exclude obvious textures +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # zoomed in +width = 1128 +height = 720 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # zoom transition +width = 1000 +height = 600 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # zoom transition 2 +width = 1000 +height = 720 +overwriteWidth = 2560 +overwriteHeight = 1440 + +[TextureRedefine] # half-res alpha +width = 640 +height = 360 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # half-res (zoomed in) +width = 564 +height = 360 +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # half-res (zoom transition) +width = 500 +height = 300 +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # half-res (zoom transition 2) +width = 500 +height = 360 +overwriteWidth = 1280 +overwriteHeight = 720 + +[TextureRedefine] # quarter-res alpha +width = 320 +height = 180 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 640 +overwriteHeight = 360 + +[TextureRedefine] # q-res (zoomed in) +width = 282 +height = 180 +overwriteWidth = 640 +overwriteHeight = 360 + +[TextureRedefine] # q-res (zoom transition) +width = 250 +height = 150 +overwriteWidth = 640 +overwriteHeight = 360 + +[TextureRedefine] # q-res (zoom transition 2) +width = 250 +height = 180 +overwriteWidth = 640 +overwriteHeight = 360 + +[TextureRedefine] # gamepad + +width = 854 +height = 480 +#overwriteWidth = 1920 +#overwriteHeight = 1080 \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_1800p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/CaptainToadTreasureTracker_1800p/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..ecbdb758 --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1800p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Horizontal Bloom +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_1800p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/CaptainToadTreasureTracker_1800p/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..1ca34191 --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1800p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Vertical Bloom +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_1800p/rules.txt b/Quality/CaptainToadTreasureTracker_1800p/rules.txt new file mode 100644 index 00000000..0228884f --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_1800p/rules.txt @@ -0,0 +1,86 @@ +[Definition] +titleIds = 0005000010180600,0005000010180700,0005000010180500 +name = "Captain Toad Treasure Tracker - 3200x1800" +version = 2 + +[TextureRedefine] # tv +width = 1280 +height = 720 +formatsExcluded = 0x008,0x41A,0x034,0x035 # exclude obvious textures +overwriteWidth = 3200 +overwriteHeight = 1800 + +[TextureRedefine] # zoomed in +width = 1128 +height = 720 +overwriteWidth = 3200 +overwriteHeight = 1800 + +[TextureRedefine] # zoom transition +width = 1000 +height = 600 +overwriteWidth = 3200 +overwriteHeight = 1800 + +[TextureRedefine] # zoom transition 2 +width = 1000 +height = 720 +overwriteWidth = 3200 +overwriteHeight = 1800 + +[TextureRedefine] # half-res alpha +width = 640 +height = 360 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 1600 +overwriteHeight = 900 + +[TextureRedefine] # half-res (zoomed in) +width = 564 +height = 360 +overwriteWidth = 1600 +overwriteHeight = 900 + +[TextureRedefine] # half-res (zoom transition) +width = 500 +height = 300 +overwriteWidth = 1600 +overwriteHeight = 900 + +[TextureRedefine] # half-res (zoom transition 2) +width = 500 +height = 360 +overwriteWidth = 1600 +overwriteHeight = 900 + +[TextureRedefine] # quarter-res alpha +width = 320 +height = 180 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 800 +overwriteHeight = 450 + +[TextureRedefine] # q-res (zoomed in) +width = 282 +height = 180 +overwriteWidth = 800 +overwriteHeight = 450 + +[TextureRedefine] # q-res (zoom transition) +width = 250 +height = 150 +overwriteWidth = 800 +overwriteHeight = 450 + +[TextureRedefine] # q-res (zoom transition 2) +width = 250 +height = 180 +overwriteWidth = 800 +overwriteHeight = 450 + +[TextureRedefine] # gamepad + +width = 854 +height = 480 +#overwriteWidth = 1920 +#overwriteHeight = 1080 diff --git a/Quality/CaptainToadTreasureTracker_2160p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/CaptainToadTreasureTracker_2160p/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..ecbdb758 --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_2160p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Horizontal Bloom +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_2160p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/CaptainToadTreasureTracker_2160p/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..1ca34191 --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_2160p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Vertical Bloom +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/CaptainToadTreasureTracker_2160p/rules.txt b/Quality/CaptainToadTreasureTracker_2160p/rules.txt new file mode 100644 index 00000000..457e1cba --- /dev/null +++ b/Quality/CaptainToadTreasureTracker_2160p/rules.txt @@ -0,0 +1,86 @@ +[Definition] +titleIds = 0005000010180600,0005000010180700,0005000010180500 +name = "Captain Toad Treasure Tracker - 3840x2160" +version = 2 + +[TextureRedefine] # tv +width = 1280 +height = 720 +formatsExcluded = 0x008,0x41A,0x034,0x035 # exclude obvious textures +overwriteWidth = 3840 +overwriteHeight = 2160 + +[TextureRedefine] # zoomed in +width = 1128 +height = 720 +overwriteWidth = 3840 +overwriteHeight = 2160 + +[TextureRedefine] # zoom transition +width = 1000 +height = 600 +overwriteWidth = 3840 +overwriteHeight = 2160 + +[TextureRedefine] # zoom transition 2 +width = 1000 +height = 720 +overwriteWidth = 3840 +overwriteHeight = 2160 + +[TextureRedefine] # half-res alpha +width = 640 +height = 360 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # half-res (zoomed in) +width = 564 +height = 360 +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # half-res (zoom transition) +width = 500 +height = 300 +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # half-res (zoom transition 2) +width = 500 +height = 360 +overwriteWidth = 1920 +overwriteHeight = 1080 + +[TextureRedefine] # quarter-res alpha +width = 320 +height = 180 +formatsExcluded = 0x41A # exclude obvious textures +overwriteWidth = 960 +overwriteHeight = 540 + +[TextureRedefine] # q-res (zoomed in) +width = 282 +height = 180 +overwriteWidth = 960 +overwriteHeight = 540 + +[TextureRedefine] # q-res (zoom transition) +width = 250 +height = 150 +overwriteWidth = 960 +overwriteHeight = 540 + +[TextureRedefine] # q-res (zoom transition 2) +width = 250 +height = 180 +overwriteWidth = 960 +overwriteHeight = 540 + +[TextureRedefine] # gamepad + +width = 854 +height = 480 +#overwriteWidth = 1920 +#overwriteHeight = 1080 \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080p/4102408f48cb6b94_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1080p/4102408f48cb6b94_0000000000000079_ps.txt new file mode 100644 index 00000000..3a08ba7e --- /dev/null +++ b/Quality/SuperMario3DWorld_1080p/4102408f48cb6b94_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4102408f48cb6b94 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080p/46575655811a12b7_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1080p/46575655811a12b7_0000000000000079_ps.txt new file mode 100644 index 00000000..535e6fc5 --- /dev/null +++ b/Quality/SuperMario3DWorld_1080p/46575655811a12b7_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 46575655811a12b7 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Weights and Offsets calculated with BlurNinja with these arguments: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080p/74b3539704b05bfd_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1080p/74b3539704b05bfd_0000000000000079_ps.txt new file mode 100644 index 00000000..63adcd52 --- /dev/null +++ b/Quality/SuperMario3DWorld_1080p/74b3539704b05bfd_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 74b3539704b05bfd +// Used for: Horizontal Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 3 --reduce 3 13 --linear +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080p/f5190dd4ae552353_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1080p/f5190dd4ae552353_0000000000000079_ps.txt new file mode 100644 index 00000000..341223d9 --- /dev/null +++ b/Quality/SuperMario3DWorld_1080p/f5190dd4ae552353_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader f5190dd4ae552353 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080p/rules.txt b/Quality/SuperMario3DWorld_1080p/rules.txt index 1d829b00..6006bd12 100644 --- a/Quality/SuperMario3DWorld_1080p/rules.txt +++ b/Quality/SuperMario3DWorld_1080p/rules.txt @@ -1,6 +1,6 @@ [Definition] -titleIds = 0005000010145d00,0005000010145c00,0005000010106100,0005000010180600,0005000010180700,0005000010180500 -name = "Super Mario 3D World + Captain Toad: Treasure Tracker - 1920x1080" +titleIds = 0005000010145d00,0005000010145c00,0005000010106100 +name = "Super Mario 3D World - 1920x1080" version = 2 [TextureRedefine] # tv diff --git a/Quality/SuperMario3DWorld_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt deleted file mode 100644 index fa5d4c1e..00000000 --- a/Quality/SuperMario3DWorld_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt +++ /dev/null @@ -1,27 +0,0 @@ -#version 420 -#extension GL_ARB_texture_gather : enable -// shader 0457fe3efc9a772f -// Used for: Horizontal Blur (Captain Toad Treasure Tracker) -const float blurFactor = 1.0; //Higher is less blur - -// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ -layout(binding = 0) uniform sampler2D textureUnitPS0; -layout(location = 0) in vec4 passParameterSem0; -layout(location = 0) out vec4 passPixelColor0; - -uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); -uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); - -ivec2 inputRes = textureSize(textureUnitPS0, 0); -vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); -vec2 scale = outputRes * blurFactor; -void main() -{ - vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); - vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; - for (int i = 1; i<4; i++) { - R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; - R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; - } - passPixelColor0 = R1f; -} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080pUW/4102408f48cb6b94_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1080pUW/4102408f48cb6b94_0000000000000079_ps.txt new file mode 100644 index 00000000..3a08ba7e --- /dev/null +++ b/Quality/SuperMario3DWorld_1080pUW/4102408f48cb6b94_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4102408f48cb6b94 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080pUW/46575655811a12b7_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1080pUW/46575655811a12b7_0000000000000079_ps.txt new file mode 100644 index 00000000..535e6fc5 --- /dev/null +++ b/Quality/SuperMario3DWorld_1080pUW/46575655811a12b7_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 46575655811a12b7 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Weights and Offsets calculated with BlurNinja with these arguments: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080pUW/74b3539704b05bfd_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1080pUW/74b3539704b05bfd_0000000000000079_ps.txt new file mode 100644 index 00000000..63adcd52 --- /dev/null +++ b/Quality/SuperMario3DWorld_1080pUW/74b3539704b05bfd_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 74b3539704b05bfd +// Used for: Horizontal Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 3 --reduce 3 13 --linear +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt deleted file mode 100644 index 106a8a74..00000000 --- a/Quality/SuperMario3DWorld_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt +++ /dev/null @@ -1,27 +0,0 @@ -#version 420 -#extension GL_ARB_texture_gather : enable -// shader 9fad3b3505a6d831 -// Used for: Vertical Blur (Captain Toad Treasure Tracker) -const float blurFactor = 1.0; //Higher is less blur - -// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ -layout(binding = 0) uniform sampler2D textureUnitPS0; -layout(location = 0) in vec4 passParameterSem0; -layout(location = 0) out vec4 passPixelColor0; - -uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); -uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); - -ivec2 inputRes = textureSize(textureUnitPS0, 0); -vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); -vec2 scale = outputRes * blurFactor; -void main() -{ - vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); - vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; - for (int i = 1; i<4; i++) { - R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; - R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; - } - passPixelColor0 = R1f; -} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080pUW/f5190dd4ae552353_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1080pUW/f5190dd4ae552353_0000000000000079_ps.txt new file mode 100644 index 00000000..341223d9 --- /dev/null +++ b/Quality/SuperMario3DWorld_1080pUW/f5190dd4ae552353_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader f5190dd4ae552353 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1080pUW/rules.txt b/Quality/SuperMario3DWorld_1080pUW/rules.txt index acf4899b..59841802 100644 --- a/Quality/SuperMario3DWorld_1080pUW/rules.txt +++ b/Quality/SuperMario3DWorld_1080pUW/rules.txt @@ -1,6 +1,6 @@ [Definition] -titleIds = 0005000010145d00,0005000010145c00,0005000010106100,0005000010180600,0005000010180700,0005000010180500 -name = "Super Mario 3D World + Captain Toad: Treasure Tracker - 2560x1080 (21:9)" +titleIds = 0005000010145d00,0005000010145c00,0005000010106100 +name = "Super Mario 3D World - 2560x1080 (21:9)" version = 2 [TextureRedefine] # tv diff --git a/Quality/SuperMario3DWorld_1440p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1440p/0457fe3efc9a772f_0000000000000079_ps.txt deleted file mode 100644 index fa5d4c1e..00000000 --- a/Quality/SuperMario3DWorld_1440p/0457fe3efc9a772f_0000000000000079_ps.txt +++ /dev/null @@ -1,27 +0,0 @@ -#version 420 -#extension GL_ARB_texture_gather : enable -// shader 0457fe3efc9a772f -// Used for: Horizontal Blur (Captain Toad Treasure Tracker) -const float blurFactor = 1.0; //Higher is less blur - -// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ -layout(binding = 0) uniform sampler2D textureUnitPS0; -layout(location = 0) in vec4 passParameterSem0; -layout(location = 0) out vec4 passPixelColor0; - -uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); -uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); - -ivec2 inputRes = textureSize(textureUnitPS0, 0); -vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); -vec2 scale = outputRes * blurFactor; -void main() -{ - vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); - vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; - for (int i = 1; i<4; i++) { - R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; - R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; - } - passPixelColor0 = R1f; -} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1440p/4102408f48cb6b94_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1440p/4102408f48cb6b94_0000000000000079_ps.txt new file mode 100644 index 00000000..3a08ba7e --- /dev/null +++ b/Quality/SuperMario3DWorld_1440p/4102408f48cb6b94_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4102408f48cb6b94 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1440p/46575655811a12b7_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1440p/46575655811a12b7_0000000000000079_ps.txt new file mode 100644 index 00000000..535e6fc5 --- /dev/null +++ b/Quality/SuperMario3DWorld_1440p/46575655811a12b7_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 46575655811a12b7 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Weights and Offsets calculated with BlurNinja with these arguments: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1440p/74b3539704b05bfd_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1440p/74b3539704b05bfd_0000000000000079_ps.txt new file mode 100644 index 00000000..63adcd52 --- /dev/null +++ b/Quality/SuperMario3DWorld_1440p/74b3539704b05bfd_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 74b3539704b05bfd +// Used for: Horizontal Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 3 --reduce 3 13 --linear +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1440p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1440p/9fad3b3505a6d831_0000000000000079_ps.txt deleted file mode 100644 index 106a8a74..00000000 --- a/Quality/SuperMario3DWorld_1440p/9fad3b3505a6d831_0000000000000079_ps.txt +++ /dev/null @@ -1,27 +0,0 @@ -#version 420 -#extension GL_ARB_texture_gather : enable -// shader 9fad3b3505a6d831 -// Used for: Vertical Blur (Captain Toad Treasure Tracker) -const float blurFactor = 1.0; //Higher is less blur - -// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ -layout(binding = 0) uniform sampler2D textureUnitPS0; -layout(location = 0) in vec4 passParameterSem0; -layout(location = 0) out vec4 passPixelColor0; - -uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); -uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); - -ivec2 inputRes = textureSize(textureUnitPS0, 0); -vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); -vec2 scale = outputRes * blurFactor; -void main() -{ - vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); - vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; - for (int i = 1; i<4; i++) { - R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; - R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; - } - passPixelColor0 = R1f; -} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1440p/f5190dd4ae552353_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1440p/f5190dd4ae552353_0000000000000079_ps.txt new file mode 100644 index 00000000..341223d9 --- /dev/null +++ b/Quality/SuperMario3DWorld_1440p/f5190dd4ae552353_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader f5190dd4ae552353 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1440p/rules.txt b/Quality/SuperMario3DWorld_1440p/rules.txt index 1ed312f4..a1c90e74 100644 --- a/Quality/SuperMario3DWorld_1440p/rules.txt +++ b/Quality/SuperMario3DWorld_1440p/rules.txt @@ -1,6 +1,6 @@ [Definition] -titleIds = 0005000010145d00,0005000010145c00,0005000010106100,0005000010180600,0005000010180700,0005000010180500 -name = "Super Mario 3D World + Captain Toad: Treasure Tracker - 2560x1440" +titleIds = 0005000010145d00,0005000010145c00,0005000010106100 +name = "Super Mario 3D World - 2560x1440" version = 2 [TextureRedefine] # tv diff --git a/Quality/SuperMario3DWorld_1800p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1800p/0457fe3efc9a772f_0000000000000079_ps.txt deleted file mode 100644 index fa5d4c1e..00000000 --- a/Quality/SuperMario3DWorld_1800p/0457fe3efc9a772f_0000000000000079_ps.txt +++ /dev/null @@ -1,27 +0,0 @@ -#version 420 -#extension GL_ARB_texture_gather : enable -// shader 0457fe3efc9a772f -// Used for: Horizontal Blur (Captain Toad Treasure Tracker) -const float blurFactor = 1.0; //Higher is less blur - -// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ -layout(binding = 0) uniform sampler2D textureUnitPS0; -layout(location = 0) in vec4 passParameterSem0; -layout(location = 0) out vec4 passPixelColor0; - -uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); -uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); - -ivec2 inputRes = textureSize(textureUnitPS0, 0); -vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); -vec2 scale = outputRes * blurFactor; -void main() -{ - vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); - vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; - for (int i = 1; i<4; i++) { - R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; - R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; - } - passPixelColor0 = R1f; -} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1800p/4102408f48cb6b94_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1800p/4102408f48cb6b94_0000000000000079_ps.txt new file mode 100644 index 00000000..3a08ba7e --- /dev/null +++ b/Quality/SuperMario3DWorld_1800p/4102408f48cb6b94_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4102408f48cb6b94 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1800p/46575655811a12b7_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1800p/46575655811a12b7_0000000000000079_ps.txt new file mode 100644 index 00000000..535e6fc5 --- /dev/null +++ b/Quality/SuperMario3DWorld_1800p/46575655811a12b7_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 46575655811a12b7 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Weights and Offsets calculated with BlurNinja with these arguments: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1800p/74b3539704b05bfd_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1800p/74b3539704b05bfd_0000000000000079_ps.txt new file mode 100644 index 00000000..63adcd52 --- /dev/null +++ b/Quality/SuperMario3DWorld_1800p/74b3539704b05bfd_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 74b3539704b05bfd +// Used for: Horizontal Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 3 --reduce 3 13 --linear +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1800p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1800p/9fad3b3505a6d831_0000000000000079_ps.txt deleted file mode 100644 index 106a8a74..00000000 --- a/Quality/SuperMario3DWorld_1800p/9fad3b3505a6d831_0000000000000079_ps.txt +++ /dev/null @@ -1,27 +0,0 @@ -#version 420 -#extension GL_ARB_texture_gather : enable -// shader 9fad3b3505a6d831 -// Used for: Vertical Blur (Captain Toad Treasure Tracker) -const float blurFactor = 1.0; //Higher is less blur - -// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ -layout(binding = 0) uniform sampler2D textureUnitPS0; -layout(location = 0) in vec4 passParameterSem0; -layout(location = 0) out vec4 passPixelColor0; - -uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); -uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); - -ivec2 inputRes = textureSize(textureUnitPS0, 0); -vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); -vec2 scale = outputRes * blurFactor; -void main() -{ - vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); - vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; - for (int i = 1; i<4; i++) { - R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; - R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; - } - passPixelColor0 = R1f; -} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1800p/f5190dd4ae552353_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_1800p/f5190dd4ae552353_0000000000000079_ps.txt new file mode 100644 index 00000000..341223d9 --- /dev/null +++ b/Quality/SuperMario3DWorld_1800p/f5190dd4ae552353_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader f5190dd4ae552353 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_1800p/rules.txt b/Quality/SuperMario3DWorld_1800p/rules.txt index e5a5e821..9649ab6b 100644 --- a/Quality/SuperMario3DWorld_1800p/rules.txt +++ b/Quality/SuperMario3DWorld_1800p/rules.txt @@ -1,6 +1,6 @@ [Definition] -titleIds = 0005000010145d00,0005000010145c00,0005000010106100,0005000010180600,0005000010180700,0005000010180500 -name = "Super Mario 3D World + Captain Toad: Treasure Tracker - 3200x1800" +titleIds = 0005000010145d00,0005000010145c00,0005000010106100 +name = "Super Mario 3D World - 3200x1800" version = 2 [TextureRedefine] # tv diff --git a/Quality/SuperMario3DWorld_2160p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_2160p/0457fe3efc9a772f_0000000000000079_ps.txt deleted file mode 100644 index fa5d4c1e..00000000 --- a/Quality/SuperMario3DWorld_2160p/0457fe3efc9a772f_0000000000000079_ps.txt +++ /dev/null @@ -1,27 +0,0 @@ -#version 420 -#extension GL_ARB_texture_gather : enable -// shader 0457fe3efc9a772f -// Used for: Horizontal Blur (Captain Toad Treasure Tracker) -const float blurFactor = 1.0; //Higher is less blur - -// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ -layout(binding = 0) uniform sampler2D textureUnitPS0; -layout(location = 0) in vec4 passParameterSem0; -layout(location = 0) out vec4 passPixelColor0; - -uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); -uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); - -ivec2 inputRes = textureSize(textureUnitPS0, 0); -vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); -vec2 scale = outputRes * blurFactor; -void main() -{ - vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); - vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; - for (int i = 1; i<4; i++) { - R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; - R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; - } - passPixelColor0 = R1f; -} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_2160p/4102408f48cb6b94_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_2160p/4102408f48cb6b94_0000000000000079_ps.txt new file mode 100644 index 00000000..3a08ba7e --- /dev/null +++ b/Quality/SuperMario3DWorld_2160p/4102408f48cb6b94_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4102408f48cb6b94 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_2160p/46575655811a12b7_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_2160p/46575655811a12b7_0000000000000079_ps.txt new file mode 100644 index 00000000..535e6fc5 --- /dev/null +++ b/Quality/SuperMario3DWorld_2160p/46575655811a12b7_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 46575655811a12b7 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Weights and Offsets calculated with BlurNinja with these arguments: --expand 4 --reduce 4 17 --linear +uniform float weight[] = float[](0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767); +uniform float offset[] = float[](0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_2160p/74b3539704b05bfd_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_2160p/74b3539704b05bfd_0000000000000079_ps.txt new file mode 100644 index 00000000..63adcd52 --- /dev/null +++ b/Quality/SuperMario3DWorld_2160p/74b3539704b05bfd_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 74b3539704b05bfd +// Used for: Horizontal Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +// Calculated with BlurNinja with as parameters: --expand 3 --reduce 3 13 --linear +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_2160p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_2160p/9fad3b3505a6d831_0000000000000079_ps.txt deleted file mode 100644 index 106a8a74..00000000 --- a/Quality/SuperMario3DWorld_2160p/9fad3b3505a6d831_0000000000000079_ps.txt +++ /dev/null @@ -1,27 +0,0 @@ -#version 420 -#extension GL_ARB_texture_gather : enable -// shader 9fad3b3505a6d831 -// Used for: Vertical Blur (Captain Toad Treasure Tracker) -const float blurFactor = 1.0; //Higher is less blur - -// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ -layout(binding = 0) uniform sampler2D textureUnitPS0; -layout(location = 0) in vec4 passParameterSem0; -layout(location = 0) out vec4 passPixelColor0; - -uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); -uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); - -ivec2 inputRes = textureSize(textureUnitPS0, 0); -vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); -vec2 scale = outputRes * blurFactor; -void main() -{ - vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); - vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; - for (int i = 1; i<4; i++) { - R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; - R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; - } - passPixelColor0 = R1f; -} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_2160p/f5190dd4ae552353_0000000000000079_ps.txt b/Quality/SuperMario3DWorld_2160p/f5190dd4ae552353_0000000000000079_ps.txt new file mode 100644 index 00000000..341223d9 --- /dev/null +++ b/Quality/SuperMario3DWorld_2160p/f5190dd4ae552353_0000000000000079_ps.txt @@ -0,0 +1,27 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader f5190dd4ae552353 +// Used for: Vertical Blur 1 +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/SuperMario3DWorld_2160p/rules.txt b/Quality/SuperMario3DWorld_2160p/rules.txt index f871f4b8..cf9d5ab4 100644 --- a/Quality/SuperMario3DWorld_2160p/rules.txt +++ b/Quality/SuperMario3DWorld_2160p/rules.txt @@ -1,6 +1,6 @@ [Definition] -titleIds = 0005000010145d00,0005000010145c00,0005000010106100,0005000010180600,0005000010180700,0005000010180500 -name = "Super Mario 3D World + Captain Toad: Treasure Tracker - 3840x2160" +titleIds = 0005000010145d00,0005000010145c00,0005000010106100 +name = "Super Mario 3D World - 3840x2160" version = 2 [TextureRedefine] # tv