diff --git a/Source/XenobladeX/034f3827969964b2_0000000000000000_vs.txt b/Source/XenobladeX/034f3827969964b2_0000000000000000_vs.txt new file mode 100644 index 00000000..c7ba002e --- /dev/null +++ b/Source/XenobladeX/034f3827969964b2_0000000000000000_vs.txt @@ -0,0 +1,128 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 034f3827969964b2 +//shadow acne fix time-of-day station +// to-do Magic value, review other solution. +layout(binding = 1, std140) uniform uniformBlockVS1 +{ +vec4 uf_blockVS1[1024]; +}; + +layout(binding = 2, std140) uniform uniformBlockVS2 +{ +vec4 uf_blockVS2[1024]; +}; + +uniform vec2 uf_windowSpaceToClipSpaceTransform; +layout(location = 0) in uvec4 attrDataSem0; +layout(location = 1) in uvec4 attrDataSem1; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R3i = ivec4(0); +ivec4 R4i = ivec4(0); +ivec4 R127i = ivec4(0); +uvec4 attrDecoder; +int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i; +ivec4 PV0i = ivec4(0), PV1i = ivec4(0); +int PS0i = 0, PS1i = 0; +ivec4 tempi = ivec4(0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = ivec4(gl_VertexID, 0, 0, gl_InstanceID); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R2i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = ((attrDecoder.xy>>8)&0xFF)|((attrDecoder.xy<<8)&0xFF00); +attrDecoder.z = 0; +attrDecoder.w = 0; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), 0, 1); +// 0 +R4i.w = 0x3f800000; +R0i.z = R1i.x * 0x00000003; +PS0i = R0i.z; +// 1 +R1i.x = PS0i + 0x00000002; +R0i.y = PS0i + int(1); +R3i.xyzw = floatBitsToInt(uf_blockVS1[R0i.z].xyzw); +R0i.xyzw = floatBitsToInt(uf_blockVS1[R0i.y].xyzw); +R1i.xyzw = floatBitsToInt(uf_blockVS1[R1i.x].xyzw); +// 0 +R127i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(R2i.w)),vec4(intBitsToFloat(R3i.x),intBitsToFloat(R3i.y),intBitsToFloat(R3i.z),intBitsToFloat(R3i.w)))); +PV0i.x = R127i.x; +PV0i.y = R127i.x; +PV0i.z = R127i.x; +PV0i.w = R127i.x; +// 1 +backupReg0i = R0i.x; +backupReg1i = R0i.z; +backupReg2i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(R2i.w)),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),intBitsToFloat(backupReg1i),intBitsToFloat(backupReg2i)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.y = tempi.x; +// 2 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(R2i.w)),vec4(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(R1i.z),intBitsToFloat(R1i.w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.z = tempi.x; +// 3 +R1i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R127i.y),intBitsToFloat(PV0i.x),intBitsToFloat(R4i.w)),vec4(uf_blockVS2[0].x,uf_blockVS2[0].y,uf_blockVS2[0].z,uf_blockVS2[0].w))); +PV1i.x = R1i.x; +PV1i.y = R1i.x; +PV1i.z = R1i.x; +PV1i.w = R1i.x; +// 4 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R127i.y),intBitsToFloat(R127i.z),intBitsToFloat(R4i.w)),vec4(uf_blockVS2[1].x,uf_blockVS2[1].y,uf_blockVS2[1].z,uf_blockVS2[1].w))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R1i.y = tempi.x; +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R127i.y),intBitsToFloat(R127i.z),intBitsToFloat(R4i.w)),vec4(uf_blockVS2[2].x,uf_blockVS2[2].y,uf_blockVS2[2].z,uf_blockVS2[2].w))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R1i.z = tempi.x; +// 6 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R127i.y),intBitsToFloat(R127i.z),intBitsToFloat(R4i.w)),vec4(uf_blockVS2[3].x,uf_blockVS2[3].y,uf_blockVS2[3].z,uf_blockVS2[3].w))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R1i.w = tempi.x; +// export +gl_Position = vec4(intBitsToFloat(R1i.x), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z)+0.0002, intBitsToFloat(R1i.w)); //shadow bias +// export +// skipped export to semanticId 255 +// 0 +} diff --git a/Source/XenobladeX/1bef7019c97eb2b1_0000000000000079_ps.txt b/Source/XenobladeX/1bef7019c97eb2b1_0000000000000079_ps.txt new file mode 100644 index 00000000..66828c5a --- /dev/null +++ b/Source/XenobladeX/1bef7019c97eb2b1_0000000000000079_ps.txt @@ -0,0 +1,1311 @@ + + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 1bef7019c97eb2b1 +//Vertlica line glare (anamorphic lens ) +// To-do - As long as brigntess fix is needed, this will always be dodgy .. +const float resScale = ; +//const float resScale = 3.0; +uniform ivec4 uf_remappedPS[2]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4f51000 res 80x46x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 6 6 6 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R6f = vec4(0.0); +vec4 R7f = vec4(0.0); +vec4 R8f = vec4(0.0); +vec4 R9f = vec4(0.0); +vec4 R10f = vec4(0.0); +vec4 R11f = vec4(0.0); +vec4 R12f = vec4(0.0); +vec4 R13f = vec4(0.0); +vec4 R14f = vec4(0.0); +vec4 R15f = vec4(0.0); +vec4 R16f = vec4(0.0); +vec4 R17f = vec4(0.0); +vec4 R18f = vec4(0.0); +vec4 R19f = vec4(0.0); +vec4 R20f = vec4(0.0); +vec4 R21f = vec4(0.0); +vec4 R22f = vec4(0.0); +vec4 R23f = vec4(0.0); +vec4 R24f = vec4(0.0); +vec4 R25f = vec4(0.0); +vec4 R26f = vec4(0.0); +vec4 R27f = vec4(0.0); +vec4 R28f = vec4(0.0); +vec4 R29f = vec4(0.0); +vec4 R30f = vec4(0.0); +vec4 R31f = vec4(0.0); +vec4 R32f = vec4(0.0); +vec4 R33f = vec4(0.0); +vec4 R34f = vec4(0.0); +vec4 R35f = vec4(0.0); +vec4 R36f = vec4(0.0); +vec4 R37f = vec4(0.0); +vec4 R38f = vec4(0.0); +vec4 R39f = vec4(0.0); +vec4 R122f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R125f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +R4f.xyz = (texture(textureUnitPS0, R0f.xy).xyz); +// 0 +R1f.x = R0f.x + intBitsToFloat(uf_remappedPS[0].x); +R1f.y = R0f.y + intBitsToFloat(uf_remappedPS[0].y); +R2f.z = R0f.x + -(intBitsToFloat(uf_remappedPS[0].x)); +R1f.w = intBitsToFloat(uf_remappedPS[1].x) * intBitsToFloat(uf_remappedPS[1].y); +PV0f.w = R1f.w; +R2f.y = R0f.y + -(intBitsToFloat(uf_remappedPS[0].y)); //m +PS0f = R2f.y; +// 1 +R5f.x = PV0f.w * intBitsToFloat(uf_remappedPS[1].y); //n +// 2 +R3f.z = intBitsToFloat(uf_remappedPS[0].y) * intBitsToFloat(uf_remappedPS[0].z); +PV0f.z = R3f.z; +R127f.w = intBitsToFloat(uf_remappedPS[0].x) * intBitsToFloat(uf_remappedPS[0].z); +PV0f.w = R127f.w; +// 3 +R8f.x = R5f.x * intBitsToFloat(uf_remappedPS[1].y); +R5f.y = PV0f.w + (intBitsToFloat(uf_remappedPS[0].x)/ resScale); //y +PV1f.y = R5f.y; +R2f.w = PV0f.z + intBitsToFloat(uf_remappedPS[0].y); +PV1f.w = R2f.w; +// 4 +R3f.x = R0f.x + PV1f.y; +R3f.y = R0f.y + PV1f.w; +R0f.z = R0f.x + -(PV1f.y); +R0f.w = R0f.y + -(PV1f.w); +R7f.x = R127f.w * (intBitsToFloat(uf_remappedPS[0].z) / resScale); +PS0f = R7f.x; +R1f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R2f.xyz = (texture(textureUnitPS0, R2f.zy).xyz); +R12f.xyz = (texture(textureUnitPS0, R3f.xy).xyz); +R6f.xyz = (texture(textureUnitPS0, R0f.zw).xyz); +// 0 +PV0f.x = max(R4f.y, R1f.y); +PV0f.y = max(R4f.x, R1f.x); +R127f.z = max(R4f.z, R1f.z); +PV0f.w = R1f.w * R1f.x; +PS0f = R1f.w * R1f.y; +// 1 +PV1f.x = R1f.w * R1f.z; +PV1f.y = max(PV0f.y, R2f.x); +R123f.z = (R4f.x * intBitsToFloat(uf_remappedPS[1].x) + PV0f.w); +PV1f.z = R123f.z; +R123f.w = (R4f.y * intBitsToFloat(uf_remappedPS[1].x) + PS0f); +PV1f.w = R123f.w; +R127f.y = max(PV0f.x, R2f.y); +PS1f = R127f.y; +// 2 +PV0f.x = max(R127f.z, R2f.z); +R123f.y = (R1f.w * R2f.x + PV1f.z); +PV0f.y = R123f.y; +R123f.z = (R1f.w * R2f.y + PV1f.w); +PV0f.z = R123f.z; +R123f.w = (R4f.z * intBitsToFloat(uf_remappedPS[1].x) + PV1f.x); +PV0f.w = R123f.w; +R0f.w = max(PV1f.y, R6f.x); +PS0f = R0f.w; +// 3 +R123f.x = (R5f.x * R12f.x + PV0f.y); +PV1f.x = R123f.x; +R123f.y = (R1f.w * R2f.z + PV0f.w); +PV1f.y = R123f.y; +R123f.z = (R5f.x * R12f.y + PV0f.z); +PV1f.z = R123f.z; +R1f.w = max(R127f.y, R6f.y); +R4f.y = max(PV0f.x, R6f.z); +PS1f = R4f.y; +// 4 +R2f.x = (R5f.x * R6f.x + PV1f.x); +R2f.y = (R5f.x * R6f.y + PV1f.z); +R127f.z = R3f.z * intBitsToFloat(uf_remappedPS[0].z); +PV0f.z = R127f.z; +R123f.w = (R5f.x * R12f.z + PV1f.y); +PV0f.w = R123f.w; +R126f.z = R5f.y + R7f.x; +PS0f = R126f.z; +// 5 +backupReg0f = R5f.x; +R5f.x = R0f.x + PS0f; +R1f.y = R8f.x * intBitsToFloat(uf_remappedPS[1].y); +PV1f.y = R1f.y; +R3f.z = (backupReg0f * R6f.z + PV0f.w); +R127f.w = R2f.w + PV0f.z; +PV1f.w = R127f.w; +R6f.x = R0f.x + -(PS0f); +PS1f = R6f.x; +// 6 +PV0f.x = R7f.x *( intBitsToFloat(uf_remappedPS[0].z)/ resScale); +R5f.y = R0f.y + PV1f.w; +R6f.z = R0f.y + -(PV1f.w); +PV0f.w = R127f.z * intBitsToFloat(uf_remappedPS[0].z); //n +R3f.w = PV1f.y * intBitsToFloat(uf_remappedPS[1].y); //n +PS0f = R3f.w; +// 7 +R4f.x = PV0f.x * intBitsToFloat(uf_remappedPS[0].z); +PV1f.x = R4f.x; +R3f.y = PV0f.w * intBitsToFloat(uf_remappedPS[0].z); +R4f.z = R127f.w + PV0f.w; +PV1f.z = R4f.z; +PV1f.w = R126f.z + PV0f.x; +R3f.x = PS0f * intBitsToFloat(uf_remappedPS[1].y); +PS1f = R3f.x; +// 8 +R7f.x = R0f.x + PV1f.w; +R7f.y = R0f.y + PV1f.z; +R2f.z = R0f.x + -(PV1f.w); +R2f.w = R0f.y + -(PV1f.z); +R1f.x = PV1f.w + PV1f.x; +PS0f = R1f.x; +R11f.xyz = (texture(textureUnitPS0, R5f.xy).xyz); +R6f.xyz = (texture(textureUnitPS0, R6f.xz).xyz); +R13f.xyz = (texture(textureUnitPS0, R7f.xy).xyz); +R7f.xyz = (texture(textureUnitPS0, R2f.zw).xyz); +// 0 +R127f.x = max(R1f.w, R6f.y); +R123f.y = (R8f.x * R11f.x + R2f.x); +PV0f.y = R123f.y; +R123f.z = (R8f.x * R11f.y + R2f.y); +PV0f.z = R123f.z; +R123f.w = (R8f.x * R11f.z + R3f.z); +PV0f.w = R123f.w; +// 1 +PV1f.x = max(R0f.w, R6f.x); +R123f.y = (R8f.x * R6f.x + PV0f.y); +PV1f.y = R123f.y; +R126f.z = max(R4f.y, R6f.z); +R123f.w = (R8f.x * R6f.y + PV0f.z); +PV1f.w = R123f.w; +R122f.x = (R8f.x * R6f.z + PV0f.w); +PS1f = R122f.x; +// 2 +R123f.x = (R1f.y * R13f.z + PS1f); +PV0f.x = R123f.x; +R6f.y = max(PV1f.x, R7f.x); +R123f.z = (R1f.y * R13f.y + PV1f.w); +PV0f.z = R123f.z; +R123f.w = (R1f.y * R13f.x + PV1f.y); +PV0f.w = R123f.w; +R6f.x = max(R127f.x, R7f.y); +PS0f = R6f.x; +// 3 +backupReg0f = R7f.y; +backupReg1f = R7f.x; +backupReg2f = R7f.z; +R7f.x = (R1f.y * R7f.z + PV0f.x); +R7f.y = (R1f.y * backupReg0f + PV0f.z); +R7f.z = (R1f.y * backupReg1f + PV0f.w); +R0f.w = max(R126f.z, backupReg2f); +R127f.w = R4f.z + R3f.y; +PS1f = R127f.w; +// 4 +backupReg0f = R4f.x; +R4f.xyz = vec3(R0f.x,R0f.y,R0f.x) + vec3(R1f.x,PS1f,-(R1f.x)); +R4f.w = R0f.y + -(PS1f); +PS0f = backupReg0f * intBitsToFloat(uf_remappedPS[0].z); +// 5 +R5f.x = R3f.x * intBitsToFloat(uf_remappedPS[1].y); +PV1f.y = R1f.x + PS0f; +PV1f.z = R3f.y * intBitsToFloat(uf_remappedPS[0].z); +R1f.w = PS0f * intBitsToFloat(uf_remappedPS[0].z); +PV1f.w = R1f.w; +// 6 +R1f.x = R0f.x + PV1f.y; +R2f.y = PV1f.z * intBitsToFloat(uf_remappedPS[0].z); +PV0f.y = R2f.y; +R3f.z = R0f.x + -(PV1f.y); +PV0f.w = R127f.w + PV1f.z; +R6f.z = PV1f.y + PV1f.w; +PS0f = R6f.z; +// 7 +R8f.x = R0f.x + PS0f; +R1f.y = R0f.y + PV0f.w; +R5f.z = R0f.x + -(PS0f); +R2f.w = PV0f.w + PV0f.y; +R3f.y = R0f.y + -(PV0f.w); +PS1f = R3f.y; +R14f.xyz = (texture(textureUnitPS0, R4f.xy).xyz); +R4f.xyz = (texture(textureUnitPS0, R4f.zw).xyz); +R15f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R1f.xyz = (texture(textureUnitPS0, R3f.zy).xyz); +// 0 +R123f.x = (R3f.w * R14f.z + R7f.x); +PV0f.x = R123f.x; +PV0f.y = max(R6f.y, R4f.x); +R123f.z = (R3f.w * R14f.x + R7f.z); +PV0f.z = R123f.z; +R123f.w = (R3f.w * R14f.y + R7f.y); +PV0f.w = R123f.w; +R127f.x = max(R0f.w, R4f.z); +PS0f = R127f.x; +// 1 +R123f.x = (R3f.w * R4f.z + PV0f.x); +PV1f.x = R123f.x; +PV1f.y = max(R6f.x, R4f.y); +R123f.z = (R3f.w * R4f.y + PV0f.w); +PV1f.z = R123f.z; +R123f.w = (R3f.w * R4f.x + PV0f.z); +PV1f.w = R123f.w; +R0f.w = max(PV0f.y, R1f.x); +PS1f = R0f.w; +// 2 +R123f.x = (R3f.x * R15f.x + PV1f.w); +PV0f.x = R123f.x; +R4f.y = max(PV1f.y, R1f.y); +R123f.z = (R3f.x * R15f.y + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R3f.x * R15f.z + PV1f.x); +PV0f.w = R123f.w; +R6f.y = max(R127f.x, R1f.z); +PS0f = R6f.y; +// 3 +backupReg0f = R1f.x; +backupReg1f = R1f.z; +R1f.x = (R3f.x * backupReg0f + PV0f.x); +R8f.y = R0f.y + R2f.w; +R1f.z = (R3f.x * backupReg1f + PV0f.w); +R3f.w = (R3f.x * R1f.y + PV0f.z); +R5f.y = R0f.y + -(R2f.w); +PS1f = R5f.y; +// 4 +PV0f.x = R2f.y * intBitsToFloat(uf_remappedPS[0].z); +PV0f.y = R1f.w * intBitsToFloat(uf_remappedPS[0].z); +R4f.z = R5f.x * intBitsToFloat(uf_remappedPS[1].y); +PV0f.z = R4f.z; +// 5 +backupReg0f = R6f.z; +R4f.x = PV0f.z * intBitsToFloat(uf_remappedPS[1].y); +R1f.y = PV0f.y * intBitsToFloat(uf_remappedPS[0].z); +PV1f.y = R1f.y; +R6f.z = R2f.w + PV0f.x; +PV1f.z = R6f.z; +PV1f.w = backupReg0f + PV0f.y; +R7f.y = PV0f.x * intBitsToFloat(uf_remappedPS[0].z); +PS1f = R7f.y; +// 6 +R2f.xyz = vec3(R0f.x,R0f.y,R0f.x) + vec3(PV1f.w,PV1f.z,-(PV1f.w)); +R2f.w = R0f.y + -(PV1f.z); +R3f.x = PV1f.w + PV1f.y; +PS0f = R3f.x; +R16f.xyz = (texture(textureUnitPS0, R8f.xy).xyz); +R8f.xyz = (texture(textureUnitPS0, R5f.zy).xyz); +R17f.xyz = (texture(textureUnitPS0, R2f.xy).xyz); +R2f.xyz = (texture(textureUnitPS0, R2f.zw).xyz); +// 0 +R127f.x = max(R4f.y, R8f.y); +R123f.y = (R5f.x * R16f.x + R1f.x); +PV0f.y = R123f.y; +R123f.z = (R5f.x * R16f.y + R3f.w); +PV0f.z = R123f.z; +R123f.w = (R5f.x * R16f.z + R1f.z); +PV0f.w = R123f.w; +// 1 +PV1f.x = max(R0f.w, R8f.x); +R123f.y = (R5f.x * R8f.x + PV0f.y); +PV1f.y = R123f.y; +R126f.z = max(R6f.y, R8f.z); +R123f.w = (R5f.x * R8f.y + PV0f.z); +PV1f.w = R123f.w; +R122f.x = (R5f.x * R8f.z + PV0f.w); +PS1f = R122f.x; +// 2 +R123f.x = (R4f.z * R17f.z + PS1f); +PV0f.x = R123f.x; +R8f.y = max(PV1f.x, R2f.x); +R123f.z = (R4f.z * R17f.y + PV1f.w); +PV0f.z = R123f.z; +R123f.w = (R4f.z * R17f.x + PV1f.y); +PV0f.w = R123f.w; +R8f.x = max(R127f.x, R2f.y); +PS0f = R8f.x; +// 3 +backupReg0f = R4f.z; +R5f.x = (R4f.z * R2f.z + PV0f.x); +R6f.y = (R4f.z * R2f.y + PV0f.z); +R4f.z = (backupReg0f * R2f.x + PV0f.w); +R0f.w = max(R126f.z, R2f.z); +R2f.x = R0f.x + R3f.x; +PS1f = R2f.x; +// 4 +backupReg0f = R7f.y; +backupReg0f = R7f.y; +R6f.x = R0f.x + -(R3f.x); +R7f.y = R4f.x * intBitsToFloat(uf_remappedPS[1].y); +PV0f.y = R7f.y; +R126f.z = R1f.y * intBitsToFloat(uf_remappedPS[0].z); +PV0f.z = R126f.z; +PV0f.w = R6f.z + backupReg0f; +R8f.z = backupReg0f * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R8f.z; +// 5 +R7f.x = R3f.x + PV0f.z; +PV1f.x = R7f.x; +R2f.y = R0f.y + PV0f.w; +R6f.z = R0f.y + -(PV0f.w); +R3f.w = PV0f.w + PS0f; +PV1f.w = R3f.w; +R4f.y = PV0f.y * intBitsToFloat(uf_remappedPS[1].y); +PS1f = R4f.y; +// 6 +R3f.x = R0f.x + PV1f.x; +R3f.y = R0f.y + PV1f.w; +R2f.z = R0f.x + -(PV1f.x); +R2f.w = R0f.y + -(PV1f.w); +R9f.x = R126f.z * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R9f.x; +R18f.xyz = (texture(textureUnitPS0, R2f.xy).xyz); +R1f.xyz = (texture(textureUnitPS0, R6f.xz).xyz); +R19f.xyz = (texture(textureUnitPS0, R3f.xy).xyz); +R2f.xyz = (texture(textureUnitPS0, R2f.zw).xyz); +// 0 +R123f.x = (R4f.x * R18f.z + R5f.x); +PV0f.x = R123f.x; +R127f.y = max(R0f.w, R1f.z); +R123f.z = (R4f.x * R18f.x + R4f.z); +PV0f.z = R123f.z; +R123f.w = (R4f.x * R18f.y + R6f.y); +PV0f.w = R123f.w; +R4f.z = R4f.y * intBitsToFloat(uf_remappedPS[1].y); +PS0f = R4f.z; +// 1 +R123f.x = (R4f.x * R1f.y + PV0f.w); +PV1f.x = R123f.x; +PV1f.y = max(R8f.x, R1f.y); +PV1f.z = max(R8f.y, R1f.x); +R123f.w = (R4f.x * R1f.x + PV0f.z); +PV1f.w = R123f.w; +R122f.x = (R4f.x * R1f.z + PV0f.x); +PS1f = R122f.x; +// 2 +R123f.x = (R7f.y * R19f.x + PV1f.w); +PV0f.x = R123f.x; +R1f.y = max(PV1f.z, R2f.x); +R123f.z = (R7f.y * R19f.y + PV1f.x); +PV0f.z = R123f.z; +R123f.w = (R7f.y * R19f.z + PS1f); +PV0f.w = R123f.w; +R1f.z = max(PV1f.y, R2f.y); +PS0f = R1f.z; +// 3 +backupReg0f = R2f.z; +backupReg1f = R2f.y; +R1f.x = (R7f.y * R2f.x + PV0f.x); +R2f.y = max(R127f.y, R2f.z); +R2f.z = (R7f.y * backupReg0f + PV0f.w); +R0f.w = (R7f.y * backupReg1f + PV0f.z); +PS1f = R8f.z * intBitsToFloat(uf_remappedPS[0].z); +// 4 +R127f.x = PS1f * intBitsToFloat(uf_remappedPS[0].z); +R127f.y = R9f.x * intBitsToFloat(uf_remappedPS[0].z); +PV0f.y = R127f.y; +PV0f.z = R7f.x + R9f.x; +R127f.w = R3f.w + PS1f; +PV0f.w = R127f.w; +R4f.w = R4f.z * intBitsToFloat(uf_remappedPS[1].y); +PS0f = R4f.w; +// 5 +R7f.x = R0f.x + PV0f.z; +R7f.y = R0f.y + PV0f.w; +R3f.z = R0f.x + -(PV0f.z); +R3f.w = R0f.y + -(PV0f.w); +R126f.w = PV0f.z + PV0f.y; +PS1f = R126f.w; +// 6 +R9f.x = R0f.x + PS1f; +R8f.y = R127f.y * intBitsToFloat(uf_remappedPS[0].z); +PV0f.y = R8f.y; +PV0f.z = R127f.w + R127f.x; +R2f.w = R0f.x + -(PS1f); +R6f.y = R127f.x * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R6f.y; +// 7 +R2f.x = R0f.y + -(PV0f.z); +R9f.y = R0f.y + PV0f.z; +R8f.z = R126f.w + PV0f.y; +R1f.w = PV0f.z + PS0f; +R4f.x = R4f.w * intBitsToFloat(uf_remappedPS[1].y); +PS1f = R4f.x; +R20f.xyz = (texture(textureUnitPS0, R7f.xy).xyz); +R3f.xyz = (texture(textureUnitPS0, R3f.zw).xyz); +R21f.xyz = (texture(textureUnitPS0, R9f.xy).xyz); +R9f.xyz = (texture(textureUnitPS0, R2f.wx).xyz); +// 0 +R127f.x = max(R1f.y, R3f.x); +R123f.y = (R4f.y * R20f.x + R1f.x); +PV0f.y = R123f.y; +R123f.z = (R4f.y * R20f.y + R0f.w); +PV0f.z = R123f.z; +R123f.w = (R4f.y * R20f.z + R2f.z); +PV0f.w = R123f.w; +// 1 +R123f.x = (R4f.y * R3f.y + PV0f.z); +PV1f.x = R123f.x; +R123f.y = (R4f.y * R3f.x + PV0f.y); +PV1f.y = R123f.y; +R126f.z = max(R2f.y, R3f.z); +PV1f.w = max(R1f.z, R3f.y); +R122f.x = (R4f.y * R3f.z + PV0f.w); +PS1f = R122f.x; +// 2 +R123f.x = (R4f.z * R21f.z + PS1f); +PV0f.x = R123f.x; +R3f.y = max(R127f.x, R9f.x); +R123f.z = (R4f.z * R21f.y + PV1f.x); +PV0f.z = R123f.z; +R123f.w = (R4f.z * R21f.x + PV1f.y); +PV0f.w = R123f.w; +R1f.x = max(PV1f.w, R9f.y); +PS0f = R1f.x; +// 3 +backupReg0f = R4f.z; +R3f.x = (R4f.z * R9f.z + PV0f.x); +R2f.y = (R4f.z * R9f.y + PV0f.z); +R4f.z = (backupReg0f * R9f.x + PV0f.w); +R0f.w = max(R126f.z, R9f.z); +R9f.y = R0f.y + R1f.w; +PS1f = R9f.y; +// 4 +backupReg0f = R6f.y; +R9f.x = R0f.x + R8f.z; +R6f.y = R0f.y + -(R1f.w); +R6f.z = R0f.x + -(R8f.z); +PV0f.w = R8f.y * intBitsToFloat(uf_remappedPS[0].z); +PS0f = backupReg0f * intBitsToFloat(uf_remappedPS[0].z); +// 5 +R2f.x = R4f.x * intBitsToFloat(uf_remappedPS[1].y); +PV1f.y = R8f.z + PV0f.w; +R9f.z = PV0f.w * intBitsToFloat(uf_remappedPS[0].z); +PV1f.z = R9f.z; +R2f.w = R1f.w + PS0f; +PV1f.w = R2f.w; +R3f.w = PS0f * intBitsToFloat(uf_remappedPS[0].z); +PS1f = R3f.w; +// 6 +R8f.x = R0f.x + PV1f.y; +R8f.y = R0f.y + PV1f.w; +R1f.z = R0f.x + -(PV1f.y); +R1f.w = R0f.y + -(PV1f.w); +R3f.z = PV1f.y + PV1f.z; +PS0f = R3f.z; +R22f.xyz = (texture(textureUnitPS0, R9f.xy).xyz); +R6f.xyz = (texture(textureUnitPS0, R6f.zy).xyz); +R23f.xyz = (texture(textureUnitPS0, R8f.xy).xyz); +R8f.xyz = (texture(textureUnitPS0, R1f.zw).xyz); +// 0 +R123f.x = (R4f.w * R22f.z + R3f.x); +PV0f.x = R123f.x; +PV0f.y = max(R3f.y, R6f.x); +R123f.z = (R4f.w * R22f.x + R4f.z); +PV0f.z = R123f.z; +R123f.w = (R4f.w * R22f.y + R2f.y); +PV0f.w = R123f.w; +R127f.x = max(R0f.w, R6f.z); +PS0f = R127f.x; +// 1 +R123f.x = (R4f.w * R6f.z + PV0f.x); +PV1f.x = R123f.x; +PV1f.y = max(R1f.x, R6f.y); +R123f.z = (R4f.w * R6f.y + PV0f.w); +PV1f.z = R123f.z; +R123f.w = (R4f.w * R6f.x + PV0f.z); +PV1f.w = R123f.w; +R4f.w = max(PV0f.y, R8f.x); +PS1f = R4f.w; +// 2 +R123f.x = (R4f.x * R23f.x + PV1f.w); +PV0f.x = R123f.x; +R6f.y = max(PV1f.y, R8f.y); +R123f.z = (R4f.x * R23f.y + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R4f.x * R23f.z + PV1f.x); +PV0f.w = R123f.w; +R2f.y = max(R127f.x, R8f.z); +PS0f = R2f.y; +// 3 +backupReg0f = R8f.z; +R1f.x = (R4f.x * R8f.x + PV0f.x); +R127f.y = R2f.w + R3f.w; +PV1f.y = R127f.y; +R8f.z = (R4f.x * backupReg0f + PV0f.w); +R2f.w = (R4f.x * R8f.y + PV0f.z); +R4f.x = R0f.x + R3f.z; +PS1f = R4f.x; +// 4 +backupReg0f = R9f.z; +R9f.x = R0f.x + -(R3f.z); +R4f.y = R0f.y + PV1f.y; +R9f.z = R0f.y + -(PV1f.y); +R0f.w = R2f.x * intBitsToFloat(uf_remappedPS[1].y); +PV0f.w = R0f.w; +PS0f = backupReg0f * intBitsToFloat(uf_remappedPS[0].z); +// 5 +PV1f.x = R3f.w * intBitsToFloat(uf_remappedPS[0].z); +R10f.y = PV0f.w * intBitsToFloat(uf_remappedPS[1].y); +R6f.z = PS0f * intBitsToFloat(uf_remappedPS[0].z); +PV1f.z = R6f.z; +PV1f.w = R3f.z + PS0f; +// 6 +R8f.x = R0f.x + PV1f.w; +R1f.y = PV1f.x * intBitsToFloat(uf_remappedPS[0].z); +PV0f.y = R1f.y; +PV0f.z = R127f.y + PV1f.x; +R3f.w = R0f.x + -(PV1f.w); +R6f.x = PV1f.w + PV1f.z; +PS0f = R6f.x; +// 7 +R7f.x = R0f.x + PS0f; +R8f.y = R0f.y + PV0f.z; +R3f.z = R0f.y + -(PV0f.z); +R1f.w = PV0f.z + PV0f.y; +R5f.x = R0f.x + -(PS0f); +PS1f = R5f.x; +R24f.xyz = (texture(textureUnitPS0, R4f.xy).xyz); +R9f.xyz = (texture(textureUnitPS0, R9f.xz).xyz); +R25f.xyz = (texture(textureUnitPS0, R8f.xy).xyz); +R3f.xyz = (texture(textureUnitPS0, R3f.wz).xyz); +// 0 +R127f.x = max(R6f.y, R9f.y); +R123f.y = (R2f.x * R24f.x + R1f.x); +PV0f.y = R123f.y; +R123f.z = (R2f.x * R24f.y + R2f.w); +PV0f.z = R123f.z; +R123f.w = (R2f.x * R24f.z + R8f.z); +PV0f.w = R123f.w; +R126f.w = R6f.z * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R126f.w; +// 1 +PV1f.x = max(R4f.w, R9f.x); +R123f.y = (R2f.x * R9f.x + PV0f.y); +PV1f.y = R123f.y; +R126f.z = max(R2f.y, R9f.z); +R123f.w = (R2f.x * R9f.y + PV0f.z); +PV1f.w = R123f.w; +R122f.x = (R2f.x * R9f.z + PV0f.w); +PS1f = R122f.x; +// 2 +R123f.x = (R0f.w * R25f.z + PS1f); +PV0f.x = R123f.x; +R2f.y = max(PV1f.x, R3f.x); +R123f.z = (R0f.w * R25f.y + PV1f.w); +PV0f.z = R123f.z; +R123f.w = (R0f.w * R25f.x + PV1f.y); +PV0f.w = R123f.w; +R9f.x = max(R127f.x, R3f.y); +PS0f = R9f.x; +// 3 +backupReg0f = R3f.y; +backupReg1f = R3f.x; +backupReg2f = R3f.z; +R3f.x = (R0f.w * R3f.z + PV0f.x); +R3f.y = (R0f.w * backupReg0f + PV0f.z); +R3f.z = (R0f.w * backupReg1f + PV0f.w); +R0f.w = max(R126f.z, backupReg2f); +R7f.y = R0f.y + R1f.w; +PS1f = R7f.y; +// 4 +backupReg0f = R126f.w; +backupReg0f = R126f.w; +R8f.x = R10f.y * intBitsToFloat(uf_remappedPS[1].y); +PV0f.x = R8f.x; +R5f.y = R0f.y + -(R1f.w); +PV0f.z = R1f.y * intBitsToFloat(uf_remappedPS[0].z); +R126f.w = R6f.x + backupReg0f; +PV0f.w = R126f.w; +R2f.x = backupReg0f * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R2f.x; +// 5 +R1f.x = R0f.x + PV0f.w; +R9f.y = PV0f.x * intBitsToFloat(uf_remappedPS[1].y); +PV1f.y = R9f.y; +R6f.z = R0f.x + -(PV0f.w); +PV1f.w = R1f.w + PV0f.z; +R1f.w = PV0f.z * intBitsToFloat(uf_remappedPS[0].z); +PS1f = R1f.w; +// 6 +R6f.x = R0f.y + -(PV1f.w); +R1f.y = R0f.y + PV1f.w; +R9f.z = R126f.w + R2f.x; +R4f.w = PV1f.w + PS1f; +R8f.z = PV1f.y * intBitsToFloat(uf_remappedPS[1].y); +PS0f = R8f.z; +R26f.xyz = (texture(textureUnitPS0, R7f.xy).xyz); +R5f.xyz = (texture(textureUnitPS0, R5f.xy).xyz); +R27f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R6f.xyz = (texture(textureUnitPS0, R6f.zx).xyz); +// 0 +R123f.x = (R10f.y * R26f.z + R3f.x); +PV0f.x = R123f.x; +R127f.y = max(R0f.w, R5f.z); +R123f.z = (R10f.y * R26f.x + R3f.z); +PV0f.z = R123f.z; +R123f.w = (R10f.y * R26f.y + R3f.y); +PV0f.w = R123f.w; +R126f.y = R2f.x * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R126f.y; +// 1 +R123f.x = (R10f.y * R5f.y + PV0f.w); +PV1f.x = R123f.x; +PV1f.y = max(R9f.x, R5f.y); +PV1f.z = max(R2f.y, R5f.x); +R123f.w = (R10f.y * R5f.x + PV0f.z); +PV1f.w = R123f.w; +R122f.x = (R10f.y * R5f.z + PV0f.x); +PS1f = R122f.x; +// 2 +R123f.x = (R8f.x * R27f.x + PV1f.w); +PV0f.x = R123f.x; +R2f.y = max(PV1f.z, R6f.x); +R123f.z = (R8f.x * R27f.y + PV1f.x); +PV0f.z = R123f.z; +R123f.w = (R8f.x * R27f.z + PS1f); +PV0f.w = R123f.w; +R3f.z = max(PV1f.y, R6f.y); +PS0f = R3f.z; +// 3 +backupReg0f = R6f.z; +R5f.x = (R8f.x * R6f.x + PV0f.x); +R5f.y = max(R127f.y, R6f.z); +R6f.z = (R8f.x * backupReg0f + PV0f.w); +R0f.w = (R8f.x * R6f.y + PV0f.z); +R6f.x = R0f.x + R9f.z; +PS1f = R6f.x; +// 4 +backupReg0f = R9f.z; +R9f.x = R0f.x + -(R9f.z); +R6f.y = R0f.y + R4f.w; +R9f.z = R0f.y + -(R4f.w); +R126f.w = R1f.w * intBitsToFloat(uf_remappedPS[0].z); +PV0f.w = R126f.w; +R127f.w = backupReg0f + R126f.y; +PS0f = R127f.w; +// 5 +R8f.x = R0f.x + PS0f; +R3f.y = R8f.z * intBitsToFloat(uf_remappedPS[1].y); +PV1f.y = R3f.y; +R1f.z = R4f.w + PV0f.w; +PV1f.z = R1f.z; +R4f.w = R0f.x + -(PS0f); +R5f.z = R126f.y * intBitsToFloat(uf_remappedPS[0].z); +PS1f = R5f.z; +// 6 +R4f.x = R0f.y + -(PV1f.z); +R8f.y = R0f.y + PV1f.z; +R2f.z = R126f.w * intBitsToFloat(uf_remappedPS[0].z); +R1f.w = R127f.w + PS1f; +R3f.x = PV1f.y * intBitsToFloat(uf_remappedPS[1].y); +PS0f = R3f.x; +R28f.xyz = (texture(textureUnitPS0, R6f.xy).xyz); +R10f.xyz = (texture(textureUnitPS0, R9f.xz).xyz); +R29f.xyz = (texture(textureUnitPS0, R8f.xy).xyz); +R4f.xyz = (texture(textureUnitPS0, R4f.wx).xyz); +// 0 +R127f.x = max(R2f.y, R10f.x); +R123f.y = (R9f.y * R28f.x + R5f.x); +PV0f.y = R123f.y; +R123f.z = (R9f.y * R28f.y + R0f.w); +PV0f.z = R123f.z; +R123f.w = (R9f.y * R28f.z + R6f.z); +PV0f.w = R123f.w; +R127f.w = R5f.z * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R127f.w; +// 1 +R123f.x = (R9f.y * R10f.y + PV0f.z); +PV1f.x = R123f.x; +R123f.y = (R9f.y * R10f.x + PV0f.y); +PV1f.y = R123f.y; +R126f.z = max(R5f.y, R10f.z); +PV1f.w = max(R3f.z, R10f.y); +R122f.x = (R9f.y * R10f.z + PV0f.w); +PS1f = R122f.x; +// 2 +R123f.x = (R8f.z * R29f.z + PS1f); +PV0f.x = R123f.x; +R10f.y = max(R127f.x, R4f.x); +R123f.z = (R8f.z * R29f.y + PV1f.x); +PV0f.z = R123f.z; +R123f.w = (R8f.z * R29f.x + PV1f.y); +PV0f.w = R123f.w; +R8f.x = max(PV1f.w, R4f.y); +PS0f = R8f.x; +// 3 +backupReg0f = R4f.z; +R10f.x = (R8f.z * R4f.z + PV0f.x); +R9f.y = (R8f.z * R4f.y + PV0f.z); +R4f.z = (R8f.z * R4f.x + PV0f.w); +R0f.w = max(R126f.z, backupReg0f); +R4f.x = R0f.x + R1f.w; +PS1f = R4f.x; +// 4 +R1f.x = R0f.x + -(R1f.w); +R8f.y = R1f.w + R127f.w; +PV0f.y = R8f.y; +R126f.z = R2f.z * intBitsToFloat(uf_remappedPS[0].z); +PV0f.z = R126f.z; +PV0f.w = R1f.z + R2f.z; +R6f.y = R3f.x * intBitsToFloat(uf_remappedPS[1].y); +PS0f = R6f.y; +// 5 +R5f.x = R0f.x + PV0f.y; +R4f.y = R0f.y + PV0f.w; +R1f.z = R0f.y + -(PV0f.w); +R1f.w = PV0f.w + PV0f.z; +PV1f.w = R1f.w; +R2f.x = R0f.x + -(PV0f.y); +PS1f = R2f.x; +// 6 +R9f.x = R127f.w * intBitsToFloat(uf_remappedPS[0].z); +R5f.y = R0f.y + PV1f.w; +R2f.z = R0f.y + -(PV1f.w); +R4f.w = R126f.z * intBitsToFloat(uf_remappedPS[0].z); +R3f.z = R6f.y * intBitsToFloat(uf_remappedPS[1].y); +PS0f = R3f.z; +R30f.xyz = (texture(textureUnitPS0, R4f.xy).xyz); +R1f.xyz = (texture(textureUnitPS0, R1f.xz).xyz); +R31f.xyz = (texture(textureUnitPS0, R5f.xy).xyz); +R2f.xyz = (texture(textureUnitPS0, R2f.xz).xyz); +// 0 +R123f.x = (R3f.y * R30f.z + R10f.x); +PV0f.x = R123f.x; +R126f.y = max(R0f.w, R1f.z); +R123f.z = (R3f.y * R30f.x + R4f.z); +PV0f.z = R123f.z; +R123f.w = (R3f.y * R30f.y + R9f.y); +PV0f.w = R123f.w; +R127f.w = R1f.w + R4f.w; +PS0f = R127f.w; +// 1 +R123f.x = (R3f.y * R1f.y + PV0f.w); +PV1f.x = R123f.x; +PV1f.y = max(R8f.x, R1f.y); +PV1f.z = max(R10f.y, R1f.x); +R123f.w = (R3f.y * R1f.x + PV0f.z); +PV1f.w = R123f.w; +R122f.x = (R3f.y * R1f.z + PV0f.x); +PS1f = R122f.x; +// 2 +R123f.x = (R3f.x * R31f.x + PV1f.w); +PV0f.x = R123f.x; +R1f.y = max(PV1f.z, R2f.x); +R123f.z = (R3f.x * R31f.y + PV1f.x); +PV0f.z = R123f.z; +R123f.w = (R3f.x * R31f.z + PS1f); +PV0f.w = R123f.w; +R8f.z = max(PV1f.y, R2f.y); +PS0f = R8f.z; +// 3 +backupReg0f = R3f.x; +backupReg0f = R3f.x; +backupReg0f = R3f.x; +backupReg1f = R8f.y; +R3f.x = (backupReg0f * R2f.x + PV0f.x); +R8f.y = max(R126f.y, R2f.z); +R1f.z = (backupReg0f * R2f.z + PV0f.w); +R0f.w = (backupReg0f * R2f.y + PV0f.z); +R126f.z = backupReg1f + R9f.x; +PS1f = R126f.z; +// 4 +backupReg0f = R9f.x; +R9f.x = R0f.x + PS1f; +R9f.y = R0f.y + R127f.w; +R2f.z = R0f.x + -(PS1f); +R2f.w = R0f.y + -(R127f.w); +PS0f = backupReg0f * intBitsToFloat(uf_remappedPS[0].z); +// 5 +PV1f.x = R4f.w * intBitsToFloat(uf_remappedPS[0].z); +R4f.y = R3f.z * intBitsToFloat(uf_remappedPS[1].y); +R4f.z = PS0f * intBitsToFloat(uf_remappedPS[0].z); +PV1f.z = R4f.z; +PV1f.w = R126f.z + PS0f; +// 6 +R2f.x = R0f.x + PV1f.w; +R3f.y = PV1f.x * intBitsToFloat(uf_remappedPS[0].z); +PV0f.y = R3f.y; +PV0f.z = R127f.w + PV1f.x; +R4f.w = R0f.x + -(PV1f.w); +R1f.x = PV1f.w + PV1f.z; +PS0f = R1f.x; +// 7 +R4f.x = R0f.y + -(PV0f.z); +R2f.y = R0f.y + PV0f.z; +R10f.z = R0f.x + PS0f; +R1f.w = PV0f.z + PV0f.y; +R5f.x = R0f.x + -(PS0f); +PS1f = R5f.x; +R32f.xyz = (texture(textureUnitPS0, R9f.xy).xyz); +R9f.xyz = (texture(textureUnitPS0, R2f.zw).xyz); +R33f.xyz = (texture(textureUnitPS0, R2f.xy).xyz); +R2f.xyz = (texture(textureUnitPS0, R4f.wx).xyz); +// 0 +R127f.x = max(R1f.y, R9f.x); +R123f.y = (R6f.y * R32f.x + R3f.x); +PV0f.y = R123f.y; +R123f.z = (R6f.y * R32f.y + R0f.w); +PV0f.z = R123f.z; +R123f.w = (R6f.y * R32f.z + R1f.z); +PV0f.w = R123f.w; +R127f.w = R4f.z * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R127f.w; +// 1 +R123f.x = (R6f.y * R9f.y + PV0f.z); +PV1f.x = R123f.x; +R123f.y = (R6f.y * R9f.x + PV0f.y); +PV1f.y = R123f.y; +R126f.z = max(R8f.y, R9f.z); +PV1f.w = max(R8f.z, R9f.y); +R122f.x = (R6f.y * R9f.z + PV0f.w); +PS1f = R122f.x; +// 2 +R123f.x = (R3f.z * R33f.z + PS1f); +PV0f.x = R123f.x; +R6f.y = max(R127f.x, R2f.x); +R123f.z = (R3f.z * R33f.y + PV1f.x); +PV0f.z = R123f.z; +R123f.w = (R3f.z * R33f.x + PV1f.y); +PV0f.w = R123f.w; +R4f.x = max(PV1f.w, R2f.y); +PS0f = R4f.x; +// 3 +backupReg0f = R2f.y; +backupReg1f = R3f.z; +R9f.x = (R3f.z * R2f.z + PV0f.x); +R2f.y = (R3f.z * backupReg0f + PV0f.z); +R3f.z = (backupReg1f * R2f.x + PV0f.w); +R0f.w = max(R126f.z, R2f.z); +R10f.y = R0f.y + R1f.w; +PS1f = R10f.y; +// 4 +backupReg0f = R127f.w; +backupReg0f = R127f.w; +R8f.x = R4f.y * intBitsToFloat(uf_remappedPS[1].y); +PV0f.x = R8f.x; +R5f.y = R0f.y + -(R1f.w); +PV0f.z = R3f.y * intBitsToFloat(uf_remappedPS[0].z); +R127f.w = R1f.x + backupReg0f; +PV0f.w = R127f.w; +R3f.x = backupReg0f * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R3f.x; +// 5 +R1f.x = R0f.x + PV0f.w; +R3f.y = PV0f.x * intBitsToFloat(uf_remappedPS[1].y); +PV1f.y = R3f.y; +R2f.z = R0f.x + -(PV0f.w); +PV1f.w = R1f.w + PV0f.z; +R1f.w = PV0f.z * intBitsToFloat(uf_remappedPS[0].z); +PS1f = R1f.w; +// 6 +R2f.x = R0f.y + -(PV1f.w); +R1f.y = R0f.y + PV1f.w; +R8f.z = R127f.w + R3f.x; +R4f.w = PV1f.w + PS1f; +R9f.z = PV1f.y * intBitsToFloat(uf_remappedPS[1].y); +PS0f = R9f.z; +R34f.xyz = (texture(textureUnitPS0, R10f.zy).xyz); +R5f.xyz = (texture(textureUnitPS0, R5f.xy).xyz); +R35f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R1f.xyz = (texture(textureUnitPS0, R2f.zx).xyz); +// 0 +R123f.x = (R4f.y * R34f.z + R9f.x); +PV0f.x = R123f.x; +R126f.y = max(R0f.w, R5f.z); +R123f.z = (R4f.y * R34f.x + R3f.z); +PV0f.z = R123f.z; +R123f.w = (R4f.y * R34f.y + R2f.y); +PV0f.w = R123f.w; +R127f.y = R3f.x * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R127f.y; +// 1 +R123f.x = (R4f.y * R5f.y + PV0f.w); +PV1f.x = R123f.x; +PV1f.y = max(R4f.x, R5f.y); +PV1f.z = max(R6f.y, R5f.x); +R123f.w = (R4f.y * R5f.x + PV0f.z); +PV1f.w = R123f.w; +R122f.x = (R4f.y * R5f.z + PV0f.x); +PS1f = R122f.x; +// 2 +R123f.x = (R8f.x * R35f.x + PV1f.w); +PV0f.x = R123f.x; +R5f.y = max(PV1f.z, R1f.x); +R123f.z = (R8f.x * R35f.y + PV1f.x); +PV0f.z = R123f.z; +R123f.w = (R8f.x * R35f.z + PS1f); +PV0f.w = R123f.w; +R3f.z = max(PV1f.y, R1f.y); +PS0f = R3f.z; +// 3 +backupReg0f = R1f.z; +R3f.x = (R8f.x * R1f.x + PV0f.x); +R6f.y = max(R126f.y, R1f.z); +R1f.z = (R8f.x * backupReg0f + PV0f.w); +R0f.w = (R8f.x * R1f.y + PV0f.z); +R1f.x = R0f.x + R8f.z; +PS1f = R1f.x; +// 4 +backupReg0f = R8f.z; +R8f.x = R0f.x + -(R8f.z); +R1f.y = R0f.y + R4f.w; +R8f.z = R0f.y + -(R4f.w); +R127f.w = R1f.w * intBitsToFloat(uf_remappedPS[0].z); +PV0f.w = R127f.w; +R126f.w = backupReg0f + R127f.y; +PS0f = R126f.w; +// 5 +R4f.x = R0f.x + PS0f; +R2f.y = R9f.z * intBitsToFloat(uf_remappedPS[1].y); +PV1f.y = R2f.y; +R2f.z = R4f.w + PV0f.w; +PV1f.z = R2f.z; +R5f.w = R0f.x + -(PS0f); +R5f.z = R127f.y * intBitsToFloat(uf_remappedPS[0].z); +PS1f = R5f.z; +// 6 +R5f.x = R0f.y + -(PV1f.z); +R4f.y = R0f.y + PV1f.z; +R10f.z = R127f.w * intBitsToFloat(uf_remappedPS[0].z); +R4f.w = R126f.w + PS1f; +R6f.x = PV1f.y * intBitsToFloat(uf_remappedPS[1].y); +PS0f = R6f.x; +R36f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R8f.xyz = (texture(textureUnitPS0, R8f.xz).xyz); +R37f.xyz = (texture(textureUnitPS0, R4f.xy).xyz); +R4f.xyz = (texture(textureUnitPS0, R5f.wx).xyz); +// 0 +R127f.x = max(R5f.y, R8f.x); +R123f.y = (R3f.y * R36f.x + R3f.x); +PV0f.y = R123f.y; +R123f.z = (R3f.y * R36f.y + R0f.w); +PV0f.z = R123f.z; +R123f.w = (R3f.y * R36f.z + R1f.z); +PV0f.w = R123f.w; +R127f.w = R5f.z * intBitsToFloat(uf_remappedPS[0].z); +PS0f = R127f.w; +// 1 +R123f.x = (R3f.y * R8f.y + PV0f.z); +PV1f.x = R123f.x; +R123f.y = (R3f.y * R8f.x + PV0f.y); +PV1f.y = R123f.y; +R126f.z = max(R6f.y, R8f.z); +PV1f.w = max(R3f.z, R8f.y); +R122f.x = (R3f.y * R8f.z + PV0f.w); +PS1f = R122f.x; +// 2 +R123f.x = (R9f.z * R37f.z + PS1f); +PV0f.x = R123f.x; +R8f.y = max(R127f.x, R4f.x); +R123f.z = (R9f.z * R37f.y + PV1f.x); +PV0f.z = R123f.z; +R123f.w = (R9f.z * R37f.x + PV1f.y); +PV0f.w = R123f.w; +R5f.x = max(PV1f.w, R4f.y); +PS0f = R5f.x; +// 3 +backupReg0f = R4f.z; +R8f.x = (R9f.z * R4f.z + PV0f.x); +R6f.y = (R9f.z * R4f.y + PV0f.z); +R4f.z = (R9f.z * R4f.x + PV0f.w); +R0f.w = max(R126f.z, backupReg0f); +R4f.x = R0f.x + R4f.w; +PS1f = R4f.x; +// 4 +R2f.x = R0f.x + -(R4f.w); +R5f.y = R4f.w + R127f.w; +PV0f.y = R5f.y; +R126f.z = R10f.z * intBitsToFloat(uf_remappedPS[0].z); +PV0f.z = R126f.z; +PV0f.w = R2f.z + R10f.z; +R7f.y = R6f.x * intBitsToFloat(uf_remappedPS[1].y); +PS0f = R7f.y; +// 5 +R3f.x = R0f.x + PV0f.y; +R4f.y = R0f.y + PV0f.w; +R2f.z = R0f.y + -(PV0f.w); +R4f.w = PV0f.w + PV0f.z; +PV1f.w = R4f.w; +R10f.x = R0f.x + -(PV0f.y); +PS1f = R10f.x; +// 6 +R1f.x = R127f.w * intBitsToFloat(uf_remappedPS[0].z); +R3f.y = R0f.y + PV1f.w; +R10f.z = R0f.y + -(PV1f.w); +R5f.w = R126f.z * intBitsToFloat(uf_remappedPS[0].z); +R3f.z = R7f.y * intBitsToFloat(uf_remappedPS[1].y); +PS0f = R3f.z; +R38f.xyz = (texture(textureUnitPS0, R4f.xy).xyz); +R9f.xyz = (texture(textureUnitPS0, R2f.xz).xyz); +R39f.xyz = (texture(textureUnitPS0, R3f.xy).xyz); +R10f.xyz = (texture(textureUnitPS0, R10f.xz).xyz); +// 0 +R123f.x = (R2f.y * R38f.z + R8f.x); +PV0f.x = R123f.x; +R127f.y = max(R0f.w, R9f.z); +R123f.z = (R2f.y * R38f.x + R4f.z); +PV0f.z = R123f.z; +R123f.w = (R2f.y * R38f.y + R6f.y); +PV0f.w = R123f.w; +R127f.w = R4f.w + R5f.w; +PS0f = R127f.w; +// 1 +R123f.x = (R2f.y * R9f.y + PV0f.w); +PV1f.x = R123f.x; +PV1f.y = max(R5f.x, R9f.y); +PV1f.z = max(R8f.y, R9f.x); +R123f.w = (R2f.y * R9f.x + PV0f.z); +PV1f.w = R123f.w; +R122f.x = (R2f.y * R9f.z + PV0f.x); +PS1f = R122f.x; +// 2 +R123f.x = (R6f.x * R39f.x + PV1f.w); +PV0f.x = R123f.x; +R8f.y = max(PV1f.z, R10f.x); +R123f.z = (R6f.x * R39f.y + PV1f.x); +PV0f.z = R123f.z; +R123f.w = (R6f.x * R39f.z + PS1f); +PV0f.w = R123f.w; +R4f.z = max(PV1f.y, R10f.y); +PS0f = R4f.z; +// 3 +backupReg0f = R6f.x; +backupReg0f = R6f.x; +backupReg0f = R6f.x; +backupReg1f = R10f.y; +R6f.x = (backupReg0f * R10f.x + PV0f.x); +R10f.y = max(R127f.y, R10f.z); +R9f.z = (backupReg0f * R10f.z + PV0f.w); +R0f.w = (backupReg0f * backupReg1f + PV0f.z); +PS1f = R5f.y + R1f.x; +// 4 +backupReg0f = R1f.x; +R1f.x = R0f.x + PS1f; +R1f.y = R0f.y + R127f.w; +R10f.z = R0f.x + -(PS1f); +R10f.w = R0f.y + -(R127f.w); +R122f.x = (backupReg0f * intBitsToFloat(uf_remappedPS[0].z) + PS1f); +PS0f = R122f.x; +// 5 +R5f.x = R0f.x + PS0f; +PV1f.y = max(R11f.x, R12f.x); +R2f.z = R0f.x + -(PS0f); +R123f.w = (R5f.w * intBitsToFloat(uf_remappedPS[0].z) + R127f.w); +PV1f.w = R123f.w; +PS1f = max(R11f.y, R12f.y); +// 6 +backupReg0f = R11f.z; +R0f.x = max(R13f.x, PV1f.y); +R5f.y = R0f.y + PV1f.w; +R11f.z = max(backupReg0f, R12f.z); +R5f.w = max(R13f.y, PS1f); +R2f.y = R0f.y + -(PV1f.w); +PS0f = R2f.y; +R12f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R1f.xyz = (texture(textureUnitPS0, R10f.zw).xyz); +R5f.xyz = (texture(textureUnitPS0, R5f.xy).xyz); +R2f.xyz = (texture(textureUnitPS0, R2f.zy).xyz); +// 0 +backupReg0f = R0f.x; +PV0f.x = max(R14f.y, R5f.w); +PV0f.y = max(R14f.x, backupReg0f); +PV0f.z = max(R13f.z, R11f.z); +R127f.w = (R7f.y * R12f.y + R0f.w); +// 1 +R127f.x = (R7f.y * R12f.x + R6f.x); +PV1f.y = max(R15f.y, PV0f.x); +PV1f.z = max(R15f.x, PV0f.y); +PV1f.w = max(R14f.z, PV0f.z); +R126f.w = (R7f.y * R12f.z + R9f.z); +PS1f = R126f.w; +// 2 +PV0f.x = max(R15f.z, PV1f.w); +R126f.y = max(R8f.y, R1f.x); +PV0f.z = max(R16f.y, PV1f.y); +PV0f.w = max(R16f.x, PV1f.z); +R125f.w = max(R4f.z, R1f.y); +PS0f = R125f.w; +// 3 +PV1f.x = max(R17f.x, PV0f.w); +PV1f.y = max(R16f.z, PV0f.x); +R127f.z = max(R10f.y, R1f.z); +PV1f.w = max(R17f.y, PV0f.z); +R127f.y = (R7f.y * R1f.x + R127f.x); +PS1f = R127f.y; +// 4 +PV0f.x = max(R18f.y, PV1f.w); +PV0f.y = max(R18f.x, PV1f.x); +PV0f.z = max(R17f.z, PV1f.y); +R123f.w = (R7f.y * R1f.y + R127f.w); +PV0f.w = R123f.w; +R127f.w = (R7f.y * R1f.z + R126f.w); +PS0f = R127f.w; +// 5 +R127f.x = (R3f.z * R5f.x + R127f.y); +PV1f.y = max(R19f.y, PV0f.x); +PV1f.z = max(R19f.x, PV0f.y); +PV1f.w = max(R18f.z, PV0f.z); +R126f.z = (R3f.z * R5f.y + PV0f.w); +PS1f = R126f.z; +// 6 +PV0f.x = max(R19f.z, PV1f.w); +R127f.y = (R3f.z * R5f.z + R127f.w); +PV0f.z = max(R20f.y, PV1f.y); +PV0f.w = max(R20f.x, PV1f.z); +// 7 +PV1f.x = max(R21f.x, PV0f.w); +PV1f.y = max(R20f.z, PV0f.x); +PV1f.w = max(R21f.y, PV0f.z); +// 8 +PV0f.x = max(R22f.y, PV1f.w); +PV0f.y = max(R22f.x, PV1f.x); +PV0f.z = max(R21f.z, PV1f.y); +// 9 +PV1f.y = max(R23f.y, PV0f.x); +PV1f.z = max(R23f.x, PV0f.y); +PV1f.w = max(R22f.z, PV0f.z); +// 10 +PV0f.x = max(R23f.z, PV1f.w); +PV0f.z = max(R24f.y, PV1f.y); +PV0f.w = max(R24f.x, PV1f.z); +// 11 +backupReg0f = R126f.z; +PV1f.x = max(R25f.x, PV0f.w); +PV1f.y = max(R24f.z, PV0f.x); +R126f.z = (R3f.z * R2f.x + R127f.x); +PV1f.w = max(R25f.y, PV0f.z); +R125f.z = (R3f.z * R2f.y + backupReg0f); +PS1f = R125f.z; +// 12 +PV0f.x = max(R26f.y, PV1f.w); +PV0f.y = max(R26f.x, PV1f.x); +PV0f.z = max(R25f.z, PV1f.y); +R127f.w = (R3f.z * R2f.z + R127f.y); +// 13 +PV1f.y = max(R27f.y, PV0f.x); +PV1f.z = max(R27f.x, PV0f.y); +PV1f.w = max(R26f.z, PV0f.z); +// 14 +PV0f.x = max(R27f.z, PV1f.w); +PV0f.z = max(R28f.y, PV1f.y); +PV0f.w = max(R28f.x, PV1f.z); +// 15 +PV1f.x = max(R29f.x, PV0f.w); +PV1f.y = max(R28f.z, PV0f.x); +PV1f.w = max(R29f.y, PV0f.z); +// 16 +PV0f.x = max(R30f.y, PV1f.w); +PV0f.y = max(R30f.x, PV1f.x); +PV0f.z = max(R29f.z, PV1f.y); +R29f.w = 1.0; +// 17 +PV1f.y = max(R31f.y, PV0f.x); +PV1f.z = max(R31f.x, PV0f.y); +PV1f.w = max(R30f.z, PV0f.z); +// 18 +PV0f.x = max(R31f.z, PV1f.w); +PV0f.z = max(R32f.y, PV1f.y); +PV0f.w = max(R32f.x, PV1f.z); +// 19 +PV1f.x = max(R33f.x, PV0f.w); +PV1f.y = max(R32f.z, PV0f.x); +PV1f.w = max(R33f.y, PV0f.z); +// 20 +PV0f.x = max(R34f.y, PV1f.w); +PV0f.y = max(R34f.x, PV1f.x); +PV0f.z = max(R33f.z, PV1f.y); +// 21 +PV1f.y = max(R35f.y, PV0f.x); +PV1f.z = max(R35f.x, PV0f.y); +PV1f.w = max(R34f.z, PV0f.z); +// 22 +PV0f.x = max(R35f.z, PV1f.w); +PV0f.z = max(R36f.y, PV1f.y); +PV0f.w = max(R36f.x, PV1f.z); +// 23 +PV1f.x = max(R37f.x, PV0f.w); +PV1f.y = max(R36f.z, PV0f.x); +PV1f.w = max(R37f.y, PV0f.z); +// 24 +PV0f.x = max(R38f.y, PV1f.w); +PV0f.y = max(R38f.x, PV1f.x); +PV0f.z = max(R37f.z, PV1f.y); +// 25 +PV1f.y = max(R39f.y, PV0f.x); +PV1f.z = max(R39f.x, PV0f.y); +PV1f.w = max(R38f.z, PV0f.z); +// 26 +PV0f.x = max(R39f.z, PV1f.w); +PV0f.z = max(R12f.y, PV1f.y); +PV0f.w = max(R12f.x, PV1f.z); +// 27 +PV1f.x = max(R5f.x, PV0f.w); +PV1f.y = max(R12f.z, PV0f.x); +PV1f.w = max(R5f.y, PV0f.z); +// 28 +PV0f.x = max(R2f.y, PV1f.w); +PV0f.y = max(R2f.x, PV1f.x); +PV0f.z = max(R5f.z, PV1f.y); +// 29 +PV1f.y = max(R125f.w, PV0f.x); +PV1f.z = max(R126f.y, PV0f.y); +PV1f.w = max(R2f.z, PV0f.z); +// 30 +PV0f.x = max(R127f.z, PV1f.w); +PV0f.y = PV1f.z + -(R126f.z); +PV0f.w = PV1f.y + -(R125f.z); +// 31 +R123f.x = (PV0f.w * intBitsToFloat(0x3ecccccd) + R125f.z); +PV1f.x = R123f.x; +R123f.y = (PV0f.y * intBitsToFloat(0x3ecccccd) + R126f.z); +PV1f.y = R123f.y; +PV1f.z = PV0f.x + -(R127f.w); +// 32 +PV0f.y = PV1f.x * intBitsToFloat(uf_remappedPS[1].z); +PV0f.z = PV1f.y * intBitsToFloat(uf_remappedPS[1].z); +R123f.w = (PV1f.z * intBitsToFloat(0x3ecccccd) + R127f.w); +PV0f.w = R123f.w; +// 33 +R2f.x = PV0f.w * intBitsToFloat(uf_remappedPS[1].z); +R29f.y = min(PV0f.y, intBitsToFloat(uf_remappedPS[1].w)); +R29f.x = min(PV0f.z, intBitsToFloat(uf_remappedPS[1].w)); +PS1f = R29f.x; +// 34 +R29f.z = min(R2f.x, intBitsToFloat(uf_remappedPS[1].w)); +// export +passPixelColor0 = vec4(R29f.x, R29f.y, R29f.z, R29f.w); +} diff --git a/Source/XenobladeX/3cc7e98f78c258b4_00000000000003ca_ps.txt b/Source/XenobladeX/3cc7e98f78c258b4_00000000000003ca_ps.txt new file mode 100644 index 00000000..d24f3265 --- /dev/null +++ b/Source/XenobladeX/3cc7e98f78c258b4_00000000000003ca_ps.txt @@ -0,0 +1,78 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 3cc7e98f78c258b4 // brightness workaround. +// To-do, .5 is daylight and 1.0 night is wiiu "correct" for nvidia +// changes here in turn "breaks" bloom as they over or under expose depending on day/night + +const float preExposure = 0.55; // old brigntess tweak. Truncates at around .45+ +const float gammaPostExposure = 1.1; // compensate pre exposure, but loss of contrast when positive. +uniform ivec4 uf_remappedPS[1]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 1) uniform sampler3D textureUnitPS1;// Tex1 addr 0x2603b000 res 16x16x16 dim 2 tm: 7 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x10) Sampler1 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz) * preExposure; +// 0 +R127f.x = R0f.z * intBitsToFloat(uf_remappedPS[0].x); +R127f.x = clamp(R127f.x, 0.0, 1.0); +R127f.y = R0f.y * intBitsToFloat(uf_remappedPS[0].x); +R127f.y = clamp(R127f.y, 0.0, 1.0); +PV0f.z = R0f.x * intBitsToFloat(uf_remappedPS[0].x); +PV0f.z = clamp(PV0f.z, 0.0, 1.0); +R1f.w = 1.0; +// 1 +tempResultf = log2(PV0f.z); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS1f = tempResultf; +// 2 +R127f.z = PS1f * intBitsToFloat(0x3ee8ba2e); +tempResultf = log2(R127f.y); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0f = tempResultf; +// 3 +R127f.w = PS0f * intBitsToFloat(0x3ee8ba2e); +tempResultf = log2(R127f.x); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS1f = tempResultf; +// 4 +R127f.x = PS1f * intBitsToFloat(0x3ee8ba2e); +PS0f = exp2(R127f.z); +// 5 +R0f.x = (PS0f * intBitsToFloat(uf_remappedPS[0].z) + intBitsToFloat(uf_remappedPS[0].w)); +PS1f = exp2(R127f.w); +// 6 +R0f.y = (PS1f * intBitsToFloat(uf_remappedPS[0].z) + intBitsToFloat(uf_remappedPS[0].w)); +PS0f = exp2(R127f.x); +// 7 +R0f.z = (PS0f * intBitsToFloat(uf_remappedPS[0].z) + intBitsToFloat(uf_remappedPS[0].w)); +R1f.xyz = (texture(textureUnitPS1, vec3(R0f.x,R0f.y,R0f.z)).xyz); +// export +R1f = vec4(pow(R1f.xyz, vec3(1. / gammaPostExposure)), 1.0); +passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +} diff --git a/Source/XenobladeX/59df1c7e1806366c_00000000000003c9_ps.txt b/Source/XenobladeX/59df1c7e1806366c_00000000000003c9_ps.txt new file mode 100644 index 00000000..49d1cd0a --- /dev/null +++ b/Source/XenobladeX/59df1c7e1806366c_00000000000003c9_ps.txt @@ -0,0 +1,223 @@ + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 59df1c7e1806366c +// aa-restore. Intial version +//To - do //R2i.xyzw is possible a cemu bug. Replace with Alex FXAA +const float resScale = ; +//const float resScale = 3.0; +uniform ivec4 uf_remappedPS[2]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4e12000 res 1280x720x1 dim 1 tm: 4 format 0001 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 0) out vec4 passPixelColor0; + +uniform vec2 uf_fragCoordScale; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R3i = ivec4(0); +ivec4 R4i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R126i = ivec4(0); +ivec4 R127i = ivec4(0); +int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i; +ivec4 PV0i = ivec4(0), PV1i = ivec4(0); +int PS0i = 0, PS1i = 0; +ivec4 tempi = ivec4(0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +bool activeMaskStack[2]; +bool activeMaskStackC[3]; +activeMaskStack[0] = false; +activeMaskStackC[0] = false; +activeMaskStackC[1] = false; +activeMaskStack[0] = true; +activeMaskStackC[0] = true; +activeMaskStackC[1] = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = floatBitsToInt(passParameterSem0); +R1i = floatBitsToInt(passParameterSem1); +if( activeMaskStackC[1] == true ) { +//R2i.xyzw = floatBitsToInt(textureGather(textureUnitPS0, intBitsToFloat(R0i.zw)).xyzw); // cemu bug? Review later +R0i.x = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R1i.xy)).x); // edge blur/chromatic +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +backupReg0i = R2i.x; +R2i.x = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(0x3aaaaaab)); //0.0026041667 / 2 0x3aaaaaab +PV0i.x = R2i.x; +R127i.y = floatBitsToInt(max(intBitsToFloat(R2i.y), intBitsToFloat(R2i.w))); +R127i.z = floatBitsToInt(min(intBitsToFloat(R2i.y), intBitsToFloat(R2i.w))); +// 1 +PV1i.y = floatBitsToInt(min(intBitsToFloat(R2i.z), intBitsToFloat(PV0i.x))); +PV1i.w = floatBitsToInt(max(intBitsToFloat(R2i.z), intBitsToFloat(PV0i.x))); +// 2 +R4i.y = floatBitsToInt(max(intBitsToFloat(R127i.y), intBitsToFloat(PV1i.w))); +PV0i.y = R4i.y; +R4i.z = floatBitsToInt(min(intBitsToFloat(R127i.z), intBitsToFloat(PV1i.y))); +PV0i.z = R4i.z; +// 3 +backupReg0i = R0i.x; +backupReg0i = R0i.x; +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedPS[0].x)/resScale); +PV1i.y = floatBitsToInt(max(intBitsToFloat(backupReg0i), intBitsToFloat(PV0i.y))); +PV1i.z = floatBitsToInt(min(intBitsToFloat(backupReg0i), intBitsToFloat(PV0i.z))); +// 4 +R0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.z)) + intBitsToFloat(PV1i.y)); +R0i.w = floatBitsToInt(max(intBitsToFloat(PV1i.x), intBitsToFloat(uf_remappedPS[0].y))); +// 5 +backupReg0i = R0i.x; +predResult = (intBitsToFloat(R0i.w) > intBitsToFloat(backupReg0i)); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +if( (0 == 0)) discard; +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +R127i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(R2i.w)),vec4(-(1.0),1.0,1.0,-(1.0)))); +PV0i.x = R127i.x; +PV0i.y = R127i.x; +PV0i.z = R127i.x; +PV0i.w = R127i.x; +R127i.z = 0; +PS0i = R127i.z; +// 1 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(R2i.w)),vec4(-(1.0),1.0,-(1.0),1.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.y = tempi.x; +R4i.w = 0x3f800000; +PS1i = R4i.w; +// 2 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(PV1i.x),intBitsToFloat(R127i.z),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(PV1i.x),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +// 3 +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +PS1i = floatBitsToInt(tempResultf); +// 4 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PS1i)); +PV0i.x = R127i.x; +R127i.w = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(PS1i)); +PV0i.w = R127i.w; +// 5 +PV1i.x = floatBitsToInt(max(intBitsToFloat(PV0i.x), -(intBitsToFloat(PV0i.x)))); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.w) * intBitsToFloat(uf_remappedPS[1].y)/ resScale); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedPS[1].x)/ resScale); +PV1i.w = floatBitsToInt(max(intBitsToFloat(PV0i.w), -(intBitsToFloat(PV0i.w)))); +// 6 +R0i.x = floatBitsToInt(intBitsToFloat(R1i.x) + -(intBitsToFloat(PV1i.z))); +R0i.y = floatBitsToInt(intBitsToFloat(R1i.y) + -(intBitsToFloat(PV1i.y))); +PV0i.z = floatBitsToInt(min(intBitsToFloat(PV1i.x), intBitsToFloat(PV1i.w))); +R2i.w = floatBitsToInt(intBitsToFloat(R1i.x) + intBitsToFloat(PV1i.z)); +R2i.y = floatBitsToInt(intBitsToFloat(R1i.y) + intBitsToFloat(PV1i.y)); +PS0i = R2i.y; +// 7 +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedPS[0].z)/ resScale); +// 8 +PS0i = floatBitsToInt(1.0 / intBitsToFloat(PV1i.y)); +// 9 +PV1i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS0i)); +PV1i.w = floatBitsToInt(intBitsToFloat(R127i.x) * intBitsToFloat(PS0i)); +// 10 +PV0i.x = floatBitsToInt(max(intBitsToFloat(PV1i.z), intBitsToFloat(0xc0000000))); +PV0i.y = floatBitsToInt(max(intBitsToFloat(PV1i.w), intBitsToFloat(0xc0000000))); +// 11 +PV1i.z = floatBitsToInt(min(intBitsToFloat(PV0i.x), 2.0)); +PV1i.w = floatBitsToInt(min(intBitsToFloat(PV0i.y), 2.0)); +// 12 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.z) * intBitsToFloat(uf_remappedPS[1].w)/ resScale); +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedPS[1].z)/ resScale); +// 13 +backupReg0i = R1i.x; +backupReg1i = R1i.y; +backupReg0i = R1i.x; +backupReg1i = R1i.y; +R1i.x = floatBitsToInt(intBitsToFloat(backupReg0i) + -(intBitsToFloat(PV0i.w))); +R1i.y = floatBitsToInt(intBitsToFloat(backupReg1i) + -(intBitsToFloat(PV0i.x))); +R0i.z = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(PV0i.w)); +R0i.w = floatBitsToInt(intBitsToFloat(backupReg1i) + intBitsToFloat(PV0i.x)); +} +if( activeMaskStackC[1] == true ) { +R1i.xyz = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R1i.xy)).xyz); +R3i.xyz = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R0i.zw)).xyz); +R0i.xyz = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R0i.xy)).xyz); +R2i.xyz = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R2i.wy)).xyz); +} +if( activeMaskStackC[1] == true ) { +// 0 +R127i.x = floatBitsToInt(intBitsToFloat(R1i.z) + intBitsToFloat(R3i.z)); +PV0i.y = floatBitsToInt(intBitsToFloat(R1i.y) + intBitsToFloat(R3i.y)); +PV0i.z = floatBitsToInt(intBitsToFloat(R1i.x) + intBitsToFloat(R3i.x)); +// 1 +backupReg0i = R0i.x; +PV1i.x = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(R2i.x)); +R127i.y = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(R2i.z)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) * 0.25); +PV1i.w = floatBitsToInt(intBitsToFloat(R0i.y) + intBitsToFloat(R2i.y)); +PS1i = floatBitsToInt(intBitsToFloat(PV0i.z) * 0.25); +// 2 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * 0.25 + intBitsToFloat(PS1i))); +PV0i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * 0.25); +R127i.z = PV1i.x; +R127i.z = floatBitsToInt(intBitsToFloat(R127i.z) / 2.0); +R127i.w = floatBitsToInt((intBitsToFloat(PV1i.w) * 0.25 + intBitsToFloat(PV1i.z))); +PV0i.w = R127i.w; +R126i.y = PV1i.w; +R126i.y = floatBitsToInt(intBitsToFloat(R126i.y) / 2.0); +PS0i = R126i.y; +// 3 +PV1i.x = ((intBitsToFloat(PV0i.w) > intBitsToFloat(R4i.y))?int(0xFFFFFFFF):int(0x0)); +PV1i.y = ((intBitsToFloat(R4i.z) > intBitsToFloat(PV0i.w))?int(0xFFFFFFFF):int(0x0)); +R126i.z = floatBitsToInt((intBitsToFloat(R127i.y) * 0.25 + intBitsToFloat(PV0i.y))); +R126i.w = R127i.y; +R126i.w = floatBitsToInt(intBitsToFloat(R126i.w) / 2.0); +// 4 +R123i.w = ((PV1i.y == 0)?(PV1i.x):(int(-1))); +PV0i.w = R123i.w; +// 5 +R4i.x = ((PV0i.w == 0)?(R127i.x):(R127i.z)); +R4i.y = ((PV0i.w == 0)?(R127i.w):(R126i.y)); +R4i.z = ((PV0i.w == 0)?(R126i.z):(R126i.w)); +} +// export +passPixelColor0 = vec4(intBitsToFloat(R4i.x), intBitsToFloat(R4i.y), intBitsToFloat(R4i.z), intBitsToFloat(R4i.w)); +} diff --git a/Source/XenobladeX/840947e29015aa9a_00000000000003c9_ps.txt b/Source/XenobladeX/840947e29015aa9a_00000000000003c9_ps.txt new file mode 100644 index 00000000..375a6d9d --- /dev/null +++ b/Source/XenobladeX/840947e29015aa9a_00000000000003c9_ps.txt @@ -0,0 +1,167 @@ + + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 840947e29015aa9a +// cutscene DOF, reveal talk BG +// To-do Review multi pass performance and bokeh depth +const float resScale = ; +//const float resScale = 3; +uniform ivec4 uf_remappedPS[3]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf4386000 res 1280x720x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +vec4 blur9(sampler2D image, vec2 uv, vec2 resolution, vec2 direction) { + vec4 color = vec4(0.0); + vec2 off1 = vec2(1.3846153846) * direction; + vec2 off2 = vec2(3.2307692308) * direction; + color += texture2D(image, uv) * 0.2270270270; + color += texture2D(image, uv + (off1 / resolution)) * 0.3162162162; + color += texture2D(image, uv - (off1 / resolution)) * 0.3162162162; + color += texture2D(image, uv + (off2 / resolution)) * 0.0702702703; + color += texture2D(image, uv - (off2 / resolution)) * 0.0702702703; + return color; +} + +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R6f = vec4(0.0); +vec4 R7f = vec4(0.0); +vec4 R8f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +R1f = passParameterSem1; +// 0 +R2f.x = R1f.x + (intBitsToFloat(uf_remappedPS[0].x)/ resScale); +R2f.y = R1f.y + (intBitsToFloat(uf_remappedPS[0].y)/ resScale); +R0f.z = R1f.x + (intBitsToFloat(uf_remappedPS[0].z)/ resScale); +R0f.w = R1f.y + (intBitsToFloat(uf_remappedPS[0].w)/ resScale); +// 1 +backupReg0f = R1f.x; +backupReg1f = R1f.y; +backupReg0f = R1f.x; +backupReg1f = R1f.y; +R1f.xyz = vec3(backupReg0f,backupReg1f,backupReg0f) + vec3(intBitsToFloat(uf_remappedPS[1].x)/ resScale,intBitsToFloat(uf_remappedPS[1].y)/ resScale,intBitsToFloat(uf_remappedPS[1].z)/ resScale); +R1f.w = backupReg1f + intBitsToFloat(uf_remappedPS[1].w)/ resScale; + +vec2 texsizetest = vec2(1280.0, 720.0); +//R4f = blur9(textureUnitPS0, R1f.xy, texsizetest, vec2(1.0, 1.0)); +//R3f = blur9(textureUnitPS0, R0f.zw, texsizetest, vec2(1.0, 1.0)); + +//R3f.xyz = (texture(textureUnitPS1, R2f.xy).xyz); +R3f = (blur9(textureUnitPS1, R2f.xy, texsizetest, vec2(1.0, 1.0))); // remove, redundant, blur on next step +R4f = (blur9(textureUnitPS1, R0f.zw, texsizetest, vec2(1.0, 1.0))); +R5f = (blur9(textureUnitPS1, R1f.xy, texsizetest, vec2(1.0, 1.0))); +R6f = (blur9(textureUnitPS1, R1f.zw, texsizetest, vec2(1.0, 1.0))); +R2f.xyz = (texture(textureUnitPS0, R2f.xy).xyz); +R7f.xyz = (texture(textureUnitPS0, R0f.zw).xyz); +R8f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R1f.xyz = (texture(textureUnitPS0, R1f.zw).xyz); +// 0 +tempf.x = dot(vec4(R3f.x,R3f.y,R3f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0)); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R127f.w = tempf.x; +R127f.z = R2f.x + R7f.x; +PS0f = R127f.z; +// 1 +tempf.x = dot(vec4(R4f.x,R4f.y,R4f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0)); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +R127f.y = R2f.y + R7f.y; +PS1f = R127f.y; +// 2 +tempf.x = dot(vec4(R5f.x,R5f.y,R5f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0)); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +PS0f = R127f.w + PV1f.x; +// 3 +tempf.x = dot(vec4(R6f.x,R6f.y,R6f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0)); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +PS1f = PS0f + PV0f.x; +// 4 +PV0f.y = PS1f + PV1f.x; +PV0f.z = R127f.y + R8f.y; +PV0f.w = R2f.z + R7f.z; +// 5 +R123f.x = (PV0f.y * 0.25 + -(R0f.x)); +PV1f.x = R123f.x; +PV1f.y = R127f.z + R8f.x; +PV1f.z = PV0f.z + R1f.y; +PV1f.w = PV0f.w + R8f.z; +// 6 +PV0f.x = PV1f.y + R1f.x; +PV0f.y = PV1f.w + R1f.z; +PV0f.z = PV1f.z * 0.25; +PV0f.w = max(PV1f.x, -(PV1f.x)); +// 7 +backupReg0f = R0f.y; +PV1f.x = PV0f.x * 0.25; +PV1f.y = PV0f.y * 0.25; +PV1f.z = backupReg0f * PV0f.w; +PV1f.z = clamp(PV1f.z, 0.0, 1.0); +PV1f.w = max(PV0f.z, 0.0); +// 8 +PV0f.x = max(PV1f.y, 0.0); +R0f.y = min(PV1f.w, 4.0); +PV0f.z = max(PV1f.x, 0.0); +tempResultf = log2(PV1f.z); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0f = tempResultf; +// 9 +PV1f.x = PS0f * intBitsToFloat(uf_remappedPS[2].w); +R0f.z = min(PV0f.x, 4.0); +R0f.x = min(PV0f.z, 4.0); +PS1f = R0f.x; +// 10 +PS0f = exp2(PV1f.x); +// 11 +R0f.w = PS0f * intBitsToFloat(uf_remappedPS[2].z); +// export +passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w); +} diff --git a/Source/XenobladeX/8c1e55fd967b0496_0000000000000079_ps.txt b/Source/XenobladeX/8c1e55fd967b0496_0000000000000079_ps.txt new file mode 100644 index 00000000..0138d664 --- /dev/null +++ b/Source/XenobladeX/8c1e55fd967b0496_0000000000000079_ps.txt @@ -0,0 +1,167 @@ + + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 8c1e55fd967b0496 +// ver/horz alignment tweak, just a magic value +// To-do. Go back and re-center all passes instead. + +const float resScale = ; +//const float resScale = 3.0; // +uniform ivec4 uf_remappedPS[5]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4e76000 res 320x180x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 6 6 6 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +const float repositionBloom = 1.00125; +//mattdesl MIT - https://github.com/Jam3/glsl-fast-gaussian-blur +vec4 blur9(sampler2D image, vec2 uv, vec2 resolution, vec2 direction) { + vec4 color = vec4(0.0); + vec2 off1 = vec2(1.3846153846) * direction; + vec2 off2 = vec2(3.2307692308) * direction; + color += texture2D(image, uv) * 0.2270270270; + color += texture2D(image, uv + (off1 / resolution)) * 0.3162162162; + color += texture2D(image, uv - (off1 / resolution)) * 0.3162162162; + color += texture2D(image, uv + (off2 / resolution)) * 0.0702702703; + color += texture2D(image, uv - (off2 / resolution)) * 0.0702702703; + return color; +} + + +int clampFI32(int v) +{ + if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); + else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); + return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ + vec4 R0f = vec4(0.0); + vec4 R1f = vec4(0.0); + vec4 R2f = vec4(0.0); + vec4 R3f = vec4(0.0); + vec4 R4f = vec4(0.0); + vec4 R5f = vec4(0.0); + vec4 R123f = vec4(0.0); + vec4 R126f = vec4(0.0); + vec4 R127f = vec4(0.0); + float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; + vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); + float PS0f = 0.0, PS1f = 0.0; + vec4 tempf = vec4(0.0); + float tempResultf; + int tempResulti; + ivec4 ARi = ivec4(0); + bool predResult = true; + vec3 cubeMapSTM; + int cubeMapFaceId; + R0f = passParameterSem0; + vec2 scaleFactor = vec2(repositionBloom, repositionBloom); //Added + R0f.xy = R0f.xy * scaleFactor;// re-align bloom.. hack until issue source is found. + + // 0 + R1f.x = R0f.x + (intBitsToFloat(uf_remappedPS[0].x) / resScale); + R1f.y = R0f.y + (intBitsToFloat(uf_remappedPS[0].y) / resScale); + R0f.z = R0f.x + (intBitsToFloat(uf_remappedPS[1].x) / resScale); + R0f.w = R0f.y + (intBitsToFloat(uf_remappedPS[1].y) / resScale); + R5f.w = 1.0 ; + PS0f = R5f.w; + // 1 + R2f.x = R0f.x + (intBitsToFloat(uf_remappedPS[2].x) / resScale); + R2f.y = R0f.y + (intBitsToFloat(uf_remappedPS[2].y) / resScale); + R1f.z = R0f.x + (intBitsToFloat(uf_remappedPS[3].x) / resScale); + R1f.w = R0f.y + (intBitsToFloat(uf_remappedPS[3].y) / resScale); + // 2 + backupReg0f = R0f.x; + backupReg1f = R0f.y; + R0f.x = backupReg0f + (intBitsToFloat(uf_remappedPS[4].x) / resScale); + R0f.y = backupReg1f + (intBitsToFloat(uf_remappedPS[4].y) / resScale); + + //hack aproximate 720 blur + //vec2 texsizetest = vec2(2560.0,1440.0 ); +R4f = blur9(textureUnitPS0, R1f.xy, textureSize(textureUnitPS0, 0), vec2(1.0, 1.0)); +R3f = blur9(textureUnitPS0, R0f.zw, textureSize(textureUnitPS0, 0), vec2(1.0, 1.0)); +R2f = blur9(textureUnitPS0, R2f.xy, textureSize(textureUnitPS0, 0), vec2(1.0, 1.0)); +R1f = blur9(textureUnitPS0, R1f.zw, textureSize(textureUnitPS0, 0), vec2(1.0, 1.0)); +R0f = blur9(textureUnitPS0, R0f.xy, textureSize(textureUnitPS0, 0), vec2(1.0, 1.0)); + + /* + R4f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); + R3f.xyz = (texture(textureUnitPS0, R0f.zw).xyz); + R2f.xyz = (texture(textureUnitPS0, R2f.xy).xyz); + R1f.xyz = (texture(textureUnitPS0, R1f.zw).xyz); + R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz); + */ + // 0 + PV0f.x = R4f.y * intBitsToFloat(uf_remappedPS[0].z); + PV0f.y = R4f.x * intBitsToFloat(uf_remappedPS[0].z); + PV0f.z = R4f.z * intBitsToFloat(uf_remappedPS[0].z); + PV0f.w = max(R3f.x, R4f.x); + R127f.z = max(R3f.y, R4f.y); + PS0f = R127f.z; + // 1 + R123f.x = (R3f.z * intBitsToFloat(uf_remappedPS[1].z) + PV0f.z); + PV1f.x = R123f.x; + PV1f.y = max(R3f.z, R4f.z); + R123f.z = (R3f.y * intBitsToFloat(uf_remappedPS[1].z) + PV0f.x); + PV1f.z = R123f.z; + R123f.w = (R3f.x * intBitsToFloat(uf_remappedPS[1].z) + PV0f.y); + PV1f.w = R123f.w; + R127f.y = max(PV0f.w, R2f.x); + PS1f = R127f.y; + // 2 + R127f.x = max(R127f.z, R2f.y); + R123f.y = (R2f.y * intBitsToFloat(uf_remappedPS[2].z) + PV1f.z); + PV0f.y = R123f.y; + R123f.z = (R2f.x * intBitsToFloat(uf_remappedPS[2].z) + PV1f.w); + PV0f.z = R123f.z; + R123f.w = (R2f.z * intBitsToFloat(uf_remappedPS[2].z) + PV1f.x); + PV0f.w = R123f.w; + R127f.w = max(PV1f.y, R2f.z); + PS0f = R127f.w; + // 3 + backupReg0f = R0f.y; + R123f.x = (R1f.x * intBitsToFloat(uf_remappedPS[3].z) + PV0f.z); + PV1f.x = R123f.x; + PV1f.y = max(R0f.x, R1f.x); + R123f.z = (R1f.y * intBitsToFloat(uf_remappedPS[3].z) + PV0f.y); + PV1f.z = R123f.z; + R126f.w = (R1f.z * intBitsToFloat(uf_remappedPS[3].z) + PV0f.w); + PS1f = max(backupReg0f, R1f.y); + // 4 + backupReg0f = R0f.x; + backupReg1f = R0f.y; + PV0f.x = max(R127f.y, PV1f.y); + PV0f.y = max(R0f.z, R1f.z); + R127f.z = (backupReg0f * intBitsToFloat(uf_remappedPS[4].z) + PV1f.x); + PV0f.z = R127f.z; + PV0f.w = max(R127f.x, PS1f); + R127f.x = (backupReg1f * intBitsToFloat(uf_remappedPS[4].z) + PV1f.z); + PS0f = R127f.x; + // 5 + backupReg0f = R0f.z; + PV1f.x = PV0f.x + -(PV0f.z); + PV1f.y = PV0f.w + -(PS0f); + PV1f.z = max(R127f.w, PV0f.y); + R127f.w = (backupReg0f * intBitsToFloat(uf_remappedPS[4].z) + R126f.w); + PV1f.w = R127f.w; + // 6 + PV0f.x = PV1f.z + -(PV1f.w); + R5f.y = (PV1f.y * 0.25 + R127f.x);//degree of bloom + R5f.x = (PV1f.x * 0.25 + R127f.z); + PS0f = R5f.x; + // 7 + R5f.z = (PV0f.x * 0.25 + R127f.w); + // export + passPixelColor0 = vec4(R5f.x, R5f.y, R5f.z, R5f.w); +} diff --git a/Source/XenobladeX/91f557914ed24b44_00000000000003c9_ps.txt b/Source/XenobladeX/91f557914ed24b44_00000000000003c9_ps.txt new file mode 100644 index 00000000..f5d63300 --- /dev/null +++ b/Source/XenobladeX/91f557914ed24b44_00000000000003c9_ps.txt @@ -0,0 +1,72 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 91f557914ed24b44 +// re-alignt off axis bloom +//To-do Re-do whole chain with centered viewport values. +uniform ivec4 uf_remappedPS[1]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4386000 res 1280x720x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf5376000 res 640x360x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 2) in vec4 passParameterSem2; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; +const float repositionBloom = 1.00225; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +R1f = passParameterSem1; +R2f = passParameterSem2; +vec2 scaleFactor = vec2(repositionBloom, repositionBloom); //Added +R2f.xy = R2f.xy * scaleFactor;// re-align bloom.. hack until issue source is found. + +R1f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R2f.xyz = (texture(textureUnitPS1, R2f.xy).xyz); +// 0 +tempf.x = dot(vec4(R1f.x,R1f.y,R1f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0)); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +// 1 +PV1f.y = -(R0f.x) + PV0f.x; +// 2 +PV0f.x = max(PV1f.y, -(PV1f.y)); +// 3 +PV1f.w = R0f.y * PV0f.x; +PV1f.w = clamp(PV1f.w, 0.0, 1.0); +// 4 +tempResultf = log2(PV1f.w); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0f = tempResultf; +// 5 +PV1f.y = PS0f * intBitsToFloat(uf_remappedPS[0].w); +// 6 +PS0f = exp2(PV1f.y); +// 7 +R2f.w = PS0f * intBitsToFloat(uf_remappedPS[0].z); //sharpen +// export +passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +} diff --git a/Source/XenobladeX/_4d4b09634a7eab30_0000000000001e49_ps.txt b/Source/XenobladeX/_4d4b09634a7eab30_0000000000001e49_ps.txt new file mode 100644 index 00000000..d9d3537d --- /dev/null +++ b/Source/XenobladeX/_4d4b09634a7eab30_0000000000001e49_ps.txt @@ -0,0 +1,561 @@ + + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4d4b09634a7eab30 +// Last step vertical blend - _disabled probably overkill. +// To-do candidate for multi pass / bokeh replacement +const float resScale = ; +uniform ivec4 uf_remappedPS[7]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4fde000 res 640x360x1 dim 1 tm: 4 format 0820 compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf51aa000 res 640x360x1 dim 1 tm: 4 format 0820 compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 2) uniform sampler2D textureUnitPS2;// Tex2 addr 0xf4e12000 res 640x360x1 dim 1 tm: 4 format 0820 compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler2 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; +//const float resScale = 2.0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R6f = vec4(0.0); +vec4 R7f = vec4(0.0); +vec4 R8f = vec4(0.0); +vec4 R9f = vec4(0.0); +vec4 R10f = vec4(0.0); +vec4 R11f = vec4(0.0); +vec4 R12f = vec4(0.0); +vec4 R13f = vec4(0.0); +vec4 R14f = vec4(0.0); +vec4 R15f = vec4(0.0); +vec4 R16f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R124f = vec4(0.0); +vec4 R125f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +R15f.xyzw = (texture(textureUnitPS2, R0f.xy).xyzw); +// 0 +R1f.x = R0f.x + (intBitsToFloat(uf_remappedPS[0].x) / resScale); +R1f.y = R0f.y + (intBitsToFloat(uf_remappedPS[0].y) / resScale); +R0f.z = R0f.x + (intBitsToFloat(uf_remappedPS[0].z) / resScale); +R0f.w = R0f.y + (intBitsToFloat(uf_remappedPS[0].w) / resScale); +R16f.w = R15f.w; +PS0f = R16f.w; +// 1 +R2f.x = R0f.x + (intBitsToFloat(uf_remappedPS[1].x) / resScale); +R2f.y = R0f.y + (intBitsToFloat(uf_remappedPS[1].y) / resScale); +R1f.z = R0f.x + (intBitsToFloat(uf_remappedPS[1].z) / resScale); +R1f.w = R0f.y + (intBitsToFloat(uf_remappedPS[1].w) / resScale); +// 2 +R3f.x = R0f.x + (intBitsToFloat(uf_remappedPS[2].x) / resScale); +R3f.y = R0f.y + (intBitsToFloat(uf_remappedPS[2].y) / resScale); +R2f.z = R0f.x + (intBitsToFloat(uf_remappedPS[2].z) / resScale); +R2f.w = R0f.y + (intBitsToFloat(uf_remappedPS[2].w) / resScale); +// 3 +R4f.x = R0f.x + (intBitsToFloat(uf_remappedPS[3].x) / resScale); +R4f.y = R0f.y + (intBitsToFloat(uf_remappedPS[3].y) / resScale); +R3f.z = R0f.x + (intBitsToFloat(uf_remappedPS[3].z) / resScale); +R3f.w = R0f.y + (intBitsToFloat(uf_remappedPS[3].w)/ resScale); +R5f.xyzw = (texture(textureUnitPS1, R1f.xy).xyzw); +R6f.xyzw = (texture(textureUnitPS1, R0f.zw).xyzw); +R7f.xyzw = (texture(textureUnitPS1, R2f.xy).xyzw); +R9f.xyzw = (texture(textureUnitPS1, R1f.zw).xyzw); +R8f.xyzw = (texture(textureUnitPS1, R3f.xy).xyzw); +R11f.xyzw = (texture(textureUnitPS1, R2f.zw).xyzw); +R10f.xyzw = (texture(textureUnitPS0, R4f.xy).xyzw); +R12f.xyzw = (texture(textureUnitPS0, R3f.zw).xyzw); +// 0 +R4f.x = R0f.x + (intBitsToFloat(uf_remappedPS[4].x) / resScale); +R4f.y = R0f.y + (intBitsToFloat(uf_remappedPS[4].y) / resScale); +R3f.z = R0f.x + (intBitsToFloat(uf_remappedPS[4].z) / resScale); +R3f.w = R0f.y + (intBitsToFloat(uf_remappedPS[4].w) / resScale); +R127f.z = R5f.w + -(0.5); +R127f.z *= 2.0; +R127f.z = clamp(R127f.z, 0.0, 1.0); +PS0f = R127f.z; +// 1 +backupReg0f = R0f.x; +backupReg1f = R0f.y; +backupReg0f = R0f.x; +backupReg1f = R0f.y; +R0f.x = backupReg0f + (intBitsToFloat(uf_remappedPS[5].x) / resScale); +R0f.y = backupReg1f + (intBitsToFloat(uf_remappedPS[5].y) / resScale); +R2f.z = backupReg0f + (intBitsToFloat(uf_remappedPS[5].z) / resScale); +R2f.w = backupReg1f + (intBitsToFloat(uf_remappedPS[5].w) / resScale); +PS1f = R5f.x + -(0.0); +// 2 +PV0f.x = R5f.y + -(0.0); +R127f.y = R6f.w + -(0.5); +R127f.y *= 2.0; +R127f.y = clamp(R127f.y, 0.0, 1.0); +R126f.z = R127f.z + 1.0; +PV0f.w = R5f.z + -(0.0); +R125f.z = (R127f.z * PS1f + R15f.x); +PS0f = R125f.z; +// 3 +R123f.x = (R127f.z * PV0f.w + R15f.z); +PV1f.x = R123f.x; +R123f.y = (R127f.z * PV0f.x + R15f.y); +PV1f.y = R123f.y; +PV1f.z = R6f.x + -(0.0); +PV1f.w = R6f.y + -(0.0); +PS1f = R6f.z + -(0.0); +// 4 +R3f.x = (R127f.y * PV1f.w + PV1f.y); +R3f.y = (R127f.y * PV1f.z + R125f.z); +R1f.z = R7f.w + -(0.5); +R1f.z *= 2.0; +R1f.z = clamp(R1f.z, 0.0, 1.0); +R1f.w = R126f.z + R127f.y; +R0f.w = (R127f.y * PS1f + PV1f.x); +PS0f = R0f.w; +R4f.xyzw = (texture(textureUnitPS0, R4f.xy).xyzw); +R13f.xyzw = (texture(textureUnitPS0, R3f.zw).xyzw); +R14f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw); +R2f.xyzw = (texture(textureUnitPS0, R2f.zw).xyzw); +// 0 +PV0f.x = R7f.y + -(0.0); +PV0f.y = R7f.x + -(0.0); +R126f.z = R1f.w + R1f.z; +PV0f.w = R7f.z + -(0.0); +R127f.x = R9f.w + -(0.5); +R127f.x *= 2.0; +R127f.x = clamp(R127f.x, 0.0, 1.0); +PS0f = R127f.x; +// 1 +R126f.x = (R1f.z * PV0f.w + R0f.w); +R123f.y = (R1f.z * PV0f.x + R3f.x); +PV1f.y = R123f.y; +R123f.z = (R1f.z * PV0f.y + R3f.y); +PV1f.z = R123f.z; +PV1f.w = R9f.x + -(0.0); +PS1f = R9f.y + -(0.0); +// 2 +backupReg0f = R126f.z; +R125f.x = R8f.w + -(0.5); +R125f.x *= 2.0; +R125f.x = clamp(R125f.x, 0.0, 1.0); +PV0f.y = R9f.z + -(0.0); +R126f.z = backupReg0f + R127f.x; +R127f.w = (R127f.x * PV1f.w + PV1f.z); +R126f.w = (R127f.x * PS1f + PV1f.y); +PS0f = R126f.w; +// 3 +PV1f.x = R8f.x + -(0.0); +PV1f.y = R8f.y + -(0.0); +R123f.z = (R127f.x * PV0f.y + R126f.x); +PV1f.z = R123f.z; +R125f.w = R5f.w + -(intBitsToFloat(0x3f666666)); +PS1f = R8f.z + -(0.0); +// 4 +backupReg0f = R125f.x; +backupReg0f = R125f.x; +backupReg1f = R126f.z; +backupReg0f = R125f.x; +backupReg0f = R125f.x; +R125f.x = (backupReg0f * PV1f.y + R126f.w); +R127f.y = (backupReg0f * PV1f.x + R127f.w); +R126f.z = backupReg1f + backupReg0f; +R127f.w = R11f.w + -(0.5); +R127f.w *= 2.0; +R127f.w = clamp(R127f.w, 0.0, 1.0); +R126f.w = (backupReg0f * PS1f + PV1f.z); +PS0f = R126f.w; +// 5 +R127f.x = -(R15f.y) + R5f.y; +R126f.y = -(R15f.x) + R5f.x; +R125f.z = R125f.w * intBitsToFloat(0x41200000); +R125f.z = clamp(R125f.z, 0.0, 1.0); +R125f.w = -(R15f.z) + R5f.z; +R127f.z = R6f.w + -(intBitsToFloat(0x3f666666)); +PS1f = R127f.z; +// 6 +PV0f.x = R11f.x + -(0.0); +PV0f.y = R11f.y + -(0.0); +R124f.z = R8f.w + -(intBitsToFloat(0x3f666666)); +R124f.w = R7f.w + -(intBitsToFloat(0x3f666666)); +PS0f = R11f.z + -(0.0); +// 7 +backupReg0f = R125f.x; +backupReg1f = R127f.w; +backupReg2f = R127f.y; +backupReg1f = R127f.w; +R125f.x = R10f.w + -(0.5); +R125f.x *= 2.0; +R125f.x = clamp(R125f.x, 0.0, 1.0); +R127f.y = R126f.z + R127f.w; +R126f.z = (R127f.w * PV0f.y + backupReg0f); +R127f.w = (backupReg1f * PV0f.x + backupReg2f); +R125f.y = (backupReg1f * PS0f + R126f.w); +PS1f = R125f.y; +// 8 +backupReg0f = R127f.x; +backupReg1f = R126f.y; +backupReg2f = R127f.z; +R127f.x = (R125f.w * R125f.z + R15f.z); +R126f.y = (backupReg0f * R125f.z + R15f.y); +R127f.z = (backupReg1f * R125f.z + R15f.x); +R125f.w = backupReg2f * intBitsToFloat(0x41200000); +R125f.w = clamp(R125f.w, 0.0, 1.0); +R126f.x = -(R15f.x) + R6f.x; +PS0f = R126f.x; +// 9 +R6f.x = R124f.w * intBitsToFloat(0x41200000); +R6f.x = clamp(R6f.x, 0.0, 1.0); +R124f.y = -(R15f.x) + R7f.x; +R125f.z = -(R15f.z) + R6f.z; +R124f.w = -(R15f.y) + R6f.y; +R124f.x = -(R15f.y) + R7f.y; +PS1f = R124f.x; +// 10 +R7f.x = R124f.z * intBitsToFloat(0x41200000); +R7f.x = clamp(R7f.x, 0.0, 1.0); +R7f.y = R9f.w + -(intBitsToFloat(0x3f666666)); +R124f.z = -(R15f.x) + R8f.x; +R126f.w = -(R15f.z) + R7f.z; +R7f.w = -(R15f.y) + R8f.y; +PS0f = R7f.w; +// 11 +backupReg0f = R8f.z; +PV1f.x = R10f.y + -(0.0); +PV1f.y = R10f.z + -(0.0); +R8f.z = -(R15f.z) + backupReg0f; +PV1f.w = R10f.x + -(0.0); +R8f.y = R10f.w + -(intBitsToFloat(0x3f666666)); +PS1f = R8f.y; +// 12 +backupReg0f = R125f.x; +backupReg0f = R125f.x; +backupReg1f = R127f.y; +backupReg0f = R125f.x; +backupReg0f = R125f.x; +R125f.x = (backupReg0f * PV1f.w + R127f.w); +R127f.y = (backupReg0f * PV1f.x + R126f.z); +R126f.z = R12f.w + -(0.5); +R126f.z *= 2.0; +R126f.z = clamp(R126f.z, 0.0, 1.0); +R127f.w = backupReg1f + backupReg0f; +R7f.z = (backupReg0f * PV1f.y + R125f.y); +PS0f = R7f.z; +// 13 +backupReg0f = R126f.x; +backupReg1f = R126f.y; +backupReg2f = R127f.z; +backupReg3f = R124f.w; +R126f.x = max(R15f.z, R127f.x); +R126f.y = (backupReg0f * R125f.w + R15f.x); +R127f.z = max(R15f.y, backupReg1f); +R124f.w = max(R15f.x, backupReg2f); +R127f.x = (backupReg3f * R125f.w + R15f.y); +PS1f = R127f.x; +// 14 +backupReg0f = R6f.x; +backupReg0f = R6f.x; +backupReg1f = R124f.y; +backupReg0f = R6f.x; +backupReg2f = R125f.z; +R6f.x = (R126f.w * backupReg0f + R15f.z); +R124f.y = (R124f.x * backupReg0f + R15f.y); +R125f.z = (backupReg1f * backupReg0f + R15f.x); +R126f.w = (backupReg2f * R125f.w + R15f.z); +R8f.x = R7f.y * intBitsToFloat(0x41200000); +R8f.x = clamp(R8f.x, 0.0, 1.0); +PS0f = R8f.x; +// 15 +backupReg0f = R9f.x; +R9f.x = (R124f.z * R7f.x + R15f.x); +R125f.y = -(R15f.z) + R9f.z; +R9f.z = -(R15f.y) + R9f.y; +R9f.w = -(R15f.x) + backupReg0f; +R124f.x = (R7f.w * R7f.x + R15f.y); +PS1f = R124f.x; +// 16 +backupReg0f = R8f.y; +backupReg1f = R8f.z; +backupReg2f = R7f.x; +R7f.x = R11f.w + -(intBitsToFloat(0x3f666666)); +R8f.y = backupReg0f * intBitsToFloat(0x41200000); +R8f.y = clamp(R8f.y, 0.0, 1.0); +R8f.z = -(R15f.x) + R10f.x; +R7f.w = (backupReg1f * backupReg2f + R15f.z); +R6f.z = -(R15f.y) + R10f.y; +PS0f = R6f.z; +// 17 +PV1f.x = R12f.x + -(0.0); +R10f.y = -(R15f.z) + R10f.z; +R124f.z = R12f.y + -(0.0); +R125f.w = R12f.z + -(0.0); +R8f.w = R4f.w + -(0.5); +R8f.w *= 2.0; +R8f.w = clamp(R8f.w, 0.0, 1.0); +PS1f = R8f.w; +// 18 +R10f.x = R127f.w + R126f.z; +R9f.y = R4f.w + -(intBitsToFloat(0x3f666666)); +R10f.z = max(R124f.w, R126f.y); +R10f.w = max(R127f.z, R127f.x); +R5f.z = (R126f.z * PV1f.x + R125f.x); +PS0f = R5f.z; +// 19 +backupReg0f = R7f.z; +backupReg1f = R7f.w; +backupReg2f = R6f.x; +R6f.x = max(R126f.x, R126f.w); +R7f.y = (R126f.z * R124f.z + R127f.y); +R7f.z = (R126f.z * R125f.w + backupReg0f); +R7f.w = max(R124f.x, R124f.y); +R6f.w = max(backupReg1f, backupReg2f); +PS1f = R6f.w; +// 20 +backupReg0f = R8f.x; +backupReg0f = R8f.x; +backupReg1f = R9f.z; +backupReg0f = R8f.x; +R8f.x = (R9f.w * backupReg0f + R15f.x); +R6f.y = max(R9f.x, R125f.z); +R9f.z = (R125f.y * backupReg0f + R15f.z); +R9f.w = (backupReg1f * backupReg0f + R15f.y); +R5f.y = -(R15f.y) + R11f.y; +PS0f = R5f.y; +// 21 +backupReg0f = R7f.x; +backupReg1f = R10f.y; +R7f.x = -(R15f.z) + R11f.z; +R10f.y = (R8f.z * R8f.y + R15f.x); +R11f.z = -(R15f.x) + R11f.x; +R11f.w = backupReg0f * intBitsToFloat(0x41200000); +R11f.w = clamp(R11f.w, 0.0, 1.0); +R8f.z = (backupReg1f * R8f.y + R15f.z); +PS1f = R8f.z; +// 0 +R124f.x = R12f.w + -(intBitsToFloat(0x3f666666)); +R125f.y = R4f.y + -(0.0); +R125f.z = R4f.x + -(0.0); +R126f.w = (R6f.z * R8f.y + R15f.y); +R126f.x = R4f.z + -(0.0); +PS0f = R126f.x; +// 1 +R127f.x = -(R15f.z) + R4f.z; +R127f.y = -(R15f.y) + R4f.y; +R126f.z = -(R15f.x) + R4f.x; +R125f.w = R9f.y * intBitsToFloat(0x41200000); +R125f.w = clamp(R125f.w, 0.0, 1.0); +R124f.z = R10f.x + R8f.w; +PS1f = R124f.z; +// 2 +R125f.x = max(R10f.z, R8f.x); +R124f.y = R13f.w + -(0.5); +R124f.y *= 2.0; +R124f.y = clamp(R124f.y, 0.0, 1.0); +R127f.z = max(R6f.x, R9f.z); +R127f.w = R14f.w + -(intBitsToFloat(0x3f666666)); +R9f.z = (R8f.w * R125f.y + R7f.y); +PS0f = R9f.z; +// 3 +backupReg0f = R6f.y; +backupReg1f = R125f.z; +backupReg2f = R126f.x; +R126f.x = max(R10f.w, R9f.w); +R6f.y = R124f.x * intBitsToFloat(0x41200000); +R6f.y = clamp(R6f.y, 0.0, 1.0); +R125f.z = max(R10f.y, backupReg0f); +R124f.w = (R8f.w * backupReg1f + R5f.z); +R126f.y = (R8f.w * backupReg2f + R7f.z); +PS1f = R126f.y; +// 4 +backupReg0f = R12f.x; +backupReg1f = R12f.y; +R12f.x = max(R8f.z, R6f.w); +R12f.y = max(R126f.w, R7f.w); +R5f.z = -(R15f.x) + backupReg0f; +R6f.w = -(R15f.y) + backupReg1f; +R7f.w = -(R15f.z) + R12f.z; +PS0f = R7f.w; +// 5 +backupReg0f = R127f.y; +R124f.x = (R126f.z * R125f.w + R15f.x); +R127f.y = (R7f.x * R11f.w + R15f.z); +R126f.z = (R5f.y * R11f.w + R15f.y); +R126f.w = (R11f.z * R11f.w + R15f.x); +R8f.z = (backupReg0f * R125f.w + R15f.y); +PS1f = R8f.z; +// 6 +backupReg0f = R127f.x; +backupReg1f = R125f.w; +R127f.x = R13f.x + -(0.0); +R125f.y = R13f.y + -(0.0); +R11f.z = R13f.z + -(0.0); +R125f.w = (backupReg0f * backupReg1f + R15f.z); +R12f.z = R13f.w + -(intBitsToFloat(0x3f666666)); +PS0f = R12f.z; +// 7 +backupReg0f = R124f.z; +R6f.x = R127f.w * intBitsToFloat(0x41200000); +R6f.x = clamp(R6f.x, 0.0, 1.0); +R5f.y = -(R15f.x) + R14f.x; +R124f.z = R14f.w + -(0.5); +R124f.z *= 2.0; +R124f.z = clamp(R124f.z, 0.0, 1.0); +R127f.w = backupReg0f + R124f.y; +R7f.x = -(R15f.y) + R14f.y; +PS1f = R7f.x; +// 8 +backupReg0f = R126f.z; +backupReg1f = R127f.x; +R127f.x = max(R125f.x, R126f.w); +R10f.y = R2f.w + -(intBitsToFloat(0x3f666666)); +R126f.z = max(R126f.x, backupReg0f); +R126f.w = -(R15f.z) + R14f.z; +R7f.y = (R124f.y * backupReg1f + R124f.w); +PS0f = R7f.y; +// 9 +backupReg0f = R127f.y; +backupReg1f = R125f.z; +R125f.x = (R124f.y * R125f.y + R9f.z); +R127f.y = max(R125f.w, R12f.x); +R125f.z = max(R127f.z, backupReg0f); +R11f.w = max(R124f.x, backupReg1f); +R125f.y = R14f.x + -(0.0); +PS1f = R125f.y; +// 10 +backupReg0f = R8f.z; +backupReg1f = R12f.y; +R12f.x = -(R15f.x) + R13f.x; +R12f.y = R12f.z * intBitsToFloat(0x41200000); +R12f.y = clamp(R12f.y, 0.0, 1.0); +R8f.z = max(backupReg0f, backupReg1f); +R124f.w = (R124f.y * R11f.z + R126f.y); +R8f.x = R2f.w + -(0.5); +R8f.x *= 2.0; +R8f.x = clamp(R8f.x, 0.0, 1.0); +PS0f = R8f.x; +// 11 +R124f.x = (R7f.w * R6f.y + R15f.z); +R126f.y = (R6f.w * R6f.y + R15f.y); +R127f.z = (R5f.z * R6f.y + R15f.x); +R6f.w = -(R15f.y) + R13f.y; +R5f.z = -(R15f.z) + R13f.z; +PS1f = R5f.z; +// 12 +backupReg0f = R14f.z; +backupReg1f = R126f.w; +R126f.x = R14f.y + -(0.0); +R124f.y = (R7f.x * R6f.x + R15f.y); +R14f.z = (R5f.y * R6f.x + R15f.x); +R125f.w = backupReg0f + -(0.0); +R126f.w = (backupReg1f * R6f.x + R15f.z); +PS0f = R126f.w; +// 13 +R6f.x = R10f.y * intBitsToFloat(0x41200000); +R6f.x = clamp(R6f.x, 0.0, 1.0); +R10f.y = -(R15f.y) + R2f.y; +R13f.z = R127f.w + R124f.z; +R127f.w = -(R15f.x) + R2f.x; +R5f.y = -(R15f.z) + R2f.z; +PS1f = R5f.y; +// 14 +backupReg0f = R127f.x; +backupReg1f = R127f.z; +R127f.x = max(R126f.w, R127f.y); +R127f.y = max(R125f.z, R124f.x); +R127f.z = max(R126f.z, R126f.y); +R126f.w = max(backupReg0f, backupReg1f); +R14f.w = R2f.x + -(0.0); +PS0f = R14f.w; +// 15 +backupReg0f = R126f.x; +backupReg1f = R124f.z; +backupReg2f = R125f.y; +R126f.x = (R124f.z * R125f.w + R124f.w); +R125f.y = (R124f.z * backupReg0f + R125f.x); +R124f.z = (backupReg1f * backupReg2f + R7f.y); +R124f.w = max(R14f.z, R11f.w); +R11f.w = max(R124f.y, R8f.z); +PS1f = R11f.w; +// 16 +R123f.x = (R6f.w * R12f.y + R15f.y); +PV0f.x = R123f.x; +R123f.y = (R12f.x * R12f.y + R15f.x); +PV0f.y = R123f.y; +R126f.z = R2f.y + -(0.0); +R125f.w = (R5f.z * R12f.y + R15f.z); +R124f.y = R2f.z + -(0.0); +PS0f = R124f.y; +// 17 +backupReg0f = R127f.z; +R125f.x = (R127f.w * R6f.x + R15f.x); +R126f.y = max(R126f.w, PV0f.y); +R127f.z = (R5f.y * R6f.x + R15f.z); +R127f.w = (R10f.y * R6f.x + R15f.y); +R5f.y = max(backupReg0f, PV0f.x); +PS1f = R5f.y; +// 18 +backupReg0f = R126f.z; +backupReg1f = R126f.x; +R126f.x = max(R127f.y, R125f.w); +R127f.y = (R8f.x * R14f.w + R124f.z); +R126f.z = (R8f.x * backupReg0f + R125f.y); +PV0f.w = R13f.z + R8f.x; +R124f.z = (R8f.x * R124f.y + backupReg1f); +PS0f = R124f.z; +// 19 +PV1f.x = max(R127f.w, R11f.w); +PV1f.y = max(R125f.x, R124f.w); +PV1f.w = max(R127f.z, R127f.x); +R127f.z = 1.0 / PV0f.w; +PS1f = R127f.z; +// 20 +backupReg0f = R126f.x; +R126f.x = max(backupReg0f, PV1f.w); +PV0f.y = max(R5f.y, PV1f.x); +PV0f.z = max(R126f.y, PV1f.y); +R127f.w = R127f.y * PS1f; +PV0f.w = R127f.w; +R127f.x = R126f.z * PS1f; +PS0f = R127f.x; +// 21 +PV1f.y = PV0f.y + -(PS0f); +PV1f.z = PV0f.z + -(PV0f.w); +R124f.w = R124f.z * R127f.z; +PV1f.w = R124f.w; +// 22 +PV0f.x = R126f.x + -(PV1f.w); +R16f.y = (PV1f.y * intBitsToFloat(uf_remappedPS[6].x) + R127f.x); +R16f.x = (PV1f.z * intBitsToFloat(uf_remappedPS[6].x) + R127f.w); +PS0f = R16f.x; +// 23 +R16f.z = (PV0f.x * intBitsToFloat(uf_remappedPS[6].x) + R124f.w); +// export +passPixelColor0 = vec4(R16f.x, R16f.y, R16f.z, R16f.w); +} diff --git a/Source/XenobladeX/_59df1c7e1806366c_00000000000003c9_ps.txt b/Source/XenobladeX/_59df1c7e1806366c_00000000000003c9_ps.txt new file mode 100644 index 00000000..dde71f07 --- /dev/null +++ b/Source/XenobladeX/_59df1c7e1806366c_00000000000003c9_ps.txt @@ -0,0 +1,214 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 59df1c7e1806366c +// aaremoval. Can't be combined with AA restore as they share the same shader. +uniform ivec4 uf_remappedPS[2]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4e12000 res 1280x720x1 dim 1 tm: 4 format 0001 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R3i = ivec4(0); +ivec4 R4i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R126i = ivec4(0); +ivec4 R127i = ivec4(0); +int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i; +ivec4 PV0i = ivec4(0), PV1i = ivec4(0); +int PS0i = 0, PS1i = 0; +ivec4 tempi = ivec4(0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +bool activeMaskStack[2]; +bool activeMaskStackC[3]; +activeMaskStack[0] = false; +activeMaskStackC[0] = false; +activeMaskStackC[1] = false; +activeMaskStack[0] = true; +activeMaskStackC[0] = true; +activeMaskStackC[1] = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +/* +R0i = floatBitsToInt(passParameterSem0); +R1i = floatBitsToInt(passParameterSem1); +if( activeMaskStackC[1] == true ) { +R2i.xyzw = floatBitsToInt(textureGather(textureUnitPS0, intBitsToFloat(R0i.zw)).xyzw); +R0i.x = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R1i.xy)).x); +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +backupReg0i = R2i.x; +R2i.x = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(0x3b2aaaab)); +PV0i.x = R2i.x; +R127i.y = floatBitsToInt(max(intBitsToFloat(R2i.y), intBitsToFloat(R2i.w))); +R127i.z = floatBitsToInt(min(intBitsToFloat(R2i.y), intBitsToFloat(R2i.w))); +// 1 +PV1i.y = floatBitsToInt(min(intBitsToFloat(R2i.z), intBitsToFloat(PV0i.x))); +PV1i.w = floatBitsToInt(max(intBitsToFloat(R2i.z), intBitsToFloat(PV0i.x))); +// 2 +R4i.y = floatBitsToInt(max(intBitsToFloat(R127i.y), intBitsToFloat(PV1i.w))); +PV0i.y = R4i.y; +R4i.z = floatBitsToInt(min(intBitsToFloat(R127i.z), intBitsToFloat(PV1i.y))); +PV0i.z = R4i.z; +// 3 +backupReg0i = R0i.x; +backupReg0i = R0i.x; +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedPS[0].x)); +PV1i.y = floatBitsToInt(max(intBitsToFloat(backupReg0i), intBitsToFloat(PV0i.y))); +PV1i.z = floatBitsToInt(min(intBitsToFloat(backupReg0i), intBitsToFloat(PV0i.z))); +// 4 +R0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.z)) + intBitsToFloat(PV1i.y)); +R0i.w = floatBitsToInt(max(intBitsToFloat(PV1i.x), intBitsToFloat(uf_remappedPS[0].y))); +// 5 +backupReg0i = R0i.x; +predResult = (intBitsToFloat(R0i.w) > intBitsToFloat(backupReg0i)); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +if( (0 == 0)) discard; +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +R127i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(R2i.w)),vec4(-(1.0),1.0,1.0,-(1.0)))); +PV0i.x = R127i.x; +PV0i.y = R127i.x; +PV0i.z = R127i.x; +PV0i.w = R127i.x; +R127i.z = 0; +PS0i = R127i.z; +// 1 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(R2i.w)),vec4(-(1.0),1.0,-(1.0),1.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.y = tempi.x; +R4i.w = 0x3f800000; +PS1i = R4i.w; +// 2 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(PV1i.x),intBitsToFloat(R127i.z),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(PV1i.x),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +// 3 +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +PS1i = floatBitsToInt(tempResultf); +// 4 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PS1i)); +PV0i.x = R127i.x; +R127i.w = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(PS1i)); +PV0i.w = R127i.w; +// 5 +PV1i.x = floatBitsToInt(max(intBitsToFloat(PV0i.x), -(intBitsToFloat(PV0i.x)))); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.w) * intBitsToFloat(uf_remappedPS[1].y)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedPS[1].x)); +PV1i.w = floatBitsToInt(max(intBitsToFloat(PV0i.w), -(intBitsToFloat(PV0i.w)))); +// 6 +R0i.x = floatBitsToInt(intBitsToFloat(R1i.x) + -(intBitsToFloat(PV1i.z))); +R0i.y = floatBitsToInt(intBitsToFloat(R1i.y) + -(intBitsToFloat(PV1i.y))); +PV0i.z = floatBitsToInt(min(intBitsToFloat(PV1i.x), intBitsToFloat(PV1i.w))); +R2i.w = floatBitsToInt(intBitsToFloat(R1i.x) + intBitsToFloat(PV1i.z)); +R2i.y = floatBitsToInt(intBitsToFloat(R1i.y) + intBitsToFloat(PV1i.y)); +PS0i = R2i.y; +// 7 +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedPS[0].z)); +// 8 +PS0i = floatBitsToInt(1.0 / intBitsToFloat(PV1i.y)); +// 9 +PV1i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS0i)); +PV1i.w = floatBitsToInt(intBitsToFloat(R127i.x) * intBitsToFloat(PS0i)); +// 10 +PV0i.x = floatBitsToInt(max(intBitsToFloat(PV1i.z), intBitsToFloat(0xc0000000))); +PV0i.y = floatBitsToInt(max(intBitsToFloat(PV1i.w), intBitsToFloat(0xc0000000))); +// 11 +PV1i.z = floatBitsToInt(min(intBitsToFloat(PV0i.x), 2.0)); +PV1i.w = floatBitsToInt(min(intBitsToFloat(PV0i.y), 2.0)); +// 12 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.z) * intBitsToFloat(uf_remappedPS[1].w)); +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedPS[1].z)); +// 13 +backupReg0i = R1i.x; +backupReg1i = R1i.y; +backupReg0i = R1i.x; +backupReg1i = R1i.y; +R1i.x = floatBitsToInt(intBitsToFloat(backupReg0i) + -(intBitsToFloat(PV0i.w))); +R1i.y = floatBitsToInt(intBitsToFloat(backupReg1i) + -(intBitsToFloat(PV0i.x))); +R0i.z = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(PV0i.w)); +R0i.w = floatBitsToInt(intBitsToFloat(backupReg1i) + intBitsToFloat(PV0i.x)); +} +if( activeMaskStackC[1] == true ) { +R1i.xyz = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R1i.xy)).xyz); +R3i.xyz = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R0i.zw)).xyz); +R0i.xyz = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R0i.xy)).xyz); +R2i.xyz = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R2i.wy)).xyz); +} +if( activeMaskStackC[1] == true ) { +// 0 +R127i.x = floatBitsToInt(intBitsToFloat(R1i.z) + intBitsToFloat(R3i.z)); +PV0i.y = floatBitsToInt(intBitsToFloat(R1i.y) + intBitsToFloat(R3i.y)); +PV0i.z = floatBitsToInt(intBitsToFloat(R1i.x) + intBitsToFloat(R3i.x)); +// 1 +backupReg0i = R0i.x; +PV1i.x = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(R2i.x)); +R127i.y = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(R2i.z)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) * 0.25); +PV1i.w = floatBitsToInt(intBitsToFloat(R0i.y) + intBitsToFloat(R2i.y)); +PS1i = floatBitsToInt(intBitsToFloat(PV0i.z) * 0.25); +// 2 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * 0.25 + intBitsToFloat(PS1i))); +PV0i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * 0.25); +R127i.z = PV1i.x; +R127i.z = floatBitsToInt(intBitsToFloat(R127i.z) / 2.0); +R127i.w = floatBitsToInt((intBitsToFloat(PV1i.w) * 0.25 + intBitsToFloat(PV1i.z))); +PV0i.w = R127i.w; +R126i.y = PV1i.w; +R126i.y = floatBitsToInt(intBitsToFloat(R126i.y) / 2.0); +PS0i = R126i.y; +// 3 +PV1i.x = ((intBitsToFloat(PV0i.w) > intBitsToFloat(R4i.y))?int(0xFFFFFFFF):int(0x0)); +PV1i.y = ((intBitsToFloat(R4i.z) > intBitsToFloat(PV0i.w))?int(0xFFFFFFFF):int(0x0)); +R126i.z = floatBitsToInt((intBitsToFloat(R127i.y) * 0.25 + intBitsToFloat(PV0i.y))); +R126i.w = R127i.y; +R126i.w = floatBitsToInt(intBitsToFloat(R126i.w) / 2.0); +// 4 +R123i.w = ((PV1i.y == 0)?(PV1i.x):(int(-1))); +PV0i.w = R123i.w; +// 5 +R4i.x = ((PV0i.w == 0)?(R127i.x):(R127i.z)); +R4i.y = ((PV0i.w == 0)?(R127i.w):(R126i.y)); +R4i.z = ((PV0i.w == 0)?(R126i.z):(R126i.w)); +} +// export +passPixelColor0 = vec4(intBitsToFloat(R4i.x), intBitsToFloat(R4i.y), intBitsToFloat(R4i.z), intBitsToFloat(R4i.w)); +*/ +} diff --git a/Source/XenobladeX/_5eb82314ffb8484e_00000000000007f9_ps.txt b/Source/XenobladeX/_5eb82314ffb8484e_00000000000007f9_ps.txt new file mode 100644 index 00000000..19ebcfa4 --- /dev/null +++ b/Source/XenobladeX/_5eb82314ffb8484e_00000000000007f9_ps.txt @@ -0,0 +1,577 @@ + + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 5eb82314ffb8484e // bg scale, probably overkill to scale +// Bgscale - _disabled probably overkill. +// To-do candidate for multi pass / bokeh replacement +const float resScale = ; +//const float resScale = 2.0; +uniform ivec4 uf_remappedPS[7]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4e12000 res 640x360x1 dim 1 tm: 4 format 0820 compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +layout(location = 1) out vec4 passPixelColor1; +uniform vec2 uf_fragCoordScale; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R6f = vec4(0.0); +vec4 R7f = vec4(0.0); +vec4 R8f = vec4(0.0); +vec4 R9f = vec4(0.0); +vec4 R10f = vec4(0.0); +vec4 R11f = vec4(0.0); +vec4 R12f = vec4(0.0); +vec4 R13f = vec4(0.0); +vec4 R14f = vec4(0.0); +vec4 R15f = vec4(0.0); +vec4 R16f = vec4(0.0); +vec4 R17f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R124f = vec4(0.0); +vec4 R125f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +R14f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw); +// 0 +R1f.x = R0f.x + (intBitsToFloat(uf_remappedPS[0].x) / resScale); +R1f.y = R0f.y + (intBitsToFloat(uf_remappedPS[0].y) / resScale); +R0f.z = R0f.x + (intBitsToFloat(uf_remappedPS[0].z) / resScale); +R0f.w = R0f.y + (intBitsToFloat(uf_remappedPS[0].w) / resScale); +R17f.w = R14f.w; +PS0f = R17f.w; +// 1 +R2f.x = R0f.x + (intBitsToFloat(uf_remappedPS[1].x) / resScale); +R2f.y = R0f.y + (intBitsToFloat(uf_remappedPS[1].y) / resScale); +R1f.z = R0f.x + (intBitsToFloat(uf_remappedPS[1].z) / resScale); +R1f.w = R0f.y + (intBitsToFloat(uf_remappedPS[1].w) / resScale); +R16f.w = R14f.w; +PS1f = R16f.w; +// 2 +R3f.x = R0f.x + (intBitsToFloat(uf_remappedPS[2].x) / resScale); +R3f.y = R0f.y + (intBitsToFloat(uf_remappedPS[2].y) / resScale); +R2f.z = R0f.x + (intBitsToFloat(uf_remappedPS[2].z) / resScale); +R2f.w = R0f.y + (intBitsToFloat(uf_remappedPS[2].w) / resScale); +// 3 +R4f.x = R0f.x + (intBitsToFloat(uf_remappedPS[3].x) / resScale); +R4f.y = R0f.y + (intBitsToFloat(uf_remappedPS[3].y) / resScale); +R3f.z = R0f.x + (intBitsToFloat(uf_remappedPS[3].z) / resScale); +R3f.w = R0f.y + (intBitsToFloat(uf_remappedPS[3].w) / resScale); +R5f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw); +R6f.xyzw = (texture(textureUnitPS0, R0f.zw).xyzw); +R7f.xyzw = (texture(textureUnitPS0, R2f.xy).xyzw); +R9f.xyzw = (texture(textureUnitPS0, R1f.zw).xyzw); +R8f.xyzw = (texture(textureUnitPS0, R3f.xy).xyzw); +R10f.xyzw = (texture(textureUnitPS0, R2f.zw).xyzw); +R11f.xyzw = (texture(textureUnitPS0, R4f.xy).xyzw); +R12f.xyzw = (texture(textureUnitPS0, R3f.zw).xyzw); +// 0 +R4f.x = R0f.x + (intBitsToFloat(uf_remappedPS[4].x) / resScale); +R4f.y = R0f.y + (intBitsToFloat(uf_remappedPS[4].y) / resScale); +R3f.z = R0f.x + (intBitsToFloat(uf_remappedPS[4].z) / resScale); +R3f.w = R0f.y + (intBitsToFloat(uf_remappedPS[4].w) / resScale); +R127f.x = R5f.w + -(0.5); +R127f.x *= 2.0; +R127f.x = clamp(R127f.x, 0.0, 1.0); +PS0f = R127f.x; +// 1 +backupReg0f = R0f.x; +backupReg1f = R0f.y; +backupReg0f = R0f.x; +backupReg1f = R0f.y; +R0f.x = backupReg0f + (intBitsToFloat(uf_remappedPS[5].z) / resScale); +R0f.y = backupReg1f + (intBitsToFloat(uf_remappedPS[5].w) / resScale); +R2f.z = backupReg0f + (intBitsToFloat(uf_remappedPS[5].x) / resScale); +R2f.w = backupReg1f + (intBitsToFloat(uf_remappedPS[5].y) / resScale); +PS1f = R5f.x + -(0.0); +// 2 +R126f.x = R127f.x + 1.0; +PV0f.y = R5f.z + -(0.0); +PV0f.z = R5f.y + -(0.0); +R127f.w = R6f.w + -(0.5); +R127f.w *= 2.0; +R127f.w = clamp(R127f.w, 0.0, 1.0); +R125f.x = (R127f.x * PS1f + R14f.x); +PS0f = R125f.x; +// 3 +PV1f.x = R6f.x + -(0.0); +PV1f.y = R6f.y + -(0.0); +R123f.z = (R127f.x * PV0f.y + R14f.z); +PV1f.z = R123f.z; +R123f.w = (R127f.x * PV0f.z + R14f.y); +PV1f.w = R123f.w; +PS1f = R6f.z + -(0.0); +// 4 +R3f.x = R7f.w + -(0.5); +R3f.x *= 2.0; +R3f.x = clamp(R3f.x, 0.0, 1.0); +R3f.y = R126f.x + R127f.w; +R1f.z = (R127f.w * PV1f.y + PV1f.w); +R1f.w = (R127f.w * PV1f.x + R125f.x); +R2f.y = (R127f.w * PS1f + PV1f.z); +PS0f = R2f.y; +R4f.xyzw = (texture(textureUnitPS0, R4f.xy).xyzw); +R13f.xyzw = (texture(textureUnitPS0, R3f.zw).xyzw); +R15f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw); +R0f.xyzw = (texture(textureUnitPS0, R2f.zw).xyzw); +// 0 +R126f.x = R3f.y + R3f.x; +PV0f.y = R7f.z + -(0.0); +PV0f.z = R7f.y + -(0.0); +PV0f.w = R7f.x + -(0.0); +R127f.z = R9f.w + -(0.5); +R127f.z *= 2.0; +R127f.z = clamp(R127f.z, 0.0, 1.0); +PS0f = R127f.z; +// 1 +R123f.x = (R3f.x * PV0f.w + R1f.w); +PV1f.x = R123f.x; +R127f.y = R5f.w + -(intBitsToFloat(0x3f666666)); +R126f.z = (R3f.x * PV0f.y + R2f.y); +R127f.w = (R3f.x * PV0f.z + R1f.z); +PS1f = R9f.x + -(0.0); +// 2 +PV0f.x = R9f.y + -(0.0); +R126f.y = R126f.x + R127f.z; +R124f.z = R8f.w + -(0.5); +R124f.z *= 2.0; +R124f.z = clamp(R124f.z, 0.0, 1.0); +PV0f.w = R9f.z + -(0.0); +R125f.z = (R127f.z * PS1f + PV1f.x); +PS0f = R125f.z; +// 3 +R126f.x = (R127f.z * PV0f.w + R126f.z); +R125f.y = (R127f.z * PV0f.x + R127f.w); +R126f.z = R127f.y * intBitsToFloat(0x41200000); +R126f.z = clamp(R126f.z, 0.0, 1.0); +R127f.w = -(R14f.x) + R5f.x; +R127f.z = -(R14f.y) + R5f.y; +PS1f = R127f.z; +// 4 +R125f.x = R6f.w + -(intBitsToFloat(0x3f666666)); +R124f.y = -(R14f.z) + R5f.z; +R5f.z = R7f.w + -(intBitsToFloat(0x3f666666)); +PV0f.w = R8f.x + -(0.0); +R127f.y = R8f.y + -(0.0); +PS0f = R127f.y; +// 5 +backupReg0f = R126f.y; +backupReg1f = R125f.z; +PV1f.x = R8f.z + -(0.0); +R126f.y = R8f.w + -(intBitsToFloat(0x3f666666)); +R125f.z = backupReg0f + R124f.z; +R125f.w = R10f.w + -(0.5); +R125f.w *= 2.0; +R125f.w = clamp(R125f.w, 0.0, 1.0); +R126f.w = (R124f.z * PV0f.w + backupReg1f); +PS1f = R126f.w; +// 6 +backupReg0f = R126f.x; +backupReg1f = R127f.y; +backupReg2f = R127f.z; +R126f.x = (R127f.w * R126f.z + R14f.x); +R127f.y = (R124f.z * PV1f.x + backupReg0f); +R127f.z = (R124f.z * backupReg1f + R125f.y); +R124f.w = (backupReg2f * R126f.z + R14f.y); +R5f.w = R125f.x * intBitsToFloat(0x41200000); +R5f.w = clamp(R5f.w, 0.0, 1.0); +PS0f = R5f.w; +// 7 +backupReg0f = R124f.y; +backupReg1f = R126f.z; +R125f.x = -(R14f.x) + R6f.x; +R124f.y = -(R14f.y) + R6f.y; +R126f.z = (backupReg0f * backupReg1f + R14f.z); +R6f.w = -(R14f.z) + R6f.z; +R1f.w = -(R14f.x) + R7f.x; +PS1f = R1f.w; +// 8 +backupReg0f = R126f.y; +R127f.x = R5f.z * intBitsToFloat(0x41200000); +R127f.x = clamp(R127f.x, 0.0, 1.0); +R126f.y = -(R14f.z) + R7f.z; +R124f.z = -(R14f.y) + R7f.y; +R7f.w = R9f.w + -(intBitsToFloat(0x3f666666)); +R2f.w = backupReg0f * intBitsToFloat(0x41200000); +R2f.w = clamp(R2f.w, 0.0, 1.0); +PS0f = R2f.w; +// 9 +R124f.x = -(R14f.z) + R8f.z; +R125f.y = -(R14f.y) + R8f.y; +R8f.z = -(R14f.x) + R8f.x; +R127f.w = R10f.x + -(0.0); +PS1f = R10f.y + -(0.0); +// 10 +R8f.x = R10f.w + -(intBitsToFloat(0x3f666666)); +R6f.y = R125f.z + R125f.w; +PV0f.z = R10f.z + -(0.0); +R8f.w = R11f.w + -(0.5); +R8f.w *= 2.0; +R8f.w = clamp(R8f.w, 0.0, 1.0); +R5f.x = (R125f.w * PS1f + R127f.z); +PS0f = R5f.x; +// 11 +backupReg0f = R126f.x; +backupReg1f = R124f.z; +R126f.x = max(R14f.x, backupReg0f); +R5f.y = (R125f.w * R127f.w + R126f.w); +R124f.z = max(R14f.z, R126f.z); +R3f.w = (R125f.w * PV0f.z + R127f.y); +R126f.w = (backupReg1f * R127f.x + R14f.y); +PS1f = R126f.w; +// 12 +backupReg0f = R125f.x; +backupReg1f = R126f.y; +R125f.x = max(R14f.y, R124f.w); +R126f.y = (R6f.w * R5f.w + R14f.z); +R126f.z = (R124f.y * R5f.w + R14f.y); +R124f.w = (backupReg0f * R5f.w + R14f.x); +R125f.z = (backupReg1f * R127f.x + R14f.z); +PS0f = R125f.z; +// 13 +backupReg0f = R127f.x; +backupReg1f = R9f.z; +R127f.x = (R1f.w * backupReg0f + R14f.x); +R124f.y = -(R14f.x) + R9f.x; +R9f.z = R7f.w * intBitsToFloat(0x41200000); +R9f.z = clamp(R9f.z, 0.0, 1.0); +R125f.w = -(R14f.y) + R9f.y; +R1f.w = -(R14f.z) + backupReg1f; +PS1f = R1f.w; +// 14 +backupReg0f = R124f.x; +backupReg1f = R125f.y; +R124f.x = (backupReg0f * R2f.w + R14f.z); +R125f.y = R8f.x * intBitsToFloat(0x41200000); +R125f.y = clamp(R125f.y, 0.0, 1.0); +R127f.z = (backupReg1f * R2f.w + R14f.y); +R127f.w = (R8f.z * R2f.w + R14f.x); +R2f.w = -(R14f.y) + R10f.y; +PS0f = R2f.w; +// 15 +backupReg0f = R10f.x; +backupReg1f = R10f.z; +R10f.x = -(R14f.x) + backupReg0f; +R127f.y = R11f.y + -(0.0); +R10f.zwy = vec3(-(R14f.z),R11f.x,R11f.z) + vec3(backupReg1f,-(0.0),-(0.0)); +PS1f = R10f.y; +// 16 +backupReg0f = R126f.x; +backupReg1f = R124f.z; +backupReg2f = R126f.y; +R126f.x = max(backupReg0f, R124f.w); +R126f.y = max(R125f.x, R126f.z); +R126f.z = R6f.y + R8f.w; +R7f.w = R12f.w + -(0.5); +R7f.w *= 2.0; +R7f.w = clamp(R7f.w, 0.0, 1.0); +R124f.z = max(backupReg1f, backupReg2f); +PS0f = R124f.z; +// 17 +R8f.x = max(R124f.x, R125f.z); +R9f.y = max(R127f.z, R126f.w); +R127f.z = max(R127f.w, R127f.x); +R127f.w = (R124f.y * R9f.z + R14f.x); +R124f.y = (R125f.w * R9f.z + R14f.y); +PS1f = R124f.y; +// 18 +backupReg0f = R127f.y; +R127f.x = (R1f.w * R9f.z + R14f.z); +R127f.y = (R10f.x * R125f.y + R14f.x); +R125f.z = (R2f.w * R125f.y + R14f.y); +R1f.w = (R10f.z * R125f.y + R14f.z); +R2f.w = (R8f.w * backupReg0f + R5f.x); +PS0f = R2f.w; +// 19 +backupReg0f = R10f.y; +R10f.x = (R8f.w * R10f.w + R5f.y); +R10f.y = R12f.x + -(0.0); +R9f.z = (R8f.w * backupReg0f + R3f.w); +R8f.w = R12f.y + -(0.0); +R9f.x = R12f.z + -(0.0); +PS1f = R9f.x; +// 20 +R7f.x = R12f.w + -(intBitsToFloat(0x3f666666)); +R8f.y = R11f.w + -(intBitsToFloat(0x3f666666)); +R10f.z = R126f.z + R7f.w; +R10f.w = max(R126f.y, R124f.y); +R7f.y = max(R124f.z, R127f.x); +PS0f = R7f.y; +// 21 +backupReg0f = R9f.y; +R6f.x = R13f.w + -(intBitsToFloat(0x3f666666)); +R9f.y = max(R126f.x, R127f.w); +R8f.z = max(R127f.y, R127f.z); +R9f.w = R4f.w + -(0.5); +R9f.w *= 2.0; +R9f.w = clamp(R9f.w, 0.0, 1.0); +R5f.z = max(R125f.z, backupReg0f); +PS1f = R5f.z; +// 0 +R127f.x = (R7f.w * R9f.x + R9f.z); +R127f.y = max(R1f.w, R8f.x); +R125f.z = R8f.y * intBitsToFloat(0x41200000); +R125f.z = clamp(R125f.z, 0.0, 1.0); +R127f.w = (R7f.w * R10f.y + R10f.x); +R124f.y = -(R14f.z) + R11f.z; +PS0f = R124f.y; +// 1 +R125f.x = -(R14f.y) + R11f.y; +R11f.y = R7f.x * intBitsToFloat(0x41200000); +R11f.y = clamp(R11f.y, 0.0, 1.0); +R127f.z = (R7f.w * R8f.w + R2f.w); +R125f.w = -(R14f.x) + R11f.x; +R125f.y = -(R14f.y) + R12f.y; +PS1f = R125f.y; +// 2 +backupReg0f = R12f.x; +R12f.x = -(R14f.z) + R12f.z; +R126f.yzw = vec3(R4f.x,-(R14f.x),R4f.y) + vec3(-(0.0),backupReg0f,-(0.0)); +R126f.x = R4f.z + -(0.0); +PS0f = R126f.x; +// 3 +backupReg0f = R10f.z; +R124f.x = R4f.w + -(intBitsToFloat(0x3f666666)); +R8f.y = R6f.x * intBitsToFloat(0x41200000); +R8f.y = clamp(R8f.y, 0.0, 1.0); +R10f.z = R13f.w + -(0.5); +R10f.z *= 2.0; +R10f.z = clamp(R10f.z, 0.0, 1.0); +R124f.w = backupReg0f + R9f.w; +R12f.y = -(R14f.x) + R13f.x; +PS1f = R12f.y; +// 4 +backupReg0f = R127f.x; +R127f.x = -(R14f.y) + R13f.y; +R10f.y = max(R9f.y, R8f.z); +R124f.z = R15f.w + -(intBitsToFloat(0x3f666666)); +R12f.w = -(R14f.z) + R13f.z; +R9f.y = (R9f.w * R126f.x + backupReg0f); +PS0f = R9f.y; +// 5 +backupReg0f = R124f.x; +backupReg1f = R7f.y; +backupReg2f = R10f.w; +R124f.x = (R9f.w * R126f.y + R127f.w); +R7f.y = backupReg0f * intBitsToFloat(0x41200000); +R7f.y = clamp(R7f.y, 0.0, 1.0); +R12f.z = max(backupReg1f, R127f.y); +R10f.w = max(backupReg2f, R5f.z); +R5f.z = -(R14f.x) + R4f.x; +PS1f = R5f.z; +// 6 +backupReg0f = R127f.z; +R126f.x = (R125f.w * R125f.z + R14f.x); +R126f.y = (R124f.y * R125f.z + R14f.z); +R127f.z = (R9f.w * R126f.w + backupReg0f); +R125f.w = (R125f.x * R125f.z + R14f.y); +R127f.y = (R12f.x * R11f.y + R14f.z); +PS0f = R127f.y; +// 7 +backupReg0f = R125f.y; +backupReg1f = R126f.z; +R12f.x = -(R14f.z) + R4f.z; +R125f.y = R13f.x + -(0.0); +R126f.z = (backupReg0f * R11f.y + R14f.y); +R126f.w = (backupReg1f * R11f.y + R14f.x); +R8f.z = R0f.w + -(0.5); +R8f.z *= 2.0; +R8f.z = clamp(R8f.z, 0.0, 1.0); +PS1f = R8f.z; +// 8 +backupReg0f = R4f.y; +R125f.x = R13f.y + -(0.0); +R4f.y = -(R14f.y) + backupReg0f; +R125f.z = R124f.w + R10f.z; +R124f.w = R13f.z + -(0.0); +R127f.w = R0f.w + -(intBitsToFloat(0x3f666666)); +PS0f = R127f.w; +// 9 +backupReg0f = R127f.x; +R127f.x = (R12f.w * R8f.y + R14f.z); +R124f.y = (backupReg0f * R8f.y + R14f.y); +R123f.z = (R12f.y * R8f.y + R14f.x); +PV1f.z = R123f.z; +R12f.w = R124f.z * intBitsToFloat(0x41200000); +R12f.w = clamp(R12f.w, 0.0, 1.0); +R4f.x = -(R14f.x) + R15f.x; +PS1f = R4f.x; +// 10 +R13f.x = (R10f.z * R125f.y + R124f.x); +R125f.y = max(PV1f.z, R126f.w); +R124f.z = -(R14f.z) + R15f.z; +R126f.w = -(R14f.y) + R15f.y; +R124f.x = max(R10f.w, R125f.w); +PS0f = R124f.x; +// 11 +backupReg0f = R125f.x; +backupReg1f = R124f.y; +R125f.x = (R10f.z * R124f.w + R9f.y); +R124f.y = (R10f.z * backupReg0f + R127f.z); +R10f.z = max(backupReg1f, R126f.z); +R125f.w = max(R127f.x, R127f.y); +R127f.y = R0f.x + -(0.0); +PS1f = R127f.y; +// 12 +backupReg0f = R126f.x; +backupReg1f = R126f.y; +backupReg2f = R127f.w; +R126f.x = (R5f.z * R7f.y + R14f.x); +R126f.y = max(R10f.y, backupReg0f); +R126f.z = (R12f.x * R7f.y + R14f.z); +R127f.w = max(R12f.z, backupReg1f); +R5f.z = backupReg2f * intBitsToFloat(0x41200000); +R5f.z = clamp(R5f.z, 0.0, 1.0); +PS0f = R5f.z; +// 13 +backupReg0f = R4f.y; +R12f.x = -(R14f.z) + R0f.z; +R4f.y = -(R14f.x) + R0f.x; +R127f.z = (backupReg0f * R7f.y + R14f.y); +R124f.w = R0f.z + -(0.0); +R7f.y = R15f.w + -(0.5); +R7f.y *= 2.0; +R7f.y = clamp(R7f.y, 0.0, 1.0); +PS1f = R7f.y; +// 14 +backupReg0f = R0f.y; +backupReg1f = R125f.z; +R127f.x = R0f.y + -(0.0); +R0f.y = -(R14f.y) + backupReg0f; +R125f.z = backupReg1f + R8f.z; +R123f.w = (R4f.x * R12f.w + R14f.x); +PV0f.w = R123f.w; +R0f.x = (R126f.w * R12f.w + R14f.y); +PS0f = R0f.x; +// 15 +backupReg0f = R126f.x; +R126f.x = max(R126f.y, backupReg0f); +R126f.y = max(R124f.x, R127f.z); +R127f.z = max(PV0f.w, R125f.y); +R123f.w = (R124f.z * R12f.w + R14f.z); +PV1f.w = R123f.w; +R124f.x = R15f.x + -(0.0); +PS1f = R124f.x; +// 16 +backupReg0f = R127f.x; +backupReg1f = R126f.z; +R127f.x = (R8f.z * R127f.y + R13f.x); +R127f.y = (R8f.z * backupReg0f + R124f.y); +R126f.z = max(R127f.w, backupReg1f); +R127f.w = (R8f.z * R124f.w + R125f.x); +R124f.y = max(PV1f.w, R125f.w); +PS0f = R124f.y; +// 17 +R123f.x = (R4f.y * R5f.z + R14f.x); +PV1f.x = R123f.x; +R123f.y = (R0f.y * R5f.z + R14f.y); +PV1f.y = R123f.y; +R124f.z = max(R0f.x, R10f.z); +// 18 +backupReg0f = R126f.y; +R123f.x = (R12f.x * R5f.z + R14f.z); +PV0f.x = R123f.x; +R126f.y = max(R126f.x, PV1f.x); +PV0f.z = R15f.z + -(0.0); +PV0f.w = R15f.y + -(0.0); +R5f.z = max(backupReg0f, PV1f.y); +PS0f = R5f.z; +// 19 +backupReg0f = R127f.x; +backupReg1f = R126f.z; +backupReg2f = R127f.w; +R127f.x = (R7f.y * PV0f.w + R127f.y); +R127f.y = (R7f.y * R124f.x + backupReg0f); +R126f.z = R125f.z + R7f.y; +R127f.w = max(backupReg1f, PV0f.x); +R125f.w = (R7f.y * PV0f.z + backupReg2f); +PS1f = R125f.w; +// 20 +PV0f.x = max(R10f.y, R127f.z); +PV0f.z = max(R12f.z, R124f.y); +PV0f.w = max(R10f.w, R124f.z); +R127f.z = 1.0 / R6f.y; +PS0f = R127f.z; +// 21 +backupReg0f = R126f.y; +R124f.x = max(PV0f.w, R5f.z); +R126f.y = max(PV0f.x, backupReg0f); +R5f.z = R5f.y * PS0f; +R14f.w = max(PV0f.z, R127f.w); +PS1f = 1.0 / R126f.z; +// 22 +backupReg0f = R3f.w; +R12f.x = R5f.x * R127f.z; +PV0f.x = R12f.x; +R5f.y = R127f.y * PS1f; +PV0f.y = R5f.y; +R14f.z = R127f.x * PS1f; +PV0f.z = R14f.z; +R3f.w = backupReg0f * R127f.z; +PV0f.w = R3f.w; +R15f.z = R125f.w * PS1f; +PS0f = R15f.z; +// 23 +backupReg0f = R10f.y; +backupReg1f = R12f.z; +R5f.x = R10f.w + -(PV0f.x); +R10f.y = backupReg0f + -(R5f.z); +R12f.z = -(PV0f.y) + R126f.y; +R10f.w = backupReg1f + -(PV0f.w); +R6f.y = -(PV0f.z) + R124f.x; +PS1f = R6f.y; +// 0 +PV0f.x = -(R15f.z) + R14f.w; +R17f.y = (R5f.x * intBitsToFloat(uf_remappedPS[6].x) + R12f.x); +R17f.z = (R10f.w * intBitsToFloat(uf_remappedPS[6].x) + R3f.w); +R17f.x = (R10f.y * intBitsToFloat(uf_remappedPS[6].x) + R5f.z); +PS0f = R17f.x; +// 1 +R16f.x = (R12f.z * intBitsToFloat(uf_remappedPS[6].x) + R5f.y); +PV1f.x = R16f.x; +R16f.y = (R6f.y * intBitsToFloat(uf_remappedPS[6].x) + R14f.z); +PV1f.y = R16f.y; +R16f.z = (PV0f.x * intBitsToFloat(uf_remappedPS[6].x) + R15f.z); +PV1f.z = R16f.z; +// 2 +R1f.xyz = vec3(PV1f.x,PV1f.y,PV1f.z); +R1f.w = R16f.w; +// 3 +R0f.xyz = vec3(R17f.x,R17f.y,R17f.z); +R0f.w = R17f.w; +// export +passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w); +passPixelColor1 = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +} diff --git a/Source/XenobladeX/b253dca415790207_0000000000000079_ps.txt b/Source/XenobladeX/b253dca415790207_0000000000000079_ps.txt new file mode 100644 index 00000000..6574f6e7 --- /dev/null +++ b/Source/XenobladeX/b253dca415790207_0000000000000079_ps.txt @@ -0,0 +1,140 @@ + + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader b253dca415790207 +// motion blur fix +// To-do, review just hardcoding half length for higher res, probably looks better +const float resScale = ; +//const float resScale = 3; +uniform ivec4 uf_remappedPS[5]; + +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4e12000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +// 0 +R1f.x = R0f.x + intBitsToFloat(uf_remappedPS[0].x)/ resScale; +R1f.y = R0f.y + intBitsToFloat(uf_remappedPS[0].y)/ resScale; +R0f.z = R0f.x + intBitsToFloat(uf_remappedPS[1].x)/ resScale; +R0f.w = R0f.y + intBitsToFloat(uf_remappedPS[1].y)/ resScale; +R5f.w = 1.0; +PS0f = R5f.w; +// 1 +R2f.x = R0f.x + intBitsToFloat(uf_remappedPS[2].x)/ resScale; +R2f.y = R0f.y + intBitsToFloat(uf_remappedPS[2].y)/ resScale; +R1f.z = R0f.x + intBitsToFloat(uf_remappedPS[3].x)/ resScale; +R1f.w = R0f.y + intBitsToFloat(uf_remappedPS[3].y)/ resScale; +// 2 +backupReg0f = R0f.x; +backupReg1f = R0f.y; +R0f.x = backupReg0f + intBitsToFloat(uf_remappedPS[4].x)/ resScale; +R0f.y = backupReg1f + intBitsToFloat(uf_remappedPS[4].y)/resScale; +R3f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R4f.xyz = (texture(textureUnitPS0, R0f.zw).xyz); +R2f.xyz = (texture(textureUnitPS0, R2f.xy).xyz); +R1f.xyz = (texture(textureUnitPS0, R1f.zw).xyz); +R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz); +// 0 +PV0f.x = R3f.y + -(0.5); +PV0f.x *= 2.0; +PV0f.y = R3f.x + -(0.5); +PV0f.y *= 2.0; +R127f.z = R4f.x + -(0.5); +R127f.z *= 2.0; +R127f.w = R4f.y + -(0.5); +R127f.w *= 2.0; +PS0f = R3f.z * intBitsToFloat(uf_remappedPS[0].z); +// 1 +R123f.x = (R4f.z * intBitsToFloat(uf_remappedPS[1].z) + PS0f); +PV1f.x = R123f.x; +R127f.y = R2f.x + -(0.5); +R127f.y *= 2.0; +PV1f.z = PV0f.y * intBitsToFloat(uf_remappedPS[0].z); +PV1f.w = PV0f.x * intBitsToFloat(uf_remappedPS[0].z); +R126f.z = R2f.y + -(0.5); +R126f.z *= 2.0; +PS1f = R126f.z; +// 2 +R123f.x = (R127f.z * intBitsToFloat(uf_remappedPS[1].z) + PV1f.z); +PV0f.x = R123f.x; +R126f.y = R1f.x + -(0.5); +R126f.y *= 2.0; +R123f.z = (R127f.w * intBitsToFloat(uf_remappedPS[1].z) + PV1f.w); +PV0f.z = R123f.z; +R123f.w = (R2f.z * intBitsToFloat(uf_remappedPS[2].z) + PV1f.x); +PV0f.w = R123f.w; +R127f.w = R1f.y + -(0.5); +R127f.w *= 2.0; +PS0f = R127f.w; +// 3 +R123f.x = (R126f.z * intBitsToFloat(uf_remappedPS[2].z) + PV0f.z); +PV1f.x = R123f.x; +R123f.y = (R127f.y * intBitsToFloat(uf_remappedPS[2].z) + PV0f.x); +PV1f.y = R123f.y; +R126f.z = R0f.x + -(0.5); +R126f.z *= 2.0; +R123f.w = (R1f.z * intBitsToFloat(uf_remappedPS[3].z) + PV0f.w); +PV1f.w = R123f.w; +R126f.w = R0f.y + -(0.5); +R126f.w *= 2.0; +PS1f = R126f.w; +// 4 +R123f.x = (R0f.z * intBitsToFloat(uf_remappedPS[4].z) + PV1f.w); +PV0f.x = R123f.x; +R123f.y = (R126f.y * intBitsToFloat(uf_remappedPS[3].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R127f.w * intBitsToFloat(uf_remappedPS[3].z) + PV1f.x); +PV0f.z = R123f.z; +// 5 +R123f.y = (R126f.w * intBitsToFloat(uf_remappedPS[4].z) + PV0f.z); +PV1f.y = R123f.y; +R123f.z = (R126f.z * intBitsToFloat(uf_remappedPS[4].z) + PV0f.y); +PV1f.z = R123f.z; +R5f.z = PV0f.x; +PS1f = R5f.z; +// 6 +R5f.x = PV1f.z + 1.0; +R5f.x /= 2.0; +R5f.y = PV1f.y + 1.0; +R5f.y /= 2.0; +// export +passPixelColor0 = vec4(R5f.x, R5f.y, R5f.z, R5f.w); +} diff --git a/Source/XenobladeX/b3fb199c73caa796_00000000000003c9_ps.txt b/Source/XenobladeX/b3fb199c73caa796_00000000000003c9_ps.txt new file mode 100644 index 00000000..74b780ea --- /dev/null +++ b/Source/XenobladeX/b3fb199c73caa796_00000000000003c9_ps.txt @@ -0,0 +1,215 @@ + + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader b3fb199c73caa796 +// open world and skell bloom. +// To-do - As long as brigntess fix is used, this will always be dodgy .. +const float resScale = ; + +//const float resScale = 3.0; +//const float exposure = 0.9; +uniform ivec4 uf_remappedPS[4]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf551a000 res 1280x720x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + + +//const float repositionBloom = 1.00125; +//mattdesl MIT - https://github.com/Jam3/glsl-fast-gaussian-blur +vec4 blur9(sampler2D image, vec2 uv, vec2 resolution, vec2 direction) { + vec4 color = vec4(0.0); + vec2 off1 = vec2(1.3846153846) * direction; + vec2 off2 = vec2(3.2307692308) * direction; + color += texture2D(image, uv) * 0.2270270270; + color += texture2D(image, uv + (off1 / resolution)) * 0.3162162162; + color += texture2D(image, uv - (off1 / resolution)) * 0.3162162162; + color += texture2D(image, uv + (off2 / resolution)) * 0.0702702703; + color += texture2D(image, uv - (off2 / resolution)) * 0.0702702703; + return color; +} +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R6f = vec4(0.0); +vec4 R7f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R124f = vec4(0.0); +vec4 R125f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +// 0 +R1f.x = R0f.x + (intBitsToFloat(uf_remappedPS[0].x)/resScale); +R1f.y = R0f.y + (intBitsToFloat(uf_remappedPS[0].y) / resScale); +R0f.z = R0f.x + (intBitsToFloat(uf_remappedPS[0].z) / resScale); +R0f.w = R0f.y + (intBitsToFloat(uf_remappedPS[0].w) / resScale); +// 1 +backupReg0f = R0f.x; +backupReg1f = R0f.y; +backupReg0f = R0f.x; +backupReg1f = R0f.y; +R0f.x = backupReg0f + (intBitsToFloat(uf_remappedPS[1].x) / resScale); +R0f.y = backupReg1f + (intBitsToFloat(uf_remappedPS[1].y) / resScale); +R1f.z = backupReg0f + (intBitsToFloat(uf_remappedPS[1].z) / resScale); +R1f.w = backupReg1f + (intBitsToFloat(uf_remappedPS[1].w) / resScale); +R2f.xyzw = (texture(textureUnitPS1, R1f.xy).xyzw); +R3f.xyzw = (texture(textureUnitPS1, R0f.zw).xyzw); +R4f.xyzw = (texture(textureUnitPS1, R0f.xy).xyzw); +R5f.xyzw = (texture(textureUnitPS1, R1f.zw).xyzw); +R6f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw); +R7f.xyzw = (texture(textureUnitPS0, R0f.zw).xyzw); +R0f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw); +R1f.xyzw = (texture(textureUnitPS0, R1f.zw).xyzw); +// 0 +PV0f.x = R2f.z + R3f.z; +PV0f.y = R2f.y + R3f.y; +PV0f.z = R2f.x + R3f.x; +PV0f.w = R2f.w + R3f.w; +// 1 +PV1f.x = PV0f.x + R4f.z; +PV1f.y = PV0f.y + R4f.y; +PV1f.z = PV0f.z + R4f.x; +PV1f.w = PV0f.w + R4f.w; +R127f.x = R6f.x + R7f.x; +PS1f = R127f.x; +// 2 +PV0f.x = PV1f.x + R5f.z; +PV0f.y = PV1f.y + R5f.y; +PV0f.z = PV1f.z + R5f.x; +PV0f.w = PV1f.w + R5f.w; +R127f.w = R6f.y + R7f.y; +PS0f = R127f.w; +// 3 +PV1f.x = PV0f.x * intBitsToFloat(uf_remappedPS[2].z); +PV1f.y = PV0f.y * intBitsToFloat(uf_remappedPS[2].z); +PV1f.z = PV0f.z * intBitsToFloat(uf_remappedPS[2].z); +PV1f.w = PV0f.w * intBitsToFloat(uf_remappedPS[2].z); +R127f.z = R6f.z + R7f.z; +PS1f = R127f.z; +// 4 +PV0f.x = max(PV1f.x, 0.0); +PV0f.y = max(PV1f.y, 0.0); +PV0f.z = max(PV1f.z, 0.0); +PV0f.w = max(PV1f.w, 0.0); +R126f.y = R6f.w + R7f.w; +PS0f = R126f.y; +// 5 +R6f.x = min(PV0f.x, 4.0); +PV1f.x = R6f.x; +R125f.y = min(PV0f.y, 4.0); +PV1f.y = R125f.y; +R126f.z = min(PV0f.z, 4.0); +PV1f.z = R126f.z; +R125f.w = min(PV0f.w, 4.0); +R124f.x = R127f.x + R0f.x; +PS1f = R124f.x; +// 6 +PV0f.x = PV1f.z + -(intBitsToFloat(uf_remappedPS[2].x)); +PV0f.y = PV1f.y + -(intBitsToFloat(uf_remappedPS[3].x)); +PV0f.z = PV1f.z + -(intBitsToFloat(uf_remappedPS[3].x)); +PV0f.w = PV1f.x + -(intBitsToFloat(uf_remappedPS[3].x)); +R127f.y = PV1f.y + -(intBitsToFloat(uf_remappedPS[2].x)); +PS0f = R127f.y; +// 7 +R127f.x = R6f.x + -(intBitsToFloat(uf_remappedPS[2].x)); +PV1f.y = max(PV0f.z, 0.0); +PV1f.z = max(PV0f.y, 0.0); +PV1f.w = max(PV0f.w, 0.0); +R126f.x = max(PV0f.x, 0.0); +PS1f = R126f.x; +// 8 +backupReg0f = R127f.y; +R125f.x = dot(vec4(intBitsToFloat(uf_remappedPS[3].y),intBitsToFloat(uf_remappedPS[3].y),intBitsToFloat(uf_remappedPS[3].y),-0.0),vec4(PV1f.y,PV1f.z,PV1f.w,0.0)); +PV0f.x = R125f.x; +PV0f.y = R125f.x; +PV0f.z = R125f.x; +PV0f.w = R125f.x; +R127f.y = max(backupReg0f, 0.0); +PS0f = R127f.y; +// 9 +backupReg0f = R126f.y; +backupReg1f = R127f.x; +backupReg2f = R127f.w; +R127f.x = R127f.z + R0f.z; +R126f.y = backupReg0f + R0f.w; +PV1f.z = max(backupReg1f, 0.0); +R127f.w = backupReg2f + R0f.y; +R126f.w = R126f.z * PV0f.x; +PS1f = R126f.w; +// 10 +tempf.x = dot(vec4(intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].y),-0.0),vec4(R126f.x,R127f.y,PV1f.z,0.0)); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R124f.w = tempf.x; +R127f.z = R125f.y * R125f.x; +PS0f = R127f.z; +// 11 +PV1f.x = R125f.w * R125f.x; +PV1f.y = R6f.x * R125f.x; +R125f.z = R127f.w + R1f.y; +R127f.w = R127f.x + R1f.z; +R0f.w = R126f.y + R1f.w; +PS1f = R0f.w; +// 12 +backupReg0f = R124f.x; +R124f.x = (R125f.y * R124f.w + R127f.z); +R125f.y = (R6f.x * R124f.w + PV1f.y); +PV0f.z = backupReg0f + R1f.x; +R123f.w = (R126f.z * R124f.w + R126f.w); +PV0f.w = R123f.w; +R127f.x = (R125f.w * R124f.w + PV1f.x); +PS0f = R127f.x; +// 13 +R125f.x = R127f.w * intBitsToFloat(uf_remappedPS[3].z); +R126f.y = R125f.z * intBitsToFloat(uf_remappedPS[3].z); +PV1f.z = PV0f.z * intBitsToFloat(uf_remappedPS[3].z); +R127f.w = R0f.w * intBitsToFloat(uf_remappedPS[3].z); +PS1f = min(PV0f.w, intBitsToFloat(uf_remappedPS[2].w)); +// 14 +PV0f.x = min(R127f.x, intBitsToFloat(uf_remappedPS[2].w)); +PV0f.y = min(R125f.y, intBitsToFloat(uf_remappedPS[2].w)); +PV0f.z = min(R124f.x, intBitsToFloat(uf_remappedPS[2].w)); +R0f.x = max(PV1f.z, PS1f); +PS0f = R0f.x; +// 15 +R0f.y = max(R126f.y, PV0f.z); +R0f.z = max(R125f.x, PV0f.y); +R0f.w = max(R127f.w, PV0f.x); +// export +passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w); +} diff --git a/Source/XenobladeX/cf4eda5057e1a527_0000000000000000_vs.txt b/Source/XenobladeX/cf4eda5057e1a527_0000000000000000_vs.txt new file mode 100644 index 00000000..f4135a3d --- /dev/null +++ b/Source/XenobladeX/cf4eda5057e1a527_0000000000000000_vs.txt @@ -0,0 +1,67 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader cf4eda5057e1a527 +//shadow acne fix in city. +// to-do Magic value, review other solution. +uniform ivec4 uf_remappedVS[1]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +layout(location = 0) in uvec4 attrDataSem0; +layout(location = 1) in uvec4 attrDataSem1; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +backupReg0f = R2f.x; +backupReg1f = R2f.y; +R2f.x = backupReg0f; +R2f.y = backupReg1f; +PV0f.z = R1f.y * intBitsToFloat(uf_remappedVS[0].y); +PV0f.w = R1f.x * intBitsToFloat(uf_remappedVS[0].x); +// 1 +R1f.x = PV0f.w + intBitsToFloat(uf_remappedVS[0].z) + 0.0006; +R1f.y = PV0f.z + intBitsToFloat(uf_remappedVS[0].w); +// export +gl_Position = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +// export +passParameterSem0 = vec4(R2f.x, R2f.y, R2f.z, R2f.z); +// 0 +} diff --git a/Source/XenobladeX/d8e69e8df8c227f5_00000000000003c9_ps.txt b/Source/XenobladeX/d8e69e8df8c227f5_00000000000003c9_ps.txt new file mode 100644 index 00000000..a27415e5 --- /dev/null +++ b/Source/XenobladeX/d8e69e8df8c227f5_00000000000003c9_ps.txt @@ -0,0 +1,182 @@ + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader d8e69e8df8c227f5 +// Inital blur step pixelation fix, naive blur9 hack to aproximate 720 blur. +// To-do review performance hit of multi pass and depth for bokeh blur +const float resScale = ; +//const float resScale = 3.0; // + +uniform ivec4 uf_remappedPS[3]; + +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf4386000 res 1280x720x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; +const float repositionBlur = 1.00425; +//mattdesl MIT - https://github.com/Jam3/glsl-fast-gaussian-blur +vec4 blur9(sampler2D image, vec2 uv, vec2 resolution, vec2 direction) { + vec4 color = vec4(0.0); + vec2 off1 = vec2(1.3846153846) * direction; + vec2 off2 = vec2(3.2307692308) * direction; + color += texture2D(image, uv) * 0.2270270270; + color += texture2D(image, uv + (off1 / resolution)) * 0.3162162162; + color += texture2D(image, uv - (off1 / resolution)) * 0.3162162162; + color += texture2D(image, uv + (off2 / resolution)) * 0.0702702703; + color += texture2D(image, uv - (off2 / resolution)) * 0.0702702703; + return color; +} + +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R5f = vec4(0.0); +vec4 R6f = vec4(0.0); +vec4 R7f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +vec2 scaleFactor = vec2(repositionBlur, repositionBlur); //Added +R0f.xy = R0f.xy * scaleFactor;// re-align bloom.. hack until issue source is found. +// 0 +R1f.x = R0f.x + (intBitsToFloat(uf_remappedPS[0].x)/ resScale); +R1f.y = R0f.y + (intBitsToFloat(uf_remappedPS[0].y)/ resScale); +R0f.z = R0f.x + (intBitsToFloat(uf_remappedPS[0].z)/ resScale); +R0f.w = R0f.y + (intBitsToFloat(uf_remappedPS[0].w)/ resScale); +// 1 + +backupReg0f = R0f.x; +backupReg1f = R0f.y; +backupReg0f = R0f.x; +backupReg1f = R0f.y; +R0f.x = backupReg0f + (intBitsToFloat(uf_remappedPS[1].x)/ resScale); +R0f.y = backupReg1f + (intBitsToFloat(uf_remappedPS[1].y)/ resScale); +R1f.z = backupReg0f + (intBitsToFloat(uf_remappedPS[1].z)/ resScale); +R1f.w = backupReg1f + (intBitsToFloat(uf_remappedPS[1].w)/ resScale); + + + + +R2f.xyz = (texture(textureUnitPS1, R1f.xy).xyz); +R3f.xyz = (texture(textureUnitPS1, R0f.zw).xyz); +R4f.xyz = (texture(textureUnitPS1, R0f.xy).xyz); +R5f.xyz = (texture(textureUnitPS1, R1f.zw).xyz); + +//hack aproximate 720 blur +R6f = blur9(textureUnitPS0, R1f.xy, textureSize(textureUnitPS0, 0), vec2(0.0, 1.0)); // note, check what goes wrong with textureSize(textureUnitPS0, 0), +R7f = blur9(textureUnitPS0, R0f.zw, textureSize(textureUnitPS0, 0), vec2(1.0, 0.0)); +R0f = blur9(textureUnitPS0, R0f.xy, textureSize(textureUnitPS0, 0), vec2(0.0, 1.0)); +R1f = blur9(textureUnitPS0, R1f.zw, textureSize(textureUnitPS0, 0), vec2(1.0, 0.0)); + + +/* +R6f.xyz = (texture(textureUnitPS0, R1f.xy).xyz); +R7f.xyz = (texture(textureUnitPS0, R0f.zw).xyz); +R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz); +R1f.xyz = (texture(textureUnitPS0, R1f.zw).xyz); +*/ +// 0// 0.125, 31.875, 8128.125 +tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0)); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R127f.w = tempf.x; +R127f.z = R6f.x + R7f.x; +PS0f = R127f.z; +// 1 +tempf.x = dot(vec4(R3f.x,R3f.y,R3f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0)); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +R127f.y = R6f.y + R7f.y; +PS1f = R127f.y; +// 2 +tempf.x = dot(vec4(R4f.x,R4f.y,R4f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0)); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +PS0f = R127f.w + PV1f.x; +// 3 +tempf.x = dot(vec4(R5f.x,R5f.y,R5f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0)); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +PS1f = PS0f + PV0f.x; +// 4 +backupReg0f = R0f.y; +PV0f.y = PS1f + PV1f.x; +PV0f.z = R127f.y + backupReg0f; +PV0f.w = R6f.z + R7f.z; +// 5 +backupReg0f = R0f.z; +R123f.x = (PV0f.y * 0.25 + -(intBitsToFloat(uf_remappedPS[2].x))); +PV1f.x = R123f.x; +PV1f.y = R127f.z + R0f.x; +PV1f.z = PV0f.z + R1f.y; +PV1f.w = PV0f.w + backupReg0f; +// 6 +PV0f.x = PV1f.y + R1f.x; +PV0f.y = PV1f.w + R1f.z; +PV0f.z = PV1f.z * 0.25; +PV0f.w = max(PV1f.x, -(PV1f.x)); +// 7 +PV1f.x = PV0f.x * 0.25; +PV1f.y = PV0f.y * 0.25; +PV1f.z = PV0f.w * intBitsToFloat(uf_remappedPS[2].y); +PV1f.z = clamp(PV1f.z, 0.0, 1.0); +PV1f.w = max(PV0f.z, 0.0); +// 8 +PV0f.x = max(PV1f.y, 0.0); +R1f.y = min(PV1f.w, 4.0); +PV0f.z = max(PV1f.x, 0.0); +tempResultf = log2(PV1f.z); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0f = tempResultf; +// 9 +PV1f.x = PS0f * intBitsToFloat(uf_remappedPS[2].w); +R1f.z = min(PV0f.x, 4.0); +R1f.x = min(PV0f.z, 4.0); +PS1f = R1f.x; +// 10 +PS0f = exp2(PV1f.x); +// 11 +R1f.w = PS0f * intBitsToFloat(uf_remappedPS[2].z); + +//R1f = blur9(textureUnitPS0, R1f.xy, vec2(2560.0, 1440.0), vec2(1.0, 0.0)); +// export +passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +} diff --git a/Source/XenobladeX/d936195db0dd8e7d_0000000000001e52_ps.txt b/Source/XenobladeX/d936195db0dd8e7d_0000000000001e52_ps.txt new file mode 100644 index 00000000..3b19a74e --- /dev/null +++ b/Source/XenobladeX/d936195db0dd8e7d_0000000000001e52_ps.txt @@ -0,0 +1,94 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader d936195db0dd8e7d +// cross fade brightness +// To-do, .5 is daylight and 1.0 night is wiiu "correct" for nvidia +// changes here in turn "breaks" bloom as they over or under expose depending on day/night +const float preExposure = 0.55; // old brigntess tweak. Truncates at around .45+ +const float gammaPostExposure = 1.1; // compensate pre exposure, but loss of contrast when positive. + +uniform ivec4 uf_remappedPS[1]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 1) uniform sampler3D textureUnitPS1;// Tex1 addr 0x26032000 res 16x16x16 dim 2 tm: 7 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x10) Sampler1 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 2) uniform sampler3D textureUnitPS2;// Tex2 addr 0x2603b000 res 16x16x16 dim 2 tm: 7 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x10) Sampler2 ClampX/Y/Z: 2 2 2 border: 0 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R2f = vec4(0.0); +vec4 R127f = vec4(0.0); +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = passParameterSem0; +R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz) *preExposure; +// 0 +backupReg0f = R0f.x; +PV0f.x = backupReg0f * intBitsToFloat(uf_remappedPS[0].x); +PV0f.x = clamp(PV0f.x, 0.0, 1.0); +R127f.z = R0f.z * intBitsToFloat(uf_remappedPS[0].x); +R127f.z = clamp(R127f.z, 0.0, 1.0); +R127f.w = R0f.y * intBitsToFloat(uf_remappedPS[0].x); +R127f.w = clamp(R127f.w, 0.0, 1.0); +R2f.w = 1.0; +PS0f = R2f.w; +// 1 +tempResultf = log2(PV0f.x); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS1f = tempResultf; +// 2 +R127f.x = PS1f * intBitsToFloat(0x3ee8ba2e); +tempResultf = log2(R127f.w); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0f = tempResultf; +// 3 +R127f.y = PS0f * intBitsToFloat(0x3ee8ba2e); +tempResultf = log2(R127f.z); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS1f = tempResultf; +// 4 +R127f.w = PS1f * intBitsToFloat(0x3ee8ba2e); +PS0f = exp2(R127f.x); +// 5 +R0f.x = (PS0f * intBitsToFloat(uf_remappedPS[0].z) + intBitsToFloat(uf_remappedPS[0].w)); +PS1f = exp2(R127f.y); +// 6 +R0f.y = (PS1f * intBitsToFloat(uf_remappedPS[0].z) + intBitsToFloat(uf_remappedPS[0].w)); +PS0f = exp2(R127f.w); +// 7 +R0f.z = (PS0f * intBitsToFloat(uf_remappedPS[0].z) + intBitsToFloat(uf_remappedPS[0].w)); +R1f.xyz = (texture(textureUnitPS1, vec3(R0f.x,R0f.y,R0f.z)).xyz); +R0f.xyz = (texture(textureUnitPS2, vec3(R0f.x,R0f.y,R0f.z)).xyz); +// 0 +backupReg0f = R0f.y; +backupReg1f = R0f.x; +PV0f.x = R1f.z + -(R0f.z); +PV0f.y = R1f.y + -(backupReg0f); +PV0f.z = R1f.x + -(backupReg1f); +// 1 +R2f.x = (PV0f.z * intBitsToFloat(uf_remappedPS[0].y) + R0f.x); +R2f.y = (PV0f.y * intBitsToFloat(uf_remappedPS[0].y) + R0f.y); +R2f.z = (PV0f.x * intBitsToFloat(uf_remappedPS[0].y) + R0f.z); +// export +R2f = vec4(pow(R2f.xyz, vec3(1. / gammaPostExposure)), 1.0); +passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +} diff --git a/Source/XenobladeX/fdb5a87dd0368c6b_000000000000f249_ps.txt b/Source/XenobladeX/fdb5a87dd0368c6b_000000000000f249_ps.txt new file mode 100644 index 00000000..9c661ee7 --- /dev/null +++ b/Source/XenobladeX/fdb5a87dd0368c6b_000000000000f249_ps.txt @@ -0,0 +1,479 @@ + + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader fdb5a87dd0368c6b +// shadows scaling, ie 4096 = x4 +// To do - some nice edge smoothing at higher res +const float resScale = ; +//const float resScale = 4; +uniform ivec4 uf_remappedPS[23]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4386000 res 1280x720x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0 +layout(binding = 1) uniform sampler2DShadow textureUnitPS1;// Tex1 addr 0xf551a000 res 1024x1024x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 6 6 6 border: 2 +layout(binding = 2) uniform sampler2DShadow textureUnitPS2;// Tex2 addr 0xf571a000 res 1024x1024x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler2 ClampX/Y/Z: 6 6 6 border: 2 +layout(binding = 3) uniform sampler2DShadow textureUnitPS3;// Tex3 addr 0xf591a000 res 512x512x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler3 ClampX/Y/Z: 6 6 6 border: 2 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R3i = ivec4(0); +ivec4 R4i = ivec4(0); +ivec4 R5i = ivec4(0); +ivec4 R6i = ivec4(0); +ivec4 R7i = ivec4(0); +ivec4 R8i = ivec4(0); +ivec4 R9i = ivec4(0); +ivec4 R10i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R126i = ivec4(0); +ivec4 R127i = ivec4(0); +int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i; +ivec4 PV0i = ivec4(0), PV1i = ivec4(0); +int PS0i = 0, PS1i = 0; +ivec4 tempi = ivec4(0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +bool activeMaskStack[4]; +bool activeMaskStackC[5]; +activeMaskStack[0] = false; +activeMaskStack[1] = false; +activeMaskStack[2] = false; +activeMaskStackC[0] = false; +activeMaskStackC[1] = false; +activeMaskStackC[2] = false; +activeMaskStackC[3] = false; +activeMaskStack[0] = true; +activeMaskStackC[0] = true; +activeMaskStackC[1] = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = floatBitsToInt(passParameterSem0); +R1i = floatBitsToInt(passParameterSem1); +if( activeMaskStackC[1] == true ) { +R1i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R1i.xy)).xyz); +} +if( activeMaskStackC[1] == true ) { +// 0 +backupReg0i = R0i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedPS[0].x),intBitsToFloat(uf_remappedPS[0].y),intBitsToFloat(uf_remappedPS[0].z),-0.0),vec4(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(R1i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R5i.w = tempi.x; +PS0i = floatBitsToInt(1.0 / intBitsToFloat(backupReg0i)); +// 1 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(PS0i)); +R6i.y = floatBitsToInt(intBitsToFloat(uf_remappedPS[1].y) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_remappedPS[2].y) * 1.0); +R127i.w = floatBitsToInt(intBitsToFloat(uf_remappedPS[2].x) * 1.0); +R4i.x = floatBitsToInt(intBitsToFloat(uf_remappedPS[1].x) * 1.0); +PS1i = R4i.x; +// 2 +R5i.x = floatBitsToInt(intBitsToFloat(R0i.x) * intBitsToFloat(PV1i.x)); +R7i.y = floatBitsToInt(intBitsToFloat(R0i.y) * intBitsToFloat(PV1i.x)); +R5i.z = floatBitsToInt(intBitsToFloat(uf_remappedPS[1].z) * 1.0); +PV0i.w = floatBitsToInt(intBitsToFloat(uf_remappedPS[2].z) * 1.0); +// 3 +backupReg0i = R127i.z; +R123i.x = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[3].x)+ intBitsToFloat(R127i.w))); +PV1i.x = R123i.x; +R127i.z = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[3].z) + intBitsToFloat(PV0i.w))); +R123i.w = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[3].y) + intBitsToFloat(backupReg0i))); +PV1i.w = R123i.w; +// 4 +R127i.x = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[4].y) + intBitsToFloat(PV1i.w))); +R127i.y = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[4].x) + intBitsToFloat(PV1i.x))); +R126i.z = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[5].x) + intBitsToFloat(R4i.x))); +R127i.w = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[5].y) + intBitsToFloat(R6i.y))); +// 5 +R126i.y = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[5].z) + intBitsToFloat(R5i.z))); +R126i.w = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[4].z) + intBitsToFloat(R127i.z))); +// 6 +backupReg0i = R127i.x; +backupReg1i = R127i.y; +backupReg2i = R127i.w; +R127i.x = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[6].x) + intBitsToFloat(R126i.z))); +R127i.y = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[7].y) + intBitsToFloat(backupReg0i))); +PV0i.y = R127i.y; +R126i.z = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[7].x) + intBitsToFloat(backupReg1i))); +PV0i.z = R126i.z; +R127i.w = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[6].y) + intBitsToFloat(backupReg2i))); +// 7 +backupReg0i = R126i.y; +backupReg1i = R126i.w; +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.z) + -(0.5)); +R126i.y = floatBitsToInt(intBitsToFloat(PV0i.y) + -(0.5)); +R123i.z = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[6].z) + intBitsToFloat(backupReg0i))); +PV1i.z = R123i.z; +R126i.w = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[7].z) + intBitsToFloat(backupReg1i))); +// 8 +R6i.x = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[8].x) + intBitsToFloat(R127i.x))); +R5i.y = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[8].y) + intBitsToFloat(R127i.w))); +R0i.z = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[8].z) + intBitsToFloat(PV1i.z))); +R2i.x = floatBitsToInt(max(intBitsToFloat(PV1i.x), -(intBitsToFloat(PV1i.x)))); +PS0i = R2i.x; +// 9 +R127i.x = ((0.5 > intBitsToFloat(PS0i))?int(0xFFFFFFFF):int(0x0)); +PV1i.y = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(uf_remappedPS[9].z)); +PV1i.z = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(uf_remappedPS[10].z)); +R0i.y = floatBitsToInt(max(intBitsToFloat(R126i.y), -(intBitsToFloat(R126i.y)))); +PS1i = R0i.y; +// 10 +R126i.x = ((0.5 > intBitsToFloat(PS1i))?int(0xFFFFFFFF):int(0x0)); +PV0i.y = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(uf_remappedPS[11].z)); +PV0i.z = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(uf_remappedPS[12].z)); +R0i.w = PV1i.y; +R0i.w = clampFI32(R0i.w); +R1i.w = PV1i.z; +R1i.w = clampFI32(R1i.w); +PS0i = R1i.w; +// 11 +R0i.x = floatBitsToInt(intBitsToFloat(R126i.z) + intBitsToFloat(uf_remappedPS[9].x) / resScale); +PV1i.y = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(uf_remappedPS[13].z)); +R0i.z = floatBitsToInt(intBitsToFloat(R127i.y) + intBitsToFloat(uf_remappedPS[9].y) / resScale); +R2i.w = PV0i.z; +R2i.w = clampFI32(R2i.w); +R3i.w = PV0i.y; +R3i.w = clampFI32(R3i.w); +PS1i = R3i.w; +// 12 +R1i.x = floatBitsToInt(intBitsToFloat(R126i.z) + intBitsToFloat(uf_remappedPS[10].x) / resScale); +R1i.y = floatBitsToInt(intBitsToFloat(R127i.y) + intBitsToFloat(uf_remappedPS[10].y) / resScale); +R2i.z = floatBitsToInt(intBitsToFloat(R126i.z) + intBitsToFloat(uf_remappedPS[12].x) / resScale); +R4i.w = PV1i.y; +R4i.w = clampFI32(R4i.w); +R2i.y = floatBitsToInt(intBitsToFloat(R127i.y) + intBitsToFloat(uf_remappedPS[12].y) / resScale); +PS0i = R2i.y; +// 13 +R3i.x = floatBitsToInt(intBitsToFloat(R126i.z) + intBitsToFloat(uf_remappedPS[11].x) / resScale); +R3i.y = floatBitsToInt(intBitsToFloat(R127i.y) + intBitsToFloat(uf_remappedPS[11].y) / resScale); +R4i.z = floatBitsToInt(intBitsToFloat(R6i.x) + intBitsToFloat(uf_remappedPS[13].x) / resScale); +R6i.w = ((R127i.x == 0)?(0):(R126i.x)); +R4i.y = floatBitsToInt(intBitsToFloat(R5i.y) + intBitsToFloat(uf_remappedPS[13].y) / resScale); +PS1i = R4i.y; +} +if( activeMaskStackC[1] == true ) { +R8i.x = floatBitsToInt(texture(textureUnitPS1, vec3(intBitsToFloat(R0i.xz), intBitsToFloat(R0i.w)))); +R0i.x = floatBitsToInt(texture(textureUnitPS1, vec3(intBitsToFloat(R1i.xy), intBitsToFloat(R1i.w)))); +R9i.x = floatBitsToInt(texture(textureUnitPS1, vec3(intBitsToFloat(R2i.zy), intBitsToFloat(R2i.w)))); +R10i.x = floatBitsToInt(texture(textureUnitPS1, vec3(intBitsToFloat(R3i.xy), intBitsToFloat(R3i.w)))); +R1i.x = floatBitsToInt(texture(textureUnitPS3, vec3(intBitsToFloat(R4i.zy), intBitsToFloat(R4i.w)))); +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +R7i.x = floatBitsToInt(intBitsToFloat(uf_remappedPS[14].x) * 1.0); +PV0i.x = R7i.x; +R1i.y = floatBitsToInt(intBitsToFloat(uf_remappedPS[14].y) * 1.0); +PV0i.y = R1i.y; +R2i.z = floatBitsToInt(intBitsToFloat(uf_remappedPS[14].z) * 1.0); +PV0i.z = R2i.z; +// 1 +R123i.x = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[15].z) + intBitsToFloat(PV0i.z))); +PV1i.x = R123i.x; +R123i.z = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[15].y) + intBitsToFloat(PV0i.y))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[15].x) + intBitsToFloat(PV0i.x))); +PV1i.w = R123i.w; +// 2 +R123i.y = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[16].x) + intBitsToFloat(PV1i.w))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[16].z) + intBitsToFloat(PV1i.x))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[16].y) + intBitsToFloat(PV1i.z))); +PV0i.w = R123i.w; +// 3 +R3i.x = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[17].x) + intBitsToFloat(PV0i.y))); +R3i.y = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[17].y) + intBitsToFloat(PV0i.w))); +R0i.z = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[17].z) + intBitsToFloat(PV0i.z))); +// 4 +predResult = (R6i.w != 0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +activeMaskStack[2] = activeMaskStack[1]; +activeMaskStackC[3] = activeMaskStackC[2]; +// 0 +PV0i.z = floatBitsToInt(intBitsToFloat(R8i.x) + intBitsToFloat(R0i.x)); +R5i.w = floatBitsToInt(max(intBitsToFloat(R2i.x), intBitsToFloat(R0i.y))); +// 1 +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R9i.x)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R10i.x)); +// 3 +R1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * 0.25); +// 4 +predResult = (intBitsToFloat(R5i.w) > intBitsToFloat(0x3eae147b)); +activeMaskStack[2] = predResult; +activeMaskStackC[3] = predResult == true && activeMaskStackC[2] == true; +} +else { +activeMaskStack[2] = false; +activeMaskStackC[3] = false; +} +if( activeMaskStackC[3] == true ) { +// 0 +R0i.x = floatBitsToInt(intBitsToFloat(R3i.x) + intBitsToFloat(uf_remappedPS[18].x)); +R0i.y = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[18].y)); +R1i.z = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(uf_remappedPS[18].z)); +PV0i.z = R1i.z; +// 1 +R8i.x = floatBitsToInt(intBitsToFloat(R3i.x) + intBitsToFloat(uf_remappedPS[19].x)); +R8i.y = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[19].y)); +R1i.z = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(uf_remappedPS[19].z)); +PV1i.z = R1i.z; +R0i.w = PV0i.z; +R0i.w = clampFI32(R0i.w); +// 2 +R2i.x = floatBitsToInt(intBitsToFloat(R3i.x) + intBitsToFloat(uf_remappedPS[20].x)); +R2i.y = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[20].y)); +R1i.z = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(uf_remappedPS[20].z)); +PV0i.z = R1i.z; +R8i.w = PV1i.z; +R8i.w = clampFI32(R8i.w); +// 3 +backupReg0i = R3i.x; +backupReg1i = R3i.y; +R3i.x = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(uf_remappedPS[21].x)); +R3i.y = floatBitsToInt(intBitsToFloat(backupReg1i) + intBitsToFloat(uf_remappedPS[21].y)); +R1i.z = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(uf_remappedPS[21].z)); +PV1i.z = R1i.z; +R2i.w = PV0i.z; +R2i.w = clampFI32(R2i.w); +// 4 +R3i.w = PV1i.z; +R3i.w = clampFI32(R3i.w); +} +if( activeMaskStackC[3] == true ) { +R1i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R0i.xy), intBitsToFloat(R0i.w)))); +R0i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R8i.xy), intBitsToFloat(R8i.w)))); +R2i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R2i.xy), intBitsToFloat(R2i.w)))); +R3i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R3i.xy), intBitsToFloat(R3i.w)))); +} +if( activeMaskStackC[3] == true ) { +// 0 +PV0i.y = floatBitsToInt(intBitsToFloat(R0i.x) + intBitsToFloat(R1i.x)); +PV0i.z = floatBitsToInt(intBitsToFloat(R5i.w) + -(intBitsToFloat(0x3eae147b))); +// 1 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.y) + intBitsToFloat(R2i.x)); +R127i.y = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(0x40c80000)); +// 2 +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.x) + intBitsToFloat(R3i.x)); +// 3 +R123i.x = floatBitsToInt((intBitsToFloat(PV0i.w) * 0.25 + -(intBitsToFloat(R1i.w)))); +PV1i.x = R123i.x; +// 4 +backupReg0i = R1i.w; +R1i.w = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(R127i.y) + intBitsToFloat(backupReg0i))); +} +activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true; +activeMaskStack[1] = activeMaskStack[1] == false; +activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true; +if( activeMaskStackC[2] == true ) { +activeMaskStack[2] = activeMaskStack[1]; +activeMaskStackC[3] = activeMaskStackC[2]; +// 0 +R123i.y = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[15].z) + intBitsToFloat(R2i.z))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[15].y) + intBitsToFloat(R1i.y))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[15].x) + intBitsToFloat(R7i.x))); +PV0i.w = R123i.w; +// 1 +R123i.x = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[16].x) + intBitsToFloat(PV0i.w))); +PV1i.x = R123i.x; +R123i.z = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[16].z) + intBitsToFloat(PV0i.y))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[16].y) + intBitsToFloat(PV0i.z))); +PV1i.w = R123i.w; +// 2 +R3i.x = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[17].x) + intBitsToFloat(PV1i.x))); +PV0i.x = R3i.x; +R3i.y = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[17].y) + intBitsToFloat(PV1i.w))); +PV0i.y = R3i.y; +R0i.z = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[17].z) + intBitsToFloat(PV1i.z))); +// 3 +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) + -(0.5)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) + -(0.5)); +// 4 +R0i.x = floatBitsToInt(max(intBitsToFloat(PV1i.w), -(intBitsToFloat(PV1i.w)))); +PV0i.x = R0i.x; +R0i.y = floatBitsToInt(max(intBitsToFloat(PV1i.z), -(intBitsToFloat(PV1i.z)))); +PV0i.y = R0i.y; +// 5 +PV1i.x = ((0.5 > intBitsToFloat(PV0i.y))?int(0xFFFFFFFF):int(0x0)); +PV1i.y = ((0.5 > intBitsToFloat(PV0i.x))?int(0xFFFFFFFF):int(0x0)); +// 6 +R0i.w = ((PV1i.y == 0)?(0):(PV1i.x)); +// 7 +predResult = (R0i.w != 0); +activeMaskStack[2] = predResult; +activeMaskStackC[3] = predResult == true && activeMaskStackC[2] == true; +} +else { +activeMaskStack[2] = false; +activeMaskStackC[3] = false; +} +if( activeMaskStackC[3] == true ) { +// 0 +backupReg0i = R0i.z; +R127i.x = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(uf_remappedPS[18].z)); +PV0i.z = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(uf_remappedPS[19].z)); +R6i.w = floatBitsToInt(max(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y))); +// 1 +R0i.x = floatBitsToInt(intBitsToFloat(R3i.x) + intBitsToFloat(uf_remappedPS[19].x) / resScale); +R0i.y = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[19].y) / resScale); +R1i.z = floatBitsToInt(intBitsToFloat(R3i.x) + intBitsToFloat(uf_remappedPS[18].x) / resScale); +R0i.w = PV0i.z; +R0i.w = clampFI32(R0i.w); +R1i.y = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[18].y) / resScale); +PS1i = R1i.y; +// 2 +backupReg0i = R0i.z; +R2i.x = floatBitsToInt(intBitsToFloat(R3i.x) + intBitsToFloat(uf_remappedPS[20].x) / resScale); +R2i.y = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[20].y) / resScale); +PV0i.z = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(uf_remappedPS[20].z)); +R1i.w = R127i.x; +R1i.w = clampFI32(R1i.w); +// 3 +backupReg0i = R3i.x; +R3i.x = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(uf_remappedPS[21].x) / resScale); +PV1i.y = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(uf_remappedPS[21].z)); +R3i.z = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[21].y) / resScale); +R2i.w = PV0i.z; +R2i.w = clampFI32(R2i.w); +// 4 +R3i.w = PV1i.y; +R3i.w = clampFI32(R3i.w); +} +if( activeMaskStackC[3] == true ) { +R0i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R0i.xy), intBitsToFloat(R0i.w)))); +R1i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R1i.zy), intBitsToFloat(R1i.w)))); +R2i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R2i.xy), intBitsToFloat(R2i.w)))); +R3i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R3i.xz), intBitsToFloat(R3i.w)))); +} +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +PV0i.y = floatBitsToInt(intBitsToFloat(R0i.x) + intBitsToFloat(R1i.x)); +// 1 +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) + intBitsToFloat(R2i.x)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.z) + intBitsToFloat(R3i.x)); +// 3 +R1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * 0.25); +// 4 +predResult = (intBitsToFloat(R6i.w) > intBitsToFloat(0x3eae147b)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +backupReg0i = R4i.x; +R4i.x = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[5].x) + intBitsToFloat(backupReg0i))); +PV0i.x = R4i.x; +R1i.y = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[5].y) + intBitsToFloat(R6i.y))); +PV0i.y = R1i.y; +R0i.z = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[5].z) + intBitsToFloat(R5i.z))); +PV0i.z = R0i.z; +// 1 +R4i.x = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[6].x) + intBitsToFloat(PV0i.x))); +PV1i.x = R4i.x; +R1i.y = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[6].y) + intBitsToFloat(PV0i.y))); +PV1i.y = R1i.y; +R0i.z = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(uf_remappedPS[6].z) + intBitsToFloat(PV0i.z))); +PV1i.z = R0i.z; +// 2 +R4i.x = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[8].x) + intBitsToFloat(PV1i.x))); +PV0i.x = R4i.x; +R1i.y = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[8].y) + intBitsToFloat(PV1i.y))); +PV0i.y = R1i.y; +R0i.z = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[8].z) + intBitsToFloat(PV1i.z))); +PV0i.z = R0i.z; +// 3 +R4i.x = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(uf_remappedPS[13].x)); +R4i.y = floatBitsToInt(intBitsToFloat(PV0i.y) + intBitsToFloat(uf_remappedPS[13].y)); +R0i.z = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(uf_remappedPS[13].z)); +PV1i.z = R0i.z; +// 4 +R4i.w = PV1i.z; +R4i.w = clampFI32(R4i.w); +} +if( activeMaskStackC[4] == true ) { +R0i.x = floatBitsToInt(texture(textureUnitPS3, vec3(intBitsToFloat(R4i.xy), intBitsToFloat(R4i.w)))); +} +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = floatBitsToInt(-(intBitsToFloat(R1i.w)) + intBitsToFloat(R0i.x)); +PV0i.z = floatBitsToInt(intBitsToFloat(R6i.w) + -(intBitsToFloat(0x3eae147b))); +// 1 +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(0x40c80000)); +// 2 +backupReg0i = R1i.w; +R1i.w = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(PV1i.y) + intBitsToFloat(backupReg0i))); +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +activeMaskStack[2] = activeMaskStack[2] == false; +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +R127i.x = floatBitsToInt(-(intBitsToFloat(R1i.x)) + 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(R5i.y) + -(0.5)); +PV0i.w = floatBitsToInt(intBitsToFloat(R6i.x) + -(0.5)); +// 1 +PV1i.x = floatBitsToInt(max(intBitsToFloat(PV0i.z), -(intBitsToFloat(PV0i.z)))); +PV1i.y = floatBitsToInt(max(intBitsToFloat(PV0i.w), -(intBitsToFloat(PV0i.w)))); +// 2 +PV0i.w = floatBitsToInt(max(intBitsToFloat(PV1i.y), intBitsToFloat(PV1i.x))); +// 3 +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.w) + -(intBitsToFloat(0x3ecccccd))); +// 4 +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.z) * intBitsToFloat(0x41200000)); +PV0i.y = clampFI32(PV0i.y); +// 5 +R1i.w = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(PV0i.y) + intBitsToFloat(R1i.x))); +} +activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true; +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +R0i.x = floatBitsToInt((intBitsToFloat(R1i.w) * intBitsToFloat(uf_remappedPS[22].x) + intBitsToFloat(uf_remappedPS[22].y))); +R0i.w = 0; +} +// export +passPixelColor0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.x), intBitsToFloat(R0i.x), intBitsToFloat(R0i.w)); +}