From 908ab8acdcb91e4779e72038ac69d514eb128642 Mon Sep 17 00:00:00 2001 From: Crementif Date: Mon, 9 Oct 2017 21:26:07 +0200 Subject: [PATCH] Splitted SM3DW and CTTT. Added partial DoF and Bloom fix. Splitted Super Mario 3D World and Captain Toad: Treasure Tracker as both are getting their own shaders. Both are partial due to mips which are hard to scale and due to the rarity of some of the bloom shaders (only in the latest world. Might fix them later but they're awfully long and weird) --- .../0457fe3efc9a772f_0000000000000079_ps.txt | 2 +- .../9fad3b3505a6d831_0000000000000079_ps.txt | 2 +- .../rules.txt | 99 +++++++++++++++++++ .../0457fe3efc9a772f_0000000000000079_ps.txt | 2 +- .../9fad3b3505a6d831_0000000000000079_ps.txt | 2 +- .../rules.txt | 99 +++++++++++++++++++ .../0457fe3efc9a772f_0000000000000079_ps.txt | 2 +- .../9fad3b3505a6d831_0000000000000079_ps.txt | 2 +- .../rules.txt | 99 +++++++++++++++++++ .../4102408f48cb6b94_0000000000000079_ps.txt | 28 ++++++ .../46575655811a12b7_0000000000000079_ps.txt | 28 ++++++ .../74b3539704b05bfd_0000000000000079_ps.txt | 28 ++++++ .../f5190dd4ae552353_0000000000000079_ps.txt | 27 +++++ Enthusiast/SuperMario3DWorld_2880p/rules.txt | 4 +- .../4102408f48cb6b94_0000000000000079_ps.txt | 28 ++++++ .../46575655811a12b7_0000000000000079_ps.txt | 28 ++++++ .../74b3539704b05bfd_0000000000000079_ps.txt | 28 ++++++ .../f5190dd4ae552353_0000000000000079_ps.txt | 27 +++++ Enthusiast/SuperMario3DWorld_4320p/rules.txt | 4 +- .../4102408f48cb6b94_0000000000000079_ps.txt | 28 ++++++ .../46575655811a12b7_0000000000000079_ps.txt | 28 ++++++ .../74b3539704b05bfd_0000000000000079_ps.txt | 28 ++++++ .../f5190dd4ae552353_0000000000000079_ps.txt | 27 +++++ Enthusiast/SuperMario3DWorld_5760p/rules.txt | 4 +- Performance/SuperMario3DWorld_360p/rules.txt | 4 +- Performance/SuperMario3DWorld_540p/rules.txt | 4 +- .../0457fe3efc9a772f_0000000000000079_ps.txt | 2 +- .../9fad3b3505a6d831_0000000000000079_ps.txt | 2 +- .../rules.txt | 86 ++++++++++++++++ .../0457fe3efc9a772f_0000000000000079_ps.txt | 27 +++++ .../9fad3b3505a6d831_0000000000000079_ps.txt | 27 +++++ .../patches.txt | 34 +++++++ .../rules.txt | 79 +++++++++++++++ .../0457fe3efc9a772f_0000000000000079_ps.txt | 27 +++++ .../9fad3b3505a6d831_0000000000000079_ps.txt | 27 +++++ .../rules.txt | 86 ++++++++++++++++ .../0457fe3efc9a772f_0000000000000079_ps.txt | 27 +++++ .../9fad3b3505a6d831_0000000000000079_ps.txt | 27 +++++ .../rules.txt | 86 ++++++++++++++++ .../0457fe3efc9a772f_0000000000000079_ps.txt | 27 +++++ .../9fad3b3505a6d831_0000000000000079_ps.txt | 27 +++++ .../rules.txt | 86 ++++++++++++++++ .../4102408f48cb6b94_0000000000000079_ps.txt | 28 ++++++ .../46575655811a12b7_0000000000000079_ps.txt | 28 ++++++ .../74b3539704b05bfd_0000000000000079_ps.txt | 28 ++++++ .../f5190dd4ae552353_0000000000000079_ps.txt | 27 +++++ Quality/SuperMario3DWorld_1080p/rules.txt | 4 +- .../0457fe3efc9a772f_0000000000000079_ps.txt | 27 ----- .../4102408f48cb6b94_0000000000000079_ps.txt | 28 ++++++ .../46575655811a12b7_0000000000000079_ps.txt | 28 ++++++ .../74b3539704b05bfd_0000000000000079_ps.txt | 28 ++++++ .../9fad3b3505a6d831_0000000000000079_ps.txt | 27 ----- .../f5190dd4ae552353_0000000000000079_ps.txt | 27 +++++ Quality/SuperMario3DWorld_1080pUW/rules.txt | 4 +- .../0457fe3efc9a772f_0000000000000079_ps.txt | 27 ----- .../4102408f48cb6b94_0000000000000079_ps.txt | 28 ++++++ .../46575655811a12b7_0000000000000079_ps.txt | 28 ++++++ .../74b3539704b05bfd_0000000000000079_ps.txt | 28 ++++++ .../9fad3b3505a6d831_0000000000000079_ps.txt | 27 ----- .../f5190dd4ae552353_0000000000000079_ps.txt | 27 +++++ Quality/SuperMario3DWorld_1440p/rules.txt | 4 +- .../0457fe3efc9a772f_0000000000000079_ps.txt | 27 ----- .../4102408f48cb6b94_0000000000000079_ps.txt | 28 ++++++ .../46575655811a12b7_0000000000000079_ps.txt | 28 ++++++ .../74b3539704b05bfd_0000000000000079_ps.txt | 28 ++++++ .../9fad3b3505a6d831_0000000000000079_ps.txt | 27 ----- .../f5190dd4ae552353_0000000000000079_ps.txt | 27 +++++ Quality/SuperMario3DWorld_1800p/rules.txt | 4 +- .../0457fe3efc9a772f_0000000000000079_ps.txt | 27 ----- .../4102408f48cb6b94_0000000000000079_ps.txt | 28 ++++++ .../46575655811a12b7_0000000000000079_ps.txt | 28 ++++++ .../74b3539704b05bfd_0000000000000079_ps.txt | 28 ++++++ .../9fad3b3505a6d831_0000000000000079_ps.txt | 27 ----- .../f5190dd4ae552353_0000000000000079_ps.txt | 27 +++++ Quality/SuperMario3DWorld_2160p/rules.txt | 4 +- 75 files changed, 1886 insertions(+), 244 deletions(-) rename Enthusiast/{SuperMario3DWorld_2880p => CaptainToadTreasureTracker_2880p}/0457fe3efc9a772f_0000000000000079_ps.txt (94%) rename Enthusiast/{SuperMario3DWorld_5760p => CaptainToadTreasureTracker_2880p}/9fad3b3505a6d831_0000000000000079_ps.txt (94%) create mode 100644 Enthusiast/CaptainToadTreasureTracker_2880p/rules.txt rename Enthusiast/{SuperMario3DWorld_5760p => CaptainToadTreasureTracker_4320p}/0457fe3efc9a772f_0000000000000079_ps.txt (94%) rename Enthusiast/{SuperMario3DWorld_2880p => CaptainToadTreasureTracker_4320p}/9fad3b3505a6d831_0000000000000079_ps.txt (94%) create mode 100644 Enthusiast/CaptainToadTreasureTracker_4320p/rules.txt rename Enthusiast/{SuperMario3DWorld_4320p => CaptainToadTreasureTracker_5760p}/0457fe3efc9a772f_0000000000000079_ps.txt (94%) rename {Quality/SuperMario3DWorld_1080p => Enthusiast/CaptainToadTreasureTracker_5760p}/9fad3b3505a6d831_0000000000000079_ps.txt (94%) create mode 100644 Enthusiast/CaptainToadTreasureTracker_5760p/rules.txt create mode 100644 Enthusiast/SuperMario3DWorld_2880p/4102408f48cb6b94_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_2880p/46575655811a12b7_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_2880p/74b3539704b05bfd_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_2880p/f5190dd4ae552353_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_4320p/4102408f48cb6b94_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_4320p/46575655811a12b7_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_4320p/74b3539704b05bfd_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_4320p/f5190dd4ae552353_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_5760p/4102408f48cb6b94_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_5760p/46575655811a12b7_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_5760p/74b3539704b05bfd_0000000000000079_ps.txt create mode 100644 Enthusiast/SuperMario3DWorld_5760p/f5190dd4ae552353_0000000000000079_ps.txt rename Quality/{SuperMario3DWorld_1080p => CaptainToadTreasureTracker_1080p}/0457fe3efc9a772f_0000000000000079_ps.txt (94%) rename {Enthusiast/SuperMario3DWorld_4320p => Quality/CaptainToadTreasureTracker_1080p}/9fad3b3505a6d831_0000000000000079_ps.txt (94%) create mode 100644 Quality/CaptainToadTreasureTracker_1080p/rules.txt create mode 100644 Quality/CaptainToadTreasureTracker_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/CaptainToadTreasureTracker_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/CaptainToadTreasureTracker_1080pUW/patches.txt create mode 100644 Quality/CaptainToadTreasureTracker_1080pUW/rules.txt create mode 100644 Quality/CaptainToadTreasureTracker_1440p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/CaptainToadTreasureTracker_1440p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/CaptainToadTreasureTracker_1440p/rules.txt create mode 100644 Quality/CaptainToadTreasureTracker_1800p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/CaptainToadTreasureTracker_1800p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/CaptainToadTreasureTracker_1800p/rules.txt create mode 100644 Quality/CaptainToadTreasureTracker_2160p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/CaptainToadTreasureTracker_2160p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/CaptainToadTreasureTracker_2160p/rules.txt create mode 100644 Quality/SuperMario3DWorld_1080p/4102408f48cb6b94_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1080p/46575655811a12b7_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1080p/74b3539704b05bfd_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1080p/f5190dd4ae552353_0000000000000079_ps.txt delete mode 100644 Quality/SuperMario3DWorld_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1080pUW/4102408f48cb6b94_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1080pUW/46575655811a12b7_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1080pUW/74b3539704b05bfd_0000000000000079_ps.txt delete mode 100644 Quality/SuperMario3DWorld_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1080pUW/f5190dd4ae552353_0000000000000079_ps.txt delete mode 100644 Quality/SuperMario3DWorld_1440p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1440p/4102408f48cb6b94_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1440p/46575655811a12b7_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1440p/74b3539704b05bfd_0000000000000079_ps.txt delete mode 100644 Quality/SuperMario3DWorld_1440p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1440p/f5190dd4ae552353_0000000000000079_ps.txt delete mode 100644 Quality/SuperMario3DWorld_1800p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1800p/4102408f48cb6b94_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1800p/46575655811a12b7_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1800p/74b3539704b05bfd_0000000000000079_ps.txt delete mode 100644 Quality/SuperMario3DWorld_1800p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_1800p/f5190dd4ae552353_0000000000000079_ps.txt delete mode 100644 Quality/SuperMario3DWorld_2160p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_2160p/4102408f48cb6b94_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_2160p/46575655811a12b7_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_2160p/74b3539704b05bfd_0000000000000079_ps.txt delete mode 100644 Quality/SuperMario3DWorld_2160p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/SuperMario3DWorld_2160p/f5190dd4ae552353_0000000000000079_ps.txt 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