The-Homebrew-Cloud/cemu_graphic_packs
2
0
Fork 0
mirror of https://github.com/cemu-project/cemu_graphic_packs.git synced 2024-11-29 12:54:15 +01:00
Code Issues Packages Projects Releases Wiki Activity
9dc80a18eb
cemu_graphic_packs/Enhancement/Runner2_DisableBlur/4fe1bb2bc0611f15_0000000000000079_ps.txt
Milan 5623b7ffed Switch to Travis CI with multiple builds (#218) 
* [Hyrule Warriors] Fixed coop-gamepad resolution (#212)

Thanks to @offline2007 for making a PR with this fix.

* [BotW] Add more lava artifact spots

Thanks to Soos from the discord for reporting these two spots.

Seems like there's likely some more manual editing that needs to be done, these shaders are just very minor (name) changes on the primarily used lava lake shader.

* Add Minecraft

* Shit pack

Probably only prevents HUD from counting down lmao

* add Splatoon LOD Bias pack

* Add BotW LOD Bias

* Change LOD Bias settings for BotW & Splat

Pretty much NVIDIA Inspector -3 now... If you want -16 you know what to do:

overwriteLodBias = -16

* [SSB4] Replace pixel mess with black screen

Should take care of the character issue, but it's now a black screen...

If you want to go back to the old method, comment out the width and height overrides and uncomment the format override

https://cdn.discordapp.com/attachments/416648220433711116/442867371229708311/unknown.png

* Add Runner2

Blur automatically disabled in res packs, separate pack made for native res users

Will add other regions at later date unless someone beats me to it

* Add other regions to Runner2

Demo title id included

* Switch to Travis CI with multiple builds

This will swap over to Travis which offers native linux builds. It's, against our expectations, slower or equal (probably due to lower specs), then our current Appveyor build. It does allow for a cleaner build and also implements a way to add random resolutions people would like to be added in our new 2 parallel building method. It builds Github Releases that contain multiple assets. This'll also make the common downloaded resolutions be more on their own so that people won't have loading problems. Also, the building process contains less initial spam due to the Travis' line folding. If there's an error from the php script it'll unfold automatically so no information is really hidden.
2018-05-13 13:10:06 -07:00

316 lines
10 KiB
Plaintext
Raw Blame History

#version 420
#extension GL_ARB_texture_gather : enable
#extension GL_ARB_separate_shader_objects : enable
// shader 4fe1bb2bc0611f15
// Disable this fucking godforsaken piece of shit blur filter that makes the game look lower res than it actually is
uniform ivec4 uf_remappedPS[1];
layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4000800 res 1280x720x1 dim 1 tm: 4 format 041a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0
layout(location = 0) out vec4 passPixelColor0;
uniform vec2 uf_fragCoordScale;
int clampFI32(int v)
{
if( v == 0x7FFFFFFF )
return floatBitsToInt(1.0);
else if( v == 0xFFFFFFFF )
return floatBitsToInt(0.0);
return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
}
float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
void main()
{
vec4 R0f = vec4(0.0);
vec4 R1f = vec4(0.0);
vec4 R2f = vec4(0.0);
vec4 R3f = vec4(0.0);
vec4 R4f = vec4(0.0);
vec4 R5f = vec4(0.0);
vec4 R6f = vec4(0.0);
vec4 R7f = vec4(0.0);
vec4 R8f = vec4(0.0);
vec4 R9f = vec4(0.0);
vec4 R10f = vec4(0.0);
vec4 R11f = vec4(0.0);
vec4 R123f = vec4(0.0);
vec4 R124f = vec4(0.0);
vec4 R125f = vec4(0.0);
vec4 R126f = vec4(0.0);
vec4 R127f = vec4(0.0);
float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
float PS0f = 0.0, PS1f = 0.0;
vec4 tempf = vec4(0.0);
float tempResultf;
int tempResulti;
ivec4 ARi = ivec4(0);
bool predResult = true;
vec3 cubeMapSTM;
int cubeMapFaceId;
R0f = vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw);
// 0
PV0f.z = R0f.x + 0.5;
PV0f.w = R0f.y + 0.5;
// 1
R4f.x = mul_nonIEEE(PV0f.z, intBitsToFloat(uf_remappedPS[0].x));
PV1f.x = R4f.x;
R4f.y = mul_nonIEEE(PV0f.w, intBitsToFloat(uf_remappedPS[0].y));
PV1f.y = R4f.y;
// 2
R0f.xyz = vec3(PV1f.x,PV1f.y,PV1f.x) + vec3(intBitsToFloat(0xba99999a),0.0,0.0);
R0f.w = PV1f.y + intBitsToFloat(0xbb088889);
R1f.x = PV1f.x + intBitsToFloat(0x3a99999a);
PS0f = R1f.x;
// 3
R2f.x = R4f.x + 0.0;
R1f.y = R4f.y + 0.0;
R2f.zwy = vec3(R4f.y,R4f.x,R4f.y) + vec3(intBitsToFloat(0x3b088889),intBitsToFloat(0xba99999a),intBitsToFloat(0xbb088889));
PS1f = R2f.y;
// 4
R3f.x = R4f.x + intBitsToFloat(0xba99999a);
R3f.y = R4f.y + intBitsToFloat(0x3b088889);
R1f.z = R4f.x + intBitsToFloat(0x3a99999a);
R1f.w = R4f.y + intBitsToFloat(0xbb088889);
R6f.x = R4f.x + intBitsToFloat(0x3a99999a);
PS0f = R6f.x;
//R11f.xyzw = (texture(textureUnitPS0, R4f.xy).xyzw);
R11f.xyzw = (texture(textureUnitPS0, R3f.xy).xyzw);
R5f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
R0f.xyzw = (texture(textureUnitPS0, R0f.zw).xyzw);
R7f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
R8f.xyzw = (texture(textureUnitPS0, R2f.xz).xyzw);
R9f.xyzw = (texture(textureUnitPS0, R2f.wy).xyzw);
R3f.xyzw = (texture(textureUnitPS0, R3f.xy).xyzw);
R10f.xyzw = (texture(textureUnitPS0, R1f.zw).xyzw);
// 0
R127f.x = -(R11f.x) + R5f.x;
R6f.y = R4f.y + intBitsToFloat(0x3b088889);
R123f.z = (R11f.w * 2.0 + -(1.0));
PV0f.z = R123f.z;
PV0f.w = R5f.w + intBitsToFloat(0x3c23d70a);
R127f.w = -(R11f.y) + R5f.y;
PS0f = R127f.w;
// 1
R126f.x = -(R11f.z) + R5f.z;
//PV1f.y = max(PV0f.z, -(PV0f.z));
PV1f.y = max(PV1f.z, -(PV1f.z));
PV1f.z = -(R11f.w) + PV0f.w;
R126f.w = -(R11f.w) + R5f.w;
PS1f = R0f.w + intBitsToFloat(0x3c23d70a);
// 2
backupReg0f = R0f.x;
PV0f.x = -(PV1f.y) + 1.0;
R123f.y = intBitsToFloat(((PV1f.z >= 0.0)?(floatBitsToInt(1.0)):(0)));
PV0f.y = R123f.y;
R127f.z = -(R11f.w) + PS1f;
R5f.w = R7f.w + intBitsToFloat(0x3c23d70a);
R1f.w = -(R11f.x) + backupReg0f;
PS0f = R1f.w;
// 3
R5f.x = (mul_nonIEEE(R127f.x,PV0f.y) + R11f.x);
R5f.y = (mul_nonIEEE(R127f.w,PV0f.y) + R11f.y);
R5f.z = (mul_nonIEEE(R126f.x,PV0f.y) + R11f.z);
R2f.w = max(PV0f.x, intBitsToFloat(0x3de38e39));
PV1f.w = R2f.w;
R4f.y = (mul_nonIEEE(R126f.w,PV0f.y) + R11f.w);
PS1f = R4f.y;
// 4
backupReg0f = R0f.y;
backupReg1f = R0f.z;
backupReg2f = R0f.w;
R4f.x = intBitsToFloat(((R127f.z >= 0.0)?(floatBitsToInt(1.0)):(0)));
R0f.yzw = vec3(-(R11f.y),-(PV1f.w),-(R11f.z)) + vec3(backupReg0f,1.0,backupReg1f);
R0f.x = -(R11f.w) + backupReg2f;
PS0f = R0f.x;
R6f.xyzw = (texture(textureUnitPS0, R6f.xy).xyzw);
// 0
backupReg0f = R0f.y;
R127f.x = R8f.w + intBitsToFloat(0x3c23d70a);
R0f.y = R0f.z * intBitsToFloat(0x3e15f619);
PV0f.y = R0f.y;
R127f.z = -(R11f.w) + R5f.w;
R126f.w = (mul_nonIEEE(backupReg0f,R4f.x) + R11f.y);
R125f.x = (mul_nonIEEE(R0f.x,R4f.x) + R11f.w);
PS0f = R125f.x;
// 1
PV1f.x = mul_nonIEEE(PV0f.y, R5f.x);
PV1f.y = mul_nonIEEE(PV0f.y, R4f.y);
PV1f.z = mul_nonIEEE(PV0f.y, R5f.z);
PV1f.w = mul_nonIEEE(PV0f.y, R5f.y);
R127f.w = (mul_nonIEEE(R1f.w,R4f.x) + R11f.x);
PS1f = R127f.w;
// 2
R126f.x = (mul_nonIEEE(R11f.x,R2f.w) + PV1f.x);
R126f.y = (mul_nonIEEE(R11f.w,R2f.w) + PV1f.y);
R126f.z = (mul_nonIEEE(R11f.z,R2f.w) + PV1f.z);
R125f.w = (mul_nonIEEE(R11f.y,R2f.w) + PV1f.w);
R127f.y = (mul_nonIEEE(R0f.w,R4f.x) + R11f.z);
PS0f = R127f.y;
// 3
R124f.x = -(R11f.x) + R7f.x;
R124f.y = intBitsToFloat(((R127f.z >= 0.0)?(floatBitsToInt(1.0)):(0)));
R127f.z = -(R11f.z) + R7f.z;
R124f.w = -(R11f.y) + R7f.y;
R125f.y = -(R11f.w) + R7f.w;
PS1f = R125f.y;
// 4
backupReg0f = R127f.x;
backupReg1f = R0f.y;
backupReg2f = R126f.z;
backupReg1f = R0f.y;
R127f.x = (mul_nonIEEE(R0f.y,R127f.w) + R126f.x);
PV0f.y = -(R11f.w) + backupReg0f;
R126f.z = (mul_nonIEEE(backupReg1f,R127f.y) + backupReg2f);
R127f.w = R9f.w + intBitsToFloat(0x3c23d70a);
R126f.x = (mul_nonIEEE(backupReg1f,R125f.x) + R126f.y);
PS0f = R126f.x;
// 5
backupReg0f = R124f.x;
R124f.x = (mul_nonIEEE(backupReg0f,R124f.y) + R11f.x);
R127f.y = (mul_nonIEEE(R127f.z,R124f.y) + R11f.z);
R127f.z = (mul_nonIEEE(R0f.y,R126f.w) + R125f.w);
R126f.w = (mul_nonIEEE(R124f.w,R124f.y) + R11f.y);
R7f.x = intBitsToFloat(((PV0f.y >= 0.0)?(floatBitsToInt(1.0)):(0)));
PS1f = R7f.x;
// 6
backupReg0f = R127f.w;
R125f.x = -(R11f.z) + R8f.z;
R123f.y = (mul_nonIEEE(R125f.y,R124f.y) + R11f.w);
PV0f.y = R123f.y;
R125f.z = -(R11f.w) + R8f.w;
R127f.w = -(R11f.x) + R8f.x;
R124f.z = -(R11f.w) + backupReg0f;
PS0f = R124f.z;
// 7
backupReg0f = R127f.x;
backupReg1f = R126f.w;
R127f.x = R3f.w + intBitsToFloat(0x3c23d70a);
R125f.y = (mul_nonIEEE(R0f.y,R124f.x) + backupReg0f);
PV1f.z = -(R11f.y) + R8f.y;
R126f.w = (mul_nonIEEE(R0f.y,backupReg1f) + R127f.z);
R125f.w = (mul_nonIEEE(R0f.y,PV0f.y) + R126f.x);
PS1f = R125f.w;
// 8
backupReg0f = R125f.x;
backupReg1f = R127f.y;
backupReg2f = R126f.z;
backupReg3f = R127f.w;
R125f.x = (mul_nonIEEE(PV1f.z,R7f.x) + R11f.y);
R127f.y = (mul_nonIEEE(backupReg0f,R7f.x) + R11f.z);
R126f.z = (mul_nonIEEE(R0f.y,backupReg1f) + backupReg2f);
R127f.w = (mul_nonIEEE(backupReg3f,R7f.x) + R11f.x);
R126f.x = (mul_nonIEEE(R125f.z,R7f.x) + R11f.w);
PS0f = R126f.x;
// 9
R124f.x = -(R11f.x) + R9f.x;
R126f.y = intBitsToFloat(((R124f.z >= 0.0)?(floatBitsToInt(1.0)):(0)));
R124f.zwy = vec3(-(R11f.z),-(R11f.y),-(R11f.w)) + vec3(R9f.z,R9f.y,R9f.w);
PS1f = R124f.y;
// 10
backupReg0f = R127f.x;
backupReg1f = R0f.y;
backupReg2f = R126f.z;
backupReg1f = R0f.y;
R127f.x = (mul_nonIEEE(R0f.y,R127f.w) + R125f.y);
PV0f.y = -(R11f.w) + backupReg0f;
R126f.z = (mul_nonIEEE(backupReg1f,R127f.y) + backupReg2f);
R127f.w = R10f.w + intBitsToFloat(0x3c23d70a);
R9f.x = backupReg1f * intBitsToFloat(0x3f3504f3);
PS0f = R9f.x;
// 11
backupReg0f = R126f.x;
R126f.x = (mul_nonIEEE(R0f.y,backupReg0f) + R125f.w);
R127f.y = (mul_nonIEEE(R124f.z,R126f.y) + R11f.z);
R124f.z = (mul_nonIEEE(R0f.y,R125f.x) + R126f.w);
R126f.w = (mul_nonIEEE(R124f.w,R126f.y) + R11f.y);
R125f.x = intBitsToFloat(((PV0f.y >= 0.0)?(floatBitsToInt(1.0)):(0)));
PS1f = R125f.x;
// 12
backupReg0f = R126f.y;
R123f.x = (mul_nonIEEE(R124f.x,R126f.y) + R11f.x);
PV0f.x = R123f.x;
R126f.y = (mul_nonIEEE(R124f.y,backupReg0f) + R11f.w);
R125f.z = -(R11f.z) + R3f.z;
R125f.w = -(R11f.x) + R3f.x;
R124f.x = -(R11f.w) + R3f.w;
PS0f = R124f.x;
// 13
backupReg0f = R127f.y;
backupReg1f = R126f.z;
PV1f.x = -(R11f.w) + R127f.w;
R127f.y = R6f.w + intBitsToFloat(0x3c23d70a);
PV1f.z = -(R11f.y) + R3f.y;
R127f.w = (mul_nonIEEE(R9f.x,PV0f.x) + R127f.x);
R126f.z = (mul_nonIEEE(R9f.x,backupReg0f) + backupReg1f);
PS1f = R126f.z;
// 14
backupReg0f = R126f.x;
backupReg1f = R126f.w;
R126f.x = (mul_nonIEEE(R9f.x,R126f.y) + backupReg0f);
R126f.y = (mul_nonIEEE(R125f.z,R125f.x) + R11f.z);
R125f.z = (mul_nonIEEE(PV1f.z,R125f.x) + R11f.y);
R126f.w = (mul_nonIEEE(R9f.x,backupReg1f) + R124f.z);
R3f.y = intBitsToFloat(((PV1f.x >= 0.0)?(floatBitsToInt(1.0)):(0)));
PS0f = R3f.y;
// 15
backupReg0f = R125f.x;
backupReg0f = R125f.x;
R125f.x = (mul_nonIEEE(R124f.x,backupReg0f) + R11f.w);
R124f.y = -(R11f.y) + R10f.y;
R124f.z = -(R11f.z) + R10f.z;
R123f.w = (mul_nonIEEE(R125f.w,backupReg0f) + R11f.x);
PV1f.w = R123f.w;
R125f.y = -(R11f.w) + R10f.w;
PS1f = R125f.y;
// 16
backupReg0f = R127f.w;
backupReg1f = R126f.z;
R124f.x = -(R11f.x) + R10f.x;
PV0f.y = -(R11f.w) + R127f.y;
R126f.z = (mul_nonIEEE(R9f.x,R125f.z) + R126f.w);
R127f.w = (mul_nonIEEE(R9f.x,PV1f.w) + backupReg0f);
R127f.y = (mul_nonIEEE(R9f.x,R126f.y) + backupReg1f);
PS0f = R127f.y;
// 17
backupReg0f = R126f.x;
backupReg1f = R124f.z;
backupReg2f = R124f.y;
R126f.x = (mul_nonIEEE(R9f.x,R125f.x) + backupReg0f);
R124f.y = intBitsToFloat(((PV0f.y >= 0.0)?(floatBitsToInt(1.0)):(0)));
PV1f.y = R124f.y;
R124f.z = (mul_nonIEEE(backupReg1f,R3f.y) + R11f.z);
R126f.w = (mul_nonIEEE(backupReg2f,R3f.y) + R11f.y);
PS1f = -(R11f.z) + R6f.z;
// 18
R123f.x = (mul_nonIEEE(R124f.x,R3f.y) + R11f.x);
PV0f.x = R123f.x;
R123f.y = (mul_nonIEEE(R125f.y,R3f.y) + R11f.w);
PV0f.y = R123f.y;
R125f.z = -(R11f.w) + R6f.w;
R125f.w = -(R11f.x) + R6f.x;
R125f.y = (mul_nonIEEE(PS1f,PV1f.y) + R11f.z);
PS0f = R125f.y;
// 19
backupReg0f = R126f.x;
R126f.x = (mul_nonIEEE(R9f.x,PV0f.x) + R127f.w);
R123f.y = (mul_nonIEEE(R9f.x,R124f.z) + R127f.y);
PV1f.y = R123f.y;
PV1f.z = -(R11f.y) + R6f.y;
R127f.w = (mul_nonIEEE(R9f.x,R126f.w) + R126f.z);
R126f.w = (mul_nonIEEE(R9f.x,PV0f.y) + backupReg0f);
PS1f = R126f.w;
// 20
R123f.x = (mul_nonIEEE(R125f.z,R124f.y) + R11f.w);
PV0f.x = R123f.x;
R123f.z = (mul_nonIEEE(PV1f.z,R124f.y) + R11f.y);
PV0f.z = R123f.z;
R123f.w = (mul_nonIEEE(R125f.w,R124f.y) + R11f.x);
PV0f.w = R123f.w;
R11f.z = (mul_nonIEEE(R9f.x,R125f.y) + PV1f.y);
PS0f = R11f.z;
// 21
R11f.x = (mul_nonIEEE(R9f.x,PV0f.w) + R126f.x);
R11f.y = (mul_nonIEEE(R9f.x,PV0f.z) + R127f.w);
R11f.w = (mul_nonIEEE(R9f.x,PV0f.x) + R126f.w);
// export
passPixelColor0 = vec4(R11f.x, R11f.y, R11f.z, R11f.w);
}
Reference in New Issue View Git Blame Copy Permalink